Subversion Repositories mips_enhanced

/*

 * tkparse.c

 *

 * Eric Youngdale was the original author of xconfig.

 * Michael Elizabeth Chastain (mec@shout.net) is the current maintainer.

 *

 * Parse a config.in file and translate it to a wish script.

 * This task has three parts:

 *

 *   tkparse.c  tokenize the input

 *   tkcond.c   transform 'if ...' statements

 *   tkgen.c    generate output

 *

 * Change History

 *

 * 7 January 1999, Michael Elizabeth Chastain, <mec@shout.net>

 * - Teach dep_tristate about a few literals, such as:

 *     dep_tristate 'foo' CONFIG_FOO m

 *   Also have it print an error message and exit on some parse failures.

 *

 * 14 January 1999, Michael Elizabeth Chastain, <mec@shout.net>

 * - Don't fclose stdin.  Thanks to Tony Hoyle for nailing this one.

 *

 * 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.

 *

 * 23 January 1999, Michael Elizabeth Chastain, <mec@shout.net>

 * - Remove bug-compatible code.

 *

 * 07 July 1999, Andrzej M. Krzysztofowicz, <ankry@mif.pg.gda.pl>

 * - Submenus implemented,

 * - plenty of option updating/displaying fixes,

 * - dep_bool, define_hex, define_int, define_string, define_tristate and

 *   undef implemented,

 * - dep_tristate fixed to support multiple dependencies,

 * - handling of variables with an empty value implemented,

 * - value checking for int and hex fields,

 * - more checking during condition parsing; choice variables are treated as

 *   all others now,

 *

 * 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"

static struct kconfig * config_list = NULL;

static struct kconfig * config_last = NULL;

static const char * current_file = "<unknown file>";

static int lineno = 0;

static void do_source( const char * );

#undef strcmp

int my_strcmp( const char * s1, const char * s2 ) { return strcmp( s1, s2 ); }

#define strcmp my_strcmp

/*

 * Report a syntax error.

 */

static void syntax_error( const char * msg )

{

    fprintf( stderr, "%s: %d: %s\n", current_file, lineno, msg );

    exit( 1 );

}

/*

 * Find index of a specyfic variable in the symbol table.

 * Create a new entry if it does not exist yet.

 */

#define VARTABLE_SIZE 2048

struct variable vartable[VARTABLE_SIZE];

int max_varnum = 0;

int get_varnum( char * name )

{

    int i;

    for ( i = 1; i <= max_varnum; i++ )

        if ( strcmp( vartable[i].name, name ) == 0 )

            return i;

    if (max_varnum > VARTABLE_SIZE-1)

        syntax_error( "Too many variables defined." );

    vartable[++max_varnum].name = malloc( strlen( name )+1 );

    strcpy( vartable[max_varnum].name, name );

    return max_varnum;

}

/*

 * Get a string.

 */

static const char * get_string( const char * pnt, char ** label )

{

    const char * word;

    word = pnt;

    for ( ; ; )

    {

        if ( *pnt == '\0' || *pnt == ' ' || *pnt == '\t' )

            break;

        pnt++;

    }

    *label = malloc( pnt - word + 1 );

    memcpy( *label, word, pnt - word );

    (*label)[pnt - word] = '\0';

    if ( *pnt != '\0' )

        pnt++;

    return pnt;

}

/*

 * Get a quoted string.

 * Insert a '\' before any characters that need quoting.

 */

static const char * get_qstring( const char * pnt, char ** label )

{

    char quote_char;

    char newlabel [2048];

    char * pnt1;

    /* advance to the open quote */

    for ( ; ; )

    {

        if ( *pnt == '\0' )

            return pnt;

        quote_char = *pnt++;

        if ( quote_char == '"' || quote_char == '\'' )

            break;

    }

    /* copy into an intermediate buffer */

    pnt1 = newlabel;

    for ( ; ; )

    {

        if ( *pnt == '\0' )

            syntax_error( "unterminated quoted string" );

        if ( *pnt == quote_char && pnt[-1] != '\\' )

            break;

        /* copy the character, quoting if needed */

        if ( *pnt == '"' || *pnt == '\'' || *pnt == '[' || *pnt == ']' )

            *pnt1++ = '\\';

        *pnt1++ = *pnt++;

    }

    /* copy the label into a permanent location */

    *pnt1++ = '\0';

    *label = (char *) malloc( pnt1 - newlabel );

    memcpy( *label, newlabel, pnt1 - newlabel );

    /* skip over last quote and next whitespace */

    pnt++;

    while ( *pnt == ' ' || *pnt == '\t' )

        pnt++;

    return pnt;

}

