Mercurial > hg > CbC > CbC_gcc
comparison libcpp/traditional.c @ 0:a06113de4d67
first commit
author | kent <kent@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 17 Jul 2009 14:47:48 +0900 |
parents | |
children | 04ced10e8804 |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a06113de4d67 |
---|---|
1 /* CPP Library - traditional lexical analysis and macro expansion. | |
2 Copyright (C) 2002, 2004, 2005, 2007, 2008, 2009 | |
3 Free Software Foundation, Inc. | |
4 Contributed by Neil Booth, May 2002 | |
5 | |
6 This program is free software; you can redistribute it and/or modify it | |
7 under the terms of the GNU General Public License as published by the | |
8 Free Software Foundation; either version 3, or (at your option) any | |
9 later version. | |
10 | |
11 This program is distributed in the hope that it will be useful, | |
12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 GNU General Public License for more details. | |
15 | |
16 You should have received a copy of the GNU General Public License | |
17 along with this program; see the file COPYING3. If not see | |
18 <http://www.gnu.org/licenses/>. */ | |
19 | |
20 #include "config.h" | |
21 #include "system.h" | |
22 #include "cpplib.h" | |
23 #include "internal.h" | |
24 | |
25 /* The replacement text of a function-like macro is stored as a | |
26 contiguous sequence of aligned blocks, each representing the text | |
27 between subsequent parameters. | |
28 | |
29 Each block comprises the text between its surrounding parameters, | |
30 the length of that text, and the one-based index of the following | |
31 parameter. The final block in the replacement text is easily | |
32 recognizable as it has an argument index of zero. */ | |
33 | |
34 struct block | |
35 { | |
36 unsigned int text_len; | |
37 unsigned short arg_index; | |
38 uchar text[1]; | |
39 }; | |
40 | |
41 #define BLOCK_HEADER_LEN offsetof (struct block, text) | |
42 #define BLOCK_LEN(TEXT_LEN) CPP_ALIGN (BLOCK_HEADER_LEN + (TEXT_LEN)) | |
43 | |
44 /* Structure holding information about a function-like macro | |
45 invocation. */ | |
46 struct fun_macro | |
47 { | |
48 /* Memory buffer holding the trad_arg array. */ | |
49 _cpp_buff *buff; | |
50 | |
51 /* An array of size the number of macro parameters + 1, containing | |
52 the offsets of the start of each macro argument in the output | |
53 buffer. The argument continues until the character before the | |
54 start of the next one. */ | |
55 size_t *args; | |
56 | |
57 /* The hashnode of the macro. */ | |
58 cpp_hashnode *node; | |
59 | |
60 /* The offset of the macro name in the output buffer. */ | |
61 size_t offset; | |
62 | |
63 /* The line the macro name appeared on. */ | |
64 source_location line; | |
65 | |
66 /* Zero-based index of argument being currently lexed. */ | |
67 unsigned int argc; | |
68 }; | |
69 | |
70 /* Lexing state. It is mostly used to prevent macro expansion. */ | |
71 enum ls {ls_none = 0, /* Normal state. */ | |
72 ls_fun_open, /* When looking for '('. */ | |
73 ls_fun_close, /* When looking for ')'. */ | |
74 ls_defined, /* After defined. */ | |
75 ls_defined_close, /* Looking for ')' of defined(). */ | |
76 ls_hash, /* After # in preprocessor conditional. */ | |
77 ls_predicate, /* After the predicate, maybe paren? */ | |
78 ls_answer}; /* In answer to predicate. */ | |
79 | |
80 /* Lexing TODO: Maybe handle space in escaped newlines. Stop lex.c | |
81 from recognizing comments and directives during its lexing pass. */ | |
82 | |
83 static const uchar *skip_whitespace (cpp_reader *, const uchar *, int); | |
84 static cpp_hashnode *lex_identifier (cpp_reader *, const uchar *); | |
85 static const uchar *copy_comment (cpp_reader *, const uchar *, int); | |
86 static void check_output_buffer (cpp_reader *, size_t); | |
87 static void push_replacement_text (cpp_reader *, cpp_hashnode *); | |
88 static bool scan_parameters (cpp_reader *, cpp_macro *); | |
89 static bool recursive_macro (cpp_reader *, cpp_hashnode *); | |
90 static void save_replacement_text (cpp_reader *, cpp_macro *, unsigned int); | |
91 static void maybe_start_funlike (cpp_reader *, cpp_hashnode *, const uchar *, | |
92 struct fun_macro *); | |
93 static void save_argument (struct fun_macro *, size_t); | |
94 static void replace_args_and_push (cpp_reader *, struct fun_macro *); | |
95 static size_t canonicalize_text (uchar *, const uchar *, size_t, uchar *); | |
96 | |
97 /* Ensures we have N bytes' space in the output buffer, and | |
98 reallocates it if not. */ | |
99 static void | |
100 check_output_buffer (cpp_reader *pfile, size_t n) | |
101 { | |
102 /* We might need two bytes to terminate an unterminated comment, and | |
103 one more to terminate the line with a NUL. */ | |
104 n += 2 + 1; | |
105 | |
106 if (n > (size_t) (pfile->out.limit - pfile->out.cur)) | |
107 { | |
108 size_t size = pfile->out.cur - pfile->out.base; | |
109 size_t new_size = (size + n) * 3 / 2; | |
110 | |
111 pfile->out.base = XRESIZEVEC (unsigned char, pfile->out.base, new_size); | |
112 pfile->out.limit = pfile->out.base + new_size; | |
113 pfile->out.cur = pfile->out.base + size; | |
114 } | |
115 } | |
116 | |
117 /* Skip a C-style block comment in a macro as a result of -CC. | |
118 Buffer->cur points to the initial asterisk of the comment. */ | |
119 static void | |
120 skip_macro_block_comment (cpp_reader *pfile) | |
121 { | |
122 const uchar *cur = pfile->buffer->cur; | |
123 | |
124 cur++; | |
125 if (*cur == '/') | |
126 cur++; | |
127 | |
128 /* People like decorating comments with '*', so check for '/' | |
129 instead for efficiency. */ | |
130 while(! (*cur++ == '/' && cur[-2] == '*') ) | |
131 ; | |
132 | |
133 pfile->buffer->cur = cur; | |
134 } | |
135 | |
136 /* CUR points to the asterisk introducing a comment in the current | |
137 context. IN_DEFINE is true if we are in the replacement text of a | |
138 macro. | |
139 | |
140 The asterisk and following comment is copied to the buffer pointed | |
141 to by pfile->out.cur, which must be of sufficient size. | |
142 Unterminated comments are diagnosed, and correctly terminated in | |
143 the output. pfile->out.cur is updated depending upon IN_DEFINE, | |
144 -C, -CC and pfile->state.in_directive. | |
145 | |
146 Returns a pointer to the first character after the comment in the | |
147 input buffer. */ | |
148 static const uchar * | |
149 copy_comment (cpp_reader *pfile, const uchar *cur, int in_define) | |
150 { | |
151 bool unterminated, copy = false; | |
152 source_location src_loc = pfile->line_table->highest_line; | |
153 cpp_buffer *buffer = pfile->buffer; | |
154 | |
155 buffer->cur = cur; | |
156 if (pfile->context->prev) | |
157 unterminated = false, skip_macro_block_comment (pfile); | |
158 else | |
159 unterminated = _cpp_skip_block_comment (pfile); | |
160 | |
161 if (unterminated) | |
162 cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0, | |
163 "unterminated comment"); | |
164 | |
165 /* Comments in directives become spaces so that tokens are properly | |
166 separated when the ISO preprocessor re-lexes the line. The | |
167 exception is #define. */ | |
168 if (pfile->state.in_directive) | |
169 { | |
170 if (in_define) | |
171 { | |
172 if (CPP_OPTION (pfile, discard_comments_in_macro_exp)) | |
173 pfile->out.cur--; | |
174 else | |
175 copy = true; | |
176 } | |
177 else | |
178 pfile->out.cur[-1] = ' '; | |
179 } | |
180 else if (CPP_OPTION (pfile, discard_comments)) | |
181 pfile->out.cur--; | |
182 else | |
183 copy = true; | |
184 | |
185 if (copy) | |
186 { | |
187 size_t len = (size_t) (buffer->cur - cur); | |
188 memcpy (pfile->out.cur, cur, len); | |
189 pfile->out.cur += len; | |
190 if (unterminated) | |
191 { | |
192 *pfile->out.cur++ = '*'; | |
193 *pfile->out.cur++ = '/'; | |
194 } | |
195 } | |
196 | |
197 return buffer->cur; | |
198 } | |
199 | |
200 /* CUR points to any character in the input buffer. Skips over all | |
201 contiguous horizontal white space and NULs, including comments if | |
202 SKIP_COMMENTS, until reaching the first non-horizontal-whitespace | |
203 character or the end of the current context. Escaped newlines are | |
204 removed. | |
205 | |
206 The whitespace is copied verbatim to the output buffer, except that | |
207 comments are handled as described in copy_comment(). | |
208 pfile->out.cur is updated. | |
209 | |
210 Returns a pointer to the first character after the whitespace in | |
211 the input buffer. */ | |
212 static const uchar * | |
213 skip_whitespace (cpp_reader *pfile, const uchar *cur, int skip_comments) | |
214 { | |
215 uchar *out = pfile->out.cur; | |
216 | |
217 for (;;) | |
218 { | |
219 unsigned int c = *cur++; | |
220 *out++ = c; | |
221 | |
222 if (is_nvspace (c)) | |
223 continue; | |
224 | |
225 if (c == '/' && *cur == '*' && skip_comments) | |
226 { | |
227 pfile->out.cur = out; | |
228 cur = copy_comment (pfile, cur, false /* in_define */); | |
229 out = pfile->out.cur; | |
230 continue; | |
231 } | |
232 | |
233 out--; | |
234 break; | |
235 } | |
236 | |
237 pfile->out.cur = out; | |
238 return cur - 1; | |
239 } | |
240 | |
241 /* Lexes and outputs an identifier starting at CUR, which is assumed | |
242 to point to a valid first character of an identifier. Returns | |
243 the hashnode, and updates out.cur. */ | |
244 static cpp_hashnode * | |
245 lex_identifier (cpp_reader *pfile, const uchar *cur) | |
246 { | |
247 size_t len; | |
248 uchar *out = pfile->out.cur; | |
249 cpp_hashnode *result; | |
250 | |
251 do | |
252 *out++ = *cur++; | |
253 while (is_numchar (*cur)); | |
254 | |
255 CUR (pfile->context) = cur; | |
256 len = out - pfile->out.cur; | |
257 result = CPP_HASHNODE (ht_lookup (pfile->hash_table, pfile->out.cur, | |
258 len, HT_ALLOC)); | |
259 pfile->out.cur = out; | |
260 return result; | |
261 } | |
262 | |
263 /* Overlays the true file buffer temporarily with text of length LEN | |
264 starting at START. The true buffer is restored upon calling | |
265 restore_buff(). */ | |
266 void | |
267 _cpp_overlay_buffer (cpp_reader *pfile, const uchar *start, size_t len) | |
268 { | |
269 cpp_buffer *buffer = pfile->buffer; | |
270 | |
271 pfile->overlaid_buffer = buffer; | |
272 pfile->saved_cur = buffer->cur; | |
273 pfile->saved_rlimit = buffer->rlimit; | |
274 pfile->saved_line_base = buffer->next_line; | |
275 buffer->need_line = false; | |
276 | |
277 buffer->cur = start; | |
278 buffer->line_base = start; | |
279 buffer->rlimit = start + len; | |
280 } | |
281 | |
282 /* Restores a buffer overlaid by _cpp_overlay_buffer(). */ | |
283 void | |
284 _cpp_remove_overlay (cpp_reader *pfile) | |
285 { | |
286 cpp_buffer *buffer = pfile->overlaid_buffer; | |
287 | |
288 buffer->cur = pfile->saved_cur; | |
289 buffer->rlimit = pfile->saved_rlimit; | |
290 buffer->line_base = pfile->saved_line_base; | |
291 buffer->need_line = true; | |
292 | |
293 pfile->overlaid_buffer = NULL; | |
294 } | |
295 | |
296 /* Reads a logical line into the output buffer. Returns TRUE if there | |
297 is more text left in the buffer. */ | |
298 bool | |
299 _cpp_read_logical_line_trad (cpp_reader *pfile) | |
300 { | |
301 do | |
302 { | |
303 if (pfile->buffer->need_line && !_cpp_get_fresh_line (pfile)) | |
304 return false; | |
305 } | |
306 while (!_cpp_scan_out_logical_line (pfile, NULL) || pfile->state.skipping); | |
307 | |
308 return pfile->buffer != NULL; | |
309 } | |
310 | |
311 /* Set up state for finding the opening '(' of a function-like | |
312 macro. */ | |
313 static void | |
314 maybe_start_funlike (cpp_reader *pfile, cpp_hashnode *node, const uchar *start, struct fun_macro *macro) | |
315 { | |
316 unsigned int n = node->value.macro->paramc + 1; | |
317 | |
318 if (macro->buff) | |
319 _cpp_release_buff (pfile, macro->buff); | |
320 macro->buff = _cpp_get_buff (pfile, n * sizeof (size_t)); | |
321 macro->args = (size_t *) BUFF_FRONT (macro->buff); | |
322 macro->node = node; | |
323 macro->offset = start - pfile->out.base; | |
324 macro->argc = 0; | |
325 } | |
326 | |
327 /* Save the OFFSET of the start of the next argument to MACRO. */ | |
328 static void | |
329 save_argument (struct fun_macro *macro, size_t offset) | |
330 { | |
331 macro->argc++; | |
332 if (macro->argc <= macro->node->value.macro->paramc) | |
333 macro->args[macro->argc] = offset; | |
334 } | |
335 | |
336 /* Copies the next logical line in the current buffer (starting at | |
337 buffer->cur) to the output buffer. The output is guaranteed to | |
338 terminate with a NUL character. buffer->cur is updated. | |
339 | |
340 If MACRO is non-NULL, then we are scanning the replacement list of | |
341 MACRO, and we call save_replacement_text() every time we meet an | |
342 argument. */ | |
343 bool | |
344 _cpp_scan_out_logical_line (cpp_reader *pfile, cpp_macro *macro) | |
345 { | |
346 bool result = true; | |
347 cpp_context *context; | |
348 const uchar *cur; | |
349 uchar *out; | |
350 struct fun_macro fmacro; | |
351 unsigned int c, paren_depth = 0, quote; | |
352 enum ls lex_state = ls_none; | |
353 bool header_ok; | |
354 const uchar *start_of_input_line; | |
355 | |
356 fmacro.buff = NULL; | |
357 fmacro.args = NULL; | |
358 fmacro.node = NULL; | |
359 fmacro.offset = 0; | |
360 fmacro.line = 0; | |
361 fmacro.argc = 0; | |
362 | |
363 quote = 0; | |
364 header_ok = pfile->state.angled_headers; | |
365 CUR (pfile->context) = pfile->buffer->cur; | |
366 RLIMIT (pfile->context) = pfile->buffer->rlimit; | |
367 pfile->out.cur = pfile->out.base; | |
368 pfile->out.first_line = pfile->line_table->highest_line; | |
369 /* start_of_input_line is needed to make sure that directives really, | |
370 really start at the first character of the line. */ | |
371 start_of_input_line = pfile->buffer->cur; | |
372 new_context: | |
373 context = pfile->context; | |
374 cur = CUR (context); | |
375 check_output_buffer (pfile, RLIMIT (context) - cur); | |
376 out = pfile->out.cur; | |
377 | |
378 for (;;) | |
379 { | |
380 if (!context->prev | |
381 && cur >= pfile->buffer->notes[pfile->buffer->cur_note].pos) | |
382 { | |
383 pfile->buffer->cur = cur; | |
384 _cpp_process_line_notes (pfile, false); | |
385 } | |
386 c = *cur++; | |
387 *out++ = c; | |
388 | |
389 /* Whitespace should "continue" out of the switch, | |
390 non-whitespace should "break" out of it. */ | |
391 switch (c) | |
392 { | |
393 case ' ': | |
394 case '\t': | |
395 case '\f': | |
396 case '\v': | |
397 case '\0': | |
398 continue; | |
399 | |
400 case '\n': | |
401 /* If this is a macro's expansion, pop it. */ | |
402 if (context->prev) | |
403 { | |
404 pfile->out.cur = out - 1; | |
405 _cpp_pop_context (pfile); | |
406 goto new_context; | |
407 } | |
408 | |
409 /* Omit the newline from the output buffer. */ | |
410 pfile->out.cur = out - 1; | |
411 pfile->buffer->cur = cur; | |
412 pfile->buffer->need_line = true; | |
413 CPP_INCREMENT_LINE (pfile, 0); | |
414 | |
415 if ((lex_state == ls_fun_open || lex_state == ls_fun_close) | |
416 && !pfile->state.in_directive | |
417 && _cpp_get_fresh_line (pfile)) | |
418 { | |
419 /* Newlines in arguments become a space, but we don't | |
420 clear any in-progress quote. */ | |
421 if (lex_state == ls_fun_close) | |
422 out[-1] = ' '; | |
423 cur = pfile->buffer->cur; | |
424 continue; | |
425 } | |
426 goto done; | |
427 | |
428 case '<': | |
429 if (header_ok) | |
430 quote = '>'; | |
431 break; | |
432 case '>': | |
433 if (c == quote) | |
434 quote = 0; | |
435 break; | |
436 | |
437 case '"': | |
438 case '\'': | |
439 if (c == quote) | |
440 quote = 0; | |
441 else if (!quote) | |
442 quote = c; | |
443 break; | |
444 | |
445 case '\\': | |
446 /* Skip escaped quotes here, it's easier than above. */ | |
447 if (*cur == '\\' || *cur == '"' || *cur == '\'') | |
448 *out++ = *cur++; | |
449 break; | |
450 | |
451 case '/': | |
452 /* Traditional CPP does not recognize comments within | |
453 literals. */ | |
454 if (!quote && *cur == '*') | |
455 { | |
456 pfile->out.cur = out; | |
457 cur = copy_comment (pfile, cur, macro != 0); | |
458 out = pfile->out.cur; | |
459 continue; | |
460 } | |
461 break; | |
462 | |
463 case '_': | |
464 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': | |
465 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': | |
466 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': | |
467 case 's': case 't': case 'u': case 'v': case 'w': case 'x': | |
468 case 'y': case 'z': | |
469 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': | |
470 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': | |
471 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': | |
472 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': | |
473 case 'Y': case 'Z': | |
474 if (!pfile->state.skipping && (quote == 0 || macro)) | |
475 { | |
476 cpp_hashnode *node; | |
477 uchar *out_start = out - 1; | |
478 | |
479 pfile->out.cur = out_start; | |
480 node = lex_identifier (pfile, cur - 1); | |
481 out = pfile->out.cur; | |
482 cur = CUR (context); | |
483 | |
484 if (node->type == NT_MACRO | |
485 /* Should we expand for ls_answer? */ | |
486 && (lex_state == ls_none || lex_state == ls_fun_open) | |
487 && !pfile->state.prevent_expansion) | |
488 { | |
489 /* Macros invalidate MI optimization. */ | |
490 pfile->mi_valid = false; | |
491 if (! (node->flags & NODE_BUILTIN) | |
492 && node->value.macro->fun_like) | |
493 { | |
494 maybe_start_funlike (pfile, node, out_start, &fmacro); | |
495 lex_state = ls_fun_open; | |
496 fmacro.line = pfile->line_table->highest_line; | |
497 continue; | |
498 } | |
499 else if (!recursive_macro (pfile, node)) | |
500 { | |
501 /* Remove the object-like macro's name from the | |
502 output, and push its replacement text. */ | |
503 pfile->out.cur = out_start; | |
504 push_replacement_text (pfile, node); | |
505 lex_state = ls_none; | |
506 goto new_context; | |
507 } | |
508 } | |
509 else if (macro && (node->flags & NODE_MACRO_ARG) != 0) | |
510 { | |
511 /* Found a parameter in the replacement text of a | |
512 #define. Remove its name from the output. */ | |
513 pfile->out.cur = out_start; | |
514 save_replacement_text (pfile, macro, node->value.arg_index); | |
515 out = pfile->out.base; | |
516 } | |
517 else if (lex_state == ls_hash) | |
518 { | |
519 lex_state = ls_predicate; | |
520 continue; | |
521 } | |
522 else if (pfile->state.in_expression | |
523 && node == pfile->spec_nodes.n_defined) | |
524 { | |
525 lex_state = ls_defined; | |
526 continue; | |
527 } | |
528 } | |
529 break; | |
530 | |
531 case '(': | |
532 if (quote == 0) | |
533 { | |
534 paren_depth++; | |
535 if (lex_state == ls_fun_open) | |
536 { | |
537 if (recursive_macro (pfile, fmacro.node)) | |
538 lex_state = ls_none; | |
539 else | |
540 { | |
541 lex_state = ls_fun_close; | |
542 paren_depth = 1; | |
543 out = pfile->out.base + fmacro.offset; | |
544 fmacro.args[0] = fmacro.offset; | |
545 } | |
546 } | |
547 else if (lex_state == ls_predicate) | |
548 lex_state = ls_answer; | |
549 else if (lex_state == ls_defined) | |
550 lex_state = ls_defined_close; | |
551 } | |
552 break; | |
553 | |
554 case ',': | |
555 if (quote == 0 && lex_state == ls_fun_close && paren_depth == 1) | |
556 save_argument (&fmacro, out - pfile->out.base); | |
557 break; | |
558 | |
559 case ')': | |
560 if (quote == 0) | |
561 { | |
562 paren_depth--; | |
563 if (lex_state == ls_fun_close && paren_depth == 0) | |
564 { | |
565 cpp_macro *m = fmacro.node->value.macro; | |
566 | |
567 m->used = 1; | |
568 lex_state = ls_none; | |
569 save_argument (&fmacro, out - pfile->out.base); | |
570 | |
571 /* A single zero-length argument is no argument. */ | |
572 if (fmacro.argc == 1 | |
573 && m->paramc == 0 | |
574 && out == pfile->out.base + fmacro.offset + 1) | |
575 fmacro.argc = 0; | |
576 | |
577 if (_cpp_arguments_ok (pfile, m, fmacro.node, fmacro.argc)) | |
578 { | |
579 /* Remove the macro's invocation from the | |
580 output, and push its replacement text. */ | |
581 pfile->out.cur = (pfile->out.base | |
582 + fmacro.offset); | |
583 CUR (context) = cur; | |
584 replace_args_and_push (pfile, &fmacro); | |
585 goto new_context; | |
586 } | |
587 } | |
588 else if (lex_state == ls_answer || lex_state == ls_defined_close) | |
589 lex_state = ls_none; | |
590 } | |
591 break; | |
592 | |
593 case '#': | |
594 if (cur - 1 == start_of_input_line | |
595 /* A '#' from a macro doesn't start a directive. */ | |
596 && !pfile->context->prev | |
597 && !pfile->state.in_directive) | |
598 { | |
599 /* A directive. With the way _cpp_handle_directive | |
600 currently works, we only want to call it if either we | |
601 know the directive is OK, or we want it to fail and | |
602 be removed from the output. If we want it to be | |
603 passed through (the assembler case) then we must not | |
604 call _cpp_handle_directive. */ | |
605 pfile->out.cur = out; | |
606 cur = skip_whitespace (pfile, cur, true /* skip_comments */); | |
607 out = pfile->out.cur; | |
608 | |
609 if (*cur == '\n') | |
610 { | |
611 /* Null directive. Ignore it and don't invalidate | |
612 the MI optimization. */ | |
613 pfile->buffer->need_line = true; | |
614 CPP_INCREMENT_LINE (pfile, 0); | |
615 result = false; | |
616 goto done; | |
617 } | |
618 else | |
619 { | |
620 bool do_it = false; | |
621 | |
622 if (is_numstart (*cur) | |
623 && CPP_OPTION (pfile, lang) != CLK_ASM) | |
624 do_it = true; | |
625 else if (is_idstart (*cur)) | |
626 /* Check whether we know this directive, but don't | |
627 advance. */ | |
628 do_it = lex_identifier (pfile, cur)->is_directive; | |
629 | |
630 if (do_it || CPP_OPTION (pfile, lang) != CLK_ASM) | |
631 { | |
632 /* This is a kludge. We want to have the ISO | |
633 preprocessor lex the next token. */ | |
634 pfile->buffer->cur = cur; | |
635 _cpp_handle_directive (pfile, false /* indented */); | |
636 result = false; | |
637 goto done; | |
638 } | |
639 } | |
640 } | |
641 | |
642 if (pfile->state.in_expression) | |
643 { | |
644 lex_state = ls_hash; | |
645 continue; | |
646 } | |
647 break; | |
648 | |
649 default: | |
650 break; | |
651 } | |
652 | |
653 /* Non-whitespace disables MI optimization and stops treating | |
654 '<' as a quote in #include. */ | |
655 header_ok = false; | |
656 if (!pfile->state.in_directive) | |
657 pfile->mi_valid = false; | |
658 | |
659 if (lex_state == ls_none) | |
660 continue; | |
661 | |
662 /* Some of these transitions of state are syntax errors. The | |
663 ISO preprocessor will issue errors later. */ | |
664 if (lex_state == ls_fun_open) | |
665 /* Missing '('. */ | |
666 lex_state = ls_none; | |
667 else if (lex_state == ls_hash | |
668 || lex_state == ls_predicate | |
669 || lex_state == ls_defined) | |
670 lex_state = ls_none; | |
671 | |
672 /* ls_answer and ls_defined_close keep going until ')'. */ | |
673 } | |
674 | |
675 done: | |
676 if (fmacro.buff) | |
677 _cpp_release_buff (pfile, fmacro.buff); | |
678 | |
679 if (lex_state == ls_fun_close) | |
680 cpp_error_with_line (pfile, CPP_DL_ERROR, fmacro.line, 0, | |
681 "unterminated argument list invoking macro \"%s\"", | |
682 NODE_NAME (fmacro.node)); | |
683 return result; | |
684 } | |
685 | |
686 /* Push a context holding the replacement text of the macro NODE on | |
687 the context stack. NODE is either object-like, or a function-like | |
688 macro with no arguments. */ | |
689 static void | |
690 push_replacement_text (cpp_reader *pfile, cpp_hashnode *node) | |
691 { | |
692 size_t len; | |
693 const uchar *text; | |
694 uchar *buf; | |
695 | |
696 if (node->flags & NODE_BUILTIN) | |
697 { | |
698 text = _cpp_builtin_macro_text (pfile, node); | |
699 len = ustrlen (text); | |
700 buf = _cpp_unaligned_alloc (pfile, len + 1); | |
701 memcpy (buf, text, len); | |
702 buf[len]='\n'; | |
703 text = buf; | |
704 } | |
705 else | |
706 { | |
707 cpp_macro *macro = node->value.macro; | |
708 macro->used = 1; | |
709 text = macro->exp.text; | |
710 macro->traditional = 1; | |
711 len = macro->count; | |
712 } | |
713 | |
714 _cpp_push_text_context (pfile, node, text, len); | |
715 } | |
716 | |
717 /* Returns TRUE if traditional macro recursion is detected. */ | |
718 static bool | |
719 recursive_macro (cpp_reader *pfile, cpp_hashnode *node) | |
720 { | |
721 bool recursing = !!(node->flags & NODE_DISABLED); | |
722 | |
723 /* Object-like macros that are already expanding are necessarily | |
724 recursive. | |
725 | |
726 However, it is possible to have traditional function-like macros | |
727 that are not infinitely recursive but recurse to any given depth. | |
728 Further, it is easy to construct examples that get ever longer | |
729 until the point they stop recursing. So there is no easy way to | |
730 detect true recursion; instead we assume any expansion more than | |
731 20 deep since the first invocation of this macro must be | |
732 recursing. */ | |
733 if (recursing && node->value.macro->fun_like) | |
734 { | |
735 size_t depth = 0; | |
736 cpp_context *context = pfile->context; | |
737 | |
738 do | |
739 { | |
740 depth++; | |
741 if (context->macro == node && depth > 20) | |
742 break; | |
743 context = context->prev; | |
744 } | |
745 while (context); | |
746 recursing = context != NULL; | |
747 } | |
748 | |
749 if (recursing) | |
750 cpp_error (pfile, CPP_DL_ERROR, | |
751 "detected recursion whilst expanding macro \"%s\"", | |
752 NODE_NAME (node)); | |
753 | |
754 return recursing; | |
755 } | |
756 | |
757 /* Return the length of the replacement text of a function-like or | |
758 object-like non-builtin macro. */ | |
759 size_t | |
760 _cpp_replacement_text_len (const cpp_macro *macro) | |
761 { | |
762 size_t len; | |
763 | |
764 if (macro->fun_like && (macro->paramc != 0)) | |
765 { | |
766 const uchar *exp; | |
767 | |
768 len = 0; | |
769 for (exp = macro->exp.text;;) | |
770 { | |
771 struct block *b = (struct block *) exp; | |
772 | |
773 len += b->text_len; | |
774 if (b->arg_index == 0) | |
775 break; | |
776 len += NODE_LEN (macro->params[b->arg_index - 1]); | |
777 exp += BLOCK_LEN (b->text_len); | |
778 } | |
779 } | |
780 else | |
781 len = macro->count; | |
782 | |
783 return len; | |
784 } | |
785 | |
786 /* Copy the replacement text of MACRO to DEST, which must be of | |
787 sufficient size. It is not NUL-terminated. The next character is | |
788 returned. */ | |
789 uchar * | |
790 _cpp_copy_replacement_text (const cpp_macro *macro, uchar *dest) | |
791 { | |
792 if (macro->fun_like && (macro->paramc != 0)) | |
793 { | |
794 const uchar *exp; | |
795 | |
796 for (exp = macro->exp.text;;) | |
797 { | |
798 struct block *b = (struct block *) exp; | |
799 cpp_hashnode *param; | |
800 | |
801 memcpy (dest, b->text, b->text_len); | |
802 dest += b->text_len; | |
803 if (b->arg_index == 0) | |
804 break; | |
805 param = macro->params[b->arg_index - 1]; | |
806 memcpy (dest, NODE_NAME (param), NODE_LEN (param)); | |
807 dest += NODE_LEN (param); | |
808 exp += BLOCK_LEN (b->text_len); | |
809 } | |
810 } | |
811 else | |
812 { | |
813 memcpy (dest, macro->exp.text, macro->count); | |
814 dest += macro->count; | |
815 } | |
816 | |
817 return dest; | |
818 } | |
819 | |
820 /* Push a context holding the replacement text of the macro NODE on | |
821 the context stack. NODE is either object-like, or a function-like | |
822 macro with no arguments. */ | |
823 static void | |
824 replace_args_and_push (cpp_reader *pfile, struct fun_macro *fmacro) | |
825 { | |
826 cpp_macro *macro = fmacro->node->value.macro; | |
827 | |
828 if (macro->paramc == 0) | |
829 push_replacement_text (pfile, fmacro->node); | |
830 else | |
831 { | |
832 const uchar *exp; | |
833 uchar *p; | |
834 _cpp_buff *buff; | |
835 size_t len = 0; | |
836 int cxtquote = 0; | |
837 | |
838 /* Get an estimate of the length of the argument-replaced text. | |
839 This is a worst case estimate, assuming that every replacement | |
840 text character needs quoting. */ | |
841 for (exp = macro->exp.text;;) | |
842 { | |
843 struct block *b = (struct block *) exp; | |
844 | |
845 len += b->text_len; | |
846 if (b->arg_index == 0) | |
847 break; | |
848 len += 2 * (fmacro->args[b->arg_index] | |
849 - fmacro->args[b->arg_index - 1] - 1); | |
850 exp += BLOCK_LEN (b->text_len); | |
851 } | |
852 | |
853 /* Allocate room for the expansion plus \n. */ | |
854 buff = _cpp_get_buff (pfile, len + 1); | |
855 | |
856 /* Copy the expansion and replace arguments. */ | |
857 /* Accumulate actual length, including quoting as necessary */ | |
858 p = BUFF_FRONT (buff); | |
859 len = 0; | |
860 for (exp = macro->exp.text;;) | |
861 { | |
862 struct block *b = (struct block *) exp; | |
863 size_t arglen; | |
864 int argquote; | |
865 uchar *base; | |
866 uchar *in; | |
867 | |
868 len += b->text_len; | |
869 /* Copy the non-argument text literally, keeping | |
870 track of whether matching quotes have been seen. */ | |
871 for (arglen = b->text_len, in = b->text; arglen > 0; arglen--) | |
872 { | |
873 if (*in == '"') | |
874 cxtquote = ! cxtquote; | |
875 *p++ = *in++; | |
876 } | |
877 /* Done if no more arguments */ | |
878 if (b->arg_index == 0) | |
879 break; | |
880 arglen = (fmacro->args[b->arg_index] | |
881 - fmacro->args[b->arg_index - 1] - 1); | |
882 base = pfile->out.base + fmacro->args[b->arg_index - 1]; | |
883 in = base; | |
884 #if 0 | |
885 /* Skip leading whitespace in the text for the argument to | |
886 be substituted. To be compatible with gcc 2.95, we would | |
887 also need to trim trailing whitespace. Gcc 2.95 trims | |
888 leading and trailing whitespace, which may be a bug. The | |
889 current gcc testsuite explicitly checks that this leading | |
890 and trailing whitespace in actual arguments is | |
891 preserved. */ | |
892 while (arglen > 0 && is_space (*in)) | |
893 { | |
894 in++; | |
895 arglen--; | |
896 } | |
897 #endif | |
898 for (argquote = 0; arglen > 0; arglen--) | |
899 { | |
900 if (cxtquote && *in == '"') | |
901 { | |
902 if (in > base && *(in-1) != '\\') | |
903 argquote = ! argquote; | |
904 /* Always add backslash before double quote if argument | |
905 is expanded in a quoted context */ | |
906 *p++ = '\\'; | |
907 len++; | |
908 } | |
909 else if (cxtquote && argquote && *in == '\\') | |
910 { | |
911 /* Always add backslash before a backslash in an argument | |
912 that is expanded in a quoted context and also in the | |
913 range of a quoted context in the argument itself. */ | |
914 *p++ = '\\'; | |
915 len++; | |
916 } | |
917 *p++ = *in++; | |
918 len++; | |
919 } | |
920 exp += BLOCK_LEN (b->text_len); | |
921 } | |
922 | |
923 /* \n-terminate. */ | |
924 *p = '\n'; | |
925 _cpp_push_text_context (pfile, fmacro->node, BUFF_FRONT (buff), len); | |
926 | |
927 /* So we free buffer allocation when macro is left. */ | |
928 pfile->context->buff = buff; | |
929 } | |
930 } | |
931 | |
932 /* Read and record the parameters, if any, of a function-like macro | |
933 definition. Destroys pfile->out.cur. | |
934 | |
935 Returns true on success, false on failure (syntax error or a | |
936 duplicate parameter). On success, CUR (pfile->context) is just | |
937 past the closing parenthesis. */ | |
938 static bool | |
939 scan_parameters (cpp_reader *pfile, cpp_macro *macro) | |
940 { | |
941 const uchar *cur = CUR (pfile->context) + 1; | |
942 bool ok; | |
943 | |
944 for (;;) | |
945 { | |
946 cur = skip_whitespace (pfile, cur, true /* skip_comments */); | |
947 | |
948 if (is_idstart (*cur)) | |
949 { | |
950 ok = false; | |
951 if (_cpp_save_parameter (pfile, macro, lex_identifier (pfile, cur))) | |
952 break; | |
953 cur = skip_whitespace (pfile, CUR (pfile->context), | |
954 true /* skip_comments */); | |
955 if (*cur == ',') | |
956 { | |
957 cur++; | |
958 continue; | |
959 } | |
960 ok = (*cur == ')'); | |
961 break; | |
962 } | |
963 | |
964 ok = (*cur == ')' && macro->paramc == 0); | |
965 break; | |
966 } | |
967 | |
968 if (!ok) | |
969 cpp_error (pfile, CPP_DL_ERROR, "syntax error in macro parameter list"); | |
970 | |
971 CUR (pfile->context) = cur + (*cur == ')'); | |
972 | |
973 return ok; | |
974 } | |
975 | |
976 /* Save the text from pfile->out.base to pfile->out.cur as | |
977 the replacement text for the current macro, followed by argument | |
978 ARG_INDEX, with zero indicating the end of the replacement | |
979 text. */ | |
980 static void | |
981 save_replacement_text (cpp_reader *pfile, cpp_macro *macro, | |
982 unsigned int arg_index) | |
983 { | |
984 size_t len = pfile->out.cur - pfile->out.base; | |
985 uchar *exp; | |
986 | |
987 if (macro->paramc == 0) | |
988 { | |
989 /* Object-like and function-like macros without parameters | |
990 simply store their \n-terminated replacement text. */ | |
991 exp = _cpp_unaligned_alloc (pfile, len + 1); | |
992 memcpy (exp, pfile->out.base, len); | |
993 exp[len] = '\n'; | |
994 macro->exp.text = exp; | |
995 macro->traditional = 1; | |
996 macro->count = len; | |
997 } | |
998 else | |
999 { | |
1000 /* Store the text's length (unsigned int), the argument index | |
1001 (unsigned short, base 1) and then the text. */ | |
1002 size_t blen = BLOCK_LEN (len); | |
1003 struct block *block; | |
1004 | |
1005 if (macro->count + blen > BUFF_ROOM (pfile->a_buff)) | |
1006 _cpp_extend_buff (pfile, &pfile->a_buff, macro->count + blen); | |
1007 | |
1008 exp = BUFF_FRONT (pfile->a_buff); | |
1009 block = (struct block *) (exp + macro->count); | |
1010 macro->exp.text = exp; | |
1011 macro->traditional = 1; | |
1012 | |
1013 /* Write out the block information. */ | |
1014 block->text_len = len; | |
1015 block->arg_index = arg_index; | |
1016 memcpy (block->text, pfile->out.base, len); | |
1017 | |
1018 /* Lex the rest into the start of the output buffer. */ | |
1019 pfile->out.cur = pfile->out.base; | |
1020 | |
1021 macro->count += blen; | |
1022 | |
1023 /* If we've finished, commit the memory. */ | |
1024 if (arg_index == 0) | |
1025 BUFF_FRONT (pfile->a_buff) += macro->count; | |
1026 } | |
1027 } | |
1028 | |
1029 /* Analyze and save the replacement text of a macro. Returns true on | |
1030 success. */ | |
1031 bool | |
1032 _cpp_create_trad_definition (cpp_reader *pfile, cpp_macro *macro) | |
1033 { | |
1034 const uchar *cur; | |
1035 uchar *limit; | |
1036 cpp_context *context = pfile->context; | |
1037 | |
1038 /* The context has not been set up for command line defines, and CUR | |
1039 has not been updated for the macro name for in-file defines. */ | |
1040 pfile->out.cur = pfile->out.base; | |
1041 CUR (context) = pfile->buffer->cur; | |
1042 RLIMIT (context) = pfile->buffer->rlimit; | |
1043 check_output_buffer (pfile, RLIMIT (context) - CUR (context)); | |
1044 | |
1045 /* Is this a function-like macro? */ | |
1046 if (* CUR (context) == '(') | |
1047 { | |
1048 bool ok = scan_parameters (pfile, macro); | |
1049 | |
1050 /* Remember the params so we can clear NODE_MACRO_ARG flags. */ | |
1051 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff); | |
1052 | |
1053 /* Setting macro to NULL indicates an error occurred, and | |
1054 prevents unnecessary work in _cpp_scan_out_logical_line. */ | |
1055 if (!ok) | |
1056 macro = NULL; | |
1057 else | |
1058 { | |
1059 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc]; | |
1060 macro->fun_like = 1; | |
1061 } | |
1062 } | |
1063 | |
1064 /* Skip leading whitespace in the replacement text. */ | |
1065 pfile->buffer->cur | |
1066 = skip_whitespace (pfile, CUR (context), | |
1067 CPP_OPTION (pfile, discard_comments_in_macro_exp)); | |
1068 | |
1069 pfile->state.prevent_expansion++; | |
1070 _cpp_scan_out_logical_line (pfile, macro); | |
1071 pfile->state.prevent_expansion--; | |
1072 | |
1073 if (!macro) | |
1074 return false; | |
1075 | |
1076 /* Skip trailing white space. */ | |
1077 cur = pfile->out.base; | |
1078 limit = pfile->out.cur; | |
1079 while (limit > cur && is_space (limit[-1])) | |
1080 limit--; | |
1081 pfile->out.cur = limit; | |
1082 save_replacement_text (pfile, macro, 0); | |
1083 | |
1084 return true; | |
1085 } | |
1086 | |
1087 /* Copy SRC of length LEN to DEST, but convert all contiguous | |
1088 whitespace to a single space, provided it is not in quotes. The | |
1089 quote currently in effect is pointed to by PQUOTE, and is updated | |
1090 by the function. Returns the number of bytes copied. */ | |
1091 static size_t | |
1092 canonicalize_text (uchar *dest, const uchar *src, size_t len, uchar *pquote) | |
1093 { | |
1094 uchar *orig_dest = dest; | |
1095 uchar quote = *pquote; | |
1096 | |
1097 while (len) | |
1098 { | |
1099 if (is_space (*src) && !quote) | |
1100 { | |
1101 do | |
1102 src++, len--; | |
1103 while (len && is_space (*src)); | |
1104 *dest++ = ' '; | |
1105 } | |
1106 else | |
1107 { | |
1108 if (*src == '\'' || *src == '"') | |
1109 { | |
1110 if (!quote) | |
1111 quote = *src; | |
1112 else if (quote == *src) | |
1113 quote = 0; | |
1114 } | |
1115 *dest++ = *src++, len--; | |
1116 } | |
1117 } | |
1118 | |
1119 *pquote = quote; | |
1120 return dest - orig_dest; | |
1121 } | |
1122 | |
1123 /* Returns true if MACRO1 and MACRO2 have expansions different other | |
1124 than in the form of their whitespace. */ | |
1125 bool | |
1126 _cpp_expansions_different_trad (const cpp_macro *macro1, | |
1127 const cpp_macro *macro2) | |
1128 { | |
1129 uchar *p1 = XNEWVEC (uchar, macro1->count + macro2->count); | |
1130 uchar *p2 = p1 + macro1->count; | |
1131 uchar quote1 = 0, quote2 = 0; | |
1132 bool mismatch; | |
1133 size_t len1, len2; | |
1134 | |
1135 if (macro1->paramc > 0) | |
1136 { | |
1137 const uchar *exp1 = macro1->exp.text, *exp2 = macro2->exp.text; | |
1138 | |
1139 mismatch = true; | |
1140 for (;;) | |
1141 { | |
1142 struct block *b1 = (struct block *) exp1; | |
1143 struct block *b2 = (struct block *) exp2; | |
1144 | |
1145 if (b1->arg_index != b2->arg_index) | |
1146 break; | |
1147 | |
1148 len1 = canonicalize_text (p1, b1->text, b1->text_len, "e1); | |
1149 len2 = canonicalize_text (p2, b2->text, b2->text_len, "e2); | |
1150 if (len1 != len2 || memcmp (p1, p2, len1)) | |
1151 break; | |
1152 if (b1->arg_index == 0) | |
1153 { | |
1154 mismatch = false; | |
1155 break; | |
1156 } | |
1157 exp1 += BLOCK_LEN (b1->text_len); | |
1158 exp2 += BLOCK_LEN (b2->text_len); | |
1159 } | |
1160 } | |
1161 else | |
1162 { | |
1163 len1 = canonicalize_text (p1, macro1->exp.text, macro1->count, "e1); | |
1164 len2 = canonicalize_text (p2, macro2->exp.text, macro2->count, "e2); | |
1165 mismatch = (len1 != len2 || memcmp (p1, p2, len1)); | |
1166 } | |
1167 | |
1168 free (p1); | |
1169 return mismatch; | |
1170 } |