URL https://opencores.org/ocsvn/core_arm/core_arm/trunk

Subversion Repositories core_arm

[/] [core_arm/] [trunk/] [build/] [config/] [confdata.c] - Blame information for rev 4

Details | Compare with Previous | View Log


/*
 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
 * Released under the terms of the GNU GPL v2.0.
 */
 
#include <sys/stat.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#define LKC_DIRECT_LINK
#include "lkc.h"
 
const char conf_def_filename[] = ".config";
 
const char conf_defname[] = "extra/Configs/Config.default";
 
const char *conf_confnames[] = {
        ".config",
        conf_defname,
        NULL,
};
 
static char *conf_expand_value(const char *in)
{
        struct symbol *sym;
        const char *src;
        static char res_value[SYMBOL_MAXLENGTH];
        char *dst, name[SYMBOL_MAXLENGTH];
 
        res_value[0] = 0;
        dst = name;
        while ((src = strchr(in, '$'))) {
                strncat(res_value, in, src - in);
                src++;
                dst = name;
                while (isalnum(*src) || *src == '_')
                        *dst++ = *src++;
                *dst = 0;
                sym = sym_lookup(name, 0);
                sym_calc_value(sym);
                strcat(res_value, sym_get_string_value(sym));
                in = src;
        }
        strcat(res_value, in);
 
        return res_value;
}
 
char *conf_get_default_confname(void)
{
        struct stat buf;
        static char fullname[4096+1];
        char *env, *name;
 
        name = conf_expand_value(conf_defname);
        env = getenv(SRCTREE);
        if (env) {
                sprintf(fullname, "%s/%s", env, name);
                if (!stat(fullname, &buf))
                        return fullname;
        }
        return name;
}
 
