contrib/dialog/dialog.c

   1 /*
   2  * $Id: dialog.c,v 1.281 2021/01/17 16:52:18 tom Exp $
   3  *
   4  *  cdialog - Display simple dialog boxes from shell scripts
   5  *
   6  *  Copyright 2000-2020,2021    Thomas E. Dickey
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU Lesser General Public License, version 2.1
  10  *  as published by the Free Software Foundation.
  11  *
  12  *  This program is distributed in the hope that it will be useful, but
  13  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Lesser General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Lesser General Public
  18  *  License along with this program; if not, write to
  19  *      Free Software Foundation, Inc.
  20  *      51 Franklin St., Fifth Floor
  21  *      Boston, MA 02110, USA.
  22  *
  23  *  An earlier version of this program lists as authors
  24  *      Savio Lam (lam836@cs.cuhk.hk)
  25  */
  26
  27 #include <dialog.h>
  28
  29 #include <stddef.h>
  30 #include <string.h>
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33
  34 #ifdef HAVE_SETLOCALE
  35 #include <locale.h>
  36 #endif
  37
  38 #include <dlg_internals.h>
  39
  40 #define PASSARGS             t,       av,        offset_add
  41 #define CALLARGS const char *t, char *av[], int *offset_add
  42 typedef int (callerFn) (CALLARGS);
  43
  44 typedef enum {
  45     o_unknown = 0
  46     ,o_allow_close
  47     ,o_and_widget
  48     ,o_ascii_lines
  49     ,o_aspect_ratio
  50     ,o_auto_placement
  51     ,o_backtitle
  52     ,o_beep_signal
  53     ,o_beep_after_signal
  54     ,o_begin_set
  55     ,o_cancel_label
  56     ,o_checklist
  57     ,o_dlg_clear_screen
  58     ,o_colors
  59     ,o_column_separator
  60     ,o_cr_wrap
  61     ,o_create_rc
  62     ,o_cursor_off_label
  63     ,o_date_format
  64     ,o_default_button
  65     ,o_default_item
  66     ,o_defaultno
  67     ,o_erase_on_exit
  68     ,o_exit_label
  69     ,o_extra_button
  70     ,o_extra_label
  71     ,o_fixed_font
  72     ,o_form
  73     ,o_gauge
  74     ,o_help
  75     ,o_help_button
  76     ,o_help_file
  77     ,o_help_label
  78     ,o_help_line
  79     ,o_help_status
  80     ,o_help_tags
  81     ,o_icon
  82     ,o_ignore
  83     ,o_infobox
  84     ,o_input_fd
  85     ,o_inputbox
  86     ,o_inputmenu
  87     ,o_insecure
  88     ,o_item_help
  89     ,o_keep_colors
  90     ,o_keep_tite
  91     ,o_keep_window
  92     ,o_last_key
  93     ,o_max_input
  94     ,o_menu
  95     ,o_mixedform
  96     ,o_mixedgauge
  97     ,o_msgbox
  98     ,o_no_close
  99     ,o_nocollapse
 100     ,o_no_cr_wrap
 101     ,o_cant_kill
 102     ,o_no_hot_list
 103     ,o_no_label
 104     ,o_no_lines
 105     ,o_no_mouse
 106     ,o_no_nl_expand
 107     ,o_use_shadow
 108     ,o_nocancel
 109     ,o_nook
 110     ,o_ok_label
 111     ,o_output_fd
 112     ,o_output_separator
 113     ,o_passwordbox
 114     ,o_passwordform
 115     ,o_pause
 116     ,o_prgbox
 117     ,o_print_maxsize
 118     ,o_print_siz
 119     ,o_text_only
 120     ,o_print_text_size
 121     ,o_print_version
 122     ,o_programbox
 123     ,o_progressbox
 124     ,o_quoted
 125     ,o_radiolist
 126     ,o_screen_center
 127     ,o_use_scrollbar
 128     ,o_separate_output
 129     ,o_separate_str
 130     ,o_single_quoted
 131     ,o_size_err
 132     ,o_sleep_secs
 133     ,o_smooth
 134     ,o_output_stderr
 135     ,o_output_stdout
 136     ,o_tab_correct
 137     ,o_tab_len
 138     ,o_tailbox
 139     ,o_tailboxbg
 140     ,o_textbox
 141     ,o_time_format
 142     ,o_timeout_secs
 143     ,o_title
 144     ,o_trim_whitespace
 145     ,o_under_mouse
 146     ,o_version
 147     ,o_visit_items
 148     ,o_wmclass
 149     ,o_yes_label
 150     ,o_yesno
 151 #ifdef HAVE_WHIPTAIL
 152     ,o_fullbutton
 153     ,o_topleft
 154 #endif
 155 #ifdef HAVE_XDIALOG
 156     ,o_calendar
 157     ,o_dselect
 158     ,o_editbox
 159     ,o_fselect
 160     ,o_timebox
 161     ,o_week_start
 162 #endif
 163 #ifdef HAVE_XDIALOG2
 164     ,o_buildlist
 165     ,o_rangebox
 166     ,o_reorder
 167     ,o_treeview
 168 #endif
 169 #if defined(HAVE_XDIALOG2) || defined(HAVE_WHIPTAIL)
 170     ,o_no_items
 171     ,o_no_tags
 172 #endif
 173 #ifdef HAVE_DLG_TRACE
 174     ,o_trace
 175 #endif
 176     ,o_iso_week
 177 } eOptions;
 178
 179 typedef enum {
 180     tUnknown
 181     ,tFalse
 182     ,tTrue
 183     ,tNumber
 184     ,tString
 185 } tOptions;
 186
 187 /*
 188  * The bits in 'pass' are used to decide which options are applicable at
 189  * different stages in the program:
 190  *      1 flags before widgets
 191  *      2 widgets
 192  *      4 non-widget options
 193  */
 194 typedef struct {
 195     const char *name;
 196     eOptions code;
 197     int vars;                   /* 0=none, 1=state, 2=vars */
 198     tOptions type;              /* type for bool(true/false), number, string */
 199     unsigned offset;
 200     int pass;                   /* 1,2,4 or combination */
 201     const char *help;           /* NULL to suppress, non-empty to display params */
 202 } Options;
 203
 204 typedef struct {
 205     eOptions code;
 206     int argmin, argmax;
 207     callerFn *jumper;
 208 } Mode;
 209
 210 /* use these macros for simple options in DIALOG_STATE */
 211 #define ssF(name) o_##name, 1, tFalse,  offsetof(DIALOG_STATE,name)
 212 #define ssT(name) o_##name, 1, tTrue,   offsetof(DIALOG_STATE,name)
 213 #define ssN(name) o_##name, 1, tNumber, offsetof(DIALOG_STATE,name)
 214 #define ssS(name) o_##name, 1, tString, offsetof(DIALOG_STATE,name)
 215
 216 /* use these macros for simple options in DIALOG_VARS */
 217 #define svF(name) o_##name, 2, tFalse,  offsetof(DIALOG_VARS,name)
 218 #define svT(name) o_##name, 2, tTrue,   offsetof(DIALOG_VARS,name)
 219 #define svN(name) o_##name, 2, tNumber, offsetof(DIALOG_VARS,name)
 220 #define svS(name) o_##name, 2, tString, offsetof(DIALOG_VARS,name)
 221
 222 /* use these macros for ignored options */
 223 #define xxF(name) o_##name, 0, tFalse,  0
 224 #define xxT(name) o_##name, 0, tTrue,   0
 225 #define xxN(name) o_##name, 0, tNumber, 0
 226 #define xxS(name) o_##name, 0, tString, 0
 227
 228 /* use this macro for widget options */
 229 #define opW(name) o_##name, 0, 0, 0
 230
 231 /* use this macro for other options */
 232 #define opO(name) o_##name, 0, 0, 0
 233
 234 static int known_opts = 0;
 235 static const char **dialog_opts;
 236 static char **dialog_argv;
 237
 238 static char **special_argv = 0;
 239 static int special_argc = 0;
 240
 241 static bool ignore_unknown = FALSE;
 242
 243 static const char *program = "dialog";
 244
 245 #ifdef NO_LEAKS
 246 typedef struct _all_blobs {
 247     struct _all_blobs *next;
 248     void *blob;
 249 } AllBlobs;
 250
 251 static AllBlobs *all_blobs;
 252 #endif
 253
 254 /*
 255  * The options[] table is organized this way to make it simple to maintain
 256  * a sorted list of options for the help-message.
 257  *
 258  * Because Boolean options correspond to "true", --shadow is listed here while
 259  * --no-shadow is not.  The findOption and optionBool functions handle the
 260  * cases where "no" is added or removed from the option name to derive an
 261  * opposite setting.
 262  */
 263 /* *INDENT-OFF* */
 264 static const Options options[] = {
 265     { "allow-close",    xxT(allow_close),       1, NULL },
 266     { "and-widget",     opO(and_widget),        4, NULL },
 267     { "ascii-lines",    svT(ascii_lines),       1, "" },
 268     { "aspect",         ssN(aspect_ratio),      1, "<ratio>" },
 269     { "auto-placement", xxT(auto_placement),    1, NULL },
 270     { "backtitle",      svS(backtitle),         1, "<backtitle>" },
 271     { "beep",           svT(beep_signal),       1, "" },
 272     { "beep-after",     svT(beep_after_signal), 1, "" },
 273     { "begin",          svT(begin_set),         1, "<y> <x>" },
 274     { "cancel-label",   svS(cancel_label),      1, "<str>" },
 275     { "checklist",      opW(checklist),         2, "<text> <height> <width> <list height> <tag1> <item1> <status1>..." },
 276     { "clear",          svT(dlg_clear_screen),  1, "" },
 277     { "colors",         svT(colors),            1, "" },
 278     { "column-separator",svS(column_separator), 1, "<str>" },
 279     { "cr-wrap",        svT(cr_wrap),           1, "" },
 280     { "create-rc",      opO(create_rc),         1, NULL },
 281     { "cursor-off-label",svT(cursor_off_label), 1, "" },
 282     { "date-format",    svS(date_format),       1, "<str>" },
 283     { "default-button", xxS(default_button),    1, "<str>" },
 284     { "default-item",   svS(default_item),      1, "<str>" },
 285     { "defaultno",      svT(defaultno),         1, "" },
 286     { "erase-on-exit",  svT(erase_on_exit),     1, "" },
 287     { "exit-label",     svS(exit_label),        1, "<str>" },
 288     { "extra-button",   svT(extra_button),      1, "" },
 289     { "extra-label",    svS(extra_label),       1, "<str>" },
 290     { "fixed-font",     xxT(fixed_font),        1, NULL },
 291     { "form",           opW(form),              2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1>..." },
 292     { "gauge",          opW(gauge),             2, "<text> <height> <width> [<percent>]" },
 293     { "guage",          opW(gauge),             2, NULL },
 294     { "help",           opO(help),              4, "" },
 295     { "help-button",    svT(help_button),       1, "" },
 296     { "help-label",     svS(help_label),        1, "<str>" },
 297     { "help-status",    svT(help_status),       1, "" },
 298     { "help-tags",      svT(help_tags),         1, "" },
 299     { "hfile",          svS(help_file),         1, "<str>" },
 300     { "hline",          svS(help_line),         1, "<str>" },
 301     { "icon",           xxS(icon),              1, NULL },
 302     { "ignore",         opO(ignore),            1, "" },
 303     { "infobox",        opW(infobox),           2, "<text> <height> <width>" },
 304     { "input-fd",       opO(input_fd),          1, "<fd>" },
 305     { "inputbox",       opW(inputbox),          2, "<text> <height> <width> [<init>]" },
 306     { "inputmenu",      opW(inputmenu),         2, "<text> <height> <width> <menu height> <tag1> <item1>..." },
 307     { "insecure",       svT(insecure),          1, "" },
 308     { "item-help",      svT(item_help),         1, "" },
 309     { "keep-colors",    xxT(keep_colors),       1, NULL },
 310     { "keep-tite",      svT(keep_tite),         1, "" },
 311     { "keep-window",    svT(keep_window),       1, "" },
 312     { "last-key",       svT(last_key),          1, "" },
 313     { "max-input",      svN(max_input),         1, "<n>" },
 314     { "menu",           opW(menu),              2, "<text> <height> <width> <menu height> <tag1> <item1>..." },
 315     { "mixedform",      opW(mixedform),         2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1> <itype>..." },
 316     { "mixedgauge",     opW(mixedgauge),        2, "<text> <height> <width> <percent> <tag1> <item1>..." },
 317     { "msgbox",         opW(msgbox),            2, "<text> <height> <width>" },
 318     { "no-cancel",      svT(nocancel),          1, "" },
 319     { "no-close",       xxT(no_close),          1, NULL },
 320     { "no-collapse",    svT(nocollapse),        1, "" },
 321     { "no-hot-list",    svT(no_hot_list),       1, "" },
 322     { "no-kill",        svT(cant_kill),         1, "" },
 323     { "no-label",       svS(no_label),          1, "<str>" },
 324     { "no-lines",       svT(no_lines),          1, "" },
 325     { "no-mouse",       ssT(no_mouse),          1, "" },
 326     { "no-nl-expand",   svT(no_nl_expand),      1, "" },
 327     { "no-ok",          svT(nook),              1, "" },
 328     { "no-shadow",      ssF(use_shadow),        1, "" },
 329     { "ok-label",       svS(ok_label),          1, "<str>" },
 330     { "output-fd",      opO(output_fd),         1, "<fd>" },
 331     { "output-separator",svS(output_separator), 1, "<str>" },
 332     { "passwordbox",    opW(passwordbox),       2, "<text> <height> <width> [<init>]" },
 333     { "passwordform",   opW(passwordform),      2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1>..." },
 334     { "pause",          opW(pause),             2, "<text> <height> <width> <seconds>" },
 335     { "prgbox",         opW(prgbox),            2, "<text> <command> <height> <width>" },
 336     { "print-maxsize",  opO(print_maxsize),     1, "" },
 337     { "print-size",     svT(print_siz),         1, "" },
 338     { "print-text-only",ssT(text_only),         5, "<text> <height> <width>" },
 339     { "print-text-size",opO(print_text_size),   5, "<text> <height> <width>" },
 340     { "print-version",  opO(print_version),     5, "" },
 341     { "programbox",     opW(programbox),        2, "<text> <height> <width>" },
 342     { "progressbox",    opW(progressbox),       2, "<text> <height> <width>" },
 343     { "quoted",         svT(quoted),            1, "" },
 344     { "radiolist",      opW(radiolist),         2, "<text> <height> <width> <list height> <tag1> <item1> <status1>..." },
 345     { "screen-center",  xxT(screen_center),     1, NULL },
 346     { "scrollbar",      ssT(use_scrollbar),     1, "" },
 347     { "separate-output",svT(separate_output),   1, "" },
 348     { "separate-widget",ssS(separate_str),      1, "<str>" },
 349     { "separator",      svS(output_separator),  1, NULL },
 350     { "single-quoted",  svT(single_quoted),     1, "" },
 351     { "size-err",       svT(size_err),          1, "" },
 352     { "sleep",          svN(sleep_secs),        1, "<secs>" },
 353     { "smooth",         xxT(smooth),            1, NULL },
 354     { "stderr",         opO(output_stderr),     1, "" },
 355     { "stdout",         opO(output_stdout),     1, "" },
 356     { "tab-correct",    svT(tab_correct),       1, "" },
 357     { "tab-len",        ssN(tab_len),           1, "<n>" },
 358     { "tailbox",        opW(tailbox),           2, "<file> <height> <width>" },
 359     { "tailboxbg",      opW(tailboxbg),         2, "<file> <height> <width>" },
 360     { "textbox",        opW(textbox),           2, "<file> <height> <width>" },
 361     { "time-format",    svS(time_format),       1, "<str>" },
 362     { "timeout",        svN(timeout_secs),      1, "<secs>" },
 363     { "title",          svS(title),             1, "<title>" },
 364     { "trim",           svT(trim_whitespace),   1, "" },
 365     { "under-mouse",    xxT(under_mouse),       1, NULL },
 366     { "version",        opO(version),           5, "" },
 367     { "visit-items",    ssT(visit_items),       1, "" },
 368     { "wmclass",        xxS(wmclass),           1, NULL },
 369     { "yes-label",      svS(yes_label),         1, "<str>" },
 370     { "yesno",          opW(yesno),             2, "<text> <height> <width>" },
 371 #ifdef HAVE_WHIPTAIL
 372     { "cancel-button",  svS(cancel_label),      1, NULL },
 373     { "fb",             xxT(fullbutton),        1, NULL },
 374     { "fullbutton",     xxT(fullbutton),        1, NULL },
 375     { "no-button",      svS(no_label),          1, NULL },
 376     { "ok-button",      svS(ok_label),          1, NULL },
 377     { "scrolltext",     ssT(use_scrollbar),     1, NULL },
 378     { "topleft",        svT(begin_set),         1, NULL },
 379     { "yes-button",     svS(yes_label),         1, NULL },
 380 #endif
 381 #ifdef HAVE_XDIALOG
 382     { "calendar",       opW(calendar),          2, "<text> <height> <width> <day> <month> <year>" },
 383     { "dselect",        opW(dselect),           2, "<directory> <height> <width>" },
 384     { "editbox",        opW(editbox),           2, "<file> <height> <width>" },
 385     { "fselect",        opW(fselect),           2, "<filepath> <height> <width>" },
 386     { "timebox",        opW(timebox),           2, "<text> <height> <width> <hour> <minute> <second>" },
 387     { "week-start",     svS(week_start),        1, "<str>" },
 388     { "iso-week",       svT(iso_week),          1, NULL },
 389 #endif
 390 #ifdef HAVE_XDIALOG2
 391     { "buildlist",      opW(buildlist),         2, "<text> <height> <width> <list-height> <tag1> <item1> <status1>..." },
 392     { "no-items",       svT(no_items),          1, "" },
 393     { "no-tags",        svT(no_tags),           1, "" },
 394     { "rangebox",       opW(rangebox),          2, "<text> <height> <width> <min-value> <max-value> <default-value>" },
 395     { "reorder",        svT(reorder),           1, "" },
 396     { "treeview",       opW(treeview),          2, "<text> <height> <width> <list-height> <tag1> <item1> <status1> <depth1>..." },
 397 #endif
 398 #if defined(HAVE_XDIALOG2) || defined(HAVE_WHIPTAIL)
 399     { "noitem",         svT(no_items),          1, NULL },
 400     { "notags",         svT(no_tags),           1, NULL },
 401 #endif
 402 #ifdef HAVE_DLG_TRACE
 403     { "trace",          opO(trace),             1, "<file>" },
 404 #endif
 405 };
 406 /* *INDENT-ON* */
 407
 408 #ifdef NO_LEAKS
 409 static void
 410 ignore_leak(void *value)
 411 {
 412     AllBlobs *next = dlg_calloc(AllBlobs, (size_t) 1);
 413     if (next != 0) {
 414         next->blob = value;
 415         next->next = all_blobs;
 416         all_blobs = next;
 417     }
 418 }
 419
 420 static void
 421 handle_leaks(void)
 422 {
 423     while (all_blobs != 0) {
 424         char *blob = all_blobs->blob;
 425         AllBlobs *next = all_blobs->next;
 426         free(blob);
 427         free(all_blobs);
 428         all_blobs = next;
 429     }
 430     free(dialog_opts);
 431     if (special_argv != 0) {
 432         free(special_argv[0]);
 433         free(special_argv);
 434         special_argv = 0;
 435         special_argc = 0;
 436     }
 437 }
 438 #else
 439 #define handle_leaks()          /* nothing */
 440 #define ignore_leak(n)          /* nothing */
 441 #endif
 442
 443 #define OptionChars "\
 444 0123456789\
 445 -\
 446 abcdefghijklmnopqrstuvwxyz\
 447 "
 448
 449 /*
 450  * Check if the given string from main's argv is an option.
 451  */
 452 static bool
 453 isOption(const char *arg)
 454 {
 455     bool result = FALSE;
 456
 457     if (arg != 0) {
 458         if (dialog_opts != 0) {
 459             int n;
 460             for (n = 0; dialog_opts[n] != 0; ++n) {
 461                 if (dialog_opts[n] == arg) {
 462                     result = TRUE;
 463                     break;
 464                 }
 465             }
 466         } else if (!strncmp(arg, "--", (size_t) 2) && isalpha(UCH(arg[2]))) {
 467             if (strlen(arg) == (strspn) (arg, OptionChars)) {
 468                 result = TRUE;
 469             } else {
 470                 handle_leaks();
 471                 dlg_exiterr("Invalid option \"%s\"", arg);
 472             }
 473         }
 474     }
 475     return result;
 476 }
 477
 478 /*
 479  * Make an array showing which argv[] entries are options.  Use "--" as a
 480  * special token to escape the next argument, allowing it to begin with "--".
 481  * When we find a "--" argument, also remove it from argv[] and adjust argc.
 482  * That appears to be an undocumented feature of the popt library.
 483  *
 484  * Also, if we see a "--file", expand it into the parameter list by reading the
 485  * text from the given file and stripping quotes, treating whitespace outside
 486  * quotes as a parameter delimiter.
 487  *
 488  * Finally, if we see a "--args", dump the current list of arguments to the
 489  * standard error.  This is used for debugging complex --file combinations.
 490  */
 491 static void
 492 unescape_argv(int *argcp, char ***argvp)
 493 {
 494     int j, k;
 495     int limit_includes = 20 + *argcp;
 496     int count_includes = 0;
 497     bool doalloc = FALSE;
 498     char *filename;
 499     const char **my_argv = 0;
 500     int my_argc;
 501
 502     DLG_TRACE(("# unescape_argv\n"));
 503     for (k = 0; k < 2; ++k) {
 504
 505         my_argc = 0;
 506         if (special_argv != 0) {
 507             for (j = 0; special_argv[j] != 0; ++j) {
 508                 if (!strcmp(special_argv[j], "--")) {
 509                     break;
 510                 } else if (isOption(special_argv[j])) {
 511                     if (k != 0)
 512                         my_argv[my_argc] = special_argv[j];
 513                     my_argc++;
 514                 }
 515             }
 516         }
 517
 518         if (k == 0) {
 519             my_argc += (*argcp + 1);
 520             my_argv = dlg_calloc(const char *, (size_t) my_argc);
 521             assert_ptr(my_argv, "unescape_argv");
 522         }
 523     }
 524
 525     for (j = 1; j < *argcp; j++) {
 526         bool escaped = FALSE;
 527         if (!strcmp((*argvp)[j], "--")) {
 528             escaped = TRUE;
 529             dlg_eat_argv(argcp, argvp, j, 1);
 530         } else if (!strcmp((*argvp)[j], "--args")) {
 531             fprintf(stderr, "Showing arguments at arg%d\n", j);
 532             for (k = 0; k < *argcp; ++k) {
 533                 fprintf(stderr, " arg%d:%s\n", k, (*argvp)[k]);
 534             }
 535             dlg_eat_argv(argcp, argvp, j, 1);
 536             --j;
 537         } else if (!strcmp((*argvp)[j], "--file")) {
 538             if (++count_includes > limit_includes) {
 539                 handle_leaks();
 540                 dlg_exiterr("Too many --file options");
 541             }
 542
 543             if ((filename = (*argvp)[j + 1]) != 0) {
 544                 FILE *fp;
 545                 char **list;
 546
 547                 if (*filename == '&') {
 548                     fp = fdopen(atoi(filename + sizeof(char)), "r");
 549                 } else {
 550                     fp = fopen(filename, "r");
 551                 }
 552
 553                 if (fp) {
 554                     char *blob;
 555                     int added;
 556                     size_t bytes_read;
 557                     size_t length;
 558                     int n;
 559
 560                     DLG_TRACE(("# opened --file %s ..\n", filename));
 561                     blob = NULL;
 562                     length = 0;
 563                     do {
 564                         blob = dlg_realloc(char, length + BUFSIZ + 1, blob);
 565                         assert_ptr(blob, "unescape_argv");
 566                         bytes_read = fread(blob + length,
 567                                            sizeof(char),
 568                                              (size_t) BUFSIZ,
 569                                            fp);
 570                         length += bytes_read;
 571                         if (ferror(fp)) {
 572                             handle_leaks();
 573                             dlg_exiterr("error on filehandle in unescape_argv");
 574                         }
 575                     } while (bytes_read == BUFSIZ);
 576                     fclose(fp);
 577
 578                     blob[length] = '\0';
 579                     ignore_leak(blob);
 580
 581                     list = dlg_string_to_argv(blob);
 582                     added = dlg_count_argv(list);
 583                     if (added > 2) {
 584                         /* *argcp arguments before the expansion of --file
 585                            - 2 for the removal of '--file <filepath>'
 586                            + added for the arguments contained in <filepath>
 587                            + 1 for the terminating NULL pointer */
 588                         size_t need = (size_t) (*argcp + added - 1);
 589                         if (doalloc) {
 590                             *argvp = dlg_realloc(char *, need, *argvp);
 591                             assert_ptr(*argvp, "unescape_argv");
 592                         } else {
 593                             char **newp = dlg_malloc(char *, need);
 594                             ignore_leak(newp);
 595                             assert_ptr(newp, "unescape_argv");
 596                             for (n = 0; n < *argcp; ++n) {
 597                                 newp[n] = (*argvp)[n];
 598                             }
 599                             /* The new array is not NULL-terminated yet. */
 600                             *argvp = newp;
 601                             doalloc = TRUE;
 602                         }
 603                         my_argv = dlg_realloc(const char *, need, my_argv);
 604                         assert_ptr(my_argv, "unescape_argv");
 605
 606                         /* Shift the arguments after '--file <filepath>'
 607                            right by (added - 2) positions */
 608                         for (n = *argcp - 1; n >= j + 2; --n) {
 609                             (*argvp)[n + added - 2] = (*argvp)[n];
 610                         }
 611                     } else if (added < 2) {
 612                         /* 0 or 1 argument read from the included file
 613                            -> shift the arguments after '--file <filepath>'
 614                            left by (2 - added) positions */
 615                         for (n = j + added; n + 2 - added < *argcp; ++n) {
 616                             (*argvp)[n] = (*argvp)[n + 2 - added];
 617                         }
 618                     }
 619                     /* Copy the inserted arguments to *argvp */
 620                     for (n = 0; n < added; ++n) {
 621                         (*argvp)[n + j] = list[n];
 622                     }
 623                     *argcp += added - 2;
 624                     (*argvp)[*argcp] = 0;       /* Write the NULL terminator */
 625                     free(list); /* No-op if 'list' is NULL */
 626                     /* Force rescan starting from the first inserted argument */
 627                     --j;
 628                     DLG_TRACE(("# finished --file\n"));
 629                     continue;
 630                 } else {
 631                     handle_leaks();
 632                     dlg_exiterr("Cannot open --file %s", filename);
 633                 }
 634             } else {
 635                 handle_leaks();
 636                 dlg_exiterr("No value given for --file");
 637             }
 638         }
 639         if (!escaped
 640             && (*argvp)[j] != 0
 641             && !strncmp((*argvp)[j], "--", (size_t) 2)
 642             && isalpha(UCH((*argvp)[j][2]))) {
 643             my_argv[my_argc++] = (*argvp)[j];
 644             DLG_TRACE(("#\toption argv[%d]=%s\n", j, (*argvp)[j]));
 645         }
 646     }
 647
 648     my_argv[my_argc] = 0;
 649
 650     known_opts = my_argc;
 651     dialog_opts = my_argv;
 652
 653     DLG_TRACE(("#\t%d options vs %d arguments\n", known_opts, *argcp));
 654     dialog_argv = (*argvp);
 655 }
 656
 657 static const Options *
 658 findOption(const char *name, int pass, bool recur)
 659 {
 660     const Options *result = NULL;
 661
 662     if (!strncmp(name, "--", 2) && isalpha(UCH(name[2]))) {
 663         unsigned n;
 664
 665         name += 2;              /* skip the "--" */
 666         for (n = 0; n < TableSize(options); n++) {
 667             if ((pass & options[n].pass) != 0
 668                 && !strcmp(name, options[n].name)) {
 669                 result = &options[n];
 670                 break;
 671             }
 672         }
 673         if (result == NULL && !recur) {
 674             char *temp = malloc(8 + strlen(name));
 675             if (temp != NULL) {
 676                 if (!strncmp(name, "no", 2)) {
 677                     int skip = !strncmp(name, "no-", 3) ? 3 : 2;
 678                     sprintf(temp, "--no-%s", name + skip);
 679                     result = findOption(temp, pass, TRUE);
 680                     if (result == NULL) {
 681                         sprintf(temp, "--%s", name + skip);
 682                         result = findOption(temp, pass, TRUE);
 683                     }
 684                 }
 685                 if (result == NULL && strncmp(name, "no", 2)) {
 686                     sprintf(temp, "--no-%s", name);
 687                     result = findOption(temp, pass, TRUE);
 688                 }
 689                 free(temp);
 690             }
 691         }
 692     }
 693     return result;
 694 }
 695
 696 static eOptions
 697 lookupOption(const char *name, int pass)
 698 {
 699     eOptions result = o_unknown;
 700     const Options *data = findOption(name, pass, FALSE);
 701     if (data != NULL) {
 702         result = data->code;
 703     }
 704     return result;
 705 }
 706
 707 static void
 708 Usage(const char *msg)
 709 {
 710     handle_leaks();
 711     dlg_exiterr("%s.\nUse --help to list options.\n\n", msg);
 712 }
 713
 714 /*
 715  * Count arguments, stopping at the end of the argument list, or on any of our
 716  * "--" tokens.
 717  */
 718 static int
 719 arg_rest(char *argv[])
 720 {
 721     int i = 1;                  /* argv[0] points to a "--" token */
 722
 723     while (argv[i] != 0
 724            && (!isOption(argv[i]) || lookupOption(argv[i], 7) == o_unknown))
 725         i++;
 726     return i;
 727 }
 728
 729 /*
 730  * In MultiWidget this function is needed to count how many tags
 731  * a widget (menu, checklist, radiolist) has
 732  */
 733 static int
 734 howmany_tags(char *argv[], int group)
 735 {
 736     int result = 0;
 737     char temp[80];
 738
 739     while (argv[0] != 0) {
 740         int have;
 741
 742         if (isOption(argv[0]))
 743             break;
 744         if ((have = arg_rest(argv)) < group) {
 745             const char *format = _("Expected %d arguments, found only %d");
 746             sprintf(temp, format, group, have);
 747             Usage(temp);
 748         } else if ((have % group) != 0) {
 749             const char *format = _("Expected %d arguments, found extra %d");
 750             sprintf(temp, format, group, (have % group));
 751             Usage(temp);
 752         }
 753
 754         argv += have;
 755         result += (have / group);
 756     }
 757
 758     return result;
 759 }
 760
 761 static int
 762 numeric_arg(char **av, int n)
 763 {
 764     int result = 0;
 765
 766     if (n < dlg_count_argv(av)) {
 767         char *last = 0;
 768         result = (int) strtol(av[n], &last, 10);
 769
 770         if (last == 0 || *last != 0) {
 771             char msg[80];
 772
 773             sprintf(msg, "Expected a number for token %d of %.20s", n, av[0]);
 774             Usage(msg);
 775         }
 776     }
 777     return result;
 778 }
 779
 780 static char *
 781 optional_str(char **av, int n, char *dft)
 782 {
 783     char *ret = dft;
 784     if (arg_rest(av) > n)
 785         ret = av[n];
 786     return ret;
 787 }
 788
 789 #if defined(HAVE_DLG_GAUGE) || defined(HAVE_XDIALOG)
 790 static int
 791 optional_num(char **av, int n, int dft)
 792 {
 793     int ret = dft;
 794     if (arg_rest(av) > n)
 795         ret = numeric_arg(av, n);
 796     return ret;
 797 }
 798 #endif
 799
 800 /*
 801  * On AIX 4.x, we have to flush the output right away since there is a bug in
 802  * the curses package which discards stdout even when we've used newterm to
 803  * redirect output to /dev/tty.
 804  */
 805 static int
 806 show_result(int ret)
 807 {
 808     bool either = FALSE;
 809
 810     switch (ret) {
 811     case DLG_EXIT_OK:
 812     case DLG_EXIT_EXTRA:
 813     case DLG_EXIT_HELP:
 814     case DLG_EXIT_ITEM_HELP:
 815         if ((dialog_state.output_count > 1) && !dialog_vars.separate_output) {
 816             fputs((dialog_state.separate_str
 817                    ? dialog_state.separate_str
 818                    : DEFAULT_SEPARATE_STR),
 819                   dialog_state.output);
 820             either = TRUE;
 821         }
 822         if (dialog_vars.input_result != 0
 823             && dialog_vars.input_result[0] != '\0') {
 824             fputs(dialog_vars.input_result, dialog_state.output);
 825             DLG_TRACE(("# input_result:\n%s\n", dialog_vars.input_result));
 826             either = TRUE;
 827         }
 828         if (either) {
 829             fflush(dialog_state.output);
 830         }
 831         break;
 832     }
 833     return ret;
 834 }
 835
 836 /*
 837  * These are the widget callers.
 838  */
 839
 840 static int
 841 call_yesno(CALLARGS)
 842 {
 843     *offset_add = 4;
 844     return dialog_yesno(t,
 845                         av[1],
 846                         numeric_arg(av, 2),
 847                         numeric_arg(av, 3));
 848 }
 849
 850 static int
 851 call_msgbox(CALLARGS)
 852 {
 853     *offset_add = 4;
 854     return dialog_msgbox(t,
 855                          av[1],
 856                          numeric_arg(av, 2),
 857                          numeric_arg(av, 3), 1);
 858 }
 859
 860 static int
 861 call_infobox(CALLARGS)
 862 {
 863     *offset_add = 4;
 864     return dialog_msgbox(t,
 865                          av[1],
 866                          numeric_arg(av, 2),
 867                          numeric_arg(av, 3), 0);
 868 }
 869
 870 static int
 871 call_textbox(CALLARGS)
 872 {
 873     *offset_add = 4;
 874     return dialog_textbox(t,
 875                           av[1],
 876                           numeric_arg(av, 2),
 877                           numeric_arg(av, 3));
 878 }
 879
 880 static int
 881 call_menu(CALLARGS)
 882 {
 883     int tags = howmany_tags(av + 5, MENUBOX_TAGS);
 884     *offset_add = 5 + tags * MENUBOX_TAGS;
 885
 886     return dialog_menu(t,
 887                        av[1],
 888                        numeric_arg(av, 2),
 889                        numeric_arg(av, 3),
 890                        numeric_arg(av, 4),
 891                        tags, av + 5);
 892 }
 893
 894 static int
 895 call_inputmenu(CALLARGS)
 896 {
 897     int tags = howmany_tags(av + 5, MENUBOX_TAGS);
 898     bool free_extra_label = FALSE;
 899     int result;
 900
 901     dialog_vars.input_menu = TRUE;
 902
 903     if (dialog_vars.max_input == 0)
 904         dialog_vars.max_input = MAX_LEN / 2;
 905
 906     if (dialog_vars.extra_label == 0) {
 907         free_extra_label = TRUE;
 908         dialog_vars.extra_label = dlg_strclone(_("Rename"));
 909     }
 910
 911     dialog_vars.extra_button = TRUE;
 912
 913     *offset_add = 5 + tags * MENUBOX_TAGS;
 914     result = dialog_menu(t,
 915                          av[1],
 916                          numeric_arg(av, 2),
 917                          numeric_arg(av, 3),
 918                          numeric_arg(av, 4),
 919                          tags, av + 5);
 920     if (free_extra_label) {
 921         free(dialog_vars.extra_label);
 922         dialog_vars.extra_label = 0;
 923     }
 924     return result;
 925 }
 926
 927 static int
 928 call_checklist(CALLARGS)
 929 {
 930     int tags = howmany_tags(av + 5, CHECKBOX_TAGS);
 931     int code;
 932
 933     *offset_add = 5 + tags * CHECKBOX_TAGS;
 934     code = dialog_checklist(t,
 935                             av[1],
 936                             numeric_arg(av, 2),
 937                             numeric_arg(av, 3),
 938                             numeric_arg(av, 4),
 939                             tags, av + 5, FLAG_CHECK);
 940     return code;
 941 }
 942
 943 static int
 944 call_radiolist(CALLARGS)
 945 {
 946     int tags = howmany_tags(av + 5, CHECKBOX_TAGS);
 947     *offset_add = 5 + tags * CHECKBOX_TAGS;
 948     return dialog_checklist(t,
 949                             av[1],
 950                             numeric_arg(av, 2),
 951                             numeric_arg(av, 3),
 952                             numeric_arg(av, 4),
 953                             tags, av + 5, FLAG_RADIO);
 954 }
 955
 956 static int
 957 call_inputbox(CALLARGS)
 958 {
 959     *offset_add = arg_rest(av);
 960     return dialog_inputbox(t,
 961                            av[1],
 962                            numeric_arg(av, 2),
 963                            numeric_arg(av, 3),
 964                            optional_str(av, 4, 0), 0);
 965 }
 966
 967 static int
 968 call_passwordbox(CALLARGS)
 969 {
 970     *offset_add = arg_rest(av);
 971     return dialog_inputbox(t,
 972                            av[1],
 973                            numeric_arg(av, 2),
 974                            numeric_arg(av, 3),
 975                            optional_str(av, 4, 0), 1);
 976 }
 977
 978 #ifdef HAVE_XDIALOG
 979 static int
 980 call_calendar(CALLARGS)
 981 {
 982     *offset_add = arg_rest(av);
 983     return dialog_calendar(t,
 984                            av[1],
 985                            numeric_arg(av, 2),
 986                            numeric_arg(av, 3),
 987                            optional_num(av, 4, -1),
 988                            optional_num(av, 5, -1),
 989                            optional_num(av, 6, -1));
 990 }
 991
 992 static int
 993 call_dselect(CALLARGS)
 994 {
 995     *offset_add = arg_rest(av);
 996     return dialog_dselect(t,
 997                           av[1],
 998                           numeric_arg(av, 2),
 999                           numeric_arg(av, 3));
1000 }
1001
1002 static int
1003 call_editbox(CALLARGS)
1004 {
1005     *offset_add = 4;
1006     return dialog_editbox(t,
1007                           av[1],
1008                           numeric_arg(av, 2),
1009                           numeric_arg(av, 3));
1010 }
1011
1012 static int
1013 call_fselect(CALLARGS)
1014 {
1015     *offset_add = arg_rest(av);
1016     return dialog_fselect(t,
1017                           av[1],
1018                           numeric_arg(av, 2),
1019                           numeric_arg(av, 3));
1020 }
1021
1022 static int
1023 call_timebox(CALLARGS)
1024 {
1025     *offset_add = arg_rest(av);
1026     return dialog_timebox(t,
1027                           av[1],
1028                           numeric_arg(av, 2),
1029                           numeric_arg(av, 3),
1030                           optional_num(av, 4, -1),
1031                           optional_num(av, 5, -1),
1032                           optional_num(av, 6, -1));
1033 }
1034 #endif /* HAVE_XDIALOG */
1035
1036 /* dialog 1.2 widgets */
1037 #ifdef HAVE_XDIALOG2
1038
1039 #define DisableNoTags() \
1040         bool save_no_tags = dialog_vars.no_tags; \
1041         bool save_no_items = dialog_vars.no_items; \
1042         dialog_vars.no_tags = TRUE; \
1043         dialog_vars.no_items = FALSE
1044
1045 #define RestoreNoTags() \
1046         dialog_vars.no_tags = save_no_tags; \
1047         dialog_vars.no_items = save_no_items
1048
1049 static int
1050 call_buildlist(CALLARGS)
1051 {
1052     int tags = howmany_tags(av + 5, CHECKBOX_TAGS);
1053     int result;
1054
1055     DisableNoTags();
1056
1057     *offset_add = 5 + tags * CHECKBOX_TAGS;
1058     result = dialog_buildlist(t,
1059                               av[1],
1060                               numeric_arg(av, 2),
1061                               numeric_arg(av, 3),
1062                               numeric_arg(av, 4),
1063                               tags, av + 5,
1064                               dialog_vars.reorder);
1065     RestoreNoTags();
1066     return result;
1067 }
1068
1069 static int
1070 call_rangebox(CALLARGS)
1071 {
1072     int min_value;
1073
1074     *offset_add = arg_rest(av);
1075     min_value = numeric_arg(av, 4);
1076     return dialog_rangebox(t,
1077                            av[1],
1078                            numeric_arg(av, 2),
1079                            numeric_arg(av, 3),
1080                            min_value,
1081                            numeric_arg(av, 5),
1082                            (*offset_add > 6) ? numeric_arg(av, 6) : min_value);
1083 }
1084
1085 static int
1086 call_treeview(CALLARGS)
1087 {
1088     int tags = howmany_tags(av + 5, TREEVIEW_TAGS);
1089     int result;
1090
1091     DisableNoTags();
1092
1093     *offset_add = arg_rest(av);
1094     result = dialog_treeview(t,
1095                              av[1],
1096                              numeric_arg(av, 2),
1097                              numeric_arg(av, 3),
1098                              numeric_arg(av, 4),
1099                              tags, av + 5, FLAG_RADIO);
1100     RestoreNoTags();
1101     return result;
1102 }
1103 #endif /* HAVE_XDIALOG */
1104
1105 #ifdef HAVE_DLG_FORMBOX
1106 static int
1107 call_form(CALLARGS)
1108 {
1109     int group = FORMBOX_TAGS;
1110     int tags = howmany_tags(av + 5, group);
1111     *offset_add = 5 + tags * group;
1112
1113     return dialog_form(t,
1114                        av[1],
1115                        numeric_arg(av, 2),
1116                        numeric_arg(av, 3),
1117                        numeric_arg(av, 4),
1118                        tags, av + 5);
1119 }
1120
1121 static int
1122 call_password_form(CALLARGS)
1123 {
1124     unsigned save = dialog_vars.formitem_type;
1125     int result;
1126
1127     dialog_vars.formitem_type = 1;
1128     result = call_form(PASSARGS);
1129     dialog_vars.formitem_type = save;
1130
1131     return result;
1132 }
1133 #endif /* HAVE_DLG_FORMBOX */
1134
1135 #ifdef HAVE_DLG_MIXEDFORM
1136 static int
1137 call_mixed_form(CALLARGS)
1138 {
1139     int group = MIXEDFORM_TAGS;
1140     int tags = howmany_tags(av + 5, group);
1141     *offset_add = 5 + tags * group;
1142
1143     return dialog_mixedform(t,
1144                             av[1],
1145                             numeric_arg(av, 2),
1146                             numeric_arg(av, 3),
1147                             numeric_arg(av, 4),
1148                             tags, av + 5);
1149 }
1150 #endif /* HAVE_DLG_MIXEDFORM */
1151
1152 #ifdef HAVE_DLG_GAUGE
1153 static int
1154 call_gauge(CALLARGS)
1155 {
1156     *offset_add = arg_rest(av);
1157     return dialog_gauge(t,
1158                         av[1],
1159                         numeric_arg(av, 2),
1160                         numeric_arg(av, 3),
1161                         optional_num(av, 4, 0));
1162 }
1163
1164 static int
1165 call_pause(CALLARGS)
1166 {
1167     *offset_add = arg_rest(av);
1168     return dialog_pause(t,
1169                         av[1],
1170                         numeric_arg(av, 2),
1171                         numeric_arg(av, 3),
1172                         numeric_arg(av, 4));
1173 }
1174 #endif
1175
1176 #ifdef HAVE_MIXEDGAUGE
1177 static int
1178 call_mixed_gauge(CALLARGS)
1179 {
1180 #define MIXEDGAUGE_BASE 5
1181     int tags = howmany_tags(av + MIXEDGAUGE_BASE, MIXEDGAUGE_TAGS);
1182     *offset_add = MIXEDGAUGE_BASE + tags * MIXEDGAUGE_TAGS;
1183     return dialog_mixedgauge(t,
1184                              av[1],
1185                              numeric_arg(av, 2),
1186                              numeric_arg(av, 3),
1187                              numeric_arg(av, 4),
1188                              tags, av + MIXEDGAUGE_BASE);
1189 }
1190 #endif
1191
1192 #ifdef HAVE_DLG_GAUGE
1193 static int
1194 call_prgbox(CALLARGS)
1195 {
1196     *offset_add = arg_rest(av);
1197     /* the original version does not accept a prompt string, but for
1198      * consistency we allow it.
1199      */
1200     return ((*offset_add == 5)
1201             ? dialog_prgbox(t,
1202                             av[1],
1203                             av[2],
1204                             numeric_arg(av, 3),
1205                             numeric_arg(av, 4), TRUE)
1206             : dialog_prgbox(t,
1207                             "",
1208                             av[1],
1209                             numeric_arg(av, 2),
1210                             numeric_arg(av, 3), TRUE));
1211 }
1212 #endif
1213
1214 #ifdef HAVE_DLG_GAUGE
1215 static int
1216 call_programbox(CALLARGS)
1217 {
1218     int result;
1219
1220     *offset_add = arg_rest(av);
1221     /* this function is a compromise between --prgbox and --progressbox.
1222      */
1223     result = ((*offset_add == 4)
1224               ? dlg_progressbox(t,
1225                                 av[1],
1226                                 numeric_arg(av, 2),
1227                                 numeric_arg(av, 3),
1228                                 TRUE,
1229                                 dialog_state.pipe_input)
1230               : dlg_progressbox(t,
1231                                 "",
1232                                 numeric_arg(av, 1),
1233                                 numeric_arg(av, 2),
1234                                 TRUE,
1235                                 dialog_state.pipe_input));
1236     dialog_state.pipe_input = 0;
1237     return result;
1238 }
1239 #endif
1240
1241 #ifdef HAVE_DLG_GAUGE
1242 static int
1243 call_progressbox(CALLARGS)
1244 {
1245     *offset_add = arg_rest(av);
1246     /* the original version does not accept a prompt string, but for
1247      * consistency we allow it.
1248      */
1249     return ((*offset_add == 4)
1250             ? dialog_progressbox(t,
1251                                  av[1],
1252                                  numeric_arg(av, 2),
1253                                  numeric_arg(av, 3))
1254             : dialog_progressbox(t,
1255                                  "",
1256                                  numeric_arg(av, 1),
1257                                  numeric_arg(av, 2)));
1258 }
1259 #endif
1260
1261 #ifdef HAVE_DLG_TAILBOX
1262 static int
1263 call_tailbox(CALLARGS)
1264 {
1265     *offset_add = 4;
1266     return dialog_tailbox(t,
1267                           av[1],
1268                           numeric_arg(av, 2),
1269                           numeric_arg(av, 3),
1270                           FALSE);
1271 }
1272
1273 static int
1274 call_tailboxbg(CALLARGS)
1275 {
1276     *offset_add = 4;
1277     return dialog_tailbox(t,
1278                           av[1],
1279                           numeric_arg(av, 2),
1280                           numeric_arg(av, 3),
1281                           TRUE);
1282 }
1283 #endif
1284 /* *INDENT-OFF* */
1285 static const Mode modes[] =
1286 {
1287     {o_yesno,           4, 4, call_yesno},
1288     {o_msgbox,          4, 4, call_msgbox},
1289     {o_infobox,         4, 4, call_infobox},
1290     {o_textbox,         4, 4, call_textbox},
1291     {o_menu,            6, 0, call_menu},
1292     {o_inputmenu,       6, 0, call_inputmenu},
1293     {o_checklist,       7, 0, call_checklist},
1294     {o_radiolist,       7, 0, call_radiolist},
1295     {o_inputbox,        4, 5, call_inputbox},
1296     {o_passwordbox,     4, 5, call_passwordbox},
1297 #ifdef HAVE_DLG_GAUGE
1298     {o_gauge,           4, 5, call_gauge},
1299     {o_pause,           5, 5, call_pause},
1300     {o_prgbox,          4, 5, call_prgbox},
1301     {o_programbox,      3, 4, call_programbox},
1302     {o_progressbox,     3, 4, call_progressbox},
1303 #endif
1304 #ifdef HAVE_DLG_FORMBOX
1305     {o_passwordform,   13, 0, call_password_form},
1306     {o_form,           13, 0, call_form},
1307 #endif
1308 #ifdef HAVE_MIXEDGAUGE
1309     {o_mixedgauge,      MIXEDGAUGE_BASE, 0, call_mixed_gauge},
1310 #endif
1311 #ifdef HAVE_DLG_MIXEDFORM
1312     {o_mixedform,      13, 0, call_mixed_form},
1313 #endif
1314 #ifdef HAVE_DLG_TAILBOX
1315     {o_tailbox,         4, 4, call_tailbox},
1316     {o_tailboxbg,       4, 4, call_tailboxbg},
1317 #endif
1318 #ifdef HAVE_XDIALOG
1319     {o_calendar,        4, 7, call_calendar},
1320     {o_dselect,         4, 5, call_dselect},
1321     {o_editbox,         4, 4, call_editbox},
1322     {o_fselect,         4, 5, call_fselect},
1323     {o_timebox,         4, 7, call_timebox},
1324 #endif
1325 #ifdef HAVE_XDIALOG2
1326     {o_buildlist,       4, 0, call_buildlist},
1327     {o_rangebox,        5, 7, call_rangebox},
1328     {o_treeview,        4, 0, call_treeview},
1329 #endif
1330 };
1331 /* *INDENT-ON* */
1332
1333 static char *
1334 optionString(char **argv, int *num)
1335 {
1336     int next = *num + 1;
1337     char *result = argv[next];
1338     if (result == 0) {
1339         char temp[80];
1340         sprintf(temp, "Expected a string-parameter for %.20s", argv[*num]);
1341         Usage(temp);
1342     }
1343     *num = next;
1344     return result;
1345 }
1346
1347 static int
1348 optionValue(char **argv, int *num)
1349 {
1350     int next = *num + 1;
1351     char *src = argv[next];
1352     char *tmp = 0;
1353     int result = 0;
1354
1355     if (src != 0) {
1356         result = (int) strtol(src, &tmp, 0);
1357         if (tmp == 0 || *tmp != 0)
1358             src = 0;
1359     }
1360
1361     if (src == 0) {
1362         char temp[80];
1363         sprintf(temp, "Expected a numeric-parameter for %.20s", argv[*num]);
1364         Usage(temp);
1365     }
1366     *num = next;
1367     return result;
1368 }
1369
1370 /*
1371  * In findOption, we made provision for adding/removing a "no" prefix from
1372  * any boolean option.  This function determines the actual true/false result.
1373  */
1374 static bool
1375 optionBool(const char *actual, const Options * data)
1376 {
1377     bool normal = (data->type == tTrue) ? TRUE : FALSE;
1378     bool result = !strcmp(actual + 2, data->name) ? normal : !normal;
1379     if (result != normal) {
1380         int want_no = (strncmp(actual + 2, "no", 2) == 0);
1381         int have_no = (strncmp(data->name, "no", 2) == 0);
1382         if (have_no == want_no)
1383             result = normal;
1384     }
1385     return result;
1386 }
1387
1388 /* Return exit-code for a named button */
1389 static int
1390 button_code(const char *name)
1391 {
1392     /* *INDENT-OFF* */
1393     static struct {
1394         const char *name;
1395         int code;
1396     } table[] = {
1397         { "ok",     DLG_EXIT_OK },
1398         { "yes",    DLG_EXIT_OK },
1399         { "cancel", DLG_EXIT_CANCEL },
1400         { "no",     DLG_EXIT_CANCEL },
1401         { "help",   DLG_EXIT_HELP },
1402         { "extra",  DLG_EXIT_EXTRA },
1403     };
1404     /* *INDENT-ON* */
1405
1406     int code = DLG_EXIT_ERROR;
1407     size_t i;
1408
1409     for (i = 0; i < TableSize(table); i++) {
1410         if (!dlg_strcmp(name, table[i].name)) {
1411             code = table[i].code;
1412             break;
1413         }
1414     }
1415
1416     if (code == DLG_EXIT_ERROR) {
1417         char temp[80];
1418         sprintf(temp, "Button name \"%.20s\" unknown", name);
1419         Usage(temp);
1420     }
1421
1422     return code;
1423 }
1424
1425 /*
1426  * If this is the last option, we do not want any error messages - just our
1427  * output.  Calling end_dialog() cancels the refresh() at the end of the
1428  * program as well.
1429  */
1430 static void
1431 IgnoreNonScreen(char **argv, int offset)
1432 {
1433     if (argv[offset + 1] == 0) {
1434         ignore_unknown = TRUE;
1435         end_dialog();
1436     }
1437 }
1438
1439 static void
1440 PrintTextOnly(char **argv, int *offset, eOptions code)
1441 {
1442     /* TODO - handle two optional numeric params */
1443     char *text;
1444     int height = 0;
1445     int width = 0;
1446     int height2 = 0;
1447     int width2 = 0;
1448     int next = arg_rest(argv + *offset);
1449
1450     if (LINES <= 0 && COLS <= 0) {
1451         dlg_ttysize(fileno(dialog_state.input),
1452                     &dialog_state.screen_height,
1453                     &dialog_state.screen_width);
1454     }
1455
1456     text = strdup(optionString(argv, offset));
1457     IgnoreNonScreen(argv, *offset);
1458
1459     if (next >= 1) {
1460         next = MIN(next, 3);
1461         height = numeric_arg(argv, *offset + 1);
1462         if (next >= 2)
1463             width = numeric_arg(argv, *offset + 2);
1464         *offset += next - 1;
1465     }
1466
1467     dlg_trim_string(text);
1468     dlg_auto_size(NULL, text, &height2, &width2, height, width);
1469
1470     switch (code) {
1471     case o_text_only:
1472         dialog_state.text_only = TRUE;
1473         dlg_print_autowrap(stdscr, text, height2, width2);
1474         dialog_state.text_only = FALSE;
1475         break;
1476     case o_print_text_size:
1477         fprintf(dialog_state.output, "%d %d\n",
1478                 dialog_state.text_height,
1479                 dialog_state.text_width);
1480         break;
1481     default:
1482         break;
1483     }
1484 }
1485
1486 /*
1487  * Print parts of a message
1488  */
1489 static void
1490 PrintList(const char *const *list)
1491 {
1492     const char *leaf = strrchr(program, '/');
1493     unsigned n = 0;
1494
1495     if (leaf != 0)
1496         leaf++;
1497     else
1498         leaf = program;
1499
1500     while (*list != 0) {
1501         fprintf(dialog_state.output, *list, n ? leaf : dialog_version());
1502         (void) fputc('\n', dialog_state.output);
1503         n = 1;
1504         list++;
1505     }
1506 }
1507
1508 static const Mode *
1509 lookupMode(eOptions code)
1510 {
1511     const Mode *modePtr = 0;
1512     unsigned n;
1513
1514     for (n = 0; n < TableSize(modes); n++) {
1515         if (modes[n].code == code) {
1516             modePtr = &modes[n];
1517             break;
1518         }
1519     }
1520     return modePtr;
1521 }
1522
1523 static int
1524 compare_opts(const void *a, const void *b)
1525 {
1526     Options *const *p = (Options * const *) a;
1527     Options *const *q = (Options * const *) b;
1528     return strcmp((*p)->name, (*q)->name);
1529 }
1530
1531 /*
1532  * Print program's version.
1533  */
1534 static void
1535 PrintVersion(FILE *fp)
1536 {
1537     fprintf(fp, "Version: %s\n", dialog_version());
1538 }
1539
1540 /*
1541  * Print program help-message
1542  */
1543 static void
1544 Help(void)
1545 {
1546     static const char *const tbl_1[] =
1547     {
1548         "cdialog (ComeOn Dialog!) version %s",
1549         "Copyright 2000-2020,2021 Thomas E. Dickey",
1550         "This is free software; see the source for copying conditions.  There is NO",
1551         "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.",
1552         "",
1553         "* Display dialog boxes from shell scripts *",
1554         "",
1555         "Usage: %s <options> { --and-widget <options> }",
1556         "where options are \"common\" options, followed by \"box\" options",
1557         "",
1558 #ifdef HAVE_RC_FILE
1559         "Special options:",
1560         "  [--create-rc \"file\"]",
1561 #endif
1562         0
1563     }, *const tbl_3[] =
1564     {
1565         "",
1566         "Auto-size with height and width = 0. Maximize with height and width = -1.",
1567         "Global-auto-size if also menu_height/list_height = 0.",
1568         0
1569     };
1570     size_t limit = TableSize(options);
1571     size_t j, k;
1572     const Options **opts;
1573
1574     end_dialog();
1575     dialog_state.output = stdout;
1576
1577     opts = dlg_calloc(const Options *, limit);
1578     assert_ptr(opts, "Help");
1579     for (j = 0; j < limit; ++j) {
1580         opts[j] = &(options[j]);
1581     }
1582     qsort(opts, limit, sizeof(Options *), compare_opts);
1583
1584     PrintList(tbl_1);
1585     fprintf(dialog_state.output, "Common options:\n ");
1586     for (j = k = 0; j < limit; j++) {
1587         if ((opts[j]->pass & 1)
1588             && opts[j]->help != 0) {
1589             size_t len = 6 + strlen(opts[j]->name) + strlen(opts[j]->help);
1590             k += len;
1591             if (k > 75) {
1592                 fprintf(dialog_state.output, "\n ");
1593                 k = len;
1594             }
1595             fprintf(dialog_state.output, " [--%s%s%s]", opts[j]->name,
1596                     *(opts[j]->help) ? " " : "", opts[j]->help);
1597         }
1598     }
1599     fprintf(dialog_state.output, "\nBox options:\n");
1600     for (j = 0; j < limit; j++) {
1601         if ((opts[j]->pass & 2) != 0
1602             && opts[j]->help != 0
1603             && lookupMode(opts[j]->code)) {
1604             fprintf(dialog_state.output, "  --%-12s %s\n", opts[j]->name,
1605                     opts[j]->help);
1606         }
1607     }
1608     PrintList(tbl_3);
1609
1610     free(opts);
1611     handle_leaks();
1612     dlg_exit(DLG_EXIT_OK);
1613 }
1614
1615 #ifdef HAVE_DLG_TRACE
1616 /*
1617  * Only the first call to dlg_trace will open a trace file.  But each time
1618  * --trace is parsed, we show the whole parameter list as it is at that moment,
1619  * counting discarded parameters.  The only way to capture the whole parameter
1620  * list is if --trace is the first option.
1621  */
1622 static void
1623 process_trace_option(char **argv, int *offset)
1624 {
1625     int j;
1626
1627     if (dialog_state.trace_output == 0) {
1628         dlg_trace(optionString(argv, offset));
1629     } else {
1630         DLG_TRACE(("# ignore extra --trace option\n"));
1631         *offset += 1;
1632     }
1633
1634     DLG_TRACE(("# Parameters:\n"));
1635     for (j = 0; argv[j] != 0; ++j) {
1636         DLG_TRACE(("#\targv[%d] = %s\n", j, argv[j]));
1637     }
1638 }
1639 #endif
1640
1641 /*
1642  * "Common" options apply to all widgets more/less.  Most of the common options
1643  * set values in dialog_vars, a few set dialog_state and a couple write to the
1644  * output stream.
1645  */
1646 static int
1647 process_common_options(int argc, char **argv, int offset, int output)
1648 {
1649     const Options *data = NULL;
1650     bool done = FALSE;
1651
1652     DLG_TRACE(("# process_common_options, offset %d:%d\n", offset, argc));
1653
1654     while (!done && offset < argc) {
1655         static char empty[] = "";
1656         eOptions code = o_unknown;
1657         char *sval = empty;
1658         bool bval;
1659         int nval;
1660         char *target;
1661
1662         DLG_TRACE(("#\targv[%d] = %s\n", offset, argv[offset]));
1663         if ((data = findOption(argv[offset], 1, FALSE)) == NULL) {
1664             done = TRUE;
1665             continue;
1666         }
1667
1668         switch (data->vars) {
1669         default:
1670             target = NULL;
1671             break;
1672         case 1:
1673             target = (char *) &dialog_state;
1674             break;
1675         case 2:
1676             target = (char *) &dialog_vars;
1677             break;
1678         }
1679
1680 #define TraceTarget \
1681             ((target == (char *) &dialog_state) \
1682              ? "dialog_state" \
1683              : "dialog_vars")
1684 #define TraceBVal (bval ? "TRUE" : "FALSE")
1685 #define TraceDone(fmt,value) \
1686         DLG_TRACE(("#\t.. set %s.%s = %"fmt"\n", TraceTarget, data->name, value))
1687 #define TraceLate(fmt,value) \
1688         DLG_TRACE(("#\t.. defer setting %s = %"fmt"\n", data->name, value))
1689
1690         code = data->code;
1691         switch (data->type) {
1692         default:
1693             break;
1694         case tFalse:
1695         case tTrue:
1696             bval = optionBool(argv[offset], data);
1697             if (target != NULL) {
1698                 *(bool *) (target + data->offset) = bval;
1699                 TraceDone("s", TraceBVal);
1700             } else {
1701                 TraceLate("s", TraceBVal);
1702             }
1703             break;
1704         case tNumber:
1705             nval = optionValue(argv, &offset);
1706             if (target != NULL) {
1707                 *(int *) (void *) (target + data->offset) = nval;
1708                 TraceDone("d", nval);
1709             } else {
1710                 TraceLate("d", nval);
1711             }
1712             break;
1713         case tString:
1714             sval = optionString(argv, &offset);
1715             if (target != NULL) {
1716                 *(char **) (void *) (target + data->offset) = sval;
1717                 TraceDone("s", sval);
1718             } else {
1719                 TraceLate("s", sval);
1720             }
1721             break;
1722         }
1723
1724         switch (code) {
1725         case o_defaultno:
1726             dialog_vars.default_button = DLG_EXIT_CANCEL;
1727             break;
1728         case o_default_button:
1729             dialog_vars.default_button = button_code(sval);
1730             dialog_vars.defaultno = dialog_vars.default_button == DLG_EXIT_CANCEL;
1731             break;
1732         case o_text_only:
1733         case o_print_text_size:
1734             PrintTextOnly(argv, &offset, code);
1735             break;
1736         case o_print_maxsize:
1737             if (output) {
1738                 IgnoreNonScreen(argv, offset);
1739                 fflush(dialog_state.output);
1740                 fprintf(dialog_state.output, "MaxSize: %d, %d\n", SLINES, SCOLS);
1741             }
1742             break;
1743         case o_print_version:
1744             if (output) {
1745                 PrintVersion(dialog_state.output);
1746             }
1747             break;
1748         case o_visit_items:
1749             dialog_state.visit_cols = 1;
1750             break;
1751         case o_begin_set:
1752 #ifdef HAVE_WHIPTAIL
1753             if (!strcmp(argv[offset], "--topleft")) {
1754                 dialog_vars.begin_y = 0;
1755                 dialog_vars.begin_x = 0;
1756             } else
1757 #endif
1758             {
1759                 dialog_vars.begin_y = optionValue(argv, &offset);
1760                 dialog_vars.begin_x = optionValue(argv, &offset);
1761             }
1762             break;
1763         case o_ascii_lines:
1764             dialog_vars.no_lines = FALSE;
1765             break;
1766         case o_no_lines:
1767             dialog_vars.ascii_lines = FALSE;
1768             break;
1769         case o_no_mouse:
1770             mouse_close();
1771             break;
1772         case o_unknown:
1773             done = !ignore_unknown;
1774         default:
1775             break;
1776 #ifdef HAVE_DLG_TRACE
1777         case o_trace:
1778             process_trace_option(argv, &offset);
1779             break;
1780 #endif
1781         case o_iso_week:
1782             if (dialog_vars.week_start == 0) {  /* Monday is implied */
1783                 static char default_1st[] = "1";
1784                 dialog_vars.week_start = default_1st;
1785             }
1786             break;
1787         }
1788         if (!done)
1789             offset++;
1790     }
1791
1792     if (dialog_state.aspect_ratio == 0)
1793         dialog_state.aspect_ratio = DEFAULT_ASPECT_RATIO;
1794
1795     return offset;
1796 }
1797
1798 /*
1799  * Initialize options at the start of a series of common options culminating
1800  * in a widget.
1801  */
1802 static void
1803 init_result(char *buffer)
1804 {
1805     static bool first = TRUE;
1806
1807     DLG_TRACE(("# init_result\n"));
1808
1809     /* clear everything we do not save for the next widget */
1810     memset(&dialog_vars, 0, sizeof(dialog_vars));
1811
1812     dialog_vars.input_result = buffer;
1813     dialog_vars.input_result[0] = '\0';
1814
1815     dialog_vars.default_button = -1;
1816
1817     /*
1818      * The first time this is called, check for common options given by an
1819      * environment variable.
1820      */
1821     if (first) {
1822         char *env = dlg_getenv_str("DIALOGOPTS");
1823         if (env != 0)
1824             env = dlg_strclone(env);
1825         if (env != 0) {
1826             special_argv = dlg_string_to_argv(env);
1827             special_argc = dlg_count_argv(special_argv);
1828         }
1829         first = FALSE;
1830     }
1831
1832     if (special_argv != 0) {
1833         process_common_options(special_argc, special_argv, 0, FALSE);
1834     }
1835 }
1836
1837 int
1838 main(int argc, char *argv[])
1839 {
1840     char temp[256];
1841     bool esc_pressed = FALSE;
1842     bool keep_tite = FALSE;
1843     int initial = 1;
1844     int offset = 1;
1845     int offset_add = 0;
1846     int retval = DLG_EXIT_OK;
1847     int j;
1848     eOptions code;
1849     char my_buffer[MAX_LEN + 1];
1850
1851     memset(&dialog_state, 0, sizeof(dialog_state));
1852     memset(&dialog_vars, 0, sizeof(dialog_vars));
1853
1854 #if defined(ENABLE_NLS)
1855     /* initialize locale support */
1856     setlocale(LC_ALL, "");
1857     bindtextdomain(NLS_TEXTDOMAIN, LOCALEDIR);
1858     textdomain(NLS_TEXTDOMAIN);
1859 #elif defined(HAVE_SETLOCALE)
1860     (void) setlocale(LC_ALL, "");
1861 #endif
1862
1863     init_result(my_buffer);     /* honor $DIALOGOPTS */
1864     unescape_argv(&argc, &argv);
1865     program = argv[0];
1866     dialog_state.output = stderr;
1867     dialog_state.input = stdin;
1868
1869     /*
1870      * Look for the last --stdout, --stderr or --output-fd option, and use
1871      * that.  We can only write to one of them.  If --stdout is used, that
1872      * can interfere with initializing the curses library, so we want to
1873      * know explicitly if it is used.
1874      *
1875      * Also, look for any --version or --help message, processing those
1876      * immediately.
1877      */
1878     while (offset < argc) {
1879         int base = offset;
1880         switch (lookupOption(argv[offset], 7)) {
1881         case o_output_stdout:
1882             dialog_state.output = stdout;
1883             break;
1884         case o_output_stderr:
1885             dialog_state.output = stderr;
1886             break;
1887         case o_input_fd:
1888             if ((j = optionValue(argv, &offset)) < 0
1889                 || (dialog_state.input = fdopen(j, "r")) == 0) {
1890                 handle_leaks();
1891                 dlg_exiterr("Cannot open input-fd\n");
1892             }
1893             break;
1894         case o_output_fd:
1895             if ((j = optionValue(argv, &offset)) < 0
1896                 || (dialog_state.output = fdopen(j, "w")) == 0) {
1897                 handle_leaks();
1898                 dlg_exiterr("Cannot open output-fd\n");
1899             }
1900             break;
1901         case o_keep_tite:
1902             keep_tite = TRUE;
1903             break;
1904         case o_version:
1905             dialog_state.output = stdout;
1906             PrintVersion(dialog_state.output);
1907             dlg_exit(DLG_EXIT_OK);
1908             break;
1909         case o_help:
1910             Help();
1911             break;
1912 #ifdef HAVE_DLG_TRACE
1913         case o_trace:
1914             /*
1915              * Process/remove the --trace option if it is the first option.
1916              * Otherwise, process it in more/less expected order as a
1917              * "common" option.
1918              */
1919             if (base == 1) {
1920                 process_trace_option(argv, &offset);
1921                 break;
1922             } else {
1923                 ++offset;
1924                 continue;
1925             }
1926 #endif
1927         default:
1928             ++offset;
1929             continue;
1930         }
1931         DLG_TRACE(("# discarding %d parameters starting with argv[%d] (%s)\n",
1932                    1 + offset - base, base,
1933                    argv[base]));
1934         for (j = base; j < argc; ++j) {
1935             dialog_argv[j] = dialog_argv[j + 1 + (offset - base)];
1936         }
1937         argc -= (1 + offset - base);
1938         offset = base;
1939     }
1940     offset = 1;
1941     init_result(my_buffer);
1942     dialog_vars.keep_tite |= keep_tite;         /* init_result() cleared global */
1943
1944     /*
1945      * Dialog's output may be redirected (see above).  Handle the special
1946      * case of options that only report information without interaction.
1947      */
1948     if (argc == 2) {
1949         switch (code = lookupOption(argv[1], 7)) {
1950         case o_print_maxsize:
1951             (void) initscr();
1952             endwin();
1953             fflush(dialog_state.output);
1954             fprintf(dialog_state.output, "MaxSize: %d, %d\n", SLINES, SCOLS);
1955             break;
1956         case o_print_version:
1957             PrintVersion(dialog_state.output);
1958             break;
1959         case o_dlg_clear_screen:
1960             initscr();
1961             refresh();
1962             dlg_keep_tite((dialog_state.output == stdout) ? stderr : stdout);
1963             endwin();
1964             break;
1965         case o_ignore:
1966             break;
1967         default:
1968             Help();
1969             break;
1970         }
1971         dlg_exit(DLG_EXIT_OK);
1972     } else if (argc < 2) {
1973         Help();
1974     }
1975 #ifdef HAVE_RC_FILE
1976     else if (lookupOption(argv[1], 7) == o_create_rc) {
1977         if (argc != 3) {
1978             sprintf(temp, "Expected a filename for %.50s", argv[1]);
1979             Usage(temp);
1980         }
1981         if (dlg_parse_rc() == -1) {     /* Read the configuration file */
1982             handle_leaks();
1983             dlg_exiterr("dialog: dlg_parse_rc");
1984         }
1985         dlg_create_rc(argv[2]);
1986         dlg_exit(DLG_EXIT_OK);
1987     }
1988 #endif
1989     else {
1990         /*
1991          * Handle combinations of common options including --print-text-only
1992          * which can be done before involving curses, in case we can exit
1993          * without initializing curses (and writing to the terminal).
1994          */
1995         initial = process_common_options(argc, argv, offset, TRUE);
1996         if (initial >= argc)
1997             dlg_exit(DLG_EXIT_OK);
1998     }
1999
2000     init_dialog(dialog_state.input, dialog_state.output);
2001
2002     while (offset < argc && !esc_pressed) {
2003         int have;
2004         const Mode *modePtr;
2005
2006         init_result(my_buffer);
2007         offset = process_common_options(argc, argv, offset, offset > initial);
2008
2009         if (argv[offset] == NULL) {
2010             if (ignore_unknown)
2011                 break;
2012             Usage("Expected a box option");
2013         }
2014
2015         if (dialog_vars.separate_output) {
2016             switch (lookupOption(argv[offset], 2)) {
2017 #ifdef HAVE_XDIALOG2
2018             case o_buildlist:
2019             case o_treeview:
2020 #endif
2021             case o_checklist:
2022                 break;
2023             default:
2024                 sprintf(temp,
2025                         "Unexpected widget with --separate-output %.20s",
2026                         argv[offset]);
2027                 Usage(temp);
2028             }
2029         }
2030
2031         dlg_put_backtitle();
2032
2033         /* use a table to look for the requested mode, to avoid code duplication */
2034
2035         modePtr = 0;
2036         if ((code = lookupOption(argv[offset], 2)) != o_unknown)
2037             modePtr = lookupMode(code);
2038         if (modePtr == 0) {
2039             sprintf(temp, "%s option %.20s",
2040                     lookupOption(argv[offset], 7) != o_unknown
2041                     ? "Unexpected"
2042                     : "Unknown",
2043                     argv[offset]);
2044             Usage(temp);
2045         }
2046
2047         have = arg_rest(&argv[offset]);
2048         if (have < modePtr->argmin) {
2049             sprintf(temp, "Expected at least %d tokens for %.20s, have %d",
2050                     modePtr->argmin - 1, argv[offset],
2051                     have - 1);
2052             Usage(temp);
2053         }
2054         if (modePtr->argmax && have > modePtr->argmax) {
2055             sprintf(temp,
2056                     "Expected no more than %d tokens for %.20s, have %d",
2057                     modePtr->argmax - 1, argv[offset],
2058                     have - 1);
2059             Usage(temp);
2060         }
2061
2062         /*
2063          * Trim whitespace from non-title option values, e.g., the ones that
2064          * will be used as captions or prompts.   Do that only for the widget
2065          * we are about to process, since the "--trim" option is reset before
2066          * accumulating options for each widget.
2067          */
2068         for (j = offset + 1; j <= offset + have; j++) {
2069             switch (lookupOption(argv[j - 1], 7)) {
2070             case o_unknown:
2071             case o_title:
2072             case o_backtitle:
2073             case o_help_line:
2074             case o_help_file:
2075                 break;
2076             default:
2077                 if (argv[j] != 0) {
2078                     char *argv_j = strdup(argv[j]);
2079                     if (argv_j != 0) {
2080                         dlg_trim_string(argv_j);
2081                         argv[j] = argv_j;
2082                     } else {
2083                         argv[j] = strdup("?");
2084                     }
2085                     ignore_leak(argv[j]);
2086                 }
2087                 break;
2088             }
2089         }
2090
2091         DLG_TRACE(("# execute %s\n", argv[offset]));
2092         retval = show_result((*(modePtr->jumper)) (dialog_vars.title,
2093                                                    argv + offset,
2094                                                    &offset_add));
2095         DLG_TRACE(("# widget returns %d\n", retval));
2096         offset += offset_add;
2097
2098         if (dialog_vars.input_result != my_buffer) {
2099             free(dialog_vars.input_result);
2100             dialog_vars.input_result = 0;
2101         }
2102
2103         if (retval == DLG_EXIT_ESC) {
2104             esc_pressed = TRUE;
2105         } else {
2106
2107             if (dialog_vars.beep_after_signal)
2108                 (void) beep();
2109
2110             if (dialog_vars.sleep_secs)
2111                 (void) napms(dialog_vars.sleep_secs * 1000);
2112
2113             if (offset < argc) {
2114                 switch (lookupOption(argv[offset], 7)) {
2115                 case o_and_widget:
2116                     offset++;
2117                     break;
2118                 case o_unknown:
2119                     sprintf(temp, "Expected --and-widget, not %.20s",
2120                             argv[offset]);
2121                     Usage(temp);
2122                     break;
2123                 default:
2124                     /* if we got a cancel, etc., stop chaining */
2125                     if (retval != DLG_EXIT_OK)
2126                         esc_pressed = TRUE;
2127                     else
2128                         dialog_vars.dlg_clear_screen = TRUE;
2129                     break;
2130                 }
2131             }
2132             if (dialog_vars.dlg_clear_screen)
2133                 dlg_clear();
2134         }
2135     }
2136
2137     dlg_killall_bg(&retval);
2138     if (dialog_state.screen_initialized) {
2139         (void) refresh();
2140         end_dialog();
2141     }
2142     handle_leaks();
2143     dlg_exit(retval);
2144 }