contrib/dialog/dialog.c

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