int conf_read(const char *name)
{
        FILE *in = NULL;
        char line[1024];
        char *p, *p2;
        int lineno = 0;
        struct symbol *sym;
        struct property *prop;
        struct expr *e;
        int i;
 
        if (name) {
                in = zconf_fopen(name);
        } else {
                const char **names = conf_confnames;
                while ((name = *names++)) {
                        name = conf_expand_value(name);
                        in = zconf_fopen(name);
                        if (in) {
                                printf("#\n"
                                       "# using defaults found in %s\n"
                                       "#\n", name);
                                break;
                        }
                }
        }
 
        if (!in)
                return 1;
 
        for_all_symbols(i, sym) {
                sym->flags |= SYMBOL_NEW | SYMBOL_CHANGED;
                sym->flags &= ~SYMBOL_VALID;
                switch (sym->type) {
                case S_INT:
                case S_HEX:
                case S_STRING:
                        if (sym->user.val)
                                free(sym->user.val);
                default:
                        sym->user.val = NULL;
                        sym->user.tri = no;
                }
        }
 
        while (fgets(line, sizeof(line), in)) {
                lineno++;
                sym = NULL;
                switch (line[0]) {
                case '#':
                        if (line[1]!=' ')
                                continue;
                        p = strchr(line + 2, ' ');
                        if (!p)
                                continue;
                        *p++ = 0;
                        if (strncmp(p, "is not set", 10))
                                continue;
                        sym = sym_find(line + 2);
                        if (!sym) {
                                fprintf(stderr, "%s:%d: trying to assign nonexistent symbol %s\n", name, lineno, line + 2);
                                break;
                        }
                        switch (sym->type) {
                        case S_BOOLEAN:
                        case S_TRISTATE:
                                sym->user.tri = no;
                                sym->flags &= ~SYMBOL_NEW;
                                break;
                        default:
                                ;
                        }
                        break;
 
                case 'A' ... 'Z':
                        p = strchr(line, '=');
                        if (!p)
                                continue;
                        *p++ = 0;
                        p2 = strchr(p, '\n');
                        if (p2)
                                *p2 = 0;
                        sym = sym_find(line);
                        if (!sym) {
                                fprintf(stderr, "%s:%d: trying to assign nonexistent symbol %s\n", name, lineno, line);
                                break;
                        }
                        switch (sym->type) {
                        case S_TRISTATE:
                                if (p[0] == 'm') {
                                        sym->user.tri = mod;
                                        sym->flags &= ~SYMBOL_NEW;
                                        break;
                                }
                        case S_BOOLEAN:
                                if (p[0] == 'y') {
                                        sym->user.tri = yes;
                                        sym->flags &= ~SYMBOL_NEW;
                                        break;
                                }
                                if (p[0] == 'n') {
                                        sym->user.tri = no;
                                        sym->flags &= ~SYMBOL_NEW;
                                        break;
                                }
                                break;
                        case S_STRING:
                                if (*p++ != '"')
                                        break;
                                for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
                                        if (*p2 == '"') {
                                                *p2 = 0;
                                                break;
                                        }
                                        memmove(p2, p2 + 1, strlen(p2));
                                }
                                if (!p2) {
                                        fprintf(stderr, "%s:%d: invalid string found\n", name, lineno);
                                        exit(1);
                                }
                        case S_INT:
                        case S_HEX:
                                if (sym_string_valid(sym, p)) {
                                        sym->user.val = strdup(p);
                                        sym->flags &= ~SYMBOL_NEW;
                                } else {
                                        fprintf(stderr, "%s:%d: symbol value '%s' invalid for %s\n", name, lineno, p, sym->name);
                                        exit(1);
                                }
                                break;
                        default:
                                ;
                        }
                        break;
                case '\n':
                        break;
                default:
                        continue;
                }
                if (sym && sym_is_choice_value(sym)) {
                        struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
                        switch (sym->user.tri) {
                        case no:
                                break;
                        case mod:
                                if (cs->user.tri == yes)
                                        /* warn? */;
                                break;
                        case yes:
                                if (cs->user.tri != no)
                                        /* warn? */;
                                cs->user.val = sym;
                                break;
                        }
                        cs->user.tri = E_OR(cs->user.tri, sym->user.tri);
                        cs->flags &= ~SYMBOL_NEW;
                }
        }
        fclose(in);
 
        for_all_symbols(i, sym) {
                sym_calc_value(sym);
                if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
                        if (sym->visible == no)
                                sym->flags |= SYMBOL_NEW;
                        switch (sym->type) {
                        case S_STRING:
                        case S_INT:
                        case S_HEX:
                                if (!sym_string_within_range(sym, sym->user.val))
                                        sym->flags |= SYMBOL_NEW;
                        default:
                                break;
                        }
                }
                if (!sym_is_choice(sym))
                        continue;
                prop = sym_get_choice_prop(sym);
                for (e = prop->expr; e; e = e->left.expr)
                        if (e->right.sym->visible != no)
                                sym->flags |= e->right.sym->flags & SYMBOL_NEW;
        }
 
        sym_change_count = 1;
 
        return 0;
}
 
