GDB (xrefs)

cli-script.c
Go to the documentation of this file.
1 /* GDB CLI command scripting.
2
3 Copyright (C) 1986-2018 Free Software Foundation, 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 #include "defs.h"
21 #include "value.h"
22 #include "language.h" /* For value_true */
23 #include <ctype.h>
24
25 #include "ui-out.h"
26 #include "top.h"
27 #include "breakpoint.h"
28 #include "cli/cli-cmds.h"
29 #include "cli/cli-decode.h"
30 #include "cli/cli-script.h"
31
32 #include "extension.h"
33 #include "interps.h"
34 #include "compile/compile.h"
35
36 #include <vector>
37
38 /* Prototypes for local functions. */
39
40 static enum command_control_type
41 recurse_read_control_structure (char * (*read_next_line_func) (void),
42 struct command_line *current_cmd,
43 void (*validator)(char *, void *),
44 void *closure);
45
46 static char *read_next_line (void);
47
48 /* Level of control structure when reading. */
49 static int control_level;
50
51 /* Level of control structure when executing. */
52 static int command_nest_depth = 1;
53
54 /* This is to prevent certain commands being printed twice. */
55 static int suppress_next_print_command_trace = 0;
56
57 /* A non-owning slice of a string. */
58
59 struct string_view
60 {
61 string_view (const char *str_, size_t len_)
62 : str (str_), len (len_)
63 {}
64
65 const char *str;
66 size_t len;
67 };
68
69 /* Structure for arguments to user defined functions. */
70
71 class user_args
72 {
73 public:
74 /* Save the command line and store the locations of arguments passed
75 to the user defined function. */
76 explicit user_args (const char *line);
77
78 /* Insert the stored user defined arguments into the $arg arguments
79 found in LINE. */
80 std::string insert_args (const char *line) const;
81
82 private:
83 /* Disable copy/assignment. (Since the elements of A point inside
84 COMMAND, copying would need to reconstruct the A vector in the
85 new copy.) */
86 user_args (const user_args &) =delete;
87 user_args &operator= (const user_args &) =delete;
88
89 /* It is necessary to store a copy of the command line to ensure
90 that the arguments are not overwritten before they are used. */
91 std::string m_command_line;
92
93 /* The arguments. Each element points inside M_COMMAND_LINE. */
94 std::vector<string_view> m_args;
95 };
96
97 /* The stack of arguments passed to user defined functions. We need a
98 stack because user-defined functions can call other user-defined
99 functions. */
100 static std::vector<std::unique_ptr<user_args>> user_args_stack;
101
102 /* An RAII-base class used to push/pop args on the user args
103 stack. */
104 struct scoped_user_args_level
105 {
106 /* Parse the command line and push the arguments in the user args
107 stack. */
108 explicit scoped_user_args_level (const char *line)
109 {
110 user_args_stack.emplace_back (new user_args (line));
111 }
112
113 /* Pop the current user arguments from the stack. */
114 ~scoped_user_args_level ()
115 {
116 user_args_stack.pop_back ();
117 }
118 };
119
120
121 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
122 by "end"). */
123
124 static int
125 multi_line_command_p (enum command_control_type type)
126 {
127 switch (type)
128 {
129 case if_control:
130 case while_control:
131 case while_stepping_control:
132 case commands_control:
133 case compile_control:
134 case python_control:
135 case guile_control:
136 return 1;
137 default:
138 return 0;
139 }
140 }
141
142 /* Allocate, initialize a new command line structure for one of the
143 control commands (if/while). */
144
145 static struct command_line *
146 build_command_line (enum command_control_type type, const char *args)
147 {
148 struct command_line *cmd;
149
150 if ((args == NULL || *args == '\0')
151 && (type == if_control || type == while_control))
152 error (_("if/while commands require arguments."));
153 gdb_assert (args != NULL);
154
155 cmd = XNEW (struct command_line);
156 cmd->next = NULL;
157 cmd->control_type = type;
158
159 cmd->body_count = 1;
160 cmd->body_list = XCNEWVEC (struct command_line *, cmd->body_count);
161 cmd->line = xstrdup (args);
162
163 return cmd;
164 }
165
166 /* Build and return a new command structure for the control commands
167 such as "if" and "while". */
168
169 command_line_up
170 get_command_line (enum command_control_type type, const char *arg)
171 {
172 /* Allocate and build a new command line structure. */
173 command_line_up cmd (build_command_line (type, arg));
174
175 /* Read in the body of this command. */
176 if (recurse_read_control_structure (read_next_line, cmd.get (), 0, 0)
177 == invalid_control)
178 {
179 warning (_("Error reading in canned sequence of commands."));
180 return NULL;
181 }
182
183 return cmd;
184 }
185
186 /* Recursively print a command (including full control structures). */
187
188 void
189 print_command_lines (struct ui_out *uiout, struct command_line *cmd,
190 unsigned int depth)
191 {
192 struct command_line *list;
193
194 list = cmd;
195 while (list)
196 {
197 if (depth)
198 uiout->spaces (2 * depth);
199
200 /* A simple command, print it and continue. */
201 if (list->control_type == simple_control)
202 {
203 uiout->field_string (NULL, list->line);
204 uiout->text ("\n");
205 list = list->next;
206 continue;
207 }
208
209 /* loop_continue to jump to the start of a while loop, print it
210 and continue. */
211 if (list->control_type == continue_control)
212 {
213 uiout->field_string (NULL, "loop_continue");
214 uiout->text ("\n");
215 list = list->next;
216 continue;
217 }
218
219 /* loop_break to break out of a while loop, print it and
220 continue. */
221 if (list->control_type == break_control)
222 {
223 uiout->field_string (NULL, "loop_break");
224 uiout->text ("\n");
225 list = list->next;
226 continue;
227 }
228
229 /* A while command. Recursively print its subcommands and
230 continue. */
231 if (list->control_type == while_control
232 || list->control_type == while_stepping_control)
233 {
234 /* For while-stepping, the line includes the 'while-stepping'
235 token. See comment in process_next_line for explanation.
236 Here, take care not print 'while-stepping' twice. */
237 if (list->control_type == while_control)
238 uiout->field_fmt (NULL, "while %s", list->line);
239 else
240 uiout->field_string (NULL, list->line);
241 uiout->text ("\n");
242 print_command_lines (uiout, *list->body_list, depth + 1);
243 if (depth)
244 uiout->spaces (2 * depth);
245 uiout->field_string (NULL, "end");
246 uiout->text ("\n");
247 list = list->next;
248 continue;
249 }
250
251 /* An if command. Recursively print both arms before
252 continueing. */
253 if (list->control_type == if_control)
254 {
255 uiout->field_fmt (NULL, "if %s", list->line);
256 uiout->text ("\n");
257 /* The true arm. */
258 print_command_lines (uiout, list->body_list[0], depth + 1);
259
260 /* Show the false arm if it exists. */
261 if (list->body_count == 2)
262 {
263 if (depth)
264 uiout->spaces (2 * depth);
265 uiout->field_string (NULL, "else");
266 uiout->text ("\n");
267 print_command_lines (uiout, list->body_list[1], depth + 1);
268 }
269
270 if (depth)
271 uiout->spaces (2 * depth);
272 uiout->field_string (NULL, "end");
273 uiout->text ("\n");
274 list = list->next;
275 continue;
276 }
277
278 /* A commands command. Print the breakpoint commands and
279 continue. */
280 if (list->control_type == commands_control)
281 {
282 if (*(list->line))
283 uiout->field_fmt (NULL, "commands %s", list->line);
284 else
285 uiout->field_string (NULL, "commands");
286 uiout->text ("\n");
287 print_command_lines (uiout, *list->body_list, depth + 1);
288 if (depth)
289 uiout->spaces (2 * depth);
290 uiout->field_string (NULL, "end");
291 uiout->text ("\n");
292 list = list->next;
293 continue;
294 }
295
296 if (list->control_type == python_control)
297 {
298 uiout->field_string (NULL, "python");
299 uiout->text ("\n");
300 /* Don't indent python code at all. */
301 print_command_lines (uiout, *list->body_list, 0);
302 if (depth)
303 uiout->spaces (2 * depth);
304 uiout->field_string (NULL, "end");
305 uiout->text ("\n");
306 list = list->next;
307 continue;
308 }
309
310 if (list->control_type == compile_control)
311 {
312 uiout->field_string (NULL, "compile expression");
313 uiout->text ("\n");
314 print_command_lines (uiout, *list->body_list, 0);
315 if (depth)
316 uiout->spaces (2 * depth);
317 uiout->field_string (NULL, "end");
318 uiout->text ("\n");
319 list = list->next;
320 continue;
321 }
322
323 if (list->control_type == guile_control)
324 {
325 uiout->field_string (NULL, "guile");
326 uiout->text ("\n");
327 print_command_lines (uiout, *list->body_list, depth + 1);
328 if (depth)
329 uiout->spaces (2 * depth);
330 uiout->field_string (NULL, "end");
331 uiout->text ("\n");
332 list = list->next;
333 continue;
334 }
335
336 /* Ignore illegal command type and try next. */
337 list = list->next;
338 } /* while (list) */
339 }
340
341 /* Handle pre-post hooks. */
342
343 class scoped_restore_hook_in
344 {
345 public:
346
347 scoped_restore_hook_in (struct cmd_list_element *c)
348 : m_cmd (c)
349 {
350 }
351
352 ~scoped_restore_hook_in ()
353 {
354 m_cmd->hook_in = 0;
355 }
356
357 scoped_restore_hook_in (const scoped_restore_hook_in &) = delete;
358 scoped_restore_hook_in &operator= (const scoped_restore_hook_in &) = delete;
359
360 private:
361
362 struct cmd_list_element *m_cmd;
363 };
364
365 void
366 execute_cmd_pre_hook (struct cmd_list_element *c)
367 {
368 if ((c->hook_pre) && (!c->hook_in))
369 {
370 scoped_restore_hook_in restore_hook (c);
371 c->hook_in = 1; /* Prevent recursive hooking. */
372 execute_user_command (c->hook_pre, nullptr);
373 }
374 }
375
376 void
377 execute_cmd_post_hook (struct cmd_list_element *c)
378 {
379 if ((c->hook_post) && (!c->hook_in))
380 {
381 scoped_restore_hook_in restore_hook (c);
382 c->hook_in = 1; /* Prevent recursive hooking. */
383 execute_user_command (c->hook_post, nullptr);
384 }
385 }
386
387 void
388 execute_user_command (struct cmd_list_element *c, const char *args)
389 {
390 struct ui *ui = current_ui;
391 struct command_line *cmdlines;
392 enum command_control_type ret;
393 extern unsigned int max_user_call_depth;
394
395 cmdlines = c->user_commands;
396 if (cmdlines == 0)
397 /* Null command */
398 return;
399
400 scoped_user_args_level push_user_args (args);
401
402 if (user_args_stack.size () > max_user_call_depth)
403 error (_("Max user call depth exceeded -- command aborted."));
404
405 /* Set the instream to 0, indicating execution of a
406 user-defined function. */
407 scoped_restore restore_instream
408 = make_scoped_restore (&ui->instream, nullptr);
409
410 scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
411
412 scoped_restore save_nesting
413 = make_scoped_restore (&command_nest_depth, command_nest_depth + 1);
414 while (cmdlines)
415 {
416 ret = execute_control_command (cmdlines);
417 if (ret != simple_control && ret != break_control)
418 {
419 warning (_("Error executing canned sequence of commands."));
420 break;
421 }
422 cmdlines = cmdlines->next;
423 }
424 }
425
426 /* This function is called every time GDB prints a prompt. It ensures
427 that errors and the like do not confuse the command tracing. */
428
429 void
430 reset_command_nest_depth (void)
431 {
432 command_nest_depth = 1;
433
434 /* Just in case. */
435 suppress_next_print_command_trace = 0;
436 }
437
438 /* Print the command, prefixed with '+' to represent the call depth.
439 This is slightly complicated because this function may be called
440 from execute_command and execute_control_command. Unfortunately
441 execute_command also prints the top level control commands.
442 In these cases execute_command will call execute_control_command
443 via while_command or if_command. Inner levels of 'if' and 'while'
444 are dealt with directly. Therefore we can use these functions
445 to determine whether the command has been printed already or not. */
446 void
447 print_command_trace (const char *cmd)
448 {
449 int i;
450
451 if (suppress_next_print_command_trace)
452 {
453 suppress_next_print_command_trace = 0;
454 return;
455 }
456
457 if (!source_verbose && !trace_commands)
458 return;
459
460 for (i=0; i < command_nest_depth; i++)
461 printf_filtered ("+");
462
463 printf_filtered ("%s\n", cmd);
464 }
465
466 /* Helper for execute_control_command. */
467
468 static enum command_control_type
469 execute_control_command_1 (struct command_line *cmd)
470 {
471 struct command_line *current;
472 struct value *val;
473 struct value *val_mark;
474 int loop;
475 enum command_control_type ret;
476
477 /* Start by assuming failure, if a problem is detected, the code
478 below will simply "break" out of the switch. */
479 ret = invalid_control;
480
481 switch (cmd->control_type)
482 {
483 case simple_control:
484 {
485 /* A simple command, execute it and return. */
486 std::string new_line = insert_user_defined_cmd_args (cmd->line);
487 execute_command (new_line.c_str (), 0);
488 ret = cmd->control_type;
489 break;
490 }
491
492 case continue_control:
493 print_command_trace ("loop_continue");
494
495 /* Return for "continue", and "break" so we can either
496 continue the loop at the top, or break out. */
497 ret = cmd->control_type;
498 break;
499
500 case break_control:
501 print_command_trace ("loop_break");
502
503 /* Return for "continue", and "break" so we can either
504 continue the loop at the top, or break out. */
505 ret = cmd->control_type;
506 break;
507
508 case while_control:
509 {
510 int len = strlen (cmd->line) + 7;
511 char *buffer = (char *) alloca (len);
512
513 xsnprintf (buffer, len, "while %s", cmd->line);
514 print_command_trace (buffer);
515
516 /* Parse the loop control expression for the while statement. */
517 std::string new_line = insert_user_defined_cmd_args (cmd->line);
518 expression_up expr = parse_expression (new_line.c_str ());
519
520 ret = simple_control;
521 loop = 1;
522
523 /* Keep iterating so long as the expression is true. */
524 while (loop == 1)
525 {
526 int cond_result;
527
528 QUIT;
529
530 /* Evaluate the expression. */
531 val_mark = value_mark ();
532 val = evaluate_expression (expr.get ());
533 cond_result = value_true (val);
534 value_free_to_mark (val_mark);
535
536 /* If the value is false, then break out of the loop. */
537 if (!cond_result)
538 break;
539
540 /* Execute the body of the while statement. */
541 current = *cmd->body_list;
542 while (current)
543 {
544 scoped_restore save_nesting
545 = make_scoped_restore (&command_nest_depth, command_nest_depth + 1);
546 ret = execute_control_command_1 (current);
547
548 /* If we got an error, or a "break" command, then stop
549 looping. */
550 if (ret == invalid_control || ret == break_control)
551 {
552 loop = 0;
553 break;
554 }
555
556 /* If we got a "continue" command, then restart the loop
557 at this point. */
558 if (ret == continue_control)
559 break;
560
561 /* Get the next statement. */
562 current = current->next;
563 }
564 }
565
566 /* Reset RET so that we don't recurse the break all the way down. */
567 if (ret == break_control)
568 ret = simple_control;
569
570 break;
571 }
572
573 case if_control:
574 {
575 int len = strlen (cmd->line) + 4;
576 char *buffer = (char *) alloca (len);
577
578 xsnprintf (buffer, len, "if %s", cmd->line);
579 print_command_trace (buffer);
580
581 /* Parse the conditional for the if statement. */
582 std::string new_line = insert_user_defined_cmd_args (cmd->line);
583 expression_up expr = parse_expression (new_line.c_str ());
584
585 current = NULL;
586 ret = simple_control;
587
588 /* Evaluate the conditional. */
589 val_mark = value_mark ();
590 val = evaluate_expression (expr.get ());
591
592 /* Choose which arm to take commands from based on the value
593 of the conditional expression. */
594 if (value_true (val))
595 current = *cmd->body_list;
596 else if (cmd->body_count == 2)
597 current = *(cmd->body_list + 1);
598 value_free_to_mark (val_mark);
599
600 /* Execute commands in the given arm. */
601 while (current)
602 {
603 scoped_restore save_nesting
604 = make_scoped_restore (&command_nest_depth, command_nest_depth + 1);
605 ret = execute_control_command_1 (current);
606
607 /* If we got an error, get out. */
608 if (ret != simple_control)
609 break;
610
611 /* Get the next statement in the body. */
612 current = current->next;
613 }
614
615 break;
616 }
617
618 case commands_control:
619 {
620 /* Breakpoint commands list, record the commands in the
621 breakpoint's command list and return. */
622 std::string new_line = insert_user_defined_cmd_args (cmd->line);
623 ret = commands_from_control_command (new_line.c_str (), cmd);
624 break;
625 }
626
627 case compile_control:
628 eval_compile_command (cmd, NULL, cmd->control_u.compile.scope,
629 cmd->control_u.compile.scope_data);
630 ret = simple_control;
631 break;
632
633 case python_control:
634 case guile_control:
635 {
636 eval_ext_lang_from_control_command (cmd);
637 ret = simple_control;
638 break;
639 }
640
641 default:
642 warning (_("Invalid control type in canned commands structure."));
643 break;
644 }
645
646 return ret;
647 }
648
649 enum command_control_type
650 execute_control_command (struct command_line *cmd)
651 {
652 /* Make sure we use the console uiout. It's possible that we are executing
653 breakpoint commands while running the MI interpreter. */
654 interp *console = interp_lookup (current_ui, INTERP_CONSOLE);
655 scoped_restore save_uiout
656 = make_scoped_restore (&current_uiout, interp_ui_out (console));
657
658 return execute_control_command_1 (cmd);
659 }
660
661 /* Like execute_control_command, but first set
662 suppress_next_print_command_trace. */
663
664 enum command_control_type
665 execute_control_command_untraced (struct command_line *cmd)
666 {
667 suppress_next_print_command_trace = 1;
668 return execute_control_command (cmd);
669 }
670
671
672 /* "while" command support. Executes a body of statements while the
673 loop condition is nonzero. */
674
675 static void
676 while_command (const char *arg, int from_tty)
677 {
678 control_level = 1;
679 command_line_up command = get_command_line (while_control, arg);
680
681 if (command == NULL)
682 return;
683
684 scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
685
686 execute_control_command_untraced (command.get ());
687 }
688
689 /* "if" command support. Execute either the true or false arm depending
690 on the value of the if conditional. */
691
692 static void
693 if_command (const char *arg, int from_tty)
694 {
695 control_level = 1;
696 command_line_up command = get_command_line (if_control, arg);
697
698 if (command == NULL)
699 return;
700
701 scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
702
703 execute_control_command_untraced (command.get ());
704 }
705
706 /* Bind the incoming arguments for a user defined command to $arg0,
707 $arg1 ... $argN. */
708
709 user_args::user_args (const char *command_line)
710 {
711 const char *p;
712
713 if (command_line == NULL)
714 return;
715
716 m_command_line = command_line;
717 p = m_command_line.c_str ();
718
719 while (*p)
720 {
721 const char *start_arg;
722 int squote = 0;
723 int dquote = 0;
724 int bsquote = 0;
725
726 /* Strip whitespace. */
727 while (*p == ' ' || *p == '\t')
728 p++;
729
730 /* P now points to an argument. */
731 start_arg = p;
732
733 /* Get to the end of this argument. */
734 while (*p)
735 {
736 if (((*p == ' ' || *p == '\t')) && !squote && !dquote && !bsquote)
737 break;
738 else
739 {
740 if (bsquote)
741 bsquote = 0;
742 else if (*p == '\\')
743 bsquote = 1;
744 else if (squote)
745 {
746 if (*p == '\'')
747 squote = 0;
748 }
749 else if (dquote)
750 {
751 if (*p == '"')
752 dquote = 0;
753 }
754 else
755 {
756 if (*p == '\'')
757 squote = 1;
758 else if (*p == '"')
759 dquote = 1;
760 }
761 p++;
762 }
763 }
764
765 m_args.emplace_back (start_arg, p - start_arg);
766 }
767 }
768
769 /* Given character string P, return a point to the first argument
770 ($arg), or NULL if P contains no arguments. */
771
772 static const char *
773 locate_arg (const char *p)
774 {
775 while ((p = strchr (p, '$')))
776 {
777 if (startswith (p, "$arg")
778 && (isdigit (p[4]) || p[4] == 'c'))
779 return p;
780 p++;
781 }
782 return NULL;
783 }
784
785 /* See cli-script.h. */
786
787 std::string
788 insert_user_defined_cmd_args (const char *line)
789 {
790 /* If we are not in a user-defined command, treat $argc, $arg0, et
791 cetera as normal convenience variables. */
792 if (user_args_stack.empty ())
793 return line;
794
795 const std::unique_ptr<user_args> &args = user_args_stack.back ();
796 return args->insert_args (line);
797 }
798
799 /* Insert the user defined arguments stored in user_args into the $arg
800 arguments found in line. */
801
802 std::string
803 user_args::insert_args (const char *line) const
804 {
805 std::string new_line;
806 const char *p;
807
808 while ((p = locate_arg (line)))
809 {
810 new_line.append (line, p - line);
811
812 if (p[4] == 'c')
813 {
814 new_line += std::to_string (m_args.size ());
815 line = p + 5;
816 }
817 else
818 {
819 char *tmp;
820 unsigned long i;
821
822 errno = 0;
823 i = strtoul (p + 4, &tmp, 10);
824 if ((i == 0 && tmp == p + 4) || errno != 0)
825 line = p + 4;
826 else if (i >= m_args.size ())
827 error (_("Missing argument %ld in user function."), i);
828 else
829 {
830 new_line.append (m_args[i].str, m_args[i].len);
831 line = tmp;
832 }
833 }
834 }
835 /* Don't forget the tail. */
836 new_line.append (line);
837
838 return new_line;
839 }
840
841
842 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
843 code bodies. This is typically used when we encounter an "else"
844 clause for an "if" command. */
845
846 static void
847 realloc_body_list (struct command_line *command, int new_length)
848 {
849 int n;
850 struct command_line **body_list;
851
852 n = command->body_count;
853
854 /* Nothing to do? */
855 if (new_length <= n)
856 return;
857
858 body_list = XCNEWVEC (struct command_line *, new_length);
859
860 memcpy (body_list, command->body_list, sizeof (struct command_line *) * n);
861
862 xfree (command->body_list);
863 command->body_list = body_list;
864 command->body_count = new_length;
865 }
866
867 /* Read next line from stdin. Passed to read_command_line_1 and
868 recurse_read_control_structure whenever we need to read commands
869 from stdin. */
870
871 static char *
872 read_next_line (void)
873 {
874 struct ui *ui = current_ui;
875 char *prompt_ptr, control_prompt[256];
876 int i = 0;
877 int from_tty = ui->instream == ui->stdin_stream;
878
879 if (control_level >= 254)
880 error (_("Control nesting too deep!"));
881
882 /* Set a prompt based on the nesting of the control commands. */
883 if (from_tty
884 || (ui->instream == 0 && deprecated_readline_hook != NULL))
885 {
886 for (i = 0; i < control_level; i++)
887 control_prompt[i] = ' ';
888 control_prompt[i] = '>';
889 control_prompt[i + 1] = '\0';
890 prompt_ptr = (char *) &control_prompt[0];
891 }
892 else
893 prompt_ptr = NULL;
894
895 return command_line_input (prompt_ptr, from_tty, "commands");
896 }
897
898 /* Return true if CMD's name is NAME. */
899
900 static bool
901 command_name_equals (struct cmd_list_element *cmd, const char *name)
902 {
903 return (cmd != NULL
904 && cmd != CMD_LIST_AMBIGUOUS
905 && strcmp (cmd->name, name) == 0);
906 }
907
908 /* Given an input line P, skip the command and return a pointer to the
909 first argument. */
910
911 static const char *
912 line_first_arg (const char *p)
913 {
914 const char *first_arg = p + find_command_name_length (p);
915
916 return skip_spaces (first_arg);
917 }
918
919 /* Process one input line. If the command is an "end", return such an
920 indication to the caller. If PARSE_COMMANDS is true, strip leading
921 whitespace (trailing whitespace is always stripped) in the line,
922 attempt to recognize GDB control commands, and also return an
923 indication if the command is an "else" or a nop.
924
925 Otherwise, only "end" is recognized. */
926
927 static enum misc_command_type
928 process_next_line (char *p, struct command_line **command, int parse_commands,
929 void (*validator)(char *, void *), void *closure)
930 {
931 char *p_end;
932 char *p_start;
933 int not_handled = 0;
934
935 /* Not sure what to do here. */
936 if (p == NULL)
937 return end_command;
938
939 /* Strip trailing whitespace. */
940 p_end = p + strlen (p);
941 while (p_end > p && (p_end[-1] == ' ' || p_end[-1] == '\t'))
942 p_end--;
943
944 p_start = p;
945 /* Strip leading whitespace. */
946 while (p_start < p_end && (*p_start == ' ' || *p_start == '\t'))
947 p_start++;
948
949 /* 'end' is always recognized, regardless of parse_commands value.
950 We also permit whitespace before end and after. */
951 if (p_end - p_start == 3 && startswith (p_start, "end"))
952 return end_command;
953
954 if (parse_commands)
955 {
956 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
957 const char *cmd_name = p;
958 struct cmd_list_element *cmd
959 = lookup_cmd_1 (&cmd_name, cmdlist, NULL, 1);
960 cmd_name = skip_spaces (cmd_name);
961 bool inline_cmd = *cmd_name != '\0';
962
963 /* If commands are parsed, we skip initial spaces. Otherwise,
964 which is the case for Python commands and documentation
965 (see the 'document' command), spaces are preserved. */
966 p = p_start;
967
968 /* Blanks and comments don't really do anything, but we need to
969 distinguish them from else, end and other commands which can
970 be executed. */
971 if (p_end == p || p[0] == '#')
972 return nop_command;
973
974 /* Is the else clause of an if control structure? */
975 if (p_end - p == 4 && startswith (p, "else"))
976 return else_command;
977
978 /* Check for while, if, break, continue, etc and build a new
979 command line structure for them. */
980 if (command_name_equals (cmd, "while-stepping"))
981 {
982 /* Because validate_actionline and encode_action lookup
983 command's line as command, we need the line to
984 include 'while-stepping'.
985
986 For 'ws' alias, the command will have 'ws', not expanded
987 to 'while-stepping'. This is intentional -- we don't
988 really want frontend to send a command list with 'ws',
989 and next break-info returning command line with
990 'while-stepping'. This should work, but might cause the
991 breakpoint to be marked as changed while it's actually
992 not. */
993 *command = build_command_line (while_stepping_control, p);
994 }
995 else if (command_name_equals (cmd, "while"))
996 {
997 *command = build_command_line (while_control, line_first_arg (p));
998 }
999 else if (command_name_equals (cmd, "if"))
1000 {
1001 *command = build_command_line (if_control, line_first_arg (p));
1002 }
1003 else if (command_name_equals (cmd, "commands"))
1004 {
1005 *command = build_command_line (commands_control, line_first_arg (p));
1006 }
1007 else if (command_name_equals (cmd, "python") && !inline_cmd)
1008 {
1009 /* Note that we ignore the inline "python command" form
1010 here. */
1011 *command = build_command_line (python_control, "");
1012 }
1013 else if (command_name_equals (cmd, "compile") && !inline_cmd)
1014 {
1015 /* Note that we ignore the inline "compile command" form
1016 here. */
1017 *command = build_command_line (compile_control, "");
1018 (*command)->control_u.compile.scope = COMPILE_I_INVALID_SCOPE;
1019 }
1020 else if (command_name_equals (cmd, "guile") && !inline_cmd)
1021 {
1022 /* Note that we ignore the inline "guile command" form here. */
1023 *command = build_command_line (guile_control, "");
1024 }
1025 else if (p_end - p == 10 && startswith (p, "loop_break"))
1026 {
1027 *command = XNEW (struct command_line);
1028 (*command)->next = NULL;
1029 (*command)->line = NULL;
1030 (*command)->control_type = break_control;
1031 (*command)->body_count = 0;
1032 (*command)->body_list = NULL;
1033 }
1034 else if (p_end - p == 13 && startswith (p, "loop_continue"))
1035 {
1036 *command = XNEW (struct command_line);
1037 (*command)->next = NULL;
1038 (*command)->line = NULL;
1039 (*command)->control_type = continue_control;
1040 (*command)->body_count = 0;
1041 (*command)->body_list = NULL;
1042 }
1043 else
1044 not_handled = 1;
1045 }
1046
1047 if (!parse_commands || not_handled)
1048 {
1049 /* A normal command. */
1050 *command = XNEW (struct command_line);
1051 (*command)->next = NULL;
1052 (*command)->line = savestring (p, p_end - p);
1053 (*command)->control_type = simple_control;
1054 (*command)->body_count = 0;
1055 (*command)->body_list = NULL;
1056 }
1057
1058 if (validator)
1059 {
1060
1061 TRY
1062 {
1063 validator ((*command)->line, closure);
1064 }
1065 CATCH (ex, RETURN_MASK_ALL)
1066 {
1067 xfree (*command);
1068 throw_exception (ex);
1069 }
1070 END_CATCH
1071 }
1072
1073 /* Nothing special. */
1074 return ok_command;
1075 }
1076
1077 /* Recursively read in the control structures and create a
1078 command_line structure from them. Use read_next_line_func to
1079 obtain lines of the command. */
1080
1081 static enum command_control_type
1082 recurse_read_control_structure (char * (*read_next_line_func) (void),
1083 struct command_line *current_cmd,
1084 void (*validator)(char *, void *),
1085 void *closure)
1086 {
1087 int current_body, i;
1088 enum misc_command_type val;
1089 enum command_control_type ret;
1090 struct command_line **body_ptr, *child_tail, *next;
1091
1092 child_tail = NULL;
1093 current_body = 1;
1094
1095 /* Sanity checks. */
1096 if (current_cmd->control_type == simple_control)
1097 error (_("Recursed on a simple control type."));
1098
1099 if (current_body > current_cmd->body_count)
1100 error (_("Allocated body is smaller than this command type needs."));
1101
1102 /* Read lines from the input stream and build control structures. */
1103 while (1)
1104 {
1105 dont_repeat ();
1106
1107 next = NULL;
1108 val = process_next_line (read_next_line_func (), &next,
1109 current_cmd->control_type != python_control
1110 && current_cmd->control_type != guile_control
1111 && current_cmd->control_type != compile_control,
1112 validator, closure);
1113
1114 /* Just skip blanks and comments. */
1115 if (val == nop_command)
1116 continue;
1117
1118 if (val == end_command)
1119 {
1120 if (multi_line_command_p (current_cmd->control_type))
1121 {
1122 /* Success reading an entire canned sequence of commands. */
1123 ret = simple_control;
1124 break;
1125 }
1126 else
1127 {
1128 ret = invalid_control;
1129 break;
1130 }
1131 }
1132
1133 /* Not the end of a control structure. */
1134 if (val == else_command)
1135 {
1136 if (current_cmd->control_type == if_control
1137 && current_body == 1)
1138 {
1139 realloc_body_list (current_cmd, 2);
1140 current_body = 2;
1141 child_tail = NULL;
1142 continue;
1143 }
1144 else
1145 {
1146 ret = invalid_control;
1147 break;
1148 }
1149 }
1150
1151 if (child_tail)
1152 {
1153 child_tail->next = next;
1154 }
1155 else
1156 {
1157 body_ptr = current_cmd->body_list;
1158 for (i = 1; i < current_body; i++)
1159 body_ptr++;
1160
1161 *body_ptr = next;
1162
1163 }
1164
1165 child_tail = next;
1166
1167 /* If the latest line is another control structure, then recurse
1168 on it. */
1169 if (multi_line_command_p (next->control_type))
1170 {
1171 control_level++;
1172 ret = recurse_read_control_structure (read_next_line_func, next,
1173 validator, closure);
1174 control_level--;
1175
1176 if (ret != simple_control)
1177 break;
1178 }
1179 }
1180
1181 dont_repeat ();
1182
1183 return ret;
1184 }
1185
1186 /* Read lines from the input stream and accumulate them in a chain of
1187 struct command_line's, which is then returned. For input from a
1188 terminal, the special command "end" is used to mark the end of the
1189 input, and is not included in the returned chain of commands.
1190
1191 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1192 is always stripped) in the line and attempt to recognize GDB control
1193 commands. Otherwise, only "end" is recognized. */
1194
1195 #define END_MESSAGE "End with a line saying just \"end\"."
1196
1197 command_line_up
1198 read_command_lines (char *prompt_arg, int from_tty, int parse_commands,
1199 void (*validator)(char *, void *), void *closure)
1200 {
1201 if (from_tty && input_interactive_p (current_ui))
1202 {
1203 if (deprecated_readline_begin_hook)
1204 {
1205 /* Note - intentional to merge messages with no newline. */
1206 (*deprecated_readline_begin_hook) ("%s %s\n", prompt_arg,
1207 END_MESSAGE);
1208 }
1209 else
1210 {
1211 printf_unfiltered ("%s\n%s\n", prompt_arg, END_MESSAGE);
1212 gdb_flush (gdb_stdout);
1213 }
1214 }
1215
1216
1217 /* Reading commands assumes the CLI behavior, so temporarily
1218 override the current interpreter with CLI. */
1219 command_line_up head;
1220 if (current_interp_named_p (INTERP_CONSOLE))
1221 head = read_command_lines_1 (read_next_line, parse_commands,
1222 validator, closure);
1223 else
1224 {
1225 scoped_restore_interp interp_restorer (INTERP_CONSOLE);
1226
1227 head = read_command_lines_1 (read_next_line, parse_commands,
1228 validator, closure);
1229 }
1230
1231 if (from_tty && input_interactive_p (current_ui)
1232 && deprecated_readline_end_hook)
1233 {
1234 (*deprecated_readline_end_hook) ();
1235 }
1236 return (head);
1237 }
1238
1239 /* Act the same way as read_command_lines, except that each new line is
1240 obtained using READ_NEXT_LINE_FUNC. */
1241
1242 command_line_up
1243 read_command_lines_1 (char * (*read_next_line_func) (void), int parse_commands,
1244 void (*validator)(char *, void *), void *closure)
1245 {
1246 struct command_line *tail, *next;
1247 command_line_up head;
1248 enum command_control_type ret;
1249 enum misc_command_type val;
1250
1251 control_level = 0;
1252 tail = NULL;
1253
1254 while (1)
1255 {
1256 dont_repeat ();
1257 val = process_next_line (read_next_line_func (), &next, parse_commands,
1258 validator, closure);
1259
1260 /* Ignore blank lines or comments. */
1261 if (val == nop_command)
1262 continue;
1263
1264 if (val == end_command)
1265 {
1266 ret = simple_control;
1267 break;
1268 }
1269
1270 if (val != ok_command)
1271 {
1272 ret = invalid_control;
1273 break;
1274 }
1275
1276 if (multi_line_command_p (next->control_type))
1277 {
1278 control_level++;
1279 ret = recurse_read_control_structure (read_next_line_func, next,
1280 validator, closure);
1281 control_level--;
1282
1283 if (ret == invalid_control)
1284 break;
1285 }
1286
1287 if (tail)
1288 {
1289 tail->next = next;
1290 }
1291 else
1292 {
1293 head.reset (next);
1294 }
1295 tail = next;
1296 }
1297
1298 dont_repeat ();
1299
1300 if (ret == invalid_control)
1301 return NULL;
1302
1303 return head;
1304 }
1305
1306 /* Free a chain of struct command_line's. */
1307
1308 void
1309 free_command_lines (struct command_line **lptr)
1310 {
1311 struct command_line *l = *lptr;
1312 struct command_line *next;
1313 struct command_line **blist;
1314 int i;
1315
1316 while (l)
1317 {
1318 if (l->body_count > 0)
1319 {
1320 blist = l->body_list;
1321 for (i = 0; i < l->body_count; i++, blist++)
1322 free_command_lines (blist);
1323 }
1324 next = l->next;
1325 xfree (l->line);
1326 xfree (l);
1327 l = next;
1328 }
1329 *lptr = NULL;
1330 }
1331
1332 command_line_up
1333 copy_command_lines (struct command_line *cmds)
1334 {
1335 struct command_line *result = NULL;
1336
1337 if (cmds)
1338 {
1339 result = XNEW (struct command_line);
1340
1341 result->next = copy_command_lines (cmds->next).release ();
1342 result->line = xstrdup (cmds->line);
1343 result->control_type = cmds->control_type;
1344 result->body_count = cmds->body_count;
1345 if (cmds->body_count > 0)
1346 {
1347 int i;
1348
1349 result->body_list = XNEWVEC (struct command_line *, cmds->body_count);
1350
1351 for (i = 0; i < cmds->body_count; i++)
1352 result->body_list[i]
1353 = copy_command_lines (cmds->body_list[i]).release ();
1354 }
1355 else
1356 result->body_list = NULL;
1357 }
1358
1359 return command_line_up (result);
1360 }
1361
1362 /* Validate that *COMNAME is a valid name for a command. Return the
1363 containing command list, in case it starts with a prefix command.
1364 The prefix must already exist. *COMNAME is advanced to point after
1365 any prefix, and a NUL character overwrites the space after the
1366 prefix. */
1367
1368 static struct cmd_list_element **
1369 validate_comname (const char **comname)
1370 {
1371 struct cmd_list_element **list = &cmdlist;
1372 const char *p, *last_word;
1373
1374 if (*comname == 0)
1375 error_no_arg (_("name of command to define"));
1376
1377 /* Find the last word of the argument. */
1378 p = *comname + strlen (*comname);
1379 while (p > *comname && isspace (p[-1]))
1380 p--;
1381 while (p > *comname && !isspace (p[-1]))
1382 p--;
1383 last_word = p;
1384
1385 /* Find the corresponding command list. */
1386 if (last_word != *comname)
1387 {
1388 struct cmd_list_element *c;
1389
1390 /* Separate the prefix and the command. */
1391 std::string prefix (*comname, last_word - 1);
1392 const char *tem = prefix.c_str ();
1393
1394 c = lookup_cmd (&tem, cmdlist, "", 0, 1);
1395 if (c->prefixlist == NULL)
1396 error (_("\"%s\" is not a prefix command."), prefix.c_str ());
1397
1398 list = c->prefixlist;
1399 *comname = last_word;
1400 }
1401
1402 p = *comname;
1403 while (*p)
1404 {
1405 if (!isalnum (*p) && *p != '-' && *p != '_')
1406 error (_("Junk in argument list: \"%s\""), p);
1407 p++;
1408 }
1409
1410 return list;
1411 }
1412
1413 /* This is just a placeholder in the command data structures. */
1414 static void
1415 user_defined_command (const char *ignore, int from_tty)
1416 {
1417 }
1418
1419 static void
1420 define_command (const char *comname, int from_tty)
1421 {
1422 #define MAX_TMPBUF 128
1423 enum cmd_hook_type
1424 {
1425 CMD_NO_HOOK = 0,
1426 CMD_PRE_HOOK,
1427 CMD_POST_HOOK
1428 };
1429 struct cmd_list_element *c, *newc, *hookc = 0, **list;
1430 const char *tem, *comfull;
1431 char tmpbuf[MAX_TMPBUF];
1432 int hook_type = CMD_NO_HOOK;
1433 int hook_name_size = 0;
1434
1435 #define HOOK_STRING "hook-"
1436 #define HOOK_LEN 5
1437 #define HOOK_POST_STRING "hookpost-"
1438 #define HOOK_POST_LEN 9
1439
1440 comfull = comname;
1441 list = validate_comname (&comname);
1442
1443 /* Look it up, and verify that we got an exact match. */
1444 tem = comname;
1445 c = lookup_cmd (&tem, *list, "", -1, 1);
1446 if (c && strcmp (comname, c->name) != 0)
1447 c = 0;
1448
1449 if (c)
1450 {
1451 int q;
1452
1453 if (c->theclass == class_user || c->theclass == class_alias)
1454 q = query (_("Redefine command \"%s\"? "), c->name);
1455 else
1456 q = query (_("Really redefine built-in command \"%s\"? "), c->name);
1457 if (!q)
1458 error (_("Command \"%s\" not redefined."), c->name);
1459 }
1460
1461 /* If this new command is a hook, then mark the command which it
1462 is hooking. Note that we allow hooking `help' commands, so that
1463 we can hook the `stop' pseudo-command. */
1464
1465 if (!strncmp (comname, HOOK_STRING, HOOK_LEN))
1466 {
1467 hook_type = CMD_PRE_HOOK;
1468 hook_name_size = HOOK_LEN;
1469 }
1470 else if (!strncmp (comname, HOOK_POST_STRING, HOOK_POST_LEN))
1471 {
1472 hook_type = CMD_POST_HOOK;
1473 hook_name_size = HOOK_POST_LEN;
1474 }
1475
1476 if (hook_type != CMD_NO_HOOK)
1477 {
1478 /* Look up cmd it hooks, and verify that we got an exact match. */
1479 tem = comname + hook_name_size;
1480 hookc = lookup_cmd (&tem, *list, "", -1, 0);
1481 if (hookc && strcmp (comname + hook_name_size, hookc->name) != 0)
1482 hookc = 0;
1483 if (!hookc)
1484 {
1485 warning (_("Your new `%s' command does not "
1486 "hook any existing command."),
1487 comfull);
1488 if (!query (_("Proceed? ")))
1489 error (_("Not confirmed."));
1490 }
1491 }
1492
1493 comname = xstrdup (comname);
1494
1495 xsnprintf (tmpbuf, sizeof (tmpbuf),
1496 "Type commands for definition of \"%s\".", comfull);
1497 command_line_up cmds = read_command_lines (tmpbuf, from_tty, 1, 0, 0);
1498
1499 if (c && c->theclass == class_user)
1500 free_command_lines (&c->user_commands);
1501
1502 newc = add_cmd (comname, class_user, user_defined_command,
1503 (c && c->theclass == class_user)
1504 ? c->doc : xstrdup ("User-defined."), list);
1505 newc->user_commands = cmds.release ();
1506
1507 /* If this new command is a hook, then mark both commands as being
1508 tied. */
1509 if (hookc)
1510 {
1511 switch (hook_type)
1512 {
1513 case CMD_PRE_HOOK:
1514 hookc->hook_pre = newc; /* Target gets hooked. */
1515 newc->hookee_pre = hookc; /* We are marked as hooking target cmd. */
1516 break;
1517 case CMD_POST_HOOK:
1518 hookc->hook_post = newc; /* Target gets hooked. */
1519 newc->hookee_post = hookc; /* We are marked as hooking
1520 target cmd. */
1521 break;
1522 default:
1523 /* Should never come here as hookc would be 0. */
1524 internal_error (__FILE__, __LINE__, _("bad switch"));
1525 }
1526 }
1527 }
1528
1529 static void
1530 document_command (const char *comname, int from_tty)
1531 {
1532 struct cmd_list_element *c, **list;
1533 const char *tem;
1534 const char *comfull;
1535 char tmpbuf[128];
1536
1537 comfull = comname;
1538 list = validate_comname (&comname);
1539
1540 tem = comname;
1541 c = lookup_cmd (&tem, *list, "", 0, 1);
1542
1543 if (c->theclass != class_user)
1544 error (_("Command \"%s\" is built-in."), comfull);
1545
1546 xsnprintf (tmpbuf, sizeof (tmpbuf), "Type documentation for \"%s\".",
1547 comfull);
1548 command_line_up doclines = read_command_lines (tmpbuf, from_tty, 0, 0, 0);
1549
1550 if (c->doc)
1551 xfree ((char *) c->doc);
1552
1553 {
1554 struct command_line *cl1;
1555 int len = 0;
1556 char *doc;
1557
1558 for (cl1 = doclines.get (); cl1; cl1 = cl1->next)
1559 len += strlen (cl1->line) + 1;
1560
1561 doc = (char *) xmalloc (len + 1);
1562 *doc = 0;
1563
1564 for (cl1 = doclines.get (); cl1; cl1 = cl1->next)
1565 {
1566 strcat (doc, cl1->line);
1567 if (cl1->next)
1568 strcat (doc, "\n");
1569 }
1570
1571 c->doc = doc;
1572 }
1573 }
1574
1575 /* Used to implement source_command. */
1576
1577 void
1578 script_from_file (FILE *stream, const char *file)
1579 {
1580 if (stream == NULL)
1581 internal_error (__FILE__, __LINE__, _("called with NULL file pointer!"));
1582
1583 scoped_restore restore_line_number
1584 = make_scoped_restore (&source_line_number, 0);
1585 scoped_restore resotre_file
1586 = make_scoped_restore (&source_file_name, file);
1587
1588 scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
1589
1590 TRY
1591 {
1592 read_command_file (stream);
1593 }
1594 CATCH (e, RETURN_MASK_ERROR)
1595 {
1596 /* Re-throw the error, but with the file name information
1597 prepended. */
1598 throw_error (e.error,
1599 _("%s:%d: Error in sourced command file:\n%s"),
1600 source_file_name, source_line_number, e.message);
1601 }
1602 END_CATCH
1603 }
1604
1605 /* Print the definition of user command C to STREAM. Or, if C is a
1606 prefix command, show the definitions of all user commands under C
1607 (recursively). PREFIX and NAME combined are the name of the
1608 current command. */
1609 void
1610 show_user_1 (struct cmd_list_element *c, const char *prefix, const char *name,
1611 struct ui_file *stream)
1612 {
1613 struct command_line *cmdlines;
1614
1615 if (c->prefixlist != NULL)
1616 {
1617 const char *prefixname = c->prefixname;
1618
1619 for (c = *c->prefixlist; c != NULL; c = c->next)
1620 if (c->theclass == class_user || c->prefixlist != NULL)
1621 show_user_1 (c, prefixname, c->name, gdb_stdout);
1622 return;
1623 }
1624
1625 cmdlines = c->user_commands;
1626 fprintf_filtered (stream, "User command \"%s%s\":\n", prefix, name);
1627
1628 if (!cmdlines)
1629 return;
1630 print_command_lines (current_uiout, cmdlines, 1);
1631 fputs_filtered ("\n", stream);
1632 }
1633
1634 void
1635 _initialize_cli_script (void)
1636 {
1637 add_com ("document", class_support, document_command, _("\
1638 Document a user-defined command.\n\
1639 Give command name as argument. Give documentation on following lines.\n\
1640 End with a line of just \"end\"."));
1641 add_com ("define", class_support, define_command, _("\
1642 Define a new command name. Command name is argument.\n\
1643 Definition appears on following lines, one command per line.\n\
1644 End with a line of just \"end\".\n\
1645 Use the \"document\" command to give documentation for the new command.\n\
1646 Commands defined in this way may have up to ten arguments."));
1647
1648 add_com ("while", class_support, while_command, _("\
1649 Execute nested commands WHILE the conditional expression is non zero.\n\
1650 The conditional expression must follow the word `while' and must in turn be\n\
1651 followed by a new line. The nested commands must be entered one per line,\n\
1652 and should be terminated by the word `end'."));
1653
1654 add_com ("if", class_support, if_command, _("\
1655 Execute nested commands once IF the conditional expression is non zero.\n\
1656 The conditional expression must follow the word `if' and must in turn be\n\
1657 followed by a new line. The nested commands must be entered one per line,\n\
1658 and should be terminated by the word 'else' or `end'. If an else clause\n\
1659 is used, the same rules apply to its nested commands as to the first ones."));
1660 }
error_no_arg
void error_no_arg(const char *why)
Definition: cli-cmds.c:185
top.h
string
const char * string
Definition: signals.c:50
command_line::body_count
int body_count
Definition: cli-script.h:67
command_line
Definition: cli-script.h:51
document_command
static void document_command(const char *comname, int from_tty)
Definition: cli-script.c:1530
cmd_list_element::name
const char * name
Definition: cli-decode.h:52
value_mark
struct value * value_mark(void)
Definition: value.c:1589
cmd_list_element::next
struct cmd_list_element * next
Definition: cli-decode.h:49
while_control
Definition: cli-script.h:38
while_command
static void while_command(const char *arg, int from_tty)
Definition: cli-script.c:676
eval_compile_command
void eval_compile_command(struct command_line *cmd, const char *cmd_string, enum compile_i_scope_types scope, void *scope_data)
Definition: compile.c:622
current_ui
struct ui * current_ui
Definition: event-top.c:453
execute_cmd_pre_hook
void execute_cmd_pre_hook(struct cmd_list_element *c)
Definition: cli-script.c:366
execute_control_command_untraced
enum command_control_type execute_control_command_untraced(struct command_line *cmd)
Definition: cli-script.c:665
user_args::m_args
std::vector< string_view > m_args
Definition: cli-script.c:94
suppress_next_print_command_trace
static int suppress_next_print_command_trace
Definition: cli-script.c:55
ui_out::field_string
void field_string(const char *fldname, const char *string)
Definition: ui-out.c:544
RETURN_MASK_ALL
Definition: common-exceptions.h:44
expression_up
gdb::unique_xmalloc_ptr< expression > expression_up
Definition: expression.h:87
guile_control
Definition: cli-script.h:43
xfree
void xfree(void *)
user_args::m_command_line
std::string m_command_line
Definition: cli-script.c:91
read_command_lines_1
command_line_up read_command_lines_1(char *(*read_next_line_func)(void), int parse_commands, void(*validator)(char *, void *), void *closure)
Definition: cli-script.c:1243
class_support
Definition: command.h:42
command_line_input
char * command_line_input(const char *, int, const char *)
Definition: top.c:1173
cmd_list_element
Definition: cli-decode.h:46
user_defined_command
static void user_defined_command(const char *ignore, int from_tty)
Definition: cli-script.c:1415
if
if(!(yy_init))
Definition: ada-lex.c:1075
warning
void warning(const char *fmt,...)
Definition: errors.c:26
ui::async
int async
Definition: top.h:102
query
int query(const char *ctlstr,...)
Definition: utils.c:1063
get_command_line
command_line_up get_command_line(enum command_control_type type, const char *arg)
Definition: cli-script.c:170
cmd_list_element::hook_post
struct cmd_list_element * hook_post
Definition: cli-decode.h:147
scoped_user_args_level::~scoped_user_args_level
~scoped_user_args_level()
Definition: cli-script.c:114
cmd_list_element::hook_in
unsigned int hook_in
Definition: cli-decode.h:85
scoped_restore_hook_in::operator=
scoped_restore_hook_in & operator=(const scoped_restore_hook_in &)=delete
interp
Definition: interps.h:41
scoped_user_args_level::scoped_user_args_level
scoped_user_args_level(const char *line)
Definition: cli-script.c:108
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
interp_ui_out
struct ui_out * interp_ui_out(struct interp *interp)
Definition: interps.c:257
lookup_cmd
struct cmd_list_element * lookup_cmd(const char **line, struct cmd_list_element *list, const char *cmdtype, int allow_unknown, int ignore_help_classes)
Definition: cli-decode.c:1515
cli-cmds.h
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
cmd_list_element::hookee_post
struct cmd_list_element * hookee_post
Definition: cli-decode.h:196
build_command_line
static struct command_line * build_command_line(enum command_control_type type, const char *args)
Definition: cli-script.c:146
lookup_cmd_1
struct cmd_list_element * lookup_cmd_1(const char **text, struct cmd_list_element *clist, struct cmd_list_element **result_list, int ignore_help_classes)
Definition: cli-decode.c:1385
INTERP_CONSOLE
#define INTERP_CONSOLE
Definition: interps.h:170
cmdlist
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:79
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
validate_comname
static struct cmd_list_element ** validate_comname(const char **comname)
Definition: cli-script.c:1369
_
#define _(String)
Definition: gdb_locale.h:35
ui_file
Definition: ui-file.h:26
defs.h
process_next_line
static enum misc_command_type process_next_line(char *p, struct command_line **command, int parse_commands, void(*validator)(char *, void *), void *closure)
Definition: cli-script.c:928
cmd_list_element::prefix
struct cmd_list_element * prefix
Definition: cli-decode.h:161
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
read_command_lines
command_line_up read_command_lines(char *prompt_arg, int from_tty, int parse_commands, void(*validator)(char *, void *), void *closure)
Definition: cli-script.c:1198
END_MESSAGE
#define END_MESSAGE
Definition: cli-script.c:1195
string_view::str
const char * str
Definition: cli-script.c:65
ui_out::text
void text(const char *string)
Definition: ui-out.c:581
command_line::compile
struct command_line::@21::@22 compile
execute_user_command
void execute_user_command(struct cmd_list_element *c, const char *args)
Definition: cli-script.c:388
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
cli-decode.h
cmd_list_element::user_commands
struct command_line * user_commands
Definition: cli-decode.h:188
XNEW
#define XNEW(T)
Definition: poison.h:109
execute_command
void execute_command(const char *, int)
Definition: top.c:540
make_scoped_restore
scoped_restore_tmpl< T > make_scoped_restore(T *var)
Definition: scoped_restore.h:105
user_args
Definition: cli-script.c:71
end_command
Definition: cli-script.h:28
if_control
Definition: cli-script.h:39
evaluate_expression
struct value * evaluate_expression(struct expression *exp)
Definition: eval.c:144
class_user
Definition: command.h:44
XCNEWVEC
#define XCNEWVEC(T, N)
Definition: poison.h:157
TRY
#define TRY
Definition: common-exceptions.h:246
command_line::line
char * line
Definition: cli-script.h:54
name
const char *const name
Definition: aarch64-tdep.c:76
scoped_user_args_level
Definition: cli-script.c:104
copy_command_lines
command_line_up copy_command_lines(struct command_line *cmds)
Definition: cli-script.c:1333
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
cmd_list_element::hook_pre
struct cmd_list_element * hook_pre
Definition: cli-decode.h:144
source_file_name
const char * source_file_name
Definition: top.c:402
read_next_line
static char * read_next_line(void)
Definition: cli-script.c:872
else_command
Definition: cli-script.h:29
hook_type
void(* hook_type)(const char *)
Definition: corefile.c:45
ui::instream
FILE * instream
Definition: top.h:115
input_interactive_p
int input_interactive_p(struct ui *)
Definition: top.c:1673
eval_ext_lang_from_control_command
void eval_ext_lang_from_control_command(struct command_line *cmd)
Definition: extension.c:353
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
python_control
Definition: cli-script.h:41
continue_control
Definition: cli-script.h:37
invalid_control
Definition: cli-script.h:45
fputs_filtered
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1811
HOOK_POST_STRING
#define HOOK_POST_STRING
current_uiout
#define current_uiout
Definition: ui-out.h:39
cli-script.h
scoped_restore_hook_in
Definition: cli-script.c:343
scoped_restore_base
Definition: scoped_restore.h:24
type
Definition: gdbtypes.h:749
break_control
Definition: cli-script.h:36
class_alias
Definition: command.h:43
line_first_arg
static const char * line_first_arg(const char *p)
Definition: cli-script.c:912
language.h
type
static const char * type
Definition: language.c:113
execute_control_command_1
static enum command_control_type execute_control_command_1(struct command_line *cmd)
Definition: cli-script.c:469
command_control_type
command_control_type
Definition: cli-script.h:33
ui
Definition: top.h:56
commands_control
Definition: cli-script.h:40
user_args::insert_args
std::string insert_args(const char *line) const
Definition: cli-script.c:803
startswith
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:107
CMD_LIST_AMBIGUOUS
#define CMD_LIST_AMBIGUOUS
Definition: command.h:228
scoped_restore_hook_in::m_cmd
struct cmd_list_element * m_cmd
Definition: cli-script.c:362
recurse_read_control_structure
static enum command_control_type recurse_read_control_structure(char *(*read_next_line_func)(void), struct command_line *current_cmd, void(*validator)(char *, void *), void *closure)
Definition: cli-script.c:1082
max_user_call_depth
unsigned int max_user_call_depth
Definition: cli-cmds.c:73
breakpoint.h
scoped_restore_interp
Definition: interps.h:106
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
print_command_lines
void print_command_lines(struct ui_out *uiout, struct command_line *cmd, unsigned int depth)
Definition: cli-script.c:189
while_stepping_control
Definition: cli-script.h:44
xmalloc
void * xmalloc(YYSIZE_T)
script_from_file
void script_from_file(FILE *stream, const char *file)
Definition: cli-script.c:1578
interps.h
locate_arg
static const char * locate_arg(const char *p)
Definition: cli-script.c:773
misc_command_type
misc_command_type
Definition: cli-script.h:25
HOOK_STRING
#define HOOK_STRING
command_name_equals
static bool command_name_equals(struct cmd_list_element *cmd, const char *name)
Definition: cli-script.c:901
extension.h
scoped_restore_hook_in::scoped_restore_hook_in
scoped_restore_hook_in(struct cmd_list_element *c)
Definition: cli-script.c:347
ui_out::spaces
void void spaces(int numspaces)
Definition: ui-out.c:575
deprecated_readline_begin_hook
void(* deprecated_readline_begin_hook)(const char *,...) ATTRIBUTE_FPTR_PRINTF_1
Definition: top.c:214
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
value
Definition: value.c:169
nop_command
Definition: cli-script.h:30
ui_out
Definition: ui-out.h:77
user_args::operator=
user_args & operator=(const user_args &)=delete
MAX_TMPBUF
#define MAX_TMPBUF
insert_user_defined_cmd_args
std::string insert_user_defined_cmd_args(const char *line)
Definition: cli-script.c:788
throw_exception
void throw_exception(struct gdb_exception exception)
Definition: common-exceptions.c:312
command_line::next
struct command_line * next
Definition: cli-script.h:53
command_line::control_type
enum command_control_type control_type
Definition: cli-script.h:55
compile.h
XNEWVEC
#define XNEWVEC(T, N)
Definition: poison.h:145
deprecated_readline_end_hook
void(* deprecated_readline_end_hook)(void)
Definition: top.c:216
execute_cmd_post_hook
void execute_cmd_post_hook(struct cmd_list_element *c)
Definition: cli-script.c:377
multi_line_command_p
static int multi_line_command_p(enum command_control_type type)
Definition: cli-script.c:125
find_command_name_length
int find_command_name_length(const char *text)
Definition: cli-decode.c:1294
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
string_view::len
size_t len
Definition: cli-script.c:66
scoped_restore_hook_in::~scoped_restore_hook_in
~scoped_restore_hook_in()
Definition: cli-script.c:352
simple_control
Definition: cli-script.h:35
if_command
static void if_command(const char *arg, int from_tty)
Definition: cli-script.c:693
define_command
static void define_command(const char *comname, int from_tty)
Definition: cli-script.c:1420
buffer
Definition: buffer.h:23
string_view::string_view
string_view(const char *str_, size_t len_)
Definition: cli-script.c:61
cmd_list_element::theclass
enum command_class theclass
Definition: cli-decode.h:55
user_args::user_args
user_args(const char *line)
Definition: cli-script.c:709
value_free_to_mark
void value_free_to_mark(const struct value *mark)
Definition: value.c:1641
value.h
compile_control
Definition: cli-script.h:42
command_nest_depth
static int command_nest_depth
Definition: cli-script.c:52
reset_command_nest_depth
void reset_command_nest_depth(void)
Definition: cli-script.c:430
source_line_number
int source_line_number
Definition: top.c:396
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
parse_expression
expression_up parse_expression(const char *)
Definition: parse.c:1237
savestring
char * savestring(const char *ptr, size_t len)
Definition: common-utils.c:226
trace_commands
int trace_commands
Definition: cli-cmds.c:164
ui::stdin_stream
FILE * stdin_stream
Definition: top.h:109
cmd_list_element::doc
const char * doc
Definition: cli-decode.h:130
cmd_list_element::prefixlist
struct cmd_list_element ** prefixlist
Definition: cli-decode.h:151
show_user_1
void show_user_1(struct cmd_list_element *c, const char *prefix, const char *name, struct ui_file *stream)
Definition: cli-script.c:1610
HOOK_LEN
#define HOOK_LEN
cmd_list_element::hookee_pre
struct cmd_list_element * hookee_pre
Definition: cli-decode.h:192
command_line_up
std::unique_ptr< command_line, command_lines_deleter > command_line_up
Definition: cli-script.h:88
control_level
static int control_level
Definition: cli-script.c:49
user_args_stack
static std::vector< std::unique_ptr< user_args > > user_args_stack
Definition: cli-script.c:100
dont_repeat
void dont_repeat(void)
Definition: top.c:695
_initialize_cli_script
void _initialize_cli_script(void)
Definition: cli-script.c:1635
print_command_trace
void print_command_trace(const char *cmd)
Definition: cli-script.c:447
gdb_flush
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:93
value_true
int value_true(struct value *val)
Definition: language.c:426
QUIT
#define QUIT
Definition: defs.h:179
realloc_body_list
static void realloc_body_list(struct command_line *command, int new_length)
Definition: cli-script.c:847
add_com
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:902
COMPILE_I_INVALID_SCOPE
Definition: defs.h:63
command_line::body_list
struct command_line ** body_list
Definition: cli-script.h:71
cmd_list_element::prefixname
const char * prefixname
Definition: cli-decode.h:158
HOOK_POST_LEN
#define HOOK_POST_LEN
current_interp_named_p
int current_interp_named_p(const char *interp_name)
Definition: interps.c:299
error
void error(const char *fmt,...)
Definition: errors.c:38
command_line::control_u
union command_line::@21 control_u
ok_command
Definition: cli-script.h:27
throw_error
void throw_error(enum errors error, const char *fmt,...)
Definition: common-exceptions.c:389
free_command_lines
void free_command_lines(struct command_line **lptr)
Definition: cli-script.c:1309
execute_control_command
enum command_control_type execute_control_command(struct command_line *cmd)
Definition: cli-script.c:650
commands_from_control_command
enum command_control_type commands_from_control_command(const char *arg, struct command_line *cmd)
Definition: breakpoint.c:1289
string_view
Definition: cli-script.c:59
ui_out::field_fmt
void field_fmt(const char *fldname, const char *format,...) ATTRIBUTE_PRINTF(3
Definition: ui-out.c:557
ui-out.h
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
read_command_file
void read_command_file(FILE *stream)
Definition: top.c:406
source_verbose
int source_verbose
Definition: cli-cmds.c:163
interp_lookup
struct interp * interp_lookup(struct ui *ui, const char *name)
Definition: interps.c:219
deprecated_readline_hook
char *(* deprecated_readline_hook)(const char *)
Definition: top.c:215