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->c.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 } 1171