gcc/cpplib.c

   1 /* CPP Library.
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000 Free Software Foundation, Inc.
   4    Contributed by Per Bothner, 1994-95.
   5    Based on CCCP program by Paul Rubin, June 1986
   6    Adapted to ANSI C, Richard Stallman, Jan 1987
   7
   8 This program is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 2, or (at your option) any
  11 later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24
  25 #include "cpplib.h"
  26 #include "cpphash.h"
  27 #include "intl.h"
  28 #include "symcat.h"
  29
  30 /* `struct directive' defines one #-directive, including how to handle it.  */
  31
  32 struct directive
  33 {
  34   directive_handler func;       /* Function to handle directive.  */
  35   const U_CHAR *name;           /* Name of directive.  */
  36   unsigned short length;        /* Length of name.  */
  37   unsigned short flags;         /* Flags describing this directive.  */
  38 };
  39
  40 /* Stack of conditionals currently in progress
  41    (including both successful and failing conditionals).  */
  42
  43 struct if_stack
  44 {
  45   struct if_stack *next;
  46   int lineno;                   /* line number where condition started */
  47   int if_succeeded;             /* truth of last condition in this group */
  48   const U_CHAR *control_macro;  /* macro name for #ifndef around entire file */
  49   int type;                     /* type of last directive seen in this group */
  50 };
  51 typedef struct if_stack IF_STACK;
  52
  53 /* Forward declarations.  */
  54
  55 static void validate_else               PARAMS ((cpp_reader *, const U_CHAR *));
  56 static int parse_ifdef                  PARAMS ((cpp_reader *, const U_CHAR *));
  57 static unsigned int parse_include       PARAMS ((cpp_reader *, const U_CHAR *));
  58 static int conditional_skip             PARAMS ((cpp_reader *, int, int,
  59                                                  U_CHAR *));
  60 static int skip_if_group                PARAMS ((cpp_reader *));
  61 static void pass_thru_directive         PARAMS ((const U_CHAR *, size_t,
  62                                                  cpp_reader *, int));
  63 static int read_line_number             PARAMS ((cpp_reader *, int *));
  64 static U_CHAR *detect_if_not_defined    PARAMS ((cpp_reader *));
  65 static int consider_directive_while_skipping
  66                                         PARAMS ((cpp_reader *, IF_STACK *));
  67
  68 /* Values for the flags field of the table below.  KANDR and COND
  69    directives come from traditional (K&R) C.  The difference is, if we
  70    care about it while skipping a failed conditional block, its origin
  71    is COND.  STDC89 directives come from the 1989 C standard.
  72    EXTENSION directives are extensions, with origins noted below.  */
  73
  74 #define KANDR       0
  75 #define COND        1
  76 #define STDC89      2
  77 #define EXTENSION   3
  78
  79 #define ORIGIN_MASK 3
  80 #define ORIGIN(f) ((f) & ORIGIN_MASK)
  81 #define TRAD_DIRECT_P(f) (ORIGIN (f) == KANDR || ORIGIN (f) == COND)
  82
  83 /* This is the table of directive handlers.  It is ordered by
  84    frequency of occurrence; the numbers at the end are directive
  85    counts from all the source code I have lying around (egcs and libc
  86    CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
  87    pcmcia-cs-3.0.9).
  88
  89    The entries with a dash and a name after the count are extensions,
  90    of which all but #warning and #include_next are deprecated.  The name
  91    is where the extension appears to have come from.  */
  92
  93 /* #sccs is not always recognized.  */
  94 #ifdef SCCS_DIRECTIVE
  95 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION)          /*     0 - SVR2? */
  96 #else
  97 # define SCCS_ENTRY /* nothing */
  98 #endif
  99
 100 #define DIRECTIVE_TABLE                                                  \
 101 D(define,       T_DEFINE = 0,   KANDR)                     /* 270554 */ \
 102 D(include,      T_INCLUDE,      KANDR | SYNTAX_INCLUDE)    /*  52262 */ \
 103 D(endif,        T_ENDIF,        COND)                      /*  45855 */ \
 104 D(ifdef,        T_IFDEF,        COND)                      /*  22000 */ \
 105 D(if,           T_IF,           COND)                      /*  18162 */ \
 106 D(else,         T_ELSE,         COND)                       /*  9863 */ \
 107 D(ifndef,       T_IFNDEF,       COND)                       /*  9675 */ \
 108 D(undef,        T_UNDEF,        KANDR)                      /*  4837 */ \
 109 D(line,         T_LINE,         KANDR)                      /*  2465 */ \
 110 D(elif,         T_ELIF,         COND)                       /*   610 */ \
 111 D(error,        T_ERROR,        STDC89)                     /*   475 */ \
 112 D(pragma,       T_PRAGMA,       STDC89)                     /*   195 */ \
 113 D(warning,      T_WARNING,      EXTENSION)                  /*    22 GNU */ \
 114 D(include_next, T_INCLUDE_NEXT, EXTENSION | SYNTAX_INCLUDE) /*    19 GNU */ \
 115 D(ident,        T_IDENT,        EXTENSION)                  /*    11 SVR4 */ \
 116 D(import,       T_IMPORT,       EXTENSION | SYNTAX_INCLUDE) /*     0 ObjC */ \
 117 D(assert,       T_ASSERT,       EXTENSION | SYNTAX_ASSERT)  /*     0 SVR4 */ \
 118 D(unassert,     T_UNASSERT,     EXTENSION | SYNTAX_ASSERT)  /*     0 SVR4 */ \
 119 SCCS_ENTRY
 120
 121 /* Use the table to generate a series of prototypes, an enum for the
 122    directive names, and an array of directive handlers.  */
 123
 124 /* The directive-processing functions are declared to return int
 125    instead of void, because some old compilers have trouble with
 126    pointers to functions returning void.  */
 127
 128 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
 129 #define D(name, t, f) static int CONCAT2(do_,name) PARAMS ((cpp_reader *));
 130 DIRECTIVE_TABLE
 131 #undef D
 132
 133 #define D(n, tag, f) tag,
 134 enum
 135 {
 136   DIRECTIVE_TABLE
 137   N_DIRECTIVES
 138 };
 139 #undef D
 140
 141 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
 142 #define D(name, t, flags) \
 143 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
 144   sizeof STRINGX(name) - 1, flags },
 145 static const struct directive dtable[] =
 146 {
 147 DIRECTIVE_TABLE
 148 };
 149 #undef D
 150 #undef DIRECTIVE_TABLE
 151
 152 /* Check if a token's name matches that of a known directive.  Put in
 153    this file to save exporting dtable and other unneeded information.  */
 154 void
 155 _cpp_check_directive (list, token)
 156      cpp_toklist *list;
 157      cpp_token *token;
 158 {
 159   const U_CHAR *name = list->namebuf + token->val.name.offset;
 160   size_t len = token->val.name.len;
 161   unsigned int i;
 162
 163   list->dir_handler = 0;
 164   list->dir_flags = 0;
 165
 166   for (i = 0; i < N_DIRECTIVES; i++)
 167     if (dtable[i].length == len && !ustrncmp (dtable[i].name, name, len))
 168       {
 169         list->dir_handler = dtable[i].func;
 170         list->dir_flags = dtable[i].flags;
 171         break;
 172       }
 173 }
 174
 175 /* Handle a possible # directive.
 176    '#' has already been read.  */
 177
 178 int
 179 _cpp_handle_directive (pfile)
 180      cpp_reader *pfile;
 181 {
 182   int i;
 183   int hash_at_bol;
 184   unsigned int len;
 185   U_CHAR *ident;
 186   long old_written = CPP_WRITTEN (pfile);
 187   enum cpp_ttype tok;
 188
 189   if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
 190     {
 191       cpp_ice (pfile, "handle_directive called on macro buffer");
 192       return 0;
 193     }
 194
 195   /* -traditional directives are recognized only with the # in column 1.  */
 196   hash_at_bol = CPP_IN_COLUMN_1 (pfile);
 197
 198   /* Scan the next token, then pretend we didn't.  */
 199   CPP_SET_MARK (pfile);
 200   pfile->no_macro_expand++;
 201   tok = _cpp_get_directive_token (pfile);
 202   pfile->no_macro_expand--;
 203
 204   ident = pfile->token_buffer + old_written;
 205   len = CPP_PWRITTEN (pfile) - ident;
 206   CPP_SET_WRITTEN (pfile, old_written);
 207   CPP_GOTO_MARK (pfile);
 208
 209   /* # followed by a number is equivalent to #line.  Do not recognize
 210      this form in assembly language source files.  Complain about this
 211      form if we're being pedantic, but not if this is regurgitated
 212      input (preprocessed or fed back in by the C++ frontend).  */
 213   if (tok == CPP_NUMBER)
 214     {
 215       if (CPP_OPTION (pfile, lang_asm))
 216         return 0;
 217
 218       if (CPP_PEDANTIC (pfile)
 219           && CPP_BUFFER (pfile)->ihash
 220           && ! CPP_OPTION (pfile, preprocessed))
 221         cpp_pedwarn (pfile, "# followed by integer");
 222       do_line (pfile);
 223       return 1;
 224     }
 225
 226   /* If we are rescanning preprocessed input, don't obey any directives
 227      other than # nnn.  */
 228   else if (CPP_OPTION (pfile, preprocessed))
 229     return 0;
 230
 231   /* A line of just # becomes blank.  */
 232   else if (tok == CPP_VSPACE)
 233     return 1;
 234
 235   /* A NAME token might in fact be a directive!  */
 236   else if (tok == CPP_NAME)
 237     {
 238       for (i = 0; i < N_DIRECTIVES; i++)
 239         {
 240           if (dtable[i].length == len
 241               && !ustrncmp (dtable[i].name, ident, len))
 242             goto real_directive;
 243         }
 244       /* Don't complain about invalid directives in assembly source,
 245          we don't know where the comments are, and # may introduce
 246          assembler pseudo-ops.  */
 247       if (!CPP_OPTION (pfile, lang_asm))
 248         cpp_error (pfile, "invalid preprocessing directive #%s", ident);
 249       return 0;
 250     }
 251   /* And anything else means the # wasn't a directive marker.   */
 252   else
 253     return 0;
 254
 255  real_directive:
 256
 257   /* In -traditional mode, a directive is ignored unless its # is in
 258      column 1.  */
 259   if (CPP_TRADITIONAL (pfile) && !hash_at_bol)
 260     {
 261       if (CPP_WTRADITIONAL (pfile))
 262         cpp_warning (pfile, "ignoring #%s because of its indented #",
 263                      dtable[i].name);
 264       return 0;
 265     }
 266
 267   /* no_directives is set when we are parsing macro arguments.  Directives
 268      in macro arguments are undefined behavior (C99 6.10.3.11); this
 269      implementation chooses to make them hard errors.  */
 270   if (pfile->no_directives)
 271     {
 272       cpp_error (pfile, "#%s may not be used inside a macro argument",
 273                  dtable[i].name);
 274       _cpp_skip_rest_of_line (pfile);
 275       return 1;
 276     }
 277
 278   /* Issue -pedantic warnings for extended directives.   */
 279   if (CPP_PEDANTIC (pfile) && ORIGIN (dtable[i].flags) == EXTENSION)
 280     cpp_pedwarn (pfile, "ISO C does not allow #%s", dtable[i].name);
 281
 282   /* -Wtraditional gives warnings about directives with inappropriate
 283      indentation of #.  */
 284   if (CPP_WTRADITIONAL (pfile))
 285     {
 286       if (!hash_at_bol && TRAD_DIRECT_P (dtable[i].flags))
 287         cpp_warning (pfile, "traditional C ignores #%s with the # indented",
 288                      dtable[i].name);
 289       else if (hash_at_bol && ! TRAD_DIRECT_P (dtable[i].flags))
 290         cpp_warning (pfile,
 291                 "suggest hiding #%s from traditional C with an indented #",
 292                      dtable[i].name);
 293     }
 294
 295   /* Unfortunately, it's necessary to scan the directive name again,
 296      now we know we're going to consume it.  FIXME.  */
 297
 298   pfile->no_macro_expand++;
 299   _cpp_get_directive_token (pfile);
 300   pfile->no_macro_expand--;
 301   CPP_SET_WRITTEN (pfile, old_written);
 302
 303   /* Some directives (e.g. #if) may return a request to execute
 304      another directive handler immediately.  No directive ever
 305      requests that #define be executed immediately, so it is safe for
 306      the loop to terminate when some function returns 0 (== T_DEFINE).  */
 307   while ((i = dtable[i].func (pfile)));
 308   return 1;
 309 }
 310
 311 /* Pass a directive through to the output file.
 312    BUF points to the contents of the directive, as a contiguous string.
 313    LEN is the length of the string pointed to by BUF.
 314    KEYWORD is the keyword-table entry for the directive.  */
 315
 316 static void
 317 pass_thru_directive (buf, len, pfile, keyword)
 318      const U_CHAR *buf;
 319      size_t len;
 320      cpp_reader *pfile;
 321      int keyword;
 322 {
 323   const struct directive *kt = &dtable[keyword];
 324   register unsigned klen = kt->length;
 325
 326   CPP_RESERVE (pfile, 1 + klen + len);
 327   CPP_PUTC_Q (pfile, '#');
 328   CPP_PUTS_Q (pfile, kt->name, klen);
 329   if (len != 0 && buf[0] != ' ')
 330     CPP_PUTC_Q (pfile, ' ');
 331   CPP_PUTS_Q (pfile, buf, len);
 332 }
 333
 334 /* Process a #define command.  */
 335
 336 static int
 337 do_define (pfile)
 338      cpp_reader *pfile;
 339 {
 340   HASHNODE *node;
 341   int len;
 342   U_CHAR *sym;
 343   cpp_toklist *list = &pfile->directbuf;
 344
 345   pfile->no_macro_expand++;
 346   pfile->parsing_define_directive++;
 347   CPP_OPTION (pfile, discard_comments)++;
 348
 349   _cpp_scan_line (pfile, list);
 350
 351   /* First token on the line must be a NAME.  There must be at least
 352      one token (the VSPACE at the end).  */
 353   if (TOK_TYPE (list, 0) != CPP_NAME)
 354     {
 355       cpp_error_with_line (pfile, list->line, TOK_COL (list, 0),
 356                            "#define must be followed by an identifier");
 357       goto out;
 358     }
 359
 360   sym = TOK_NAME (list, 0);
 361   len = TOK_LEN (list, 0);
 362
 363   /* That NAME is not allowed to be "defined".  (Not clear if the
 364      standard requires this.)  */
 365   if (len == 7 && !ustrncmp (sym, U"defined", 7))
 366     {
 367       cpp_error_with_line (pfile, list->line, TOK_COL (list, 0),
 368                            "\"defined\" is not a legal macro name");
 369       goto out;
 370     }
 371
 372   node = _cpp_lookup (pfile, sym, len);
 373   /* Check for poisoned identifiers now.  All other checks
 374      are done in cpphash.c.  */
 375   if (node->type == T_POISON)
 376     {
 377       cpp_error (pfile, "redefining poisoned `%.*s'", len, sym);
 378       goto out;
 379     }
 380
 381   if (_cpp_create_definition (pfile, list, node) == 0)
 382     goto out;
 383
 384   if (CPP_OPTION (pfile, debug_output)
 385       || CPP_OPTION (pfile, dump_macros) == dump_definitions)
 386     _cpp_dump_definition (pfile, node);
 387   else if (CPP_OPTION (pfile, dump_macros) == dump_names)
 388     pass_thru_directive (sym, len, pfile, T_DEFINE);
 389
 390  out:
 391   pfile->no_macro_expand--;
 392   pfile->parsing_define_directive--;
 393   CPP_OPTION (pfile, discard_comments)--;
 394   return 0;
 395 }
 396
 397 /* Handle #include and #import.  */
 398
 399 static unsigned int
 400 parse_include (pfile, name)
 401      cpp_reader *pfile;
 402      const U_CHAR *name;
 403 {
 404   long old_written = CPP_WRITTEN (pfile);
 405   enum cpp_ttype token;
 406   int len;
 407
 408   pfile->parsing_include_directive++;
 409   token = _cpp_get_directive_token (pfile);
 410   pfile->parsing_include_directive--;
 411
 412   len = CPP_WRITTEN (pfile) - old_written;
 413
 414   if (token == CPP_STRING)
 415     ; /* No special treatment required.  */
 416 #ifdef VMS
 417   else if (token == CPP_NAME)
 418     {
 419       /* Support '#include xyz' like VAX-C.  It is taken as
 420          '#include <xyz.h>' and generates a warning.  */
 421       cpp_warning (pfile, "#%s filename is obsolete, use #%s <filename.h>",
 422                    name, name);
 423
 424       /* Rewrite the token to <xyz.h>.  */
 425       CPP_RESERVE (pfile, 4);
 426       len += 4;
 427       memmove (pfile->token_buffer + old_written + 1,
 428                pfile->token_buffer + old_written,
 429                CPP_WRITTEN (pfile) - old_written);
 430       pfile->token_buffer[old_written] = '<';
 431       CPP_PUTS_Q (pfile, ".h>", 2);
 432     }
 433 #endif
 434   else
 435     {
 436       cpp_error (pfile, "`#%s' expects \"FILENAME\" or <FILENAME>", name);
 437       CPP_SET_WRITTEN (pfile, old_written);
 438       _cpp_skip_rest_of_line (pfile);
 439       return 0;
 440     }
 441
 442   if (_cpp_get_directive_token (pfile) != CPP_VSPACE)
 443     {
 444       cpp_error (pfile, "junk at end of `#%s'", name);
 445       _cpp_skip_rest_of_line (pfile);
 446     }
 447
 448   CPP_SET_WRITTEN (pfile, old_written);
 449
 450   if (len == 0)
 451     cpp_error (pfile, "empty file name in `#%s'", name);
 452
 453   return len;
 454 }
 455
 456 static int
 457 do_include (pfile)
 458      cpp_reader *pfile;
 459 {
 460   unsigned int len;
 461   U_CHAR *token;
 462
 463   len = parse_include (pfile, dtable[T_INCLUDE].name);
 464   if (len == 0)
 465     return 0;
 466   token = (U_CHAR *) alloca (len + 1);
 467   memcpy (token, CPP_PWRITTEN (pfile), len);
 468   token[len] = '\0';
 469
 470   if (CPP_OPTION (pfile, dump_includes))
 471     pass_thru_directive (token, len, pfile, T_INCLUDE);
 472
 473   _cpp_execute_include (pfile, token, len, 0, 0);
 474   return 0;
 475 }
 476
 477 static int
 478 do_import (pfile)
 479      cpp_reader *pfile;
 480 {
 481   unsigned int len;
 482   U_CHAR *token;
 483
 484   if (CPP_OPTION (pfile, warn_import)
 485       && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
 486     {
 487       pfile->import_warning = 1;
 488       cpp_warning (pfile,
 489            "#import is obsolete, use an #ifndef wrapper in the header file");
 490     }
 491
 492   len = parse_include (pfile, dtable[T_IMPORT].name);
 493   if (len == 0)
 494     return 0;
 495   token = (U_CHAR *) alloca (len + 1);
 496   memcpy (token, CPP_PWRITTEN (pfile), len);
 497   token[len] = '\0';
 498
 499   if (CPP_OPTION (pfile, dump_includes))
 500     pass_thru_directive (token, len, pfile, T_IMPORT);
 501
 502   _cpp_execute_include (pfile, token, len, 1, 0);
 503   return 0;
 504 }
 505
 506 static int
 507 do_include_next (pfile)
 508      cpp_reader *pfile;
 509 {
 510   unsigned int len;
 511   U_CHAR *token;
 512   struct file_name_list *search_start = 0;
 513
 514   len = parse_include (pfile, dtable[T_INCLUDE_NEXT].name);
 515   if (len == 0)
 516     return 0;
 517   token = (U_CHAR *) alloca (len + 1);
 518   memcpy (token, CPP_PWRITTEN (pfile), len);
 519   token[len] = '\0';
 520
 521   if (CPP_OPTION (pfile, dump_includes))
 522     pass_thru_directive (token, len, pfile, T_INCLUDE_NEXT);
 523
 524   /* For #include_next, skip in the search path past the dir in which the
 525      containing file was found.  Treat files specified using an absolute path
 526      as if there are no more directories to search.  Treat the primary source
 527      file like any other included source, but generate a warning.  */
 528   if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)))
 529     {
 530       if (CPP_BUFFER (pfile)->ihash->foundhere != ABSOLUTE_PATH)
 531         search_start = CPP_BUFFER (pfile)->ihash->foundhere->next;
 532     }
 533   else
 534     cpp_warning (pfile, "#include_next in primary source file");
 535
 536   _cpp_execute_include (pfile, token, len, 0, search_start);
 537   return 0;
 538 }
 539
 540 /* Subroutine of do_line.  Read next token from PFILE without adding it to
 541    the output buffer.  If it is a number between 1 and 4, store it in *NUM
 542    and return 1; otherwise, return 0 and complain if we aren't at the end
 543    of the directive.  */
 544
 545 static int
 546 read_line_number (pfile, num)
 547      cpp_reader *pfile;
 548      int *num;
 549 {
 550   long save_written = CPP_WRITTEN (pfile);
 551   U_CHAR *p;
 552   enum cpp_ttype token = _cpp_get_directive_token (pfile);
 553   p = pfile->token_buffer + save_written;
 554
 555   if (token == CPP_NUMBER && p + 1 == CPP_PWRITTEN (pfile)
 556       && p[0] >= '1' && p[0] <= '4')
 557     {
 558       *num = p[0] - '0';
 559       CPP_SET_WRITTEN (pfile, save_written);
 560       return 1;
 561     }
 562   else
 563     {
 564       if (token != CPP_VSPACE && token != CPP_EOF)
 565         cpp_error (pfile, "invalid format `#line' command");
 566       CPP_SET_WRITTEN (pfile, save_written);
 567       return 0;
 568     }
 569 }
 570
 571 /* Interpret #line command.
 572    Note that the filename string (if any) is treated as if it were an
 573    include filename.  That means no escape handling.  */
 574
 575 static int
 576 do_line (pfile)
 577      cpp_reader *pfile;
 578 {
 579   cpp_buffer *ip = CPP_BUFFER (pfile);
 580   unsigned int new_lineno;
 581   long old_written = CPP_WRITTEN (pfile);
 582   enum cpp_ttype token;
 583   char *x;
 584
 585   token = _cpp_get_directive_token (pfile);
 586
 587   if (token != CPP_NUMBER)
 588     {
 589       cpp_error (pfile, "token after `#line' is not an integer");
 590       goto bad_line_directive;
 591     }
 592
 593   CPP_PUTC (pfile, '\0');  /* not terminated for us */
 594   new_lineno = strtoul ((const char *) (pfile->token_buffer + old_written),
 595                         &x, 10);
 596   if (x[0] != '\0')
 597     {
 598       cpp_error (pfile, "token after `#line' is not an integer");
 599       goto bad_line_directive;
 600     }
 601   CPP_SET_WRITTEN (pfile, old_written);
 602
 603   if (CPP_PEDANTIC (pfile) && (new_lineno <= 0 || new_lineno > 32767))
 604     cpp_pedwarn (pfile, "line number out of range in `#line' command");
 605
 606   token = _cpp_get_directive_token (pfile);
 607
 608   if (token == CPP_STRING)
 609     {
 610       U_CHAR *fname = pfile->token_buffer + old_written + 1;
 611       U_CHAR *end_name = CPP_PWRITTEN (pfile) - 1;
 612       int action_number = 0;
 613
 614       if (read_line_number (pfile, &action_number))
 615         {
 616           if (CPP_PEDANTIC (pfile))
 617             cpp_pedwarn (pfile, "garbage at end of `#line' command");
 618
 619           /* This is somewhat questionable: change the buffer stack
 620              depth so that output_line_command thinks we've stacked
 621              another buffer. */
 622           if (action_number == 1)
 623             {
 624               pfile->buffer_stack_depth++;
 625               ip->system_header_p = 0;
 626               read_line_number (pfile, &action_number);
 627             }
 628           else if (action_number == 2)
 629             {
 630               pfile->buffer_stack_depth--;
 631               ip->system_header_p = 0;
 632               read_line_number (pfile, &action_number);
 633             }
 634           if (action_number == 3)
 635             {
 636               ip->system_header_p = 1;
 637               read_line_number (pfile, &action_number);
 638             }
 639           if (action_number == 4)
 640             {
 641               ip->system_header_p = 2;
 642               read_line_number (pfile, &action_number);
 643             }
 644         }
 645
 646       *end_name = '\0';
 647
 648       if (strcmp ((const char *)fname, ip->nominal_fname))
 649         {
 650           if (!strcmp ((const char *)fname, ip->ihash->name))
 651             ip->nominal_fname = ip->ihash->name;
 652           else
 653             ip->nominal_fname = _cpp_fake_ihash (pfile, (const char *)fname);
 654         }
 655     }
 656   else if (token != CPP_VSPACE && token != CPP_EOF)
 657     {
 658       cpp_error (pfile, "token after `#line %d' is not a string", new_lineno);
 659       goto bad_line_directive;
 660     }
 661
 662   /* The Newline at the end of this line remains to be processed.
 663      To put the next line at the specified line number,
 664      we must store a line number now that is one less.  */
 665   ip->lineno = new_lineno - 1;
 666   CPP_SET_WRITTEN (pfile, old_written);
 667   return 0;
 668
 669  bad_line_directive:
 670   _cpp_skip_rest_of_line (pfile);
 671   CPP_SET_WRITTEN (pfile, old_written);
 672   return 0;
 673 }
 674
 675 /* Remove the definition of a symbol from the symbol table.
 676    According to the C standard, it is not an error to undef
 677    something that has no definitions. */
 678 static int
 679 do_undef (pfile)
 680      cpp_reader *pfile;
 681 {
 682   int len;
 683   HASHNODE *hp;
 684   U_CHAR *name;
 685   long here = CPP_WRITTEN (pfile);
 686   enum cpp_ttype token;
 687
 688   pfile->no_macro_expand++;
 689   token = _cpp_get_directive_token (pfile);
 690   pfile->no_macro_expand--;
 691
 692   if (token != CPP_NAME)
 693     {
 694       cpp_error (pfile, "token after #undef is not an identifier");
 695       _cpp_skip_rest_of_line (pfile);
 696       return 0;
 697     }
 698   len = CPP_WRITTEN (pfile) - here;
 699
 700   token = _cpp_get_directive_token (pfile);
 701   if (token != CPP_VSPACE)
 702   {
 703       cpp_pedwarn (pfile, "junk on line after #undef");
 704       _cpp_skip_rest_of_line (pfile);
 705   }
 706
 707   name = pfile->token_buffer + here;
 708   CPP_SET_WRITTEN (pfile, here);
 709
 710   hp = _cpp_lookup (pfile, name, len);
 711   if (hp->type == T_VOID)
 712     ; /* Not defined in the first place - do nothing.  */
 713   else if (hp->type == T_POISON)
 714     cpp_error (pfile, "cannot undefine poisoned \"%s\"", hp->name);
 715   else
 716     {
 717       /* If we are generating additional info for debugging (with -g) we
 718          need to pass through all effective #undef commands.  */
 719       if (CPP_OPTION (pfile, debug_output))
 720         pass_thru_directive (hp->name, len, pfile, T_UNDEF);
 721
 722       if (hp->type != T_MACRO && hp->type != T_FMACRO
 723           && hp->type != T_EMPTY && hp->type != T_IDENTITY)
 724         cpp_warning (pfile, "undefining `%s'", hp->name);
 725
 726       _cpp_free_definition (hp);
 727       hp->type = T_VOID;
 728     }
 729
 730   return 0;
 731 }
 732
 733 /*
 734  * Report an error detected by the program we are processing.
 735  * Use the text of the line in the error message.
 736  * (We use error because it prints the filename & line#.)
 737  */
 738
 739 static int
 740 do_error (pfile)
 741      cpp_reader *pfile;
 742 {
 743   const U_CHAR *text, *limit;
 744
 745   _cpp_skip_hspace (pfile);
 746   text = CPP_BUFFER (pfile)->cur;
 747   _cpp_skip_rest_of_line (pfile);
 748   limit = CPP_BUFFER (pfile)->cur;
 749
 750   cpp_error (pfile, "#error %.*s", (int)(limit - text), text);
 751   return 0;
 752 }
 753
 754 /*
 755  * Report a warning detected by the program we are processing.
 756  * Use the text of the line in the warning message, then continue.
 757  */
 758
 759 static int
 760 do_warning (pfile)
 761      cpp_reader *pfile;
 762 {
 763   const U_CHAR *text, *limit;
 764
 765   _cpp_skip_hspace (pfile);
 766   text = CPP_BUFFER (pfile)->cur;
 767   _cpp_skip_rest_of_line (pfile);
 768   limit = CPP_BUFFER (pfile)->cur;
 769
 770   cpp_warning (pfile, "#warning %.*s", (int)(limit - text), text);
 771   return 0;
 772 }
 773
 774 /* Report program identification.  */
 775
 776 static int
 777 do_ident (pfile)
 778      cpp_reader *pfile;
 779 {
 780   long old_written = CPP_WRITTEN (pfile);
 781
 782   CPP_PUTS (pfile, "#ident ", 7);
 783
 784   /* Next token should be a string constant.  */
 785   if (_cpp_get_directive_token (pfile) == CPP_STRING)
 786     /* And then a newline.  */
 787     if (_cpp_get_directive_token (pfile) == CPP_VSPACE)
 788       /* Good - ship it.  */
 789       return 0;
 790
 791   cpp_error (pfile, "invalid #ident");
 792   _cpp_skip_rest_of_line (pfile);
 793   CPP_SET_WRITTEN (pfile, old_written);  /* discard directive */
 794
 795   return 0;
 796 }
 797
 798 /* Pragmata handling.  We handle some of these, and pass the rest on
 799    to the front end.  C99 defines three pragmas and says that no macro
 800    expansion is to be performed on them; whether or not macro
 801    expansion happens for other pragmas is implementation defined.
 802    This implementation never macro-expands the text after #pragma.
 803
 804    We currently do not support the _Pragma operator.  Support for that
 805    has to be coordinated with the front end.  Proposed implementation:
 806    both #pragma blah blah and _Pragma("blah blah") become
 807    __builtin_pragma(blah blah) and we teach the parser about that.  */
 808
 809 /* Sub-handlers for the pragmas needing treatment here.
 810    They return 1 if the token buffer is to be popped, 0 if not. */
 811 static int do_pragma_once               PARAMS ((cpp_reader *));
 812 static int do_pragma_implementation     PARAMS ((cpp_reader *));
 813 static int do_pragma_poison             PARAMS ((cpp_reader *));
 814 static int do_pragma_default            PARAMS ((cpp_reader *));
 815
 816 static int
 817 do_pragma (pfile)
 818      cpp_reader *pfile;
 819 {
 820   long here, key;
 821   U_CHAR *buf;
 822   int pop;
 823   enum cpp_ttype token;
 824
 825   here = CPP_WRITTEN (pfile);
 826   CPP_PUTS (pfile, "#pragma ", 8);
 827
 828   key = CPP_WRITTEN (pfile);
 829   pfile->no_macro_expand++;
 830   token = _cpp_get_directive_token (pfile);
 831   if (token != CPP_NAME)
 832     {
 833       if (token == CPP_VSPACE)
 834         goto empty;
 835       else
 836         goto skip;
 837     }
 838
 839   buf = pfile->token_buffer + key;
 840   CPP_PUTC (pfile, ' ');
 841
 842 #define tokis(x) !strncmp((char *) buf, x, sizeof(x) - 1)
 843   if (tokis ("once"))
 844     pop = do_pragma_once (pfile);
 845   else if (tokis ("implementation"))
 846     pop = do_pragma_implementation (pfile);
 847   else if (tokis ("poison"))
 848     pop = do_pragma_poison (pfile);
 849   else
 850     pop = do_pragma_default (pfile);
 851 #undef tokis
 852
 853   if (_cpp_get_directive_token (pfile) != CPP_VSPACE)
 854     goto skip;
 855
 856   if (pop)
 857     CPP_SET_WRITTEN (pfile, here);
 858   pfile->no_macro_expand--;
 859   return 0;
 860
 861  skip:
 862   cpp_error (pfile, "malformed #pragma directive");
 863   _cpp_skip_rest_of_line (pfile);
 864  empty:
 865   CPP_SET_WRITTEN (pfile, here);
 866   pfile->no_macro_expand--;
 867   return 0;
 868 }
 869
 870 static int
 871 do_pragma_default (pfile)
 872      cpp_reader *pfile;
 873 {
 874   while (_cpp_get_directive_token (pfile) != CPP_VSPACE)
 875     CPP_PUTC (pfile, ' ');
 876   return 0;
 877 }
 878
 879 static int
 880 do_pragma_once (pfile)
 881      cpp_reader *pfile;
 882 {
 883   cpp_buffer *ip = CPP_BUFFER (pfile);
 884
 885   /* Allow #pragma once in system headers, since that's not the user's
 886      fault.  */
 887   if (!ip->system_header_p)
 888     cpp_warning (pfile, "`#pragma once' is obsolete");
 889
 890   if (CPP_PREV_BUFFER (ip) == NULL)
 891     cpp_warning (pfile, "`#pragma once' outside include file");
 892   else
 893     ip->ihash->control_macro = U"";  /* never repeat */
 894
 895   return 1;
 896 }
 897
 898 static int
 899 do_pragma_implementation (pfile)
 900      cpp_reader *pfile;
 901 {
 902   /* Be quiet about `#pragma implementation' for a file only if it hasn't
 903      been included yet.  */
 904   enum cpp_ttype token;
 905   long written = CPP_WRITTEN (pfile);
 906   U_CHAR *name;
 907   char *copy;
 908   size_t len;
 909
 910   token = _cpp_get_directive_token (pfile);
 911   if (token == CPP_VSPACE)
 912     return 0;
 913   else if (token != CPP_STRING)
 914     {
 915       cpp_error (pfile, "malformed #pragma implementation");
 916       return 1;
 917     }
 918
 919   /* Trim the leading and trailing quote marks from the string.  */
 920   name = pfile->token_buffer + written + 1;
 921   len = CPP_PWRITTEN (pfile) - name;
 922   copy = alloca (len);
 923   memcpy (copy, name, len - 1);
 924   copy[len - 1] = '\0';
 925
 926   if (cpp_included (pfile, copy))
 927     cpp_warning (pfile,
 928          "`#pragma implementation' for `%s' appears after file is included",
 929                  copy);
 930   return 0;
 931 }
 932
 933 static int
 934 do_pragma_poison (pfile)
 935      cpp_reader *pfile;
 936 {
 937   /* Poison these symbols so that all subsequent usage produces an
 938      error message.  */
 939   U_CHAR *p;
 940   HASHNODE *hp;
 941   long written;
 942   size_t len;
 943   enum cpp_ttype token;
 944   int writeit;
 945
 946   /* As a rule, don't include #pragma poison commands in output,
 947      unless the user asks for them.  */
 948   writeit = (CPP_OPTION (pfile, debug_output)
 949              || CPP_OPTION (pfile, dump_macros) == dump_definitions
 950              || CPP_OPTION (pfile, dump_macros) == dump_names);
 951
 952   for (;;)
 953     {
 954       written = CPP_WRITTEN (pfile);
 955       token = _cpp_get_directive_token (pfile);
 956       if (token == CPP_VSPACE)
 957         break;
 958       if (token != CPP_NAME)
 959         {
 960           cpp_error (pfile, "invalid #pragma poison directive");
 961           _cpp_skip_rest_of_line (pfile);
 962           return 1;
 963         }
 964
 965       p = pfile->token_buffer + written;
 966       len = CPP_PWRITTEN (pfile) - p;
 967       hp = _cpp_lookup (pfile, p, len);
 968       if (hp->type == T_POISON)
 969         ;  /* It is allowed to poison the same identifier twice.  */
 970       else
 971         {
 972           if (hp->type != T_VOID)
 973             cpp_warning (pfile, "poisoning existing macro `%s'", hp->name);
 974           _cpp_free_definition (hp);
 975           hp->type = T_POISON;
 976         }
 977       if (writeit)
 978         CPP_PUTC (pfile, ' ');
 979     }
 980   return !writeit;
 981 }
 982
 983 /* Just ignore #sccs, on systems where we define it at all.  */
 984 #ifdef SCCS_DIRECTIVE
 985 static int
 986 do_sccs (pfile)
 987      cpp_reader *pfile;
 988 {
 989   _cpp_skip_rest_of_line (pfile);
 990   return 0;
 991 }
 992 #endif
 993
 994 /* We've found an `#if' directive.  If the only thing before it in
 995    this file is white space, and if it is of the form
 996    `#if ! defined SYMBOL', then SYMBOL is a possible controlling macro
 997    for inclusion of this file.  (See redundant_include_p in cppfiles.c
 998    for an explanation of controlling macros.)  If so, return a
 999    malloced copy of SYMBOL.  Otherwise, return NULL.  */
