/*

 * command.y - yacc/bison parser for debugger commands.

 */

/*

 * Copyright (C) 2004, 2010, 2011, 2014, 2016, 2017

 * the Free Software Foundation, Inc.

 *

 * This file is part of GAWK, the GNU implementation of the

 * AWK Programming Language.

 *

 * GAWK is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or

 * (at your option) any later version.

 *

 * GAWK is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335,

 * USA 

 */

%{

#include "awk.h"

#include "cmd.h"

#if 0

#define YYDEBUG 12

int yydebug = 2;

#endif

static int yylex(void);

static void yyerror(const char *mesg, ...);

static int find_command(const char *token, size_t toklen);

static bool want_nodeval = false;

static int cmd_idx = -1;		/* index of current command in cmd table */

static int repeat_idx = -1;		/* index of last repeatable command in command table */

static CMDARG *arg_list = NULL;		/* list of arguments */

static long errcount = 0;

static char *lexptr_begin = NULL;

static bool in_commands = false;

static int num_dim;

static bool in_eval = false;

static const char start_EVAL[] = "function @eval(){";

static const char end_EVAL[] = "}";

static CMDARG *append_statement(CMDARG *stmt_list, char *stmt);

static NODE *concat_args(CMDARG *a, int count);

#ifdef HAVE_LIBREADLINE

static char *next_word(char *p, int len, char **endp);

static void history_expand_line(char **line);

static char *command_generator(const char *text, int state);

static char *srcfile_generator(const char *text, int state);

static char *argument_generator(const char *text, int state);

static char *variable_generator(const char *text, int state);

extern char *option_generator(const char *text, int state);

static int this_cmd = D_illegal;

#else

#define history_expand_line(p)	/* nothing */

static int rl_inhibit_completion;	/* dummy variable */

#endif

struct argtoken {

	const char *name;

	enum argtype cmd;

	enum nametypeval value;

};

/*

 * These two should be static, but there are some compilers that

 * don't like the static keyword with an empty size. Therefore give

 * them names that are less likely to conflict with the rest of gawk.

 */

#define argtab zz_debug_argtab

#define cmdtab zz_debug_cmdtab

extern struct argtoken argtab[];

extern struct cmdtoken cmdtab[];

static CMDARG *mk_cmdarg(enum argtype type);

static void append_cmdarg(CMDARG *arg);

static int find_argument(CMDARG *arg);

#define YYSTYPE CMDARG *

%}

%token D_BACKTRACE D_BREAK D_CLEAR D_CONTINUE D_DELETE D_DISABLE D_DOWN

%token D_ENABLE D_FINISH D_FRAME D_HELP D_IGNORE D_INFO D_LIST

%token D_NEXT D_NEXTI D_PRINT D_PRINTF D_QUIT D_RETURN D_RUN D_SET

%token D_STEP D_STEPI D_TBREAK D_UP D_UNTIL

%token D_DISPLAY D_UNDISPLAY D_WATCH D_UNWATCH

%token D_DUMP D_TRACE

%token D_INT D_STRING D_NODE D_VARIABLE

%token D_OPTION D_COMMANDS D_END D_SILENT D_SOURCE

%token D_SAVE D_EVAL D_CONDITION

%token D_STATEMENT

%%

input

	: /* empty */

	| input line

	  {

		cmd_idx = -1;

		want_nodeval = false;

		if (lexptr_begin != NULL) {

			if (input_from_tty && lexptr_begin[0] != '\0')

				add_history(lexptr_begin);

			efree(lexptr_begin);

			lexptr_begin = NULL;

		}

		if (arg_list != NULL) {

			free_cmdarg(arg_list);

			arg_list = NULL;

		}

	  }

	;

