scripts/tkparse.c

   1 /*
   2  * tkparse.c
   3  *
   4  * Eric Youngdale was the original author of xconfig.
   5  * Michael Elizabeth Chastain (mec@shout.net) is the current maintainer.
   6  *
   7  * Parse a config.in file and translate it to a wish script.
   8  * This task has three parts:
   9  *
  10  *   tkparse.c  tokenize the input
  11  *   tkcond.c   transform 'if ...' statements
  12  *   tkgen.c    generate output
  13  *
  14  * Change History
  15  *
  16  * 7 January 1999, Michael Elizabeth Chastain, <mec@shout.net>
  17  * - Teach dep_tristate about a few literals, such as:
  18  *     dep_tristate 'foo' CONFIG_FOO m
  19  *   Also have it print an error message and exit on some parse failures.
  20  *
  21  * 14 January 1999, Michael Elizabeth Chastain, <mec@shout.net>
  22  * - Don't fclose stdin.  Thanks to Tony Hoyle for nailing this one.
  23  *
  24  * 14 January 1999, Michael Elizabeth Chastain, <mec@shout.net>
  25  * - Steam-clean this file.  I tested this by generating kconfig.tk for
  26  *   every architecture and comparing it character-for-character against
  27  *   the output of the old tkparse.
  28  *
  29  * 23 January 1999, Michael Elizabeth Chastain, <mec@shout.net>
  30  * - Remove bug-compatible code.
  31  *
  32  * 07 July 1999, Andrzej M. Krzysztofowicz, <ankry@mif.pg.gda.pl>
  33  * - Submenus implemented,
  34  * - plenty of option updating/displaying fixes,
  35  * - dep_bool, define_hex, define_int, define_string, define_tristate and
  36  *   undef implemented,
  37  * - dep_tristate fixed to support multiple dependencies,
  38  * - handling of variables with an empty value implemented,
  39  * - value checking for int and hex fields,
  40  * - more checking during condition parsing; choice variables are treated as
  41  *   all others now,
  42  *
  43  * TO DO:
  44  * - xconfig is at the end of its life cycle.  Contact <mec@shout.net> if
  45  *   you are interested in working on the replacement.
  46  */
  47
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <string.h>
  51
  52 #include "tkparse.h"
  53
  54 static struct kconfig * config_list = NULL;
  55 static struct kconfig * config_last = NULL;
  56 static const char * current_file = "<unknown file>";
  57 static int lineno = 0;
  58
  59 static void do_source( const char * );
  60
  61 #undef strcmp
  62 int my_strcmp( const char * s1, const char * s2 ) { return strcmp( s1, s2 ); }
  63 #define strcmp my_strcmp
  64
  65 /*
  66  * Report a syntax error.
  67  */
  68 static void syntax_error( const char * msg )
  69 {
  70     fprintf( stderr, "%s: %d: %s\n", current_file, lineno, msg );
  71     exit( 1 );
  72 }
  73
  74
  75
  76 /*
  77  * Find index of a specyfic variable in the symbol table.
  78  * Create a new entry if it does not exist yet.
  79  */
  80 #define VARTABLE_SIZE 2048
  81 struct variable vartable[VARTABLE_SIZE];
  82 int max_varnum = 0;
  83
  84 int get_varnum( char * name )
  85 {
  86     int i;
  87
  88     for ( i = 1; i <= max_varnum; i++ )
  89         if ( strcmp( vartable[i].name, name ) == 0 )
  90             return i;
  91     if (max_varnum > VARTABLE_SIZE-1)
  92         syntax_error( "Too many variables defined." );
  93     vartable[++max_varnum].name = malloc( strlen( name )+1 );
  94     strcpy( vartable[max_varnum].name, name );
  95     return max_varnum;
  96 }
  97
  98
  99
 100 /*
 101  * Get a string.
 102  */
 103 static const char * get_string( const char * pnt, char ** label )
 104 {
 105     const char * word;
 106
 107     word = pnt;
 108     for ( ; ; )
 109     {
 110         if ( *pnt == '\0' || *pnt == ' ' || *pnt == '\t' )
 111             break;
 112         pnt++;
 113     }
 114
 115     *label = malloc( pnt - word + 1 );
 116     memcpy( *label, word, pnt - word );
 117     (*label)[pnt - word] = '\0';
 118
 119     if ( *pnt != '\0' )
 120         pnt++;
 121     return pnt;
 122 }
 123
 124
 125
 126 /*
 127  * Get a quoted string.
 128  * Insert a '\' before any characters that need quoting.
 129  */
 130 static const char * get_qstring( const char * pnt, char ** label )
 131 {
 132     char quote_char;
 133     char newlabel [2048];
 134     char * pnt1;
 135
 136     /* advance to the open quote */
 137     for ( ; ; )
 138     {
 139         if ( *pnt == '\0' )
 140             return pnt;
 141         quote_char = *pnt++;
 142         if ( quote_char == '"' || quote_char == '\'' )
 143             break;
 144     }
 145
 146     /* copy into an intermediate buffer */
 147     pnt1 = newlabel;
 148     for ( ; ; )
 149     {
 150         if ( *pnt == '\0' )
 151             syntax_error( "unterminated quoted string" );
 152         if ( *pnt == quote_char && pnt[-1] != '\\' )
 153             break;
 154
 155         /* copy the character, quoting if needed */
 156         if ( *pnt == '"' || *pnt == '\'' || *pnt == '[' || *pnt == ']' )
 157             *pnt1++ = '\\';
 158         *pnt1++ = *pnt++;
 159     }
 160
 161     /* copy the label into a permanent location */
 162     *pnt1++ = '\0';
 163     *label = (char *) malloc( pnt1 - newlabel );
 164     memcpy( *label, newlabel, pnt1 - newlabel );
 165
 166     /* skip over last quote and next whitespace */
 167     pnt++;
 168     while ( *pnt == ' ' || *pnt == '\t' )
 169         pnt++;
 170     return pnt;
 171 }
 172
 173
 174
 175 /*
 176  * Get a quoted or unquoted string. It is recognized by the first
 177  * non-white character. '"' and '"' are not allowed inside the string.
 178  */
 179 static const char * get_qnqstring( const char * pnt, char ** label )
 180 {
 181     char quote_char;
 182
 183     while ( *pnt == ' ' || *pnt == '\t' )
 184         pnt++;
 185
 186     if ( *pnt == '\0' )
 187         return pnt;
 188     quote_char = *pnt;
 189     if ( quote_char == '"' || quote_char == '\'' )
 190         return get_qstring( pnt, label );
 191     else
 192         return get_string( pnt, label );
 193 }
 194
 195
 196
 197 /*
 198  * Tokenize an 'if' statement condition.
 199  */
 200 static struct condition * tokenize_if( const char * pnt )
 201 {
 202     struct condition * list;
 203     struct condition * last;
 204     struct condition * prev;
 205
 206     /* eat the open bracket */
 207     while ( *pnt == ' ' || *pnt == '\t' )
 208         pnt++;
 209     if ( *pnt != '[' )
 210         syntax_error( "bad 'if' condition" );
 211     pnt++;
 212
 213     list = last = NULL;
 214     for ( ; ; )
 215     {
 216         struct condition * cond;
 217
 218         /* advance to the next token */
 219         while ( *pnt == ' ' || *pnt == '\t' )
 220             pnt++;
 221         if ( *pnt == '\0' )
 222             syntax_error( "unterminated 'if' condition" );
 223         if ( *pnt == ']' )
 224             return list;
 225
 226         /* allocate a new token */
 227         cond = malloc( sizeof(*cond) );
 228         memset( cond, 0, sizeof(*cond) );
 229         if ( last == NULL )
 230             { list = last = cond; prev = NULL; }
 231         else
 232             { prev = last; last->next = cond; last = cond; }
 233
 234         /* determine the token value */
 235         if ( *pnt == '-' && pnt[1] == 'a' )
 236         {
 237             if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) )
 238                 syntax_error( "incorrect argument" );
 239             cond->op = op_and;  pnt += 2; continue;
 240         }
 241
 242         if ( *pnt == '-' && pnt[1] == 'o' )
 243         {
 244             if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) )
 245                 syntax_error( "incorrect argument" );
 246             cond->op = op_or;   pnt += 2; continue;
 247         }
 248
 249         if ( *pnt == '!' && pnt[1] == '=' )
 250         {
 251             if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) )
 252                 syntax_error( "incorrect argument" );
 253             cond->op = op_neq;  pnt += 2; continue;
 254         }
 255
 256         if ( *pnt == '=' )
 257         {
 258             if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) )
 259                 syntax_error( "incorrect argument" );
 260             cond->op = op_eq;   pnt += 1; continue;
 261         }
 262
 263         if ( *pnt == '!' )
 264         {
 265             if ( prev && ( prev->op != op_and && prev->op != op_or
 266                       && prev->op != op_bang ) )
 267                 syntax_error( "incorrect argument" );
 268             cond->op = op_bang; pnt += 1; continue;
 269         }
 270
 271         if ( *pnt == '"' )
 272         {
 273             const char * word;
 274
 275             if ( prev && ( prev->op == op_variable || prev->op == op_constant ) )
 276                 syntax_error( "incorrect argument" );
 277             /* advance to the word */
 278             pnt++;
 279             if ( *pnt == '$' )
 280                 { cond->op = op_variable; pnt++; }
 281             else
 282                 { cond->op = op_constant; }
 283
 284             /* find the end of the word */
 285             word = pnt;
 286             for ( ; ; )
 287             {
 288                 if ( *pnt == '\0' )
 289                     syntax_error( "unterminated double quote" );
 290                 if ( *pnt == '"' )
 291                     break;
 292                 pnt++;
 293             }
 294
 295             /* store a copy of this word */
 296             {
 297                 char * str = malloc( pnt - word + 1 );
 298                 memcpy( str, word, pnt - word );
 299                 str [pnt - word] = '\0';
 300                 if ( cond->op == op_variable )
 301                 {
 302                     cond->nameindex = get_varnum( str );
 303                     free( str );
 304                 }
 305                 else /* op_constant */
 306                 {
 307                     cond->str = str;
 308                 }
 309             }
 310
 311             pnt++;
 312             continue;
 313         }
 314
 315         /* unknown token */
 316         syntax_error( "bad if condition" );
 317     }
 318 }
 319
 320
 321
 322 /*
 323  * Tokenize a choice list.  Choices appear as pairs of strings;
 324  * note that I am parsing *inside* the double quotes.  Ugh.
 325  */
 326 static const char * tokenize_choices( struct kconfig * cfg_choose,
 327     const char * pnt )
 328 {
 329     int default_checked = 0;
 330     for ( ; ; )
 331     {
 332         struct kconfig * cfg;
 333         char * buffer = malloc( 64 );
 334
 335         /* skip whitespace */
 336         while ( *pnt == ' ' || *pnt == '\t' )
 337             pnt++;
 338         if ( *pnt == '\0' )
 339             return pnt;
 340
 341         /* allocate a new kconfig line */
 342         cfg = malloc( sizeof(*cfg) );
 343         memset( cfg, 0, sizeof(*cfg) );
 344         if ( config_last == NULL )
 345             { config_last = config_list = cfg; }
 346         else
 347             { config_last->next = cfg; config_last = cfg; }
 348
 349         /* fill out the line */
 350         cfg->token      = token_choice_item;
 351         cfg->cfg_parent = cfg_choose;
 352         pnt = get_string( pnt, &cfg->label );
 353         if ( ! default_checked &&
 354              ! strncmp( cfg->label, cfg_choose->value, strlen( cfg_choose->value ) ) )
 355         {
 356             default_checked = 1;
 357             free( cfg_choose->value );
 358             cfg_choose->value = cfg->label;
 359         }
 360         while ( *pnt == ' ' || *pnt == '\t' )
 361             pnt++;
 362         pnt = get_string( pnt, &buffer );
 363         cfg->nameindex = get_varnum( buffer );
 364     }
 365     if ( ! default_checked )
 366         syntax_error( "bad 'choice' default value" );
 367     return pnt;
 368 }
 369
 370
 371
 372 /*
 373  * Tokenize one line.
 374  */
 375 static void tokenize_line( const char * pnt )
 376 {
 377     static struct kconfig * last_menuoption = NULL;
 378     enum e_token token;
 379     struct kconfig * cfg;
 380     struct dependency ** dep_ptr;
 381     char * buffer = malloc( 64 );
 382
 383     /* skip white space */
 384     while ( *pnt == ' ' || *pnt == '\t' )
 385         pnt++;
 386
 387     /*
 388      * categorize the next token
 389      */
 390
 391 #define match_token(t, s) \
 392     if (strncmp(pnt, s, strlen(s)) == 0) { token = t; pnt += strlen(s); break; }
 393
 394     token = token_UNKNOWN;
 395     switch ( *pnt )
 396     {
 397     default:
 398         break;
 399
 400     case '#':
 401     case '\0':
 402         return;
 403
 404     case 'b':
 405         match_token( token_bool, "bool" );
 406         break;
 407
 408     case 'c':
 409         match_token( token_choice_header, "choice"  );
 410         match_token( token_comment, "comment" );
 411         break;
 412
 413     case 'd':
 414         match_token( token_define_bool, "define_bool" );
 415         match_token( token_define_hex, "define_hex" );
 416         match_token( token_define_int, "define_int" );
 417         match_token( token_define_string, "define_string" );
 418         match_token( token_define_tristate, "define_tristate" );
 419         match_token( token_dep_bool, "dep_bool" );
 420         match_token( token_dep_mbool, "dep_mbool" );
 421         match_token( token_dep_tristate, "dep_tristate" );
 422         break;
 423
 424     case 'e':
 425         match_token( token_else, "else" );
 426         match_token( token_endmenu, "endmenu" );
 427         break;
 428
 429     case 'f':
 430         match_token( token_fi, "fi" );
 431         break;
 432
 433     case 'h':
 434         match_token( token_hex, "hex" );
 435         break;
 436
 437     case 'i':
 438         match_token( token_if, "if" );
 439         match_token( token_int, "int" );
 440         break;
 441
 442     case 'm':
 443         match_token( token_mainmenu_name, "mainmenu_name" );
 444         match_token( token_mainmenu_option, "mainmenu_option" );
 445         break;
 446
 447     case 's':
 448         match_token( token_source, "source" );
 449         match_token( token_string, "string" );
 450         break;
 451
 452     case 't':
 453         match_token( token_then, "then" );
 454         match_token( token_tristate, "tristate" );
 455         break;
 456
 457     case 'u':
 458         match_token( token_unset, "unset" );
 459         break;
 460     }
 461
 462 #undef match_token
 463
 464     if ( token == token_source )
 465     {
 466         while ( *pnt == ' ' || *pnt == '\t' )
 467             pnt++;
 468         do_source( pnt );
 469         return;
 470     }
 471
 472     if ( token == token_then )
 473     {
 474         if ( config_last != NULL && config_last->token == token_if )
 475             return;
 476         syntax_error( "bogus 'then'" );
 477     }
 478
 479 #if 0
 480     if ( token == token_unset )
 481     {
 482         fprintf( stderr, "Ignoring 'unset' command\n" );
 483         return;
 484     }
 485 #endif
 486
 487     if ( token == token_UNKNOWN )
 488         syntax_error( "unknown command" );
 489
 490     /*
 491      * Allocate an item.
 492      */
 493     cfg = malloc( sizeof(*cfg) );
 494     memset( cfg, 0, sizeof(*cfg) );
 495     if ( config_last == NULL )
 496         { config_last = config_list = cfg; }
 497     else
 498         { config_last->next = cfg; config_last = cfg; }
 499
 500     /*
 501      * Tokenize the arguments.
 502      */
 503     while ( *pnt == ' ' || *pnt == '\t' )
 504         pnt++;
 505
 506     cfg->token = token;
 507     switch ( token )
 508     {
 509     default:
 510         syntax_error( "unknown token" );
 511
 512     case token_bool:
 513     case token_tristate:
 514         pnt = get_qstring ( pnt, &cfg->label );
 515         pnt = get_string  ( pnt, &buffer );
 516         cfg->nameindex = get_varnum( buffer );
 517         break;
 518
 519     case token_choice_header:
 520         {
 521             static int choose_number = 0;
 522             char * choice_list;
 523
 524             pnt = get_qstring ( pnt, &cfg->label  );
 525             pnt = get_qstring ( pnt, &choice_list );
 526             pnt = get_string  ( pnt, &cfg->value  );
 527             cfg->nameindex = -(choose_number++);
 528             tokenize_choices( cfg, choice_list );
 529             free( choice_list );
 530         }
 531         break;
 532
 533     case token_comment:
 534         pnt = get_qstring(pnt, &cfg->label);
 535         if ( last_menuoption != NULL )
 536         {
 537             pnt = get_qstring(pnt, &cfg->label);
 538             if (cfg->label == NULL)
 539                 syntax_error( "missing comment text" );
 540             last_menuoption->label = cfg->label;
 541             last_menuoption = NULL;
 542         }
 543         break;
 544
 545     case token_define_bool:
 546     case token_define_tristate:
 547         pnt = get_string( pnt, &buffer );
 548         cfg->nameindex = get_varnum( buffer );
 549         while ( *pnt == ' ' || *pnt == '\t' )
 550             pnt++;
 551         if ( ( pnt[0] == 'Y'  || pnt[0] == 'M' || pnt[0] == 'N'
 552         ||     pnt[0] == 'y'  || pnt[0] == 'm' || pnt[0] == 'n' )
 553         &&   ( pnt[1] == '\0' || pnt[1] == ' ' || pnt[1] == '\t' ) )
 554         {
 555             if      ( *pnt == 'n' || *pnt == 'N' ) cfg->value = strdup( "CONSTANT_N" );
 556             else if ( *pnt == 'y' || *pnt == 'Y' ) cfg->value = strdup( "CONSTANT_Y" );
 557             else if ( *pnt == 'm' || *pnt == 'M' ) cfg->value = strdup( "CONSTANT_M" );
 558         }
 559         else if ( *pnt == '$' )
 560         {
 561             pnt++;
 562             pnt = get_string( pnt, &cfg->value );
 563         }
 564         else
 565         {
 566             syntax_error( "unknown define_bool value" );
 567         }
 568         get_varnum( cfg->value );
 569         break;
 570
 571     case token_define_hex:
 572     case token_define_int:
 573         pnt = get_string( pnt, &buffer );
 574         cfg->nameindex = get_varnum( buffer );
 575         pnt = get_string( pnt, &cfg->value );
 576         break;
 577
 578     case token_define_string:
 579         pnt = get_string( pnt, &buffer );
 580         cfg->nameindex = get_varnum( buffer );
 581         pnt = get_qnqstring( pnt, &cfg->value );
 582         if (cfg->value == NULL)
 583             syntax_error( "missing value" );
 584         break;
 585
 586     case token_dep_bool:
 587     case token_dep_mbool:
 588     case token_dep_tristate:
 589         pnt = get_qstring ( pnt, &cfg->label );
 590         pnt = get_string  ( pnt, &buffer );
 591         cfg->nameindex = get_varnum( buffer );
 592
 593         while ( *pnt == ' ' || *pnt == '\t' )
 594             pnt++;
 595
 596         dep_ptr = &(cfg->depend);
 597
 598         do {
 599             *dep_ptr = (struct dependency *) malloc( sizeof( struct dependency ) );
 600             (*dep_ptr)->next = NULL;
 601
 602             if ( ( pnt[0] == 'Y'  || pnt[0] == 'M' || pnt[0] == 'N'
 603             ||     pnt[0] == 'y'  || pnt[0] == 'm' || pnt[0] == 'n' )
 604             &&   ( pnt[1] == '\0' || pnt[1] == ' ' || pnt[1] == '\t' ) )
 605             {
 606                 /* dep_tristate 'foo' CONFIG_FOO m */
 607                 if      ( pnt[0] == 'Y' || pnt[0] == 'y' )
 608                     (*dep_ptr)->name = strdup( "CONSTANT_Y" );
 609                 else if ( pnt[0] == 'N' || pnt[0] == 'n' )
 610                     (*dep_ptr)->name = strdup( "CONSTANT_N" );
 611                 else
 612                     (*dep_ptr)->name = strdup( "CONSTANT_M" );
 613                 pnt++;
 614                 get_varnum( (*dep_ptr)->name );
 615             }
 616             else if ( *pnt == '$' )
 617             {
 618                 pnt++;
 619                 pnt = get_string( pnt, &(*dep_ptr)->name );
 620                 get_varnum( (*dep_ptr)->name );
 621             }
 622             else
 623             {
 624                 syntax_error( "can't handle dep_bool/dep_mbool/dep_tristate condition" );
 625             }
 626             dep_ptr = &(*dep_ptr)->next;
 627             while ( *pnt == ' ' || *pnt == '\t' )
 628                 pnt++;
 629         } while ( *pnt );
 630
 631         /*
 632          * Create a conditional for this object's dependencies.
 633          */
 634         {
 635             char fake_if [1024];
 636             struct dependency * dep;
 637             struct condition ** cond_ptr;
 638             int first = 1;
 639
 640             cond_ptr = &(cfg->cond);
 641             for ( dep = cfg->depend; dep; dep = dep->next )
 642             {
 643                 if ( token == token_dep_tristate
 644                 && ! strcmp( dep->name, "CONSTANT_M" ) )
 645                 {
 646                     continue;
 647                 }
 648                 if ( first )
 649                 {
 650                     first = 0;
 651                 }
 652                 else
 653                 {
 654                     *cond_ptr = malloc( sizeof(struct condition) );
 655                     memset( *cond_ptr, 0, sizeof(struct condition) );
 656                     (*cond_ptr)->op = op_and;
 657                     cond_ptr = &(*cond_ptr)->next;
 658                 }
 659                 *cond_ptr = malloc( sizeof(struct condition) );
 660                 memset( *cond_ptr, 0, sizeof(struct condition) );
 661                 (*cond_ptr)->op = op_lparen;
 662                 if ( token == token_dep_bool )
 663                     sprintf( fake_if, "[ \"$%s\" = \"y\" -o \"$%s\" = \"\" ]; then",
 664                         dep->name, dep->name );
 665                 else
 666                     sprintf( fake_if, "[ \"$%s\" = \"y\" -o \"$%s\" = \"m\" -o \"$%s\" = \"\" ]; then",
 667                         dep->name, dep->name, dep->name );
 668                 (*cond_ptr)->next = tokenize_if( fake_if );
 669                 while ( *cond_ptr )
 670                     cond_ptr = &(*cond_ptr)->next;
 671                 *cond_ptr = malloc( sizeof(struct condition) );
 672                 memset( *cond_ptr, 0, sizeof(struct condition) );
 673                 (*cond_ptr)->op = op_rparen;
 674                 cond_ptr = &(*cond_ptr)->next;
 675             }
 676         }
 677         break;
 678
 679     case token_else:
 680     case token_endmenu:
 681     case token_fi:
 682         break;
 683
 684     case token_hex:
 685     case token_int:
 686         pnt = get_qstring ( pnt, &cfg->label );
 687         pnt = get_string  ( pnt, &buffer );
 688         cfg->nameindex = get_varnum( buffer );
 689         pnt = get_string  ( pnt, &cfg->value );
 690         break;
 691
 692     case token_string:
 693         pnt = get_qstring ( pnt, &cfg->label );
 694         pnt = get_string  ( pnt, &buffer );
 695         cfg->nameindex = get_varnum( buffer );
 696         pnt = get_qnqstring  ( pnt, &cfg->value );
 697         if (cfg->value == NULL)
 698             syntax_error( "missing initial value" );
 699         break;
 700
 701     case token_if:
 702         cfg->cond = tokenize_if( pnt );
 703         break;
 704
 705     case token_mainmenu_name:
 706         pnt = get_qstring( pnt, &cfg->label );
 707         break;
 708
 709     case token_mainmenu_option:
 710         if ( strncmp( pnt, "next_comment", 12 ) == 0 )
 711             last_menuoption = cfg;
 712         else
 713             pnt = get_qstring( pnt, &cfg->label );
 714         break;
 715
 716     case token_unset:
 717         pnt = get_string( pnt, &buffer );
 718         cfg->nameindex = get_varnum( buffer );
 719         while ( *pnt == ' ' || *pnt == '\t' )
 720             pnt++;
 721         while (*pnt)
 722         {
 723             cfg->next = (struct kconfig *) malloc( sizeof(struct kconfig) );
 724             memset( cfg->next, 0, sizeof(struct kconfig) );
 725             cfg = cfg->next;
 726             cfg->token = token_unset;
 727             pnt = get_string( pnt, &buffer );
 728             cfg->nameindex = get_varnum( buffer );
 729             while ( *pnt == ' ' || *pnt == '\t' )
 730                 pnt++;
 731         }
 732         break;
 733     }
 734     return;
 735 }
 736
 737
 738
 739 /*
 740  * Implement the "source" command.
 741  */
 742 static void do_source( const char * filename )
 743 {
 744     char buffer [2048];
 745     FILE * infile;
 746     const char * old_file;
 747     int old_lineno;
 748     int offset;
 749
 750     /* open the file */
 751     if ( strcmp( filename, "-" ) == 0 )
 752         infile = stdin;
 753     else
 754         infile = fopen( filename, "r" );
 755
 756     /* if that failed, try ../filename */
 757     if ( infile == NULL )
 758     {
 759         sprintf( buffer, "../%s", filename );
 760         infile = fopen( buffer, "r" );
 761     }
 762
 763     if ( infile == NULL )
 764     {
 765         sprintf( buffer, "unable to open %s", filename );
 766         syntax_error( buffer );
 767     }
 768
 769     /* push the new file name and line number */
 770     old_file     = current_file;
 771     old_lineno   = lineno;
 772     current_file = filename;
 773     lineno       = 0;
 774
 775     /* read and process lines */
 776     for ( offset = 0; ; )
 777     {
 778         char * pnt;
 779
 780         /* read a line */
 781         fgets( buffer + offset, sizeof(buffer) - offset, infile );
 782         if ( feof( infile ) )
 783             break;
 784         lineno++;
 785
 786         /* strip the trailing return character */
 787         pnt = buffer + strlen(buffer) - 1;
 788         if ( *pnt == '\n' )
 789             *pnt-- = '\0';
 790
 791         /* eat \ NL pairs */
 792         if ( *pnt == '\\' )
 793         {
 794             offset = pnt - buffer;
 795             continue;
 796         }
 797
 798         /* tokenize this line */
 799         tokenize_line( buffer );
 800         offset = 0;
 801     }
 802
 803     /* that's all, folks */
 804     if ( infile != stdin )
 805         fclose( infile );
 806     current_file = old_file;
 807     lineno       = old_lineno;
 808     return;
 809 }
 810
 811
 812
 813 /*
 814  * Main program.
 815  */
 816 int main( int argc, const char * argv [] )
 817 {
 818     do_source        ( "-"         );
 819     fix_conditionals ( config_list );
 820     dump_tk_script   ( config_list );
 821     return 0;
 822 }