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