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