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

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [rc203soc/] [sw/] [uClinux/] [scripts/] [tkcond.c] - Blame information for rev 1782

Details | Compare with Previous | View Log


/* parser config.in
 *
 * Version 1.0
 * Eric Youngdale
 * 10/95
 *
 * The general idea here is that we want to parse a config.in file and
 * from this, we generate a wish script which gives us effectively the
 * same functionality that the original config.in script provided.
 *
 * This task is split roughly into 3 parts.  The first parse is the parse
 * of the input file itself.  The second part is where we analyze the
 * #ifdef clauses, and attach a linked list of tokens to each of the
 * menu items.  In this way, each menu item has a complete list of
 * dependencies that are used to enable/disable the options.
 * The third part is to take the configuration database we have build,
 * and build the actual wish script.
 *
 * This file contains the code to further process the conditions from
 * the "ifdef" clauses.
 *
 * The conditions are assumed to be one of the following formats
 *
 * simple_condition:= "$VARIABLE" == y/n/m
 * simple_condition:= "$VARIABLE != y/n/m
 *
 * simple_condition -a simple_condition
 *
 * If the input condition contains '(' or ')' it would screw us up, but for now
 * this is not a problem.
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "tkparse.h"
 
 
/*
 * Walk a condition chain and invert it so that the logical result is
 * inverted.
 */
static void invert_condition(struct condition * cnd)
{
  /*
   * This is simple.  Just walk through the list, and invert
   * all of the operators.
   */
  for(;cnd; cnd = cnd->next)
    {
      switch(cnd->op)
        {
        case op_and:
          cnd->op = op_or;
          break;
        case op_or:
          /*
           * This is not turned into op_and - we need to keep track
           * of what operators were used here since we have an optimization
           * later on to remove duplicate conditions, and having
           * inverted ors in there would make it harder if we did not
           * distinguish an inverted or from an and we inserted because
           * of nested ifs.
           */
          cnd->op = op_and1;
          break;
        case op_neq:
          cnd->op = op_eq;
          break;
        case op_eq:
          cnd->op = op_neq;
          break;
        default:
          break;
        }
    }
}
 
/*
 * Walk a condition chain, and free the memory associated with it.
 */
static void free_condition(struct condition * cnd)
{
  struct condition * next;
  for(;cnd; cnd = next)
    {
      next = cnd->next;
 
      if( cnd->variable.str != NULL )
        free(cnd->variable.str);
 
      free(cnd);
    }
}
 
/*
 * Walk all of the conditions, and look for choice values.  Convert
 * the tokens into something more digestible.
 */
void fix_choice_cond()
{
  struct condition * cond;
  struct condition * cond2;
  struct kconfig * cfg;
  char tmpbuf[10];
 
  for(cfg = config;cfg != NULL; cfg = cfg->next)
    {
      if( cfg->cond == NULL )
        {
          continue;
        }
 
      for(cond = cfg->cond; cond != NULL; cond = cond->next)
        {
          if( cond->op != op_kvariable )
            continue;
 
          if( cond->variable.cfg->tok != tok_choice )
            continue;
 
          /*
           * Look ahead for what we are comparing this to.  There should
           * be one operator in between.
           */
          cond2 = cond->next->next;
          strcpy(tmpbuf, cond->variable.cfg->label);
 
          if( strcmp(cond2->variable.str, "y") == 0 )
            {
              cond->variable.cfg = cond->variable.cfg->choice_label;
              cond2->variable.str = strdup(tmpbuf);
            }
          else
            {
              fprintf(stderr,"Ooops\n");
              exit(0);
            }
        }
 
    }
}
 
/*
 * Walk the stack of conditions, and clone all of them with "&&" operators
 * gluing them together.  The conditions from each level of the stack
 * are wrapped in parenthesis so as to guarantee that the results
 * are logically correct.
 */
struct condition * get_token_cond(struct condition ** cond, int depth)
{
  int i;
  struct condition * newcond;
  struct condition * tail;
  struct condition * new;
  struct condition * ocond;
  struct kconfig * cfg;
 
