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

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [libcpp/] [internal.h] - Blame information for rev 13

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 13 jlechner
/* Part of CPP library.
2
   Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3
   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 2, 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; if not, write to the Free Software
17
Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
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
#ifndef HAVE_ICONV_H
30
#undef HAVE_ICONV
31
#endif
32
 
33
#if HAVE_ICONV
34
#include <iconv.h>
35
#else
36
#define HAVE_ICONV 0
37
typedef int iconv_t;  /* dummy */
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
};
52
 
53
#define BITS_PER_CPPCHAR_T (CHAR_BIT * sizeof (cppchar_t))
54
 
55
/* Test if a sign is valid within a preprocessing number.  */
56
#define VALID_SIGN(c, prevc) \
57
  (((c) == '+' || (c) == '-') && \
58
   ((prevc) == 'e' || (prevc) == 'E' \
59
    || (((prevc) == 'p' || (prevc) == 'P') \
60
        && CPP_OPTION (pfile, extended_numbers))))
61
 
62
#define CPP_OPTION(PFILE, OPTION) ((PFILE)->opts.OPTION)
63
#define CPP_BUFFER(PFILE) ((PFILE)->buffer)
64
#define CPP_BUF_COLUMN(BUF, CUR) ((CUR) - (BUF)->line_base)
65
#define CPP_BUF_COL(BUF) CPP_BUF_COLUMN(BUF, (BUF)->cur)
66
 
67
#define CPP_INCREMENT_LINE(PFILE, COLS_HINT) do { \
68
    const struct line_maps *line_table = PFILE->line_table; \
69
    const struct line_map *map = &line_table->maps[line_table->used-1]; \
70
    unsigned int line = SOURCE_LINE (map, line_table->highest_line); \
71
    linemap_line_start (PFILE->line_table, line + 1, COLS_HINT); \
72
  } while (0)
73
 
74
/* Maximum nesting of cpp_buffers.  We use a static limit, partly for
75
   efficiency, and partly to limit runaway recursion.  */
76
#define CPP_STACK_MAX 200
77
 
78
/* Host alignment handling.  */
79
struct dummy
80
{
81
  char c;
82
  union
83
  {
84
    double d;
85
    int *p;
86
  } u;
87
};
88
 
89
#define DEFAULT_ALIGNMENT offsetof (struct dummy, u)
90
#define CPP_ALIGN2(size, align) (((size) + ((align) - 1)) & ~((align) - 1))
91
#define CPP_ALIGN(size) CPP_ALIGN2 (size, DEFAULT_ALIGNMENT)
92
 
93
#define _cpp_mark_macro_used(NODE) do {                                 \
94
  if ((NODE)->type == NT_MACRO && !((NODE)->flags & NODE_BUILTIN))      \
95
    (NODE)->value.macro->used = 1; } while (0)
96
 
97
/* A generic memory buffer, and operations on it.  */
98
typedef struct _cpp_buff _cpp_buff;
99
struct _cpp_buff
100
{
101
  struct _cpp_buff *next;
102
  unsigned char *base, *cur, *limit;
103
};
104
 
105
extern _cpp_buff *_cpp_get_buff (cpp_reader *, size_t);
106
extern void _cpp_release_buff (cpp_reader *, _cpp_buff *);
107
extern void _cpp_extend_buff (cpp_reader *, _cpp_buff **, size_t);
108
extern _cpp_buff *_cpp_append_extend_buff (cpp_reader *, _cpp_buff *, size_t);
109
extern void _cpp_free_buff (_cpp_buff *);
110
extern unsigned char *_cpp_aligned_alloc (cpp_reader *, size_t);
111
extern unsigned char *_cpp_unaligned_alloc (cpp_reader *, size_t);
112
 
113
#define BUFF_ROOM(BUFF) (size_t) ((BUFF)->limit - (BUFF)->cur)
114
#define BUFF_FRONT(BUFF) ((BUFF)->cur)
115
#define BUFF_LIMIT(BUFF) ((BUFF)->limit)
116
 
117
/* #include types.  */
118
enum include_type {IT_INCLUDE, IT_INCLUDE_NEXT, IT_IMPORT, IT_CMDLINE};
119
 
120
union utoken
121
{
122
  const cpp_token *token;
123
  const cpp_token **ptoken;
124
};
125
 
126
/* A "run" of tokens; part of a chain of runs.  */
127
typedef struct tokenrun tokenrun;
128
struct tokenrun
129
{
130
  tokenrun *next, *prev;
131
  cpp_token *base, *limit;
132
};
133
 