line

	: nls

	| command nls

	  {

		if (errcount == 0 && cmd_idx >= 0) {

			Func_cmd cmdfunc;

			bool terminate = false;

			CMDARG *args;

			int ctype = 0;

			ctype = cmdtab[cmd_idx].type;

			/* a blank line repeats previous command

			 * (list, next, nexti, step, stepi and continue without arguments).

			 * save the index in the command table; used in yylex

			 */

			if ((ctype == D_list

					|| ctype == D_next

					|| ctype == D_step

					|| ctype == D_nexti

					|| ctype == D_stepi

					|| ctype == D_continue)

				&& arg_list == NULL

				&& ! in_commands

				&& input_from_tty

			)

				repeat_idx = cmd_idx;

			else

				repeat_idx = -1;

			/* call the command handler; reset the globals arg_list, cmd_idx,

			 * since this handler could invoke yyparse again.

			 * call do_commands for the list of commands in `commands';

			 * arg_list isn't freed on return.

			 */

			cmdfunc = cmdtab[cmd_idx].cf_ptr;

			if (in_commands)

				cmdfunc = do_commands;

			cmd_idx = -1;

			want_nodeval = false;

			args = arg_list;

			arg_list = NULL;

			terminate = (*cmdfunc)(args, ctype);

			if (! in_commands || ctype == D_commands)

				free_cmdarg(args);

			if (terminate)

				YYACCEPT;

		}

	  }

	| error nls

	  {

		yyerrok;

	  }

	;

control_cmd

	: D_CONTINUE

	| D_NEXT

	| D_NEXTI

	| D_STEP

	| D_STEPI

	;

d_cmd

	: D_UNDISPLAY

	| D_UNWATCH

	| D_DISABLE

	| D_DELETE

	;

frame_cmd

	: D_UP

	| D_DOWN

	| D_BACKTRACE

	| D_FRAME

	;

break_cmd

	: D_BREAK

	| D_TBREAK

	;

/* mid-rule action buried in non-terminal to avoid conflict */

set_want_nodeval

	: { want_nodeval = true; }

	;

eval_prologue

	: D_EVAL set_want_nodeval opt_param_list nls

	  {

		if (errcount == 0) {

			/* don't free arg_list;	passed on to statement_list

			 * non-terminal (empty rule action). See below.

			 */

			if (input_from_tty) {

				dbg_prompt = eval_prompt;

				fprintf(out_fp,

		_("Type (g)awk statement(s). End with the command \"end\"\n"));

				rl_inhibit_completion = 1;

			}

			cmd_idx = -1;

			in_eval = true;

		}

	  }

	;

statement_list

	: /* empty */

	  {

		$$ = append_statement(arg_list, (char *) start_EVAL);

		if (read_a_line == read_commands_string)	/* unserializing 'eval' in 'commands' */

			$$->a_string[0] = '\0';

		free_cmdarg(arg_list);

		arg_list = NULL;

	  }

	| statement_list D_STATEMENT { $$ = append_statement($1, lexptr_begin); } nls

	  {

		$$ = $3;

	  }

	;

eval_cmd

	: eval_prologue statement_list D_END

	  {

		arg_list = append_statement($2, (char *) end_EVAL);

		if (read_a_line == read_commands_string) {	/* unserializing 'eval' in 'commands' */

			char *str = arg_list->a_string;

			size_t len = strlen(str);

			assert(len > 2 && str[len - 2] == '}');

			str[len - 2] = '\0';

		}

		if (input_from_tty) {

			dbg_prompt = in_commands ? commands_prompt : dgawk_prompt;

			rl_inhibit_completion = 0;

		}

		cmd_idx = find_command("eval", 4);

		in_eval = false;

	  }

	| D_EVAL set_want_nodeval string_node

	  {

		NODE *n;

		CMDARG *arg;

		n = $3->a_node;

		arg = append_statement(NULL, (char *) start_EVAL);

		(void) append_statement(arg, n->stptr);

		(void) append_statement(arg, (char *) end_EVAL);

		free_cmdarg(arg_list);

		arg_list = arg;

	  }

	;

