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