134
/* Accessor macros for struct cpp_context.  */
135
#define FIRST(c) ((c)->u.iso.first)
136
#define LAST(c) ((c)->u.iso.last)
137
#define CUR(c) ((c)->u.trad.cur)
138
#define RLIMIT(c) ((c)->u.trad.rlimit)
139
 
140
typedef struct cpp_context cpp_context;
141
struct cpp_context
142
{
143
  /* Doubly-linked list.  */
144
  cpp_context *next, *prev;
145
 
146
  union
147
  {
148
    /* For ISO macro expansion.  Contexts other than the base context
149
       are contiguous tokens.  e.g. macro expansions, expanded
150
       argument tokens.  */
151
    struct
152
    {
153
      union utoken first;
154
      union utoken last;
155
    } iso;
156
 
157
    /* For traditional macro expansion.  */
158
    struct
159
    {
160
      const unsigned char *cur;
161
      const unsigned char *rlimit;
162
    } trad;
163
  } u;
164
 
165
  /* If non-NULL, a buffer used for storage related to this context.
166
     When the context is popped, the buffer is released.  */
167
  _cpp_buff *buff;
168
 
169
  /* For a macro context, the macro node, otherwise NULL.  */
170
  cpp_hashnode *macro;
171
 
172
  /* True if utoken element is token, else ptoken.  */
173
  bool direct_p;
174
};
175
 
176
struct lexer_state
177
{
178
  /* Nonzero if first token on line is CPP_HASH.  */
179
  unsigned char in_directive;
180
 
181
  /* Nonzero if in a directive that will handle padding tokens itself.
182
     #include needs this to avoid problems with computed include and
183
     spacing between tokens.  */
184
  unsigned char directive_wants_padding;
185
 
186
  /* True if we are skipping a failed conditional group.  */
187
  unsigned char skipping;
188
 
189
  /* Nonzero if in a directive that takes angle-bracketed headers.  */
190
  unsigned char angled_headers;
191
 
192
  /* Nonzero if in a #if or #elif directive.  */
193
  unsigned char in_expression;
194
 
195
  /* Nonzero to save comments.  Turned off if discard_comments, and in
196
     all directives apart from #define.  */
197
  unsigned char save_comments;
198
 
199
  /* Nonzero if lexing __VA_ARGS__ is valid.  */
200
  unsigned char va_args_ok;
201
 
202
  /* Nonzero if lexing poisoned identifiers is valid.  */
203
  unsigned char poisoned_ok;
204
 
205
  /* Nonzero to prevent macro expansion.  */
206
  unsigned char prevent_expansion;
207
 
208
  /* Nonzero when handling a deferred pragma.  */
209
  unsigned char in_deferred_pragma;
210
 
211
  /* Nonzero when parsing arguments to a function-like macro.  */
212
  unsigned char parsing_args;
213
 
214
  /* Nonzero if prevent_expansion is true only because output is
215
     being discarded.  */
216
  unsigned char discarding_output;
217
 
218
  /* Nonzero to skip evaluating part of an expression.  */
219
  unsigned int skip_eval;
220
};
221
 
222
/* Special nodes - identifiers with predefined significance.  */
223
struct spec_nodes
224
{
225
  cpp_hashnode *n_defined;              /* defined operator */
226
  cpp_hashnode *n_true;                 /* C++ keyword true */
227
  cpp_hashnode *n_false;                /* C++ keyword false */
228
  cpp_hashnode *n__VA_ARGS__;           /* C99 vararg macros */
229
};
230
 
231
typedef struct _cpp_line_note _cpp_line_note;
232
struct _cpp_line_note
233
{
234
  /* Location in the clean line the note refers to.  */
235
  const unsigned char *pos;
236
 
237
  /* Type of note.  The 9 'from' trigraph characters represent those
238
     trigraphs, '\\' an escaped newline, ' ' an escaped newline with
239
     intervening space, and anything else is invalid.  */
240
  unsigned int type;
241
};
242
 
