2003-09-08 Andrew Cagney <cagney@redhat.com>
[external/binutils.git] / gdb / macroexp.c
1 /* C preprocessor macro expansion for GDB.
2    Copyright 2002 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 2 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, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA.  */
21
22 #include "defs.h"
23 #include "gdb_obstack.h"
24 #include "bcache.h"
25 #include "macrotab.h"
26 #include "macroexp.h"
27 #include "gdb_assert.h"
28
29
30 \f
31 /* A resizeable, substringable string type.  */
32
33
34 /* A string type that we can resize, quickly append to, and use to
35    refer to substrings of other strings.  */
36 struct macro_buffer
37 {
38   /* An array of characters.  The first LEN bytes are the real text,
39      but there are SIZE bytes allocated to the array.  If SIZE is
40      zero, then this doesn't point to a malloc'ed block.  If SHARED is
41      non-zero, then this buffer is actually a pointer into some larger
42      string, and we shouldn't append characters to it, etc.  Because
43      of sharing, we can't assume in general that the text is
44      null-terminated.  */
45   char *text;
46
47   /* The number of characters in the string.  */
48   int len;
49
50   /* The number of characters allocated to the string.  If SHARED is
51      non-zero, this is meaningless; in this case, we set it to zero so
52      that any "do we have room to append something?" tests will fail,
53      so we don't always have to check SHARED before using this field.  */
54   int size;
55
56   /* Zero if TEXT can be safely realloc'ed (i.e., it's its own malloc
57      block).  Non-zero if TEXT is actually pointing into the middle of
58      some other block, and we shouldn't reallocate it.  */
59   int shared;
60
61   /* For detecting token splicing. 
62
63      This is the index in TEXT of the first character of the token
64      that abuts the end of TEXT.  If TEXT contains no tokens, then we
65      set this equal to LEN.  If TEXT ends in whitespace, then there is
66      no token abutting the end of TEXT (it's just whitespace), and
67      again, we set this equal to LEN.  We set this to -1 if we don't
68      know the nature of TEXT.  */
69   int last_token;
70
71   /* If this buffer is holding the result from get_token, then this 
72      is non-zero if it is an identifier token, zero otherwise.  */
73   int is_identifier;
74 };
75
76
77 /* Set the macro buffer *B to the empty string, guessing that its
78    final contents will fit in N bytes.  (It'll get resized if it
79    doesn't, so the guess doesn't have to be right.)  Allocate the
80    initial storage with xmalloc.  */
81 static void
82 init_buffer (struct macro_buffer *b, int n)
83 {
84   /* Small value for initial testing.  */
85   n = 1;
86
87   b->size = n;
88   if (n > 0)
89     b->text = (char *) xmalloc (n);
90   else
91     b->text = NULL;
92   b->len = 0;
93   b->shared = 0;
94   b->last_token = -1;
95 }
96
97
98 /* Set the macro buffer *BUF to refer to the LEN bytes at ADDR, as a
99    shared substring.  */
100 static void
101 init_shared_buffer (struct macro_buffer *buf, char *addr, int len)
102 {
103   buf->text = addr;
104   buf->len = len;
105   buf->shared = 1;
106   buf->size = 0;
107   buf->last_token = -1;
108 }
109
110
111 /* Free the text of the buffer B.  Raise an error if B is shared.  */
112 static void
113 free_buffer (struct macro_buffer *b)
114 {
115   gdb_assert (! b->shared);
116   if (b->size)
117     xfree (b->text);
118 }
119
120
121 /* A cleanup function for macro buffers.  */
122 static void
123 cleanup_macro_buffer (void *untyped_buf)
124 {
125   free_buffer ((struct macro_buffer *) untyped_buf);
126 }
127
128
129 /* Resize the buffer B to be at least N bytes long.  Raise an error if
130    B shouldn't be resized.  */
131 static void
132 resize_buffer (struct macro_buffer *b, int n)
133 {
134   /* We shouldn't be trying to resize shared strings.  */
135   gdb_assert (! b->shared);
136   
137   if (b->size == 0)
138     b->size = n;
139   else
140     while (b->size <= n)
141       b->size *= 2;
142
143   b->text = xrealloc (b->text, b->size);
144 }
145
146
147 /* Append the character C to the buffer B.  */
148 static void
149 appendc (struct macro_buffer *b, int c)
150 {
151   int new_len = b->len + 1;
152
153   if (new_len > b->size)
154     resize_buffer (b, new_len);
155
156   b->text[b->len] = c;
157   b->len = new_len;
158 }
159
160
161 /* Append the LEN bytes at ADDR to the buffer B.  */
162 static void
163 appendmem (struct macro_buffer *b, char *addr, int len)
164 {
165   int new_len = b->len + len;
166
167   if (new_len > b->size)
168     resize_buffer (b, new_len);
169
170   memcpy (b->text + b->len, addr, len);
171   b->len = new_len;
172 }
173
174
175 \f
176 /* Recognizing preprocessor tokens.  */
177
178
179 static int
180 is_whitespace (int c)
181 {
182   return (c == ' '
183           || c == '\t'
184           || c == '\n'
185           || c == '\v'
186           || c == '\f');
187 }
188
189
190 static int
191 is_digit (int c)
192 {
193   return ('0' <= c && c <= '9');
194 }
195
196
197 static int
198 is_identifier_nondigit (int c)
199 {
200   return (c == '_'
201           || ('a' <= c && c <= 'z')
202           || ('A' <= c && c <= 'Z'));
203 }
204
205
206 static void
207 set_token (struct macro_buffer *tok, char *start, char *end)
208 {
209   init_shared_buffer (tok, start, end - start);
210   tok->last_token = 0;
211
212   /* Presumed; get_identifier may overwrite this. */
213   tok->is_identifier = 0;
214 }
215
216
217 static int
218 get_comment (struct macro_buffer *tok, char *p, char *end)
219 {
220   if (p + 2 > end)
221     return 0;
222   else if (p[0] == '/'
223            && p[1] == '*')
224     {
225       char *tok_start = p;
226
227       p += 2;
228
229       for (; p < end; p++)
230         if (p + 2 <= end
231             && p[0] == '*'
232             && p[1] == '/')
233           {
234             p += 2;
235             set_token (tok, tok_start, p);
236             return 1;
237           }
238
239       error ("Unterminated comment in macro expansion.");
240     }
241   else if (p[0] == '/'
242            && p[1] == '/')
243     {
244       char *tok_start = p;
245
246       p += 2;
247       for (; p < end; p++)
248         if (*p == '\n')
249           break;
250
251       set_token (tok, tok_start, p);
252       return 1;
253     }
254   else
255     return 0;
256 }
257
258
259 static int
260 get_identifier (struct macro_buffer *tok, char *p, char *end)
261 {
262   if (p < end
263       && is_identifier_nondigit (*p))
264     {
265       char *tok_start = p;
266
267       while (p < end
268              && (is_identifier_nondigit (*p)
269                  || is_digit (*p)))
270         p++;
271
272       set_token (tok, tok_start, p);
273       tok->is_identifier = 1;
274       return 1;
275     }
276   else
277     return 0;
278 }
279
280
281 static int
282 get_pp_number (struct macro_buffer *tok, char *p, char *end)
283 {
284   if (p < end
285       && (is_digit (*p)
286           || *p == '.'))
287     {
288       char *tok_start = p;
289
290       while (p < end)
291         {
292           if (is_digit (*p)
293               || is_identifier_nondigit (*p)
294               || *p == '.')
295             p++;
296           else if (p + 2 <= end
297                    && strchr ("eEpP.", *p)
298                    && (p[1] == '+' || p[1] == '-'))
299             p += 2;
300           else
301             break;
302         }
303
304       set_token (tok, tok_start, p);
305       return 1;
306     }
307   else
308     return 0;
309 }
310
311
312
313 /* If the text starting at P going up to (but not including) END
314    starts with a character constant, set *TOK to point to that
315    character constant, and return 1.  Otherwise, return zero.
316    Signal an error if it contains a malformed or incomplete character
317    constant.  */
318 static int
319 get_character_constant (struct macro_buffer *tok, char *p, char *end)
320 {
321   /* ISO/IEC 9899:1999 (E)  Section 6.4.4.4  paragraph 1 
322      But of course, what really matters is that we handle it the same
323      way GDB's C/C++ lexer does.  So we call parse_escape in utils.c
324      to handle escape sequences.  */
325   if ((p + 1 <= end && *p == '\'')
326       || (p + 2 <= end && p[0] == 'L' && p[1] == '\''))
327     {
328       char *tok_start = p;
329       char *body_start;
330
331       if (*p == '\'')
332         p++;
333       else if (*p == 'L')
334         p += 2;
335       else
336         gdb_assert (0);
337
338       body_start = p;
339       for (;;)
340         {
341           if (p >= end)
342             error ("Unmatched single quote.");
343           else if (*p == '\'')
344             {
345               if (p == body_start)
346                 error ("A character constant must contain at least one "
347                        "character.");
348               p++;
349               break;
350             }
351           else if (*p == '\\')
352             {
353               p++;
354               parse_escape (&p);
355             }
356           else
357             p++;
358         }
359
360       set_token (tok, tok_start, p);
361       return 1;
362     }
363   else
364     return 0;
365 }
366
367
368 /* If the text starting at P going up to (but not including) END
369    starts with a string literal, set *TOK to point to that string
370    literal, and return 1.  Otherwise, return zero.  Signal an error if
371    it contains a malformed or incomplete string literal.  */
372 static int
373 get_string_literal (struct macro_buffer *tok, char *p, char *end)
374 {
375   if ((p + 1 <= end
376        && *p == '\"')
377       || (p + 2 <= end
378           && p[0] == 'L'
379           && p[1] == '\"'))
380     {
381       char *tok_start = p;
382
383       if (*p == '\"')
384         p++;
385       else if (*p == 'L')
386         p += 2;
387       else
388         gdb_assert (0);
389
390       for (;;)
391         {
392           if (p >= end)
393             error ("Unterminated string in expression.");
394           else if (*p == '\"')
395             {
396               p++;
397               break;
398             }
399           else if (*p == '\n')
400             error ("Newline characters may not appear in string "
401                    "constants.");
402           else if (*p == '\\')
403             {
404               p++;
405               parse_escape (&p);
406             }
407           else
408             p++;
409         }
410
411       set_token (tok, tok_start, p);
412       return 1;
413     }
414   else
415     return 0;
416 }
417
418
419 static int
420 get_punctuator (struct macro_buffer *tok, char *p, char *end)
421 {
422   /* Here, speed is much less important than correctness and clarity.  */
423
424   /* ISO/IEC 9899:1999 (E)  Section 6.4.6  Paragraph 1  */
425   static const char * const punctuators[] = {
426     "[", "]", "(", ")", "{", "}", ".", "->", 
427     "++", "--", "&", "*", "+", "-", "~", "!",
428     "/", "%", "<<", ">>", "<", ">", "<=", ">=", "==", "!=", 
429     "^", "|", "&&", "||",
430     "?", ":", ";", "...",
431     "=", "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|=",
432     ",", "#", "##",
433     "<:", ":>", "<%", "%>", "%:", "%:%:",
434     0
435   };
436
437   int i;
438
439   if (p + 1 <= end)
440     {
441       for (i = 0; punctuators[i]; i++)
442         {
443           const char *punctuator = punctuators[i];
444
445           if (p[0] == punctuator[0])
446             {
447               int len = strlen (punctuator);
448
449               if (p + len <= end
450                   && ! memcmp (p, punctuator, len))
451                 {
452                   set_token (tok, p, p + len);
453                   return 1;
454                 }
455             }
456         }
457     }
458
459   return 0;
460 }
461
462
463 /* Peel the next preprocessor token off of SRC, and put it in TOK.
464    Mutate TOK to refer to the first token in SRC, and mutate SRC to
465    refer to the text after that token.  SRC must be a shared buffer;
466    the resulting TOK will be shared, pointing into the same string SRC
467    does.  Initialize TOK's last_token field.  Return non-zero if we
468    succeed, or 0 if we didn't find any more tokens in SRC.  */
469 static int
470 get_token (struct macro_buffer *tok,
471            struct macro_buffer *src)
472 {
473   char *p = src->text;
474   char *end = p + src->len;
475
476   gdb_assert (src->shared);
477
478   /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
479
480      preprocessing-token: 
481          header-name
482          identifier
483          pp-number
484          character-constant
485          string-literal
486          punctuator
487          each non-white-space character that cannot be one of the above
488
489      We don't have to deal with header-name tokens, since those can
490      only occur after a #include, which we will never see.  */
491
492   while (p < end)
493     if (is_whitespace (*p))
494       p++;
495     else if (get_comment (tok, p, end))
496       p += tok->len;
497     else if (get_pp_number (tok, p, end)
498              || get_character_constant (tok, p, end)
499              || get_string_literal (tok, p, end)
500              /* Note: the grammar in the standard seems to be
501                 ambiguous: L'x' can be either a wide character
502                 constant, or an identifier followed by a normal
503                 character constant.  By trying `get_identifier' after
504                 we try get_character_constant and get_string_literal,
505                 we give the wide character syntax precedence.  Now,
506                 since GDB doesn't handle wide character constants
507                 anyway, is this the right thing to do?  */
508              || get_identifier (tok, p, end)
509              || get_punctuator (tok, p, end))
510       {
511         /* How many characters did we consume, including whitespace?  */
512         int consumed = p - src->text + tok->len;
513         src->text += consumed;
514         src->len -= consumed;
515         return 1;
516       }
517     else 
518       {
519         /* We have found a "non-whitespace character that cannot be
520            one of the above."  Make a token out of it.  */
521         int consumed;
522
523         set_token (tok, p, p + 1);
524         consumed = p - src->text + tok->len;
525         src->text += consumed;
526         src->len -= consumed;
527         return 1;
528       }
529
530   return 0;
531 }
532
533
534 \f
535 /* Appending token strings, with and without splicing  */
536
537
538 /* Append the macro buffer SRC to the end of DEST, and ensure that
539    doing so doesn't splice the token at the end of SRC with the token
540    at the beginning of DEST.  SRC and DEST must have their last_token
541    fields set.  Upon return, DEST's last_token field is set correctly.
542
543    For example:
544
545    If DEST is "(" and SRC is "y", then we can return with
546    DEST set to "(y" --- we've simply appended the two buffers.
547
548    However, if DEST is "x" and SRC is "y", then we must not return
549    with DEST set to "xy" --- that would splice the two tokens "x" and
550    "y" together to make a single token "xy".  However, it would be
551    fine to return with DEST set to "x y".  Similarly, "<" and "<" must
552    yield "< <", not "<<", etc.  */
553 static void
554 append_tokens_without_splicing (struct macro_buffer *dest,
555                                 struct macro_buffer *src)
556 {
557   int original_dest_len = dest->len;
558   struct macro_buffer dest_tail, new_token;
559
560   gdb_assert (src->last_token != -1);
561   gdb_assert (dest->last_token != -1);
562   
563   /* First, just try appending the two, and call get_token to see if
564      we got a splice.  */
565   appendmem (dest, src->text, src->len);
566
567   /* If DEST originally had no token abutting its end, then we can't
568      have spliced anything, so we're done.  */
569   if (dest->last_token == original_dest_len)
570     {
571       dest->last_token = original_dest_len + src->last_token;
572       return;
573     }
574
575   /* Set DEST_TAIL to point to the last token in DEST, followed by
576      all the stuff we just appended.  */
577   init_shared_buffer (&dest_tail,
578                       dest->text + dest->last_token,
579                       dest->len - dest->last_token);
580
581   /* Re-parse DEST's last token.  We know that DEST used to contain
582      at least one token, so if it doesn't contain any after the
583      append, then we must have spliced "/" and "*" or "/" and "/" to
584      make a comment start.  (Just for the record, I got this right
585      the first time.  This is not a bug fix.)  */
586   if (get_token (&new_token, &dest_tail)
587       && (new_token.text + new_token.len
588           == dest->text + original_dest_len))
589     {
590       /* No splice, so we're done.  */
591       dest->last_token = original_dest_len + src->last_token;
592       return;
593     }
594
595   /* Okay, a simple append caused a splice.  Let's chop dest back to
596      its original length and try again, but separate the texts with a
597      space.  */
598   dest->len = original_dest_len;
599   appendc (dest, ' ');
600   appendmem (dest, src->text, src->len);
601
602   init_shared_buffer (&dest_tail,
603                       dest->text + dest->last_token,
604                       dest->len - dest->last_token);
605
606   /* Try to re-parse DEST's last token, as above.  */
607   if (get_token (&new_token, &dest_tail)
608       && (new_token.text + new_token.len
609           == dest->text + original_dest_len))
610     {
611       /* No splice, so we're done.  */
612       dest->last_token = original_dest_len + 1 + src->last_token;
613       return;
614     }
615
616   /* As far as I know, there's no case where inserting a space isn't
617      enough to prevent a splice.  */
618   internal_error (__FILE__, __LINE__,
619                   "unable to avoid splicing tokens during macro expansion");
620 }
621
622
623 \f
624 /* Expanding macros!  */
625
626
627 /* A singly-linked list of the names of the macros we are currently 
628    expanding --- for detecting expansion loops.  */
629 struct macro_name_list {
630   const char *name;
631   struct macro_name_list *next;
632 };
633
634
635 /* Return non-zero if we are currently expanding the macro named NAME,
636    according to LIST; otherwise, return zero.
637
638    You know, it would be possible to get rid of all the NO_LOOP
639    arguments to these functions by simply generating a new lookup
640    function and baton which refuses to find the definition for a
641    particular macro, and otherwise delegates the decision to another
642    function/baton pair.  But that makes the linked list of excluded
643    macros chained through untyped baton pointers, which will make it
644    harder to debug.  :( */
645 static int
646 currently_rescanning (struct macro_name_list *list, const char *name)
647 {
648   for (; list; list = list->next)
649     if (strcmp (name, list->name) == 0)
650       return 1;
651
652   return 0;
653 }
654
655
656 /* Gather the arguments to a macro expansion.
657
658    NAME is the name of the macro being invoked.  (It's only used for
659    printing error messages.)
660
661    Assume that SRC is the text of the macro invocation immediately
662    following the macro name.  For example, if we're processing the
663    text foo(bar, baz), then NAME would be foo and SRC will be (bar,
664    baz).
665
666    If SRC doesn't start with an open paren ( token at all, return
667    zero, leave SRC unchanged, and don't set *ARGC_P to anything.
668
669    If SRC doesn't contain a properly terminated argument list, then
670    raise an error.
671
672    Otherwise, return a pointer to the first element of an array of
673    macro buffers referring to the argument texts, and set *ARGC_P to
674    the number of arguments we found --- the number of elements in the
675    array.  The macro buffers share their text with SRC, and their
676    last_token fields are initialized.  The array is allocated with
677    xmalloc, and the caller is responsible for freeing it.
678
679    NOTE WELL: if SRC starts with a open paren ( token followed
680    immediately by a close paren ) token (e.g., the invocation looks
681    like "foo()"), we treat that as one argument, which happens to be
682    the empty list of tokens.  The caller should keep in mind that such
683    a sequence of tokens is a valid way to invoke one-parameter
684    function-like macros, but also a valid way to invoke zero-parameter
685    function-like macros.  Eeew.
686
687    Consume the tokens from SRC; after this call, SRC contains the text
688    following the invocation.  */
689
690 static struct macro_buffer *
691 gather_arguments (const char *name, struct macro_buffer *src, int *argc_p)
692 {
693   struct macro_buffer tok;
694   int args_len, args_size;
695   struct macro_buffer *args = NULL;
696   struct cleanup *back_to = make_cleanup (free_current_contents, &args);
697
698   /* Does SRC start with an opening paren token?  Read from a copy of
699      SRC, so SRC itself is unaffected if we don't find an opening
700      paren.  */
701   {
702     struct macro_buffer temp;
703     init_shared_buffer (&temp, src->text, src->len);
704
705     if (! get_token (&tok, &temp)
706         || tok.len != 1
707         || tok.text[0] != '(')
708       {
709         discard_cleanups (back_to);
710         return 0;
711       }
712   }
713
714   /* Consume SRC's opening paren.  */
715   get_token (&tok, src);
716
717   args_len = 0;
718   args_size = 1;                /* small for initial testing */
719   args = (struct macro_buffer *) xmalloc (sizeof (*args) * args_size);
720
721   for (;;)
722     {
723       struct macro_buffer *arg;
724       int depth;
725
726       /* Make sure we have room for the next argument.  */
727       if (args_len >= args_size)
728         {
729           args_size *= 2;
730           args = xrealloc (args, sizeof (*args) * args_size);
731         }
732
733       /* Initialize the next argument.  */
734       arg = &args[args_len++];
735       set_token (arg, src->text, src->text);
736
737       /* Gather the argument's tokens.  */
738       depth = 0;
739       for (;;)
740         {
741           char *start = src->text;
742
743           if (! get_token (&tok, src))
744             error ("Malformed argument list for macro `%s'.", name);
745       
746           /* Is tok an opening paren?  */
747           if (tok.len == 1 && tok.text[0] == '(')
748             depth++;
749
750           /* Is tok is a closing paren?  */
751           else if (tok.len == 1 && tok.text[0] == ')')
752             {
753               /* If it's a closing paren at the top level, then that's
754                  the end of the argument list.  */
755               if (depth == 0)
756                 {
757                   discard_cleanups (back_to);
758                   *argc_p = args_len;
759                   return args;
760                 }
761
762               depth--;
763             }
764
765           /* If tok is a comma at top level, then that's the end of
766              the current argument.  */
767           else if (tok.len == 1 && tok.text[0] == ',' && depth == 0)
768             break;
769
770           /* Extend the current argument to enclose this token.  If
771              this is the current argument's first token, leave out any
772              leading whitespace, just for aesthetics.  */
773           if (arg->len == 0)
774             {
775               arg->text = tok.text;
776               arg->len = tok.len;
777               arg->last_token = 0;
778             }
779           else
780             {
781               arg->len = (tok.text + tok.len) - arg->text;
782               arg->last_token = tok.text - arg->text;
783             }
784         }
785     }
786 }
787
788
789 /* The `expand' and `substitute_args' functions both invoke `scan'
790    recursively, so we need a forward declaration somewhere.  */
791 static void scan (struct macro_buffer *dest,
792                   struct macro_buffer *src,
793                   struct macro_name_list *no_loop,
794                   macro_lookup_ftype *lookup_func,
795                   void *lookup_baton);
796
797
798 /* Given the macro definition DEF, being invoked with the actual
799    arguments given by ARGC and ARGV, substitute the arguments into the
800    replacement list, and store the result in DEST.
801
802    If it is necessary to expand macro invocations in one of the
803    arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
804    definitions, and don't expand invocations of the macros listed in
805    NO_LOOP.  */
806 static void
807 substitute_args (struct macro_buffer *dest, 
808                  struct macro_definition *def,
809                  int argc, struct macro_buffer *argv,
810                  struct macro_name_list *no_loop,
811                  macro_lookup_ftype *lookup_func,
812                  void *lookup_baton)
813 {
814   /* A macro buffer for the macro's replacement list.  */
815   struct macro_buffer replacement_list;
816
817   init_shared_buffer (&replacement_list, (char *) def->replacement,
818                       strlen (def->replacement));
819
820   gdb_assert (dest->len == 0);
821   dest->last_token = 0;
822
823   for (;;)
824     {
825       struct macro_buffer tok;
826       char *original_rl_start = replacement_list.text;
827       int substituted = 0;
828       
829       /* Find the next token in the replacement list.  */
830       if (! get_token (&tok, &replacement_list))
831         break;
832
833       /* Just for aesthetics.  If we skipped some whitespace, copy
834          that to DEST.  */
835       if (tok.text > original_rl_start)
836         {
837           appendmem (dest, original_rl_start, tok.text - original_rl_start);
838           dest->last_token = dest->len;
839         }
840
841       /* Is this token the stringification operator?  */
842       if (tok.len == 1
843           && tok.text[0] == '#')
844         error ("Stringification is not implemented yet.");
845
846       /* Is this token the splicing operator?  */
847       if (tok.len == 2
848           && tok.text[0] == '#'
849           && tok.text[1] == '#')
850         error ("Token splicing is not implemented yet.");
851
852       /* Is this token an identifier?  */
853       if (tok.is_identifier)
854         {
855           int i;
856
857           /* Is it the magic varargs parameter?  */
858           if (tok.len == 11
859               && ! memcmp (tok.text, "__VA_ARGS__", 11))
860             error ("Variable-arity macros not implemented yet.");
861
862           /* Is it one of the parameters?  */
863           for (i = 0; i < def->argc; i++)
864             if (tok.len == strlen (def->argv[i])
865                 && ! memcmp (tok.text, def->argv[i], tok.len))
866               {
867                 struct macro_buffer arg_src;
868
869                 /* Expand any macro invocations in the argument text,
870                    and append the result to dest.  Remember that scan
871                    mutates its source, so we need to scan a new buffer
872                    referring to the argument's text, not the argument
873                    itself.  */
874                 init_shared_buffer (&arg_src, argv[i].text, argv[i].len);
875                 scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
876                 substituted = 1;
877                 break;
878               }
879         }
880
881       /* If it wasn't a parameter, then just copy it across.  */
882       if (! substituted)
883         append_tokens_without_splicing (dest, &tok);
884     }
885 }
886
887
888 /* Expand a call to a macro named ID, whose definition is DEF.  Append
889    its expansion to DEST.  SRC is the input text following the ID
890    token.  We are currently rescanning the expansions of the macros
891    named in NO_LOOP; don't re-expand them.  Use LOOKUP_FUNC and
892    LOOKUP_BATON to find definitions for any nested macro references.  
893
894    Return 1 if we decided to expand it, zero otherwise.  (If it's a
895    function-like macro name that isn't followed by an argument list,
896    we don't expand it.)  If we return zero, leave SRC unchanged.  */
897 static int
898 expand (const char *id,
899         struct macro_definition *def, 
900         struct macro_buffer *dest,
901         struct macro_buffer *src,
902         struct macro_name_list *no_loop,
903         macro_lookup_ftype *lookup_func,
904         void *lookup_baton)
905 {
906   struct macro_name_list new_no_loop;
907
908   /* Create a new node to be added to the front of the no-expand list.
909      This list is appropriate for re-scanning replacement lists, but
910      it is *not* appropriate for scanning macro arguments; invocations
911      of the macro whose arguments we are gathering *do* get expanded
912      there.  */
913   new_no_loop.name = id;
914   new_no_loop.next = no_loop;
915
916   /* What kind of macro are we expanding?  */
917   if (def->kind == macro_object_like)
918     {
919       struct macro_buffer replacement_list;
920
921       init_shared_buffer (&replacement_list, (char *) def->replacement,
922                           strlen (def->replacement));
923
924       scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
925       return 1;
926     }
927   else if (def->kind == macro_function_like)
928     {
929       struct cleanup *back_to = make_cleanup (null_cleanup, 0);
930       int argc;
931       struct macro_buffer *argv = NULL;
932       struct macro_buffer substituted;
933       struct macro_buffer substituted_src;
934
935       if (def->argc >= 1
936           && strcmp (def->argv[def->argc - 1], "...") == 0)
937         error ("Varargs macros not implemented yet.");
938
939       make_cleanup (free_current_contents, &argv);
940       argv = gather_arguments (id, src, &argc);
941
942       /* If we couldn't find any argument list, then we don't expand
943          this macro.  */
944       if (! argv)
945         {
946           do_cleanups (back_to);
947           return 0;
948         }
949
950       /* Check that we're passing an acceptable number of arguments for
951          this macro.  */
952       if (argc != def->argc)
953         {
954           /* Remember that a sequence of tokens like "foo()" is a
955              valid invocation of a macro expecting either zero or one
956              arguments.  */
957           if (! (argc == 1
958                  && argv[0].len == 0
959                  && def->argc == 0))
960             error ("Wrong number of arguments to macro `%s' "
961                    "(expected %d, got %d).",
962                    id, def->argc, argc);
963         }
964
965       /* Note that we don't expand macro invocations in the arguments
966          yet --- we let subst_args take care of that.  Parameters that
967          appear as operands of the stringifying operator "#" or the
968          splicing operator "##" don't get macro references expanded,
969          so we can't really tell whether it's appropriate to macro-
970          expand an argument until we see how it's being used.  */
971       init_buffer (&substituted, 0);
972       make_cleanup (cleanup_macro_buffer, &substituted);
973       substitute_args (&substituted, def, argc, argv, no_loop,
974                        lookup_func, lookup_baton);
975
976       /* Now `substituted' is the macro's replacement list, with all
977          argument values substituted into it properly.  Re-scan it for
978          macro references, but don't expand invocations of this macro.
979
980          We create a new buffer, `substituted_src', which points into
981          `substituted', and scan that.  We can't scan `substituted'
982          itself, since the tokenization process moves the buffer's
983          text pointer around, and we still need to be able to find
984          `substituted's original text buffer after scanning it so we
985          can free it.  */
986       init_shared_buffer (&substituted_src, substituted.text, substituted.len);
987       scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
988
989       do_cleanups (back_to);
990
991       return 1;
992     }
993   else
994     internal_error (__FILE__, __LINE__, "bad macro definition kind");
995 }
996
997
998 /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
999    constitute a macro invokation not forbidden in NO_LOOP, append its
1000    expansion to DEST and return non-zero.  Otherwise, return zero, and
1001    leave DEST unchanged.
1002
1003    SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
1004    SRC_FIRST must be a string built by get_token.  */
1005 static int
1006 maybe_expand (struct macro_buffer *dest,
1007               struct macro_buffer *src_first,
1008               struct macro_buffer *src_rest,
1009               struct macro_name_list *no_loop,
1010               macro_lookup_ftype *lookup_func,
1011               void *lookup_baton)
1012 {
1013   gdb_assert (src_first->shared);
1014   gdb_assert (src_rest->shared);
1015   gdb_assert (! dest->shared);
1016
1017   /* Is this token an identifier?  */
1018   if (src_first->is_identifier)
1019     {
1020       /* Make a null-terminated copy of it, since that's what our
1021          lookup function expects.  */
1022       char *id = xmalloc (src_first->len + 1);
1023       struct cleanup *back_to = make_cleanup (xfree, id);
1024       memcpy (id, src_first->text, src_first->len);
1025       id[src_first->len] = 0;
1026           
1027       /* If we're currently re-scanning the result of expanding
1028          this macro, don't expand it again.  */
1029       if (! currently_rescanning (no_loop, id))
1030         {
1031           /* Does this identifier have a macro definition in scope?  */
1032           struct macro_definition *def = lookup_func (id, lookup_baton);
1033
1034           if (def && expand (id, def, dest, src_rest, no_loop,
1035                              lookup_func, lookup_baton))
1036             {
1037               do_cleanups (back_to);
1038               return 1;
1039             }
1040         }
1041
1042       do_cleanups (back_to);
1043     }
1044
1045   return 0;
1046 }
1047
1048
1049 /* Expand macro references in SRC, appending the results to DEST.
1050    Assume we are re-scanning the result of expanding the macros named
1051    in NO_LOOP, and don't try to re-expand references to them.
1052
1053    SRC must be a shared buffer; DEST must not be one.  */
1054 static void
1055 scan (struct macro_buffer *dest,
1056       struct macro_buffer *src,
1057       struct macro_name_list *no_loop,
1058       macro_lookup_ftype *lookup_func,
1059       void *lookup_baton)
1060 {
1061   gdb_assert (src->shared);
1062   gdb_assert (! dest->shared);
1063
1064   for (;;)
1065     {
1066       struct macro_buffer tok;
1067       char *original_src_start = src->text;
1068
1069       /* Find the next token in SRC.  */
1070       if (! get_token (&tok, src))
1071         break;
1072
1073       /* Just for aesthetics.  If we skipped some whitespace, copy
1074          that to DEST.  */
1075       if (tok.text > original_src_start)
1076         {
1077           appendmem (dest, original_src_start, tok.text - original_src_start);
1078           dest->last_token = dest->len;
1079         }
1080
1081       if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
1082         /* We didn't end up expanding tok as a macro reference, so
1083            simply append it to dest.  */
1084         append_tokens_without_splicing (dest, &tok);
1085     }
1086
1087   /* Just for aesthetics.  If there was any trailing whitespace in
1088      src, copy it to dest.  */
1089   if (src->len)
1090     {
1091       appendmem (dest, src->text, src->len);
1092       dest->last_token = dest->len;
1093     }
1094 }
1095
1096
1097 char *
1098 macro_expand (const char *source,
1099               macro_lookup_ftype *lookup_func,
1100               void *lookup_func_baton)
1101 {
1102   struct macro_buffer src, dest;
1103   struct cleanup *back_to;
1104
1105   init_shared_buffer (&src, (char *) source, strlen (source));
1106
1107   init_buffer (&dest, 0);
1108   dest.last_token = 0;
1109   back_to = make_cleanup (cleanup_macro_buffer, &dest);
1110
1111   scan (&dest, &src, 0, lookup_func, lookup_func_baton);
1112
1113   appendc (&dest, '\0');
1114
1115   discard_cleanups (back_to);
1116   return dest.text;
1117 }
1118
1119
1120 char *
1121 macro_expand_once (const char *source,
1122                    macro_lookup_ftype *lookup_func,
1123                    void *lookup_func_baton)
1124 {
1125   error ("Expand-once not implemented yet.");
1126 }
1127
1128
1129 char *
1130 macro_expand_next (char **lexptr,
1131                    macro_lookup_ftype *lookup_func,
1132                    void *lookup_baton)
1133 {
1134   struct macro_buffer src, dest, tok;
1135   struct cleanup *back_to;
1136
1137   /* Set up SRC to refer to the input text, pointed to by *lexptr.  */
1138   init_shared_buffer (&src, *lexptr, strlen (*lexptr));
1139
1140   /* Set up DEST to receive the expansion, if there is one.  */
1141   init_buffer (&dest, 0);
1142   dest.last_token = 0;
1143   back_to = make_cleanup (cleanup_macro_buffer, &dest);
1144
1145   /* Get the text's first preprocessing token.  */
1146   if (! get_token (&tok, &src))
1147     {
1148       do_cleanups (back_to);
1149       return 0;
1150     }
1151
1152   /* If it's a macro invocation, expand it.  */
1153   if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
1154     {
1155       /* It was a macro invocation!  Package up the expansion as a
1156          null-terminated string and return it.  Set *lexptr to the
1157          start of the next token in the input.  */
1158       appendc (&dest, '\0');
1159       discard_cleanups (back_to);
1160       *lexptr = src.text;
1161       return dest.text;
1162     }
1163   else
1164     {
1165       /* It wasn't a macro invocation.  */
1166       do_cleanups (back_to);
1167       return 0;
1168     }
1169 }