command

	: D_HELP help_args

	| D_QUIT

	| D_RUN

	| D_FINISH

	| control_cmd opt_plus_integer

	| frame_cmd opt_integer

	  {

		if (cmdtab[cmd_idx].class == D_FRAME

				&& $2 != NULL && $2->a_int < 0)

			yyerror(_("invalid frame number: %d"), $2->a_int);

	  }

	| D_INFO D_STRING

	  {

		int idx = find_argument($2);

		if (idx < 0)

			yyerror(_("info: invalid option - \"%s\""), $2->a_string);

		else {

			efree($2->a_string);

			$2->a_string = NULL;

			$2->type = D_argument;

			$2->a_argument = argtab[idx].value;

		}

	  }

	| D_IGNORE plus_integer D_INT

	| D_ENABLE enable_args

	| D_PRINT { want_nodeval = true; } print_args

	| D_PRINTF { want_nodeval = true; } printf_args

	| D_LIST list_args

	| D_UNTIL location

	| D_CLEAR location

	| break_cmd break_args

	| D_SET { want_nodeval = true; } variable '=' node

	| D_OPTION option_args

	| D_RETURN { want_nodeval = true; } opt_node

	| D_DISPLAY { want_nodeval = true; } opt_variable

	| D_WATCH { want_nodeval = true; } variable condition_exp

	| d_cmd opt_integer_list

	| D_DUMP opt_string

	| D_SOURCE D_STRING

	  {

		if (in_cmd_src($2->a_string))

			yyerror(_("source \"%s\": already sourced."), $2->a_string);

	  }

	| D_SAVE D_STRING

	  {

		if (! input_from_tty)

			yyerror(_("save \"%s\": command not permitted."), $2->a_string);

	  }

	| D_COMMANDS commands_arg

	  {

		int type = 0;

		int num;

		if ($2 != NULL)

			num = $2->a_int;

		if (errcount != 0)

			;

		else if (in_commands)

			yyerror(_("Can't use command `commands' for breakpoint/watchpoint commands"));

		else if ($2 == NULL &&  ! (type = has_break_or_watch_point(&num, true)))

			yyerror(_("no breakpoint/watchpoint has been set yet"));

		else if ($2 != NULL && ! (type = has_break_or_watch_point(&num, false)))

			yyerror(_("invalid breakpoint/watchpoint number"));

		if (type) {

			in_commands = true;

			if (input_from_tty) {

				dbg_prompt = commands_prompt;

				fprintf(out_fp, _("Type commands for when %s %d is hit, one per line.\n"),

								(type == D_break) ? "breakpoint" : "watchpoint", num);

				fprintf(out_fp, _("End with the command \"end\"\n"));

			}

		}

	  }

	| D_END

	  {

		if (! in_commands)

			yyerror(_("`end' valid only in command `commands' or `eval'"));

		else {

			if (input_from_tty)

				dbg_prompt = dgawk_prompt;

			in_commands = false;

		}

	  }

	| D_SILENT

	  {

		if (! in_commands)

			yyerror(_("`silent' valid only in command `commands'"));

	  }

	| D_TRACE D_STRING

	  {

		int idx = find_argument($2);

		if (idx < 0)

			yyerror(_("trace: invalid option - \"%s\""), $2->a_string);

		else {

			efree($2->a_string);

			$2->a_string = NULL;

			$2->type = D_argument;

			$2->a_argument = argtab[idx].value;

		}

	  }

	| D_CONDITION plus_integer { want_nodeval = true; } condition_exp

	  {

		int type;

		int num = $2->a_int;

		type = has_break_or_watch_point(&num, false);

		if (! type)

			yyerror(_("condition: invalid breakpoint/watchpoint number"));

	  }

	| eval_cmd

	  {

		if (in_commands) {

			/* Prepend command 'eval' to argument list */

			CMDARG *arg;

			arg = mk_cmdarg(D_string);

			arg->a_string = estrdup("eval", 4);

			arg->next = arg_list;

			arg_list = arg;

		}

	  }

	;

condition_exp

	: opt_string_node

	  {

		if ($1 != NULL) {

			NODE *n = $1->a_node;

			$1->type = D_string;

			$1->a_string = n->stptr;

			freenode(n);

		}

		$$ = $1;

	  }

	;

commands_arg

	: opt_plus_integer

	| error

	  {	$$ = NULL; }

	;

opt_param_list

	: /* empty */

	  { $$ = NULL; }

	| param_list

	;

param_list

	: D_VARIABLE

	| param_list D_VARIABLE

	| param_list ',' D_VARIABLE

	| error

	  { $$ = NULL; }

	;

opt_string_node

	: /* empty */

	  { $$ = NULL; }

	| string_node

	| error

	  { $$ = NULL; }

	;

string_node

	: D_NODE

	  {

		NODE *n;

		n = $1->a_node;

		if ((n->flags & STRING) == 0)

			yyerror(_("argument not a string"));

	  }

	;

