libcpp/internal.h

   1 /* Part of CPP library.
   2    Copyright (C) 1997-2020 Free Software Foundation, Inc.
   3
   4 This program is free software; you can redistribute it and/or modify it
   5 under the terms of the GNU General Public License as published by the
   6 Free Software Foundation; either version 3, or (at your option) any
   7 later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; see the file COPYING3.  If not see
  16 <http://www.gnu.org/licenses/>.  */
  17
  18 /* This header defines all the internal data structures and functions
  19    that need to be visible across files.  It should not be used outside
  20    cpplib.  */
  21
  22 #ifndef LIBCPP_INTERNAL_H
  23 #define LIBCPP_INTERNAL_H
  24
  25 #include "symtab.h"
  26 #include "cpplib.h"
  27
  28 #if HAVE_ICONV
  29 #include <iconv.h>
  30 #else
  31 #define HAVE_ICONV 0
  32 typedef int iconv_t;  /* dummy */
  33 #endif
  34
  35 #ifdef __cplusplus
  36 extern "C" {
  37 #endif
  38
  39 struct directive;               /* Deliberately incomplete.  */
  40 struct pending_option;
  41 struct op;
  42 struct _cpp_strbuf;
  43
  44 typedef bool (*convert_f) (iconv_t, const unsigned char *, size_t,
  45                            struct _cpp_strbuf *);
  46 struct cset_converter
  47 {
  48   convert_f func;
  49   iconv_t cd;
  50   int width;
  51 };
  52
  53 #define BITS_PER_CPPCHAR_T (CHAR_BIT * sizeof (cppchar_t))
  54
  55 /* Test if a sign is valid within a preprocessing number.  */
  56 #define VALID_SIGN(c, prevc) \
  57   (((c) == '+' || (c) == '-') && \
  58    ((prevc) == 'e' || (prevc) == 'E' \
  59     || (((prevc) == 'p' || (prevc) == 'P') \
  60         && CPP_OPTION (pfile, extended_numbers))))
  61
  62 #define DIGIT_SEP(c) ((c) == '\'' && CPP_OPTION (pfile, digit_separators))
  63
  64 #define CPP_OPTION(PFILE, OPTION) ((PFILE)->opts.OPTION)
  65 #define CPP_BUFFER(PFILE) ((PFILE)->buffer)
  66 #define CPP_BUF_COLUMN(BUF, CUR) ((CUR) - (BUF)->line_base)
  67 #define CPP_BUF_COL(BUF) CPP_BUF_COLUMN(BUF, (BUF)->cur)
  68
  69 #define CPP_INCREMENT_LINE(PFILE, COLS_HINT) do { \
  70     const class line_maps *line_table = PFILE->line_table; \
  71     const struct line_map_ordinary *map = \
  72       LINEMAPS_LAST_ORDINARY_MAP (line_table); \
  73     linenum_type line = SOURCE_LINE (map, line_table->highest_line); \
  74     linemap_line_start (PFILE->line_table, line + 1, COLS_HINT); \
  75   } while (0)
  76
  77 /* Host alignment handling.  */
  78 struct dummy
  79 {
  80   char c;
  81   union
  82   {
  83     double d;
  84     int *p;
  85   } u;
  86 };
  87
  88 #define DEFAULT_ALIGNMENT offsetof (struct dummy, u)
  89 #define CPP_ALIGN2(size, align) (((size) + ((align) - 1)) & ~((align) - 1))
  90 #define CPP_ALIGN(size) CPP_ALIGN2 (size, DEFAULT_ALIGNMENT)
  91
  92 #define _cpp_mark_macro_used(NODE)                                      \
  93   (cpp_user_macro_p (NODE) ? (NODE)->value.macro->used = 1 : 0)
  94
  95 /* A generic memory buffer, and operations on it.  */
  96 typedef struct _cpp_buff _cpp_buff;
  97 struct _cpp_buff
  98 {
  99   struct _cpp_buff *next;
 100   unsigned char *base, *cur, *limit;
 101 };
 102
 103 extern _cpp_buff *_cpp_get_buff (cpp_reader *, size_t);
 104 extern void _cpp_release_buff (cpp_reader *, _cpp_buff *);
 105 extern void _cpp_extend_buff (cpp_reader *, _cpp_buff **, size_t);
 106 extern _cpp_buff *_cpp_append_extend_buff (cpp_reader *, _cpp_buff *, size_t);
 107 extern void _cpp_free_buff (_cpp_buff *);
 108 extern unsigned char *_cpp_aligned_alloc (cpp_reader *, size_t);
 109 extern unsigned char *_cpp_unaligned_alloc (cpp_reader *, size_t);
 110
 111 #define BUFF_ROOM(BUFF) (size_t) ((BUFF)->limit - (BUFF)->cur)
 112 #define BUFF_FRONT(BUFF) ((BUFF)->cur)
 113 #define BUFF_LIMIT(BUFF) ((BUFF)->limit)
 114
 115 /* #include types.  */
 116 enum include_type
 117   {
 118    /* Directive-based including mechanisms.  */
 119    IT_INCLUDE,  /* #include */
 120    IT_INCLUDE_NEXT,  /* #include_next */
 121    IT_IMPORT,   /* #import  */
 122
 123    /* Non-directive including mechanisms.  */
 124    IT_CMDLINE,  /* -include */
 125    IT_DEFAULT,  /* forced header  */
 126    IT_MAIN,     /* main, start on line 1 */
 127    IT_MAIN_INJECT,  /* main, but there will be an injected preamble
 128                        before line 1 */
 129
 130    IT_DIRECTIVE_HWM = IT_IMPORT + 1,  /* Directives below this.  */
 131    IT_HEADER_HWM = IT_DEFAULT + 1     /* Header files below this.  */
 132   };
 133
 134 union utoken
 135 {
 136   const cpp_token *token;
 137   const cpp_token **ptoken;
 138 };
 139
 140 /* A "run" of tokens; part of a chain of runs.  */
 141 typedef struct tokenrun tokenrun;
 142 struct tokenrun
 143 {
 144   tokenrun *next, *prev;
 145   cpp_token *base, *limit;
 146 };
 147
 148 /* Accessor macros for struct cpp_context.  */
 149 #define FIRST(c) ((c)->u.iso.first)
 150 #define LAST(c) ((c)->u.iso.last)
 151 #define CUR(c) ((c)->u.trad.cur)
 152 #define RLIMIT(c) ((c)->u.trad.rlimit)
 153
 154 /* This describes some additional data that is added to the macro
 155    token context of type cpp_context, when -ftrack-macro-expansion is
 156    on.  */
 157 typedef struct
 158 {
 159   /* The node of the macro we are referring to.  */
 160   cpp_hashnode *macro_node;
 161   /* This buffer contains an array of virtual locations.  The virtual
 162      location at index 0 is the virtual location of the token at index
 163      0 in the current instance of cpp_context; similarly for all the
 164      other virtual locations.  */
 165   location_t *virt_locs;
 166   /* This is a pointer to the current virtual location.  This is used
 167      to iterate over the virtual locations while we iterate over the
 168      tokens they belong to.  */
 169   location_t *cur_virt_loc;
 170 } macro_context;
 171
 172 /* The kind of tokens carried by a cpp_context.  */
 173 enum context_tokens_kind {
 174   /* This is the value of cpp_context::tokens_kind if u.iso.first
 175      contains an instance of cpp_token **.  */
 176   TOKENS_KIND_INDIRECT,
 177   /* This is the value of cpp_context::tokens_kind if u.iso.first
 178      contains an instance of cpp_token *.  */
 179   TOKENS_KIND_DIRECT,
 180   /* This is the value of cpp_context::tokens_kind when the token
 181      context contains tokens resulting from macro expansion.  In that
 182      case struct cpp_context::macro points to an instance of struct
 183      macro_context.  This is used only when the
 184      -ftrack-macro-expansion flag is on.  */
 185   TOKENS_KIND_EXTENDED
 186 };
 187
 188 typedef struct cpp_context cpp_context;
 189 struct cpp_context
 190 {
 191   /* Doubly-linked list.  */
 192   cpp_context *next, *prev;
 193
 194   union
 195   {
 196     /* For ISO macro expansion.  Contexts other than the base context
 197        are contiguous tokens.  e.g. macro expansions, expanded
 198        argument tokens.  */
 199     struct
 200     {
 201       union utoken first;
 202       union utoken last;
 203     } iso;
 204
 205     /* For traditional macro expansion.  */
 206     struct
 207     {
 208       const unsigned char *cur;
 209       const unsigned char *rlimit;
 210     } trad;
 211   } u;
 212
 213   /* If non-NULL, a buffer used for storage related to this context.
 214      When the context is popped, the buffer is released.  */
 215   _cpp_buff *buff;
 216
 217   /* If tokens_kind is TOKEN_KIND_EXTENDED, then (as we thus are in a
 218      macro context) this is a pointer to an instance of macro_context.
 219      Otherwise if tokens_kind is *not* TOKEN_KIND_EXTENDED, then, if
 220      we are in a macro context, this is a pointer to an instance of
 221      cpp_hashnode, representing the name of the macro this context is
 222      for.  If we are not in a macro context, then this is just NULL.
 223      Note that when tokens_kind is TOKEN_KIND_EXTENDED, the memory
 224      used by the instance of macro_context pointed to by this member
 225      is de-allocated upon de-allocation of the instance of struct
 226      cpp_context.  */
 227   union
 228   {
 229     macro_context *mc;
 230     cpp_hashnode *macro;
 231   } c;
 232
 233   /* This determines the type of tokens held by this context.  */
 234   enum context_tokens_kind tokens_kind;
 235 };
 236
 237 struct lexer_state
 238 {
 239   /* 1 if we're handling a directive.  2 if it's an include-like
 240      directive.  */
 241   unsigned char in_directive;
 242
 243   /* Nonzero if in a directive that will handle padding tokens itself.
 244      #include needs this to avoid problems with computed include and
 245      spacing between tokens.  */
 246   unsigned char directive_wants_padding;
 247
 248   /* True if we are skipping a failed conditional group.  */
 249   unsigned char skipping;
 250
 251   /* Nonzero if in a directive that takes angle-bracketed headers.  */
 252   unsigned char angled_headers;
 253
 254   /* Nonzero if in a #if or #elif directive.  */
 255   unsigned char in_expression;
 256
 257   /* Nonzero to save comments.  Turned off if discard_comments, and in
 258      all directives apart from #define.  */
 259   unsigned char save_comments;
 260
 261   /* Nonzero if lexing __VA_ARGS__ and __VA_OPT__ are valid.  */
 262   unsigned char va_args_ok;
 263
 264   /* Nonzero if lexing poisoned identifiers is valid.  */
 265   unsigned char poisoned_ok;
 266
 267   /* Nonzero to prevent macro expansion.  */
 268   unsigned char prevent_expansion;
 269
 270   /* Nonzero when parsing arguments to a function-like macro.  */
 271   unsigned char parsing_args;
 272
 273   /* Nonzero if prevent_expansion is true only because output is
 274      being discarded.  */
 275   unsigned char discarding_output;
 276
 277   /* Nonzero to skip evaluating part of an expression.  */
 278   unsigned int skip_eval;
 279
 280   /* Nonzero when tokenizing a deferred pragma.  */
 281   unsigned char in_deferred_pragma;
 282
 283   /* Nonzero if the deferred pragma being handled allows macro expansion.  */
 284   unsigned char pragma_allow_expansion;
 285 };
 286
 287 /* Special nodes - identifiers with predefined significance.  */
 288 struct spec_nodes
 289 {
 290   cpp_hashnode *n_defined;              /* defined operator */
 291   cpp_hashnode *n_true;                 /* C++ keyword true */
 292   cpp_hashnode *n_false;                /* C++ keyword false */
 293   cpp_hashnode *n__VA_ARGS__;           /* C99 vararg macros */
 294   cpp_hashnode *n__VA_OPT__;            /* C++ vararg macros */
 295 };
 296
 297 typedef struct _cpp_line_note _cpp_line_note;
 298 struct _cpp_line_note
 299 {
 300   /* Location in the clean line the note refers to.  */
 301   const unsigned char *pos;
 302
 303   /* Type of note.  The 9 'from' trigraph characters represent those
 304      trigraphs, '\\' an escaped newline, ' ' an escaped newline with
 305      intervening space, 0 represents a note that has already been handled,
 306      and anything else is invalid.  */
 307   unsigned int type;
 308 };
 309
 310 /* Represents the contents of a file cpplib has read in.  */
 311 struct cpp_buffer
 312 {
 313   const unsigned char *cur;        /* Current location.  */
 314   const unsigned char *line_base;  /* Start of current physical line.  */
 315   const unsigned char *next_line;  /* Start of to-be-cleaned logical line.  */
 316
 317   const unsigned char *buf;        /* Entire character buffer.  */
 318   const unsigned char *rlimit;     /* Writable byte at end of file.  */
 319   const unsigned char *to_free;    /* Pointer that should be freed when
 320                                       popping the buffer.  */
 321
 322   _cpp_line_note *notes;           /* Array of notes.  */
 323   unsigned int cur_note;           /* Next note to process.  */
 324   unsigned int notes_used;         /* Number of notes.  */
 325   unsigned int notes_cap;          /* Size of allocated array.  */
 326
 327   struct cpp_buffer *prev;
 328
 329   /* Pointer into the file table; non-NULL if this is a file buffer.
 330      Used for include_next and to record control macros.  */
 331   struct _cpp_file *file;
 332
 333   /* Saved value of __TIMESTAMP__ macro - date and time of last modification
 334      of the assotiated file.  */
 335   const unsigned char *timestamp;
 336
 337   /* Value of if_stack at start of this file.
 338      Used to prohibit unmatched #endif (etc) in an include file.  */
 339   struct if_stack *if_stack;
 340
 341   /* True if we need to get the next clean line.  */
 342   bool need_line : 1;
 343
 344   /* True if we have already warned about C++ comments in this file.
 345      The warning happens only for C89 extended mode with -pedantic on,
 346      or for -Wtraditional, and only once per file (otherwise it would
 347      be far too noisy).  */
 348   bool warned_cplusplus_comments : 1;
 349
 350   /* True if we don't process trigraphs and escaped newlines.  True
 351      for preprocessed input, command line directives, and _Pragma
 352      buffers.  */
 353   bool from_stage3 : 1;
 354
 355   /* At EOF, a buffer is automatically popped.  If RETURN_AT_EOF is
 356      true, a CPP_EOF token is then returned.  Otherwise, the next
 357      token from the enclosing buffer is returned.  */
 358   bool return_at_eof : 1;
 359
 360   /* One for a system header, two for a C system header file that therefore
 361      needs to be extern "C" protected in C++, and zero otherwise.  */
 362   unsigned char sysp;
 363
 364   /* The directory of the this buffer's file.  Its NAME member is not
 365      allocated, so we don't need to worry about freeing it.  */
 366   struct cpp_dir dir;
 367
 368   /* Descriptor for converting from the input character set to the
 369      source character set.  */
 370   struct cset_converter input_cset_desc;
 371 };
 372
 373 /* The list of saved macros by push_macro pragma.  */
 374 struct def_pragma_macro {
 375   /* Chain element to previous saved macro.  */
 376   struct def_pragma_macro *next;
 377   /* Name of the macro.  */
 378   char *name;
 379   /* The stored macro content.  */
 380   unsigned char *definition;
 381
 382   /* Definition line number.  */
 383   location_t line;
 384   /* If macro defined in system header.  */
 385   unsigned int syshdr   : 1;
 386   /* Nonzero if it has been expanded or had its existence tested.  */
 387   unsigned int used     : 1;
 388
 389   /* Mark if we save an undefined macro.  */
 390   unsigned int is_undef : 1;
 391   /* Nonzero if it was a builtin macro.  */
 392   unsigned int is_builtin : 1;
 393 };
 394
 395 /* A cpp_reader encapsulates the "state" of a pre-processor run.
 396    Applying cpp_get_token repeatedly yields a stream of pre-processor
 397    tokens.  Usually, there is only one cpp_reader object active.  */
 398 struct cpp_reader
 399 {
 400   /* Top of buffer stack.  */
 401   cpp_buffer *buffer;
 402
 403   /* Overlaid buffer (can be different after processing #include).  */
 404   cpp_buffer *overlaid_buffer;
 405
 406   /* Lexer state.  */
 407   struct lexer_state state;
 408
 409   /* Source line tracking.  */
 410   class line_maps *line_table;
 411
 412   /* The line of the '#' of the current directive.  */
 413   location_t directive_line;
 414
 415   /* Memory buffers.  */
 416   _cpp_buff *a_buff;            /* Aligned permanent storage.  */
 417   _cpp_buff *u_buff;            /* Unaligned permanent storage.  */
 418   _cpp_buff *free_buffs;        /* Free buffer chain.  */
 419
 420   /* Context stack.  */
 421   struct cpp_context base_context;
 422   struct cpp_context *context;
 423
 424   /* If in_directive, the directive if known.  */
 425   const struct directive *directive;
 426
 427   /* Token generated while handling a directive, if any. */
 428   cpp_token directive_result;
 429
 430   /* When expanding a macro at top-level, this is the location of the
 431      macro invocation.  */
 432   location_t invocation_location;
 433
 434   /* This is the node representing the macro being expanded at
 435      top-level.  The value of this data member is valid iff
 436      cpp_in_macro_expansion_p() returns TRUE.  */
 437   cpp_hashnode *top_most_macro_node;
 438
 439   /* Nonzero if we are about to expand a macro.  Note that if we are
 440      really expanding a macro, the function macro_of_context returns
 441      the macro being expanded and this flag is set to false.  Client
 442      code should use the function cpp_in_macro_expansion_p to know if we
 443      are either about to expand a macro, or are actually expanding
 444      one.  */
 445   bool about_to_expand_macro_p;
 446
 447   /* Search paths for include files.  */
 448   struct cpp_dir *quote_include;        /* "" */
 449   struct cpp_dir *bracket_include;      /* <> */
 450   struct cpp_dir no_search_path;        /* No path.  */
 451
 452   /* Chain of all hashed _cpp_file instances.  */
 453   struct _cpp_file *all_files;
 454
 455   struct _cpp_file *main_file;
 456
 457   /* File and directory hash table.  */
 458   struct htab *file_hash;
 459   struct htab *dir_hash;
 460   struct file_hash_entry_pool *file_hash_entries;
 461
 462   /* Negative path lookup hash table.  */
 463   struct htab *nonexistent_file_hash;
 464   struct obstack nonexistent_file_ob;
 465
 466   /* Nonzero means don't look for #include "foo" the source-file
 467      directory.  */
 468   bool quote_ignores_source_dir;
 469
 470   /* Nonzero if any file has contained #pragma once or #import has
 471      been used.  */
 472   bool seen_once_only;
 473
 474   /* Multiple include optimization.  */
 475   const cpp_hashnode *mi_cmacro;
 476   const cpp_hashnode *mi_ind_cmacro;
 477   bool mi_valid;
 478
 479   /* Lexing.  */
 480   cpp_token *cur_token;
 481   tokenrun base_run, *cur_run;
 482   unsigned int lookaheads;
 483
 484   /* Nonzero prevents the lexer from re-using the token runs.  */
 485   unsigned int keep_tokens;
 486
 487   /* Buffer to hold macro definition string.  */
 488   unsigned char *macro_buffer;
 489   unsigned int macro_buffer_len;
 490
 491   /* Descriptor for converting from the source character set to the
 492      execution character set.  */
 493   struct cset_converter narrow_cset_desc;
 494
 495   /* Descriptor for converting from the source character set to the
 496      UTF-8 execution character set.  */
 497   struct cset_converter utf8_cset_desc;
 498
 499   /* Descriptor for converting from the source character set to the
 500      UTF-16 execution character set.  */
 501   struct cset_converter char16_cset_desc;
 502
 503   /* Descriptor for converting from the source character set to the
 504      UTF-32 execution character set.  */
 505   struct cset_converter char32_cset_desc;
 506
 507   /* Descriptor for converting from the source character set to the
 508      wide execution character set.  */
 509   struct cset_converter wide_cset_desc;
 510
 511   /* Date and time text.  Calculated together if either is requested.  */
 512   const unsigned char *date;
 513   const unsigned char *time;
 514
 515   /* Externally set timestamp to replace current date and time useful for
 516      reproducibility.  It should be initialized to -2 (not yet set) and
 517      set to -1 to disable it or to a non-negative value to enable it.  */
 518   time_t source_date_epoch;
 519
 520   /* EOF token, and a token forcing paste avoidance.  */
 521   cpp_token avoid_paste;
 522   cpp_token eof;
 523
 524   /* Opaque handle to the dependencies of mkdeps.c.  */
 525   class mkdeps *deps;
 526
 527   /* Obstack holding all macro hash nodes.  This never shrinks.
 528      See identifiers.c */
 529   struct obstack hash_ob;
 530
 531   /* Obstack holding buffer and conditional structures.  This is a
 532      real stack.  See directives.c.  */
 533   struct obstack buffer_ob;
 534
 535   /* Pragma table - dynamic, because a library user can add to the
 536      list of recognized pragmas.  */
 537   struct pragma_entry *pragmas;
 538
 539   /* Call backs to cpplib client.  */
 540   struct cpp_callbacks cb;
 541
 542   /* Identifier hash table.  */
 543   struct ht *hash_table;
 544
 545   /* Expression parser stack.  */
 546   struct op *op_stack, *op_limit;
 547
 548   /* User visible options.  */
 549   struct cpp_options opts;
 550
 551   /* Special nodes - identifiers with predefined significance to the
 552      preprocessor.  */
 553   struct spec_nodes spec_nodes;
 554
 555   /* Whether cpplib owns the hashtable.  */
 556   bool our_hashtable;
 557
 558   /* Traditional preprocessing output buffer (a logical line).  */
 559   struct
 560   {
 561     unsigned char *base;
 562     unsigned char *limit;
 563     unsigned char *cur;
 564     location_t first_line;
 565   } out;
 566
 567   /* Used for buffer overlays by traditional.c.  */
 568   const unsigned char *saved_cur, *saved_rlimit, *saved_line_base;
 569
 570   /* A saved list of the defined macros, for dependency checking
 571      of precompiled headers.  */
 572   struct cpp_savedstate *savedstate;
 573
 574   /* Next value of __COUNTER__ macro. */
 575   unsigned int counter;
 576
 577   /* Table of comments, when state.save_comments is true.  */
 578   cpp_comment_table comments;
 579
 580   /* List of saved macros by push_macro.  */
 581   struct def_pragma_macro *pushed_macros;
 582
 583   /* If non-zero, the lexer will use this location for the next token
 584      instead of getting a location from the linemap.  */
 585   location_t forced_token_location;
 586 };
 587
 588 /* Character classes.  Based on the more primitive macros in safe-ctype.h.
 589    If the definition of `numchar' looks odd to you, please look up the
 590    definition of a pp-number in the C standard [section 6.4.8 of C99].
 591
 592    In the unlikely event that characters other than \r and \n enter
 593    the set is_vspace, the macro handle_newline() in lex.c must be
 594    updated.  */
 595 #define _dollar_ok(x)   ((x) == '$' && CPP_OPTION (pfile, dollars_in_ident))
 596
 597 #define is_idchar(x)    (ISIDNUM(x) || _dollar_ok(x))
 598 #define is_numchar(x)   ISIDNUM(x)
 599 #define is_idstart(x)   (ISIDST(x) || _dollar_ok(x))
 600 #define is_numstart(x)  ISDIGIT(x)
 601 #define is_hspace(x)    ISBLANK(x)
 602 #define is_vspace(x)    IS_VSPACE(x)
 603 #define is_nvspace(x)   IS_NVSPACE(x)
 604 #define is_space(x)     IS_SPACE_OR_NUL(x)
 605
 606 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
 607
 608 /* This table is constant if it can be initialized at compile time,
 609    which is the case if cpp was compiled with GCC >=2.7, or another
 610    compiler that supports C99.  */
 611 #if HAVE_DESIGNATED_INITIALIZERS
 612 extern const unsigned char _cpp_trigraph_map[UCHAR_MAX + 1];
 613 #else
 614 extern unsigned char _cpp_trigraph_map[UCHAR_MAX + 1];
 615 #endif
 616
 617 #if !defined (HAVE_UCHAR) && !defined (IN_GCC)
 618 typedef unsigned char uchar;
 619 #endif
 620
 621 #define UC (const uchar *)  /* Intended use: UC"string" */
 622
 623 /* Macros.  */
 624
 625 static inline int cpp_in_system_header (cpp_reader *);
 626 static inline int
 627 cpp_in_system_header (cpp_reader *pfile)
 628 {
 629   return pfile->buffer ? pfile->buffer->sysp : 0;
 630 }
 631 #define CPP_PEDANTIC(PF) CPP_OPTION (PF, cpp_pedantic)
 632 #define CPP_WTRADITIONAL(PF) CPP_OPTION (PF, cpp_warn_traditional)
 633
 634 static inline int cpp_in_primary_file (cpp_reader *);
 635 static inline int
 636 cpp_in_primary_file (cpp_reader *pfile)
 637 {
 638   return pfile->line_table->depth == 1;
 639 }
 640
 641 /* True if NODE is a macro for the purposes of ifdef, defined etc.  */
 642 inline bool _cpp_defined_macro_p (cpp_hashnode *node)
 643 {
 644   /* Do not treat conditional macros as being defined.  This is due to
 645      the powerpc port using conditional macros for 'vector', 'bool',
 646      and 'pixel' to act as conditional keywords.  This messes up tests
 647      like #ifndef bool.  */
 648   return cpp_macro_p (node) && !(node->flags & NODE_CONDITIONAL);
 649 }
 650
 651 /* In macro.c */
 652 extern void _cpp_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node);
 653 inline void _cpp_maybe_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node)
 654 {
 655   if (!(node->flags & NODE_USED))
 656     _cpp_notify_macro_use (pfile, node);
 657 }
 658 extern cpp_macro *_cpp_new_macro (cpp_reader *, cpp_macro_kind, void *);
 659 extern void _cpp_free_definition (cpp_hashnode *);
 660 extern bool _cpp_create_definition (cpp_reader *, cpp_hashnode *);
 661 extern void _cpp_pop_context (cpp_reader *);
 662 extern void _cpp_push_text_context (cpp_reader *, cpp_hashnode *,
 663                                     const unsigned char *, size_t);
 664 extern bool _cpp_save_parameter (cpp_reader *, unsigned, cpp_hashnode *,
 665                                  cpp_hashnode *);
 666 extern void _cpp_unsave_parameters (cpp_reader *, unsigned);
 667 extern bool _cpp_arguments_ok (cpp_reader *, cpp_macro *, const cpp_hashnode *,
 668                                unsigned int);
 669 extern const unsigned char *_cpp_builtin_macro_text (cpp_reader *,
 670                                                      cpp_hashnode *,
 671                                                      location_t = 0);
 672 extern int _cpp_warn_if_unused_macro (cpp_reader *, cpp_hashnode *, void *);
 673 extern void _cpp_push_token_context (cpp_reader *, cpp_hashnode *,
 674                                      const cpp_token *, unsigned int);
 675 extern void _cpp_backup_tokens_direct (cpp_reader *, unsigned int);
 676
 677 /* In identifiers.c */
 678 extern void _cpp_init_hashtable (cpp_reader *, cpp_hash_table *);
 679 extern void _cpp_destroy_hashtable (cpp_reader *);
 680
 681 /* In files.c */
 682 enum _cpp_find_file_kind
 683   { _cpp_FFK_NORMAL, _cpp_FFK_FAKE, _cpp_FFK_PRE_INCLUDE, _cpp_FFK_HAS_INCLUDE };
 684 extern _cpp_file *_cpp_find_file (cpp_reader *, const char *, cpp_dir *,
 685                                   int angle, _cpp_find_file_kind, location_t);
 686 extern bool _cpp_find_failed (_cpp_file *);
 687 extern void _cpp_mark_file_once_only (cpp_reader *, struct _cpp_file *);
 688 extern void _cpp_fake_include (cpp_reader *, const char *);
 689 extern bool _cpp_stack_file (cpp_reader *, _cpp_file*, include_type, location_t);
 690 extern bool _cpp_stack_include (cpp_reader *, const char *, int,
 691                                 enum include_type, location_t);
 692 extern int _cpp_compare_file_date (cpp_reader *, const char *, int);
 693 extern void _cpp_report_missing_guards (cpp_reader *);
 694 extern void _cpp_init_files (cpp_reader *);
 695 extern void _cpp_cleanup_files (cpp_reader *);
 696 extern void _cpp_pop_file_buffer (cpp_reader *, struct _cpp_file *,
 697                                   const unsigned char *);
 698 extern bool _cpp_save_file_entries (cpp_reader *pfile, FILE *f);
 699 extern bool _cpp_read_file_entries (cpp_reader *, FILE *);
 700 extern const char *_cpp_get_file_name (_cpp_file *);
 701 extern struct stat *_cpp_get_file_stat (_cpp_file *);
 702 extern bool _cpp_has_header (cpp_reader *, const char *, int,
 703                              enum include_type);
 704
 705 /* In expr.c */
 706 extern bool _cpp_parse_expr (cpp_reader *, bool);
 707 extern struct op *_cpp_expand_op_stack (cpp_reader *);
 708
 709 /* In lex.c */
 710 extern void _cpp_process_line_notes (cpp_reader *, int);
 711 extern void _cpp_clean_line (cpp_reader *);
 712 extern bool _cpp_get_fresh_line (cpp_reader *);
 713 extern bool _cpp_skip_block_comment (cpp_reader *);
 714 extern cpp_token *_cpp_temp_token (cpp_reader *);
 715 extern const cpp_token *_cpp_lex_token (cpp_reader *);
 716 extern cpp_token *_cpp_lex_direct (cpp_reader *);
 717 extern unsigned char *_cpp_spell_ident_ucns (unsigned char *, cpp_hashnode *);
 718 extern int _cpp_equiv_tokens (const cpp_token *, const cpp_token *);
 719 extern void _cpp_init_tokenrun (tokenrun *, unsigned int);
 720 extern cpp_hashnode *_cpp_lex_identifier (cpp_reader *, const char *);
 721 extern int _cpp_remaining_tokens_num_in_context (cpp_context *);
 722 extern void _cpp_init_lexer (void);
 723 static inline void *_cpp_reserve_room (cpp_reader *pfile, size_t have,
 724                                        size_t extra)
 725 {
 726   if (BUFF_ROOM (pfile->a_buff) < (have + extra))
 727     _cpp_extend_buff (pfile, &pfile->a_buff, extra);
 728   return BUFF_FRONT (pfile->a_buff);
 729 }
 730 extern void *_cpp_commit_buff (cpp_reader *pfile, size_t size);
 731
 732 /* In init.c.  */
 733 extern void _cpp_maybe_push_include_file (cpp_reader *);
 734 extern const char *cpp_named_operator2name (enum cpp_ttype type);
 735 extern void _cpp_restore_special_builtin (cpp_reader *pfile,
 736                                           struct def_pragma_macro *);
 737
 738 /* In directives.c */
 739 extern int _cpp_test_assertion (cpp_reader *, unsigned int *);
 740 extern int _cpp_handle_directive (cpp_reader *, bool);
 741 extern void _cpp_define_builtin (cpp_reader *, const char *);
 742 extern char ** _cpp_save_pragma_names (cpp_reader *);
 743 extern void _cpp_restore_pragma_names (cpp_reader *, char **);
 744 extern int _cpp_do__Pragma (cpp_reader *, location_t);
 745 extern void _cpp_init_directives (cpp_reader *);
 746 extern void _cpp_init_internal_pragmas (cpp_reader *);
 747 extern void _cpp_do_file_change (cpp_reader *, enum lc_reason, const char *,
 748                                  linenum_type, unsigned int);
 749 extern void _cpp_pop_buffer (cpp_reader *);
 750 extern char *_cpp_bracket_include (cpp_reader *);
 751
 752 /* In traditional.c.  */
 753 extern bool _cpp_scan_out_logical_line (cpp_reader *, cpp_macro *, bool);
 754 extern bool _cpp_read_logical_line_trad (cpp_reader *);
 755 extern void _cpp_overlay_buffer (cpp_reader *pfile, const unsigned char *,
 756                                  size_t);
 757 extern void _cpp_remove_overlay (cpp_reader *);
 758 extern cpp_macro *_cpp_create_trad_definition (cpp_reader *);
 759 extern bool _cpp_expansions_different_trad (const cpp_macro *,
 760                                             const cpp_macro *);
 761 extern unsigned char *_cpp_copy_replacement_text (const cpp_macro *,
 762                                                   unsigned char *);
 763 extern size_t _cpp_replacement_text_len (const cpp_macro *);
 764
 765 /* In charset.c.  */
 766
 767 /* The normalization state at this point in the sequence.
 768    It starts initialized to all zeros, and at the end
 769    'level' is the normalization level of the sequence.  */
 770
 771 struct normalize_state
 772 {
 773   /* The previous starter character.  */
 774   cppchar_t previous;
 775   /* The combining class of the previous character (whether or not a
 776      starter).  */
 777   unsigned char prev_class;
 778   /* The lowest normalization level so far.  */
 779   enum cpp_normalize_level level;
 780 };
 781 #define INITIAL_NORMALIZE_STATE { 0, 0, normalized_KC }
 782 #define NORMALIZE_STATE_RESULT(st) ((st)->level)
 783
 784 /* We saw a character C that matches ISIDNUM(), update a
 785    normalize_state appropriately.  */
 786 #define NORMALIZE_STATE_UPDATE_IDNUM(st, c)     \
 787   ((st)->previous = (c), (st)->prev_class = 0)
 788
 789 extern bool _cpp_valid_ucn (cpp_reader *, const unsigned char **,
 790                             const unsigned char *, int,
 791                             struct normalize_state *state,
 792                             cppchar_t *,
 793                             source_range *char_range,
 794                             cpp_string_location_reader *loc_reader);
 795
 796 extern bool _cpp_valid_utf8 (cpp_reader *pfile,
 797                              const uchar **pstr,
 798                              const uchar *limit,
 799                              int identifier_pos,
 800                              struct normalize_state *nst,
 801                              cppchar_t *cp);
 802
 803 extern void _cpp_destroy_iconv (cpp_reader *);
 804 extern unsigned char *_cpp_convert_input (cpp_reader *, const char *,
 805                                           unsigned char *, size_t, size_t,
 806                                           const unsigned char **, off_t *);
 807 extern const char *_cpp_default_encoding (void);
 808 extern cpp_hashnode * _cpp_interpret_identifier (cpp_reader *pfile,
 809                                                  const unsigned char *id,
 810                                                  size_t len);
 811
 812 /* Utility routines and macros.  */
 813 #define DSC(str) (const unsigned char *)str, sizeof str - 1
 814
 815 /* These are inline functions instead of macros so we can get type
 816    checking.  */
 817 static inline int ustrcmp (const unsigned char *, const unsigned char *);
 818 static inline int ustrncmp (const unsigned char *, const unsigned char *,
 819                             size_t);
 820 static inline size_t ustrlen (const unsigned char *);
 821 static inline const unsigned char *uxstrdup (const unsigned char *);
 822 static inline const unsigned char *ustrchr (const unsigned char *, int);
 823 static inline int ufputs (const unsigned char *, FILE *);
 824
 825 /* Use a const char for the second parameter since it is usually a literal.  */
 826 static inline int ustrcspn (const unsigned char *, const char *);
 827
 828 static inline int
 829 ustrcmp (const unsigned char *s1, const unsigned char *s2)
 830 {
 831   return strcmp ((const char *)s1, (const char *)s2);
 832 }
 833
 834 static inline int
 835 ustrncmp (const unsigned char *s1, const unsigned char *s2, size_t n)
 836 {
 837   return strncmp ((const char *)s1, (const char *)s2, n);
 838 }
 839
 840 static inline int
 841 ustrcspn (const unsigned char *s1, const char *s2)
 842 {
 843   return strcspn ((const char *)s1, s2);
 844 }
 845
 846 static inline size_t
 847 ustrlen (const unsigned char *s1)
 848 {
 849   return strlen ((const char *)s1);
 850 }
 851
 852 static inline const unsigned char *
 853 uxstrdup (const unsigned char *s1)
 854 {
 855   return (const unsigned char *) xstrdup ((const char *)s1);
 856 }
 857
 858 static inline const unsigned char *
 859 ustrchr (const unsigned char *s1, int c)
 860 {
 861   return (const unsigned char *) strchr ((const char *)s1, c);
 862 }
 863
 864 static inline int
 865 ufputs (const unsigned char *s, FILE *f)
 866 {
 867   return fputs ((const char *)s, f);
 868 }
 869
 870   /* In line-map.c.  */
 871
 872 /* Create a macro map.  A macro map encodes source locations of tokens
 873    that are part of a macro replacement-list, at a macro expansion
 874    point. See the extensive comments of struct line_map and struct
 875    line_map_macro, in line-map.h.
 876
 877    This map shall be created when the macro is expanded. The map
 878    encodes the source location of the expansion point of the macro as
 879    well as the "original" source location of each token that is part
 880    of the macro replacement-list. If a macro is defined but never
 881    expanded, it has no macro map.  SET is the set of maps the macro
 882    map should be part of.  MACRO_NODE is the macro which the new macro
 883    map should encode source locations for.  EXPANSION is the location
 884    of the expansion point of MACRO. For function-like macros
 885    invocations, it's best to make it point to the closing parenthesis
 886    of the macro, rather than the the location of the first character
 887    of the macro.  NUM_TOKENS is the number of tokens that are part of
 888    the replacement-list of MACRO.  */
 889 const line_map_macro *linemap_enter_macro (class line_maps *,
 890                                            struct cpp_hashnode*,
 891                                            location_t,
 892                                            unsigned int);
 893
 894 /* Create and return a virtual location for a token that is part of a
 895    macro expansion-list at a macro expansion point.  See the comment
 896    inside struct line_map_macro to see what an expansion-list exactly
 897    is.
 898
 899    A call to this function must come after a call to
 900    linemap_enter_macro.
 901
 902    MAP is the map into which the source location is created.  TOKEN_NO
 903    is the index of the token in the macro replacement-list, starting
 904    at number 0.
 905
 906    ORIG_LOC is the location of the token outside of this macro
 907    expansion.  If the token comes originally from the macro
 908    definition, it is the locus in the macro definition; otherwise it
 909    is a location in the context of the caller of this macro expansion
 910    (which is a virtual location or a source location if the caller is
 911    itself a macro expansion or not).
 912
 913    MACRO_DEFINITION_LOC is the location in the macro definition,
 914    either of the token itself or of a macro parameter that it
 915    replaces.  */
 916 location_t linemap_add_macro_token (const line_map_macro *,
 917                                     unsigned int,
 918                                     location_t,
 919                                     location_t);
 920
 921 /* Return the source line number corresponding to source location
 922    LOCATION.  SET is the line map set LOCATION comes from.  If
 923    LOCATION is the location of token that is part of the
 924    expansion-list of a macro expansion return the line number of the
 925    macro expansion point.  */
 926 int linemap_get_expansion_line (class line_maps *,
 927                                 location_t);
 928
 929 /* Return the path of the file corresponding to source code location
 930    LOCATION.
 931
 932    If LOCATION is the location of a token that is part of the
 933    replacement-list of a macro expansion return the file path of the
 934    macro expansion point.
 935
 936    SET is the line map set LOCATION comes from.  */
 937 const char* linemap_get_expansion_filename (class line_maps *,
 938                                             location_t);
 939
 940 #ifdef __cplusplus
 941 }
 942 #endif
 943
 944 #endif /* ! LIBCPP_INTERNAL_H */