]> Git Repo - binutils.git/blob - gdb/cli/cli-script.c
Unify gdb puts functions
[binutils.git] / gdb / cli / cli-script.c
1 /* GDB CLI command scripting.
2
3    Copyright (C) 1986-2022 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
45 static enum command_control_type
46 recurse_read_control_structure
47     (gdb::function_view<const char * ()> read_next_line_func,
48      struct command_line *current_cmd,
49      gdb::function_view<void (const char *)> validator);
50
51 static void do_define_command (const char *comname, int from_tty,
52                                const counted_command_line *commands);
53
54 static void do_document_command (const char *comname, int from_tty,
55                                  const counted_command_line *commands);
56
57 static const char *read_next_line ();
58
59 /* Level of control structure when reading.  */
60 static int control_level;
61
62 /* Level of control structure when executing.  */
63 static int command_nest_depth = 1;
64
65 /* This is to prevent certain commands being printed twice.  */
66 static int suppress_next_print_command_trace = 0;
67
68 /* Command element for the 'while' command.  */
69 static cmd_list_element *while_cmd_element = nullptr;
70
71 /* Command element for the 'if' command.  */
72 static cmd_list_element *if_cmd_element = nullptr;
73
74 /* Command element for the 'define' command.  */
75 static cmd_list_element *define_cmd_element = nullptr;
76
77 /* Command element for the 'document' command.  */
78 static cmd_list_element *document_cmd_element = nullptr;
79
80 /* Structure for arguments to user defined functions.  */
81
82 class user_args
83 {
84 public:
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
93 private:
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 };
107
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.  */
111 static 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.  */
115 struct scoped_user_args_level
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.  */
125   ~scoped_user_args_level ()
126   {
127     user_args_stack.pop_back ();
128   }
129 };
130
131 \f
132 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
133    by "end").  */
134
135 static int
136 multi_line_command_p (enum command_control_type type)
137 {
138   switch (type)
139     {
140     case if_control:
141     case while_control:
142     case while_stepping_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
158 static command_line_up
159 build_command_line (enum command_control_type type, const char *args)
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
180 counted_command_line
181 get_command_line (enum command_control_type type, const char *arg)
182 {
183   /* Allocate and build a new command line structure.  */
184   counted_command_line cmd (build_command_line (type, arg).release (),
185                             command_lines_deleter ());
186
187   /* Read in the body of this command.  */
188   if (recurse_read_control_structure (read_next_line, cmd.get (), 0)
189       == invalid_control)
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
200 void
201 print_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
244           || list->control_type == while_stepping_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
355 class scoped_restore_hook_in
356 {
357 public:
358
359   scoped_restore_hook_in (struct cmd_list_element *c)
360     : m_cmd (c)
361   {
362   }
363
364   ~scoped_restore_hook_in ()
365   {
366     m_cmd->hook_in = 0;
367   }
368
369   scoped_restore_hook_in (const scoped_restore_hook_in &) = delete;
370   scoped_restore_hook_in &operator= (const scoped_restore_hook_in &) = delete;
371
372 private:
373
374   struct cmd_list_element *m_cmd;
375 };
376
377 void
378 execute_cmd_pre_hook (struct cmd_list_element *c)
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
388 void
389 execute_cmd_post_hook (struct cmd_list_element *c)
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
401 void
402 execute_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     {
410       enum command_control_type ret = execute_control_command (cmdlines,
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
423 std::string
424 execute_control_commands_to_string (struct command_line *commands,
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
437 void
438 execute_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
452   if (user_args_stack.size () > max_user_call_depth)
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
466 void
467 reset_command_nest_depth (void)
468 {
469   command_nest_depth = 1;
470
471   /* Just in case.  */
472   suppress_next_print_command_trace = 0;
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.  */
483 ATTRIBUTE_PRINTF (1, 2)
484 void
485 print_command_trace (const char *fmt, ...)
486 {
487   int i;
488
489   if (suppress_next_print_command_trace)
490     {
491       suppress_next_print_command_trace = 0;
492       return;
493     }
494
495   if (!source_verbose && !trace_commands)
496     return;
497
498   for (i=0; i < command_nest_depth; i++)
499     printf_filtered ("+");
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
511 static enum command_control_type
512 execute_control_command_1 (struct command_line *cmd, int from_tty)
513 {
514   struct command_line *current;
515   struct value *val;
516   struct value *val_mark;
517   int loop;
518   enum command_control_type ret;
519
520   /* Start by assuming failure, if a problem is detected, the code
521      below will simply "break" out of the switch.  */
522   ret = invalid_control;
523
524   switch (cmd->control_type)
525     {
526     case simple_control:
527       {
528         /* A simple command, execute it and return.  */
529         std::string new_line = insert_user_defined_cmd_args (cmd->line);
530         execute_command (new_line.c_str (), from_tty);
531         ret = cmd->control_type;
532         break;
533       }
534
535     case continue_control:
536       print_command_trace ("loop_continue");
537
538       /* Return for "continue", and "break" so we can either
539          continue the loop at the top, or break out.  */
540       ret = cmd->control_type;
541       break;
542
543     case break_control:
544       print_command_trace ("loop_break");
545
546       /* Return for "continue", and "break" so we can either
547          continue the loop at the top, or break out.  */
548       ret = cmd->control_type;
549       break;
550
551     case while_control:
552       {
553         print_command_trace ("while %s", cmd->line);
554
555         /* Parse the loop control expression for the while statement.  */
556         std::string new_line = insert_user_defined_cmd_args (cmd->line);
557         expression_up expr = parse_expression (new_line.c_str ());
558
559         ret = simple_control;
560         loop = 1;
561
562         /* Keep iterating so long as the expression is true.  */
563         while (loop == 1)
564           {
565             bool cond_result;
566
567             QUIT;
568
569             /* Evaluate the expression.  */
570             val_mark = value_mark ();
571             val = evaluate_expression (expr.get ());
572             cond_result = value_true (val);
573             value_free_to_mark (val_mark);
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         val_mark = value_mark ();
625         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         value_free_to_mark (val_mark);
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:
663       eval_compile_command (cmd, NULL, cmd->control_u.compile.scope,
664                             cmd->control_u.compile.scope_data);
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       {
683         eval_ext_lang_from_control_command (cmd);
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
696 enum command_control_type
697 execute_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.  */
704   interp *console = interp_lookup (current_ui, INTERP_CONSOLE);
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
714 enum command_control_type
715 execute_control_command_untraced (struct command_line *cmd)
716 {
717   suppress_next_print_command_trace = 1;
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
725 static void
726 while_command (const char *arg, int from_tty)
727 {
728   control_level = 1;
729   counted_command_line command = get_command_line (while_control, arg);
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
742 static void
743 if_command (const char *arg, int from_tty)
744 {
745   control_level = 1;
746   counted_command_line command = get_command_line (if_control, arg);
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
759 user_args::user_args (const char *command_line)
760 {
761   const char *p;
762
763   if (command_line == NULL)
764     return;
765
766   m_command_line = command_line;
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
822 static const char *
823 locate_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
837 std::string
838 insert_user_defined_cmd_args (const char *line)
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
852 std::string
853 user_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 \f
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
896 static const char *
897 read_next_line ()
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 (prompt_ptr, "commands");
921 }
922
923 /* Given an input line P, skip the command and return a pointer to the
924    first argument.  */
925
926 static const char *
927 line_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
942 static enum misc_command_type
943 process_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.  */
997       if (cmd == while_stepping_cmd_element)
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.  */
1010           *command = build_command_line (while_stepping_control, p);
1011         }
1012       else if (cmd == while_cmd_element)
1013         *command = build_command_line (while_control, line_first_arg (p));
1014       else if (cmd == if_cmd_element)
1015         *command = build_command_line (if_control, line_first_arg (p));
1016       else if (cmd == commands_cmd_element)
1017         *command = build_command_line (commands_control, line_first_arg (p));
1018       else if (cmd == define_cmd_element)
1019         *command = build_command_line (define_control, line_first_arg (p));
1020       else if (cmd == document_cmd_element)
1021         *command = build_command_line (document_control, line_first_arg (p));
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"))
1043         *command = command_line_up (new command_line (continue_control));
1044       else
1045         not_handled = 1;
1046     }
1047
1048   if (!parse_commands || not_handled)
1049     {
1050       /* A normal command.  */
1051       *command = command_line_up (new command_line (simple_control,
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
1066 static enum command_control_type
1067 recurse_read_control_structure (gdb::function_view<const char * ()> read_next_line_func,
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;
1075   command_line_up next;
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       next = nullptr;
1089       val = process_next_line (read_next_line_func (), &next,
1090                                current_cmd->control_type != python_control
1091                                && current_cmd->control_type != guile_control
1092                                && current_cmd->control_type != compile_control,
1093                                validator);
1094
1095       /* Just skip blanks and comments.  */
1096       if (val == nop_command)
1097         continue;
1098
1099       if (val == end_command)
1100         {
1101           if (multi_line_command_p (current_cmd->control_type))
1102             {
1103               /* Success reading an entire canned sequence of commands.  */
1104               ret = simple_control;
1105               break;
1106             }
1107           else
1108             {
1109               ret = invalid_control;
1110               break;
1111             }
1112         }
1113
1114       /* Not the end of a control structure.  */
1115       if (val == else_command)
1116         {
1117           if (current_cmd->control_type == if_control
1118               && current_body == &current_cmd->body_list_0)
1119             {
1120               current_body = &current_cmd->body_list_1;
1121               child_tail = nullptr;
1122               continue;
1123             }
1124           else
1125             {
1126               ret = invalid_control;
1127               break;
1128             }
1129         }
1130
1131       /* Transfer ownership of NEXT to the command's body list.  */
1132       if (child_tail != nullptr)
1133         {
1134           child_tail->next = next.release ();
1135           child_tail = child_tail->next;
1136         }
1137       else
1138         {
1139           child_tail = next.get ();
1140           *current_body = counted_command_line (next.release (),
1141                                                 command_lines_deleter ());
1142         }
1143
1144       /* If the latest line is another control structure, then recurse
1145          on it.  */
1146       if (multi_line_command_p (child_tail->control_type))
1147         {
1148           control_level++;
1149           ret = recurse_read_control_structure (read_next_line_func,
1150                                                 child_tail,
1151                                                 validator);
1152           control_level--;
1153
1154           if (ret != simple_control)
1155             break;
1156         }
1157     }
1158
1159   dont_repeat ();
1160
1161   return ret;
1162 }
1163
1164 /* Read lines from the input stream and accumulate them in a chain of
1165    struct command_line's, which is then returned.  For input from a
1166    terminal, the special command "end" is used to mark the end of the
1167    input, and is not included in the returned chain of commands.
1168
1169    If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1170    is always stripped) in the line and attempt to recognize GDB control
1171    commands.  Otherwise, only "end" is recognized.  */
1172
1173 #define END_MESSAGE "End with a line saying just \"end\"."
1174
1175 counted_command_line
1176 read_command_lines (const char *prompt_arg, int from_tty, int parse_commands,
1177                     gdb::function_view<void (const char *)> validator)
1178 {
1179   if (from_tty && input_interactive_p (current_ui))
1180     {
1181       if (deprecated_readline_begin_hook)
1182         {
1183           /* Note - intentional to merge messages with no newline.  */
1184           (*deprecated_readline_begin_hook) ("%s  %s\n", prompt_arg,
1185                                              END_MESSAGE);
1186         }
1187       else
1188         printf_unfiltered ("%s\n%s\n", prompt_arg, END_MESSAGE);
1189     }
1190
1191
1192   /* Reading commands assumes the CLI behavior, so temporarily
1193      override the current interpreter with CLI.  */
1194   counted_command_line head (nullptr, command_lines_deleter ());
1195   if (current_interp_named_p (INTERP_CONSOLE))
1196     head = read_command_lines_1 (read_next_line, parse_commands,
1197                                  validator);
1198   else
1199     {
1200       scoped_restore_interp interp_restorer (INTERP_CONSOLE);
1201
1202       head = read_command_lines_1 (read_next_line, parse_commands,
1203                                    validator);
1204     }
1205
1206   if (from_tty && input_interactive_p (current_ui)
1207       && deprecated_readline_end_hook)
1208     {
1209       (*deprecated_readline_end_hook) ();
1210     }
1211   return (head);
1212 }
1213
1214 /* Act the same way as read_command_lines, except that each new line is
1215    obtained using READ_NEXT_LINE_FUNC.  */
1216
1217 counted_command_line
1218 read_command_lines_1 (gdb::function_view<const char * ()> read_next_line_func,
1219                       int parse_commands,
1220                       gdb::function_view<void (const char *)> validator)
1221 {
1222   struct command_line *tail;
1223   counted_command_line head (nullptr, command_lines_deleter ());
1224   enum command_control_type ret;
1225   enum misc_command_type val;
1226   command_line_up next;
1227
1228   control_level = 0;
1229   tail = NULL;
1230
1231   while (1)
1232     {
1233       dont_repeat ();
1234       val = process_next_line (read_next_line_func (), &next, parse_commands,
1235                                validator);
1236
1237       /* Ignore blank lines or comments.  */
1238       if (val == nop_command)
1239         continue;
1240
1241       if (val == end_command)
1242         {
1243           ret = simple_control;
1244           break;
1245         }
1246
1247       if (val != ok_command)
1248         {
1249           ret = invalid_control;
1250           break;
1251         }
1252
1253       if (multi_line_command_p (next->control_type))
1254         {
1255           control_level++;
1256           ret = recurse_read_control_structure (read_next_line_func, next.get (),
1257                                                 validator);
1258           control_level--;
1259
1260           if (ret == invalid_control)
1261             break;
1262         }
1263
1264       /* Transfer ownership of NEXT to the HEAD list.  */
1265       if (tail)
1266         {
1267           tail->next = next.release ();
1268           tail = tail->next;
1269         }
1270       else
1271         {
1272           tail = next.get ();
1273           head = counted_command_line (next.release (),
1274                                        command_lines_deleter ());
1275         }
1276     }
1277
1278   dont_repeat ();
1279
1280   if (ret == invalid_control)
1281     return NULL;
1282
1283   return head;
1284 }
1285
1286 /* Free a chain of struct command_line's.  */
1287
1288 void
1289 free_command_lines (struct command_line **lptr)
1290 {
1291   struct command_line *l = *lptr;
1292   struct command_line *next;
1293
1294   while (l)
1295     {
1296       next = l->next;
1297       delete l;
1298       l = next;
1299     }
1300   *lptr = NULL;
1301 }
1302 \f
1303 /* Validate that *COMNAME is a valid name for a command.  Return the
1304    containing command list, in case it starts with a prefix command.
1305    The prefix must already exist.  *COMNAME is advanced to point after
1306    any prefix, and a NUL character overwrites the space after the
1307    prefix.  */
1308
1309 static struct cmd_list_element **
1310 validate_comname (const char **comname)
1311 {
1312   struct cmd_list_element **list = &cmdlist;
1313   const char *p, *last_word;
1314
1315   if (*comname == 0)
1316     error_no_arg (_("name of command to define"));
1317
1318   /* Find the last word of the argument.  */
1319   p = *comname + strlen (*comname);
1320   while (p > *comname && isspace (p[-1]))
1321     p--;
1322   while (p > *comname && !isspace (p[-1]))
1323     p--;
1324   last_word = p;
1325
1326   /* Find the corresponding command list.  */
1327   if (last_word != *comname)
1328     {
1329       struct cmd_list_element *c;
1330
1331       /* Separate the prefix and the command.  */
1332       std::string prefix (*comname, last_word - 1);
1333       const char *tem = prefix.c_str ();
1334
1335       c = lookup_cmd (&tem, cmdlist, "", NULL, 0, 1);
1336       if (!c->is_prefix ())
1337         error (_("\"%s\" is not a prefix command."), prefix.c_str ());
1338
1339       list = c->subcommands;
1340       *comname = last_word;
1341     }
1342
1343   p = *comname;
1344   while (*p)
1345     {
1346       if (!valid_cmd_char_p (*p))
1347         error (_("Junk in argument list: \"%s\""), p);
1348       p++;
1349     }
1350
1351   return list;
1352 }
1353
1354 /* This is just a placeholder in the command data structures.  */
1355 static void
1356 user_defined_command (const char *ignore, int from_tty)
1357 {
1358 }
1359
1360 /* Define a user-defined command.  If COMMANDS is NULL, then this is a
1361    top-level call and the commands will be read using
1362    read_command_lines.  Otherwise, it is a "define" command in an
1363    existing command and the commands are provided.  In the
1364    non-top-level case, various prompts and warnings are disabled.  */
1365
1366 static void
1367 do_define_command (const char *comname, int from_tty,
1368                    const counted_command_line *commands)
1369 {
1370   enum cmd_hook_type
1371     {
1372       CMD_NO_HOOK = 0,
1373       CMD_PRE_HOOK,
1374       CMD_POST_HOOK
1375     };
1376   struct cmd_list_element *c, *newc, *hookc = 0, **list;
1377   const char *comfull;
1378   int  hook_type      = CMD_NO_HOOK;
1379   int  hook_name_size = 0;
1380    
1381 #define HOOK_STRING     "hook-"
1382 #define HOOK_LEN 5
1383 #define HOOK_POST_STRING "hookpost-"
1384 #define HOOK_POST_LEN    9
1385
1386   comfull = comname;
1387   list = validate_comname (&comname);
1388
1389   c = lookup_cmd_exact (comname, *list);
1390
1391   if (c && commands == nullptr)
1392     {
1393       int q;
1394
1395       if (c->theclass == class_user || c->theclass == class_alias)
1396         {
1397           /* if C is a prefix command that was previously defined,
1398              tell the user its subcommands will be kept, and ask
1399              if ok to redefine the command.  */
1400           if (c->is_prefix ())
1401             q = (c->user_commands.get () == nullptr
1402                  || query (_("Keeping subcommands of prefix command \"%s\".\n"
1403                              "Redefine command \"%s\"? "), c->name, c->name));
1404           else
1405             q = query (_("Redefine command \"%s\"? "), c->name);
1406         }
1407       else
1408         q = query (_("Really redefine built-in command \"%s\"? "), c->name);
1409       if (!q)
1410         error (_("Command \"%s\" not redefined."), c->name);
1411     }
1412
1413   /* If this new command is a hook, then mark the command which it
1414      is hooking.  Note that we allow hooking `help' commands, so that
1415      we can hook the `stop' pseudo-command.  */
1416
1417   if (!strncmp (comname, HOOK_STRING, HOOK_LEN))
1418     {
1419        hook_type      = CMD_PRE_HOOK;
1420        hook_name_size = HOOK_LEN;
1421     }
1422   else if (!strncmp (comname, HOOK_POST_STRING, HOOK_POST_LEN))
1423     {
1424       hook_type      = CMD_POST_HOOK;
1425       hook_name_size = HOOK_POST_LEN;
1426     }
1427
1428   if (hook_type != CMD_NO_HOOK)
1429     {
1430       /* Look up cmd it hooks.  */
1431       hookc = lookup_cmd_exact (comname + hook_name_size, *list,
1432                                 /* ignore_help_classes = */ false);
1433       if (!hookc && commands == nullptr)
1434         {
1435           warning (_("Your new `%s' command does not "
1436                      "hook any existing command."),
1437                    comfull);
1438           if (!query (_("Proceed? ")))
1439             error (_("Not confirmed."));
1440         }
1441     }
1442
1443   comname = xstrdup (comname);
1444
1445   counted_command_line cmds;
1446   if (commands == nullptr)
1447     {
1448       std::string prompt
1449         = string_printf ("Type commands for definition of \"%s\".", comfull);
1450       cmds = read_command_lines (prompt.c_str (), from_tty, 1, 0);
1451     }
1452   else
1453     cmds = *commands;
1454
1455   {
1456     struct cmd_list_element **c_subcommands
1457       = c == nullptr ? nullptr : c->subcommands;
1458
1459     newc = add_cmd (comname, class_user, user_defined_command,
1460                     (c != nullptr && c->theclass == class_user)
1461                     ? c->doc : xstrdup ("User-defined."), list);
1462     newc->user_commands = std::move (cmds);
1463
1464     /* If we define or re-define a command that was previously defined
1465        as a prefix, keep the prefix information.  */
1466     if (c_subcommands != nullptr)
1467       {
1468         newc->subcommands = c_subcommands;
1469         /* allow_unknown: see explanation in equivalent logic in
1470            define_prefix_command ().  */
1471         newc->allow_unknown = newc->user_commands.get () != nullptr;
1472     }
1473   }
1474
1475   /* If this new command is a hook, then mark both commands as being
1476      tied.  */
1477   if (hookc)
1478     {
1479       switch (hook_type)
1480         {
1481         case CMD_PRE_HOOK:
1482           hookc->hook_pre  = newc;  /* Target gets hooked.  */
1483           newc->hookee_pre = hookc; /* We are marked as hooking target cmd.  */
1484           break;
1485         case CMD_POST_HOOK:
1486           hookc->hook_post  = newc;  /* Target gets hooked.  */
1487           newc->hookee_post = hookc; /* We are marked as hooking
1488                                         target cmd.  */
1489           break;
1490         default:
1491           /* Should never come here as hookc would be 0.  */
1492           internal_error (__FILE__, __LINE__, _("bad switch"));
1493         }
1494     }
1495 }
1496
1497 static void
1498 define_command (const char *comname, int from_tty)
1499 {
1500   do_define_command (comname, from_tty, nullptr);
1501 }
1502
1503 /* Document a user-defined command.  If COMMANDS is NULL, then this is a
1504    top-level call and the document will be read using read_command_lines.
1505    Otherwise, it is a "document" command in an existing command and the
1506    commands are provided.  */
1507 static void
1508 do_document_command (const char *comname, int from_tty,
1509                      const counted_command_line *commands)
1510 {
1511   struct cmd_list_element *c, **list;
1512   const char *tem;
1513   const char *comfull;
1514
1515   comfull = comname;
1516   list = validate_comname (&comname);
1517
1518   tem = comname;
1519   c = lookup_cmd (&tem, *list, "", NULL, 0, 1);
1520
1521   if (c->theclass != class_user)
1522     error (_("Command \"%s\" is built-in."), comfull);
1523
1524   counted_command_line doclines;
1525
1526   if (commands == nullptr)
1527     {
1528       std::string prompt 
1529         = string_printf ("Type documentation for \"%s\".", comfull);
1530       doclines = read_command_lines (prompt.c_str (), from_tty, 0, 0);
1531     }
1532   else
1533     doclines = *commands;
1534
1535   xfree ((char *) c->doc);
1536
1537   {
1538     struct command_line *cl1;
1539     int len = 0;
1540     char *doc;
1541
1542     for (cl1 = doclines.get (); cl1; cl1 = cl1->next)
1543       len += strlen (cl1->line) + 1;
1544
1545     doc = (char *) xmalloc (len + 1);
1546     *doc = 0;
1547
1548     for (cl1 = doclines.get (); cl1; cl1 = cl1->next)
1549       {
1550         strcat (doc, cl1->line);
1551         if (cl1->next)
1552           strcat (doc, "\n");
1553       }
1554
1555     c->doc = doc;
1556   }
1557 }
1558
1559 static void
1560 document_command (const char *comname, int from_tty)
1561 {
1562   do_document_command (comname, from_tty, nullptr);
1563 }
1564
1565 /* Implementation of the "define-prefix" command.  */
1566
1567 static void
1568 define_prefix_command (const char *comname, int from_tty)
1569 {
1570   struct cmd_list_element *c, **list;
1571   const char *comfull;
1572
1573   comfull = comname;
1574   list = validate_comname (&comname);
1575
1576   c = lookup_cmd_exact (comname, *list);
1577
1578   if (c != nullptr && c->theclass != class_user)
1579     error (_("Command \"%s\" is built-in."), comfull);
1580
1581   if (c != nullptr && c->is_prefix ())
1582     {
1583       /* c is already a user defined prefix command.  */
1584       return;
1585     }
1586
1587   /* If the command does not exist at all, create it.  */
1588   if (c == nullptr)
1589     {
1590       comname = xstrdup (comname);
1591       c = add_cmd (comname, class_user, user_defined_command,
1592                    xstrdup ("User-defined."), list);
1593     }
1594
1595   /* Allocate the c->subcommands, which marks the command as a prefix
1596      command.  */
1597   c->subcommands = new struct cmd_list_element*;
1598   *(c->subcommands) = nullptr;
1599   /* If the prefix command C is not a command, then it must be followed
1600      by known subcommands.  Otherwise, if C is also a normal command,
1601      it can be followed by C args that must not cause a 'subcommand'
1602      not recognised error, and thus we must allow unknown.  */
1603   c->allow_unknown = c->user_commands.get () != nullptr;
1604 }
1605
1606 \f
1607 /* Used to implement source_command.  */
1608
1609 void
1610 script_from_file (FILE *stream, const char *file)
1611 {
1612   if (stream == NULL)
1613     internal_error (__FILE__, __LINE__, _("called with NULL file pointer!"));
1614
1615   scoped_restore restore_line_number
1616     = make_scoped_restore (&source_line_number, 0);
1617   scoped_restore restore_file
1618     = make_scoped_restore<std::string, const std::string &> (&source_file_name,
1619                                                              file);
1620
1621   scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
1622
1623   try
1624     {
1625       read_command_file (stream);
1626     }
1627   catch (const gdb_exception_error &e)
1628     {
1629       /* Re-throw the error, but with the file name information
1630          prepended.  */
1631       throw_error (e.error,
1632                    _("%s:%d: Error in sourced command file:\n%s"),
1633                    source_file_name.c_str (), source_line_number,
1634                    e.what ());
1635     }
1636 }
1637
1638 /* Print the definition of user command C to STREAM.  Or, if C is a
1639    prefix command, show the definitions of all user commands under C
1640    (recursively).  PREFIX and NAME combined are the name of the
1641    current command.  */
1642 void
1643 show_user_1 (struct cmd_list_element *c, const char *prefix, const char *name,
1644              struct ui_file *stream)
1645 {
1646   if (cli_user_command_p (c))
1647     {
1648       struct command_line *cmdlines = c->user_commands.get ();
1649
1650       fprintf_filtered (stream, "User %scommand \"",
1651                         c->is_prefix () ? "prefix" : "");
1652       fprintf_styled (stream, title_style.style (), "%s%s",
1653                       prefix, name);
1654       fprintf_filtered (stream, "\":\n");
1655       if (cmdlines)
1656         {
1657           print_command_lines (current_uiout, cmdlines, 1);
1658           gdb_puts ("\n", stream);
1659         }
1660     }
1661
1662   if (c->is_prefix ())
1663     {
1664       const std::string prefixname = c->prefixname ();
1665
1666       for (c = *c->subcommands; c != NULL; c = c->next)
1667         if (c->theclass == class_user || c->is_prefix ())
1668           show_user_1 (c, prefixname.c_str (), c->name, gdb_stdout);
1669     }
1670
1671 }
1672
1673 void _initialize_cli_script ();
1674 void
1675 _initialize_cli_script ()
1676 {
1677   struct cmd_list_element *c;
1678
1679   /* "document", "define" and "define-prefix" use command_completer,
1680      as this helps the user to either type the command name and/or
1681      its prefixes.  */
1682   document_cmd_element = add_com ("document", class_support, document_command,
1683                                   _("\
1684 Document a user-defined command.\n\
1685 Give command name as argument.  Give documentation on following lines.\n\
1686 End with a line of just \"end\"."));
1687   set_cmd_completer (document_cmd_element, command_completer);
1688   define_cmd_element = add_com ("define", class_support, define_command, _("\
1689 Define a new command name.  Command name is argument.\n\
1690 Definition appears on following lines, one command per line.\n\
1691 End with a line of just \"end\".\n\
1692 Use the \"document\" command to give documentation for the new command.\n\
1693 Commands defined in this way may accept an unlimited number of arguments\n\
1694 accessed via $arg0 .. $argN.  $argc tells how many arguments have\n\
1695 been passed."));
1696   set_cmd_completer (define_cmd_element, command_completer);
1697   c = add_com ("define-prefix", class_support, define_prefix_command,
1698            _("\
1699 Define or mark a command as a user-defined prefix command.\n\
1700 User defined prefix commands can be used as prefix commands for\n\
1701 other user defined commands.\n\
1702 If the command already exists, it is changed to a prefix command."));
1703   set_cmd_completer (c, command_completer);
1704
1705   while_cmd_element = add_com ("while", class_support, while_command, _("\
1706 Execute nested commands WHILE the conditional expression is non zero.\n\
1707 The conditional expression must follow the word `while' and must in turn be\n\
1708 followed by a new line.  The nested commands must be entered one per line,\n\
1709 and should be terminated by the word `end'."));
1710
1711   if_cmd_element = add_com ("if", class_support, if_command, _("\
1712 Execute nested commands once IF the conditional expression is non zero.\n\
1713 The conditional expression must follow the word `if' and must in turn be\n\
1714 followed by a new line.  The nested commands must be entered one per line,\n\
1715 and should be terminated by the word 'else' or `end'.  If an else clause\n\
1716 is used, the same rules apply to its nested commands as to the first ones."));
1717 }
This page took 0.1218 seconds and 4 git commands to generate.