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 #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 && ! buffer->was_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       /* Only accept flags for the # 55 form.  */
 720       if (! pfile->state.line_extension)
 721         check_eol (pfile);
 722       else
 723         {
 724           int flag = 0, sysp = 0;
 725
 726           flag = read_flag (pfile, flag);
 727           if (flag == 1)
 728             {
 729               reason = FC_ENTER;
 730               flag = read_flag (pfile, flag);
 731             }
 732           else if (flag == 2)
 733             {
 734               reason = FC_LEAVE;
 735               flag = read_flag (pfile, flag);
 736             }
 737           if (flag == 3)
 738             {
 739               sysp = 1;
 740               flag = read_flag (pfile, flag);
 741               if (flag == 4)
 742                 sysp = 2, read_flag (pfile, flag);
 743             }
 744
 745           if (reason == FC_ENTER)
 746             {
 747               /* Fake a buffer stack for diagnostics.  */
 748               cpp_push_buffer (pfile, 0, 0, BUF_FAKE, fname);
 749               /* Fake an include for cpp_included.  */
 750               _cpp_fake_include (pfile, fname);
 751               buffer = pfile->buffer;
 752             }
 753           else if (reason == FC_LEAVE)
 754             {
 755               if (buffer->type != BUF_FAKE)
 756                 cpp_warning (pfile, "file \"%s\" left but not entered",
 757                              buffer->nominal_fname);
 758               else
 759                 {
 760                   cpp_pop_buffer (pfile);
 761                   buffer = pfile->buffer;
 762                   if (strcmp (buffer->nominal_fname, fname))
 763                     cpp_warning (pfile, "expected to return to file \"%s\"",
 764                                  buffer->nominal_fname);
 765                   if (buffer->lineno + 1 != new_lineno)
 766                     cpp_warning (pfile, "expected to return to line number %u",
 767                                  buffer->lineno + 1);
 768                   if (buffer->sysp != sysp)
 769                     cpp_warning (pfile, "header flags for \"%s\" have changed",
 770                                  buffer->nominal_fname);
 771                 }
 772             }
 773           buffer->sysp = sysp;
 774         }
 775       buffer->nominal_fname = fname;
 776     }
 777   else if (token.type != CPP_EOF)
 778     {
 779       cpp_error (pfile, "\"%s\" is not a valid filename",
 780                  cpp_token_as_text (pfile, &token));
 781       return;
 782     }
 783
 784   /* Our line number is incremented after the directive is processed.  */
 785   buffer->lineno = new_lineno - 1;
 786   _cpp_do_file_change (pfile, reason, filename, lineno);
 787 }
 788
 789 /* Arrange the file_change callback.  */
 790 void
 791 _cpp_do_file_change (pfile, reason, from_file, from_lineno)
 792      cpp_reader *pfile;
 793      enum cpp_fc_reason reason;
 794      const char *from_file;
 795      unsigned int from_lineno;
 796 {
 797   if (pfile->cb.file_change)
 798     {
 799       cpp_file_change fc;
 800       cpp_buffer *buffer = pfile->buffer;
 801
 802       fc.reason = reason;
 803       fc.to.filename = buffer->nominal_fname;
 804       fc.to.lineno = buffer->lineno + 1;
 805       fc.sysp = buffer->sysp;
 806       fc.externc = CPP_OPTION (pfile, cplusplus) && buffer->sysp == 2;
 807
 808       /* Caller doesn't need to handle FC_ENTER.  */
 809       if (reason == FC_ENTER)
 810         {
 811           if (buffer->prev)
 812             {
 813               from_file = buffer->prev->nominal_fname;
 814               from_lineno = buffer->prev->lineno;
 815             }
 816           else
 817             from_file = 0;
 818         }
 819       /* Special case for file "foo.i" with "# 1 foo.c" on first line.  */
 820       else if (reason == FC_RENAME && ! buffer->prev
 821                && pfile->directive_pos.line == 1)
 822         from_file = 0;
 823
 824       fc.from.filename = from_file;
 825       fc.from.lineno = from_lineno;
 826       pfile->cb.file_change (pfile, &fc);
 827     }
 828 }
 829
 830 /*
 831  * Report a warning or error detected by the program we are
 832  * processing.  Use the directive's tokens in the error message.
 833  */
 834
 835 static void
 836 do_diagnostic (pfile, code, print_dir)
 837      cpp_reader *pfile;
 838      enum error_type code;
 839      int print_dir;
 840 {
 841   if (_cpp_begin_message (pfile, code, NULL, 0))
 842     {
 843       if (print_dir)
 844         fprintf (stderr, "#%s ", pfile->directive->name);
 845       pfile->state.prevent_expansion++;
 846       cpp_output_line (pfile, stderr);
 847       pfile->state.prevent_expansion--;
 848     }
 849 }
 850
 851 static void
 852 do_error (pfile)
 853      cpp_reader *pfile;
 854 {
 855   do_diagnostic (pfile, ERROR, 1);
 856 }
 857
 858 static void
 859 do_warning (pfile)
 860      cpp_reader *pfile;
 861 {
 862   do_diagnostic (pfile, WARNING, 1);
 863 }
 864
 865 /* Report program identification.  */
 866
 867 static void
 868 do_ident (pfile)
 869      cpp_reader *pfile;
 870 {
 871   cpp_token str;
 872
 873   cpp_get_token (pfile, &str);
 874   if (str.type != CPP_STRING)
 875     cpp_error (pfile, "invalid #ident");
 876   else if (pfile->cb.ident)
 877     (*pfile->cb.ident) (pfile, &str.val.str);
 878
 879   check_eol (pfile);
 880 }
 881
 882 /* Pragmata handling.  We handle some of these, and pass the rest on
 883    to the front end.  C99 defines three pragmas and says that no macro
 884    expansion is to be performed on them; whether or not macro
 885    expansion happens for other pragmas is implementation defined.
 886    This implementation never macro-expands the text after #pragma.  */
 887
 888 /* Sub-handlers for the pragmas needing treatment here.
 889    They return 1 if the token buffer is to be popped, 0 if not. */
 890 struct pragma_entry
 891 {
 892   struct pragma_entry *next;
 893   const char *name;
 894   size_t len;
 895   int isnspace;
 896   union {
 897     void (*handler) PARAMS ((cpp_reader *));
 898     struct pragma_entry *space;
 899   } u;
 900 };
 901
 902 void
 903 cpp_register_pragma (pfile, space, name, handler)
 904      cpp_reader *pfile;
 905      const char *space;
 906      const char *name;
 907      void (*handler) PARAMS ((cpp_reader *));
 908 {
 909   struct pragma_entry **x, *new;
 910   size_t len;
 911
 912   x = &pfile->pragmas;
 913   if (space)
 914     {
 915       struct pragma_entry *p = pfile->pragmas;
 916       len = strlen (space);
 917       while (p)
 918         {
 919           if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
 920             {
 921               x = &p->u.space;
 922               goto found;
 923             }
 924           p = p->next;
 925         }
 926       cpp_ice (pfile, "unknown #pragma namespace %s", space);
 927       return;
 928     }
 929
 930  found:
 931   new = xnew (struct pragma_entry);
 932   new->name = name;
 933   new->len = strlen (name);
 934   new->isnspace = 0;
 935   new->u.handler = handler;
 936
 937   new->next = *x;
 938   *x = new;
 939 }
 940
 941 void
 942 cpp_register_pragma_space (pfile, space)
 943      cpp_reader *pfile;
 944      const char *space;
 945 {
 946   struct pragma_entry *new;
 947   const struct pragma_entry *p = pfile->pragmas;
 948   size_t len = strlen (space);
 949
 950   while (p)
 951     {
 952       if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
 953         /* Multiple different callers are allowed to register the same
 954            namespace.  */
 955         return;
 956       p = p->next;
 957     }
 958
 959   new = xnew (struct pragma_entry);
 960   new->name = space;
 961   new->len = len;
 962   new->isnspace = 1;
 963   new->u.space = 0;
 964
 965   new->next = pfile->pragmas;
 966   pfile->pragmas = new;
 967 }
 968
 969 void
 970 _cpp_init_internal_pragmas (pfile)
 971      cpp_reader *pfile;
 972 {
 973   /* top level */
 974   cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
 975   cpp_register_pragma (pfile, 0, "once", do_pragma_once);
 976
 977   /* GCC namespace */
 978   cpp_register_pragma_space (pfile, "GCC");
 979
 980   cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
 981   cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
 982   cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
 983 }
 984
 985 static void
 986 do_pragma (pfile)
 987      cpp_reader *pfile;
 988 {
 989   const struct pragma_entry *p;
 990   cpp_token tok;
 991   const cpp_hashnode *node;
 992   const U_CHAR *name;
 993   size_t len;
 994   int drop = 0;
 995
 996   p = pfile->pragmas;
 997   pfile->state.prevent_expansion++;
 998   cpp_start_lookahead (pfile);
 999
1000  new_space:
1001   cpp_get_token (pfile, &tok);
1002   if (tok.type == CPP_NAME)
1003     {
1004       node = tok.val.node;
1005       name = node->name;
1006       len = node->length;
1007       while (p)
1008         {
1009           if (strlen (p->name) == len && !memcmp (p->name, name, len))
1010             {
1011               if (p->isnspace)
1012                 {
1013                   p = p->u.space;
1014                   goto new_space;
1015                 }
1016               else
1017                 {
1018                   (*p->u.handler) (pfile);
1019                   drop = 1;
1020                   break;
1021                 }
1022             }
1023           p = p->next;
1024         }
1025     }
1026
1027   cpp_stop_lookahead (pfile, drop);
1028   pfile->state.prevent_expansion--;
1029
1030   if (!drop && pfile->cb.def_pragma)
1031     (*pfile->cb.def_pragma) (pfile);
1032 }
1033
1034 static void
1035 do_pragma_once (pfile)
1036      cpp_reader *pfile;
1037 {
1038   cpp_warning (pfile, "#pragma once is obsolete");
1039
1040   if (pfile->buffer->prev == NULL)
1041     cpp_warning (pfile, "#pragma once in main file");
1042   else
1043     _cpp_never_reread (pfile->buffer->inc);
1044
1045   check_eol (pfile);
1046 }
1047
1048 static void
1049 do_pragma_poison (pfile)
1050      cpp_reader *pfile;
1051 {
1052   /* Poison these symbols so that all subsequent usage produces an
1053      error message.  */
1054   cpp_token tok;
1055   cpp_hashnode *hp;
1056
1057   pfile->state.poisoned_ok = 1;
1058   for (;;)
1059     {
1060       _cpp_lex_token (pfile, &tok);
1061       if (tok.type == CPP_EOF)
1062         break;
1063       if (tok.type != CPP_NAME)
1064         {
1065           cpp_error (pfile, "invalid #pragma GCC poison directive");
1066           break;
1067         }
1068
1069       hp = tok.val.node;
1070       if (hp->flags & NODE_POISONED)
1071         continue;
1072
1073       if (hp->type == NT_MACRO)
1074         cpp_warning (pfile, "poisoning existing macro \"%s\"", hp->name);
1075       _cpp_free_definition (hp);
1076       hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1077     }
1078   pfile->state.poisoned_ok = 0;
1079
1080 #if 0                           /* Doesn't quite work yet.  */
1081   if (tok.type == CPP_EOF && pfile->cb.poison)
1082     (*pfile->cb.poison) (pfile);
1083 #endif
1084 }
1085
1086 /* Mark the current header as a system header.  This will suppress
1087    some categories of warnings (notably those from -pedantic).  It is
1088    intended for use in system libraries that cannot be implemented in
1089    conforming C, but cannot be certain that their headers appear in a
1090    system include directory.  To prevent abuse, it is rejected in the
1091    primary source file.  */
1092 static void
1093 do_pragma_system_header (pfile)
1094      cpp_reader *pfile;
1095 {
1096   cpp_buffer *buffer = pfile->buffer;
1097
1098   if (buffer->prev == 0)
1099     cpp_warning (pfile, "#pragma system_header ignored outside include file");
1100   else
1101     cpp_make_system_header (pfile, 1, 0);
1102
1103   check_eol (pfile);
1104 }
1105
1106 /* Check the modified date of the current include file against a specified
1107    file. Issue a diagnostic, if the specified file is newer. We use this to
1108    determine if a fixed header should be refixed.  */
1109 static void
1110 do_pragma_dependency (pfile)
1111      cpp_reader *pfile;
1112 {
1113   cpp_token header, msg;
1114   int ordering;
1115
1116   if (parse_include (pfile, &header))
1117     return;
1118
1119   ordering = _cpp_compare_file_date (pfile, &header);
1120   if (ordering < 0)
1121     cpp_warning (pfile, "cannot find source %s",
1122                  cpp_token_as_text (pfile, &header));
1123   else if (ordering > 0)
1124     {
1125       cpp_warning (pfile, "current file is older than %s",
1126                    cpp_token_as_text (pfile, &header));
1127       cpp_start_lookahead (pfile);
1128       cpp_get_token (pfile, &msg);
1129       cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
1130       if (msg.type != CPP_EOF)
1131         do_diagnostic (pfile, WARNING, 0);
1132     }
1133 }
1134
1135 /* Check syntax is "(string-literal)".  Returns 0 on success.  */
1136 static int
1137 get__Pragma_string (pfile, string)
1138      cpp_reader *pfile;
1139      cpp_token *string;
1140 {
1141   cpp_token paren;
1142
1143   cpp_get_token (pfile, &paren);
1144   if (paren.type != CPP_OPEN_PAREN)
1145     return 1;
1146
1147   cpp_get_token (pfile, string);
1148   if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1149     return 1;
1150
1151   cpp_get_token (pfile, &paren);
1152   return paren.type != CPP_CLOSE_PAREN;
1153 }
1154
1155 /* Returns a malloced buffer containing a destringized cpp_string by
1156    removing the first \ of \" and \\ sequences.  */
1157 static unsigned char *
1158 destringize (in, len)
1159      const cpp_string *in;
1160      unsigned int *len;
1161 {
1162   const unsigned char *src, *limit;
1163   unsigned char *dest, *result;
1164
1165   dest = result = (unsigned char *) xmalloc (in->len);
1166   for (src = in->text, limit = src + in->len; src < limit;)
1167     {
1168       /* We know there is a character following the backslash.  */
1169       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1170         src++;
1171       *dest++ = *src++;
1172     }
1173
1174   *len = dest - result;
1175   return result;
1176 }
1177
1178 void
1179 _cpp_do__Pragma (pfile)
1180      cpp_reader *pfile;
1181 {
1182   cpp_token string;
1183   unsigned char *buffer;
1184   unsigned int len;
1185
1186   if (get__Pragma_string (pfile, &string))
1187     {
1188       cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1189       return;
1190     }
1191
1192   buffer = destringize (&string.val.str, &len);
1193   run_directive (pfile, T_PRAGMA, BUF_PRAGMA, (char *) buffer, len);
1194   free ((PTR) buffer);
1195 }
1196
1197 /* Just ignore #sccs, on systems where we define it at all.  */
1198 #ifdef SCCS_DIRECTIVE
1199 static void
1200 do_sccs (pfile)
1201      cpp_reader *pfile ATTRIBUTE_UNUSED;
1202 {
1203 }
1204 #endif
1205
1206 static void
1207 do_ifdef (pfile)
1208      cpp_reader *pfile;
1209 {
1210   int skip = 1;
1211
1212   if (! pfile->buffer->was_skipping)
1213     {
1214       const cpp_hashnode *node = lex_macro_node (pfile);
1215
1216       if (node)
1217         skip = node->type != NT_MACRO;
1218
1219       if (node)
1220         check_eol (pfile);
1221     }
1222
1223   push_conditional (pfile, skip, T_IFDEF, 0);
1224 }
1225
1226 static void
1227 do_ifndef (pfile)
1228      cpp_reader *pfile;
1229 {
1230   int skip = 1;
1231   const cpp_hashnode *node = 0;
1232
1233   if (! pfile->buffer->was_skipping)
1234     {
1235       node = lex_macro_node (pfile);
1236       if (node)
1237         skip = node->type == NT_MACRO;
1238
1239       if (node)
1240         check_eol (pfile);
1241     }
1242
1243   push_conditional (pfile, skip, T_IFNDEF, node);
1244 }
1245
1246 /* #if cooperates with parse_defined to handle multiple-include
1247    optimisations.  If macro expansions or identifiers appear in the
1248    expression, we cannot treat it as a controlling conditional, since
1249    their values could change in the future.  */
1250
1251 static void
1252 do_if (pfile)
1253      cpp_reader *pfile;
1254 {
1255   int skip = 1;
1256   const cpp_hashnode *cmacro = 0;
1257
1258   if (! pfile->buffer->was_skipping)
1259     {
1260       /* Controlling macro of #if ! defined ()  */
1261       pfile->mi_ind_cmacro = 0;
1262       skip = _cpp_parse_expr (pfile) == 0;
1263       cmacro = pfile->mi_ind_cmacro;
1264     }
1265
1266   push_conditional (pfile, skip, T_IF, cmacro);
1267 }
1268
1269 /* Flip skipping state if appropriate and continue without changing
1270    if_stack; this is so that the error message for missing #endif's
1271    etc. will point to the original #if.  */
1272
1273 static void
1274 do_else (pfile)
1275      cpp_reader *pfile;
1276 {
1277   cpp_buffer *buffer = pfile->buffer;
1278   struct if_stack *ifs = buffer->if_stack;
1279
1280   if (ifs == NULL)
1281     cpp_error (pfile, "#else without #if");
1282   else
1283     {
1284       if (ifs->type == T_ELSE)
1285         {
1286           cpp_error (pfile, "#else after #else");
1287           cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1288                                "the conditional began here");
1289         }
1290       ifs->type = T_ELSE;
1291
1292       /* Buffer->was_skipping is 1 if all conditionals in this chain
1293          have been false, 2 if a conditional has been true.  */
1294       if (! ifs->was_skipping && buffer->was_skipping != 2)
1295         buffer->was_skipping = ! buffer->was_skipping;
1296
1297       /* Invalidate any controlling macro.  */
1298       ifs->mi_cmacro = 0;
1299     }
1300
1301   check_eol (pfile);
1302 }
1303
1304 /* handle a #elif directive by not changing if_stack either.  see the
1305    comment above do_else.  */
1306
1307 static void
1308 do_elif (pfile)
1309      cpp_reader *pfile;
1310 {
1311   cpp_buffer *buffer = pfile->buffer;
1312   struct if_stack *ifs = buffer->if_stack;
1313
1314   if (ifs == NULL)
1315     cpp_error (pfile, "#elif without #if");
1316   else
1317     {
1318       if (ifs->type == T_ELSE)
1319         {
1320           cpp_error (pfile, "#elif after #else");
1321           cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1322                                "the conditional began here");
1323         }
1324       ifs->type = T_ELIF;
1325
1326       /* Don't evaluate #elif if our higher level is skipping.  */
1327       if (! ifs->was_skipping)
1328         {
1329           /* Buffer->was_skipping is 1 if all conditionals in this
1330              chain have been false, 2 if a conditional has been true.  */
1331           if (buffer->was_skipping == 1)
1332             buffer->was_skipping = ! _cpp_parse_expr (pfile);
1333           else
1334             buffer->was_skipping = 2;
1335
1336           /* Invalidate any controlling macro.  */
1337           ifs->mi_cmacro = 0;
1338         }
1339     }
1340 }
1341
1342 /* #endif pops the if stack and resets pfile->skipping.  */
1343
1344 static void
1345 do_endif (pfile)
1346      cpp_reader *pfile;
1347 {
1348   cpp_buffer *buffer = pfile->buffer;
1349   struct if_stack *ifs = buffer->if_stack;
1350
1351   if (ifs == NULL)
1352     cpp_error (pfile, "#endif without #if");
1353   else
1354     {
1355       /* If potential control macro, we go back outside again.  */
1356       if (ifs->next == 0 && ifs->mi_cmacro)
1357         {
1358           pfile->mi_state = MI_OUTSIDE;
1359           pfile->mi_cmacro = ifs->mi_cmacro;
1360         }
1361
1362       buffer->if_stack = ifs->next;
1363       buffer->was_skipping = ifs->was_skipping;
1364       obstack_free (pfile->buffer_ob, ifs);
1365     }
1366
1367   check_eol (pfile);
1368 }
1369
1370 /* Push an if_stack entry and set pfile->skipping accordingly.
1371    If this is a #ifndef starting at the beginning of a file,
1372    CMACRO is the macro name tested by the #ifndef.  */
1373
1374 static void
1375 push_conditional (pfile, skip, type, cmacro)
1376      cpp_reader *pfile;
1377      int skip;
1378      int type;
1379      const cpp_hashnode *cmacro;
1380 {
1381   struct if_stack *ifs;
1382   cpp_buffer *buffer = pfile->buffer;
1383
1384   ifs = xobnew (pfile->buffer_ob, struct if_stack);
1385   ifs->pos = pfile->directive_pos;
1386   ifs->next = buffer->if_stack;
1387   ifs->was_skipping = buffer->was_skipping;
1388   ifs->type = type;
1389   if (pfile->mi_state == MI_OUTSIDE && pfile->mi_cmacro == 0)
1390     ifs->mi_cmacro = cmacro;
1391   else
1392     ifs->mi_cmacro = 0;
1393
1394   buffer->was_skipping = skip;
1395   buffer->if_stack = ifs;
1396 }
1397
1398 /* Read the tokens of the answer into the macro pool.  Only commit the
1399    memory if we intend it as permanent storage, i.e. the #assert case.
1400    Returns 0 on success.  */
1401
1402 static int
1403 parse_answer (pfile, answerp, type)
1404      cpp_reader *pfile;
1405      struct answer **answerp;
1406      int type;
1407 {
1408   cpp_token paren, *token;
1409   struct answer *answer;
1410
1411   if (POOL_FRONT (&pfile->macro_pool) + sizeof (struct answer) >
1412       POOL_LIMIT (&pfile->macro_pool))
1413     _cpp_next_chunk (&pfile->macro_pool, sizeof (struct answer), 0);
1414   answer = (struct answer *) POOL_FRONT (&pfile->macro_pool);
1415   answer->count = 0;
1416
1417   /* In a conditional, it is legal to not have an open paren.  We
1418      should save the following token in this case.  */
1419   if (type == T_IF)
1420     cpp_start_lookahead (pfile);
1421   cpp_get_token (pfile, &paren);
1422   if (type == T_IF)
1423     cpp_stop_lookahead (pfile, paren.type == CPP_OPEN_PAREN);
1424
1425   /* If not a paren, see if we're OK.  */
1426   if (paren.type != CPP_OPEN_PAREN)
1427     {
1428       /* In a conditional no answer is a test for any answer.  It
1429          could be followed by any token.  */
1430       if (type == T_IF)
1431         return 0;
1432
1433       /* #unassert with no answer is valid - it removes all answers.  */
1434       if (type == T_UNASSERT && paren.type == CPP_EOF)
1435         return 0;
1436
1437       cpp_error (pfile, "missing '(' after predicate");
1438       return 1;
1439     }
1440
1441   for (;;)
1442     {
1443       token = &answer->first[answer->count];
1444       /* Check we have room for the token.  */
1445       if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1446         {
1447           _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1448                            (unsigned char **) &answer);
1449           token = &answer->first[answer->count];
1450         }
1451
1452       cpp_get_token (pfile, token);
1453       if (token->type == CPP_CLOSE_PAREN)
1454         break;
1455
1456       if (token->type == CPP_EOF)
1457         {
1458           cpp_error (pfile, "missing ')' to complete answer");
1459           return 1;
1460         }
1461       answer->count++;
1462     }
1463
1464   if (answer->count == 0)
1465     {
1466       cpp_error (pfile, "predicate's answer is empty");
1467       return 1;
1468     }
1469
1470   /* Drop whitespace at start.  */
1471   answer->first->flags &= ~PREV_WHITE;
1472   *answerp = answer;
1473
1474   if (type == T_ASSERT || type == T_UNASSERT)
1475     check_eol (pfile);
1476   return 0;
1477 }
1478
1479 /* Parses an assertion, returning a pointer to the hash node of the
1480    predicate, or 0 on error.  If an answer was supplied, it is placed
1481    in ANSWERP, otherwise it is set to 0.  */
1482 static cpp_hashnode *
1483 parse_assertion (pfile, answerp, type)
1484      cpp_reader *pfile;
1485      struct answer **answerp;
1486      int type;
1487 {
1488   cpp_hashnode *result = 0;
1489   cpp_token predicate;
1490
1491   /* We don't expand predicates or answers.  */
1492   pfile->state.prevent_expansion++;
1493
1494   *answerp = 0;
1495   cpp_get_token (pfile, &predicate);
1496   if (predicate.type == CPP_EOF)
1497     cpp_error (pfile, "assertion without predicate");
1498   else if (predicate.type != CPP_NAME)
1499     cpp_error (pfile, "predicate must be an identifier");
1500   else if (parse_answer (pfile, answerp, type) == 0)
1501     {
1502       unsigned int len = predicate.val.node->length;
1503       unsigned char *sym = alloca (len + 1);
1504
1505       /* Prefix '#' to get it out of macro namespace.  */
1506       sym[0] = '#';
1507       memcpy (sym + 1, predicate.val.node->name, len);
1508       result = cpp_lookup (pfile, sym, len + 1);
1509     }
1510
1511   pfile->state.prevent_expansion--;
1512   return result;
1513 }
1514
1515 /* Returns a pointer to the pointer to the answer in the answer chain,
1516    or a pointer to NULL if the answer is not in the chain.  */
1517 static struct answer **
1518 find_answer (node, candidate)
1519      cpp_hashnode *node;
1520      const struct answer *candidate;
1521 {
1522   unsigned int i;
1523   struct answer **result;
1524
1525   for (result = &node->value.answers; *result; result = &(*result)->next)
1526     {
1527       struct answer *answer = *result;
1528
1529       if (answer->count == candidate->count)
1530         {
1531           for (i = 0; i < answer->count; i++)
1532             if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1533               break;
1534
1535           if (i == answer->count)
1536             break;
1537         }
1538     }
1539
1540   return result;
1541 }
1542
1543 /* Test an assertion within a preprocessor conditional.  Returns
1544    non-zero on failure, zero on success.  On success, the result of
1545    the test is written into VALUE.  */
1546 int
1547 _cpp_test_assertion (pfile, value)
1548      cpp_reader *pfile;
1549      int *value;
1550 {
1551   struct answer *answer;
1552   cpp_hashnode *node;
1553
1554   node = parse_assertion (pfile, &answer, T_IF);
1555   if (node)
1556     *value = (node->type == NT_ASSERTION &&
1557               (answer == 0 || *find_answer (node, answer) != 0));
1558
1559   /* We don't commit the memory for the answer - it's temporary only.  */
1560   return node == 0;
1561 }
1562
1563 static void
1564 do_assert (pfile)
1565      cpp_reader *pfile;
1566 {
1567   struct answer *new_answer;
1568   cpp_hashnode *node;
1569
1570   node = parse_assertion (pfile, &new_answer, T_ASSERT);
1571   if (node)
1572     {
1573       /* Place the new answer in the answer list.  First check there
1574          is not a duplicate.  */
1575       new_answer->next = 0;
1576       if (node->type == NT_ASSERTION)
1577         {
1578           if (*find_answer (node, new_answer))
1579             {
1580               cpp_warning (pfile, "\"%s\" re-asserted", node->name + 1);
1581               return;
1582             }
1583           new_answer->next = node->value.answers;
1584         }
1585       node->type = NT_ASSERTION;
1586       node->value.answers = new_answer;
1587       POOL_COMMIT (&pfile->macro_pool, (sizeof (struct answer)
1588                                         + (new_answer->count - 1)
1589                                         * sizeof (cpp_token)));
1590     }
1591 }
1592
1593 static void
1594 do_unassert (pfile)
1595      cpp_reader *pfile;
1596 {
1597   cpp_hashnode *node;
1598   struct answer *answer;
1599
1600   node = parse_assertion (pfile, &answer, T_UNASSERT);
1601   /* It isn't an error to #unassert something that isn't asserted.  */
1602   if (node && node->type == NT_ASSERTION)
1603     {
1604       if (answer)
1605         {
1606           struct answer **p = find_answer (node, answer), *temp;
1607
1608           /* Remove the answer from the list.  */
1609           temp = *p;
1610           if (temp)
1611             *p = temp->next;
1612
1613           /* Did we free the last answer?  */
1614           if (node->value.answers == 0)
1615             node->type = NT_VOID;
1616         }
1617       else
1618         _cpp_free_definition (node);
1619     }
1620
1621   /* We don't commit the memory for the answer - it's temporary only.  */
1622 }
1623
1624 /* These are for -D, -U, -A.  */
1625
1626 /* Process the string STR as if it appeared as the body of a #define.
1627    If STR is just an identifier, define it with value 1.
1628    If STR has anything after the identifier, then it should
1629    be identifier=definition. */
1630
1631 void
1632 cpp_define (pfile, str)
1633      cpp_reader *pfile;
1634      const char *str;
1635 {
1636   char *buf, *p;
1637   size_t count;
1638
1639   /* Copy the entire option so we can modify it.
1640      Change the first "=" in the string to a space.  If there is none,
1641      tack " 1" on the end.  */
1642
1643   /* Length including the null.  */
1644   count = strlen (str);
1645   buf = (char *) alloca (count + 2);
1646   memcpy (buf, str, count);
1647
1648   p = strchr (str, '=');
1649   if (p)
1650     buf[p - str] = ' ';
1651   else
1652     {
1653       buf[count++] = ' ';
1654       buf[count++] = '1';
1655     }
1656
1657   run_directive (pfile, T_DEFINE, BUF_CL_OPTION, buf, count);
1658 }
1659
1660 /* Slight variant of the above for use by initialize_builtins.  */
1661 void
1662 _cpp_define_builtin (pfile, str)
1663      cpp_reader *pfile;
1664      const char *str;
1665 {
1666   run_directive (pfile, T_DEFINE, BUF_BUILTIN, str, strlen (str));
1667 }
1668
1669 /* Process MACRO as if it appeared as the body of an #undef.  */
1670 void
1671 cpp_undef (pfile, macro)
1672      cpp_reader *pfile;
1673      const char *macro;
1674 {
1675   run_directive (pfile, T_UNDEF, BUF_CL_OPTION, macro, strlen (macro));
1676 }
1677
1678 /* Process the string STR as if it appeared as the body of a #assert. */
1679 void
1680 cpp_assert (pfile, str)
1681      cpp_reader *pfile;
1682      const char *str;
1683 {
1684   handle_assertion (pfile, str, T_ASSERT);
1685 }
1686
1687 /* Process STR as if it appeared as the body of an #unassert. */
1688 void
1689 cpp_unassert (pfile, str)
1690      cpp_reader *pfile;
1691      const char *str;
1692 {
1693   handle_assertion (pfile, str, T_UNASSERT);
1694 }
1695
1696 /* Common code for cpp_assert (-A) and cpp_unassert (-A-).  */
1697 static void
1698 handle_assertion (pfile, str, type)
1699      cpp_reader *pfile;
1700      const char *str;
1701      int type;
1702 {
1703   size_t count = strlen (str);
1704   const char *p = strchr (str, '=');
1705
1706   if (p)
1707     {
1708       /* Copy the entire option so we can modify it.  Change the first
1709          "=" in the string to a '(', and tack a ')' on the end.  */
1710       char *buf = (char *) alloca (count + 1);
1711
1712       memcpy (buf, str, count);
1713       buf[p - str] = '(';
1714       buf[count++] = ')';
1715       str = buf;
1716     }
1717
1718   run_directive (pfile, type, BUF_CL_OPTION, str, count);
1719 }
1720
1721 /* The number of errors for a given reader.  */
1722 unsigned int
1723 cpp_errors (pfile)
1724      cpp_reader *pfile;
1725 {
1726   return pfile->errors;
1727 }
1728
1729 /* The options structure.  */
1730 cpp_options *
1731 cpp_get_options (pfile)
1732      cpp_reader *pfile;
1733 {
1734   return &pfile->opts;
1735 }
1736
1737 /* The callbacks structure.  */
1738 cpp_callbacks *
1739 cpp_get_callbacks (pfile)
1740      cpp_reader *pfile;
1741 {
1742   return &pfile->cb;
1743 }
1744
1745 /* Copy the given callbacks structure to our own.  */
1746 void
1747 cpp_set_callbacks (pfile, cb)
1748      cpp_reader *pfile;
1749      cpp_callbacks *cb;
1750 {
1751   pfile->cb = *cb;
1752 }
1753
1754 /* Push a new buffer on the buffer stack.  Returns the new buffer; it
1755    doesn't fail.  It does not generate a file change call back; that
1756    is the responsibility of the caller.  */
1757 cpp_buffer *
1758 cpp_push_buffer (pfile, buffer, len, type, filename)
1759      cpp_reader *pfile;
1760      const U_CHAR *buffer;
1761      size_t len;
1762      enum cpp_buffer_type type;
1763      const char *filename;
1764 {
1765   cpp_buffer *new = xobnew (pfile->buffer_ob, cpp_buffer);
1766
1767   if (type == BUF_FAKE)
1768     {
1769       /* A copy of the current buffer, just with a new name and type.  */
1770       memcpy (new, pfile->buffer, sizeof (cpp_buffer));
1771       new->type = BUF_FAKE;
1772     }
1773   else
1774     {
1775       if (type == BUF_BUILTIN)
1776         filename = _("<builtin>");
1777       else if (type == BUF_CL_OPTION)
1778         filename = _("<command line>");
1779       else if (type == BUF_PRAGMA)
1780         filename = "<_Pragma>";
1781
1782       /* Clears, amongst other things, if_stack and mi_cmacro.  */
1783       memset (new, 0, sizeof (cpp_buffer));
1784
1785       new->line_base = new->buf = new->cur = buffer;
1786       new->rlimit = buffer + len;
1787       new->sysp = 0;
1788
1789       /* No read ahead or extra char initially.  */
1790       new->read_ahead = EOF;
1791       new->extra_char = EOF;
1792
1793       /* Preprocessed files, builtins, _Pragma and command line
1794          options don't do trigraph and escaped newline processing.  */
1795       new->from_stage3 = type != BUF_FILE || CPP_OPTION (pfile, preprocessed);
1796
1797       pfile->lexer_pos.output_line = 1;
1798     }
1799
1800   new->nominal_fname = filename;
1801   new->type = type;
1802   new->prev = pfile->buffer;
1803   new->pfile = pfile;
1804   new->include_stack_listed = 0;
1805   new->lineno = 1;
1806
1807   pfile->state.next_bol = 1;
1808   pfile->buffer_stack_depth++;
1809   pfile->buffer = new;
1810
1811   return new;
1812 }
1813
1814 /* If called from do_line, pops a single buffer.  Otherwise pops all
1815    buffers until a real file is reached.  Generates appropriate
1816    call-backs.  */
1817 cpp_buffer *
1818 cpp_pop_buffer (pfile)
1819      cpp_reader *pfile;
1820 {
1821   cpp_buffer *buffer;
1822   struct if_stack *ifs;
1823
1824   for (;;)
1825     {
1826       buffer = pfile->buffer;
1827       /* Walk back up the conditional stack till we reach its level at
1828          entry to this file, issuing error messages.  */
1829       for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1830         cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1831                              "unterminated #%s", dtable[ifs->type].name);
1832
1833       if (buffer->type == BUF_FAKE)
1834         buffer->prev->cur = buffer->cur;
1835       else if (buffer->type == BUF_FILE)
1836         _cpp_pop_file_buffer (pfile, buffer);
1837
1838       pfile->buffer = buffer->prev;
1839       pfile->buffer_stack_depth--;
1840
1841       /* Callbacks only generated for faked or real files.  */
1842       if (buffer->type != BUF_FILE && buffer->type != BUF_FAKE)
1843         break;
1844
1845       /* No callback for EOF of last file.  */
1846       if (!pfile->buffer)
1847         break;
1848
1849       /* do_line does its own call backs.  */
1850       pfile->buffer->include_stack_listed = 0;
1851       if (pfile->directive == &dtable[T_LINE])
1852         break;
1853
1854       _cpp_do_file_change (pfile, FC_LEAVE, buffer->nominal_fname,
1855                            buffer->lineno);
1856       if (pfile->buffer->type == BUF_FILE)
1857         break;
1858
1859       cpp_warning (pfile, "file \"%s\" entered but not left",
1860                    buffer->nominal_fname);
1861     }
1862
1863   obstack_free (pfile->buffer_ob, buffer);
1864   return pfile->buffer;
1865 }
1866
1867 #define obstack_chunk_alloc xmalloc
1868 #define obstack_chunk_free free
1869 void
1870 _cpp_init_stacks (pfile)
1871      cpp_reader *pfile;
1872 {
1873   int i;
1874   cpp_hashnode *node;
1875
1876   pfile->buffer_ob = xnew (struct obstack);
1877   obstack_init (pfile->buffer_ob);
1878
1879   /* Register the directives.  */
1880   for (i = 1; i < N_DIRECTIVES; i++)
1881     {
1882       node = cpp_lookup (pfile, dtable[i - 1].name, dtable[i - 1].length);
1883       node->directive_index = i;
1884     }
1885 }
1886
1887 void
1888 _cpp_cleanup_stacks (pfile)
1889      cpp_reader *pfile;
1890 {
1891   obstack_free (pfile->buffer_ob, 0);
1892   free (pfile->buffer_ob);
1893 }