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