243
/* Represents the contents of a file cpplib has read in.  */
244
struct cpp_buffer
245
{
246
  const unsigned char *cur;        /* Current location.  */
247
  const unsigned char *line_base;  /* Start of current physical line.  */
248
  const unsigned char *next_line;  /* Start of to-be-cleaned logical line.  */
249
 
250
  const unsigned char *buf;        /* Entire character buffer.  */
251
  const unsigned char *rlimit;     /* Writable byte at end of file.  */
252
 
253
  _cpp_line_note *notes;           /* Array of notes.  */
254
  unsigned int cur_note;           /* Next note to process.  */
255
  unsigned int notes_used;         /* Number of notes.  */
256
  unsigned int notes_cap;          /* Size of allocated array.  */
257
 
258
  struct cpp_buffer *prev;
259
 
260
  /* Pointer into the file table; non-NULL if this is a file buffer.
261
     Used for include_next and to record control macros.  */
262
  struct _cpp_file *file;
263
 
264
  /* Value of if_stack at start of this file.
265
     Used to prohibit unmatched #endif (etc) in an include file.  */
266
  struct if_stack *if_stack;
267
 
268
  /* True if we need to get the next clean line.  */
269
  bool need_line;
270
 
271
  /* True if we have already warned about C++ comments in this file.
272
     The warning happens only for C89 extended mode with -pedantic on,
273
     or for -Wtraditional, and only once per file (otherwise it would
274
     be far too noisy).  */
275
  unsigned int warned_cplusplus_comments : 1;
276
 
277
  /* True if we don't process trigraphs and escaped newlines.  True
278
     for preprocessed input, command line directives, and _Pragma
279
     buffers.  */
280
  unsigned int from_stage3 : 1;
281
 
282
  /* At EOF, a buffer is automatically popped.  If RETURN_AT_EOF is
283
     true, a CPP_EOF token is then returned.  Otherwise, the next
284
     token from the enclosing buffer is returned.  */
285
  unsigned int return_at_eof : 1;
286
 
287
  /* One for a system header, two for a C system header file that therefore
288
     needs to be extern "C" protected in C++, and zero otherwise.  */
289
  unsigned char sysp;
290
 
291
  /* The directory of the this buffer's file.  Its NAME member is not
292
     allocated, so we don't need to worry about freeing it.  */
293
  struct cpp_dir dir;
294
 
295
  /* Descriptor for converting from the input character set to the
296
     source character set.  */
297
  struct cset_converter input_cset_desc;
298
};
299
 
300
/* A cpp_reader encapsulates the "state" of a pre-processor run.
301
   Applying cpp_get_token repeatedly yields a stream of pre-processor
302
   tokens.  Usually, there is only one cpp_reader object active.  */
