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