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

Subversion Repositories mips_enhanced

[/] [mips_enhanced/] [trunk/] [grlib-gpl-1.0.19-b3188/] [bin/] [tkconfig/] [tkcond.c] - Blame information for rev 2

Details | Compare with Previous | View Log


/*
 * tkcond.c
 *
 * Eric Youngdale was the original author of xconfig.
 * Michael Elizabeth Chastain (mec@shout.net) is the current maintainer.
 *
 * This file takes the tokenized statement list and transforms 'if ...'
 * statements.  For each simple statement, I find all of the 'if' statements
 * that enclose it, and attach the aggregate conditionals of those 'if'
 * statements to the cond list of the simple statement.
 *
 * 14 January 1999, Michael Elizabeth Chastain, <mec@shout.net>
 * - Steam-clean this file.  I tested this by generating kconfig.tk for
 *   every architecture and comparing it character-for-character against
 *   the output of the old tkparse.
 *
 * 07 July 1999, Andrzej M. Krzysztofowicz <ankry@mif.pg.gda.pl>
 * - kvariables removed; all variables are stored in a single table now
 * - some elimination of options non-valid for current architecture
 *   implemented.
 * - negation (!) eliminated from conditions
 *
 * TO DO:
 * - xconfig is at the end of its life cycle.  Contact <mec@shout.net> if
 *   you are interested in working on the replacement.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "tkparse.h"
 
 
 
/*
 * Mark variables which are defined anywhere.
 */
static void mark_variables( struct kconfig * scfg )
{
    struct kconfig * cfg;
    int i;
 
    for ( i = 1; i <= max_varnum; i++ )
        vartable[i].defined = 0;
    for ( cfg = scfg; cfg != NULL; cfg = cfg->next )
    {
        if ( cfg->token == token_bool
        ||   cfg->token == token_choice_item
        ||   cfg->token == token_define_bool
        ||   cfg->token == token_define_hex
        ||   cfg->token == token_define_int
        ||   cfg->token == token_define_string
        ||   cfg->token == token_define_tristate
        ||   cfg->token == token_dep_bool
        ||   cfg->token == token_dep_mbool
        ||   cfg->token == token_dep_tristate
        ||   cfg->token == token_hex
        ||   cfg->token == token_int
        ||   cfg->token == token_string
        ||   cfg->token == token_tristate
        ||   cfg->token == token_unset )
        {
            if ( cfg->nameindex > 0 )    /* paranoid */
            {
                vartable[cfg->nameindex].defined = 1;
            }
        }
    }
}
 
 
 
static void free_cond( struct condition *cond )
{
    struct condition *tmp, *tmp1;
    for ( tmp = cond; tmp; tmp = tmp1 )
    {
        tmp1 = tmp->next;
        free( (void*)tmp );
    }
}
 
 
 
/*
 * Remove the bang operator from a condition to avoid priority problems.
 * "!" has different priorities as "test" command argument and in
 * a tk script.
 */
static struct condition * remove_bang( struct condition * condition )
{
    struct condition * conda, * condb, * prev = NULL;
 
    for ( conda = condition; conda; conda = conda->next )
    {
        if ( conda->op == op_bang && conda->next &&
           ( condb = conda->next->next ) )
        {
            if ( condb->op == op_eq || condb->op == op_neq )
            {
                condb->op = (condb->op == op_eq) ? op_neq : op_eq;
                conda->op = op_nuked;
                if ( prev )
                {
                    prev->next = conda->next;
                }
                else
                {
                    condition = conda->next;
                }
                conda->next = NULL;
                free_cond( conda );
                conda = condb;
            }
        }
        prev = conda;
    }
    return condition;
}
 
 
 
/*
 * Make a new condition chain by joining the current condition stack with
 * the "&&" operator for glue.
 */
