]>
Commit | Line | Data |
---|---|---|
88ae23e7 | 1 | /* Part of CPP library. |
d6d52dd6 | 2 | Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. |
4283012f JL |
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 2, 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; if not, write to the Free Software | |
42b17236 | 16 | Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
4283012f | 17 | |
88ae23e7 ZW |
18 | /* This header defines all the internal data structures and functions |
19 | that need to be visible across files. It's called cpphash.h for | |
20 | historical reasons. */ | |
21 | ||
bb52fa7f ZW |
22 | #ifndef __GCC_CPPHASH__ |
23 | #define __GCC_CPPHASH__ | |
24 | ||
8121d2c3 NB |
25 | struct directive; /* These are deliberately incomplete. */ |
26 | struct htab; | |
27 | ||
93c80368 NB |
28 | /* Test if a sign is valid within a preprocessing number. */ |
29 | #define VALID_SIGN(c, prevc) \ | |
30 | (((c) == '+' || (c) == '-') && \ | |
31 | ((prevc) == 'e' || (prevc) == 'E' \ | |
bdb05a7b NB |
32 | || (((prevc) == 'p' || (prevc) == 'P') \ |
33 | && CPP_OPTION (pfile, extended_numbers)))) | |
93c80368 | 34 | |
8121d2c3 NB |
35 | #define CPP_OPTION(PFILE, OPTION) ((PFILE)->opts.OPTION) |
36 | #define CPP_BUFFER(PFILE) ((PFILE)->buffer) | |
37 | #define CPP_BUF_LINE(BUF) ((BUF)->lineno) | |
38 | #define CPP_BUF_COLUMN(BUF, CUR) ((CUR) - (BUF)->line_base + (BUF)->col_adjust) | |
39 | #define CPP_BUF_COL(BUF) CPP_BUF_COLUMN(BUF, (BUF)->cur) | |
40 | ||
41 | /* Maximum nesting of cpp_buffers. We use a static limit, partly for | |
42 | efficiency, and partly to limit runaway recursion. */ | |
43 | #define CPP_STACK_MAX 200 | |
44 | ||
93c80368 | 45 | /* Memory pools. */ |
269592a8 | 46 | #define POOL_ALIGN(size, align) (((size) + ((align) - 1)) & ~((align) - 1)) |
93c80368 NB |
47 | #define POOL_FRONT(p) ((p)->cur->front) |
48 | #define POOL_LIMIT(p) ((p)->cur->limit) | |
49 | #define POOL_BASE(p) ((p)->cur->base) | |
50 | #define POOL_SIZE(p) ((p)->cur->limit - (p)->cur->base) | |
51 | #define POOL_ROOM(p) ((p)->cur->limit - (p)->cur->front) | |
52 | #define POOL_USED(p) ((p)->cur->front - (p)->cur->base) | |
269592a8 NB |
53 | #define POOL_COMMIT(p, len) do {\ |
54 | ((p)->cur->front += POOL_ALIGN (len, (p)->align));\ | |
93c80368 NB |
55 | if ((p)->cur->front > (p)->cur->limit) abort ();} while (0) |
56 | ||
57 | typedef struct cpp_chunk cpp_chunk; | |
58 | struct cpp_chunk | |
15dad1d9 | 59 | { |
93c80368 NB |
60 | cpp_chunk *next; |
61 | unsigned char *front; | |
62 | unsigned char *limit; | |
63 | unsigned char *base; | |
15dad1d9 ZW |
64 | }; |
65 | ||
8121d2c3 NB |
66 | typedef struct cpp_pool cpp_pool; |
67 | struct cpp_pool | |
68 | { | |
69 | struct cpp_chunk *cur, *locked; | |
70 | unsigned char *pos; /* Current position. */ | |
71 | unsigned int align; | |
72 | unsigned int locks; | |
73 | }; | |
74 | ||
591e15a1 NB |
75 | /* List of directories to look for include files in. */ |
76 | struct search_path | |
88ae23e7 | 77 | { |
591e15a1 NB |
78 | struct search_path *next; |
79 | ||
80 | /* NOTE: NAME may not be null terminated for the case of the current | |
81 | file's directory! */ | |
82 | const char *name; | |
83 | unsigned int len; | |
88ae23e7 | 84 | /* We use these to tell if the directory mentioned here is a duplicate |
591e15a1 | 85 | of an earlier directory on the search path. */ |
88ae23e7 ZW |
86 | ino_t ino; |
87 | dev_t dev; | |
591e15a1 | 88 | /* Non-zero if it is a system include directory. */ |
88ae23e7 | 89 | int sysp; |
591e15a1 NB |
90 | /* Mapping of file names for this directory. Only used on MS-DOS |
91 | and related platforms. */ | |
88ae23e7 ZW |
92 | struct file_name_map *name_map; |
93 | }; | |
bfb9dc7f | 94 | |
8121d2c3 NB |
95 | /* Multiple-include optimisation. */ |
96 | enum mi_state {MI_FAILED = 0, MI_OUTSIDE}; | |
97 | enum mi_ind {MI_IND_NONE = 0, MI_IND_NOT}; | |
98 | ||
ba133c96 NB |
99 | /* #include types. */ |
100 | enum include_type {IT_INCLUDE, IT_INCLUDE_NEXT, IT_IMPORT, IT_CMDLINE}; | |
101 | ||
8121d2c3 NB |
102 | typedef struct toklist toklist; |
103 | struct toklist | |
104 | { | |
105 | cpp_token *first; | |
106 | cpp_token *limit; | |
107 | }; | |
108 | ||
109 | typedef struct cpp_context cpp_context; | |
110 | struct cpp_context | |
111 | { | |
112 | /* Doubly-linked list. */ | |
113 | cpp_context *next, *prev; | |
114 | ||
115 | /* Contexts other than the base context are contiguous tokens. | |
116 | e.g. macro expansions, expanded argument tokens. */ | |
117 | struct toklist list; | |
118 | ||
119 | /* For a macro context, these are the macro and its arguments. */ | |
120 | cpp_macro *macro; | |
121 | }; | |
122 | ||
123 | struct lexer_state | |
124 | { | |
125 | /* Nonzero if first token on line is CPP_HASH. */ | |
126 | unsigned char in_directive; | |
127 | ||
128 | /* Nonzero if in a directive that takes angle-bracketed headers. */ | |
129 | unsigned char angled_headers; | |
130 | ||
131 | /* Nonzero to save comments. Turned off if discard_comments, and in | |
132 | all directives apart from #define. */ | |
133 | unsigned char save_comments; | |
134 | ||
135 | /* If nonzero the next token is at the beginning of the line. */ | |
136 | unsigned char next_bol; | |
137 | ||
138 | /* Nonzero if we're mid-comment. */ | |
139 | unsigned char lexing_comment; | |
140 | ||
141 | /* Nonzero if lexing __VA_ARGS__ is valid. */ | |
142 | unsigned char va_args_ok; | |
143 | ||
144 | /* Nonzero if lexing poisoned identifiers is valid. */ | |
145 | unsigned char poisoned_ok; | |
146 | ||
147 | /* Nonzero to prevent macro expansion. */ | |
148 | unsigned char prevent_expansion; | |
149 | ||
150 | /* Nonzero when parsing arguments to a function-like macro. */ | |
151 | unsigned char parsing_args; | |
152 | ||
153 | /* Nonzero when in a # NUMBER directive. */ | |
154 | unsigned char line_extension; | |
155 | }; | |
156 | ||
157 | /* Special nodes - identifiers with predefined significance. */ | |
158 | struct spec_nodes | |
159 | { | |
160 | cpp_hashnode *n_L; /* L"str" */ | |
161 | cpp_hashnode *n_defined; /* defined operator */ | |
037313ae ZW |
162 | cpp_hashnode *n_true; /* C++ keyword true */ |
163 | cpp_hashnode *n_false; /* C++ keyword false */ | |
8121d2c3 NB |
164 | cpp_hashnode *n__Pragma; /* _Pragma operator */ |
165 | cpp_hashnode *n__STRICT_ANSI__; /* STDC_0_IN_SYSTEM_HEADERS */ | |
166 | cpp_hashnode *n__CHAR_UNSIGNED__; /* plain char is unsigned */ | |
167 | cpp_hashnode *n__VA_ARGS__; /* C99 vararg macros */ | |
168 | }; | |
169 | ||
27e2564a NB |
170 | struct cpp_buffer |
171 | { | |
172 | const unsigned char *cur; /* current position */ | |
173 | const unsigned char *rlimit; /* end of valid data */ | |
174 | const unsigned char *line_base; /* start of current line */ | |
175 | cppchar_t read_ahead; /* read ahead character */ | |
176 | cppchar_t extra_char; /* extra read-ahead for long tokens. */ | |
177 | ||
178 | struct cpp_reader *pfile; /* Owns this buffer. */ | |
179 | struct cpp_buffer *prev; | |
180 | ||
181 | const unsigned char *buf; /* entire buffer */ | |
182 | ||
183 | /* Filename specified with #line command. */ | |
184 | const char *nominal_fname; | |
185 | ||
27e2564a NB |
186 | /* Pointer into the include table. Used for include_next and |
187 | to record control macros. */ | |
188 | struct include_file *inc; | |
189 | ||
190 | /* Value of if_stack at start of this file. | |
191 | Used to prohibit unmatched #endif (etc) in an include file. */ | |
192 | struct if_stack *if_stack; | |
193 | ||
194 | /* Token column position adjustment owing to tabs in whitespace. */ | |
195 | unsigned int col_adjust; | |
196 | ||
197 | /* Line number at line_base (above). */ | |
198 | unsigned int lineno; | |
199 | ||
bd969772 NB |
200 | /* Contains PREV_WHITE and/or AVOID_LPASTE. */ |
201 | unsigned char saved_flags; | |
202 | ||
27e2564a NB |
203 | /* Because of the way the lexer works, -Wtrigraphs can sometimes |
204 | warn twice for the same trigraph. This helps prevent that. */ | |
205 | const unsigned char *last_Wtrigraphs; | |
206 | ||
207 | /* True if we have already warned about C++ comments in this file. | |
208 | The warning happens only for C89 extended mode with -pedantic on, | |
209 | or for -Wtraditional, and only once per file (otherwise it would | |
210 | be far too noisy). */ | |
211 | unsigned char warned_cplusplus_comments; | |
212 | ||
213 | /* True if we don't process trigraphs and escaped newlines. True | |
214 | for preprocessed input, command line directives, and _Pragma | |
215 | buffers. */ | |
216 | unsigned char from_stage3; | |
217 | ||
218 | /* Temporary storage for pfile->skipping whilst in a directive. */ | |
219 | unsigned char was_skipping; | |
642ce434 NB |
220 | |
221 | /* 1 = system header file, 2 = C system header file used for C++. */ | |
222 | unsigned char sysp; | |
0bda4760 NB |
223 | |
224 | /* Nonzero means we have printed (while error reporting) a list of | |
225 | containing files that matches the current status. */ | |
226 | unsigned char include_stack_listed; | |
227 | ||
ba133c96 NB |
228 | /* Nonzero means that the directory to start searching for "" |
229 | include files has been calculated and stored in "dir" below. */ | |
230 | unsigned char search_cached; | |
231 | ||
0bda4760 NB |
232 | /* Buffer type. */ |
233 | ENUM_BITFIELD (cpp_buffer_type) type : 8; | |
591e15a1 NB |
234 | |
235 | /* The directory of the this buffer's file. Its NAME member is not | |
236 | allocated, so we don't need to worry about freeing it. */ | |
237 | struct search_path dir; | |
27e2564a NB |
238 | }; |
239 | ||
8121d2c3 NB |
240 | /* A cpp_reader encapsulates the "state" of a pre-processor run. |
241 | Applying cpp_get_token repeatedly yields a stream of pre-processor | |
242 | tokens. Usually, there is only one cpp_reader object active. */ | |
243 | ||
244 | struct cpp_reader | |
245 | { | |
246 | /* Top of buffer stack. */ | |
247 | cpp_buffer *buffer; | |
248 | ||
249 | /* Lexer state. */ | |
250 | struct lexer_state state; | |
251 | ||
252 | /* The position of the last lexed token and last lexed directive. */ | |
253 | cpp_lexer_pos lexer_pos; | |
254 | cpp_lexer_pos directive_pos; | |
255 | ||
256 | /* Memory pools. */ | |
257 | cpp_pool ident_pool; /* For all identifiers, and permanent | |
258 | numbers and strings. */ | |
259 | cpp_pool macro_pool; /* For macro definitions. Permanent. */ | |
260 | cpp_pool argument_pool; /* For macro arguments. Temporary. */ | |
261 | ||
262 | /* Context stack. */ | |
263 | struct cpp_context base_context; | |
264 | struct cpp_context *context; | |
265 | ||
266 | /* If in_directive, the directive if known. */ | |
267 | const struct directive *directive; | |
268 | ||
269 | /* Multiple inlcude optimisation. */ | |
270 | enum mi_state mi_state; | |
271 | enum mi_ind mi_if_not_defined; | |
272 | unsigned int mi_lexed; | |
273 | const cpp_hashnode *mi_cmacro; | |
274 | const cpp_hashnode *mi_ind_cmacro; | |
275 | ||
276 | /* Token lookahead. */ | |
277 | struct cpp_lookahead *la_read; /* Read from this lookahead. */ | |
278 | struct cpp_lookahead *la_write; /* Write to this lookahead. */ | |
279 | struct cpp_lookahead *la_unused; /* Free store. */ | |
280 | struct cpp_lookahead *la_saved; /* Backup when entering directive. */ | |
281 | ||
282 | /* Error counter for exit code. */ | |
283 | unsigned int errors; | |
284 | ||
285 | /* Line and column where a newline was first seen in a string | |
286 | constant (multi-line strings). */ | |
287 | cpp_lexer_pos mlstring_pos; | |
288 | ||
289 | /* Buffer to hold macro definition string. */ | |
290 | unsigned char *macro_buffer; | |
291 | unsigned int macro_buffer_len; | |
292 | ||
293 | /* Current depth in #include directives that use <...>. */ | |
294 | unsigned int system_include_depth; | |
295 | ||
296 | /* Current depth of buffer stack. */ | |
297 | unsigned int buffer_stack_depth; | |
298 | ||
299 | /* Current depth in #include directives. */ | |
300 | unsigned int include_depth; | |
301 | ||
302 | /* Hash table of macros and assertions. See cpphash.c. */ | |
303 | struct htab *hashtab; | |
304 | ||
305 | /* Tree of other included files. See cppfiles.c. */ | |
306 | struct splay_tree_s *all_include_files; | |
307 | ||
8121d2c3 NB |
308 | /* Current maximum length of directory names in the search path |
309 | for include files. (Altered as we get more of them.) */ | |
310 | unsigned int max_include_len; | |
311 | ||
312 | /* Date and time tokens. Calculated together if either is requested. */ | |
313 | cpp_token date; | |
314 | cpp_token time; | |
315 | ||
316 | /* Opaque handle to the dependencies of mkdeps.c. Used by -M etc. */ | |
317 | struct deps *deps; | |
318 | ||
319 | /* Obstack holding all macro hash nodes. This never shrinks. | |
320 | See cpphash.c */ | |
321 | struct obstack *hash_ob; | |
322 | ||
323 | /* Obstack holding buffer and conditional structures. This is a | |
324 | real stack. See cpplib.c */ | |
325 | struct obstack *buffer_ob; | |
326 | ||
327 | /* Pragma table - dynamic, because a library user can add to the | |
328 | list of recognized pragmas. */ | |
329 | struct pragma_entry *pragmas; | |
330 | ||
331 | /* Call backs. */ | |
332 | struct cpp_callbacks cb; | |
333 | ||
334 | /* User visible options. */ | |
335 | struct cpp_options opts; | |
336 | ||
337 | /* Special nodes - identifiers with predefined significance to the | |
338 | preprocessor. */ | |
339 | struct spec_nodes spec_nodes; | |
340 | ||
341 | /* We're printed a warning recommending against using #import. */ | |
342 | unsigned char import_warning; | |
343 | ||
8121d2c3 NB |
344 | /* True if we are skipping a failed conditional group. */ |
345 | unsigned char skipping; | |
cb773845 ZW |
346 | |
347 | /* Whether to print our version number. Done this way so | |
348 | we don't get it twice for -v -version. */ | |
349 | unsigned char print_version; | |
8121d2c3 NB |
350 | }; |
351 | ||
f6bbde28 | 352 | /* Character classes. Based on the more primitive macros in safe-ctype.h. |
88ae23e7 | 353 | If the definition of `numchar' looks odd to you, please look up the |
91fcd158 NB |
354 | definition of a pp-number in the C standard [section 6.4.8 of C99]. |
355 | ||
356 | In the unlikely event that characters other than \r and \n enter | |
357 | the set is_vspace, the macro handle_newline() in cpplex.c must be | |
358 | updated. */ | |
ae79697b | 359 | #define _dollar_ok(x) ((x) == '$' && CPP_OPTION (pfile, dollars_in_ident)) |
88ae23e7 | 360 | |
f6bbde28 ZW |
361 | #define is_idchar(x) (ISIDNUM(x) || _dollar_ok(x)) |
362 | #define is_numchar(x) ISIDNUM(x) | |
363 | #define is_idstart(x) (ISIDST(x) || _dollar_ok(x)) | |
364 | #define is_numstart(x) ISDIGIT(x) | |
365 | #define is_hspace(x) ISBLANK(x) | |
366 | #define is_vspace(x) IS_VSPACE(x) | |
367 | #define is_nvspace(x) IS_NVSPACE(x) | |
368 | #define is_space(x) IS_SPACE_OR_NUL(x) | |
88ae23e7 | 369 | |
f6bbde28 | 370 | /* This table is constant if it can be initialized at compile time, |
88ae23e7 ZW |
371 | which is the case if cpp was compiled with GCC >=2.7, or another |
372 | compiler that supports C99. */ | |
61d0346d | 373 | #if HAVE_DESIGNATED_INITIALIZERS |
61d0346d | 374 | extern const unsigned char _cpp_trigraph_map[UCHAR_MAX + 1]; |
88ae23e7 | 375 | #else |
61d0346d | 376 | extern unsigned char _cpp_trigraph_map[UCHAR_MAX + 1]; |
88ae23e7 ZW |
377 | #endif |
378 | ||
379 | /* Macros. */ | |
380 | ||
ae79697b | 381 | #define CPP_PRINT_DEPS(PFILE) CPP_OPTION (PFILE, print_deps) |
bfb9dc7f | 382 | #define CPP_IN_SYSTEM_HEADER(PFILE) \ |
642ce434 | 383 | (CPP_BUFFER (PFILE) && CPP_BUFFER (PFILE)->sysp) |
28e0f040 NB |
384 | #define CPP_PEDANTIC(PF) CPP_OPTION (PF, pedantic) |
385 | #define CPP_WTRADITIONAL(PF) CPP_OPTION (PF, warn_traditional) | |
88ae23e7 | 386 | |
711b8824 ZW |
387 | /* Hash step. The hash calculation is duplicated in cpp_lookup and |
388 | parse_name. */ | |
0d9f234d | 389 | #define HASHSTEP(r, c) ((r) * 67 + (c - 113)); |
711b8824 | 390 | |
58fea6af | 391 | /* In cpperror.c */ |
2f878973 | 392 | enum error_type { WARNING = 0, WARNING_SYSHDR, PEDWARN, ERROR, FATAL, ICE }; |
58fea6af | 393 | extern int _cpp_begin_message PARAMS ((cpp_reader *, enum error_type, |
93c80368 | 394 | const char *, const cpp_lexer_pos *)); |
58fea6af | 395 | |
711b8824 | 396 | /* In cppmacro.c */ |
f8f769ea | 397 | extern void _cpp_free_definition PARAMS ((cpp_hashnode *)); |
041c3194 | 398 | extern int _cpp_create_definition PARAMS ((cpp_reader *, cpp_hashnode *)); |
93c80368 | 399 | extern void _cpp_pop_context PARAMS ((cpp_reader *)); |
93c80368 | 400 | extern void _cpp_free_lookaheads PARAMS ((cpp_reader *)); |
b528a07e | 401 | extern void _cpp_release_lookahead PARAMS ((cpp_reader *)); |
93c80368 NB |
402 | extern void _cpp_push_token PARAMS ((cpp_reader *, const cpp_token *, |
403 | const cpp_lexer_pos *)); | |
711b8824 ZW |
404 | |
405 | /* In cpphash.c */ | |
93c80368 NB |
406 | extern void _cpp_init_hashtable PARAMS ((cpp_reader *)); |
407 | extern void _cpp_cleanup_hashtable PARAMS ((cpp_reader *)); | |
408 | extern cpp_hashnode *_cpp_lookup_with_hash PARAMS ((cpp_reader*, size_t, | |
409 | unsigned int)); | |
bb52fa7f | 410 | |
88ae23e7 | 411 | /* In cppfiles.c */ |
d6d52dd6 | 412 | extern void _cpp_fake_include PARAMS ((cpp_reader *, const char *)); |
642ce434 | 413 | extern void _cpp_never_reread PARAMS ((struct include_file *)); |
e7182666 | 414 | extern char *_cpp_simplify_pathname PARAMS ((char *)); |
614c7d37 | 415 | extern int _cpp_read_file PARAMS ((cpp_reader *, const char *)); |
ba133c96 NB |
416 | extern int _cpp_execute_include PARAMS ((cpp_reader *, |
417 | const cpp_token *, | |
418 | enum include_type)); | |
93c80368 NB |
419 | extern int _cpp_compare_file_date PARAMS ((cpp_reader *, |
420 | const cpp_token *)); | |
c71f835b ZW |
421 | extern void _cpp_report_missing_guards PARAMS ((cpp_reader *)); |
422 | extern void _cpp_init_includes PARAMS ((cpp_reader *)); | |
423 | extern void _cpp_cleanup_includes PARAMS ((cpp_reader *)); | |
f9a0e96c | 424 | extern void _cpp_pop_file_buffer PARAMS ((cpp_reader *, cpp_buffer *)); |
88ae23e7 ZW |
425 | |
426 | /* In cppexp.c */ | |
427 | extern int _cpp_parse_expr PARAMS ((cpp_reader *)); | |
428 | ||
45b966db | 429 | /* In cpplex.c */ |
93c80368 | 430 | extern void _cpp_lex_token PARAMS ((cpp_reader *, cpp_token *)); |
15dad1d9 ZW |
431 | extern int _cpp_equiv_tokens PARAMS ((const cpp_token *, |
432 | const cpp_token *)); | |
93c80368 NB |
433 | extern void _cpp_init_pool PARAMS ((cpp_pool *, unsigned int, |
434 | unsigned int, unsigned int)); | |
435 | extern void _cpp_free_pool PARAMS ((cpp_pool *)); | |
436 | extern unsigned char *_cpp_pool_reserve PARAMS ((cpp_pool *, unsigned int)); | |
437 | extern unsigned char *_cpp_pool_alloc PARAMS ((cpp_pool *, unsigned int)); | |
438 | extern unsigned char *_cpp_next_chunk PARAMS ((cpp_pool *, unsigned int, | |
439 | unsigned char **)); | |
440 | extern void _cpp_lock_pool PARAMS ((cpp_pool *)); | |
441 | extern void _cpp_unlock_pool PARAMS ((cpp_pool *)); | |
45b966db ZW |
442 | |
443 | /* In cpplib.c */ | |
93c80368 NB |
444 | extern int _cpp_test_assertion PARAMS ((cpp_reader *, int *)); |
445 | extern int _cpp_handle_directive PARAMS ((cpp_reader *, int)); | |
446 | extern void _cpp_define_builtin PARAMS ((cpp_reader *, const char *)); | |
a5c3cccd | 447 | extern void _cpp_do__Pragma PARAMS ((cpp_reader *)); |
c71f835b ZW |
448 | extern void _cpp_init_stacks PARAMS ((cpp_reader *)); |
449 | extern void _cpp_cleanup_stacks PARAMS ((cpp_reader *)); | |
58fea6af | 450 | extern void _cpp_init_internal_pragmas PARAMS ((cpp_reader *)); |
eb1f4d9d NB |
451 | extern void _cpp_do_file_change PARAMS ((cpp_reader *, enum cpp_fc_reason, |
452 | const char *, unsigned int)); | |
12cf91fe | 453 | |
c31a6508 | 454 | /* Utility routines and macros. */ |
93c80368 | 455 | #define DSC(str) (const U_CHAR *)str, sizeof str - 1 |
c31a6508 | 456 | #define xnew(T) (T *) xmalloc (sizeof(T)) |
a58d32c2 | 457 | #define xcnew(T) (T *) xcalloc (1, sizeof(T)) |
c31a6508 | 458 | #define xnewvec(T, N) (T *) xmalloc (sizeof(T) * (N)) |
711b8824 | 459 | #define xcnewvec(T, N) (T *) xcalloc (N, sizeof(T)) |
c71f835b | 460 | #define xobnew(O, T) (T *) obstack_alloc (O, sizeof(T)) |
c31a6508 | 461 | |
8121d2c3 NB |
462 | /* These are inline functions instead of macros so we can get type |
463 | checking. */ | |
464 | typedef unsigned char U_CHAR; | |
465 | #define U (const U_CHAR *) /* Intended use: U"string" */ | |
466 | ||
467 | static inline int ustrcmp PARAMS ((const U_CHAR *, const U_CHAR *)); | |
468 | static inline int ustrncmp PARAMS ((const U_CHAR *, const U_CHAR *, | |
469 | size_t)); | |
470 | static inline size_t ustrlen PARAMS ((const U_CHAR *)); | |
471 | static inline U_CHAR *uxstrdup PARAMS ((const U_CHAR *)); | |
472 | static inline U_CHAR *ustrchr PARAMS ((const U_CHAR *, int)); | |
473 | static inline int ufputs PARAMS ((const U_CHAR *, FILE *)); | |
474 | ||
475 | static inline int | |
476 | ustrcmp (s1, s2) | |
477 | const U_CHAR *s1, *s2; | |
478 | { | |
479 | return strcmp ((const char *)s1, (const char *)s2); | |
480 | } | |
481 | ||
482 | static inline int | |
483 | ustrncmp (s1, s2, n) | |
484 | const U_CHAR *s1, *s2; | |
485 | size_t n; | |
486 | { | |
487 | return strncmp ((const char *)s1, (const char *)s2, n); | |
488 | } | |
489 | ||
490 | static inline size_t | |
491 | ustrlen (s1) | |
492 | const U_CHAR *s1; | |
493 | { | |
494 | return strlen ((const char *)s1); | |
495 | } | |
496 | ||
497 | static inline U_CHAR * | |
498 | uxstrdup (s1) | |
499 | const U_CHAR *s1; | |
500 | { | |
501 | return (U_CHAR *) xstrdup ((const char *)s1); | |
502 | } | |
503 | ||
504 | static inline U_CHAR * | |
505 | ustrchr (s1, c) | |
506 | const U_CHAR *s1; | |
507 | int c; | |
508 | { | |
509 | return (U_CHAR *) strchr ((const char *)s1, c); | |
510 | } | |
511 | ||
512 | static inline int | |
513 | ufputs (s, f) | |
514 | const U_CHAR *s; | |
515 | FILE *f; | |
516 | { | |
517 | return fputs ((const char *)s, f); | |
518 | } | |
519 | ||
bb52fa7f | 520 | #endif |