contrib/dialog/dialog.c

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