Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / macroexp.c
CommitLineData
5796c8dc 1/* C preprocessor macro expansion for GDB.
ef5ccd6c 2 Copyright (C) 2002-2013 Free Software Foundation, Inc.
5796c8dc
SS
3 Contributed by Red Hat, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "gdb_obstack.h"
22#include "bcache.h"
23#include "macrotab.h"
24#include "macroexp.h"
25#include "gdb_assert.h"
26#include "c-lang.h"
27
28
29\f
30/* A resizeable, substringable string type. */
31
32
33/* A string type that we can resize, quickly append to, and use to
34 refer to substrings of other strings. */
35struct macro_buffer
36{
37 /* An array of characters. The first LEN bytes are the real text,
38 but there are SIZE bytes allocated to the array. If SIZE is
39 zero, then this doesn't point to a malloc'ed block. If SHARED is
40 non-zero, then this buffer is actually a pointer into some larger
41 string, and we shouldn't append characters to it, etc. Because
42 of sharing, we can't assume in general that the text is
43 null-terminated. */
44 char *text;
45
46 /* The number of characters in the string. */
47 int len;
48
49 /* The number of characters allocated to the string. If SHARED is
50 non-zero, this is meaningless; in this case, we set it to zero so
51 that any "do we have room to append something?" tests will fail,
52 so we don't always have to check SHARED before using this field. */
53 int size;
54
55 /* Zero if TEXT can be safely realloc'ed (i.e., it's its own malloc
56 block). Non-zero if TEXT is actually pointing into the middle of
57 some other block, and we shouldn't reallocate it. */
58 int shared;
59
60 /* For detecting token splicing.
61
62 This is the index in TEXT of the first character of the token
63 that abuts the end of TEXT. If TEXT contains no tokens, then we
64 set this equal to LEN. If TEXT ends in whitespace, then there is
65 no token abutting the end of TEXT (it's just whitespace), and
66 again, we set this equal to LEN. We set this to -1 if we don't
67 know the nature of TEXT. */
68 int last_token;
69
70 /* If this buffer is holding the result from get_token, then this
71 is non-zero if it is an identifier token, zero otherwise. */
72 int is_identifier;
73};
74
75
76/* Set the macro buffer *B to the empty string, guessing that its
77 final contents will fit in N bytes. (It'll get resized if it
78 doesn't, so the guess doesn't have to be right.) Allocate the
79 initial storage with xmalloc. */
80static void
81init_buffer (struct macro_buffer *b, int n)
82{
83 b->size = n;
84 if (n > 0)
85 b->text = (char *) xmalloc (n);
86 else
87 b->text = NULL;
88 b->len = 0;
89 b->shared = 0;
90 b->last_token = -1;
91}
92
93
94/* Set the macro buffer *BUF to refer to the LEN bytes at ADDR, as a
95 shared substring. */
96static void
97init_shared_buffer (struct macro_buffer *buf, char *addr, int len)
98{
99 buf->text = addr;
100 buf->len = len;
101 buf->shared = 1;
102 buf->size = 0;
103 buf->last_token = -1;
104}
105
106
107/* Free the text of the buffer B. Raise an error if B is shared. */
108static void
109free_buffer (struct macro_buffer *b)
110{
111 gdb_assert (! b->shared);
112 if (b->size)
113 xfree (b->text);
114}
115
ef5ccd6c
JM
116/* Like free_buffer, but return the text as an xstrdup()d string.
117 This only exists to try to make the API relatively clean. */
118
119static char *
120free_buffer_return_text (struct macro_buffer *b)
121{
122 gdb_assert (! b->shared);
123 gdb_assert (b->size);
124 /* Nothing to do. */
125 return b->text;
126}
5796c8dc
SS
127
128/* A cleanup function for macro buffers. */
129static void
130cleanup_macro_buffer (void *untyped_buf)
131{
132 free_buffer ((struct macro_buffer *) untyped_buf);
133}
134
135
136/* Resize the buffer B to be at least N bytes long. Raise an error if
137 B shouldn't be resized. */
138static void
139resize_buffer (struct macro_buffer *b, int n)
140{
141 /* We shouldn't be trying to resize shared strings. */
142 gdb_assert (! b->shared);
143
144 if (b->size == 0)
145 b->size = n;
146 else
147 while (b->size <= n)
148 b->size *= 2;
149
150 b->text = xrealloc (b->text, b->size);
151}
152
153
154/* Append the character C to the buffer B. */
155static void
156appendc (struct macro_buffer *b, int c)
157{
158 int new_len = b->len + 1;
159
160 if (new_len > b->size)
161 resize_buffer (b, new_len);
162
163 b->text[b->len] = c;
164 b->len = new_len;
165}
166
167
168/* Append the LEN bytes at ADDR to the buffer B. */
169static void
170appendmem (struct macro_buffer *b, char *addr, int len)
171{
172 int new_len = b->len + len;
173
174 if (new_len > b->size)
175 resize_buffer (b, new_len);
176
177 memcpy (b->text + b->len, addr, len);
178 b->len = new_len;
179}
180
181
182\f
183/* Recognizing preprocessor tokens. */
184
185
186int
187macro_is_whitespace (int c)
188{
189 return (c == ' '
190 || c == '\t'
191 || c == '\n'
192 || c == '\v'
193 || c == '\f');
194}
195
196
197int
198macro_is_digit (int c)
199{
200 return ('0' <= c && c <= '9');
201}
202
203
204int
205macro_is_identifier_nondigit (int c)
206{
207 return (c == '_'
208 || ('a' <= c && c <= 'z')
209 || ('A' <= c && c <= 'Z'));
210}
211
212
213static void
214set_token (struct macro_buffer *tok, char *start, char *end)
215{
216 init_shared_buffer (tok, start, end - start);
217 tok->last_token = 0;
218
c50c785c 219 /* Presumed; get_identifier may overwrite this. */
5796c8dc
SS
220 tok->is_identifier = 0;
221}
222
223
224static int
225get_comment (struct macro_buffer *tok, char *p, char *end)
226{
227 if (p + 2 > end)
228 return 0;
229 else if (p[0] == '/'
230 && p[1] == '*')
231 {
232 char *tok_start = p;
233
234 p += 2;
235
236 for (; p < end; p++)
237 if (p + 2 <= end
238 && p[0] == '*'
239 && p[1] == '/')
240 {
241 p += 2;
242 set_token (tok, tok_start, p);
243 return 1;
244 }
245
246 error (_("Unterminated comment in macro expansion."));
247 }
248 else if (p[0] == '/'
249 && p[1] == '/')
250 {
251 char *tok_start = p;
252
253 p += 2;
254 for (; p < end; p++)
255 if (*p == '\n')
256 break;
257
258 set_token (tok, tok_start, p);
259 return 1;
260 }
261 else
262 return 0;
263}
264
265
266static int
267get_identifier (struct macro_buffer *tok, char *p, char *end)
268{
269 if (p < end
270 && macro_is_identifier_nondigit (*p))
271 {
272 char *tok_start = p;
273
274 while (p < end
275 && (macro_is_identifier_nondigit (*p)
276 || macro_is_digit (*p)))
277 p++;
278
279 set_token (tok, tok_start, p);
280 tok->is_identifier = 1;
281 return 1;
282 }
283 else
284 return 0;
285}
286
287
288static int
289get_pp_number (struct macro_buffer *tok, char *p, char *end)
290{
291 if (p < end
292 && (macro_is_digit (*p)
293 || (*p == '.'
294 && p + 2 <= end
295 && macro_is_digit (p[1]))))
296 {
297 char *tok_start = p;
298
299 while (p < end)
300 {
301 if (p + 2 <= end
302 && strchr ("eEpP", *p)
303 && (p[1] == '+' || p[1] == '-'))
304 p += 2;
305 else if (macro_is_digit (*p)
306 || macro_is_identifier_nondigit (*p)
307 || *p == '.')
308 p++;
309 else
310 break;
311 }
312
313 set_token (tok, tok_start, p);
314 return 1;
315 }
316 else
317 return 0;
318}
319
320
321
322/* If the text starting at P going up to (but not including) END
323 starts with a character constant, set *TOK to point to that
324 character constant, and return 1. Otherwise, return zero.
325 Signal an error if it contains a malformed or incomplete character
326 constant. */
327static int
328get_character_constant (struct macro_buffer *tok, char *p, char *end)
329{
330 /* ISO/IEC 9899:1999 (E) Section 6.4.4.4 paragraph 1
331 But of course, what really matters is that we handle it the same
332 way GDB's C/C++ lexer does. So we call parse_escape in utils.c
333 to handle escape sequences. */
334 if ((p + 1 <= end && *p == '\'')
335 || (p + 2 <= end
336 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
337 && p[1] == '\''))
338 {
339 char *tok_start = p;
5796c8dc
SS
340 int char_count = 0;
341
342 if (*p == '\'')
343 p++;
344 else if (*p == 'L' || *p == 'u' || *p == 'U')
345 p += 2;
346 else
c50c785c 347 gdb_assert_not_reached ("unexpected character constant");
5796c8dc 348
5796c8dc
SS
349 for (;;)
350 {
351 if (p >= end)
352 error (_("Unmatched single quote."));
353 else if (*p == '\'')
354 {
355 if (!char_count)
356 error (_("A character constant must contain at least one "
357 "character."));
358 p++;
359 break;
360 }
361 else if (*p == '\\')
362 {
363 p++;
364 char_count += c_parse_escape (&p, NULL);
365 }
366 else
367 {
368 p++;
369 char_count++;
370 }
371 }
372
373 set_token (tok, tok_start, p);
374 return 1;
375 }
376 else
377 return 0;
378}
379
380
381/* If the text starting at P going up to (but not including) END
382 starts with a string literal, set *TOK to point to that string
383 literal, and return 1. Otherwise, return zero. Signal an error if
384 it contains a malformed or incomplete string literal. */
385static int
386get_string_literal (struct macro_buffer *tok, char *p, char *end)
387{
388 if ((p + 1 <= end
389 && *p == '"')
390 || (p + 2 <= end
391 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
392 && p[1] == '"'))
393 {
394 char *tok_start = p;
395
396 if (*p == '"')
397 p++;
398 else if (*p == 'L' || *p == 'u' || *p == 'U')
399 p += 2;
400 else
c50c785c 401 gdb_assert_not_reached ("unexpected string literal");
5796c8dc
SS
402
403 for (;;)
404 {
405 if (p >= end)
406 error (_("Unterminated string in expression."));
407 else if (*p == '"')
408 {
409 p++;
410 break;
411 }
412 else if (*p == '\n')
413 error (_("Newline characters may not appear in string "
414 "constants."));
415 else if (*p == '\\')
416 {
417 p++;
418 c_parse_escape (&p, NULL);
419 }
420 else
421 p++;
422 }
423
424 set_token (tok, tok_start, p);
425 return 1;
426 }
427 else
428 return 0;
429}
430
431
432static int
433get_punctuator (struct macro_buffer *tok, char *p, char *end)
434{
435 /* Here, speed is much less important than correctness and clarity. */
436
437 /* ISO/IEC 9899:1999 (E) Section 6.4.6 Paragraph 1.
438 Note that this table is ordered in a special way. A punctuator
439 which is a prefix of another punctuator must appear after its
440 "extension". Otherwise, the wrong token will be returned. */
441 static const char * const punctuators[] = {
442 "[", "]", "(", ")", "{", "}", "?", ";", ",", "~",
443 "...", ".",
444 "->", "--", "-=", "-",
445 "++", "+=", "+",
446 "*=", "*",
447 "!=", "!",
448 "&&", "&=", "&",
449 "/=", "/",
450 "%>", "%:%:", "%:", "%=", "%",
451 "^=", "^",
452 "##", "#",
453 ":>", ":",
454 "||", "|=", "|",
455 "<<=", "<<", "<=", "<:", "<%", "<",
456 ">>=", ">>", ">=", ">",
457 "==", "=",
458 0
459 };
460
461 int i;
462
463 if (p + 1 <= end)
464 {
465 for (i = 0; punctuators[i]; i++)
466 {
467 const char *punctuator = punctuators[i];
468
469 if (p[0] == punctuator[0])
470 {
471 int len = strlen (punctuator);
472
473 if (p + len <= end
474 && ! memcmp (p, punctuator, len))
475 {
476 set_token (tok, p, p + len);
477 return 1;
478 }
479 }
480 }
481 }
482
483 return 0;
484}
485
486
487/* Peel the next preprocessor token off of SRC, and put it in TOK.
488 Mutate TOK to refer to the first token in SRC, and mutate SRC to
489 refer to the text after that token. SRC must be a shared buffer;
490 the resulting TOK will be shared, pointing into the same string SRC
491 does. Initialize TOK's last_token field. Return non-zero if we
492 succeed, or 0 if we didn't find any more tokens in SRC. */
493static int
494get_token (struct macro_buffer *tok,
495 struct macro_buffer *src)
496{
497 char *p = src->text;
498 char *end = p + src->len;
499
500 gdb_assert (src->shared);
501
502 /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
503
504 preprocessing-token:
505 header-name
506 identifier
507 pp-number
508 character-constant
509 string-literal
510 punctuator
511 each non-white-space character that cannot be one of the above
512
513 We don't have to deal with header-name tokens, since those can
514 only occur after a #include, which we will never see. */
515
516 while (p < end)
517 if (macro_is_whitespace (*p))
518 p++;
519 else if (get_comment (tok, p, end))
520 p += tok->len;
521 else if (get_pp_number (tok, p, end)
522 || get_character_constant (tok, p, end)
523 || get_string_literal (tok, p, end)
524 /* Note: the grammar in the standard seems to be
525 ambiguous: L'x' can be either a wide character
526 constant, or an identifier followed by a normal
527 character constant. By trying `get_identifier' after
528 we try get_character_constant and get_string_literal,
529 we give the wide character syntax precedence. Now,
530 since GDB doesn't handle wide character constants
531 anyway, is this the right thing to do? */
532 || get_identifier (tok, p, end)
533 || get_punctuator (tok, p, end))
534 {
535 /* How many characters did we consume, including whitespace? */
536 int consumed = p - src->text + tok->len;
cf7f2e2d 537
5796c8dc
SS
538 src->text += consumed;
539 src->len -= consumed;
540 return 1;
541 }
542 else
543 {
544 /* We have found a "non-whitespace character that cannot be
545 one of the above." Make a token out of it. */
546 int consumed;
547
548 set_token (tok, p, p + 1);
549 consumed = p - src->text + tok->len;
550 src->text += consumed;
551 src->len -= consumed;
552 return 1;
553 }
554
555 return 0;
556}
557
558
559\f
560/* Appending token strings, with and without splicing */
561
562
563/* Append the macro buffer SRC to the end of DEST, and ensure that
564 doing so doesn't splice the token at the end of SRC with the token
565 at the beginning of DEST. SRC and DEST must have their last_token
566 fields set. Upon return, DEST's last_token field is set correctly.
567
568 For example:
569
570 If DEST is "(" and SRC is "y", then we can return with
571 DEST set to "(y" --- we've simply appended the two buffers.
572
573 However, if DEST is "x" and SRC is "y", then we must not return
574 with DEST set to "xy" --- that would splice the two tokens "x" and
575 "y" together to make a single token "xy". However, it would be
576 fine to return with DEST set to "x y". Similarly, "<" and "<" must
577 yield "< <", not "<<", etc. */
578static void
579append_tokens_without_splicing (struct macro_buffer *dest,
580 struct macro_buffer *src)
581{
582 int original_dest_len = dest->len;
583 struct macro_buffer dest_tail, new_token;
584
585 gdb_assert (src->last_token != -1);
586 gdb_assert (dest->last_token != -1);
587
588 /* First, just try appending the two, and call get_token to see if
589 we got a splice. */
590 appendmem (dest, src->text, src->len);
591
592 /* If DEST originally had no token abutting its end, then we can't
593 have spliced anything, so we're done. */
594 if (dest->last_token == original_dest_len)
595 {
596 dest->last_token = original_dest_len + src->last_token;
597 return;
598 }
599
600 /* Set DEST_TAIL to point to the last token in DEST, followed by
601 all the stuff we just appended. */
602 init_shared_buffer (&dest_tail,
603 dest->text + dest->last_token,
604 dest->len - dest->last_token);
605
606 /* Re-parse DEST's last token. We know that DEST used to contain
607 at least one token, so if it doesn't contain any after the
608 append, then we must have spliced "/" and "*" or "/" and "/" to
609 make a comment start. (Just for the record, I got this right
610 the first time. This is not a bug fix.) */
611 if (get_token (&new_token, &dest_tail)
612 && (new_token.text + new_token.len
613 == dest->text + original_dest_len))
614 {
615 /* No splice, so we're done. */
616 dest->last_token = original_dest_len + src->last_token;
617 return;
618 }
619
620 /* Okay, a simple append caused a splice. Let's chop dest back to
621 its original length and try again, but separate the texts with a
622 space. */
623 dest->len = original_dest_len;
624 appendc (dest, ' ');
625 appendmem (dest, src->text, src->len);
626
627 init_shared_buffer (&dest_tail,
628 dest->text + dest->last_token,
629 dest->len - dest->last_token);
630
631 /* Try to re-parse DEST's last token, as above. */
632 if (get_token (&new_token, &dest_tail)
633 && (new_token.text + new_token.len
634 == dest->text + original_dest_len))
635 {
636 /* No splice, so we're done. */
637 dest->last_token = original_dest_len + 1 + src->last_token;
638 return;
639 }
640
641 /* As far as I know, there's no case where inserting a space isn't
642 enough to prevent a splice. */
643 internal_error (__FILE__, __LINE__,
644 _("unable to avoid splicing tokens during macro expansion"));
645}
646
647/* Stringify an argument, and insert it into DEST. ARG is the text to
648 stringify; it is LEN bytes long. */
649
650static void
ef5ccd6c 651stringify (struct macro_buffer *dest, const char *arg, int len)
5796c8dc
SS
652{
653 /* Trim initial whitespace from ARG. */
654 while (len > 0 && macro_is_whitespace (*arg))
655 {
656 ++arg;
657 --len;
658 }
659
660 /* Trim trailing whitespace from ARG. */
661 while (len > 0 && macro_is_whitespace (arg[len - 1]))
662 --len;
663
664 /* Insert the string. */
665 appendc (dest, '"');
666 while (len > 0)
667 {
668 /* We could try to handle strange cases here, like control
669 characters, but there doesn't seem to be much point. */
670 if (macro_is_whitespace (*arg))
671 {
672 /* Replace a sequence of whitespace with a single space. */
673 appendc (dest, ' ');
674 while (len > 1 && macro_is_whitespace (arg[1]))
675 {
676 ++arg;
677 --len;
678 }
679 }
680 else if (*arg == '\\' || *arg == '"')
681 {
682 appendc (dest, '\\');
683 appendc (dest, *arg);
684 }
685 else
686 appendc (dest, *arg);
687 ++arg;
688 --len;
689 }
690 appendc (dest, '"');
691 dest->last_token = dest->len;
692}
693
ef5ccd6c
JM
694/* See macroexp.h. */
695
696char *
697macro_stringify (const char *str)
698{
699 struct macro_buffer buffer;
700 int len = strlen (str);
701
702 init_buffer (&buffer, len);
703 stringify (&buffer, str, len);
704 appendc (&buffer, '\0');
705
706 return free_buffer_return_text (&buffer);
707}
708
5796c8dc
SS
709\f
710/* Expanding macros! */
711
712
713/* A singly-linked list of the names of the macros we are currently
714 expanding --- for detecting expansion loops. */
715struct macro_name_list {
716 const char *name;
717 struct macro_name_list *next;
718};
719
720
721/* Return non-zero if we are currently expanding the macro named NAME,
722 according to LIST; otherwise, return zero.
723
724 You know, it would be possible to get rid of all the NO_LOOP
725 arguments to these functions by simply generating a new lookup
726 function and baton which refuses to find the definition for a
727 particular macro, and otherwise delegates the decision to another
728 function/baton pair. But that makes the linked list of excluded
729 macros chained through untyped baton pointers, which will make it
c50c785c 730 harder to debug. :( */
5796c8dc
SS
731static int
732currently_rescanning (struct macro_name_list *list, const char *name)
733{
734 for (; list; list = list->next)
735 if (strcmp (name, list->name) == 0)
736 return 1;
737
738 return 0;
739}
740
741
742/* Gather the arguments to a macro expansion.
743
744 NAME is the name of the macro being invoked. (It's only used for
745 printing error messages.)
746
747 Assume that SRC is the text of the macro invocation immediately
748 following the macro name. For example, if we're processing the
749 text foo(bar, baz), then NAME would be foo and SRC will be (bar,
750 baz).
751
752 If SRC doesn't start with an open paren ( token at all, return
753 zero, leave SRC unchanged, and don't set *ARGC_P to anything.
754
755 If SRC doesn't contain a properly terminated argument list, then
756 raise an error.
757
758 For a variadic macro, NARGS holds the number of formal arguments to
759 the macro. For a GNU-style variadic macro, this should be the
760 number of named arguments. For a non-variadic macro, NARGS should
761 be -1.
762
763 Otherwise, return a pointer to the first element of an array of
764 macro buffers referring to the argument texts, and set *ARGC_P to
765 the number of arguments we found --- the number of elements in the
766 array. The macro buffers share their text with SRC, and their
767 last_token fields are initialized. The array is allocated with
768 xmalloc, and the caller is responsible for freeing it.
769
770 NOTE WELL: if SRC starts with a open paren ( token followed
771 immediately by a close paren ) token (e.g., the invocation looks
772 like "foo()"), we treat that as one argument, which happens to be
773 the empty list of tokens. The caller should keep in mind that such
774 a sequence of tokens is a valid way to invoke one-parameter
775 function-like macros, but also a valid way to invoke zero-parameter
776 function-like macros. Eeew.
777
778 Consume the tokens from SRC; after this call, SRC contains the text
779 following the invocation. */
780
781static struct macro_buffer *
782gather_arguments (const char *name, struct macro_buffer *src,
783 int nargs, int *argc_p)
784{
785 struct macro_buffer tok;
786 int args_len, args_size;
787 struct macro_buffer *args = NULL;
788 struct cleanup *back_to = make_cleanup (free_current_contents, &args);
789
790 /* Does SRC start with an opening paren token? Read from a copy of
791 SRC, so SRC itself is unaffected if we don't find an opening
792 paren. */
793 {
794 struct macro_buffer temp;
cf7f2e2d 795
5796c8dc
SS
796 init_shared_buffer (&temp, src->text, src->len);
797
798 if (! get_token (&tok, &temp)
799 || tok.len != 1
800 || tok.text[0] != '(')
801 {
802 discard_cleanups (back_to);
803 return 0;
804 }
805 }
806
807 /* Consume SRC's opening paren. */
808 get_token (&tok, src);
809
810 args_len = 0;
811 args_size = 6;
812 args = (struct macro_buffer *) xmalloc (sizeof (*args) * args_size);
813
814 for (;;)
815 {
816 struct macro_buffer *arg;
817 int depth;
818
819 /* Make sure we have room for the next argument. */
820 if (args_len >= args_size)
821 {
822 args_size *= 2;
823 args = xrealloc (args, sizeof (*args) * args_size);
824 }
825
826 /* Initialize the next argument. */
827 arg = &args[args_len++];
828 set_token (arg, src->text, src->text);
829
830 /* Gather the argument's tokens. */
831 depth = 0;
832 for (;;)
833 {
5796c8dc
SS
834 if (! get_token (&tok, src))
835 error (_("Malformed argument list for macro `%s'."), name);
836
837 /* Is tok an opening paren? */
838 if (tok.len == 1 && tok.text[0] == '(')
839 depth++;
840
841 /* Is tok is a closing paren? */
842 else if (tok.len == 1 && tok.text[0] == ')')
843 {
844 /* If it's a closing paren at the top level, then that's
845 the end of the argument list. */
846 if (depth == 0)
847 {
848 /* In the varargs case, the last argument may be
849 missing. Add an empty argument in this case. */
850 if (nargs != -1 && args_len == nargs - 1)
851 {
852 /* Make sure we have room for the argument. */
853 if (args_len >= args_size)
854 {
855 args_size++;
856 args = xrealloc (args, sizeof (*args) * args_size);
857 }
858 arg = &args[args_len++];
859 set_token (arg, src->text, src->text);
860 }
861
862 discard_cleanups (back_to);
863 *argc_p = args_len;
864 return args;
865 }
866
867 depth--;
868 }
869
870 /* If tok is a comma at top level, then that's the end of
871 the current argument. However, if we are handling a
872 variadic macro and we are computing the last argument, we
873 want to include the comma and remaining tokens. */
874 else if (tok.len == 1 && tok.text[0] == ',' && depth == 0
875 && (nargs == -1 || args_len < nargs))
876 break;
877
878 /* Extend the current argument to enclose this token. If
879 this is the current argument's first token, leave out any
880 leading whitespace, just for aesthetics. */
881 if (arg->len == 0)
882 {
883 arg->text = tok.text;
884 arg->len = tok.len;
885 arg->last_token = 0;
886 }
887 else
888 {
889 arg->len = (tok.text + tok.len) - arg->text;
890 arg->last_token = tok.text - arg->text;
891 }
892 }
893 }
894}
895
896
897/* The `expand' and `substitute_args' functions both invoke `scan'
898 recursively, so we need a forward declaration somewhere. */
899static void scan (struct macro_buffer *dest,
900 struct macro_buffer *src,
901 struct macro_name_list *no_loop,
902 macro_lookup_ftype *lookup_func,
903 void *lookup_baton);
904
905
906/* A helper function for substitute_args.
907
908 ARGV is a vector of all the arguments; ARGC is the number of
909 arguments. IS_VARARGS is true if the macro being substituted is a
910 varargs macro; in this case VA_ARG_NAME is the name of the
911 "variable" argument. VA_ARG_NAME is ignored if IS_VARARGS is
912 false.
913
914 If the token TOK is the name of a parameter, return the parameter's
915 index. If TOK is not an argument, return -1. */
916
917static int
918find_parameter (const struct macro_buffer *tok,
919 int is_varargs, const struct macro_buffer *va_arg_name,
920 int argc, const char * const *argv)
921{
922 int i;
923
924 if (! tok->is_identifier)
925 return -1;
926
927 for (i = 0; i < argc; ++i)
c50c785c
JM
928 if (tok->len == strlen (argv[i])
929 && !memcmp (tok->text, argv[i], tok->len))
5796c8dc
SS
930 return i;
931
932 if (is_varargs && tok->len == va_arg_name->len
933 && ! memcmp (tok->text, va_arg_name->text, tok->len))
934 return argc - 1;
935
936 return -1;
937}
938
939/* Given the macro definition DEF, being invoked with the actual
940 arguments given by ARGC and ARGV, substitute the arguments into the
941 replacement list, and store the result in DEST.
942
943 IS_VARARGS should be true if DEF is a varargs macro. In this case,
944 VA_ARG_NAME should be the name of the "variable" argument -- either
945 __VA_ARGS__ for c99-style varargs, or the final argument name, for
946 GNU-style varargs. If IS_VARARGS is false, this parameter is
947 ignored.
948
949 If it is necessary to expand macro invocations in one of the
950 arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
951 definitions, and don't expand invocations of the macros listed in
952 NO_LOOP. */
953
954static void
955substitute_args (struct macro_buffer *dest,
956 struct macro_definition *def,
957 int is_varargs, const struct macro_buffer *va_arg_name,
958 int argc, struct macro_buffer *argv,
959 struct macro_name_list *no_loop,
960 macro_lookup_ftype *lookup_func,
961 void *lookup_baton)
962{
963 /* A macro buffer for the macro's replacement list. */
964 struct macro_buffer replacement_list;
965 /* The token we are currently considering. */
966 struct macro_buffer tok;
967 /* The replacement list's pointer from just before TOK was lexed. */
968 char *original_rl_start;
969 /* We have a single lookahead token to handle token splicing. */
970 struct macro_buffer lookahead;
971 /* The lookahead token might not be valid. */
972 int lookahead_valid;
973 /* The replacement list's pointer from just before LOOKAHEAD was
974 lexed. */
975 char *lookahead_rl_start;
976
977 init_shared_buffer (&replacement_list, (char *) def->replacement,
978 strlen (def->replacement));
979
980 gdb_assert (dest->len == 0);
981 dest->last_token = 0;
982
983 original_rl_start = replacement_list.text;
984 if (! get_token (&tok, &replacement_list))
985 return;
986 lookahead_rl_start = replacement_list.text;
987 lookahead_valid = get_token (&lookahead, &replacement_list);
988
989 for (;;)
990 {
991 /* Just for aesthetics. If we skipped some whitespace, copy
992 that to DEST. */
993 if (tok.text > original_rl_start)
994 {
995 appendmem (dest, original_rl_start, tok.text - original_rl_start);
996 dest->last_token = dest->len;
997 }
998
999 /* Is this token the stringification operator? */
1000 if (tok.len == 1
1001 && tok.text[0] == '#')
1002 {
1003 int arg;
1004
1005 if (!lookahead_valid)
1006 error (_("Stringification operator requires an argument."));
1007
1008 arg = find_parameter (&lookahead, is_varargs, va_arg_name,
1009 def->argc, def->argv);
1010 if (arg == -1)
1011 error (_("Argument to stringification operator must name "
1012 "a macro parameter."));
1013
1014 stringify (dest, argv[arg].text, argv[arg].len);
1015
1016 /* Read one token and let the loop iteration code handle the
1017 rest. */
1018 lookahead_rl_start = replacement_list.text;
1019 lookahead_valid = get_token (&lookahead, &replacement_list);
1020 }
1021 /* Is this token the splicing operator? */
1022 else if (tok.len == 2
1023 && tok.text[0] == '#'
1024 && tok.text[1] == '#')
1025 error (_("Stray splicing operator"));
1026 /* Is the next token the splicing operator? */
1027 else if (lookahead_valid
1028 && lookahead.len == 2
1029 && lookahead.text[0] == '#'
1030 && lookahead.text[1] == '#')
1031 {
cf7f2e2d 1032 int finished = 0;
5796c8dc
SS
1033 int prev_was_comma = 0;
1034
1035 /* Note that GCC warns if the result of splicing is not a
1036 token. In the debugger there doesn't seem to be much
1037 benefit from doing this. */
1038
1039 /* Insert the first token. */
1040 if (tok.len == 1 && tok.text[0] == ',')
1041 prev_was_comma = 1;
1042 else
1043 {
1044 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1045 def->argc, def->argv);
cf7f2e2d 1046
5796c8dc
SS
1047 if (arg != -1)
1048 appendmem (dest, argv[arg].text, argv[arg].len);
1049 else
1050 appendmem (dest, tok.text, tok.len);
1051 }
1052
1053 /* Apply a possible sequence of ## operators. */
1054 for (;;)
1055 {
1056 if (! get_token (&tok, &replacement_list))
1057 error (_("Splicing operator at end of macro"));
1058
1059 /* Handle a comma before a ##. If we are handling
1060 varargs, and the token on the right hand side is the
1061 varargs marker, and the final argument is empty or
1062 missing, then drop the comma. This is a GNU
1063 extension. There is one ambiguous case here,
1064 involving pedantic behavior with an empty argument,
1065 but we settle that in favor of GNU-style (GCC uses an
1066 option). If we aren't dealing with varargs, we
1067 simply insert the comma. */
1068 if (prev_was_comma)
1069 {
1070 if (! (is_varargs
1071 && tok.len == va_arg_name->len
1072 && !memcmp (tok.text, va_arg_name->text, tok.len)
1073 && argv[argc - 1].len == 0))
1074 appendmem (dest, ",", 1);
1075 prev_was_comma = 0;
1076 }
1077
1078 /* Insert the token. If it is a parameter, insert the
1079 argument. If it is a comma, treat it specially. */
1080 if (tok.len == 1 && tok.text[0] == ',')
1081 prev_was_comma = 1;
1082 else
1083 {
1084 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1085 def->argc, def->argv);
cf7f2e2d 1086
5796c8dc
SS
1087 if (arg != -1)
1088 appendmem (dest, argv[arg].text, argv[arg].len);
1089 else
1090 appendmem (dest, tok.text, tok.len);
1091 }
1092
1093 /* Now read another token. If it is another splice, we
1094 loop. */
1095 original_rl_start = replacement_list.text;
1096 if (! get_token (&tok, &replacement_list))
1097 {
1098 finished = 1;
1099 break;
1100 }
1101
1102 if (! (tok.len == 2
1103 && tok.text[0] == '#'
1104 && tok.text[1] == '#'))
1105 break;
1106 }
1107
1108 if (prev_was_comma)
1109 {
1110 /* We saw a comma. Insert it now. */
1111 appendmem (dest, ",", 1);
1112 }
1113
1114 dest->last_token = dest->len;
1115 if (finished)
1116 lookahead_valid = 0;
1117 else
1118 {
1119 /* Set up for the loop iterator. */
1120 lookahead = tok;
1121 lookahead_rl_start = original_rl_start;
1122 lookahead_valid = 1;
1123 }
1124 }
1125 else
1126 {
1127 /* Is this token an identifier? */
1128 int substituted = 0;
1129 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1130 def->argc, def->argv);
1131
1132 if (arg != -1)
1133 {
1134 struct macro_buffer arg_src;
1135
1136 /* Expand any macro invocations in the argument text,
1137 and append the result to dest. Remember that scan
1138 mutates its source, so we need to scan a new buffer
1139 referring to the argument's text, not the argument
1140 itself. */
1141 init_shared_buffer (&arg_src, argv[arg].text, argv[arg].len);
1142 scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
1143 substituted = 1;
1144 }
1145
1146 /* If it wasn't a parameter, then just copy it across. */
1147 if (! substituted)
1148 append_tokens_without_splicing (dest, &tok);
1149 }
1150
1151 if (! lookahead_valid)
1152 break;
1153
1154 tok = lookahead;
1155 original_rl_start = lookahead_rl_start;
1156
1157 lookahead_rl_start = replacement_list.text;
1158 lookahead_valid = get_token (&lookahead, &replacement_list);
1159 }
1160}
1161
1162
1163/* Expand a call to a macro named ID, whose definition is DEF. Append
1164 its expansion to DEST. SRC is the input text following the ID
1165 token. We are currently rescanning the expansions of the macros
1166 named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and
c50c785c 1167 LOOKUP_BATON to find definitions for any nested macro references.
5796c8dc
SS
1168
1169 Return 1 if we decided to expand it, zero otherwise. (If it's a
1170 function-like macro name that isn't followed by an argument list,
1171 we don't expand it.) If we return zero, leave SRC unchanged. */
1172static int
1173expand (const char *id,
1174 struct macro_definition *def,
1175 struct macro_buffer *dest,
1176 struct macro_buffer *src,
1177 struct macro_name_list *no_loop,
1178 macro_lookup_ftype *lookup_func,
1179 void *lookup_baton)
1180{
1181 struct macro_name_list new_no_loop;
1182
1183 /* Create a new node to be added to the front of the no-expand list.
1184 This list is appropriate for re-scanning replacement lists, but
1185 it is *not* appropriate for scanning macro arguments; invocations
1186 of the macro whose arguments we are gathering *do* get expanded
1187 there. */
1188 new_no_loop.name = id;
1189 new_no_loop.next = no_loop;
1190
1191 /* What kind of macro are we expanding? */
1192 if (def->kind == macro_object_like)
1193 {
1194 struct macro_buffer replacement_list;
1195
1196 init_shared_buffer (&replacement_list, (char *) def->replacement,
1197 strlen (def->replacement));
1198
1199 scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
1200 return 1;
1201 }
1202 else if (def->kind == macro_function_like)
1203 {
1204 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
1205 int argc = 0;
1206 struct macro_buffer *argv = NULL;
1207 struct macro_buffer substituted;
1208 struct macro_buffer substituted_src;
c50c785c 1209 struct macro_buffer va_arg_name = {0};
5796c8dc
SS
1210 int is_varargs = 0;
1211
1212 if (def->argc >= 1)
1213 {
1214 if (strcmp (def->argv[def->argc - 1], "...") == 0)
1215 {
1216 /* In C99-style varargs, substitution is done using
1217 __VA_ARGS__. */
1218 init_shared_buffer (&va_arg_name, "__VA_ARGS__",
1219 strlen ("__VA_ARGS__"));
1220 is_varargs = 1;
1221 }
1222 else
1223 {
1224 int len = strlen (def->argv[def->argc - 1]);
cf7f2e2d 1225
5796c8dc
SS
1226 if (len > 3
1227 && strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0)
1228 {
1229 /* In GNU-style varargs, the name of the
1230 substitution parameter is the name of the formal
1231 argument without the "...". */
1232 init_shared_buffer (&va_arg_name,
1233 (char *) def->argv[def->argc - 1],
1234 len - 3);
1235 is_varargs = 1;
1236 }
1237 }
1238 }
1239
1240 make_cleanup (free_current_contents, &argv);
1241 argv = gather_arguments (id, src, is_varargs ? def->argc : -1,
1242 &argc);
1243
1244 /* If we couldn't find any argument list, then we don't expand
1245 this macro. */
1246 if (! argv)
1247 {
1248 do_cleanups (back_to);
1249 return 0;
1250 }
1251
1252 /* Check that we're passing an acceptable number of arguments for
1253 this macro. */
1254 if (argc != def->argc)
1255 {
1256 if (is_varargs && argc >= def->argc - 1)
1257 {
1258 /* Ok. */
1259 }
1260 /* Remember that a sequence of tokens like "foo()" is a
1261 valid invocation of a macro expecting either zero or one
1262 arguments. */
1263 else if (! (argc == 1
1264 && argv[0].len == 0
1265 && def->argc == 0))
1266 error (_("Wrong number of arguments to macro `%s' "
1267 "(expected %d, got %d)."),
1268 id, def->argc, argc);
1269 }
1270
1271 /* Note that we don't expand macro invocations in the arguments
1272 yet --- we let subst_args take care of that. Parameters that
1273 appear as operands of the stringifying operator "#" or the
1274 splicing operator "##" don't get macro references expanded,
1275 so we can't really tell whether it's appropriate to macro-
1276 expand an argument until we see how it's being used. */
1277 init_buffer (&substituted, 0);
1278 make_cleanup (cleanup_macro_buffer, &substituted);
1279 substitute_args (&substituted, def, is_varargs, &va_arg_name,
1280 argc, argv, no_loop, lookup_func, lookup_baton);
1281
1282 /* Now `substituted' is the macro's replacement list, with all
1283 argument values substituted into it properly. Re-scan it for
1284 macro references, but don't expand invocations of this macro.
1285
1286 We create a new buffer, `substituted_src', which points into
1287 `substituted', and scan that. We can't scan `substituted'
1288 itself, since the tokenization process moves the buffer's
1289 text pointer around, and we still need to be able to find
1290 `substituted's original text buffer after scanning it so we
1291 can free it. */
1292 init_shared_buffer (&substituted_src, substituted.text, substituted.len);
1293 scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
1294
1295 do_cleanups (back_to);
1296
1297 return 1;
1298 }
1299 else
1300 internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
1301}
1302
1303
1304/* If the single token in SRC_FIRST followed by the tokens in SRC_REST
1305 constitute a macro invokation not forbidden in NO_LOOP, append its
1306 expansion to DEST and return non-zero. Otherwise, return zero, and
1307 leave DEST unchanged.
1308
1309 SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
1310 SRC_FIRST must be a string built by get_token. */
1311static int
1312maybe_expand (struct macro_buffer *dest,
1313 struct macro_buffer *src_first,
1314 struct macro_buffer *src_rest,
1315 struct macro_name_list *no_loop,
1316 macro_lookup_ftype *lookup_func,
1317 void *lookup_baton)
1318{
1319 gdb_assert (src_first->shared);
1320 gdb_assert (src_rest->shared);
1321 gdb_assert (! dest->shared);
1322
1323 /* Is this token an identifier? */
1324 if (src_first->is_identifier)
1325 {
1326 /* Make a null-terminated copy of it, since that's what our
1327 lookup function expects. */
1328 char *id = xmalloc (src_first->len + 1);
1329 struct cleanup *back_to = make_cleanup (xfree, id);
cf7f2e2d 1330
5796c8dc
SS
1331 memcpy (id, src_first->text, src_first->len);
1332 id[src_first->len] = 0;
1333
1334 /* If we're currently re-scanning the result of expanding
1335 this macro, don't expand it again. */
1336 if (! currently_rescanning (no_loop, id))
1337 {
1338 /* Does this identifier have a macro definition in scope? */
1339 struct macro_definition *def = lookup_func (id, lookup_baton);
1340
1341 if (def && expand (id, def, dest, src_rest, no_loop,
1342 lookup_func, lookup_baton))
1343 {
1344 do_cleanups (back_to);
1345 return 1;
1346 }
1347 }
1348
1349 do_cleanups (back_to);
1350 }
1351
1352 return 0;
1353}
1354
1355
1356/* Expand macro references in SRC, appending the results to DEST.
1357 Assume we are re-scanning the result of expanding the macros named
1358 in NO_LOOP, and don't try to re-expand references to them.
1359
1360 SRC must be a shared buffer; DEST must not be one. */
1361static void
1362scan (struct macro_buffer *dest,
1363 struct macro_buffer *src,
1364 struct macro_name_list *no_loop,
1365 macro_lookup_ftype *lookup_func,
1366 void *lookup_baton)
1367{
1368 gdb_assert (src->shared);
1369 gdb_assert (! dest->shared);
1370
1371 for (;;)
1372 {
1373 struct macro_buffer tok;
1374 char *original_src_start = src->text;
1375
1376 /* Find the next token in SRC. */
1377 if (! get_token (&tok, src))
1378 break;
1379
1380 /* Just for aesthetics. If we skipped some whitespace, copy
1381 that to DEST. */
1382 if (tok.text > original_src_start)
1383 {
1384 appendmem (dest, original_src_start, tok.text - original_src_start);
1385 dest->last_token = dest->len;
1386 }
1387
1388 if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
1389 /* We didn't end up expanding tok as a macro reference, so
1390 simply append it to dest. */
1391 append_tokens_without_splicing (dest, &tok);
1392 }
1393
1394 /* Just for aesthetics. If there was any trailing whitespace in
1395 src, copy it to dest. */
1396 if (src->len)
1397 {
1398 appendmem (dest, src->text, src->len);
1399 dest->last_token = dest->len;
1400 }
1401}
1402
1403
1404char *
1405macro_expand (const char *source,
1406 macro_lookup_ftype *lookup_func,
1407 void *lookup_func_baton)
1408{
1409 struct macro_buffer src, dest;
1410 struct cleanup *back_to;
1411
1412 init_shared_buffer (&src, (char *) source, strlen (source));
1413
1414 init_buffer (&dest, 0);
1415 dest.last_token = 0;
1416 back_to = make_cleanup (cleanup_macro_buffer, &dest);
1417
1418 scan (&dest, &src, 0, lookup_func, lookup_func_baton);
1419
1420 appendc (&dest, '\0');
1421
1422 discard_cleanups (back_to);
1423 return dest.text;
1424}
1425
1426
1427char *
1428macro_expand_once (const char *source,
1429 macro_lookup_ftype *lookup_func,
1430 void *lookup_func_baton)
1431{
1432 error (_("Expand-once not implemented yet."));
1433}
1434
1435
1436char *
1437macro_expand_next (char **lexptr,
1438 macro_lookup_ftype *lookup_func,
1439 void *lookup_baton)
1440{
1441 struct macro_buffer src, dest, tok;
1442 struct cleanup *back_to;
1443
1444 /* Set up SRC to refer to the input text, pointed to by *lexptr. */
1445 init_shared_buffer (&src, *lexptr, strlen (*lexptr));
1446
1447 /* Set up DEST to receive the expansion, if there is one. */
1448 init_buffer (&dest, 0);
1449 dest.last_token = 0;
1450 back_to = make_cleanup (cleanup_macro_buffer, &dest);
1451
1452 /* Get the text's first preprocessing token. */
1453 if (! get_token (&tok, &src))
1454 {
1455 do_cleanups (back_to);
1456 return 0;
1457 }
1458
1459 /* If it's a macro invocation, expand it. */
1460 if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
1461 {
1462 /* It was a macro invocation! Package up the expansion as a
1463 null-terminated string and return it. Set *lexptr to the
1464 start of the next token in the input. */
1465 appendc (&dest, '\0');
1466 discard_cleanups (back_to);
1467 *lexptr = src.text;
1468 return dest.text;
1469 }
1470 else
1471 {
1472 /* It wasn't a macro invocation. */
1473 do_cleanups (back_to);
1474 return 0;
1475 }
1476}