Add casts to memory allocation related calls
[external/binutils.git] / gdb / macroexp.c
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 \f
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, 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.  */
67   int last_token;
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.  */
71   int is_identifier;
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
108 free_buffer (struct macro_buffer *b)
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 *
119 free_buffer_return_text (struct macro_buffer *b)
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 = (char *) 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 \f
182 /* Recognizing preprocessor tokens.  */
183
184
185 int
186 macro_is_whitespace (int c)
187 {
188   return (c == ' '
189           || c == '\t'
190           || c == '\n'
191           || c == '\v'
192           || c == '\f');
193 }
194
195
196 int
197 macro_is_digit (int c)
198 {
199   return ('0' <= c && c <= '9');
200 }
201
202
203 int
204 macro_is_identifier_nondigit (int c)
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
269       && macro_is_identifier_nondigit (*p))
270     {
271       char *tok_start = p;
272
273       while (p < end
274              && (macro_is_identifier_nondigit (*p)
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)
305                    || macro_is_identifier_nondigit (*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 \f
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
584 append_tokens_without_splicing (struct macro_buffer *dest,
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 \f
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.  */
720 struct macro_name_list {
721   const char *name;
722   struct macro_name_list *next;
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 = XNEWVEC (struct macro_buffer, 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 = XRESIZEVEC (struct macro_buffer, 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 = XRESIZEVEC (struct macro_buffer, args,
862                                              args_size);
863                         }
864                       arg = &args[args_len++];
865                       set_token (arg, src->text, src->text);
866                     }
867
868                   discard_cleanups (back_to);
869                   *argc_p = args_len;
870                   return args;
871                 }
872
873               depth--;
874             }
875
876           /* If tok is a comma at top level, then that's the end of
877              the current argument.  However, if we are handling a
878              variadic macro and we are computing the last argument, we
879              want to include the comma and remaining tokens.  */
880           else if (tok.len == 1 && tok.text[0] == ',' && depth == 0
881                    && (nargs == -1 || args_len < nargs))
882             break;
883
884           /* Extend the current argument to enclose this token.  If
885              this is the current argument's first token, leave out any
886              leading whitespace, just for aesthetics.  */
887           if (arg->len == 0)
888             {
889               arg->text = tok.text;
890               arg->len = tok.len;
891               arg->last_token = 0;
892             }
893           else
894             {
895               arg->len = (tok.text + tok.len) - arg->text;
896               arg->last_token = tok.text - arg->text;
897             }
898         }
899     }
900 }
901
902
903 /* The `expand' and `substitute_args' functions both invoke `scan'
904    recursively, so we need a forward declaration somewhere.  */
905 static void scan (struct macro_buffer *dest,
906                   struct macro_buffer *src,
907                   struct macro_name_list *no_loop,
908                   macro_lookup_ftype *lookup_func,
909                   void *lookup_baton);
910
911
912 /* A helper function for substitute_args.
913    
914    ARGV is a vector of all the arguments; ARGC is the number of
915    arguments.  IS_VARARGS is true if the macro being substituted is a
916    varargs macro; in this case VA_ARG_NAME is the name of the
917    "variable" argument.  VA_ARG_NAME is ignored if IS_VARARGS is
918    false.
919
920    If the token TOK is the name of a parameter, return the parameter's
921    index.  If TOK is not an argument, return -1.  */
922
923 static int
924 find_parameter (const struct macro_buffer *tok,
925                 int is_varargs, const struct macro_buffer *va_arg_name,
926                 int argc, const char * const *argv)
927 {
928   int i;
929
930   if (! tok->is_identifier)
931     return -1;
932
933   for (i = 0; i < argc; ++i)
934     if (tok->len == strlen (argv[i]) 
935         && !memcmp (tok->text, argv[i], tok->len))
936       return i;
937
938   if (is_varargs && tok->len == va_arg_name->len
939       && ! memcmp (tok->text, va_arg_name->text, tok->len))
940     return argc - 1;
941
942   return -1;
943 }
944  
945 /* Given the macro definition DEF, being invoked with the actual
946    arguments given by ARGC and ARGV, substitute the arguments into the
947    replacement list, and store the result in DEST.
948
949    IS_VARARGS should be true if DEF is a varargs macro.  In this case,
950    VA_ARG_NAME should be the name of the "variable" argument -- either
951    __VA_ARGS__ for c99-style varargs, or the final argument name, for
952    GNU-style varargs.  If IS_VARARGS is false, this parameter is
953    ignored.
954
955    If it is necessary to expand macro invocations in one of the
956    arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
957    definitions, and don't expand invocations of the macros listed in
958    NO_LOOP.  */
959
960 static void
961 substitute_args (struct macro_buffer *dest, 
962                  struct macro_definition *def,
963                  int is_varargs, const struct macro_buffer *va_arg_name,
964                  int argc, struct macro_buffer *argv,
965                  struct macro_name_list *no_loop,
966                  macro_lookup_ftype *lookup_func,
967                  void *lookup_baton)
968 {
969   /* A macro buffer for the macro's replacement list.  */
970   struct macro_buffer replacement_list;
971   /* The token we are currently considering.  */
972   struct macro_buffer tok;
973   /* The replacement list's pointer from just before TOK was lexed.  */
974   char *original_rl_start;
975   /* We have a single lookahead token to handle token splicing.  */
976   struct macro_buffer lookahead;
977   /* The lookahead token might not be valid.  */
978   int lookahead_valid;
979   /* The replacement list's pointer from just before LOOKAHEAD was
980      lexed.  */
981   char *lookahead_rl_start;
982
983   init_shared_buffer (&replacement_list, (char *) def->replacement,
984                       strlen (def->replacement));
985
986   gdb_assert (dest->len == 0);
987   dest->last_token = 0;
988
989   original_rl_start = replacement_list.text;
990   if (! get_token (&tok, &replacement_list))
991     return;
992   lookahead_rl_start = replacement_list.text;
993   lookahead_valid = get_token (&lookahead, &replacement_list);
994
995   for (;;)
996     {
997       /* Just for aesthetics.  If we skipped some whitespace, copy
998          that to DEST.  */
999       if (tok.text > original_rl_start)
1000         {
1001           appendmem (dest, original_rl_start, tok.text - original_rl_start);
1002           dest->last_token = dest->len;
1003         }
1004
1005       /* Is this token the stringification operator?  */
1006       if (tok.len == 1
1007           && tok.text[0] == '#')
1008         {
1009           int arg;
1010
1011           if (!lookahead_valid)
1012             error (_("Stringification operator requires an argument."));
1013
1014           arg = find_parameter (&lookahead, is_varargs, va_arg_name,
1015                                 def->argc, def->argv);
1016           if (arg == -1)
1017             error (_("Argument to stringification operator must name "
1018                      "a macro parameter."));
1019
1020           stringify (dest, argv[arg].text, argv[arg].len);
1021
1022           /* Read one token and let the loop iteration code handle the
1023              rest.  */
1024           lookahead_rl_start = replacement_list.text;
1025           lookahead_valid = get_token (&lookahead, &replacement_list);
1026         }
1027       /* Is this token the splicing operator?  */
1028       else if (tok.len == 2
1029                && tok.text[0] == '#'
1030                && tok.text[1] == '#')
1031         error (_("Stray splicing operator"));
1032       /* Is the next token the splicing operator?  */
1033       else if (lookahead_valid
1034                && lookahead.len == 2
1035                && lookahead.text[0] == '#'
1036                && lookahead.text[1] == '#')
1037         {
1038           int finished = 0;
1039           int prev_was_comma = 0;
1040
1041           /* Note that GCC warns if the result of splicing is not a
1042              token.  In the debugger there doesn't seem to be much
1043              benefit from doing this.  */
1044
1045           /* Insert the first token.  */
1046           if (tok.len == 1 && tok.text[0] == ',')
1047             prev_was_comma = 1;
1048           else
1049             {
1050               int arg = find_parameter (&tok, is_varargs, va_arg_name,
1051                                         def->argc, def->argv);
1052
1053               if (arg != -1)
1054                 appendmem (dest, argv[arg].text, argv[arg].len);
1055               else
1056                 appendmem (dest, tok.text, tok.len);
1057             }
1058
1059           /* Apply a possible sequence of ## operators.  */
1060           for (;;)
1061             {
1062               if (! get_token (&tok, &replacement_list))
1063                 error (_("Splicing operator at end of macro"));
1064
1065               /* Handle a comma before a ##.  If we are handling
1066                  varargs, and the token on the right hand side is the
1067                  varargs marker, and the final argument is empty or
1068                  missing, then drop the comma.  This is a GNU
1069                  extension.  There is one ambiguous case here,
1070                  involving pedantic behavior with an empty argument,
1071                  but we settle that in favor of GNU-style (GCC uses an
1072                  option).  If we aren't dealing with varargs, we
1073                  simply insert the comma.  */
1074               if (prev_was_comma)
1075                 {
1076                   if (! (is_varargs
1077                          && tok.len == va_arg_name->len
1078                          && !memcmp (tok.text, va_arg_name->text, tok.len)
1079                          && argv[argc - 1].len == 0))
1080                     appendmem (dest, ",", 1);
1081                   prev_was_comma = 0;
1082                 }
1083
1084               /* Insert the token.  If it is a parameter, insert the
1085                  argument.  If it is a comma, treat it specially.  */
1086               if (tok.len == 1 && tok.text[0] == ',')
1087                 prev_was_comma = 1;
1088               else
1089                 {
1090                   int arg = find_parameter (&tok, is_varargs, va_arg_name,
1091                                             def->argc, def->argv);
1092
1093                   if (arg != -1)
1094                     appendmem (dest, argv[arg].text, argv[arg].len);
1095                   else
1096                     appendmem (dest, tok.text, tok.len);
1097                 }
1098
1099               /* Now read another token.  If it is another splice, we
1100                  loop.  */
1101               original_rl_start = replacement_list.text;
1102               if (! get_token (&tok, &replacement_list))
1103                 {
1104                   finished = 1;
1105                   break;
1106                 }
1107
1108               if (! (tok.len == 2
1109                      && tok.text[0] == '#'
1110                      && tok.text[1] == '#'))
1111                 break;
1112             }
1113
1114           if (prev_was_comma)
1115             {
1116               /* We saw a comma.  Insert it now.  */
1117               appendmem (dest, ",", 1);
1118             }
1119
1120           dest->last_token = dest->len;
1121           if (finished)
1122             lookahead_valid = 0;
1123           else
1124             {
1125               /* Set up for the loop iterator.  */
1126               lookahead = tok;
1127               lookahead_rl_start = original_rl_start;
1128               lookahead_valid = 1;
1129             }
1130         }
1131       else
1132         {
1133           /* Is this token an identifier?  */
1134           int substituted = 0;
1135           int arg = find_parameter (&tok, is_varargs, va_arg_name,
1136                                     def->argc, def->argv);
1137
1138           if (arg != -1)
1139             {
1140               struct macro_buffer arg_src;
1141
1142               /* Expand any macro invocations in the argument text,
1143                  and append the result to dest.  Remember that scan
1144                  mutates its source, so we need to scan a new buffer
1145                  referring to the argument's text, not the argument
1146                  itself.  */
1147               init_shared_buffer (&arg_src, argv[arg].text, argv[arg].len);
1148               scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
1149               substituted = 1;
1150             }
1151
1152           /* If it wasn't a parameter, then just copy it across.  */
1153           if (! substituted)
1154             append_tokens_without_splicing (dest, &tok);
1155         }
1156
1157       if (! lookahead_valid)
1158         break;
1159
1160       tok = lookahead;
1161       original_rl_start = lookahead_rl_start;
1162
1163       lookahead_rl_start = replacement_list.text;
1164       lookahead_valid = get_token (&lookahead, &replacement_list);
1165     }
1166 }
1167
1168
1169 /* Expand a call to a macro named ID, whose definition is DEF.  Append
1170    its expansion to DEST.  SRC is the input text following the ID
1171    token.  We are currently rescanning the expansions of the macros
1172    named in NO_LOOP; don't re-expand them.  Use LOOKUP_FUNC and
1173    LOOKUP_BATON to find definitions for any nested macro references.
1174
1175    Return 1 if we decided to expand it, zero otherwise.  (If it's a
1176    function-like macro name that isn't followed by an argument list,
1177    we don't expand it.)  If we return zero, leave SRC unchanged.  */
1178 static int
1179 expand (const char *id,
1180         struct macro_definition *def, 
1181         struct macro_buffer *dest,
1182         struct macro_buffer *src,
1183         struct macro_name_list *no_loop,
1184         macro_lookup_ftype *lookup_func,
1185         void *lookup_baton)
1186 {
1187   struct macro_name_list new_no_loop;
1188
1189   /* Create a new node to be added to the front of the no-expand list.
1190      This list is appropriate for re-scanning replacement lists, but
1191      it is *not* appropriate for scanning macro arguments; invocations
1192      of the macro whose arguments we are gathering *do* get expanded
1193      there.  */
1194   new_no_loop.name = id;
1195   new_no_loop.next = no_loop;
1196
1197   /* What kind of macro are we expanding?  */
1198   if (def->kind == macro_object_like)
1199     {
1200       struct macro_buffer replacement_list;
1201
1202       init_shared_buffer (&replacement_list, (char *) def->replacement,
1203                           strlen (def->replacement));
1204
1205       scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
1206       return 1;
1207     }
1208   else if (def->kind == macro_function_like)
1209     {
1210       struct cleanup *back_to = make_cleanup (null_cleanup, 0);
1211       int argc = 0;
1212       struct macro_buffer *argv = NULL;
1213       struct macro_buffer substituted;
1214       struct macro_buffer substituted_src;
1215       struct macro_buffer va_arg_name = {0};
1216       int is_varargs = 0;
1217
1218       if (def->argc >= 1)
1219         {
1220           if (strcmp (def->argv[def->argc - 1], "...") == 0)
1221             {
1222               /* In C99-style varargs, substitution is done using
1223                  __VA_ARGS__.  */
1224               init_shared_buffer (&va_arg_name, "__VA_ARGS__",
1225                                   strlen ("__VA_ARGS__"));
1226               is_varargs = 1;
1227             }
1228           else
1229             {
1230               int len = strlen (def->argv[def->argc - 1]);
1231
1232               if (len > 3
1233                   && strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0)
1234                 {
1235                   /* In GNU-style varargs, the name of the
1236                      substitution parameter is the name of the formal
1237                      argument without the "...".  */
1238                   init_shared_buffer (&va_arg_name,
1239                                       (char *) def->argv[def->argc - 1],
1240                                       len - 3);
1241                   is_varargs = 1;
1242                 }
1243             }
1244         }
1245
1246       make_cleanup (free_current_contents, &argv);
1247       argv = gather_arguments (id, src, is_varargs ? def->argc : -1,
1248                                &argc);
1249
1250       /* If we couldn't find any argument list, then we don't expand
1251          this macro.  */
1252       if (! argv)
1253         {
1254           do_cleanups (back_to);
1255           return 0;
1256         }
1257
1258       /* Check that we're passing an acceptable number of arguments for
1259          this macro.  */
1260       if (argc != def->argc)
1261         {
1262           if (is_varargs && argc >= def->argc - 1)
1263             {
1264               /* Ok.  */
1265             }
1266           /* Remember that a sequence of tokens like "foo()" is a
1267              valid invocation of a macro expecting either zero or one
1268              arguments.  */
1269           else if (! (argc == 1
1270                       && argv[0].len == 0
1271                       && def->argc == 0))
1272             error (_("Wrong number of arguments to macro `%s' "
1273                    "(expected %d, got %d)."),
1274                    id, def->argc, argc);
1275         }
1276
1277       /* Note that we don't expand macro invocations in the arguments
1278          yet --- we let subst_args take care of that.  Parameters that
1279          appear as operands of the stringifying operator "#" or the
1280          splicing operator "##" don't get macro references expanded,
1281          so we can't really tell whether it's appropriate to macro-
1282          expand an argument until we see how it's being used.  */
1283       init_buffer (&substituted, 0);
1284       make_cleanup (cleanup_macro_buffer, &substituted);
1285       substitute_args (&substituted, def, is_varargs, &va_arg_name,
1286                        argc, argv, no_loop, lookup_func, lookup_baton);
1287
1288       /* Now `substituted' is the macro's replacement list, with all
1289          argument values substituted into it properly.  Re-scan it for
1290          macro references, but don't expand invocations of this macro.
1291
1292          We create a new buffer, `substituted_src', which points into
1293          `substituted', and scan that.  We can't scan `substituted'
1294          itself, since the tokenization process moves the buffer's
1295          text pointer around, and we still need to be able to find
1296          `substituted's original text buffer after scanning it so we
1297          can free it.  */
1298       init_shared_buffer (&substituted_src, substituted.text, substituted.len);
1299       scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
1300
1301       do_cleanups (back_to);
1302
1303       return 1;
1304     }
1305   else
1306     internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
1307 }
1308
1309
1310 /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
1311    constitute a macro invokation not forbidden in NO_LOOP, append its
1312    expansion to DEST and return non-zero.  Otherwise, return zero, and
1313    leave DEST unchanged.
1314
1315    SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
1316    SRC_FIRST must be a string built by get_token.  */
1317 static int
1318 maybe_expand (struct macro_buffer *dest,
1319               struct macro_buffer *src_first,
1320               struct macro_buffer *src_rest,
1321               struct macro_name_list *no_loop,
1322               macro_lookup_ftype *lookup_func,
1323               void *lookup_baton)
1324 {
1325   gdb_assert (src_first->shared);
1326   gdb_assert (src_rest->shared);
1327   gdb_assert (! dest->shared);
1328
1329   /* Is this token an identifier?  */
1330   if (src_first->is_identifier)
1331     {
1332       /* Make a null-terminated copy of it, since that's what our
1333          lookup function expects.  */
1334       char *id = (char *) xmalloc (src_first->len + 1);
1335       struct cleanup *back_to = make_cleanup (xfree, id);
1336
1337       memcpy (id, src_first->text, src_first->len);
1338       id[src_first->len] = 0;
1339           
1340       /* If we're currently re-scanning the result of expanding
1341          this macro, don't expand it again.  */
1342       if (! currently_rescanning (no_loop, id))
1343         {
1344           /* Does this identifier have a macro definition in scope?  */
1345           struct macro_definition *def = lookup_func (id, lookup_baton);
1346
1347           if (def && expand (id, def, dest, src_rest, no_loop,
1348                              lookup_func, lookup_baton))
1349             {
1350               do_cleanups (back_to);
1351               return 1;
1352             }
1353         }
1354
1355       do_cleanups (back_to);
1356     }
1357
1358   return 0;
1359 }
1360
1361
1362 /* Expand macro references in SRC, appending the results to DEST.
1363    Assume we are re-scanning the result of expanding the macros named
1364    in NO_LOOP, and don't try to re-expand references to them.
1365
1366    SRC must be a shared buffer; DEST must not be one.  */
1367 static void
1368 scan (struct macro_buffer *dest,
1369       struct macro_buffer *src,
1370       struct macro_name_list *no_loop,
1371       macro_lookup_ftype *lookup_func,
1372       void *lookup_baton)
1373 {
1374   gdb_assert (src->shared);
1375   gdb_assert (! dest->shared);
1376
1377   for (;;)
1378     {
1379       struct macro_buffer tok;
1380       char *original_src_start = src->text;
1381
1382       /* Find the next token in SRC.  */
1383       if (! get_token (&tok, src))
1384         break;
1385
1386       /* Just for aesthetics.  If we skipped some whitespace, copy
1387          that to DEST.  */
1388       if (tok.text > original_src_start)
1389         {
1390           appendmem (dest, original_src_start, tok.text - original_src_start);
1391           dest->last_token = dest->len;
1392         }
1393
1394       if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
1395         /* We didn't end up expanding tok as a macro reference, so
1396            simply append it to dest.  */
1397         append_tokens_without_splicing (dest, &tok);
1398     }
1399
1400   /* Just for aesthetics.  If there was any trailing whitespace in
1401      src, copy it to dest.  */
1402   if (src->len)
1403     {
1404       appendmem (dest, src->text, src->len);
1405       dest->last_token = dest->len;
1406     }
1407 }
1408
1409
1410 char *
1411 macro_expand (const char *source,
1412               macro_lookup_ftype *lookup_func,
1413               void *lookup_func_baton)
1414 {
1415   struct macro_buffer src, dest;
1416   struct cleanup *back_to;
1417
1418   init_shared_buffer (&src, (char *) source, strlen (source));
1419
1420   init_buffer (&dest, 0);
1421   dest.last_token = 0;
1422   back_to = make_cleanup (cleanup_macro_buffer, &dest);
1423
1424   scan (&dest, &src, 0, lookup_func, lookup_func_baton);
1425
1426   appendc (&dest, '\0');
1427
1428   discard_cleanups (back_to);
1429   return dest.text;
1430 }
1431
1432
1433 char *
1434 macro_expand_once (const char *source,
1435                    macro_lookup_ftype *lookup_func,
1436                    void *lookup_func_baton)
1437 {
1438   error (_("Expand-once not implemented yet."));
1439 }
1440
1441
1442 char *
1443 macro_expand_next (const char **lexptr,
1444                    macro_lookup_ftype *lookup_func,
1445                    void *lookup_baton)
1446 {
1447   struct macro_buffer src, dest, tok;
1448   struct cleanup *back_to;
1449
1450   /* Set up SRC to refer to the input text, pointed to by *lexptr.  */
1451   init_shared_buffer (&src, (char *) *lexptr, strlen (*lexptr));
1452
1453   /* Set up DEST to receive the expansion, if there is one.  */
1454   init_buffer (&dest, 0);
1455   dest.last_token = 0;
1456   back_to = make_cleanup (cleanup_macro_buffer, &dest);
1457
1458   /* Get the text's first preprocessing token.  */
1459   if (! get_token (&tok, &src))
1460     {
1461       do_cleanups (back_to);
1462       return 0;
1463     }
1464
1465   /* If it's a macro invocation, expand it.  */
1466   if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
1467     {
1468       /* It was a macro invocation!  Package up the expansion as a
1469          null-terminated string and return it.  Set *lexptr to the
1470          start of the next token in the input.  */
1471       appendc (&dest, '\0');
1472       discard_cleanups (back_to);
1473       *lexptr = src.text;
1474       return dest.text;
1475     }
1476   else
1477     {
1478       /* It wasn't a macro invocation.  */
1479       do_cleanups (back_to);
1480       return 0;
1481     }
1482 }