![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to symbol.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / tools / kconfig|
Return to symbol.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / tools / kconfig |
1.1 root 1: /*
2: * Copyright (C) 2002 Roman Zippel <[email protected]>
3: * Released under the terms of the GNU GPL v2.0.
4: */
5:
6: #include <ctype.h>
7: #include <stdlib.h>
8: #include <string.h>
9: #include <regex.h>
10: #include <sys/utsname.h>
11:
12: #define LKC_DIRECT_LINK
13: #include "lkc.h"
14:
15: struct symbol symbol_yes = {
16: .name = "y",
17: .curr = { "y", yes },
18: .flags = SYMBOL_CONST|SYMBOL_VALID,
19: }, symbol_mod = {
20: .name = "m",
21: .curr = { "m", mod },
22: .flags = SYMBOL_CONST|SYMBOL_VALID,
23: }, symbol_no = {
24: .name = "n",
25: .curr = { "n", no },
26: .flags = SYMBOL_CONST|SYMBOL_VALID,
27: }, symbol_empty = {
28: .name = "",
29: .curr = { "", no },
30: .flags = SYMBOL_VALID,
31: };
32:
33: struct symbol *sym_defconfig_list;
34: struct symbol *modules_sym;
35: tristate modules_val;
36:
37: struct expr *sym_env_list;
38:
39: static void sym_add_default(struct symbol *sym, const char *def)
40: {
41: struct property *prop = prop_alloc(P_DEFAULT, sym);
42:
43: prop->expr = expr_alloc_symbol(sym_lookup(def, SYMBOL_CONST));
44: }
45:
46: void sym_init(void)
47: {
48: struct symbol *sym;
49: struct utsname uts;
50: static bool inited = false;
51:
52: if (inited)
53: return;
54: inited = true;
55:
56: uname(&uts);
57:
58: sym = sym_lookup("UNAME_RELEASE", 0);
59: sym->type = S_STRING;
60: sym->flags |= SYMBOL_AUTO;
61: sym_add_default(sym, uts.release);
62: }
63:
64: enum symbol_type sym_get_type(struct symbol *sym)
65: {
66: enum symbol_type type = sym->type;
67:
68: if (type == S_TRISTATE) {
69: if (sym_is_choice_value(sym) && sym->visible == yes)
70: type = S_BOOLEAN;
71: else if (modules_val == no)
72: type = S_BOOLEAN;
73: }
74: return type;
75: }
76:
77: const char *sym_type_name(enum symbol_type type)
78: {
79: switch (type) {
80: case S_BOOLEAN:
81: return "boolean";
82: case S_TRISTATE:
83: return "tristate";
84: case S_INT:
85: return "integer";
86: case S_HEX:
87: return "hex";
88: case S_STRING:
89: return "string";
90: case S_UNKNOWN:
91: return "unknown";
92: case S_OTHER:
93: break;
94: }
95: return "???";
96: }
97:
98: struct property *sym_get_choice_prop(struct symbol *sym)
99: {
100: struct property *prop;
101:
102: for_all_choices(sym, prop)
103: return prop;
104: return NULL;
105: }
106:
107: struct property *sym_get_env_prop(struct symbol *sym)
108: {
109: struct property *prop;
110:
111: for_all_properties(sym, prop, P_ENV)
112: return prop;
113: return NULL;
114: }
115:
116: struct property *sym_get_default_prop(struct symbol *sym)
117: {
118: struct property *prop;
119:
120: for_all_defaults(sym, prop) {
121: prop->visible.tri = expr_calc_value(prop->visible.expr);
122: if (prop->visible.tri != no)
123: return prop;
124: }
125: return NULL;
126: }
127:
128: static struct property *sym_get_range_prop(struct symbol *sym)
129: {
130: struct property *prop;
131:
132: for_all_properties(sym, prop, P_RANGE) {
133: prop->visible.tri = expr_calc_value(prop->visible.expr);
134: if (prop->visible.tri != no)
135: return prop;
136: }
137: return NULL;
138: }
139:
140: static int sym_get_range_val(struct symbol *sym, int base)
141: {
142: sym_calc_value(sym);
143: switch (sym->type) {
144: case S_INT:
145: base = 10;
146: break;
147: case S_HEX:
148: base = 16;
149: break;
150: default:
151: break;
152: }
153: return strtol(sym->curr.val, NULL, base);
154: }
155:
156: static void sym_validate_range(struct symbol *sym)
157: {
158: struct property *prop;
159: int base, val, val2;
160: char str[64];
161:
162: switch (sym->type) {
163: case S_INT:
164: base = 10;
165: break;
166: case S_HEX:
167: base = 16;
168: break;
169: default:
170: return;
171: }
172: prop = sym_get_range_prop(sym);
173: if (!prop)
174: return;
175: val = strtol(sym->curr.val, NULL, base);
176: val2 = sym_get_range_val(prop->expr->left.sym, base);
177: if (val >= val2) {
178: val2 = sym_get_range_val(prop->expr->right.sym, base);
179: if (val <= val2)
180: return;
181: }
182: if (sym->type == S_INT)
183: sprintf(str, "%d", val2);
184: else
185: sprintf(str, "0x%x", val2);
186: sym->curr.val = strdup(str);
187: }
188:
189: static void sym_calc_visibility(struct symbol *sym)
190: {
191: struct property *prop;
192: tristate tri;
193:
194: /* any prompt visible? */
195: tri = no;
196: for_all_prompts(sym, prop) {
197: prop->visible.tri = expr_calc_value(prop->visible.expr);
198: tri = EXPR_OR(tri, prop->visible.tri);
199: }
200: if (tri == mod && (sym->type != S_TRISTATE || modules_val == no))
201: tri = yes;
202: if (sym->visible != tri) {
203: sym->visible = tri;
204: sym_set_changed(sym);
205: }
206: if (sym_is_choice_value(sym))
207: return;
208: /* defaulting to "yes" if no explicit "depends on" are given */
209: tri = yes;
210: if (sym->dir_dep.expr)
211: tri = expr_calc_value(sym->dir_dep.expr);
212: if (tri == mod)
213: tri = yes;
214: if (sym->dir_dep.tri != tri) {
215: sym->dir_dep.tri = tri;
216: sym_set_changed(sym);
217: }
218: tri = no;
219: if (sym->rev_dep.expr)
220: tri = expr_calc_value(sym->rev_dep.expr);
221: if (tri == mod && sym_get_type(sym) == S_BOOLEAN)
222: tri = yes;
223: if (sym->rev_dep.tri != tri) {
224: sym->rev_dep.tri = tri;
225: sym_set_changed(sym);
226: }
227: }
228:
229: /*
230: * Find the default symbol for a choice.
231: * First try the default values for the choice symbol
232: * Next locate the first visible choice value
233: * Return NULL if none was found
234: */
235: struct symbol *sym_choice_default(struct symbol *sym)
236: {
237: struct symbol *def_sym;
238: struct property *prop;
239: struct expr *e;
240:
241: /* any of the defaults visible? */
242: for_all_defaults(sym, prop) {
243: prop->visible.tri = expr_calc_value(prop->visible.expr);
244: if (prop->visible.tri == no)
245: continue;
246: def_sym = prop_get_symbol(prop);
247: if (def_sym->visible != no)
248: return def_sym;
249: }
250:
251: /* just get the first visible value */
252: prop = sym_get_choice_prop(sym);
253: expr_list_for_each_sym(prop->expr, e, def_sym)
254: if (def_sym->visible != no)
255: return def_sym;
256:
257: /* failed to locate any defaults */
258: return NULL;
259: }
260:
261: static struct symbol *sym_calc_choice(struct symbol *sym)
262: {
263: struct symbol *def_sym;
264: struct property *prop;
265: struct expr *e;
266:
267: /* first calculate all choice values' visibilities */
268: prop = sym_get_choice_prop(sym);
269: expr_list_for_each_sym(prop->expr, e, def_sym)
270: sym_calc_visibility(def_sym);
271:
272: /* is the user choice visible? */
273: def_sym = sym->def[S_DEF_USER].val;
274: if (def_sym && def_sym->visible != no)
275: return def_sym;
276:
277: def_sym = sym_choice_default(sym);
278:
279: if (def_sym == NULL)
280: /* no choice? reset tristate value */
281: sym->curr.tri = no;
282:
283: return def_sym;
284: }
285:
286: void sym_calc_value(struct symbol *sym)
287: {
288: struct symbol_value newval, oldval;
289: struct property *prop;
290: struct expr *e;
291:
292: if (!sym)
293: return;
294:
295: if (sym->flags & SYMBOL_VALID)
296: return;
297: sym->flags |= SYMBOL_VALID;
298:
299: oldval = sym->curr;
300:
301: switch (sym->type) {
302: case S_INT:
303: case S_HEX:
304: case S_STRING:
305: newval = symbol_empty.curr;
306: break;
307: case S_BOOLEAN:
308: case S_TRISTATE:
309: newval = symbol_no.curr;
310: break;
311: default:
312: sym->curr.val = sym->name;
313: sym->curr.tri = no;
314: return;
315: }
316: if (!sym_is_choice_value(sym))
317: sym->flags &= ~SYMBOL_WRITE;
318:
319: sym_calc_visibility(sym);
320:
321: /* set default if recursively called */
322: sym->curr = newval;
323:
324: switch (sym_get_type(sym)) {
325: case S_BOOLEAN:
326: case S_TRISTATE:
327: if (sym_is_choice_value(sym) && sym->visible == yes) {
328: prop = sym_get_choice_prop(sym);
329: newval.tri = (prop_get_symbol(prop)->curr.val == sym) ? yes : no;
330: } else {
331: if (sym->visible != no) {
332: /* if the symbol is visible use the user value
333: * if available, otherwise try the default value
334: */
335: sym->flags |= SYMBOL_WRITE;
336: if (sym_has_value(sym)) {
337: newval.tri = EXPR_AND(sym->def[S_DEF_USER].tri,
338: sym->visible);
339: goto calc_newval;
340: }
341: }
342: if (sym->rev_dep.tri != no)
343: sym->flags |= SYMBOL_WRITE;
344: if (!sym_is_choice(sym)) {
345: prop = sym_get_default_prop(sym);
346: if (prop) {
347: sym->flags |= SYMBOL_WRITE;
348: newval.tri = EXPR_AND(expr_calc_value(prop->expr),
349: prop->visible.tri);
350: }
351: }
352: calc_newval:
353: if (sym->dir_dep.tri == no && sym->rev_dep.tri != no) {
354: struct expr *e;
355: e = expr_simplify_unmet_dep(sym->rev_dep.expr,
356: sym->dir_dep.expr);
357: fprintf(stderr, "warning: (");
358: expr_fprint(e, stderr);
359: fprintf(stderr, ") selects %s which has unmet direct dependencies (",
360: sym->name);
361: expr_fprint(sym->dir_dep.expr, stderr);
362: fprintf(stderr, ")\n");
363: expr_free(e);
364: }
365: newval.tri = EXPR_OR(newval.tri, sym->rev_dep.tri);
366: }
367: if (newval.tri == mod && sym_get_type(sym) == S_BOOLEAN)
368: newval.tri = yes;
369: break;
370: case S_STRING:
371: case S_HEX:
372: case S_INT:
373: if (sym->visible != no) {
374: sym->flags |= SYMBOL_WRITE;
375: if (sym_has_value(sym)) {
376: newval.val = sym->def[S_DEF_USER].val;
377: break;
378: }
379: }
380: prop = sym_get_default_prop(sym);
381: if (prop) {
382: struct symbol *ds = prop_get_symbol(prop);
383: if (ds) {
384: sym->flags |= SYMBOL_WRITE;
385: sym_calc_value(ds);
386: newval.val = ds->curr.val;
387: }
388: }
389: break;
390: default:
391: ;
392: }
393:
394: sym->curr = newval;
395: if (sym_is_choice(sym) && newval.tri == yes)
396: sym->curr.val = sym_calc_choice(sym);
397: sym_validate_range(sym);
398:
399: if (memcmp(&oldval, &sym->curr, sizeof(oldval))) {
400: sym_set_changed(sym);
401: if (modules_sym == sym) {
402: sym_set_all_changed();
403: modules_val = modules_sym->curr.tri;
404: }
405: }
406:
407: if (sym_is_choice(sym)) {
408: struct symbol *choice_sym;
409:
410: prop = sym_get_choice_prop(sym);
411: expr_list_for_each_sym(prop->expr, e, choice_sym) {
412: if ((sym->flags & SYMBOL_WRITE) &&
413: choice_sym->visible != no)
414: choice_sym->flags |= SYMBOL_WRITE;
415: if (sym->flags & SYMBOL_CHANGED)
416: sym_set_changed(choice_sym);
417: }
418: }
419:
420: if (sym->flags & SYMBOL_AUTO)
421: sym->flags &= ~SYMBOL_WRITE;
422: }
423:
424: void sym_clear_all_valid(void)
425: {
426: struct symbol *sym;
427: int i;
428:
429: for_all_symbols(i, sym)
430: sym->flags &= ~SYMBOL_VALID;
431: sym_add_change_count(1);
432: if (modules_sym)
433: sym_calc_value(modules_sym);
434: }
435:
436: void sym_set_changed(struct symbol *sym)
437: {
438: struct property *prop;
439:
440: sym->flags |= SYMBOL_CHANGED;
441: for (prop = sym->prop; prop; prop = prop->next) {
442: if (prop->menu)
443: prop->menu->flags |= MENU_CHANGED;
444: }
445: }
446:
447: void sym_set_all_changed(void)
448: {
449: struct symbol *sym;
450: int i;
451:
452: for_all_symbols(i, sym)
453: sym_set_changed(sym);
454: }
455:
456: bool sym_tristate_within_range(struct symbol *sym, tristate val)
457: {
458: int type = sym_get_type(sym);
459:
460: if (sym->visible == no)
461: return false;
462:
463: if (type != S_BOOLEAN && type != S_TRISTATE)
464: return false;
465:
466: if (type == S_BOOLEAN && val == mod)
467: return false;
468: if (sym->visible <= sym->rev_dep.tri)
469: return false;
470: if (sym_is_choice_value(sym) && sym->visible == yes)
471: return val == yes;
472: return val >= sym->rev_dep.tri && val <= sym->visible;
473: }
474:
475: bool sym_set_tristate_value(struct symbol *sym, tristate val)
476: {
477: tristate oldval = sym_get_tristate_value(sym);
478:
479: if (oldval != val && !sym_tristate_within_range(sym, val))
480: return false;
481:
482: if (!(sym->flags & SYMBOL_DEF_USER)) {
483: sym->flags |= SYMBOL_DEF_USER;
484: sym_set_changed(sym);
485: }
486: /*
487: * setting a choice value also resets the new flag of the choice
488: * symbol and all other choice values.
489: */
490: if (sym_is_choice_value(sym) && val == yes) {
491: struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
492: struct property *prop;
493: struct expr *e;
494:
495: cs->def[S_DEF_USER].val = sym;
496: cs->flags |= SYMBOL_DEF_USER;
497: prop = sym_get_choice_prop(cs);
498: for (e = prop->expr; e; e = e->left.expr) {
499: if (e->right.sym->visible != no)
500: e->right.sym->flags |= SYMBOL_DEF_USER;
501: }
502: }
503:
504: sym->def[S_DEF_USER].tri = val;
505: if (oldval != val)
506: sym_clear_all_valid();
507:
508: return true;
509: }
510:
511: tristate sym_toggle_tristate_value(struct symbol *sym)
512: {
513: tristate oldval, newval;
514:
515: oldval = newval = sym_get_tristate_value(sym);
516: do {
517: switch (newval) {
518: case no:
519: newval = mod;
520: break;
521: case mod:
522: newval = yes;
523: break;
524: case yes:
525: newval = no;
526: break;
527: }
528: if (sym_set_tristate_value(sym, newval))
529: break;
530: } while (oldval != newval);
531: return newval;
532: }
533:
534: bool sym_string_valid(struct symbol *sym, const char *str)
535: {
536: signed char ch;
537:
538: switch (sym->type) {
539: case S_STRING:
540: return true;
541: case S_INT:
542: ch = *str++;
543: if (ch == '-')
544: ch = *str++;
545: if (!isdigit(ch))
546: return false;
547: if (ch == '0' && *str != 0)
548: return false;
549: while ((ch = *str++)) {
550: if (!isdigit(ch))
551: return false;
552: }
553: return true;
554: case S_HEX:
555: if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
556: str += 2;
557: ch = *str++;
558: do {
559: if (!isxdigit(ch))
560: return false;
561: } while ((ch = *str++));
562: return true;
563: case S_BOOLEAN:
564: case S_TRISTATE:
565: switch (str[0]) {
566: case 'y': case 'Y':
567: case 'm': case 'M':
568: case 'n': case 'N':
569: return true;
570: }
571: return false;
572: default:
573: return false;
574: }
575: }
576:
577: bool sym_string_within_range(struct symbol *sym, const char *str)
578: {
579: struct property *prop;
580: int val;
581:
582: switch (sym->type) {
583: case S_STRING:
584: return sym_string_valid(sym, str);
585: case S_INT:
586: if (!sym_string_valid(sym, str))
587: return false;
588: prop = sym_get_range_prop(sym);
589: if (!prop)
590: return true;
591: val = strtol(str, NULL, 10);
592: return val >= sym_get_range_val(prop->expr->left.sym, 10) &&
593: val <= sym_get_range_val(prop->expr->right.sym, 10);
594: case S_HEX:
595: if (!sym_string_valid(sym, str))
596: return false;
597: prop = sym_get_range_prop(sym);
598: if (!prop)
599: return true;
600: val = strtol(str, NULL, 16);
601: return val >= sym_get_range_val(prop->expr->left.sym, 16) &&
602: val <= sym_get_range_val(prop->expr->right.sym, 16);
603: case S_BOOLEAN:
604: case S_TRISTATE:
605: switch (str[0]) {
606: case 'y': case 'Y':
607: return sym_tristate_within_range(sym, yes);
608: case 'm': case 'M':
609: return sym_tristate_within_range(sym, mod);
610: case 'n': case 'N':
611: return sym_tristate_within_range(sym, no);
612: }
613: return false;
614: default:
615: return false;
616: }
617: }
618:
619: bool sym_set_string_value(struct symbol *sym, const char *newval)
620: {
621: const char *oldval;
622: char *val;
623: int size;
624:
625: switch (sym->type) {
626: case S_BOOLEAN:
627: case S_TRISTATE:
628: switch (newval[0]) {
629: case 'y': case 'Y':
630: return sym_set_tristate_value(sym, yes);
631: case 'm': case 'M':
632: return sym_set_tristate_value(sym, mod);
633: case 'n': case 'N':
634: return sym_set_tristate_value(sym, no);
635: }
636: return false;
637: default:
638: ;
639: }
640:
641: if (!sym_string_within_range(sym, newval))
642: return false;
643:
644: if (!(sym->flags & SYMBOL_DEF_USER)) {
645: sym->flags |= SYMBOL_DEF_USER;
646: sym_set_changed(sym);
647: }
648:
649: oldval = sym->def[S_DEF_USER].val;
650: size = strlen(newval) + 1;
651: if (sym->type == S_HEX && (newval[0] != '0' || (newval[1] != 'x' && newval[1] != 'X'))) {
652: size += 2;
653: sym->def[S_DEF_USER].val = val = malloc(size);
654: *val++ = '0';
655: *val++ = 'x';
656: } else if (!oldval || strcmp(oldval, newval))
657: sym->def[S_DEF_USER].val = val = malloc(size);
658: else
659: return true;
660:
661: strcpy(val, newval);
662: free((void *)oldval);
663: sym_clear_all_valid();
664:
665: return true;
666: }
667:
668: /*
669: * Find the default value associated to a symbol.
670: * For tristate symbol handle the modules=n case
671: * in which case "m" becomes "y".
672: * If the symbol does not have any default then fallback
673: * to the fixed default values.
674: */
675: const char *sym_get_string_default(struct symbol *sym)
676: {
677: struct property *prop;
678: struct symbol *ds;
679: const char *str;
680: tristate val;
681:
682: sym_calc_visibility(sym);
683: sym_calc_value(modules_sym);
684: val = symbol_no.curr.tri;
685: str = symbol_empty.curr.val;
686:
687: /* If symbol has a default value look it up */
688: prop = sym_get_default_prop(sym);
689: if (prop != NULL) {
690: switch (sym->type) {
691: case S_BOOLEAN:
692: case S_TRISTATE:
693: /* The visibility may limit the value from yes => mod */
694: val = EXPR_AND(expr_calc_value(prop->expr), prop->visible.tri);
695: break;
696: default:
697: /*
698: * The following fails to handle the situation
699: * where a default value is further limited by
700: * the valid range.
701: */
702: ds = prop_get_symbol(prop);
703: if (ds != NULL) {
704: sym_calc_value(ds);
705: str = (const char *)ds->curr.val;
706: }
707: }
708: }
709:
710: /* Handle select statements */
711: val = EXPR_OR(val, sym->rev_dep.tri);
712:
713: /* transpose mod to yes if modules are not enabled */
714: if (val == mod)
715: if (!sym_is_choice_value(sym) && modules_sym->curr.tri == no)
716: val = yes;
717:
718: /* transpose mod to yes if type is bool */
719: if (sym->type == S_BOOLEAN && val == mod)
720: val = yes;
721:
722: switch (sym->type) {
723: case S_BOOLEAN:
724: case S_TRISTATE:
725: switch (val) {
726: case no: return "n";
727: case mod: return "m";
728: case yes: return "y";
729: }
730: case S_INT:
731: case S_HEX:
732: return str;
733: case S_STRING:
734: return str;
735: case S_OTHER:
736: case S_UNKNOWN:
737: break;
738: }
739: return "";
740: }
741:
742: const char *sym_get_string_value(struct symbol *sym)
743: {
744: tristate val;
745:
746: switch (sym->type) {
747: case S_BOOLEAN:
748: case S_TRISTATE:
749: val = sym_get_tristate_value(sym);
750: switch (val) {
751: case no:
752: return "n";
753: case mod:
754: return "m";
755: case yes:
756: return "y";
757: }
758: break;
759: default:
760: ;
761: }
762: return (const char *)sym->curr.val;
763: }
764:
765: bool sym_is_changable(struct symbol *sym)
766: {
767: return sym->visible > sym->rev_dep.tri;
768: }
769:
770: static unsigned strhash(const char *s)
771: {
772: /* fnv32 hash */
773: unsigned hash = 2166136261U;
774: for (; *s; s++)
775: hash = (hash ^ *s) * 0x01000193;
776: return hash;
777: }
778:
779: struct symbol *sym_lookup(const char *name, int flags)
780: {
781: struct symbol *symbol;
782: char *new_name;
783: int hash;
784:
785: if (name) {
786: if (name[0] && !name[1]) {
787: switch (name[0]) {
788: case 'y': return &symbol_yes;
789: case 'm': return &symbol_mod;
790: case 'n': return &symbol_no;
791: }
792: }
793: hash = strhash(name) % SYMBOL_HASHSIZE;
794:
795: for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
796: if (symbol->name &&
797: !strcmp(symbol->name, name) &&
798: (flags ? symbol->flags & flags
799: : !(symbol->flags & (SYMBOL_CONST|SYMBOL_CHOICE))))
800: return symbol;
801: }
802: new_name = strdup(name);
803: } else {
804: new_name = NULL;
805: hash = 0;
806: }
807:
808: symbol = malloc(sizeof(*symbol));
809: memset(symbol, 0, sizeof(*symbol));
810: symbol->name = new_name;
811: symbol->type = S_UNKNOWN;
812: symbol->flags |= flags;
813:
814: symbol->next = symbol_hash[hash];
815: symbol_hash[hash] = symbol;
816:
817: return symbol;
818: }
819:
820: struct symbol *sym_find(const char *name)
821: {
822: struct symbol *symbol = NULL;
823: int hash = 0;
824:
825: if (!name)
826: return NULL;
827:
828: if (name[0] && !name[1]) {
829: switch (name[0]) {
830: case 'y': return &symbol_yes;
831: case 'm': return &symbol_mod;
832: case 'n': return &symbol_no;
833: }
834: }
835: hash = strhash(name) % SYMBOL_HASHSIZE;
836:
837: for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
838: if (symbol->name &&
839: !strcmp(symbol->name, name) &&
840: !(symbol->flags & SYMBOL_CONST))
841: break;
842: }
843:
844: return symbol;
845: }
846:
847: /*
848: * Expand symbol's names embedded in the string given in argument. Symbols'
849: * name to be expanded shall be prefixed by a '$'. Unknown symbol expands to
850: * the empty string.
851: */
852: const char *sym_expand_string_value(const char *in)
853: {
854: const char *src;
855: char *res;
856: size_t reslen;
857:
858: reslen = strlen(in) + 1;
859: res = malloc(reslen);
860: res[0] = '\0';
861:
862: while ((src = strchr(in, '$'))) {
863: char *p, name[SYMBOL_MAXLENGTH];
864: const char *symval = "";
865: struct symbol *sym;
866: size_t newlen;
867:
868: strncat(res, in, src - in);
869: src++;
870:
871: p = name;
872: while (isalnum(*src) || *src == '_')
873: *p++ = *src++;
874: *p = '\0';
875:
876: sym = sym_find(name);
877: if (sym != NULL) {
878: sym_calc_value(sym);
879: symval = sym_get_string_value(sym);
880: }
881:
882: newlen = strlen(res) + strlen(symval) + strlen(src) + 1;
883: if (newlen > reslen) {
884: reslen = newlen;
885: res = realloc(res, reslen);
886: }
887:
888: strcat(res, symval);
889: in = src;
890: }
891: strcat(res, in);
892:
893: return res;
894: }
895:
896: struct symbol **sym_re_search(const char *pattern)
897: {
898: struct symbol *sym, **sym_arr = NULL;
899: int i, cnt, size;
900: regex_t re;
901:
902: cnt = size = 0;
903: /* Skip if empty */
904: if (strlen(pattern) == 0)
905: return NULL;
906: if (regcomp(&re, pattern, REG_EXTENDED|REG_NOSUB|REG_ICASE))
907: return NULL;
908:
909: for_all_symbols(i, sym) {
910: if (sym->flags & SYMBOL_CONST || !sym->name)
911: continue;
912: if (regexec(&re, sym->name, 0, NULL, 0))
913: continue;
914: if (cnt + 1 >= size) {
915: void *tmp = sym_arr;
916: size += 16;
917: sym_arr = realloc(sym_arr, size * sizeof(struct symbol *));
918: if (!sym_arr) {
919: free(tmp);
920: return NULL;
921: }
922: }
923: sym_calc_value(sym);
924: sym_arr[cnt++] = sym;
925: }
926: if (sym_arr)
927: sym_arr[cnt] = NULL;
928: regfree(&re);
929:
930: return sym_arr;
931: }
932:
933: /*
934: * When we check for recursive dependencies we use a stack to save
935: * current state so we can print out relevant info to user.
936: * The entries are located on the call stack so no need to free memory.
937: * Note inser() remove() must always match to properly clear the stack.
938: */
939: static struct dep_stack {
940: struct dep_stack *prev, *next;
941: struct symbol *sym;
942: struct property *prop;
943: struct expr *expr;
944: } *check_top;
945:
946: static void dep_stack_insert(struct dep_stack *stack, struct symbol *sym)
947: {
948: memset(stack, 0, sizeof(*stack));
949: if (check_top)
950: check_top->next = stack;
951: stack->prev = check_top;
952: stack->sym = sym;
953: check_top = stack;
954: }
955:
956: static void dep_stack_remove(void)
957: {
958: check_top = check_top->prev;
959: if (check_top)
960: check_top->next = NULL;
961: }
962:
963: /*
964: * Called when we have detected a recursive dependency.
965: * check_top point to the top of the stact so we use
966: * the ->prev pointer to locate the bottom of the stack.
967: */
968: static void sym_check_print_recursive(struct symbol *last_sym)
969: {
970: struct dep_stack *stack;
971: struct symbol *sym, *next_sym;
972: struct menu *menu = NULL;
973: struct property *prop;
974: struct dep_stack cv_stack;
975:
976: if (sym_is_choice_value(last_sym)) {
977: dep_stack_insert(&cv_stack, last_sym);
978: last_sym = prop_get_symbol(sym_get_choice_prop(last_sym));
979: }
980:
981: for (stack = check_top; stack != NULL; stack = stack->prev)
982: if (stack->sym == last_sym)
983: break;
984: if (!stack) {
985: fprintf(stderr, "unexpected recursive dependency error\n");
986: return;
987: }
988:
989: for (; stack; stack = stack->next) {
990: sym = stack->sym;
991: next_sym = stack->next ? stack->next->sym : last_sym;
992: prop = stack->prop;
993: if (prop == NULL)
994: prop = stack->sym->prop;
995:
996: /* for choice values find the menu entry (used below) */
997: if (sym_is_choice(sym) || sym_is_choice_value(sym)) {
998: for (prop = sym->prop; prop; prop = prop->next) {
999: menu = prop->menu;
1000: if (prop->menu)
1001: break;
1002: }
1003: }
1004: if (stack->sym == last_sym)
1005: fprintf(stderr, "%s:%d:error: recursive dependency detected!\n",
1006: prop->file->name, prop->lineno);
1007: if (stack->expr) {
1008: fprintf(stderr, "%s:%d:\tsymbol %s %s value contains %s\n",
1009: prop->file->name, prop->lineno,
1010: sym->name ? sym->name : "<choice>",
1011: prop_get_type_name(prop->type),
1012: next_sym->name ? next_sym->name : "<choice>");
1013: } else if (stack->prop) {
1014: fprintf(stderr, "%s:%d:\tsymbol %s depends on %s\n",
1015: prop->file->name, prop->lineno,
1016: sym->name ? sym->name : "<choice>",
1017: next_sym->name ? next_sym->name : "<choice>");
1018: } else if (sym_is_choice(sym)) {
1019: fprintf(stderr, "%s:%d:\tchoice %s contains symbol %s\n",
1020: menu->file->name, menu->lineno,
1021: sym->name ? sym->name : "<choice>",
1022: next_sym->name ? next_sym->name : "<choice>");
1023: } else if (sym_is_choice_value(sym)) {
1024: fprintf(stderr, "%s:%d:\tsymbol %s is part of choice %s\n",
1025: menu->file->name, menu->lineno,
1026: sym->name ? sym->name : "<choice>",
1027: next_sym->name ? next_sym->name : "<choice>");
1028: } else {
1029: fprintf(stderr, "%s:%d:\tsymbol %s is selected by %s\n",
1030: prop->file->name, prop->lineno,
1031: sym->name ? sym->name : "<choice>",
1032: next_sym->name ? next_sym->name : "<choice>");
1033: }
1034: }
1035:
1036: if (check_top == &cv_stack)
1037: dep_stack_remove();
1038: }
1039:
1040: static struct symbol *sym_check_expr_deps(struct expr *e)
1041: {
1042: struct symbol *sym;
1043:
1044: if (!e)
1045: return NULL;
1046: switch (e->type) {
1047: case E_OR:
1048: case E_AND:
1049: sym = sym_check_expr_deps(e->left.expr);
1050: if (sym)
1051: return sym;
1052: return sym_check_expr_deps(e->right.expr);
1053: case E_NOT:
1054: return sym_check_expr_deps(e->left.expr);
1055: case E_EQUAL:
1056: case E_UNEQUAL:
1057: sym = sym_check_deps(e->left.sym);
1058: if (sym)
1059: return sym;
1060: return sym_check_deps(e->right.sym);
1061: case E_SYMBOL:
1062: return sym_check_deps(e->left.sym);
1063: default:
1064: break;
1065: }
1066: printf("Oops! How to check %d?\n", e->type);
1067: return NULL;
1068: }
1069:
1070: /* return NULL when dependencies are OK */
1071: static struct symbol *sym_check_sym_deps(struct symbol *sym)
1072: {
1073: struct symbol *sym2;
1074: struct property *prop;
1075: struct dep_stack stack;
1076:
1077: dep_stack_insert(&stack, sym);
1078:
1079: sym2 = sym_check_expr_deps(sym->rev_dep.expr);
1080: if (sym2)
1081: goto out;
1082:
1083: for (prop = sym->prop; prop; prop = prop->next) {
1084: if (prop->type == P_CHOICE || prop->type == P_SELECT)
1085: continue;
1086: stack.prop = prop;
1087: sym2 = sym_check_expr_deps(prop->visible.expr);
1088: if (sym2)
1089: break;
1090: if (prop->type != P_DEFAULT || sym_is_choice(sym))
1091: continue;
1092: stack.expr = prop->expr;
1093: sym2 = sym_check_expr_deps(prop->expr);
1094: if (sym2)
1095: break;
1096: stack.expr = NULL;
1097: }
1098:
1099: out:
1100: dep_stack_remove();
1101:
1102: return sym2;
1103: }
1104:
1105: static struct symbol *sym_check_choice_deps(struct symbol *choice)
1106: {
1107: struct symbol *sym, *sym2;
1108: struct property *prop;
1109: struct expr *e;
1110: struct dep_stack stack;
1111:
1112: dep_stack_insert(&stack, choice);
1113:
1114: prop = sym_get_choice_prop(choice);
1115: expr_list_for_each_sym(prop->expr, e, sym)
1116: sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
1117:
1118: choice->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
1119: sym2 = sym_check_sym_deps(choice);
1120: choice->flags &= ~SYMBOL_CHECK;
1121: if (sym2)
1122: goto out;
1123:
1124: expr_list_for_each_sym(prop->expr, e, sym) {
1125: sym2 = sym_check_sym_deps(sym);
1126: if (sym2)
1127: break;
1128: }
1129: out:
1130: expr_list_for_each_sym(prop->expr, e, sym)
1131: sym->flags &= ~SYMBOL_CHECK;
1132:
1133: if (sym2 && sym_is_choice_value(sym2) &&
1134: prop_get_symbol(sym_get_choice_prop(sym2)) == choice)
1135: sym2 = choice;
1136:
1137: dep_stack_remove();
1138:
1139: return sym2;
1140: }
1141:
1142: struct symbol *sym_check_deps(struct symbol *sym)
1143: {
1144: struct symbol *sym2;
1145: struct property *prop;
1146:
1147: if (sym->flags & SYMBOL_CHECK) {
1148: sym_check_print_recursive(sym);
1149: return sym;
1150: }
1151: if (sym->flags & SYMBOL_CHECKED)
1152: return NULL;
1153:
1154: if (sym_is_choice_value(sym)) {
1155: struct dep_stack stack;
1156:
1157: /* for choice groups start the check with main choice symbol */
1158: dep_stack_insert(&stack, sym);
1159: prop = sym_get_choice_prop(sym);
1160: sym2 = sym_check_deps(prop_get_symbol(prop));
1161: dep_stack_remove();
1162: } else if (sym_is_choice(sym)) {
1163: sym2 = sym_check_choice_deps(sym);
1164: } else {
1165: sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
1166: sym2 = sym_check_sym_deps(sym);
1167: sym->flags &= ~SYMBOL_CHECK;
1168: }
1169:
1170: if (sym2 && sym2 == sym)
1171: sym2 = NULL;
1172:
1173: return sym2;
1174: }
1175:
1176: struct property *prop_alloc(enum prop_type type, struct symbol *sym)
1177: {
1178: struct property *prop;
1179: struct property **propp;
1180:
1181: prop = malloc(sizeof(*prop));
1182: memset(prop, 0, sizeof(*prop));
1183: prop->type = type;
1184: prop->sym = sym;
1185: prop->file = current_file;
1186: prop->lineno = zconf_lineno();
1187:
1188: /* append property to the prop list of symbol */
1189: if (sym) {
1190: for (propp = &sym->prop; *propp; propp = &(*propp)->next)
1191: ;
1192: *propp = prop;
1193: }
1194:
1195: return prop;
1196: }
1197:
1198: struct symbol *prop_get_symbol(struct property *prop)
1199: {
1200: if (prop->expr && (prop->expr->type == E_SYMBOL ||
1201: prop->expr->type == E_LIST))
1202: return prop->expr->left.sym;
1203: return NULL;
1204: }
1205:
1206: const char *prop_get_type_name(enum prop_type type)
1207: {
1208: switch (type) {
1209: case P_PROMPT:
1210: return "prompt";
1211: case P_ENV:
1212: return "env";
1213: case P_COMMENT:
1214: return "comment";
1215: case P_MENU:
1216: return "menu";
1217: case P_DEFAULT:
1218: return "default";
1219: case P_CHOICE:
1220: return "choice";
1221: case P_SELECT:
1222: return "select";
1223: case P_RANGE:
1224: return "range";
1225: case P_SYMBOL:
1226: return "symbol";
1227: case P_UNKNOWN:
1228: break;
1229: }
1230: return "unknown";
1231: }
1232:
1233: static void prop_add_env(const char *env)
1234: {
1235: struct symbol *sym, *sym2;
1236: struct property *prop;
1237: char *p;
1238:
1239: sym = current_entry->sym;
1240: sym->flags |= SYMBOL_AUTO;
1241: for_all_properties(sym, prop, P_ENV) {
1242: sym2 = prop_get_symbol(prop);
1243: if (strcmp(sym2->name, env))
1244: menu_warn(current_entry, "redefining environment symbol from %s",
1245: sym2->name);
1246: return;
1247: }
1248:
1249: prop = prop_alloc(P_ENV, sym);
1250: prop->expr = expr_alloc_symbol(sym_lookup(env, SYMBOL_CONST));
1251:
1252: sym_env_list = expr_alloc_one(E_LIST, sym_env_list);
1253: sym_env_list->right.sym = sym;
1254:
1255: p = getenv(env);
1256: if (p)
1257: sym_add_default(sym, p);
1258: else
1259: menu_warn(current_entry, "environment variable %s undefined", env);
1260: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.