static struct condition * join_condition_stack( struct condition * conditions [],
    int depth )
{
    struct condition * cond_list;
    struct condition * cond_last;
    int i, is_first = 1;
 
    cond_list = cond_last = NULL;
 
    for ( i = 0; i < depth; i++ )
    {
        if ( conditions[i]->op == op_false )
        {
            struct condition * cnew;
 
            /* It is always false condition */
            cnew = malloc( sizeof(*cnew) );
            memset( cnew, 0, sizeof(*cnew) );
            cnew->op = op_false;
            cond_list = cond_last = cnew;
            goto join_done;
        }
    }
    for ( i = 0; i < depth; i++ )
    {
        struct condition * cond;
        struct condition * cnew;
        int add_paren;
 
        /* omit always true conditions */
        if ( conditions[i]->op == op_true )
            continue;
 
        /* if i have another condition, add an '&&' operator */
        if ( !is_first )
        {
            cnew = malloc( sizeof(*cnew) );
            memset( cnew, 0, sizeof(*cnew) );
            cnew->op = op_and;
            cond_last->next = cnew;
            cond_last = cnew;
        }
 
        if ( conditions[i]->op != op_lparen )
        {
            /* add a '(' */
            add_paren = 1;
            cnew = malloc( sizeof(*cnew) );
            memset( cnew, 0, sizeof(*cnew) );
            cnew->op = op_lparen;
            if ( cond_last == NULL )
                { cond_list = cond_last = cnew; }
            else
                { cond_last->next = cnew; cond_last = cnew; }
        }
        else
        {
            add_paren = 0;
        }
 
        /* duplicate the chain */
        for ( cond = conditions [i]; cond != NULL; cond = cond->next )
        {
            cnew            = malloc( sizeof(*cnew) );
            cnew->next      = NULL;
            cnew->op        = cond->op;
            cnew->str       = cond->str ? strdup( cond->str ) : NULL;
            cnew->nameindex = cond->nameindex;
            if ( cond_last == NULL )
                { cond_list = cond_last = cnew; }
            else
                { cond_last->next = cnew; cond_last = cnew; }
        }
 
        if ( add_paren )
        {
            /* add a ')' */
            cnew = malloc( sizeof(*cnew) );
            memset( cnew, 0, sizeof(*cnew) );
            cnew->op = op_rparen;
            cond_last->next = cnew;
            cond_last = cnew;
        }
        is_first = 0;
    }
 
    /*
     * Remove duplicate conditions.
     */
    {
        struct condition *cond1, *cond1b, *cond1c, *cond1d, *cond1e, *cond1f;
 
        for ( cond1 = cond_list; cond1 != NULL; cond1 = cond1->next )
        {
            if ( cond1->op == op_lparen )
            {
                cond1b = cond1 ->next; if ( cond1b == NULL ) break;
                cond1c = cond1b->next; if ( cond1c == NULL ) break;
                cond1d = cond1c->next; if ( cond1d == NULL ) break;
                cond1e = cond1d->next; if ( cond1e == NULL ) break;
                cond1f = cond1e->next; if ( cond1f == NULL ) break;
 
                if ( cond1b->op == op_variable
                && ( cond1c->op == op_eq || cond1c->op == op_neq )
                &&   cond1d->op == op_constant
                &&   cond1e->op == op_rparen )
                {
                    struct condition *cond2, *cond2b, *cond2c, *cond2d, *cond2e, *cond2f;
 
                    for ( cond2 = cond1f->next; cond2 != NULL; cond2 = cond2->next )
                    {
                        if ( cond2->op == op_lparen )
                        {
                            cond2b = cond2 ->next; if ( cond2b == NULL ) break;
                            cond2c = cond2b->next; if ( cond2c == NULL ) break;
                            cond2d = cond2c->next; if ( cond2d == NULL ) break;
                            cond2e = cond2d->next; if ( cond2e == NULL ) break;
                            cond2f = cond2e->next;
 
                            /* look for match */
                            if ( cond2b->op == op_variable
                            &&   cond2b->nameindex == cond1b->nameindex
                            &&   cond2c->op == cond1c->op
                            &&   cond2d->op == op_constant
                            &&   strcmp( cond2d->str, cond1d->str ) == 0
                            &&   cond2e->op == op_rparen )
                            {
                                /* one of these must be followed by && */
                                if ( cond1f->op == op_and
                                || ( cond2f != NULL && cond2f->op == op_and ) )
                                {
                                    /* nuke the first duplicate */
                                    cond1 ->op = op_nuked;
                                    cond1b->op = op_nuked;
                                    cond1c->op = op_nuked;
                                    cond1d->op = op_nuked;
                                    cond1e->op = op_nuked;
                                    if ( cond1f->op == op_and )
                                        cond1f->op = op_nuked;
                                    else
                                        cond2f->op = op_nuked;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
 
join_done:
    return cond_list;
}
 
 
static char arch_sparc[] = "sparc";
static char * current_arch = arch_sparc;
 
/*
 * Eliminating conditions with ARCH = <not current>.
 */
static struct condition *eliminate_other_arch( struct condition *list )
{
    struct condition *cond1a = list, *cond1b = NULL, *cond1c = NULL, *cond1d = NULL;
    if ( current_arch == NULL )
        current_arch = getenv( "ARCH" );
    if ( current_arch == NULL )
    {
        fprintf( stderr, "error: ARCH undefined\n" );
        exit( 1 );
    }
    if ( cond1a->op == op_variable
    && ! strcmp( vartable[cond1a->nameindex].name, "ARCH" ) )
    {
        cond1b = cond1a->next; if ( cond1b == NULL ) goto done;
        cond1c = cond1b->next; if ( cond1c == NULL ) goto done;
        cond1d = cond1c->next;
        if ( cond1c->op == op_constant && cond1d == NULL )
        {
            if ( (cond1b->op == op_eq && strcmp( cond1c->str, current_arch ))
            ||   (cond1b->op == op_neq && ! strcmp( cond1c->str, current_arch )) )
            {
                /* This is for another architecture */
                cond1a->op = op_false;
                cond1a->next = NULL;
                free_cond( cond1b );
                return cond1a;
            }
            else if ( (cond1b->op == op_neq && strcmp( cond1c->str, current_arch ))
                 ||   (cond1b->op == op_eq && ! strcmp( cond1c->str, current_arch )) )
            {
                /* This is for current architecture */
                cond1a->op = op_true;
                cond1a->next = NULL;
                free_cond( cond1b );
                return cond1a;
            }
        }
        else if ( cond1c->op == op_constant && cond1d->op == op_or )
        {
            if ( (cond1b->op == op_eq && strcmp( cond1c->str, current_arch ))
            ||   (cond1b->op == op_neq && ! strcmp( cond1c->str, current_arch )) )
            {
                /* This is for another architecture */
                cond1b = cond1d->next;
                cond1d->next = NULL;
                free_cond( cond1a );
                return eliminate_other_arch( cond1b );
            }
            else if ( (cond1b->op == op_neq && strcmp( cond1c->str, current_arch ))
                 || (cond1b->op == op_eq && ! strcmp( cond1c->str, current_arch )) )
            {
                /* This is for current architecture */
                cond1a->op = op_true;
                cond1a->next = NULL;
                free_cond( cond1b );
                return cond1a;
            }
        }
        else if ( cond1c->op == op_constant && cond1d->op == op_and )
        {
            if ( (cond1b->op == op_eq && strcmp( cond1c->str, current_arch ))
            ||   (cond1b->op == op_neq && ! strcmp( cond1c->str, current_arch )) )
            {
                /* This is for another architecture */
                int l_par = 0;
 
                for ( cond1c = cond1d->next; cond1c; cond1c = cond1c->next )
                {
                    if ( cond1c->op == op_lparen )
                        l_par++;
                    else if ( cond1c->op == op_rparen )
                        l_par--;
                    else if ( cond1c->op == op_or && l_par == 0 )
                    /* Expression too complex - don't touch */
                        return cond1a;
                    else if ( l_par < 0 )
                    {
                        fprintf( stderr, "incorrect condition: programming error ?\n" );
                        exit( 1 );
                    }
                }
                cond1a->op = op_false;
                cond1a->next = NULL;
                free_cond( cond1b );
                return cond1a;
            }
            else if ( (cond1b->op == op_neq && strcmp( cond1c->str, current_arch ))
                 || (cond1b->op == op_eq && ! strcmp( cond1c->str, current_arch )) )
            {
                /* This is for current architecture */
                cond1b = cond1d->next;
                cond1d->next = NULL;
                free_cond( cond1a );
                return eliminate_other_arch( cond1b );
            }
        }
    }
    if ( cond1a->op == op_variable && ! vartable[cond1a->nameindex].defined )
    {
        cond1b = cond1a->next; if ( cond1b == NULL ) goto done;
        cond1c = cond1b->next; if ( cond1c == NULL ) goto done;
        cond1d = cond1c->next;
 
        if ( cond1c->op == op_constant
        && ( cond1d == NULL || cond1d->op == op_and ) ) /*???*/
        {
            if ( cond1b->op == op_eq && strcmp( cond1c->str, "" ) )
            {
                cond1a->op = op_false;
                cond1a->next = NULL;
                free_cond( cond1b );
                return cond1a;
            }
        }
        else if ( cond1c->op == op_constant && cond1d->op == op_or )
        {
            if ( cond1b->op == op_eq && strcmp( cond1c->str, "" ) )
            {
                cond1b = cond1d->next;
                cond1d->next = NULL;
                free_cond( cond1a );
                return eliminate_other_arch( cond1b );
            }
        }
    }
done:
    return list;
}
 
 
 
/*
 * This is the main transformation function.
 */
void fix_conditionals( struct kconfig * scfg )
{
    struct kconfig * cfg;
 
    /*
     * Transform op_variable to op_kvariable.
     */
    mark_variables( scfg );
 
    /*
     * Walk the statement list, maintaining a stack of current conditions.
     *   token_if      push its condition onto the stack.
     *   token_else    invert the condition on the top of the stack.
     *   token_endif   pop the stack.
     *
     * For a simple statement, create a condition chain by joining together
     * all of the conditions on the stack.
     */
    {
        struct condition * cond_stack [32];
        int depth = 0;
        struct kconfig * prev = NULL;
 
        for ( cfg = scfg; cfg != NULL; cfg = cfg->next )
        {
            int good = 1;
            switch ( cfg->token )
            {
            default:
                break;
 
            case token_if:
                cond_stack [depth++] =
                    remove_bang( eliminate_other_arch( cfg->cond ) );
                cfg->cond = NULL;
                break;
 
            case token_else:
                {
                    /*
                     * Invert the condition chain.
                     *
                     * Be careful to transfrom op_or to op_and1, not op_and.
                     * I will need this later in the code that removes
                     * duplicate conditions.
                     */
                    struct condition * cond;
 
                    for ( cond  = cond_stack [depth-1];
                          cond != NULL;
                          cond  = cond->next )
                    {
                        switch( cond->op )
                        {
                        default:     break;
                        case op_and: cond->op = op_or;   break;
                        case op_or:  cond->op = op_and1; break;
                        case op_neq: cond->op = op_eq;   break;
                        case op_eq:  cond->op = op_neq;  break;
                        case op_true: cond->op = op_false;break;
                        case op_false:cond->op = op_true; break;
                        }
                    }
                }
                break;
 
            case token_fi:
                --depth;
                break;
 
            case token_bool:
            case token_choice_item:
            case token_choice_header:
            case token_comment:
            case token_define_bool:
            case token_define_hex:
            case token_define_int:
            case token_define_string:
            case token_define_tristate:
            case token_endmenu:
            case token_hex:
            case token_int:
            case token_mainmenu_option:
            case token_string:
            case token_tristate:
            case token_unset:
                cfg->cond = join_condition_stack( cond_stack, depth );
                if ( cfg->cond && cfg->cond->op == op_false )
                {
                    good = 0;
                    if ( prev )
                        prev->next = cfg->next;
                    else
                        scfg = cfg->next;
                }
                break;
 
            case token_dep_bool:
            case token_dep_mbool:
            case token_dep_tristate:
                /*
                 * Same as the other simple statements, plus an additional
                 * condition for the dependency.
                 */
                if ( cfg->cond )
                {
                    cond_stack [depth] = eliminate_other_arch( cfg->cond );
                    cfg->cond = join_condition_stack( cond_stack, depth+1 );
                }
                else
                {
                    cfg->cond = join_condition_stack( cond_stack, depth );
                }
                if ( cfg->cond && cfg->cond->op == op_false )
                {
                    good = 0;
                    if ( prev )
                        prev->next = cfg->next;
                    else
                        scfg = cfg->next;
                }
                break;
            }
            if ( good )
                prev = cfg;
        }
    }
}
 
 
 
#if 0
void dump_condition( struct condition *list )
{
    struct condition *tmp;
    for ( tmp = list; tmp; tmp = tmp->next )
    {
        switch (tmp->op)
        {
        default:
            break;
        case op_variable:
            printf( " %s", vartable[tmp->nameindex].name );
            break;
        case op_constant:
            printf( " %s", tmp->str );
            break;
        case op_eq:
            printf( " =" );
            break;
        case op_bang:
            printf( " !" );
            break;
        case op_neq:
            printf( " !=" );
            break;
        case op_and:
        case op_and1:
            printf( " -a" );
            break;
        case op_or:
            printf( " -o" );
            break;
        case op_true:
            printf( " TRUE" );
            break;
        case op_false:
            printf( " FALSE" );
            break;
        case op_lparen:
            printf( " (" );
            break;
        case op_rparen:
            printf( " )" );
            break;
        }
    }
    printf( "\n" );
}
#endif

Browse

Tools

Subversion Repositories mips_enhanced

[/] [mips_enhanced/] [trunk/] [grlib-gpl-1.0.19-b3188/] [bin/] [tkconfig/] [tkcond.c] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	dimamali	`/*`
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			`* 07 July 1999, Andrzej M. Krzysztofowicz <ankry@mif.pg.gda.pl>`
18			`* - kvariables removed; all variables are stored in a single table now`
19			`* - some elimination of options non-valid for current architecture`
20			`* implemented.`
21			`* - negation (!) eliminated from conditions`
22			`*`
23			`* TO DO:`
24			`* - xconfig is at the end of its life cycle. Contact <mec@shout.net> if`
25			`* you are interested in working on the replacement.`
26			`*/`
27
28			`#include <stdio.h>`
29			`#include <stdlib.h>`
30			`#include <string.h>`
31
32			`#include "tkparse.h"`
33
34
35
36			`/*`
37			`* Mark variables which are defined anywhere.`
38			`*/`
39			`static void mark_variables( struct kconfig * scfg )`
40			`{`
41			`struct kconfig * cfg;`
42			`int i;`
43
44			`for ( i = 1; i <= max_varnum; i++ )`
45			`vartable[i].defined = 0;`
46			`for ( cfg = scfg; cfg != NULL; cfg = cfg->next )`
47			`{`
48			`if ( cfg->token == token_bool`
49			`\|\| cfg->token == token_choice_item`
50			`\|\| cfg->token == token_define_bool`
51			`\|\| cfg->token == token_define_hex`
52			`\|\| cfg->token == token_define_int`
53			`\|\| cfg->token == token_define_string`
54			`\|\| cfg->token == token_define_tristate`
55			`\|\| cfg->token == token_dep_bool`
56			`\|\| cfg->token == token_dep_mbool`
57			`\|\| cfg->token == token_dep_tristate`
58			`\|\| cfg->token == token_hex`
59			`\|\| cfg->token == token_int`
60			`\|\| cfg->token == token_string`
61			`\|\| cfg->token == token_tristate`
62			`\|\| cfg->token == token_unset )`
63			`{`
64			`if ( cfg->nameindex > 0 ) /* paranoid */`
65			`{`
66			`vartable[cfg->nameindex].defined = 1;`
67			`}`
68			`}`
69			`}`
70			`}`
71
72
73
74			`static void free_cond( struct condition *cond )`
75			`{`
76			`struct condition tmp, tmp1;`
77			`for ( tmp = cond; tmp; tmp = tmp1 )`
78			`{`
79			`tmp1 = tmp->next;`
80			`free( (void*)tmp );`
81			`}`
82			`}`
83
84
85
86			`/*`
87			`* Remove the bang operator from a condition to avoid priority problems.`
88			`* "!" has different priorities as "test" command argument and in`
89			`* a tk script.`
90			`*/`
91			`static struct condition * remove_bang( struct condition * condition )`
92			`{`
93			`struct condition * conda, * condb, * prev = NULL;`
94
95			`for ( conda = condition; conda; conda = conda->next )`
96			`{`
97			`if ( conda->op == op_bang && conda->next &&`
98			`( condb = conda->next->next ) )`
99			`{`
100			`if ( condb->op == op_eq \|\| condb->op == op_neq )`
101			`{`
102			`condb->op = (condb->op == op_eq) ? op_neq : op_eq;`
103			`conda->op = op_nuked;`
104			`if ( prev )`
105			`{`
106			`prev->next = conda->next;`
107			`}`
108			`else`
109			`{`
110			`condition = conda->next;`
111			`}`
112			`conda->next = NULL;`
113			`free_cond( conda );`
114			`conda = condb;`
115			`}`
116			`}`
117			`prev = conda;`
118			`}`
119			`return condition;`
120			`}`
121
122
123
124			`/*`
125			`* Make a new condition chain by joining the current condition stack with`
126			`* the "&&" operator for glue.`
127			`*/`
128			`static struct condition * join_condition_stack( struct condition * conditions [],`
129			`int depth )`
130			`{`
131			`struct condition * cond_list;`
132			`struct condition * cond_last;`
133			`int i, is_first = 1;`
134
135			`cond_list = cond_last = NULL;`
136
137			`for ( i = 0; i < depth; i++ )`
138			`{`
139			`if ( conditions[i]->op == op_false )`
140			`{`
141			`struct condition * cnew;`
142
143			`/* It is always false condition */`
144			`cnew = malloc( sizeof(*cnew) );`
145			`memset( cnew, 0, sizeof(*cnew) );`
146			`cnew->op = op_false;`
147			`cond_list = cond_last = cnew;`
148			`goto join_done;`
149			`}`
150			`}`
151			`for ( i = 0; i < depth; i++ )`
152			`{`
153			`struct condition * cond;`
154			`struct condition * cnew;`
155			`int add_paren;`
156
157			`/* omit always true conditions */`
158			`if ( conditions[i]->op == op_true )`
159			`continue;`
160
161			`/* if i have another condition, add an '&&' operator */`
162			`if ( !is_first )`
163			`{`
164			`cnew = malloc( sizeof(*cnew) );`
165			`memset( cnew, 0, sizeof(*cnew) );`
166			`cnew->op = op_and;`
167			`cond_last->next = cnew;`
168			`cond_last = cnew;`
169			`}`
170
171			`if ( conditions[i]->op != op_lparen )`
172			`{`
173			`/* add a '(' */`
174			`add_paren = 1;`
175			`cnew = malloc( sizeof(*cnew) );`
176			`memset( cnew, 0, sizeof(*cnew) );`
177			`cnew->op = op_lparen;`
178			`if ( cond_last == NULL )`
179			`{ cond_list = cond_last = cnew; }`
180			`else`
181			`{ cond_last->next = cnew; cond_last = cnew; }`
182			`}`
183			`else`
184			`{`
185			`add_paren = 0;`
186			`}`
187
188			`/* duplicate the chain */`
189			`for ( cond = conditions [i]; cond != NULL; cond = cond->next )`
190			`{`
191			`cnew = malloc( sizeof(*cnew) );`
192			`cnew->next = NULL;`
193			`cnew->op = cond->op;`
194			`cnew->str = cond->str ? strdup( cond->str ) : NULL;`
195			`cnew->nameindex = cond->nameindex;`
196			`if ( cond_last == NULL )`
197			`{ cond_list = cond_last = cnew; }`
198			`else`
199			`{ cond_last->next = cnew; cond_last = cnew; }`
200			`}`
201
202			`if ( add_paren )`
203			`{`
204			`/* add a ')' */`
205			`cnew = malloc( sizeof(*cnew) );`
206			`memset( cnew, 0, sizeof(*cnew) );`
207			`cnew->op = op_rparen;`
208			`cond_last->next = cnew;`
209			`cond_last = cnew;`
210			`}`
211			`is_first = 0;`
212			`}`
213
214			`/*`
215			`* Remove duplicate conditions.`
216			`*/`
217			`{`
218			`struct condition cond1, cond1b, cond1c, cond1d, cond1e, cond1f;`
219
220			`for ( cond1 = cond_list; cond1 != NULL; cond1 = cond1->next )`
221			`{`
222			`if ( cond1->op == op_lparen )`
223			`{`
224			`cond1b = cond1 ->next; if ( cond1b == NULL ) break;`
225			`cond1c = cond1b->next; if ( cond1c == NULL ) break;`
226			`cond1d = cond1c->next; if ( cond1d == NULL ) break;`
227			`cond1e = cond1d->next; if ( cond1e == NULL ) break;`
228			`cond1f = cond1e->next; if ( cond1f == NULL ) break;`
229
230			`if ( cond1b->op == op_variable`
231			`&& ( cond1c->op == op_eq \|\| cond1c->op == op_neq )`
232			`&& cond1d->op == op_constant`
233			`&& cond1e->op == op_rparen )`
234			`{`
235			`struct condition cond2, cond2b, cond2c, cond2d, cond2e, cond2f;`
236
237			`for ( cond2 = cond1f->next; cond2 != NULL; cond2 = cond2->next )`
238			`{`
239			`if ( cond2->op == op_lparen )`
240			`{`
241			`cond2b = cond2 ->next; if ( cond2b == NULL ) break;`
242			`cond2c = cond2b->next; if ( cond2c == NULL ) break;`
243			`cond2d = cond2c->next; if ( cond2d == NULL ) break;`
244			`cond2e = cond2d->next; if ( cond2e == NULL ) break;`
245			`cond2f = cond2e->next;`
246
247			`/* look for match */`
248			`if ( cond2b->op == op_variable`
249			`&& cond2b->nameindex == cond1b->nameindex`
250			`&& cond2c->op == cond1c->op`
251			`&& cond2d->op == op_constant`
252			`&& strcmp( cond2d->str, cond1d->str ) == 0`
253			`&& cond2e->op == op_rparen )`
254			`{`
255			`/* one of these must be followed by && */`
256			`if ( cond1f->op == op_and`
257			`\|\| ( cond2f != NULL && cond2f->op == op_and ) )`
258			`{`
259			`/* nuke the first duplicate */`
260			`cond1 ->op = op_nuked;`
261			`cond1b->op = op_nuked;`
262			`cond1c->op = op_nuked;`
263			`cond1d->op = op_nuked;`
264			`cond1e->op = op_nuked;`
265			`if ( cond1f->op == op_and )`
266			`cond1f->op = op_nuked;`
267			`else`
268			`cond2f->op = op_nuked;`
269			`}`
270			`}`
271			`}`
272			`}`
273			`}`
274			`}`
275			`}`
276			`}`
277
278			`join_done:`
279			`return cond_list;`
280			`}`
281
282
283			`static char arch_sparc[] = "sparc";`
284			`static char * current_arch = arch_sparc;`
285
286			`/*`
287			`* Eliminating conditions with ARCH = <not current>.`
288			`*/`
289			`static struct condition eliminate_other_arch( struct condition list )`
290			`{`
291			`struct condition cond1a = list, cond1b = NULL, cond1c = NULL, cond1d = NULL;`
292			`if ( current_arch == NULL )`
293			`current_arch = getenv( "ARCH" );`
294			`if ( current_arch == NULL )`
295			`{`
296			`fprintf( stderr, "error: ARCH undefined\n" );`
297			`exit( 1 );`
298			`}`
299			`if ( cond1a->op == op_variable`
300			`&& ! strcmp( vartable[cond1a->nameindex].name, "ARCH" ) )`
301			`{`
302			`cond1b = cond1a->next; if ( cond1b == NULL ) goto done;`
303			`cond1c = cond1b->next; if ( cond1c == NULL ) goto done;`
304			`cond1d = cond1c->next;`
305			`if ( cond1c->op == op_constant && cond1d == NULL )`
306			`{`
307			`if ( (cond1b->op == op_eq && strcmp( cond1c->str, current_arch ))`
308			`\|\| (cond1b->op == op_neq && ! strcmp( cond1c->str, current_arch )) )`
309			`{`
310			`/* This is for another architecture */`
311			`cond1a->op = op_false;`
312			`cond1a->next = NULL;`
313			`free_cond( cond1b );`
314			`return cond1a;`
315			`}`
316			`else if ( (cond1b->op == op_neq && strcmp( cond1c->str, current_arch ))`
317			`\|\| (cond1b->op == op_eq && ! strcmp( cond1c->str, current_arch )) )`
318			`{`
319			`/* This is for current architecture */`
320			`cond1a->op = op_true;`
321			`cond1a->next = NULL;`
322			`free_cond( cond1b );`
323			`return cond1a;`
324			`}`
325			`}`
326			`else if ( cond1c->op == op_constant && cond1d->op == op_or )`
327			`{`
328			`if ( (cond1b->op == op_eq && strcmp( cond1c->str, current_arch ))`
329			`\|\| (cond1b->op == op_neq && ! strcmp( cond1c->str, current_arch )) )`
330			`{`
331			`/* This is for another architecture */`
332			`cond1b = cond1d->next;`
333			`cond1d->next = NULL;`
334			`free_cond( cond1a );`
335			`return eliminate_other_arch( cond1b );`
336			`}`
337			`else if ( (cond1b->op == op_neq && strcmp( cond1c->str, current_arch ))`
338			`\|\| (cond1b->op == op_eq && ! strcmp( cond1c->str, current_arch )) )`
339			`{`
340			`/* This is for current architecture */`
341			`cond1a->op = op_true;`
342			`cond1a->next = NULL;`
343			`free_cond( cond1b );`
344			`return cond1a;`
345			`}`
346			`}`
347			`else if ( cond1c->op == op_constant && cond1d->op == op_and )`
348			`{`
349			`if ( (cond1b->op == op_eq && strcmp( cond1c->str, current_arch ))`
350			`\|\| (cond1b->op == op_neq && ! strcmp( cond1c->str, current_arch )) )`
351			`{`
352			`/* This is for another architecture */`
353			`int l_par = 0;`
354
355			`for ( cond1c = cond1d->next; cond1c; cond1c = cond1c->next )`
356			`{`
357			`if ( cond1c->op == op_lparen )`
358			`l_par++;`
359			`else if ( cond1c->op == op_rparen )`
360			`l_par--;`
361			`else if ( cond1c->op == op_or && l_par == 0 )`
362			`/* Expression too complex - don't touch */`
363			`return cond1a;`
364			`else if ( l_par < 0 )`
365			`{`
366			`fprintf( stderr, "incorrect condition: programming error ?\n" );`
367			`exit( 1 );`
368			`}`
369			`}`
370			`cond1a->op = op_false;`
371			`cond1a->next = NULL;`
372			`free_cond( cond1b );`
373			`return cond1a;`
374			`}`
375			`else if ( (cond1b->op == op_neq && strcmp( cond1c->str, current_arch ))`
376			`\|\| (cond1b->op == op_eq && ! strcmp( cond1c->str, current_arch )) )`
377			`{`
378			`/* This is for current architecture */`
379			`cond1b = cond1d->next;`
380			`cond1d->next = NULL;`
381			`free_cond( cond1a );`
382			`return eliminate_other_arch( cond1b );`
383			`}`
384			`}`
385			`}`
386			`if ( cond1a->op == op_variable && ! vartable[cond1a->nameindex].defined )`
387			`{`
388			`cond1b = cond1a->next; if ( cond1b == NULL ) goto done;`
389			`cond1c = cond1b->next; if ( cond1c == NULL ) goto done;`
390			`cond1d = cond1c->next;`
391
392			`if ( cond1c->op == op_constant`
393			`&& ( cond1d == NULL \|\| cond1d->op == op_and ) ) /???/`
394			`{`
395			`if ( cond1b->op == op_eq && strcmp( cond1c->str, "" ) )`
396			`{`
397			`cond1a->op = op_false;`
398			`cond1a->next = NULL;`
399			`free_cond( cond1b );`
400			`return cond1a;`
401			`}`
402			`}`
403			`else if ( cond1c->op == op_constant && cond1d->op == op_or )`
404			`{`
405			`if ( cond1b->op == op_eq && strcmp( cond1c->str, "" ) )`
406			`{`
407			`cond1b = cond1d->next;`
408			`cond1d->next = NULL;`
409			`free_cond( cond1a );`
410			`return eliminate_other_arch( cond1b );`
411			`}`
412			`}`
413			`}`
414			`done:`
415			`return list;`
416			`}`
417
418
419
420			`/*`
421			`* This is the main transformation function.`
422			`*/`
423			`void fix_conditionals( struct kconfig * scfg )`
424			`{`
425			`struct kconfig * cfg;`
426
427			`/*`
428			`* Transform op_variable to op_kvariable.`
429			`*/`
430			`mark_variables( scfg );`
431
432			`/*`
433			`* Walk the statement list, maintaining a stack of current conditions.`
434			`* token_if push its condition onto the stack.`
435			`* token_else invert the condition on the top of the stack.`
436			`* token_endif pop the stack.`
437			`*`
438			`* For a simple statement, create a condition chain by joining together`
439			`* all of the conditions on the stack.`
440			`*/`
441			`{`
442			`struct condition * cond_stack [32];`
443			`int depth = 0;`
444			`struct kconfig * prev = NULL;`
445
446			`for ( cfg = scfg; cfg != NULL; cfg = cfg->next )`
447			`{`
448			`int good = 1;`
449			`switch ( cfg->token )`
450			`{`
451			`default:`
452			`break;`
453
454			`case token_if:`
455			`cond_stack [depth++] =`
456			`remove_bang( eliminate_other_arch( cfg->cond ) );`
457			`cfg->cond = NULL;`
458			`break;`
459
460			`case token_else:`
461			`{`
462			`/*`
463			`* Invert the condition chain.`
464			`*`
465			`* Be careful to transfrom op_or to op_and1, not op_and.`
466			`* I will need this later in the code that removes`
467			`* duplicate conditions.`
468			`*/`
469			`struct condition * cond;`
470
471			`for ( cond = cond_stack [depth-1];`
472			`cond != NULL;`
473			`cond = cond->next )`
474			`{`
475			`switch( cond->op )`
476			`{`
477			`default: break;`
478			`case op_and: cond->op = op_or; break;`
479			`case op_or: cond->op = op_and1; break;`
480			`case op_neq: cond->op = op_eq; break;`
481			`case op_eq: cond->op = op_neq; break;`
482			`case op_true: cond->op = op_false;break;`
483			`case op_false:cond->op = op_true; break;`
484			`}`
485			`}`
486			`}`
487			`break;`
488
489			`case token_fi:`
490			`--depth;`
491			`break;`
492
493			`case token_bool:`
494			`case token_choice_item:`
495			`case token_choice_header:`
496			`case token_comment:`
497			`case token_define_bool:`
498			`case token_define_hex:`
499			`case token_define_int:`
500			`case token_define_string:`
501			`case token_define_tristate:`
502			`case token_endmenu:`
503			`case token_hex:`
504			`case token_int:`
505			`case token_mainmenu_option:`
506			`case token_string:`
507			`case token_tristate:`
508			`case token_unset:`
509			`cfg->cond = join_condition_stack( cond_stack, depth );`
510			`if ( cfg->cond && cfg->cond->op == op_false )`
511			`{`
512			`good = 0;`
513			`if ( prev )`
514			`prev->next = cfg->next;`
515			`else`
516			`scfg = cfg->next;`
517			`}`
518			`break;`
519
520			`case token_dep_bool:`
521			`case token_dep_mbool:`
522			`case token_dep_tristate:`
523			`/*`
524			`* Same as the other simple statements, plus an additional`
525			`* condition for the dependency.`
526			`*/`
527			`if ( cfg->cond )`
528			`{`
529			`cond_stack [depth] = eliminate_other_arch( cfg->cond );`
530			`cfg->cond = join_condition_stack( cond_stack, depth+1 );`
531			`}`
532			`else`
533			`{`
534			`cfg->cond = join_condition_stack( cond_stack, depth );`
535			`}`
536			`if ( cfg->cond && cfg->cond->op == op_false )`
537			`{`
538			`good = 0;`
539			`if ( prev )`
540			`prev->next = cfg->next;`
541			`else`
542			`scfg = cfg->next;`
543			`}`
544			`break;`
545			`}`
546			`if ( good )`
547			`prev = cfg;`
548			`}`
549			`}`
550			`}`
551
552
553
554			`#if 0`
555			`void dump_condition( struct condition *list )`
556			`{`
557			`struct condition *tmp;`
558			`for ( tmp = list; tmp; tmp = tmp->next )`
559			`{`
560			`switch (tmp->op)`
561			`{`
562			`default:`
563			`break;`
564			`case op_variable:`
565			`printf( " %s", vartable[tmp->nameindex].name );`
566			`break;`
567			`case op_constant:`
568			`printf( " %s", tmp->str );`
569			`break;`
570			`case op_eq:`
571			`printf( " =" );`
572			`break;`
573			`case op_bang:`
574			`printf( " !" );`
575			`break;`
576			`case op_neq:`
577			`printf( " !=" );`
578			`break;`
579			`case op_and:`
580			`case op_and1:`
581			`printf( " -a" );`
582			`break;`
583			`case op_or:`
584			`printf( " -o" );`
585			`break;`
586			`case op_true:`
587			`printf( " TRUE" );`
588			`break;`
589			`case op_false:`
590			`printf( " FALSE" );`
591			`break;`
592			`case op_lparen:`
593			`printf( " (" );`
594			`break;`
595			`case op_rparen:`
596			`printf( " )" );`
597			`break;`
598			`}`
599			`}`
600			`printf( "\n" );`
601			`}`
602			`#endif`