Include string.h in common-defs.h
[external/binutils.git] / gdb / macrocmd.c
1 /* C preprocessor macro expansion commands for GDB.
2    Copyright (C) 2002-2014 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 "cli/cli-utils.h"
26 #include "command.h"
27 #include "gdbcmd.h"
28 #include "linespec.h"
29
30 \f
31 /* The `macro' prefix command.  */
32
33 static struct cmd_list_element *macrolist;
34
35 static void
36 macro_command (char *arg, int from_tty)
37 {
38   printf_unfiltered
39     ("\"macro\" must be followed by the name of a macro command.\n");
40   help_list (macrolist, "macro ", all_commands, gdb_stdout);
41 }
42
43
44 \f
45 /* Macro expansion commands.  */
46
47
48 /* Prints an informational message regarding the lack of macro information.  */
49 static void
50 macro_inform_no_debuginfo (void)
51 {
52   puts_filtered ("GDB has no preprocessor macro information for that code.\n");
53 }
54
55 static void
56 macro_expand_command (char *exp, int from_tty)
57 {
58   struct macro_scope *ms = NULL;
59   char *expanded = NULL;
60   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
61
62   make_cleanup (free_current_contents, &expanded);
63
64   /* You know, when the user doesn't specify any expression, it would be
65      really cool if this defaulted to the last expression evaluated.
66      Then it would be easy to ask, "Hey, what did I just evaluate?"  But
67      at the moment, the `print' commands don't save the last expression
68      evaluated, just its value.  */
69   if (! exp || ! *exp)
70     error (_("You must follow the `macro expand' command with the"
71            " expression you\n"
72            "want to expand."));
73
74   ms = default_macro_scope ();
75   if (ms)
76     {
77       expanded = macro_expand (exp, standard_macro_lookup, ms);
78       fputs_filtered ("expands to: ", gdb_stdout);
79       fputs_filtered (expanded, gdb_stdout);
80       fputs_filtered ("\n", gdb_stdout);
81     }
82   else
83     macro_inform_no_debuginfo ();
84
85   do_cleanups (cleanup_chain);
86   return;
87 }
88
89
90 static void
91 macro_expand_once_command (char *exp, int from_tty)
92 {
93   struct macro_scope *ms = NULL;
94   char *expanded = NULL;
95   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
96   make_cleanup (free_current_contents, &expanded);
97
98   /* You know, when the user doesn't specify any expression, it would be
99      really cool if this defaulted to the last expression evaluated.
100      And it should set the once-expanded text as the new `last
101      expression'.  That way, you could just hit return over and over and
102      see the expression expanded one level at a time.  */
103   if (! exp || ! *exp)
104     error (_("You must follow the `macro expand-once' command with"
105            " the expression\n"
106            "you want to expand."));
107
108   ms = default_macro_scope ();
109   if (ms)
110     {
111       expanded = macro_expand_once (exp, standard_macro_lookup, ms);
112       fputs_filtered ("expands to: ", gdb_stdout);
113       fputs_filtered (expanded, gdb_stdout);
114       fputs_filtered ("\n", gdb_stdout);
115     }
116   else
117     macro_inform_no_debuginfo ();
118
119   do_cleanups (cleanup_chain);
120   return;
121 }
122
123 /*  Outputs the include path of a macro starting at FILE and LINE to STREAM.
124
125     Care should be taken that this function does not cause any lookups into
126     the splay tree so that it can be safely used while iterating.  */
127 static void
128 show_pp_source_pos (struct ui_file *stream,
129                     struct macro_source_file *file,
130                     int line)
131 {
132   char *fullname;
133
134   fullname = macro_source_fullname (file);
135   fprintf_filtered (stream, "%s:%d\n", fullname, line);
136   xfree (fullname);
137
138   while (file->included_by)
139     {
140       fullname = macro_source_fullname (file->included_by);
141       fprintf_filtered (gdb_stdout, "  included at %s:%d\n", fullname,
142                         file->included_at_line);
143       xfree (fullname);
144       file = file->included_by;
145     }
146 }
147
148 /* Outputs a macro for human consumption, detailing the include path
149    and macro definition.  NAME is the name of the macro.
150    D the definition.  FILE the start of the include path, and LINE the
151    line number in FILE.
152
153    Care should be taken that this function does not cause any lookups into
154    the splay tree so that it can be safely used while iterating.  */
155 static void
156 print_macro_definition (const char *name,
157                         const struct macro_definition *d,
158                         struct macro_source_file *file,
159                         int line)
160 {
161   fprintf_filtered (gdb_stdout, "Defined at ");
162   show_pp_source_pos (gdb_stdout, file, line);
163
164   if (line != 0)
165     fprintf_filtered (gdb_stdout, "#define %s", name);
166   else
167     fprintf_filtered (gdb_stdout, "-D%s", name);
168
169   if (d->kind == macro_function_like)
170     {
171       int i;
172
173       fputs_filtered ("(", gdb_stdout);
174       for (i = 0; i < d->argc; i++)
175         {
176           fputs_filtered (d->argv[i], gdb_stdout);
177           if (i + 1 < d->argc)
178             fputs_filtered (", ", gdb_stdout);
179         }
180       fputs_filtered (")", gdb_stdout);
181     }
182
183   if (line != 0)
184     fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
185   else
186     fprintf_filtered (gdb_stdout, "=%s\n", d->replacement);
187 }
188
189 /* A callback function for usage with macro_for_each and friends.
190    If USER_DATA is null all macros will be printed.
191    Otherwise USER_DATA is considered to be a string, printing
192    only macros who's NAME matches USER_DATA.  Other arguments are
193    routed to print_macro_definition.  */
194 static void
195 print_macro_callback (const char *name, const struct macro_definition *macro,
196                    struct macro_source_file *source, int line,
197                    void *user_data)
198 {
199   if (! user_data || strcmp (user_data, name) == 0)
200     print_macro_definition (name, macro, source, line);
201 }
202
203 /* The implementation of the `info macro' command.  */
204 static void
205 info_macro_command (char *args, int from_tty)
206 {
207   struct macro_scope *ms = NULL;
208   struct cleanup *cleanup_chain;
209   char *name;
210   int show_all_macros_named = 0;
211   char *arg_start = args;
212   int processing_args = 1;
213
214   while (processing_args
215          && arg_start && *arg_start == '-' && *arg_start != '\0')
216     {
217       char *p = skip_to_space (arg_start);
218
219       if (strncmp (arg_start, "-a", p - arg_start) == 0
220           || strncmp (arg_start, "-all", p - arg_start) == 0)
221         show_all_macros_named = 1;
222       else if (strncmp (arg_start, "--", p - arg_start) == 0)
223           /* Our macro support seems rather C specific but this would
224              seem necessary for languages allowing - in macro names.
225              e.g. Scheme's (defmacro ->foo () "bar\n")  */
226         processing_args = 0;
227       else
228         {
229           /* Relies on modified 'args' not making it in to history */
230           *p = '\0';
231           error (_("Unrecognized option '%s' to info macro command.  "
232                    "Try \"help info macro\"."), arg_start);
233         }
234
235         arg_start = skip_spaces (p);
236     }
237
238   name = arg_start;
239
240   if (! name || ! *name)
241     error (_("You must follow the `info macro' command with the name"
242              " of the macro\n"
243              "whose definition you want to see."));
244
245   ms = default_macro_scope ();
246   cleanup_chain = make_cleanup (free_current_contents, &ms);
247
248   if (! ms)
249     macro_inform_no_debuginfo ();
250   else if (show_all_macros_named)
251     macro_for_each (ms->file->table, print_macro_callback, name);
252   else
253     {
254       struct macro_definition *d;
255
256       d = macro_lookup_definition (ms->file, ms->line, name);
257       if (d)
258         {
259           int line;
260           struct macro_source_file *file
261             = macro_definition_location (ms->file, ms->line, name, &line);
262
263           print_macro_definition (name, d, file, line);
264         }
265       else
266         {
267           fprintf_filtered (gdb_stdout,
268                             "The symbol `%s' has no definition as a C/C++"
269                             " preprocessor macro\n"
270                             "at ", name);
271           show_pp_source_pos (gdb_stdout, ms->file, ms->line);
272         }
273     }
274
275   do_cleanups (cleanup_chain);
276 }
277
278 /* Implementation of the "info macros" command. */
279 static void
280 info_macros_command (char *args, int from_tty)
281 {
282   struct macro_scope *ms = NULL;
283   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
284
285   if (args == NULL)
286     ms = default_macro_scope ();
287   else
288     {
289       struct symtabs_and_lines sals =
290         decode_line_with_current_source (args, 0);
291
292       if (sals.nelts)
293         ms = sal_macro_scope (sals.sals[0]);
294     }
295
296   if (! ms || ! ms->file || ! ms->file->table)
297     macro_inform_no_debuginfo ();
298   else
299     macro_for_each_in_scope (ms->file, ms->line, print_macro_callback, NULL);
300
301   do_cleanups (cleanup_chain);
302 }
303
304 \f
305 /* User-defined macros.  */
306
307 static void
308 skip_ws (char **expp)
309 {
310   while (macro_is_whitespace (**expp))
311     ++*expp;
312 }
313
314 /* Try to find the bounds of an identifier.  If an identifier is
315    found, returns a newly allocated string; otherwise returns NULL.
316    EXPP is a pointer to an input string; it is updated to point to the
317    text following the identifier.  If IS_PARAMETER is true, this
318    function will also allow "..." forms as used in varargs macro
319    parameters.  */
320
321 static char *
322 extract_identifier (char **expp, int is_parameter)
323 {
324   char *result;
325   char *p = *expp;
326   unsigned int len;
327
328   if (is_parameter && !strncmp (p, "...", 3))
329     {
330       /* Ok.  */
331     }
332   else
333     {
334       if (! *p || ! macro_is_identifier_nondigit (*p))
335         return NULL;
336       for (++p;
337            *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p));
338            ++p)
339         ;
340     }
341
342   if (is_parameter && !strncmp (p, "...", 3))      
343     p += 3;
344
345   len = p - *expp;
346   result = (char *) xmalloc (len + 1);
347   memcpy (result, *expp, len);
348   result[len] = '\0';
349   *expp += len;
350   return result;
351 }
352
353 /* Helper function to clean up a temporarily-constructed macro object.
354    This assumes that the contents were all allocated with xmalloc.  */
355 static void
356 free_macro_definition_ptr (void *ptr)
357 {
358   int i;
359   struct macro_definition *loc = (struct macro_definition *) ptr;
360
361   for (i = 0; i < loc->argc; ++i)
362     xfree ((char *) loc->argv[i]);
363   xfree ((char *) loc->argv);
364   /* Note that the 'replacement' field is not allocated.  */
365 }
366
367 static void
368 macro_define_command (char *exp, int from_tty)
369 {
370   struct macro_definition new_macro;
371   char *name = NULL;
372   struct cleanup *cleanup_chain;
373
374   if (!exp)
375     error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
376
377   cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro);
378   make_cleanup (free_current_contents, &name);
379
380   memset (&new_macro, 0, sizeof (struct macro_definition));
381
382   skip_ws (&exp);
383   name = extract_identifier (&exp, 0);
384   if (! name)
385     error (_("Invalid macro name."));
386   if (*exp == '(')
387     {
388       /* Function-like macro.  */
389       int alloced = 5;
390       char **argv = (char **) xmalloc (alloced * sizeof (char *));
391
392       new_macro.kind = macro_function_like;
393       new_macro.argc = 0;
394       new_macro.argv = (const char * const *) argv;
395
396       /* Skip the '(' and whitespace.  */
397       ++exp;
398       skip_ws (&exp);
399
400       while (*exp != ')')
401         {
402           int i;
403
404           if (new_macro.argc == alloced)
405             {
406               alloced *= 2;
407               argv = (char **) xrealloc (argv, alloced * sizeof (char *));
408               /* Must update new_macro as well...  */
409               new_macro.argv = (const char * const *) argv;
410             }
411           argv[new_macro.argc] = extract_identifier (&exp, 1);
412           if (! argv[new_macro.argc])
413             error (_("Macro is missing an argument."));
414           ++new_macro.argc;
415
416           for (i = new_macro.argc - 2; i >= 0; --i)
417             {
418               if (! strcmp (argv[i], argv[new_macro.argc - 1]))
419                 error (_("Two macro arguments with identical names."));
420             }
421
422           skip_ws (&exp);
423           if (*exp == ',')
424             {
425               ++exp;
426               skip_ws (&exp);
427             }
428           else if (*exp != ')')
429             error (_("',' or ')' expected at end of macro arguments."));
430         }
431       /* Skip the closing paren.  */
432       ++exp;
433       skip_ws (&exp);
434
435       macro_define_function (macro_main (macro_user_macros), -1, name,
436                              new_macro.argc, (const char **) new_macro.argv,
437                              exp);
438     }
439   else
440     {
441       skip_ws (&exp);
442       macro_define_object (macro_main (macro_user_macros), -1, name, exp);
443     }
444
445   do_cleanups (cleanup_chain);
446 }
447
448
449 static void
450 macro_undef_command (char *exp, int from_tty)
451 {
452   char *name;
453
454   if (!exp)
455     error (_("usage: macro undef NAME"));
456
457   skip_ws (&exp);
458   name = extract_identifier (&exp, 0);
459   if (! name)
460     error (_("Invalid macro name."));
461   macro_undef (macro_main (macro_user_macros), -1, name);
462   xfree (name);
463 }
464
465
466 static void
467 print_one_macro (const char *name, const struct macro_definition *macro,
468                  struct macro_source_file *source, int line,
469                  void *ignore)
470 {
471   fprintf_filtered (gdb_stdout, "macro define %s", name);
472   if (macro->kind == macro_function_like)
473     {
474       int i;
475
476       fprintf_filtered (gdb_stdout, "(");
477       for (i = 0; i < macro->argc; ++i)
478         fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "",
479                           macro->argv[i]);
480       fprintf_filtered (gdb_stdout, ")");
481     }
482   fprintf_filtered (gdb_stdout, " %s\n", macro->replacement);
483 }
484
485
486 static void
487 macro_list_command (char *exp, int from_tty)
488 {
489   macro_for_each (macro_user_macros, print_one_macro, NULL);
490 }
491
492 \f
493 /* Initializing the `macrocmd' module.  */
494
495 extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */
496
497 void
498 _initialize_macrocmd (void)
499 {
500   /* We introduce a new command prefix, `macro', under which we'll put
501      the various commands for working with preprocessor macros.  */
502   add_prefix_cmd ("macro", class_info, macro_command,
503                   _("Prefix for commands dealing with C preprocessor macros."),
504                   &macrolist, "macro ", 0, &cmdlist);
505
506   add_cmd ("expand", no_class, macro_expand_command, _("\
507 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\
508 Show the expanded expression."),
509            &macrolist);
510   add_alias_cmd ("exp", "expand", no_class, 1, &macrolist);
511   add_cmd ("expand-once", no_class, macro_expand_once_command, _("\
512 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\
513 Show the expanded expression.\n\
514 \n\
515 This command differs from `macro expand' in that it only expands macro\n\
516 invocations that appear directly in EXPRESSION; if expanding a macro\n\
517 introduces further macro invocations, those are left unexpanded.\n\
518 \n\
519 `macro expand-once' helps you see how a particular macro expands,\n\
520 whereas `macro expand' shows you how all the macros involved in an\n\
521 expression work together to yield a pre-processed expression."),
522            &macrolist);
523   add_alias_cmd ("exp1", "expand-once", no_class, 1, &macrolist);
524
525   add_cmd ("macro", no_class, info_macro_command,
526            _("Show the definition of MACRO, and it's source location.\n\
527 Usage: info macro [-a|-all] [--] MACRO\n\
528 Options: \n\
529   -a, --all    Output all definitions of MACRO in the current compilation\
530  unit.\n\
531   --           Specify the end of arguments and the beginning of the MACRO."),
532
533            &infolist);
534
535   add_cmd ("macros", no_class, info_macros_command,
536            _("Show the definitions of all macros at LINESPEC, or the current \
537 source location.\n\
538 Usage: info macros [LINESPEC]"),
539            &infolist);
540
541   add_cmd ("define", no_class, macro_define_command, _("\
542 Define a new C/C++ preprocessor macro.\n\
543 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
544 preprocessor directive of the form `#define DEFINITION' such that the\n\
545 definition is visible in all the inferior's source files.\n\
546 For example:\n\
547   (gdb) macro define PI (3.1415926)\n\
548   (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
549            &macrolist);
550
551   add_cmd ("undef", no_class, macro_undef_command, _("\
552 Remove the definition of the C/C++ preprocessor macro with the given name."),
553            &macrolist);
554
555   add_cmd ("list", no_class, macro_list_command,
556            _("List all the macros defined using the `macro define' command."),
557            &macrolist);
558 }