Vendor import of dialog-1.1-20100428.

1 files changed, 1710 insertions, 0 deletions

diff --git a/dialog.c b/dialog.c
new file mode 100644
index 0000000..3f718b4
--- /dev/null
+++ b/dialog.c
@@ -0,0 +1,1710 @@
+/*
+ * $Id: dialog.c,v 1.177 2010/01/18 09:21:14 tom Exp $
+ *
+ *  cdialog - Display simple dialog boxes from shell scripts
+ *
+ *  Copyright 2000-2008,2010	Thomas E. Dickey
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License, version 2.1
+ *  as published by the Free Software Foundation.
+ *
+ *  This program 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this program; if not, write to
+ *	Free Software Foundation, Inc.
+ *	51 Franklin St., Fifth Floor
+ *	Boston, MA 02110, USA.
+ *
+ *  An earlier version of this program lists as authors
+ *	Savio Lam (lam836@cs.cuhk.hk)
+ */
+
+#include <dialog.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#ifdef HAVE_SETLOCALE
+#include <locale.h>
+#endif
+
+#define PASSARGS             t,       av,        offset_add
+#define CALLARGS const char *t, char *av[], int *offset_add
+typedef int (callerFn) (CALLARGS);
+
+typedef enum {
+    o_unknown = 0
+    ,o_allow_close
+    ,o_and_widget
+    ,o_ascii_lines
+    ,o_aspect
+    ,o_auto_placement
+    ,o_backtitle
+    ,o_beep
+    ,o_beep_after
+    ,o_begin
+    ,o_calendar
+    ,o_cancel_label
+    ,o_checklist
+    ,o_clear
+    ,o_colors
+    ,o_column_separator
+    ,o_cr_wrap
+    ,o_create_rc
+    ,o_date_format
+    ,o_default_item
+    ,o_defaultno
+    ,o_dselect
+    ,o_editbox
+    ,o_exit_label
+    ,o_extra_button
+    ,o_extra_label
+    ,o_fixed_font
+    ,o_form
+    ,o_fselect
+    ,o_fullbutton
+    ,o_gauge
+    ,o_help
+    ,o_help_button
+    ,o_help_label
+    ,o_help_status
+    ,o_icon
+    ,o_ignore
+    ,o_infobox
+    ,o_input_fd
+    ,o_inputbox
+    ,o_inputmenu
+    ,o_insecure
+    ,o_item_help
+    ,o_keep_colors
+    ,o_keep_tite
+    ,o_keep_window
+    ,o_max_input
+    ,o_menu
+    ,o_mixedform
+    ,o_mixedgauge
+    ,o_msgbox
+    ,o_no_close
+    ,o_no_collapse
+    ,o_no_cr_wrap
+    ,o_no_kill
+    ,o_no_label
+    ,o_no_lines
+    ,o_no_shadow
+    ,o_nocancel
+    ,o_noitem
+    ,o_nook
+    ,o_ok_label
+    ,o_output_fd
+    ,o_output_separator
+    ,o_passwordbox
+    ,o_passwordform
+    ,o_pause
+    ,o_print_maxsize
+    ,o_print_size
+    ,o_print_version
+    ,o_progressbox
+    ,o_quoted
+    ,o_radiolist
+    ,o_screen_center
+    ,o_scrollbar
+    ,o_separate_output
+    ,o_separate_widget
+    ,o_separator
+    ,o_shadow
+    ,o_single_quoted
+    ,o_size_err
+    ,o_sleep
+    ,o_smooth
+    ,o_stderr
+    ,o_stdout
+    ,o_tab_correct
+    ,o_tab_len
+    ,o_tailbox
+    ,o_tailboxbg
+    ,o_textbox
+    ,o_time_format
+    ,o_timebox
+    ,o_timeout
+    ,o_title
+    ,o_trim
+    ,o_under_mouse
+    ,o_visit_items
+    ,o_wmclass
+    ,o_yes_label
+    ,o_yesno
+#ifdef HAVE_DLG_TRACE
+    ,o_trace
+#endif
+} eOptions;
+
+/*
+ * The bits in 'pass' are used to decide which options are applicable at
+ * different stages in the program:
+ *	1 flags before widgets
+ *	2 widgets
+ *	4 non-widget options
+ */
+typedef struct {
+    const char *name;
+    eOptions code;
+    int pass;			/* 1,2,4 or combination */
+    const char *help;		/* NULL to suppress, non-empty to display params */
+} Options;
+
+typedef struct {
+    eOptions code;
+    int argmin, argmax;
+    callerFn *jumper;
+} Mode;
+
+static bool *dialog_opts;
+static char **dialog_argv;
+
+static bool ignore_unknown = FALSE;
+
+static const char *program = "dialog";
+
+/*
+ * The options[] table is organized this way to make it simple to maintain
+ * a sorted list of options for the help-message.
+ */
+/* *INDENT-OFF* */
+static const Options options[] = {
+    { "allow-close",	o_allow_close,		1, NULL },
+    { "and-widget",	o_and_widget,		4, NULL },
+    { "ascii-lines",	o_ascii_lines, 		1, "" },
+    { "aspect",		o_aspect,		1, "<ratio>" },
+    { "auto-placement", o_auto_placement,	1, NULL },
+    { "backtitle",	o_backtitle,		1, "<backtitle>" },
+    { "beep",		o_beep,			1, NULL },
+    { "beep-after",	o_beep_after,		1, NULL },
+    { "begin",		o_begin,		1, "<y> <x>" },
+    { "calendar",	o_calendar,		2, "<text> <height> <width> <day> <month> <year>" },
+    { "cancel-label",	o_cancel_label,		1, "<str>" },
+    { "checklist",	o_checklist,		2, "<text> <height> <width> <list height> <tag1> <item1> <status1>..." },
+    { "clear",		o_clear,		1, "" },
+    { "colors",		o_colors,		1, "" },
+    { "column-separator",o_column_separator,	1, "<str>" },
+    { "cr-wrap",	o_cr_wrap,		1, "" },
+    { "create-rc",	o_create_rc,		1, NULL },
+    { "date-format",	o_date_format,		1, "<str>" },
+    { "default-item",	o_default_item,		1, "<str>" },
+    { "defaultno",	o_defaultno,		1, "" },
+    { "dselect",	o_dselect,		2, "<directory> <height> <width>" },
+    { "editbox",	o_editbox,		2, "<file> <height> <width>" },
+    { "exit-label",	o_exit_label,		1, "<str>" },
+    { "extra-button",	o_extra_button,		1, "" },
+    { "extra-label",	o_extra_label,		1, "<str>" },
+    { "fb",		o_fullbutton,		1, NULL },
+    { "fixed-font",	o_fixed_font,		1, NULL },
+    { "form",		o_form,			2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1>..." },
+    { "fselect",	o_fselect,		2, "<filepath> <height> <width>" },
+    { "fullbutton",	o_fullbutton,		1, NULL },
+    { "gauge",		o_gauge,		2, "<text> <height> <width> [<percent>]" },
+    { "guage",		o_gauge,		2, NULL },
+    { "help",		o_help,			4, "" },
+    { "help-button",	o_help_button,		1, "" },
+    { "help-label",	o_help_label,		1, "<str>" },
+    { "help-status",	o_help_status,		1, "" },
+    { "icon",		o_icon,			1, NULL },
+    { "ignore",		o_ignore,		1, "" },
+    { "infobox",	o_infobox,		2, "<text> <height> <width>" },
+    { "input-fd",	o_input_fd,		1, "<fd>" },
+    { "inputbox",	o_inputbox,		2, "<text> <height> <width> [<init>]" },
+    { "inputmenu",	o_inputmenu,		2, "<text> <height> <width> <menu height> <tag1> <item1>..." },
+    { "insecure",	o_insecure,		1, "" },
+    { "item-help",	o_item_help,		1, "" },
+    { "keep-colors",	o_keep_colors,		1, NULL },
+    { "keep-tite",	o_keep_tite,		1, "" },
+    { "keep-window",	o_keep_window,		1, "" },
+    { "max-input",	o_max_input,		1, "<n>" },
+    { "menu",		o_menu,			2, "<text> <height> <width> <menu height> <tag1> <item1>..." },
+    { "mixedform",	o_mixedform,		2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1> <itype>..." },
+    { "mixedgauge",	o_mixedgauge,		2, "<text> <height> <width> <percent> <tag1> <item1>..." },
+    { "msgbox",		o_msgbox,		2, "<text> <height> <width>" },
+    { "no-cancel",	o_nocancel,		1, "" },
+    { "no-close",	o_no_close,		1, NULL },
+    { "no-collapse",	o_no_collapse,		1, "" },
+    { "no-cr-wrap",	o_no_cr_wrap,		1, NULL },
+    { "no-kill",	o_no_kill,		1, "" },
+    { "no-label",	o_no_label,		1, "<str>" },
+    { "no-lines",	o_no_lines, 		1, "" },
+    { "no-ok",		o_nook,			1, "" },
+    { "no-shadow",	o_no_shadow,		1, "" },
+    { "nocancel",	o_nocancel,		1, NULL }, /* see --no-cancel */
+    { "noitem",		o_noitem,		1, NULL },
+    { "nook",		o_nook,			1, "" }, /* See no-ok */
+    { "ok-label",	o_ok_label,		1, "<str>" },
+    { "output-fd",	o_output_fd,		1, "<fd>" },
+    { "output-separator",o_output_separator,	1, "<str>" },
+    { "passwordbox",	o_passwordbox,		2, "<text> <height> <width> [<init>]" },
+    { "passwordform",	o_passwordform,		2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1>..." },
+    { "pause",		o_pause,		2, "<text> <height> <width> <seconds>" },
+    { "print-maxsize",	o_print_maxsize,	1, "" },
+    { "print-size",	o_print_size,		1, "" },
+    { "print-version",	o_print_version,	5, "" },
+    { "progressbox",	o_progressbox,		2, "<height> <width>" },
+    { "quoted",		o_quoted,		1, "" },
+    { "radiolist",	o_radiolist,		2, "<text> <height> <width> <list height> <tag1> <item1> <status1>..." },
+    { "screen-center",	o_screen_center,	1, NULL },
+    { "scrollbar",	o_scrollbar,		1, "" },
+    { "separate-output",o_separate_output,	1, "" },
+    { "separate-widget",o_separate_widget,	1, "<str>" },
+    { "separator",	o_separator,		1, NULL },
+    { "shadow",		o_shadow,		1, "" },
+    { "single-quoted",	o_single_quoted,	1, "" },
+    { "size-err",	o_size_err,		1, "" },
+    { "sleep",		o_sleep,		1, "<secs>" },
+    { "smooth",		o_smooth,		1, NULL },
+    { "stderr",		o_stderr,		1, "" },
+    { "stdout",		o_stdout,		1, "" },
+    { "tab-correct",	o_tab_correct,		1, "" },
+    { "tab-len",	o_tab_len,		1, "<n>" },
+    { "tailbox",	o_tailbox,		2, "<file> <height> <width>" },
+    { "tailboxbg",	o_tailboxbg,		2, "<file> <height> <width>" },
+    { "textbox",	o_textbox,		2, "<file> <height> <width>" },
+    { "time-format",	o_time_format,		1, "<str>" },
+    { "timebox",	o_timebox,		2, "<text> <height> <width> <hour> <minute> <second>" },
+    { "timeout",	o_timeout,		1, "<secs>" },
+    { "title",		o_title,		1, "<title>" },
+    { "trim",		o_trim,			1, "" },
+    { "under-mouse", 	o_under_mouse,		1, NULL },
+    { "version",	o_print_version,	5, "" },
+    { "visit-items", 	o_visit_items,		1, "" },
+    { "wmclass",	o_wmclass,		1, NULL },
+    { "yes-label",	o_yes_label,		1, "<str>" },
+    { "yesno",		o_yesno,		2, "<text> <height> <width>" },
+#ifdef HAVE_DLG_TRACE
+    { "trace",		o_trace,		1, "<file>" },
+#endif
+};
+/* *INDENT-ON* */
+
+/*
+ * Convert a string to an argv[], returning a char** index (which must be
+ * freed by the caller).  The string is modified (replacing gaps between
+ * tokens with nulls).
+ */
+static char **
+string_to_argv(char *blob)
+{
+    size_t n;
+    int pass;
+    size_t length = strlen(blob);
+    char **result = 0;
+
+    for (pass = 0; pass < 2; ++pass) {
+	bool inparm = FALSE;
+	bool quoted = FALSE;
+	char *param = blob;
+	size_t count = 0;
+
+	for (n = 0; n < length; ++n) {
+	    if (quoted && blob[n] == '"') {
+		quoted = FALSE;
+	    } else if (blob[n] == '"') {
+		quoted = TRUE;
+		if (!inparm) {
+		    if (pass)
+			result[count] = param;
+		    ++count;
+		    inparm = TRUE;
+		}
+	    } else if (blob[n] == '\\') {
+		if (quoted && !isspace(UCH(blob[n + 1]))) {
+		    if (!inparm) {
+			if (pass)
+			    result[count] = param;
+			++count;
+			inparm = TRUE;
+		    }
+		    if (pass) {
+			*param++ = blob[n];
+			*param++ = blob[n + 1];
+		    }
+		}
+		++n;
+	    } else if (!quoted && isspace(UCH(blob[n]))) {
+		inparm = FALSE;
+		if (pass) {
+		    *param++ = '\0';
+		}
+	    } else {
+		if (!inparm) {
+		    if (pass)
+			result[count] = param;
+		    ++count;
+		    inparm = TRUE;
+		}
+		if (pass) {
+		    *param++ = blob[n];
+		}
+	    }
+	}
+
+	if (!pass) {
+	    if (count) {
+		result = dlg_calloc(char *, count + 1);
+		assert_ptr(result, "string_to_argv");
+	    } else {
+		break;		/* no tokens found */
+	    }
+	} else {
+	    *param = '\0';
+	}
+    }
+    return result;
+}
+
+/*
+ * Count the entries in an argv list.
+ */
+static int
+count_argv(char **argv)
+{
+    int result = 0;
+
+    if (argv != 0) {
+	while (argv[result] != 0)
+	    ++result;
+    }
+    return result;
+}
+
+static int
+eat_argv(int *argcp, char ***argvp, int start, int count)
+{
+    int k;
+
+    *argcp -= count;
+    for (k = start; k <= *argcp; k++)
+	(*argvp)[k] = (*argvp)[k + count];
+    (*argvp)[*argcp] = 0;
+    return TRUE;
+}
+
+/*
+ * Make an array showing which argv[] entries are options.  Use "--" as a
+ * special token to escape the next argument, allowing it to begin with "--".
+ * When we find a "--" argument, also remove it from argv[] and adjust argc.
+ * That appears to be an undocumented feature of the popt library.
+ *
+ * Also, if we see a "--file", expand it into the parameter list by reading the
+ * text from the given file and stripping quotes, treating whitespace outside
+ * quotes as a parameter delimiter.
+ *
+ * Finally, if we see a "--args", dump the current list of arguments to the
+ * standard error.  This is used for debugging complex --file combinations.
+ */
+static void
+unescape_argv(int *argcp, char ***argvp)
+{
+    int j, k;
+    int limit_includes = 20 + *argcp;
+    int count_includes = 0;
+    bool changed = FALSE;
+    bool doalloc = FALSE;
+    char *filename;
+
+    dialog_opts = dlg_calloc(bool, (size_t) *argcp + 1);
+    assert_ptr(dialog_opts, "unescape_argv");
+
+    for (j = 1; j < *argcp; j++) {
+	bool escaped = FALSE;
+	if (!strcmp((*argvp)[j], "--")) {
+	    escaped = TRUE;
+	    changed = eat_argv(argcp, argvp, j, 1);
+	} else if (!strcmp((*argvp)[j], "--args")) {
+	    fprintf(stderr, "Showing arguments at arg%d\n", j);
+	    for (k = 0; k < *argcp; ++k) {
+		fprintf(stderr, " arg%d:%s\n", k, (*argvp)[k]);
+	    }
+	    changed = eat_argv(argcp, argvp, j, 1);
+	} else if (!strcmp((*argvp)[j], "--file")) {
+	    if (++count_includes > limit_includes)
+		dlg_exiterr("Too many --file options");
+
+	    if ((filename = (*argvp)[j + 1]) != 0) {
+		FILE *fp;
+		char **list;
+		char *blob;
+		int added;
+		size_t bytes_read;
+		size_t length;
+		int n;
+
+		if (*filename == '&') {
+		    fp = fdopen(atoi(filename + sizeof(char)), "r");
+		} else {
+		    fp = fopen(filename, "r");
+		}
+
+		if (fp) {
+		    blob = NULL;
+		    length = 0;
+		    do {
+			blob = dlg_realloc(char, length + BUFSIZ + 1, blob);
+			assert_ptr(blob, "unescape_argv");
+			bytes_read = fread(blob + length,
+					   sizeof(char),
+					   BUFSIZ,
+					   fp);
+			length += bytes_read;
+			if (ferror(fp))
+			    dlg_exiterr("error on filehandle in unescape_argv");
+		    } while (bytes_read == BUFSIZ);
+		    fclose(fp);
+
+		    blob[length] = '\0';
+
+		    list = string_to_argv(blob);
+		    if ((added = count_argv(list)) != 0) {
+			if (added > 2) {
+			    size_t need = (size_t) (*argcp + added + 1);
+			    if (doalloc) {
+				*argvp = dlg_realloc(char *, need, *argvp);
+				assert_ptr(*argvp, "unescape_argv");
+			    } else {
+				char **newp = dlg_malloc(char *, need);
+				assert_ptr(newp, "unescape_argv");
+				for (n = 0; n < *argcp; ++n) {
+				    newp[n] = (*argvp)[n];
+				}
+				*argvp = newp;
+				doalloc = TRUE;
+			    }
+			    dialog_opts = dlg_realloc(bool, need, dialog_opts);
+			    assert_ptr(dialog_opts, "unescape_argv");
+			}
+			for (n = *argcp; n >= j + 2; --n) {
+			    (*argvp)[n + added - 2] = (*argvp)[n];
+			    dialog_opts[n + added - 2] = dialog_opts[n];
+			}
+			for (n = 0; n < added; ++n) {
+			    (*argvp)[n + j] = list[n];
+			    dialog_opts[n + j] = FALSE;
+			}
+			*argcp += added - 2;
+			free(list);
+		    }
+		} else {
+		    dlg_exiterr("Cannot open --file %s", filename);
+		}
+		(*argvp)[*argcp] = 0;
+		++j;
+		continue;
+	    } else {
+		dlg_exiterr("No value given for --file");
+	    }
+	}
+	if (!escaped
+	    && (*argvp)[j] != 0
+	    && !strncmp((*argvp)[j], "--", 2)
+	    && isalpha(UCH((*argvp)[j][2]))) {
+	    dialog_opts[j] = TRUE;
+	}
+    }
+
+    /* if we didn't find any "--" tokens, there's no reason to do the table
+     * lookup in isOption()
+     */
+    if (!changed) {
+	free(dialog_opts);
+	dialog_opts = 0;
+    }
+    dialog_argv = (*argvp);
+}
+
+/*
+ * Check if the given string from main's argv is an option.
+ */
+static bool
+isOption(const char *arg)
+{
+    bool result = FALSE;
+
+    if (arg != 0) {
+	if (dialog_opts != 0) {
+	    int n;
+	    for (n = 1; dialog_argv[n] != 0; ++n) {
+		if (dialog_argv[n] == arg) {
+		    result = dialog_opts[n];
+		    break;
+		}
+	    }
+	} else if (!strncmp(arg, "--", 2) && isalpha(UCH(arg[2]))) {
+	    result = TRUE;
+	}
+    }
+    return result;
+}
+
+static eOptions
+lookupOption(const char *name, int pass)
+{
+    unsigned n;
+
+    if (isOption(name)) {
+	name += 2;
+	for (n = 0; n < sizeof(options) / sizeof(options[0]); n++) {
+	    if ((pass & options[n].pass) != 0
+		&& !strcmp(name, options[n].name)) {
+		return options[n].code;
+	    }
+	}
+    }
+    return o_unknown;
+}
+
+static void
+Usage(const char *msg)
+{
+    dlg_exiterr("Error: %s.\nUse --help to list options.\n\n", msg);
+}
+
+/*
+ * Count arguments, stopping at the end of the argument list, or on any of our
+ * "--" tokens.
+ */
+static int
+arg_rest(char *argv[])
+{
+    int i = 1;			/* argv[0] points to a "--" token */
+
+    while (argv[i] != 0
+	   && (!isOption(argv[i]) || lookupOption(argv[i], 7) == o_unknown))
+	i++;
+    return i;
+}
+
+/*
+ * In MultiWidget this function is needed to count how many tags
+ * a widget (menu, checklist, radiolist) has
+ */
+static int
+howmany_tags(char *argv[], int group)
+{
+    int result = 0;
+    int have;
+    const char *format = "Expected %d arguments, found only %d";
+    char temp[80];
+
+    while (argv[0] != 0) {
+	if (isOption(argv[0]))
+	    break;
+	if ((have = arg_rest(argv)) < group) {
+	    sprintf(temp, format, group, have);
+	    Usage(temp);
+	}
+
+	argv += group;
+	result++;
+    }
+
+    return result;
+}
+
+static int
+numeric_arg(char **av, int n)
+{
+    char *last = 0;
+    int result = strtol(av[n], &last, 10);
+    char msg[80];
+
+    if (last == 0 || *last != 0) {
+	sprintf(msg, "Expected a number for token %d of %.20s", n, av[0]);
+	Usage(msg);
+    }
+    return result;
+}
+
+static char *
+optional_str(char **av, int n, char *dft)
+{
+    char *ret = dft;
+    if (arg_rest(av) > n)
+	ret = av[n];
+    return ret;
+}
+
+#if defined(HAVE_DLG_GAUGE) || defined(HAVE_XDIALOG)
+static int
+optional_num(char **av, int n, int dft)
+{
+    int ret = dft;
+    if (arg_rest(av) > n)
+	ret = numeric_arg(av, n);
+    return ret;
+}
+#endif
+
+/*
+ * On AIX 4.x, we have to flush the output right away since there is a bug in
+ * the curses package which discards stdout even when we've used newterm to
+ * redirect output to /dev/tty.
+ */
+static int
+show_result(int ret)
+{
+    bool either = FALSE;
+
+    switch (ret) {
+    case DLG_EXIT_OK:
+    case DLG_EXIT_EXTRA:
+    case DLG_EXIT_HELP:
+    case DLG_EXIT_ITEM_HELP:
+	if ((dialog_state.output_count > 1) && !dialog_vars.separate_output) {
+	    fputs((dialog_state.separate_str
+		   ? dialog_state.separate_str
+		   : DEFAULT_SEPARATE_STR),
+		  dialog_state.output);
+	    either = TRUE;
+	}
+	if (dialog_vars.input_result[0] != '\0') {
+	    fputs(dialog_vars.input_result, dialog_state.output);
+	    either = TRUE;
+	}
+	if (either) {
+	    fflush(dialog_state.output);
+	}
+	break;
+    }
+    return ret;
+}
+
+/*
+ * These are the widget callers.
+ */
+
+static int
+call_yesno(CALLARGS)
+{
+    *offset_add = 4;
+    return dialog_yesno(t,
+			av[1],
+			numeric_arg(av, 2),
+			numeric_arg(av, 3));
+}
+
+static int
+call_msgbox(CALLARGS)
+{
+    *offset_add = 4;
+    return dialog_msgbox(t,
+			 av[1],
+			 numeric_arg(av, 2),
+			 numeric_arg(av, 3), 1);
+}
+
+static int
+call_infobox(CALLARGS)
+{
+    *offset_add = 4;
+    return dialog_msgbox(t,
+			 av[1],
+			 numeric_arg(av, 2),
+			 numeric_arg(av, 3), 0);
+}
+
+static int
+call_textbox(CALLARGS)
+{
+    *offset_add = 4;
+    return dialog_textbox(t,
+			  av[1],
+			  numeric_arg(av, 2),
+			  numeric_arg(av, 3));
+}
+
+static int
+call_menu(CALLARGS)
+{
+    int tags = howmany_tags(av + 5, MENUBOX_TAGS);
+    *offset_add = 5 + tags * MENUBOX_TAGS;
+
+    return dialog_menu(t,
+		       av[1],
+		       numeric_arg(av, 2),
+		       numeric_arg(av, 3),
+		       numeric_arg(av, 4),
+		       tags, av + 5);
+}
+
+static int
+call_inputmenu(CALLARGS)
+{
+    int tags = howmany_tags(av + 5, MENUBOX_TAGS);
+
+    dialog_vars.input_menu = TRUE;
+
+    if (dialog_vars.max_input == 0)
+	dialog_vars.max_input = MAX_LEN / 2;
+
+    if (dialog_vars.extra_label == 0)
+	dialog_vars.extra_label = _("Rename");
+
+    dialog_vars.extra_button = TRUE;
+
+    *offset_add = 5 + tags * MENUBOX_TAGS;
+    return dialog_menu(t,
+		       av[1],
+		       numeric_arg(av, 2),
+		       numeric_arg(av, 3),
+		       numeric_arg(av, 4),
+		       tags, av + 5);
+}
+
+static int
+call_checklist(CALLARGS)
+{
+    int tags = howmany_tags(av + 5, CHECKBOX_TAGS);
+    int code;
+    bool save_quoted = dialog_vars.quoted;
+
+    dialog_vars.quoted = !dialog_vars.separate_output;
+    *offset_add = 5 + tags * CHECKBOX_TAGS;
+    code = dialog_checklist(t,
+			    av[1],
+			    numeric_arg(av, 2),
+			    numeric_arg(av, 3),
+			    numeric_arg(av, 4),
+			    tags, av + 5, FLAG_CHECK);
+    dialog_vars.quoted = save_quoted;
+    return code;
+}
+
+static int
+call_radiolist(CALLARGS)
+{
+    int tags = howmany_tags(av + 5, CHECKBOX_TAGS);
+    *offset_add = 5 + tags * CHECKBOX_TAGS;
+    return dialog_checklist(t,
+			    av[1],
+			    numeric_arg(av, 2),
+			    numeric_arg(av, 3),
+			    numeric_arg(av, 4),
+			    tags, av + 5, FLAG_RADIO);
+}
+
+static int
+call_inputbox(CALLARGS)
+{
+    *offset_add = arg_rest(av);
+    return dialog_inputbox(t,
+			   av[1],
+			   numeric_arg(av, 2),
+			   numeric_arg(av, 3),
+			   optional_str(av, 4, 0), 0);
+}
+
+static int
+call_passwordbox(CALLARGS)
+{
+    *offset_add = arg_rest(av);
+    return dialog_inputbox(t,
+			   av[1],
+			   numeric_arg(av, 2),
+			   numeric_arg(av, 3),
+			   optional_str(av, 4, 0), 1);
+}
+
+#ifdef HAVE_XDIALOG
+static int
+call_calendar(CALLARGS)
+{
+    *offset_add = arg_rest(av);
+    return dialog_calendar(t,
+			   av[1],
+			   numeric_arg(av, 2),
+			   numeric_arg(av, 3),
+			   optional_num(av, 4, -1),
+			   optional_num(av, 5, -1),
+			   optional_num(av, 6, -1));
+}
+
+static int
+call_dselect(CALLARGS)
+{
+    *offset_add = arg_rest(av);
+    return dialog_dselect(t,
+			  av[1],
+			  numeric_arg(av, 2),
+			  numeric_arg(av, 3));
+}
+
+static int
+call_editbox(CALLARGS)
+{
+    *offset_add = 4;
+    return dialog_editbox(t,
+			  av[1],
+			  numeric_arg(av, 2),
+			  numeric_arg(av, 3));
+}
+
+static int
+call_fselect(CALLARGS)
+{
+    *offset_add = arg_rest(av);
+    return dialog_fselect(t,
+			  av[1],
+			  numeric_arg(av, 2),
+			  numeric_arg(av, 3));
+}
+
+static int
+call_timebox(CALLARGS)
+{
+    *offset_add = arg_rest(av);
+    return dialog_timebox(t,
+			  av[1],
+			  numeric_arg(av, 2),
+			  numeric_arg(av, 3),
+			  optional_num(av, 4, -1),
+			  optional_num(av, 5, -1),
+			  optional_num(av, 6, -1));
+}
+#endif /* HAVE_XDIALOG */
+
+#ifdef HAVE_DLG_FORMBOX
+static int
+call_form(CALLARGS)
+{
+    int group = FORMBOX_TAGS;
+    int tags = howmany_tags(av + 5, group);
+    *offset_add = 5 + tags * group;
+
+    return dialog_form(t,
+		       av[1],
+		       numeric_arg(av, 2),
+		       numeric_arg(av, 3),
+		       numeric_arg(av, 4),
+		       tags, av + 5);
+}
+
+static int
+call_password_form(CALLARGS)
+{
+    unsigned save = dialog_vars.formitem_type;
+    int result;
+
+    dialog_vars.formitem_type = 1;
+    result = call_form(PASSARGS);
+    dialog_vars.formitem_type = save;
+
+    return result;
+}
+#endif /* HAVE_DLG_FORMBOX */
+
+#ifdef HAVE_DLG_MIXEDFORM
+static int
+call_mixed_form(CALLARGS)
+{
+    int group = MIXEDFORM_TAGS;
+    int tags = howmany_tags(av + 5, group);
+    *offset_add = 5 + tags * group;
+
+    return dialog_mixedform(t,
+			    av[1],
+			    numeric_arg(av, 2),
+			    numeric_arg(av, 3),
+			    numeric_arg(av, 4),
+			    tags, av + 5);
+}
+#endif /* HAVE_DLG_MIXEDFORM */
+
+#ifdef HAVE_DLG_GAUGE
+static int
+call_gauge(CALLARGS)
+{
+    *offset_add = arg_rest(av);
+    return dialog_gauge(t,
+			av[1],
+			numeric_arg(av, 2),
+			numeric_arg(av, 3),
+			optional_num(av, 4, 0));
+}
+
+static int
+call_pause(CALLARGS)
+{
+    *offset_add = arg_rest(av);
+    return dialog_pause(t,
+			av[1],
+			numeric_arg(av, 2),
+			numeric_arg(av, 3),
+			numeric_arg(av, 4));
+}
+#endif
+
+#ifdef HAVE_MIXEDGAUGE
+static int
+call_mixed_gauge(CALLARGS)
+{
+#define MIXEDGAUGE_BASE 5
+    int tags = howmany_tags(av + MIXEDGAUGE_BASE, MIXEDGAUGE_TAGS);
+    *offset_add = MIXEDGAUGE_BASE + tags * MIXEDGAUGE_TAGS;
+    return dialog_mixedgauge(t,
+			     av[1],
+			     numeric_arg(av, 2),
+			     numeric_arg(av, 3),
+			     numeric_arg(av, 4),
+			     tags, av + MIXEDGAUGE_BASE);
+}
+#endif
+
+#ifdef HAVE_DLG_GAUGE
+static int
+call_progressbox(CALLARGS)
+{
+    *offset_add = arg_rest(av);
+    /* the original version does not accept a prompt string, but for
+     * consistency we allow it.
+     */
+    return ((*offset_add == 4)
+	    ? dialog_progressbox(t,
+				 av[1],
+				 numeric_arg(av, 2),
+				 numeric_arg(av, 3))
+	    : dialog_progressbox(t,
+				 "",
+				 numeric_arg(av, 1),
+				 numeric_arg(av, 2)));
+}
+#endif
+
+#ifdef HAVE_DLG_TAILBOX
+static int
+call_tailbox(CALLARGS)
+{
+    *offset_add = 4;
+    return dialog_tailbox(t,
+			  av[1],
+			  numeric_arg(av, 2),
+			  numeric_arg(av, 3),
+			  FALSE);
+}
+
+static int
+call_tailboxbg(CALLARGS)
+{
+    *offset_add = 4;
+    return dialog_tailbox(t,
+			  av[1],
+			  numeric_arg(av, 2),
+			  numeric_arg(av, 3),
+			  TRUE);
+}
+#endif
+/* *INDENT-OFF* */
+static const Mode modes[] =
+{
+    {o_yesno,           4, 4, call_yesno},
+    {o_msgbox,          4, 4, call_msgbox},
+    {o_infobox,         4, 4, call_infobox},
+    {o_textbox,         4, 4, call_textbox},
+    {o_menu,            7, 0, call_menu},
+    {o_inputmenu,       7, 0, call_inputmenu},
+    {o_checklist,       8, 0, call_checklist},
+    {o_radiolist,       8, 0, call_radiolist},
+    {o_inputbox,        4, 5, call_inputbox},
+    {o_passwordbox,     4, 5, call_passwordbox},
+#ifdef HAVE_DLG_GAUGE
+    {o_gauge,           4, 5, call_gauge},
+    {o_pause,           5, 5, call_pause},
+    {o_progressbox,     3, 4, call_progressbox},
+#endif
+#ifdef HAVE_DLG_FORMBOX
+    {o_passwordform,   13, 0, call_password_form},
+    {o_form,           13, 0, call_form},
+#endif
+#ifdef HAVE_MIXEDGAUGE
+    {o_mixedgauge,      MIXEDGAUGE_BASE, 0, call_mixed_gauge},
+#endif
+#ifdef HAVE_DLG_MIXEDFORM
+    {o_mixedform,      13, 0, call_mixed_form},
+#endif
+#ifdef HAVE_DLG_TAILBOX
+    {o_tailbox,         4, 4, call_tailbox},
+    {o_tailboxbg,       4, 4, call_tailboxbg},
+#endif
+#ifdef HAVE_XDIALOG
+    {o_calendar,        4, 7, call_calendar},
+    {o_dselect,         4, 5, call_dselect},
+    {o_editbox,         4, 4, call_editbox},
+    {o_fselect,         4, 5, call_fselect},
+    {o_timebox,         4, 7, call_timebox},
+#endif
+};
+/* *INDENT-ON* */
+
+static char *
+optionString(char **argv, int *num)
+{
+    int next = *num + 1;
+    char *result = argv[next];
+    if (result == 0) {
+	char temp[80];
+	sprintf(temp, "Expected a string-parameter for %.20s", argv[*num]);
+	Usage(temp);
+    }
+    *num = next;
+    return result;
+}
+
+static int
+optionValue(char **argv, int *num)
+{
+    int next = *num + 1;
+    char *src = argv[next];
+    char *tmp = 0;
+    int result = 0;
+
+    if (src != 0) {
+	result = strtol(src, &tmp, 0);
+	if (tmp == 0 || *tmp != 0)
+	    src = 0;
+    }
+
+    if (src == 0) {
+	char temp[80];
+	sprintf(temp, "Expected a numeric-parameter for %.20s", argv[*num]);
+	Usage(temp);
+    }
+    *num = next;
+    return result;
+}
+
+/*
+ * Print parts of a message
+ */
+static void
+PrintList(const char *const *list)
+{
+    const char *leaf = strrchr(program, '/');
+    unsigned n = 0;
+
+    if (leaf != 0)
+	leaf++;
+    else
+	leaf = program;
+
+    while (*list != 0) {
+	fprintf(dialog_state.output, *list, n ? leaf : dialog_version());
+	(void) fputc('\n', dialog_state.output);
+	n = 1;
+	list++;
+    }
+}
+
+static const Mode *
+lookupMode(eOptions code)
+{
+    const Mode *modePtr = 0;
+    unsigned n;
+
+    for (n = 0; n < sizeof(modes) / sizeof(modes[0]); n++) {
+	if (modes[n].code == code) {
+	    modePtr = &modes[n];
+	    break;
+	}
+    }
+    return modePtr;
+}
+
+static int
+compare_opts(const void *a, const void *b)
+{
+    Options *const *p = (Options * const *) a;
+    Options *const *q = (Options * const *) b;
+    return strcmp((*p)->name, (*q)->name);
+}
+
+/*
+ * Print program help-message
+ */
+static void
+Help(void)
+{
+    static const char *const tbl_1[] =
+    {
+	"cdialog (ComeOn Dialog!) version %s",
+	"Copyright 2000-2007,2008 Thomas E. Dickey",
+	"This is free software; see the source for copying conditions.  There is NO",
+	"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.",
+	"",
+	"* Display dialog boxes from shell scripts *",
+	"",
+	"Usage: %s <options> { --and-widget <options> }",
+	"where options are \"common\" options, followed by \"box\" options",
+	"",
+#ifdef HAVE_RC_FILE
+	"Special options:",
+	"  [--create-rc \"file\"]",
+#endif
+	0
+    }, *const tbl_3[] =
+    {
+	"",
+	"Auto-size with height and width = 0. Maximize with height and width = -1.",
+	"Global-auto-size if also menu_height/list_height = 0.",
+	0
+    };
+    unsigned limit = sizeof(options) / sizeof(options[0]);
+    unsigned j, k;
+    const Options **opts;
+
+    opts = dlg_calloc(const Options *, limit);
+    assert_ptr(opts, "Help");
+    for (j = 0; j < limit; ++j) {
+	opts[j] = &(options[j]);
+    }
+    qsort(opts, limit, sizeof(Options *), compare_opts);
+
+    PrintList(tbl_1);
+    fprintf(dialog_state.output, "Common options:\n ");
+    for (j = k = 0; j < limit; j++) {
+	if ((opts[j]->pass & 1)
+	    && opts[j]->help != 0) {
+	    unsigned len = 6 + strlen(opts[j]->name) + strlen(opts[j]->help);
+	    k += len;
+	    if (k > 75) {
+		fprintf(dialog_state.output, "\n ");
+		k = len;
+	    }
+	    fprintf(dialog_state.output, " [--%s%s%s]", opts[j]->name,
+		    *(opts[j]->help) ? " " : "", opts[j]->help);
+	}
+    }
+    fprintf(dialog_state.output, "\nBox options:\n");
+    for (j = 0; j < limit; j++) {
+	if ((opts[j]->pass & 2) != 0
+	    && opts[j]->help != 0
+	    && lookupMode(opts[j]->code))
+	    fprintf(dialog_state.output, "  --%-12s %s\n", opts[j]->name,
+		    opts[j]->help);
+    }
+    PrintList(tbl_3);
+
+    free(opts);
+    dlg_exit(DLG_EXIT_OK);
+}
+
+/*
+ * "Common" options apply to all widgets more/less.  Most of the common options
+ * set values in dialog_vars, a few set dialog_state and a couple write to the
+ * output stream.
+ */
+static int
+process_common_options(int argc, char **argv, int offset, bool output)
+{
+    bool done = FALSE;
+
+    while (offset < argc && !done) {	/* Common options */
+	switch (lookupOption(argv[offset], 1)) {
+	case o_title:
+	    dialog_vars.title = optionString(argv, &offset);
+	    break;
+	case o_backtitle:
+	    dialog_vars.backtitle = optionString(argv, &offset);
+	    break;
+	case o_separate_widget:
+	    dialog_state.separate_str = optionString(argv, &offset);
+	    break;
+	case o_separate_output:
+	    dialog_vars.separate_output = TRUE;
+	    break;
+	case o_colors:
+	    dialog_vars.colors = TRUE;
+	    break;
+	case o_cr_wrap:
+	    dialog_vars.cr_wrap = TRUE;
+	    break;
+	case o_no_collapse:
+	    dialog_vars.nocollapse = TRUE;
+	    break;
+	case o_no_kill:
+	    dialog_vars.cant_kill = TRUE;
+	    break;
+	case o_nocancel:
+	    dialog_vars.nocancel = TRUE;
+	    break;
+	case o_nook:
+	    dialog_vars.nook = TRUE;
+	    break;
+	case o_quoted:
+	    dialog_vars.quoted = TRUE;
+	    break;
+	case o_single_quoted:
+	    dialog_vars.single_quoted = TRUE;
+	    break;
+	case o_size_err:
+	    dialog_vars.size_err = TRUE;
+	    break;
+	case o_beep:
+	    dialog_vars.beep_signal = TRUE;
+	    break;
+	case o_beep_after:
+	    dialog_vars.beep_after_signal = TRUE;
+	    break;
+	case o_scrollbar:
+	    dialog_state.use_scrollbar = TRUE;
+	    break;
+	case o_shadow:
+	    dialog_state.use_shadow = TRUE;
+	    break;
+	case o_defaultno:
+	    dialog_vars.defaultno = TRUE;
+	    break;
+	case o_default_item:
+	    dialog_vars.default_item = optionString(argv, &offset);
+	    break;
+	case o_insecure:
+	    dialog_vars.insecure = TRUE;
+	    break;
+	case o_item_help:
+	    dialog_vars.item_help = TRUE;
+	    break;
+	case o_help_button:
+	    dialog_vars.help_button = TRUE;
+	    break;
+	case o_help_status:
+	    dialog_vars.help_status = TRUE;
+	    break;
+	case o_extra_button:
+	    dialog_vars.extra_button = TRUE;
+	    break;
+	case o_ignore:
+	    ignore_unknown = TRUE;
+	    break;
+	case o_keep_window:
+	    dialog_vars.keep_window = TRUE;
+	    break;
+	case o_no_shadow:
+	    dialog_state.use_shadow = FALSE;
+	    break;
+	case o_print_size:
+	    dialog_vars.print_siz = TRUE;
+	    break;
+	case o_print_maxsize:
+	    if (output) {
+		/*
+		 * If this is the last option, we do not want any error
+		 * messages - just our output.  Calling end_dialog() cancels
+		 * the refresh() at the end of the program as well.
+		 */
+		if (argv[offset + 1] == 0) {
+		    ignore_unknown = TRUE;
+		    end_dialog();
+		}
+		fflush(dialog_state.output);
+		fprintf(dialog_state.output, "MaxSize: %d, %d\n", SLINES, SCOLS);
+	    }
+	    break;
+	case o_print_version:
+	    if (output) {
+		fprintf(stdout, "Version: %s\n", dialog_version());
+	    }
+	    break;
+	case o_separator:
+	case o_output_separator:
+	    dialog_vars.output_separator = optionString(argv, &offset);
+	    break;
+	case o_column_separator:
+	    dialog_vars.column_separator = optionString(argv, &offset);
+	    break;
+	case o_tab_correct:
+	    dialog_vars.tab_correct = TRUE;
+	    break;
+	case o_sleep:
+	    dialog_vars.sleep_secs = optionValue(argv, &offset);
+	    break;
+	case o_timeout:
+	    dialog_vars.timeout_secs = optionValue(argv, &offset);
+	    break;
+	case o_max_input:
+	    dialog_vars.max_input = optionValue(argv, &offset);
+	    break;
+	case o_tab_len:
+	    dialog_state.tab_len = optionValue(argv, &offset);
+	    break;
+	case o_trim:
+	    dialog_vars.trim_whitespace = TRUE;
+	    break;
+	case o_visit_items:
+	    dialog_state.visit_items = TRUE;
+	    break;
+	case o_aspect:
+	    dialog_state.aspect_ratio = optionValue(argv, &offset);
+	    break;
+	case o_begin:
+	    dialog_vars.begin_set = TRUE;
+	    dialog_vars.begin_y = optionValue(argv, &offset);
+	    dialog_vars.begin_x = optionValue(argv, &offset);
+	    break;
+	case o_clear:
+	    dialog_vars.dlg_clear_screen = TRUE;
+	    break;
+	case o_yes_label:
+	    dialog_vars.yes_label = optionString(argv, &offset);
+	    break;
+	case o_no_label:
+	    dialog_vars.no_label = optionString(argv, &offset);
+	    break;
+	case o_ok_label:
+	    dialog_vars.ok_label = optionString(argv, &offset);
+	    break;
+	case o_cancel_label:
+	    dialog_vars.cancel_label = optionString(argv, &offset);
+	    break;
+	case o_extra_label:
+	    dialog_vars.extra_label = optionString(argv, &offset);
+	    break;
+	case o_exit_label:
+	    dialog_vars.exit_label = optionString(argv, &offset);
+	    break;
+	case o_help_label:
+	    dialog_vars.help_label = optionString(argv, &offset);
+	    break;
+	case o_date_format:
+	    dialog_vars.date_format = optionString(argv, &offset);
+	    break;
+	case o_time_format:
+	    dialog_vars.time_format = optionString(argv, &offset);
+	    break;
+	case o_keep_tite:
+	    dialog_vars.keep_tite = TRUE;
+	    break;
+	case o_ascii_lines:
+	    dialog_vars.ascii_lines = TRUE;
+	    dialog_vars.no_lines = FALSE;
+	    break;
+	case o_no_lines:
+	    dialog_vars.no_lines = TRUE;
+	    dialog_vars.ascii_lines = FALSE;
+	    break;
+	case o_noitem:
+	case o_fullbutton:
+	    /* ignore */
+	    break;
+	    /* options of Xdialog which we ignore */
+	case o_icon:
+	case o_wmclass:
+	    (void) optionString(argv, &offset);
+	    /* FALLTHRU */
+	case o_allow_close:
+	case o_auto_placement:
+	case o_fixed_font:
+	case o_keep_colors:
+	case o_no_close:
+	case o_no_cr_wrap:
+	case o_screen_center:
+	case o_smooth:
+	case o_under_mouse:
+	    break;
+	case o_unknown:
+	    if (ignore_unknown)
+		break;
+	    /* FALLTHRU */
+	default:		/* no more common options */
+	    done = TRUE;
+	    break;
+#ifdef HAVE_DLG_TRACE
+	case o_trace:
+	    dlg_trace(optionString(argv, &offset));
+	    break;
+#endif
+	}
+	if (!done)
+	    offset++;
+    }
+    return offset;
+}
+
+/*
+ * Initialize options at the start of a series of common options culminating
+ * in a widget.
+ */
+static void
+init_result(char *buffer)
+{
+    static bool first = TRUE;
+    static char **special_argv = 0;
+    static int special_argc = 0;
+
+    /* clear everything we do not save for the next widget */
+    memset(&dialog_vars, 0, sizeof(dialog_vars));
+
+    dialog_vars.input_result = buffer;
+    dialog_vars.input_result[0] = '\0';
+
+    /*
+     * The first time this is called, check for common options given by an
+     * environment variable.
+     */
+    if (first) {
+	char *env = getenv("DIALOGOPTS");
+	if (env != 0)
+	    env = dlg_strclone(env);
+	if (env != 0) {
+	    special_argv = string_to_argv(env);
+	    special_argc = count_argv(special_argv);
+	}
+    }
+    if (special_argv != 0) {
+	process_common_options(special_argc, special_argv, 0, FALSE);
+#ifdef NO_LEAKS
+	free(special_argv[0]);
+	free(special_argv);
+	first = TRUE;
+#endif
+    }
+}
+
+int
+main(int argc, char *argv[])
+{
+    char temp[256];
+    bool esc_pressed = FALSE;
+    bool keep_tite = FALSE;
+    int offset = 1;
+    int offset_add;
+    int retval = DLG_EXIT_OK;
+    int j, have;
+    eOptions code;
+    const Mode *modePtr;
+    char my_buffer[MAX_LEN + 1];
+
+    memset(&dialog_state, 0, sizeof(dialog_state));
+    memset(&dialog_vars, 0, sizeof(dialog_vars));
+
+#if defined(ENABLE_NLS)
+    /* initialize locale support */
+    setlocale(LC_ALL, "");
+    bindtextdomain(PACKAGE, LOCALEDIR);
+    textdomain(PACKAGE);
+#elif defined(HAVE_SETLOCALE)
+    (void) setlocale(LC_ALL, "");
+#endif
+
+    unescape_argv(&argc, &argv);
+    program = argv[0];
+    dialog_state.output = stderr;
+    dialog_state.input = stdin;
+
+    /*
+     * Look for the last --stdout, --stderr or --output-fd option, and use
+     * that.  We can only write to one of them.  If --stdout is used, that
+     * can interfere with initializing the curses library, so we want to
+     * know explicitly if it is used.
+     */
+    while (offset < argc) {
+	int base = offset;
+	switch (lookupOption(argv[offset], 7)) {
+	case o_stdout:
+	    dialog_state.output = stdout;
+	    break;
+	case o_stderr:
+	    dialog_state.output = stderr;
+	    break;
+	case o_input_fd:
+	    if ((j = optionValue(argv, &offset)) < 0
+		|| (dialog_state.input = fdopen(j, "r")) == 0)
+		dlg_exiterr("Cannot open input-fd\n");
+	    break;
+	case o_output_fd:
+	    if ((j = optionValue(argv, &offset)) < 0
+		|| (dialog_state.output = fdopen(j, "w")) == 0)
+		dlg_exiterr("Cannot open output-fd\n");
+	    break;
+	case o_keep_tite:
+	    keep_tite = TRUE;
+	    break;
+	default:
+	    ++offset;
+	    continue;
+	}
+	for (j = base; j < argc; ++j) {
+	    dialog_argv[j] = dialog_argv[j + 1 + (offset - base)];
+	    if (dialog_opts != 0)
+		dialog_opts[j] = dialog_opts[j + 1 + (offset - base)];
+	}
+	argc -= (1 + offset - base);
+	offset = base;
+    }
+    offset = 1;
+    init_result(my_buffer);
+
+    if (argc == 2) {		/* if we don't want clear screen */
+	switch (lookupOption(argv[1], 7)) {
+	case o_print_maxsize:
+	    (void) initscr();
+	    endwin();
+	    fflush(dialog_state.output);
+	    fprintf(dialog_state.output, "MaxSize: %d, %d\n", SLINES, SCOLS);
+	    break;
+	case o_print_version:
+	    fprintf(stdout, "Version: %s\n", dialog_version());
+	    break;
+	case o_clear:
+	    initscr();
+	    refresh();
+	    endwin();
+	    break;
+	case o_ignore:
+	    break;
+	default:
+	case o_help:
+	    dialog_state.output = stdout;
+	    Help();
+	    break;
+	}
+	return DLG_EXIT_OK;
+    }
+
+    if (argc < 2) {
+	Help();
+    }
+#ifdef HAVE_RC_FILE
+    if (lookupOption(argv[1], 7) == o_create_rc) {
+	if (argc != 3) {
+	    sprintf(temp, "Expected a filename for %.50s", argv[1]);
+	    Usage(temp);
+	}
+	if (dlg_parse_rc() == -1)	/* Read the configuration file */
+	    dlg_exiterr("dialog: dlg_parse_rc");
+	dlg_create_rc(argv[2]);
+	return DLG_EXIT_OK;
+    }
+#endif
+
+    dialog_vars.keep_tite = keep_tite;	/* init_result() cleared global */
+
+    init_dialog(dialog_state.input, dialog_state.output);
+
+    while (offset < argc && !esc_pressed) {
+	init_result(my_buffer);
+
+	offset = process_common_options(argc, argv, offset, TRUE);
+
+	if (argv[offset] == NULL) {
+	    if (ignore_unknown)
+		break;
+	    Usage("Expected a box option");
+	}
+
+	if (lookupOption(argv[offset], 2) != o_checklist
+	    && dialog_vars.separate_output) {
+	    sprintf(temp, "Expected --checklist, not %.20s", argv[offset]);
+	    Usage(temp);
+	}
+
+	if (dialog_state.aspect_ratio == 0)
+	    dialog_state.aspect_ratio = DEFAULT_ASPECT_RATIO;
+
+	dlg_put_backtitle();
+
+	/* use a table to look for the requested mode, to avoid code duplication */
+
+	modePtr = 0;
+	if ((code = lookupOption(argv[offset], 2)) != o_unknown)
+	    modePtr = lookupMode(code);
+	if (modePtr == 0) {
+	    sprintf(temp, "%s option %.20s",
+		    lookupOption(argv[offset], 7) != o_unknown
+		    ? "Unexpected"
+		    : "Unknown",
+		    argv[offset]);
+	    Usage(temp);
+	}
+
+	have = arg_rest(&argv[offset]);
+	if (have < modePtr->argmin) {
+	    sprintf(temp, "Expected at least %d tokens for %.20s, have %d",
+		    modePtr->argmin - 1, argv[offset],
+		    have - 1);
+	    Usage(temp);
+	}
+	if (modePtr->argmax && have > modePtr->argmax) {
+	    sprintf(temp,
+		    "Expected no more than %d tokens for %.20s, have %d",
+		    modePtr->argmax - 1, argv[offset],
+		    have - 1);
+	    Usage(temp);
+	}
+
+	/*
+	 * Trim whitespace from non-title option values, e.g., the ones that
+	 * will be used as captions or prompts.   Do that only for the widget
+	 * we are about to process, since the "--trim" option is reset before
+	 * accumulating options for each widget.
+	 */
+	for (j = offset + 1; j <= offset + have; j++) {
+	    switch (lookupOption(argv[j - 1], 7)) {
+	    case o_unknown:
+	    case o_title:
+	    case o_backtitle:
+		break;
+	    default:
+		if (argv[j] != 0) {
+		    dlg_trim_string(argv[j]);
+		}
+		break;
+	    }
+	}
+
+	retval = show_result((*(modePtr->jumper)) (dialog_vars.title,
+						   argv + offset,
+						   &offset_add));
+	offset += offset_add;
+
+	if (dialog_vars.input_result != my_buffer)
+	    free(dialog_vars.input_result);
+
+	if (retval == DLG_EXIT_ESC) {
+	    esc_pressed = TRUE;
+	} else {
+
+	    if (dialog_vars.beep_after_signal)
+		(void) beep();
+
+	    if (dialog_vars.sleep_secs)
+		(void) napms(dialog_vars.sleep_secs * 1000);
+
+	    if (offset < argc) {
+		switch (lookupOption(argv[offset], 7)) {
+		case o_and_widget:
+		    offset++;
+		    break;
+		case o_unknown:
+		    sprintf(temp, "Expected --and-widget, not %.20s",
+			    argv[offset]);
+		    Usage(temp);
+		    break;
+		default:
+		    /* if we got a cancel, etc., stop chaining */
+		    if (retval != DLG_EXIT_OK)
+			esc_pressed = TRUE;
+		    else
+			dialog_vars.dlg_clear_screen = TRUE;
+		    break;
+		}
+	    }
+	    if (dialog_vars.dlg_clear_screen)
+		dlg_clear();
+	}
+    }
+
+    dlg_killall_bg(&retval);
+    if (dialog_state.screen_initialized) {
+	(void) refresh();
+	end_dialog();
+    }
+    dlg_exit(retval);
+}