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