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