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