303
struct cpp_reader
304
{
305
  /* Top of buffer stack.  */
306
  cpp_buffer *buffer;
307
 
308
  /* Overlaid buffer (can be different after processing #include).  */
309
  cpp_buffer *overlaid_buffer;
310
 
311
  /* Lexer state.  */
312
  struct lexer_state state;
313
 
314
  /* Source line tracking.  */
315
  struct line_maps *line_table;
316
 
317
  /* The line of the '#' of the current directive.  */
318
  source_location directive_line;
319
 
320
  /* Memory buffers.  */
321
  _cpp_buff *a_buff;            /* Aligned permanent storage.  */
322
  _cpp_buff *u_buff;            /* Unaligned permanent storage.  */
323
  _cpp_buff *free_buffs;        /* Free buffer chain.  */
324
 
325
  /* Context stack.  */
326
  struct cpp_context base_context;
327
  struct cpp_context *context;
328
 
329
  /* If in_directive, the directive if known.  */
330
  const struct directive *directive;
331
 
332
  /* Token generated while handling a directive, if any. */
333
  cpp_token directive_result;
334
 
335
  /* Search paths for include files.  */
336
  struct cpp_dir *quote_include;        /* "" */
337
  struct cpp_dir *bracket_include;      /* <> */
338
  struct cpp_dir no_search_path;        /* No path.  */
339
 
340
  /* Chain of all hashed _cpp_file instances.  */
341
  struct _cpp_file *all_files;
342
 
343
  struct _cpp_file *main_file;
344
 
345
  /* File and directory hash table.  */
346
  struct htab *file_hash;
347
  struct htab *dir_hash;
348
  struct file_hash_entry *file_hash_entries;
349
  unsigned int file_hash_entries_allocated, file_hash_entries_used;
350
 
351
  /* Nonzero means don't look for #include "foo" the source-file
352
     directory.  */
353
  bool quote_ignores_source_dir;
354
 
355
  /* Nonzero if any file has contained #pragma once or #import has
356
     been used.  */
357
  bool seen_once_only;
358
 
359
  /* Multiple include optimization.  */
360
  const cpp_hashnode *mi_cmacro;
361
  const cpp_hashnode *mi_ind_cmacro;
362
  bool mi_valid;
363
 
364
  /* Lexing.  */
365
  cpp_token *cur_token;
366
  tokenrun base_run, *cur_run;
367
  unsigned int lookaheads;
368
 
369
  /* Nonzero prevents the lexer from re-using the token runs.  */
370
  unsigned int keep_tokens;
371
 
372
  /* Error counter for exit code.  */
373
  unsigned int errors;
374
 
375
  /* Buffer to hold macro definition string.  */
376
  unsigned char *macro_buffer;
377
  unsigned int macro_buffer_len;
378
 
379
  /* Descriptor for converting from the source character set to the
380
     execution character set.  */
381
  struct cset_converter narrow_cset_desc;
382
 
383
  /* Descriptor for converting from the source character set to the
384
     wide execution character set.  */
385
  struct cset_converter wide_cset_desc;
386
 
387
  /* Date and time text.  Calculated together if either is requested.  */
388
  const unsigned char *date;
389
  const unsigned char *time;
390
 
391
  /* EOF token, and a token forcing paste avoidance.  */
392
  cpp_token avoid_paste;
393
  cpp_token eof;
394
 
395
  /* Opaque handle to the dependencies of mkdeps.c.  */
396
  struct deps *deps;
397
 
398
  /* Obstack holding all macro hash nodes.  This never shrinks.
399
     See identifiers.c */
400
  struct obstack hash_ob;
401
 
402
  /* Obstack holding buffer and conditional structures.  This is a
403
     real stack.  See directives.c.  */
404
  struct obstack buffer_ob;
405
 
406
  /* Pragma table - dynamic, because a library user can add to the
407
     list of recognized pragmas.  */
408
  struct pragma_entry *pragmas;
409
 
410
  /* Call backs to cpplib client.  */
411
  struct cpp_callbacks cb;
412
 
413
  /* Identifier hash table.  */
414
  struct ht *hash_table;
415
 
416
  /* Expression parser stack.  */
417
  struct op *op_stack, *op_limit;
418
 
419
  /* User visible options.  */
420
  struct cpp_options opts;
421
 
422
  /* Special nodes - identifiers with predefined significance to the
423
     preprocessor.  */
424
  struct spec_nodes spec_nodes;
425
 
426
  /* Whether cpplib owns the hashtable.  */
427
  bool our_hashtable;
428
 
429
  /* Traditional preprocessing output buffer (a logical line).  */
430
  struct
431
  {
432
    unsigned char *base;
433
    unsigned char *limit;
434
    unsigned char *cur;
435
    source_location first_line;
436
  } out;
437
 
438
  /* Used for buffer overlays by traditional.c.  */
439
  const unsigned char *saved_cur, *saved_rlimit, *saved_line_base;
440
 
441
  /* A saved list of the defined macros, for dependency checking
442
     of precompiled headers.  */
443
  struct cpp_savedstate *savedstate;
444
};
445
 
446
/* Character classes.  Based on the more primitive macros in safe-ctype.h.
447
   If the definition of `numchar' looks odd to you, please look up the
448
   definition of a pp-number in the C standard [section 6.4.8 of C99].
449
 
450
   In the unlikely event that characters other than \r and \n enter
451
   the set is_vspace, the macro handle_newline() in lex.c must be
452
   updated.  */
453
#define _dollar_ok(x)   ((x) == '$' && CPP_OPTION (pfile, dollars_in_ident))
454
 
455
#define is_idchar(x)    (ISIDNUM(x) || _dollar_ok(x))
456
#define is_numchar(x)   ISIDNUM(x)
457
#define is_idstart(x)   (ISIDST(x) || _dollar_ok(x))
458
#define is_numstart(x)  ISDIGIT(x)
459
#define is_hspace(x)    ISBLANK(x)
460
#define is_vspace(x)    IS_VSPACE(x)
461
#define is_nvspace(x)   IS_NVSPACE(x)
462
#define is_space(x)     IS_SPACE_OR_NUL(x)
463
 
464
/* This table is constant if it can be initialized at compile time,
465
   which is the case if cpp was compiled with GCC >=2.7, or another
466
   compiler that supports C99.  */
467
#if HAVE_DESIGNATED_INITIALIZERS
468
extern const unsigned char _cpp_trigraph_map[UCHAR_MAX + 1];
469
#else
470
extern unsigned char _cpp_trigraph_map[UCHAR_MAX + 1];
471
#endif
472
 
473
/* Macros.  */
474
 
