libcpp/internal.h

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