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