gcc/cpplib.c

   1 /* CPP Library. (Directive handling.)
   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 "obstack.h"
  29 #include "symcat.h"
  30
  31 /* Chained list of answers to an assertion.  */
  32 struct answer
  33 {
  34   struct answer *next;
  35   unsigned int count;
  36   cpp_token first[1];
  37 };
  38
  39 /* Stack of conditionals currently in progress
  40    (including both successful and failing conditionals).  */
  41
  42 struct if_stack
  43 {
  44   struct if_stack *next;
  45   cpp_lexer_pos pos;            /* line and column where condition started */
  46   const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
  47   unsigned char was_skipping;   /* Value of pfile->skipping before this if.  */
  48   int type;                     /* type of last directive seen in this group */
  49 };
  50
  51 /* Values for the origin field of struct directive.  KANDR directives
  52    come from traditional (K&R) C.  STDC89 directives come from the
  53    1989 C standard.  EXTENSION directives are extensions.  */
  54 #define KANDR           0
  55 #define STDC89          1
  56 #define EXTENSION       2
  57
  58 /* Values for the flags field of struct directive.  COND indicates a
  59    conditional; IF_COND an opening conditional.  INCL means to treat
  60    "..." and <...> as q-char and h-char sequences respectively.  IN_I
  61    means this directive should be handled even if -fpreprocessed is in
  62    effect (these are the directives with callback hooks).  */
  63 #define COND            (1 << 0)
  64 #define IF_COND         (1 << 1)
  65 #define INCL            (1 << 2)
  66 #define IN_I            (1 << 3)
  67
  68 /* Defines one #-directive, including how to handle it.  */
  69 typedef void (*directive_handler) PARAMS ((cpp_reader *));
  70 typedef struct directive directive;
  71 struct directive
  72 {
  73   directive_handler handler;    /* Function to handle directive.  */
  74   const U_CHAR *name;           /* Name of directive.  */
  75   unsigned short length;        /* Length of name.  */
  76   unsigned char origin;         /* Origin of directive.  */
  77   unsigned char flags;          /* Flags describing this directive.  */
  78 };
  79
  80 /* Forward declarations.  */
  81
  82 static void skip_rest_of_line   PARAMS ((cpp_reader *));
  83 static void check_eol           PARAMS ((cpp_reader *));
  84 static void start_directive     PARAMS ((cpp_reader *));
  85 static void end_directive       PARAMS ((cpp_reader *, int));
  86 static void run_directive       PARAMS ((cpp_reader *, int,
  87                                          const char *, size_t,
  88                                          const char *));
  89 static int glue_header_name     PARAMS ((cpp_reader *, cpp_token *));
  90 static int  parse_include       PARAMS ((cpp_reader *, cpp_token *));
  91 static void push_conditional    PARAMS ((cpp_reader *, int, int,
  92                                          const cpp_hashnode *));
  93 static unsigned int read_flag   PARAMS ((cpp_reader *));
  94 static int  strtoul_for_line    PARAMS ((const U_CHAR *, unsigned int,
  95                                          unsigned long *));
  96 static void do_diagnostic       PARAMS ((cpp_reader *, enum error_type, int));
  97 static cpp_hashnode *lex_macro_node     PARAMS ((cpp_reader *));
  98 static void do_pragma_once      PARAMS ((cpp_reader *));
  99 static void do_pragma_poison    PARAMS ((cpp_reader *));
 100 static void do_pragma_system_header     PARAMS ((cpp_reader *));
 101 static void do_pragma_dependency        PARAMS ((cpp_reader *));
 102 static int get__Pragma_string   PARAMS ((cpp_reader *, cpp_token *));
 103 static unsigned char *destringize       PARAMS ((const cpp_string *,
 104                                                  unsigned int *));
 105 static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
 106 static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
 107                                               int));
 108 static struct answer ** find_answer PARAMS ((cpp_hashnode *,
 109                                              const struct answer *));
 110 static void handle_assertion    PARAMS ((cpp_reader *, const char *, int));
 111
 112 /* This is the table of directive handlers.  It is ordered by
 113    frequency of occurrence; the numbers at the end are directive
 114    counts from all the source code I have lying around (egcs and libc
 115    CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
 116    pcmcia-cs-3.0.9).  This is no longer important as directive lookup
 117    is now O(1).  All extensions other than #warning and #include_next
 118    are deprecated.  The name is where the extension appears to have
 119    come from.  */
 120
 121 #define DIRECTIVE_TABLE                                                 \
 122 D(define,       T_DEFINE = 0,   KANDR,     IN_I)           /* 270554 */ \
 123 D(include,      T_INCLUDE,      KANDR,     INCL)           /*  52262 */ \
 124 D(endif,        T_ENDIF,        KANDR,     COND)           /*  45855 */ \
 125 D(ifdef,        T_IFDEF,        KANDR,     COND | IF_COND) /*  22000 */ \
 126 D(if,           T_IF,           KANDR,     COND | IF_COND) /*  18162 */ \
 127 D(else,         T_ELSE,         KANDR,     COND)           /*   9863 */ \
 128 D(ifndef,       T_IFNDEF,       KANDR,     COND | IF_COND) /*   9675 */ \
 129 D(undef,        T_UNDEF,        KANDR,     IN_I)           /*   4837 */ \
 130 D(line,         T_LINE,         KANDR,     IN_I)           /*   2465 */ \
 131 D(elif,         T_ELIF,         KANDR,     COND)           /*    610 */ \
 132 D(error,        T_ERROR,        STDC89,    0)              /*    475 */ \
 133 D(pragma,       T_PRAGMA,       STDC89,    IN_I)           /*    195 */ \
 134 D(warning,      T_WARNING,      EXTENSION, 0)              /*     22 */ \
 135 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL)           /*     19 */ \
 136 D(ident,        T_IDENT,        EXTENSION, IN_I)           /*     11 */ \
 137 D(import,       T_IMPORT,       EXTENSION, INCL)           /* 0 ObjC */ \
 138 D(assert,       T_ASSERT,       EXTENSION, 0)              /* 0 SVR4 */ \
 139 D(unassert,     T_UNASSERT,     EXTENSION, 0)              /* 0 SVR4 */ \
 140 SCCS_ENTRY                                                 /* 0 SVR4? */
 141
 142 /* #sccs is not always recognized.  */
 143 #ifdef SCCS_DIRECTIVE
 144 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
 145 #else
 146 # define SCCS_ENTRY /* nothing */
 147 #endif
 148
 149 /* Use the table to generate a series of prototypes, an enum for the
 150    directive names, and an array of directive handlers.  */
 151
 152 /* The directive-processing functions are declared to return int
 153    instead of void, because some old compilers have trouble with
 154    pointers to functions returning void.  */
 155
 156 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
 157 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
 158 DIRECTIVE_TABLE
 159 #undef D
 160
 161 #define D(n, tag, o, f) tag,
 162 enum
 163 {
 164   T_BAD_DIRECTIVE,
 165   DIRECTIVE_TABLE
 166   N_DIRECTIVES
 167 };
 168 #undef D
 169
 170 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
 171 #define D(name, t, origin, flags) \
 172 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
 173   sizeof STRINGX(name) - 1, origin, flags },
 174 static const directive dtable[] =
 175 {
 176 DIRECTIVE_TABLE
 177 };
 178 #undef D
 179 #undef DIRECTIVE_TABLE
 180
 181 /* Skip any remaining tokens in a directive.  */
 182 static void
 183 skip_rest_of_line (pfile)
 184      cpp_reader *pfile;
 185 {
 186   cpp_token token;
 187
 188   /* Discard all input lookaheads.  */
 189   while (pfile->la_read)
 190     _cpp_release_lookahead (pfile);
 191
 192   /* Discard all stacked contexts.  */
 193   while (pfile->context != &pfile->base_context)
 194     _cpp_pop_context (pfile);
 195
 196   /* Sweep up all tokens remaining on the line.  */
 197   pfile->state.prevent_expansion++;
 198   while (!pfile->state.next_bol)
 199     _cpp_lex_token (pfile, &token);
 200   pfile->state.prevent_expansion--;
 201 }
 202
 203 /* Ensure there are no stray tokens at the end of a directive.  */
 204 static void
 205 check_eol (pfile)
 206      cpp_reader *pfile;
 207 {
 208   if (!pfile->state.next_bol)
 209     {
 210       cpp_token token;
 211
 212       _cpp_lex_token (pfile, &token);
 213       if (token.type != CPP_EOF)
 214         cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
 215                      pfile->directive->name);
 216     }
 217 }
 218
 219 /* Called when entering a directive, _Pragma or command-line directive.  */
 220 static void
 221 start_directive (pfile)
 222      cpp_reader *pfile;
 223 {
 224   cpp_buffer *buffer = pfile->buffer;
 225
 226   /* Setup in-directive state.  */
 227   pfile->state.in_directive = 1;
 228   pfile->state.save_comments = 0;
 229
 230   /* Some handlers need the position of the # for diagnostics.  */
 231   pfile->directive_pos = pfile->lexer_pos;
 232
 233   /* Don't save directive tokens for external clients.  */
 234   pfile->la_saved = pfile->la_write;
 235   pfile->la_write = 0;
 236
 237   /* Turn off skipping.  */
 238   buffer->was_skipping = pfile->skipping;
 239   pfile->skipping = 0;
 240 }
 241
 242 /* Called when leaving a directive, _Pragma or command-line directive.  */
 243 static void
 244 end_directive (pfile, skip_line)
 245      cpp_reader *pfile;
 246      int skip_line;
 247 {
 248   cpp_buffer *buffer = pfile->buffer;
 249
 250   /* We don't skip for an assembler #.  */
 251   if (skip_line)
 252     skip_rest_of_line (pfile);
 253
 254   /* Restore pfile->skipping after skip_rest_of_line.  Otherwise the
 255      lexer might not return!  */
 256   pfile->skipping = buffer->was_skipping;
 257
 258   /* Restore state.  */
 259   pfile->la_write = pfile->la_saved;
 260   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
 261   pfile->state.in_directive = 0;
 262   pfile->state.angled_headers = 0;
 263   pfile->state.line_extension = 0;
 264   pfile->directive = 0;
 265 }
 266
 267 /* Check if a token's name matches that of a known directive.  Put in
 268    this file to save exporting dtable and other unneeded information.  */
 269 int
 270 _cpp_handle_directive (pfile, indented)
 271      cpp_reader *pfile;
 272      int indented;
 273 {
 274   cpp_buffer *buffer = pfile->buffer;
 275   const directive *dir = 0;
 276   cpp_token dname;
 277   int skip = 1;
 278
 279   start_directive (pfile);
 280
 281   /* Lex the directive name directly.  */
 282   _cpp_lex_token (pfile, &dname);
 283
 284   if (dname.type == CPP_NAME)
 285     {
 286       unsigned int index = dname.val.node->directive_index;
 287       if (index)
 288         dir = &dtable[index - 1];
 289     }
 290   else if (dname.type == CPP_NUMBER)
 291     {
 292       /* # followed by a number is equivalent to #line.  Do not
 293          recognize this form in assembly language source files or
 294          skipped conditional groups.  Complain about this form if
 295          we're being pedantic, but not if this is regurgitated input
 296          (preprocessed or fed back in by the C++ frontend).  */
 297       if (! buffer->was_skipping && CPP_OPTION (pfile, lang) != CLK_ASM)
 298         {
 299           dir = &dtable[T_LINE];
 300           pfile->state.line_extension = 1;
 301           _cpp_push_token (pfile, &dname, &pfile->directive_pos);
 302           if (CPP_PEDANTIC (pfile) && buffer->inc
 303               && ! CPP_OPTION (pfile, preprocessed))
 304             cpp_pedwarn (pfile, "# followed by integer");
 305         }
 306     }
 307
 308   pfile->directive = dir;
 309   if (dir)
 310     {
 311       /* Make sure we lex headers correctly, whether skipping or not.  */
 312       pfile->state.angled_headers = dir->flags & INCL;
 313
 314       /* If we are rescanning preprocessed input, only directives tagged
 315          with IN_I are honored, and the warnings below are suppressed.  */
 316       if (! CPP_OPTION (pfile, preprocessed) || dir->flags & IN_I)
 317         {
 318           /* Traditionally, a directive is ignored unless its # is in
 319              column 1.  Therefore in code intended to work with K+R
 320              compilers, directives added by C89 must have their #
 321              indented, and directives present in traditional C must
 322              not.  This is true even of directives in skipped
 323              conditional blocks.  */
 324           if (CPP_WTRADITIONAL (pfile))
 325             {
 326               if (indented && dir->origin == KANDR)
 327                 cpp_warning (pfile,
 328                              "traditional C ignores #%s with the # indented",
 329                              dir->name);
 330               else if (!indented && dir->origin != KANDR)
 331                 cpp_warning (pfile,
 332              "suggest hiding #%s from traditional C with an indented #",
 333                              dir->name);
 334             }
 335
 336           /* If we are skipping a failed conditional group, all
 337              non-conditional directives are ignored.  */
 338           if (! buffer->was_skipping || (dir->flags & COND))
 339             {
 340               /* Issue -pedantic warnings for extensions.   */
 341               if (CPP_PEDANTIC (pfile) && dir->origin == EXTENSION)
 342                 cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
 343
 344               /* If we have a directive that is not an opening
 345                  conditional, invalidate any control macro.  */
 346               if (! (dir->flags & IF_COND))
 347                 pfile->mi_state = MI_FAILED;
 348
 349               (*dir->handler) (pfile);
 350             }
 351         }
 352     }
 353   else if (dname.type != CPP_EOF && ! pfile->skipping)
 354     {
 355       /* An unknown directive.  Don't complain about it in assembly
 356          source: we don't know where the comments are, and # may
 357          introduce assembler pseudo-ops.  Don't complain about invalid
 358          directives in skipped conditional groups (6.10 p4).  */
 359       if (CPP_OPTION (pfile, lang) == CLK_ASM)
 360         {
 361           /* Output the # and lookahead token for the assembler.  */
 362           _cpp_push_token (pfile, &dname, &pfile->directive_pos);
 363           skip = 0;
 364         }
 365       else
 366         cpp_error (pfile, "invalid preprocessing directive #%s",
 367                    cpp_token_as_text (pfile, &dname));
 368     }
 369
 370   end_directive (pfile, skip);
 371   return skip;
 372 }
 373
 374 /* Directive handler wrapper used by the command line option
 375    processor.  */
 376 static void
 377 run_directive (pfile, dir_no, buf, count, name)
 378      cpp_reader *pfile;
 379      int dir_no;
 380      const char *buf;
 381      size_t count;
 382      const char *name;
 383 {
 384   unsigned int output_line = pfile->lexer_pos.output_line;
 385   cpp_buffer *buffer = cpp_push_buffer (pfile, (const U_CHAR *) buf, count);
 386
 387   if (buffer)
 388     {
 389       const struct directive *dir = &dtable[dir_no];
 390
 391       if (name)
 392         buffer->nominal_fname = name;
 393       else
 394         buffer->nominal_fname = _("<command line>");
 395
 396       /* For _Pragma, the text is passed through preprocessing stage 3
 397          only, i.e. no trigraphs, no escaped newline removal, and no
 398          macro expansion.  Do the same for command-line directives.  */
 399       buffer->from_stage3 = 1;
 400
 401       if (dir_no == T_PRAGMA)
 402         {
 403           /* A kludge to avoid line markers for _Pragma.  */
 404           pfile->lexer_pos.output_line = output_line;
 405           /* Avoid interpretation of directives in a _Pragma string.  */
 406           pfile->state.next_bol = 0;
 407         }
 408
 409       start_directive (pfile);
 410       pfile->state.prevent_expansion++;
 411       (void) (*dir->handler) (pfile);
 412       pfile->state.prevent_expansion--;
 413       check_eol (pfile);
 414       end_directive (pfile, 1);
 415
 416       cpp_pop_buffer (pfile);
 417     }
 418 }
 419
 420 /* Checks for validity the macro name in #define, #undef, #ifdef and
 421    #ifndef directives.  */
 422 static cpp_hashnode *
 423 lex_macro_node (pfile)
 424      cpp_reader *pfile;
 425 {
 426   cpp_token token;
 427
 428   /* Lex the macro name directly.  */
 429   _cpp_lex_token (pfile, &token);
 430
 431   /* The token immediately after #define must be an identifier.  That
 432      identifier is not allowed to be "defined".  See predefined macro
 433      names (6.10.8.4).  In C++, it is not allowed to be any of the
 434      <iso646.h> macro names (which are keywords in C++) either.  */
 435
 436   if (token.type != CPP_NAME)
 437     {
 438       if (token.type == CPP_EOF)
 439         cpp_error (pfile, "no macro name given in #%s directive",
 440                    pfile->directive->name);
 441       else if (token.flags & NAMED_OP)
 442         cpp_error (pfile,
 443                    "\"%s\" cannot be used as a macro name as it is an operator in C++",
 444                    token.val.node->name);
 445       else
 446         cpp_error (pfile, "macro names must be identifiers");
 447     }
 448   else
 449     {
 450       cpp_hashnode *node = token.val.node;
 451
 452       /* In Objective C, some keywords begin with '@', but general
 453          identifiers do not, and you're not allowed to #define them.  */
 454       if (node == pfile->spec_nodes.n_defined || node->name[0] == '@')
 455         cpp_error (pfile, "\"%s\" cannot be used as a macro name", node->name);
 456       else if (!(node->flags & NODE_POISONED))
 457         return node;
 458     }
 459
 460   return 0;
 461 }
 462
 463 /* Process a #define directive.  Most work is done in cppmacro.c.  */
 464 static void
 465 do_define (pfile)
 466      cpp_reader *pfile;
 467 {
 468   cpp_hashnode *node = lex_macro_node (pfile);
 469
 470   if (node)
 471     {
 472       /* Use the permanent pool for storage.  */
 473       pfile->string_pool = &pfile->ident_pool;
 474
 475       if (_cpp_create_definition (pfile, node))
 476         if (pfile->cb.define)
 477           (*pfile->cb.define) (pfile, node);
 478
 479       /* Revert to the temporary pool.  */
 480       pfile->string_pool = &pfile->temp_string_pool;
 481     }
 482 }
 483
 484 /* Handle #undef.  Marks the identifier NT_VOID in the hash table.  */
 485 static void
 486 do_undef (pfile)
 487      cpp_reader *pfile;
 488 {
 489   cpp_hashnode *node = lex_macro_node (pfile);
 490
 491   /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
 492      is not currently defined as a macro name.  */
 493   if (node && node->type == NT_MACRO)
 494     {
 495       if (pfile->cb.undef)
 496         (*pfile->cb.undef) (pfile, node);
 497
 498       if (node->flags & NODE_BUILTIN)
 499         cpp_warning (pfile, "undefining \"%s\"", node->name);
 500
 501       _cpp_free_definition (node);
 502     }
 503   check_eol (pfile);
 504 }
 505
 506 /* Helper routine used by parse_include.  Reinterpret the current line
 507    as an h-char-sequence (< ... >); we are looking at the first token
 508    after the <.  Returns zero on success.  */
 509 static int
 510 glue_header_name (pfile, header)
 511      cpp_reader *pfile;
 512      cpp_token *header;
 513 {
 514   cpp_token token;
 515   unsigned char *buffer, *token_mem;
 516   size_t len, total_len = 0, capacity = 1024;
 517
 518   /* To avoid lexed tokens overwriting our glued name, we can only
 519      allocate from the string pool once we've lexed everything.  */
 520
 521   buffer = (unsigned char *) xmalloc (capacity);
 522   for (;;)
 523     {
 524       cpp_get_token (pfile, &token);
 525
 526       if (token.type == CPP_GREATER || token.type == CPP_EOF)
 527         break;
 528
 529       len = cpp_token_len (&token);
 530       if (total_len + len > capacity)
 531         {
 532           capacity = (capacity + len) * 2;
 533           buffer = (unsigned char *) xrealloc (buffer, capacity);
 534         }
 535
 536       if (token.flags & PREV_WHITE)
 537         buffer[total_len++] = ' ';
 538
 539       total_len = cpp_spell_token (pfile, &token, &buffer[total_len]) - buffer;
 540     }
 541
 542   if (token.type == CPP_EOF)
 543     cpp_error (pfile, "missing terminating > character");
 544   else
 545     {
 546       token_mem = _cpp_pool_alloc (pfile->string_pool, total_len);
 547       memcpy (token_mem, buffer, total_len);
 548
 549       header->type = CPP_HEADER_NAME;
 550       header->flags &= ~PREV_WHITE;
 551       header->val.str.len = total_len;
 552       header->val.str.text = token_mem;
 553     }
 554
 555   free ((PTR) buffer);
 556   return token.type == CPP_EOF;
 557 }
 558
 559 /* Parse the header name of #include, #include_next, #import and
 560    #pragma dependency.  Returns zero on success.  */
 561 static int
 562 parse_include (pfile, header)
 563      cpp_reader *pfile;
 564      cpp_token *header;
 565 {
 566   int is_pragma = pfile->directive == &dtable[T_PRAGMA];
 567   const unsigned char *dir;
 568
 569   if (is_pragma)
 570     dir = U"pragma dependency";
 571   else
 572     dir = pfile->directive->name;
 573
 574   /* Allow macro expansion.  */
 575   cpp_get_token (pfile, header);
 576   if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
 577     {
 578       if (header->type != CPP_LESS)
 579         {
 580           cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
 581           return 1;
 582         }
 583       if (glue_header_name (pfile, header))
 584         return 1;
 585     }
 586
 587   if (header->val.str.len == 0)
 588     {
 589       cpp_error (pfile, "empty file name in #%s", dir);
 590       return 1;
 591     }
 592
 593   if (!is_pragma)
 594     {
 595       check_eol (pfile);
 596       /* Get out of macro context, if we are.  */
 597       skip_rest_of_line (pfile);
 598       if (pfile->cb.include)
 599         (*pfile->cb.include) (pfile, dir, header);
 600     }
 601
 602   return 0;
 603 }
 604
 605 static void
 606 do_include (pfile)
 607      cpp_reader *pfile;
 608 {
 609   cpp_token header;
 610
 611   if (!parse_include (pfile, &header))
 612     _cpp_execute_include (pfile, &header, 0, 0);
 613 }
 614
 615 static void
 616 do_import (pfile)
 617      cpp_reader *pfile;
 618 {
 619   cpp_token header;
 620
 621   if (!pfile->import_warning && CPP_OPTION (pfile, warn_import))
 622     {
 623       pfile->import_warning = 1;
 624       cpp_warning (pfile,
 625            "#import is obsolete, use an #ifndef wrapper in the header file");
 626     }
 627
 628   if (!parse_include (pfile, &header))
 629     _cpp_execute_include (pfile, &header, 1, 0);
 630 }
 631
 632 static void
 633 do_include_next (pfile)
 634      cpp_reader *pfile;
 635 {
 636   cpp_token header;
 637
 638   if (!parse_include (pfile, &header))
 639     _cpp_execute_include (pfile, &header, 0, 1);
 640 }
 641
 642 /* Subroutine of do_line.  Read possible flags after file name.  If it
 643    is a number between 1 and 4, return it, otherwise return 0.  If
 644    it's not the end of the directive complain.  */
 645
 646 static unsigned int
 647 read_flag (pfile)
 648      cpp_reader *pfile;
 649 {
 650   cpp_token token;
 651
 652   _cpp_lex_token (pfile, &token);
 653   if (token.type == CPP_NUMBER && token.val.str.len == 1)
 654     {
 655       unsigned int flag = token.val.str.text[0] - '1';
 656       if (flag <= 3)
 657         return flag + 1;
 658     }
 659
 660   if (token.type != CPP_EOF)
 661     cpp_error (pfile, "invalid flag \"%s\" in line directive",
 662                cpp_token_as_text (pfile, &token));
 663   return 0;
 664 }
 665
 666 /* Another subroutine of do_line.  Convert a number in STR, of length
 667    LEN, to binary; store it in NUMP, and return 0 if the number was
 668    well-formed, 1 if not.  Temporary, hopefully.  */
 669 static int
 670 strtoul_for_line (str, len, nump)
 671      const U_CHAR *str;
 672      unsigned int len;
 673      unsigned long *nump;
 674 {
 675   unsigned long reg = 0;
 676   U_CHAR c;
 677   while (len--)
 678     {
 679       c = *str++;
 680       if (!ISDIGIT (c))
 681         return 1;
 682       reg *= 10;
 683       reg += c - '0';
 684     }
 685   *nump = reg;
 686   return 0;
 687 }
 688
 689 /* Interpret #line command.
 690    Note that the filename string (if any) is treated as if it were an
 691    include filename.  That means no escape handling.  */
 692
 693 static void
 694 do_line (pfile)
 695      cpp_reader *pfile;
 696 {
 697   cpp_buffer *buffer = pfile->buffer;
 698   const char *filename = buffer->nominal_fname;
 699   unsigned int lineno = buffer->lineno;
 700   enum cpp_fc_reason reason = FC_RENAME;
 701   unsigned long new_lineno;
 702   unsigned int cap;
 703   cpp_token token;
 704
 705   /* C99 raised the minimum limit on #line numbers.  */
 706   cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
 707
 708   /* #line commands expand macros.  */
 709   cpp_get_token (pfile, &token);
 710   if (token.type != CPP_NUMBER
 711       || strtoul_for_line (token.val.str.text, token.val.str.len, &new_lineno))
 712     {
 713       cpp_error (pfile, "\"%s\" after #line is not a positive integer",
 714                  cpp_token_as_text (pfile, &token));
 715       return;
 716     }
 717
 718   if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
 719     cpp_pedwarn (pfile, "line number out of range");
 720
 721   cpp_get_token (pfile, &token);
 722   if (token.type == CPP_STRING)
 723     {
 724       char *fname;
 725       unsigned int len;
 726
 727       /* FIXME: memory leak.  */
 728       len = token.val.str.len;
 729       fname = xmalloc (len + 1);
 730       memcpy (fname, token.val.str.text, len);
 731       fname[len] = '\0';
 732
 733       _cpp_simplify_pathname (fname);
 734       buffer->nominal_fname = fname;
 735
 736       if (pfile->state.line_extension)
 737         {
 738           int flag, sysp = 0;
 739
 740           flag = read_flag (pfile);
 741           if (flag == 1)
 742             {
 743               reason = FC_ENTER;
 744               flag = read_flag (pfile);
 745             }
 746           else if (flag == 2)
 747             {
 748               reason = FC_LEAVE;
 749               flag = read_flag (pfile);
 750             }
 751           if (flag == 3)
 752             {
 753               flag = read_flag (pfile);
 754               sysp = 1;
 755             }
 756
 757           cpp_make_system_header (pfile, sysp, flag == 4);
 758         }
 759
 760       check_eol (pfile);
 761     }
 762   else if (token.type != CPP_EOF)
 763     {
 764       cpp_error (pfile, "\"%s\" is not a valid filename",
 765                  cpp_token_as_text (pfile, &token));
 766       return;
 767     }
 768
 769   /* Our line number is incremented after the directive is processed.  */
 770   buffer->lineno = new_lineno - 1;
 771   _cpp_do_file_change (pfile, reason, filename, lineno);
 772 }
 773
 774 /* Arrange the file_change callback.  The assumption is that the
 775    current buffer's lineno is one less than the next line.  */
 776 void
 777 _cpp_do_file_change (pfile, reason, from_file, from_lineno)
 778      cpp_reader *pfile;
 779      enum cpp_fc_reason reason;
 780      const char *from_file;
 781      unsigned int from_lineno;
 782 {
 783   if (pfile->cb.change_file)
 784     {
 785       cpp_file_change fc;
 786       cpp_buffer *buffer = pfile->buffer;
 787
 788       fc.reason = reason;
 789       fc.from.filename = from_file;
 790       fc.from.lineno = from_lineno;
 791       fc.to.filename = buffer->nominal_fname;
 792       fc.to.lineno = buffer->lineno + 1;
 793       fc.sysp = buffer->sysp;
 794       fc.externc = CPP_OPTION (pfile, cplusplus) && buffer->sysp == 2;
 795       pfile->cb.change_file (pfile, &fc);
 796     }
 797 }
 798
 799 /*
 800  * Report a warning or error detected by the program we are
 801  * processing.  Use the directive's tokens in the error message.
 802  */
 803
 804 static void
 805 do_diagnostic (pfile, code, print_dir)
 806      cpp_reader *pfile;
 807      enum error_type code;
 808      int print_dir;
 809 {
 810   if (_cpp_begin_message (pfile, code, NULL, 0))
 811     {
 812       if (print_dir)
 813         fprintf (stderr, "#%s ", pfile->directive->name);
 814       pfile->state.prevent_expansion++;
 815       cpp_output_line (pfile, stderr);
 816       pfile->state.prevent_expansion--;
 817     }
 818 }
 819
 820 static void
 821 do_error (pfile)
 822      cpp_reader *pfile;
 823 {
 824   do_diagnostic (pfile, ERROR, 1);
 825 }
 826
 827 static void
 828 do_warning (pfile)
 829      cpp_reader *pfile;
 830 {
 831   do_diagnostic (pfile, WARNING, 1);
 832 }
 833
 834 /* Report program identification.  */
 835
 836 static void
 837 do_ident (pfile)
 838      cpp_reader *pfile;
 839 {
 840   cpp_token str;
 841
 842   cpp_get_token (pfile, &str);
 843   if (str.type != CPP_STRING)
 844     cpp_error (pfile, "invalid #ident");
 845   else if (pfile->cb.ident)
 846     (*pfile->cb.ident) (pfile, &str.val.str);
 847
 848   check_eol (pfile);
 849 }
 850
 851 /* Pragmata handling.  We handle some of these, and pass the rest on
 852    to the front end.  C99 defines three pragmas and says that no macro
 853    expansion is to be performed on them; whether or not macro
 854    expansion happens for other pragmas is implementation defined.
 855    This implementation never macro-expands the text after #pragma.  */
 856
 857 /* Sub-handlers for the pragmas needing treatment here.
 858    They return 1 if the token buffer is to be popped, 0 if not. */
 859 struct pragma_entry
 860 {
 861   struct pragma_entry *next;
 862   const char *name;
 863   size_t len;
 864   int isnspace;
 865   union {
 866     void (*handler) PARAMS ((cpp_reader *));
 867     struct pragma_entry *space;
 868   } u;
 869 };
 870
 871 void
 872 cpp_register_pragma (pfile, space, name, handler)
 873      cpp_reader *pfile;
 874      const char *space;
 875      const char *name;
 876      void (*handler) PARAMS ((cpp_reader *));
 877 {
 878   struct pragma_entry **x, *new;
 879   size_t len;
 880
 881   x = &pfile->pragmas;
 882   if (space)
 883     {
 884       struct pragma_entry *p = pfile->pragmas;
 885       len = strlen (space);
 886       while (p)
 887         {
 888           if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
 889             {
 890               x = &p->u.space;
 891               goto found;
 892             }
 893           p = p->next;
 894         }
 895       cpp_ice (pfile, "unknown #pragma namespace %s", space);
 896       return;
 897     }
 898
 899  found:
 900   new = xnew (struct pragma_entry);
 901   new->name = name;
 902   new->len = strlen (name);
 903   new->isnspace = 0;
 904   new->u.handler = handler;
 905
 906   new->next = *x;
 907   *x = new;
 908 }
 909
 910 void
 911 cpp_register_pragma_space (pfile, space)
 912      cpp_reader *pfile;
 913      const char *space;
 914 {
 915   struct pragma_entry *new;
 916   const struct pragma_entry *p = pfile->pragmas;
 917   size_t len = strlen (space);
 918
 919   while (p)
 920     {
 921       if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
 922         /* Multiple different callers are allowed to register the same
 923            namespace.  */
 924         return;
 925       p = p->next;
 926     }
 927
 928   new = xnew (struct pragma_entry);
 929   new->name = space;
 930   new->len = len;
 931   new->isnspace = 1;
 932   new->u.space = 0;
 933
 934   new->next = pfile->pragmas;
 935   pfile->pragmas = new;
 936 }
 937
 938 void
 939 _cpp_init_internal_pragmas (pfile)
 940      cpp_reader *pfile;
 941 {
 942   /* top level */
 943   cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
 944   cpp_register_pragma (pfile, 0, "once", do_pragma_once);
 945
 946   /* GCC namespace */
 947   cpp_register_pragma_space (pfile, "GCC");
 948
 949   cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
 950   cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
 951   cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
 952 }
 953
 954 static void
 955 do_pragma (pfile)
 956      cpp_reader *pfile;
 957 {
 958   const struct pragma_entry *p;
 959   cpp_token tok;
 960   const cpp_hashnode *node;
 961   const U_CHAR *name;
 962   size_t len;
 963   int drop = 0;
 964
 965   p = pfile->pragmas;
 966   pfile->state.prevent_expansion++;
 967   cpp_start_lookahead (pfile);
 968
 969  new_space:
 970   cpp_get_token (pfile, &tok);
 971   if (tok.type == CPP_NAME)
 972     {
 973       node = tok.val.node;
 974       name = node->name;
 975       len = node->length;
 976       while (p)
 977         {
 978           if (strlen (p->name) == len && !memcmp (p->name, name, len))
 979             {
 980               if (p->isnspace)
 981                 {
 982                   p = p->u.space;
 983                   goto new_space;
 984                 }
 985               else
 986                 {
 987                   (*p->u.handler) (pfile);
 988                   drop = 1;
 989                   break;
 990                 }
 991             }
 992           p = p->next;
 993         }
 994     }
 995
 996   cpp_stop_lookahead (pfile, drop);
 997   pfile->state.prevent_expansion--;
 998
 999   if (!drop && pfile->cb.def_pragma)
1000     (*pfile->cb.def_pragma) (pfile);
1001 }
1002
1003 static void
1004 do_pragma_once (pfile)
1005      cpp_reader *pfile;
1006 {
1007   cpp_warning (pfile, "#pragma once is obsolete");
1008
1009   if (pfile->buffer->prev == NULL)
1010     cpp_warning (pfile, "#pragma once in main file");
1011   else
1012     _cpp_never_reread (pfile->buffer->inc);
1013
1014   check_eol (pfile);
1015 }
1016
1017 static void
1018 do_pragma_poison (pfile)
1019      cpp_reader *pfile;
1020 {
1021   /* Poison these symbols so that all subsequent usage produces an
1022      error message.  */
1023   cpp_token tok;
1024   cpp_hashnode *hp;
1025
1026   pfile->state.poisoned_ok = 1;
1027   for (;;)
1028     {
1029       _cpp_lex_token (pfile, &tok);
1030       if (tok.type == CPP_EOF)
1031         break;
1032       if (tok.type != CPP_NAME)
1033         {
1034           cpp_error (pfile, "invalid #pragma GCC poison directive");
1035           break;
1036         }
1037
1038       hp = tok.val.node;
1039       if (hp->flags & NODE_POISONED)
1040         continue;
1041
1042       if (hp->type == NT_MACRO)
1043         cpp_warning (pfile, "poisoning existing macro \"%s\"", hp->name);
1044       _cpp_free_definition (hp);
1045       hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1046     }
1047   pfile->state.poisoned_ok = 0;
1048
1049 #if 0                           /* Doesn't quite work yet.  */
1050   if (tok.type == CPP_EOF && pfile->cb.poison)
1051     (*pfile->cb.poison) (pfile);
1052 #endif
1053 }
1054
1055 /* Mark the current header as a system header.  This will suppress
1056    some categories of warnings (notably those from -pedantic).  It is
1057    intended for use in system libraries that cannot be implemented in
1058    conforming C, but cannot be certain that their headers appear in a
1059    system include directory.  To prevent abuse, it is rejected in the
1060    primary source file.  */
1061 static void
1062 do_pragma_system_header (pfile)
1063      cpp_reader *pfile;
1064 {
1065   cpp_buffer *buffer = pfile->buffer;
1066
1067   if (buffer->prev == 0)
1068     cpp_warning (pfile, "#pragma system_header ignored outside include file");
1069   else
1070     cpp_make_system_header (pfile, 1, 0);
1071
1072   check_eol (pfile);
1073 }
1074
1075 /* Check the modified date of the current include file against a specified
1076    file. Issue a diagnostic, if the specified file is newer. We use this to
1077    determine if a fixed header should be refixed.  */
1078 static void
1079 do_pragma_dependency (pfile)
1080      cpp_reader *pfile;
1081 {
1082   cpp_token header, msg;
1083   int ordering;
1084
1085   if (parse_include (pfile, &header))
1086     return;
1087
1088   ordering = _cpp_compare_file_date (pfile, &header);
1089   if (ordering < 0)
1090     cpp_warning (pfile, "cannot find source %s",
1091                  cpp_token_as_text (pfile, &header));
1092   else if (ordering > 0)
1093     {
1094       cpp_warning (pfile, "current file is older than %s",
1095                    cpp_token_as_text (pfile, &header));
1096       cpp_start_lookahead (pfile);
1097       cpp_get_token (pfile, &msg);
1098       cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
1099       if (msg.type != CPP_EOF)
1100         do_diagnostic (pfile, WARNING, 0);
1101     }
1102 }
1103
1104 /* Check syntax is "(string-literal)".  Returns 0 on success.  */
1105 static int
1106 get__Pragma_string (pfile, string)
1107      cpp_reader *pfile;
1108      cpp_token *string;
1109 {
1110   cpp_token paren;
1111
1112   cpp_get_token (pfile, &paren);
1113   if (paren.type != CPP_OPEN_PAREN)
1114     return 1;
1115
1116   cpp_get_token (pfile, string);
1117   if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1118     return 1;
1119
1120   cpp_get_token (pfile, &paren);
1121   return paren.type != CPP_CLOSE_PAREN;
1122 }
1123
1124 /* Returns a malloced buffer containing a destringized cpp_string by
1125    removing the first \ of \" and \\ sequences.  */
1126 static unsigned char *
1127 destringize (in, len)
1128      const cpp_string *in;
1129      unsigned int *len;
1130 {
1131   const unsigned char *src, *limit;
1132   unsigned char *dest, *result;
1133
1134   dest = result = (unsigned char *) xmalloc (in->len);
1135   for (src = in->text, limit = src + in->len; src < limit;)
1136     {
1137       /* We know there is a character following the backslash.  */
1138       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1139         src++;
1140       *dest++ = *src++;
1141     }
1142
1143   *len = dest - result;
1144   return result;
1145 }
1146
1147 void
1148 _cpp_do__Pragma (pfile)
1149      cpp_reader *pfile;
1150 {
1151   cpp_token string;
1152   unsigned char *buffer;
1153   unsigned int len;
1154
1155   if (get__Pragma_string (pfile, &string))
1156     {
1157       cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1158       return;
1159     }
1160
1161   buffer = destringize (&string.val.str, &len);
1162   run_directive (pfile, T_PRAGMA, (char *) buffer, len, _("<_Pragma>"));
1163   free ((PTR) buffer);
1164 }
1165
1166 /* Just ignore #sccs, on systems where we define it at all.  */
1167 #ifdef SCCS_DIRECTIVE
1168 static void
1169 do_sccs (pfile)
1170      cpp_reader *pfile ATTRIBUTE_UNUSED;
1171 {
1172 }
1173 #endif
1174
1175 static void
1176 do_ifdef (pfile)
1177      cpp_reader *pfile;
1178 {
1179   int skip = 1;
1180
1181   if (! pfile->buffer->was_skipping)
1182     {
1183       const cpp_hashnode *node = lex_macro_node (pfile);
1184
1185       if (node)
1186         skip = node->type != NT_MACRO;
1187
1188       if (node)
1189         check_eol (pfile);
1190     }
1191
1192   push_conditional (pfile, skip, T_IFDEF, 0);
1193 }
1194
1195 static void
1196 do_ifndef (pfile)
1197      cpp_reader *pfile;
1198 {
1199   int skip = 1;
1200   const cpp_hashnode *node = 0;
1201
1202   if (! pfile->buffer->was_skipping)
1203     {
1204       node = lex_macro_node (pfile);
1205       if (node)
1206         skip = node->type == NT_MACRO;
1207
1208       if (node)
1209         check_eol (pfile);
1210     }
1211
1212   push_conditional (pfile, skip, T_IFNDEF, node);
1213 }
1214
1215 /* #if cooperates with parse_defined to handle multiple-include
1216    optimisations.  If macro expansions or identifiers appear in the
1217    expression, we cannot treat it as a controlling conditional, since
1218    their values could change in the future.  */
1219
1220 static void
1221 do_if (pfile)
1222      cpp_reader *pfile;
1223 {
1224   int skip = 1;
1225   const cpp_hashnode *cmacro = 0;
1226
1227   if (! pfile->buffer->was_skipping)
1228     {
1229       /* Controlling macro of #if ! defined ()  */
1230       pfile->mi_ind_cmacro = 0;
1231       skip = _cpp_parse_expr (pfile) == 0;
1232       cmacro = pfile->mi_ind_cmacro;
1233     }
1234
1235   push_conditional (pfile, skip, T_IF, cmacro);
1236 }
1237
1238 /* Flip skipping state if appropriate and continue without changing
1239    if_stack; this is so that the error message for missing #endif's
1240    etc. will point to the original #if.  */
1241
1242 static void
1243 do_else (pfile)
1244      cpp_reader *pfile;
1245 {
1246   cpp_buffer *buffer = pfile->buffer;
1247   struct if_stack *ifs = buffer->if_stack;
1248
1249   if (ifs == NULL)
1250     cpp_error (pfile, "#else without #if");
1251   else
1252     {
1253       if (ifs->type == T_ELSE)
1254         {
1255           cpp_error (pfile, "#else after #else");
1256           cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1257                                "the conditional began here");
1258         }
1259       ifs->type = T_ELSE;
1260
1261       /* Buffer->was_skipping is 1 if all conditionals in this chain
1262          have been false, 2 if a conditional has been true.  */
1263       if (! ifs->was_skipping && buffer->was_skipping != 2)
1264         buffer->was_skipping = ! buffer->was_skipping;
1265
1266       /* Invalidate any controlling macro.  */
1267       ifs->mi_cmacro = 0;
1268     }
1269
1270   check_eol (pfile);
1271 }
1272
1273 /* handle a #elif directive by not changing if_stack either.  see the
1274    comment above do_else.  */
1275
1276 static void
1277 do_elif (pfile)
1278      cpp_reader *pfile;
1279 {
1280   cpp_buffer *buffer = pfile->buffer;
1281   struct if_stack *ifs = buffer->if_stack;
1282
1283   if (ifs == NULL)
1284     cpp_error (pfile, "#elif without #if");
1285   else
1286     {
1287       if (ifs->type == T_ELSE)
1288         {
1289           cpp_error (pfile, "#elif after #else");
1290           cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1291                                "the conditional began here");
1292         }
1293       ifs->type = T_ELIF;
1294
1295       /* Don't evaluate #elif if our higher level is skipping.  */
1296       if (! ifs->was_skipping)
1297         {
1298           /* Buffer->was_skipping is 1 if all conditionals in this
1299              chain have been false, 2 if a conditional has been true.  */
1300           if (buffer->was_skipping == 1)
1301             buffer->was_skipping = ! _cpp_parse_expr (pfile);
1302           else
1303             buffer->was_skipping = 2;
1304
1305           /* Invalidate any controlling macro.  */
1306           ifs->mi_cmacro = 0;
1307         }
1308     }
1309 }
1310
1311 /* #endif pops the if stack and resets pfile->skipping.  */
1312
1313 static void
1314 do_endif (pfile)
1315      cpp_reader *pfile;
1316 {
1317   cpp_buffer *buffer = pfile->buffer;
1318   struct if_stack *ifs = buffer->if_stack;
1319
1320   if (ifs == NULL)
1321     cpp_error (pfile, "#endif without #if");
1322   else
1323     {
1324       /* If potential control macro, we go back outside again.  */
1325       if (ifs->next == 0 && ifs->mi_cmacro)
1326         {
1327           pfile->mi_state = MI_OUTSIDE;
1328           pfile->mi_cmacro = ifs->mi_cmacro;
1329         }
1330
1331       buffer->if_stack = ifs->next;
1332       buffer->was_skipping = ifs->was_skipping;
1333       obstack_free (pfile->buffer_ob, ifs);
1334     }
1335
1336   check_eol (pfile);
1337 }
1338
1339 /* Push an if_stack entry and set pfile->skipping accordingly.
1340    If this is a #ifndef starting at the beginning of a file,
1341    CMACRO is the macro name tested by the #ifndef.  */
1342
1343 static void
1344 push_conditional (pfile, skip, type, cmacro)
1345      cpp_reader *pfile;
1346      int skip;
1347      int type;
1348      const cpp_hashnode *cmacro;
1349 {
1350   struct if_stack *ifs;
1351   cpp_buffer *buffer = pfile->buffer;
1352
1353   ifs = xobnew (pfile->buffer_ob, struct if_stack);
1354   ifs->pos = pfile->directive_pos;
1355   ifs->next = buffer->if_stack;
1356   ifs->was_skipping = buffer->was_skipping;
1357   ifs->type = type;
1358   if (pfile->mi_state == MI_OUTSIDE && pfile->mi_cmacro == 0)
1359     ifs->mi_cmacro = cmacro;
1360   else
1361     ifs->mi_cmacro = 0;
1362
1363   buffer->was_skipping = skip;
1364   buffer->if_stack = ifs;
1365 }
1366
1367 /* Read the tokens of the answer into the macro pool.  Only commit the
1368    memory if we intend it as permanent storage, i.e. the #assert case.
1369    Returns 0 on success.  */
1370
1371 static int
1372 parse_answer (pfile, answerp, type)
1373      cpp_reader *pfile;
1374      struct answer **answerp;
1375      int type;
1376 {
1377   cpp_token paren, *token;
1378   struct answer *answer;
1379
1380   if (POOL_FRONT (&pfile->macro_pool) + sizeof (struct answer) >
1381       POOL_LIMIT (&pfile->macro_pool))
1382     _cpp_next_chunk (&pfile->macro_pool, sizeof (struct answer), 0);
1383   answer = (struct answer *) POOL_FRONT (&pfile->macro_pool);
1384   answer->count = 0;
1385
1386   /* In a conditional, it is legal to not have an open paren.  We
1387      should save the following token in this case.  */
1388   if (type == T_IF)
1389     cpp_start_lookahead (pfile);
1390   cpp_get_token (pfile, &paren);
1391   if (type == T_IF)
1392     cpp_stop_lookahead (pfile, paren.type == CPP_OPEN_PAREN);
1393
1394   /* If not a paren, see if we're OK.  */
1395   if (paren.type != CPP_OPEN_PAREN)
1396     {
1397       /* In a conditional no answer is a test for any answer.  It
1398          could be followed by any token.  */
1399       if (type == T_IF)
1400         return 0;
1401
1402       /* #unassert with no answer is valid - it removes all answers.  */
1403       if (type == T_UNASSERT && paren.type == CPP_EOF)
1404         return 0;
1405
1406       cpp_error (pfile, "missing '(' after predicate");
1407       return 1;
1408     }
1409
1410   for (;;)
1411     {
1412       token = &answer->first[answer->count];
1413       /* Check we have room for the token.  */
1414       if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1415         {
1416           _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1417                            (unsigned char **) &answer);
1418           token = &answer->first[answer->count];
1419         }
1420
1421       cpp_get_token (pfile, token);
1422       if (token->type == CPP_CLOSE_PAREN)
1423         break;
1424
1425       if (token->type == CPP_EOF)
1426         {
1427           cpp_error (pfile, "missing ')' to complete answer");
1428           return 1;
1429         }
1430       answer->count++;
1431     }
1432
1433   if (answer->count == 0)
1434     {
1435       cpp_error (pfile, "predicate's answer is empty");
1436       return 1;
1437     }
1438
1439   /* Drop whitespace at start.  */
1440   answer->first->flags &= ~PREV_WHITE;
1441   *answerp = answer;
1442
1443   if (type == T_ASSERT || type == T_UNASSERT)
1444     check_eol (pfile);
1445   return 0;
1446 }
1447
1448 /* Parses an assertion, returning a pointer to the hash node of the
1449    predicate, or 0 on error.  If an answer was supplied, it is placed
1450    in ANSWERP, otherwise it is set to 0.  */
1451 static cpp_hashnode *
1452 parse_assertion (pfile, answerp, type)
1453      cpp_reader *pfile;
1454      struct answer **answerp;
1455      int type;
1456 {
1457   cpp_hashnode *result = 0;
1458   cpp_token predicate;
1459
1460   /* We don't expand predicates or answers.  */
1461   pfile->state.prevent_expansion++;
1462
1463   /* Use the permanent pool for storage (for the answers).  */
1464   pfile->string_pool = &pfile->ident_pool;
1465
1466   *answerp = 0;
1467   cpp_get_token (pfile, &predicate);
1468   if (predicate.type == CPP_EOF)
1469     cpp_error (pfile, "assertion without predicate");
1470   else if (predicate.type != CPP_NAME)
1471     cpp_error (pfile, "predicate must be an identifier");
1472   else if (parse_answer (pfile, answerp, type) == 0)
1473     {
1474       unsigned int len = predicate.val.node->length;
1475       unsigned char *sym = alloca (len + 1);
1476
1477       /* Prefix '#' to get it out of macro namespace.  */
1478       sym[0] = '#';
1479       memcpy (sym + 1, predicate.val.node->name, len);
1480       result = cpp_lookup (pfile, sym, len + 1);
1481     }
1482
1483   pfile->string_pool = &pfile->temp_string_pool;
1484   pfile->state.prevent_expansion--;
1485   return result;
1486 }
1487
1488 /* Returns a pointer to the pointer to the answer in the answer chain,
1489    or a pointer to NULL if the answer is not in the chain.  */
1490 static struct answer **
1491 find_answer (node, candidate)
1492      cpp_hashnode *node;
1493      const struct answer *candidate;
1494 {
1495   unsigned int i;
1496   struct answer **result;
1497
1498   for (result = &node->value.answers; *result; result = &(*result)->next)
1499     {
1500       struct answer *answer = *result;
1501
1502       if (answer->count == candidate->count)
1503         {
1504           for (i = 0; i < answer->count; i++)
1505             if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1506               break;
1507
1508           if (i == answer->count)
1509             break;
1510         }
1511     }
1512
1513   return result;
1514 }
1515
1516 /* Test an assertion within a preprocessor conditional.  Returns
1517    non-zero on failure, zero on success.  On success, the result of
1518    the test is written into VALUE.  */
1519 int
1520 _cpp_test_assertion (pfile, value)
1521      cpp_reader *pfile;
1522      int *value;
1523 {
1524   struct answer *answer;
1525   cpp_hashnode *node;
1526
1527   node = parse_assertion (pfile, &answer, T_IF);
1528   if (node)
1529     *value = (node->type == NT_ASSERTION &&
1530               (answer == 0 || *find_answer (node, answer) != 0));
1531
1532   /* We don't commit the memory for the answer - it's temporary only.  */
1533   return node == 0;
1534 }
1535
1536 static void
1537 do_assert (pfile)
1538      cpp_reader *pfile;
1539 {
1540   struct answer *new_answer;
1541   cpp_hashnode *node;
1542
1543   node = parse_assertion (pfile, &new_answer, T_ASSERT);
1544   if (node)
1545     {
1546       /* Place the new answer in the answer list.  First check there
1547          is not a duplicate.  */
1548       new_answer->next = 0;
1549       if (node->type == NT_ASSERTION)
1550         {
1551           if (*find_answer (node, new_answer))
1552             {
1553               cpp_warning (pfile, "\"%s\" re-asserted", node->name + 1);
1554               return;
1555             }
1556           new_answer->next = node->value.answers;
1557         }
1558       node->type = NT_ASSERTION;
1559       node->value.answers = new_answer;
1560       POOL_COMMIT (&pfile->macro_pool, (sizeof (struct answer)
1561                                         + (new_answer->count - 1)
1562                                         * sizeof (cpp_token)));
1563     }
1564 }
1565
1566 static void
1567 do_unassert (pfile)
1568      cpp_reader *pfile;
1569 {
1570   cpp_hashnode *node;
1571   struct answer *answer;
1572
1573   node = parse_assertion (pfile, &answer, T_UNASSERT);
1574   /* It isn't an error to #unassert something that isn't asserted.  */
1575   if (node && node->type == NT_ASSERTION)
1576     {
1577       if (answer)
1578         {
1579           struct answer **p = find_answer (node, answer), *temp;
1580
1581           /* Remove the answer from the list.  */
1582           temp = *p;
1583           if (temp)
1584             *p = temp->next;
1585
1586           /* Did we free the last answer?  */
1587           if (node->value.answers == 0)
1588             node->type = NT_VOID;
1589         }
1590       else
1591         _cpp_free_definition (node);
1592     }
1593
1594   /* We don't commit the memory for the answer - it's temporary only.  */
1595 }
1596
1597 /* These are for -D, -U, -A.  */
1598
1599 /* Process the string STR as if it appeared as the body of a #define.
1600    If STR is just an identifier, define it with value 1.
1601    If STR has anything after the identifier, then it should
1602    be identifier=definition. */
1603
1604 void
1605 cpp_define (pfile, str)
1606      cpp_reader *pfile;
1607      const char *str;
1608 {
1609   char *buf, *p;
1610   size_t count;
1611
1612   /* Copy the entire option so we can modify it.
1613      Change the first "=" in the string to a space.  If there is none,
1614      tack " 1" on the end.  */
1615
1616   /* Length including the null.  */
1617   count = strlen (str);
1618   buf = (char *) alloca (count + 2);
1619   memcpy (buf, str, count);
1620
1621   p = strchr (str, '=');
1622   if (p)
1623     buf[p - str] = ' ';
1624   else
1625     {
1626       buf[count++] = ' ';
1627       buf[count++] = '1';
1628     }
1629
1630   run_directive (pfile, T_DEFINE, buf, count, 0);
1631 }
1632
1633 /* Slight variant of the above for use by initialize_builtins, which (a)
1634    knows how to set up the buffer itself, (b) needs a different "filename"
1635    tag.  */
1636 void
1637 _cpp_define_builtin (pfile, str)
1638      cpp_reader *pfile;
1639      const char *str;
1640 {
1641   run_directive (pfile, T_DEFINE, str, strlen (str), _("<builtin>"));
1642 }
1643
1644 /* Process MACRO as if it appeared as the body of an #undef.  */
1645 void
1646 cpp_undef (pfile, macro)
1647      cpp_reader *pfile;
1648      const char *macro;
1649 {
1650   run_directive (pfile, T_UNDEF, macro, strlen (macro), 0);
1651 }
1652
1653 /* Process the string STR as if it appeared as the body of a #assert. */
1654 void
1655 cpp_assert (pfile, str)
1656      cpp_reader *pfile;
1657      const char *str;
1658 {
1659   handle_assertion (pfile, str, T_ASSERT);
1660 }
1661
1662 /* Process STR as if it appeared as the body of an #unassert. */
1663 void
1664 cpp_unassert (pfile, str)
1665      cpp_reader *pfile;
1666      const char *str;
1667 {
1668   handle_assertion (pfile, str, T_UNASSERT);
1669 }
1670
1671 /* Common code for cpp_assert (-A) and cpp_unassert (-A-).  */
1672 static void
1673 handle_assertion (pfile, str, type)
1674      cpp_reader *pfile;
1675      const char *str;
1676      int type;
1677 {
1678   size_t count = strlen (str);
1679   const char *p = strchr (str, '=');
1680
1681   if (p)
1682     {
1683       /* Copy the entire option so we can modify it.  Change the first
1684          "=" in the string to a '(', and tack a ')' on the end.  */
1685       char *buf = (char *) alloca (count + 1);
1686
1687       memcpy (buf, str, count);
1688       buf[p - str] = '(';
1689       buf[count++] = ')';
1690       str = buf;
1691     }
1692
1693   run_directive (pfile, type, str, count, 0);
1694 }
1695
1696 /* Push a new buffer on the buffer stack.  Buffer can be NULL, but
1697    then LEN should be 0.  Returns the new buffer; it doesn't fail.  */
1698
1699 cpp_buffer *
1700 cpp_push_buffer (pfile, buffer, len)
1701      cpp_reader *pfile;
1702      const U_CHAR *buffer;
1703      size_t len;
1704 {
1705   cpp_buffer *new = xobnew (pfile->buffer_ob, cpp_buffer);
1706
1707   /* Clears, amongst other things, if_stack and mi_cmacro.  */
1708   memset (new, 0, sizeof (cpp_buffer));
1709   new->line_base = new->buf = new->cur = buffer;
1710   new->rlimit = buffer + len;
1711   new->prev = pfile->buffer;
1712   new->pfile = pfile;
1713   /* Preprocessed files don't do trigraph and escaped newline processing.  */
1714   new->from_stage3 = CPP_OPTION (pfile, preprocessed);
1715   /* No read ahead or extra char initially.  */
1716   new->read_ahead = EOF;
1717   new->extra_char = EOF;
1718
1719   pfile->state.next_bol = 1;
1720   pfile->buffer_stack_depth++;
1721   pfile->lexer_pos.output_line = 1;
1722
1723   pfile->buffer = new;
1724   return new;
1725 }
1726
1727 cpp_buffer *
1728 cpp_pop_buffer (pfile)
1729      cpp_reader *pfile;
1730 {
1731   cpp_buffer *buffer = pfile->buffer;
1732   const char *filename = buffer->nominal_fname;
1733   unsigned int lineno = buffer->lineno;
1734   struct if_stack *ifs = buffer->if_stack;
1735   int wfb = (buffer->inc != 0);
1736
1737   /* Walk back up the conditional stack till we reach its level at
1738      entry to this file, issuing error messages.  */
1739   for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1740     cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1741                          "unterminated #%s", dtable[ifs->type].name);
1742
1743   if (wfb)
1744     _cpp_pop_file_buffer (pfile, buffer);
1745
1746   pfile->buffer = buffer->prev;
1747   obstack_free (pfile->buffer_ob, buffer);
1748   pfile->buffer_stack_depth--;
1749
1750   if (pfile->buffer && wfb)
1751     _cpp_do_file_change (pfile, FC_LEAVE, filename, lineno);
1752
1753   return pfile->buffer;
1754 }
1755
1756 #define obstack_chunk_alloc xmalloc
1757 #define obstack_chunk_free free
1758 void
1759 _cpp_init_stacks (pfile)
1760      cpp_reader *pfile;
1761 {
1762   int i;
1763   cpp_hashnode *node;
1764
1765   pfile->buffer_ob = xnew (struct obstack);
1766   obstack_init (pfile->buffer_ob);
1767
1768   /* Register the directives.  */
1769   for (i = 1; i < N_DIRECTIVES; i++)
1770     {
1771       node = cpp_lookup (pfile, dtable[i - 1].name, dtable[i - 1].length);
1772       node->directive_index = i;
1773     }
1774 }
1775
1776 void
1777 _cpp_cleanup_stacks (pfile)
1778      cpp_reader *pfile;
1779 {
1780   obstack_free (pfile->buffer_ob, 0);
1781   free (pfile->buffer_ob);
1782 }