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