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