/*

 * Get a quoted or unquoted string. It is recognized by the first

 * non-white character. '"' and '"' are not allowed inside the string.

 */

static const char * get_qnqstring( const char * pnt, char ** label )

{

    char quote_char;

    while ( *pnt == ' ' || *pnt == '\t' )

        pnt++;

    if ( *pnt == '\0' )

        return pnt;

    quote_char = *pnt;

    if ( quote_char == '"' || quote_char == '\'' )

        return get_qstring( pnt, label );

    else

        return get_string( pnt, label );

}

/*

 * Tokenize an 'if' statement condition.

 */

static struct condition * tokenize_if( const char * pnt )

{

    struct condition * list;

    struct condition * last;

    struct condition * prev;

    /* eat the open bracket */

    while ( *pnt == ' ' || *pnt == '\t' )

        pnt++;

    if ( *pnt != '[' )

        syntax_error( "bad 'if' condition" );

    pnt++;

    list = last = NULL;

    for ( ; ; )

    {

        struct condition * cond;

        /* advance to the next token */

        while ( *pnt == ' ' || *pnt == '\t' )

            pnt++;

        if ( *pnt == '\0' )

            syntax_error( "unterminated 'if' condition" );

        if ( *pnt == ']' )

            return list;

        /* allocate a new token */

        cond = malloc( sizeof(*cond) );

        memset( cond, 0, sizeof(*cond) );

        if ( last == NULL )

            { list = last = cond; prev = NULL; }

        else

            { prev = last; last->next = cond; last = cond; }

        /* determine the token value */

        if ( *pnt == '-' && pnt[1] == 'a' )

        {

            if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) )

                syntax_error( "incorrect argument" );

            cond->op = op_and;  pnt += 2; continue;

        }

        if ( *pnt == '-' && pnt[1] == 'o' )

        {

            if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) )

                syntax_error( "incorrect argument" );

            cond->op = op_or;   pnt += 2; continue;

        }

        if ( *pnt == '!' && pnt[1] == '=' )

        {

            if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) )

                syntax_error( "incorrect argument" );

            cond->op = op_neq;  pnt += 2; continue;

        }

        if ( *pnt == '=' )

        {

            if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) )

                syntax_error( "incorrect argument" );

            cond->op = op_eq;   pnt += 1; continue;

        }

        if ( *pnt == '!' )

        {

            if ( prev && ( prev->op != op_and && prev->op != op_or

                      && prev->op != op_bang ) )

                syntax_error( "incorrect argument" );

            cond->op = op_bang; pnt += 1; continue;

        }

        if ( *pnt == '"' )

        {

            const char * word;

            if ( prev && ( prev->op == op_variable || prev->op == op_constant ) )

                syntax_error( "incorrect argument" );

            /* advance to the word */

            pnt++;

            if ( *pnt == '$' )

                { cond->op = op_variable; pnt++; }

            else

                { cond->op = op_constant; }

            /* find the end of the word */

            word = pnt;

            for ( ; ; )

            {

                if ( *pnt == '\0' )

                    syntax_error( "unterminated double quote" );

                if ( *pnt == '"' )

                    break;

                pnt++;

            }

            /* store a copy of this word */

            {

                char * str = malloc( pnt - word + 1 );

                memcpy( str, word, pnt - word );

                str [pnt - word] = '\0';

                if ( cond->op == op_variable )

                {

                    cond->nameindex = get_varnum( str );

                    free( str );

                }

                else /* op_constant */

                {

                    cond->str = str;

                }

            }

            pnt++;

            continue;

        }

        /* unknown token */

        syntax_error( "bad if condition" );

    }

}

/*

 * Tokenize a choice list.  Choices appear as pairs of strings;

 * note that I am parsing *inside* the double quotes.  Ugh.

 */

static const char * tokenize_choices( struct kconfig * cfg_choose,

    const char * pnt )