option_args

	: /* empty */

	  { $$ = NULL; }

	| D_STRING

	  {

		if (find_option($1->a_string) < 0)

			yyerror(_("option: invalid parameter - \"%s\""), $1->a_string);

 	  }

	| D_STRING '=' D_STRING

	  {

		if (find_option($1->a_string) < 0)

			yyerror(_("option: invalid parameter - \"%s\""), $1->a_string);

 	  }

	;

func_name

	: D_STRING

	  {

		NODE *n;

		n = lookup($1->a_string);

		if (n == NULL || n->type != Node_func)

			yyerror(_("no such function - \"%s\""), $1->a_string);

		else {

			$1->type = D_func;

			efree($1->a_string);

			$1->a_string = NULL;

			$1->a_node = n;

		}

	  }

	;

location

	: /* empty */

	  { $$ = NULL; }

	| plus_integer

	| func_name

	| D_STRING ':' plus_integer

	| D_STRING ':' func_name

	;

break_args

	: /* empty */

	  { $$ = NULL; }

	| plus_integer { want_nodeval = true; } condition_exp

	| func_name

	| D_STRING ':' plus_integer { want_nodeval = true; } condition_exp

	| D_STRING ':' func_name

	;

opt_variable

	: /* empty */

	  { $$ = NULL; }

	| variable

	;

opt_string

	: /* empty */

	  { $$ = NULL; }

	| D_STRING

	;

opt_node

	: /* empty */

	  { $$ = NULL; }

	| node

	;

help_args

	: /* empty */

	| D_STRING

	;

enable_args

	: opt_integer_list

	| D_STRING opt_integer_list

	  {

		int idx = find_argument($1);

		if (idx < 0)

			yyerror(_("enable: invalid option - \"%s\""), $1->a_string);

		else {

			efree($1->a_string);

			$1->a_string = NULL;

			$1->type = D_argument;

			$1->a_argument = argtab[idx].value;

		}

	  }

	;

print_exp

	: variable

	| '@' D_VARIABLE

	  {

		$2->type = D_array;	/* dump all items */

		$2->a_count = 0;

	  }

	| '@' D_VARIABLE subscript_list /* dump sub-array items*/

	  {

		$2->type = D_array;

		$2->a_count = num_dim;

	  }

	;

print_args

	: print_exp

	| print_args print_exp

	| print_args ',' print_exp

	| error

	;

printf_exp

	: D_NODE

	| variable

	;

printf_args

	: printf_exp

	| printf_args ',' printf_exp

	| error

	;

list_args

	: /* empty */

	  { $$ = NULL; }

	| '+'

	  { $$ = NULL; }

	| '-'

	  {

		CMDARG *a;

		a = mk_cmdarg(D_int);

		a->a_int = -1;

		append_cmdarg(a);

	  }

	| plus_integer

	| func_name

	| integer_range

	| D_STRING ':' plus_integer

	| D_STRING ':' func_name

	| D_STRING ':' integer_range

	;

integer_range

	: plus_integer '-' plus_integer

	  {

		if ($1->a_int > $3->a_int)

			yyerror(_("invalid range specification: %d - %d"),

				$1->a_int, $3->a_int);

		else

			$1->type = D_range;

		$$ = $1;

	  }

	;

opt_integer_list

	: /* empty */

	  { $$ = NULL; }

	| integer_list

	| error

	;

integer_list

	: plus_integer

	| integer_range

	| integer_list plus_integer

	| integer_list integer_range

	;

exp_list

	: node

	  { $$ = $1; }

	| exp_list ',' node

	  { $$ = $1; }

	| error

	;

subscript

	: '[' exp_list ']'

	  {

		CMDARG *a;

		NODE *subs;

		int count = 0;

		for (a = $2; a != NULL; a = a->next)

			count++;

		subs = concat_args($2, count);

		free_cmdarg($2->next);

		$2->next = NULL;

		$2->type = D_node;

		$2->a_node = subs;

		$$ = $2;

	  }

	| '[' exp_list error

	;

subscript_list

	: subscript

	  { $$ = $1; num_dim = 1; }

	| subscript_list subscript

	  {	$$ = $1; num_dim++; }

	;

