libcpp/internal.h

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