]>
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 | ||
88ae23e7 ZW |
75 | /* List of directories to look for include files in. */ |
76 | struct file_name_list | |
77 | { | |
78 | struct file_name_list *next; | |
79 | struct file_name_list *alloc; /* for the cache of | |
80 | current directory entries */ | |
81 | char *name; | |
82 | unsigned int nlen; | |
83 | /* We use these to tell if the directory mentioned here is a duplicate | |
84 | of an earlier directory on the search path. */ | |
85 | ino_t ino; | |
86 | dev_t dev; | |
87 | /* If the following is nonzero, it is a C-language system include | |
88 | directory. */ | |
89 | int sysp; | |
90 | /* Mapping of file names for this directory. | |
91 | Only used on MS-DOS and related platforms. */ | |
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 | ||
99 | typedef struct toklist toklist; | |
100 | struct toklist | |
101 | { | |
102 | cpp_token *first; | |
103 | cpp_token *limit; | |
104 | }; | |
105 | ||
106 | typedef struct cpp_context cpp_context; | |
107 | struct cpp_context | |
108 | { | |
109 | /* Doubly-linked list. */ | |
110 | cpp_context *next, *prev; | |
111 | ||
112 | /* Contexts other than the base context are contiguous tokens. | |
113 | e.g. macro expansions, expanded argument tokens. */ | |
114 | struct toklist list; | |
115 | ||
116 | /* For a macro context, these are the macro and its arguments. */ | |
117 | cpp_macro *macro; | |
118 | }; | |
119 | ||
120 | struct lexer_state | |
121 | { | |
122 | /* Nonzero if first token on line is CPP_HASH. */ | |
123 | unsigned char in_directive; | |
124 | ||
125 | /* Nonzero if in a directive that takes angle-bracketed headers. */ | |
126 | unsigned char angled_headers; | |
127 | ||
128 | /* Nonzero to save comments. Turned off if discard_comments, and in | |
129 | all directives apart from #define. */ | |
130 | unsigned char save_comments; | |
131 | ||
132 | /* If nonzero the next token is at the beginning of the line. */ | |
133 | unsigned char next_bol; | |
134 | ||
135 | /* Nonzero if we're mid-comment. */ | |
136 | unsigned char lexing_comment; | |
137 | ||
138 | /* Nonzero if lexing __VA_ARGS__ is valid. */ | |
139 | unsigned char va_args_ok; | |
140 | ||
141 | /* Nonzero if lexing poisoned identifiers is valid. */ | |
142 | unsigned char poisoned_ok; | |
143 | ||
144 | /* Nonzero to prevent macro expansion. */ | |
145 | unsigned char prevent_expansion; | |
146 | ||
147 | /* Nonzero when parsing arguments to a function-like macro. */ | |
148 | unsigned char parsing_args; | |
149 | ||
150 | /* Nonzero when in a # NUMBER directive. */ | |
151 | unsigned char line_extension; | |
152 | }; | |
153 | ||
154 | /* Special nodes - identifiers with predefined significance. */ | |
155 | struct spec_nodes | |
156 | { | |
157 | cpp_hashnode *n_L; /* L"str" */ | |
158 | cpp_hashnode *n_defined; /* defined operator */ | |
037313ae ZW |
159 | cpp_hashnode *n_true; /* C++ keyword true */ |
160 | cpp_hashnode *n_false; /* C++ keyword false */ | |
8121d2c3 NB |
161 | cpp_hashnode *n__Pragma; /* _Pragma operator */ |
162 | cpp_hashnode *n__STRICT_ANSI__; /* STDC_0_IN_SYSTEM_HEADERS */ | |
163 | cpp_hashnode *n__CHAR_UNSIGNED__; /* plain char is unsigned */ | |
164 | cpp_hashnode *n__VA_ARGS__; /* C99 vararg macros */ | |
165 | }; | |
166 | ||
27e2564a NB |
167 | struct cpp_buffer |
168 | { | |
169 | const unsigned char *cur; /* current position */ | |
170 | const unsigned char *rlimit; /* end of valid data */ | |
171 | const unsigned char *line_base; /* start of current line */ | |
172 | cppchar_t read_ahead; /* read ahead character */ | |
173 | cppchar_t extra_char; /* extra read-ahead for long tokens. */ | |
174 | ||
175 | struct cpp_reader *pfile; /* Owns this buffer. */ | |
176 | struct cpp_buffer *prev; | |
177 | ||
178 | const unsigned char *buf; /* entire buffer */ | |
179 | ||
180 | /* Filename specified with #line command. */ | |
181 | const char *nominal_fname; | |
182 | ||
183 | /* Actual directory of this file, used only for "" includes */ | |
184 | struct file_name_list *actual_dir; | |
185 | ||
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 | ||
228 | /* Buffer type. */ | |
229 | ENUM_BITFIELD (cpp_buffer_type) type : 8; | |
27e2564a NB |
230 | }; |
231 | ||
8121d2c3 NB |
232 | /* A cpp_reader encapsulates the "state" of a pre-processor run. |
233 | Applying cpp_get_token repeatedly yields a stream of pre-processor | |
234 | tokens. Usually, there is only one cpp_reader object active. */ | |
235 | ||
236 | struct cpp_reader | |
237 | { | |
238 | /* Top of buffer stack. */ | |
239 | cpp_buffer *buffer; | |
240 | ||
241 | /* Lexer state. */ | |
242 | struct lexer_state state; | |
243 | ||
244 | /* The position of the last lexed token and last lexed directive. */ | |
245 | cpp_lexer_pos lexer_pos; | |
246 | cpp_lexer_pos directive_pos; | |
247 | ||
248 | /* Memory pools. */ | |
249 | cpp_pool ident_pool; /* For all identifiers, and permanent | |
250 | numbers and strings. */ | |
251 | cpp_pool macro_pool; /* For macro definitions. Permanent. */ | |
252 | cpp_pool argument_pool; /* For macro arguments. Temporary. */ | |
253 | ||
254 | /* Context stack. */ | |
255 | struct cpp_context base_context; | |
256 | struct cpp_context *context; | |
257 | ||
258 | /* If in_directive, the directive if known. */ | |
259 | const struct directive *directive; | |
260 | ||
261 | /* Multiple inlcude optimisation. */ | |
262 | enum mi_state mi_state; | |
263 | enum mi_ind mi_if_not_defined; | |
264 | unsigned int mi_lexed; | |
265 | const cpp_hashnode *mi_cmacro; | |
266 | const cpp_hashnode *mi_ind_cmacro; | |
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 | ||
294 | /* Hash table of macros and assertions. See cpphash.c. */ | |
295 | struct htab *hashtab; | |
296 | ||
297 | /* Tree of other included files. See cppfiles.c. */ | |
298 | struct splay_tree_s *all_include_files; | |
299 | ||
300 | /* Chain of `actual directory' file_name_list entries, for "" | |
301 | inclusion. */ | |
302 | struct file_name_list *actual_dirs; | |
303 | ||
304 | /* Current maximum length of directory names in the search path | |
305 | for include files. (Altered as we get more of them.) */ | |
306 | unsigned int max_include_len; | |
307 | ||
308 | /* Date and time tokens. Calculated together if either is requested. */ | |
309 | cpp_token date; | |
310 | cpp_token time; | |
311 | ||
312 | /* Opaque handle to the dependencies of mkdeps.c. Used by -M etc. */ | |
313 | struct deps *deps; | |
314 | ||
315 | /* Obstack holding all macro hash nodes. This never shrinks. | |
316 | See cpphash.c */ | |
317 | struct obstack *hash_ob; | |
318 | ||
319 | /* Obstack holding buffer and conditional structures. This is a | |
320 | real stack. See cpplib.c */ | |
321 | struct obstack *buffer_ob; | |
322 | ||
323 | /* Pragma table - dynamic, because a library user can add to the | |
324 | list of recognized pragmas. */ | |
325 | struct pragma_entry *pragmas; | |
326 | ||
327 | /* Call backs. */ | |
328 | struct cpp_callbacks cb; | |
329 | ||
330 | /* User visible options. */ | |
331 | struct cpp_options opts; | |
332 | ||
333 | /* Special nodes - identifiers with predefined significance to the | |
334 | preprocessor. */ | |
335 | struct spec_nodes spec_nodes; | |
336 | ||
337 | /* We're printed a warning recommending against using #import. */ | |
338 | unsigned char import_warning; | |
339 | ||
340 | /* True after cpp_start_read completes. Used to inhibit some | |
341 | warnings while parsing the command line. */ | |
342 | unsigned char done_initializing; | |
343 | ||
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 | ||
88ae23e7 | 381 | #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)->prev) |
ae79697b | 382 | #define CPP_PRINT_DEPS(PFILE) CPP_OPTION (PFILE, print_deps) |
bfb9dc7f | 383 | #define CPP_IN_SYSTEM_HEADER(PFILE) \ |
642ce434 | 384 | (CPP_BUFFER (PFILE) && CPP_BUFFER (PFILE)->sysp) |
28e0f040 NB |
385 | #define CPP_PEDANTIC(PF) CPP_OPTION (PF, pedantic) |
386 | #define CPP_WTRADITIONAL(PF) CPP_OPTION (PF, warn_traditional) | |
88ae23e7 | 387 | |
711b8824 ZW |
388 | /* Hash step. The hash calculation is duplicated in cpp_lookup and |
389 | parse_name. */ | |
0d9f234d | 390 | #define HASHSTEP(r, c) ((r) * 67 + (c - 113)); |
711b8824 | 391 | |
58fea6af ZW |
392 | /* In cpperror.c */ |
393 | enum error_type { WARNING = 0, PEDWARN, ERROR, FATAL, ICE }; | |
394 | extern int _cpp_begin_message PARAMS ((cpp_reader *, enum error_type, | |
93c80368 | 395 | const char *, const cpp_lexer_pos *)); |
58fea6af | 396 | |
711b8824 | 397 | /* In cppmacro.c */ |
f8f769ea | 398 | extern void _cpp_free_definition PARAMS ((cpp_hashnode *)); |
041c3194 | 399 | extern int _cpp_create_definition PARAMS ((cpp_reader *, cpp_hashnode *)); |
93c80368 | 400 | extern void _cpp_pop_context PARAMS ((cpp_reader *)); |
93c80368 | 401 | extern void _cpp_free_lookaheads PARAMS ((cpp_reader *)); |
b528a07e | 402 | extern void _cpp_release_lookahead PARAMS ((cpp_reader *)); |
93c80368 NB |
403 | extern void _cpp_push_token PARAMS ((cpp_reader *, const cpp_token *, |
404 | const cpp_lexer_pos *)); | |
711b8824 ZW |
405 | |
406 | /* In cpphash.c */ | |
93c80368 NB |
407 | extern void _cpp_init_hashtable PARAMS ((cpp_reader *)); |
408 | extern void _cpp_cleanup_hashtable PARAMS ((cpp_reader *)); | |
409 | extern cpp_hashnode *_cpp_lookup_with_hash PARAMS ((cpp_reader*, size_t, | |
410 | unsigned int)); | |
bb52fa7f | 411 | |
88ae23e7 | 412 | /* In cppfiles.c */ |
d6d52dd6 | 413 | extern void _cpp_fake_include PARAMS ((cpp_reader *, const char *)); |
642ce434 | 414 | extern void _cpp_never_reread PARAMS ((struct include_file *)); |
88ae23e7 | 415 | extern void _cpp_simplify_pathname PARAMS ((char *)); |
614c7d37 | 416 | extern int _cpp_read_file PARAMS ((cpp_reader *, const char *)); |
93c80368 | 417 | extern void _cpp_execute_include PARAMS ((cpp_reader *, |
642ce434 | 418 | const cpp_token *, int, int)); |
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 |