ivlpp/lexor.lex

   1 %{
   2 /*
   3  * Copyright (c) 1999-2008 Stephen Williams (steve@icarus.com)
   4  *
   5  *    This source code is free software; you can redistribute it
   6  *    and/or modify it in source code form under the terms of the GNU
   7  *    General Public License as published by the Free Software
   8  *    Foundation; either version 2 of the License, or (at your option)
   9  *    any later version.
  10  *
  11  *    This program is distributed in the hope that it will be useful,
  12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *    GNU General Public License for more details.
  15  *
  16  *    You should have received a copy of the GNU General Public License
  17  *    along with this program; if not, write to the Free Software
  18  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  19  */
  20
  21 # include "config.h"
  22
  23 # include  <stdio.h>
  24 #ifdef HAVE_MALLOC_H
  25 # include  <malloc.h>
  26 #endif
  27 # include  <stdlib.h>
  28 # include  <string.h>
  29 # include  <ctype.h>
  30 # include  <assert.h>
  31
  32 # include  "globals.h"
  33
  34 static void output_init();
  35 #define YY_USER_INIT output_init()
  36
  37 static void  def_start();
  38 static void  def_add_arg();
  39 static void  def_finish();
  40 static void  def_undefine();
  41 static void  do_define();
  42 static int   def_is_done();
  43 static int   is_defined(const char*name);
  44
  45 static int   macro_needs_args(const char*name);
  46 static void  macro_start_args();
  47 static void  macro_add_to_arg();
  48 static void  macro_finish_arg();
  49 static void  do_expand(int use_args);
  50 static char* macro_name();
  51
  52 static void include_filename();
  53 static void do_include();
  54
  55 static int load_next_input();
  56
  57 struct include_stack_t
  58 {
  59     char* path;
  60
  61     /* If the current input is from a file, this member is set. */
  62     FILE* file;
  63
  64     /* If we are reparsing a macro expansion, file is 0 and this
  65      * member points to the string in progress
  66      */
  67     const char* str;
  68
  69     /* If we are reparsing a macro expansion, this member indicates
  70      * the amount of space it occupies in the macro expansion buffer.
  71      * This will be zero for macros without arguments.
  72      */
  73     int ebs;
  74
  75     int stringify_flag;
  76
  77     unsigned lineno;
  78     YY_BUFFER_STATE yybs;
  79
  80     struct include_stack_t* next;
  81 };
  82
  83 static void emit_pathline(struct include_stack_t* isp);
  84
  85 /*
  86  * The file_queue is a singly-linked list of the files that were
  87  * listed on the command line/file list.
  88  */
  89 static struct include_stack_t* file_queue = 0;
  90
  91 static int do_expand_stringify_flag = 0;
  92
  93 /*
  94  * The istack is the inclusion stack.
  95  */
  96 static struct include_stack_t* istack  = 0;
  97 static struct include_stack_t* standby = 0;
  98
  99 /*
 100  * Keep a stack of active ifdef, so that I can report errors
 101  * when there are missing endifs.
 102  */
 103 struct ifdef_stack_t
 104 {
 105     char*    path;
 106     unsigned lineno;
 107
 108     struct ifdef_stack_t* next;
 109 };
 110
 111 static struct ifdef_stack_t* ifdef_stack = 0;
 112
 113 static void ifdef_enter(void)
 114 {
 115     struct ifdef_stack_t*cur;
 116
 117     cur = (struct ifdef_stack_t*) calloc(1, sizeof(struct ifdef_stack_t));
 118     cur->path = strdup(istack->path);
 119     cur->lineno = istack->lineno;
 120     cur->next = ifdef_stack;
 121
 122     ifdef_stack = cur;
 123 }
 124
 125 static void ifdef_leave(void)
 126 {
 127     struct ifdef_stack_t* cur;
 128
 129     assert(ifdef_stack);
 130
 131     cur = ifdef_stack;
 132     ifdef_stack = cur->next;
 133
 134     if (strcmp(istack->path,cur->path) != 0)
 135     {
 136         fprintf
 137         (
 138             stderr,
 139             "%s:%u: warning: This `endif matches an ifdef in another file.\n",
 140             istack->path,
 141             istack->lineno+1
 142         );
 143
 144         fprintf
 145         (
 146             stderr,
 147             "%s:%u: This is the odd matched `ifdef.\n",
 148             cur->path,
 149             cur->lineno+1
 150         );
 151     }
 152
 153     free(cur->path);
 154     free(cur);
 155 }
 156
 157 #define YY_INPUT(buf,result,max_size) do {                 \
 158     if (istack->file) {                                    \
 159         size_t rc = fread(buf, 1, max_size, istack->file); \
 160         result = (rc == 0) ? YY_NULL : rc;                 \
 161     } else {                                               \
 162         if (*istack->str == 0)                             \
 163             result = YY_NULL;                              \
 164         else {                                             \
 165             buf[0] = *istack->str++;                       \
 166             result = 1;                                    \
 167         }                                                  \
 168     }                                                      \
 169 } while (0)
 170
 171 static int comment_enter = 0;
 172 static int pragma_enter = 0;
 173 static int string_enter = 0;
 174
 175 static int ma_parenthesis_level = 0;
 176 %}
 177
 178 %option stack
 179 %option nounput
 180 %option noinput
 181 %option noyy_top_state
 182 %option noyywrap
 183
 184 %x PPINCLUDE
 185 %x DEF_NAME
 186 %x DEF_ARG
 187 %x DEF_SEP
 188 %x DEF_TXT
 189 %x MA_START
 190 %x MA_ADD
 191 %x CCOMMENT
 192 %x IFCCOMMENT
 193 %x PCOMENT
 194 %x CSTRING
 195 %x ERROR_LINE
 196
 197 %x IFDEF_FALSE
 198 %s IFDEF_TRUE
 199 %x IFDEF_SUPR
 200
 201 W        [ \t\b\f]+
 202
 203 /* The grouping parentheses are necessary for compatibility with
 204  * older versions of flex (at least 2.5.31); they are supposed to
 205  * be implied, according to the flex manual.
 206  */
 207 keywords (include|define|undef|ifdef|ifndef|else|elseif|endif)
 208
 209 %%
 210
 211 "//"[^\r\n]* { ECHO; }
 212
 213  /* detect multiline, c-style comments, passing them directly to the
 214   * output. This is necessary to allow for ignoring directives that
 215   * are included within the comments.
 216   */
 217
 218 "/*"              { comment_enter = YY_START; BEGIN(CCOMMENT); ECHO; }
 219 <CCOMMENT>[^\r\n] { ECHO; }
 220 <CCOMMENT>\n\r    |
 221 <CCOMMENT>\r\n    |
 222 <CCOMMENT>\n      |
 223 <CCOMMENT>\r      { istack->lineno += 1; fputc('\n', yyout); }
 224 <CCOMMENT>"*/"    { BEGIN(comment_enter); ECHO; }
 225
 226  /* Detect and pass multiline pragma comments. As with C-style
 227   * comments, pragma comments are passed through, and preprocessor
 228   * directives contained within are ignored. Contains macros are
 229   * expanded, however.
 230   */
 231 "(*"{W}?")"      { ECHO; }
 232 "(*"             { pragma_enter = YY_START; BEGIN(PCOMENT); ECHO; }
 233 <PCOMENT>[^\r\n] { ECHO; }
 234 <PCOMENT>\n\r    |
 235 <PCOMENT>\r\n    |
 236 <PCOMENT>\n      |
 237 <PCOMENT>\r      { istack->lineno += 1; fputc('\n', yyout); }
 238 <PCOMENT>"*)"    { BEGIN(pragma_enter); ECHO; }
 239
 240 <PCOMENT>`{keywords} {
 241     emit_pathline(istack);
 242     error_count += 1;
 243     fprintf
 244     (
 245         stderr,
 246         "error: macro names cannot be directive keywords ('%s'); replaced with nothing.\n",
 247         yytext
 248     );
 249 }
 250
 251 <PCOMENT>`[a-zA-Z][a-zA-Z0-9_$]* {
 252     if (macro_needs_args(yytext+1)) yy_push_state(MA_START); else do_expand(0);
 253 }
 254
 255  /* Strings do not contain preprocessor directives, but can expand
 256   * macros. If that happens, they get expanded in the context of the
 257   * string.
 258   */
 259 \"            { string_enter = YY_START; BEGIN(CSTRING); ECHO; }
 260 <CSTRING>\\\" |
 261 <CSTRING>\\`  { ECHO; }
 262 <CSTRING>\r\n |
 263 <CSTRING>\n\r |
 264 <CSTRING>\n   |
 265 <CSTRING>\r   { fputc('\n', yyout); }
 266 <CSTRING>\"   { BEGIN(string_enter);  ECHO; }
 267 <CSTRING>.    { ECHO; }
 268
 269  /* This set of patterns matches the include directive and the name
 270   * that follows it. when the directive ends, the do_include function
 271   * performs the include operation.
 272   */
 273 ^{W}?`include { yy_push_state(PPINCLUDE); }
 274
 275 <PPINCLUDE>`{keywords} {
 276     emit_pathline(istack);
 277     error_count += 1;
 278     fprintf
 279     (
 280         stderr,
 281         "error: macro names cannot be directive keywords ('%s'); replaced with nothing.\n",
 282         yytext
 283     );
 284 }
 285
 286 <PPINCLUDE>`[a-zA-Z][a-zA-Z0-9_]* {
 287     if (macro_needs_args(yytext+1)) yy_push_state(MA_START); else do_expand(0);
 288 }
 289
 290 <PPINCLUDE>\"[^\"]*\" { include_filename(); }
 291
 292 <PPINCLUDE>[ \t\b\f] { ; }
 293
 294   /* Catch single-line comments that share the line with an include
 295    * directive. And while I'm at it, I might as well preserve the
 296    * comment in the output stream.
 297    */
 298 <PPINCLUDE>"//"[^\r\n]* { ECHO; }
 299
 300  /* These finish the include directive (EOF or EOL) so I revert the
 301   * lexor state and execute the inclusion.
 302   */
 303
 304  /* There is a bug in flex <= 2.5.34 that prevents the continued action '|'
 305   * from working properly when the final action is associated with <<EOF>>.
 306   * Therefore, the action is repeated. */
 307
 308 <PPINCLUDE>\r\n    |
 309 <PPINCLUDE>\n\r    |
 310 <PPINCLUDE>\n      |
 311 <PPINCLUDE>\r      { istack->lineno += 1; yy_pop_state(); do_include(); }
 312 <PPINCLUDE><<EOF>> { istack->lineno += 1; yy_pop_state(); do_include(); }
 313
 314  /* Anything that is not matched by the above is an error of some
 315   * sort. Print an error message and absorb the rest of the line.
 316   */
 317 <PPINCLUDE>. {
 318     emit_pathline(istack);
 319     fprintf(stderr, "error: malformed `include directive. Did you quote the file name?\n");
 320     error_count += 1;
 321     BEGIN(ERROR_LINE);
 322 }
 323
 324   /* Detect the define directive, and match the name. If followed by a
 325    * '(', collect the formal arguments. Consume any white space, then
 326    * go into DEF_TXT mode and collect the defined value.
 327    */
 328 `define{W} { yy_push_state(DEF_NAME); }
 329
 330 <DEF_NAME>{keywords}{W}? {
 331     emit_pathline(istack);
 332     error_count += 1;
 333     BEGIN(ERROR_LINE);
 334     fprintf
 335     (
 336         stderr,
 337         "error: malformed `define directive: macro names cannot be directive keywords\n"
 338     );
 339 }
 340
 341 <DEF_NAME>[a-zA-Z_][a-zA-Z0-9_$]*"("{W}? { BEGIN(DEF_ARG); def_start(); }
 342 <DEF_NAME>[a-zA-Z_][a-zA-Z0-9_$]*{W}?    { BEGIN(DEF_TXT); def_start(); }
 343
 344 <DEF_ARG>[a-zA-Z_][a-zA-Z0-9_$]*{W}? { BEGIN(DEF_SEP); def_add_arg(); }
 345
 346 <DEF_SEP>","{W}? { BEGIN(DEF_ARG); }
 347 <DEF_SEP>")"{W}? { BEGIN(DEF_TXT); }
 348
 349 <DEF_ARG,DEF_SEP>"//"[^\r\n]* { ECHO; }
 350 <DEF_ARG,DEF_SEP>"/*"         { comment_enter = YY_START; BEGIN(CCOMMENT); ECHO; }
 351 <DEF_ARG,DEF_SEP>{W}          {}
 352
 353 <DEF_ARG,DEF_SEP>(\n|"\r\n"|"\n\r"|\r){W}? { istack->lineno += 1; fputc('\n', yyout); }
 354
 355 <DEF_NAME,DEF_ARG,DEF_SEP>. {
 356     emit_pathline(istack);
 357     fprintf(stderr, "error: malformed `define directive.\n");
 358     error_count += 1;
 359     BEGIN(ERROR_LINE);
 360 }
 361
 362 <DEF_TXT>.*[^\r\n] { do_define(); }
 363
 364 <DEF_TXT>(\n|"\r\n"|"\n\r"|\r) {
 365     if (def_is_done()) {
 366         def_finish();
 367         yy_pop_state();
 368     }
 369
 370     istack->lineno += 1;
 371     fputc('\n', yyout);
 372 }
 373
 374  /* If the define is terminated by an EOF, then finish the define
 375   * whether there was a continuation or not.
 376   */
 377 <DEF_TXT><<EOF>> {
 378     def_finish();
 379
 380     istack->lineno += 1;
 381     fputc('\n', yyout);
 382
 383     yy_pop_state();
 384
 385     if (!load_next_input())
 386         yyterminate();
 387 }
 388
 389 `undef{W}[a-zA-Z_][a-zA-Z0-9_$]*{W}?.* { def_undefine(); }
 390
 391   /* Detect conditional compilation directives, and parse them. If I
 392    * find the name defined, switch to the IFDEF_TRUE state and stay
 393    * there until I get an `else or `endif. Otherwise, switch to the
 394    * IFDEF_FALSE state and start tossing data.
 395    *
 396    * Handle suppressed `ifdef with an additional suppress start
 397    * condition that stacks on top of the IFDEF_FALSE so that output is
 398    * not accidentally turned on within nested ifdefs.
 399    */
 400 `ifdef{W}[a-zA-Z_][a-zA-Z0-9_$]* {
 401     char* name = strchr(yytext, '`'); assert(name);
 402
 403     name += 6;
 404     name += strspn(name, " \t\b\f");
 405
 406     ifdef_enter();
 407
 408     if (is_defined(name))
 409         yy_push_state(IFDEF_TRUE);
 410     else
 411         yy_push_state(IFDEF_FALSE);
 412 }
 413
 414 `ifndef{W}[a-zA-Z_][a-zA-Z0-9_$]* {
 415     char* name = strchr(yytext, '`'); assert(name);
 416
 417     name += 7;
 418     name += strspn(name, " \t\b\f");
 419
 420     ifdef_enter();
 421
 422     if (!is_defined(name))
 423         yy_push_state(IFDEF_TRUE);
 424     else
 425         yy_push_state(IFDEF_FALSE);
 426 }
 427
 428 <IFDEF_FALSE,IFDEF_SUPR>`ifdef{W}  |
 429 <IFDEF_FALSE,IFDEF_SUPR>`ifndef{W} { ifdef_enter(); yy_push_state(IFDEF_SUPR); }
 430
 431 <IFDEF_TRUE>`elsif{W}[a-zA-Z_][a-zA-Z0-9_$]* { BEGIN(IFDEF_SUPR); }
 432
 433 <IFDEF_FALSE>`elsif{W}[a-zA-Z_][a-zA-Z0-9_$]* {
 434     char* name = strchr(yytext, '`'); assert(name);
 435
 436     name += 6;
 437     name += strspn(name, " \t\b\f");
 438
 439     if (is_defined(name))
 440         BEGIN(IFDEF_TRUE);
 441     else
 442         BEGIN(IFDEF_FALSE);
 443 }
 444
 445 <IFDEF_SUPR>`elsif{W}[a-zA-Z_][a-zA-Z0-9_$]* {  }
 446
 447 <IFDEF_TRUE>`else  { BEGIN(IFDEF_SUPR); }
 448 <IFDEF_FALSE>`else { BEGIN(IFDEF_TRUE); }
 449 <IFDEF_SUPR>`else  {}
 450
 451 <IFDEF_FALSE,IFDEF_SUPR>"//"[^\r\n]* {}
 452
 453 <IFDEF_FALSE,IFDEF_SUPR>"/*" { comment_enter = YY_START; BEGIN(IFCCOMMENT); }
 454
 455 <IFCCOMMENT>[^\r\n] {}
 456 <IFCCOMMENT>\n\r    |
 457 <IFCCOMMENT>\r\n    |
 458 <IFCCOMMENT>\n      |
 459 <IFCCOMMENT>\r      { istack->lineno += 1; }
 460 <IFCCOMMENT>"*/"    { BEGIN(comment_enter); }
 461
 462 <IFDEF_FALSE,IFDEF_SUPR>[^\r\n] {  }
 463 <IFDEF_FALSE,IFDEF_SUPR>\n\r    |
 464 <IFDEF_FALSE,IFDEF_SUPR>\r\n    |
 465 <IFDEF_FALSE,IFDEF_SUPR>\n      |
 466 <IFDEF_FALSE,IFDEF_SUPR>\r      { istack->lineno += 1; fputc('\n', yyout); }
 467
 468 <IFDEF_FALSE,IFDEF_TRUE,IFDEF_SUPR>`endif { ifdef_leave(); yy_pop_state(); }
 469
 470 `ifdef {
 471     error_count += 1;
 472     fprintf
 473     (
 474         stderr,
 475         "%s:%u: `ifdef without a macro name - ignored.\n",
 476         istack->path, istack->lineno+1
 477     );
 478 }
 479
 480 `ifndef {
 481     error_count += 1;
 482     fprintf
 483     (
 484         stderr,
 485         "%s:%u: `ifndef without a macro name - ignored.\n",
 486         istack->path, istack->lineno+1
 487     );
 488 }
 489
 490 `elsif {
 491     error_count += 1;
 492     fprintf
 493     (
 494         stderr,
 495         "%s:%u: `elsif without a macro name - ignored.\n",
 496         istack->path, istack->lineno+1
 497     );
 498 }
 499
 500 `elsif{W}[a-zA-Z_][a-zA-Z0-9_$]* {
 501     error_count += 1;
 502     fprintf
 503     (
 504         stderr,
 505         "%s:%u: `elsif without a matching `ifdef - ignored.\n",
 506         istack->path, istack->lineno+1
 507     );
 508 }
 509
 510 `else {
 511     error_count += 1;
 512     fprintf
 513     (
 514         stderr,
 515         "%s:%u: `else without a matching `ifdef - ignored.\n",
 516         istack->path, istack->lineno+1
 517     );
 518 }
 519
 520 `endif {
 521     error_count += 1;
 522     fprintf
 523     (
 524         stderr,
 525         "%s:%u: `endif without a matching `ifdef - ignored.\n",
 526         istack->path, istack->lineno+1
 527     );
 528 }
 529
 530 `{keywords} {
 531     emit_pathline(istack);
 532     error_count += 1;
 533     fprintf
 534     (
 535         stderr,
 536         "error: macro names cannot be directive keywords ('%s'); replaced with nothing.\n",
 537         yytext
 538     );
 539 }
 540
 541  /* This pattern notices macros and arranges for them to be replaced. */
 542 `[a-zA-Z_][a-zA-Z0-9_$]* {
 543     if (macro_needs_args(yytext+1))
 544         yy_push_state(MA_START);
 545     else
 546         do_expand(0);
 547 }
 548
 549   /* Stringified version of macro expansion. */
 550 ``[a-zA-Z_][a-zA-Z0-9_$]* {
 551       assert(do_expand_stringify_flag == 0);
 552       do_expand_stringify_flag = 1;
 553       fputc('"', yyout);
 554       if (macro_needs_args(yytext+2))
 555             yy_push_state(MA_START);
 556       else
 557             do_expand(0);
 558 }
 559
 560 <MA_START>\(  { BEGIN(MA_ADD); macro_start_args(); }
 561
 562 <MA_START>{W} {}
 563
 564 <MA_START>(\n|"\r\n"|"\n\r"|\r){W}? {
 565     istack->lineno += 1;
 566     fputc('\n', yyout);
 567 }
 568
 569 <MA_START>. {
 570     emit_pathline(istack);
 571
 572     fprintf(stderr, "error: missing argument list for `%s.\n", macro_name());
 573     error_count += 1;
 574
 575     yy_pop_state();
 576     yyless(0);
 577 }
 578
 579 <MA_ADD>\"[^\"\n\r]*\" { macro_add_to_arg(0); }
 580
 581 <MA_ADD>\"[^\"\n\r]* {
 582     emit_pathline(istack);
 583
 584     fprintf(stderr, "error: unterminated string.\n");
 585     error_count += 1;
 586
 587     BEGIN(ERROR_LINE);
 588 }
 589
 590 <MA_ADD>'[^\n\r]' { macro_add_to_arg(0); }
 591
 592 <MA_ADD>{W} { macro_add_to_arg(1); }
 593
 594 <MA_ADD>"(" { macro_add_to_arg(0); ma_parenthesis_level++; }
 595
 596 <MA_ADD>"," { macro_finish_arg(); }
 597
 598 <MA_ADD>")" {
 599     if (ma_parenthesis_level > 0) {
 600         macro_add_to_arg(0);
 601         ma_parenthesis_level--;
 602     } else {
 603         macro_finish_arg();
 604         yy_pop_state();
 605         do_expand(1);
 606     }
 607 }
 608
 609 <MA_ADD>(\n|"\r\n"|"\n\r"|\r){W}? {
 610     macro_add_to_arg(1);
 611     istack->lineno += 1;
 612     fputc('\n', yyout);
 613 }
 614
 615 <MA_ADD>. { macro_add_to_arg(0); }
 616
 617 <MA_START,MA_ADD>"//"[^\r\n]* { ECHO; }
 618
 619 <MA_START,MA_ADD>"/*" { comment_enter = YY_START; BEGIN(CCOMMENT); ECHO; }
 620
 621  /* Any text that is not a directive just gets passed through to the
 622   * output. Very easy.
 623   */
 624 [^\r\n] { ECHO; }
 625 \n\r    |
 626 \r\n    |
 627 \n      |
 628 \r      { istack->lineno += 1; fputc('\n', yyout); }
 629
 630  /* Absorb the rest of the line when a broken directive is detected. */
 631 <ERROR_LINE>[^\r\n]* { yy_pop_state(); }
 632
 633 <ERROR_LINE>(\n|"\r\n"|"\n\r"|\r) {
 634     yy_pop_state();
 635     istack->lineno += 1;
 636     fputc('\n', yyout);
 637 }
 638
 639 <<EOF>> { if (!load_next_input()) yyterminate(); }
 640
 641 %%
 642  /* Defined macros are kept in this table for convenient lookup. As
 643   * `define directives are matched (and the do_define() function
 644   * called) the tree is built up to match names with values. If a
 645   * define redefines an existing name, the new value it taken.
 646   */
 647 struct define_t
 648 {
 649     char*   name;
 650     char*   value;
 651     int     keyword; /* keywords don't get rescanned for fresh values. */
 652     int     argc;
 653
 654     struct define_t*    left;
 655     struct define_t*    right;
 656     struct define_t*    up;
 657 };
 658
 659 static struct define_t* def_table = 0;
 660
 661 static struct define_t* def_lookup(const char*name)
 662 {
 663     struct define_t* cur = def_table;
 664
 665     if (cur == 0)
 666         return 0;
 667
 668     assert(cur->up == 0);
 669
 670     while (cur)
 671     {
 672         int cmp = strcmp(name, cur->name);
 673
 674         if (cmp == 0)
 675             return cur;
 676
 677         cur = (cmp < 0) ? cur->left : cur->right;
 678     }
 679
 680     return 0;
 681 }
 682
 683 static int is_defined(const char*name)
 684 {
 685     return def_lookup(name) != 0;
 686 }
 687
 688 /*
 689  * The following variables are used to temporarily hold the name and
 690  * formal arguments of a macro definition as it is being parsed. As
 691  * for C program arguments, def_argc counts the arguments (including
 692  * the macro name), the value returned by def_argv(0) points to the
 693  * macro name, the value returned by def_argv(1) points to the first
 694  * argument, and so on.
 695  *
 696  * These variables are also used for storing the actual arguments when
 697  * a macro is instantiated.
 698  */
 699 #define MAX_DEF_ARG 256 // allows argument IDs to be stored in a single char
 700
 701 #define DEF_BUF_CHUNK 256
 702
 703 static char* def_buf = 0;
 704 static int   def_buf_size = 0;
 705 static int   def_buf_free = 0;
 706
 707 static int   def_argc = 0;
 708 static int   def_argo[MAX_DEF_ARG];  // offset of first character in arg
 709 static int   def_argl[MAX_DEF_ARG];  // length of arg string.
 710
 711 /*
 712  * Return a pointer to the start of argument 'arg'. Returned pointers
 713  * may go stale after a call to def_buf_grow_to_fit.
 714  */
 715 static inline char* def_argv(int arg)
 716 {
 717     return def_buf + def_argo[arg];
 718 }
 719
 720 static void check_for_max_args()
 721 {
 722     if (def_argc == MAX_DEF_ARG)
 723     {
 724         emit_pathline(istack);
 725         fprintf(stderr, "error: too many macro arguments - aborting\n");
 726         exit(1);
 727     }
 728 }
 729
 730 static void def_buf_grow_to_fit(int length)
 731 {
 732     while (length >= def_buf_free)
 733     {
 734         def_buf_size += DEF_BUF_CHUNK;
 735         def_buf_free += DEF_BUF_CHUNK;
 736         def_buf = realloc(def_buf, def_buf_size);
 737         assert(def_buf != 0);
 738     }
 739 }
 740
 741 static void def_start()
 742 {
 743     def_buf_free = def_buf_size;
 744     def_argc = 0;
 745     def_add_arg();
 746 }
 747
 748 static void def_add_arg()
 749 {
 750     int length = yyleng;
 751
 752     check_for_max_args();
 753
 754     /* Remove trailing white space and, if necessary, opening brace. */
 755     while (isspace(yytext[length - 1]))
 756         length--;
 757
 758     if (yytext[length - 1] == '(')
 759         length--;
 760
 761     yytext[length] = 0;
 762
 763     /* Make sure there's room in the buffer for the new argument. */
 764     def_buf_grow_to_fit(length);
 765
 766     /* Store the new argument. */
 767     def_argl[def_argc] = length;
 768     def_argo[def_argc] = def_buf_size - def_buf_free;
 769     strcpy(def_argv(def_argc++), yytext);
 770     def_buf_free -= length + 1;
 771 }
 772
 773 void define_macro(const char* name, const char* value, int keyword, int argc)
 774 {
 775     struct define_t* def;
 776
 777     def = malloc(sizeof(struct define_t));
 778     def->name = strdup(name);
 779     def->value = strdup(value);
 780     def->keyword = keyword;
 781     def->argc = argc;
 782     def->left = 0;
 783     def->right = 0;
 784     def->up = 0;
 785
 786     if (def_table == 0)
 787         def_table = def;
 788     else
 789     {
 790         struct define_t* cur = def_table;
 791
 792         while (1)
 793         {
 794             int cmp = strcmp(def->name, cur->name);
 795
 796             if (cmp == 0)
 797             {
 798                 free(cur->value);
 799                 cur->value = def->value;
 800                 free(def->name);
 801                 free(def);
 802                 break;
 803             }
 804             else if (cmp < 0)
 805             {
 806                 if (cur->left != 0)
 807                     cur = cur->left;
 808                 else
 809                 {
 810                     cur->left = def;
 811                     def->up = cur;
 812                     break;
 813                 }
 814             }
 815             else
 816             {
 817                 if (cur->right != 0)
 818                     cur = cur->right;
 819                 else
 820                 {
 821                     cur->right = def;
 822                     def->up = cur;
 823                     break;
 824                 }
 825             }
 826         }
 827     }
 828 }
 829
 830 /*
 831  * The do_define function accumulates the defined value in these
 832  * variables. When the define is over, the def_finish() function
 833  * executes the define and clears this text. The define_continue_flag
 834  * is set if do_define detects that the definition is to be continued
 835  * on the next line.
 836  */
 837 static char*  define_text = 0;
 838 static size_t define_cnt = 0;
 839
 840 static int define_continue_flag = 0;
 841
 842 /*
 843  * Define a special character code used to mark the insertion point
 844  * for arguments in the macro text. This should be a character that
 845  * will not occur in the Verilog source code.
 846  */
 847 #define ARG_MARK '\a'
 848
 849 #define _STR1(x) #x
 850 #define _STR2(x) _STR1(x)
 851
 852 /*
 853  * Find an argument, but only if it is not directly preceded by something
 854  * that would make it part of another simple identifier ([a-zA-Z0-9_$]).
 855  */
 856 static char *find_arg(char*ptr, char*head, char*arg)
 857 {
 858     char *cp = ptr;
 859
 860     while (1) {
 861         /* Look for a candidate match, just return if none is found. */
 862         cp = strstr(cp, arg);
 863         if (!cp) break;
 864
 865         /* If we are not at the start of the string verify that this
 866          * match is not in the middle of another identifier.
 867          */
 868         if (cp != head &&
 869             (isalnum(*(cp-1)) || *(cp-1) == '_' || *(cp-1) == '$')) {
 870             cp++;
 871             continue;
 872         }
 873
 874         break;
 875     }
 876
 877     return cp;
 878 }
 879
 880 /*
 881  * Collect the definition. Normally, this returns 0. If there is a
 882  * continuation, then return 1 and this function may be called again
 883  * to collect another line of the definition.
 884  */
 885 static void do_define()
 886 {
 887     char* cp;
 888     char* head;
 889     char* tail;
 890     int added_cnt;
 891     int arg;
 892
 893     define_continue_flag = 0;
 894
 895     /* Look for comments in the definition, and remove them. The
 896      * "//" style comments go to the end of the line and terminate
 897      * the definition, but the multi-line comments are simply cut
 898      * out, and the define continues.
 899      */
 900     cp = strchr(yytext, '/');
 901
 902     while (cp && *cp)
 903     {
 904         if (cp[1] == '/') {
 905             *cp = 0;
 906             break;
 907         }
 908
 909         if (cp[1] == '*')
 910         {
 911             tail = strstr(cp+2, "*/");
 912
 913             if (tail == 0)
 914             {
 915                 *cp = 0;
 916                 fprintf
 917                 (
 918                     stderr,
 919                     "%s:%u: Unterminated comment in define\n",
 920                     istack->path, istack->lineno+1
 921                 );
 922                 break;
 923             }
 924
 925             memmove(cp, tail+2, strlen(tail+2)+1);
 926             continue;
 927         }
 928
 929         cp = strchr(cp+1, '/');
 930     }
 931
 932     /* Trim trailing white space. */
 933     cp = yytext + strlen(yytext);
 934     while (cp > yytext)
 935     {
 936         if (!isspace(cp[-1]))
 937             break;
 938
 939         cp -= 1;
 940         *cp = 0;
 941     }
 942
 943     /* Detect the continuation sequence. If I find it, remove it
 944      * and the white space that preceeds it, then replace all that
 945      * with a single newline.
 946      */
 947     if ((cp > yytext) && (cp[-1] == '\\'))
 948     {
 949         cp -= 1;
 950         cp[0] = 0;
 951
 952         while ((cp > yytext) && isspace(cp[-1])) {
 953             cp -= 1;
 954             *cp = 0;
 955         }
 956
 957         *cp++ = '\n';
 958         *cp = 0;
 959
 960         define_continue_flag = 1;
 961     }
 962
 963     /* Accumulate this text into the define_text string. */
 964     define_text = realloc(define_text, define_cnt + (cp-yytext) + 1); assert(define_text != 0);
 965
 966     head = &define_text[define_cnt];
 967     strcpy(head, yytext);
 968
 969     define_cnt += cp-yytext;
 970
 971     tail = &define_text[define_cnt];
 972
 973     /* If the text for a macro with arguments contains occurrences
 974      * of ARG_MARK, issue an error message and suppress the macro.
 975      */
 976     if ((def_argc > 1) && strchr(head, ARG_MARK))
 977     {
 978         emit_pathline(istack);
 979         error_count += 1;
 980         def_argc = 0;
 981
 982         fprintf
 983         (
 984             stderr,
 985             "error: implementation restriction - macro text may not contain a %s character\n",
 986             _STR2(ARG_MARK)
 987         );
 988     }
 989
 990     /* Look for formal argument names in the definition, and replace
 991      * each occurrence with the sequence ARG_MARK,'\ddd' where ddd is
 992      * the  formal argument index number.
 993      */
 994     added_cnt = 0;
 995     for (arg = 1; arg < def_argc; arg++)
 996     {
 997         int argl = def_argl[arg];
 998
 999         cp = find_arg(head, head, def_argv(arg));
1000
1001         while (cp && *cp)
1002         {
1003             added_cnt += 2 - argl;
1004
1005             if (added_cnt > 0)
1006             {
1007                 char* base = define_text;
1008
1009                 define_cnt += added_cnt;
1010                 define_text = realloc(define_text, define_cnt + 1); assert(define_text != 0);
1011
1012                 head = &define_text[head - base];
1013                 tail = &define_text[tail - base];
1014                 cp   = &define_text[cp   - base];
1015
1016                 added_cnt = 0;
1017             }
1018
1019             memmove(cp+2, cp+argl, tail-(cp+argl)+1);
1020
1021             tail += 2 - argl;
1022
1023             *cp++ = ARG_MARK;
1024             *cp++ = arg;
1025             cp = find_arg(cp, head, def_argv(arg));
1026         }
1027     }
1028     define_cnt += added_cnt;
1029 }
1030
1031 /*
1032  * Return true if the definition text is done. This is the opposite of
1033  * the define_continue_flag.
1034  */
1035 static int def_is_done()
1036 {
1037     return !define_continue_flag;
1038 }
1039
1040 /*
1041  * After some number of calls to do_define, this function is called to
1042  * assigned value to the parsed name. If there is no value, then
1043  * assign the string "" (empty string.)
1044  */
1045 static void def_finish()
1046 {
1047     define_continue_flag = 0;
1048
1049     if (def_argc <= 0)
1050         return;
1051
1052     if (!define_text)
1053         define_macro(def_argv(0), "", 0, def_argc);
1054     else
1055     {
1056         define_macro(def_argv(0), define_text, 0, def_argc);
1057
1058         free(define_text);
1059
1060         define_text = 0;
1061         define_cnt = 0;
1062     }
1063
1064     def_argc = 0;
1065 }
1066
1067 static void def_undefine()
1068 {
1069     struct define_t* cur;
1070     struct define_t* tail;
1071
1072     /* def_buf is used to store the macro name. Make sure there is
1073      * enough space.
1074      */
1075     def_buf_grow_to_fit(yyleng);
1076
1077     sscanf(yytext, "`undef %s", def_buf);
1078
1079     cur = def_lookup(def_buf);
1080     if (cur == 0) return;
1081
1082     if (cur->up == 0)
1083     {
1084         if ((cur->left == 0) && (cur->right == 0))
1085             def_table = 0;
1086         else if (cur->left == 0)
1087         {
1088             def_table = cur->right;
1089             if (cur->right)
1090             cur->right->up = 0;
1091         }
1092         else if (cur->right == 0)
1093         {
1094             assert(cur->left);
1095             def_table = cur->left;
1096             def_table->up = 0;
1097         }
1098         else
1099         {
1100             tail = cur->left;
1101             while (tail->right)
1102                 tail = tail->right;
1103
1104             tail->right = cur->right;
1105             tail->right->up = tail;
1106
1107             def_table = cur->left;
1108             def_table->up = 0;
1109         }
1110     }
1111     else if (cur->left == 0)
1112     {
1113         if (cur->up->left == cur)
1114             cur->up->left = cur->right;
1115         else
1116         {
1117             assert(cur->up->right == cur);
1118             cur->up->right = cur->right;
1119         }
1120
1121         if (cur->right)
1122             cur->right->up = cur->up;
1123     }
1124     else if (cur->right == 0)
1125     {
1126         assert(cur->left);
1127
1128         if (cur->up->left == cur)
1129             cur->up->left = cur->left;
1130         else
1131         {
1132             assert(cur->up->right == cur);
1133             cur->up->right = cur->left;
1134         }
1135
1136         cur->left->up = cur->up;
1137     }
1138     else
1139     {
1140         tail = cur->left;
1141
1142         assert(cur->left && cur->right);
1143
1144         while (tail->right)
1145             tail = tail->right;
1146
1147         tail->right = cur->right;
1148         tail->right->up = tail;
1149
1150         if (cur->up->left == cur)
1151             cur->up->left = cur->left;
1152         else
1153         {
1154             assert(cur->up->right == cur);
1155             cur->up->right = cur->left;
1156         }
1157
1158         cur->left->up = cur->up;
1159     }
1160
1161     free(cur->name);
1162     free(cur->value);
1163     free(cur);
1164 }
1165
1166 /*
1167  * When a macro is instantiated in the source, macro_needs_args() is
1168  * used to look up the name and return whether it is a macro that
1169  * takes arguments. A pointer to the macro descriptor is stored in
1170  * cur_macro so that do_expand() doesn't need to look it up again.
1171  */
1172 static struct define_t* cur_macro = 0;
1173
1174 static int macro_needs_args(const char*text)
1175 {
1176     cur_macro = def_lookup(text);
1177
1178     if (cur_macro)
1179         return (cur_macro->argc > 1);
1180     else
1181     {
1182         emit_pathline(istack);
1183         fprintf(stderr, "warning: macro %s undefined (and assumed null) at this point.\n", text);
1184         return 0;
1185     }
1186 }
1187
1188 static char* macro_name()
1189 {
1190     return cur_macro ? cur_macro->name : "";
1191 }
1192
1193 static void macro_start_args()
1194 {
1195     /* The macro name can be found via cur_macro, so create a null
1196      * entry for arg 0. This will be used by macro_finish_arg() to
1197      * calculate the buffer location for arg 1.
1198      */
1199     def_buf_free = def_buf_size - 1;
1200     def_buf[0] = 0;
1201     def_argo[0] = 0;
1202     def_argl[0] = 0;
1203     def_argc = 1;
1204 };
1205
1206 static void macro_add_to_arg(int is_white_space)
1207 {
1208     char* tail;
1209     int   length = yyleng;
1210
1211     check_for_max_args();
1212
1213     /* Replace any run of white space with a single space */
1214     if (is_white_space)
1215     {
1216         yytext[0] = ' ';
1217         yytext[1] = 0;
1218         length = 1;
1219     }
1220
1221     /* Make sure there's room in the buffer for the new argument. */
1222     def_buf_grow_to_fit(length);
1223
1224     /* Store the new text. */
1225     tail = &def_buf[def_buf_size - def_buf_free];
1226     strcpy(tail, yytext);
1227     def_buf_free -= length;
1228 }
1229
1230 static void macro_finish_arg()
1231 {
1232     char* tail = &def_buf[def_buf_size - def_buf_free];
1233
1234     check_for_max_args();
1235
1236     *tail = 0;
1237
1238     def_argo[def_argc] = def_argo[def_argc-1] + def_argl[def_argc-1] + 1;
1239     def_argl[def_argc] = tail - def_argv(def_argc);
1240
1241     def_buf_free -= 1;
1242     def_argc++;
1243 }
1244
1245 /*
1246  * The following variables are used to hold macro expansions that are
1247  * built dynamically using supplied arguments. Buffer space is allocated
1248  * as the macro is expanded, and is only released once the expansion has
1249  * been reparsed. This means that the buffer acts as a stack for nested
1250  * macro expansions.
1251  *
1252  * The expansion buffer is only used for macros with arguments - the
1253  * text for simple macros can be taken directly from the macro table.
1254  */
1255 #define EXP_BUF_CHUNK 256
1256
1257 static char*exp_buf = 0;
1258 static int  exp_buf_size = 0;
1259 static int  exp_buf_free = 0;
1260
1261 static void exp_buf_grow_to_fit(int length)
1262 {
1263     while (length >= exp_buf_free)
1264     {
1265         exp_buf_size += EXP_BUF_CHUNK;
1266         exp_buf_free += EXP_BUF_CHUNK;
1267         exp_buf = realloc(exp_buf, exp_buf_size); assert(exp_buf != 0);
1268     }
1269 }
1270
1271 static void expand_using_args()
1272 {
1273     char* head;
1274     char* tail;
1275     char* dest;
1276     int arg;
1277     int length;
1278
1279     if (def_argc != cur_macro->argc)
1280     {
1281         emit_pathline(istack);
1282         fprintf(stderr, "error: wrong number of arguments for `%s\n", cur_macro->name);
1283         return;
1284     }
1285
1286     head = cur_macro->value;
1287     tail = head;
1288
1289     while (*tail)
1290     {
1291         if (*tail != ARG_MARK)
1292             tail++;
1293         else
1294         {
1295             arg = tail[1]; assert(arg < def_argc);
1296
1297             length = (tail - head) + def_argl[arg];
1298             exp_buf_grow_to_fit(length);
1299
1300             dest = &exp_buf[exp_buf_size - exp_buf_free];
1301             memcpy(dest, head, tail - head);
1302             dest += tail - head;
1303             memcpy(dest, def_argv(arg), def_argl[arg]);
1304
1305             exp_buf_free -= length;
1306
1307             head = tail + 2;
1308             tail = head;
1309         }
1310     }
1311
1312     length = tail - head;
1313     exp_buf_grow_to_fit(length);
1314
1315     dest = &exp_buf[exp_buf_size - exp_buf_free];
1316     memcpy(dest, head, length + 1);
1317
1318     exp_buf_free -= length + 1;
1319 }
1320
1321 /*
1322  * When a macro use is discovered in the source, this function is
1323  * used to emit the substitution in its place.
1324  */
1325 static void do_expand(int use_args)
1326 {
1327     if (cur_macro)
1328     {
1329         struct include_stack_t*isp;
1330         int head = 0;
1331         int tail = 0;
1332
1333         if (cur_macro->keyword)
1334         {
1335             fprintf(yyout, "%s", cur_macro->value);
1336             return;
1337         }
1338
1339         if (use_args)
1340         {
1341             head = exp_buf_size - exp_buf_free;
1342             expand_using_args();
1343             tail = exp_buf_size - exp_buf_free;
1344
1345             if (tail == head)
1346                 return;
1347         }
1348
1349         isp = (struct include_stack_t*) calloc(1, sizeof(struct include_stack_t));
1350
1351         isp->stringify_flag = do_expand_stringify_flag;
1352         do_expand_stringify_flag = 0;
1353         if (use_args)
1354         {
1355             isp->str = &exp_buf[head];
1356             isp->ebs = tail - head;
1357         }
1358         else
1359         {
1360             isp->str = cur_macro->value;
1361             isp->ebs = 0;
1362         }
1363
1364         isp->next = istack;
1365         istack->yybs = YY_CURRENT_BUFFER;
1366         istack = isp;
1367
1368         yy_switch_to_buffer(yy_create_buffer(istack->file, YY_BUF_SIZE));
1369     } else {
1370           if (do_expand_stringify_flag) {
1371                 do_expand_stringify_flag = 0;
1372                 fputc('"', yyout);
1373           }
1374     }
1375 }
1376
1377 /*
1378  * Include file handling works by keeping an include stack of the
1379  * files that are opened and being processed. The first item on the
1380  * stack is the current file being scanned. If I get to an include
1381  * statement,
1382  *
1383  *    open the new file,
1384  *    save the current buffer context,
1385  *    create a new buffer context,
1386  *    and push the new file information.
1387  *
1388  * When the file runs out, it is closed and the buffer is deleted
1389  * If after popping the current file information there is another
1390  * file on the stack, that file's buffer context is restored and
1391  * parsing resumes.
1392  */
1393
1394 static void output_init()
1395 {
1396     if (line_direct_flag)
1397         fprintf(yyout, "`line 1 \"%s\" 0\n", istack->path);
1398 }
1399
1400 static void include_filename()
1401 {
1402     if(standby)
1403     {
1404         emit_pathline(istack);
1405         fprintf
1406         (
1407             stderr,
1408             "error: malformed `include directive. Extra junk on line?\n"
1409         );
1410         exit(1);
1411     }
1412
1413     standby = malloc(sizeof(struct include_stack_t));
1414     standby->path = strdup(yytext+1);
1415     standby->path[strlen(standby->path)-1] = 0;
1416     standby->lineno = 0;
1417 }
1418
1419 static void do_include()
1420 {
1421     /* standby is defined by include_filename() */
1422     if (standby->path[0] == '/')
1423     {
1424         if ((standby->file = fopen(standby->path, "r")))
1425             goto code_that_switches_buffers;
1426     }
1427     else
1428     {
1429         unsigned idx, start = 0;
1430         char path[4096];
1431         char *cp;
1432
1433         /* Add the current path to the start of the include_dir list. */
1434         strcpy(path, istack->path);
1435         cp = strrchr(path, '/');
1436
1437         if (cp == 0)
1438             start = 1;  /* A base file so already in [1] */
1439         else
1440         {
1441             *cp = '\0';
1442
1443             /* We do not need a strdup here since the path is read before
1444              * it is overridden. If the search order is changed add a
1445              * strdup here and a free below.
1446              */
1447             include_dir[0] = path;
1448         }
1449
1450         for (idx = start ;  idx < include_cnt ;  idx += 1)
1451         {
1452             sprintf(path, "%s/%s", include_dir[idx], standby->path);
1453
1454             if ((standby->file = fopen(path, "r")))
1455             {
1456                 standby->path = strdup(path);
1457                 goto code_that_switches_buffers;
1458             }
1459         }
1460     }
1461
1462     fprintf(stderr, "%s:%u: Include file %s not found\n", istack->path, istack->lineno, standby->path);
1463     exit(1);
1464
1465                                     code_that_switches_buffers:
1466
1467     if(depend_file)
1468         fprintf(depend_file, "%s\n", standby->path);
1469
1470     if (line_direct_flag)
1471         fprintf(yyout, "\n`line %u \"%s\" 1\n", istack->lineno+1, standby->path);
1472
1473     standby->next = istack;
1474     standby->stringify_flag = 0;
1475
1476     istack->yybs = YY_CURRENT_BUFFER;
1477     istack = standby;
1478
1479     standby = 0;
1480
1481     yy_switch_to_buffer(yy_create_buffer(istack->file, YY_BUF_SIZE));
1482 }
1483
1484 /* walk the include stack until we find an entry with a valid pathname,
1485  * and print the file and line from that entry for use in an error message.
1486  * The istack entries created by do_expand() for macro expansions do not
1487  * contain pathnames. This finds instead the real file in which the outermost
1488  * macro was used.
1489  */
1490 static void emit_pathline(struct include_stack_t* isp)
1491 {
1492     while(isp && (isp->path == NULL))
1493         isp = isp->next;
1494
1495     assert(isp);
1496
1497     fprintf(stderr, "%s:%u: ", isp->path, isp->lineno+1);
1498 }
1499
1500 static void lexor_done()
1501 {
1502     while (ifdef_stack)
1503     {
1504         struct ifdef_stack_t*cur = ifdef_stack;
1505         ifdef_stack = cur->next;
1506
1507         fprintf
1508         (
1509             stderr,
1510             "%s:%u: error: This `ifdef lacks an `endif.\n",
1511             cur->path, cur->lineno+1
1512         );
1513
1514         free(cur->path);
1515         free(cur);
1516         error_count += 1;
1517     }
1518 }
1519
1520 static int load_next_input()
1521 {
1522     int line_mask_flag = 0;
1523     struct include_stack_t* isp = istack;
1524     istack = isp->next;
1525
1526     /* Delete the current input buffers, and free the cell. */
1527     yy_delete_buffer(YY_CURRENT_BUFFER);
1528
1529     if (isp->file)
1530     {
1531         free(isp->path);
1532         fclose(isp->file);
1533     }
1534     else
1535     {
1536         /* If I am printing line directives and I just finished
1537          * macro substitution, I should terminate the line and
1538          * arrange for a new directive to be printed.
1539          */
1540         if (line_direct_flag && istack && istack->path && isp->lineno)
1541             fprintf(yyout, "\n");
1542         else
1543             line_mask_flag = 1;
1544
1545         exp_buf_free += isp->ebs;
1546     }
1547
1548     if (isp->stringify_flag) {
1549           fputc('"', yyout);
1550     }
1551
1552     free(isp);
1553
1554     /* If I am out of include stack, the main input is
1555      * done. Look for another file to process in the input
1556      * queue. If none are there, give up. Otherwise, open the file
1557      * and continue parsing.
1558      */
1559     if (istack == 0)
1560     {
1561         if (file_queue == 0)
1562         {
1563             lexor_done();
1564             return 0;
1565         }
1566
1567         istack = file_queue;
1568         file_queue = file_queue->next;
1569
1570         istack->next = 0;
1571         istack->lineno = 0;
1572         istack->file = fopen(istack->path, "r");
1573
1574         if (istack->file == 0)
1575         {
1576             perror(istack->path);
1577             error_count += 1;
1578             return 0;
1579         }
1580
1581         if (line_direct_flag)
1582             fprintf(yyout, "\n`line 1 \"%s\" 0\n", istack->path);
1583
1584         if(depend_file)
1585             fprintf(depend_file, "%s\n", istack->path);
1586
1587         yyrestart(istack->file);
1588         return 1;
1589     }
1590
1591     /* Otherwise, resume the input buffer that is the new stack
1592      * top. If I need to print a line directive, do so.
1593      */
1594     yy_switch_to_buffer(istack->yybs);
1595
1596     if (line_direct_flag && istack->path && !line_mask_flag)
1597         fprintf(yyout, "\n`line %u \"%s\" 2\n", istack->lineno+1, istack->path);
1598
1599     return 1;
1600 }
1601
1602 /*
1603  * The dump_precompiled_defines() and load_precompiled_defines()
1604  * functions dump/load macro definitions to/from a file. The defines
1605  * are in the form:
1606  *
1607  *       <name>:<argc>:<len>:<value>
1608  *
1609  * for easy extraction. The value is already precompiled to handle
1610  * macro substitution. The <len> is the number of bytes in the
1611  * <value>. This is necessary because the value may contain arbitrary
1612  * text, including ':' and \n characters.
1613  *
1614  * Each record is terminated by a \n character.
1615  */
1616 static void do_dump_precompiled_defines(FILE* out, struct define_t* table)
1617 {
1618     if (!table->keyword)
1619 #ifdef __MINGW32__  /* MinGW does not know about z. */
1620         fprintf(out, "%s:%d:%d:%s\n", table->name, table->argc, strlen(table->value), table->value);
1621 #else
1622         fprintf(out, "%s:%d:%zd:%s\n", table->name, table->argc, strlen(table->value), table->value);
1623 #endif
1624
1625     if (table->left)
1626         do_dump_precompiled_defines(out, table->left);
1627
1628     if (table->right)
1629         do_dump_precompiled_defines(out, table->right);
1630 }
1631
1632 void dump_precompiled_defines(FILE* out)
1633 {
1634     if (def_table)
1635         do_dump_precompiled_defines(out, def_table);
1636 }
1637
1638 void load_precompiled_defines(FILE* src)
1639 {
1640     char buf[4096];
1641     int ch;
1642
1643     while ((ch = fgetc(src)) != EOF)
1644     {
1645         char* cp = buf;
1646         char* name = 0;
1647         char* value = 0;
1648
1649         int argc = 0;
1650         size_t len = 0;
1651
1652         name = cp;
1653
1654         *cp++ = ch;
1655
1656         while ((ch = fgetc(src)) != EOF && ch != ':')
1657             *cp++ = ch;
1658
1659         if (ch != ':')
1660             return;
1661
1662         /* Terminate the name string. */
1663         *cp++ = 0;
1664
1665         /* Read the argc number */
1666         while (isdigit(ch = fgetc(src)))
1667             argc = 10*argc + ch-'0';
1668
1669         if (ch != ':')
1670             return;
1671
1672         while (isdigit(ch = fgetc(src)))
1673             len = 10*len + ch-'0';
1674
1675         if (ch != ':')
1676             return;
1677
1678         value = cp;
1679
1680         while (len > 0)
1681         {
1682             ch = fgetc(src);
1683             if (ch == EOF)
1684                 return;
1685
1686             *cp++ = ch;
1687             len -= 1;
1688         }
1689
1690         *cp++ = 0;
1691
1692         ch = fgetc(src);
1693         if (ch != '\n')
1694             return;
1695
1696         define_macro(name, value, 0, argc);
1697     }
1698 }
1699
1700 /*
1701  * This function initializes the whole process. The first file is
1702  * opened, and the lexor is initialized. The include stack is cleared
1703  * and ready to go.
1704  */
1705 void reset_lexor(FILE* out, char* paths[])
1706 {
1707     unsigned idx;
1708     struct include_stack_t* isp;
1709     struct include_stack_t* tail = 0;
1710
1711     isp = malloc(sizeof(struct include_stack_t));
1712     isp->next = 0;
1713     isp->path = strdup(paths[0]);
1714     isp->file = fopen(paths[0], "r");
1715     isp->str = 0;
1716     isp->ebs = 0;
1717     isp->lineno = 0;
1718     isp->stringify_flag = 0;
1719
1720     if (isp->file == 0)
1721     {
1722         perror(paths[0]);
1723         exit(1);
1724     }
1725
1726     if(depend_file)
1727           fprintf(depend_file, "%s\n", paths[0]);
1728
1729     yyout = out;
1730
1731     yyrestart(isp->file);
1732
1733     assert(istack == 0);
1734     istack = isp;
1735
1736     /* Now build up a queue of all the remaining file names, so
1737      * that load_next_input() can pull them when needed.
1738      */
1739     for (idx = 1 ; paths[idx] ; idx += 1)
1740     {
1741         isp = malloc(sizeof(struct include_stack_t));
1742         isp->path = strdup(paths[idx]);
1743         isp->file = 0;
1744         isp->str = 0;
1745         isp->ebs = 0;
1746         isp->next = 0;
1747         isp->lineno = 0;
1748         isp->stringify_flag = 0;
1749
1750         if (tail)
1751             tail->next = isp;
1752         else
1753             file_queue = isp;
1754
1755         tail = isp;
1756     }
1757 }