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