gcc/cpplib.c

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