gcc/cpplib.c

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