gdb/cli/cli-script.c

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