  newcond = tail = NULL;
  for(i=0; i<depth; i++, cond++)
    {
      /*
       * First insert the left parenthesis
       */
      new = (struct condition *) malloc(sizeof(struct condition));
      memset(new, 0, sizeof(*new));
      new->op = op_lparen;
      if( tail == NULL )
        {
          newcond = tail = new;
        }
      else
        {
          tail->next = new;
          tail = new;
        }
 
      /*
       * Now duplicate the chain.
       */
      ocond = *cond;
      for(;ocond != NULL; ocond = ocond->next)
        {
          new = (struct condition *) malloc(sizeof(struct condition));
          memset(new, 0, sizeof(*new));
          new->op = ocond->op;
          if( ocond->variable.str != NULL )
            {
              if( ocond->op == op_variable )
                {
                  /*
                   * Search for structure to insert here.
                   */
                  for(cfg = config;cfg != NULL; cfg = cfg->next)
                    {
                      if( cfg->tok != tok_bool
                         && cfg->tok != tok_int
                         && cfg->tok != tok_hex
                         && cfg->tok != tok_tristate
                         && cfg->tok != tok_choice
                         && cfg->tok != tok_dep_tristate)
                        {
                          continue;
                        }
                      if( strcmp(cfg->optionname, ocond->variable.str) == 0)
                        {
                          new->variable.cfg = cfg;
                          new->op = op_kvariable;
                          break;
                        }
                    }
                  if( cfg == NULL )
                    {
                      new->variable.str = strdup(ocond->variable.str);
                    }
                }
              else
                {
                  new->variable.str = strdup(ocond->variable.str);
                }
            }
          tail->next = new;
          tail = new;
        }
 
      /*
       * Next insert the left parenthesis
       */
      new = (struct condition *) malloc(sizeof(struct condition));
      memset(new, 0, sizeof(*new));
      new->op = op_rparen;
      tail->next = new;
      tail = new;
 
      /*
       * Insert an and operator, if we have another condition.
       */
      if( i < depth - 1 )
        {
          new = (struct condition *) malloc(sizeof(struct condition));
          memset(new, 0, sizeof(*new));
          new->op = op_and;
          tail->next = new;
          tail = new;
        }
 
    }
 
  return newcond;
}
 
/*
 * Walk a single chain of conditions and clone it.  These are assumed
 * to be created/processed by  get_token_cond in a previous pass.
 */
struct condition * get_token_cond_frag(struct condition * cond,
                                       struct condition ** last)
{
  struct condition * newcond;
  struct condition * tail;
  struct condition * new;
  struct condition * ocond;
 
  newcond = tail = NULL;
 
  /*
   * Now duplicate the chain.
   */
  for(ocond = cond;ocond != NULL; ocond = ocond->next)
    {
      new = (struct condition *) malloc(sizeof(struct condition));
      memset(new, 0, sizeof(*new));
      new->op = ocond->op;
      new->variable.cfg = ocond->variable.cfg;
      if( tail == NULL )
        {
          newcond = tail = new;
        }
      else
        {
          tail->next = new;
          tail = new;
        }
    }
 
  new = (struct condition *) malloc(sizeof(struct condition));
  memset(new, 0, sizeof(*new));
  new->op = op_and;
  tail->next = new;
  tail = new;
 
  *last = tail;
  return newcond;
}
 
/*
 * Walk through the if conditionals and maintain a chain.
 */
