GDB (xrefs)

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