1000
1001 static U_CHAR *
1002 detect_if_not_defined (pfile)
1003      cpp_reader *pfile;
1004 {
1005   U_CHAR *control_macro = 0;
1006   enum cpp_ttype token;
1007   unsigned int base_offset;
1008   unsigned int token_offset;
1009   unsigned int need_rparen = 0;
1010   unsigned int token_len;
1011
1012   if (pfile->only_seen_white != 2)
1013     return NULL;
1014
1015   /* Save state required for restore.  */
1016   pfile->no_macro_expand++;
1017   CPP_SET_MARK (pfile);
1018   base_offset = CPP_WRITTEN (pfile);
1019
1020   /* Look for `!', */
1021   if (_cpp_get_directive_token (pfile) != CPP_OTHER
1022       || CPP_WRITTEN (pfile) != (size_t) base_offset + 1
1023       || CPP_PWRITTEN (pfile)[-1] != '!')
1024     goto restore;
1025
1026   /* ...then `defined', */
1027   token_offset = CPP_WRITTEN (pfile);
1028   token = _cpp_get_directive_token (pfile);
1029   if (token != CPP_NAME)
1030     goto restore;
1031   if (ustrncmp (pfile->token_buffer + token_offset, U"defined", 7))
1032     goto restore;
1033
1034   /* ...then an optional '(' and the name, */
1035   token_offset = CPP_WRITTEN (pfile);
1036   token = _cpp_get_directive_token (pfile);
1037   if (token == CPP_OPEN_PAREN)
1038     {
1039       token_offset = CPP_WRITTEN (pfile);
1040       need_rparen = 1;
1041       token = _cpp_get_directive_token (pfile);
1042     }
1043   if (token != CPP_NAME)
1044     goto restore;
1045
1046   token_len = CPP_WRITTEN (pfile) - token_offset;
1047
1048   /* ...then the ')', if necessary, */
1049   if (need_rparen && _cpp_get_directive_token (pfile) != CPP_CLOSE_PAREN)
1050     goto restore;
1051
1052   /* ...and make sure there's nothing else on the line.  */
1053   if (_cpp_get_directive_token (pfile) != CPP_VSPACE)
1054     goto restore;
1055
1056   /* We have a legitimate controlling macro for this header.  */
1057   control_macro = (U_CHAR *) xmalloc (token_len + 1);
1058   memcpy (control_macro, pfile->token_buffer + token_offset, token_len);
1059   control_macro[token_len] = '\0';
1060
1061  restore:
1062   CPP_SET_WRITTEN (pfile, base_offset);
1063   pfile->no_macro_expand--;
1064   CPP_GOTO_MARK (pfile);
1065
1066   return control_macro;
1067 }
1068
1069 /*
1070  * #if is straightforward; just call _cpp_parse_expr, then conditional_skip.
1071  * Also, check for a reinclude preventer of the form #if !defined (MACRO).
1072  */
1073
1074 static int
1075 do_if (pfile)
1076      cpp_reader *pfile;
1077 {
1078   U_CHAR *control_macro = detect_if_not_defined (pfile);
1079   int value = _cpp_parse_expr (pfile);
1080   return conditional_skip (pfile, value == 0, T_IF, control_macro);
1081 }
1082
1083 /*
1084  * handle a #elif directive by not changing  if_stack  either.
1085  * see the comment above do_else.
1086  */
1087
1088 static int
1089 do_elif (pfile)
1090      cpp_reader *pfile;
1091 {
1092   if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
1093     {
1094       cpp_error (pfile, "`#elif' not within a conditional");
1095       return 0;
1096     }
1097   else
1098     {
1099       if (pfile->if_stack->type == T_ELSE)
1100         {
1101           cpp_error (pfile, "`#elif' after `#else'");
1102           cpp_error_with_line (pfile, pfile->if_stack->lineno, 0,
1103                                "the conditional began here");
1104         }
1105       pfile->if_stack->type = T_ELIF;
1106     }
1107
1108   if (pfile->if_stack->if_succeeded)
1109     {
1110       _cpp_skip_rest_of_line (pfile);
1111       return skip_if_group (pfile);
1112     }
1113   if (_cpp_parse_expr (pfile) == 0)
1114     return skip_if_group (pfile);
1115
1116   ++pfile->if_stack->if_succeeded;      /* continue processing input */
1117   return 0;
1118 }
1119
1120 /* Parse an #ifdef or #ifndef directive.  Returns 1 for defined, 0 for
1121    not defined; the macro tested is left in the token buffer (but
1122    popped).  */
1123
1124 static int
1125 parse_ifdef (pfile, name)
1126      cpp_reader *pfile;
1127      const U_CHAR *name;
1128 {
1129   U_CHAR *ident;
1130   unsigned int len;
1131   enum cpp_ttype token;
1132   long old_written = CPP_WRITTEN (pfile);
1133   int defined;
1134
1135   pfile->no_macro_expand++;
1136   token = _cpp_get_directive_token (pfile);
1137   pfile->no_macro_expand--;
1138
1139   ident = pfile->token_buffer + old_written;
1140   len = CPP_WRITTEN (pfile) - old_written;
1141
1142   if (token == CPP_VSPACE)
1143     {
1144       if (! CPP_TRADITIONAL (pfile))
1145         cpp_pedwarn (pfile, "`#%s' with no argument", name);
1146       defined = 0;
1147       goto done;
1148     }
1149   else if (token == CPP_NAME)
1150     {
1151       defined = cpp_defined (pfile, ident, len);
1152       CPP_PUTC (pfile, '\0');  /* so it can be copied with xstrdup */
1153     }
1154   else
1155     {
1156       defined = 0;
1157       if (! CPP_TRADITIONAL (pfile))
1158         cpp_error (pfile, "`#%s' with invalid argument", name);
1159     }
1160
1161   if (!CPP_TRADITIONAL (pfile))
1162     {
1163       if (_cpp_get_directive_token (pfile) == CPP_VSPACE)
1164         goto done;
1165
1166       cpp_pedwarn (pfile, "garbage at end of `#%s' argument", name);
1167     }
1168   _cpp_skip_rest_of_line (pfile);
1169
1170  done:
1171   CPP_SET_WRITTEN (pfile, old_written); /* Pop */
1172   return defined;
1173 }
1174
1175 /* #ifdef is dead simple.  */
1176
1177 static int
1178 do_ifdef (pfile)
1179      cpp_reader *pfile;
1180 {
1181   int skip = ! parse_ifdef (pfile, dtable[T_IFDEF].name);
1182   return conditional_skip (pfile, skip, T_IFDEF, 0);
1183 }
1184
1185 /* #ifndef is a tad more complex, because we need to check for a
1186    no-reinclusion wrapper.  */
1187
1188 static int
1189 do_ifndef (pfile)
1190      cpp_reader *pfile;
1191 {
1192   int start_of_file, skip;
1193   U_CHAR *control_macro = 0;
1194
1195   start_of_file = pfile->only_seen_white == 2;
1196   skip = parse_ifdef (pfile, dtable[T_IFNDEF].name);
1197
1198   if (start_of_file && !skip)
1199     control_macro = uxstrdup (CPP_PWRITTEN (pfile));
1200
1201   return conditional_skip (pfile, skip, T_IFNDEF, control_macro);
1202 }
1203
1204 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
1205    If this is a #ifndef starting at the beginning of a file,
1206    CONTROL_MACRO is the macro name tested by the #ifndef.
1207    Otherwise, CONTROL_MACRO is 0.  */
1208
1209 static int
1210 conditional_skip (pfile, skip, type, control_macro)
1211      cpp_reader *pfile;
1212      int skip;
1213      int type;
1214      U_CHAR *control_macro;
1215 {
1216   IF_STACK *temp;
1217
1218   temp = (IF_STACK *) xcalloc (1, sizeof (IF_STACK));
1219   temp->lineno = CPP_BUFFER (pfile)->lineno;
1220   temp->next = pfile->if_stack;
1221   temp->control_macro = control_macro;
1222   pfile->if_stack = temp;
1223
1224   pfile->if_stack->type = type;
1225
1226   if (skip != 0)
1227     return skip_if_group (pfile);
1228
1229   ++pfile->if_stack->if_succeeded;
1230   return 0;
1231 }
1232
1233 /* Subroutine of skip_if_group.  Examine one preprocessing directive
1234    and return 0 if skipping should continue, or the directive number
1235    of the directive that ends the block if it should halt.
1236
1237    Also adjusts the if_stack as appropriate.  The `#' has been read,
1238    but not the identifier. */
1239
1240 static int
1241 consider_directive_while_skipping (pfile, stack)
1242     cpp_reader *pfile;
1243     IF_STACK *stack;
1244 {
1245   long ident;
1246   int i, hash_at_bol;
1247   unsigned int len;
1248   IF_STACK *temp;
1249
1250   /* -traditional directives are recognized only with the # in column 1.  */
1251   hash_at_bol = CPP_IN_COLUMN_1 (pfile);
1252
1253   ident = CPP_WRITTEN (pfile);
1254   if (_cpp_get_directive_token (pfile) != CPP_NAME)
1255     return 0;
1256   len = CPP_WRITTEN (pfile) - ident;
1257
1258   for (i = 0; i < N_DIRECTIVES; i++)
1259     {
1260       if (dtable[i].length == len
1261           && !ustrncmp (dtable[i].name, pfile->token_buffer + ident, len))
1262         goto real_directive;
1263     }
1264   return 0;
1265
1266  real_directive:
1267
1268   /* If it's not a directive of interest to us, return now.  */
1269   if (ORIGIN (dtable[i].flags) != COND)
1270     return 0;
1271
1272   /* First, deal with -traditional and -Wtraditional.
1273      All COND directives are from K+R.  */
1274
1275   if (! hash_at_bol)
1276     {
1277       if (CPP_TRADITIONAL (pfile))
1278         {
1279           if (CPP_WTRADITIONAL (pfile))
1280             cpp_warning (pfile, "ignoring #%s because of its indented #",
1281                          dtable[i].name);
1282           return 0;
1283         }
1284       if (CPP_WTRADITIONAL (pfile))
1285         cpp_warning (pfile, "traditional C ignores %s with the # indented",
1286                      dtable[i].name);
1287     }
1288
1289   switch (i)
1290     {
1291     default:
1292       cpp_ice (pfile, "non COND directive in switch in c_d_w_s");
1293       return 0;
1294
1295     case T_IF:
1296     case T_IFDEF:
1297     case T_IFNDEF:
1298       temp = (IF_STACK *) xcalloc (1, sizeof (IF_STACK));
1299       temp->lineno = CPP_BUFFER (pfile)->lineno;
1300       temp->next = pfile->if_stack;
1301       temp->type = i;
1302       pfile->if_stack = temp;
1303       return 0;
1304
1305     case T_ELSE:
1306       if (pfile->if_stack != stack)
1307         validate_else (pfile, dtable[i].name);
1308       /* fall through */
1309     case T_ELIF:
1310       if (pfile->if_stack == stack)
1311         return i;
1312
1313       pfile->if_stack->type = i;
1314       return 0;
1315
1316     case T_ENDIF:
1317       if (pfile->if_stack != stack)
1318         validate_else (pfile, dtable[i].name);
1319
1320       if (pfile->if_stack == stack)
1321         return i;
1322
1323       temp = pfile->if_stack;
1324       pfile->if_stack = temp->next;
1325       free (temp);
1326       return 0;
1327     }
1328 }
1329
1330 /* Skip to #endif, #else, or #elif.  Consumes the directive that
1331    causes it to stop, but not its argument.  Returns the number of
1332    that directive, which must be passed back up to
1333    _cpp_handle_directive, which will execute it.  */
1334 static int
1335 skip_if_group (pfile)
1336     cpp_reader *pfile;
1337 {
1338   enum cpp_ttype token;
1339   IF_STACK *save_if_stack = pfile->if_stack; /* don't pop past here */
1340   long old_written;
1341   int ret = 0;
1342
1343   /* We are no longer at the start of the file.  */
1344   pfile->only_seen_white = 0;
1345
1346   old_written = CPP_WRITTEN (pfile);
1347   pfile->no_macro_expand++;
1348   for (;;)
1349     {
1350       /* We are at the end of a line.
1351          XXX Serious layering violation here.  */
1352       int c = CPP_BUF_PEEK (CPP_BUFFER (pfile));
1353       if (c == EOF)
1354         break;  /* Caller will issue error.  */
1355       else if (c != '\n')
1356         cpp_ice (pfile, "character %c at end of line in skip_if_group", c);
1357       CPP_BUFFER (pfile)->cur++;
1358       CPP_BUMP_LINE (pfile);
1359       CPP_SET_WRITTEN (pfile, old_written);
1360       pfile->only_seen_white = 1;
1361
1362       token = _cpp_get_directive_token (pfile);
1363
1364       if (token == CPP_DIRECTIVE)
1365         {
1366           ret = consider_directive_while_skipping (pfile, save_if_stack);
1367           if (ret)
1368             break;
1369         }
1370
1371       if (token != CPP_VSPACE)
1372         _cpp_skip_rest_of_line (pfile);
1373     }
1374   CPP_SET_WRITTEN (pfile, old_written);
1375   pfile->no_macro_expand--;
1376   return ret;
1377 }
1378
1379 /*
1380  * handle a #else directive.  Do this by just continuing processing
1381  * without changing  if_stack ;  this is so that the error message
1382  * for missing #endif's etc. will point to the original #if.  It
1383  * is possible that something different would be better.
1384  */
1385
1386 static int
1387 do_else (pfile)
1388      cpp_reader *pfile;
1389 {
1390   validate_else (pfile, dtable[T_ELSE].name);
1391   _cpp_skip_rest_of_line (pfile);
1392
1393   if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
1394     {
1395       cpp_error (pfile, "`#else' not within a conditional");
1396       return 0;
1397     }
1398   else
1399     {
1400       /* #ifndef can't have its special treatment for containing the whole file
1401          if it has a #else clause.  */
1402       pfile->if_stack->control_macro = 0;
1403
1404       if (pfile->if_stack->type == T_ELSE)
1405         {
1406           cpp_error (pfile, "`#else' after `#else'");
1407           cpp_error_with_line (pfile, pfile->if_stack->lineno, 0,
1408                                "the conditional began here");
1409         }
1410       pfile->if_stack->type = T_ELSE;
1411     }
1412
1413   if (pfile->if_stack->if_succeeded)
1414     return skip_if_group (pfile);
1415
1416   ++pfile->if_stack->if_succeeded;      /* continue processing input */
1417   return 0;
1418 }
1419
1420 /*
1421  * unstack after #endif command
1422  */
1423
1424 static int
1425 do_endif (pfile)
1426      cpp_reader *pfile;
1427 {
1428   validate_else (pfile, dtable[T_ENDIF].name);
1429   _cpp_skip_rest_of_line (pfile);
1430
1431   if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
1432     cpp_error (pfile, "`#endif' not within a conditional");
1433   else
1434     {
1435       IF_STACK *temp = pfile->if_stack;
1436       pfile->if_stack = temp->next;
1437       if (temp->control_macro != 0)
1438         pfile->potential_control_macro = temp->control_macro;
1439       free (temp);
1440     }
1441   return 0;
1442 }
1443
1444 /* Issue -pedantic warning for text which is not a comment following
1445    an #else or #endif.  Do not warn in system headers, as this is harmless
1446    and very common on old systems.  */
1447
1448 static void
1449 validate_else (pfile, directive)
1450      cpp_reader *pfile;
1451      const U_CHAR *directive;
1452 {
1453   long old_written;
1454   if (! CPP_PEDANTIC (pfile))
1455     return;
1456
1457   old_written = CPP_WRITTEN (pfile);
1458   pfile->no_macro_expand++;
1459   if (_cpp_get_directive_token (pfile) != CPP_VSPACE)
1460     cpp_pedwarn (pfile,
1461                  "text following `#%s' violates ANSI standard", directive);
1462   CPP_SET_WRITTEN (pfile, old_written);
1463   pfile->no_macro_expand--;
1464 }
1465
1466 /* Called when we reach the end of a macro buffer.  Walk back up the
1467    conditional stack till we reach its level at entry to this file,
1468    issuing error messages.  */
1469 void
1470 _cpp_unwind_if_stack (pfile, pbuf)
1471      cpp_reader *pfile;
1472      cpp_buffer *pbuf;
1473 {
1474   struct if_stack *ifs, *nifs;
1475
1476   for (ifs = pfile->if_stack;
1477        ifs != pbuf->if_stack;
1478        ifs = nifs)
1479     {
1480       cpp_error_with_line (pfile, ifs->lineno, 0,
1481                            "unterminated `#%s' conditional",
1482                            dtable[ifs->type].name);
1483
1484       nifs = ifs->next;
1485       free (ifs);
1486     }
1487   pfile->if_stack = ifs;
1488 }
1489
1490 static int
1491 do_assert (pfile)
1492      cpp_reader *pfile;
1493 {
1494   long old_written;
1495   U_CHAR *sym;
1496   int ret;
1497   HASHNODE *base, *this;
1498   size_t blen, tlen;
1499
1500   old_written = CPP_WRITTEN (pfile);    /* remember where it starts */
1501   ret = _cpp_parse_assertion (pfile);
1502   if (ret == 0)
1503     goto error;
1504   else if (ret == 1)
1505     {
1506       cpp_error (pfile, "missing token-sequence in #assert");
1507       goto error;
1508     }
1509   tlen = CPP_WRITTEN (pfile) - old_written;
1510
1511   if (_cpp_get_directive_token (pfile) != CPP_VSPACE)
1512     {
1513       cpp_error (pfile, "junk at end of #assert");
1514       goto error;
1515     }
1516   sym = pfile->token_buffer + old_written;
1517
1518   this = _cpp_lookup (pfile, sym, tlen);
1519   if (this->type == T_ASSERT)
1520     {
1521       cpp_warning (pfile, "%s re-asserted", sym);
1522       goto error;
1523     }
1524
1525   blen = ustrchr (sym, '(') - sym;
1526   base = _cpp_lookup (pfile, sym, blen);
1527   if (base->type == T_VOID)
1528     {
1529       base->type = T_ASSERT;
1530       base->value.aschain = 0;
1531     }
1532
1533   this->type = T_ASSERT;
1534   this->value.aschain = base->value.aschain;
1535   base->value.aschain = this;
1536
1537  error:
1538   _cpp_skip_rest_of_line (pfile);
1539   CPP_SET_WRITTEN (pfile, old_written);
1540   return 0;
1541 }
1542
1543 static int
1544 do_unassert (pfile)
1545      cpp_reader *pfile;
1546 {
1547   int ret;
1548   long old_written;
1549   U_CHAR *sym;
1550   long baselen, thislen;
1551   HASHNODE *base, *this, *next;
1552
1553   old_written = CPP_WRITTEN (pfile);
1554   ret = _cpp_parse_assertion (pfile);
1555   if (ret == 0)
1556     goto out;
1557   thislen = CPP_WRITTEN (pfile) - old_written;
1558
1559   if (_cpp_get_directive_token (pfile) != CPP_VSPACE)
1560     {
1561       cpp_error (pfile, "junk at end of #unassert");
1562       goto out;
1563     }
1564   sym = pfile->token_buffer + old_written;
1565   CPP_SET_WRITTEN (pfile, old_written);
1566
1567   if (ret == 1)
1568     {
1569       base = _cpp_lookup (pfile, sym, thislen);
1570       if (base->type == T_VOID)
1571         goto out;  /* It isn't an error to #undef what isn't #defined,
1572                       so it isn't an error to #unassert what isn't
1573                       #asserted either. */
1574
1575       for (this = base->value.aschain; this; this = next)
1576         {
1577           next = this->value.aschain;
1578           this->value.aschain = NULL;
1579           this->type = T_VOID;
1580         }
1581       base->value.aschain = NULL;
1582       base->type = T_VOID;
1583     }
1584   else
1585     {
1586       baselen = ustrchr (sym, '(') - sym;
1587       base = _cpp_lookup (pfile, sym, baselen);
1588       if (base->type == T_VOID) goto out;
1589       this = _cpp_lookup (pfile, sym, thislen);
1590       if (this->type == T_VOID) goto out;
1591
1592       next = base;
1593       while (next->value.aschain != this)
1594         next = next->value.aschain;
1595
1596       next->value.aschain = this->value.aschain;
1597       this->value.aschain = NULL;
1598       this->type = T_VOID;
1599
1600       if (base->value.aschain == NULL)
1601         /* Last answer for this predicate deleted. */
1602         base->type = T_VOID;
1603     }
1604   return 0;
1605
1606  out:
1607   _cpp_skip_rest_of_line (pfile);
1608   CPP_SET_WRITTEN (pfile, old_written);
1609   return 0;
1610 }
1611
1612 /* These are for -D, -U, -A.  */
1613
1614 /* Process the string STR as if it appeared as the body of a #define.
1615    If STR is just an identifier, define it with value 1.
1616    If STR has anything after the identifier, then it should
1617    be identifier=definition. */
1618
1619 void
1620 cpp_define (pfile, str)
1621      cpp_reader *pfile;
1622      const char *str;
1623 {
1624   char *buf, *p;
1625   size_t count;
1626
1627   p = strchr (str, '=');
1628   /* Copy the entire option so we can modify it.
1629      Change the first "=" in the string to a space.  If there is none,
1630      tack " 1" on the end.  Then add a newline and a NUL.  */
1631
1632   if (p)
1633     {
1634       count = strlen (str) + 2;
1635       buf = (char *) alloca (count);
1636       memcpy (buf, str, count - 2);
1637       buf[p - str] = ' ';
1638       buf[count - 2] = '\n';
1639       buf[count - 1] = '\0';
1640     }
1641   else
1642     {
1643       count = strlen (str) + 4;
1644       buf = (char *) alloca (count);
1645       memcpy (buf, str, count - 4);
1646       strcpy (&buf[count-4], " 1\n");
1647     }
1648
1649   if (cpp_push_buffer (pfile, (U_CHAR *)buf, count - 1) != NULL)
1650     {
1651       do_define (pfile);
1652       cpp_pop_buffer (pfile);
1653     }
1654 }
1655
1656 /* Process MACRO as if it appeared as the body of an #undef.  */
1657 void
1658 cpp_undef (pfile, macro)
1659      cpp_reader *pfile;
1660      const char *macro;
1661 {
1662   /* Copy the string so we can append a newline.  */
1663   size_t len = strlen (macro);
1664   char *buf = (char *) alloca (len + 2);
1665   memcpy (buf, macro, len);
1666   buf[len]     = '\n';
1667   buf[len + 1] = '\0';
1668   if (cpp_push_buffer (pfile, (U_CHAR *)buf, len + 1) != NULL)
1669     {
1670       do_undef (pfile);
1671       cpp_pop_buffer (pfile);
1672     }
1673 }
1674
1675 /* Process the string STR as if it appeared as the body of a #assert. */
1676 void
1677 cpp_assert (pfile, str)
1678      cpp_reader *pfile;
1679      const char *str;
1680 {
1681   if (cpp_push_buffer (pfile, (const U_CHAR *)str, strlen (str)) != NULL)
1682     {
1683       do_assert (pfile);
1684       cpp_pop_buffer (pfile);
1685     }
1686 }
1687
1688 /* Process STR as if it appeared as the body of an #unassert. */
1689 void
1690 cpp_unassert (pfile, str)
1691      cpp_reader *pfile;
1692      const char *str;
1693 {
1694   if (cpp_push_buffer (pfile, (const U_CHAR *)str, strlen (str)) != NULL)
1695     {
1696       do_unassert (pfile);
1697       cpp_pop_buffer (pfile);
1698     }
1699 }
1700
1701 /* Determine whether the identifier ID, of length LEN, is a defined macro.  */
1702 int
1703 cpp_defined (pfile, id, len)
1704      cpp_reader *pfile;
1705      const U_CHAR *id;
1706      int len;
1707 {
1708   HASHNODE *hp = _cpp_lookup (pfile, id, len);
1709   if (hp->type == T_POISON)
1710     {
1711       cpp_error (pfile, "attempt to use poisoned `%s'", hp->name);
1712       return 0;
1713     }
1714   return (hp->type != T_VOID);
1715 }