1 /* C preprocessor macro expansion commands for GDB. 2 Copyright (C) 2002, 2007, 2008, 2009 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 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 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 if (line != 0) 162 fprintf_filtered (gdb_stdout, "#define %s", name); 163 else 164 fprintf_filtered (gdb_stdout, "-D%s", name); 165 if (d->kind == macro_function_like) 166 { 167 int i; 168 169 fputs_filtered ("(", gdb_stdout); 170 for (i = 0; i < d->argc; i++) 171 { 172 fputs_filtered (d->argv[i], gdb_stdout); 173 if (i + 1 < d->argc) 174 fputs_filtered (", ", gdb_stdout); 175 } 176 fputs_filtered (")", gdb_stdout); 177 } 178 if (line != 0) 179 fprintf_filtered (gdb_stdout, " %s\n", d->replacement); 180 else 181 fprintf_filtered (gdb_stdout, "=%s\n", d->replacement); 182 } 183 else 184 { 185 fprintf_filtered (gdb_stdout, 186 "The symbol `%s' has no definition as a C/C++" 187 " preprocessor macro\n" 188 "at ", name); 189 show_pp_source_pos (gdb_stdout, ms->file, ms->line); 190 } 191 192 do_cleanups (cleanup_chain); 193 } 194 195 196 197 /* User-defined macros. */ 198 199 static void 200 skip_ws (char **expp) 201 { 202 while (macro_is_whitespace (**expp)) 203 ++*expp; 204 } 205 206 /* Try to find the bounds of an identifier. If an identifier is 207 found, returns a newly allocated string; otherwise returns NULL. 208 EXPP is a pointer to an input string; it is updated to point to the 209 text following the identifier. If IS_PARAMETER is true, this 210 function will also allow "..." forms as used in varargs macro 211 parameters. */ 212 213 static char * 214 extract_identifier (char **expp, int is_parameter) 215 { 216 char *result; 217 char *p = *expp; 218 unsigned int len; 219 220 if (is_parameter && !strncmp (p, "...", 3)) 221 { 222 /* Ok. */ 223 } 224 else 225 { 226 if (! *p || ! macro_is_identifier_nondigit (*p)) 227 return NULL; 228 for (++p; 229 *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p)); 230 ++p) 231 ; 232 } 233 234 if (is_parameter && !strncmp (p, "...", 3)) 235 p += 3; 236 237 len = p - *expp; 238 result = (char *) xmalloc (len + 1); 239 memcpy (result, *expp, len); 240 result[len] = '\0'; 241 *expp += len; 242 return result; 243 } 244 245 /* Helper function to clean up a temporarily-constructed macro object. 246 This assumes that the contents were all allocated with xmalloc. */ 247 static void 248 free_macro_definition_ptr (void *ptr) 249 { 250 int i; 251 struct macro_definition *loc = (struct macro_definition *) ptr; 252 for (i = 0; i < loc->argc; ++i) 253 xfree ((char *) loc->argv[i]); 254 xfree ((char *) loc->argv); 255 /* Note that the 'replacement' field is not allocated. */ 256 } 257 258 static void 259 macro_define_command (char *exp, int from_tty) 260 { 261 struct macro_definition new_macro; 262 char *name = NULL; 263 struct cleanup *cleanup_chain; 264 265 if (!exp) 266 error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]")); 267 268 cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro); 269 make_cleanup (free_current_contents, &name); 270 271 memset (&new_macro, 0, sizeof (struct macro_definition)); 272 273 skip_ws (&exp); 274 name = extract_identifier (&exp, 0); 275 if (! name) 276 error (_("Invalid macro name.")); 277 if (*exp == '(') 278 { 279 /* Function-like macro. */ 280 int alloced = 5; 281 char **argv = (char **) xmalloc (alloced * sizeof (char *)); 282 283 new_macro.kind = macro_function_like; 284 new_macro.argc = 0; 285 new_macro.argv = (const char * const *) argv; 286 287 /* Skip the '(' and whitespace. */ 288 ++exp; 289 skip_ws (&exp); 290 291 while (*exp != ')') 292 { 293 int i; 294 295 if (new_macro.argc == alloced) 296 { 297 alloced *= 2; 298 argv = (char **) xrealloc (argv, alloced * sizeof (char *)); 299 /* Must update new_macro as well... */ 300 new_macro.argv = (const char * const *) argv; 301 } 302 argv[new_macro.argc] = extract_identifier (&exp, 1); 303 if (! argv[new_macro.argc]) 304 error (_("Macro is missing an argument.")); 305 ++new_macro.argc; 306 307 for (i = new_macro.argc - 2; i >= 0; --i) 308 { 309 if (! strcmp (argv[i], argv[new_macro.argc - 1])) 310 error (_("Two macro arguments with identical names.")); 311 } 312 313 skip_ws (&exp); 314 if (*exp == ',') 315 { 316 ++exp; 317 skip_ws (&exp); 318 } 319 else if (*exp != ')') 320 error (_("',' or ')' expected at end of macro arguments.")); 321 } 322 /* Skip the closing paren. */ 323 ++exp; 324 skip_ws (&exp); 325 326 macro_define_function (macro_main (macro_user_macros), -1, name, 327 new_macro.argc, (const char **) new_macro.argv, 328 exp); 329 } 330 else 331 { 332 skip_ws (&exp); 333 macro_define_object (macro_main (macro_user_macros), -1, name, exp); 334 } 335 336 do_cleanups (cleanup_chain); 337 } 338 339 340 static void 341 macro_undef_command (char *exp, int from_tty) 342 { 343 char *name; 344 345 if (!exp) 346 error (_("usage: macro undef NAME")); 347 348 skip_ws (&exp); 349 name = extract_identifier (&exp, 0); 350 if (! name) 351 error (_("Invalid macro name.")); 352 macro_undef (macro_main (macro_user_macros), -1, name); 353 xfree (name); 354 } 355 356 357 static void 358 print_one_macro (const char *name, const struct macro_definition *macro, 359 void *ignore) 360 { 361 fprintf_filtered (gdb_stdout, "macro define %s", name); 362 if (macro->kind == macro_function_like) 363 { 364 int i; 365 fprintf_filtered (gdb_stdout, "("); 366 for (i = 0; i < macro->argc; ++i) 367 fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "", 368 macro->argv[i]); 369 fprintf_filtered (gdb_stdout, ")"); 370 } 371 fprintf_filtered (gdb_stdout, " %s\n", macro->replacement); 372 } 373 374 375 static void 376 macro_list_command (char *exp, int from_tty) 377 { 378 macro_for_each (macro_user_macros, print_one_macro, NULL); 379 } 380 381 382 383 /* Initializing the `macrocmd' module. */ 384 385 extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */ 386 387 void 388 _initialize_macrocmd (void) 389 { 390 struct cmd_list_element *c; 391 392 /* We introduce a new command prefix, `macro', under which we'll put 393 the various commands for working with preprocessor macros. */ 394 add_prefix_cmd ("macro", class_info, macro_command, 395 _("Prefix for commands dealing with C preprocessor macros."), 396 ¯olist, "macro ", 0, &cmdlist); 397 398 add_cmd ("expand", no_class, macro_expand_command, _("\ 399 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\ 400 Show the expanded expression."), 401 ¯olist); 402 add_alias_cmd ("exp", "expand", no_class, 1, ¯olist); 403 add_cmd ("expand-once", no_class, macro_expand_once_command, _("\ 404 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\ 405 Show the expanded expression.\n\ 406 \n\ 407 This command differs from `macro expand' in that it only expands macro\n\ 408 invocations that appear directly in EXPRESSION; if expanding a macro\n\ 409 introduces further macro invocations, those are left unexpanded.\n\ 410 \n\ 411 `macro expand-once' helps you see how a particular macro expands,\n\ 412 whereas `macro expand' shows you how all the macros involved in an\n\ 413 expression work together to yield a pre-processed expression."), 414 ¯olist); 415 add_alias_cmd ("exp1", "expand-once", no_class, 1, ¯olist); 416 417 add_cmd ("macro", no_class, info_macro_command, 418 _("Show the definition of MACRO, and its source location."), 419 &infolist); 420 421 add_cmd ("define", no_class, macro_define_command, _("\ 422 Define a new C/C++ preprocessor macro.\n\ 423 The GDB command `macro define DEFINITION' is equivalent to placing a\n\ 424 preprocessor directive of the form `#define DEFINITION' such that the\n\ 425 definition is visible in all the inferior's source files.\n\ 426 For example:\n\ 427 (gdb) macro define PI (3.1415926)\n\ 428 (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"), 429 ¯olist); 430 431 add_cmd ("undef", no_class, macro_undef_command, _("\ 432 Remove the definition of the C/C++ preprocessor macro with the given name."), 433 ¯olist); 434 435 add_cmd ("list", no_class, macro_list_command, 436 _("List all the macros defined using the `macro define' command."), 437 ¯olist); 438 } 439