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