scripts/kconfig/expr.c

   1 /*
   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 <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 #include "lkc.h"
  11
  12 #define DEBUG_EXPR      0
  13
  14 struct expr *expr_alloc_symbol(struct symbol *sym)
  15 {
  16         struct expr *e = calloc(1, sizeof(*e));
  17         e->type = E_SYMBOL;
  18         e->left.sym = sym;
  19         return e;
  20 }
  21
  22 struct expr *expr_alloc_one(enum expr_type type, struct expr *ce)
  23 {
  24         struct expr *e = calloc(1, sizeof(*e));
  25         e->type = type;
  26         e->left.expr = ce;
  27         return e;
  28 }
  29
  30 struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2)
  31 {
  32         struct expr *e = calloc(1, sizeof(*e));
  33         e->type = type;
  34         e->left.expr = e1;
  35         e->right.expr = e2;
  36         return e;
  37 }
  38
  39 struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2)
  40 {
  41         struct expr *e = calloc(1, sizeof(*e));
  42         e->type = type;
  43         e->left.sym = s1;
  44         e->right.sym = s2;
  45         return e;
  46 }
  47
  48 struct expr *expr_alloc_and(struct expr *e1, struct expr *e2)
  49 {
  50         if (!e1)
  51                 return e2;
  52         return e2 ? expr_alloc_two(E_AND, e1, e2) : e1;
  53 }
  54
  55 struct expr *expr_alloc_or(struct expr *e1, struct expr *e2)
  56 {
  57         if (!e1)
  58                 return e2;
  59         return e2 ? expr_alloc_two(E_OR, e1, e2) : e1;
  60 }
  61
  62 struct expr *expr_copy(const struct expr *org)
  63 {
  64         struct expr *e;
  65
  66         if (!org)
  67                 return NULL;
  68
  69         e = malloc(sizeof(*org));
  70         memcpy(e, org, sizeof(*org));
  71         switch (org->type) {
  72         case E_SYMBOL:
  73                 e->left = org->left;
  74                 break;
  75         case E_NOT:
  76                 e->left.expr = expr_copy(org->left.expr);
  77                 break;
  78         case E_EQUAL:
  79         case E_UNEQUAL:
  80                 e->left.sym = org->left.sym;
  81                 e->right.sym = org->right.sym;
  82                 break;
  83         case E_AND:
  84         case E_OR:
  85         case E_LIST:
  86                 e->left.expr = expr_copy(org->left.expr);
  87                 e->right.expr = expr_copy(org->right.expr);
  88                 break;
  89         default:
  90                 printf("can't copy type %d\n", e->type);
  91                 free(e);
  92                 e = NULL;
  93                 break;
  94         }
  95
  96         return e;
  97 }
  98
  99 void expr_free(struct expr *e)
 100 {
 101         if (!e)
 102                 return;
 103
 104         switch (e->type) {
 105         case E_SYMBOL:
 106                 break;
 107         case E_NOT:
 108                 expr_free(e->left.expr);
 109                 return;
 110         case E_EQUAL:
 111         case E_UNEQUAL:
 112                 break;
 113         case E_OR:
 114         case E_AND:
 115                 expr_free(e->left.expr);
 116                 expr_free(e->right.expr);
 117                 break;
 118         default:
 119                 printf("how to free type %d?\n", e->type);
 120                 break;
 121         }
 122         free(e);
 123 }
 124
 125 static int trans_count;
 126
 127 #define e1 (*ep1)
 128 #define e2 (*ep2)
 129
 130 static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct expr **ep2)
 131 {
 132         if (e1->type == type) {
 133                 __expr_eliminate_eq(type, &e1->left.expr, &e2);
 134                 __expr_eliminate_eq(type, &e1->right.expr, &e2);
 135                 return;
 136         }
 137         if (e2->type == type) {
 138                 __expr_eliminate_eq(type, &e1, &e2->left.expr);
 139                 __expr_eliminate_eq(type, &e1, &e2->right.expr);
 140                 return;
 141         }
 142         if (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
 143             e1->left.sym == e2->left.sym &&
 144             (e1->left.sym == &symbol_yes || e1->left.sym == &symbol_no))
 145                 return;
 146         if (!expr_eq(e1, e2))
 147                 return;
 148         trans_count++;
 149         expr_free(e1); expr_free(e2);
 150         switch (type) {
 151         case E_OR:
 152                 e1 = expr_alloc_symbol(&symbol_no);
 153                 e2 = expr_alloc_symbol(&symbol_no);
 154                 break;
 155         case E_AND:
 156                 e1 = expr_alloc_symbol(&symbol_yes);
 157                 e2 = expr_alloc_symbol(&symbol_yes);
 158                 break;
 159         default:
 160                 ;
 161         }
 162 }
 163
 164 void expr_eliminate_eq(struct expr **ep1, struct expr **ep2)
 165 {
 166         if (!e1 || !e2)
 167                 return;
 168         switch (e1->type) {
 169         case E_OR:
 170         case E_AND:
 171                 __expr_eliminate_eq(e1->type, ep1, ep2);
 172         default:
 173                 ;
 174         }
 175         if (e1->type != e2->type) switch (e2->type) {
 176         case E_OR:
 177         case E_AND:
 178                 __expr_eliminate_eq(e2->type, ep1, ep2);
 179         default:
 180                 ;
 181         }
 182         e1 = expr_eliminate_yn(e1);
 183         e2 = expr_eliminate_yn(e2);
 184 }
 185
 186 #undef e1
 187 #undef e2
 188
 189 int expr_eq(struct expr *e1, struct expr *e2)
 190 {
 191         int res, old_count;
 192
 193         if (e1->type != e2->type)
 194                 return 0;
 195         switch (e1->type) {
 196         case E_EQUAL:
 197         case E_UNEQUAL:
 198                 return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
 199         case E_SYMBOL:
 200                 return e1->left.sym == e2->left.sym;
 201         case E_NOT:
 202                 return expr_eq(e1->left.expr, e2->left.expr);
 203         case E_AND:
 204         case E_OR:
 205                 e1 = expr_copy(e1);
 206                 e2 = expr_copy(e2);
 207                 old_count = trans_count;
 208                 expr_eliminate_eq(&e1, &e2);
 209                 res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
 210                        e1->left.sym == e2->left.sym);
 211                 expr_free(e1);
 212                 expr_free(e2);
 213                 trans_count = old_count;
 214                 return res;
 215         case E_LIST:
 216         case E_RANGE:
 217         case E_NONE:
 218                 /* panic */;
 219         }
 220
 221         if (DEBUG_EXPR) {
 222                 expr_fprint(e1, stdout);
 223                 printf(" = ");
 224                 expr_fprint(e2, stdout);
 225                 printf(" ?\n");
 226         }
 227
 228         return 0;
 229 }
 230
 231 struct expr *expr_eliminate_yn(struct expr *e)
 232 {
 233         struct expr *tmp;
 234
 235         if (e) switch (e->type) {
 236         case E_AND:
 237                 e->left.expr = expr_eliminate_yn(e->left.expr);
 238                 e->right.expr = expr_eliminate_yn(e->right.expr);
 239                 if (e->left.expr->type == E_SYMBOL) {
 240                         if (e->left.expr->left.sym == &symbol_no) {
 241                                 expr_free(e->left.expr);
 242                                 expr_free(e->right.expr);
 243                                 e->type = E_SYMBOL;
 244                                 e->left.sym = &symbol_no;
 245                                 e->right.expr = NULL;
 246                                 return e;
 247                         } else if (e->left.expr->left.sym == &symbol_yes) {
 248                                 free(e->left.expr);
 249                                 tmp = e->right.expr;
 250                                 *e = *(e->right.expr);
 251                                 free(tmp);
 252                                 return e;
 253                         }
 254                 }
 255                 if (e->right.expr->type == E_SYMBOL) {
 256                         if (e->right.expr->left.sym == &symbol_no) {
 257                                 expr_free(e->left.expr);
 258                                 expr_free(e->right.expr);
 259                                 e->type = E_SYMBOL;
 260                                 e->left.sym = &symbol_no;
 261                                 e->right.expr = NULL;
 262                                 return e;
 263                         } else if (e->right.expr->left.sym == &symbol_yes) {
 264                                 free(e->right.expr);
 265                                 tmp = e->left.expr;
 266                                 *e = *(e->left.expr);
 267                                 free(tmp);
 268                                 return e;
 269                         }
 270                 }
 271                 break;
 272         case E_OR:
 273                 e->left.expr = expr_eliminate_yn(e->left.expr);
 274                 e->right.expr = expr_eliminate_yn(e->right.expr);
 275                 if (e->left.expr->type == E_SYMBOL) {
 276                         if (e->left.expr->left.sym == &symbol_no) {
 277                                 free(e->left.expr);
 278                                 tmp = e->right.expr;
 279                                 *e = *(e->right.expr);
 280                                 free(tmp);
 281                                 return e;
 282                         } else if (e->left.expr->left.sym == &symbol_yes) {
 283                                 expr_free(e->left.expr);
 284                                 expr_free(e->right.expr);
 285                                 e->type = E_SYMBOL;
 286                                 e->left.sym = &symbol_yes;
 287                                 e->right.expr = NULL;
 288                                 return e;
 289                         }
 290                 }
 291                 if (e->right.expr->type == E_SYMBOL) {
 292                         if (e->right.expr->left.sym == &symbol_no) {
 293                                 free(e->right.expr);
 294                                 tmp = e->left.expr;
 295                                 *e = *(e->left.expr);
 296                                 free(tmp);
 297                                 return e;
 298                         } else if (e->right.expr->left.sym == &symbol_yes) {
 299                                 expr_free(e->left.expr);
 300                                 expr_free(e->right.expr);
 301                                 e->type = E_SYMBOL;
 302                                 e->left.sym = &symbol_yes;
 303                                 e->right.expr = NULL;
 304                                 return e;
 305                         }
 306                 }
 307                 break;
 308         default:
 309                 ;
 310         }
 311         return e;
 312 }
 313
 314 /*
 315  * bool FOO!=n => FOO
 316  */
 317 struct expr *expr_trans_bool(struct expr *e)
 318 {
 319         if (!e)
 320                 return NULL;
 321         switch (e->type) {
 322         case E_AND:
 323         case E_OR:
 324         case E_NOT:
 325                 e->left.expr = expr_trans_bool(e->left.expr);
 326                 e->right.expr = expr_trans_bool(e->right.expr);
 327                 break;
 328         case E_UNEQUAL:
 329                 // FOO!=n -> FOO
 330                 if (e->left.sym->type == S_TRISTATE) {
 331                         if (e->right.sym == &symbol_no) {
 332                                 e->type = E_SYMBOL;
 333                                 e->right.sym = NULL;
 334                         }
 335                 }
 336                 break;
 337         default:
 338                 ;
 339         }
 340         return e;
 341 }
 342
 343 /*
 344  * e1 || e2 -> ?
 345  */
 346 static struct expr *expr_join_or(struct expr *e1, struct expr *e2)
 347 {
 348         struct expr *tmp;
 349         struct symbol *sym1, *sym2;
 350
 351         if (expr_eq(e1, e2))
 352                 return expr_copy(e1);
 353         if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
 354                 return NULL;
 355         if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
 356                 return NULL;
 357         if (e1->type == E_NOT) {
 358                 tmp = e1->left.expr;
 359                 if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
 360                         return NULL;
 361                 sym1 = tmp->left.sym;
 362         } else
 363                 sym1 = e1->left.sym;
 364         if (e2->type == E_NOT) {
 365                 if (e2->left.expr->type != E_SYMBOL)
 366                         return NULL;
 367                 sym2 = e2->left.expr->left.sym;
 368         } else
 369                 sym2 = e2->left.sym;
 370         if (sym1 != sym2)
 371                 return NULL;
 372         if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
 373                 return NULL;
 374         if (sym1->type == S_TRISTATE) {
 375                 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
 376                     ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
 377                      (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) {
 378                         // (a='y') || (a='m') -> (a!='n')
 379                         return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_no);
 380                 }
 381                 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
 382                     ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
 383                      (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) {
 384                         // (a='y') || (a='n') -> (a!='m')
 385                         return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_mod);
 386                 }
 387                 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
 388                     ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
 389                      (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) {
 390                         // (a='m') || (a='n') -> (a!='y')
 391                         return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_yes);
 392                 }
 393         }
 394         if (sym1->type == S_BOOLEAN && sym1 == sym2) {
 395                 if ((e1->type == E_NOT && e1->left.expr->type == E_SYMBOL && e2->type == E_SYMBOL) ||
 396                     (e2->type == E_NOT && e2->left.expr->type == E_SYMBOL && e1->type == E_SYMBOL))
 397                         return expr_alloc_symbol(&symbol_yes);
 398         }
 399
 400         if (DEBUG_EXPR) {
 401                 printf("optimize (");
 402                 expr_fprint(e1, stdout);
 403                 printf(") || (");
 404                 expr_fprint(e2, stdout);
 405                 printf(")?\n");
 406         }
 407         return NULL;
 408 }
 409
 410 static struct expr *expr_join_and(struct expr *e1, struct expr *e2)
 411 {
 412         struct expr *tmp;
 413         struct symbol *sym1, *sym2;
 414
 415         if (expr_eq(e1, e2))
 416                 return expr_copy(e1);
 417         if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
 418                 return NULL;
 419         if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
 420                 return NULL;
 421         if (e1->type == E_NOT) {
 422                 tmp = e1->left.expr;
 423                 if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
 424                         return NULL;
 425                 sym1 = tmp->left.sym;
 426         } else
 427                 sym1 = e1->left.sym;
 428         if (e2->type == E_NOT) {
 429                 if (e2->left.expr->type != E_SYMBOL)
 430                         return NULL;
 431                 sym2 = e2->left.expr->left.sym;
 432         } else
 433                 sym2 = e2->left.sym;
 434         if (sym1 != sym2)
 435                 return NULL;
 436         if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
 437                 return NULL;
 438
 439         if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_yes) ||
 440             (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_yes))
 441                 // (a) && (a='y') -> (a='y')
 442                 return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
 443
 444         if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_no) ||
 445             (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_no))
 446                 // (a) && (a!='n') -> (a)
 447                 return expr_alloc_symbol(sym1);
 448
 449         if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_mod) ||
 450             (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_mod))
 451                 // (a) && (a!='m') -> (a='y')
 452                 return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
 453
 454         if (sym1->type == S_TRISTATE) {
 455                 if (e1->type == E_EQUAL && e2->type == E_UNEQUAL) {
 456                         // (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
 457                         sym2 = e1->right.sym;
 458                         if ((e2->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
 459                                 return sym2 != e2->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
 460                                                              : expr_alloc_symbol(&symbol_no);
 461                 }
 462                 if (e1->type == E_UNEQUAL && e2->type == E_EQUAL) {
 463                         // (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
 464                         sym2 = e2->right.sym;
 465                         if ((e1->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
 466                                 return sym2 != e1->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
 467                                                              : expr_alloc_symbol(&symbol_no);
 468                 }
 469                 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
 470                            ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
 471                             (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes)))
 472                         // (a!='y') && (a!='n') -> (a='m')
 473                         return expr_alloc_comp(E_EQUAL, sym1, &symbol_mod);
 474
 475                 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
 476                            ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
 477                             (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes)))
 478                         // (a!='y') && (a!='m') -> (a='n')
 479                         return expr_alloc_comp(E_EQUAL, sym1, &symbol_no);
 480
 481                 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
 482                            ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
 483                             (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod)))
 484                         // (a!='m') && (a!='n') -> (a='m')
 485                         return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
 486
 487                 if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_mod) ||
 488                     (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_mod) ||
 489                     (e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_yes) ||
 490                     (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_yes))
 491                         return NULL;
 492         }
 493
 494         if (DEBUG_EXPR) {
 495                 printf("optimize (");
 496                 expr_fprint(e1, stdout);
 497                 printf(") && (");
 498                 expr_fprint(e2, stdout);
 499                 printf(")?\n");
 500         }
 501         return NULL;
 502 }
 503
 504 static void expr_eliminate_dups1(enum expr_type type, struct expr **ep1, struct expr **ep2)
 505 {
 506 #define e1 (*ep1)
 507 #define e2 (*ep2)
 508         struct expr *tmp;
 509
 510         if (e1->type == type) {
 511                 expr_eliminate_dups1(type, &e1->left.expr, &e2);
 512                 expr_eliminate_dups1(type, &e1->right.expr, &e2);
 513                 return;
 514         }
 515         if (e2->type == type) {
 516                 expr_eliminate_dups1(type, &e1, &e2->left.expr);
 517                 expr_eliminate_dups1(type, &e1, &e2->right.expr);
 518                 return;
 519         }
 520         if (e1 == e2)
 521                 return;
 522
 523         switch (e1->type) {
 524         case E_OR: case E_AND:
 525                 expr_eliminate_dups1(e1->type, &e1, &e1);
 526         default:
 527                 ;
 528         }
 529
 530         switch (type) {
 531         case E_OR:
 532                 tmp = expr_join_or(e1, e2);
 533                 if (tmp) {
 534                         expr_free(e1); expr_free(e2);
 535                         e1 = expr_alloc_symbol(&symbol_no);
 536                         e2 = tmp;
 537                         trans_count++;
 538                 }
 539                 break;
 540         case E_AND:
 541                 tmp = expr_join_and(e1, e2);
 542                 if (tmp) {
 543                         expr_free(e1); expr_free(e2);
 544                         e1 = expr_alloc_symbol(&symbol_yes);
 545                         e2 = tmp;
 546                         trans_count++;
 547                 }
 548                 break;
 549         default:
 550                 ;
 551         }
 552 #undef e1
 553 #undef e2
 554 }
 555
 556 static void expr_eliminate_dups2(enum expr_type type, struct expr **ep1, struct expr **ep2)
 557 {
 558 #define e1 (*ep1)
 559 #define e2 (*ep2)
 560         struct expr *tmp, *tmp1, *tmp2;
 561
 562         if (e1->type == type) {
 563                 expr_eliminate_dups2(type, &e1->left.expr, &e2);
 564                 expr_eliminate_dups2(type, &e1->right.expr, &e2);
 565                 return;
 566         }
 567         if (e2->type == type) {
 568                 expr_eliminate_dups2(type, &e1, &e2->left.expr);
 569                 expr_eliminate_dups2(type, &e1, &e2->right.expr);
 570         }
 571         if (e1 == e2)
 572                 return;
 573
 574         switch (e1->type) {
 575         case E_OR:
 576                 expr_eliminate_dups2(e1->type, &e1, &e1);
 577                 // (FOO || BAR) && (!FOO && !BAR) -> n
 578                 tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1)));
 579                 tmp2 = expr_copy(e2);
 580                 tmp = expr_extract_eq_and(&tmp1, &tmp2);
 581                 if (expr_is_yes(tmp1)) {
 582                         expr_free(e1);
 583                         e1 = expr_alloc_symbol(&symbol_no);
 584                         trans_count++;
 585                 }
 586                 expr_free(tmp2);
 587                 expr_free(tmp1);
 588                 expr_free(tmp);
 589                 break;
 590         case E_AND:
 591                 expr_eliminate_dups2(e1->type, &e1, &e1);
 592                 // (FOO && BAR) || (!FOO || !BAR) -> y
 593                 tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1)));
 594                 tmp2 = expr_copy(e2);
 595                 tmp = expr_extract_eq_or(&tmp1, &tmp2);
 596                 if (expr_is_no(tmp1)) {
 597                         expr_free(e1);
 598                         e1 = expr_alloc_symbol(&symbol_yes);
 599                         trans_count++;
 600                 }
 601                 expr_free(tmp2);
 602                 expr_free(tmp1);
 603                 expr_free(tmp);
 604                 break;
 605         default:
 606                 ;
 607         }
 608 #undef e1
 609 #undef e2
 610 }
 611
 612 struct expr *expr_eliminate_dups(struct expr *e)
 613 {
 614         int oldcount;
 615         if (!e)
 616                 return e;
 617
 618         oldcount = trans_count;
 619         while (1) {
 620                 trans_count = 0;
 621                 switch (e->type) {
 622                 case E_OR: case E_AND:
 623                         expr_eliminate_dups1(e->type, &e, &e);
 624                         expr_eliminate_dups2(e->type, &e, &e);
 625                 default:
 626                         ;
 627                 }
 628                 if (!trans_count)
 629                         break;
 630                 e = expr_eliminate_yn(e);
 631         }
 632         trans_count = oldcount;
 633         return e;
 634 }
 635
 636 struct expr *expr_transform(struct expr *e)
 637 {
 638         struct expr *tmp;
 639
 640         if (!e)
 641                 return NULL;
 642         switch (e->type) {
 643         case E_EQUAL:
 644         case E_UNEQUAL:
 645         case E_SYMBOL:
 646         case E_LIST:
 647                 break;
 648         default:
 649                 e->left.expr = expr_transform(e->left.expr);
 650                 e->right.expr = expr_transform(e->right.expr);
 651         }
 652
 653         switch (e->type) {
 654         case E_EQUAL:
 655                 if (e->left.sym->type != S_BOOLEAN)
 656                         break;
 657                 if (e->right.sym == &symbol_no) {
 658                         e->type = E_NOT;
 659                         e->left.expr = expr_alloc_symbol(e->left.sym);
 660                         e->right.sym = NULL;
 661                         break;
 662                 }
 663                 if (e->right.sym == &symbol_mod) {
 664                         printf("boolean symbol %s tested for 'm'? test forced to 'n'\n", e->left.sym->name);
 665                         e->type = E_SYMBOL;
 666                         e->left.sym = &symbol_no;
 667                         e->right.sym = NULL;
 668                         break;
 669                 }
 670                 if (e->right.sym == &symbol_yes) {
 671                         e->type = E_SYMBOL;
 672                         e->right.sym = NULL;
 673                         break;
 674                 }
 675                 break;
 676         case E_UNEQUAL:
 677                 if (e->left.sym->type != S_BOOLEAN)
 678                         break;
 679                 if (e->right.sym == &symbol_no) {
 680                         e->type = E_SYMBOL;
 681                         e->right.sym = NULL;
 682                         break;
 683                 }
 684                 if (e->right.sym == &symbol_mod) {
 685                         printf("boolean symbol %s tested for 'm'? test forced to 'y'\n", e->left.sym->name);
 686                         e->type = E_SYMBOL;
 687                         e->left.sym = &symbol_yes;
 688                         e->right.sym = NULL;
 689                         break;
 690                 }
 691                 if (e->right.sym == &symbol_yes) {
 692                         e->type = E_NOT;
 693                         e->left.expr = expr_alloc_symbol(e->left.sym);
 694                         e->right.sym = NULL;
 695                         break;
 696                 }
 697                 break;
 698         case E_NOT:
 699                 switch (e->left.expr->type) {
 700                 case E_NOT:
 701                         // !!a -> a
 702                         tmp = e->left.expr->left.expr;
 703                         free(e->left.expr);
 704                         free(e);
 705                         e = tmp;
 706                         e = expr_transform(e);
 707                         break;
 708                 case E_EQUAL:
 709                 case E_UNEQUAL:
 710                         // !a='x' -> a!='x'
 711                         tmp = e->left.expr;
 712                         free(e);
 713                         e = tmp;
 714                         e->type = e->type == E_EQUAL ? E_UNEQUAL : E_EQUAL;
 715                         break;
 716                 case E_OR:
 717                         // !(a || b) -> !a && !b
 718                         tmp = e->left.expr;
 719                         e->type = E_AND;
 720                         e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr);
 721                         tmp->type = E_NOT;
 722                         tmp->right.expr = NULL;
 723                         e = expr_transform(e);
 724                         break;
 725                 case E_AND:
 726                         // !(a && b) -> !a || !b
 727                         tmp = e->left.expr;
 728                         e->type = E_OR;
 729                         e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr);
 730                         tmp->type = E_NOT;
 731                         tmp->right.expr = NULL;
 732                         e = expr_transform(e);
 733                         break;
 734                 case E_SYMBOL:
 735                         if (e->left.expr->left.sym == &symbol_yes) {
 736                                 // !'y' -> 'n'
 737                                 tmp = e->left.expr;
 738                                 free(e);
 739                                 e = tmp;
 740                                 e->type = E_SYMBOL;
 741                                 e->left.sym = &symbol_no;
 742                                 break;
 743                         }
 744                         if (e->left.expr->left.sym == &symbol_mod) {
 745                                 // !'m' -> 'm'
 746                                 tmp = e->left.expr;
 747                                 free(e);
 748                                 e = tmp;
 749                                 e->type = E_SYMBOL;
 750                                 e->left.sym = &symbol_mod;
 751                                 break;
 752                         }
 753                         if (e->left.expr->left.sym == &symbol_no) {
 754                                 // !'n' -> 'y'
 755                                 tmp = e->left.expr;
 756                                 free(e);
 757                                 e = tmp;
 758                                 e->type = E_SYMBOL;
 759                                 e->left.sym = &symbol_yes;
 760                                 break;
 761                         }
 762                         break;
 763                 default:
 764                         ;
 765                 }
 766                 break;
 767         default:
 768                 ;
 769         }
 770         return e;
 771 }
 772
 773 int expr_contains_symbol(struct expr *dep, struct symbol *sym)
 774 {
 775         if (!dep)
 776                 return 0;
 777
 778         switch (dep->type) {
 779         case E_AND:
 780         case E_OR:
 781                 return expr_contains_symbol(dep->left.expr, sym) ||
 782                        expr_contains_symbol(dep->right.expr, sym);
 783         case E_SYMBOL:
 784                 return dep->left.sym == sym;
 785         case E_EQUAL:
 786         case E_UNEQUAL:
 787                 return dep->left.sym == sym ||
 788                        dep->right.sym == sym;
 789         case E_NOT:
 790                 return expr_contains_symbol(dep->left.expr, sym);
 791         default:
 792                 ;
 793         }
 794         return 0;
 795 }
 796
 797 bool expr_depends_symbol(struct expr *dep, struct symbol *sym)
 798 {
 799         if (!dep)
 800                 return false;
 801
 802         switch (dep->type) {
 803         case E_AND:
 804                 return expr_depends_symbol(dep->left.expr, sym) ||
 805                        expr_depends_symbol(dep->right.expr, sym);
 806         case E_SYMBOL:
 807                 return dep->left.sym == sym;
 808         case E_EQUAL:
 809                 if (dep->left.sym == sym) {
 810                         if (dep->right.sym == &symbol_yes || dep->right.sym == &symbol_mod)
 811                                 return true;
 812                 }
 813                 break;
 814         case E_UNEQUAL:
 815                 if (dep->left.sym == sym) {
 816                         if (dep->right.sym == &symbol_no)
 817                                 return true;
 818                 }
 819                 break;
 820         default:
 821                 ;
 822         }
 823         return false;
 824 }
 825
 826 struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2)
 827 {
 828         struct expr *tmp = NULL;
 829         expr_extract_eq(E_AND, &tmp, ep1, ep2);
 830         if (tmp) {
 831                 *ep1 = expr_eliminate_yn(*ep1);
 832                 *ep2 = expr_eliminate_yn(*ep2);
 833         }
 834         return tmp;
 835 }
 836
 837 struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2)
 838 {
 839         struct expr *tmp = NULL;
 840         expr_extract_eq(E_OR, &tmp, ep1, ep2);
 841         if (tmp) {
 842                 *ep1 = expr_eliminate_yn(*ep1);
 843                 *ep2 = expr_eliminate_yn(*ep2);
 844         }
 845         return tmp;
 846 }
 847
 848 void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2)
 849 {
 850 #define e1 (*ep1)
 851 #define e2 (*ep2)
 852         if (e1->type == type) {
 853                 expr_extract_eq(type, ep, &e1->left.expr, &e2);
 854                 expr_extract_eq(type, ep, &e1->right.expr, &e2);
 855                 return;
 856         }
 857         if (e2->type == type) {
 858                 expr_extract_eq(type, ep, ep1, &e2->left.expr);
 859                 expr_extract_eq(type, ep, ep1, &e2->right.expr);
 860                 return;
 861         }
 862         if (expr_eq(e1, e2)) {
 863                 *ep = *ep ? expr_alloc_two(type, *ep, e1) : e1;
 864                 expr_free(e2);
 865                 if (type == E_AND) {
 866                         e1 = expr_alloc_symbol(&symbol_yes);
 867                         e2 = expr_alloc_symbol(&symbol_yes);
 868                 } else if (type == E_OR) {
 869                         e1 = expr_alloc_symbol(&symbol_no);
 870                         e2 = expr_alloc_symbol(&symbol_no);
 871                 }
 872         }
 873 #undef e1
 874 #undef e2
 875 }
 876
 877 struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym)
 878 {
 879         struct expr *e1, *e2;
 880
 881         if (!e) {
 882                 e = expr_alloc_symbol(sym);
 883                 if (type == E_UNEQUAL)
 884                         e = expr_alloc_one(E_NOT, e);
 885                 return e;
 886         }
 887         switch (e->type) {
 888         case E_AND:
 889                 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
 890                 e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
 891                 if (sym == &symbol_yes)
 892                         e = expr_alloc_two(E_AND, e1, e2);
 893                 if (sym == &symbol_no)
 894                         e = expr_alloc_two(E_OR, e1, e2);
 895                 if (type == E_UNEQUAL)
 896                         e = expr_alloc_one(E_NOT, e);
 897                 return e;
 898         case E_OR:
 899                 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
 900                 e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
 901                 if (sym == &symbol_yes)
 902                         e = expr_alloc_two(E_OR, e1, e2);
 903                 if (sym == &symbol_no)
 904                         e = expr_alloc_two(E_AND, e1, e2);
 905                 if (type == E_UNEQUAL)
 906                         e = expr_alloc_one(E_NOT, e);
 907                 return e;
 908         case E_NOT:
 909                 return expr_trans_compare(e->left.expr, type == E_EQUAL ? E_UNEQUAL : E_EQUAL, sym);
 910         case E_UNEQUAL:
 911         case E_EQUAL:
 912                 if (type == E_EQUAL) {
 913                         if (sym == &symbol_yes)
 914                                 return expr_copy(e);
 915                         if (sym == &symbol_mod)
 916                                 return expr_alloc_symbol(&symbol_no);
 917                         if (sym == &symbol_no)
 918                                 return expr_alloc_one(E_NOT, expr_copy(e));
 919                 } else {
 920                         if (sym == &symbol_yes)
 921                                 return expr_alloc_one(E_NOT, expr_copy(e));
 922                         if (sym == &symbol_mod)
 923                                 return expr_alloc_symbol(&symbol_yes);
 924                         if (sym == &symbol_no)
 925                                 return expr_copy(e);
 926                 }
 927                 break;
 928         case E_SYMBOL:
 929                 return expr_alloc_comp(type, e->left.sym, sym);
 930         case E_LIST:
 931         case E_RANGE:
 932         case E_NONE:
 933                 /* panic */;
 934         }
 935         return NULL;
 936 }
 937
 938 tristate expr_calc_value(struct expr *e)
 939 {
 940         tristate val1, val2;
 941         const char *str1, *str2;
 942
 943         if (!e)
 944                 return yes;
 945
 946         switch (e->type) {
 947         case E_SYMBOL:
 948                 sym_calc_value(e->left.sym);
 949                 return e->left.sym->curr.tri;
 950         case E_AND:
 951                 val1 = expr_calc_value(e->left.expr);
 952                 val2 = expr_calc_value(e->right.expr);
 953                 return EXPR_AND(val1, val2);
 954         case E_OR:
 955                 val1 = expr_calc_value(e->left.expr);
 956                 val2 = expr_calc_value(e->right.expr);
 957                 return EXPR_OR(val1, val2);
 958         case E_NOT:
 959                 val1 = expr_calc_value(e->left.expr);
 960                 return EXPR_NOT(val1);
 961         case E_EQUAL:
 962                 sym_calc_value(e->left.sym);
 963                 sym_calc_value(e->right.sym);
 964                 str1 = sym_get_string_value(e->left.sym);
 965                 str2 = sym_get_string_value(e->right.sym);
 966                 return !strcmp(str1, str2) ? yes : no;
 967         case E_UNEQUAL:
 968                 sym_calc_value(e->left.sym);
 969                 sym_calc_value(e->right.sym);
 970                 str1 = sym_get_string_value(e->left.sym);
 971                 str2 = sym_get_string_value(e->right.sym);
 972                 return !strcmp(str1, str2) ? no : yes;
 973         default:
 974                 printf("expr_calc_value: %d?\n", e->type);
 975                 return no;
 976         }
 977 }
 978
 979 int expr_compare_type(enum expr_type t1, enum expr_type t2)
 980 {
 981 #if 0
 982         return 1;
 983 #else
 984         if (t1 == t2)
 985                 return 0;
 986         switch (t1) {
 987         case E_EQUAL:
 988         case E_UNEQUAL:
 989                 if (t2 == E_NOT)
 990                         return 1;
 991         case E_NOT:
 992                 if (t2 == E_AND)
 993                         return 1;
 994         case E_AND:
 995                 if (t2 == E_OR)
 996                         return 1;
 997         case E_OR:
 998                 if (t2 == E_LIST)
 999                         return 1;
1000         case E_LIST:
1001                 if (t2 == 0)
1002                         return 1;
1003         default:
1004                 return -1;
1005         }
1006         printf("[%dgt%d?]", t1, t2);
1007         return 0;
1008 #endif
1009 }
1010
1011 static inline struct expr *
1012 expr_get_leftmost_symbol(const struct expr *e)
1013 {
1014
1015         if (e == NULL)
1016                 return NULL;
1017
1018         while (e->type != E_SYMBOL)
1019                 e = e->left.expr;
1020
1021         return expr_copy(e);
1022 }
1023
1024 /*
1025  * Given expression `e1' and `e2', returns the leaf of the longest
1026  * sub-expression of `e1' not containing 'e2.
1027  */
1028 struct expr *expr_simplify_unmet_dep(struct expr *e1, struct expr *e2)
1029 {
1030         struct expr *ret;
1031
1032         switch (e1->type) {
1033         case E_OR:
1034                 return expr_alloc_and(
1035                     expr_simplify_unmet_dep(e1->left.expr, e2),
1036                     expr_simplify_unmet_dep(e1->right.expr, e2));
1037         case E_AND: {
1038                 struct expr *e;
1039                 e = expr_alloc_and(expr_copy(e1), expr_copy(e2));
1040                 e = expr_eliminate_dups(e);
1041                 ret = (!expr_eq(e, e1)) ? e1 : NULL;
1042                 expr_free(e);
1043                 break;
1044                 }
1045         default:
1046                 ret = e1;
1047                 break;
1048         }
1049
1050         return expr_get_leftmost_symbol(ret);
1051 }
1052
1053 void expr_print(struct expr *e, void (*fn)(void *, struct symbol *, const char *), void *data, int prevtoken)
1054 {
1055         if (!e) {
1056                 fn(data, NULL, "y");
1057                 return;
1058         }
1059
1060         if (expr_compare_type(prevtoken, e->type) > 0)
1061                 fn(data, NULL, "(");
1062         switch (e->type) {
1063         case E_SYMBOL:
1064                 if (e->left.sym->name)
1065                         fn(data, e->left.sym, e->left.sym->name);
1066                 else
1067                         fn(data, NULL, "<choice>");
1068                 break;
1069         case E_NOT:
1070                 fn(data, NULL, "!");
1071                 expr_print(e->left.expr, fn, data, E_NOT);
1072                 break;
1073         case E_EQUAL:
1074                 if (e->left.sym->name)
1075                         fn(data, e->left.sym, e->left.sym->name);
1076                 else
1077                         fn(data, NULL, "<choice>");
1078                 fn(data, NULL, "=");
1079                 fn(data, e->right.sym, e->right.sym->name);
1080                 break;
1081         case E_UNEQUAL:
1082                 if (e->left.sym->name)
1083                         fn(data, e->left.sym, e->left.sym->name);
1084                 else
1085                         fn(data, NULL, "<choice>");
1086                 fn(data, NULL, "!=");
1087                 fn(data, e->right.sym, e->right.sym->name);
1088                 break;
1089         case E_OR:
1090                 expr_print(e->left.expr, fn, data, E_OR);
1091                 fn(data, NULL, " || ");
1092                 expr_print(e->right.expr, fn, data, E_OR);
1093                 break;
1094         case E_AND:
1095                 expr_print(e->left.expr, fn, data, E_AND);
1096                 fn(data, NULL, " && ");
1097                 expr_print(e->right.expr, fn, data, E_AND);
1098                 break;
1099         case E_LIST:
1100                 fn(data, e->right.sym, e->right.sym->name);
1101                 if (e->left.expr) {
1102                         fn(data, NULL, " ^ ");
1103                         expr_print(e->left.expr, fn, data, E_LIST);
1104                 }
1105                 break;
1106         case E_RANGE:
1107                 fn(data, NULL, "[");
1108                 fn(data, e->left.sym, e->left.sym->name);
1109                 fn(data, NULL, " ");
1110                 fn(data, e->right.sym, e->right.sym->name);
1111                 fn(data, NULL, "]");
1112                 break;
1113         default:
1114           {
1115                 char buf[32];
1116                 sprintf(buf, "<unknown type %d>", e->type);
1117                 fn(data, NULL, buf);
1118                 break;
1119           }
1120         }
1121         if (expr_compare_type(prevtoken, e->type) > 0)
1122                 fn(data, NULL, ")");
1123 }
1124
1125 static void expr_print_file_helper(void *data, struct symbol *sym, const char *str)
1126 {
1127         xfwrite(str, strlen(str), 1, data);
1128 }
1129
1130 void expr_fprint(struct expr *e, FILE *out)
1131 {
1132         expr_print(e, expr_print_file_helper, out, E_NONE);
1133 }
1134
1135 static void expr_print_gstr_helper(void *data, struct symbol *sym, const char *str)
1136 {
1137         struct gstr *gs = (struct gstr*)data;
1138         const char *sym_str = NULL;
1139
1140         if (sym)
1141                 sym_str = sym_get_string_value(sym);
1142
1143         if (gs->max_width) {
1144                 unsigned extra_length = strlen(str);
1145                 const char *last_cr = strrchr(gs->s, '\n');
1146                 unsigned last_line_length;
1147
1148                 if (sym_str)
1149                         extra_length += 4 + strlen(sym_str);
1150
1151                 if (!last_cr)
1152                         last_cr = gs->s;
1153
1154                 last_line_length = strlen(gs->s) - (last_cr - gs->s);
1155
1156                 if ((last_line_length + extra_length) > gs->max_width)
1157                         str_append(gs, "\\\n");
1158         }
1159
1160         str_append(gs, str);
1161         if (sym && sym->type != S_UNKNOWN)
1162                 str_printf(gs, " [=%s]", sym_str);
1163 }
1164
1165 void expr_gstr_print(struct expr *e, struct gstr *gs)
1166 {
1167         expr_print(e, expr_print_gstr_helper, gs, E_NONE);
1168 }