int conf_write(const char *name)
{
        FILE *out;
        struct symbol *sym;
        struct menu *menu;
        const char *basename;
        char dirname[128], tmpname[128], newname[128];
        int type, l;
        const char *str;
 
        dirname[0] = 0;
        if (name && name[0]) {
                char *slash = strrchr(name, '/');
                if (slash) {
                        int size = slash - name + 1;
                        memcpy(dirname, name, size);
                        dirname[size] = 0;
                        if (slash[1])
                                basename = slash + 1;
                        else
                                basename = conf_def_filename;
                } else
                        basename = name;
        } else
                basename = conf_def_filename;
 
        sprintf(newname, "%s.tmpconfig.%d", dirname, getpid());
        out = fopen(newname, "w");
        if (!out)
                return 1;
        fprintf(out, "#\n"
                     "# Automatically generated make config: don't edit\n"
                     "#\n");
        if (!sym_change_count)
                sym_clear_all_valid();
 
        menu = rootmenu.list;
        while (menu) {
                sym = menu->sym;
                if (!sym) {
                        if (!menu_is_visible(menu))
                                goto next;
                        str = menu_get_prompt(menu);
                        fprintf(out, "\n"
                                     "#\n"
                                     "# %s\n"
                                     "#\n", str);
                } else if (!(sym->flags & SYMBOL_CHOICE)) {
                        sym_calc_value(sym);
                        if (!(sym->flags & SYMBOL_WRITE))
                                goto next;
                        sym->flags &= ~SYMBOL_WRITE;
                        type = sym->type;
                        if (type == S_TRISTATE) {
                                sym_calc_value(modules_sym);
                                if (modules_sym->curr.tri == no)
                                        type = S_BOOLEAN;
                        }
                        switch (type) {
                        case S_BOOLEAN:
                        case S_TRISTATE:
                                switch (sym_get_tristate_value(sym)) {
                                case no:
                                        fprintf(out, "# %s is not set\n", sym->name);
                                        break;
                                case mod:
                                        fprintf(out, "%s=m\n", sym->name);
                                        break;
                                case yes:
                                        fprintf(out, "%s=y\n", sym->name);
                                        break;
                                }
                                break;
                        case S_STRING:
                                // fix me
                                str = sym_get_string_value(sym);
                                fprintf(out, "%s=\"", sym->name);
                                do {
                                        l = strcspn(str, "\"\\");
                                        if (l) {
                                                fwrite(str, l, 1, out);
                                        }
                                        str += l;
                                        while (*str == '\\' || *str == '"') {
                                                fprintf(out, "\\%c", *str);
                                                str++;
                                        }
                                } while (*str);
                                fputs("\"\n", out);
                                break;
                        case S_HEX:
                                str = sym_get_string_value(sym);
                                if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
                                        fprintf(out, "%s=%s\n", sym->name, str);
                                        break;
                                }
                        case S_INT:
                                str = sym_get_string_value(sym);
                                fprintf(out, "%s=%s\n", sym->name, str);
                                break;
                        }
                }
 
        next:
                if (menu->list) {
                        menu = menu->list;
                        continue;
                }
                if (menu->next)
                        menu = menu->next;
                else while ((menu = menu->parent)) {
                        if (menu->next) {
                                menu = menu->next;
                                break;
                        }
                }
        }
        fclose(out);
        if (!name || basename != conf_def_filename) {
                if (!name)
                        name = conf_def_filename;
                sprintf(tmpname, "%s.old", name);
                rename(name, tmpname);
        }
        sprintf(tmpname, "%s%s", dirname, basename);
        if (rename(newname, tmpname))
                return 1;
 
        sym_change_count = 0;
 
        return 0;
}

Browse

Tools

Subversion Repositories core_arm

[/] [core_arm/] [trunk/] [build/] [config/] [confdata.c] - Blame information for rev 4

