URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [tags/] [before_ORP/] [uclinux/] [uClinux-2.0.x/] [scripts/] [tkcond.c] - Rev 901
Go to most recent revision | Compare with Previous | Blame | 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; } } } } }
Go to most recent revision | Compare with Previous | Blame | View Log