scripts/tkcond.c

   1 /*
   2  * tkcond.c
   3  *
   4  * Eric Youngdale was the original author of xconfig.
   5  * Michael Elizabeth Chastain (mec@shout.net) is the current maintainer.
   6  *
   7  * This file takes the tokenized statement list and transforms 'if ...'
   8  * statements.  For each simple statement, I find all of the 'if' statements
   9  * that enclose it, and attach the aggregate conditionals of those 'if'
  10  * statements to the cond list of the simple statement.
  11  *
  12  * 14 January 1999, Michael Elizabeth Chastain, <mec@shout.net>
  13  * - Steam-clean this file.  I tested this by generating kconfig.tk for
  14  *   every architecture and comparing it character-for-character against
  15  *   the output of the old tkparse.
  16  *
  17  * TO DO:
  18  * - xconfig is at the end of its life cycle.  Contact <mec@shout.net> if
  19  *   you are interested in working on the replacement.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "tkparse.h"
  27
  28
  29
  30 /*
  31  * Transform op_variable to op_kvariable.
  32  *
  33  * This works, but it's gross, speed-wise.  It would benefit greatly
  34  * from a simple hash table that maps names to cfg.
  35  *
  36  * Note well: this is actually better than the loop structure xconfig
  37  * has been staggering along with for three years, which performs
  38  * this whole procedure inside *another* loop on active conditionals.
  39  */
  40 void transform_to_kvariable( struct kconfig * scfg )
  41 {
  42     struct kconfig * cfg;
  43
  44     for ( cfg = scfg; cfg != NULL; cfg = cfg->next )
  45     {
  46         struct condition * cond;
  47
  48         for ( cond = cfg->cond; cond != NULL; cond = cond->next )
  49         {
  50             if ( cond->op == op_variable )
  51             {
  52                 /* Here's where it gets DISGUSTING. */
  53                 struct kconfig * cfg1;
  54
  55                 for ( cfg1 = scfg; cfg1 != NULL; cfg1 = cfg1->next )
  56                 {
  57                     if ( cfg1->token == token_bool
  58                     ||   cfg1->token == token_choice_item
  59                     ||   cfg1->token == token_dep_tristate
  60                     ||   cfg1->token == token_hex
  61                     ||   cfg1->token == token_int
  62                     ||   cfg1->token == token_string
  63                     ||   cfg1->token == token_tristate )
  64                     {
  65                         if ( strcmp( cond->str, cfg1->optionname ) == 0 )
  66                         {
  67                             cond->op  = op_kvariable;
  68                             cond->str = NULL;
  69                             cond->cfg = cfg1;
  70                             break;
  71                         }
  72                     }
  73                 }
  74             }
  75
  76 #if 0
  77             /*
  78              * Maybe someday this will be useful, but right now it
  79              * gives a lot of false positives on files like
  80              * drivers/video/Config.in that are meant for more
  81              * than one architecture.  Turn it on if you want to play
  82              * with it though; it does work.  -- mec
  83              */
  84             if ( cond->op == op_variable )
  85             {
  86                 if ( strcmp( cond->str, "ARCH"       ) != 0
  87                 &&   strcmp( cond->str, "CONSTANT_Y" ) != 0
  88                 &&   strcmp( cond->str, "CONSTANT_M" ) != 0
  89                 &&   strcmp( cond->str, "CONSTANT_N" ) != 0 )
  90                 {
  91                     fprintf( stderr, "warning: $%s used but not defined\n",
  92                         cond->str );
  93                 }
  94             }
  95 #endif
  96         }
  97     }
  98 }
  99
 100
 101
 102 /*
 103  * Make a new condition chain by joining the current condition stack with
 104  * the "&&" operator for glue.
 105  */
 106 struct condition * join_condition_stack( struct condition * conditions [],
 107     int depth )
 108 {
 109     struct condition * cond_list;
 110     struct condition * cond_last;
 111     int i;
 112
 113     cond_list = cond_last = NULL;
 114     for ( i = 0; i < depth; i++ )
 115     {
 116         struct condition * cond;
 117         struct condition * cnew;
 118
 119         /* add a '(' */
 120         cnew = malloc( sizeof(*cnew) );
 121         memset( cnew, 0, sizeof(*cnew) );
 122         cnew->op = op_lparen;
 123         if ( cond_last == NULL )
 124             { cond_list = cond_last = cnew; }
 125         else
 126             { cond_last->next = cnew; cond_last = cnew; }
 127
 128         /* duplicate the chain */
 129         for ( cond = conditions [i]; cond != NULL; cond = cond->next )
 130         {
 131             cnew            = malloc( sizeof(*cnew) );
 132             cnew->next      = NULL;
 133             cnew->op        = cond->op;
 134             cnew->str       = cond->str ? strdup( cond->str ) : NULL;
 135             cnew->cfg       = cond->cfg;
 136             cond_last->next = cnew;
 137             cond_last       = cnew;
 138         }
 139
 140         /* add a ')' */
 141         cnew = malloc( sizeof(*cnew) );
 142         memset( cnew, 0, sizeof(*cnew) );
 143         cnew->op = op_rparen;
 144         cond_last->next = cnew;
 145         cond_last = cnew;
 146
 147         /* if i have another condition, add an '&&' operator */
 148         if ( i < depth - 1 )
 149         {
 150             cnew = malloc( sizeof(*cnew) );
 151             memset( cnew, 0, sizeof(*cnew) );
 152             cnew->op = op_and;
 153             cond_last->next = cnew;
 154             cond_last = cnew;
 155         }
 156     }
 157
 158     /*
 159      * Remove duplicate conditions.
 160      */
 161     {
 162         struct condition *cond1, *cond1b, *cond1c, *cond1d, *cond1e, *cond1f;
 163
 164         for ( cond1 = cond_list; cond1 != NULL; cond1 = cond1->next )
 165         {
 166             if ( cond1->op == op_lparen )
 167             {
 168                 cond1b = cond1 ->next; if ( cond1b == NULL ) break;
 169                 cond1c = cond1b->next; if ( cond1c == NULL ) break;
 170                 cond1d = cond1c->next; if ( cond1d == NULL ) break;
 171                 cond1e = cond1d->next; if ( cond1e == NULL ) break;
 172                 cond1f = cond1e->next; if ( cond1f == NULL ) break;
 173
 174                 if ( cond1b->op == op_kvariable
 175                 && ( cond1c->op == op_eq || cond1c->op == op_neq )
 176                 &&   cond1d->op == op_constant
 177                 &&   cond1e->op == op_rparen )
 178                 {
 179                     struct condition *cond2, *cond2b, *cond2c, *cond2d, *cond2e, *cond2f;
 180
 181                     for ( cond2 = cond1f->next; cond2 != NULL; cond2 = cond2->next )
 182                     {
 183                         if ( cond2->op == op_lparen )
 184                         {
 185                             cond2b = cond2 ->next; if ( cond2b == NULL ) break;
 186                             cond2c = cond2b->next; if ( cond2c == NULL ) break;
 187                             cond2d = cond2c->next; if ( cond2d == NULL ) break;
 188                             cond2e = cond2d->next; if ( cond2e == NULL ) break;
 189                             cond2f = cond2e->next;
 190
 191                             /* look for match */
 192                             if ( cond2b->op == op_kvariable
 193                             &&   cond2b->cfg == cond1b->cfg
 194                             &&   cond2c->op == cond1c->op
 195                             &&   cond2d->op == op_constant
 196                             &&   strcmp( cond2d->str, cond1d->str ) == 0
 197                             &&   cond2e->op == op_rparen )
 198                             {
 199                                 /* one of these must be followed by && */
 200                                 if ( cond1f->op == op_and
 201                                 || ( cond2f != NULL && cond2f->op == op_and ) )
 202                                 {
 203                                     /* nuke the first duplicate */
 204                                     cond1 ->op = op_nuked;
 205                                     cond1b->op = op_nuked;
 206                                     cond1c->op = op_nuked;
 207                                     cond1d->op = op_nuked;
 208                                     cond1e->op = op_nuked;
 209                                     if ( cond1f->op == op_and )
 210                                         cond1f->op = op_nuked;
 211                                     else
 212                                         cond2f->op = op_nuked;
 213                                 }
 214                             }
 215                         }
 216                     }
 217                 }
 218             }
 219         }
 220     }
 221
 222     return cond_list;
 223 }
 224
 225
 226
 227 /*
 228  * This is the main transformation function.
 229  */
 230 void fix_conditionals( struct kconfig * scfg )
 231 {
 232     struct kconfig * cfg;
 233
 234     /*
 235      * Transform op_variable to op_kvariable.
 236      */
 237     transform_to_kvariable( scfg );
 238
 239     /*
 240      * Transform conditions that use variables from "choice" statements.
 241      * Choice values appear to the user as a collection of booleans, and the
 242      * script can test the individual booleans.  But internally, all I have is
 243      * the N-way value of an unnamed temporary for the whole statement.  So I
 244      * have to tranform '"$CONFIG_M386" != "y"'
 245      * into '"$tmpvar_N" != "CONFIG_M386"'.
 246      */
 247     for ( cfg = scfg; cfg != NULL; cfg = cfg->next )
 248     {
 249         struct condition * cond;
 250
 251         for ( cond = cfg->cond; cond != NULL; cond = cond->next )
 252         {
 253             if ( cond->op == op_kvariable && cond->cfg->token == token_choice_item )
 254             {
 255                 /*
 256                  * Look two more tokens down for the comparison token.
 257                  * It has to be "y" for this trick to work.
 258                  *
 259                  * If you get this error, don't even think about relaxing the
 260                  * strcmp test.  You will produce incorrect TK code.  Instead,
 261                  * look for the place in your Config.in script where you are
 262                  * comparing a 'choice' variable to a value other than 'y',
 263                  * and rewrite the comparison to be '= "y"' or '!= "y"'.
 264                  */
 265                 struct condition * cond2 = cond->next->next;
 266                 const char * label;
 267
 268                 if ( strcmp( cond2->str, "y" ) != 0 )
 269                 {
 270                     fprintf( stderr, "tkparse choked in fix_choice_cond\n" );
 271                     exit( 1 );
 272                 }
 273
 274                 label = cond->cfg->label;
 275                 cond->cfg  = cond->cfg->cfg_parent;
 276                 cond2->str = strdup( label );
 277             }
 278         }
 279     }
 280
 281     /*
 282      * Walk the statement list, maintaining a stack of current conditions.
 283      *   token_if      push its condition onto the stack.
 284      *   token_else    invert the condition on the top of the stack.
 285      *   token_endif   pop the stack.
 286      *
 287      * For a simple statement, create a condition chain by joining together
 288      * all of the conditions on the stack.
 289      */
 290     {
 291         struct condition * cond_stack [32];
 292         int depth = 0;
 293
 294         for ( cfg = scfg; cfg != NULL; cfg = cfg->next )
 295         {
 296             switch ( cfg->token )
 297             {
 298             default:
 299                 break;
 300
 301             case token_if:
 302                 cond_stack [depth++] = cfg->cond;
 303                 cfg->cond = NULL;
 304                 break;
 305
 306             case token_else:
 307                 {
 308                     /*
 309                      * Invert the condition chain.
 310                      *
 311                      * Be careful to transfrom op_or to op_and1, not op_and.
 312                      * I will need this later in the code that removes
 313                      * duplicate conditions.
 314                      */
 315                     struct condition * cond;
 316
 317                     for ( cond  = cond_stack [depth-1];
 318                           cond != NULL;
 319                           cond  = cond->next )
 320                     {
 321                         switch( cond->op )
 322                         {
 323                         default:     break;
 324                         case op_and: cond->op = op_or;   break;
 325                         case op_or:  cond->op = op_and1; break;
 326                         case op_neq: cond->op = op_eq;   break;
 327                         case op_eq:  cond->op = op_neq;  break;
 328                         }
 329                     }
 330                 }
 331                 break;
 332
 333             case token_fi:
 334                 --depth;
 335                 break;
 336
 337             case token_bool:
 338             case token_choice_item:
 339             case token_comment:
 340             case token_define_bool:
 341             case token_hex:
 342             case token_int:
 343             case token_mainmenu_option:
 344             case token_string:
 345             case token_tristate:
 346                 cfg->cond = join_condition_stack( cond_stack, depth );
 347                 break;
 348
 349             case token_dep_tristate:
 350                 /*
 351                  * Same as the other simple statements, plus an additional
 352                  * condition for the dependency.
 353                  */
 354                 cond_stack [depth] = cfg->cond;
 355                 cfg->cond = join_condition_stack( cond_stack, depth+1 );
 356                 break;
 357             }
 358         }
 359     }
 360 }