gcc/cpplib.c

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