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