author | kergoth <kergoth> | 2003-06-17 17:03:49 (UTC) |
---|---|---|
committer | kergoth <kergoth> | 2003-06-17 17:03:49 (UTC) |
commit | 16e53b2a2e94742f3b55ee73700bb264e36638d4 (patch) (unidiff) | |
tree | 4f2b65a635d25c1ce0cfeea7953623c2bf7d9534 /scripts/kconfig/expr.c | |
parent | 384b7f1a42f9f2f101dc8fe11c3625055d96f672 (diff) | |
download | opie-16e53b2a2e94742f3b55ee73700bb264e36638d4.zip opie-16e53b2a2e94742f3b55ee73700bb264e36638d4.tar.gz opie-16e53b2a2e94742f3b55ee73700bb264e36638d4.tar.bz2 |
Update LinuxKernelConf version to 1.4.
-rw-r--r-- | scripts/kconfig/expr.c | 35 |
1 files changed, 32 insertions, 3 deletions
diff --git a/scripts/kconfig/expr.c b/scripts/kconfig/expr.c index d1af2a5..3f15ae8 100644 --- a/scripts/kconfig/expr.c +++ b/scripts/kconfig/expr.c | |||
@@ -10,96 +10,103 @@ | |||
10 | #define LKC_DIRECT_LINK | 10 | #define LKC_DIRECT_LINK |
11 | #include "lkc.h" | 11 | #include "lkc.h" |
12 | 12 | ||
13 | struct expr *expr_alloc_symbol(struct symbol *sym) | 13 | struct expr *expr_alloc_symbol(struct symbol *sym) |
14 | { | 14 | { |
15 | struct expr *e = malloc(sizeof(*e)); | 15 | struct expr *e = malloc(sizeof(*e)); |
16 | memset(e, 0, sizeof(*e)); | 16 | memset(e, 0, sizeof(*e)); |
17 | e->type = E_SYMBOL; | 17 | e->type = E_SYMBOL; |
18 | e->left.sym = sym; | 18 | e->left.sym = sym; |
19 | return e; | 19 | return e; |
20 | } | 20 | } |
21 | 21 | ||
22 | struct expr *expr_alloc_one(enum expr_type type, struct expr *ce) | 22 | struct expr *expr_alloc_one(enum expr_type type, struct expr *ce) |
23 | { | 23 | { |
24 | struct expr *e = malloc(sizeof(*e)); | 24 | struct expr *e = malloc(sizeof(*e)); |
25 | memset(e, 0, sizeof(*e)); | 25 | memset(e, 0, sizeof(*e)); |
26 | e->type = type; | 26 | e->type = type; |
27 | e->left.expr = ce; | 27 | e->left.expr = ce; |
28 | return e; | 28 | return e; |
29 | } | 29 | } |
30 | 30 | ||
31 | struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2) | 31 | struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2) |
32 | { | 32 | { |
33 | struct expr *e = malloc(sizeof(*e)); | 33 | struct expr *e = malloc(sizeof(*e)); |
34 | memset(e, 0, sizeof(*e)); | 34 | memset(e, 0, sizeof(*e)); |
35 | e->type = type; | 35 | e->type = type; |
36 | e->left.expr = e1; | 36 | e->left.expr = e1; |
37 | e->right.expr = e2; | 37 | e->right.expr = e2; |
38 | return e; | 38 | return e; |
39 | } | 39 | } |
40 | 40 | ||
41 | struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2) | 41 | struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2) |
42 | { | 42 | { |
43 | struct expr *e = malloc(sizeof(*e)); | 43 | struct expr *e = malloc(sizeof(*e)); |
44 | memset(e, 0, sizeof(*e)); | 44 | memset(e, 0, sizeof(*e)); |
45 | e->type = type; | 45 | e->type = type; |
46 | e->left.sym = s1; | 46 | e->left.sym = s1; |
47 | e->right.sym = s2; | 47 | e->right.sym = s2; |
48 | return e; | 48 | return e; |
49 | } | 49 | } |
50 | 50 | ||
51 | struct expr *expr_alloc_and(struct expr *e1, struct expr *e2) | 51 | struct expr *expr_alloc_and(struct expr *e1, struct expr *e2) |
52 | { | 52 | { |
53 | if (!e1) | 53 | if (!e1) |
54 | return e2; | 54 | return e2; |
55 | return e2 ? expr_alloc_two(E_AND, e1, e2) : e1; | 55 | return e2 ? expr_alloc_two(E_AND, e1, e2) : e1; |
56 | } | 56 | } |
57 | 57 | ||
58 | struct expr *expr_alloc_or(struct expr *e1, struct expr *e2) | ||
59 | { | ||
60 | if (!e1) | ||
61 | return e2; | ||
62 | return e2 ? expr_alloc_two(E_OR, e1, e2) : e1; | ||
63 | } | ||
64 | |||
58 | struct expr *expr_copy(struct expr *org) | 65 | struct expr *expr_copy(struct expr *org) |
59 | { | 66 | { |
60 | struct expr *e; | 67 | struct expr *e; |
61 | 68 | ||
62 | if (!org) | 69 | if (!org) |
63 | return NULL; | 70 | return NULL; |
64 | 71 | ||
65 | e = malloc(sizeof(*org)); | 72 | e = malloc(sizeof(*org)); |
66 | memcpy(e, org, sizeof(*org)); | 73 | memcpy(e, org, sizeof(*org)); |
67 | switch (org->type) { | 74 | switch (org->type) { |
68 | case E_SYMBOL: | 75 | case E_SYMBOL: |
69 | e->left = org->left; | 76 | e->left = org->left; |
70 | break; | 77 | break; |
71 | case E_NOT: | 78 | case E_NOT: |
72 | e->left.expr = expr_copy(org->left.expr); | 79 | e->left.expr = expr_copy(org->left.expr); |
73 | break; | 80 | break; |
74 | case E_EQUAL: | 81 | case E_EQUAL: |
75 | case E_UNEQUAL: | 82 | case E_UNEQUAL: |
76 | e->left.sym = org->left.sym; | 83 | e->left.sym = org->left.sym; |
77 | e->right.sym = org->right.sym; | 84 | e->right.sym = org->right.sym; |
78 | break; | 85 | break; |
79 | case E_AND: | 86 | case E_AND: |
80 | case E_OR: | 87 | case E_OR: |
81 | case E_CHOICE: | 88 | case E_CHOICE: |
82 | e->left.expr = expr_copy(org->left.expr); | 89 | e->left.expr = expr_copy(org->left.expr); |
83 | e->right.expr = expr_copy(org->right.expr); | 90 | e->right.expr = expr_copy(org->right.expr); |
84 | break; | 91 | break; |
85 | default: | 92 | default: |
86 | printf("can't copy type %d\n", e->type); | 93 | printf("can't copy type %d\n", e->type); |
87 | free(e); | 94 | free(e); |
88 | e = NULL; | 95 | e = NULL; |
89 | break; | 96 | break; |
90 | } | 97 | } |
91 | 98 | ||
92 | return e; | 99 | return e; |
93 | } | 100 | } |
94 | 101 | ||
95 | void expr_free(struct expr *e) | 102 | void expr_free(struct expr *e) |
96 | { | 103 | { |
97 | if (!e) | 104 | if (!e) |
98 | return; | 105 | return; |
99 | 106 | ||
100 | switch (e->type) { | 107 | switch (e->type) { |
101 | case E_SYMBOL: | 108 | case E_SYMBOL: |
102 | break; | 109 | break; |
103 | case E_NOT: | 110 | case E_NOT: |
104 | expr_free(e->left.expr); | 111 | expr_free(e->left.expr); |
105 | return; | 112 | return; |
@@ -113,133 +120,147 @@ void expr_free(struct expr *e) | |||
113 | break; | 120 | break; |
114 | default: | 121 | default: |
115 | printf("how to free type %d?\n", e->type); | 122 | printf("how to free type %d?\n", e->type); |
116 | break; | 123 | break; |
117 | } | 124 | } |
118 | free(e); | 125 | free(e); |
119 | } | 126 | } |
120 | 127 | ||
121 | static int trans_count; | 128 | static int trans_count; |
122 | 129 | ||
123 | #define e1 (*ep1) | 130 | #define e1 (*ep1) |
124 | #define e2 (*ep2) | 131 | #define e2 (*ep2) |
125 | 132 | ||
126 | static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct expr **ep2) | 133 | static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct expr **ep2) |
127 | { | 134 | { |
128 | if (e1->type == type) { | 135 | if (e1->type == type) { |
129 | __expr_eliminate_eq(type, &e1->left.expr, &e2); | 136 | __expr_eliminate_eq(type, &e1->left.expr, &e2); |
130 | __expr_eliminate_eq(type, &e1->right.expr, &e2); | 137 | __expr_eliminate_eq(type, &e1->right.expr, &e2); |
131 | return; | 138 | return; |
132 | } | 139 | } |
133 | if (e2->type == type) { | 140 | if (e2->type == type) { |
134 | __expr_eliminate_eq(type, &e1, &e2->left.expr); | 141 | __expr_eliminate_eq(type, &e1, &e2->left.expr); |
135 | __expr_eliminate_eq(type, &e1, &e2->right.expr); | 142 | __expr_eliminate_eq(type, &e1, &e2->right.expr); |
136 | return; | 143 | return; |
137 | } | 144 | } |
138 | if (e1->type == E_SYMBOL && e2->type == E_SYMBOL && | 145 | if (e1->type == E_SYMBOL && e2->type == E_SYMBOL && |
139 | e1->left.sym == e2->left.sym && (e1->left.sym->flags & (SYMBOL_YES|SYMBOL_NO))) | 146 | e1->left.sym == e2->left.sym && (e1->left.sym->flags & (SYMBOL_YES|SYMBOL_NO))) |
140 | return; | 147 | return; |
141 | if (!expr_eq(e1, e2)) | 148 | if (!expr_eq(e1, e2)) |
142 | return; | 149 | return; |
143 | trans_count++; | 150 | trans_count++; |
144 | expr_free(e1); expr_free(e2); | 151 | expr_free(e1); expr_free(e2); |
145 | switch (type) { | 152 | switch (type) { |
146 | case E_OR: | 153 | case E_OR: |
147 | e1 = expr_alloc_symbol(&symbol_no); | 154 | e1 = expr_alloc_symbol(&symbol_no); |
148 | e2 = expr_alloc_symbol(&symbol_no); | 155 | e2 = expr_alloc_symbol(&symbol_no); |
149 | break; | 156 | break; |
150 | case E_AND: | 157 | case E_AND: |
151 | e1 = expr_alloc_symbol(&symbol_yes); | 158 | e1 = expr_alloc_symbol(&symbol_yes); |
152 | e2 = expr_alloc_symbol(&symbol_yes); | 159 | e2 = expr_alloc_symbol(&symbol_yes); |
153 | break; | 160 | break; |
154 | default: | 161 | default: |
155 | ; | 162 | ; |
156 | } | 163 | } |
157 | } | 164 | } |
158 | 165 | ||
159 | void expr_eliminate_eq(struct expr **ep1, struct expr **ep2) | 166 | void expr_eliminate_eq(struct expr **ep1, struct expr **ep2) |
160 | { | 167 | { |
161 | if (!e1 || !e2 || e1->type != e2->type) | 168 | if (!e1 || !e2) |
162 | return; | 169 | return; |
170 | switch (e1->type) { | ||
171 | case E_OR: | ||
172 | case E_AND: | ||
163 | __expr_eliminate_eq(e1->type, ep1, ep2); | 173 | __expr_eliminate_eq(e1->type, ep1, ep2); |
174 | default: | ||
175 | ; | ||
176 | } | ||
177 | if (e1->type != e2->type) switch (e2->type) { | ||
178 | case E_OR: | ||
179 | case E_AND: | ||
180 | __expr_eliminate_eq(e2->type, ep1, ep2); | ||
181 | default: | ||
182 | ; | ||
183 | } | ||
164 | e1 = expr_eliminate_yn(e1); | 184 | e1 = expr_eliminate_yn(e1); |
165 | e2 = expr_eliminate_yn(e2); | 185 | e2 = expr_eliminate_yn(e2); |
166 | } | 186 | } |
167 | 187 | ||
168 | #undef e1 | 188 | #undef e1 |
169 | #undef e2 | 189 | #undef e2 |
170 | 190 | ||
171 | int expr_eq(struct expr *e1, struct expr *e2) | 191 | int expr_eq(struct expr *e1, struct expr *e2) |
172 | { | 192 | { |
173 | int res, old_count; | 193 | int res, old_count; |
174 | 194 | ||
175 | if (e1->type != e2->type) | 195 | if (e1->type != e2->type) |
176 | return 0; | 196 | return 0; |
177 | switch (e1->type) { | 197 | switch (e1->type) { |
178 | case E_EQUAL: | 198 | case E_EQUAL: |
179 | case E_UNEQUAL: | 199 | case E_UNEQUAL: |
180 | return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym; | 200 | return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym; |
181 | case E_SYMBOL: | 201 | case E_SYMBOL: |
182 | return e1->left.sym == e2->left.sym; | 202 | return e1->left.sym == e2->left.sym; |
183 | case E_NOT: | 203 | case E_NOT: |
184 | return expr_eq(e1->left.expr, e2->left.expr); | 204 | return expr_eq(e1->left.expr, e2->left.expr); |
185 | case E_AND: | 205 | case E_AND: |
186 | case E_OR: | 206 | case E_OR: |
187 | e1 = expr_copy(e1); | 207 | e1 = expr_copy(e1); |
188 | e2 = expr_copy(e2); | 208 | e2 = expr_copy(e2); |
189 | old_count = trans_count; | 209 | old_count = trans_count; |
190 | expr_eliminate_eq(&e1, &e2); | 210 | expr_eliminate_eq(&e1, &e2); |
191 | res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL && | 211 | res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL && |
192 | e1->left.sym == e2->left.sym); | 212 | e1->left.sym == e2->left.sym); |
193 | expr_free(e1); | 213 | expr_free(e1); |
194 | expr_free(e2); | 214 | expr_free(e2); |
195 | trans_count = old_count; | 215 | trans_count = old_count; |
196 | return res; | 216 | return res; |
197 | case E_CHOICE: | 217 | case E_CHOICE: |
218 | case E_RANGE: | ||
198 | case E_NONE: | 219 | case E_NONE: |
199 | /* panic */; | 220 | /* panic */; |
200 | } | 221 | } |
201 | 222 | ||
202 | print_expr(0, e1, 0); | 223 | print_expr(0, e1, 0); |
203 | printf(" = "); | 224 | printf(" = "); |
204 | print_expr(0, e2, 0); | 225 | print_expr(0, e2, 0); |
205 | printf(" ?\n"); | 226 | printf(" ?\n"); |
206 | 227 | ||
207 | return 0; | 228 | return 0; |
208 | } | 229 | } |
209 | 230 | ||
210 | struct expr *expr_eliminate_yn(struct expr *e) | 231 | struct expr *expr_eliminate_yn(struct expr *e) |
211 | { | 232 | { |
212 | struct expr *tmp; | 233 | struct expr *tmp; |
213 | 234 | ||
214 | if (e) switch (e->type) { | 235 | if (e) switch (e->type) { |
215 | case E_AND: | 236 | case E_AND: |
216 | e->left.expr = expr_eliminate_yn(e->left.expr); | 237 | e->left.expr = expr_eliminate_yn(e->left.expr); |
217 | e->right.expr = expr_eliminate_yn(e->right.expr); | 238 | e->right.expr = expr_eliminate_yn(e->right.expr); |
218 | if (e->left.expr->type == E_SYMBOL) { | 239 | if (e->left.expr->type == E_SYMBOL) { |
219 | if (e->left.expr->left.sym == &symbol_no) { | 240 | if (e->left.expr->left.sym == &symbol_no) { |
220 | expr_free(e->left.expr); | 241 | expr_free(e->left.expr); |
221 | expr_free(e->right.expr); | 242 | expr_free(e->right.expr); |
222 | e->type = E_SYMBOL; | 243 | e->type = E_SYMBOL; |
223 | e->left.sym = &symbol_no; | 244 | e->left.sym = &symbol_no; |
224 | e->right.expr = NULL; | 245 | e->right.expr = NULL; |
225 | return e; | 246 | return e; |
226 | } else if (e->left.expr->left.sym == &symbol_yes) { | 247 | } else if (e->left.expr->left.sym == &symbol_yes) { |
227 | free(e->left.expr); | 248 | free(e->left.expr); |
228 | tmp = e->right.expr; | 249 | tmp = e->right.expr; |
229 | *e = *(e->right.expr); | 250 | *e = *(e->right.expr); |
230 | free(tmp); | 251 | free(tmp); |
231 | return e; | 252 | return e; |
232 | } | 253 | } |
233 | } | 254 | } |
234 | if (e->right.expr->type == E_SYMBOL) { | 255 | if (e->right.expr->type == E_SYMBOL) { |
235 | if (e->right.expr->left.sym == &symbol_no) { | 256 | if (e->right.expr->left.sym == &symbol_no) { |
236 | expr_free(e->left.expr); | 257 | expr_free(e->left.expr); |
237 | expr_free(e->right.expr); | 258 | expr_free(e->right.expr); |
238 | e->type = E_SYMBOL; | 259 | e->type = E_SYMBOL; |
239 | e->left.sym = &symbol_no; | 260 | e->left.sym = &symbol_no; |
240 | e->right.expr = NULL; | 261 | e->right.expr = NULL; |
241 | return e; | 262 | return e; |
242 | } else if (e->right.expr->left.sym == &symbol_yes) { | 263 | } else if (e->right.expr->left.sym == &symbol_yes) { |
243 | free(e->right.expr); | 264 | free(e->right.expr); |
244 | tmp = e->left.expr; | 265 | tmp = e->left.expr; |
245 | *e = *(e->left.expr); | 266 | *e = *(e->left.expr); |
@@ -852,114 +873,115 @@ struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symb | |||
852 | if (type == E_UNEQUAL) | 873 | if (type == E_UNEQUAL) |
853 | e = expr_alloc_one(E_NOT, e); | 874 | e = expr_alloc_one(E_NOT, e); |
854 | return e; | 875 | return e; |
855 | } | 876 | } |
856 | switch (e->type) { | 877 | switch (e->type) { |
857 | case E_AND: | 878 | case E_AND: |
858 | e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym); | 879 | e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym); |
859 | e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym); | 880 | e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym); |
860 | if (sym == &symbol_yes) | 881 | if (sym == &symbol_yes) |
861 | e = expr_alloc_two(E_AND, e1, e2); | 882 | e = expr_alloc_two(E_AND, e1, e2); |
862 | if (sym == &symbol_no) | 883 | if (sym == &symbol_no) |
863 | e = expr_alloc_two(E_OR, e1, e2); | 884 | e = expr_alloc_two(E_OR, e1, e2); |
864 | if (type == E_UNEQUAL) | 885 | if (type == E_UNEQUAL) |
865 | e = expr_alloc_one(E_NOT, e); | 886 | e = expr_alloc_one(E_NOT, e); |
866 | return e; | 887 | return e; |
867 | case E_OR: | 888 | case E_OR: |
868 | e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym); | 889 | e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym); |
869 | e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym); | 890 | e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym); |
870 | if (sym == &symbol_yes) | 891 | if (sym == &symbol_yes) |
871 | e = expr_alloc_two(E_OR, e1, e2); | 892 | e = expr_alloc_two(E_OR, e1, e2); |
872 | if (sym == &symbol_no) | 893 | if (sym == &symbol_no) |
873 | e = expr_alloc_two(E_AND, e1, e2); | 894 | e = expr_alloc_two(E_AND, e1, e2); |
874 | if (type == E_UNEQUAL) | 895 | if (type == E_UNEQUAL) |
875 | e = expr_alloc_one(E_NOT, e); | 896 | e = expr_alloc_one(E_NOT, e); |
876 | return e; | 897 | return e; |
877 | case E_NOT: | 898 | case E_NOT: |
878 | return expr_trans_compare(e->left.expr, type == E_EQUAL ? E_UNEQUAL : E_EQUAL, sym); | 899 | return expr_trans_compare(e->left.expr, type == E_EQUAL ? E_UNEQUAL : E_EQUAL, sym); |
879 | case E_UNEQUAL: | 900 | case E_UNEQUAL: |
880 | case E_EQUAL: | 901 | case E_EQUAL: |
881 | if (type == E_EQUAL) { | 902 | if (type == E_EQUAL) { |
882 | if (sym == &symbol_yes) | 903 | if (sym == &symbol_yes) |
883 | return expr_copy(e); | 904 | return expr_copy(e); |
884 | if (sym == &symbol_mod) | 905 | if (sym == &symbol_mod) |
885 | return expr_alloc_symbol(&symbol_no); | 906 | return expr_alloc_symbol(&symbol_no); |
886 | if (sym == &symbol_no) | 907 | if (sym == &symbol_no) |
887 | return expr_alloc_one(E_NOT, expr_copy(e)); | 908 | return expr_alloc_one(E_NOT, expr_copy(e)); |
888 | } else { | 909 | } else { |
889 | if (sym == &symbol_yes) | 910 | if (sym == &symbol_yes) |
890 | return expr_alloc_one(E_NOT, expr_copy(e)); | 911 | return expr_alloc_one(E_NOT, expr_copy(e)); |
891 | if (sym == &symbol_mod) | 912 | if (sym == &symbol_mod) |
892 | return expr_alloc_symbol(&symbol_yes); | 913 | return expr_alloc_symbol(&symbol_yes); |
893 | if (sym == &symbol_no) | 914 | if (sym == &symbol_no) |
894 | return expr_copy(e); | 915 | return expr_copy(e); |
895 | } | 916 | } |
896 | break; | 917 | break; |
897 | case E_SYMBOL: | 918 | case E_SYMBOL: |
898 | return expr_alloc_comp(type, e->left.sym, sym); | 919 | return expr_alloc_comp(type, e->left.sym, sym); |
899 | case E_CHOICE: | 920 | case E_CHOICE: |
921 | case E_RANGE: | ||
900 | case E_NONE: | 922 | case E_NONE: |
901 | /* panic */; | 923 | /* panic */; |
902 | } | 924 | } |
903 | return NULL; | 925 | return NULL; |
904 | } | 926 | } |
905 | 927 | ||
906 | tristate expr_calc_value(struct expr *e) | 928 | tristate expr_calc_value(struct expr *e) |
907 | { | 929 | { |
908 | tristate val1, val2; | 930 | tristate val1, val2; |
909 | const char *str1, *str2; | 931 | const char *str1, *str2; |
910 | 932 | ||
911 | if (!e) | 933 | if (!e) |
912 | return yes; | 934 | return yes; |
913 | 935 | ||
914 | switch (e->type) { | 936 | switch (e->type) { |
915 | case E_SYMBOL: | 937 | case E_SYMBOL: |
916 | sym_calc_value(e->left.sym); | 938 | sym_calc_value(e->left.sym); |
917 | return S_TRI(e->left.sym->curr); | 939 | return e->left.sym->curr.tri; |
918 | case E_AND: | 940 | case E_AND: |
919 | val1 = expr_calc_value(e->left.expr); | 941 | val1 = expr_calc_value(e->left.expr); |
920 | val2 = expr_calc_value(e->right.expr); | 942 | val2 = expr_calc_value(e->right.expr); |
921 | return E_AND(val1, val2); | 943 | return E_AND(val1, val2); |
922 | case E_OR: | 944 | case E_OR: |
923 | val1 = expr_calc_value(e->left.expr); | 945 | val1 = expr_calc_value(e->left.expr); |
924 | val2 = expr_calc_value(e->right.expr); | 946 | val2 = expr_calc_value(e->right.expr); |
925 | return E_OR(val1, val2); | 947 | return E_OR(val1, val2); |
926 | case E_NOT: | 948 | case E_NOT: |
927 | val1 = expr_calc_value(e->left.expr); | 949 | val1 = expr_calc_value(e->left.expr); |
928 | return E_NOT(val1); | 950 | return E_NOT(val1); |
929 | case E_EQUAL: | 951 | case E_EQUAL: |
930 | sym_calc_value(e->left.sym); | 952 | sym_calc_value(e->left.sym); |
931 | sym_calc_value(e->right.sym); | 953 | sym_calc_value(e->right.sym); |
932 | str1 = sym_get_string_value(e->left.sym); | 954 | str1 = sym_get_string_value(e->left.sym); |
933 | str2 = sym_get_string_value(e->right.sym); | 955 | str2 = sym_get_string_value(e->right.sym); |
934 | return !strcmp(str1, str2) ? yes : no; | 956 | return !strcmp(str1, str2) ? yes : no; |
935 | case E_UNEQUAL: | 957 | case E_UNEQUAL: |
936 | sym_calc_value(e->left.sym); | 958 | sym_calc_value(e->left.sym); |
937 | sym_calc_value(e->right.sym); | 959 | sym_calc_value(e->right.sym); |
938 | str1 = sym_get_string_value(e->left.sym); | 960 | str1 = sym_get_string_value(e->left.sym); |
939 | str2 = sym_get_string_value(e->right.sym); | 961 | str2 = sym_get_string_value(e->right.sym); |
940 | return !strcmp(str1, str2) ? no : yes; | 962 | return !strcmp(str1, str2) ? no : yes; |
941 | default: | 963 | default: |
942 | printf("expr_calc_value: %d?\n", e->type); | 964 | printf("expr_calc_value: %d?\n", e->type); |
943 | return no; | 965 | return no; |
944 | } | 966 | } |
945 | } | 967 | } |
946 | 968 | ||
947 | int expr_compare_type(enum expr_type t1, enum expr_type t2) | 969 | int expr_compare_type(enum expr_type t1, enum expr_type t2) |
948 | { | 970 | { |
949 | #if 0 | 971 | #if 0 |
950 | return 1; | 972 | return 1; |
951 | #else | 973 | #else |
952 | if (t1 == t2) | 974 | if (t1 == t2) |
953 | return 0; | 975 | return 0; |
954 | switch (t1) { | 976 | switch (t1) { |
955 | case E_EQUAL: | 977 | case E_EQUAL: |
956 | case E_UNEQUAL: | 978 | case E_UNEQUAL: |
957 | if (t2 == E_NOT) | 979 | if (t2 == E_NOT) |
958 | return 1; | 980 | return 1; |
959 | case E_NOT: | 981 | case E_NOT: |
960 | if (t2 == E_AND) | 982 | if (t2 == E_AND) |
961 | return 1; | 983 | return 1; |
962 | case E_AND: | 984 | case E_AND: |
963 | if (t2 == E_OR) | 985 | if (t2 == E_OR) |
964 | return 1; | 986 | return 1; |
965 | case E_OR: | 987 | case E_OR: |
@@ -972,83 +994,90 @@ int expr_compare_type(enum expr_type t1, enum expr_type t2) | |||
972 | return -1; | 994 | return -1; |
973 | } | 995 | } |
974 | printf("[%dgt%d?]", t1, t2); | 996 | printf("[%dgt%d?]", t1, t2); |
975 | return 0; | 997 | return 0; |
976 | #endif | 998 | #endif |
977 | } | 999 | } |
978 | 1000 | ||
979 | void expr_print(struct expr *e, void (*fn)(void *, const char *), void *data, int prevtoken) | 1001 | void expr_print(struct expr *e, void (*fn)(void *, const char *), void *data, int prevtoken) |
980 | { | 1002 | { |
981 | if (!e) { | 1003 | if (!e) { |
982 | fn(data, "y"); | 1004 | fn(data, "y"); |
983 | return; | 1005 | return; |
984 | } | 1006 | } |
985 | 1007 | ||
986 | if (expr_compare_type(prevtoken, e->type) > 0) | 1008 | if (expr_compare_type(prevtoken, e->type) > 0) |
987 | fn(data, "("); | 1009 | fn(data, "("); |
988 | switch (e->type) { | 1010 | switch (e->type) { |
989 | case E_SYMBOL: | 1011 | case E_SYMBOL: |
990 | if (e->left.sym->name) | 1012 | if (e->left.sym->name) |
991 | fn(data, e->left.sym->name); | 1013 | fn(data, e->left.sym->name); |
992 | else | 1014 | else |
993 | fn(data, "<choice>"); | 1015 | fn(data, "<choice>"); |
994 | break; | 1016 | break; |
995 | case E_NOT: | 1017 | case E_NOT: |
996 | fn(data, "!"); | 1018 | fn(data, "!"); |
997 | expr_print(e->left.expr, fn, data, E_NOT); | 1019 | expr_print(e->left.expr, fn, data, E_NOT); |
998 | break; | 1020 | break; |
999 | case E_EQUAL: | 1021 | case E_EQUAL: |
1000 | fn(data, e->left.sym->name); | 1022 | fn(data, e->left.sym->name); |
1001 | fn(data, "="); | 1023 | fn(data, "="); |
1002 | fn(data, e->right.sym->name); | 1024 | fn(data, e->right.sym->name); |
1003 | break; | 1025 | break; |
1004 | case E_UNEQUAL: | 1026 | case E_UNEQUAL: |
1005 | fn(data, e->left.sym->name); | 1027 | fn(data, e->left.sym->name); |
1006 | fn(data, "!="); | 1028 | fn(data, "!="); |
1007 | fn(data, e->right.sym->name); | 1029 | fn(data, e->right.sym->name); |
1008 | break; | 1030 | break; |
1009 | case E_OR: | 1031 | case E_OR: |
1010 | expr_print(e->left.expr, fn, data, E_OR); | 1032 | expr_print(e->left.expr, fn, data, E_OR); |
1011 | fn(data, " || "); | 1033 | fn(data, " || "); |
1012 | expr_print(e->right.expr, fn, data, E_OR); | 1034 | expr_print(e->right.expr, fn, data, E_OR); |
1013 | break; | 1035 | break; |
1014 | case E_AND: | 1036 | case E_AND: |
1015 | expr_print(e->left.expr, fn, data, E_AND); | 1037 | expr_print(e->left.expr, fn, data, E_AND); |
1016 | fn(data, " && "); | 1038 | fn(data, " && "); |
1017 | expr_print(e->right.expr, fn, data, E_AND); | 1039 | expr_print(e->right.expr, fn, data, E_AND); |
1018 | break; | 1040 | break; |
1019 | case E_CHOICE: | 1041 | case E_CHOICE: |
1042 | fn(data, e->right.sym->name); | ||
1020 | if (e->left.expr) { | 1043 | if (e->left.expr) { |
1021 | expr_print(e->left.expr, fn, data, E_CHOICE); | ||
1022 | fn(data, " ^ "); | 1044 | fn(data, " ^ "); |
1045 | expr_print(e->left.expr, fn, data, E_CHOICE); | ||
1023 | } | 1046 | } |
1047 | break; | ||
1048 | case E_RANGE: | ||
1049 | fn(data, "["); | ||
1050 | fn(data, e->left.sym->name); | ||
1051 | fn(data, " "); | ||
1024 | fn(data, e->right.sym->name); | 1052 | fn(data, e->right.sym->name); |
1053 | fn(data, "]"); | ||
1025 | break; | 1054 | break; |
1026 | default: | 1055 | default: |
1027 | { | 1056 | { |
1028 | char buf[32]; | 1057 | char buf[32]; |
1029 | sprintf(buf, "<unknown type %d>", e->type); | 1058 | sprintf(buf, "<unknown type %d>", e->type); |
1030 | fn(data, buf); | 1059 | fn(data, buf); |
1031 | break; | 1060 | break; |
1032 | } | 1061 | } |
1033 | } | 1062 | } |
1034 | if (expr_compare_type(prevtoken, e->type) > 0) | 1063 | if (expr_compare_type(prevtoken, e->type) > 0) |
1035 | fn(data, ")"); | 1064 | fn(data, ")"); |
1036 | } | 1065 | } |
1037 | 1066 | ||
1038 | static void expr_print_file_helper(void *data, const char *str) | 1067 | static void expr_print_file_helper(void *data, const char *str) |
1039 | { | 1068 | { |
1040 | fwrite(str, strlen(str), 1, data); | 1069 | fwrite(str, strlen(str), 1, data); |
1041 | } | 1070 | } |
1042 | 1071 | ||
1043 | void expr_fprint(struct expr *e, FILE *out) | 1072 | void expr_fprint(struct expr *e, FILE *out) |
1044 | { | 1073 | { |
1045 | expr_print(e, expr_print_file_helper, out, E_NONE); | 1074 | expr_print(e, expr_print_file_helper, out, E_NONE); |
1046 | } | 1075 | } |
1047 | 1076 | ||
1048 | void print_expr(int mask, struct expr *e, int prevtoken) | 1077 | void print_expr(int mask, struct expr *e, int prevtoken) |
1049 | { | 1078 | { |
1050 | if (!(cdebug & mask)) | 1079 | if (!(cdebug & mask)) |
1051 | return; | 1080 | return; |
1052 | expr_fprint(e, stdout); | 1081 | expr_fprint(e, stdout); |
1053 | } | 1082 | } |
1054 | 1083 | ||