Line No.	Rev	Author	Line
1	2	tarookumic	`/*`
2			`* Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>`
3			`* Released under the terms of the GNU GPL v2.0.`
4			`*/`
5
6			`#include <sys/stat.h>`
7			`#include <ctype.h>`
8			`#include <stdio.h>`
9			`#include <stdlib.h>`
10			`#include <string.h>`
11			`#include <unistd.h>`
12
13			`#define LKC_DIRECT_LINK`
14			`#include "lkc.h"`
15
16			`const char conf_def_filename[] = ".config";`
17
18			`const char conf_defname[] = "extra/Configs/Config.default";`
19
20			`const char *conf_confnames[] = {`
21			`".config",`
22			`conf_defname,`
23			`NULL,`
24			`};`
25
26			`static char conf_expand_value(const char in)`
27			`{`
28			`struct symbol *sym;`
29			`const char *src;`
30			`static char res_value[SYMBOL_MAXLENGTH];`
31			`char *dst, name[SYMBOL_MAXLENGTH];`
32
33			`res_value[0] = 0;`
34			`dst = name;`
35			`while ((src = strchr(in, '$'))) {`
36			`strncat(res_value, in, src - in);`
37			`src++;`
38			`dst = name;`
39			`while (isalnum(src) \|\| src == '_')`
40			`dst++ = src++;`
41			`*dst = 0;`
42			`sym = sym_lookup(name, 0);`
43			`sym_calc_value(sym);`
44			`strcat(res_value, sym_get_string_value(sym));`
45			`in = src;`
46			`}`
47			`strcat(res_value, in);`
48
49			`return res_value;`
50			`}`
51
52			`char *conf_get_default_confname(void)`
53			`{`
54			`struct stat buf;`
55			`static char fullname[4096+1];`
56			`char env, name;`
57
58			`name = conf_expand_value(conf_defname);`
59			`env = getenv(SRCTREE);`
60			`if (env) {`
61			`sprintf(fullname, "%s/%s", env, name);`
62			`if (!stat(fullname, &buf))`
63			`return fullname;`
64			`}`
65			`return name;`
66			`}`
67
68			`int conf_read(const char *name)`
69			`{`
70			`FILE *in = NULL;`
71			`char line[1024];`
72			`char p, p2;`
73			`int lineno = 0;`
74			`struct symbol *sym;`
75			`struct property *prop;`
76			`struct expr *e;`
77			`int i;`
78
79			`if (name) {`
80			`in = zconf_fopen(name);`
81			`} else {`
82			`const char **names = conf_confnames;`
83			`while ((name = *names++)) {`
84			`name = conf_expand_value(name);`
85			`in = zconf_fopen(name);`
86			`if (in) {`
87			`printf("#\n"`
88			`"# using defaults found in %s\n"`
89			`"#\n", name);`
90			`break;`
91			`}`
92			`}`
93			`}`
94
95			`if (!in)`
96			`return 1;`
97
98			`for_all_symbols(i, sym) {`
99			`sym->flags \|= SYMBOL_NEW \| SYMBOL_CHANGED;`
100			`sym->flags &= ~SYMBOL_VALID;`
101			`switch (sym->type) {`
102			`case S_INT:`
103			`case S_HEX:`
104			`case S_STRING:`
105			`if (sym->user.val)`
106			`free(sym->user.val);`
107			`default:`
108			`sym->user.val = NULL;`
109			`sym->user.tri = no;`
110			`}`
111			`}`
112
113			`while (fgets(line, sizeof(line), in)) {`
114			`lineno++;`
115			`sym = NULL;`
116			`switch (line[0]) {`
117			`case '#':`
118			`if (line[1]!=' ')`
119			`continue;`
120			`p = strchr(line + 2, ' ');`
121			`if (!p)`
122			`continue;`
123			`*p++ = 0;`
124			`if (strncmp(p, "is not set", 10))`
125			`continue;`
126			`sym = sym_find(line + 2);`
127			`if (!sym) {`
128			`fprintf(stderr, "%s:%d: trying to assign nonexistent symbol %s\n", name, lineno, line + 2);`
129			`break;`
130			`}`
131			`switch (sym->type) {`
132			`case S_BOOLEAN:`
133			`case S_TRISTATE:`
134			`sym->user.tri = no;`
135			`sym->flags &= ~SYMBOL_NEW;`
136			`break;`
137			`default:`
138			`;`
139			`}`
140			`break;`
141
142			`case 'A' ... 'Z':`
143			`p = strchr(line, '=');`
144			`if (!p)`
145			`continue;`
146			`*p++ = 0;`
147			`p2 = strchr(p, '\n');`
148			`if (p2)`
149			`*p2 = 0;`
150			`sym = sym_find(line);`
151			`if (!sym) {`
152			`fprintf(stderr, "%s:%d: trying to assign nonexistent symbol %s\n", name, lineno, line);`
153			`break;`
154			`}`
155			`switch (sym->type) {`
156			`case S_TRISTATE:`
157			`if (p[0] == 'm') {`
158			`sym->user.tri = mod;`
159			`sym->flags &= ~SYMBOL_NEW;`
160			`break;`
161			`}`
162			`case S_BOOLEAN:`
163			`if (p[0] == 'y') {`
164			`sym->user.tri = yes;`
165			`sym->flags &= ~SYMBOL_NEW;`
166			`break;`
167			`}`
168			`if (p[0] == 'n') {`
169			`sym->user.tri = no;`
170			`sym->flags &= ~SYMBOL_NEW;`
171			`break;`
172			`}`
173			`break;`
174			`case S_STRING:`
175			`if (*p++ != '"')`
176			`break;`
177			`for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {`
178			`if (*p2 == '"') {`
179			`*p2 = 0;`
180			`break;`
181			`}`
182			`memmove(p2, p2 + 1, strlen(p2));`
183			`}`
184			`if (!p2) {`
185			`fprintf(stderr, "%s:%d: invalid string found\n", name, lineno);`
186			`exit(1);`
187			`}`
188			`case S_INT:`
189			`case S_HEX:`
190			`if (sym_string_valid(sym, p)) {`
191			`sym->user.val = strdup(p);`
192			`sym->flags &= ~SYMBOL_NEW;`
193			`} else {`
194			`fprintf(stderr, "%s:%d: symbol value '%s' invalid for %s\n", name, lineno, p, sym->name);`
195			`exit(1);`
196			`}`
197			`break;`
198			`default:`
199			`;`
200			`}`
201			`break;`
202			`case '\n':`
203			`break;`
204			`default:`
205			`continue;`
206			`}`
207			`if (sym && sym_is_choice_value(sym)) {`
208			`struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));`
209			`switch (sym->user.tri) {`
210			`case no:`
211			`break;`
212			`case mod:`
213			`if (cs->user.tri == yes)`
214			`/* warn? */;`
215			`break;`
216			`case yes:`
217			`if (cs->user.tri != no)`
218			`/* warn? */;`
219			`cs->user.val = sym;`
220			`break;`
221			`}`
222			`cs->user.tri = E_OR(cs->user.tri, sym->user.tri);`
223			`cs->flags &= ~SYMBOL_NEW;`
224			`}`
225			`}`
226			`fclose(in);`
227
228			`for_all_symbols(i, sym) {`
229			`sym_calc_value(sym);`
230			`if (sym_has_value(sym) && !sym_is_choice_value(sym)) {`
231			`if (sym->visible == no)`
232			`sym->flags \|= SYMBOL_NEW;`
233			`switch (sym->type) {`
234			`case S_STRING:`
235			`case S_INT:`
236			`case S_HEX:`
237			`if (!sym_string_within_range(sym, sym->user.val))`
238			`sym->flags \|= SYMBOL_NEW;`
239			`default:`
240			`break;`
241			`}`
242			`}`
243			`if (!sym_is_choice(sym))`
244			`continue;`
245			`prop = sym_get_choice_prop(sym);`
246			`for (e = prop->expr; e; e = e->left.expr)`
247			`if (e->right.sym->visible != no)`
248			`sym->flags \|= e->right.sym->flags & SYMBOL_NEW;`
249			`}`
250
251			`sym_change_count = 1;`
252
253			`return 0;`
254			`}`
255
256			`int conf_write(const char *name)`
257			`{`
258			`FILE *out;`
259			`struct symbol *sym;`
260			`struct menu *menu;`
261			`const char *basename;`
262			`char dirname[128], tmpname[128], newname[128];`
263			`int type, l;`
264			`const char *str;`
265
266			`dirname[0] = 0;`
267			`if (name && name[0]) {`
268			`char *slash = strrchr(name, '/');`
269			`if (slash) {`
270			`int size = slash - name + 1;`
271			`memcpy(dirname, name, size);`
272			`dirname[size] = 0;`
273			`if (slash[1])`
274			`basename = slash + 1;`
275			`else`
276			`basename = conf_def_filename;`
277			`} else`
278			`basename = name;`
279			`} else`
280			`basename = conf_def_filename;`
281
282			`sprintf(newname, "%s.tmpconfig.%d", dirname, getpid());`
283			`out = fopen(newname, "w");`
284			`if (!out)`
285			`return 1;`
286			`fprintf(out, "#\n"`
287			`"# Automatically generated make config: don't edit\n"`
288			`"#\n");`
289			`if (!sym_change_count)`
290			`sym_clear_all_valid();`
291
292			`menu = rootmenu.list;`
293			`while (menu) {`
294			`sym = menu->sym;`
295			`if (!sym) {`
296			`if (!menu_is_visible(menu))`
297			`goto next;`
298			`str = menu_get_prompt(menu);`
299			`fprintf(out, "\n"`
300			`"#\n"`
301			`"# %s\n"`
302			`"#\n", str);`
303			`} else if (!(sym->flags & SYMBOL_CHOICE)) {`
304			`sym_calc_value(sym);`
305			`if (!(sym->flags & SYMBOL_WRITE))`
306			`goto next;`
307			`sym->flags &= ~SYMBOL_WRITE;`
308			`type = sym->type;`
309			`if (type == S_TRISTATE) {`
310			`sym_calc_value(modules_sym);`
311			`if (modules_sym->curr.tri == no)`
312			`type = S_BOOLEAN;`
313			`}`
314			`switch (type) {`
315			`case S_BOOLEAN:`
316			`case S_TRISTATE:`
317			`switch (sym_get_tristate_value(sym)) {`
318			`case no:`
319			`fprintf(out, "# %s is not set\n", sym->name);`
320			`break;`
321			`case mod:`
322			`fprintf(out, "%s=m\n", sym->name);`
323			`break;`
324			`case yes:`
325			`fprintf(out, "%s=y\n", sym->name);`
326			`break;`
327			`}`
328			`break;`
329			`case S_STRING:`
330			`// fix me`
331			`str = sym_get_string_value(sym);`
332			`fprintf(out, "%s=\"", sym->name);`
333			`do {`
334			`l = strcspn(str, "\"\\");`
335			`if (l) {`
336			`fwrite(str, l, 1, out);`
337			`}`
338			`str += l;`
339			`while (str == '\\' \|\| str == '"') {`
340			`fprintf(out, "\\%c", *str);`
341			`str++;`
342			`}`
343			`} while (*str);`
344			`fputs("\"\n", out);`
345			`break;`
346			`case S_HEX:`
347			`str = sym_get_string_value(sym);`
348			`if (str[0] != '0' \|\| (str[1] != 'x' && str[1] != 'X')) {`
349			`fprintf(out, "%s=%s\n", sym->name, str);`
350			`break;`
351			`}`
352			`case S_INT:`
353			`str = sym_get_string_value(sym);`
354			`fprintf(out, "%s=%s\n", sym->name, str);`
355			`break;`
356			`}`
357			`}`
358
359			`next:`
360			`if (menu->list) {`
361			`menu = menu->list;`
362			`continue;`
363			`}`
364			`if (menu->next)`
365			`menu = menu->next;`
366			`else while ((menu = menu->parent)) {`
367			`if (menu->next) {`
368			`menu = menu->next;`
369			`break;`
370			`}`
371			`}`
372			`}`
373			`fclose(out);`
374			`if (!name \|\| basename != conf_def_filename) {`
375			`if (!name)`
376			`name = conf_def_filename;`
377			`sprintf(tmpname, "%s.old", name);`
378			`rename(name, tmpname);`
379			`}`
380			`sprintf(tmpname, "%s%s", dirname, basename);`
381			`if (rename(newname, tmpname))`
382			`return 1;`
383
384			`sym_change_count = 0;`
385
386			`return 0;`
387			`}`