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