gcc/cpplib.c

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