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