source: IOIPSL/trunk/tools/tkcond.c @ 369

/* parser config.in
 * $Id$
 * 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;
                }
            }
        }
    }
}