variable

	: D_VARIABLE

	| '$' D_NODE

	  {

		NODE *n = $2->a_node;

		if ((n->flags & NUMBER) == 0)

			yyerror(_("non-numeric value for field number"));

		else

			$2->type = D_field;

		$$ = $2;

	  }

	| D_VARIABLE subscript_list

	  {

		/* a_string is array name, a_count is dimension count */

		$1->type = D_subscript;

		$1->a_count = num_dim;

		$$ = $1;

	  }

	;

node

	: D_NODE

	  { $$ = $1; }

	| '+' D_NODE

	  {

		NODE *n = $2->a_node;

		if ((n->flags & NUMBER) == 0)

			yyerror(_("non-numeric value found, numeric expected"));

		$$ = $2;

	  }

	| '-' D_NODE

	  {

		NODE *n = $2->a_node;

		if ((n->flags & NUMBER) == 0)

			yyerror(_("non-numeric value found, numeric expected"));

		else

			negate_num(n);

		$$ = $2;

	  }

	;

opt_plus_integer

	: /* empty */

	  { $$ = NULL; }

	| plus_integer

	  { $$ = $1; }

	;

opt_integer

	: /* empty */

	  { $$ = NULL; }

	| integer

	  { $$ = $1; }

	;

plus_integer

	: D_INT

	  {

		if ($1->a_int == 0)

			yyerror(_("non-zero integer value"));

		$$ = $1;

	  }

	| '+' D_INT

	  {

		if ($2->a_int == 0)

			yyerror(_("non-zero integer value"));

		$$ = $2;

	  }

	;

integer

	: D_INT

	  { $$ = $1; }

	| '+' D_INT

	  { $$ = $2; }

	| '-' D_INT

	  {

		$2->a_int = - $2->a_int;

		$$ = $2;

	  }

	;

nls

	: '\n'

	  {

		if (lexptr_begin != NULL) {

			if (input_from_tty && lexptr_begin[0] != '\0')

				add_history(lexptr_begin);

			efree(lexptr_begin);

			lexptr_begin = NULL;

		}

	  }

	;

%%

/* append_statement --- append 'stmt' to the list of eval awk statements */

static CMDARG *

append_statement(CMDARG *stmt_list, char *stmt)

{

	CMDARG *a, *arg;

	char *s;

	int len, slen, ssize;

#define EVALSIZE	512

	if (stmt == start_EVAL) {

		len = sizeof(start_EVAL);

		for (a = stmt_list; a != NULL; a = a->next)

			len += strlen(a->a_string) + 1;	/* 1 for ',' */

		len += EVALSIZE;

		emalloc(s, char *, (len + 1) * sizeof(char), "append_statement");

		arg = mk_cmdarg(D_string);

		arg->a_string = s;

		arg->a_count = len;	/* kludge */

		slen = sizeof("function @eval(") - 1;

		memcpy(s, start_EVAL, slen);

		for (a = stmt_list; a != NULL; a = a->next) {

			len = strlen(a->a_string);

			memcpy(s + slen, a->a_string, len);

			slen += len;

			if (a->next != NULL)

				s[slen++] = ',';

		}

		s[slen++] = ')';

		s[slen++] = '{';

		s[slen] = '\0';

		return arg;

	}

	len = strlen(stmt) + 1;	/* 1 for newline */

	s = stmt_list->a_string;

	slen = strlen(s);

	ssize = stmt_list->a_count;

	if (len > ssize - slen) {

		ssize = slen + len + EVALSIZE;

		erealloc(s, char *, (ssize + 1) * sizeof(char), "append_statement");

		stmt_list->a_string = s;

		stmt_list->a_count = ssize;

	}

	memcpy(s + slen, stmt, len);

	slen += len;

	if (slen >= 2 && s[slen - 2] != '\n') {

		s[slen - 1] = '\n';

		s[slen] = '\0';

	}

	if (stmt == end_EVAL)

		erealloc(stmt_list->a_string, char *, slen + 1, "append_statement");

	return stmt_list;

#undef EVALSIZE

}

/* command names sorted in ascending order */

struct cmdtoken cmdtab[] = {

{ "backtrace", "bt", D_backtrace, D_BACKTRACE, do_backtrace,

