gdb:
[external/binutils.git] / gdb / macrocmd.c
1 /* C preprocessor macro expansion commands for GDB.
2    Copyright (C) 2002, 2007, 2008 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
21 #include "defs.h"
22 #include "macrotab.h"
23 #include "macroexp.h"
24 #include "macroscope.h"
25 #include "command.h"
26 #include "gdbcmd.h"
27 #include "gdb_string.h"
28
29 \f
30 /* The `macro' prefix command.  */
31
32 static struct cmd_list_element *macrolist;
33
34 static void
35 macro_command (char *arg, int from_tty)
36 {
37   printf_unfiltered
38     ("\"macro\" must be followed by the name of a macro command.\n");
39   help_list (macrolist, "macro ", -1, gdb_stdout);
40 }
41
42
43 \f
44 /* Macro expansion commands.  */
45
46
47 static void
48 macro_expand_command (char *exp, int from_tty)
49 {
50   struct macro_scope *ms = NULL;
51   char *expanded = NULL;
52   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
53   make_cleanup (free_current_contents, &expanded);
54
55   /* You know, when the user doesn't specify any expression, it would be
56      really cool if this defaulted to the last expression evaluated.
57      Then it would be easy to ask, "Hey, what did I just evaluate?"  But
58      at the moment, the `print' commands don't save the last expression
59      evaluated, just its value.  */
60   if (! exp || ! *exp)
61     error (_("You must follow the `macro expand' command with the"
62            " expression you\n"
63            "want to expand."));
64
65   ms = default_macro_scope ();
66   if (ms)
67     {
68       expanded = macro_expand (exp, standard_macro_lookup, ms);
69       fputs_filtered ("expands to: ", gdb_stdout);
70       fputs_filtered (expanded, gdb_stdout);
71       fputs_filtered ("\n", gdb_stdout);
72     }
73   else
74     fputs_filtered ("GDB has no preprocessor macro information for "
75                     "that code.\n",
76                     gdb_stdout);
77
78   do_cleanups (cleanup_chain);
79   return;
80 }
81
82
83 static void
84 macro_expand_once_command (char *exp, int from_tty)
85 {
86   struct macro_scope *ms = NULL;
87   char *expanded = NULL;
88   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
89   make_cleanup (free_current_contents, &expanded);
90
91   /* You know, when the user doesn't specify any expression, it would be
92      really cool if this defaulted to the last expression evaluated.
93      And it should set the once-expanded text as the new `last
94      expression'.  That way, you could just hit return over and over and
95      see the expression expanded one level at a time.  */
96   if (! exp || ! *exp)
97     error (_("You must follow the `macro expand-once' command with"
98            " the expression\n"
99            "you want to expand."));
100
101   ms = default_macro_scope ();
102   if (ms)
103     {
104       expanded = macro_expand_once (exp, standard_macro_lookup, ms);
105       fputs_filtered ("expands to: ", gdb_stdout);
106       fputs_filtered (expanded, gdb_stdout);
107       fputs_filtered ("\n", gdb_stdout);
108     }
109   else
110     fputs_filtered ("GDB has no preprocessor macro information for "
111                     "that code.\n",
112                     gdb_stdout);
113
114   do_cleanups (cleanup_chain);
115   return;
116 }
117
118
119 static void
120 show_pp_source_pos (struct ui_file *stream,
121                     struct macro_source_file *file,
122                     int line)
123 {
124   fprintf_filtered (stream, "%s:%d\n", file->filename, line);
125
126   while (file->included_by)
127     {
128       fprintf_filtered (gdb_stdout, "  included at %s:%d\n",
129                         file->included_by->filename,
130                         file->included_at_line);
131       file = file->included_by;
132     }
133 }
134
135
136 static void
137 info_macro_command (char *name, int from_tty)
138 {
139   struct macro_scope *ms = NULL;
140   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
141   struct macro_definition *d;
142   
143   if (! name || ! *name)
144     error (_("You must follow the `info macro' command with the name"
145            " of the macro\n"
146            "whose definition you want to see."));
147
148   ms = default_macro_scope ();
149   if (! ms)
150     error (_("GDB has no preprocessor macro information for that code."));
151
152   d = macro_lookup_definition (ms->file, ms->line, name);
153   if (d)
154     {
155       int line;
156       struct macro_source_file *file
157         = macro_definition_location (ms->file, ms->line, name, &line);
158
159       fprintf_filtered (gdb_stdout, "Defined at ");
160       show_pp_source_pos (gdb_stdout, file, line);
161       fprintf_filtered (gdb_stdout, "#define %s", name);
162       if (d->kind == macro_function_like)
163         {
164           int i;
165
166           fputs_filtered ("(", gdb_stdout);
167           for (i = 0; i < d->argc; i++)
168             {
169               fputs_filtered (d->argv[i], gdb_stdout);
170               if (i + 1 < d->argc)
171                 fputs_filtered (", ", gdb_stdout);
172             }
173           fputs_filtered (")", gdb_stdout);
174         }
175       fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
176     }
177   else
178     {
179       fprintf_filtered (gdb_stdout,
180                         "The symbol `%s' has no definition as a C/C++"
181                         " preprocessor macro\n"
182                         "at ", name);
183       show_pp_source_pos (gdb_stdout, ms->file, ms->line);
184     }
185
186   do_cleanups (cleanup_chain);
187 }
188
189
190 \f
191 /* User-defined macros.  */
192
193 static void
194 skip_ws (char **expp)
195 {
196   while (macro_is_whitespace (**expp))
197     ++*expp;
198 }
199
200 static char *
201 extract_identifier (char **expp)
202 {
203   char *result;
204   char *p = *expp;
205   unsigned int len;
206   if (! *p || ! macro_is_identifier_nondigit (*p))
207     return NULL;
208   for (++p;
209        *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p));
210        ++p)
211     ;
212   len = p - *expp;
213   result = (char *) xmalloc (len + 1);
214   memcpy (result, *expp, len);
215   result[len] = '\0';
216   *expp += len;
217   return result;
218 }
219
220 /* Helper function to clean up a temporarily-constructed macro object.
221    This assumes that the contents were all allocated with xmalloc.  */
222 static void
223 free_macro_definition_ptr (void *ptr)
224 {
225   int i;
226   struct macro_definition *loc = (struct macro_definition *) ptr;
227   for (i = 0; i < loc->argc; ++i)
228     xfree ((char *) loc->argv[i]);
229   xfree ((char *) loc->argv);
230   /* Note that the 'replacement' field is not allocated.  */
231 }
232
233 static void
234 macro_define_command (char *exp, int from_tty)
235 {
236   struct macro_definition new_macro;
237   char *name = NULL;
238   struct cleanup *cleanup_chain;
239
240   if (!exp)
241     error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
242
243   cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro);
244   make_cleanup (free_current_contents, &name);
245
246   memset (&new_macro, 0, sizeof (struct macro_definition));
247
248   skip_ws (&exp);
249   name = extract_identifier (&exp);
250   if (! name)
251     error (_("Invalid macro name."));
252   if (*exp == '(')
253     {
254       /* Function-like macro.  */
255       int alloced = 5;
256       char **argv = (char **) xmalloc (alloced * sizeof (char *));
257
258       new_macro.kind = macro_function_like;
259       new_macro.argc = 0;
260       new_macro.argv = (const char * const *) argv;
261
262       /* Skip the '(' and whitespace.  */
263       ++exp;
264       skip_ws (&exp);
265
266       while (*exp != ')')
267         {
268           int i;
269
270           if (new_macro.argc == alloced)
271             {
272               alloced *= 2;
273               argv = (char **) xrealloc (argv, alloced * sizeof (char *));
274               /* Must update new_macro as well... */
275               new_macro.argv = (const char * const *) argv;
276             }
277           argv[new_macro.argc] = extract_identifier (&exp);
278           if (! argv[new_macro.argc])
279             error (_("Macro is missing an argument."));
280           ++new_macro.argc;
281
282           for (i = new_macro.argc - 2; i >= 0; --i)
283             {
284               if (! strcmp (argv[i], argv[new_macro.argc - 1]))
285                 error (_("Two macro arguments with identical names."));
286             }
287
288           skip_ws (&exp);
289           if (*exp == ',')
290             {
291               ++exp;
292               skip_ws (&exp);
293             }
294           else if (*exp != ')')
295             error (_("',' or ')' expected at end of macro arguments."));
296         }
297       /* Skip the closing paren.  */
298       ++exp;
299
300       macro_define_function (macro_main (macro_user_macros), -1, name,
301                              new_macro.argc, (const char **) new_macro.argv,
302                              exp);
303     }
304   else
305     macro_define_object (macro_main (macro_user_macros), -1, name, exp);
306
307   do_cleanups (cleanup_chain);
308 }
309
310
311 static void
312 macro_undef_command (char *exp, int from_tty)
313 {
314   char *name;
315
316   if (!exp)
317     error (_("usage: macro undef NAME"));
318
319   skip_ws (&exp);
320   name = extract_identifier (&exp);
321   if (! name)
322     error (_("Invalid macro name."));
323   macro_undef (macro_main (macro_user_macros), -1, name);
324   xfree (name);
325 }
326
327
328 static void
329 print_one_macro (const char *name, const struct macro_definition *macro)
330 {
331   fprintf_filtered (gdb_stdout, "macro define %s", name);
332   if (macro->kind == macro_function_like)
333     {
334       int i;
335       fprintf_filtered (gdb_stdout, "(");
336       for (i = 0; i < macro->argc; ++i)
337         fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "",
338                           macro->argv[i]);
339       fprintf_filtered (gdb_stdout, ")");
340     }
341   /* Note that we don't need a leading space here -- "macro define"
342      provided it.  */
343   fprintf_filtered (gdb_stdout, "%s\n", macro->replacement);
344 }
345
346
347 static void
348 macro_list_command (char *exp, int from_tty)
349 {
350   macro_for_each (macro_user_macros, print_one_macro);
351 }
352
353
354 \f
355 /* Initializing the `macrocmd' module.  */
356
357 extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */
358
359 void
360 _initialize_macrocmd (void)
361 {
362   struct cmd_list_element *c;
363
364   /* We introduce a new command prefix, `macro', under which we'll put
365      the various commands for working with preprocessor macros.  */
366   add_prefix_cmd ("macro", class_info, macro_command,
367                   _("Prefix for commands dealing with C preprocessor macros."),
368                   &macrolist, "macro ", 0, &cmdlist);
369
370   add_cmd ("expand", no_class, macro_expand_command, _("\
371 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\
372 Show the expanded expression."),
373            &macrolist);
374   add_alias_cmd ("exp", "expand", no_class, 1, &macrolist);
375   add_cmd ("expand-once", no_class, macro_expand_once_command, _("\
376 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\
377 Show the expanded expression.\n\
378 \n\
379 This command differs from `macro expand' in that it only expands macro\n\
380 invocations that appear directly in EXPRESSION; if expanding a macro\n\
381 introduces further macro invocations, those are left unexpanded.\n\
382 \n\
383 `macro expand-once' helps you see how a particular macro expands,\n\
384 whereas `macro expand' shows you how all the macros involved in an\n\
385 expression work together to yield a pre-processed expression."),
386            &macrolist);
387   add_alias_cmd ("exp1", "expand-once", no_class, 1, &macrolist);
388
389   add_cmd ("macro", no_class, info_macro_command,
390            _("Show the definition of MACRO, and its source location."),
391            &infolist);
392
393   add_cmd ("define", no_class, macro_define_command, _("\
394 Define a new C/C++ preprocessor macro.\n\
395 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
396 preprocessor directive of the form `#define DEFINITION' such that the\n\
397 definition is visible in all the inferior's source files.\n\
398 For example:\n\
399   (gdb) macro define PI (3.1415926)\n\
400   (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
401            &macrolist);
402
403   add_cmd ("undef", no_class, macro_undef_command, _("\
404 Remove the definition of the C/C++ preprocessor macro with the given name."),
405            &macrolist);
406
407   add_cmd ("list", no_class, macro_list_command,
408            _("List all the macros defined using the `macro define' command."),
409            &macrolist);
410 }