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   pfile->state.prevent_expansion++;
1149
1150   token = cpp_get_token (pfile);
1151   if (token->type == CPP_NAME)
1152     {
1153       p = lookup_pragma_entry (pfile->pragmas, token->val.node);
1154       if (p && p->is_nspace)
1155         {
1156           count = 2;
1157           token = cpp_get_token (pfile);
1158           if (token->type == CPP_NAME)
1159             p = lookup_pragma_entry (p->u.space, token->val.node);
1160           else
1161             p = NULL;
1162         }
1163     }
1164
1165   if (p && (p->is_internal || !CPP_OPTION (pfile, defer_pragmas)))
1166     {
1167       /* Since the handler below doesn't get the line number, that it
1168          might need for diagnostics, make sure it has the right
1169          numbers in place.  */
1170       if (pfile->cb.line_change)
1171         (*pfile->cb.line_change) (pfile, pragma_token, false);
1172       (*p->u.handler) (pfile);
1173     }
1174   else if (CPP_OPTION (pfile, defer_pragmas))
1175     {
1176       /* Squirrel away the pragma text.  Pragmas are newline-terminated. */
1177       const uchar *line_start, *line_end;
1178       uchar *s;
1179       cpp_string body;
1180       cpp_token *ptok;
1181
1182       _cpp_backup_tokens (pfile, count);
1183       line_start = CPP_BUFFER (pfile)->cur;
1184       line_end = ustrchr (line_start, '\n');
1185
1186       body.len = (line_end - line_start) + 1;
1187       s = _cpp_unaligned_alloc (pfile, body.len + 1);
1188       memcpy (s, line_start, body.len);
1189       s[body.len] = '\0';
1190       body.text = s;
1191
1192       /* Create a CPP_PRAGMA token.  */
1193       ptok = &pfile->directive_result;
1194       ptok->src_loc = pragma_token->src_loc;
1195       ptok->type = CPP_PRAGMA;
1196       ptok->flags = pragma_token->flags | NO_EXPAND;
1197       ptok->val.str = body;
1198     }
1199   else if (pfile->cb.def_pragma)
1200     {
1201       _cpp_backup_tokens (pfile, count);
1202       pfile->cb.def_pragma (pfile, pfile->directive_line);
1203     }
1204
1205   pfile->state.prevent_expansion--;
1206 }
1207
1208 /* Handle #pragma once.  */
1209 static void
1210 do_pragma_once (cpp_reader *pfile)
1211 {
1212   if (pfile->buffer->prev == NULL)
1213     cpp_error (pfile, CPP_DL_WARNING, "#pragma once in main file");
1214
1215   check_eol (pfile);
1216   _cpp_mark_file_once_only (pfile, pfile->buffer->file);
1217 }
1218
1219 /* Handle #pragma GCC poison, to poison one or more identifiers so
1220    that the lexer produces a hard error for each subsequent usage.  */
1221 static void
1222 do_pragma_poison (cpp_reader *pfile)
1223 {
1224   const cpp_token *tok;
1225   cpp_hashnode *hp;
1226
1227   pfile->state.poisoned_ok = 1;
1228   for (;;)
1229     {
1230       tok = _cpp_lex_token (pfile);
1231       if (tok->type == CPP_EOF)
1232         break;
1233       if (tok->type != CPP_NAME)
1234         {
1235           cpp_error (pfile, CPP_DL_ERROR,
1236                      "invalid #pragma GCC poison directive");
1237           break;
1238         }
1239
1240       hp = tok->val.node;
1241       if (hp->flags & NODE_POISONED)
1242         continue;
1243
1244       if (hp->type == NT_MACRO)
1245         cpp_error (pfile, CPP_DL_WARNING, "poisoning existing macro \"%s\"",
1246                    NODE_NAME (hp));
1247       _cpp_free_definition (hp);
1248       hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1249     }
1250   pfile->state.poisoned_ok = 0;
1251 }
1252
1253 /* Mark the current header as a system header.  This will suppress
1254    some categories of warnings (notably those from -pedantic).  It is
1255    intended for use in system libraries that cannot be implemented in
1256    conforming C, but cannot be certain that their headers appear in a
1257    system include directory.  To prevent abuse, it is rejected in the
1258    primary source file.  */
1259 static void
1260 do_pragma_system_header (cpp_reader *pfile)
1261 {
1262   cpp_buffer *buffer = pfile->buffer;
1263
1264   if (buffer->prev == 0)
1265     cpp_error (pfile, CPP_DL_WARNING,
1266                "#pragma system_header ignored outside include file");
1267   else
1268     {
1269       check_eol (pfile);
1270       skip_rest_of_line (pfile);
1271       cpp_make_system_header (pfile, 1, 0);
1272     }
1273 }
1274
1275 /* Check the modified date of the current include file against a specified
1276    file. Issue a diagnostic, if the specified file is newer. We use this to
1277    determine if a fixed header should be refixed.  */
1278 static void
1279 do_pragma_dependency (cpp_reader *pfile)
1280 {
1281   const char *fname;
1282   int angle_brackets, ordering;
1283
1284   fname = parse_include (pfile, &angle_brackets);
1285   if (!fname)
1286     return;
1287
1288   ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
1289   if (ordering < 0)
1290     cpp_error (pfile, CPP_DL_WARNING, "cannot find source file %s", fname);
1291   else if (ordering > 0)
1292     {
1293       cpp_error (pfile, CPP_DL_WARNING,
1294                  "current file is older than %s", fname);
1295       if (cpp_get_token (pfile)->type != CPP_EOF)
1296         {
1297           _cpp_backup_tokens (pfile, 1);
1298           do_diagnostic (pfile, CPP_DL_WARNING, 0);
1299         }
1300     }
1301
1302   free ((void *) fname);
1303 }
1304
1305 /* Get a token but skip padding.  */
1306 static const cpp_token *
1307 get_token_no_padding (cpp_reader *pfile)
1308 {
1309   for (;;)
1310     {
1311       const cpp_token *result = cpp_get_token (pfile);
1312       if (result->type != CPP_PADDING)
1313         return result;
1314     }
1315 }
1316
1317 /* Check syntax is "(string-literal)".  Returns the string on success,
1318    or NULL on failure.  */
1319 static const cpp_token *
1320 get__Pragma_string (cpp_reader *pfile)
1321 {
1322   const cpp_token *string;
1323
1324   if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
1325     return NULL;
1326
1327   string = get_token_no_padding (pfile);
1328   if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1329     return NULL;
1330
1331   if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
1332     return NULL;
1333
1334   return string;
1335 }
1336
1337 /* Destringize IN into a temporary buffer, by removing the first \ of
1338    \" and \\ sequences, and process the result as a #pragma directive.  */
1339 static void
1340 destringize_and_run (cpp_reader *pfile, const cpp_string *in)
1341 {
1342   const unsigned char *src, *limit;
1343   char *dest, *result;
1344
1345   dest = result = alloca (in->len - 1);
1346   src = in->text + 1 + (in->text[0] == 'L');
1347   limit = in->text + in->len - 1;
1348   while (src < limit)
1349     {
1350       /* We know there is a character following the backslash.  */
1351       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1352         src++;
1353       *dest++ = *src++;
1354     }
1355   *dest = '\n';
1356
1357   /* Ugh; an awful kludge.  We are really not set up to be lexing
1358      tokens when in the middle of a macro expansion.  Use a new
1359      context to force cpp_get_token to lex, and so skip_rest_of_line
1360      doesn't go beyond the end of the text.  Also, remember the
1361      current lexing position so we can return to it later.
1362
1363      Something like line-at-a-time lexing should remove the need for
1364      this.  */
1365   {
1366     cpp_context *saved_context = pfile->context;
1367     cpp_token *saved_cur_token = pfile->cur_token;
1368     tokenrun *saved_cur_run = pfile->cur_run;
1369
1370     pfile->context = XNEW (cpp_context);
1371     pfile->context->macro = 0;
1372     pfile->context->prev = 0;
1373     run_directive (pfile, T_PRAGMA, result, dest - result);
1374     XDELETE (pfile->context);
1375     pfile->context = saved_context;
1376     pfile->cur_token = saved_cur_token;
1377     pfile->cur_run = saved_cur_run;
1378   }
1379
1380   /* See above comment.  For the moment, we'd like
1381
1382      token1 _Pragma ("foo") token2
1383
1384      to be output as
1385
1386                 token1
1387                 # 7 "file.c"
1388                 #pragma foo
1389                 # 7 "file.c"
1390                                token2
1391
1392       Getting the line markers is a little tricky.  */
1393   if (pfile->cb.line_change)
1394     pfile->cb.line_change (pfile, pfile->cur_token, false);
1395 }
1396
1397 /* Handle the _Pragma operator.  */
1398 void
1399 _cpp_do__Pragma (cpp_reader *pfile)
1400 {
1401   const cpp_token *string = get__Pragma_string (pfile);
1402   pfile->directive_result.type = CPP_PADDING;
1403
1404   if (string)
1405     destringize_and_run (pfile, &string->val.str);
1406   else
1407     cpp_error (pfile, CPP_DL_ERROR,
1408                "_Pragma takes a parenthesized string literal");
1409 }
1410
1411 /* Handle a pragma that the front end deferred until now. */
1412 void
1413 cpp_handle_deferred_pragma (cpp_reader *pfile, const cpp_string *s)
1414 {
1415   cpp_context *saved_context = pfile->context;
1416   cpp_token *saved_cur_token = pfile->cur_token;
1417   tokenrun *saved_cur_run = pfile->cur_run;
1418   bool saved_defer_pragmas = CPP_OPTION (pfile, defer_pragmas);
1419
1420   pfile->context = XNEW (cpp_context);
1421   pfile->context->macro = 0;
1422   pfile->context->prev = 0;
1423   CPP_OPTION (pfile, defer_pragmas) = false;
1424
1425   run_directive (pfile, T_PRAGMA, s->text, s->len);
1426
1427   XDELETE (pfile->context);
1428   pfile->context = saved_context;
1429   pfile->cur_token = saved_cur_token;
1430   pfile->cur_run = saved_cur_run;
1431   CPP_OPTION (pfile, defer_pragmas) = saved_defer_pragmas;
1432 }
1433
1434 /* Ignore #sccs on all systems.  */
1435 static void
1436 do_sccs (cpp_reader *pfile ATTRIBUTE_UNUSED)
1437 {
1438 }
1439
1440 /* Handle #ifdef.  */
1441 static void
1442 do_ifdef (cpp_reader *pfile)
1443 {
1444   int skip = 1;
1445
1446   if (! pfile->state.skipping)
1447     {
1448       const cpp_hashnode *node = lex_macro_node (pfile);
1449
1450       if (node)
1451         {
1452           skip = node->type != NT_MACRO;
1453           _cpp_mark_macro_used (node);
1454           check_eol (pfile);
1455         }
1456     }
1457
1458   push_conditional (pfile, skip, T_IFDEF, 0);
1459 }
1460
1461 /* Handle #ifndef.  */
1462 static void
1463 do_ifndef (cpp_reader *pfile)
1464 {
1465   int skip = 1;
1466   const cpp_hashnode *node = 0;
1467
1468   if (! pfile->state.skipping)
1469     {
1470       node = lex_macro_node (pfile);
1471
1472       if (node)
1473         {
1474           skip = node->type == NT_MACRO;
1475           _cpp_mark_macro_used (node);
1476           check_eol (pfile);
1477         }
1478     }
1479
1480   push_conditional (pfile, skip, T_IFNDEF, node);
1481 }
1482
1483 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1484    pfile->mi_ind_cmacro so we can handle multiple-include
1485    optimizations.  If macro expansion occurs in the expression, we
1486    cannot treat it as a controlling conditional, since the expansion
1487    could change in the future.  That is handled by cpp_get_token.  */
1488 static void
1489 do_if (cpp_reader *pfile)
1490 {
1491   int skip = 1;
1492
1493   if (! pfile->state.skipping)
1494     skip = _cpp_parse_expr (pfile) == false;
1495
1496   push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1497 }
1498
1499 /* Flip skipping state if appropriate and continue without changing
1500    if_stack; this is so that the error message for missing #endif's
1501    etc. will point to the original #if.  */
1502 static void
1503 do_else (cpp_reader *pfile)
1504 {
1505   cpp_buffer *buffer = pfile->buffer;
1506   struct if_stack *ifs = buffer->if_stack;
1507
1508   if (ifs == NULL)
1509     cpp_error (pfile, CPP_DL_ERROR, "#else without #if");
1510   else
1511     {
1512       if (ifs->type == T_ELSE)
1513         {
1514           cpp_error (pfile, CPP_DL_ERROR, "#else after #else");
1515           cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1516                                "the conditional began here");
1517         }
1518       ifs->type = T_ELSE;
1519
1520       /* Skip any future (erroneous) #elses or #elifs.  */
1521       pfile->state.skipping = ifs->skip_elses;
1522       ifs->skip_elses = true;
1523
1524       /* Invalidate any controlling macro.  */
1525       ifs->mi_cmacro = 0;
1526
1527       /* Only check EOL if was not originally skipping.  */
1528       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1529         check_eol (pfile);
1530     }
1531 }
1532
1533 /* Handle a #elif directive by not changing if_stack either.  See the
1534    comment above do_else.  */
1535 static void
1536 do_elif (cpp_reader *pfile)
1537 {
1538   cpp_buffer *buffer = pfile->buffer;
1539   struct if_stack *ifs = buffer->if_stack;
1540
1541   if (ifs == NULL)
1542     cpp_error (pfile, CPP_DL_ERROR, "#elif without #if");
1543   else
1544     {
1545       if (ifs->type == T_ELSE)
1546         {
1547           cpp_error (pfile, CPP_DL_ERROR, "#elif after #else");
1548           cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1549                                "the conditional began here");
1550         }
1551       ifs->type = T_ELIF;
1552
1553       /* Only evaluate this if we aren't skipping elses.  During
1554          evaluation, set skipping to false to get lexer warnings.  */
1555       if (ifs->skip_elses)
1556         pfile->state.skipping = 1;
1557       else
1558         {
1559           pfile->state.skipping = 0;
1560           pfile->state.skipping = ! _cpp_parse_expr (pfile);
1561           ifs->skip_elses = ! pfile->state.skipping;
1562         }
1563
1564       /* Invalidate any controlling macro.  */
1565       ifs->mi_cmacro = 0;
1566     }
1567 }
1568
1569 /* #endif pops the if stack and resets pfile->state.skipping.  */
1570 static void
1571 do_endif (cpp_reader *pfile)
1572 {
1573   cpp_buffer *buffer = pfile->buffer;
1574   struct if_stack *ifs = buffer->if_stack;
1575
1576   if (ifs == NULL)
1577     cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
1578   else
1579     {
1580       /* Only check EOL if was not originally skipping.  */
1581       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1582         check_eol (pfile);
1583
1584       /* If potential control macro, we go back outside again.  */
1585       if (ifs->next == 0 && ifs->mi_cmacro)
1586         {
1587           pfile->mi_valid = true;
1588           pfile->mi_cmacro = ifs->mi_cmacro;
1589         }
1590
1591       buffer->if_stack = ifs->next;
1592       pfile->state.skipping = ifs->was_skipping;
1593       obstack_free (&pfile->buffer_ob, ifs);
1594     }
1595 }
1596
1597 /* Push an if_stack entry for a preprocessor conditional, and set
1598    pfile->state.skipping to SKIP.  If TYPE indicates the conditional
1599    is #if or #ifndef, CMACRO is a potentially controlling macro, and
1600    we need to check here that we are at the top of the file.  */
1601 static void
1602 push_conditional (cpp_reader *pfile, int skip, int type,
1603                   const cpp_hashnode *cmacro)
1604 {
1605   struct if_stack *ifs;
1606   cpp_buffer *buffer = pfile->buffer;
1607
1608   ifs = XOBNEW (&pfile->buffer_ob, struct if_stack);
1609   ifs->line = pfile->directive_line;
1610   ifs->next = buffer->if_stack;
1611   ifs->skip_elses = pfile->state.skipping || !skip;
1612   ifs->was_skipping = pfile->state.skipping;
1613   ifs->type = type;
1614   /* This condition is effectively a test for top-of-file.  */
1615   if (pfile->mi_valid && pfile->mi_cmacro == 0)
1616     ifs->mi_cmacro = cmacro;
1617   else
1618     ifs->mi_cmacro = 0;
1619
1620   pfile->state.skipping = skip;
1621   buffer->if_stack = ifs;
1622 }
1623
1624 /* Read the tokens of the answer into the macro pool, in a directive
1625    of type TYPE.  Only commit the memory if we intend it as permanent
1626    storage, i.e. the #assert case.  Returns 0 on success, and sets
1627    ANSWERP to point to the answer.  */
1628 static int
1629 parse_answer (cpp_reader *pfile, struct answer **answerp, int type)
1630 {
1631   const cpp_token *paren;
1632   struct answer *answer;
1633   unsigned int acount;
1634
1635   /* In a conditional, it is legal to not have an open paren.  We
1636      should save the following token in this case.  */
1637   paren = cpp_get_token (pfile);
1638
1639   /* If not a paren, see if we're OK.  */
1640   if (paren->type != CPP_OPEN_PAREN)
1641     {
1642       /* In a conditional no answer is a test for any answer.  It
1643          could be followed by any token.  */
1644       if (type == T_IF)
1645         {
1646           _cpp_backup_tokens (pfile, 1);
1647           return 0;
1648         }
1649
1650       /* #unassert with no answer is valid - it removes all answers.  */
1651       if (type == T_UNASSERT && paren->type == CPP_EOF)
1652         return 0;
1653
1654       cpp_error (pfile, CPP_DL_ERROR, "missing '(' after predicate");
1655       return 1;
1656     }
1657
1658   for (acount = 0;; acount++)
1659     {
1660       size_t room_needed;
1661       const cpp_token *token = cpp_get_token (pfile);
1662       cpp_token *dest;
1663
1664       if (token->type == CPP_CLOSE_PAREN)
1665         break;
1666
1667       if (token->type == CPP_EOF)
1668         {
1669           cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");
1670           return 1;
1671         }
1672
1673       /* struct answer includes the space for one token.  */
1674       room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
1675
1676       if (BUFF_ROOM (pfile->a_buff) < room_needed)
1677         _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
1678
1679       dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
1680       *dest = *token;
1681
1682       /* Drop whitespace at start, for answer equivalence purposes.  */
1683       if (acount == 0)
1684         dest->flags &= ~PREV_WHITE;
1685     }
1686
1687   if (acount == 0)
1688     {
1689       cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");
1690       return 1;
1691     }
1692
1693   answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
1694   answer->count = acount;
1695   answer->next = NULL;
1696   *answerp = answer;
1697
1698   return 0;
1699 }
1700
1701 /* Parses an assertion directive of type TYPE, returning a pointer to
1702    the hash node of the predicate, or 0 on error.  If an answer was
1703    supplied, it is placed in ANSWERP, otherwise it is set to 0.  */
1704 static cpp_hashnode *
1705 parse_assertion (cpp_reader *pfile, struct answer **answerp, int type)
1706 {
1707   cpp_hashnode *result = 0;
1708   const cpp_token *predicate;
1709
1710   /* We don't expand predicates or answers.  */
1711   pfile->state.prevent_expansion++;
1712
1713   *answerp = 0;
1714   predicate = cpp_get_token (pfile);
1715   if (predicate->type == CPP_EOF)
1716     cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");
1717   else if (predicate->type != CPP_NAME)
1718     cpp_error (pfile, CPP_DL_ERROR, "predicate must be an identifier");
1719   else if (parse_answer (pfile, answerp, type) == 0)
1720     {
1721       unsigned int len = NODE_LEN (predicate->val.node);
1722       unsigned char *sym = alloca (len + 1);
1723
1724       /* Prefix '#' to get it out of macro namespace.  */
1725       sym[0] = '#';
1726       memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
1727       result = cpp_lookup (pfile, sym, len + 1);
1728     }
1729
1730   pfile->state.prevent_expansion--;
1731   return result;
1732 }
1733
1734 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1735    or a pointer to NULL if the answer is not in the chain.  */
1736 static struct answer **
1737 find_answer (cpp_hashnode *node, const struct answer *candidate)
1738 {
1739   unsigned int i;
1740   struct answer **result;
1741
1742   for (result = &node->value.answers; *result; result = &(*result)->next)
1743     {
1744       struct answer *answer = *result;
1745
1746       if (answer->count == candidate->count)
1747         {
1748           for (i = 0; i < answer->count; i++)
1749             if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1750               break;
1751
1752           if (i == answer->count)
1753             break;
1754         }
1755     }
1756
1757   return result;
1758 }
1759
1760 /* Test an assertion within a preprocessor conditional.  Returns
1761    nonzero on failure, zero on success.  On success, the result of
1762    the test is written into VALUE, otherwise the value 0.  */
1763 int
1764 _cpp_test_assertion (cpp_reader *pfile, unsigned int *value)
1765 {
1766   struct answer *answer;
1767   cpp_hashnode *node;
1768
1769   node = parse_assertion (pfile, &answer, T_IF);
1770
1771   /* For recovery, an erroneous assertion expression is handled as a
1772      failing assertion.  */
1773   *value = 0;
1774
1775   if (node)
1776     *value = (node->type == NT_ASSERTION &&
1777               (answer == 0 || *find_answer (node, answer) != 0));
1778   else if (pfile->cur_token[-1].type == CPP_EOF)
1779     _cpp_backup_tokens (pfile, 1);
1780
1781   /* We don't commit the memory for the answer - it's temporary only.  */
1782   return node == 0;
1783 }
1784
1785 /* Handle #assert.  */
1786 static void
1787 do_assert (cpp_reader *pfile)
1788 {
1789   struct answer *new_answer;
1790   cpp_hashnode *node;
1791
1792   node = parse_assertion (pfile, &new_answer, T_ASSERT);
1793   if (node)
1794     {
1795       size_t answer_size;
1796
1797       /* Place the new answer in the answer list.  First check there
1798          is not a duplicate.  */
1799       new_answer->next = 0;
1800       if (node->type == NT_ASSERTION)
1801         {
1802           if (*find_answer (node, new_answer))
1803             {
1804               cpp_error (pfile, CPP_DL_WARNING, "\"%s\" re-asserted",
1805                          NODE_NAME (node) + 1);
1806               return;
1807             }
1808           new_answer->next = node->value.answers;
1809         }
1810
1811       answer_size = sizeof (struct answer) + ((new_answer->count - 1)
1812                                               * sizeof (cpp_token));
1813       /* Commit or allocate storage for the object.  */
1814       if (pfile->hash_table->alloc_subobject)
1815         {
1816           struct answer *temp_answer = new_answer;
1817           new_answer = pfile->hash_table->alloc_subobject (answer_size);
1818           memcpy (new_answer, temp_answer, answer_size);
1819         }
1820       else
1821         BUFF_FRONT (pfile->a_buff) += answer_size;
1822
1823       node->type = NT_ASSERTION;
1824       node->value.answers = new_answer;
1825       check_eol (pfile);
1826     }
1827 }
1828
1829 /* Handle #unassert.  */
1830 static void
1831 do_unassert (cpp_reader *pfile)
1832 {
1833   cpp_hashnode *node;
1834   struct answer *answer;
1835
1836   node = parse_assertion (pfile, &answer, T_UNASSERT);
1837   /* It isn't an error to #unassert something that isn't asserted.  */
1838   if (node && node->type == NT_ASSERTION)
1839     {
1840       if (answer)
1841         {
1842           struct answer **p = find_answer (node, answer), *temp;
1843
1844           /* Remove the answer from the list.  */
1845           temp = *p;
1846           if (temp)
1847             *p = temp->next;
1848
1849           /* Did we free the last answer?  */
1850           if (node->value.answers == 0)
1851             node->type = NT_VOID;
1852
1853           check_eol (pfile);
1854         }
1855       else
1856         _cpp_free_definition (node);
1857     }
1858
1859   /* We don't commit the memory for the answer - it's temporary only.  */
1860 }
1861
1862 /* These are for -D, -U, -A.  */
1863
1864 /* Process the string STR as if it appeared as the body of a #define.
1865    If STR is just an identifier, define it with value 1.
1866    If STR has anything after the identifier, then it should
1867    be identifier=definition.  */
1868 void
1869 cpp_define (cpp_reader *pfile, const char *str)
1870 {
1871   char *buf, *p;
1872   size_t count;
1873
1874   /* Copy the entire option so we can modify it.
1875      Change the first "=" in the string to a space.  If there is none,
1876      tack " 1" on the end.  */
1877
1878   count = strlen (str);
1879   buf = alloca (count + 3);
1880   memcpy (buf, str, count);
1881
1882   p = strchr (str, '=');
1883   if (p)
1884     buf[p - str] = ' ';
1885   else
1886     {
1887       buf[count++] = ' ';
1888       buf[count++] = '1';
1889     }
1890   buf[count] = '\n';
1891
1892   run_directive (pfile, T_DEFINE, buf, count);
1893 }
1894
1895 /* Slight variant of the above for use by initialize_builtins.  */
1896 void
1897 _cpp_define_builtin (cpp_reader *pfile, const char *str)
1898 {
1899   size_t len = strlen (str);
1900   char *buf = alloca (len + 1);
1901   memcpy (buf, str, len);
1902   buf[len] = '\n';
1903   run_directive (pfile, T_DEFINE, buf, len);
1904 }
1905
1906 /* Process MACRO as if it appeared as the body of an #undef.  */
1907 void
1908 cpp_undef (cpp_reader *pfile, const char *macro)
1909 {
1910   size_t len = strlen (macro);
1911   char *buf = alloca (len + 1);
1912   memcpy (buf, macro, len);
1913   buf[len] = '\n';
1914   run_directive (pfile, T_UNDEF, buf, len);
1915 }
1916
1917 /* Process the string STR as if it appeared as the body of a #assert.  */
1918 void
1919 cpp_assert (cpp_reader *pfile, const char *str)
1920 {
1921   handle_assertion (pfile, str, T_ASSERT);
1922 }
1923
1924 /* Process STR as if it appeared as the body of an #unassert.  */
1925 void
1926 cpp_unassert (cpp_reader *pfile, const char *str)
1927 {
1928   handle_assertion (pfile, str, T_UNASSERT);
1929 }
1930
1931 /* Common code for cpp_assert (-A) and cpp_unassert (-A-).  */
1932 static void
1933 handle_assertion (cpp_reader *pfile, const char *str, int type)
1934 {
1935   size_t count = strlen (str);
1936   const char *p = strchr (str, '=');
1937
1938   /* Copy the entire option so we can modify it.  Change the first
1939      "=" in the string to a '(', and tack a ')' on the end.  */
1940   char *buf = alloca (count + 2);
1941
1942   memcpy (buf, str, count);
1943   if (p)
1944     {
1945       buf[p - str] = '(';
1946       buf[count++] = ')';
1947     }
1948   buf[count] = '\n';
1949   str = buf;
1950
1951   run_directive (pfile, type, str, count);
1952 }
1953
1954 /* The number of errors for a given reader.  */
1955 unsigned int
1956 cpp_errors (cpp_reader *pfile)
1957 {
1958   return pfile->errors;
1959 }
1960
1961 /* The options structure.  */
1962 cpp_options *
1963 cpp_get_options (cpp_reader *pfile)
1964 {
1965   return &pfile->opts;
1966 }
1967
1968 /* The callbacks structure.  */
1969 cpp_callbacks *
1970 cpp_get_callbacks (cpp_reader *pfile)
1971 {
1972   return &pfile->cb;
1973 }
1974
1975 /* Copy the given callbacks structure to our own.  */
1976 void
1977 cpp_set_callbacks (cpp_reader *pfile, cpp_callbacks *cb)
1978 {
1979   pfile->cb = *cb;
1980 }
1981
1982 /* The dependencies structure.  (Creates one if it hasn't already been.)  */
1983 struct deps *
1984 cpp_get_deps (cpp_reader *pfile)
1985 {
1986   if (!pfile->deps)
1987     pfile->deps = deps_init ();
1988   return pfile->deps;
1989 }
1990
1991 /* Push a new buffer on the buffer stack.  Returns the new buffer; it
1992    doesn't fail.  It does not generate a file change call back; that
1993    is the responsibility of the caller.  */
1994 cpp_buffer *
1995 cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len,
1996                  int from_stage3)
1997 {
1998   cpp_buffer *new = XOBNEW (&pfile->buffer_ob, cpp_buffer);
1999
2000   /* Clears, amongst other things, if_stack and mi_cmacro.  */
2001   memset (new, 0, sizeof (cpp_buffer));
2002
2003   new->next_line = new->buf = buffer;
2004   new->rlimit = buffer + len;
2005   new->from_stage3 = from_stage3;
2006   new->prev = pfile->buffer;
2007   new->need_line = true;
2008
2009   pfile->buffer = new;
2010
2011   return new;
2012 }
2013
2014 /* Pops a single buffer, with a file change call-back if appropriate.
2015    Then pushes the next -include file, if any remain.  */
2016 void
2017 _cpp_pop_buffer (cpp_reader *pfile)
2018 {
2019   cpp_buffer *buffer = pfile->buffer;
2020   struct _cpp_file *inc = buffer->file;
2021   struct if_stack *ifs;
2022
2023   /* Walk back up the conditional stack till we reach its level at
2024      entry to this file, issuing error messages.  */
2025   for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
2026     cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2027                          "unterminated #%s", dtable[ifs->type].name);
2028
2029   /* In case of a missing #endif.  */
2030   pfile->state.skipping = 0;
2031
2032   /* _cpp_do_file_change expects pfile->buffer to be the new one.  */
2033   pfile->buffer = buffer->prev;
2034
2035   free (buffer->notes);
2036
2037   /* Free the buffer object now; we may want to push a new buffer
2038      in _cpp_push_next_include_file.  */
2039   obstack_free (&pfile->buffer_ob, buffer);
2040
2041   if (inc)
2042     {
2043       _cpp_pop_file_buffer (pfile, inc);
2044
2045       _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
2046     }
2047 }
2048
2049 /* Enter all recognized directives in the hash table.  */
2050 void
2051 _cpp_init_directives (cpp_reader *pfile)
2052 {
2053   unsigned int i;
2054   cpp_hashnode *node;
2055
2056   for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
2057     {
2058       node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
2059       node->is_directive = 1;
2060       node->directive_index = i;
2061     }
2062 }