void fix_conditionals(struct kconfig * scfg)
{
  int depth = 0;
  int i;
  struct kconfig * cfg;
  struct kconfig * cfg1;
  struct condition * conditions[25];
  struct condition * cnd;
  struct condition * cnd1;
  struct condition * cnd2;
  struct condition * cnd3;
  struct condition * newcond;
  struct condition * last;
 
  /*
   * Start by walking the chain.  Every time we see an ifdef, push
   * the condition chain on the stack.  When we see an "else", we invert
   * the condition at the top of the stack, and when we see an "endif"
   * we free all of the memory for the condition at the top of the stack
   * and remove the condition from the top of the stack.
   *
   * For any other type of token (i.e. a bool), we clone a new condition chain
   * by anding together all of the conditions that are currently stored on
   * the stack.  In this way, we have a correct representation of whatever
   * conditions govern the usage of each option.
   */
  memset(conditions, 0, sizeof(conditions));
  for(cfg=scfg;cfg != NULL; cfg = cfg->next)
    {
      switch(cfg->tok)
        {
        case tok_if:
          /*
           * Push this condition on the stack, and nuke the token
           * representing the ifdef, since we no longer need it.
           */
          conditions[depth] = cfg->cond;
          depth++;
          cfg->tok = tok_nop;
          cfg->cond =  NULL;
          break;
        case tok_else:
          /*
           * For an else, we just invert the condition at the top of
           * the stack.  This is done in place with no reallocation
           * of memory taking place.
           */
          invert_condition(conditions[depth-1]);
          cfg->tok = tok_nop;
          break;
        case tok_fi:
          depth--;
          free_condition(conditions[depth]);
          conditions[depth] = NULL;
          cfg->tok = tok_nop;
          break;
        case tok_comment:
        case tok_define:
        case tok_menuoption:
        case tok_bool:
        case tok_tristate:
        case tok_int:
        case tok_hex:
        case tok_choice:
        case tok_make:
          /*
           * We need to duplicate the chain of conditions and attach them to
           * this token.
           */
          cfg->cond = get_token_cond(&conditions[0], depth);
          break;
        case tok_dep_tristate:
          /*
           * Same as tok_tristate et al except we have a temporary
           * conditional. (Sort of a hybrid tok_if, tok_tristate, tok_fi
           * option)
           */
          conditions[depth] = cfg->cond;
          depth++;
          cfg->cond = get_token_cond(&conditions[0], depth);
          depth--;
          free_condition(conditions[depth]);
          conditions[depth] = NULL;
        default:
          break;
        }
    }
 
  /*
   * Fix any conditions involving the "choice" operator.
   */
  fix_choice_cond();
 
  /*
   * Walk through and see if there are multiple options that control the
   * same kvariable.  If there are we need to treat them a little bit
   * special.
   */
  for(cfg=scfg;cfg != NULL; cfg = cfg->next)
    {
      switch(cfg->tok)
        {
        case tok_bool:
        case tok_tristate:
        case tok_dep_tristate:
        case tok_int:
        case tok_hex:
          for(cfg1=cfg;cfg1 != NULL; cfg1 = cfg1->next)
            {
              switch(cfg1->tok)
                {
                case tok_define:
                case tok_bool:
                case tok_tristate:
                case tok_dep_tristate:
                case tok_int:
                case tok_hex:
                  if( strcmp(cfg->optionname, cfg1->optionname) == 0)
                    {
                      cfg->flags |= CFG_DUP;
                      cfg1->flags |= CFG_DUP;
                    }
                  break;
                default:
                  break;
                }
            }
          break;
        default:
          break;
        }
    }
 
  /*
   * Now go through the list, and every time we see a kvariable, check
   * to see whether it also has some dependencies.  If so, then
   * append it to our list.  The reason we do this is that we might have
   * option CONFIG_FOO which is only used if CONFIG_BAR is set.  It may
   * turn out that in config.in that the default value for CONFIG_BAR is
   * set to "y", but that CONFIG_BAR is not enabled because CONFIG_XYZZY
   * is not set.  The current condition chain does not reflect this, but
   * we can fix this by searching for the tokens that this option depends
   * upon and cloning the conditions and merging them with the list.
   */
  for(cfg=scfg;cfg != NULL; cfg = cfg->next)
    {
      /*
       * Search for a token that has a condition list.
       */
      if(cfg->cond == NULL) continue;
      for(cnd = cfg->cond; cnd; cnd=cnd->next)
        {
          /*
           * Now search the condition list for a known configuration variable
           * that has conditions of its own.
           */
          if(cnd->op != op_kvariable) continue;
          if(cnd->variable.cfg->cond == NULL) continue;
 
          if(cnd->variable.cfg->flags & CFG_DUP) continue;
          /*
           * OK, we have some conditions to append to cfg.  Make  a clone
           * of the conditions,
           */
          newcond = get_token_cond_frag(cnd->variable.cfg->cond, &last);
 
          /*
           * Finally, we splice it into our list.
           */
          last->next = cfg->cond;
          cfg->cond = newcond;
 
        }
    }
 
  /*
   * There is a strong possibility that we have duplicate conditions
   * in here.  It would make the script more efficient and readable to
   * remove these.  Here is where we assume here that there are no
   * parenthesis in the input script.
   */
  for(cfg=scfg;cfg != NULL; cfg = cfg->next)
    {
      /*
       * Search for configuration options that have conditions.
       */
      if(cfg->cond == NULL) continue;
      for(cnd = cfg->cond; cnd; cnd=cnd->next)
        {
          /*
           * Search for a left parenthesis.
           */
          if(cnd->op != op_lparen) continue;
          for(cnd1 = cnd->next; cnd1; cnd1=cnd1->next)
            {
              /*
               * Search after the previous left parenthesis, and try
               * and find a second left parenthesis.
               */
              if(cnd1->op != op_lparen) continue;
 
              /*
               * Now compare the next 5 tokens to see if they are
               * identical.  We are looking for two chains that
               * are like: '(' $VARIABLE operator constant ')'.
               */
              cnd2 = cnd;
              cnd3 = cnd1;
              for(i=0; i<5; i++, cnd2=cnd2->next, cnd3=cnd3->next)
                {
                  if(!cnd2 || !cnd3) break;
                  if(cnd2->op != cnd3->op) break;
                  if(i == 1 && (cnd2->op != op_kvariable
                     || cnd2->variable.cfg != cnd3->variable.cfg) ) break;
                  if(i==2 && cnd2->op != op_eq && cnd2->op != op_neq) break;
                  if(i == 3 && cnd2->op != op_constant &&
                     strcmp(cnd2->variable.str, cnd3->variable.str) != 0)
                    break;
                  if(i==4 && cnd2->op != op_rparen) break;
                }
              /*
               * If these match, and there is an and gluing these together,
               * then we can nuke the second one.
               */
              if(i==5 && ((cnd3 && cnd3->op == op_and)
                          ||(cnd2 && cnd2->op == op_and)))
                {
                  /*
                   * We have a duplicate.  Nuke 5 ops.
                   */
                  cnd3 = cnd1;
                  for(i=0; i<5; i++, cnd3=cnd3->next)
                    {
                      cnd3->op = op_nuked;
                    }
                  /*
                   * Nuke the and that glues the conditions together.
                   */
                  if(cnd3 && cnd3->op == op_and) cnd3->op = op_nuked;
                  else if(cnd2 && cnd2->op == op_and) cnd2->op = op_nuked;
                }
            }
        }
    }
}