475
static inline int cpp_in_system_header (cpp_reader *);
476
static inline int
477
cpp_in_system_header (cpp_reader *pfile)
478
{
479
  return pfile->buffer ? pfile->buffer->sysp : 0;
480
}
481
#define CPP_PEDANTIC(PF) CPP_OPTION (PF, pedantic)
482
#define CPP_WTRADITIONAL(PF) CPP_OPTION (PF, warn_traditional)
483
 
484
/* In errors.c  */
485
extern int _cpp_begin_message (cpp_reader *, int,
486
                               source_location, unsigned int);
487
 
488
/* In macro.c */
489
extern void _cpp_free_definition (cpp_hashnode *);
490
extern bool _cpp_create_definition (cpp_reader *, cpp_hashnode *);
491
extern void _cpp_pop_context (cpp_reader *);
492
extern void _cpp_push_text_context (cpp_reader *, cpp_hashnode *,
493
                                    const unsigned char *, size_t);
494
extern bool _cpp_save_parameter (cpp_reader *, cpp_macro *, cpp_hashnode *);
495
extern bool _cpp_arguments_ok (cpp_reader *, cpp_macro *, const cpp_hashnode *,
496
                               unsigned int);
497
extern const unsigned char *_cpp_builtin_macro_text (cpp_reader *,
498
                                                     cpp_hashnode *);
499
int _cpp_warn_if_unused_macro (cpp_reader *, cpp_hashnode *, void *);
500
/* In identifiers.c */
501
extern void _cpp_init_hashtable (cpp_reader *, hash_table *);
502
extern void _cpp_destroy_hashtable (cpp_reader *);
503
 
504
/* In files.c */
505
typedef struct _cpp_file _cpp_file;
506
extern _cpp_file *_cpp_find_file (cpp_reader *, const char *, cpp_dir *,
507
                                  bool, int);
508
extern bool _cpp_find_failed (_cpp_file *);
509
extern void _cpp_mark_file_once_only (cpp_reader *, struct _cpp_file *);
510
extern void _cpp_fake_include (cpp_reader *, const char *);
511
extern bool _cpp_stack_file (cpp_reader *, _cpp_file*, bool);
512
extern bool _cpp_stack_include (cpp_reader *, const char *, int,
513
                                enum include_type);
514
extern int _cpp_compare_file_date (cpp_reader *, const char *, int);
515
extern void _cpp_report_missing_guards (cpp_reader *);
516
extern void _cpp_init_files (cpp_reader *);
517
extern void _cpp_cleanup_files (cpp_reader *);
518
extern void _cpp_pop_file_buffer (cpp_reader *, struct _cpp_file *);
519
extern bool _cpp_save_file_entries (cpp_reader *pfile, FILE *f);
520
extern bool _cpp_read_file_entries (cpp_reader *, FILE *);
521
 
522
/* In expr.c */
523
extern bool _cpp_parse_expr (cpp_reader *);
524
extern struct op *_cpp_expand_op_stack (cpp_reader *);
525
 
526
/* In lex.c */
527
extern void _cpp_process_line_notes (cpp_reader *, int);
528
extern void _cpp_clean_line (cpp_reader *);
529
extern bool _cpp_get_fresh_line (cpp_reader *);
530
extern bool _cpp_skip_block_comment (cpp_reader *);
531
extern cpp_token *_cpp_temp_token (cpp_reader *);
532
extern const cpp_token *_cpp_lex_token (cpp_reader *);
533
extern cpp_token *_cpp_lex_direct (cpp_reader *);
534
extern int _cpp_equiv_tokens (const cpp_token *, const cpp_token *);
535
extern void _cpp_init_tokenrun (tokenrun *, unsigned int);
536
 
537
/* In init.c.  */
538
extern void _cpp_maybe_push_include_file (cpp_reader *);
539
 
540
/* In directives.c */
541
extern int _cpp_test_assertion (cpp_reader *, unsigned int *);
542
extern int _cpp_handle_directive (cpp_reader *, int);
543
extern void _cpp_define_builtin (cpp_reader *, const char *);
544
extern char ** _cpp_save_pragma_names (cpp_reader *);
545
extern void _cpp_restore_pragma_names (cpp_reader *, char **);
546
extern void _cpp_do__Pragma (cpp_reader *);
547
extern void _cpp_init_directives (cpp_reader *);
548
extern void _cpp_init_internal_pragmas (cpp_reader *);
549
extern void _cpp_do_file_change (cpp_reader *, enum lc_reason, const char *,
550
                                 unsigned int, unsigned int);
551
extern void _cpp_pop_buffer (cpp_reader *);
552
 
