gdb/cli/cli-script.c

   1 /* GDB CLI command scripting.
   2
   3    Copyright (c) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
   4    1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2006
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22    Boston, MA 02110-1301, USA.  */
  23
  24 #include "defs.h"
  25 #include "value.h"
  26 #include "language.h"           /* For value_true */
  27 #include <ctype.h>
  28
  29 #include "ui-out.h"
  30 #include "gdb_string.h"
  31 #include "exceptions.h"
  32 #include "top.h"
  33 #include "cli/cli-cmds.h"
  34 #include "cli/cli-decode.h"
  35 #include "cli/cli-script.h"
  36 #include "gdb_assert.h"
  37
  38 /* Prototypes for local functions */
  39
  40 static enum command_control_type
  41         recurse_read_control_structure (struct command_line *current_cmd);
  42
  43 static char *insert_args (char *line);
  44
  45 static struct cleanup * setup_user_args (char *p);
  46
  47 static void validate_comname (char *);
  48
  49 /* Level of control structure.  */
  50 static int control_level;
  51
  52 /* Structure for arguments to user defined functions.  */
  53 #define MAXUSERARGS 10
  54 struct user_args
  55   {
  56     struct user_args *next;
  57     /* It is necessary to store a malloced copy of the command line to
  58        ensure that the arguments are not overwritten before they are used.  */
  59     char *command;
  60     struct
  61       {
  62         char *arg;
  63         int len;
  64       }
  65     a[MAXUSERARGS];
  66     int count;
  67   }
  68  *user_args;
  69
  70 \f
  71 /* Allocate, initialize a new command line structure for one of the
  72    control commands (if/while).  */
  73
  74 static struct command_line *
  75 build_command_line (enum command_control_type type, char *args)
  76 {
  77   struct command_line *cmd;
  78
  79   if (args == NULL)
  80     error (_("if/while commands require arguments."));
  81
  82   cmd = (struct command_line *) xmalloc (sizeof (struct command_line));
  83   cmd->next = NULL;
  84   cmd->control_type = type;
  85
  86   cmd->body_count = 1;
  87   cmd->body_list
  88     = (struct command_line **) xmalloc (sizeof (struct command_line *)
  89                                         * cmd->body_count);
  90   memset (cmd->body_list, 0, sizeof (struct command_line *) * cmd->body_count);
  91   cmd->line = savestring (args, strlen (args));
  92   return cmd;
  93 }
  94
  95 /* Build and return a new command structure for the control commands
  96    such as "if" and "while".  */
  97
  98 static struct command_line *
  99 get_command_line (enum command_control_type type, char *arg)
 100 {
 101   struct command_line *cmd;
 102   struct cleanup *old_chain = NULL;
 103
 104   /* Allocate and build a new command line structure.  */
 105   cmd = build_command_line (type, arg);
 106
 107   old_chain = make_cleanup_free_command_lines (&cmd);
 108
 109   /* Read in the body of this command.  */
 110   if (recurse_read_control_structure (cmd) == invalid_control)
 111     {
 112       warning (_("Error reading in control structure."));
 113       do_cleanups (old_chain);
 114       return NULL;
 115     }
 116
 117   discard_cleanups (old_chain);
 118   return cmd;
 119 }
 120
 121 /* Recursively print a command (including full control structures).  */
 122
 123 void
 124 print_command_lines (struct ui_out *uiout, struct command_line *cmd,
 125                      unsigned int depth)
 126 {
 127   struct command_line *list;
 128
 129   list = cmd;
 130   while (list)
 131     {
 132
 133       if (depth)
 134         ui_out_spaces (uiout, 2 * depth);
 135
 136       /* A simple command, print it and continue.  */
 137       if (list->control_type == simple_control)
 138         {
 139           ui_out_field_string (uiout, NULL, list->line);
 140           ui_out_text (uiout, "\n");
 141           list = list->next;
 142           continue;
 143         }
 144
 145       /* loop_continue to jump to the start of a while loop, print it
 146          and continue. */
 147       if (list->control_type == continue_control)
 148         {
 149           ui_out_field_string (uiout, NULL, "loop_continue");
 150           ui_out_text (uiout, "\n");
 151           list = list->next;
 152           continue;
 153         }
 154
 155       /* loop_break to break out of a while loop, print it and continue.  */
 156       if (list->control_type == break_control)
 157         {
 158           ui_out_field_string (uiout, NULL, "loop_break");
 159           ui_out_text (uiout, "\n");
 160           list = list->next;
 161           continue;
 162         }
 163
 164       /* A while command.  Recursively print its subcommands and continue.  */
 165       if (list->control_type == while_control)
 166         {
 167           ui_out_field_fmt (uiout, NULL, "while %s", list->line);
 168           ui_out_text (uiout, "\n");
 169           print_command_lines (uiout, *list->body_list, depth + 1);
 170           if (depth)
 171             ui_out_spaces (uiout, 2 * depth);
 172           ui_out_field_string (uiout, NULL, "end");
 173           ui_out_text (uiout, "\n");
 174           list = list->next;
 175           continue;
 176         }
 177
 178       /* An if command.  Recursively print both arms before continueing.  */
 179       if (list->control_type == if_control)
 180         {
 181           ui_out_field_fmt (uiout, NULL, "if %s", list->line);
 182           ui_out_text (uiout, "\n");
 183           /* The true arm. */
 184           print_command_lines (uiout, list->body_list[0], depth + 1);
 185
 186           /* Show the false arm if it exists.  */
 187           if (list->body_count == 2)
 188             {
 189               if (depth)
 190                 ui_out_spaces (uiout, 2 * depth);
 191               ui_out_field_string (uiout, NULL, "else");
 192               ui_out_text (uiout, "\n");
 193               print_command_lines (uiout, list->body_list[1], depth + 1);
 194             }
 195
 196           if (depth)
 197             ui_out_spaces (uiout, 2 * depth);
 198           ui_out_field_string (uiout, NULL, "end");
 199           ui_out_text (uiout, "\n");
 200           list = list->next;
 201           continue;
 202         }
 203
 204       /* ignore illegal command type and try next */
 205       list = list->next;
 206     }                           /* while (list) */
 207 }
 208
 209 /* Handle pre-post hooks.  */
 210
 211 static void
 212 clear_hook_in_cleanup (void *data)
 213 {
 214   struct cmd_list_element *c = data;
 215   c->hook_in = 0; /* Allow hook to work again once it is complete */
 216 }
 217
 218 void
 219 execute_cmd_pre_hook (struct cmd_list_element *c)
 220 {
 221   if ((c->hook_pre) && (!c->hook_in))
 222     {
 223       struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c);
 224       c->hook_in = 1; /* Prevent recursive hooking */
 225       execute_user_command (c->hook_pre, (char *) 0);
 226       do_cleanups (cleanups);
 227     }
 228 }
 229
 230 void
 231 execute_cmd_post_hook (struct cmd_list_element *c)
 232 {
 233   if ((c->hook_post) && (!c->hook_in))
 234     {
 235       struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c);
 236       c->hook_in = 1; /* Prevent recursive hooking */
 237       execute_user_command (c->hook_post, (char *) 0);
 238       do_cleanups (cleanups);
 239     }
 240 }
 241
 242 /* Execute the command in CMD.  */
 243 static void
 244 do_restore_user_call_depth (void * call_depth)
 245 {
 246   int * depth = call_depth;
 247   (*depth)--;
 248   if ((*depth) == 0)
 249     in_user_command = 0;
 250 }
 251
 252
 253 void
 254 execute_user_command (struct cmd_list_element *c, char *args)
 255 {
 256   struct command_line *cmdlines;
 257   struct cleanup *old_chain;
 258   enum command_control_type ret;
 259   static int user_call_depth = 0;
 260   extern int max_user_call_depth;
 261
 262   old_chain = setup_user_args (args);
 263
 264   cmdlines = c->user_commands;
 265   if (cmdlines == 0)
 266     /* Null command */
 267     return;
 268
 269   if (++user_call_depth > max_user_call_depth)
 270     error (_("Max user call depth exceeded -- command aborted."));
 271
 272   make_cleanup (do_restore_user_call_depth, &user_call_depth);
 273
 274   /* Set the instream to 0, indicating execution of a
 275      user-defined function.  */
 276   make_cleanup (do_restore_instream_cleanup, instream);
 277   instream = (FILE *) 0;
 278
 279   /* Also set the global in_user_command, so that NULL instream is
 280      not confused with Insight.  */
 281   in_user_command = 1;
 282
 283   while (cmdlines)
 284     {
 285       ret = execute_control_command (cmdlines);
 286       if (ret != simple_control && ret != break_control)
 287         {
 288           warning (_("Error in control structure."));
 289           break;
 290         }
 291       cmdlines = cmdlines->next;
 292     }
 293   do_cleanups (old_chain);
 294 }
 295
 296 enum command_control_type
 297 execute_control_command (struct command_line *cmd)
 298 {
 299   struct expression *expr;
 300   struct command_line *current;
 301   struct cleanup *old_chain = make_cleanup (null_cleanup, 0);
 302   struct value *val;
 303   struct value *val_mark;
 304   int loop;
 305   enum command_control_type ret;
 306   char *new_line;
 307
 308   /* Start by assuming failure, if a problem is detected, the code
 309      below will simply "break" out of the switch.  */
 310   ret = invalid_control;
 311
 312   switch (cmd->control_type)
 313     {
 314     case simple_control:
 315       /* A simple command, execute it and return.  */
 316       new_line = insert_args (cmd->line);
 317       if (!new_line)
 318         break;
 319       make_cleanup (free_current_contents, &new_line);
 320       execute_command (new_line, 0);
 321       ret = cmd->control_type;
 322       break;
 323
 324     case continue_control:
 325     case break_control:
 326       /* Return for "continue", and "break" so we can either
 327          continue the loop at the top, or break out.  */
 328       ret = cmd->control_type;
 329       break;
 330
 331     case while_control:
 332       {
 333         /* Parse the loop control expression for the while statement.  */
 334         new_line = insert_args (cmd->line);
 335         if (!new_line)
 336           break;
 337         make_cleanup (free_current_contents, &new_line);
 338         expr = parse_expression (new_line);
 339         make_cleanup (free_current_contents, &expr);
 340
 341         ret = simple_control;
 342         loop = 1;
 343
 344         /* Keep iterating so long as the expression is true.  */
 345         while (loop == 1)
 346           {
 347             int cond_result;
 348
 349             QUIT;
 350
 351             /* Evaluate the expression.  */
 352             val_mark = value_mark ();
 353             val = evaluate_expression (expr);
 354             cond_result = value_true (val);
 355             value_free_to_mark (val_mark);
 356
 357             /* If the value is false, then break out of the loop.  */
 358             if (!cond_result)
 359               break;
 360
 361             /* Execute the body of the while statement.  */
 362             current = *cmd->body_list;
 363             while (current)
 364               {
 365                 ret = execute_control_command (current);
 366
 367                 /* If we got an error, or a "break" command, then stop
 368                    looping.  */
 369                 if (ret == invalid_control || ret == break_control)
 370                   {
 371                     loop = 0;
 372                     break;
 373                   }
 374
 375                 /* If we got a "continue" command, then restart the loop
 376                    at this point.  */
 377                 if (ret == continue_control)
 378                   break;
 379
 380                 /* Get the next statement.  */
 381                 current = current->next;
 382               }
 383           }
 384
 385         /* Reset RET so that we don't recurse the break all the way down.  */
 386         if (ret == break_control)
 387           ret = simple_control;
 388
 389         break;
 390       }
 391
 392     case if_control:
 393       {
 394         new_line = insert_args (cmd->line);
 395         if (!new_line)
 396           break;
 397         make_cleanup (free_current_contents, &new_line);
 398         /* Parse the conditional for the if statement.  */
 399         expr = parse_expression (new_line);
 400         make_cleanup (free_current_contents, &expr);
 401
 402         current = NULL;
 403         ret = simple_control;
 404
 405         /* Evaluate the conditional.  */
 406         val_mark = value_mark ();
 407         val = evaluate_expression (expr);
 408
 409         /* Choose which arm to take commands from based on the value of the
 410            conditional expression.  */
 411         if (value_true (val))
 412           current = *cmd->body_list;
 413         else if (cmd->body_count == 2)
 414           current = *(cmd->body_list + 1);
 415         value_free_to_mark (val_mark);
 416
 417         /* Execute commands in the given arm.  */
 418         while (current)
 419           {
 420             ret = execute_control_command (current);
 421
 422             /* If we got an error, get out.  */
 423             if (ret != simple_control)
 424               break;
 425
 426             /* Get the next statement in the body.  */
 427             current = current->next;
 428           }
 429
 430         break;
 431       }
 432
 433     default:
 434       warning (_("Invalid control type in command structure."));
 435       break;
 436     }
 437
 438   do_cleanups (old_chain);
 439
 440   return ret;
 441 }
 442
 443 /* "while" command support.  Executes a body of statements while the
 444    loop condition is nonzero.  */
 445
 446 void
 447 while_command (char *arg, int from_tty)
 448 {
 449   struct command_line *command = NULL;
 450
 451   control_level = 1;
 452   command = get_command_line (while_control, arg);
 453
 454   if (command == NULL)
 455     return;
 456
 457   execute_control_command (command);
 458   free_command_lines (&command);
 459 }
 460
 461 /* "if" command support.  Execute either the true or false arm depending
 462    on the value of the if conditional.  */
 463
 464 void
 465 if_command (char *arg, int from_tty)
 466 {
 467   struct command_line *command = NULL;
 468
 469   control_level = 1;
 470   command = get_command_line (if_control, arg);
 471
 472   if (command == NULL)
 473     return;
 474
 475   execute_control_command (command);
 476   free_command_lines (&command);
 477 }
 478
 479 /* Cleanup */
 480 static void
 481 arg_cleanup (void *ignore)
 482 {
 483   struct user_args *oargs = user_args;
 484   if (!user_args)
 485     internal_error (__FILE__, __LINE__,
 486                     _("arg_cleanup called with no user args.\n"));
 487
 488   user_args = user_args->next;
 489   xfree (oargs->command);
 490   xfree (oargs);
 491 }
 492
 493 /* Bind the incomming arguments for a user defined command to
 494    $arg0, $arg1 ... $argMAXUSERARGS.  */
 495
 496 static struct cleanup *
 497 setup_user_args (char *p)
 498 {
 499   struct user_args *args;
 500   struct cleanup *old_chain;
 501   unsigned int arg_count = 0;
 502
 503   args = (struct user_args *) xmalloc (sizeof (struct user_args));
 504   memset (args, 0, sizeof (struct user_args));
 505
 506   args->next = user_args;
 507   user_args = args;
 508
 509   old_chain = make_cleanup (arg_cleanup, 0/*ignored*/);
 510
 511   if (p == NULL)
 512     return old_chain;
 513
 514   user_args->command = p = xstrdup (p);
 515
 516   while (*p)
 517     {
 518       char *start_arg;
 519       int squote = 0;
 520       int dquote = 0;
 521       int bsquote = 0;
 522
 523       if (arg_count >= MAXUSERARGS)
 524         {
 525           error (_("user defined function may only have %d arguments."),
 526                  MAXUSERARGS);
 527           return old_chain;
 528         }
 529
 530       /* Strip whitespace.  */
 531       while (*p == ' ' || *p == '\t')
 532         p++;
 533
 534       /* P now points to an argument.  */
 535       start_arg = p;
 536       user_args->a[arg_count].arg = p;
 537
 538       /* Get to the end of this argument.  */
 539       while (*p)
 540         {
 541           if (((*p == ' ' || *p == '\t')) && !squote && !dquote && !bsquote)
 542             break;
 543           else
 544             {
 545               if (bsquote)
 546                 bsquote = 0;
 547               else if (*p == '\\')
 548                 bsquote = 1;
 549               else if (squote)
 550                 {
 551                   if (*p == '\'')
 552                     squote = 0;
 553                 }
 554               else if (dquote)
 555                 {
 556                   if (*p == '"')
 557                     dquote = 0;
 558                 }
 559               else
 560                 {
 561                   if (*p == '\'')
 562                     squote = 1;
 563                   else if (*p == '"')
 564                     dquote = 1;
 565                 }
 566               p++;
 567             }
 568         }
 569
 570       user_args->a[arg_count].len = p - start_arg;
 571       arg_count++;
 572       user_args->count++;
 573     }
 574   return old_chain;
 575 }
 576
 577 /* Given character string P, return a point to the first argument ($arg),
 578    or NULL if P contains no arguments.  */
 579
 580 static char *
 581 locate_arg (char *p)
 582 {
 583   while ((p = strchr (p, '$')))
 584     {
 585       if (strncmp (p, "$arg", 4) == 0
 586           && (isdigit (p[4]) || p[4] == 'c'))
 587         return p;
 588       p++;
 589     }
 590   return NULL;
 591 }
 592
 593 /* Insert the user defined arguments stored in user_arg into the $arg
 594    arguments found in line, with the updated copy being placed into nline.  */
 595
 596 static char *
 597 insert_args (char *line)
 598 {
 599   char *p, *save_line, *new_line;
 600   unsigned len, i;
 601
 602   /* If we are not in a user-defined function, treat $argc, $arg0, et
 603      cetera as normal convenience variables.  */
 604   if (user_args == NULL)
 605     return xstrdup (line);
 606
 607   /* First we need to know how much memory to allocate for the new line.  */
 608   save_line = line;
 609   len = 0;
 610   while ((p = locate_arg (line)))
 611     {
 612       len += p - line;
 613       i = p[4] - '0';
 614
 615       if (p[4] == 'c')
 616         {
 617           /* $argc.  Number will be <=10.  */
 618           len += user_args->count == 10 ? 2 : 1;
 619         }
 620       else if (i >= user_args->count)
 621         {
 622           error (_("Missing argument %d in user function."), i);
 623           return NULL;
 624         }
 625       else
 626         {
 627           len += user_args->a[i].len;
 628         }
 629       line = p + 5;
 630     }
 631
 632   /* Don't forget the tail.  */
 633   len += strlen (line);
 634
 635   /* Allocate space for the new line and fill it in.  */
 636   new_line = (char *) xmalloc (len + 1);
 637   if (new_line == NULL)
 638     return NULL;
 639
 640   /* Restore pointer to beginning of old line.  */
 641   line = save_line;
 642
 643   /* Save pointer to beginning of new line.  */
 644   save_line = new_line;
 645
 646   while ((p = locate_arg (line)))
 647     {
 648       int i, len;
 649
 650       memcpy (new_line, line, p - line);
 651       new_line += p - line;
 652
 653       if (p[4] == 'c')
 654         {
 655           gdb_assert (user_args->count >= 0 && user_args->count <= 10);
 656           if (user_args->count == 10)
 657             {
 658               *(new_line++) = '1';
 659               *(new_line++) = '0';
 660             }
 661           else
 662             *(new_line++) = user_args->count + '0';
 663         }
 664       else
 665         {
 666           i = p[4] - '0';
 667           len = user_args->a[i].len;
 668           if (len)
 669           {
 670             memcpy (new_line, user_args->a[i].arg, len);
 671             new_line += len;
 672           }
 673         }
 674       line = p + 5;
 675     }
 676   /* Don't forget the tail.  */
 677   strcpy (new_line, line);
 678
 679   /* Return a pointer to the beginning of the new line.  */
 680   return save_line;
 681 }
 682
 683 \f
 684 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
 685    code bodies.  This is typically used when we encounter an "else"
 686    clause for an "if" command.  */
 687
 688 static void
 689 realloc_body_list (struct command_line *command, int new_length)
 690 {
 691   int n;
 692   struct command_line **body_list;
 693
 694   n = command->body_count;
 695
 696   /* Nothing to do?  */
 697   if (new_length <= n)
 698     return;
 699
 700   body_list = (struct command_line **)
 701     xmalloc (sizeof (struct command_line *) * new_length);
 702
 703   memcpy (body_list, command->body_list, sizeof (struct command_line *) * n);
 704
 705   xfree (command->body_list);
 706   command->body_list = body_list;
 707   command->body_count = new_length;
 708 }
 709
 710 /* Read one line from the input stream.  If the command is an "else" or
 711    "end", return such an indication to the caller.  */
 712
 713 static enum misc_command_type
 714 read_next_line (struct command_line **command)
 715 {
 716   char *p, *p1, *prompt_ptr, control_prompt[256];
 717   int i = 0;
 718
 719   if (control_level >= 254)
 720     error (_("Control nesting too deep!"));
 721
 722   /* Set a prompt based on the nesting of the control commands.  */
 723   if (instream == stdin || (instream == 0 && deprecated_readline_hook != NULL))
 724     {
 725       for (i = 0; i < control_level; i++)
 726         control_prompt[i] = ' ';
 727       control_prompt[i] = '>';
 728       control_prompt[i + 1] = '\0';
 729       prompt_ptr = (char *) &control_prompt[0];
 730     }
 731   else
 732     prompt_ptr = NULL;
 733
 734   p = command_line_input (prompt_ptr, instream == stdin, "commands");
 735
 736   /* Not sure what to do here.  */
 737   if (p == NULL)
 738     return end_command;
 739
 740   /* Strip leading and trailing whitespace.  */
 741   while (*p == ' ' || *p == '\t')
 742     p++;
 743
 744   p1 = p + strlen (p);
 745   while (p1 != p && (p1[-1] == ' ' || p1[-1] == '\t'))
 746     p1--;
 747
 748   /* Blanks and comments don't really do anything, but we need to
 749      distinguish them from else, end and other commands which can be
 750      executed.  */
 751   if (p1 == p || p[0] == '#')
 752     return nop_command;
 753
 754   /* Is this the end of a simple, while, or if control structure?  */
 755   if (p1 - p == 3 && !strncmp (p, "end", 3))
 756     return end_command;
 757
 758   /* Is the else clause of an if control structure?  */
 759   if (p1 - p == 4 && !strncmp (p, "else", 4))
 760     return else_command;
 761
 762   /* Check for while, if, break, continue, etc and build a new command
 763      line structure for them.  */
 764   if (p1 - p > 5 && !strncmp (p, "while", 5))
 765     {
 766       char *first_arg;
 767       first_arg = p + 5;
 768       while (first_arg < p1 && isspace (*first_arg))
 769         first_arg++;
 770       *command = build_command_line (while_control, first_arg);
 771     }
 772   else if (p1 - p > 2 && !strncmp (p, "if", 2))
 773     {
 774       char *first_arg;
 775       first_arg = p + 2;
 776       while (first_arg < p1 && isspace (*first_arg))
 777         first_arg++;
 778       *command = build_command_line (if_control, first_arg);
 779     }
 780   else if (p1 - p == 10 && !strncmp (p, "loop_break", 10))
 781     {
 782       *command = (struct command_line *)
 783         xmalloc (sizeof (struct command_line));
 784       (*command)->next = NULL;
 785       (*command)->line = NULL;
 786       (*command)->control_type = break_control;
 787       (*command)->body_count = 0;
 788       (*command)->body_list = NULL;
 789     }
 790   else if (p1 - p == 13 && !strncmp (p, "loop_continue", 13))
 791     {
 792       *command = (struct command_line *)
 793         xmalloc (sizeof (struct command_line));
 794       (*command)->next = NULL;
 795       (*command)->line = NULL;
 796       (*command)->control_type = continue_control;
 797       (*command)->body_count = 0;
 798       (*command)->body_list = NULL;
 799     }
 800   else
 801     {
 802       /* A normal command.  */
 803       *command = (struct command_line *)
 804         xmalloc (sizeof (struct command_line));
 805       (*command)->next = NULL;
 806       (*command)->line = savestring (p, p1 - p);
 807       (*command)->control_type = simple_control;
 808       (*command)->body_count = 0;
 809       (*command)->body_list = NULL;
 810     }
 811
 812   /* Nothing special.  */
 813   return ok_command;
 814 }
 815
 816 /* Recursively read in the control structures and create a command_line
 817    structure from them.
 818
 819    The parent_control parameter is the control structure in which the
 820    following commands are nested.  */
 821
 822 static enum command_control_type
 823 recurse_read_control_structure (struct command_line *current_cmd)
 824 {
 825   int current_body, i;
 826   enum misc_command_type val;
 827   enum command_control_type ret;
 828   struct command_line **body_ptr, *child_tail, *next;
 829
 830   child_tail = NULL;
 831   current_body = 1;
 832
 833   /* Sanity checks.  */
 834   if (current_cmd->control_type == simple_control)
 835     error (_("Recursed on a simple control type."));
 836
 837   if (current_body > current_cmd->body_count)
 838     error (_("Allocated body is smaller than this command type needs."));
 839
 840   /* Read lines from the input stream and build control structures.  */
 841   while (1)
 842     {
 843       dont_repeat ();
 844
 845       next = NULL;
 846       val = read_next_line (&next);
 847
 848       /* Just skip blanks and comments.  */
 849       if (val == nop_command)
 850         continue;
 851
 852       if (val == end_command)
 853         {
 854           if (current_cmd->control_type == while_control
 855               || current_cmd->control_type == if_control)
 856             {
 857               /* Success reading an entire control structure.  */
 858               ret = simple_control;
 859               break;
 860             }
 861           else
 862             {
 863               ret = invalid_control;
 864               break;
 865             }
 866         }
 867
 868       /* Not the end of a control structure.  */
 869       if (val == else_command)
 870         {
 871           if (current_cmd->control_type == if_control
 872               && current_body == 1)
 873             {
 874               realloc_body_list (current_cmd, 2);
 875               current_body = 2;
 876               child_tail = NULL;
 877               continue;
 878             }
 879           else
 880             {
 881               ret = invalid_control;
 882               break;
 883             }
 884         }
 885
 886       if (child_tail)
 887         {
 888           child_tail->next = next;
 889         }
 890       else
 891         {
 892           body_ptr = current_cmd->body_list;
 893           for (i = 1; i < current_body; i++)
 894             body_ptr++;
 895
 896           *body_ptr = next;
 897
 898         }
 899
 900       child_tail = next;
 901
 902       /* If the latest line is another control structure, then recurse
 903          on it.  */
 904       if (next->control_type == while_control
 905           || next->control_type == if_control)
 906         {
 907           control_level++;
 908           ret = recurse_read_control_structure (next);
 909           control_level--;
 910
 911           if (ret != simple_control)
 912             break;
 913         }
 914     }
 915
 916   dont_repeat ();
 917
 918   return ret;
 919 }
 920
 921 /* Read lines from the input stream and accumulate them in a chain of
 922    struct command_line's, which is then returned.  For input from a
 923    terminal, the special command "end" is used to mark the end of the
 924    input, and is not included in the returned chain of commands. */
 925
 926 #define END_MESSAGE "End with a line saying just \"end\"."
 927
 928 struct command_line *
 929 read_command_lines (char *prompt_arg, int from_tty)
 930 {
 931   struct command_line *head, *tail, *next;
 932   struct cleanup *old_chain;
 933   enum command_control_type ret;
 934   enum misc_command_type val;
 935
 936   control_level = 0;
 937
 938   if (from_tty && input_from_terminal_p ())
 939     {
 940       if (deprecated_readline_begin_hook)
 941         {
 942           /* Note - intentional to merge messages with no newline */
 943           (*deprecated_readline_begin_hook) ("%s  %s\n", prompt_arg, END_MESSAGE);
 944         }
 945       else
 946         {
 947           printf_unfiltered ("%s\n%s\n", prompt_arg, END_MESSAGE);
 948           gdb_flush (gdb_stdout);
 949         }
 950     }
 951
 952   head = tail = NULL;
 953   old_chain = NULL;
 954
 955   while (1)
 956     {
 957       val = read_next_line (&next);
 958
 959       /* Ignore blank lines or comments.  */
 960       if (val == nop_command)
 961         continue;
 962
 963       if (val == end_command)
 964         {
 965           ret = simple_control;
 966           break;
 967         }
 968
 969       if (val != ok_command)
 970         {
 971           ret = invalid_control;
 972           break;
 973         }
 974
 975       if (next->control_type == while_control
 976           || next->control_type == if_control)
 977         {
 978           control_level++;
 979           ret = recurse_read_control_structure (next);
 980           control_level--;
 981
 982           if (ret == invalid_control)
 983             break;
 984         }
 985
 986       if (tail)
 987         {
 988           tail->next = next;
 989         }
 990       else
 991         {
 992           head = next;
 993           old_chain = make_cleanup_free_command_lines (&head);
 994         }
 995       tail = next;
 996     }
 997
 998   dont_repeat ();
 999
1000   if (head)
1001     {
1002       if (ret != invalid_control)
1003         {
1004           discard_cleanups (old_chain);
1005         }
1006       else
1007         do_cleanups (old_chain);
1008     }
1009
1010   if (deprecated_readline_end_hook && from_tty && input_from_terminal_p ())
1011     {
1012       (*deprecated_readline_end_hook) ();
1013     }
1014   return (head);
1015 }
1016
1017 /* Free a chain of struct command_line's.  */
1018
1019 void
1020 free_command_lines (struct command_line **lptr)
1021 {
1022   struct command_line *l = *lptr;
1023   struct command_line *next;
1024   struct command_line **blist;
1025   int i;
1026
1027   while (l)
1028     {
1029       if (l->body_count > 0)
1030         {
1031           blist = l->body_list;
1032           for (i = 0; i < l->body_count; i++, blist++)
1033             free_command_lines (blist);
1034         }
1035       next = l->next;
1036       xfree (l->line);
1037       xfree (l);
1038       l = next;
1039     }
1040   *lptr = NULL;
1041 }
1042
1043 static void
1044 do_free_command_lines_cleanup (void *arg)
1045 {
1046   free_command_lines (arg);
1047 }
1048
1049 struct cleanup *
1050 make_cleanup_free_command_lines (struct command_line **arg)
1051 {
1052   return make_cleanup (do_free_command_lines_cleanup, arg);
1053 }
1054
1055 struct command_line *
1056 copy_command_lines (struct command_line *cmds)
1057 {
1058   struct command_line *result = NULL;
1059
1060   if (cmds)
1061     {
1062       result = (struct command_line *) xmalloc (sizeof (struct command_line));
1063
1064       result->next = copy_command_lines (cmds->next);
1065       result->line = xstrdup (cmds->line);
1066       result->control_type = cmds->control_type;
1067       result->body_count = cmds->body_count;
1068       if (cmds->body_count > 0)
1069         {
1070           int i;
1071
1072           result->body_list = (struct command_line **)
1073             xmalloc (sizeof (struct command_line *) * cmds->body_count);
1074
1075           for (i = 0; i < cmds->body_count; i++)
1076             result->body_list[i] = copy_command_lines (cmds->body_list[i]);
1077         }
1078       else
1079         result->body_list = NULL;
1080     }
1081
1082   return result;
1083 }
1084 \f
1085 static void
1086 validate_comname (char *comname)
1087 {
1088   char *p;
1089
1090   if (comname == 0)
1091     error_no_arg (_("name of command to define"));
1092
1093   p = comname;
1094   while (*p)
1095     {
1096       if (!isalnum (*p) && *p != '-' && *p != '_')
1097         error (_("Junk in argument list: \"%s\""), p);
1098       p++;
1099     }
1100 }
1101
1102 /* This is just a placeholder in the command data structures.  */
1103 static void
1104 user_defined_command (char *ignore, int from_tty)
1105 {
1106 }
1107
1108 void
1109 define_command (char *comname, int from_tty)
1110 {
1111 #define MAX_TMPBUF 128
1112   enum cmd_hook_type
1113     {
1114       CMD_NO_HOOK = 0,
1115       CMD_PRE_HOOK,
1116       CMD_POST_HOOK
1117     };
1118   struct command_line *cmds;
1119   struct cmd_list_element *c, *newc, *oldc, *hookc = 0;
1120   char *tem = comname;
1121   char *tem2;
1122   char tmpbuf[MAX_TMPBUF];
1123   int  hook_type      = CMD_NO_HOOK;
1124   int  hook_name_size = 0;
1125
1126 #define HOOK_STRING     "hook-"
1127 #define HOOK_LEN 5
1128 #define HOOK_POST_STRING "hookpost-"
1129 #define HOOK_POST_LEN    9
1130
1131   validate_comname (comname);
1132
1133   /* Look it up, and verify that we got an exact match.  */
1134   c = lookup_cmd (&tem, cmdlist, "", -1, 1);
1135   if (c && strcmp (comname, c->name) != 0)
1136     c = 0;
1137
1138   if (c)
1139     {
1140       int q;
1141       if (c->class == class_user || c->class == class_alias)
1142         q = query (_("Redefine command \"%s\"? "), c->name);
1143       else
1144         q = query (_("Really redefine built-in command \"%s\"? "), c->name);
1145       if (!q)
1146         error (_("Command \"%s\" not redefined."), c->name);
1147     }
1148
1149   /* If this new command is a hook, then mark the command which it
1150      is hooking.  Note that we allow hooking `help' commands, so that
1151      we can hook the `stop' pseudo-command.  */
1152
1153   if (!strncmp (comname, HOOK_STRING, HOOK_LEN))
1154     {
1155        hook_type      = CMD_PRE_HOOK;
1156        hook_name_size = HOOK_LEN;
1157     }
1158   else if (!strncmp (comname, HOOK_POST_STRING, HOOK_POST_LEN))
1159     {
1160       hook_type      = CMD_POST_HOOK;
1161       hook_name_size = HOOK_POST_LEN;
1162     }
1163
1164   if (hook_type != CMD_NO_HOOK)
1165     {
1166       /* Look up cmd it hooks, and verify that we got an exact match.  */
1167       tem = comname + hook_name_size;
1168       hookc = lookup_cmd (&tem, cmdlist, "", -1, 0);
1169       if (hookc && strcmp (comname + hook_name_size, hookc->name) != 0)
1170         hookc = 0;
1171       if (!hookc)
1172         {
1173           warning (_("Your new `%s' command does not hook any existing command."),
1174                    comname);
1175           if (!query ("Proceed? "))
1176             error (_("Not confirmed."));
1177         }
1178     }
1179
1180   comname = savestring (comname, strlen (comname));
1181
1182   /* If the rest of the commands will be case insensitive, this one
1183      should behave in the same manner. */
1184   for (tem = comname; *tem; tem++)
1185     if (isupper (*tem))
1186       *tem = tolower (*tem);
1187
1188   sprintf (tmpbuf, "Type commands for definition of \"%s\".", comname);
1189   cmds = read_command_lines (tmpbuf, from_tty);
1190
1191   if (c && c->class == class_user)
1192     free_command_lines (&c->user_commands);
1193
1194   newc = add_cmd (comname, class_user, user_defined_command,
1195                   (c && c->class == class_user)
1196                   ? c->doc : savestring ("User-defined.", 13), &cmdlist);
1197   newc->user_commands = cmds;
1198
1199   /* If this new command is a hook, then mark both commands as being
1200      tied.  */
1201   if (hookc)
1202     {
1203       switch (hook_type)
1204         {
1205         case CMD_PRE_HOOK:
1206           hookc->hook_pre  = newc;  /* Target gets hooked.  */
1207           newc->hookee_pre = hookc; /* We are marked as hooking target cmd. */
1208           break;
1209         case CMD_POST_HOOK:
1210           hookc->hook_post  = newc;  /* Target gets hooked.  */
1211           newc->hookee_post = hookc; /* We are marked as hooking target cmd. */
1212           break;
1213         default:
1214           /* Should never come here as hookc would be 0. */
1215           internal_error (__FILE__, __LINE__, _("bad switch"));
1216         }
1217     }
1218 }
1219
1220 void
1221 document_command (char *comname, int from_tty)
1222 {
1223   struct command_line *doclines;
1224   struct cmd_list_element *c;
1225   char *tem = comname;
1226   char tmpbuf[128];
1227
1228   validate_comname (comname);
1229
1230   c = lookup_cmd (&tem, cmdlist, "", 0, 1);
1231
1232   if (c->class != class_user)
1233     error (_("Command \"%s\" is built-in."), comname);
1234
1235   sprintf (tmpbuf, "Type documentation for \"%s\".", comname);
1236   doclines = read_command_lines (tmpbuf, from_tty);
1237
1238   if (c->doc)
1239     xfree (c->doc);
1240
1241   {
1242     struct command_line *cl1;
1243     int len = 0;
1244
1245     for (cl1 = doclines; cl1; cl1 = cl1->next)
1246       len += strlen (cl1->line) + 1;
1247
1248     c->doc = (char *) xmalloc (len + 1);
1249     *c->doc = 0;
1250
1251     for (cl1 = doclines; cl1; cl1 = cl1->next)
1252       {
1253         strcat (c->doc, cl1->line);
1254         if (cl1->next)
1255           strcat (c->doc, "\n");
1256       }
1257   }
1258
1259   free_command_lines (&doclines);
1260 }
1261 \f
1262 struct source_cleanup_lines_args
1263 {
1264   int old_line;
1265   char *old_file;
1266 };
1267
1268 static void
1269 source_cleanup_lines (void *args)
1270 {
1271   struct source_cleanup_lines_args *p =
1272   (struct source_cleanup_lines_args *) args;
1273   source_line_number = p->old_line;
1274   source_file_name = p->old_file;
1275 }
1276
1277 static void
1278 do_fclose_cleanup (void *stream)
1279 {
1280   fclose (stream);
1281 }
1282
1283 struct wrapped_read_command_file_args
1284 {
1285   FILE *stream;
1286 };
1287
1288 static void
1289 wrapped_read_command_file (struct ui_out *uiout, void *data)
1290 {
1291   struct wrapped_read_command_file_args *args = data;
1292   read_command_file (args->stream);
1293 }
1294
1295 /* Used to implement source_command */
1296
1297 void
1298 script_from_file (FILE *stream, char *file)
1299 {
1300   struct cleanup *old_cleanups;
1301   struct source_cleanup_lines_args old_lines;
1302   int needed_length;
1303
1304   if (stream == NULL)
1305     internal_error (__FILE__, __LINE__, _("called with NULL file pointer!"));
1306
1307   old_cleanups = make_cleanup (do_fclose_cleanup, stream);
1308
1309   old_lines.old_line = source_line_number;
1310   old_lines.old_file = source_file_name;
1311   make_cleanup (source_cleanup_lines, &old_lines);
1312   source_line_number = 0;
1313   source_file_name = file;
1314   /* This will get set every time we read a line.  So it won't stay "" for
1315      long.  */
1316   error_pre_print = "";
1317
1318   {
1319     struct gdb_exception e;
1320     struct wrapped_read_command_file_args args;
1321     args.stream = stream;
1322     e = catch_exception (uiout, wrapped_read_command_file, &args,
1323                          RETURN_MASK_ERROR);
1324     switch (e.reason)
1325       {
1326       case 0:
1327         break;
1328       case RETURN_ERROR:
1329         /* Re-throw the error, but with the file name information
1330            prepended.  */
1331         throw_error (e.error,
1332                      _("%s:%d: Error in sourced command file:\n%s"),
1333                      source_file_name, source_line_number, e.message);
1334       default:
1335         internal_error (__FILE__, __LINE__, _("bad reason"));
1336       }
1337   }
1338
1339   do_cleanups (old_cleanups);
1340 }
1341
1342 void
1343 show_user_1 (struct cmd_list_element *c, struct ui_file *stream)
1344 {
1345   struct command_line *cmdlines;
1346
1347   cmdlines = c->user_commands;
1348   if (!cmdlines)
1349     return;
1350   fputs_filtered ("User command ", stream);
1351   fputs_filtered (c->name, stream);
1352   fputs_filtered (":\n", stream);
1353
1354   print_command_lines (uiout, cmdlines, 1);
1355   fputs_filtered ("\n", stream);
1356 }
1357