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