553
/* In traditional.c.  */
554
extern bool _cpp_scan_out_logical_line (cpp_reader *, cpp_macro *);
555
extern bool _cpp_read_logical_line_trad (cpp_reader *);
556
extern void _cpp_overlay_buffer (cpp_reader *pfile, const unsigned char *,
557
                                 size_t);
558
extern void _cpp_remove_overlay (cpp_reader *);
559
extern bool _cpp_create_trad_definition (cpp_reader *, cpp_macro *);
560
extern bool _cpp_expansions_different_trad (const cpp_macro *,
561
                                            const cpp_macro *);
562
extern unsigned char *_cpp_copy_replacement_text (const cpp_macro *,
563
                                                  unsigned char *);
564
extern size_t _cpp_replacement_text_len (const cpp_macro *);
565
 
566
/* In charset.c.  */
567
 
568
/* The normalization state at this point in the sequence.
569
   It starts initialized to all zeros, and at the end
570
   'level' is the normalization level of the sequence.  */
571
 
572
struct normalize_state
573
{
574
  /* The previous character.  */
575
  cppchar_t previous;
576
  /* The combining class of the previous character.  */
577
  unsigned char prev_class;
578
  /* The lowest normalization level so far.  */
579
  enum cpp_normalize_level level;
580
};
581
#define INITIAL_NORMALIZE_STATE { 0, 0, normalized_KC }
582
#define NORMALIZE_STATE_RESULT(st) ((st)->level)
583
 
584
/* We saw a character that matches ISIDNUM(), update a
585
   normalize_state appropriately.  */
586
#define NORMALIZE_STATE_UPDATE_IDNUM(st) \
587
  ((st)->previous = 0, (st)->prev_class = 0)
588
 
589
extern cppchar_t _cpp_valid_ucn (cpp_reader *, const unsigned char **,
590
                                 const unsigned char *, int,
591
                                 struct normalize_state *state);
592
extern void _cpp_destroy_iconv (cpp_reader *);
593
extern unsigned char *_cpp_convert_input (cpp_reader *, const char *,
594
                                          unsigned char *, size_t, size_t,
595
                                          off_t *);
596
extern const char *_cpp_default_encoding (void);
597
extern cpp_hashnode * _cpp_interpret_identifier (cpp_reader *pfile,
598
                                                 const unsigned char *id,
599
                                                 size_t len);
600
 
601
/* Utility routines and macros.  */
602
#define DSC(str) (const unsigned char *)str, sizeof str - 1
603
 
604
/* These are inline functions instead of macros so we can get type
605
   checking.  */
606
static inline int ustrcmp (const unsigned char *, const unsigned char *);
607
static inline int ustrncmp (const unsigned char *, const unsigned char *,
608
                            size_t);
609
static inline size_t ustrlen (const unsigned char *);
610
static inline unsigned char *uxstrdup (const unsigned char *);
611
static inline unsigned char *ustrchr (const unsigned char *, int);
612
static inline int ufputs (const unsigned char *, FILE *);
613
 
614
/* Use a const char for the second parameter since it is usually a literal.  */
615
static inline int ustrcspn (const unsigned char *, const char *);
616
 
617
static inline int
618
ustrcmp (const unsigned char *s1, const unsigned char *s2)
619
{
620
  return strcmp ((const char *)s1, (const char *)s2);
621
}
622
 
623
static inline int
624
ustrncmp (const unsigned char *s1, const unsigned char *s2, size_t n)
625
{
626
  return strncmp ((const char *)s1, (const char *)s2, n);
627
}
628
 
629
static inline int
630
ustrcspn (const unsigned char *s1, const char *s2)
631
{
632
  return strcspn ((const char *)s1, s2);
633
}
634
 
635
static inline size_t
636
ustrlen (const unsigned char *s1)
637
{
638
  return strlen ((const char *)s1);
639
}
640
 
641
static inline unsigned char *
642
uxstrdup (const unsigned char *s1)
643
{
644
  return (unsigned char *) xstrdup ((const char *)s1);
645
}
646
 
647
static inline unsigned char *
648
ustrchr (const unsigned char *s1, int c)
649
{
650
  return (unsigned char *) strchr ((const char *)s1, c);
651
}
652
 
653
static inline int
654
ufputs (const unsigned char *s, FILE *f)
655
{
656
  return fputs ((const char *)s, f);
657
}
658
 
659
#endif /* ! LIBCPP_INTERNAL_H */

powered by: WebSVN 2.1.0

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