{

    int default_checked = 0;

    for ( ; ; )

    {

        struct kconfig * cfg;

        char * buffer = malloc( 64 );

        /* skip whitespace */

        while ( *pnt == ' ' || *pnt == '\t' )

            pnt++;

        if ( *pnt == '\0' )

            return pnt;

        /* allocate a new kconfig line */

        cfg = malloc( sizeof(*cfg) );

        memset( cfg, 0, sizeof(*cfg) );

        if ( config_last == NULL )

            { config_last = config_list = cfg; }

        else

            { config_last->next = cfg; config_last = cfg; }

        /* fill out the line */

        cfg->token      = token_choice_item;

        cfg->cfg_parent = cfg_choose;

        pnt = get_string( pnt, &cfg->label );

        if ( ! default_checked &&

             ! strncmp( cfg->label, cfg_choose->value, strlen( cfg_choose->value ) ) )

        {

            default_checked = 1;

            free( cfg_choose->value );

            cfg_choose->value = cfg->label;

        }

        while ( *pnt == ' ' || *pnt == '\t' )

            pnt++;

        pnt = get_string( pnt, &buffer );

        cfg->nameindex = get_varnum( buffer );

    }

    if ( ! default_checked )

        syntax_error( "bad 'choice' default value" );

    return pnt;

}

/*

 * Tokenize one line.

 */

static void tokenize_line( const char * pnt )