	gettext_noop("backtrace [N] - print trace of all or N innermost (outermost if N < 0) frames.") },

{ "break", "b", D_break, D_BREAK, do_breakpoint,

	gettext_noop("break [[filename:]N|function] - set breakpoint at the specified location.") },

{ "clear", "", D_clear, D_CLEAR, do_clear,

	gettext_noop("clear [[filename:]N|function] - delete breakpoints previously set.") },

{ "commands", "", D_commands, D_COMMANDS, do_commands,

	gettext_noop("commands [num] - starts a list of commands to be executed at a breakpoint(watchpoint) hit.") },

{ "condition", "", D_condition, D_CONDITION, do_condition,

	gettext_noop("condition num [expr] - set or clear breakpoint or watchpoint condition.") },

{ "continue", "c", D_continue, D_CONTINUE, do_continue,

	gettext_noop("continue [COUNT] - continue program being debugged.") },

{ "delete", "d", D_delete, D_DELETE, do_delete_breakpoint,

	gettext_noop("delete [breakpoints] [range] - delete specified breakpoints.") },

{ "disable", "", D_disable, D_DISABLE, do_disable_breakpoint,

	gettext_noop("disable [breakpoints] [range] - disable specified breakpoints.") },

{ "display", "", D_display, D_DISPLAY, do_display,

	gettext_noop("display [var] - print value of variable each time the program stops.") },

{ "down", "", D_down, D_DOWN, do_down,

	gettext_noop("down [N] - move N frames down the stack.") },

{ "dump", "", D_dump, D_DUMP, do_dump_instructions,

	gettext_noop("dump [filename] - dump instructions to file or stdout.") },

{ "enable", "e", D_enable, D_ENABLE, do_enable_breakpoint,

	gettext_noop("enable [once|del] [breakpoints] [range] - enable specified breakpoints.") },

{ "end", "", D_end, D_END, do_commands,

	gettext_noop("end - end a list of commands or awk statements.") },

{ "eval", "", D_eval, D_EVAL, do_eval,

	gettext_noop("eval stmt|[p1, p2, ...] - evaluate awk statement(s).") },

{ "exit", "", D_quit, D_QUIT, do_quit,

	gettext_noop("exit - (same as quit) exit debugger.") },

{ "finish", "", D_finish, D_FINISH, do_finish,

	gettext_noop("finish - execute until selected stack frame returns.") },

{ "frame", "f", D_frame, D_FRAME, do_frame,

	gettext_noop("frame [N] - select and print stack frame number N.") },

{ "help", "h", D_help, D_HELP, do_help,

	gettext_noop("help [command] - print list of commands or explanation of command.") },

{ "ignore", "", D_ignore, D_IGNORE, do_ignore_breakpoint,

	gettext_noop("ignore N COUNT - set ignore-count of breakpoint number N to COUNT.") },

{ "info", "i", D_info, D_INFO, do_info,

	gettext_noop("info topic - source|sources|variables|functions|break|frame|args|locals|display|watch.") },

{ "list", "l", D_list, D_LIST, do_list,

	gettext_noop("list [-|+|[filename:]lineno|function|range] - list specified line(s).") },

{ "next", "n", D_next, D_NEXT, do_next,

	gettext_noop("next [COUNT] - step program, proceeding through subroutine calls.") },

{ "nexti", "ni", D_nexti, D_NEXTI, do_nexti,

	gettext_noop("nexti [COUNT] - step one instruction, but proceed through subroutine calls.") },

{ "option", "o", D_option, D_OPTION, do_option,

	gettext_noop("option [name[=value]] - set or display debugger option(s).") },

{ "print", "p", D_print, D_PRINT, do_print_var,

	gettext_noop("print var [var] - print value of a variable or array.") },

{ "printf", "", D_printf, D_PRINTF, do_print_f,

	gettext_noop("printf format, [arg], ... - formatted output.") },

{ "quit", "q", D_quit, D_QUIT, do_quit,

	gettext_noop("quit - exit debugger.") },

{ "return", "", D_return, D_RETURN, do_return,

	gettext_noop("return [value] - make selected stack frame return to its caller.") },

{ "run", "r", D_run, D_RUN, do_run,

	gettext_noop("run - start or restart executing program.") },

#ifdef HAVE_LIBREADLINE

{ "save", "", D_save, D_SAVE, do_save,

	gettext_noop("save filename - save commands from the session to file.") },

#endif

{ "set", "", D_set, D_SET, do_set_var,