gcc/cpplib.c

   1 /* CPP Library.
   2    Copyright (C) 1986, 87, 89, 92-98, 1999 Free Software Foundation, Inc.
   3    Contributed by Per Bothner, 1994-95.
   4    Based on CCCP program by Paul Rubin, June 1986
   5    Adapted to ANSI C, Richard Stallman, Jan 1987
   6
   7 This program is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU General Public License as published by the
   9 Free Software Foundation; either version 2, or (at your option) any
  10 later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23
  24 #include "cpplib.h"
  25 #include "cpphash.h"
  26 #include "intl.h"
  27
  28 #define SKIP_WHITE_SPACE(p) do { while (is_hspace(*p)) p++; } while (0)
  29
  30 #define PEEKN(N) (CPP_BUFFER (pfile)->rlimit - CPP_BUFFER (pfile)->cur >= (N) ? CPP_BUFFER (pfile)->cur[N] : EOF)
  31 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
  32 #define GETC() CPP_BUF_GET (CPP_BUFFER (pfile))
  33 #define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
  34 /* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
  35    (Note that it is false while we're expanding macro *arguments*.) */
  36 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
  37
  38 /* Forward declarations.  */
  39
  40 static const char *my_strerror          PROTO ((int));
  41 static void validate_else               PROTO ((cpp_reader *, const char *));
  42 static HOST_WIDEST_INT eval_if_expression       PROTO ((cpp_reader *));
  43
  44 static void conditional_skip            PROTO ((cpp_reader *, int,
  45                                                 enum node_type, U_CHAR *));
  46 static void skip_if_group               PROTO ((cpp_reader *));
  47
  48 static void parse_name                  PARAMS ((cpp_reader *, int));
  49 static void parse_string                PARAMS ((cpp_reader *, int));
  50 static int parse_assertion              PARAMS ((cpp_reader *));
  51 static const char *if_directive_name    PARAMS ((cpp_reader *,
  52                                                  struct if_stack *));
  53
  54 /* External declarations.  */
  55
  56 extern HOST_WIDEST_INT cpp_parse_expr PARAMS ((cpp_reader *));
  57
  58 /* `struct directive' defines one #-directive, including how to handle it.  */
  59
  60 struct directive {
  61   int length;                   /* Length of name */
  62   int (*func)                   /* Function to handle directive */
  63     PARAMS ((cpp_reader *, const struct directive *));
  64   const char *name;             /* Name of directive */
  65   enum node_type type;          /* Code which describes which directive.  */
  66 };
  67
  68 /* These functions are declared to return int instead of void since they
  69    are going to be placed in a table and some old compilers have trouble with
  70    pointers to functions returning void.  */
  71
  72 static int do_define PARAMS ((cpp_reader *, const struct directive *));
  73 static int do_line PARAMS ((cpp_reader *, const struct directive *));
  74 static int do_include PARAMS ((cpp_reader *, const struct directive *));
  75 static int do_undef PARAMS ((cpp_reader *, const struct directive *));
  76 static int do_error PARAMS ((cpp_reader *, const struct directive *));
  77 static int do_pragma PARAMS ((cpp_reader *, const struct directive *));
  78 static int do_ident PARAMS ((cpp_reader *, const struct directive *));
  79 static int do_if PARAMS ((cpp_reader *, const struct directive *));
  80 static int do_xifdef PARAMS ((cpp_reader *, const struct directive *));
  81 static int do_else PARAMS ((cpp_reader *, const struct directive *));
  82 static int do_elif PARAMS ((cpp_reader *, const struct directive *));
  83 static int do_endif PARAMS ((cpp_reader *, const struct directive *));
  84 #ifdef SCCS_DIRECTIVE
  85 static int do_sccs PARAMS ((cpp_reader *, const struct directive *));
  86 #endif
  87 static int do_assert PARAMS ((cpp_reader *, const struct directive *));
  88 static int do_unassert PARAMS ((cpp_reader *, const struct directive *));
  89 static int do_warning PARAMS ((cpp_reader *, const struct directive *));
  90 static enum cpp_token null_underflow PARAMS ((cpp_reader *));
  91 static int null_cleanup PARAMS ((cpp_buffer *, cpp_reader *));
  92 static int skip_comment PARAMS ((cpp_reader *, int));
  93 static int copy_comment PARAMS ((cpp_reader *, int));
  94 static void copy_rest_of_line PARAMS ((cpp_reader *));
  95 static int handle_directive PARAMS ((cpp_reader *));
  96 static void pass_thru_directive PARAMS ((const U_CHAR *, size_t, cpp_reader *,
  97                                          const struct directive *));
  98 static enum cpp_token get_directive_token PARAMS ((cpp_reader *));
  99 static int read_line_number PARAMS ((cpp_reader *, int *));
 100 static void cpp_print_file_and_line PARAMS ((cpp_reader *));
 101 static void v_cpp_error PARAMS ((cpp_reader *, const char *, va_list));
 102 static void v_cpp_warning PARAMS ((cpp_reader *, const char *, va_list));
 103 static void v_cpp_error_with_line PARAMS ((cpp_reader *, int, int,
 104                                            const char *, va_list));
 105 static void v_cpp_warning_with_line PARAMS ((cpp_reader *, int, int, const char *, va_list));
 106 static U_CHAR *detect_if_not_defined PARAMS ((cpp_reader *));
 107 static int consider_directive_while_skipping PARAMS ((cpp_reader *, IF_STACK_FRAME *));
 108
 109 /* Here is the actual list of #-directives.
 110    This table is ordered by frequency of occurrence; the numbers
 111    at the end are directive counts from all the source code I have
 112    lying around (egcs and libc CVS as of 1999-05-18, plus grub-0.5.91,
 113    linux-2.2.9, and pcmcia-cs-3.0.9).  */
 114
 115 static const struct directive directive_table[] = {
 116   /* In C89 */
 117   {  6, do_define,   "define",       T_DEFINE },        /* 270554 */
 118   {  7, do_include,  "include",      T_INCLUDE },       /*  52262 */
 119   {  5, do_endif,    "endif",        T_ENDIF },         /*  45855 */
 120   {  5, do_xifdef,   "ifdef",        T_IFDEF },         /*  22000 */
 121   {  2, do_if,       "if",           T_IF },            /*  18162 */
 122   {  4, do_else,     "else",         T_ELSE },          /*   9863 */
 123   {  6, do_xifdef,   "ifndef",       T_IFNDEF },        /*   9675 */
 124   {  5, do_undef,    "undef",        T_UNDEF },         /*   4837 */
 125   {  4, do_line,     "line",         T_LINE },          /*   2465 */
 126   {  4, do_elif,     "elif",         T_ELIF },          /*    610 */
 127   {  5, do_error,    "error",        T_ERROR },         /*    475 */
 128   {  6, do_pragma,   "pragma",       T_PRAGMA },        /*    195 */
 129
 130   /* Extensions.  All deprecated except #warning and #include_next.  */
 131   {  7, do_warning,  "warning",      T_WARNING },       /*     22 - GNU   */
 132   { 12, do_include,  "include_next", T_INCLUDE_NEXT },  /*     19 - GNU   */
 133   {  5, do_ident,    "ident",        T_IDENT },         /*     11 - SVR4  */
 134   {  6, do_include,  "import",       T_IMPORT },        /*      0 - ObjC  */
 135   {  6, do_assert,   "assert",       T_ASSERT },        /*      0 - SVR4  */
 136   {  8, do_unassert, "unassert",     T_UNASSERT },      /*      0 - SVR4  */
 137 #ifdef SCCS_DIRECTIVE
 138   {  4, do_sccs,     "sccs",         T_SCCS },          /*      0 - SVR2? */
 139 #endif
 140   {  -1, 0, "", T_UNUSED }
 141 };
 142
 143 /* Place into PFILE a quoted string representing the string SRC.
 144    Caller must reserve enough space in pfile->token_buffer.  */
 145
 146 void
 147 quote_string (pfile, src)
 148      cpp_reader *pfile;
 149      const char *src;
 150 {
 151   U_CHAR c;
 152
 153   CPP_PUTC_Q (pfile, '\"');
 154   for (;;)
 155     switch ((c = *src++))
 156       {
 157       default:
 158         if (ISPRINT (c))
 159           CPP_PUTC_Q (pfile, c);
 160         else
 161           {
 162             sprintf ((char *)CPP_PWRITTEN (pfile), "\\%03o", c);
 163             CPP_ADJUST_WRITTEN (pfile, 4);
 164           }
 165         break;
 166
 167       case '\"':
 168       case '\\':
 169         CPP_PUTC_Q (pfile, '\\');
 170         CPP_PUTC_Q (pfile, c);
 171         break;
 172
 173       case '\0':
 174         CPP_PUTC_Q (pfile, '\"');
 175         CPP_NUL_TERMINATE_Q (pfile);
 176         return;
 177       }
 178 }
 179
 180 /* Re-allocates PFILE->token_buffer so it will hold at least N more chars.  */
 181
 182 void
 183 cpp_grow_buffer (pfile, n)
 184      cpp_reader *pfile;
 185      long n;
 186 {
 187   long old_written = CPP_WRITTEN (pfile);
 188   pfile->token_buffer_size = n + 2 * pfile->token_buffer_size;
 189   pfile->token_buffer = (U_CHAR *)
 190     xrealloc(pfile->token_buffer, pfile->token_buffer_size);
 191   CPP_SET_WRITTEN (pfile, old_written);
 192 }
 193
 194 /* Process the string STR as if it appeared as the body of a #define
 195    If STR is just an identifier, define it with value 1.
 196    If STR has anything after the identifier, then it should
 197    be identifier=definition. */
 198
 199 void
 200 cpp_define (pfile, str)
 201      cpp_reader *pfile;
 202      U_CHAR *str;
 203 {
 204   U_CHAR *buf, *p;
 205   size_t count;
 206
 207   /* Copy the entire option so we can modify it.  */
 208   count = strlen (str) + 3;
 209   buf = (U_CHAR *) alloca (count);
 210   memcpy (buf, str, count - 2);
 211   /* Change the first "=" in the string to a space.  If there is none,
 212      tack " 1" on the end. */
 213   p = (U_CHAR *) strchr (buf, '=');
 214   if (p)
 215     {
 216       *p = ' ';
 217       count -= 2;
 218     }
 219   else
 220       strcpy (&buf[count-3], " 1");
 221
 222   if (cpp_push_buffer (pfile, buf, count - 1) != NULL)
 223     {
 224       do_define (pfile, NULL);
 225       cpp_pop_buffer (pfile);
 226     }
 227 }
 228
 229 /* Process the string STR as if it appeared as the body of a #assert. */
 230 void
 231 cpp_assert (pfile, str)
 232      cpp_reader *pfile;
 233      U_CHAR *str;
 234 {
 235   if (cpp_push_buffer (pfile, str, strlen (str)) != NULL)
 236     {
 237       do_assert (pfile, NULL);
 238       cpp_pop_buffer (pfile);
 239     }
 240 }
 241
 242
 243 static enum cpp_token
 244 null_underflow (pfile)
 245      cpp_reader *pfile ATTRIBUTE_UNUSED;
 246 {
 247   return CPP_EOF;
 248 }
 249
 250 static int
 251 null_cleanup (pbuf, pfile)
 252      cpp_buffer *pbuf ATTRIBUTE_UNUSED;
 253      cpp_reader *pfile ATTRIBUTE_UNUSED;
 254 {
 255   return 0;
 256 }
 257
 258 /* Skip a comment - C, C++, or Chill style.  M is the first character
 259    of the comment marker.  If this really is a comment, skip to its
 260    end and return ' '.  If we hit end-of-file before end-of-comment,
 261    return EOF.  If this is not a comment, return M (which will be
 262    '/' or '-').  */
 263
 264 static int
 265 skip_comment (pfile, m)
 266      cpp_reader *pfile;
 267      int m;
 268 {
 269   if (m == '/' && PEEKC() == '*')
 270     {
 271       int c, prev_c = -1;
 272       long line, col;
 273
 274       FORWARD(1);
 275       cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
 276       for (;;)
 277         {
 278           c = GETC ();
 279           if (c == EOF)
 280             {
 281               cpp_error_with_line (pfile, line, col, "unterminated comment");
 282               return EOF;
 283             }
 284           else if (c == '\n' || c == '\r')
 285             /* \r cannot be a macro escape marker here. */
 286             CPP_BUMP_LINE (pfile);
 287           else if (c == '/' && prev_c == '*')
 288             return ' ';
 289           else if (c == '*' && prev_c == '/'
 290                    && CPP_OPTIONS (pfile)->warn_comments)
 291             cpp_warning (pfile, "`/*' within comment");
 292
 293           prev_c = c;
 294         }
 295     }
 296   else if ((m == '/' && PEEKC() == '/'
 297             && CPP_OPTIONS (pfile)->cplusplus_comments)
 298            || (m == '-' && PEEKC() == '-'
 299                && CPP_OPTIONS (pfile)->chill))
 300     {
 301       FORWARD(1);
 302       for (;;)
 303         {
 304           int c = GETC ();
 305           if (c == EOF)
 306             return ' '; /* Allow // to be terminated by EOF.  */
 307               if (c == '\n')
 308                 {
 309                   /* Don't consider final '\n' to be part of comment.  */
 310                   FORWARD(-1);
 311                   return ' ';
 312                 }
 313               else if (c == '\r')
 314                 /* \r cannot be a macro escape marker here. */
 315                 CPP_BUMP_LINE (pfile);
 316         }
 317     }
 318   else
 319     return m;
 320 }
 321
 322 /* Identical to skip_comment except that it copies the comment into the
 323    token_buffer.  This is used if put_out_comments.  */
 324 static int
 325 copy_comment (pfile, m)
 326      cpp_reader *pfile;
 327      int m;
 328 {
 329   if (m == '/' && PEEKC() == '*')
 330     {
 331       int c, prev_c = -1;
 332       long line, col;
 333
 334       CPP_PUTC (pfile, '/');
 335       CPP_PUTC (pfile, '*');
 336       FORWARD(1);
 337       cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
 338       for (;;)
 339         {
 340           c = GETC ();
 341           if (c == EOF)
 342             {
 343               cpp_error_with_line (pfile, line, col, "unterminated comment");
 344               /* We must pretend this was a legitimate comment, so that the
 345                  output in token_buffer is not passed back tagged CPP_POP. */
 346               return ' ';
 347             }
 348           else if (c == '\r')
 349             {
 350               /* \r cannot be a macro escape marker here. */
 351               CPP_BUMP_LINE (pfile);
 352               continue;
 353             }
 354
 355           CPP_PUTC (pfile, c);
 356           if (c == '\n')
 357             {
 358               pfile->lineno++;
 359               CPP_BUMP_LINE (pfile);
 360             }
 361           else if (c == '/' && prev_c == '*')
 362             return ' ';
 363           else if (c == '*' && prev_c == '/'
 364                    && CPP_OPTIONS (pfile)->warn_comments)
 365             cpp_warning (pfile, "`/*' within comment");
 366
 367           prev_c = c;
 368         }
 369     }
 370   else if ((m == '/' && PEEKC() == '/'
 371             && CPP_OPTIONS (pfile)->cplusplus_comments)
 372            || (m == '-' && PEEKC() == '-'
 373                && CPP_OPTIONS (pfile)->chill))
 374     {
 375       CPP_PUTC (pfile, m);
 376       CPP_PUTC (pfile, m);
 377       FORWARD(1);
 378       for (;;)
 379         {
 380           int c = GETC ();
 381           if (c == EOF)
 382             return ' '; /* Allow line comments to be terminated by EOF. */
 383           else if (c == '\n')
 384             {
 385               /* Don't consider final '\n' to be part of comment.  */
 386               FORWARD(-1);
 387               return ' ';
 388             }
 389           else if (c == '\r')
 390             /* \r cannot be a macro escape marker here. */
 391             CPP_BUMP_LINE (pfile);
 392
 393           CPP_PUTC (pfile, c);
 394         }
 395     }
 396   else
 397     return m;
 398 }
 399
 400
 401 /* Skip whitespace \-newline and comments.  Does not macro-expand.  */
 402
 403 void
 404 cpp_skip_hspace (pfile)
 405      cpp_reader *pfile;
 406 {
 407   int c;
 408   while (1)
 409     {
 410       c = GETC();
 411       if (c == EOF)
 412         return;
 413       else if (is_hspace(c))
 414         {
 415           if ((c == '\f' || c == '\v') && CPP_PEDANTIC (pfile))
 416             cpp_pedwarn (pfile, "%s in preprocessing directive",
 417                          c == '\f' ? "formfeed" : "vertical tab");
 418         }
 419       else if (c == '\r')
 420         {
 421           /* \r is a backslash-newline marker if !has_escapes, and
 422              a deletable-whitespace or no-reexpansion marker otherwise. */
 423           if (CPP_BUFFER (pfile)->has_escapes)
 424             {
 425               if (PEEKC() == ' ')
 426                 FORWARD(1);
 427               else
 428                 break;
 429             }
 430           else
 431             CPP_BUFFER (pfile)->lineno++;
 432         }
 433       else if (c == '/' || c == '-')
 434         {
 435           c = skip_comment (pfile, c);
 436           if (c == EOF)
 437             return;
 438           else if (c != ' ')
 439             break;
 440         }
 441       else
 442         break;
 443     }
 444   FORWARD(-1);
 445 }
 446
 447 /* Read the rest of the current line.
 448    The line is appended to PFILE's output buffer.  */
 449
 450 static void
 451 copy_rest_of_line (pfile)
 452      cpp_reader *pfile;
 453 {
 454   for (;;)
 455     {
 456       int c = GETC();
 457       switch (c)
 458         {
 459         case '\n':
 460           FORWARD(-1);
 461         case EOF:
 462           CPP_NUL_TERMINATE (pfile);
 463           return;
 464
 465         case '\r':
 466           if (CPP_BUFFER (pfile)->has_escapes)
 467             break;
 468           else
 469             {
 470               CPP_BUFFER (pfile)->lineno++;
 471               continue;
 472             }
 473         case '\'':
 474         case '\"':
 475           parse_string (pfile, c);
 476           continue;
 477         case '/':
 478           if (PEEKC() == '*' && CPP_TRADITIONAL (pfile))
 479             {
 480               CPP_PUTS (pfile, "/**/", 4);
 481               skip_comment (pfile, c);
 482               continue;
 483             }
 484           /* else fall through */
 485         case '-':
 486           c = skip_comment (pfile, c);
 487           break;
 488
 489         case '\f':
 490         case '\v':
 491           if (CPP_PEDANTIC (pfile))
 492             cpp_pedwarn (pfile, "%s in preprocessing directive",
 493                          c == '\f' ? "formfeed" : "vertical tab");
 494           break;
 495
 496         }
 497       CPP_PUTC (pfile, c);
 498     }
 499 }
 500
 501 /* FIXME: It is almost definitely a performance win to make this do
 502    the scan itself.  >75% of calls to copy_r_o_l are from here or
 503    skip_if_group, which means the common case is to copy stuff into the
 504    token_buffer only to discard it.  */
 505 void
 506 skip_rest_of_line (pfile)
 507      cpp_reader *pfile;
 508 {
 509   long old = CPP_WRITTEN (pfile);
 510   copy_rest_of_line (pfile);
 511   CPP_SET_WRITTEN (pfile, old);
 512 }
 513
 514 /* Handle a possible # directive.
 515    '#' has already been read.  */
 516
 517 static int
 518 handle_directive (pfile)
 519      cpp_reader *pfile;
 520 {
 521   int c;
 522   register const struct directive *kt;
 523   int ident_length;
 524   U_CHAR *ident;
 525   long old_written = CPP_WRITTEN (pfile);
 526
 527   cpp_skip_hspace (pfile);
 528
 529   c = PEEKC ();
 530   if (c >= '0' && c <= '9')
 531     {
 532       /* Handle # followed by a line number.  Complain about using that
 533          form if we're being pedantic, but not if this is regurgitated
 534          input (preprocessed or fed back in by the C++ frontend).  */
 535       if (CPP_PEDANTIC (pfile)
 536           && ! CPP_PREPROCESSED (pfile)
 537           && ! CPP_BUFFER (pfile)->manual_pop)
 538         cpp_pedwarn (pfile, "`#' followed by integer");
 539       do_line (pfile, NULL);
 540       return 1;
 541     }
 542
 543   /* Now find the directive name.  */
 544   CPP_PUTC (pfile, '#');
 545   parse_name (pfile, GETC());
 546   ident = pfile->token_buffer + old_written + 1;
 547   ident_length = CPP_PWRITTEN (pfile) - ident;
 548   if (ident_length == 0)
 549     {
 550       /* A line of just `#' becomes blank.  */
 551       if (PEEKC() == '\n')
 552         return 1;
 553       else
 554         return 0;
 555     }
 556
 557   /*
 558    * Decode the keyword and call the appropriate expansion
 559    * routine, after moving the input pointer up to the next line.
 560    */
 561   for (kt = directive_table; ; kt++)
 562     {
 563       if (kt->length <= 0)
 564         return 0;
 565       if (kt->length == ident_length
 566           && !strncmp (kt->name, ident, ident_length))
 567         break;
 568     }
 569
 570   CPP_SET_WRITTEN (pfile, old_written);
 571   (*kt->func) (pfile, kt);
 572
 573   return 1;
 574 }
 575
 576 /* Pass a directive through to the output file.
 577    BUF points to the contents of the directive, as a contiguous string.
 578    LEN is the length of the string pointed to by BUF.
 579    KEYWORD is the keyword-table entry for the directive.  */
 580
 581 static void
 582 pass_thru_directive (buf, len, pfile, keyword)
 583      const U_CHAR *buf;
 584      size_t len;
 585      cpp_reader *pfile;
 586      const struct directive *keyword;
 587 {
 588   register unsigned keyword_length = keyword->length;
 589
 590   CPP_RESERVE (pfile, 1 + keyword_length + len);
 591   CPP_PUTC_Q (pfile, '#');
 592   CPP_PUTS_Q (pfile, keyword->name, keyword_length);
 593   if (len != 0 && buf[0] != ' ')
 594     CPP_PUTC_Q (pfile, ' ');
 595   CPP_PUTS_Q (pfile, buf, len);
 596 }
 597
 598 /* Check a purported macro name SYMNAME, and yield its length.  */
 599
 600 int
 601 check_macro_name (pfile, symname)
 602      cpp_reader *pfile;
 603      const U_CHAR *symname;
 604 {
 605   const U_CHAR *p;
 606   int sym_length;
 607
 608   for (p = symname; is_idchar(*p); p++)
 609     ;
 610   sym_length = p - symname;
 611   if (sym_length == 0
 612       || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
 613     cpp_error (pfile, "invalid macro name");
 614   else if (!is_idstart(*symname)
 615            || (! strncmp (symname, "defined", 7) && sym_length == 7)) {
 616     U_CHAR *msg;                        /* what pain...  */
 617     msg = (U_CHAR *) alloca (sym_length + 1);
 618     bcopy (symname, msg, sym_length);
 619     msg[sym_length] = 0;
 620     cpp_error (pfile, "invalid macro name `%s'", msg);
 621   }
 622   return sym_length;
 623 }
 624
 625 /* Process a #define command.
 626    KEYWORD is the keyword-table entry for #define,
 627    or NULL for a "predefined" macro,
 628    or the keyword-table entry for #pragma in the case of a #pragma poison.  */
 629
 630 static int
 631 do_define (pfile, keyword)
 632      cpp_reader *pfile;
 633      const struct directive *keyword;
 634 {
 635   int hashcode;
 636   MACRODEF mdef;
 637   HASHNODE *hp;
 638   long here;
 639   U_CHAR *macro, *buf, *end;
 640   enum node_type new_type;
 641
 642   here = CPP_WRITTEN (pfile);
 643   copy_rest_of_line (pfile);
 644
 645   if (keyword == NULL || keyword->type == T_DEFINE)
 646     new_type = T_MACRO;
 647   else
 648     new_type = T_POISON;
 649
 650   /* Copy out the line so we can pop the token buffer. */
 651   buf = pfile->token_buffer + here;
 652   end = CPP_PWRITTEN (pfile);
 653   macro = (U_CHAR *) alloca (end - buf + 1);
 654   bcopy (buf, macro, end - buf + 1);
 655   end = macro + (end - buf);
 656
 657   CPP_SET_WRITTEN (pfile, here);
 658
 659   mdef = create_definition (macro, end, pfile, keyword == NULL);
 660   if (mdef.defn == 0)
 661     return 0;
 662
 663   hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
 664
 665   if ((hp = cpp_lookup (pfile, mdef.symnam, mdef.symlen, hashcode)) != NULL)
 666     {
 667       int ok = 0;
 668       /* Redefining a precompiled key is ok.  */
 669       if (hp->type == T_PCSTRING)
 670         ok = 1;
 671       /* Redefining a poisoned identifier is even worse than `not ok'.  */
 672       else if (hp->type == T_POISON)
 673         ok = -1;
 674       /* Redefining a macro is ok if the definitions are the same.  */
 675       else if (hp->type == T_MACRO)
 676         ok = ! compare_defs (pfile, mdef.defn, hp->value.defn);
 677       /* Redefining a constant is ok with -D.  */
 678       else if (hp->type == T_CONST || hp->type == T_STDC)
 679         ok = ! CPP_OPTIONS (pfile)->done_initializing;
 680       /* Print the warning or error if it's not ok.  */
 681       if (ok <= 0)
 682         {
 683           if (hp->type == T_POISON)
 684             cpp_error (pfile, "redefining poisoned `%.*s'",
 685                        mdef.symlen, mdef.symnam);
 686           else
 687             cpp_pedwarn (pfile, "`%.*s' redefined", mdef.symlen, mdef.symnam);
 688           if (hp->type == T_MACRO)
 689             cpp_pedwarn_with_file_and_line (pfile, hp->value.defn->file,
 690                                             hp->value.defn->line,
 691                         "this is the location of the previous definition");
 692         }
 693       if (hp->type != T_POISON)
 694         {
 695           /* Replace the old definition.  */
 696           hp->type = new_type;
 697           hp->value.defn = mdef.defn;
 698         }
 699     }
 700   else
 701     cpp_install (pfile, mdef.symnam, mdef.symlen, new_type,
 702                  (char *) mdef.defn, hashcode);
 703
 704   if (keyword != NULL && keyword->type == T_DEFINE)
 705     {
 706       if (CPP_OPTIONS (pfile)->debug_output
 707           || CPP_OPTIONS (pfile)->dump_macros == dump_definitions)
 708         dump_definition (pfile, mdef);
 709       else if (CPP_OPTIONS (pfile)->dump_macros == dump_names)
 710         pass_thru_directive (mdef.symnam, mdef.symlen, pfile, keyword);
 711     }
 712
 713   return 0;
 714 }
 715
 716
 717 /* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack.
 718    If BUFFER != NULL, then use the LENGTH characters in BUFFER
 719    as the new input buffer.
 720    Return the new buffer, or NULL on failure.  */
 721
 722 cpp_buffer *
 723 cpp_push_buffer (pfile, buffer, length)
 724      cpp_reader *pfile;
 725      U_CHAR *buffer;
 726      long length;
 727 {
 728   cpp_buffer *buf = CPP_BUFFER (pfile);
 729   cpp_buffer *new;
 730   if (++pfile->buffer_stack_depth == CPP_STACK_MAX)
 731     {
 732       cpp_fatal (pfile, "macro or `#include' recursion too deep");
 733       return NULL;
 734     }
 735
 736   new = (cpp_buffer *) xcalloc (1, sizeof (cpp_buffer));
 737
 738   new->if_stack = pfile->if_stack;
 739   new->cleanup = null_cleanup;
 740   new->underflow = null_underflow;
 741   new->buf = new->cur = buffer;
 742   new->alimit = new->rlimit = buffer + length;
 743   new->prev = buf;
 744   new->mark = -1;
 745
 746   CPP_BUFFER (pfile) = new;
 747   return new;
 748 }
 749
 750 cpp_buffer *
 751 cpp_pop_buffer (pfile)
 752      cpp_reader *pfile;
 753 {
 754   cpp_buffer *buf = CPP_BUFFER (pfile);
 755   (*buf->cleanup) (buf, pfile);
 756   CPP_BUFFER (pfile) = CPP_PREV_BUFFER (buf);
 757   free (buf);
 758   pfile->buffer_stack_depth--;
 759   return CPP_BUFFER (pfile);
 760 }
 761
 762 /* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
 763    Pop the buffer when done.  */
 764
 765 void
 766 cpp_scan_buffer (pfile)
 767      cpp_reader *pfile;
 768 {
 769   cpp_buffer *buffer = CPP_BUFFER (pfile);
 770   enum cpp_token token;
 771   if (CPP_OPTIONS (pfile)->no_output)
 772     {
 773       long old_written = CPP_WRITTEN (pfile);
 774       /* In no-output mode, we can ignore everything but directives.  */
 775       for (;;)
 776         {
 777           if (! pfile->only_seen_white)
 778             skip_rest_of_line (pfile);
 779           token = cpp_get_token (pfile);
 780           if (token == CPP_EOF) /* Should not happen ...  */
 781             break;
 782           if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
 783             {
 784               if (CPP_PREV_BUFFER (CPP_BUFFER (pfile))
 785                   != CPP_NULL_BUFFER (pfile))
 786                 cpp_pop_buffer (pfile);
 787               break;
 788             }
 789         }
 790       CPP_SET_WRITTEN (pfile, old_written);
 791     }
 792   else
 793     {
 794       for (;;)
 795         {
 796           token = cpp_get_token (pfile);
 797           if (token == CPP_EOF) /* Should not happen ...  */
 798             break;
 799           if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
 800             {
 801               if (CPP_PREV_BUFFER (CPP_BUFFER (pfile))
 802                   != CPP_NULL_BUFFER (pfile))
 803                 cpp_pop_buffer (pfile);
 804               break;
 805             }
 806         }
 807     }
 808 }
 809
 810 /*
 811  * Rescan a string (which may have escape marks) into pfile's buffer.
 812  * Place the result in pfile->token_buffer.
 813  *
 814  * The input is copied before it is scanned, so it is safe to pass
 815  * it something from the token_buffer that will get overwritten
 816  * (because it follows CPP_WRITTEN).  This is used by do_include.
 817  */
 818
 819 void
 820 cpp_expand_to_buffer (pfile, buf, length)
 821      cpp_reader *pfile;
 822      const U_CHAR *buf;
 823      int length;
 824 {
 825   register cpp_buffer *ip;
 826   U_CHAR *buf1;
 827   int save_no_output;
 828
 829   if (length < 0)
 830     {
 831       cpp_fatal (pfile, "internal error: length < 0 in cpp_expand_to_buffer");
 832       return;
 833     }
 834
 835   /* Set up the input on the input stack.  */
 836
 837   buf1 = (U_CHAR *) alloca (length + 1);
 838   memcpy (buf1, buf, length);
 839   buf1[length] = 0;
 840
 841   ip = cpp_push_buffer (pfile, buf1, length);
 842   if (ip == NULL)
 843     return;
 844   ip->has_escapes = 1;
 845
 846   /* Scan the input, create the output.  */
 847   save_no_output = CPP_OPTIONS (pfile)->no_output;
 848   CPP_OPTIONS (pfile)->no_output = 0;
 849   cpp_scan_buffer (pfile);
 850   CPP_OPTIONS (pfile)->no_output = save_no_output;
 851
 852   CPP_NUL_TERMINATE (pfile);
 853 }
 854
 855 void
 856 cpp_buf_line_and_col (pbuf, linep, colp)
 857      register cpp_buffer *pbuf;
 858      long *linep, *colp;
 859 {
 860   if (pbuf)
 861     {
 862       *linep = pbuf->lineno;
 863       if (colp)
 864         *colp = pbuf->cur - pbuf->line_base;
 865     }
 866   else
 867     {
 868       *linep = 0;
 869       if (colp)
 870         *colp = 0;
 871     }
 872 }
 873
 874 /* Return the cpp_buffer that corresponds to a file (not a macro).  */
 875
 876 cpp_buffer *
 877 cpp_file_buffer (pfile)
 878      cpp_reader *pfile;
 879 {
 880   cpp_buffer *ip = CPP_BUFFER (pfile);
 881
 882   for ( ; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
 883     if (ip->fname != NULL)
 884       return ip;
 885   return NULL;
 886 }
 887
 888 /*
 889  * write out a #line command, for instance, after an #include file.
 890  * FILE_CHANGE says whether we are entering a file, leaving, or neither.
 891  */
 892
 893 void
 894 output_line_command (pfile, file_change)
 895      cpp_reader *pfile;
 896      enum file_change_code file_change;
 897 {
 898   long line;
 899   cpp_buffer *ip = CPP_BUFFER (pfile);
 900
 901   if (ip->fname == NULL)
 902     return;
 903
 904   if (CPP_OPTIONS (pfile)->no_line_commands
 905       || CPP_OPTIONS (pfile)->no_output)
 906     return;
 907
 908   cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, NULL);
 909
 910   /* If the current file has not changed, we omit the #line if it would
 911      appear to be a no-op, and we output a few newlines instead
 912      if we want to increase the line number by a small amount.
 913      We cannot do this if pfile->lineno is zero, because that means we
 914      haven't output any line commands yet.  (The very first line command
 915      output is a `same_file' command.)  */
 916   if (file_change == same_file && pfile->lineno != 0)
 917     {
 918       if (line == pfile->lineno)
 919         return;
 920
 921       /* If the inherited line number is a little too small,
 922          output some newlines instead of a #line command.  */
 923       if (line > pfile->lineno && line < pfile->lineno + 8)
 924         {
 925           CPP_RESERVE (pfile, 20);
 926           while (line > pfile->lineno)
 927             {
 928               CPP_PUTC_Q (pfile, '\n');
 929               pfile->lineno++;
 930             }
 931           return;
 932         }
 933     }
 934
 935   CPP_RESERVE (pfile, 4 * strlen (ip->nominal_fname) + 50);
 936   CPP_PUTS_Q (pfile, "# ", 2);
 937
 938   sprintf ((char *) CPP_PWRITTEN (pfile), "%ld ", line);
 939   CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
 940
 941   quote_string (pfile, ip->nominal_fname);
 942   if (file_change != same_file)
 943     {
 944       CPP_PUTC_Q (pfile, ' ');
 945       CPP_PUTC_Q (pfile, file_change == enter_file ? '1' : '2');
 946     }
 947   /* Tell cc1 if following text comes from a system header file.  */
 948   if (ip->system_header_p)
 949     {
 950       CPP_PUTC_Q (pfile, ' ');
 951       CPP_PUTC_Q (pfile, '3');
 952     }
 953 #ifndef NO_IMPLICIT_EXTERN_C
 954   /* Tell cc1plus if following text should be treated as C.  */
 955   if (ip->system_header_p == 2 && CPP_OPTIONS (pfile)->cplusplus)
 956     {
 957       CPP_PUTC_Q (pfile, ' ');
 958       CPP_PUTC_Q (pfile, '4');
 959     }
 960 #endif
 961   CPP_PUTC_Q (pfile, '\n');
 962   pfile->lineno = line;
 963 }
 964
 965
 966 /* Like cpp_get_token, except that it does not read past end-of-line.
 967    Also, horizontal space is skipped, and macros are popped.  */
 968
 969 static enum cpp_token
 970 get_directive_token (pfile)
 971      cpp_reader *pfile;
 972 {
 973   for (;;)
 974     {
 975       long old_written = CPP_WRITTEN (pfile);
 976       enum cpp_token token;
 977       cpp_skip_hspace (pfile);
 978       if (PEEKC () == '\n')
 979           return CPP_VSPACE;
 980       token = cpp_get_token (pfile);
 981       switch (token)
 982       {
 983       case CPP_POP:
 984           if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
 985               return token;
 986           /* ... else fall though ...  */
 987       case CPP_HSPACE:  case CPP_COMMENT:
 988           CPP_SET_WRITTEN (pfile, old_written);
 989           break;
 990       default:
 991           return token;
 992       }
 993     }
 994 }
 995 \f
 996 /* Handle #include and #import.
 997    This function expects to see "fname" or <fname> on the input.
 998
 999    The input is normally in part of the output_buffer following
1000    CPP_WRITTEN, and will get overwritten by output_line_command.
1001    I.e. in input file specification has been popped by handle_directive.
1002    This is safe.  */
1003
1004 static int
1005 do_include (pfile, keyword)
1006      cpp_reader *pfile;
1007      const struct directive *keyword;
1008 {
1009   int importing = (keyword->type == T_IMPORT);
1010   int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
1011   int angle_brackets = 0;       /* 0 for "...", 1 for <...> */
1012   int before;  /* included before? */
1013   long flen;
1014   unsigned char *ftok;
1015   cpp_buffer *fp;
1016
1017   enum cpp_token token;
1018
1019   /* Chain of dirs to search */
1020   struct include_hash *ihash;
1021   struct file_name_list *search_start;
1022
1023   long old_written = CPP_WRITTEN (pfile);
1024
1025   int fd;
1026
1027   if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
1028     {
1029       if (importing)
1030         cpp_pedwarn (pfile, "ANSI C does not allow `#import'");
1031       if (skip_dirs)
1032         cpp_pedwarn (pfile, "ANSI C does not allow `#include_next'");
1033     }
1034
1035   if (importing && CPP_OPTIONS (pfile)->warn_import
1036       && !CPP_OPTIONS (pfile)->inhibit_warnings
1037       && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
1038     {
1039       pfile->import_warning = 1;
1040       cpp_warning (pfile,
1041            "#import is obsolete, use an #ifndef wrapper in the header file");
1042     }
1043
1044   pfile->parsing_include_directive++;
1045   token = get_directive_token (pfile);
1046   pfile->parsing_include_directive--;
1047
1048   if (token == CPP_STRING)
1049     {
1050       if (pfile->token_buffer[old_written] == '<')
1051         angle_brackets = 1;
1052     }
1053 #ifdef VMS
1054   else if (token == CPP_NAME)
1055     {
1056       /* Support '#include xyz' like VAX-C.  It is taken as
1057          '#include <xyz.h>' and generates a warning.  */
1058       cpp_warning (pfile,
1059                "`#include filename' is obsolete, use `#include <filename.h>'");
1060       angle_brackets = 1;
1061
1062       /* Append the missing `.h' to the name. */
1063       CPP_PUTS (pfile, ".h", 2);
1064     }
1065 #endif
1066   else
1067     {
1068       cpp_error (pfile,
1069                  "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
1070       CPP_SET_WRITTEN (pfile, old_written);
1071       skip_rest_of_line (pfile);
1072       return 0;
1073     }
1074
1075   flen = CPP_WRITTEN (pfile) - old_written;
1076   ftok = (unsigned char *) alloca (flen + 1);
1077   memcpy (ftok, pfile->token_buffer + old_written, flen);
1078   ftok[flen] = '\0';
1079
1080   if (get_directive_token (pfile) != CPP_VSPACE)
1081     {
1082       cpp_error (pfile, "junk at end of `#include'");
1083       skip_rest_of_line (pfile);
1084     }
1085
1086   CPP_SET_WRITTEN (pfile, old_written);
1087
1088   if (flen == 0)
1089     {
1090       cpp_error (pfile, "empty file name in `#%s'", keyword->name);
1091       return 0;
1092     }
1093
1094   if (CPP_OPTIONS (pfile)->dump_includes)
1095     pass_thru_directive (ftok,
1096                          flen
1097 #ifdef VMS
1098           - ((token == CPP_NAME) ? 2 : 0)
1099 #endif
1100                          , pfile, keyword);
1101
1102 #ifdef VMS
1103   if (token == CPP_STRING)
1104 #endif
1105     {
1106       ftok++;
1107       flen -= 2;
1108       ftok[flen] = '\0';
1109     }
1110
1111   search_start = 0;
1112
1113   for (fp = CPP_BUFFER (pfile);
1114        fp != CPP_NULL_BUFFER (pfile);
1115        fp = CPP_PREV_BUFFER (fp))
1116     if (fp->fname != NULL)
1117       break;
1118
1119   if (fp == CPP_NULL_BUFFER (pfile))
1120     {
1121       cpp_fatal (pfile, "cpp internal error: fp == NULL_BUFFER in do_include");
1122       return 0;
1123     }
1124
1125   /* For #include_next, skip in the search path past the dir in which the
1126      containing file was found.  Treat files specified using an absolute path
1127      as if there are no more directories to search.  Treat the primary source
1128      file like any other included source, but generate a warning.  */
1129   if (skip_dirs && CPP_PREV_BUFFER(fp) != CPP_NULL_BUFFER (pfile))
1130     {
1131       if (fp->ihash->foundhere != ABSOLUTE_PATH)
1132         search_start = fp->ihash->foundhere->next;
1133     }
1134   else
1135     {
1136       if (skip_dirs)
1137         cpp_warning (pfile, "#include_next in primary source file");
1138
1139       if (angle_brackets)
1140         search_start = CPP_OPTIONS (pfile)->bracket_include;
1141       else
1142         {
1143           if (!CPP_OPTIONS (pfile)->ignore_srcdir)
1144             {
1145               if (fp)
1146                 search_start = fp->actual_dir;
1147             }
1148           else
1149             search_start = CPP_OPTIONS (pfile)->quote_include;
1150         }
1151     }
1152
1153   if (!search_start)
1154     {
1155       cpp_error (pfile, "No include path in which to find %s", ftok);
1156       return 0;
1157     }
1158
1159   fd = find_include_file (pfile, ftok, search_start, &ihash, &before);
1160
1161   if (fd == -2)
1162     return 0;
1163
1164   if (fd == -1)
1165     {
1166       if (CPP_OPTIONS (pfile)->print_deps_missing_files
1167           && CPP_PRINT_DEPS (pfile) > (angle_brackets ||
1168                                        (pfile->system_include_depth > 0)))
1169         {
1170           if (!angle_brackets)
1171             deps_output (pfile, ftok, ' ');
1172           else
1173             {
1174               char *p;
1175               struct file_name_list *ptr;
1176               /* If requested as a system header, assume it belongs in
1177                  the first system header directory. */
1178               if (CPP_OPTIONS (pfile)->bracket_include)
1179                 ptr = CPP_OPTIONS (pfile)->bracket_include;
1180               else
1181                 ptr = CPP_OPTIONS (pfile)->quote_include;
1182
1183               p = (char *) alloca (strlen (ptr->name)
1184                                    + strlen (ftok) + 2);
1185               if (*ptr->name != '\0')
1186                 {
1187                   strcpy (p, ptr->name);
1188                   strcat (p, "/");
1189                 }
1190               strcat (p, ftok);
1191               deps_output (pfile, p, ' ');
1192             }
1193         }
1194       /* If -M was specified, and this header file won't be added to
1195          the dependency list, then don't count this as an error,
1196          because we can still produce correct output.  Otherwise, we
1197          can't produce correct output, because there may be
1198          dependencies we need inside the missing file, and we don't
1199          know what directory this missing file exists in. */
1200       else if (CPP_PRINT_DEPS (pfile)
1201                && (CPP_PRINT_DEPS (pfile)
1202                    <= (angle_brackets || (pfile->system_include_depth > 0))))
1203         cpp_warning (pfile, "No include path in which to find %s", ftok);
1204       else
1205         cpp_error_from_errno (pfile, ftok);
1206
1207       return 0;
1208     }
1209
1210   /* For -M, add the file to the dependencies on its first inclusion. */
1211   if (!before && (CPP_PRINT_DEPS (pfile)
1212                   > (angle_brackets || (pfile->system_include_depth > 0))))
1213     deps_output (pfile, ihash->name, ' ');
1214
1215   /* Handle -H option.  */
1216   if (CPP_OPTIONS(pfile)->print_include_names)
1217     {
1218       fp = CPP_BUFFER (pfile);
1219       while ((fp = CPP_PREV_BUFFER (fp)) != CPP_NULL_BUFFER (pfile))
1220         putc ('.', stderr);
1221       fprintf (stderr, " %s\n", ihash->name);
1222     }
1223
1224   /* Actually process the file */
1225
1226   if (importing)
1227     ihash->control_macro = "";
1228
1229   if (cpp_push_buffer (pfile, NULL, 0) == NULL)
1230     {
1231       close (fd);
1232       return 0;
1233     }
1234
1235   if (angle_brackets)
1236     pfile->system_include_depth++;   /* Decremented in file_cleanup. */
1237
1238   if (finclude (pfile, fd, ihash))
1239     {
1240       output_line_command (pfile, enter_file);
1241       pfile->only_seen_white = 2;
1242     }
1243
1244   return 0;
1245 }
1246
1247 /* Subroutine of do_line.  Read next token from PFILE without adding it to
1248    the output buffer.  If it is a number between 1 and 4, store it in *NUM
1249    and return 1; otherwise, return 0 and complain if we aren't at the end
1250    of the directive.  */
1251
1252 static int
1253 read_line_number (pfile, num)
1254      cpp_reader *pfile;
1255      int *num;
1256 {
1257   long save_written = CPP_WRITTEN (pfile);
1258   U_CHAR *p = pfile->token_buffer + save_written;
1259   enum cpp_token token = get_directive_token (pfile);
1260   CPP_SET_WRITTEN (pfile, save_written);
1261
1262   if (token == CPP_NUMBER && *p >= '1' && *p <= '4' && p[1] == '\0')
1263     {
1264       *num = p[0] - '0';
1265       return 1;
1266     }
1267   else
1268     {
1269       if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP)
1270         cpp_error (pfile, "invalid format `#line' command");
1271       return 0;
1272     }
1273 }
1274
1275 /* Interpret #line command.
1276    Note that the filename string (if any) is treated as if it were an
1277    include filename.  That means no escape handling.  */
1278
1279 static int
1280 do_line (pfile, keyword)
1281      cpp_reader *pfile;
1282      const struct directive *keyword ATTRIBUTE_UNUSED;
1283 {
1284   cpp_buffer *ip = CPP_BUFFER (pfile);
1285   int new_lineno;
1286   long old_written = CPP_WRITTEN (pfile);
1287   enum file_change_code file_change = same_file;
1288   enum cpp_token token;
1289   char *x;
1290
1291   token = get_directive_token (pfile);
1292
1293   if (token != CPP_NUMBER)
1294     {
1295       cpp_error (pfile, "token after `#line' is not an integer");
1296       goto bad_line_directive;
1297     }
1298
1299   new_lineno = strtol (pfile->token_buffer + old_written, &x, 10);
1300   if (x[0] != '\0')
1301     {
1302       cpp_error (pfile, "token after `#line' is not an integer");
1303       goto bad_line_directive;
1304     }
1305   CPP_SET_WRITTEN (pfile, old_written);
1306
1307   if (CPP_PEDANTIC (pfile) && new_lineno <= 0)
1308     cpp_pedwarn (pfile, "line number out of range in `#line' command");
1309
1310   token = get_directive_token (pfile);
1311
1312   if (token == CPP_STRING)
1313     {
1314       U_CHAR *fname = pfile->token_buffer + old_written + 1;
1315       U_CHAR *end_name = CPP_PWRITTEN (pfile) - 1;
1316       int action_number = 0;
1317
1318       if (read_line_number (pfile, &action_number))
1319         {
1320           if (CPP_PEDANTIC (pfile))
1321             cpp_pedwarn (pfile, "garbage at end of `#line' command");
1322
1323           if (action_number == 1)
1324             {
1325               file_change = enter_file;
1326               read_line_number (pfile, &action_number);
1327             }
1328           else if (action_number == 2)
1329             {
1330               file_change = leave_file;
1331               read_line_number (pfile, &action_number);
1332             }
1333           if (action_number == 3)
1334             {
1335               ip->system_header_p = 1;
1336               read_line_number (pfile, &action_number);
1337             }
1338           if (action_number == 4)
1339             {
1340               ip->system_header_p = 2;
1341               read_line_number (pfile, &action_number);
1342             }
1343         }
1344
1345       *end_name = '\0';
1346
1347       if (strcmp (fname, ip->nominal_fname))
1348         {
1349           const char *newname, *oldname;
1350           if (!strcmp (fname, ip->fname))
1351             newname = ip->fname;
1352           else if (ip->last_nominal_fname
1353                    && !strcmp (fname, ip->last_nominal_fname))
1354             newname = ip->last_nominal_fname;
1355           else
1356             newname = xstrdup (fname);
1357
1358           oldname = ip->nominal_fname;
1359           ip->nominal_fname = newname;
1360
1361           if (ip->last_nominal_fname
1362               && ip->last_nominal_fname != oldname
1363               && ip->last_nominal_fname != newname
1364               && ip->last_nominal_fname != ip->fname)
1365             free ((void *) ip->last_nominal_fname);
1366
1367           if (newname == ip->fname)
1368             ip->last_nominal_fname = NULL;
1369           else
1370             ip->last_nominal_fname = oldname;
1371         }
1372     }
1373   else if (token != CPP_VSPACE && token != CPP_EOF)
1374     {
1375       cpp_error (pfile, "token after `#line %d' is not a string", new_lineno);
1376       goto bad_line_directive;
1377     }
1378
1379   /* The Newline at the end of this line remains to be processed.
1380      To put the next line at the specified line number,
1381      we must store a line number now that is one less.  */
1382   ip->lineno = new_lineno - 1;
1383   CPP_SET_WRITTEN (pfile, old_written);
1384   output_line_command (pfile, file_change);
1385   return 0;
1386
1387  bad_line_directive:
1388   skip_rest_of_line (pfile);
1389   CPP_SET_WRITTEN (pfile, old_written);
1390   return 0;
1391 }
1392
1393 /* Remove the definition of a symbol from the symbol table.
1394    According to the C standard, it is not an error to undef
1395    something that has no definitions. */
1396 static int
1397 do_undef (pfile, keyword)
1398      cpp_reader *pfile;
1399      const struct directive *keyword;
1400 {
1401   int sym_length;
1402   HASHNODE *hp;
1403   U_CHAR *buf, *name, *limit;
1404   int c;
1405   long here = CPP_WRITTEN (pfile);
1406   enum cpp_token token;
1407
1408   cpp_skip_hspace (pfile);
1409   c = GETC();
1410   if (! is_idstart(c))
1411   {
1412       cpp_error (pfile, "token after #undef is not an identifier");
1413       skip_rest_of_line (pfile);
1414       return 1;
1415   }
1416
1417   parse_name (pfile, c);
1418   buf = pfile->token_buffer + here;
1419   limit = CPP_PWRITTEN(pfile);
1420
1421   /* Copy out the token so we can pop the token buffer. */
1422   name = (U_CHAR *) alloca (limit - buf + 1);
1423   bcopy(buf, name, limit - buf);
1424   name[limit - buf] = '\0';
1425
1426   token = get_directive_token (pfile);
1427   if (token != CPP_VSPACE && token != CPP_POP)
1428   {
1429       cpp_pedwarn (pfile, "junk on line after #undef");
1430       skip_rest_of_line (pfile);
1431   }
1432
1433   CPP_SET_WRITTEN (pfile, here);
1434
1435   sym_length = check_macro_name (pfile, buf);
1436
1437   while ((hp = cpp_lookup (pfile, name, sym_length, -1)) != NULL)
1438     {
1439       /* If we are generating additional info for debugging (with -g) we
1440          need to pass through all effective #undef commands.  */
1441       if (CPP_OPTIONS (pfile)->debug_output && keyword)
1442         pass_thru_directive (name, sym_length, pfile, keyword);
1443       if (hp->type == T_POISON)
1444         cpp_error (pfile, "cannot undefine poisoned `%s'", hp->name);
1445       else
1446         {
1447           if (hp->type != T_MACRO)
1448             cpp_warning (pfile, "undefining `%s'", hp->name);
1449           delete_macro (hp);
1450         }
1451     }
1452
1453   return 0;
1454 }
1455
1456 /* Wrap do_undef for -U processing. */
1457 void
1458 cpp_undef (pfile, macro)
1459      cpp_reader *pfile;
1460      U_CHAR *macro;
1461 {
1462   if (cpp_push_buffer (pfile, macro, strlen (macro)))
1463     {
1464       do_undef (pfile, NULL);
1465       cpp_pop_buffer (pfile);
1466     }
1467 }
1468
1469 \f
1470 /*
1471  * Report an error detected by the program we are processing.
1472  * Use the text of the line in the error message.
1473  * (We use error because it prints the filename & line#.)
1474  */
1475
1476 static int
1477 do_error (pfile, keyword)
1478      cpp_reader *pfile;
1479      const struct directive *keyword ATTRIBUTE_UNUSED;
1480 {
1481   long here = CPP_WRITTEN (pfile);
1482   U_CHAR *text;
1483   copy_rest_of_line (pfile);
1484   text = pfile->token_buffer + here;
1485   SKIP_WHITE_SPACE(text);
1486
1487   cpp_error (pfile, "#error %s", text);
1488   CPP_SET_WRITTEN (pfile, here);
1489   return 0;
1490 }
1491
1492 /*
1493  * Report a warning detected by the program we are processing.
1494  * Use the text of the line in the warning message, then continue.
1495  */
1496
1497 static int
1498 do_warning (pfile, keyword)
1499      cpp_reader *pfile;
1500      const struct directive *keyword ATTRIBUTE_UNUSED;
1501 {
1502   U_CHAR *text;
1503   long here = CPP_WRITTEN(pfile);
1504   copy_rest_of_line (pfile);
1505   text = pfile->token_buffer + here;
1506   SKIP_WHITE_SPACE(text);
1507
1508   if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
1509     cpp_pedwarn (pfile, "ANSI C does not allow `#warning'");
1510
1511   /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
1512      if -pedantic-errors is given, #warning should cause an error.  */
1513   cpp_pedwarn (pfile, "#warning %s", text);
1514   CPP_SET_WRITTEN (pfile, here);
1515   return 0;
1516 }
1517
1518 /* Report program identification.
1519    This is not precisely what cccp does with #ident, however I believe
1520    it matches `closely enough' (behavior is identical as long as there
1521    are no macros on the #ident line, which is pathological in my opinion).  */
1522
1523 static int
1524 do_ident (pfile, keyword)
1525      cpp_reader *pfile;
1526      const struct directive *keyword ATTRIBUTE_UNUSED;
1527 {
1528   /* Allow #ident in system headers, since that's not user's fault.  */
1529   if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
1530     cpp_pedwarn (pfile, "ANSI C does not allow `#ident'");
1531
1532   CPP_PUTS (pfile, "#ident ", 7);
1533   cpp_skip_hspace (pfile);
1534   copy_rest_of_line (pfile);
1535
1536   return 0;
1537 }
1538
1539 /* Just check for some recognized pragmas that need validation here,
1540    and leave the text in the token buffer to be output. */
1541
1542 static int
1543 do_pragma (pfile, keyword)
1544      cpp_reader *pfile;
1545      const struct directive *keyword ATTRIBUTE_UNUSED;
1546 {
1547   long here;
1548   U_CHAR *buf;
1549
1550   CPP_PUTS (pfile, "#pragma ", 8);
1551   cpp_skip_hspace (pfile);
1552
1553   here = CPP_WRITTEN (pfile);
1554   copy_rest_of_line (pfile);
1555   buf = pfile->token_buffer + here;
1556
1557   if (!strncmp (buf, "once", 4))
1558     {
1559       cpp_buffer *ip = NULL;
1560
1561       /* Allow #pragma once in system headers, since that's not the user's
1562          fault.  */
1563       if (!CPP_BUFFER (pfile)->system_header_p)
1564         cpp_warning (pfile, "`#pragma once' is obsolete");
1565
1566       for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
1567         {
1568           if (ip == CPP_NULL_BUFFER (pfile))
1569             return 0;
1570           if (ip->fname != NULL)
1571             break;
1572         }
1573
1574       if (CPP_PREV_BUFFER (ip) == CPP_NULL_BUFFER (pfile))
1575         cpp_warning (pfile, "`#pragma once' outside include file");
1576       else
1577         ip->ihash->control_macro = "";  /* never repeat */
1578     }
1579   else if (!strncmp (buf, "implementation", 14))
1580     {
1581       /* Be quiet about `#pragma implementation' for a file only if it hasn't
1582          been included yet.  */
1583       struct include_hash *ptr;
1584       U_CHAR *p = buf + 14, *fname, *fcopy;
1585       SKIP_WHITE_SPACE (p);
1586       if (*p == '\n' || *p != '\"')
1587         return 0;
1588
1589       fname = p + 1;
1590       p = (U_CHAR *) index (fname, '\"');
1591
1592       fcopy = (U_CHAR *) alloca (p - fname + 1);
1593       bcopy (fname, fcopy, p - fname);
1594       fcopy[p-fname] = '\0';
1595
1596       ptr = include_hash (pfile, fcopy, 0);
1597       if (ptr)
1598         cpp_warning (pfile,
1599           "`#pragma implementation' for `%s' appears after file is included",
1600                      fcopy);
1601     }
1602   else if (!strncmp (buf, "poison", 6))
1603     {
1604       /* Poison these symbols so that all subsequent usage produces an
1605          error message.  */
1606       U_CHAR *p = buf + 6;
1607       size_t plen;
1608       U_CHAR *syms;
1609       int writeit;
1610
1611       SKIP_WHITE_SPACE (p);
1612       plen = strlen(p) + 1;
1613
1614       syms = (U_CHAR *) alloca (plen);
1615       memcpy (syms, p, plen);
1616
1617       /* As a rule, don't include #pragma poison commands in output,
1618          unless the user asks for them.  */
1619       writeit = (CPP_OPTIONS (pfile)->debug_output
1620                  || CPP_OPTIONS (pfile)->dump_macros == dump_definitions
1621                  || CPP_OPTIONS (pfile)->dump_macros == dump_names);
1622
1623       if (writeit)
1624         CPP_SET_WRITTEN (pfile, here);
1625       else
1626         CPP_SET_WRITTEN (pfile, here-8);
1627
1628       if (writeit)
1629         {
1630           CPP_RESERVE (pfile, plen + 7);
1631           CPP_PUTS_Q (pfile, "poison", 7);
1632         }
1633
1634       while (*syms != '\0')
1635         {
1636           U_CHAR *end = syms;
1637
1638           while (is_idchar(*end))
1639             end++;
1640
1641           if (!is_hspace(*end) && *end != '\0')
1642             {
1643               cpp_error (pfile, "invalid #pragma poison directive");
1644               return 1;
1645             }
1646
1647           if (cpp_push_buffer (pfile, syms, end - syms) != NULL)
1648             {
1649               do_define (pfile, keyword);
1650               cpp_pop_buffer (pfile);
1651             }
1652           if (writeit)
1653             {
1654               CPP_PUTC_Q (pfile, ' ');
1655               CPP_PUTS_Q (pfile, syms, end - syms);
1656             }
1657           syms = end;
1658           SKIP_WHITE_SPACE (syms);
1659         }
1660     }
1661
1662   return 0;
1663 }
1664
1665 #ifdef SCCS_DIRECTIVE
1666 /* Just ignore #sccs, on systems where we define it at all.  */
1667
1668 static int
1669 do_sccs (pfile, keyword)
1670      cpp_reader *pfile;
1671      const struct directive *keyword ATTRIBUTE_UNUSED;
1672 {
1673   if (CPP_PEDANTIC (pfile))
1674     cpp_pedwarn (pfile, "ANSI C does not allow `#sccs'");
1675   skip_rest_of_line (pfile);
1676   return 0;
1677 }
1678 #endif
1679 \f
1680
1681 /* We've found an `#if' directive.  If the only thing before it in
1682    this file is white space, and if it is of the form
1683    `#if ! defined SYMBOL', then SYMBOL is a possible controlling macro
1684    for inclusion of this file.  (See redundant_include_p in cppfiles.c
1685    for an explanation of controlling macros.)  If so, return a
1686    malloc'd copy of SYMBOL.  Otherwise, return NULL.  */
1687
1688 static U_CHAR *
1689 detect_if_not_defined (pfile)
1690      cpp_reader *pfile;
1691 {
1692   U_CHAR *control_macro = 0;
1693
1694   if (pfile->only_seen_white == 2)
1695     {
1696       char *ident;
1697       enum cpp_token token;
1698       int base_offset;
1699       int token_offset;
1700       int need_rparen = 0;
1701
1702       /* Save state required for restore.  */
1703       pfile->no_macro_expand++;
1704       parse_set_mark (pfile);
1705       base_offset = CPP_WRITTEN (pfile);
1706
1707       /* Look for `!', */
1708       if (get_directive_token (pfile) != CPP_OTHER
1709           || CPP_WRITTEN (pfile) != (size_t) base_offset + 1
1710           || CPP_PWRITTEN (pfile)[-1] != '!')
1711         goto restore;
1712
1713       /* ...then `defined', */
1714       token_offset = CPP_WRITTEN (pfile);
1715       token = get_directive_token (pfile);
1716       if (token != CPP_NAME)
1717         goto restore;
1718       ident = pfile->token_buffer + token_offset;
1719       CPP_NUL_TERMINATE (pfile);
1720       if (strcmp (ident, "defined"))
1721         goto restore;
1722
1723       /* ...then an optional '(' and the name, */
1724       token_offset = CPP_WRITTEN (pfile);
1725       token = get_directive_token (pfile);
1726       if (token == CPP_LPAREN)
1727         {
1728           token_offset = CPP_WRITTEN (pfile);
1729           token = get_directive_token (pfile);
1730           if (token != CPP_NAME)
1731             goto restore;
1732           need_rparen = 1;
1733         }
1734       else if (token != CPP_NAME)
1735         goto restore;
1736
1737       ident = pfile->token_buffer + token_offset;
1738       CPP_NUL_TERMINATE (pfile);
1739
1740       /* ...then the ')', if necessary, */
1741       if ((!need_rparen || get_directive_token (pfile) == CPP_RPAREN)
1742           /* ...and make sure there's nothing else on the line.  */
1743           && get_directive_token (pfile) == CPP_VSPACE)
1744         control_macro = xstrdup (ident);
1745
1746     restore:
1747       CPP_SET_WRITTEN (pfile, base_offset);
1748       pfile->no_macro_expand--;
1749       parse_goto_mark (pfile);
1750     }
1751
1752   return control_macro;
1753 }
1754
1755 /*
1756  * handle #if command by
1757  *   1) inserting special `defined' keyword into the hash table
1758  *      that gets turned into 0 or 1 by special_symbol (thus,
1759  *      if the luser has a symbol called `defined' already, it won't
1760  *      work inside the #if command)
1761  *   2) rescan the input into a temporary output buffer
1762  *   3) pass the output buffer to the yacc parser and collect a value
1763  *   4) clean up the mess left from steps 1 and 2.
1764  *   5) call conditional_skip to skip til the next #endif (etc.),
1765  *      or not, depending on the value from step 3.
1766  */
1767
1768 static int
1769 do_if (pfile, keyword)
1770      cpp_reader *pfile;
1771      const struct directive *keyword ATTRIBUTE_UNUSED;
1772 {
1773   U_CHAR *control_macro = detect_if_not_defined (pfile);
1774   HOST_WIDEST_INT value = eval_if_expression (pfile);
1775   conditional_skip (pfile, value == 0, T_IF, control_macro);
1776   return 0;
1777 }
1778
1779 /*
1780  * handle a #elif directive by not changing  if_stack  either.
1781  * see the comment above do_else.
1782  */
1783
1784 static int
1785 do_elif (pfile, keyword)
1786      cpp_reader *pfile;
1787      const struct directive *keyword ATTRIBUTE_UNUSED;
1788 {
1789   if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
1790     cpp_error (pfile, "`#elif' not within a conditional");
1791     return 0;
1792   } else {
1793     if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
1794       cpp_error (pfile, "`#elif' after `#else'");
1795 #if 0
1796       fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
1797 #endif
1798       if (pfile->if_stack->fname != NULL && CPP_BUFFER (pfile)->fname != NULL
1799           && strcmp (pfile->if_stack->fname,
1800                      CPP_BUFFER (pfile)->nominal_fname) != 0)
1801         fprintf (stderr, ", file %s", pfile->if_stack->fname);
1802       fprintf (stderr, ")\n");
1803     }
1804     pfile->if_stack->type = T_ELIF;
1805   }
1806
1807   if (pfile->if_stack->if_succeeded)
1808     skip_if_group (pfile);
1809   else {
1810     HOST_WIDEST_INT value = eval_if_expression (pfile);
1811     if (value == 0)
1812       skip_if_group (pfile);
1813     else {
1814       ++pfile->if_stack->if_succeeded;  /* continue processing input */
1815       output_line_command (pfile, same_file);
1816     }
1817   }
1818   return 0;
1819 }
1820
1821 /*
1822  * evaluate a #if expression in BUF, of length LENGTH,
1823  * then parse the result as a C expression and return the value as an int.
1824  */
1825
1826 static HOST_WIDEST_INT
1827 eval_if_expression (pfile)
1828      cpp_reader *pfile;
1829 {
1830   HOST_WIDEST_INT value;
1831   long old_written = CPP_WRITTEN (pfile);
1832
1833   pfile->pcp_inside_if = 1;
1834   value = cpp_parse_expr (pfile);
1835   pfile->pcp_inside_if = 0;
1836
1837   CPP_SET_WRITTEN (pfile, old_written); /* Pop */
1838
1839   return value;
1840 }
1841
1842 /*
1843  * routine to handle ifdef/ifndef.  Try to look up the symbol,
1844  * then do or don't skip to the #endif/#else/#elif depending
1845  * on what directive is actually being processed.
1846  */
1847
1848 static int
1849 do_xifdef (pfile, keyword)
1850      cpp_reader *pfile;
1851      const struct directive *keyword;
1852 {
1853   int skip;
1854   cpp_buffer *ip = CPP_BUFFER (pfile);
1855   U_CHAR *ident;
1856   int ident_length;
1857   enum cpp_token token;
1858   int start_of_file = 0;
1859   U_CHAR *control_macro = 0;
1860   int old_written = CPP_WRITTEN (pfile);
1861
1862   /* Detect a #ifndef at start of file (not counting comments).  */
1863   if (ip->fname != 0 && keyword->type == T_IFNDEF)
1864     start_of_file = pfile->only_seen_white == 2;
1865
1866   pfile->no_macro_expand++;
1867   token = get_directive_token (pfile);
1868   pfile->no_macro_expand--;
1869
1870   ident = pfile->token_buffer + old_written;
1871   ident_length = CPP_WRITTEN (pfile) - old_written;
1872   CPP_SET_WRITTEN (pfile, old_written); /* Pop */
1873
1874   if (token == CPP_VSPACE || token == CPP_POP || token == CPP_EOF)
1875     {
1876       skip = (keyword->type == T_IFDEF);
1877       if (! CPP_TRADITIONAL (pfile))
1878         cpp_pedwarn (pfile, "`#%s' with no argument", keyword->name);
1879     }
1880   else if (token == CPP_NAME)
1881     {
1882       HASHNODE *hp = cpp_lookup (pfile, ident, ident_length, -1);
1883       skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
1884       if (start_of_file && !skip)
1885         {
1886           control_macro = (U_CHAR *) xmalloc (ident_length + 1);
1887           bcopy (ident, control_macro, ident_length + 1);
1888         }
1889       if (hp != NULL && hp->type == T_POISON)
1890         {
1891           cpp_error (pfile, "attempt to use poisoned `%s'", hp->name);
1892           skip = !skip;
1893         }
1894     }
1895   else
1896     {
1897       skip = (keyword->type == T_IFDEF);
1898       if (! CPP_TRADITIONAL (pfile))
1899         cpp_error (pfile, "`#%s' with invalid argument", keyword->name);
1900     }
1901
1902   if (!CPP_TRADITIONAL (pfile))
1903     { int c;
1904       cpp_skip_hspace (pfile);
1905       c = PEEKC ();
1906       if (c != EOF && c != '\n')
1907         cpp_pedwarn (pfile, "garbage at end of `#%s' argument", keyword->name);
1908     }
1909   skip_rest_of_line (pfile);
1910
1911 #if 0
1912     if (pcp_outfile) {
1913       /* Output a precondition for this macro.  */
1914       if (hp && hp->value.defn->predefined)
1915         fprintf (pcp_outfile, "#define %s\n", hp->name);
1916       else {
1917         U_CHAR *cp = buf;
1918         fprintf (pcp_outfile, "#undef ");
1919         while (is_idchar(*cp)) /* Ick! */
1920           fputc (*cp++, pcp_outfile);
1921         putc ('\n', pcp_outfile);
1922       }
1923 #endif
1924
1925   conditional_skip (pfile, skip, T_IF, control_macro);
1926   return 0;
1927 }
1928
1929 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
1930    If this is a #ifndef starting at the beginning of a file,
1931    CONTROL_MACRO is the macro name tested by the #ifndef.
1932    Otherwise, CONTROL_MACRO is 0.  */
1933
1934 static void
1935 conditional_skip (pfile, skip, type, control_macro)
1936      cpp_reader *pfile;
1937      int skip;
1938      enum node_type type;
1939      U_CHAR *control_macro;
1940 {
1941   IF_STACK_FRAME *temp;
1942
1943   temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
1944   temp->fname = CPP_BUFFER (pfile)->nominal_fname;
1945   temp->lineno = CPP_BUFFER (pfile)->lineno;
1946   temp->next = pfile->if_stack;
1947   temp->control_macro = control_macro;
1948   pfile->if_stack = temp;
1949
1950   pfile->if_stack->type = type;
1951
1952   if (skip != 0) {
1953     skip_if_group (pfile);
1954     return;
1955   } else {
1956     ++pfile->if_stack->if_succeeded;
1957     output_line_command (pfile, same_file);
1958   }
1959 }
1960
1961 /* Subroutine of skip_if_group.  Examine one preprocessing directive and
1962    return 0 if skipping should continue, 1 if it should halt.  Also
1963    adjusts the if_stack as appropriate.
1964    The `#' has been read, but not the identifier. */
1965
1966 static int
1967 consider_directive_while_skipping (pfile, stack)
1968     cpp_reader *pfile;
1969     IF_STACK_FRAME *stack;
1970 {
1971   long ident_len, ident;
1972   const struct directive *kt;
1973   IF_STACK_FRAME *temp;
1974
1975   cpp_skip_hspace (pfile);
1976
1977   ident = CPP_WRITTEN (pfile);
1978   parse_name (pfile, GETC());
1979   ident_len = CPP_WRITTEN (pfile) - ident;
1980
1981   CPP_SET_WRITTEN (pfile, ident);
1982
1983   for (kt = directive_table; kt->length >= 0; kt++)
1984     if (kt->length == ident_len
1985         && strncmp (pfile->token_buffer + ident, kt->name, kt->length) == 0)
1986       switch (kt->type)
1987         {
1988         case T_IF:
1989         case T_IFDEF:
1990         case T_IFNDEF:
1991             temp = (IF_STACK_FRAME *) xmalloc (sizeof (IF_STACK_FRAME));
1992             temp->next = pfile->if_stack;
1993             pfile->if_stack = temp;
1994             temp->fname = CPP_BUFFER(pfile)->nominal_fname;
1995             temp->type = kt->type;
1996             return 0;
1997
1998         case T_ELSE:
1999             if (CPP_PEDANTIC (pfile) && pfile->if_stack != stack)
2000               validate_else (pfile, "#else");
2001             /* fall through */
2002         case T_ELIF:
2003             if (pfile->if_stack->type == T_ELSE)
2004               cpp_error (pfile, "`%s' after `#else'", kt->name);
2005
2006             if (pfile->if_stack == stack)
2007               return 1;
2008             else
2009               {
2010                 pfile->if_stack->type = kt->type;
2011                 return 0;
2012               }
2013
2014             case T_ENDIF:
2015                 if (CPP_PEDANTIC (pfile) && pfile->if_stack != stack)
2016                   validate_else (pfile, "#endif");
2017
2018                 if (pfile->if_stack == stack)
2019                   return 1;
2020
2021                 temp = pfile->if_stack;
2022                 pfile->if_stack = temp->next;
2023                 free (temp);
2024                 return 0;
2025
2026             default:
2027                 return 0;
2028             }
2029
2030     /* Don't let erroneous code go by.  */
2031     if (!CPP_OPTIONS (pfile)->lang_asm && CPP_PEDANTIC (pfile))
2032         cpp_pedwarn (pfile, "invalid preprocessor directive name");
2033     return 0;
2034 }
2035
2036 /* skip to #endif, #else, or #elif.  adjust line numbers, etc.
2037  * leaves input ptr at the sharp sign found.
2038  */
2039 static void
2040 skip_if_group (pfile)
2041     cpp_reader *pfile;
2042 {
2043   int c;
2044   IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */
2045   U_CHAR *beg_of_line;
2046   long old_written;
2047
2048   if (CPP_OPTIONS (pfile)->output_conditionals)
2049     {
2050       CPP_PUTS (pfile, "#failed\n", 8);
2051       pfile->lineno++;
2052       output_line_command (pfile, same_file);
2053     }
2054
2055   old_written = CPP_WRITTEN (pfile);
2056
2057   for (;;)
2058     {
2059       beg_of_line = CPP_BUFFER (pfile)->cur;
2060
2061       if (! CPP_TRADITIONAL (pfile))
2062         cpp_skip_hspace (pfile);
2063       c = GETC();
2064       if (c == '\n')
2065         {
2066           if (CPP_OPTIONS (pfile)->output_conditionals)
2067             CPP_PUTC (pfile, c);
2068           CPP_BUMP_LINE (pfile);
2069           continue;
2070         }
2071       else if (c == '#')
2072         {
2073           if (consider_directive_while_skipping (pfile, save_if_stack))
2074             break;
2075         }
2076       else if (c == EOF)
2077         return;  /* Caller will issue error. */
2078
2079       FORWARD(-1);
2080       if (CPP_OPTIONS (pfile)->output_conditionals)
2081         {
2082           CPP_PUTS (pfile, beg_of_line, CPP_BUFFER (pfile)->cur - beg_of_line);
2083           copy_rest_of_line (pfile);
2084         }
2085       else
2086         {
2087           copy_rest_of_line (pfile);
2088           CPP_SET_WRITTEN (pfile, old_written);  /* discard it */
2089         }
2090
2091       c = GETC();
2092       if (c == EOF)
2093         return;  /* Caller will issue error. */
2094       else
2095         {
2096           /* \n */
2097           if (CPP_OPTIONS (pfile)->output_conditionals)
2098             {
2099               CPP_PUTC (pfile, c);
2100               pfile->lineno++;
2101             }
2102           CPP_BUMP_LINE (pfile);
2103         }
2104     }
2105
2106   /* Back up to the beginning of this line.  Caller will process the
2107      directive. */
2108   CPP_BUFFER (pfile)->cur = beg_of_line;
2109   pfile->only_seen_white = 1;
2110   if (CPP_OPTIONS (pfile)->output_conditionals)
2111     {
2112       CPP_PUTS (pfile, "#endfailed\n", 11);
2113       pfile->lineno++;
2114     }
2115 }
2116
2117 /*
2118  * handle a #else directive.  Do this by just continuing processing
2119  * without changing  if_stack ;  this is so that the error message
2120  * for missing #endif's etc. will point to the original #if.  It
2121  * is possible that something different would be better.
2122  */
2123
2124 static int
2125 do_else (pfile, keyword)
2126      cpp_reader *pfile;
2127      const struct directive *keyword ATTRIBUTE_UNUSED;
2128 {
2129   cpp_buffer *ip = CPP_BUFFER (pfile);
2130
2131   if (CPP_PEDANTIC (pfile))
2132     validate_else (pfile, "#else");
2133   skip_rest_of_line (pfile);
2134
2135   if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
2136     cpp_error (pfile, "`#else' not within a conditional");
2137     return 0;
2138   } else {
2139     /* #ifndef can't have its special treatment for containing the whole file
2140        if it has a #else clause.  */
2141     pfile->if_stack->control_macro = 0;
2142
2143     if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
2144       cpp_error (pfile, "`#else' after `#else'");
2145       fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
2146       if (strcmp (pfile->if_stack->fname, ip->nominal_fname) != 0)
2147         fprintf (stderr, ", file %s", pfile->if_stack->fname);
2148       fprintf (stderr, ")\n");
2149     }
2150     pfile->if_stack->type = T_ELSE;
2151   }
2152
2153   if (pfile->if_stack->if_succeeded)
2154     skip_if_group (pfile);
2155   else {
2156     ++pfile->if_stack->if_succeeded;    /* continue processing input */
2157     output_line_command (pfile, same_file);
2158   }
2159   return 0;
2160 }
2161
2162 /*
2163  * unstack after #endif command
2164  */
2165
2166 static int
2167 do_endif (pfile, keyword)
2168      cpp_reader *pfile;
2169      const struct directive *keyword ATTRIBUTE_UNUSED;
2170 {
2171   if (CPP_PEDANTIC (pfile))
2172     validate_else (pfile, "#endif");
2173   skip_rest_of_line (pfile);
2174
2175   if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
2176     cpp_error (pfile, "`#endif' not within a conditional");
2177   else
2178     {
2179       IF_STACK_FRAME *temp = pfile->if_stack;
2180       pfile->if_stack = temp->next;
2181       if (temp->control_macro != 0)
2182         {
2183           /* This #endif matched a #ifndef at the start of the file.
2184              See if it is at the end of the file.  */
2185           int c;
2186
2187           parse_set_mark (pfile);
2188
2189           for (;;)
2190             {
2191               cpp_skip_hspace (pfile);
2192               c = GETC ();
2193               if (c != '\n')
2194                 break;
2195             }
2196           parse_goto_mark (pfile);
2197
2198           if (c == EOF)
2199             {
2200               /* This #endif ends a #ifndef
2201                  that contains all of the file (aside from whitespace).
2202                  Arrange not to include the file again
2203                  if the macro that was tested is defined. */
2204               struct cpp_buffer *ip;
2205               for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
2206                 if (ip->fname != NULL)
2207                   break;
2208               ip->ihash->control_macro = (char *) temp->control_macro;
2209             }
2210         }
2211       free (temp);
2212       output_line_command (pfile, same_file);
2213     }
2214   return 0;
2215 }
2216
2217 /* When an #else or #endif is found while skipping failed conditional,
2218    if -pedantic was specified, this is called to warn about text after
2219    the command name.  P points to the first char after the command name.  */
2220
2221 static void
2222 validate_else (pfile, directive)
2223      cpp_reader *pfile;
2224      const char *directive;
2225 {
2226   int c;
2227   cpp_skip_hspace (pfile);
2228   c = PEEKC ();
2229   if (c != EOF && c != '\n')
2230     cpp_pedwarn (pfile,
2231                  "text following `%s' violates ANSI standard", directive);
2232 }
2233
2234 /* Convert T_IF, etc. to a string.   Used in error messages.  */
2235 static const char *
2236 if_directive_name (pfile, ifs)
2237      cpp_reader *pfile;
2238      struct if_stack *ifs;
2239 {
2240   switch (ifs->type)
2241     {
2242     case T_IF:      return "#if";
2243     case T_IFDEF:   return "#ifdef";
2244     case T_IFNDEF:  return "#ifndef";
2245     case T_ELIF:    return "#elif";
2246     case T_ELSE:    return "#else";
2247     default:
2248       cpp_fatal (pfile, "impossible if_stack->type value %d", ifs->type);
2249       return "unknown";
2250     }
2251 }
2252
2253 /* Get the next token, and add it to the text in pfile->token_buffer.
2254    Return the kind of token we got.  */
2255
2256 enum cpp_token
2257 cpp_get_token (pfile)
2258      cpp_reader *pfile;
2259 {
2260   register int c, c2, c3;
2261   enum cpp_token token;
2262   struct cpp_options *opts = CPP_OPTIONS (pfile);
2263
2264  get_next:
2265   c = GETC();
2266   if (c == EOF)
2267     {
2268     handle_eof:
2269       if (CPP_BUFFER (pfile)->manual_pop)
2270         /* If we've been reading from redirected input, the
2271            frontend will pop the buffer.  */
2272         return CPP_EOF;
2273       else if (CPP_BUFFER (pfile)->seen_eof)
2274         {
2275           if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)) == CPP_NULL_BUFFER (pfile))
2276             return CPP_EOF;
2277
2278           cpp_pop_buffer (pfile);
2279           goto get_next;
2280         }
2281       else
2282         {
2283           cpp_buffer *next_buf = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
2284           struct if_stack *ifs, *nifs;
2285
2286           /* Unwind the conditional stack and generate error messages.  */
2287           for (ifs = pfile->if_stack;
2288                ifs != CPP_BUFFER (pfile)->if_stack;
2289                ifs = nifs)
2290             {
2291               cpp_error_with_line (pfile, ifs->lineno, -1,
2292                                    "unterminated `%s' conditional",
2293                                    if_directive_name (pfile, ifs));
2294
2295               nifs = ifs->next;
2296               free (ifs);
2297             }
2298           pfile->if_stack = ifs;
2299
2300           if (CPP_BUFFER (pfile)->nominal_fname
2301               && next_buf != CPP_NULL_BUFFER (pfile))
2302             {
2303               /* We're about to return from an #include file.
2304                  Emit #line information now (as part of the CPP_POP) result.
2305                  But the #line refers to the file we will pop to.  */
2306               cpp_buffer *cur_buffer = CPP_BUFFER (pfile);
2307               CPP_BUFFER (pfile) = next_buf;
2308               pfile->input_stack_listing_current = 0;
2309               output_line_command (pfile, leave_file);
2310               CPP_BUFFER (pfile) = cur_buffer;
2311             }
2312
2313           CPP_BUFFER (pfile)->seen_eof = 1;
2314           return CPP_POP;
2315         }
2316     }
2317   else
2318     {
2319       switch (c)
2320         {
2321         case '/':
2322           if (PEEKC () == '=')
2323             goto op2;
2324
2325         comment:
2326           if (opts->put_out_comments)
2327             c = copy_comment (pfile, c);
2328           else
2329             c = skip_comment (pfile, c);
2330           if (c == EOF)
2331             goto handle_eof;
2332           else if (c != ' ')
2333             goto randomchar;
2334
2335           /* Comments are equivalent to spaces.
2336              For -traditional, a comment is equivalent to nothing.  */
2337           if (opts->traditional || opts->put_out_comments)
2338             return CPP_COMMENT;
2339           else
2340             {
2341               CPP_PUTC (pfile, c);
2342               return CPP_HSPACE;
2343             }
2344 #if 0
2345           if (opts->for_lint) {
2346             U_CHAR *argbp;
2347             int cmdlen, arglen;
2348             char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
2349
2350             if (lintcmd != NULL) {
2351               /* I believe it is always safe to emit this newline: */
2352               obp[-1] = '\n';
2353               bcopy ("#pragma lint ", (char *) obp, 13);
2354               obp += 13;
2355               bcopy (lintcmd, (char *) obp, cmdlen);
2356               obp += cmdlen;
2357
2358               if (arglen != 0) {
2359                 *(obp++) = ' ';
2360                 bcopy (argbp, (char *) obp, arglen);
2361                 obp += arglen;
2362               }
2363
2364               /* OK, now bring us back to the state we were in before we entered
2365                  this branch.  We need #line because the newline for the pragma
2366                  could mess things up.  */
2367               output_line_command (pfile, same_file);
2368               *(obp++) = ' ';   /* just in case, if comments are copied thru */
2369               *(obp++) = '/';
2370             }
2371           }
2372 #endif
2373
2374         case '#':
2375 #if 0
2376           /* If this is expanding a macro definition, don't recognize
2377              preprocessor directives.  */
2378           if (ip->macro != 0)
2379             goto randomchar;
2380           /* If this is expand_into_temp_buffer, recognize them
2381              only after an actual newline at this level,
2382              not at the beginning of the input level.  */
2383           if (ip->fname == 0 && beg_of_line == ip->buf)
2384             goto randomchar;
2385           if (ident_length)
2386             goto specialchar;
2387 #endif
2388
2389           if (!pfile->only_seen_white)
2390             goto randomchar;
2391           if (handle_directive (pfile))
2392             return CPP_DIRECTIVE;
2393           pfile->only_seen_white = 0;
2394           return CPP_OTHER;
2395
2396         case '\"':
2397         case '\'':
2398         string:
2399           parse_string (pfile, c);
2400           pfile->only_seen_white = 0;
2401           return c == '\'' ? CPP_CHAR : CPP_STRING;
2402
2403         case '$':
2404           if (!opts->dollars_in_ident)
2405             goto randomchar;
2406           goto letter;
2407
2408         case ':':
2409           if (opts->cplusplus && PEEKC () == ':')
2410             goto op2;
2411           goto randomchar;
2412
2413         case '&':
2414         case '+':
2415         case '|':
2416           c2 = PEEKC ();
2417           if (c2 == c || c2 == '=')
2418             goto op2;
2419           goto randomchar;
2420
2421         case '*':
2422         case '!':
2423         case '%':
2424         case '=':
2425         case '^':
2426           if (PEEKC () == '=')
2427             goto op2;
2428           goto randomchar;
2429
2430         case '-':
2431           c2 = PEEKC ();
2432           if (c2 == '-' && opts->chill)
2433             goto comment;  /* Chill style comment */
2434           if (c2 == '-' || c2 == '=')
2435             goto op2;
2436           if (c2 == '>')
2437             {
2438               if (opts->cplusplus && PEEKN (1) == '*')
2439                 {
2440                   /* In C++, there's a ->* operator.  */
2441                   token = CPP_OTHER;
2442                   pfile->only_seen_white = 0;
2443                   CPP_RESERVE (pfile, 4);
2444                   CPP_PUTC_Q (pfile, c);
2445                   CPP_PUTC_Q (pfile, GETC ());
2446                   CPP_PUTC_Q (pfile, GETC ());
2447                   CPP_NUL_TERMINATE_Q (pfile);
2448                   return token;
2449                 }
2450               goto op2;
2451             }
2452           goto randomchar;
2453
2454         case '<':
2455           if (pfile->parsing_include_directive)
2456             {
2457               for (;;)
2458                 {
2459                   CPP_PUTC (pfile, c);
2460                   if (c == '>')
2461                     break;
2462                   c = GETC ();
2463                   if (c == '\n' || c == EOF)
2464                     {
2465                       cpp_error (pfile,
2466                                  "missing '>' in `#include <FILENAME>'");
2467                       break;
2468                     }
2469                   else if (c == '\r')
2470                     {
2471                       if (!CPP_BUFFER (pfile)->has_escapes)
2472                         {
2473                           /* Backslash newline is replaced by nothing. */
2474                           CPP_ADJUST_WRITTEN (pfile, -1);
2475                           CPP_BUMP_LINE (pfile);
2476                         }
2477                       else
2478                         {
2479                           /* We might conceivably get \r- or \r<space> in
2480                              here.  Just delete 'em. */
2481                           int d = GETC();
2482                           if (d != '-' && d != ' ')
2483                             cpp_fatal (pfile,
2484                                   "internal error: unrecognized escape \\r%c",
2485                                        d);
2486                           CPP_ADJUST_WRITTEN (pfile, -1);
2487                         }
2488                     }
2489                 }
2490               return CPP_STRING;
2491             }
2492           /* else fall through */
2493         case '>':
2494           c2 = PEEKC ();
2495           if (c2 == '=')
2496             goto op2;
2497           /* GNU C++ supports MIN and MAX operators <? and >?.  */
2498           if (c2 != c && (!opts->cplusplus || c2 != '?'))
2499             goto randomchar;
2500           FORWARD(1);
2501           CPP_RESERVE (pfile, 4);
2502           CPP_PUTC (pfile, c);
2503           CPP_PUTC (pfile, c2);
2504           c3 = PEEKC ();
2505           if (c3 == '=')
2506             CPP_PUTC_Q (pfile, GETC ());
2507           CPP_NUL_TERMINATE_Q (pfile);
2508           pfile->only_seen_white = 0;
2509           return CPP_OTHER;
2510
2511         case '.':
2512           c2 = PEEKC ();
2513           if (ISDIGIT(c2))
2514             {
2515               CPP_RESERVE(pfile, 2);
2516               CPP_PUTC_Q (pfile, '.');
2517               c = GETC ();
2518               goto number;
2519             }
2520
2521           /* In C++ there's a .* operator.  */
2522           if (opts->cplusplus && c2 == '*')
2523             goto op2;
2524
2525           if (c2 == '.' && PEEKN(1) == '.')
2526             {
2527               CPP_RESERVE(pfile, 4);
2528               CPP_PUTC_Q (pfile, '.');
2529               CPP_PUTC_Q (pfile, '.');
2530               CPP_PUTC_Q (pfile, '.');
2531               FORWARD (2);
2532               CPP_NUL_TERMINATE_Q (pfile);
2533               pfile->only_seen_white = 0;
2534               return CPP_3DOTS;
2535             }
2536           goto randomchar;
2537
2538         op2:
2539           token = CPP_OTHER;
2540           pfile->only_seen_white = 0;
2541           CPP_RESERVE(pfile, 3);
2542           CPP_PUTC_Q (pfile, c);
2543           CPP_PUTC_Q (pfile, GETC ());
2544           CPP_NUL_TERMINATE_Q (pfile);
2545           return token;
2546
2547         case 'L':
2548           c2 = PEEKC ();
2549           if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
2550             {
2551               CPP_PUTC (pfile, c);
2552               c = GETC ();
2553               goto string;
2554             }
2555           goto letter;
2556
2557         case '0': case '1': case '2': case '3': case '4':
2558         case '5': case '6': case '7': case '8': case '9':
2559         number:
2560           c2  = '.';
2561           for (;;)
2562             {
2563               CPP_RESERVE (pfile, 2);
2564               CPP_PUTC_Q (pfile, c);
2565               c = PEEKC ();
2566               if (c == EOF)
2567                 break;
2568               if (!is_idchar(c) && c != '.'
2569                   && ((c2 != 'e' && c2 != 'E'
2570                        && ((c2 != 'p' && c2 != 'P') || CPP_C89 (pfile)))
2571                       || (c != '+' && c != '-')))
2572                 break;
2573               FORWARD(1);
2574               c2= c;
2575             }
2576           CPP_NUL_TERMINATE_Q (pfile);
2577           pfile->only_seen_white = 0;
2578           return CPP_NUMBER;
2579         case 'b': case 'c': case 'd': case 'h': case 'o':
2580         case 'B': case 'C': case 'D': case 'H': case 'O':
2581           if (opts->chill && PEEKC () == '\'')
2582             {
2583               pfile->only_seen_white = 0;
2584               CPP_RESERVE (pfile, 2);
2585               CPP_PUTC_Q (pfile, c);
2586               CPP_PUTC_Q (pfile, '\'');
2587               FORWARD(1);
2588               for (;;)
2589                 {
2590                   c = GETC();
2591                   if (c == EOF)
2592                     goto chill_number_eof;
2593                   if (!is_idchar(c))
2594                     break;
2595                   CPP_PUTC (pfile, c);
2596                 }
2597               if (c == '\'')
2598                 {
2599                   CPP_RESERVE (pfile, 2);
2600                   CPP_PUTC_Q (pfile, c);
2601                   CPP_NUL_TERMINATE_Q (pfile);
2602                   return CPP_STRING;
2603                 }
2604               else
2605                 {
2606                   FORWARD(-1);
2607                 chill_number_eof:
2608                   CPP_NUL_TERMINATE (pfile);
2609                   return CPP_NUMBER;
2610                 }
2611             }
2612           else
2613             goto letter;
2614         case '_':
2615         case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
2616         case 'k': case 'l': case 'm': case 'n': case 'p': case 'q':
2617         case 'r': case 's': case 't': case 'u': case 'v': case 'w':
2618         case 'x': case 'y': case 'z':
2619         case 'A': case 'E': case 'F': case 'G': case 'I': case 'J':
2620         case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
2621         case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
2622         case 'Y': case 'Z':
2623         letter:
2624           {
2625             HASHNODE *hp;
2626             unsigned char *ident;
2627             int before_name_written = CPP_WRITTEN (pfile);
2628             int ident_len;
2629             parse_name (pfile, c);
2630             pfile->only_seen_white = 0;
2631             if (pfile->no_macro_expand)
2632               return CPP_NAME;
2633             ident = pfile->token_buffer + before_name_written;
2634             ident_len = CPP_PWRITTEN (pfile) - ident;
2635             hp = cpp_lookup (pfile, ident, ident_len, -1);
2636             if (!hp)
2637               return CPP_NAME;
2638             if (hp->type == T_DISABLED)
2639               {
2640                 if (pfile->output_escapes)
2641                   { /* Return "\r-IDENT", followed by '\0'.  */
2642                     int i;
2643                     CPP_RESERVE (pfile, 3);
2644                     ident = pfile->token_buffer + before_name_written;
2645                     CPP_ADJUST_WRITTEN (pfile, 2);
2646                     for (i = ident_len; i >= 0; i--) ident[i+2] = ident[i];
2647                     ident[0] = '\r';
2648                     ident[1] = '-';
2649                   }
2650                 return CPP_NAME;
2651               }
2652
2653             /* If macro wants an arglist, verify that a '(' follows.
2654                first skip all whitespace, copying it to the output
2655                after the macro name.  Then, if there is no '(',
2656                decide this is not a macro call and leave things that way.  */
2657             if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
2658             {
2659               int is_macro_call, macbuf_whitespace = 0;
2660
2661               parse_set_mark (pfile);
2662               for (;;)
2663                 {
2664                   cpp_skip_hspace (pfile);
2665                   c = PEEKC ();
2666                   is_macro_call = c == '(';
2667                   if (c != EOF)
2668                     {
2669                       if (c != '\n')
2670                         break;
2671                       FORWARD (1);
2672                     }
2673                   else
2674                     {
2675                       if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
2676                         {
2677                           if (CPP_BUFFER (pfile)->mark !=
2678                               (CPP_BUFFER (pfile)->cur
2679                                - CPP_BUFFER (pfile)->buf))
2680                              macbuf_whitespace = 1;
2681
2682                           /* The mark goes away automatically when
2683                              the buffer is popped. */
2684                           cpp_pop_buffer (pfile);
2685                           parse_set_mark (pfile);
2686                         }
2687                       else
2688                         break;
2689                     }
2690                 }
2691               if (!is_macro_call)
2692                 {
2693                   parse_goto_mark (pfile);
2694                   if (macbuf_whitespace)
2695                     CPP_PUTC (pfile, ' ');
2696                 }
2697               else
2698                 parse_clear_mark (pfile);
2699               if (!is_macro_call)
2700                 return CPP_NAME;
2701             }
2702             /* This is now known to be a macro call.
2703                Expand the macro, reading arguments as needed,
2704                and push the expansion on the input stack.  */
2705             macroexpand (pfile, hp);
2706             CPP_SET_WRITTEN (pfile, before_name_written);
2707           }
2708           goto get_next;
2709
2710         case ' ':  case '\t':  case '\v':
2711           for (;;)
2712             {
2713               CPP_PUTC (pfile, c);
2714               c = PEEKC ();
2715               if (c == EOF || !is_hspace(c))
2716                 break;
2717               FORWARD(1);
2718             }
2719           return CPP_HSPACE;
2720
2721         case '\r':
2722           if (CPP_BUFFER (pfile)->has_escapes)
2723             {
2724               c = GETC ();
2725               if (c == '-')
2726                 {
2727                   if (pfile->output_escapes)
2728                     CPP_PUTS (pfile, "\r-", 2);
2729                   parse_name (pfile, GETC ());
2730                   return CPP_NAME;
2731                 }
2732               else if (c == ' ')
2733                 {
2734                   CPP_RESERVE (pfile, 2);
2735                   if (pfile->output_escapes)
2736                     CPP_PUTC_Q (pfile, '\r');
2737                   CPP_PUTC_Q (pfile, c);
2738                   return CPP_HSPACE;
2739                 }
2740               else
2741                 {
2742                   cpp_fatal (pfile,
2743                              "internal error: unrecognized escape \\r%c", c);
2744                   goto get_next;
2745                 }
2746             }
2747           else
2748             {
2749               /* Backslash newline is ignored. */
2750               CPP_BUMP_LINE (pfile);
2751               goto get_next;
2752             }
2753
2754         case '\n':
2755           CPP_PUTC (pfile, c);
2756           if (pfile->only_seen_white == 0)
2757             pfile->only_seen_white = 1;
2758           CPP_BUMP_LINE (pfile);
2759           if (! CPP_OPTIONS (pfile)->no_line_commands)
2760             {
2761               pfile->lineno++;
2762               if (CPP_BUFFER (pfile)->lineno != pfile->lineno)
2763                 output_line_command (pfile, same_file);
2764             }
2765           return CPP_VSPACE;
2766
2767         case '(': token = CPP_LPAREN;    goto char1;
2768         case ')': token = CPP_RPAREN;    goto char1;
2769         case '{': token = CPP_LBRACE;    goto char1;
2770         case '}': token = CPP_RBRACE;    goto char1;
2771         case ',': token = CPP_COMMA;     goto char1;
2772         case ';': token = CPP_SEMICOLON; goto char1;
2773
2774         randomchar:
2775         default:
2776           token = CPP_OTHER;
2777         char1:
2778           pfile->only_seen_white = 0;
2779           CPP_PUTC (pfile, c);
2780           return token;
2781         }
2782     }
2783 }
2784
2785 /* Like cpp_get_token, but skip spaces and comments.  */
2786
2787 enum cpp_token
2788 cpp_get_non_space_token (pfile)
2789      cpp_reader *pfile;
2790 {
2791   int old_written = CPP_WRITTEN (pfile);
2792   for (;;)
2793     {
2794       enum cpp_token token = cpp_get_token (pfile);
2795       if (token != CPP_COMMENT && token != CPP_POP
2796           && token != CPP_HSPACE && token != CPP_VSPACE)
2797         return token;
2798       CPP_SET_WRITTEN (pfile, old_written);
2799     }
2800 }
2801
2802 /* Parse an identifier starting with C.  */
2803
2804 static void
2805 parse_name (pfile, c)
2806      cpp_reader *pfile;
2807      int c;
2808 {
2809   for (;;)
2810   {
2811       if (! is_idchar(c))
2812       {
2813           FORWARD (-1);
2814           break;
2815       }
2816
2817       if (c == '$' && CPP_PEDANTIC (pfile))
2818         cpp_pedwarn (pfile, "`$' in identifier");
2819
2820       CPP_RESERVE(pfile, 2); /* One more for final NUL.  */
2821       CPP_PUTC_Q (pfile, c);
2822       c = GETC();
2823       if (c == EOF)
2824         break;
2825   }
2826   CPP_NUL_TERMINATE_Q (pfile);
2827   return;
2828 }
2829
2830 /* Parse a string starting with C.  A single quoted string is treated
2831    like a double -- some programs (e.g., troff) are perverse this way.
2832    (However, a single quoted string is not allowed to extend over
2833    multiple lines.)  */
2834 static void
2835 parse_string (pfile, c)
2836      cpp_reader *pfile;
2837      int c;
2838 {
2839   long start_line, start_column;
2840
2841   cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
2842
2843   CPP_PUTC (pfile, c);
2844   while (1)
2845     {
2846       int cc = GETC();
2847       if (cc == EOF)
2848         {
2849           if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
2850             {
2851               /* try harder: this string crosses a macro expansion
2852                  boundary.  This can happen naturally if -traditional.
2853                  Otherwise, only -D can make a macro with an unmatched
2854                  quote.  */
2855               cpp_pop_buffer (pfile);
2856               continue;
2857             }
2858
2859           cpp_error_with_line (pfile, start_line, start_column,
2860                                "unterminated string or character constant");
2861           if (pfile->multiline_string_line != start_line
2862               && pfile->multiline_string_line != 0)
2863             cpp_error_with_line (pfile,
2864                                  pfile->multiline_string_line, -1,
2865                          "possible real start of unterminated constant");
2866           pfile->multiline_string_line = 0;
2867           break;
2868         }
2869       CPP_PUTC (pfile, cc);
2870       switch (cc)
2871         {
2872         case '\n':
2873           CPP_BUMP_LINE (pfile);
2874           pfile->lineno++;
2875           /* Character constants may not extend over multiple lines.
2876              In ANSI, neither may strings.  We accept multiline strings
2877              as an extension.  */
2878           if (c == '\'')
2879             {
2880               cpp_error_with_line (pfile, start_line, start_column,
2881                                    "unterminated character constant");
2882               return;
2883             }
2884           if (CPP_PEDANTIC (pfile) && pfile->multiline_string_line == 0)
2885             {
2886               cpp_pedwarn_with_line (pfile, start_line, start_column,
2887                                      "string constant runs past end of line");
2888             }
2889           if (pfile->multiline_string_line == 0)
2890             pfile->multiline_string_line = start_line;
2891           break;
2892
2893         case '\r':
2894           CPP_ADJUST_WRITTEN (pfile, -1);
2895           if (CPP_BUFFER (pfile)->has_escapes)
2896             {
2897               cpp_fatal (pfile,
2898                          "internal error: \\r escape inside string constant");
2899               FORWARD(1);
2900             }
2901           else
2902             /* Backslash newline is replaced by nothing at all.  */
2903             CPP_BUMP_LINE (pfile);
2904           break;
2905
2906         case '\\':
2907           cc = GETC();
2908           if (cc != EOF)
2909             CPP_PUTC (pfile, cc);
2910           break;
2911
2912         case '\"':
2913         case '\'':
2914           if (cc == c)
2915             return;
2916           break;
2917         }
2918     }
2919 }
2920
2921 /* Read an assertion into the token buffer, converting to
2922    canonical form: `#predicate(a n swe r)'  The next non-whitespace
2923    character to read should be the first letter of the predicate.
2924    Returns 0 for syntax error, 1 for bare predicate, 2 for predicate
2925    with answer (see callers for why). In case of 0, an error has been
2926    printed. */
2927 static int
2928 parse_assertion (pfile)
2929      cpp_reader *pfile;
2930 {
2931   int c, dropwhite;
2932   cpp_skip_hspace (pfile);
2933   c = PEEKC();
2934   if (! is_idstart(c))
2935     {
2936       cpp_error (pfile, "assertion predicate is not an identifier");
2937       return 0;
2938     }
2939   CPP_PUTC(pfile, '#');
2940   FORWARD(1);
2941   parse_name(pfile, c);
2942
2943   c = PEEKC();
2944   if (c != '(')
2945     {
2946       if (is_hspace(c) || c == '\r')
2947         cpp_skip_hspace (pfile);
2948       c = PEEKC();
2949     }
2950   if (c != '(')
2951     return 1;
2952
2953   CPP_PUTC(pfile, '(');
2954   FORWARD(1);
2955   dropwhite = 1;
2956   while ((c = GETC()) != ')')
2957     {
2958       if (is_space(c))
2959         {
2960           if (! dropwhite)
2961             {
2962               CPP_PUTC(pfile, ' ');
2963               dropwhite = 1;
2964             }
2965         }
2966       else if (c == '\n' || c == EOF)
2967         {
2968           if (c == '\n') FORWARD(-1);
2969           cpp_error (pfile, "un-terminated assertion answer");
2970           return 0;
2971         }
2972       else if (c == '\r')
2973         /* \r cannot be a macro escape here. */
2974         CPP_BUMP_LINE (pfile);
2975       else
2976         {
2977           CPP_PUTC (pfile, c);
2978           dropwhite = 0;
2979         }
2980     }
2981
2982   if (pfile->limit[-1] == ' ')
2983     pfile->limit[-1] = ')';
2984   else if (pfile->limit[-1] == '(')
2985     {
2986       cpp_error (pfile, "empty token sequence in assertion");
2987       return 0;
2988     }
2989   else
2990     CPP_PUTC (pfile, ')');
2991
2992   CPP_NUL_TERMINATE (pfile);
2993   return 2;
2994 }
2995
2996 static int
2997 do_assert (pfile, keyword)
2998      cpp_reader *pfile;
2999      const struct directive *keyword ATTRIBUTE_UNUSED;
3000 {
3001   char *sym;
3002   int ret, c;
3003   HASHNODE *base, *this;
3004   int baselen, thislen;
3005
3006   if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
3007       && !CPP_BUFFER (pfile)->system_header_p)
3008     cpp_pedwarn (pfile, "ANSI C does not allow `#assert'");
3009
3010   cpp_skip_hspace (pfile);
3011   sym = (char *) CPP_PWRITTEN (pfile);  /* remember where it starts */
3012   ret = parse_assertion (pfile);
3013   if (ret == 0)
3014     goto error;
3015   else if (ret == 1)
3016     {
3017       cpp_error (pfile, "missing token-sequence in `#assert'");
3018       goto error;
3019     }
3020
3021   cpp_skip_hspace (pfile);
3022   c = PEEKC();
3023   if (c != EOF && c != '\n')
3024     {
3025       cpp_error (pfile, "junk at end of `#assert'");
3026       goto error;
3027     }
3028
3029   thislen = strlen (sym);
3030   baselen = index (sym, '(') - sym;
3031   this = cpp_lookup (pfile, sym, thislen, -1);
3032   if (this)
3033     {
3034       cpp_warning (pfile, "`%s' re-asserted", sym);
3035       goto error;
3036     }
3037
3038   base = cpp_lookup (pfile, sym, baselen, -1);
3039   if (! base)
3040     base = cpp_install (pfile, sym, baselen, T_ASSERT, 0, -1);
3041   else if (base->type != T_ASSERT)
3042   {
3043     /* Token clash - but with what?! */
3044     cpp_fatal (pfile,
3045                "cpp internal error: base->type != T_ASSERT in do_assert");
3046     goto error;
3047   }
3048
3049   this = cpp_install (pfile, sym, thislen, T_ASSERT,
3050                       (char *)base->value.aschain, -1);
3051   base->value.aschain = this;
3052
3053   pfile->limit = (unsigned char *) sym; /* Pop */
3054   return 0;
3055
3056  error:
3057   skip_rest_of_line (pfile);
3058   pfile->limit = (unsigned char *) sym; /* Pop */
3059   return 0;
3060 }
3061
3062 static int
3063 do_unassert (pfile, keyword)
3064      cpp_reader *pfile;
3065      const struct directive *keyword ATTRIBUTE_UNUSED;
3066 {
3067   int c, ret;
3068   char *sym;
3069   long baselen, thislen;
3070   HASHNODE *base, *this, *next;
3071
3072   if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
3073       && !CPP_BUFFER (pfile)->system_header_p)
3074     cpp_pedwarn (pfile, "ANSI C does not allow `#unassert'");
3075
3076   cpp_skip_hspace (pfile);
3077
3078   sym = (char *) CPP_PWRITTEN (pfile);  /* remember where it starts */
3079   ret = parse_assertion (pfile);
3080   if (ret == 0)
3081     goto error;
3082
3083   cpp_skip_hspace (pfile);
3084   c = PEEKC ();
3085   if (c != EOF && c != '\n')
3086       cpp_error (pfile, "junk at end of `#unassert'");
3087
3088   thislen = strlen (sym);
3089   if (ret == 1)
3090     {
3091       base = cpp_lookup (pfile, sym, thislen, -1);
3092       if (! base)
3093         goto error;  /* It isn't an error to #undef what isn't #defined,
3094                         so it isn't an error to #unassert what isn't
3095                         #asserted either. */
3096
3097       for (this = base->value.aschain; this; this = next)
3098         {
3099           next = this->value.aschain;
3100           delete_macro (this);
3101         }
3102       delete_macro (base);
3103     }
3104   else
3105     {
3106       baselen = index (sym, '(') - sym;
3107       base = cpp_lookup (pfile, sym, baselen, -1);
3108       if (! base) goto error;
3109       this = cpp_lookup (pfile, sym, thislen, -1);
3110       if (! this) goto error;
3111
3112       next = base;
3113       while (next->value.aschain != this)
3114         next = next->value.aschain;
3115
3116       next->value.aschain = this->value.aschain;
3117       delete_macro (this);
3118
3119       if (base->value.aschain == NULL)
3120         delete_macro (base);  /* Last answer for this predicate deleted. */
3121     }
3122
3123   pfile->limit = (unsigned char *) sym; /* Pop */
3124   return 0;
3125  error:
3126   skip_rest_of_line (pfile);
3127   pfile->limit = (unsigned char *) sym; /* Pop */
3128   return 0;
3129 }
3130
3131 /* Process STR as if it appeared as the body of an #unassert. */
3132 void
3133 cpp_unassert (pfile, str)
3134      cpp_reader *pfile;
3135      unsigned char *str;
3136 {
3137   if (cpp_push_buffer (pfile, str, strlen (str)) != NULL)
3138     {
3139       do_assert (pfile, NULL);
3140       cpp_pop_buffer (pfile);
3141     }
3142 }
3143
3144 int
3145 cpp_read_check_assertion (pfile)
3146      cpp_reader *pfile;
3147 {
3148   U_CHAR *name = CPP_PWRITTEN (pfile);
3149   int result;
3150   HASHNODE *hp;
3151
3152   FORWARD (1);  /* Skip '#' */
3153   cpp_skip_hspace (pfile);
3154   if (! parse_assertion (pfile))
3155     result = 0;
3156   else
3157     {
3158       hp = cpp_lookup (pfile, name, CPP_PWRITTEN (pfile) - name, -1);
3159       result = (hp != 0);
3160     }
3161
3162   pfile->limit = name;
3163   return result;
3164 }
3165
3166 /* Remember the current position of PFILE.  */
3167
3168 void
3169 parse_set_mark (pfile)
3170      cpp_reader *pfile;
3171 {
3172   cpp_buffer *ip = CPP_BUFFER (pfile);
3173   if (ip->mark != -1)
3174       cpp_fatal (pfile,
3175                  "cpp internal error: ip->mark != -1 in parse_set_mark");
3176
3177   ip->mark = ip->cur - ip->buf;
3178 }
3179
3180 /* Clear the current mark - we no longer need it.  */
3181
3182 void
3183 parse_clear_mark (pfile)
3184      cpp_reader *pfile;
3185 {
3186   cpp_buffer *ip = CPP_BUFFER (pfile);
3187   if (ip->mark == -1)
3188       cpp_fatal (pfile,
3189                  "cpp internal error: ip->mark == -1 in parse_clear_mark");
3190
3191   ip->mark = -1;
3192 }
3193
3194 /* Backup the current position of PFILE to that saved in its mark,
3195    and clear the mark.  */
3196
3197 void
3198 parse_goto_mark (pfile)
3199      cpp_reader *pfile;
3200 {
3201   cpp_buffer *ip = CPP_BUFFER (pfile);
3202   if (ip->mark == -1)
3203       cpp_fatal (pfile,
3204                  "cpp internal error: ip->mark == -1 in parse_goto_mark");
3205
3206   ip->cur = ip->buf + ip->mark;
3207   ip->mark = -1;
3208 }
3209
3210 static void
3211 cpp_print_file_and_line (pfile)
3212      cpp_reader *pfile;
3213 {
3214   cpp_buffer *ip = cpp_file_buffer (pfile);
3215
3216   if (ip != NULL)
3217     {
3218       long line, col;
3219       cpp_buf_line_and_col (ip, &line, &col);
3220       cpp_file_line_for_message (pfile, ip->nominal_fname,
3221                                  line, pfile->show_column ? col : -1);
3222     }
3223 }
3224
3225 static void
3226 v_cpp_error (pfile, msgid, ap)
3227   cpp_reader *pfile;
3228   const char *msgid;
3229   va_list ap;
3230 {
3231   cpp_print_containing_files (pfile);
3232   cpp_print_file_and_line (pfile);
3233   v_cpp_message (pfile, 1, msgid, ap);
3234 }
3235
3236 void
3237 cpp_error VPROTO ((cpp_reader * pfile, const char *msgid, ...))
3238 {
3239 #ifndef ANSI_PROTOTYPES
3240   cpp_reader *pfile;
3241   const char *msgid;
3242 #endif
3243   va_list ap;
3244
3245   VA_START(ap, msgid);
3246
3247 #ifndef ANSI_PROTOTYPES
3248   pfile = va_arg (ap, cpp_reader *);
3249   msgid = va_arg (ap, const char *);
3250 #endif
3251
3252   v_cpp_error (pfile, msgid, ap);
3253   va_end(ap);
3254 }
3255
3256 /* Print error message but don't count it.  */
3257
3258 static void
3259 v_cpp_warning (pfile, msgid, ap)
3260   cpp_reader *pfile;
3261   const char *msgid;
3262   va_list ap;
3263 {
3264   if (CPP_OPTIONS (pfile)->inhibit_warnings)
3265     return;
3266
3267   if (CPP_OPTIONS (pfile)->warnings_are_errors)
3268     pfile->errors++;
3269
3270   cpp_print_containing_files (pfile);
3271   cpp_print_file_and_line (pfile);
3272   v_cpp_message (pfile, 0, msgid, ap);
3273 }
3274
3275 void
3276 cpp_warning VPROTO ((cpp_reader * pfile, const char *msgid, ...))
3277 {
3278 #ifndef ANSI_PROTOTYPES
3279   cpp_reader *pfile;
3280   const char *msgid;
3281 #endif
3282   va_list ap;
3283
3284   VA_START (ap, msgid);
3285
3286 #ifndef ANSI_PROTOTYPES
3287   pfile = va_arg (ap, cpp_reader *);
3288   msgid = va_arg (ap, const char *);
3289 #endif
3290
3291   v_cpp_warning (pfile, msgid, ap);
3292   va_end(ap);
3293 }
3294
3295 /* Print an error message and maybe count it.  */
3296
3297 void
3298 cpp_pedwarn VPROTO ((cpp_reader * pfile, const char *msgid, ...))
3299 {
3300 #ifndef ANSI_PROTOTYPES
3301   cpp_reader *pfile;
3302   const char *msgid;
3303 #endif
3304   va_list ap;
3305
3306   VA_START (ap, msgid);
3307
3308 #ifndef ANSI_PROTOTYPES
3309   pfile = va_arg (ap, cpp_reader *);
3310   msgid = va_arg (ap, const char *);
3311 #endif
3312
3313   if (CPP_OPTIONS (pfile)->pedantic_errors)
3314     v_cpp_error (pfile, msgid, ap);
3315   else
3316     v_cpp_warning (pfile, msgid, ap);
3317   va_end(ap);
3318 }
3319
3320 static void
3321 v_cpp_error_with_line (pfile, line, column, msgid, ap)
3322   cpp_reader * pfile;
3323   int line;
3324   int column;
3325   const char * msgid;
3326   va_list ap;
3327 {
3328   cpp_buffer *ip = cpp_file_buffer (pfile);
3329
3330   cpp_print_containing_files (pfile);
3331
3332   if (ip != NULL)
3333     cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
3334
3335   v_cpp_message (pfile, 1, msgid, ap);
3336 }
3337
3338 void
3339 cpp_error_with_line VPROTO ((cpp_reader * pfile, int line, int column,
3340                              const char *msgid, ...))
3341 {
3342 #ifndef ANSI_PROTOTYPES
3343   cpp_reader *pfile;
3344   int line;
3345   int column;
3346   const char *msgid;
3347 #endif
3348   va_list ap;
3349
3350   VA_START (ap, msgid);
3351
3352 #ifndef ANSI_PROTOTYPES
3353   pfile = va_arg (ap, cpp_reader *);
3354   line = va_arg (ap, int);
3355   column = va_arg (ap, int);
3356   msgid = va_arg (ap, const char *);
3357 #endif
3358
3359   v_cpp_error_with_line(pfile, line, column, msgid, ap);
3360   va_end(ap);
3361 }
3362
3363 static void
3364 v_cpp_warning_with_line (pfile, line, column, msgid, ap)
3365   cpp_reader * pfile;
3366   int line;
3367   int column;
3368   const char *msgid;
3369   va_list ap;
3370 {
3371   cpp_buffer *ip;
3372
3373   if (CPP_OPTIONS (pfile)->inhibit_warnings)
3374     return;
3375
3376   if (CPP_OPTIONS (pfile)->warnings_are_errors)
3377     pfile->errors++;
3378
3379   cpp_print_containing_files (pfile);
3380
3381   ip = cpp_file_buffer (pfile);
3382
3383   if (ip != NULL)
3384     cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
3385
3386   v_cpp_message (pfile, 0, msgid, ap);
3387 }
3388
3389 void
3390 cpp_warning_with_line VPROTO ((cpp_reader * pfile, int line, int column,
3391                                const char *msgid, ...))
3392 {
3393 #ifndef ANSI_PROTOTYPES
3394   cpp_reader *pfile;
3395   int line;
3396   int column;
3397   const char *msgid;
3398 #endif
3399   va_list ap;
3400
3401   VA_START (ap, msgid);
3402
3403 #ifndef ANSI_PROTOTYPES
3404   pfile = va_arg (ap, cpp_reader *);
3405   line = va_arg (ap, int);
3406   column = va_arg (ap, int);
3407   msgid = va_arg (ap, const char *);
3408 #endif
3409
3410   v_cpp_warning_with_line (pfile, line, column, msgid, ap);
3411   va_end(ap);
3412 }
3413
3414 void
3415 cpp_pedwarn_with_line VPROTO ((cpp_reader * pfile, int line, int column,
3416                                const char *msgid, ...))
3417 {
3418 #ifndef ANSI_PROTOTYPES
3419   cpp_reader *pfile;
3420   int line;
3421   int column;
3422   const char *msgid;
3423 #endif
3424   va_list ap;
3425
3426   VA_START (ap, msgid);
3427
3428 #ifndef ANSI_PROTOTYPES
3429   pfile = va_arg (ap, cpp_reader *);
3430   line = va_arg (ap, int);
3431   column = va_arg (ap, int);
3432   msgid = va_arg (ap, const char *);
3433 #endif
3434
3435   if (CPP_OPTIONS (pfile)->pedantic_errors)
3436     v_cpp_error_with_line (pfile, column, line, msgid, ap);
3437   else
3438     v_cpp_warning_with_line (pfile, line, column, msgid, ap);
3439   va_end(ap);
3440 }
3441
3442 /* Report a warning (or an error if pedantic_errors)
3443    giving specified file name and line number, not current.  */
3444
3445 void
3446 cpp_pedwarn_with_file_and_line VPROTO ((cpp_reader *pfile, const char *file,
3447                                         int line, const char *msgid, ...))
3448 {
3449 #ifndef ANSI_PROTOTYPES
3450   cpp_reader *pfile;
3451   const char *file;
3452   int line;
3453   const char *msgid;
3454 #endif
3455   va_list ap;
3456
3457   VA_START (ap, msgid);
3458
3459 #ifndef ANSI_PROTOTYPES
3460   pfile = va_arg (ap, cpp_reader *);
3461   file = va_arg (ap, const char *);
3462   line = va_arg (ap, int);
3463   msgid = va_arg (ap, const char *);
3464 #endif
3465
3466   if (!CPP_OPTIONS (pfile)->pedantic_errors
3467       && CPP_OPTIONS (pfile)->inhibit_warnings)
3468     return;
3469   if (file != NULL)
3470     cpp_file_line_for_message (pfile, file, line, -1);
3471   v_cpp_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors, msgid, ap);
3472   va_end(ap);
3473 }
3474
3475 /* my_strerror - return the descriptive text associated with an
3476    `errno' code.  */
3477
3478 static const char *
3479 my_strerror (errnum)
3480      int errnum;
3481 {
3482   const char *result;
3483
3484 #ifndef VMS
3485 #ifndef HAVE_STRERROR
3486   result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
3487 #else
3488   result = strerror (errnum);
3489 #endif
3490 #else   /* VMS */
3491   /* VAXCRTL's strerror() takes an optional second argument, which only
3492      matters when the first argument is EVMSERR.  However, it's simplest
3493      just to pass it unconditionally.  `vaxc$errno' is declared in
3494      <errno.h>, and maintained by the library in parallel with `errno'.
3495      We assume that caller's `errnum' either matches the last setting of
3496      `errno' by the library or else does not have the value `EVMSERR'.  */
3497
3498   result = strerror (errnum, vaxc$errno);
3499 #endif
3500
3501   if (!result)
3502     result = "errno = ?";
3503
3504   return result;
3505 }
3506
3507 /* Error including a message from `errno'.  */
3508
3509 void
3510 cpp_error_from_errno (pfile, name)
3511      cpp_reader *pfile;
3512      const char *name;
3513 {
3514   cpp_message_from_errno (pfile, 1, name);
3515 }
3516
3517 void
3518 cpp_message_from_errno (pfile, is_error, name)
3519      cpp_reader *pfile;
3520      int is_error;
3521      const char *name;
3522 {
3523   int e = errno;
3524   cpp_buffer *ip = cpp_file_buffer (pfile);
3525
3526   cpp_print_containing_files (pfile);
3527
3528   if (ip != NULL)
3529     cpp_file_line_for_message (pfile, ip->nominal_fname, ip->lineno, -1);
3530
3531   cpp_message (pfile, is_error, "%s: %s", name, my_strerror (e));
3532 }
3533
3534 void
3535 cpp_perror_with_name (pfile, name)
3536      cpp_reader *pfile;
3537      const char *name;
3538 {
3539   cpp_message (pfile, 1, "%s: %s: %s", progname, name, my_strerror (errno));
3540 }
3541
3542 /* TODO:
3543  * No pre-compiled header file support.
3544  *
3545  * Possibly different enum token codes for each C/C++ token.
3546  *
3547  * Find and cleanup remaining uses of static variables,
3548  *
3549  * Support -dM flag (dump_all_macros).
3550  *
3551  * Support for_lint flag.
3552  */