libcpp/internal.h

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