Browse

Tools

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [rc203soc/] [sw/] [uClinux/] [scripts/] [tkcond.c] - Blame information for rev 1782

Line No.	Rev	Author	Line
1	1629	jcastillo	`/* parser config.in`
2			`*`
3			`* Version 1.0`
4			`* Eric Youngdale`
5			`* 10/95`
6			`*`
7			`* The general idea here is that we want to parse a config.in file and`
8			`* from this, we generate a wish script which gives us effectively the`
9			`* same functionality that the original config.in script provided.`
10			`*`
11			`* This task is split roughly into 3 parts. The first parse is the parse`
12			`* of the input file itself. The second part is where we analyze the`
13			`* #ifdef clauses, and attach a linked list of tokens to each of the`
14			`* menu items. In this way, each menu item has a complete list of`
15			`* dependencies that are used to enable/disable the options.`
16			`* The third part is to take the configuration database we have build,`
17			`* and build the actual wish script.`
18			`*`
19			`* This file contains the code to further process the conditions from`
20			`* the "ifdef" clauses.`
21			`*`
22			`* The conditions are assumed to be one of the following formats`
23			`*`
24			`* simple_condition:= "$VARIABLE" == y/n/m`
25			`* simple_condition:= "$VARIABLE != y/n/m`
26			`*`
27			`* simple_condition -a simple_condition`
28			`*`
29			`* If the input condition contains '(' or ')' it would screw us up, but for now`
30			`* this is not a problem.`
31			`*/`
32			`#include <stdlib.h>`
33			`#include <stdio.h>`
34			`#include <string.h>`
35			`#include "tkparse.h"`
36
37
38			`/*`
39			`* Walk a condition chain and invert it so that the logical result is`
40			`* inverted.`
41			`*/`
42			`static void invert_condition(struct condition * cnd)`
43			`{`
44			`/*`
45			`* This is simple. Just walk through the list, and invert`
46			`* all of the operators.`
47			`*/`
48			`for(;cnd; cnd = cnd->next)`
49			`{`
50			`switch(cnd->op)`
51			`{`
52			`case op_and:`
53			`cnd->op = op_or;`
54			`break;`
55			`case op_or:`
56			`/*`
57			`* This is not turned into op_and - we need to keep track`
58			`* of what operators were used here since we have an optimization`
59			`* later on to remove duplicate conditions, and having`
60			`* inverted ors in there would make it harder if we did not`
61			`* distinguish an inverted or from an and we inserted because`
62			`* of nested ifs.`
63			`*/`
64			`cnd->op = op_and1;`
65			`break;`
66			`case op_neq:`
67			`cnd->op = op_eq;`
68			`break;`
69			`case op_eq:`
70			`cnd->op = op_neq;`
71			`break;`
72			`default:`
73			`break;`
74			`}`
75			`}`
76			`}`
77
78			`/*`
79			`* Walk a condition chain, and free the memory associated with it.`
80			`*/`
81			`static void free_condition(struct condition * cnd)`
82			`{`
83			`struct condition * next;`
84			`for(;cnd; cnd = next)`
85			`{`
86			`next = cnd->next;`
87
88			`if( cnd->variable.str != NULL )`
89			`free(cnd->variable.str);`
90
91			`free(cnd);`
92			`}`
93			`}`
94
95			`/*`
96			`* Walk all of the conditions, and look for choice values. Convert`
97			`* the tokens into something more digestible.`
98			`*/`
99			`void fix_choice_cond()`
100			`{`
101			`struct condition * cond;`
102			`struct condition * cond2;`
103			`struct kconfig * cfg;`
104			`char tmpbuf[10];`
105
106			`for(cfg = config;cfg != NULL; cfg = cfg->next)`
107			`{`
108			`if( cfg->cond == NULL )`
109			`{`
110			`continue;`
111			`}`
112
113			`for(cond = cfg->cond; cond != NULL; cond = cond->next)`
114			`{`
115			`if( cond->op != op_kvariable )`
116			`continue;`
117
118			`if( cond->variable.cfg->tok != tok_choice )`
119			`continue;`
120
121			`/*`
122			`* Look ahead for what we are comparing this to. There should`
123			`* be one operator in between.`
124			`*/`
125			`cond2 = cond->next->next;`
126			`strcpy(tmpbuf, cond->variable.cfg->label);`
127
128			`if( strcmp(cond2->variable.str, "y") == 0 )`
129			`{`
130			`cond->variable.cfg = cond->variable.cfg->choice_label;`
131			`cond2->variable.str = strdup(tmpbuf);`
132			`}`
133			`else`
134			`{`
135			`fprintf(stderr,"Ooops\n");`
136			`exit(0);`
137			`}`
138			`}`
139
140			`}`
141			`}`
142
143			`/*`
144			`* Walk the stack of conditions, and clone all of them with "&&" operators`
145			`* gluing them together. The conditions from each level of the stack`
146			`* are wrapped in parenthesis so as to guarantee that the results`
147			`* are logically correct.`
148			`*/`
149			`struct condition * get_token_cond(struct condition ** cond, int depth)`
150			`{`
151			`int i;`
152			`struct condition * newcond;`
153			`struct condition * tail;`
154			`struct condition * new;`
155			`struct condition * ocond;`
156			`struct kconfig * cfg;`
157
158			`newcond = tail = NULL;`
159			`for(i=0; i<depth; i++, cond++)`
160			`{`
161			`/*`
162			`* First insert the left parenthesis`
163			`*/`
164			`new = (struct condition *) malloc(sizeof(struct condition));`
165			`memset(new, 0, sizeof(*new));`
166			`new->op = op_lparen;`
167			`if( tail == NULL )`
168			`{`
169			`newcond = tail = new;`
170			`}`
171			`else`
172			`{`
173			`tail->next = new;`
174			`tail = new;`
175			`}`
176
177			`/*`
178			`* Now duplicate the chain.`
179			`*/`
180			`ocond = *cond;`
181			`for(;ocond != NULL; ocond = ocond->next)`
182			`{`
183			`new = (struct condition *) malloc(sizeof(struct condition));`
184			`memset(new, 0, sizeof(*new));`
185			`new->op = ocond->op;`
186			`if( ocond->variable.str != NULL )`
187			`{`
188			`if( ocond->op == op_variable )`
189			`{`
190			`/*`
191			`* Search for structure to insert here.`
192			`*/`
193			`for(cfg = config;cfg != NULL; cfg = cfg->next)`
194			`{`
195			`if( cfg->tok != tok_bool`
196			`&& cfg->tok != tok_int`
197			`&& cfg->tok != tok_hex`
198			`&& cfg->tok != tok_tristate`
199			`&& cfg->tok != tok_choice`
200			`&& cfg->tok != tok_dep_tristate)`
201			`{`
202			`continue;`
203			`}`
204			`if( strcmp(cfg->optionname, ocond->variable.str) == 0)`
205			`{`
206			`new->variable.cfg = cfg;`
207			`new->op = op_kvariable;`
208			`break;`
209			`}`
210			`}`
211			`if( cfg == NULL )`
212			`{`
213			`new->variable.str = strdup(ocond->variable.str);`
214			`}`
215			`}`
216			`else`
217			`{`
218			`new->variable.str = strdup(ocond->variable.str);`
219			`}`
220			`}`
221			`tail->next = new;`
222			`tail = new;`
223			`}`
224
225			`/*`
226			`* Next insert the left parenthesis`
227			`*/`
228			`new = (struct condition *) malloc(sizeof(struct condition));`
229			`memset(new, 0, sizeof(*new));`
230			`new->op = op_rparen;`
231			`tail->next = new;`
232			`tail = new;`
233
234			`/*`
235			`* Insert an and operator, if we have another condition.`
236			`*/`
237			`if( i < depth - 1 )`
238			`{`
239			`new = (struct condition *) malloc(sizeof(struct condition));`
240			`memset(new, 0, sizeof(*new));`
241			`new->op = op_and;`
242			`tail->next = new;`
243			`tail = new;`
244			`}`
245
246			`}`
247
248			`return newcond;`
249			`}`
250
251			`/*`
252			`* Walk a single chain of conditions and clone it. These are assumed`
253			`* to be created/processed by get_token_cond in a previous pass.`
254			`*/`
255			`struct condition * get_token_cond_frag(struct condition * cond,`
256			`struct condition ** last)`
257			`{`
258			`struct condition * newcond;`
259			`struct condition * tail;`
260			`struct condition * new;`
261			`struct condition * ocond;`
262
263			`newcond = tail = NULL;`
264
265			`/*`
266			`* Now duplicate the chain.`
267			`*/`
268			`for(ocond = cond;ocond != NULL; ocond = ocond->next)`
269			`{`
270			`new = (struct condition *) malloc(sizeof(struct condition));`
271			`memset(new, 0, sizeof(*new));`
272			`new->op = ocond->op;`
273			`new->variable.cfg = ocond->variable.cfg;`
274			`if( tail == NULL )`
275			`{`
276			`newcond = tail = new;`
277			`}`
278			`else`
279			`{`
280			`tail->next = new;`
281			`tail = new;`
282			`}`
283			`}`
284
285			`new = (struct condition *) malloc(sizeof(struct condition));`
286			`memset(new, 0, sizeof(*new));`
287			`new->op = op_and;`
288			`tail->next = new;`
289			`tail = new;`
290
291			`*last = tail;`
292			`return newcond;`
293			`}`
294
295			`/*`
296			`* Walk through the if conditionals and maintain a chain.`
297			`*/`
298			`void fix_conditionals(struct kconfig * scfg)`
299			`{`
300			`int depth = 0;`
301			`int i;`
302			`struct kconfig * cfg;`
303			`struct kconfig * cfg1;`
304			`struct condition * conditions[25];`
305			`struct condition * cnd;`
306			`struct condition * cnd1;`
307			`struct condition * cnd2;`
308			`struct condition * cnd3;`
309			`struct condition * newcond;`
310			`struct condition * last;`
311
312			`/*`
313			`* Start by walking the chain. Every time we see an ifdef, push`
314			`* the condition chain on the stack. When we see an "else", we invert`
315			`* the condition at the top of the stack, and when we see an "endif"`
316			`* we free all of the memory for the condition at the top of the stack`
317			`* and remove the condition from the top of the stack.`
318			`*`
319			`* For any other type of token (i.e. a bool), we clone a new condition chain`
320			`* by anding together all of the conditions that are currently stored on`
321			`* the stack. In this way, we have a correct representation of whatever`
322			`* conditions govern the usage of each option.`
323			`*/`
324			`memset(conditions, 0, sizeof(conditions));`
325			`for(cfg=scfg;cfg != NULL; cfg = cfg->next)`
326			`{`
327			`switch(cfg->tok)`
328			`{`
329			`case tok_if:`
330			`/*`
331			`* Push this condition on the stack, and nuke the token`
332			`* representing the ifdef, since we no longer need it.`
333			`*/`
334			`conditions[depth] = cfg->cond;`
335			`depth++;`
336			`cfg->tok = tok_nop;`
337			`cfg->cond = NULL;`
338			`break;`
339			`case tok_else:`
340			`/*`
341			`* For an else, we just invert the condition at the top of`
342			`* the stack. This is done in place with no reallocation`
343			`* of memory taking place.`
344			`*/`
345			`invert_condition(conditions[depth-1]);`
346			`cfg->tok = tok_nop;`
347			`break;`
348			`case tok_fi:`
349			`depth--;`
350			`free_condition(conditions[depth]);`
351			`conditions[depth] = NULL;`
352			`cfg->tok = tok_nop;`
353			`break;`
354			`case tok_comment:`
355			`case tok_define:`
356			`case tok_menuoption:`
357			`case tok_bool:`
358			`case tok_tristate:`
359			`case tok_int:`
360			`case tok_hex:`
361			`case tok_choice:`
362			`case tok_make:`
363			`/*`
364			`* We need to duplicate the chain of conditions and attach them to`
365			`* this token.`
366			`*/`
367			`cfg->cond = get_token_cond(&conditions[0], depth);`
368			`break;`
369			`case tok_dep_tristate:`
370			`/*`
371			`* Same as tok_tristate et al except we have a temporary`
372			`* conditional. (Sort of a hybrid tok_if, tok_tristate, tok_fi`
373			`* option)`
374			`*/`
375			`conditions[depth] = cfg->cond;`
376			`depth++;`
377			`cfg->cond = get_token_cond(&conditions[0], depth);`
378			`depth--;`
379			`free_condition(conditions[depth]);`
380			`conditions[depth] = NULL;`
381			`default:`
382			`break;`
383			`}`
384			`}`
385
386			`/*`
387			`* Fix any conditions involving the "choice" operator.`
388			`*/`
389			`fix_choice_cond();`
390
391			`/*`
392			`* Walk through and see if there are multiple options that control the`
393			`* same kvariable. If there are we need to treat them a little bit`
394			`* special.`
395			`*/`
396			`for(cfg=scfg;cfg != NULL; cfg = cfg->next)`
397			`{`
398			`switch(cfg->tok)`
399			`{`
400			`case tok_bool:`
401			`case tok_tristate:`
402			`case tok_dep_tristate:`
403			`case tok_int:`
404			`case tok_hex:`
405			`for(cfg1=cfg;cfg1 != NULL; cfg1 = cfg1->next)`
406			`{`
407			`switch(cfg1->tok)`
408			`{`
409			`case tok_define:`
410			`case tok_bool:`
411			`case tok_tristate:`
412			`case tok_dep_tristate:`
413			`case tok_int:`
414			`case tok_hex:`
415			`if( strcmp(cfg->optionname, cfg1->optionname) == 0)`
416			`{`
417			`cfg->flags \|= CFG_DUP;`
418			`cfg1->flags \|= CFG_DUP;`
419			`}`
420			`break;`
421			`default:`
422			`break;`
423			`}`
424			`}`
425			`break;`
426			`default:`
427			`break;`
428			`}`
429			`}`
430
431			`/*`
432			`* Now go through the list, and every time we see a kvariable, check`
433			`* to see whether it also has some dependencies. If so, then`
434			`* append it to our list. The reason we do this is that we might have`
435			`* option CONFIG_FOO which is only used if CONFIG_BAR is set. It may`
436			`* turn out that in config.in that the default value for CONFIG_BAR is`
437			`* set to "y", but that CONFIG_BAR is not enabled because CONFIG_XYZZY`
438			`* is not set. The current condition chain does not reflect this, but`
439			`* we can fix this by searching for the tokens that this option depends`
440			`* upon and cloning the conditions and merging them with the list.`
441			`*/`
442			`for(cfg=scfg;cfg != NULL; cfg = cfg->next)`
443			`{`
444			`/*`
445			`* Search for a token that has a condition list.`
446			`*/`
447			`if(cfg->cond == NULL) continue;`
448			`for(cnd = cfg->cond; cnd; cnd=cnd->next)`
449			`{`
450			`/*`
451			`* Now search the condition list for a known configuration variable`
452			`* that has conditions of its own.`
453			`*/`
454			`if(cnd->op != op_kvariable) continue;`
455			`if(cnd->variable.cfg->cond == NULL) continue;`
456
457			`if(cnd->variable.cfg->flags & CFG_DUP) continue;`
458			`/*`
459			`* OK, we have some conditions to append to cfg. Make a clone`
460			`* of the conditions,`
461			`*/`
462			`newcond = get_token_cond_frag(cnd->variable.cfg->cond, &last);`
463
464			`/*`
465			`* Finally, we splice it into our list.`
466			`*/`
467			`last->next = cfg->cond;`
468			`cfg->cond = newcond;`
469
470			`}`
471			`}`
472
473			`/*`
474			`* There is a strong possibility that we have duplicate conditions`
475			`* in here. It would make the script more efficient and readable to`
476			`* remove these. Here is where we assume here that there are no`
477			`* parenthesis in the input script.`
478			`*/`
479			`for(cfg=scfg;cfg != NULL; cfg = cfg->next)`
480			`{`
481			`/*`
482			`* Search for configuration options that have conditions.`
483			`*/`
484			`if(cfg->cond == NULL) continue;`
485			`for(cnd = cfg->cond; cnd; cnd=cnd->next)`
486			`{`
487			`/*`
488			`* Search for a left parenthesis.`
489			`*/`
490			`if(cnd->op != op_lparen) continue;`
491			`for(cnd1 = cnd->next; cnd1; cnd1=cnd1->next)`
492			`{`
493			`/*`
494			`* Search after the previous left parenthesis, and try`
495			`* and find a second left parenthesis.`
496			`*/`
497			`if(cnd1->op != op_lparen) continue;`
498
499			`/*`
500			`* Now compare the next 5 tokens to see if they are`
501			`* identical. We are looking for two chains that`
502			`* are like: '(' $VARIABLE operator constant ')'.`
503			`*/`
504			`cnd2 = cnd;`
505			`cnd3 = cnd1;`
506			`for(i=0; i<5; i++, cnd2=cnd2->next, cnd3=cnd3->next)`
507			`{`
508			`if(!cnd2 \|\| !cnd3) break;`
509			`if(cnd2->op != cnd3->op) break;`
510			`if(i == 1 && (cnd2->op != op_kvariable`
511			`\|\| cnd2->variable.cfg != cnd3->variable.cfg) ) break;`
512			`if(i==2 && cnd2->op != op_eq && cnd2->op != op_neq) break;`
513			`if(i == 3 && cnd2->op != op_constant &&`
514			`strcmp(cnd2->variable.str, cnd3->variable.str) != 0)`
515			`break;`
516			`if(i==4 && cnd2->op != op_rparen) break;`
517			`}`
518			`/*`
519			`* If these match, and there is an and gluing these together,`
520			`* then we can nuke the second one.`
521			`*/`
522			`if(i==5 && ((cnd3 && cnd3->op == op_and)`
523			`\|\|(cnd2 && cnd2->op == op_and)))`
524			`{`
525			`/*`
526			`* We have a duplicate. Nuke 5 ops.`
527			`*/`
528			`cnd3 = cnd1;`
529			`for(i=0; i<5; i++, cnd3=cnd3->next)`
530			`{`
531			`cnd3->op = op_nuked;`
532			`}`
533			`/*`
534			`* Nuke the and that glues the conditions together.`
535			`*/`
536			`if(cnd3 && cnd3->op == op_and) cnd3->op = op_nuked;`
537			`else if(cnd2 && cnd2->op == op_and) cnd2->op = op_nuked;`
538			`}`
539			`}`
540			`}`
541			`}`
542			`}`