{

    static struct kconfig * last_menuoption = NULL;

    enum e_token token;

    struct kconfig * cfg;

    struct dependency ** dep_ptr;

    char * buffer = malloc( 64 );

    /* skip white space */

    while ( *pnt == ' ' || *pnt == '\t' )

        pnt++;

    /*

     * categorize the next token

     */

#define match_token(t, s) \

    if (strncmp(pnt, s, strlen(s)) == 0) { token = t; pnt += strlen(s); break; }

    token = token_UNKNOWN;

    switch ( *pnt )

    {

    default:

        break;

    case '#':

    case '\0':

        return;

    case 'b':

        match_token( token_bool, "bool" );

        break;

    case 'c':

        match_token( token_choice_header, "choice"  );

        match_token( token_comment, "comment" );

        break;

    case 'd':

        match_token( token_define_bool, "define_bool" );

        match_token( token_define_hex, "define_hex" );

        match_token( token_define_int, "define_int" );

        match_token( token_define_string, "define_string" );

        match_token( token_define_tristate, "define_tristate" );

        match_token( token_dep_bool, "dep_bool" );

        match_token( token_dep_mbool, "dep_mbool" );

        match_token( token_dep_tristate, "dep_tristate" );

        break;

    case 'e':

        match_token( token_else, "else" );

        match_token( token_endmenu, "endmenu" );

        break;

    case 'f':

        match_token( token_fi, "fi" );

        break;

    case 'h':

        match_token( token_hex, "hex" );

        break;

    case 'i':

        match_token( token_if, "if" );

        match_token( token_int, "int" );

        break;

    case 'm':

        match_token( token_mainmenu_name, "mainmenu_name" );

        match_token( token_mainmenu_option, "mainmenu_option" );

        break;

    case 's':

        match_token( token_source, "source" );

        match_token( token_string, "string" );

        break;

    case 't':

        match_token( token_then, "then" );

        match_token( token_tristate, "tristate" );

        break;

    case 'u':

        match_token( token_unset, "unset" );

        break;

    }

#undef match_token

    if ( token == token_source )

    {

        while ( *pnt == ' ' || *pnt == '\t' )

            pnt++;

        do_source( pnt );

        return;

    }

    if ( token == token_then )

    {

        if ( config_last != NULL && config_last->token == token_if )

            return;

        syntax_error( "bogus 'then'" );

    }

#if 0

    if ( token == token_unset )

    {

        fprintf( stderr, "Ignoring 'unset' command\n" );

        return;

    }

#endif

    if ( token == token_UNKNOWN )

        syntax_error( "unknown command" );

    /*

     * Allocate an item.

     */

    cfg = malloc( sizeof(*cfg) );

    memset( cfg, 0, sizeof(*cfg) );

    if ( config_last == NULL )

        { config_last = config_list = cfg; }

    else

        { config_last->next = cfg; config_last = cfg; }

    /*

     * Tokenize the arguments.

     */

    while ( *pnt == ' ' || *pnt == '\t' )

        pnt++;

    cfg->token = token;

    switch ( token )

    {

    default:

        syntax_error( "unknown token" );

    case token_bool:

    case token_tristate:

        pnt = get_qstring ( pnt, &cfg->label );

        pnt = get_string  ( pnt, &buffer );

        cfg->nameindex = get_varnum( buffer );

        break;

    case token_choice_header:

        {

            static int choose_number = 0;

            char * choice_list;

            pnt = get_qstring ( pnt, &cfg->label  );

            pnt = get_qstring ( pnt, &choice_list );

            pnt = get_string  ( pnt, &cfg->value  );

            cfg->nameindex = -(choose_number++);

            tokenize_choices( cfg, choice_list );

            free( choice_list );

        }

        break;

    case token_comment:

        pnt = get_qstring(pnt, &cfg->label);

        if ( last_menuoption != NULL )

        {

            pnt = get_qstring(pnt, &cfg->label);

            if (cfg->label == NULL)

                syntax_error( "missing comment text" );

            last_menuoption->label = cfg->label;

            last_menuoption = NULL;

        }

        break;

    case token_define_bool:

    case token_define_tristate:

        pnt = get_string( pnt, &buffer );

        cfg->nameindex = get_varnum( buffer );

        while ( *pnt == ' ' || *pnt == '\t' )

            pnt++;

        if ( ( pnt[0] == 'Y'  || pnt[0] == 'M' || pnt[0] == 'N'

        ||     pnt[0] == 'y'  || pnt[0] == 'm' || pnt[0] == 'n' )

        &&   ( pnt[1] == '\0' || pnt[1] == ' ' || pnt[1] == '\t' ) )

        {

            if      ( *pnt == 'n' || *pnt == 'N' ) cfg->value = strdup( "CONSTANT_N" );

            else if ( *pnt == 'y' || *pnt == 'Y' ) cfg->value = strdup( "CONSTANT_Y" );

            else if ( *pnt == 'm' || *pnt == 'M' ) cfg->value = strdup( "CONSTANT_M" );

        }

        else if ( *pnt == '$' )

        {

            pnt++;

            pnt = get_string( pnt, &cfg->value );

        }

        else

        {

            syntax_error( "unknown define_bool value" );

        }

        get_varnum( cfg->value );

        break;

    case token_define_hex:

    case token_define_int:

        pnt = get_string( pnt, &buffer );

        cfg->nameindex = get_varnum( buffer );

        pnt = get_string( pnt, &cfg->value );

        break;

    case token_define_string:

        pnt = get_string( pnt, &buffer );

        cfg->nameindex = get_varnum( buffer );

        pnt = get_qnqstring( pnt, &cfg->value );

        if (cfg->value == NULL)

            syntax_error( "missing value" );

        break;

    case token_dep_bool:

    case token_dep_mbool:

    case token_dep_tristate:

        pnt = get_qstring ( pnt, &cfg->label );

        pnt = get_string  ( pnt, &buffer );

        cfg->nameindex = get_varnum( buffer );

        while ( *pnt == ' ' || *pnt == '\t' )

            pnt++;

        dep_ptr = &(cfg->depend);

        do {

            *dep_ptr = (struct dependency *) malloc( sizeof( struct dependency ) );

            (*dep_ptr)->next = NULL;

            if ( ( pnt[0] == 'Y'  || pnt[0] == 'M' || pnt[0] == 'N'

            ||     pnt[0] == 'y'  || pnt[0] == 'm' || pnt[0] == 'n' )

            &&   ( pnt[1] == '\0' || pnt[1] == ' ' || pnt[1] == '\t' ) )

            {

                /* dep_tristate 'foo' CONFIG_FOO m */

                if      ( pnt[0] == 'Y' || pnt[0] == 'y' )

                    (*dep_ptr)->name = strdup( "CONSTANT_Y" );

                else if ( pnt[0] == 'N' || pnt[0] == 'n' )

                    (*dep_ptr)->name = strdup( "CONSTANT_N" );

                else

                    (*dep_ptr)->name = strdup( "CONSTANT_M" );

                pnt++;

                get_varnum( (*dep_ptr)->name );

            }

            else if ( *pnt == '$' )

            {

                pnt++;

                pnt = get_string( pnt, &(*dep_ptr)->name );

                get_varnum( (*dep_ptr)->name );

            }

            else

            {

                syntax_error( "can't handle dep_bool/dep_mbool/dep_tristate condition" );

            }

            dep_ptr = &(*dep_ptr)->next;

            while ( *pnt == ' ' || *pnt == '\t' )

                pnt++;

        } while ( *pnt );

        /*

         * Create a conditional for this object's dependencies.

         */

        {

            char fake_if [1024];

            struct dependency * dep;

            struct condition ** cond_ptr;

            int first = 1;

            cond_ptr = &(cfg->cond);

            for ( dep = cfg->depend; dep; dep = dep->next )