1 /* C preprocessor macro expansion commands for GDB. 2 Copyright (C) 2002-2013 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 "gdb_string.h" 29 #include "linespec.h" 30 31 32 /* The `macro' prefix command. */ 33 34 static struct cmd_list_element *macrolist; 35 36 static void 37 macro_command (char *arg, int from_tty) 38 { 39 printf_unfiltered 40 ("\"macro\" must be followed by the name of a macro command.\n"); 41 help_list (macrolist, "macro ", -1, gdb_stdout); 42 } 43 44 45 46 /* Macro expansion commands. */ 47 48 49 /* Prints an informational message regarding the lack of macro information. */ 50 static void macro_inform_no_debuginfo() 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 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 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 ¯olist, "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 ¯olist); 510 add_alias_cmd ("exp", "expand", no_class, 1, ¯olist); 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 ¯olist); 523 add_alias_cmd ("exp1", "expand-once", no_class, 1, ¯olist); 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 ¯olist); 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 ¯olist); 554 555 add_cmd ("list", no_class, macro_list_command, 556 _("List all the macros defined using the `macro define' command."), 557 ¯olist); 558 } 559