OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libcpp/] [internal.h] - Blame information for rev 743

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.