home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / old / ckermit70 / ckucmd.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  155KB  |  5,595 lines

  1. #include "ckcsym.h"
  2. #define DOCHKVAR
  3.  
  4. char *cmdv = "Command package 7.0.121, 24 Dec 1999";
  5.  
  6. /*  C K U C M D  --  Interactive command package for Unix  */
  7.  
  8. /*
  9.   Author: Frank da Cruz (fdc@columbia.edu),
  10.   Columbia University Academic Information Systems, New York City.
  11.  
  12.   Copyright (C) 1985, 2000,
  13.     Trustees of Columbia University in the City of New York.
  14.     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  15.     copyright text in the ckcmai.c module for disclaimer and permissions.
  16. */
  17.  
  18. #ifdef OS2                    /* Command-terminal-to-C-Kermit character mask */
  19. int cmdmsk = 255;
  20. #else
  21. int cmdmsk = 127;
  22. #endif /* OS2 */
  23.  
  24. #ifdef BS_DIRSEP            /* Directory separator is backslash */
  25. #undef BS_DIRSEP
  26. #endif /* BS_DIRSEP */
  27.  
  28. #ifdef OS2
  29. #define BS_DIRSEP
  30. #endif /* BS_DIRSEP */
  31.  
  32. #define CKUCMD_C
  33.  
  34. #include "ckcdeb.h"                     /* Formats for debug(), etc. */
  35. #include "ckcker.h"            /* Needed for BIGBUFOK definition */
  36. #include "ckcnet.h"            /* Needed for server-side Telnet */
  37. #include "ckucmd.h"            /* Needed for xx_strp prototype */
  38. #include "ckuusr.h"                     /* Needed for prompt length */
  39.  
  40. #undef CKUCMD_C
  41.  
  42. _PROTOTYP( int unhex, (char) );
  43. _PROTOTYP( static VOID cmdclrscn, (void) );
  44.  
  45. struct keytab cmonths[] = {
  46.   { "april",     4, 0 },
  47.   { "august",    8, 0 },
  48.   { "december", 12, 0 },
  49.   { "february",  2, 0 },
  50.   { "january",   1, 0 },
  51.   { "july",      7, 0 },
  52.   { "june",      6, 0 },
  53.   { "march",     3, 0 },
  54.   { "may",       5, 0 },
  55.   { "november", 11, 0 },
  56.   { "october",  10, 0 },
  57.   { "september", 9, 0 }
  58. };
  59.  
  60. #ifndef NOICP     /* The rest only if interactive command parsing selected */
  61.  
  62. #ifndef NOSPL
  63. _PROTOTYP( int chkvar, (char *) );
  64. extern int askflag;
  65. #endif /* NOSPL */
  66.  
  67. int cmfldflgs = 0;            /* Flags for cmfld() */
  68. static int cmkwflgs = 0;        /* Flags from last keyword parse */
  69. static int blocklvl = 0;        /* Block nesting level */
  70. static int linebegin = 0;        /* Flag for at start of a line */
  71. static int quoting = 1;            /* Quoting is allowed */
  72. static int swarg = 0;            /* Parsing a switch argument */
  73. static int xcmfdb = 0;            /* Flag for parsing chained fdbs... */
  74. static int chsrc = 0;            /* Source of character, 1 = tty */
  75.  
  76. #ifdef BS_DIRSEP
  77. static int dirnamflg = 0;
  78. #endif /* BS_DIRSEP */
  79.  
  80. /*
  81. Modeled after the DECSYSTEM-20 command parser (the COMND JSYS), RIP. Features:
  82.  
  83. . parses and verifies keywords, filenames, text strings, numbers, other data
  84. . displays appropriate menu or help message when user types "?"
  85. . does keyword and filename completion when user types ESC or TAB
  86. . does partial filename completion
  87. . accepts any unique abbreviation for a keyword
  88. . allows keywords to have attributes, like "invisible" and "abbreviation"
  89. . can supply defaults for fields omitted by user
  90. . provides command retry and recall
  91. . provides command line editing (character, word, and line deletion)
  92. . accepts input from keyboard, command files, macros, or redirected stdin
  93. . allows for full or half duplex operation, character or line input
  94. . allows \-escapes for hard-to-type characters
  95. . allows specification of a user exit to expand variables, etc.
  96. . settable prompt, protected from deletion, dynamically re-evaluated each time.
  97. . allows chained parse functions.
  98.  
  99. Functions:
  100.  cmsetp - Set prompt (cmprom is prompt string)
  101.  cmsavp - Save current prompt
  102.  prompt - Issue prompt
  103.  cmini  - Clear the command buffer (before parsing a new command)
  104.  cmres  - Reset command buffer pointers (before reparsing)
  105.  cmkey  - Parse a keyword or token (also cmkey2)
  106.  cmswi  - Parse a switch
  107.  cmnum  - Parse a number
  108.  cmifi  - Parse an input file name
  109.  cmofi  - Parse an output file name (also cmifip, cmifi2, ...)
  110.  cmdir  - Parse a directory name (also cmdirp)
  111.  cmfld  - Parse an arbitrary field
  112.  cmtxt  - Parse a text string
  113.  cmdate - Parse a date-time string
  114.  cmcfm  - Parse command confirmation (end of line)
  115.  cmfdb  - Parse any of a list of the foregoing (chained parse functions)
  116.  
  117. Return codes:
  118.  -9: like -2 except this module already printed the error message
  119.  -3: no input provided when required
  120.  -2: input was invalid (e.g. not a number when a number was required)
  121.  -1: reparse required (user deleted into a preceding field)
  122.   0 or greater: success
  123. See individual functions for greater detail.
  124.  
  125. Before using these routines, the caller should #include ckucmd.h, and set the
  126. program's prompt by calling cmsetp().  If the file parsing functions cmifi,
  127. cmofi, or cmdir are to be used, this module must be linked with a ck?fio file
  128. system support module for the appropriate system, e.g. ckufio for Unix.  If
  129. the caller puts the terminal in character wakeup ("cbreak") mode with no echo,
  130. then these functions will provide line editing -- character, word, and line
  131. deletion, as well as keyword and filename completion upon ESC and help
  132. strings, keyword, or file menus upon '?'.  If the caller puts the terminal
  133. into character wakeup/noecho mode, care should be taken to restore it before
  134. exit from or interruption of the program.  If the character wakeup mode is not
  135. set, the system's own line editor may be used.
  136.  
  137. NOTE: Contrary to expectations, many #ifdef's have been added to this module.
  138. Any operation requiring an #ifdef (like clear screen, get character from
  139. keyboard, erase character from screen, etc) should eventually be turned into a
  140. call to a function that is defined in ck?tio.c, but then all the ck?tio.c
  141. modules would have to be changed...
  142. */
  143.  
  144. /* Includes */
  145.  
  146. #include "ckcker.h"
  147. #include "ckcasc.h"            /* ASCII character symbols */
  148. #include "ckucmd.h"                     /* Command parsing definitions */
  149.  
  150. #ifdef OSF13
  151. #ifdef CK_ANSIC
  152. #ifdef _NO_PROTO
  153. #undef _NO_PROTO
  154. #endif /* _NO_PROTO */
  155. #endif /* CK_ANSIC */
  156. #endif /* OSF13 */
  157.  
  158. #include <errno.h>            /* Error number symbols */
  159.  
  160. #ifdef OS2
  161. #ifndef NT
  162. #define INCL_NOPM
  163. #define INCL_VIO            /* Needed for ckocon.h */
  164. #include <os2.h>
  165. #undef COMMENT
  166. #else
  167. #define APIRET ULONG
  168. #include <windows.h>
  169. #endif /* NT */
  170. #include "ckocon.h"
  171. #include <io.h>
  172. #endif /* OS2 */
  173.  
  174. #ifdef NT
  175. #define stricmp _stricmp
  176. #endif /* NT */
  177.  
  178. #ifdef OSK
  179. #define cc ccount            /* OS-9/68K compiler bug */
  180. #endif /* OSK */
  181.  
  182. #ifdef GEMDOS                /* Atari ST */
  183. #ifdef putchar
  184. #undef putchar
  185. #endif /* putchar */
  186. #define putchar(x) conoc(x)
  187. #endif /* GEMDOS */
  188.  
  189. #ifdef CK_AUTODL
  190. extern int cmdadl, justone;
  191. #endif /* CK_AUTODL */
  192.  
  193. extern int timelimit, nzxopts;
  194.  
  195. #ifdef CKSYSLOG
  196. #ifdef UNIX
  197. #ifdef CKXPRINTF            /* Our printf macro conflicts with */
  198. #undef printf                /* use of "printf" in syslog.h */
  199. #endif /* CKXPRINTF */
  200. #include <syslog.h>
  201. #ifdef CKXPRINTF
  202. #define printf ckxprintf
  203. #endif /* CKXPRINTF */
  204. #endif /* UNIX */
  205. #endif /* CKSYSLOG */
  206.  
  207. /* Local variables */
  208.  
  209. static
  210. int psetf = 0,                          /* Flag that prompt has been set */
  211.     cc = 0,                             /* Character count */
  212.     dpx = 0,                            /* Duplex (0 = full) */
  213.     inword = 0;                /* In the middle of getting a word */
  214.  
  215. #ifdef OLDHELP
  216. static
  217. int hw = HLPLW,                         /* Help line width */
  218.     hc = HLPCW,                         /* Help line column width */
  219.     hh,                                 /* Current help column number */
  220.     hx;                                 /* Current help line position */
  221. #endif /* OLDHELP */
  222. char *dfprom = "Command? ";             /* Default prompt */
  223.  
  224. int cmflgs;                             /* Command flags */
  225. int cmfsav;                /* A saved version of them */
  226.  
  227. static char pushc = NUL;
  228. static char brkchar = NUL;
  229.  
  230. #define CMDEFAULT 1023
  231. static char cmdefault[CMDEFAULT+1];
  232.  
  233. #ifdef DCMDBUF
  234. char *cmdbuf = NULL;            /* Command buffer */
  235. char *savbuf = NULL;            /* Buffer to save copy of command */
  236. char *atmbuf = NULL;            /* Atom buffer - for current field */
  237. char *atxbuf = NULL;            /* For expanding the atom buffer */
  238. #ifdef OLDHELP
  239. static char *hlpbuf;            /* Help string buffer */
  240. #endif /* OLDHELP */
  241. static char *atybuf = NULL;        /* For copying atom buffer */
  242. static char *filbuf = NULL;        /* File name buffer */
  243. static char *cmprom = NULL;        /* Program's prompt */
  244. static char *cmprxx = NULL;        /* Program's prompt, unevaluated */
  245.  
  246. #ifdef CK_RECALL
  247. /*
  248.   Command recall is available only if we can make profligate use of malloc().
  249. */
  250. #define R_MAX 10            /* How many commands to save */
  251. int cm_recall = R_MAX;            /* Size of command recall buffer */
  252. int on_recall = 1;            /* Recall feature is ON */
  253. static int no_recall = 0;        /* Recall OFF for this cmd only */
  254. static int force_add = 0;        /* Force cmd into recall buffer */
  255. int in_recall = 0;            /* Recall buffers are init'd */
  256. static int
  257.   current = -1,                /* Pointer to current command */
  258.   rlast = -1;                /* Index of last command in buffer */
  259. static char **recall = NULL;        /* Array of recall buffer pointers */
  260. #endif /* CK_RECALL */
  261. #else
  262. char cmdbuf[CMDBL+4];                   /* Command buffer */
  263. char savbuf[CMDBL+4];                   /* Buffer to save copy of command */
  264. char atmbuf[ATMBL+4];                   /* Atom buffer */
  265. char atxbuf[CMDBL+4];                   /* For expanding the atom buffer */
  266. #ifdef OLDHELP
  267. static char hlpbuf[HLPBL+4];        /* Help string buffer */
  268. #endif /* OLDHELP */
  269. static char atybuf[ATMBL+4];        /* For copying atom buffer */
  270. static char filbuf[ATMBL+4];        /* File name buffer */
  271. static char cmprom[PROMPTL+1];        /* Program's prompt */
  272. static char cmprxx[PROMPTL+1];        /* Program's prompt, unevaluated */
  273. #endif /* DCMDBUF */
  274.  
  275. /* Command buffer pointers */
  276.  
  277. #define PPVLEN 24
  278. char ppvnambuf[PPVLEN+1] = { NUL, NUL };
  279.  
  280. char * cmbptr = NULL;            /* Current position (for export) */
  281.  
  282. static char *bp,                        /* Current command buffer position */
  283.     *pp,                                /* Start of current field */
  284.     *np;                                /* Start of next field */
  285.  
  286. static int ungw,            /* For ungetting words */
  287.     atxn;                /* Expansion buffer (atxbuf) length */
  288.  
  289. #ifdef OS2
  290. extern int wideresult;
  291. #endif /* OS2 */
  292.  
  293. extern int cmd_cols, cmd_rows, local, quiet;
  294.  
  295. #ifdef TNCODE
  296. #ifdef IAC
  297. #undef IAC
  298. #endif /* IAC */
  299. #define IAC 255
  300. #endif /* TNCODE */
  301.  
  302. #ifdef OLDHELP
  303. _PROTOTYP( static VOID addhlp, (char *) );
  304. _PROTOTYP( static VOID clrhlp, (void) );
  305. _PROTOTYP( static VOID dmphlp, (void) );
  306. #endif /* OLDHELP */
  307. _PROTOTYP( static int gtword, (int) );
  308. _PROTOTYP( static int addbuf, (char *) );
  309. _PROTOTYP( static int setatm, (char *, int) );
  310. _PROTOTYP( static VOID cmdnewl, (char) );
  311. _PROTOTYP( static VOID cmdchardel, (void) );
  312. _PROTOTYP( static VOID cmdecho, (char, int) );
  313. _PROTOTYP( static int test, (int, int) );
  314. #ifdef GEMDOS
  315. _PROTOTYP( extern char *strchr, (char *, int) );
  316. #endif /* GEMDOS */
  317.  
  318. extern char * dftty;
  319.  
  320. /* The following are for use with chained FDB's */
  321.  
  322. static int crflag = 0;            /* Carriage return was typed */
  323. static int qmflag = 0;            /* Question mark was typed */
  324. static int esflag = 0;            /* Escape was typed */
  325.  
  326. /* Directory separator */
  327.  
  328. #ifdef GEMDOS
  329. static char dirsep = '\\';
  330. #else
  331. #ifdef datageneral
  332. static char dirsep = ':';
  333. #else
  334. #ifdef MAC
  335. static char dirsep = ':';
  336. #else
  337. #ifdef VMS
  338. static char dirsep = '.';
  339. #else
  340. #ifdef STRATUS
  341. static char dirsep = '>';
  342. #else
  343. static char dirsep = '/';        /* UNIX, OS/2, OS-9, Amiga, etc. */
  344. #endif /* STRATUS */
  345. #endif /* VMS */
  346. #endif /* MAC */
  347. #endif /* datageneral */
  348. #endif /* GEMDOS */
  349.  
  350. /*  C K S P R E A D  --  Print string double-spaced  */
  351.  
  352. static char * sprptr = NULL;
  353.  
  354. static char *
  355. ckspread(s) char * s; {
  356.     int n = 0;
  357.     char * p;
  358.     n = strlen(s);
  359.     if (sprptr)
  360.       free(sprptr);
  361.     sprptr = malloc(n + n + 3);
  362.     if (sprptr) {
  363.     p = sprptr;
  364.     while (*s) {
  365.         *p++ = *s++;
  366.         *p++ = SP;
  367.     }
  368.     *p = NUL;
  369.     }
  370.     return(sprptr ? sprptr : "");
  371. }
  372.  
  373. /*  T E S T  --  Bit test  */
  374.  
  375. static int
  376. test(x,m) int x, m; { /*  Returns 1 if any bits from m are on in x, else 0  */
  377.     return((x & m) ? 1 : 0);
  378. }
  379.  
  380. /*  K W D H E L P  --  Given a keyword table, print keywords in columns.  */
  381. /*
  382.   Call with:
  383.     s     - keyword table
  384.     n     - number of entries
  385.     pat   - pattern (left substring) that must match for each keyword
  386.     pre   - prefix to add to each keyword
  387.     post  - suffix to add to each keyword
  388.     off   - offset on first screenful, allowing room for introductory text
  389.     xhlp  - 1 to print any CM_INV keywords that are not also abbreviations.
  390.             2 to print CM_INV keywords if CM_HLP also set
  391.             4 if it's a switch table (to show ':' if CM_ARG)
  392.  
  393.   Arranges keywords in columns with width based on longest keyword.
  394.   Does "more?" prompting at end of screen.
  395.   Uses global cmd_rows and cmd_cols for screen size.
  396. */
  397. VOID
  398. kwdhelp(s,n,pat,pre,post,off,xhlp)
  399.     struct keytab s[]; int n, off, xhlp; char *pat, *pre, *post;
  400. /* kwdhelp */ {
  401.  
  402.     int width = 0;
  403.     int cc;
  404.     int cols, height, i, j, k, lc, n2 = 0;
  405.     char *b = NULL, *p, *q;
  406.     char *pa, *px;
  407.     char **s2 = NULL;
  408.     char *tmpbuf = NULL;
  409.  
  410.     cc = strlen(pat);
  411.  
  412.     if (!s) return;            /* Nothing to do */
  413.     if (n < 1) return;            /* Ditto */
  414.     if (off < 0) off = 0;        /* Offset for first page */
  415.     if (!pre) pre = "";            /* Handle null string pointers */
  416.     if (!post) post = "";
  417.     lc = off;                /* Screen-line counter */
  418.  
  419.     if (xhlp & 4)            /* For switches */
  420.       tmpbuf = (char *)malloc(TMPBUFSIZ+1);
  421.  
  422.     if (s2 = (char **) malloc(n * sizeof(char *))) {
  423.     for (i = 0; i < n; i++) {    /* Find longest keyword */
  424.         s2[i] = NULL;
  425.         if (ckstrcmp(s[i].kwd,pat,cc,0))
  426.           continue;
  427.         if (s[i].flgs & CM_INV) {
  428. #ifdef COMMENT
  429. /* This code does not show invisible keywords at all except for "help ?" */
  430. /* and then only help topics (CM_HLP) in the top-level keyword list. */
  431.  
  432.         if ((xhlp & 2) == 0)
  433.           continue;
  434.         else if ((s[i].flgs & CM_HLP) == 0)
  435.           continue;
  436. #else
  437. /* This code shows invisible keywords that are not also abbreviations when */
  438. /* ? was typed AFTER the beginning of the field so the user can find out */
  439. /* what they are and (for example) why completion doesn't work at this point */
  440.  
  441.         if (s[i].flgs & CM_ABR)
  442.           continue;
  443.         else if ((xhlp & 3) == 0)
  444.           continue;
  445.         else if ((xhlp & 2) && ((s[i].flgs & CM_HLP) == 0))
  446.           continue;
  447. #endif /* COMMENT */
  448.         }
  449.         j = strlen(s[i].kwd);
  450.         if (!(xhlp & 4) || !tmpbuf) { /* Regular keyword table */
  451.         s2[n2++] = s[i].kwd;    /* Copy pointers to visible ones */
  452.         } else {            /* Switches */
  453.         sprintf(tmpbuf,        /* Make a copy that shows ":" if */
  454.             "%s%s",        /* the switch takes an argument. */
  455.             s[i].kwd,
  456.             (s[i].flgs & CM_ARG) ? ":" : ""
  457.             );
  458.         makestr(&(s2[n2]),tmpbuf);
  459.         if (s[i].flgs & CM_ARG) j++;
  460.         n2++;
  461.         }
  462.         if (j > width)
  463.           width = j;
  464.     }
  465.     /* Column width */
  466.     n = n2;
  467.     }
  468.     if (s2 && (b = (char *) malloc(cmd_cols + 1))) { /* Make a line buffer   */
  469.     char * bx;
  470.     bx = b + cmd_cols;
  471.     width += (int)strlen(pre) + (int)strlen(post) + 2;
  472.     cols = cmd_cols / width;    /* How many columns? */
  473.     if (cols < 1) cols = 1;
  474.     height = n / cols;        /* How long is each column? */
  475.     if (n % cols) height++;        /* Add one for remainder, if any */
  476.  
  477.     for (i = 0; i < height; i++) {        /* Loop for each row */
  478.         for (j = 0; j < cmd_cols; j++)  /* First fill row with blanks */
  479.           b[j] = SP;
  480.         for (j = 0; j < cols; j++) {    /* Loop for each column in row */
  481.         k = i + (j * height);       /* Index of next keyword */
  482.         if (k < n) {            /* In range? */
  483.             pa = pre;
  484.             px = post;
  485.             p = s2[k];            /* Point to verb name */
  486.             q = b + (j * width) + 1; /* Where to copy it to */
  487.             while ((q < bx) && (*q++ = *pa++)) ; /* Copy prefix */
  488.             q--;                         /* Back up over NUL */
  489.             while ((q < bx) && (*q++ = *p++)) ;     /* Copy filename */
  490.             q--;                         /* Back up over NUL */
  491.             while ((q < bx) && (*q++ = *px++)) ; /* Copy suffix */
  492.             if (j < cols - 1) {
  493.             q--;
  494.             *q = SP;    /* Replace the space */
  495.             }
  496.         }
  497.         }
  498.         p = b + cmd_cols - 1;    /* Last char in line */
  499.         while (*p-- == SP) ;    /* Trim */
  500.         *(p+2) = NUL;
  501.         printf("%s\n",b);        /* Print the line */
  502.         if (++lc > (cmd_rows - 2)) { /* Screen full? */
  503.         if (!askmore())        /* Do more-prompting... */
  504.           goto xkwdhelp;
  505.         else
  506.           lc = 0;
  507.         }
  508.     }
  509.     /* printf("\n"); */        /* Blank line at end of report */
  510.     } else {                /* Malloc failure, no columns */
  511.     for (i = 0; i < n; i++) {
  512.         if (s[i].flgs & CM_INV)    /* Use original keyword table */
  513.           continue;            /* skipping invisible entries */
  514.         printf("%s%s%s\n",pre,s[i].kwd,post);
  515.         if (++lc > (cmd_rows - 2)) { /* Screen full? */
  516.         if (!askmore())        /* Do more-prompting... */
  517.           goto xkwdhelp;
  518.         else
  519.           lc = 0;
  520.         }
  521.     }
  522.     }
  523.   xkwdhelp:
  524.     if (xhlp & 4) {
  525.     if (tmpbuf) free(tmpbuf);
  526.     for (i = 0; i < n; i++)
  527.       if (s2[i]) free(s2[i]);
  528.     }
  529.     if (s2) free(s2);            /* Free array copy */
  530.     if (b) free(b);            /* Free line buffer */
  531.     return;
  532. }
  533.  
  534. /*  F I L H E L P  --  Given a file list, print names in columns.  */
  535. /*
  536.   Call with:
  537.     n     - number of entries
  538.     pre   - prefix to add to each filename
  539.     post  - suffix to add to each filename
  540.     off   - offset on first screenful, allowing room for introductory text
  541.     cmdirflg - 1 if only directory names should be listed, 0 to list all files
  542.  
  543.   Arranges filenames in columns with width based on longest filename.
  544.   Does "more?" prompting at end of screen.
  545.   Uses global cmd_rows and cmd_cols for screen size.
  546. */
  547.  
  548. int
  549. filhelp(n,pre,post,off,cmdirflg) int n, off; char *pre, *post; int cmdirflg; {
  550.     char filbuf[CKMAXPATH + 1];        /* Temp buffer for one filename */
  551.     int width = 0;
  552.     int cols, height, i, j, k, lc, n2 = 0, rc = 0, itsadir = 0;
  553.     char *b = NULL, *p, *q;
  554.     char *pa, *px;
  555.     char **s2 = NULL;
  556. #ifdef VMS
  557.     char * cdp = zgtdir();
  558. #endif /* VMS */
  559.  
  560.     if (n < 1) return(0);
  561.     if (off < 0) off = 0;        /* Offset for first page */
  562.     if (!pre) pre = "";            /* Handle null string pointers */
  563.     if (!post) post = "";
  564.     lc = off;                /* Screen-line counter */
  565.  
  566.     if (s2 = (char **) malloc(n * sizeof(char *))) {
  567.     for (i = 0; i < n; i++) {    /* Loop through filenames */
  568.         itsadir = 0;
  569.         s2[i] = NULL;        /* Initialize each pointer to NULL */
  570.         znext(filbuf);        /* Get next filename */
  571.         if (!filbuf[0])        /* Shouldn't happen */
  572.           break;
  573. #ifdef COMMENT
  574.         itsadir = isdir(filbuf);    /* Is it a directory? */
  575.         if (cmdirflg && !itsadir)    /* No, listing directories only? */
  576.           continue;            /* So skip this one. */
  577. #endif /* COMMENT */
  578. #ifdef VMS
  579.         ckstrncpy(filbuf,zrelname(filbuf,cdp),CKMAXPATH);
  580. #endif /* VMS */
  581.         j = strlen(filbuf);
  582. #ifndef VMS
  583.         if (itsadir && j < CKMAXPATH - 1 && j > 0) {
  584.         if (filbuf[j-1] != dirsep) {
  585.             filbuf[j++] = dirsep;
  586.             filbuf[j] = NUL;
  587.         }
  588.         }
  589. #endif /* VMS */
  590.         if (!(s2[n2] = malloc(j+1))) {
  591.         printf("?Memory allocation failure\n");
  592.         rc = -9;
  593.         goto xfilhelp;
  594.         }
  595.         if (j <= CKMAXPATH) {
  596.         strcpy(s2[n2],filbuf);
  597.         n2++;
  598.         } else {
  599.         printf("?Name too long - %s\n", filbuf);
  600.         rc = -9;
  601.         goto xfilhelp;
  602.         }
  603.         if (j > width)        /* Get width of widest one */
  604.           width = j;
  605.     }
  606.     n = n2;                /* How many we actually got */
  607.     }
  608.     sh_sort(s2,NULL,n,0,0,filecase);    /* Alphabetize the list */
  609.  
  610.     rc = 1;
  611.     if (s2 && (b = (char *) malloc(cmd_cols + 1))) { /* Make a line buffer */
  612.     char * bx;
  613.     bx = b + cmd_cols;
  614.     width += (int)strlen(pre) + (int)strlen(post) + 2;
  615.     cols = cmd_cols / width;    /* How many columns? */
  616.     if (cols < 1) cols = 1;
  617.     height = n / cols;        /* How long is each column? */
  618.     if (n % cols) height++;        /* Add one for remainder, if any */
  619.  
  620.     for (i = 0; i < height; i++) {        /* Loop for each row */
  621.         for (j = 0; j < cmd_cols; j++)  /* First fill row with blanks */
  622.           b[j] = SP;
  623.         for (j = 0; j < cols; j++) {    /* Loop for each column in row */
  624.         k = i + (j * height);       /* Index of next filename */
  625.         if (k < n) {            /* In range? */
  626.             pa = pre;
  627.             px = post;
  628.             p = s2[k];                       /* Point to filename */
  629.             q = b + (j * width) + 1;             /* and destination */
  630.             while ((q < bx) && (*q++ = *pa++)) ; /* Copy prefix */
  631.             q--;                         /* Back up over NUL */
  632.             while ((q < bx) && (*q++ = *p++)) ;     /* Copy filename */
  633.             q--;                         /* Back up over NUL */
  634.             while ((q < bx) && (*q++ = *px++)) ; /* Copy suffix */
  635.             if (j < cols - 1) {
  636.             q--;
  637.             *q = SP;    /* Replace the space */
  638.             }
  639.         }
  640.         }
  641.         p = b + cmd_cols - 1;    /* Last char in line */
  642.         while (*p-- == SP) ;    /* Trim */
  643.         *(p+2) = NUL;
  644.         printf("%s\n",b);        /* Print the line */
  645.         if (++lc > (cmd_rows - 2)) { /* Screen full? */
  646.         if (!askmore()) {    /* Do more-prompting... */
  647.             rc = 0;
  648.             goto xfilhelp;
  649.         } else
  650.           lc = 0;
  651.         }
  652.     }
  653.     printf("\n");            /* Blank line at end of report */
  654.     goto xfilhelp;
  655.     } else {                /* Malloc failure, no columns */
  656.     for (i = 0; i < n; i++) {
  657.         znext(filbuf);
  658.         if (!filbuf[0]) break;
  659.         printf("%s%s%s\n",pre,filbuf,post);
  660.         if (++lc > (cmd_rows - 2)) { /* Screen full? */
  661.         if (!askmore()) {     /* Do more-prompting... */
  662.             rc = 0;
  663.             goto xfilhelp;
  664.         } else lc = 0;
  665.         }
  666.     }
  667. xfilhelp:
  668.     if (b) free(b);
  669.     for (i = 0; i < n2; i++)
  670.       if (s2[i]) free(s2[i]);
  671.     if (s2) free(s2);
  672.     return(rc);
  673.     }
  674. }
  675.  
  676. /*  C M S E T U P  --  Set up command buffers  */
  677.  
  678. #ifdef DCMDBUF
  679. int
  680. cmsetup() {
  681.     if (!(cmdbuf = malloc(CMDBL + 4))) return(-1);
  682.     if (!(savbuf = malloc(CMDBL + 4))) return(-1);
  683.     savbuf[0] = '\0';
  684. #ifdef OLDHELP
  685.     if (!(hlpbuf = malloc(HLPBL + 4))) return(-1);
  686. #endif /* OLDHELP */
  687.     if (!(atmbuf = malloc(ATMBL + 4))) return(-1);
  688.     if (!(atxbuf = malloc(CMDBL + 4))) return(-1);
  689.     if (!(atybuf = malloc(ATMBL + 4))) return(-1);
  690.     if (!(filbuf = malloc(ATMBL + 4))) return(-1);
  691.     if (!(cmprom = malloc(PROMPTL + 4))) return(-1);
  692.     if (!(cmprxx = malloc(PROMPTL + 4))) return(-1);
  693. #ifdef CK_RECALL
  694.     cmrini(cm_recall);
  695. #endif /* CK_RECALL */
  696.     return(0);
  697. }
  698. #endif /* DCMDBUF */
  699.  
  700. /*  C M S E T P  --  Set the program prompt.  */
  701.  
  702. VOID
  703. cmsetp(s) char *s; {
  704.     if (!s) s = "";
  705.     ckstrncpy(cmprxx,s,PROMPTL);
  706.     psetf = 1;                          /* Flag that prompt has been set. */
  707. }
  708.  
  709. /*  C M S A V P  --  Save a copy of the current prompt.  */
  710.  
  711. VOID
  712. #ifdef CK_ANSIC
  713. cmsavp(char s[], int n)
  714. #else
  715. cmsavp(s,n) char s[]; int n;
  716. #endif /* CK_ANSIC */
  717. /* cmsavp */ {
  718.     if (psetf)                /* But not if no prompt is set. */
  719.       ckstrncpy(s,cmprxx,n);
  720. }
  721.  
  722. int
  723. cmgbrk() {
  724.     return(brkchar);
  725. }
  726.  
  727. int
  728. cmgkwflgs() {
  729.     return(cmkwflgs);
  730. }
  731.  
  732. /*  P R O M P T  --  Issue the program prompt.  */
  733.  
  734. VOID
  735. prompt(f) xx_strp f; {
  736.     char *sx, *sy; int n;
  737. #ifdef CK_SSL
  738.     extern int ssl_active_flag, tls_active_flag;
  739. #endif /* CK_SSL */
  740. #ifdef OS2
  741.     extern int display_demo;
  742.  
  743.     /* If there is a demo screen to be displayed, display it */
  744.     if (display_demo && cmdsrc() == 0) {
  745.         demoscrn();
  746.         display_demo = 0;
  747.     }
  748. #endif /* OS2 */
  749.  
  750.     if (psetf == 0)            /* If no prompt set, set default. */
  751.       cmsetp(dfprom);
  752.  
  753.     sx = cmprxx;            /* Unevaluated copy */
  754.     if (f) {                /* If conversion function given */
  755.     sy = cmprom;            /* Evaluate it */
  756.     debug(F101,"prompt sx","",sx);
  757.     debug(F101,"prompt sy","",sy);
  758.     n = PROMPTL;
  759.     if ((*f)(sx,&sy,&n) < 0)    /* If evaluation failed */
  760.       sx = cmprxx;            /* revert to unevaluated copy */
  761.     else if (!*cmprom)        /* ditto if it came up empty */
  762.       sx = cmprxx;
  763.     else
  764.       sx = cmprom;
  765.     } else
  766.       ckstrncpy(cmprom,sx,PROMPTL);
  767.     cmprom[PROMPTL-1] = NUL;
  768.     if (!*sx)                /* Don't print if empty */
  769.       return;
  770.  
  771. #ifdef OSK
  772.     fputs(sx, stdout);
  773. #else
  774. #ifdef MAC
  775.     printf("%s", sx);
  776. #else
  777.     printf("\r%s",sx);            /* Print the prompt. */
  778. #ifdef CK_SSL
  779.     if (!(ssl_active_flag || tls_active_flag))
  780. #endif /* CK_SSL */
  781.       fflush(stdout);            /* Now! */
  782. #endif /* MAC */
  783. #endif /* OSK */
  784. }
  785.  
  786. #ifndef NOSPL
  787. VOID
  788. pushcmd(s) char * s; {            /* For use with IF command. */
  789.     if (!s) s = np;
  790.     ckstrncpy(savbuf,s,CMDBL);        /* Save the dependent clause,  */
  791.     cmres();                /* and clear the command buffer. */
  792.     debug(F110, "pushcmd savbuf", savbuf, 0);
  793. }
  794.  
  795. VOID
  796. pushqcmd(s) char * s; {            /* For use with ELSE command. */
  797.     char c, * p = savbuf;        /* Dest */
  798.     if (!s) s = np;            /* Source */
  799.     while (*s) {            /* Get first nonwhitespace char */
  800.     if (*s != SP)
  801.       break;
  802.     else
  803.       s++;
  804.     }
  805.     if (*s != '{') {            /* If it's not "{" */
  806.     pushcmd(s);            /* do regular pushcmd */
  807.     return;
  808.     }
  809.     while (c = *s++) {            /* Otherwise insert quotes */
  810.     if (c == CMDQ)
  811.       *p++ = CMDQ;
  812.     *p++ = c;
  813.     }
  814.     cmres();                /* and clear the command buffer. */
  815.     debug(F110, "pushqcmd savbuf", savbuf, 0);
  816. }
  817. #endif /* NOSPL */
  818.  
  819. #ifdef COMMENT
  820. /* no longer used... */
  821. VOID
  822. popcmd() {
  823.     ckstrncpy(cmdbuf,savbuf,CMDBL);    /* Put back the saved material */
  824.     *savbuf = '\0';            /* and clear the save buffer */
  825.     cmres();
  826. }
  827. #endif /* COMMENT */
  828.  
  829. /*  C M R E S  --  Reset pointers to beginning of command buffer.  */
  830.  
  831. VOID
  832. cmres() {
  833.     inword = 0;                /* We're not in a word */
  834.     cc = 0;                /* Character count is zero */
  835.  
  836. /* Initialize pointers */
  837.  
  838.     pp = cmdbuf;            /* Beginning of current field */
  839.     bp = cmdbuf;            /* Current position within buffer */
  840.     np = cmdbuf;            /* Where to start next field */
  841.  
  842.     cmfldflgs = 0;
  843.     cmflgs = -5;                        /* Parse not yet started. */
  844.     ungw = 0;                /* Don't need to unget a word. */
  845. }
  846.  
  847. /*  C M I N I  --  Clear the command and atom buffers, reset pointers.  */
  848.  
  849. /*
  850. The argument specifies who is to echo the user's typein --
  851.   1 means the cmd package echoes
  852.   0 somebody else (system, front end, terminal) echoes
  853. */
  854. VOID
  855. cmini(d) int d; {
  856. #ifdef DCMDBUF
  857.     if (!atmbuf)
  858.       if (cmsetup()<0)
  859.     fatal("fatal error: unable to allocate command buffers");
  860. #endif /* DCMDBUF */
  861. #ifdef USE_MEMCPY
  862.     memset(cmdbuf,0,CMDBL);
  863.     memset(atmbuf,0,ATMBL);
  864. #else
  865.     for (bp = cmdbuf; bp < cmdbuf+CMDBL; bp++) *bp = NUL;
  866.     for (bp = atmbuf; bp < atmbuf+ATMBL; bp++) *bp = NUL;
  867. #endif /* USE_MEMCPY */
  868.  
  869.     *atmbuf = *savbuf = *atxbuf = *atybuf = *filbuf = NUL;
  870. #ifdef OLDHELP
  871.     *hlpbuf = NUL;
  872. #endif /* OLDHELP */
  873.     blocklvl = 0;        /* Block level is 0 */
  874.     linebegin = 1;        /* And we're at the beginning of a line */
  875.     dpx = d;            /* Make a global copy of the echo flag */
  876.     debug(F101,"cmini dpx","",dpx);
  877.     crflag = 0;
  878.     qmflag = 0;
  879.     esflag = 0;
  880. #ifdef CK_RECALL
  881.     no_recall = 0;
  882. #endif /* CK_RECALL */
  883.     cmres();
  884. }
  885.  
  886. #ifndef NOSPL
  887. /* The following bits are to allow the command package to call itself */
  888. /* in the middle of a parse.  To do this, begin by calling cmpush, and */
  889. /* end by calling cmpop. */
  890.  
  891. #ifdef DCMDBUF
  892. struct cmp {
  893.     int i[5];                /* stack for integers */
  894.     char *c[3];                /* stack for pointers */
  895.     char *b[8];                /* stack for buffer contents */
  896. };
  897. struct cmp *cmp = 0;
  898. #else
  899. int cmp_i[CMDDEP+1][5];            /* Stack for integers */
  900. char *cmp_c[CMDDEP+1][5];        /* for misc pointers */
  901. char *cmp_b[CMDDEP+1][7];        /* for buffer contents pointers */
  902. #endif /* DCMDBUF */
  903.  
  904. int cmddep = -1;            /* Current stack depth */
  905.  
  906. int
  907. cmpush() {                /* Save the command environment */
  908.     char *cp;                /* Character pointer */
  909.  
  910.     if (cmddep >= CMDDEP)        /* Enter a new command depth */
  911.       return(-1);
  912.     cmddep++;
  913.     debug(F101,"&cmpush","",cmddep);
  914.  
  915. #ifdef DCMDBUF
  916.     /* allocate memory for cmp if not already done */
  917.     if (!cmp && !(cmp = (struct cmp *) malloc(sizeof(struct cmp)*(CMDDEP+1))))
  918.       fatal("cmpush: no memory for cmp");
  919.     cmp[cmddep].i[0] = cmflgs;        /* First do the global ints */
  920.     cmp[cmddep].i[1] = cmfsav;
  921.     cmp[cmddep].i[2] = atxn;
  922.     cmp[cmddep].i[3] = ungw;
  923.  
  924.     cmp[cmddep].c[0] = bp;        /* Then the global pointers */
  925.     cmp[cmddep].c[1] = pp;
  926.     cmp[cmddep].c[2] = np;
  927. #else
  928.     cmp_i[cmddep][0] = cmflgs;        /* First do the global ints */
  929.     cmp_i[cmddep][1] = cmfsav;
  930.     cmp_i[cmddep][2] = atxn;
  931.     cmp_i[cmddep][3] = ungw;
  932.  
  933.     cmp_c[cmddep][0] = bp;        /* Then the global pointers */
  934.     cmp_c[cmddep][1] = pp;
  935.     cmp_c[cmddep][2] = np;
  936. #endif /* DCMDBUF */
  937.  
  938.     /* Now the buffers themselves.  A lot of repititious code... */
  939.  
  940. #ifdef DCMDBUF
  941.     cp = malloc((int)strlen(cmdbuf)+1);    /* 0: Command buffer */
  942.     if (cp) strcpy(cp,cmdbuf);
  943.     cmp[cmddep].b[0] = cp;
  944.     if (cp == NULL) return(-1);
  945.  
  946.     cp = malloc((int)strlen(savbuf)+1);    /* 1: Save buffer */
  947.     if (cp) strcpy(cp,savbuf);
  948.     cmp[cmddep].b[1] = cp;
  949.     if (cp == NULL) return(-1);
  950.  
  951. #ifdef OLDHELP
  952.     cp = malloc((int)strlen(hlpbuf)+1);    /* 2: Help string buffer */
  953.     if (cp) strcpy(cp,hlpbuf);
  954.     cmp[cmddep].b[2] = cp;
  955.     if (cp == NULL) return(-1);
  956. #else
  957.     cmp[cmddep].b[2] = NULL;
  958. #endif /* OLDHELP */
  959.  
  960.     cp = malloc((int)strlen(atmbuf)+1);    /* 3: Atom buffer */
  961.     if (cp) strcpy(cp,atmbuf);
  962.     cmp[cmddep].b[3] = cp;
  963.     if (cp == NULL) return(-1);
  964.  
  965.     cp = malloc((int)strlen(atxbuf)+1);    /* 4: Expansion buffer */
  966.     if (cp) strcpy(cp,atxbuf);
  967.     cmp[cmddep].b[4] = cp;
  968.     if (cp == NULL) return(-1);
  969.  
  970.     cp = malloc((int)strlen(atybuf)+1);    /* 5: Atom buffer copy */
  971.     if (cp) strcpy(cp,atybuf);
  972.     cmp[cmddep].b[5] = cp;
  973.     if (cp == NULL) return(-1);
  974.  
  975.     cp = malloc((int)strlen(filbuf)+1);    /* 6: File name buffer */
  976.     if (cp) strcpy(cp,filbuf);
  977.     cmp[cmddep].b[6] = cp;
  978.     if (cp == NULL) return(-1);
  979. #else
  980.     cp = malloc((int)strlen(cmdbuf)+1);    /* 0: Command buffer */
  981.     if (cp) strcpy(cp,cmdbuf);
  982.     cmp_b[cmddep][0] = cp;
  983.     if (cp == NULL) return(-1);
  984.  
  985.     cp = malloc((int)strlen(savbuf)+1);    /* 1: Save buffer */
  986.     if (cp) strcpy(cp,savbuf);
  987.     cmp_b[cmddep][1] = cp;
  988.     if (cp == NULL) return(-1);
  989.  
  990. #ifdef OLDHELP
  991.     cp = malloc((int)strlen(hlpbuf)+1);    /* 2: Help string buffer */
  992.     if (cp) strcpy(cp,hlpbuf);
  993.     cmp_b[cmddep][2] = cp;
  994.     if (cp == NULL) return(-1);
  995. #else
  996.     cmp_b[cmddep][2] = NULL;
  997. #endif /* OLDHELP */
  998.  
  999.     cp = malloc((int)strlen(atmbuf)+1);    /* 3: Atom buffer */
  1000.     if (cp) strcpy(cp,atmbuf);
  1001.     cmp_b[cmddep][3] = cp;
  1002.     if (cp == NULL) return(-1);
  1003.  
  1004.     cp = malloc((int)strlen(atxbuf)+1);    /* 4: Expansion buffer */
  1005.     if (cp) strcpy(cp,atxbuf);
  1006.     cmp_b[cmddep][4] = cp;
  1007.     if (cp == NULL) return(-1);
  1008.  
  1009.     cp = malloc((int)strlen(atybuf)+1);    /* 5: Atom buffer copy */
  1010.     if (cp) strcpy(cp,atybuf);
  1011.     cmp_b[cmddep][5] = cp;
  1012.     if (cp == NULL) return(-1);
  1013.  
  1014.     cp = malloc((int)strlen(filbuf)+1);    /* 6: File name buffer */
  1015.     if (cp) strcpy(cp,filbuf);
  1016.     cmp_b[cmddep][6] = cp;
  1017.     if (cp == NULL) return(-1);
  1018. #endif /* DCMDBUF */
  1019.  
  1020.     cmini(dpx);                /* Initize the command parser */
  1021.     return(0);
  1022. }
  1023.  
  1024. int
  1025. cmpop() {                /* Restore the command environment */
  1026.     debug(F101,"&cmpop","",cmddep);
  1027.     if (cmddep < 0) return(-1);        /* Don't pop too much! */
  1028.  
  1029. #ifdef DCMDBUF
  1030.     cmflgs = cmp[cmddep].i[0];        /* First do the global ints */
  1031.     cmfsav = cmp[cmddep].i[1];
  1032.     atxn = cmp[cmddep].i[2];
  1033.     ungw = cmp[cmddep].i[3];
  1034.  
  1035.     bp = cmp[cmddep].c[0];        /* Then the global pointers */
  1036.     pp = cmp[cmddep].c[1];
  1037.     np = cmp[cmddep].c[2];
  1038. #else
  1039.     cmflgs = cmp_i[cmddep][0];        /* First do the global ints */
  1040.     cmfsav = cmp_i[cmddep][1];
  1041.     atxn = cmp_i[cmddep][2];
  1042.     ungw = cmp_i[cmddep][3];
  1043.  
  1044.     bp = cmp_c[cmddep][0];        /* Then the global pointers */
  1045.     pp = cmp_c[cmddep][1];
  1046.     np = cmp_c[cmddep][2];
  1047. #endif /* DCMDBUF */
  1048.  
  1049.     /* Now the buffers themselves. */
  1050.     /* Note: strncpy(), not ckstrncpy() -- Here we WANT the NUL padding... */
  1051.  
  1052. #ifdef DCMDBUF
  1053.     if (cmp[cmddep].b[0]) {
  1054.  
  1055.     strncpy(cmdbuf,cmp[cmddep].b[0],CMDBL); /* 0: Command buffer */
  1056.     free(cmp[cmddep].b[0]);
  1057.     cmp[cmddep].b[0] = NULL;
  1058.     }
  1059.     if (cmp[cmddep].b[1]) {
  1060.     strncpy(savbuf,cmp[cmddep].b[1],CMDBL); /* 1: Save buffer */
  1061.     free(cmp[cmddep].b[1]);
  1062.     cmp[cmddep].b[1] = NULL;
  1063.     }
  1064. #ifdef OLDHELP
  1065.     if (cmp[cmddep].b[2]) {
  1066.     strncpy(hlpbuf,cmp[cmddep].b[2],HLPBL); /* 2: Help buffer */
  1067.     free(cmp[cmddep].b[2]);
  1068.     cmp[cmddep].b[2] = NULL;
  1069.     }
  1070. #endif /* OLDHELP */
  1071.     if (cmp[cmddep].b[3]) {
  1072.     strncpy(atmbuf,cmp[cmddep].b[3],ATMBL); /* 3: Atomic buffer! */
  1073.     free(cmp[cmddep].b[3]);
  1074.     cmp[cmddep].b[3] = NULL;
  1075.     }
  1076.     if (cmp[cmddep].b[4]) {
  1077.     strncpy(atxbuf,cmp[cmddep].b[4],ATMBL); /* 4: eXpansion buffer */
  1078.     free(cmp[cmddep].b[4]);
  1079.     cmp[cmddep].b[4] = NULL;
  1080.     }
  1081.     if (cmp[cmddep].b[5]) {
  1082.     strncpy(atybuf,cmp[cmddep].b[5],ATMBL); /* 5: Atom buffer copY */
  1083.     free(cmp[cmddep].b[5]);
  1084.     cmp[cmddep].b[5] = NULL;
  1085.     }
  1086.     if (cmp[cmddep].b[6]) {
  1087.     strncpy(filbuf,cmp[cmddep].b[6],ATMBL); /* 6: Filename buffer */
  1088.     free(cmp[cmddep].b[6]);
  1089.     cmp[cmddep].b[6] = NULL;
  1090.     }
  1091. #else
  1092.     if (cmp_b[cmddep][0]) {
  1093.     strncpy(cmdbuf,cmp_b[cmddep][0],CMDBL); /* 0: Command buffer */
  1094.     free(cmp_b[cmddep][0]);
  1095.     cmp_b[cmddep][0] = NULL;
  1096.     }
  1097.     if (cmp_b[cmddep][1]) {
  1098.     strncpy(savbuf,cmp_b[cmddep][1],CMDBL); /* 1: Save buffer */
  1099.     free(cmp_b[cmddep][1]);
  1100.     cmp_b[cmddep][1] = NULL;
  1101.     }
  1102. #ifdef OLDHELP
  1103.     if (cmp_b[cmddep][2]) {
  1104.     strncpy(hlpbuf,cmp_b[cmddep][2],HLPBL); /* 2: Help buffer */
  1105.     free(cmp_b[cmddep][2]);
  1106.     cmp_b[cmddep][2] = NULL;
  1107.     }
  1108. #endif /* OLDHELP */
  1109.     if (cmp_b[cmddep][3]) {
  1110.     strncpy(atmbuf,cmp_b[cmddep][3],ATMBL); /* 3: Atomic buffer! */
  1111.     free(cmp_b[cmddep][3]);
  1112.     cmp_b[cmddep][3] = NULL;
  1113.     }
  1114.     if (cmp_b[cmddep][4]) {
  1115.     strncpy(atxbuf,cmp_b[cmddep][4],ATMBL); /* 4: eXpansion buffer */
  1116.     free(cmp_b[cmddep][4]);
  1117.     cmp_b[cmddep][4] = NULL;
  1118.     }
  1119.     if (cmp_b[cmddep][5]) {
  1120.     strncpy(atybuf,cmp_b[cmddep][5],ATMBL); /* 5: Atom buffer copY */
  1121.     free(cmp_b[cmddep][5]);
  1122.     cmp_b[cmddep][5] = NULL;
  1123.     }
  1124.     if (cmp_b[cmddep][6]) {
  1125.     strncpy(filbuf,cmp_b[cmddep][6],ATMBL); /* 6: Filename buffer */
  1126.     free(cmp_b[cmddep][6]);
  1127.     cmp_b[cmddep][6] = NULL;
  1128.     }
  1129. #endif /* DCMDBUF */
  1130.  
  1131.     cmddep--;                /* Rise, rise */
  1132.     debug(F101,"&cmpop","",cmddep);
  1133.     return(cmddep);
  1134. }
  1135. #endif /* NOSPL */
  1136.  
  1137. #ifdef COMMENT
  1138. VOID
  1139. stripq(s) char *s; {                    /* Function to strip '\' quotes */
  1140.     char *t;
  1141.     while (*s) {
  1142.         if (*s == CMDQ) {
  1143.             for (t = s; *t != '\0'; t++) *t = *(t+1);
  1144.         }
  1145.         s++;
  1146.     }
  1147. }
  1148. #endif /* COMMENT */
  1149.  
  1150. /* Convert tabs to spaces, one for one */
  1151. VOID
  1152. untab(s) char *s; {
  1153.     while (*s) {
  1154.     if (*s == HT) *s = SP;
  1155.     s++;
  1156.     }
  1157. }
  1158.  
  1159. /*  C M N U M  --  Parse a number in the indicated radix  */
  1160.  
  1161. /*
  1162.  The only radix allowed in unquoted numbers is 10.
  1163.  Parses unquoted numeric strings in base 10.
  1164.  Parses backslash-quoted numbers in the radix indicated by the quote:
  1165.    \nnn = \dnnn = decimal, \onnn = octal, \xnn = Hexadecimal.
  1166.  If these fail, then if a preprocessing function is supplied, that is applied
  1167.  and then a second attempt is made to parse an unquoted decimal string.
  1168.  And if that fails, the preprocessed string is passed to an arithmetic
  1169.  expression evaluator.
  1170.  
  1171.  Returns:
  1172.    -3 if no input present when required,
  1173.    -2 if user typed an illegal number,
  1174.    -1 if reparse needed,
  1175.     0 otherwise, with argument n set to the number that was parsed
  1176. */
  1177. int
  1178. cmnum(xhlp,xdef,radix,n,f) char *xhlp, *xdef; int radix, *n; xx_strp f; {
  1179.     int x; char *s, *zp, *zq;
  1180.     char lbrace, rbrace;
  1181.  
  1182.     if (!xhlp) xhlp = "";
  1183.     if (!xdef) xdef = "";
  1184.  
  1185.     if (cmfldflgs & 1) {
  1186.     lbrace = '(';
  1187.     rbrace = ')';
  1188.     } else {
  1189.     lbrace = '{';
  1190.     rbrace = '}';
  1191.     }
  1192.     if (radix != 10) {                  /* Just do base 10 */
  1193.         printf("cmnum: illegal radix - %d\n",radix);
  1194.         return(-1);
  1195.     } /* Easy to add others but there has never been a need for it. */
  1196.     x = cmfld(xhlp,xdef,&s,(xx_strp)0);
  1197.     debug(F101,"cmnum: cmfld","",x);
  1198.     if (x < 0) return(x);        /* Parse a field */
  1199.     zp = atmbuf;
  1200. /*
  1201.   Edit 192 - Allow any number field to be braced.  This lets us include
  1202.   spaces in expressions, but perhaps more important lets us have user-defined
  1203.   functions in numeric fields.
  1204. */
  1205.     if (*zp == lbrace) {        /* Braced field, strip braces */
  1206.     x = (int) strlen(atmbuf);
  1207.     if (x > 0) {            /* The "if" is to shut up optimizers */
  1208.         if (*(atmbuf+x-1) == rbrace) {
  1209.         *(atmbuf+x-1) = NUL;    /* that complain about a possible */
  1210.         zp++;            /* reference to atbmbuf[-1] even */
  1211.         }
  1212.     }                /* though we know that x > 0. */
  1213.     }
  1214.     if (chknum(zp)) {            /* Check for decimal number */
  1215.         *n = atoi(zp);            /* Got one, we're done. */
  1216.     debug(F101,"cmnum 1st chknum ok","",*n);
  1217.         return(0);
  1218.     } else if ((x = xxesc(&zp)) > -1) {    /* Check for backslash escape */
  1219.  
  1220. #ifndef OS2
  1221.     *n = x;
  1222. #else
  1223.     *n = wideresult;
  1224. #endif /* OS2 */
  1225.  
  1226.     debug(F101,"cmnum xxesc ok","",*n);
  1227.     return(*zp ? -2 : 0);
  1228.     } else if (f) {            /* If conversion function given */
  1229.     zq = atxbuf;            /* Try that */
  1230.     atxn = CMDBL;
  1231.     if ((*f)(zp,&zq,&atxn) < 0)    /* Convert */
  1232.       return(-2);
  1233.     zp = atxbuf;
  1234.     }
  1235.     debug(F110,"cmnum zp 1",zp,0);
  1236.     if (!*zp) zp = xdef;        /* Result empty, substitute default */
  1237.     debug(F110,"cmnum zp 2",zp,0);
  1238.     if (chknum(zp)) {            /* Check again for decimal number */
  1239.         *n = atoi(zp);            /* Got one, we're done. */
  1240.     debug(F101,"cmnum 2nd chknum ok","",*n);
  1241.         return(0);
  1242. #ifndef NOSPL
  1243.     }  else if ((x = xxesc(&zp)) > -1) { /* Check for backslash escape */
  1244. #ifndef OS2
  1245.     *n = x;
  1246. #else
  1247.     *n = wideresult;
  1248. #endif /* OS2 */
  1249.     debug(F101,"cmnum xxesc 2 ok","",*n);
  1250.     return(*zp ? -2 : 0);
  1251.     } else if (f) {            /* Not numeric, maybe an expression */
  1252.     char * p;
  1253.     p = evala(zp);
  1254.     if (chknum(p)) {
  1255.         *n = atoi(p);
  1256.         debug(F101,"cmnum exp eval ok","",*n);
  1257.         return(0);
  1258.     } else return(-2);
  1259. #endif /* NOSPL */
  1260.     } else {                /* Not numeric */
  1261.     return(-2);
  1262.     }
  1263. }
  1264.  
  1265. #ifdef CKCHANNELIO
  1266. extern int z_error;
  1267. #endif /* CKCHANNELIO */
  1268.  
  1269. /*  C M O F I  --  Parse the name of an output file  */
  1270.  
  1271. /*
  1272.  Depends on the external function zchko(); if zchko() not available, use
  1273.  cmfld() to parse output file names.
  1274.  
  1275.  Returns:
  1276.    -9 like -2, except message already printed,
  1277.    -3 if no input present when required,
  1278.    -2 if permission would be denied to create the file,
  1279.    -1 if reparse needed,
  1280.     0 or 1 if file can be created, with xp pointing to name.
  1281.     2 if given the name of an existing directory.
  1282. */
  1283. int
  1284. cmofi(xhlp,xdef,xp,f) char *xhlp, *xdef, **xp; xx_strp f; {
  1285.     int x; char *s, *zq;
  1286. #ifdef DOCHKVAR
  1287.     int tries;
  1288. #endif /* DOCHKVAR */
  1289. #ifdef DTILDE
  1290.     char *dirp;
  1291. #endif /* DTILDE */
  1292.  
  1293.     cmfldflgs = 0;
  1294.  
  1295.     if (!xhlp) xhlp = "";
  1296.     if (!xdef) xdef = "";
  1297.  
  1298.     if (*xhlp == NUL) xhlp = "Output file";
  1299.     *xp = "";
  1300.  
  1301.     x = cmfld(xhlp,xdef,&s,(xx_strp)0);
  1302.     debug(F111,"cmofi cmfld returns",s,x);
  1303.     if (x < 0)
  1304.       return(x);
  1305.  
  1306.     if (*s == '{') {            /* Strip enclosing braces */
  1307.     int n;
  1308.     n = strlen(s);
  1309.     if (s[n-1] == '}') {
  1310.         s[n-1] = NUL;
  1311.         s++;
  1312.     }
  1313.     }
  1314.     debug(F110,"cmofi 1.5",s,0);
  1315.  
  1316. #ifdef DOCHKVAR
  1317.     tries = 0;
  1318.     {
  1319.     char *p = s;
  1320.     /*
  1321.       This is really ugly.  If we skip conversion the first time through,
  1322.       then variable names like \%a will be used as filenames (e.g. creating
  1323.       a file called %A in the root directory).  If we DON'T skip conversion
  1324.       the first time through, then single backslashes used as directory
  1325.       separators in filenames will be misinterpreted as variable lead-ins.
  1326.       So we prescan to see if it has any variable references.  But this
  1327.       module is not supposed to know anything about variables, functions,
  1328.       etc, so this code does not really belong here, but rather it should
  1329.       be at the same level as zzstring().
  1330.     */
  1331. /*
  1332.   Hmmm, this looks a lot like chkvar() except it that includes \nnn number
  1333.   escapes.  But why?  This makes commands like "mkdir c:\123" impossible.
  1334.   And in fact, "mkdir c:\123" creates a directory called "c:{".  What's worse,
  1335.   rmdir(), which *does* call chkvar(), won't let us remove it.  So let's at
  1336.   least try making cmofi() symmetrical with cmifi()...
  1337. */
  1338. #ifdef COMMENT
  1339.     char * q;
  1340.     while ( (tries == 0) && (p = strchr(p,CMDQ)) ) {
  1341.         q = *(p+1);            /* Char after backslash */
  1342.         if (!q)            /* None, quit */
  1343.           break;
  1344.         if (isupper(q))        /* If letter, convert to lowercase */
  1345.           q = tolower(q);
  1346.         if (isdigit(q)) {        /* If it's a digit, */
  1347.         tries = 1;        /* assume it's a backslash code  */
  1348.         break;
  1349.         }
  1350.         switch (q) {
  1351.           case CMDQ:        /* Double backslash */
  1352.         tries = 1;        /* so call the conversion function */
  1353.         break;
  1354.           case '%':            /* Variable or array reference */
  1355.           case '&':            /* must be followed by letter */
  1356.         if (isalpha(*(p+2)) || (*(p+2) >= '0' && *(p+2) <= '9'))
  1357.           tries = 1;
  1358.         break;
  1359.           case 'm': case 'v': case '$': /* \m(), \v(), \$() */
  1360.         if (*(p+2) == '(')
  1361.           if (strchr(p+2,')'))
  1362.             tries = 1;
  1363.         break;
  1364.           case 'f':            /* \Fname() */
  1365.         if (strchr(p+2,'('))
  1366.           if (strchr(p+2,')'))
  1367.               tries = 1;
  1368.         break;
  1369.           case '{':            /* \{...} */
  1370.         if (strchr(p+2,'}'))
  1371.           tries = 1;
  1372.         break;
  1373.           case 'd': case 'o':    /* Decimal or Octal number */
  1374.             if (isdigit(*(p+2)))
  1375.           tries = 1;
  1376.         break;
  1377.           case 'x':            /* Hex number */
  1378.         if (isdigit(*(p+2)) ||
  1379.             ((*(p+2) >= 'a' && *(p+2) <= 'f') ||
  1380.              ((*(p+2) >= 'A' && *(p+2) <= 'F'))))
  1381.           tries = 1;
  1382.           default:
  1383.         break;
  1384.         }
  1385.         p++;
  1386.     }
  1387. #else
  1388. #ifndef NOSPL
  1389.     if (f) {            /* If a conversion function is given */
  1390.         char *s = p;        /* See if there are any variables in */
  1391.         while (*s) {        /* the string and if so, expand them */
  1392.         if (chkvar(s)) {
  1393.             tries = 1;
  1394.             break;
  1395.         }
  1396.         s++;
  1397.         }
  1398.     }
  1399. #endif /* NOSPL */
  1400. #endif /* COMMENT */
  1401.     }
  1402. #ifdef OS2
  1403. o_again:
  1404. #endif /* OS2 */
  1405.     if (tries == 1)
  1406. #endif /* DOCHKVAR */
  1407.     if (f) {                /* If a conversion function is given */
  1408.     zq = atxbuf;            /* do the conversion. */
  1409.     atxn = CMDBL;
  1410.     if ((x = (*f)(s,&zq,&atxn)) < 0)
  1411.       return(-2);
  1412.     s = atxbuf;
  1413.     if (!*s)            /* Result empty, substitute default */
  1414.       s = xdef;
  1415.     }
  1416.     debug(F111,"cmofi 2",s,x);
  1417.  
  1418. #ifdef DTILDE
  1419.     dirp = tilde_expand(s);        /* Expand tilde, if any, */
  1420.     if (*dirp != '\0') {        /* right in the atom buffer. */
  1421.     if (setatm(dirp,1) < 0) {
  1422.         printf("?Name too long\n");
  1423.         return(-9);
  1424.     }
  1425.     }
  1426.     s = atmbuf;
  1427.     debug(F110,"cmofi 3",s,0);
  1428. #endif /* DTILDE */
  1429.  
  1430.     if (iswild(s)) {
  1431.         printf("?Wildcards not allowed - %s\n",s);
  1432.         return(-2);
  1433.     }
  1434.     debug(F110,"cmofi 4",s,0);
  1435.  
  1436. #ifdef CK_TMPDIR
  1437.     /* isdir() function required for this! */
  1438.     if (isdir(s)) {
  1439.     debug(F110,"cmofi 5: is directory",s,0);
  1440.         *xp = s;
  1441.     return(2);
  1442.     }
  1443. #endif /* CK_TMPDIR */
  1444.  
  1445.     if (strcmp(s,CTTNAM) && (zchko(s) < 0)) { /* OK to write to console */
  1446. #ifdef COMMENT
  1447. #ifdef OS2
  1448. /*
  1449.   We don't try again because we already prescanned the string to see if
  1450.   if it contained anything that could be used by zzstring().
  1451. */
  1452.     if (tries++ < 1)
  1453.       goto o_again;
  1454. #endif /* OS2 */
  1455. #endif /* COMMENT */
  1456. /*
  1457.   Note: there are certain circumstances where zchko() can give a false
  1458.   positive, so don't rely on it to catch every conceivable situation in
  1459.   which the given output file can't be created.  In other words, we print
  1460.   a message and fail here if we KNOW the file can't be created.  If we
  1461.   succeed but the file can't be opened, the code that tries to open the file
  1462.   has to print a message.
  1463. */
  1464.     debug(F110,"cmofi 6: failure",s,0);
  1465.         printf("?Write permission denied - %s\n",s);
  1466. #ifdef CKCHANNELIO
  1467.     z_error = FX_ACC;
  1468. #endif /* CKCHANNELIO */
  1469.         return(-9);
  1470.     } else {
  1471.     debug(F110,"cmofi 7: ok",s,0);
  1472.         *xp = s;
  1473.         return(x);
  1474.     }
  1475. }
  1476.  
  1477. /*  C M I F I  --  Parse the name of an existing file  */
  1478.  
  1479. /*
  1480.  This function depends on the external functions:
  1481.    zchki()  - Check if input file exists and is readable.
  1482.    zxpand() - Expand a wild file specification into a list.
  1483.    znext()  - Return next file name from list.
  1484.  If these functions aren't available, then use cmfld() to parse filenames.
  1485. */
  1486. /*
  1487.  Returns
  1488.    -4 EOF
  1489.    -3 if no input present when required,
  1490.    -2 if file does not exist or is not readable,
  1491.    -1 if reparse needed,
  1492.     0 or 1 otherwise, with:
  1493.         xp pointing to name,
  1494.         wild = 1 if name contains '*' or '?', 0 otherwise.
  1495. */
  1496.  
  1497. /*
  1498.    C M I O F I  --  Parse an input file OR the name of a nonexistent file.
  1499.  
  1500.    Use this when an existing file is wanted (so we get help, completion, etc),
  1501.    but if a file of the given name does not exist, the name of a new file is
  1502.    accepted.  For example, with the EDIT command (edit an existing file, or
  1503.    create a new file).  Returns -9 if file does not exist.  It is up to the
  1504.    caller to check creatability.
  1505. */
  1506. static int nomsg = 0;
  1507. int
  1508. cmiofi(xhlp,xdef,xp,wild,f) char *xhlp, *xdef, **xp; int *wild; xx_strp f; {
  1509.     int msgsave, x;
  1510.     msgsave = nomsg;
  1511.     nomsg = 1;
  1512.     x = cmifi2(xhlp,xdef,xp,wild,0,NULL,f,0);
  1513.     nomsg = msgsave;
  1514.     return(x);
  1515. }
  1516.  
  1517. int
  1518. cmifi(xhlp,xdef,xp,wild,f) char *xhlp, *xdef, **xp; int *wild; xx_strp f; {
  1519.     return(cmifi2(xhlp,xdef,xp,wild,0,NULL,f,0));
  1520. }
  1521. /*
  1522.   cmifip() is called when we want to supply a path or path list to search
  1523.   in case the filename that the user gives is (a) not absolute, and (b) can't
  1524.   be found as given.  The path string can be the name of a single directory,
  1525.   or a list of directories separated by the PATHSEP character, defined in
  1526.   ckucmd.h.  Look in ckuusr.c and ckuus3.c for examples of usage.
  1527. */
  1528. int
  1529. cmifip(xhlp,xdef,xp,wild,d,path,f)
  1530.     char *xhlp,*xdef,**xp; int *wild, d; char * path; xx_strp f; {
  1531.     return(cmifi2(xhlp,xdef,xp,wild,0,path,f,0));
  1532. }
  1533.  
  1534. /*  C M D I R  --  Parse a directory name  */
  1535.  
  1536. /*
  1537.  This function depends on the external functions:
  1538.    isdir(s)  - Check if string s is the name of a directory
  1539.    zchki(s)  - Check if input file s exists and what type it is.
  1540.  If these functions aren't available, then use cmfld() to parse dir names.
  1541.  
  1542.  Returns
  1543.    -9 For all sorts of reasons, after printing appropriate error message.
  1544.    -4 EOF
  1545.    -3 if no input present when required,
  1546.    -2 if out of space or other internal error,
  1547.    -1 if reparse needed,
  1548.     0 or 1, with xp pointing to name, if directory specified,
  1549. */
  1550. int
  1551. cmdir(xhlp,xdef,xp,f) char *xhlp, *xdef, **xp; xx_strp f; {
  1552.     int wild;
  1553.     return(cmifi2(xhlp,xdef,xp,&wild,0,NULL,f,1));
  1554. }
  1555.  
  1556. /* Like CMDIR but includes PATH search */
  1557.  
  1558. int
  1559. cmdirp(xhlp,xdef,xp,path,f) char *xhlp, *xdef, **xp; char * path; xx_strp f; {
  1560.     int wild;
  1561.     return(cmifi2(xhlp,xdef,xp,&wild,0,path,f,1));
  1562. }
  1563.  
  1564. /*
  1565.   cmifi2() is the base filename parser called by cmifi, cmifip, cmdir, etc.
  1566.   Use it directly when you also want to parse a directory or device
  1567.   name as an input file, as in the DIRECTORY command.  Call with:
  1568.     xhlp  -- help message on ?
  1569.     xdef  -- default response
  1570.     xp    -- pointer to result (in our space, must be copied from here)
  1571.     wild  -- flag set upon return to indicate if filespec was wild
  1572.     d     -- 0 to parse files, 1 to parse files or directories
  1573.     path  -- search path for files
  1574.     f     -- pointer to string processing function (e.g. to evaluate variables)
  1575.     dirflg -- 1 to parse *only* directories, 0 otherwise
  1576. */
  1577. int
  1578. cmifi2(xhlp,xdef,xp,wild,d,path,f,dirflg)
  1579.     char *xhlp,*xdef,**xp; int *wild, d; char * path; xx_strp f; int dirflg; {
  1580.     extern int recursive, diractive;
  1581.     int i, x, itsadir, xc, expanded = 0, nfiles = 0;
  1582.     long y;
  1583.     char *sp = NULL, *zq, *np = NULL;
  1584.     char *sv = NULL, *p = NULL;
  1585. #ifdef DTILDE
  1586.     char *dirp;
  1587. #endif /* DTILDE */
  1588.  
  1589. #ifndef NOPARTIAL
  1590. #ifndef OS2
  1591. #ifdef OSK
  1592.     /* This large array is dynamic for OS-9 -- should do for others too... */
  1593.     extern char **mtchs;
  1594. #else
  1595. #ifdef UNIX
  1596.     /* OK, for UNIX too */
  1597.     extern char **mtchs;
  1598. #else
  1599. #ifdef VMS
  1600.     extern char **mtchs;
  1601. #else
  1602.     extern char *mtchs[];
  1603. #endif /* VMS */
  1604. #endif /* UNIX */
  1605. #endif /* OSK */
  1606. #endif /* OS2 */
  1607. #endif /* NOPARTIAL */
  1608.  
  1609.     if (!xhlp) xhlp = "";
  1610.     if (!xdef) xdef = "";
  1611.  
  1612.     cmfldflgs = 0;
  1613.     if (path)
  1614.       if (!*path)
  1615.     path = NULL;
  1616.     if (path) {                /* Make a copy we can poke */
  1617.     x = strlen(path);
  1618.     np = (char *) malloc(x + 1);
  1619.     if (np) {
  1620.         strcpy(np, path);
  1621.         path = sp = np;
  1622.     }
  1623.     }
  1624.     debug(F110,"cmifi2 path",path,0);
  1625.  
  1626.     ckstrncpy(cmdefault,xdef,CMDEFAULT);    /* Copy default */
  1627.     xdef = cmdefault;
  1628.  
  1629.     inword = 0;                /* Initialize counts & pointers */
  1630.     cc = 0;
  1631.     xc = 0;
  1632.     *xp = "";                /* Pointer to result string */
  1633.     if ((x = cmflgs) != 1) {            /* Already confirmed? */
  1634. #ifdef BS_DIRSEP
  1635.     dirnamflg = 1;
  1636.         x = gtword(0);            /* No, get a word */
  1637.     dirnamflg = 0;
  1638. #else
  1639.         x = gtword(0);                  /* No, get a word */
  1640. #endif /* BS_DIRSEP */
  1641.     } else {                /* If so, use default, if any. */
  1642.         if (setatm(xdef,1) < 0) {
  1643.         printf("?Default name too long\n");
  1644.         if (np) free(np);
  1645.         return(-9);
  1646.     }
  1647.     }
  1648.   i_path:
  1649.     *xp = atmbuf;                       /* Point to result. */
  1650.  
  1651.     while (1) {
  1652.         xc += cc;                       /* Count this character. */
  1653.         debug(F111,"cmifi gtword",atmbuf,xc);
  1654.     debug(F101,"cmifi switch x","",x);
  1655.         switch (x) {            /* x = gtword() return code */
  1656.       case -10:
  1657.         if (gtimer() > timelimit) {
  1658. #ifdef IKSD
  1659.                 extern int inserver;
  1660.                 if (inserver) {
  1661.                     printf("\r\nIKSD IDLE TIMEOUT: %d sec\r\n", timelimit);
  1662.                     doexit(GOOD_EXIT,0);
  1663.                 }
  1664. #endif /* IKSD */
  1665.         if (!quiet) printf("?Timed out\n");
  1666.         return(-10);
  1667.         } else {
  1668.         x = gtword(0);
  1669.         continue;
  1670.         }
  1671.       case -9:
  1672.         printf("Command or field too long\n");
  1673.       case -4:            /* EOF */
  1674.       case -2:            /* Out of space. */
  1675.       case -1:            /* Reparse needed */
  1676.         if (np) free(np);
  1677.         return(x);
  1678.       case 0:            /* SP or NL */
  1679.       case 1:
  1680.         if (xc == 0)        /* If no input... */
  1681.           *xp = xdef;        /* substitute the default */
  1682.         if (**xp == NUL) {        /* If field still empty return -3. */
  1683.         if (np) free(np);
  1684.         return(-3);
  1685.         }
  1686.         *xp = brstrip(*xp);        /* Strip braces */
  1687.         debug(F110,"cmifi brstrip",*xp,0);
  1688. #ifndef NOSPL
  1689.         if (f) {            /* If a conversion function is given */
  1690. #ifdef DOCHKVAR
  1691.         char *s = *xp;        /* See if there are any variables in */
  1692.         int x;
  1693.         while (*s) {        /* the string and if so, expand them */
  1694.             if (chkvar(s)) {
  1695. #endif /* DOCHKVAR */
  1696.             zq = atxbuf;
  1697.             atxn = CMDBL;
  1698.             if ((*f)(*xp,&zq,&atxn) < 0) {
  1699.                 if (np) free(np);
  1700.                 return(-2);
  1701.             }
  1702.             *xp = atxbuf;
  1703.             if (!atxbuf[0])
  1704.               *xp = xdef;
  1705. #ifdef DOCHKVAR
  1706.             break;
  1707.             }
  1708.             s++;
  1709.         }
  1710. #endif /* DOCHKVAR */
  1711.         }
  1712. #endif /* NOSPL */
  1713.  
  1714. #ifdef DTILDE
  1715.         dirp = tilde_expand(*xp);    /* Expand tilde, if any, */
  1716.         if (*dirp != '\0') {    /* in the atom buffer. */
  1717.         if (setatm(dirp,1) < 0) {
  1718.             printf("Expanded name too long\n");
  1719.             if (np) free(np);
  1720.             return(-9);
  1721.         }
  1722.         }
  1723.         *xp = atmbuf;
  1724. #endif /* DTILDE */
  1725.         debug(F110,"cmifi tilde_expand",*xp,0);
  1726.         if (!sv) {            /* Only do this once */
  1727.         sv = malloc((int)strlen(*xp)+1); /* Make a safe copy */
  1728.         if (!sv) {
  1729.             printf("?cmifi: malloc error\n");
  1730.             if (np) free(np);
  1731.             return(-9);
  1732.         }
  1733.         strcpy(sv,*xp);
  1734.         debug(F110,"cmifi sv",sv,0);
  1735.         }
  1736.  
  1737. /* This is to get around "cd /" failing because "too many directories match" */
  1738.  
  1739.         expanded = 0;        /* Didn't call zxpand */
  1740. #ifdef datageneral
  1741.         debug(F110,"cmifi isdir 1",*xp,0);
  1742.         {
  1743.         int y; char *s;
  1744.         s = *xp;
  1745.         y = strlen(s);
  1746.         if (y > 1 &&
  1747.             (s[y-1] == ':' ||
  1748.              s[y-1] == '^' ||
  1749.              s[y-1] == '=')
  1750.             )
  1751.           s[y-1] = NUL;
  1752.         }
  1753.         debug(F110,"cmifi isdir 2",*xp,0);
  1754. #endif /*  datageneral */
  1755.  
  1756. #ifdef VMS
  1757.         if (dirflg) {
  1758.         if (!strcmp(*xp,"..")) { /* For UNIXers... */
  1759.             setatm("-",0);
  1760.             *xp = atmbuf;
  1761.         } else if (!strcmp(*xp,".")) {
  1762.             setatm("[]",0);
  1763.             *xp = atmbuf;
  1764.         }
  1765.         }
  1766. #endif /* VMS */
  1767.         itsadir = isdir(*xp);    /* Is it a directory? */
  1768.         debug(F111,"cmifi itsadir",*xp,itsadir);
  1769. #ifdef VMS
  1770.         /* If they said "blah" where "blah.dir" is a directory... */
  1771.         /* change it to [.blah]. */
  1772.         if (!itsadir) {
  1773.         char tmpbuf[600];
  1774.         int flag = 0; char c, * p;
  1775.         p = *xp;
  1776.         while ((c = *p++) && !flag)
  1777.           if (ckstrchr(".[]:*?<>",c))
  1778.             flag = 1;
  1779.         debug(F111,"cmifi VMS dirname flag",*xp,flag);
  1780.         if (!flag) {
  1781.             sprintf(tmpbuf,"[.%s]",*xp);
  1782.             itsadir = isdir(tmpbuf);
  1783.             if (itsadir) {
  1784.             setatm(tmpbuf,0);
  1785.             *xp = atmbuf;
  1786.             }
  1787.             debug(F111,"cmifi VMS dirname flag itsadir",*xp,itsadir);
  1788.         }
  1789.         } else if (itsadir == 1 && *(xp[0]) == '.' && *(xp[1])) {
  1790.         char *p;
  1791.         if (p = malloc(cc + 4)) {
  1792.             sprintf(p,"[%s]",*xp);
  1793.             setatm(p,0);
  1794.             *xp = atmbuf;
  1795.             debug(F110,"cmdir .foo",*xp,0);
  1796.             free(p);
  1797.         }
  1798.         } else if (itsadir == 2 && !diractive) {
  1799.         int x;            /* [FOO]BAR.DIR instead of [FOO.BAR] */
  1800.         char *p;
  1801.         p = malloc(cc + 4);
  1802.         if (p) {
  1803.             x = cvtdir(*xp,p);    /* Convert to [FOO.BAR] */
  1804.             if (x > 0) {
  1805.             setatm(p,0);
  1806.             *xp = atmbuf;
  1807.             debug(F110,"cmdir cvtdir",*xp,0);
  1808.             }
  1809.             free(p);
  1810.         }
  1811.         }
  1812. #endif /* VMS */
  1813.  
  1814.         if (dirflg) {        /* Parsing a directory name? */
  1815.         /* Yes, does it contain wildcards? */
  1816.         if (iswild(*xp) ||
  1817.             diractive && (!strcmp(*xp,".")  || !strcmp(*xp,".."))
  1818.             ) {
  1819.             nzxopts = ZX_DIRONLY; /* Match only directory names */
  1820.             if (matchdot)  nzxopts |= ZX_MATCHDOT;
  1821.             if (recursive) nzxopts |= ZX_RECURSE;
  1822.             y = nzxpand(*xp,nzxopts);
  1823.             nfiles = y;
  1824.             expanded = 1;
  1825.         } else {
  1826. #ifdef VMS
  1827. /*
  1828.   This is to allow (e.g.) "cd foo", where FOO.DIR;1 is in the
  1829.   current directory.
  1830. */
  1831.             debug(F111,"cmdir itsadir",*xp,itsadir);
  1832.             if (!itsadir) {
  1833.             char *s;
  1834.             int n;
  1835.             s = *xp;
  1836.             n = strlen(s);
  1837.             if (n > 0 &&
  1838. #ifdef COMMENT
  1839.                 *s != '[' && s[n-1] != ']' &&
  1840.                 *s != '<' && s[n-1] != '>' &&
  1841. #else
  1842.                 ckindex("[",s,0,0,1) == 0 &&
  1843.                 ckindex("<",s,0,0,1) == 0 &&
  1844. #endif /* COMMENT */
  1845.                 s[n-1] != ':') {
  1846.                 char * dirbuf = NULL;
  1847.                 dirbuf = (char *)malloc(n+4);
  1848.                 if (dirbuf) {
  1849.                 if (*s == '.')
  1850.                   sprintf(dirbuf,"[%s]",s);
  1851.                 else
  1852.                   sprintf(dirbuf,"[.%s]",s);
  1853.                 itsadir = isdir(dirbuf);
  1854.                 debug(F111,"cmdir dirbuf",dirbuf,itsadir);
  1855.                 if (itsadir) {
  1856.                     setatm(dirbuf,0);
  1857.                     *xp = atmbuf;
  1858.                     debug(F110,"cmdir new *xp",*xp,0);
  1859.                 }
  1860.                 free(dirbuf);
  1861.                 }
  1862.  
  1863. /* This is to allow CDPATH to work in VMS... */
  1864.  
  1865.             } else if (n > 0) {
  1866.                 char * p; int i, j, k, d;
  1867.                 char rb[2] = "]";
  1868.                 if (p = malloc(x + 8)) {
  1869.                 strcpy(p,*xp);
  1870.                 i = ckindex(".",p,-1,1,1);
  1871.                 d = ckindex(".dir",p,0,0,0);
  1872.                 j = ckindex("]",p,-1,1,1);
  1873.                 if (j == 0) {
  1874.                     j = ckindex(">",p,-1,1,1);
  1875.                     rb[0] = '>';
  1876.                 }
  1877.                 k = ckindex(":",p,-1,1,1);
  1878.                 if (i < j || i < k) i = 0;
  1879.                 if (d < j || d < k) d = 0;
  1880.                 /* Change [FOO]BAR or [FOO]BAR.DIR */
  1881.                 /* to [FOO.BAR] */
  1882.                 if (j > 0 && j < n) {
  1883.                     p[j-1] = '.';
  1884.                     if (d > 0) p[d-1] = NUL;
  1885.                     strcat(p,rb);
  1886.                     debug(F110,"cmdir xxx",p,0);
  1887.                 }
  1888.                 itsadir = isdir(p);
  1889.                 debug(F111,"cmdir p",p,itsadir);
  1890.                 if (itsadir) {
  1891.                     setatm(p,0);
  1892.                     *xp = atmbuf;
  1893.                     debug(F110,"cmdir new *xp",*xp,0);
  1894.                 }
  1895.                 free(p);
  1896.                 }
  1897.             }
  1898.             }
  1899. #endif /* VMS */
  1900.             y = (!itsadir) ? 0 : 1;
  1901.             debug(F111,"cmifi y itsadir",*xp,y);
  1902.         }
  1903.         } else {            /* Parsing a filename. */
  1904.         debug(F110,"cmifi *xp pre-zxpand",*xp,0);
  1905. #ifndef COMMENT
  1906.         nzxopts = (d == 0) ? ZX_FILONLY : 0; /* So always expand. */
  1907.         if (matchdot)  nzxopts |= ZX_MATCHDOT;
  1908.         if (recursive) nzxopts |= ZX_RECURSE;
  1909.         y = nzxpand(*xp,nzxopts);
  1910. #else
  1911. /* Here we're trying to fix a problem in which a directory name is accepted */
  1912. /* as a filename, but this breaks too many other things. */
  1913.         nzxopts = 0;
  1914.         if (!d) {
  1915.             if (itsadir & !iswild(*xp)) {
  1916.             debug(F100,"cmifi dir when filonly","",0);
  1917.             printf("?Not a regular file: \"%s\"\n",*xp);
  1918.             if (sv) free(sv);
  1919.             if (np) free(np);
  1920.             return(-9);
  1921.             } else {
  1922.             nzxopts = ZX_FILONLY;
  1923.             if (matchdot)  nzxopts |= ZX_MATCHDOT;
  1924.             if (recursive) nzxopts |= ZX_RECURSE;
  1925.             y = nzxpand(*xp,nzxopts);
  1926.             }
  1927.         }
  1928. #endif /* COMMENT */
  1929.         nfiles = y;
  1930.         debug(F111,"cmifi y nzxpand",*xp,y);
  1931.         debug(F111,"cmifi y atmbuf",atmbuf,itsadir);
  1932.         expanded = 1;
  1933.         }
  1934.         /* domydir() calls zxrewind() so we MUST call nzxpand() here */
  1935.         if (!expanded && diractive) {
  1936.         debug(F110,"cmifi diractive catch-all zxpand",*xp,0);
  1937.         nzxopts = (d == 0) ? ZX_FILONLY : (dirflg ? ZX_DIRONLY : 0);
  1938.         if (matchdot)  nzxopts |= ZX_MATCHDOT;
  1939.         if (recursive) nzxopts |= ZX_RECURSE;
  1940.         y = nzxpand(*xp,nzxopts);
  1941.         nfiles = y;
  1942.         expanded = 1;
  1943.         }
  1944.         *wild = (iswild(sv) || (y > 1)) && (itsadir == 0);
  1945.  
  1946. #ifdef RECURSIVE
  1947.         if (!*wild) *wild = recursive;
  1948. #endif /* RECURSIVE */
  1949.  
  1950.         debug(F111,"cmifi sv wild",sv,*wild);
  1951.         if (dirflg && *wild && !diractive) {
  1952.         printf("?Wildcard matches more than one directory\n");
  1953.         if (sv) free(sv);
  1954.         if (np) free(np);
  1955.         return(-9);
  1956.         }
  1957.         if (itsadir && d && !dirflg) { /* It's a directory and not wild */
  1958.         if (sv) free(sv);    /* and it's ok to parse directories */
  1959.         if (np) free(np);
  1960.         return(x);
  1961.         }
  1962.         if (y == 0) {
  1963.         if (path && !isabsolute(sv)) {
  1964.             char * ptr = path;
  1965.             char c;
  1966.             while (1) {
  1967.             c = *ptr;
  1968.             if (c == PATHSEP || c == NUL) {
  1969.                 if (!*path) {
  1970.                 path = NULL;
  1971.                 break;
  1972.                 }
  1973.                 *ptr = NUL;
  1974. #ifdef UNIX
  1975. /* By definition of CDPATH, an empty member denotes the current directory */
  1976.                 if (!*path)
  1977.                   strcpy(atmbuf,".");
  1978.                 else
  1979. #endif /* UNIX */
  1980.                   strncpy(atmbuf,path,ATMBL);
  1981. #ifdef VMS
  1982.                 atmbuf[ATMBL] = NUL;
  1983. /* If we have a logical name, evaluate it recursively */
  1984.                 if (*(ptr-1) == ':') { /* Logical name ends in : */
  1985.                 char *p; int n;
  1986.                 while (((n = strlen(atmbuf))  > 0) &&
  1987.                        atmbuf[n-1] == ':') {
  1988.                     atmbuf[n-1] = NUL;
  1989.                     for (p = atmbuf; *p; p++)
  1990.                       if (islower(*p)) *p = toupper(*p);
  1991.                     debug(F111,"cmdir CDPATH LN 1",atmbuf,n);
  1992.                     p = getenv(atmbuf);
  1993.                     debug(F110,"cmdir CDPATH LN 2",p,0);
  1994.                     if (!p)
  1995.                       break;
  1996.                     strncpy(atmbuf,p,ATMBL);
  1997.                     atmbuf[ATMBL] = NUL;
  1998.                 }
  1999.                 }
  2000. #else
  2001. #ifdef OS2
  2002.                 if (*(ptr-1) != '\\' && *(ptr-1) != '/')
  2003.                   strcat(atmbuf,"\\");
  2004. #else
  2005. #ifdef UNIX
  2006.                 if (*(ptr-1) != '/')
  2007.                   strcat(atmbuf,"/");
  2008. #else
  2009. #ifdef datageneral
  2010.                 if (*(ptr-1) != ':')
  2011.                   strcat(atmbuf,":");
  2012. #endif /* datageneral */
  2013. #endif /* UNIX */
  2014. #endif /* OS2 */
  2015. #endif /* VMS */
  2016.                 strcat(atmbuf,sv);
  2017.                 debug(F110,"cmifip add path",atmbuf,0);
  2018.                 if (c == PATHSEP) ptr++;
  2019.                 path = ptr;
  2020.                 break;
  2021.             }
  2022.             ptr++;
  2023.             }
  2024.             x = 1;
  2025.             inword = 0;
  2026.             cc = 0;
  2027.             xc = (int) strlen(atmbuf);
  2028.             *xp = "";
  2029.             goto i_path;
  2030.         }
  2031.         if (d) {
  2032.             if (sv) free(sv);
  2033.             if (np) free(np);
  2034.             return(-2);
  2035.         } else {
  2036.             if (!nomsg)
  2037.               printf("?No %s match - %s\n",
  2038.                  dirflg ? "directories" : "files", sv);
  2039.             if (sv) free(sv);
  2040.             if (np) free(np);
  2041.             return(-9);
  2042.         }
  2043.         } else if (y < 0) {
  2044.         printf("?Too many %s match - %s\n",
  2045.                dirflg ? "directories" : "files", sv);
  2046.         if (sv) free(sv);
  2047.         if (np) free(np);
  2048.         return(-9);
  2049.         } else if (*wild || y > 1) {
  2050.         if (sv) free(sv);
  2051.         if (np) free(np);
  2052.         return(x);
  2053.         }
  2054.  
  2055.         /* If not wild, see if it exists and is readable. */
  2056.  
  2057.         debug(F111,"cmifi sv not wild",sv,*wild);
  2058.  
  2059.         if (expanded)
  2060.           znext(*xp);        /* Get first (only?) matching file */
  2061.         if (dirflg)            /* Maybe wild and expanded */
  2062.           itsadir = isdir(*xp);    /* so do this again. */
  2063.         y = dirflg ? itsadir : zchki(*xp); /* Now check accessibility */
  2064.         if (expanded) {
  2065. #ifdef ZXREWIND
  2066.         nfiles = zxrewind();    /* Rewind so next znext() gets 1st */
  2067. #else
  2068.  
  2069.         nzxopts = dirflg ? ZX_DIRONLY : 0;
  2070.         if (matchdot)  nzxopts |= ZX_MATCHDOT;
  2071.         if (recursive) nzxopts |= ZX_RECURSE;
  2072.         nfiles = nzxpand(*xp,nzxopts);
  2073. #endif /* ZXREWIND */
  2074.         }
  2075.         debug(F111,"cmifi nfiles",*xp,nfiles);
  2076.         free(sv);            /* done with this */
  2077.         sv = NULL;
  2078.         if (dirflg && y == 0) {
  2079.         printf("?Not a directory - %s\n",*xp);
  2080. #ifdef CKCHANNELIO
  2081.         z_error = FX_ACC;
  2082. #endif /* CKCHANNELIO */
  2083.         return(-9);
  2084.         } else if (y == -3) {
  2085.         if (!xcmfdb) {
  2086.             if (diractive)
  2087.               /* Don't show filename if we're not allowed to see it */
  2088.               printf("?Read permission denied\n");
  2089.             else
  2090.               printf("?Read permission denied - %s\n",*xp);
  2091.         }
  2092.         if (np) free(np);
  2093. #ifdef CKCHANNELIO
  2094.         z_error = FX_ACC;
  2095. #endif /* CKCHANNELIO */
  2096.         return(xcmfdb ? -6 : -9);
  2097.         } else if (y == -2) {
  2098.         if (!recursive) {
  2099.             if (np) free(np);
  2100.             if (d) return(0);
  2101.             if (!xcmfdb)
  2102.               printf("?File not readable - %s\n",*xp);
  2103. #ifdef CKCHANNELIO
  2104.             z_error = FX_ACC;
  2105. #endif /* CKCHANNELIO */
  2106.             return(xcmfdb ? -6 : -9);
  2107.         }
  2108.         } else if (y < 0) {
  2109.         if (np) free(np);
  2110.         if (!nomsg && !xcmfdb)
  2111.           printf("?File not found - %s\n",*xp);
  2112. #ifdef CKCHANNELIO
  2113.         z_error = FX_FNF;
  2114. #endif /* CKCHANNELIO */
  2115.         return(xcmfdb ? -6 : -9);
  2116.         }
  2117.         if (np) free(np);
  2118.         return(x);
  2119.  
  2120. #ifndef MAC
  2121.       case 2:            /* ESC */
  2122.         debug(F101,"cmifi esc, xc","",xc);
  2123.         if (xc == 0) {
  2124.         if (*xdef) {
  2125.             printf("%s ",xdef); /* If at beginning of field */
  2126. #ifdef GEMDOS
  2127.             fflush(stdout);
  2128. #endif /* GEMDOS */
  2129.             inword = cmflgs = 0;
  2130.             addbuf(xdef);    /* Supply default. */
  2131.             if (setatm(xdef,0) < 0) {
  2132.             printf("Default name too long\n");
  2133.             if (np) free(np);
  2134.             return(-9);
  2135.             }
  2136.         } else {        /* No default */
  2137.             bleep(BP_WARN);
  2138.         }
  2139.         break;
  2140.         }
  2141. #ifndef NOSPL
  2142.         if (f) {            /* If a conversion function is given */
  2143. #ifdef DOCHKVAR
  2144.         char *s = *xp;        /* See if there are any variables in */
  2145.         while (*s) {        /* the string and if so, expand it.  */
  2146.             if (chkvar(s)) {
  2147. #endif /* DOCHKVAR */
  2148.             zq = atxbuf;
  2149.             atxn = CMDBL;
  2150.             if ((x = (*f)(*xp,&zq,&atxn)) < 0) {
  2151.                 if (np) free(np);
  2152.                 return(-2);
  2153.             }
  2154. #ifdef DOCHKVAR
  2155.             /* reduce cc by number of \\ consumed by conversion */
  2156.             /* function (needed for OS/2, where \ is path separator) */
  2157.             cc -= (strlen(*xp) - strlen(atxbuf));
  2158. #endif /* DOCHKVAR */
  2159.             *xp = atxbuf;
  2160.             if (!atxbuf[0]) { /* Result empty, use default */
  2161.                 *xp = xdef;
  2162.                 cc = strlen(xdef);
  2163.             }
  2164. #ifdef DOCHKVAR
  2165.             break;
  2166.             }
  2167.             s++;
  2168.         }
  2169. #endif /* DOCHKVAR */
  2170.         }
  2171. #endif /* NOSPL */
  2172. #ifdef DTILDE
  2173.         dirp = tilde_expand(*xp);    /* Expand tilde, if any, */
  2174.         if (*dirp != '\0') {    /* in the atom buffer. */
  2175.         if (setatm(dirp,0) < 0) {
  2176.             printf("Expanded name too long\n");
  2177.             if (np) free(np);
  2178.             return(-9);
  2179.         }
  2180.         }
  2181.         *xp = atmbuf;
  2182. #endif /* DTILDE */
  2183.         sp = *xp + cc;
  2184. #ifdef UNIXOROSK
  2185.         if (!strcmp(atmbuf,"..")) {
  2186.         printf(" ");
  2187.         strcat(cmdbuf," ");
  2188.         cc++;
  2189.         bp++;
  2190.         *wild = 0;
  2191.         *xp = atmbuf;
  2192.         break;
  2193.         } else if (!strcmp(atmbuf,".")) {
  2194.         bleep(BP_WARN);
  2195.         if (np) free(np);
  2196.         return(-1);
  2197.         } else {
  2198.         /* This patches a glitch when user types "./foo<ESC>" */
  2199.         /* in which the next two chars are omitted from the */
  2200.         /* expansion.  There should be a better fix, however, */
  2201.         /* since there is no problem with "../foo<ESC>". */
  2202.         char *p = *xp;
  2203.         if (*p == '.' && *(p+1) == '/')
  2204.           cc -= 2;
  2205.         }
  2206. #endif /* UNIXOROSK */
  2207.  
  2208. #ifdef datageneral
  2209.         *sp++ = '+';        /* Data General AOS wildcard */
  2210. #else
  2211.         *sp++ = '*';        /* Others */
  2212. #endif /* datageneral */
  2213.         *sp-- = '\0';
  2214. #ifdef GEMDOS
  2215.         if (!strchr(*xp, '.'))    /* abde.e -> abcde.e* */
  2216.           strcat(*xp, ".*");    /* abc -> abc*.* */
  2217. #endif /* GEMDOS */
  2218.         /* Add wildcard and expand list. */
  2219. #ifdef COMMENT
  2220.         /* This kills partial completion when ESC given in path segment */
  2221.         nzxopts = dirflg ? ZX_DIRONLY : (d ? 0 : ZX_FILONLY);
  2222. #else
  2223.         nzxopts = 0;
  2224. #endif /* COMMENT */
  2225.         if (matchdot)  nzxopts |= ZX_MATCHDOT;
  2226.         if (recursive) nzxopts |= ZX_RECURSE;
  2227.         y = nzxpand(*xp,nzxopts);
  2228.         nfiles = y;
  2229.         debug(F111,"cmifi nzxpand",*xp,y);
  2230.         if (y > 0) {
  2231. #ifdef OS2
  2232.                 znext(filbuf);        /* Get first */
  2233. #ifdef ZXREWIND
  2234.         zxrewind();        /* Must "rewind" */
  2235. #else
  2236.         nzxpand(*xp,nxzopts);
  2237. #endif /* ZXREWIND */
  2238. #else  /* Not OS2 */
  2239.                 ckstrncpy(filbuf,mtchs[0],CKMAXPATH);
  2240. #endif /* OS2 */
  2241.         } else
  2242.           *filbuf = '\0';
  2243.         filbuf[CKMAXPATH] = NUL;
  2244.         debug(F111,"cmifi filbuf",filbuf,y);
  2245.         *sp = '\0';            /* Remove wildcard. */
  2246.         *wild = (y > 1);
  2247.         if (y == 0) {
  2248.         if (!nomsg) {
  2249.             printf("?No %s match - %s\n",
  2250.                dirflg ? "directories" : "files", atmbuf);
  2251.             if (np) free(np);
  2252.             return(-9);
  2253.         } else {
  2254.             bleep(BP_WARN);
  2255.             if (np) free(np);
  2256.             return(-1);
  2257.         }
  2258.         } else if (y < 0) {
  2259.         printf("?Too many %s match - %s\n",
  2260.                dirflg ? "directories" : "files", atmbuf);
  2261.         if (np) free(np);
  2262.         return(-9);
  2263.         } else if (y > 1) {     /* Not unique. */
  2264. #ifndef NOPARTIAL
  2265. /* Partial filename completion */
  2266.         int j, k; char c;
  2267.         k = 0;
  2268.         debug(F111,"cmifi partial",filbuf,cc);
  2269. #ifdef OS2
  2270.         {
  2271.             int cur = 0,
  2272.             len = 0,
  2273.             len2 = 0,
  2274.             min = strlen(filbuf);
  2275.             char localfn[CKMAXPATH+1];
  2276.  
  2277.             len = min;
  2278.             for (j = 1; j <= y; j++) {
  2279.             znext(localfn);
  2280.             if (dirflg && !isdir(localfn))
  2281.               continue;
  2282.             len2 = strlen(localfn);
  2283.             for (cur = cc;
  2284.                  cur < len && cur < len2 && cur <= min;
  2285.                  cur++
  2286.                  ) {
  2287.                             /* OS/2 or Windows, case doesn't matter */
  2288.                 if (tolower(filbuf[cur]) != tolower(localfn[cur]))
  2289.                   break;
  2290.             }
  2291.             if (cur < min)
  2292.               min = cur;
  2293.             }
  2294.             filbuf[min] = NUL;
  2295.             if (min > cc)
  2296.               k++;
  2297.         }
  2298. #else /* OS2 */
  2299.         for (i = cc; (c = filbuf[i]); i++) {
  2300.             for (j = 1; j < y; j++)
  2301.               if (mtchs[j][i] != c) break;
  2302.             if (j == y) k++;
  2303.             else filbuf[i] = filbuf[i+1] = NUL;
  2304.         }
  2305. #endif /* OS2 */
  2306.         debug(F111,"cmifi partial k",filbuf,k);
  2307.         if (k > 0) {        /* Got more characters */
  2308.             sp = filbuf + cc;    /* Point to new ones */
  2309. #ifdef VMS
  2310.             for (i = 0; i < cc; i++) {
  2311.             cmdchardel();    /* Back up over old partial spec */
  2312.             bp--;
  2313.             }
  2314.             sp = filbuf;    /* Point to new word start */
  2315.             debug(F100,"cmifi vms erase ok","",0);
  2316. #endif /* VMS */
  2317.             cc = k;        /* How many new ones we just got */
  2318.             printf("%s",sp);    /* Print them */
  2319.             while (*bp++ = *sp++) ;    /* Copy to command buffer */
  2320.             bp--;                    /* Back up over NUL */
  2321.             debug(F110,"cmifi partial cmdbuf",cmdbuf,0);
  2322.             if (setatm(filbuf,0) < 0) {
  2323.             printf("?Partial name too long\n");
  2324.             if (np) free(np);
  2325.             return(-9);
  2326.             }
  2327.             debug(F111,"cmifi partial atmbuf",atmbuf,cc);
  2328.             *xp = atmbuf;
  2329.         }
  2330. #endif /* NOPARTIAL */
  2331.         bleep(BP_WARN);
  2332.         } else {            /* Unique, complete it.  */
  2333. #ifndef VMS
  2334. #ifdef CK_TMPDIR
  2335.         /* isdir() function required for this! */
  2336.         debug(F111,"cmifi unique",filbuf,cc);
  2337.         if (isdir(filbuf) && !dirflg) {
  2338.             int len;
  2339.             len = strlen(filbuf);
  2340.             if (len > 0 && len < ATMBL - 1) {
  2341.             if (filbuf[len-1] != dirsep) {
  2342.                 filbuf[len] = dirsep;
  2343.                 filbuf[len+1] = NUL;
  2344.             }
  2345.             }
  2346.             sp = filbuf + cc;
  2347.             bleep(BP_WARN);
  2348.             printf("%s",sp);
  2349.             cc++;
  2350.             while (*bp++ = *sp++) ;
  2351.             bp--;
  2352.             if (setatm(filbuf,0) < 0) {
  2353.             printf("?Directory name too long\n");
  2354.             if (np) free(np);
  2355.             return(-9);
  2356.             }
  2357.             debug(F111,"cmifi directory atmbuf",atmbuf,cc);
  2358.             *xp = atmbuf;
  2359.         } else {        /* Not a directory or dirflg */
  2360. #endif /* CK_TMPDIR */
  2361. #endif /* VMS */
  2362. #ifndef VMS                /* VMS dir names are special */
  2363. #ifndef datageneral            /* VS dirnames must not end in ":" */
  2364.             if (dirflg) {
  2365.             int len;
  2366.             len = strlen(filbuf);
  2367.             if (len > 0 && len < ATMBL - 1) {
  2368.                 if (filbuf[len-1] != dirsep) {
  2369.                 filbuf[len] = dirsep;
  2370.                 filbuf[len+1] = NUL;
  2371.                 }
  2372.             }
  2373.             }
  2374. #endif /* datageneral */
  2375. #endif /* VMS */
  2376.             sp = filbuf + cc;    /* Point past what user typed. */
  2377. #ifdef VMS
  2378.             debug(F111,"cmifi VMS erasing",filbuf,cc);
  2379.             for (i = 0; i < cc; i++) {
  2380.             cmdchardel();    /* Back up over old partial spec */
  2381.             bp--;
  2382.             }
  2383.             sp = filbuf;    /* Point to new word start */
  2384.             debug(F111,"cmifi after VMS erase sp=",sp,cc);
  2385. #endif /* VMS */
  2386.             /* Complete the name. */
  2387. #ifdef COMMENT
  2388.             printf("%s%s",dirflg ? "" : " ",sp);
  2389. #else
  2390.             printf("%s ",sp); /* Complete the name. */
  2391. #endif /* COMMENT */
  2392. #ifdef GEMDOS
  2393.             fflush(stdout);
  2394. #endif /* GEMDOS */
  2395.             addbuf(sp);        /* Add the characters to cmdbuf. */
  2396.             if (setatm(filbuf,0) < 0) { /* And to atmbuf. */
  2397.             printf("?Completed name too long\n");
  2398.             if (np) free(np);
  2399.             return(-9);
  2400.             }
  2401.             if (dirflg && !isdir(filbuf)) {
  2402.             printf("?Not a directory - %s\n", filbuf);
  2403.             if (np) free(np);
  2404.             return(-9);
  2405.             }
  2406.             inword = cmflgs = 0;
  2407.             *xp = atmbuf;    /* Return pointer to atmbuf. */
  2408.             if (np) free(np);
  2409.             return(0);
  2410. #ifndef VMS
  2411. #ifdef CK_TMPDIR
  2412.         }
  2413. #endif /* CK_TMPDIR */
  2414. #endif /* VMS */
  2415.         }
  2416.         break;
  2417.  
  2418.       case 3:            /* Question mark - file menu wanted */
  2419.         if (*xhlp == NUL)
  2420.           printf(dirflg ? " Directory name" : " Input file specification");
  2421.         else
  2422.           printf(" %s",xhlp);
  2423. #ifdef GEMDOS
  2424.         fflush(stdout);
  2425. #endif /* GEMDOS */
  2426. #ifdef OLDHELP
  2427.         if (xc > 0) {
  2428. #endif /* OLDHELP */
  2429. #ifndef NOSPL
  2430.         if (f) {        /* If a conversion function is given */
  2431. #ifdef DOCHKVAR
  2432.             char *s = *xp;    /* See if there are any variables in */
  2433.             while (*s) {    /* the string and if so, expand them */
  2434.             if (chkvar(s)) {
  2435. #endif /* DOCHKVAR */
  2436.                 zq = atxbuf;
  2437.                 atxn = CMDBL;
  2438.                 if ((x = (*f)(*xp,&zq,&atxn)) < 0) {
  2439.                 if (np) free(np);
  2440.                 return(-2);
  2441.                 }
  2442. #ifdef DOCHKVAR
  2443.                     /* reduce cc by number of \\ consumed by conversion */
  2444.                     /* function (needed for OS/2, where \ is path separator) */
  2445.                 cc -= (strlen(*xp) - strlen(atxbuf));
  2446. #endif /* DOCHKVAR */
  2447.                 *xp = atxbuf;
  2448. #ifdef DOCHKVAR
  2449.                 break;
  2450.             }
  2451.             s++;
  2452.             }
  2453. #endif /* DOCHKVAR */
  2454.         }
  2455. #endif /* NOSPL */
  2456. #ifdef DTILDE
  2457.         dirp = tilde_expand(*xp); /* Expand tilde, if any */
  2458.         if (*dirp != '\0') {
  2459.             if (setatm(dirp,0) < 0) {
  2460.             printf("?Expanded name too long\n");
  2461.             if (np) free(np);
  2462.             return(-9);
  2463.             }
  2464.         }
  2465.         *xp = atmbuf;
  2466. #endif /* DTILDE */
  2467.         debug(F111,"cmifi ? *xp, cc",*xp,cc);
  2468.         sp = *xp + cc;        /* Insert "*" at end */
  2469. #ifdef datageneral
  2470.         *sp++ = '+';        /* Insert +, the DG wild card */
  2471. #else
  2472.         *sp++ = '*';
  2473. #endif /* datageneral */
  2474.         *sp-- = '\0';
  2475. #ifdef GEMDOS
  2476.         if (! strchr(*xp, '.'))    /* abde.e -> abcde.e* */
  2477.           strcat(*xp, ".*");    /* abc -> abc*.* */
  2478. #endif /* GEMDOS */
  2479.         debug(F110,"cmifi ? wild",*xp,0);
  2480.  
  2481. #ifdef COMMENT
  2482.         /* This kills file lists when we're still the path part */
  2483.         nzxopts = dirflg ? ZX_DIRONLY : (d ? 0 : ZX_FILONLY);
  2484. #else
  2485. #ifdef COMMENT
  2486.         /* But this makes "cd ?" list regular files */
  2487.         nzxopts = 0;
  2488. #else
  2489.         nzxopts = dirflg ? ZX_DIRONLY : 0;
  2490. #endif /* COMMENT */
  2491. #endif /* COMMENT */
  2492.         debug(F101,"cmifi matchdot","",matchdot);
  2493.         if (matchdot)  nzxopts |= ZX_MATCHDOT;
  2494.         if (recursive) nzxopts |= ZX_RECURSE;
  2495.         y = nzxpand(*xp,nzxopts);
  2496.         nfiles = y;
  2497.         *sp = '\0';
  2498.         if (y == 0) {
  2499.             if (nomsg) {
  2500.             printf(": %s\n",atmbuf);
  2501.             printf("%s%s",cmprom,cmdbuf);
  2502.             fflush(stdout);
  2503.             if (np) free(np);
  2504.             return(-1);
  2505.             } else {
  2506.             printf("?No %s match - %s\n",
  2507.                    dirflg ? "directories" : "files", atmbuf);
  2508.             if (np) free(np);
  2509.             return(-9);
  2510.             }
  2511.         } else if (y < 0) {
  2512.             printf("?Too many %s match - %s\n",
  2513.                dirflg ? "directories" : "files", atmbuf);
  2514.             if (np) free(np);
  2515.             return(-9);
  2516.         } else {
  2517.             printf(", one of the following:\n");
  2518. #ifdef OLDHELP
  2519.             clrhlp();
  2520.             for (i = 0; i < y; i++) {
  2521.             znext(filbuf);
  2522.             if (!dirflg || isdir(filbuf)) {
  2523. #ifdef VMS
  2524.                 printf(" %s\n",filbuf); /* VMS names can be long */
  2525. #else
  2526.                 addhlp(filbuf);
  2527. #endif /* VMS */
  2528.             }
  2529.             }
  2530.             dmphlp();
  2531. #else  /* New way... */
  2532.             if (filhelp(y,"","",1,dirflg) < 0) {
  2533.             if (np) free(np);
  2534.             return(-9);
  2535.             }
  2536. #endif /* OLDHELP */
  2537.         }
  2538. #ifdef OLDHELP
  2539.         } else
  2540.           printf("\n");
  2541. #endif /* OLDHELP */
  2542.         printf("%s%s",cmprom,cmdbuf);
  2543.         fflush(stdout);
  2544.         break;
  2545. #endif /* MAC */
  2546.         }
  2547. #ifdef BS_DIRSEP
  2548.         dirnamflg = 1;
  2549.         x = gtword(0);                  /* No, get a word */
  2550.     dirnamflg = 0;
  2551. #else
  2552.         x = gtword(0);                  /* No, get a word */
  2553. #endif /* BS_DIRSEP */
  2554.     *xp = atmbuf;
  2555.     }
  2556. }
  2557.  
  2558. /*  C M F L D  --  Parse an arbitrary field  */
  2559. /*
  2560.  Returns
  2561.    -3 if no input present when required,
  2562.    -2 if field too big for buffer,
  2563.    -1 if reparse needed,
  2564.     0 otherwise, xp pointing to string result.
  2565. */
  2566. int
  2567. cmfld(xhlp,xdef,xp,f) char *xhlp, *xdef, **xp; xx_strp f; {
  2568.     int x, xc;
  2569.     char *zq;
  2570.  
  2571.     inword = 0;                /* Initialize counts & pointers */
  2572.     cc = 0;
  2573.     xc = 0;
  2574.     *xp = "";
  2575.  
  2576.     debug(F110,"cmfld xdef 1",xdef,0);
  2577.  
  2578.     if (!xhlp) xhlp = "";
  2579.     if (!xdef) xdef = "";
  2580.     ckstrncpy(cmdefault,xdef,CMDEFAULT); /* Copy default */
  2581.     xdef = cmdefault;
  2582.  
  2583.     debug(F111,"cmfld xdef 2",xdef,cmflgs);
  2584.  
  2585.     if ((x = cmflgs) != 1) {            /* Already confirmed? */
  2586.         x = gtword(0);                  /* No, get a word */
  2587.     } else {
  2588.     if (setatm(xdef,0) < 0) {    /* If so, use default, if any. */
  2589.         printf("?Default too long\n");
  2590.         return(-9);
  2591.     }
  2592.     }
  2593.     *xp = atmbuf;                       /* Point to result. */
  2594.     debug(F111,"cmfld atmbuf 1",atmbuf,cmflgs);
  2595.  
  2596.     while (1) {
  2597.         xc += cc;                       /* Count the characters. */
  2598.         debug(F111,"cmfld: gtword",atmbuf,xc);
  2599.         debug(F101,"cmfld x","",x);
  2600.         switch (x) {
  2601.       case -9:
  2602.         printf("Command or field too long\n");
  2603.       case -4:            /* EOF */
  2604.       case -3:            /* Empty. */
  2605.       case -2:            /* Out of space. */
  2606.       case -1:            /* Reparse needed */
  2607.         return(x);
  2608.       case 0:            /* SP or NL */
  2609.       case 1:
  2610.         debug(F111,"cmfld 1",atmbuf,xc);
  2611.         if (xc == 0) {        /* If no input, return default. */
  2612.         if (setatm(xdef,0) < 0) {
  2613.             printf("?Default too long\n");
  2614.             return(-9);
  2615.         }
  2616.         }
  2617.         *xp = atmbuf;        /* Point to what we got. */
  2618.         debug(F111,"cmfld 2",atmbuf,(f) ? 1 : 0);
  2619.         if (f) {            /* If a conversion function is given */
  2620.         zq = atxbuf;        /* employ it now. */
  2621.         atxn = CMDBL;
  2622.         debug(F111,"cmfld zzstring",atxbuf,x);
  2623.         if ((*f)(*xp,&zq,&atxn) < 0)
  2624.           return(-2);
  2625.         if (setatm(atxbuf,1) < 0) { /* Replace by new value */
  2626.             printf("Value too long\n");
  2627.             return(-9);
  2628.         }
  2629.         *xp = atmbuf;
  2630.         }
  2631.         debug(F111,"cmfld 3",atmbuf,xc);
  2632.         if (**xp == NUL) {        /* If variable evaluates to null */
  2633.         if (setatm(xdef,0) < 0) {
  2634.             printf("?Default too long\n");
  2635.             return(-9);
  2636.         }
  2637.         if (**xp == NUL) x = -3; /* If still empty, return -3. */
  2638.         }
  2639.         debug(F111,"cmfld returns",*xp,x);
  2640.         return(x);
  2641.       case 2:            /* ESC */
  2642.         if (xc == 0 && *xdef) {
  2643.         printf("%s ",xdef); /* If at beginning of field, */
  2644. #ifdef GEMDOS
  2645.         fflush(stdout);
  2646. #endif /* GEMDOS */
  2647.         addbuf(xdef);        /* Supply default. */
  2648.         inword = cmflgs = 0;
  2649.         if (setatm(xdef,0) < 0) {
  2650.             printf("?Default too long\n");
  2651.             return(-9);
  2652.         } else            /* Return as if whole field */
  2653.           return(0);        /* typed, followed by space. */
  2654.         } else {
  2655.         bleep(BP_WARN);
  2656.         }
  2657.         break;
  2658.       case 3:            /* Question mark */
  2659.         if (*xhlp == NUL)
  2660.           printf(" Please complete this field");
  2661.         else
  2662.           printf(" %s",xhlp);
  2663.         printf("\n%s%s",cmprom,cmdbuf);
  2664.         fflush(stdout);
  2665.         break;
  2666.         }
  2667.     x = gtword(0);
  2668.     /* *xp = atmbuf; */
  2669.     }
  2670. }
  2671.  
  2672.  
  2673. /*  C M T X T  --  Get a text string, including confirmation  */
  2674.  
  2675. /*
  2676.   Print help message 'xhlp' if ? typed, supply default 'xdef' if null
  2677.   string typed.  Returns:
  2678.  
  2679.    -1 if reparse needed or buffer overflows.
  2680.     1 otherwise.
  2681.  
  2682.   with cmflgs set to return code, and xp pointing to result string.
  2683. */
  2684. int
  2685. cmtxt(xhlp,xdef,xp,f) char *xhlp; char *xdef; char **xp; xx_strp f; {
  2686.  
  2687.     int x, i;
  2688.     char *xx, *zq;
  2689.     static int xc;
  2690.  
  2691.     if (!xhlp) xhlp = "";
  2692.     if (!xdef) xdef = "";
  2693.  
  2694.     cmfldflgs = 0;
  2695.     ckstrncpy(cmdefault,xdef,CMDEFAULT); /* Copy default */
  2696.     xdef = cmdefault;
  2697.  
  2698.     debug(F101,"cmtxt, cmflgs","",cmflgs);
  2699.     inword = 0;                /* Start atmbuf counter off at 0 */
  2700.     cc = 0;
  2701.     if (cmflgs == -1) {                 /* If reparsing, */
  2702.     *xp = pp;
  2703.         xc = (int)strlen(*xp);        /* get back the total text length, */
  2704.     bp = *xp;            /* and back up the pointers. */
  2705.     np = *xp;
  2706.     pp = *xp;
  2707.     } else {                            /* otherwise, */
  2708.     debug(F100,"cmtxt: fresh start","",0);
  2709.         *xp = "";                       /* start fresh. */
  2710.         xc = 0;
  2711.     }
  2712.     *atmbuf = NUL;                      /* And empty the atom buffer. */
  2713.     rtimer();                /* Reset timer */
  2714.     if ((x = cmflgs) != 1) {
  2715.     int done = 0;
  2716.     while (!done) {
  2717.         x = gtword(0);        /* Get first word. */
  2718.         *xp = pp;            /* Save pointer to it. */
  2719.         debug(F111,"cmtxt:",*xp,cc);
  2720.         if (x == -10) {
  2721.         if (gtimer() > timelimit) {
  2722.             if (!quiet) printf("?Timed out\n");
  2723.             return(x);
  2724.         }
  2725.         } else
  2726.           done = 1;
  2727.     }
  2728.     }
  2729.     while (1) {                /* Loop for each word in text. */
  2730.         xc += cc;                       /* Char count for all words. */
  2731.         debug(F111,"cmtxt gtword",atmbuf,xc);
  2732.         debug(F101,"cmtxt x","",x);
  2733.         switch (x) {
  2734.       case -10:
  2735.         if (gtimer() > timelimit) {
  2736. #ifdef IKSD
  2737.                 extern int inserver;
  2738.                 if (inserver) {
  2739.                     printf("\r\nIKSD IDLE TIMEOUT: %d sec\r\n", timelimit);
  2740.                     doexit(GOOD_EXIT,0);
  2741.                 }
  2742. #endif /* IKSD */
  2743.         if (!quiet) printf("?Timed out\n");
  2744.         return(-10);
  2745.         } else {
  2746.         x = gtword(0);
  2747.         continue;
  2748.         }
  2749.       case -9:            /* Buffer overflow */
  2750.         printf("Command or field too long\n");
  2751.       case -4:            /* EOF */
  2752. #ifdef MAC
  2753.       case -3:            /* Quit/Timeout */
  2754. #endif /* MAC */
  2755.       case -2:            /* Overflow */
  2756.       case -1:            /* Deletion */
  2757.         return(x);
  2758.       case 0:            /* Space */
  2759.         xc++;            /* Just count it */
  2760.         break;
  2761.       case 1:            /* CR or LF */
  2762.         if (xc == 0) *xp = xdef;
  2763.         if (f) {            /* If a conversion function is given */
  2764.         zq = atxbuf;        /* Point to the expansion buffer */
  2765.         atxn = CMDBL;        /* specify its length */
  2766.         debug(F110,"cmtxt calling (*f)",*xp,0);
  2767.         if ((x = (*f)(*xp,&zq,&atxn)) < 0) return(-2);
  2768.         cc = (int)strlen(atxbuf);
  2769.         if (cc < 1) {
  2770.             *xp = xdef;
  2771.             cc = strlen(xdef);
  2772.         } else {
  2773.             *xp = atxbuf;    /* and return pointer to it. */
  2774.         }
  2775.         debug(F111,"cmtxt (*f) returns",*xp,cc);
  2776.         }
  2777.         xx = *xp;
  2778.         for (i = (int)strlen(xx) - 1; i > 0; i--)
  2779.           if (xx[i] != SP)        /* Trim trailing blanks */
  2780.         break;
  2781.           else
  2782.         xx[i] = NUL;
  2783. #ifdef CK_RECALL
  2784.         addcmd(cmdbuf);
  2785. #endif /* CK_RECALL */
  2786.         return(x);
  2787.       case 2:            /* ESC */
  2788.         if (xc == 0) {        /* Nothing typed yet */
  2789.         if (*xdef) {        /* Have a default for this field? */
  2790.             printf("%s ",xdef);    /* Yes, supply it */
  2791.             inword = cmflgs = 0;
  2792. #ifdef GEMDOS
  2793.             fflush(stdout);
  2794. #endif /* GEMDOS */
  2795.             cc = addbuf(xdef);
  2796.         } else bleep(BP_WARN);    /* No default */
  2797.         } else {            /* Already in field */
  2798.         int x; char *p;
  2799.         x = strlen(atmbuf);
  2800.         if (ckstrcmp(atmbuf,xdef,x,0)) /* Matches default? */
  2801.           bleep(BP_WARN);    /* No */
  2802.         else {            /* Yes */
  2803.             p = xdef + x;
  2804.             printf("%s ", p);
  2805. #ifdef GEMDOS
  2806.             fflush(stdout);
  2807. #endif /* GEMDOS */
  2808.             addbuf(p);
  2809.             inword = cmflgs = 0;
  2810.             debug(F110,"cmtxt: addbuf",cmdbuf,0);
  2811.         }
  2812.         }
  2813.         break;
  2814.       case 3:            /* Question Mark */
  2815.         if (*xhlp == NUL)
  2816.           printf(" Text string");
  2817.         else
  2818.           printf(" %s",xhlp);
  2819.         printf("\n%s%s",cmprom,cmdbuf);
  2820.         fflush(stdout);
  2821.         break;
  2822.       default:
  2823.         printf("?Unexpected return code from gtword() - %d\n",x);
  2824.         return(-2);
  2825.         }
  2826.         x = gtword(0);
  2827.     }
  2828. }
  2829.  
  2830. /*  C M K E Y  --  Parse a keyword  */
  2831.  
  2832. /*
  2833.  Call with:
  2834.    table    --  keyword table, in 'struct keytab' format;
  2835.    n        --  number of entries in table;
  2836.    xhlp     --  pointer to help string;
  2837.    xdef     --  pointer to default keyword;
  2838.    f        --  processing function (e.g. to evaluate variables)
  2839.    pmsg     --  0 = don't print error messages
  2840.                 1 = print error messages
  2841.                 2 = include CM_HLP keywords even if invisible
  2842.                 3 = 1+2
  2843.                 4 = parse a switch (keyword possibly ending in : or =)
  2844.  Returns:
  2845.    -3       --  no input supplied and no default available
  2846.    -2       --  input doesn't uniquely match a keyword in the table
  2847.    -1       --  user deleted too much, command reparse required
  2848.     n >= 0  --  value associated with keyword
  2849. */
  2850. int
  2851. cmkey(table,n,xhlp,xdef,f)
  2852. /* cmkey */  struct keytab table[]; int n; char *xhlp, *xdef; xx_strp f; {
  2853.     return(cmkey2(table,n,xhlp,xdef,"",f,1));
  2854. }
  2855. int
  2856. cmkeyx(table,n,xhlp,xdef,f)
  2857. /* cmkeyx */  struct keytab table[]; int n; char *xhlp, *xdef; xx_strp f; {
  2858.     return(cmkey2(table,n,xhlp,xdef,"",f,0));
  2859. }
  2860. int
  2861. cmswi(table,n,xhlp,xdef,f)
  2862. /* cmswi */  struct keytab table[]; int n; char *xhlp, *xdef; xx_strp f; {
  2863.     return(cmkey2(table,n,xhlp,xdef,"",f,4));
  2864. }
  2865.  
  2866. int
  2867. cmkey2(table,n,xhlp,xdef,tok,f,pmsg)
  2868.     struct keytab table[];
  2869.     int n;
  2870.     char *xhlp,
  2871.     *xdef;
  2872.     char *tok;
  2873.     xx_strp f;
  2874.     int pmsg;
  2875. { /* cmkey2 */
  2876.     int i, tl, y, z = 0, zz, xc, wordlen = 0, cmswitch;
  2877.     char *xp, *zq;
  2878.  
  2879.     if (!xhlp) xhlp = "";
  2880.     if (!xdef) xdef = "";
  2881.  
  2882.     cmfldflgs = 0;
  2883.     if (!table) {
  2884.     printf("?Keyword table missing\n");
  2885.     return(-9);
  2886.     }
  2887.     tl = (int)strlen(tok);
  2888.     inword = xc = cc = 0;        /* Clear character counters. */
  2889.     cmswitch = pmsg & 4;        /* Flag for parsing a switch */
  2890.  
  2891.     debug(F101,"cmkey: pmsg","",pmsg);
  2892.     debug(F101,"cmkey: cmflgs","",cmflgs);
  2893.     /* debug(F101,"cmkey: cmdbuf","",cmdbuf);*/
  2894.  
  2895.     ppvnambuf[0] = NUL;
  2896.  
  2897.     if ((zz = cmflgs) == 1) {        /* Command already entered? */
  2898.     if (setatm(xdef,0) < 0) {    /* Yes, copy default into atom buf */
  2899.         printf("?Default too long\n");
  2900.         return(-9);
  2901.     }
  2902.     } else
  2903.       zz = gtword((pmsg == 4) ? 1 : 0);    /* Otherwise get a command word */
  2904.  
  2905.     debug(F101,"cmkey table length","",n);
  2906.     debug(F101,"cmkey cmflgs","",cmflgs);
  2907.     debug(F101,"cmkey zz","",zz);
  2908.     debug(F101,"cmkey cc","",cc);
  2909.     rtimer();                /* Reset timer */
  2910.  
  2911.     while (1) {
  2912.     xc += cc;
  2913.     debug(F111,"cmkey gtword xc",atmbuf,xc);
  2914.  
  2915.     switch (zz) {
  2916.       case -10:            /* Timeout */
  2917.         if (gtimer() < timelimit) {
  2918.         zz = gtword((pmsg == 4) ? 1 : 0);
  2919.         continue;
  2920.         } else {
  2921. #ifdef IKSD
  2922.                 extern int inserver;
  2923.                 if (inserver) {
  2924.                     printf("\r\nIKSD IDLE TIMEOUT: %d sec\r\n", timelimit);
  2925.                     doexit(GOOD_EXIT,0);
  2926.                 }
  2927. #endif /* IKSD */
  2928.         return(-10);
  2929.             }
  2930.       case -5:
  2931.         return(cmflgs = 0);
  2932.       case -9:
  2933.         printf("Command or field too long\n");
  2934.       case -4:            /* EOF */
  2935.       case -3:            /* Null Command/Quit/Timeout */
  2936.       case -2:            /* Buffer overflow */
  2937.       case -1:            /* Or user did some deleting. */
  2938.         return(cmflgs = zz);
  2939.  
  2940.       case 0:            /* User terminated word with space */
  2941.       case 1:            /* or newline */
  2942.       case 4:            /* or switch ending in : or = */
  2943.         wordlen = cc;        /* Length if no conversion */
  2944.         if (cc == 0) {        /* Supply default if we got nothing */
  2945.         if ((wordlen = setatm(xdef,(zz == 4) ? 2 : 0)) < 0) {
  2946.             printf("?Default too long\n");
  2947.             return(-9);
  2948.         }
  2949.         }
  2950.         if (zz == 1 && cc == 0)    /* Required field missing */
  2951.           return(-3);
  2952.  
  2953.         if (f) {            /* If a conversion function is given */
  2954.         char * pp;
  2955.         zq = atxbuf;        /* apply it */
  2956.         pp = atxbuf;
  2957.         atxn = CMDBL;
  2958.         if ((*f)(atmbuf,&zq,&atxn) < 0) return(-2);
  2959.         debug(F110,"cmkey atxbuf after *f",atxbuf,0);
  2960.         if (!*pp)        /* Supply default if we got nothing */
  2961.           pp = xdef;
  2962.         ckstrncpy(ppvnambuf,atmbuf,PPVLEN);
  2963.         if ((wordlen = setatm(pp,(zz == 4) ? 2 : 0)) < 0) {
  2964.             printf("Evaluated keyword too long\n");
  2965.             return(-9);
  2966.         }
  2967.         }
  2968.         if (cmswitch && *atmbuf != '/') {
  2969.         if (pmsg & 1) {
  2970.             bleep(BP_FAIL);
  2971.                     printf("?Not a switch - %s\n",atmbuf);
  2972.         }
  2973.         cmflgs = -2;
  2974.         return(-6);
  2975.         }
  2976.         if (cmswitch) {
  2977.         int i;
  2978.         for (i = 0; i < wordlen; i++) {
  2979.             if (atmbuf[i] == ':' || atmbuf[i] == '=') {
  2980.             atmbuf[i] = NUL;
  2981.             break;
  2982.             }
  2983.         }
  2984.         }
  2985.         y = lookup(table,atmbuf,n,&z); /* Look up the word in the table */
  2986.         switch (y) {
  2987.           case -3:            /* Nothing to look up */
  2988.         break;
  2989.           case -2:            /* Ambiguous */
  2990.         cmflgs = -2;
  2991.         if (pmsg & 1) {
  2992.             bleep(BP_FAIL);
  2993.                     printf("?Ambiguous - %s\n",atmbuf);
  2994.             return(-9);
  2995.         }
  2996.         return(-2);
  2997.           case -1:            /* Not found at all */
  2998.         if (tl) {
  2999.             for (i = 0; i < tl; i++) /* Check for token */
  3000.               if (tok[i] == *atmbuf) { /* Got one */
  3001.               debug(F000,"cmkey token:",atmbuf,*atmbuf);
  3002.               ungword();  /* Put back the following word */
  3003.               return(-5); /* Special return code for token */
  3004.               }
  3005.         }
  3006.         if (tl == 0) {        /* No tokens were included */
  3007. #ifdef OS2
  3008.             /* In OS/2 and Windows, allow for a disk letter like DOS */
  3009.             if (isalpha(*atmbuf) && *(atmbuf+1) == ':')
  3010.               return(-7);
  3011. #endif /* OS2 */
  3012.             if ((pmsg & 1) && !quiet) {
  3013.             bleep(BP_FAIL);
  3014.             printf("?No keywords match - %s\n",atmbuf); /* cmkey */
  3015.             }
  3016.             return(cmflgs = -9);
  3017.         } else {
  3018.             if (cmflgs == 1 || cmswitch) /* cmkey2 or cmswi */
  3019.               return(cmflgs = -6);
  3020.             else
  3021.               return(cmflgs = -2);
  3022.             /* The -6 code is to let caller try another table */
  3023.         }
  3024.         break;
  3025.           default:
  3026. #ifdef CK_RECALL
  3027.         if (test(table[z].flgs,CM_NOR)) no_recall = 1;
  3028. #endif /* CK_RECALL */
  3029.         if (zz == 4)
  3030.           swarg = 1;
  3031.         cmkwflgs = table[z].flgs;
  3032.         break;
  3033.         }
  3034.         return(y);
  3035.  
  3036.       case 2:            /* User terminated word with ESC */
  3037.         debug(F101,"cmkey Esc cc","",cc);
  3038.             if (cc == 0) {
  3039.         if (*xdef != NUL) {     /* Nothing in atmbuf */
  3040.             printf("%s ",xdef); /* Supply default if any */
  3041. #ifdef GEMDOS
  3042.             fflush(stdout);
  3043. #endif /* GEMDOS */
  3044.             addbuf(xdef);
  3045.             if (setatm(xdef,0) < 0) {
  3046.             printf("?Default too long\n");
  3047.             return(-9);
  3048.             }
  3049.             inword = cmflgs = 0;
  3050.             debug(F111,"cmkey: default",atmbuf,cc);
  3051.         } else {
  3052.             debug(F101,"cmkey Esc pmsg","",0);
  3053. #ifdef COMMENT
  3054. /*
  3055.   Chained FDBs...  The idea is that this function might not have a default,
  3056.   but the next one might.  But if it doesn't, there is no way to come back to
  3057.   this one.  To be revisited later...
  3058. */
  3059.             if (xcmfdb)        /* Chained fdb -- try next one */
  3060.               return(-3);
  3061. #endif /* COMMENT */
  3062.             if (pmsg & (1|4)) {    /* So for now just beep */
  3063.             bleep(BP_WARN);
  3064.             }
  3065.             break;
  3066.         }
  3067.             }
  3068.         if (f) {            /* If a conversion function is given */
  3069.         char * pp;
  3070.         zq = atxbuf;        /* apply it */
  3071.         pp = atxbuf;
  3072.         atxn = CMDBL;
  3073.         if ((*f)(atmbuf,&zq,&atxn) < 0)
  3074.           return(-2);
  3075.         if (!*pp)
  3076.           pp = xdef;
  3077.         if (setatm(pp,0) < 0) {
  3078.             printf("Evaluated keyword too long\n");
  3079.             return(-9);
  3080.         }
  3081.         }
  3082.         y = lookup(table,atmbuf,n,&z); /* Something in atmbuf */
  3083.         debug(F111,"cmkey lookup y",atmbuf,y);
  3084.         debug(F111,"cmkey lookup z",atmbuf,z);
  3085.         if (y == -2 && z >= 0 && z < n) { /* Ambiguous */
  3086. #ifndef NOPARTIAL
  3087.         int j, k, len = 9999;    /* Do partial completion */
  3088.         /* Skip past any abbreviations in the table */
  3089.         for ( ; z < n; z++) {
  3090.             if (table[z].flgs & CM_ABR == 0)
  3091.               break;
  3092.             if (!(table[z].flgs & CM_HLP) || (pmsg & 2))
  3093.               break;
  3094.         }
  3095.         debug(F111,"cmkey partial z",atmbuf,z);
  3096.         debug(F111,"cmkey partial n",atmbuf,n);
  3097.         for (j = z+1; j < n; j++) {
  3098.             debug(F111,"cmkey partial j",table[j].kwd,j);
  3099.             if (ckstrcmp(atmbuf,table[j].kwd,cc,0))
  3100.               break;
  3101.             if (table[j].flgs & CM_ABR)
  3102.               continue;
  3103.             if ((table[j].flgs & CM_HLP) && !(pmsg & 2))
  3104.               continue;
  3105.             k = ckstrpre(table[z].kwd,table[j].kwd);
  3106.             debug(F111,"cmkey partial k",table[z].kwd,k);
  3107.             if (k < len)
  3108.               len = k; /* Length of longest common prefix */
  3109.         }
  3110.         debug(F111,"cmkey partial len",table[z].kwd,len);
  3111.         if (len != 9999 && len > cc) {
  3112.             strcat(atmbuf,table[z].kwd+cc);
  3113.             atmbuf[len] = NUL;
  3114.             printf("%s",atmbuf+cc);
  3115.             strcat(cmdbuf,atmbuf+cc);
  3116.             xc += (len - cc);
  3117.             cc = len;
  3118.         }
  3119. #endif /* NOPARTIAL */
  3120.         bleep(BP_WARN);
  3121.         break;
  3122.         } else if (y == -3) {
  3123.         bleep(BP_WARN);
  3124.         break;
  3125.         } else if (y == -1) {    /* Not found */
  3126.         if ((pmsg & 1) && !quiet) {
  3127.             bleep(BP_FAIL);
  3128.             printf("?No keywords match - \"%s\"\n",atmbuf);
  3129.         }
  3130.         cmflgs = -2;
  3131.         return(-9);
  3132.         }
  3133. /*
  3134.   If we found it, but it's a help-only keyword and the "help" bit is not
  3135.   set in pmsg, then not found.
  3136. */
  3137.         debug(F101,"cmkey flgs","",table[z].flgs);
  3138.         if (test(table[z].flgs,CM_HLP) && ((pmsg & 2) == 0)) {
  3139.         if ((pmsg & 1) && !quiet) {
  3140.             bleep(BP_FAIL);
  3141.             printf("?No keywords match - %s\n",atmbuf);
  3142.         }
  3143.         cmflgs = -2;
  3144.         return(-9);
  3145.         }
  3146. /*
  3147.   See if the keyword just found has the CM_ABR bit set in its flgs field, and
  3148.   if so, search forwards in the table for a keyword that has the same kwval
  3149.   but does not have CM_ABR (or CM_INV?) set, and then expand using the full
  3150.   keyword.  WARNING: This assumes that (a) keywords are in alphabetical order,
  3151.   and (b) the CM_ABR bit is set only if the the abbreviated keyword is a true
  3152.   abbreviation (left substring) of the full keyword.
  3153. */
  3154.         if (test(table[z].flgs,CM_ABR)) {
  3155.         int zz;
  3156.         for (zz = z+1; zz < n; zz++)
  3157.           if ((table[zz].kwval == table[z].kwval) &&
  3158.               (!test(table[zz].flgs,CM_ABR)) &&
  3159.               (!test(table[zz].flgs,CM_INV))) {
  3160.               z = zz;
  3161.               break;
  3162.           }
  3163.         }
  3164.         xp = table[z].kwd + cc;
  3165.         if (cmswitch && test(table[z].flgs,CM_ARG)) {
  3166. #ifdef VMS
  3167.         printf("%s=",xp);
  3168.         brkchar = '=';
  3169. #else
  3170.         printf("%s:",xp);
  3171.         brkchar = ':';
  3172. #endif /* VMS */
  3173.         } else {
  3174.         printf("%s ",xp);
  3175.         brkchar = SP;
  3176.         }
  3177. #ifdef CK_RECALL
  3178.         if (test(table[z].flgs,CM_NOR)) no_recall = 1;
  3179. #endif /* CK_RECALL */
  3180.         cmkwflgs = table[z].flgs;
  3181. #ifdef GEMDOS
  3182.         fflush(stdout);
  3183. #endif /* GEMDOS */
  3184.         addbuf(xp);
  3185.         if (cmswitch && test(table[z].flgs,CM_ARG)) {
  3186.         bp--;            /* Replace trailing space with : */
  3187. #ifdef VMS
  3188.         *bp++ = '=';
  3189. #else
  3190.         *bp++ = ':';
  3191. #endif /* VMS */
  3192.         *bp = NUL;
  3193.         np = bp;
  3194.         swarg = 1;
  3195.         }
  3196.         inword = 0;
  3197.         cmflgs = 0;
  3198.         debug(F110,"cmkey: addbuf",cmdbuf,0);
  3199.         return(y);
  3200.  
  3201.       case 3:            /* User typed "?" */
  3202.         if (f) {            /* If a conversion function is given */
  3203.         char * pp;
  3204.         zq = atxbuf;        /* do the conversion now. */
  3205.         pp = atxbuf;
  3206.         atxn = CMDBL;
  3207.         if ((*f)(atmbuf,&zq,&atxn) < 0) return(-2);
  3208.         if (setatm(pp,0) < 0) {
  3209.             printf("?Evaluated keyword too long\n");
  3210.             return(-9);
  3211.         }
  3212.         }
  3213.         y = lookup(table,atmbuf,n,&z); /* Look up what we have so far. */
  3214.         if (y == -1) {
  3215.         cmflgs = -2;
  3216.         if ((pmsg & 1) && !quiet) {
  3217.             bleep(BP_FAIL);
  3218.             printf(" No keywords match\n");
  3219.             return(-9);
  3220.         }
  3221.         return(-2);
  3222.         }
  3223.         if (*xhlp == NUL)
  3224.           printf(" One of the following:\n");
  3225.         else
  3226.           printf(" %s, one of the following:\n",xhlp);
  3227.  
  3228. #ifdef OLDHELP
  3229.         if ((y > -1) &&
  3230.         !test(table[z].flgs,CM_ABR) &&
  3231.         ((z >= n-1) || ckstrcmp(table[z].kwd,table[z+1].kwd,cc,0))
  3232.         ) {
  3233.         printf(" %s\n",table[z].kwd);
  3234.         } else {
  3235.         clrhlp();
  3236.         for (i = 0; i < n; i++) {
  3237.             if (!ckstrcmp(table[i].kwd,atmbuf,cc,0)
  3238.             && !test(table[i].flgs,CM_INV)
  3239.             )
  3240.               addhlp(table[i].kwd);
  3241.         }
  3242.         dmphlp();
  3243.         }
  3244. #else  /* New way ... */
  3245.         {
  3246.         int x;
  3247.         x = pmsg & (2|4);    /* See kwdhelp() comments */
  3248.         if (atmbuf[0])        /* If not at beginning of field */
  3249.           x |= 1;        /* also show invisibles */
  3250.         kwdhelp(table,n,atmbuf,"","",1,x);
  3251.         }
  3252. #endif /* OLDHELP */
  3253. #ifndef NOSPL
  3254.         {
  3255.         extern int topcmd;
  3256.         if (tl > 0 && topcmd != XXHLP) /* This is bad... */
  3257.           printf("or the name of a macro (\"do ?\" for a list)\n");
  3258.         }
  3259. #endif /* NOSPL */
  3260.         if (*atmbuf == NUL) {
  3261.         if (tl == 1)
  3262.           printf("or the token %c\n",*tok);
  3263.         else if (tl > 1)
  3264.           printf("or one of the tokens: %s\n",ckspread(tok));
  3265.         }
  3266.         printf("%s%s", cmprom, cmdbuf);
  3267.         fflush(stdout);
  3268.         break;
  3269.  
  3270.       default:
  3271.         printf("\n%d - Unexpected return code from gtword\n",zz);
  3272.         return(cmflgs = -2);
  3273.     }
  3274.     zz = gtword(0);
  3275.     debug(F111,"cmkey gtword zz",atmbuf,zz);
  3276.     }
  3277. }
  3278.  
  3279. int
  3280. chktok(tlist) char *tlist; {
  3281.     char *p;
  3282.     p = tlist;
  3283.     while (*p != NUL && *p != *atmbuf) p++;
  3284.     return((*p) ? (int) *p : 0);
  3285. }
  3286.  
  3287. /* Routines for parsing and converting dates and times */
  3288.  
  3289. #define isdatesep(c) (c==SP||c=='-'||c=='/'||c=='.'||c=='_')
  3290. #define istimesep(c) (c==':' || c=='P'||c=='p'||c=='A'||c=='a')
  3291.  
  3292. char cmdatebuf[18] = { NUL, NUL };
  3293.  
  3294. #define TU_DAYS   0
  3295. #define TU_WEEKS  1
  3296. #define TU_MONTHS 2
  3297. #define TU_YEARS  3
  3298.  
  3299. static struct keytab timeunits[] = {
  3300.   { "days",   TU_DAYS,   0 },
  3301.   { "months", TU_MONTHS, 0 },
  3302.   { "weeks",  TU_WEEKS,  0 },
  3303.   { "wks",    TU_WEEKS,  0 },
  3304.   { "years",  TU_YEARS,  0 },
  3305.   { "yrs",    TU_YEARS,  0 }
  3306. };
  3307. static int nunits = (sizeof(timeunits) / sizeof(struct keytab));
  3308.  
  3309. /*  C M C V T D A T E  --  Converts free-form date to standard form.  */
  3310.  
  3311. /*
  3312.    Call with
  3313.      s = pointer to free-format date-time
  3314.      t = 0: return time only if time was given in s
  3315.      t = 1: always return time (00:00:00 if no time given in s)
  3316.      t = 2: allow time to be > 24:00:00
  3317.    Returns:
  3318.      -1 on failure, 0 or greater on success with result in cmdate[].
  3319. */
  3320. int
  3321. cmcvtdate(s,t) char * s; int t; {
  3322.     int rc = 0, x, i, hh, mm, ss, pmflag = 0, nodate = 0, len;
  3323.     int units;
  3324.     char * fld[3], * p;
  3325.     char * year, * month = NULL, * day;
  3326.     char * hour = "00", * min = "00", * sec = "00";
  3327.     char tmpbuf[8];
  3328.     char xbuf[32];
  3329.     char ybuf[32];
  3330.     char dbuf[26];
  3331.     char daybuf[3];
  3332.     char monbuf[3];
  3333.     char yearbuf[5];
  3334.  
  3335.     debug(F110,"cmcvtdate",s,0);
  3336.     if (!s) s = "";
  3337.  
  3338.     tmpbuf[0] = NUL;
  3339.  
  3340.     while (*s == SP) s++;        /* Gobble any leading blanks */
  3341.  
  3342.     len = strlen(s);
  3343.     if (len == 0) {
  3344.     s = ckdate();
  3345.     len = 17;
  3346.     debug(F110,"cmcvtdate now",s,0);
  3347.     }
  3348.     if (len > 30) {            /* Check length of arg */
  3349.     debug(F101,"cmcvtdate date too long","",-1);
  3350.     return(-1);
  3351.     }
  3352.     ckstrncpy(xbuf,s,32);        /* Make a local copy we can poke */
  3353.     s = xbuf;                /* Point to it */
  3354.     s[len] = NUL;
  3355.  
  3356. /* First we handle "today", "yesterday", "tomorrow", etc */
  3357.  
  3358.     if (ckstrchr("+-TtYy",s[0])) {
  3359.     int i, k, n, minus = 0;
  3360.     long jd;
  3361.     jd = mjd(ckdate());
  3362.     debug(F111,"cmcvtdate NEW",s,jd);
  3363.     if (s[0] == '+' || s[0] == '-') { /* {+,-} <number> <timeunits> */
  3364.         char * kp, * np;
  3365.         char tmpyear[5];
  3366.         char * dp;
  3367.         if (s[0] == '-')        /* Sign */
  3368.           minus = 1;
  3369.         kp = s+1;            /* Skip intervening spaces */
  3370.         while (*kp) {
  3371.         if (*kp == SP) kp++;
  3372.         else break;
  3373.         }
  3374.         if (!*kp)
  3375.           return(-1);
  3376.         np = kp;            /* Number */
  3377.         while (*kp) {
  3378.         if (isdigit(*kp)) kp++;
  3379.         else break;
  3380.         }
  3381.         if (!*kp)
  3382.           return(-1);
  3383.         n = atoi(np);
  3384.         if (minus) n = 0 - n;
  3385.         debug(F101,"cmcvtdate offset n","",n);
  3386.         while (*kp) {        /* Find end of number */
  3387.         if (isdigit(*kp)) kp++;
  3388.         else break;
  3389.         }
  3390.         while (*kp) {        /* Skip spaces again */
  3391.         if (*kp == SP) kp++;
  3392.         else break;
  3393.         }
  3394.         debug(F110,"cmcvtdate unit start",kp,0);
  3395.         p = kp;            /* Units */
  3396.         while (*p) {
  3397.         if (isalpha(*p)) {
  3398.             p++;
  3399.         } else if (isdatesep(*p)) { /* Have a date separator */
  3400.             *p++ = NUL;
  3401.             break;
  3402.         } else
  3403.           return(-1);
  3404.         }
  3405.         while (*p) {        /* Skip any spaces */
  3406.         if (*p == SP) p++;
  3407.         else break;
  3408.         }
  3409.         debug(F110,"cmcvtdate time pointer",p,0);
  3410.         debug(F110,"cmcvtdate unit",kp,0);
  3411.         x = lookup(timeunits,kp,nunits,&k);    /* Look up units */
  3412.         if (x < 0) {
  3413.         debug(F111,"cmcvtdate lookup fails",kp,x);
  3414.         return(-1);
  3415.         }
  3416.         units = x;
  3417.         debug(F111,"cmcvtdate offset units",timeunits[k].kwd,units);
  3418.  
  3419.         switch (units) {        /* Handle each unit */
  3420.           case TU_DAYS:        /* Days */
  3421.         jd += n;
  3422.         strcpy(ybuf,mjd2date(jd));
  3423.         if (*p) {
  3424.             ybuf[8] = ' ';
  3425.             strcpy(ybuf+9,p);
  3426.         } else
  3427.           strcpy(ybuf+8," 00:00:00");
  3428.         s = ybuf;
  3429.         len = strlen(ybuf);
  3430.         debug(F111,"cmcvtdate days",s,len);
  3431.         goto normal;
  3432.  
  3433.           case TU_WEEKS:        /* Weeks */
  3434.         jd += (7 * n);
  3435.         strcpy(ybuf,mjd2date(jd));
  3436.         if (*p) {
  3437.             ybuf[8] = ' ';
  3438.             strcpy(ybuf+9,p);
  3439.         } else
  3440.           strcpy(ybuf+8," 00:00:00");
  3441.         s = ybuf;
  3442.         len = strlen(ybuf);
  3443.         debug(F111,"cmcvtdate weeks",s,len);
  3444.         goto normal;
  3445.  
  3446.           case TU_MONTHS: {        /* Months */
  3447.           char tmpmonth[3];
  3448.           int xyear, xmonth;
  3449.           dp = ckdate();
  3450.           tmpyear[0] = dp[0];
  3451.           tmpyear[1] = dp[1];
  3452.           tmpyear[2] = dp[2];
  3453.           tmpyear[3] = dp[3];
  3454.           tmpyear[4] = NUL;
  3455.           tmpmonth[0] = dp[4];
  3456.           tmpmonth[1] = dp[5];
  3457.           tmpmonth[2] = NUL;
  3458.           xyear = atoi(tmpyear);
  3459.           xmonth = atoi(tmpmonth);
  3460.           xmonth += n;
  3461.           xyear += (xmonth / 12);
  3462.           xmonth = (xmonth % 12);
  3463.           if (xmonth <= 0) {
  3464.               xmonth += 12;
  3465.               xyear--;
  3466.           }
  3467.           sprintf(ybuf,"%04d%02d%s",xyear,xmonth,dp+6);
  3468.           if (*p) {
  3469.               ybuf[8] = ' ';
  3470.               strcpy(ybuf+9,p);
  3471.           } else
  3472.             strcpy(ybuf+8," 00:00:00");
  3473.           s = ybuf;
  3474.           len = strlen(ybuf);
  3475.           debug(F111,"cmcvtdate months",s,len);
  3476.           goto normal;
  3477.           }
  3478.           case TU_YEARS: {        /* Years */
  3479.           dp = ckdate();
  3480.           tmpyear[0] = dp[0];
  3481.           tmpyear[1] = dp[1];
  3482.           tmpyear[2] = dp[2];
  3483.           tmpyear[3] = dp[3];
  3484.           tmpyear[4] = NUL;
  3485.           sprintf(ybuf,"%04d%s",(atoi(tmpyear)+n),dp+4);
  3486.           if (*p) {
  3487.               ybuf[8] = ' ';
  3488.               strcpy(ybuf+9,p);
  3489.           } else
  3490.             strcpy(ybuf+8," 00:00:00");
  3491.           s = ybuf;
  3492.           len = strlen(ybuf);
  3493.           debug(F111,"cmcvtdate years",s,len);
  3494.           goto normal;
  3495.           }
  3496.         }
  3497.         return(-1);
  3498.     }
  3499.     i = ckstrpre(s,"today");    /* TODAY */
  3500.     if (i > 2 && (s[i] == NUL || isdatesep(s[i]))) {
  3501.         strncpy(ybuf,ckdate(),8);
  3502.         strcpy(ybuf+8," 00:00:00");
  3503.         if (s[i])
  3504.           strcpy(ybuf+8,s+i);
  3505.         s = ybuf;
  3506.         len = strlen(s);
  3507.         debug(F111,"cmcvtdate today",s,len);
  3508.         goto normal;
  3509.     }
  3510.     i = ckstrpre(s,"tomorrow");    /* TOMORROW */
  3511.     if (i > 2 && (s[i] == NUL || isdatesep(s[i]))) {
  3512.         jd++;
  3513.         strncpy(ybuf,mjd2date(jd),8);
  3514.         strcpy(ybuf+8," 00:00:00");
  3515.         if (s[i]) strcpy(ybuf+8,s+i);
  3516.         s = ybuf;
  3517.         len = strlen(s);
  3518.         debug(F111,"cmcvtdate tomorrow",s,len);
  3519.         goto normal;
  3520.  
  3521.     }
  3522.     i = ckstrpre(s,"yesterday");    /* YESTERDAY */
  3523.     if (i > 0 && (s[i] == NUL || isdatesep(s[i]))) {
  3524.         jd--;
  3525.         strncpy(ybuf,mjd2date(jd),8);
  3526.         strcpy(ybuf+8," 00:00:00");
  3527.         if (s[i]) strcpy(ybuf+8,s+i);
  3528.         s = ybuf;
  3529.         len = strlen(s);
  3530.         debug(F111,"cmcvtdate yesterday",s,len);
  3531.         goto normal;
  3532.     }
  3533.     }
  3534.  
  3535.   normal:
  3536.  
  3537.     if (len >= 8) {            /* Already in right format? */
  3538.     if (isdigit(s[0])  && isdigit(s[1])  &&
  3539.         isdigit(s[2])  && isdigit(s[3])  &&
  3540.         isdigit(s[4])  && isdigit(s[5])  &&
  3541.         isdigit(s[6])  && isdigit(s[7]))
  3542.       if (!s[8]) {
  3543.           strcat(s," 00:00:00");
  3544.           ckstrncpy(cmdatebuf,s,18);
  3545.           debug(F111,"cmcvtdate yyyymmdd",s,rc);
  3546.           return(rc);
  3547.       } else if (len == 17 &&
  3548.              isdigit(s[9])  && isdigit(s[10]) &&
  3549.              isdigit(s[12]) && isdigit(s[13]) &&
  3550.              isdigit(s[15]) && isdigit(s[16]) &&
  3551.              s[11] == ':'   && s[14] == ':'   &&
  3552.              (s[8] == SP || s[8] == '-' || s[8] == '_')) {
  3553.           ckstrncpy(cmdatebuf,s,18);
  3554.           debug(F111,"cmcvtdate yyyymmdd hh:mm:ss",s,rc);
  3555.           return(rc);
  3556.     } else {            /* We have a numeric date */
  3557.         debug(F111,"cmcvtdate yyyymmdd xxx",s,rc);
  3558.         p = s+9;            /* Start of time field */
  3559.  
  3560.         yearbuf[0] = s[0]; yearbuf[1] = s[1];
  3561.         yearbuf[2] = s[2]; yearbuf[3] = s[3];
  3562.         yearbuf[4] = NUL;  year = yearbuf;
  3563.  
  3564.         monbuf[0] = s[4];  monbuf[1] = s[5];
  3565.         monbuf[2] = NUL;   month = monbuf;
  3566.  
  3567.         daybuf[0] = s[6];  daybuf[1] = s[7];
  3568.         daybuf[2] = NUL;   day = daybuf;
  3569.  
  3570.         goto dotime;
  3571.     }
  3572.     }
  3573.     fld[i = 0] = (p = s);        /* First field */
  3574.     while (*p) {            /* Get next two fields */
  3575.     if (isdatesep(*p)) {        /* Have a date separator */
  3576.         *p++ = NUL;            /* Replace by NUL */
  3577.         if (*p) {            /* Now we're at the next field */
  3578.         while (*p == SP) p++;    /* Skip leading spaces */
  3579.         if (!*p) break;        /* Make sure we still have something */
  3580.         if (i == 2)        /* Last one? */
  3581.           break;
  3582.         fld[++i] = p;        /* No, record pointer to this one */
  3583.         } else
  3584.           break;
  3585.     } else if (istimesep(*p)) {    /* Have a time separator */
  3586.         if (isalpha(*p) && !isdigit(*(p-1))) { /* Might be letter */
  3587.         p++;            /* in month name... */
  3588.         continue;
  3589.         }
  3590.         if (i != 0) {        /* After a date */
  3591.         debug(F111,"cmcvtdate date bad timesep",p,-1);
  3592.         return(-1);
  3593.         }
  3594.         nodate = 1;            /* Or without a date */
  3595.         break;
  3596.     }
  3597.     p++;
  3598.     }
  3599.     if (p > s && i == 0)        /* Make sure we have a date */
  3600.       nodate = 1;
  3601.  
  3602.     if (nodate) {            /* No date */
  3603.     char *tmp;            /* Substitute today's date */
  3604.     ztime(&tmp);
  3605.     if (!tmp) {
  3606.         debug(F101,"cmcvtdate null ztime","",-1);
  3607.         return(-1);
  3608.     }
  3609.     if (!*tmp) {
  3610.         debug(F101,"cmcvtdate emtpy ztime","",-1);
  3611.         return(-1);
  3612.     }
  3613.     ckstrncpy(dbuf,tmp,26);        /* Reformat */
  3614.     if (dbuf[8] == SP) dbuf[8] = '0';
  3615.     fld[0] = dbuf+8;
  3616.     dbuf[10] = NUL;
  3617.     fld[1] = dbuf+4;
  3618.     dbuf[7] = NUL;
  3619.     fld[2] = dbuf+20;
  3620.     dbuf[24] = NUL;
  3621.     p = s;                /* Back up source pointer to reparse */
  3622.     } else if (i != 2) {
  3623.     debug(F101,"cmcvtdate fail A","",-1);
  3624.     return(-1);
  3625.     }
  3626.     if (!rdigits(fld[0])) {        /* Now parse the date */
  3627.     debug(F101,"cmcvtdate fail B","",-1);
  3628.     return(-1);
  3629.     }
  3630.     if (!rdigits(fld[1])) {
  3631.     if ((x = lookup(cmonths,fld[1],12,NULL)) < 0) {
  3632.         debug(F101,"cmcvtdate fail C","",-1);
  3633.         return(-1);
  3634.     }
  3635.     sprintf(tmpbuf,"%02d",x);
  3636.     month = tmpbuf;
  3637.     }
  3638.     if (((int)strlen(fld[0]) == 4)) {    /* yyyy-xx-dd */
  3639.     year = fld[0];
  3640.     day = fld[2];
  3641.     if (!month)
  3642.       month = fld[1];        /* yyyy-mm-dd */
  3643.     } else if (((int)strlen(fld[2]) == 4)) { /* xx-xx-yyyy */
  3644.     year = fld[2];
  3645.     if (month) {            /* dd-name-yyyy */
  3646.         day = fld[0];
  3647.     } else {            /* xx-xx-yyyy */
  3648.         int f0, f1;
  3649.         f0 = atoi(fld[0]);
  3650.         f1 = atoi(fld[1]);
  3651.         if ((f0 > 12) && (f1 <= 12)) {
  3652.         day = fld[0];        /* mm-dd-yyyy */
  3653.         month = fld[1];
  3654.         } else if ((f0 <= 12) && (f1 > 12)) {
  3655.         if (!rdigits(fld[1]))
  3656.           return(-1);
  3657.         else
  3658.           day = fld[1];        /* dd-mm-yyyy */
  3659.         month = fld[0];
  3660. #ifdef COMMENT
  3661.         } else if ((f0 <= 12) && (f1 <= 12)) {
  3662.         if (!quiet)
  3663.           printf("?Day and month are ambiguous - \"%s\"\n", o);
  3664.         return(-9);
  3665. #endif /* COMMENT */
  3666.         } else {
  3667.         debug(F101,"cmcvtdate fail D","",-1);
  3668.         return(-1);
  3669.         }
  3670.     }
  3671.     } else {
  3672.     debug(F101,"cmcvtdate fail E","",-1);
  3673.     return(-1);
  3674.     }
  3675.     x = atoi(month);
  3676.     sprintf(tmpbuf,"%02d",x);        /* 2-digit numeric month */
  3677.  
  3678.   dotime:
  3679.     debug(F110,"cmcvtdate dotime s",s,0);
  3680.     debug(F110,"cmcvtdate dotime p",p,0);
  3681.     if ((x  = atoi(day)) > 31) {
  3682.     debug(F101,"cmcvtdate fail K","",-1);
  3683.     return(-1);
  3684.     }
  3685.     if (!*p && t == 0) {
  3686.     sprintf(cmdatebuf,"%s%s%02d",year,month,x);
  3687.     return(0);
  3688.     }
  3689.     fld[i = 0] = *p ? p : "00";        /* First time field */
  3690.     fld[1] = "00";
  3691.     fld[2] = "00";
  3692.     while (*p) {            /* Get the rest, if any */
  3693.     if (istimesep(*p)) {
  3694.         debug(F000,"cmcvtdate timesep:",p,*p);
  3695.         if (*p == 'P' || *p == 'p') {
  3696.         if (*(p+1) != 'M' && *(p+1) != 'm') {
  3697.             debug(F101,"cmcvtdate fail F","",-1);
  3698.             return(-1);
  3699.         } else if (!*(p+2)) {
  3700.             pmflag = 1;
  3701.             *p = NUL;
  3702.             break;
  3703.         } else {
  3704.             debug(F101,"cmcvtdate fail F","",-1);
  3705.             return(-1);
  3706.         }
  3707.         } else if (*p == 'A' || *p == 'a') {
  3708.         if (*(p+1) != 'M' && *(p+1) != 'm') {
  3709.             debug(F101,"cmcvtdate fail F","",-1);
  3710.             return(-1);
  3711.         }
  3712.         if (*(p+2)) {
  3713.             debug(F101,"cmcvtdate fail F","",-1);
  3714.             return(-1);
  3715.         }
  3716.         *p = NUL;
  3717.         break;
  3718.         }
  3719.         *p++ = NUL;
  3720.         if (*p) {
  3721.         while (*p == SP) p++;
  3722.         if (!*p) break;
  3723.         if (i == 2)
  3724.           break;
  3725.         fld[++i] = p;
  3726.         } else
  3727.           break;
  3728.     }
  3729.     p++;
  3730.     }
  3731.     debug(F101,"cmcvtdate time i","",i);
  3732.     debug(F110,"cmcvtdate time fld[0]",fld[0],0);
  3733.     debug(F110,"cmcvtdate time fld[1]",fld[1],0);
  3734.     debug(F110,"cmcvtdate time fld[2]",fld[2],0);
  3735.  
  3736.     if (!rdigits(fld[0]))
  3737.       return(-1);
  3738.  
  3739.     hour = fld[0];
  3740.     if (i >= 1) {
  3741.     if (!rdigits(fld[1]))
  3742.       return(-1);
  3743.     else
  3744.       min = fld[1];
  3745.     }
  3746.     if (i == 2) {
  3747.     if (!rdigits(fld[2]))
  3748.       return(-1);
  3749.     else
  3750.       sec = fld[2];
  3751.     }
  3752.     hh = atoi(hour);
  3753.     if (pmflag && hh <= 11)
  3754.       hh += 12;
  3755.     if ((t != 2 && hh > 24) || hh < 0) {
  3756.     debug(F101,"cmcvtdate fail G","",-1);
  3757.     return(-1);
  3758.     }
  3759.     if ((mm = atoi(min)) > 59) {
  3760.     debug(F101,"cmcvtdate fail H","",-1);
  3761.     return(-1);
  3762.     }
  3763.     if ((ss = atoi(sec)) > 59) {
  3764.     debug(F101,"cmcvtdate fail I","",-1);
  3765.     return(-1);
  3766.     }
  3767.     if (mm < 0 || ss < 0) return(-1);
  3768.     if (t != 2 && (ss > 0 || mm > 0) && hh > 23) {
  3769.     debug(F101,"cmcvtdate fail J","",-1);
  3770.     return(-1);
  3771.     }
  3772.     debug(F110,"cmcvtdate year",year,0);
  3773.     debug(F110,"cmcvtdate month",month,0);
  3774.     debug(F101,"cmcvtdate x","",x);
  3775.     debug(F101,"cmcvtdate hh","",hh);
  3776.     debug(F101,"cmcvtdate mm","",mm);
  3777.     debug(F101,"cmcvtdate ss","",ss);
  3778.  
  3779.     sprintf(cmdatebuf,"%s%s%02d %02d:%02d:%02d",year,month,x,hh,mm,ss);
  3780.  
  3781. #ifdef DEBUG
  3782.     if (deblog) {
  3783.     debug(F101,"cmcvtdate hour","",hh);
  3784.     debug(F101,"cmcvtdate minute","",mm);
  3785.     debug(F101,"cmcvtdate second","",ss);
  3786.     debug(F111,"cmcvtdate result",cmdatebuf,rc);
  3787.     }
  3788. #endif /* DEBLOG */
  3789.     return(0);
  3790. }
  3791.  
  3792.  
  3793. /*  C K C V T D A T E  --  Like cmcvtdate(), but returns string.  */
  3794. /*  For use by date-related functions */
  3795. /*  See calling conventions for cmcvtdate() above. */
  3796.  
  3797. char *
  3798. ckcvtdate(p,t) char * p; int t; {
  3799.     if (cmcvtdate(p,t) < 0)
  3800.       return("<BAD_DATE_OR_TIME>");    /* \fblah() error message */
  3801.     else
  3802.       return((char *) cmdatebuf);
  3803. }
  3804.  
  3805.  
  3806. /*  C M D A T E  --  Parse a date and/or time  */
  3807.  
  3808. /*
  3809.   Accepts date in various formats.  If the date is recognized,
  3810.   this routine returns 0 or greater with the result string pointer
  3811.   pointing to a buffer containing the date as "yyyymmdd hh:mm:ss".
  3812. */
  3813. int
  3814. cmdate(xhlp,xdef,xp,quiet,f) char *xhlp, *xdef, **xp; int quiet; xx_strp f; {
  3815.     int /* i, */ x, rc;
  3816.     char *o, *s, *zq;
  3817.  
  3818.     cmfldflgs = 0;
  3819.     if (!xhlp) xhlp = "";
  3820.     if (!xdef) xdef = "";
  3821.     if (!*xhlp) xhlp = "Date and/or time";
  3822.     *xp = "";
  3823.  
  3824.     rc = cmfld(xhlp,xdef,&s,(xx_strp)0);
  3825.     debug(F101,"cmdate cmfld rc","",rc);
  3826.     if (rc < 0)
  3827.       return(rc);
  3828.     debug(F110,"cmdate 1",s,0);
  3829.     o = s;                /* Remember what they typed. */
  3830.     s = brstrip(s);
  3831.     debug(F110,"cmdate 2",s,0);
  3832.  
  3833.     x = 0;
  3834.     if (f) {                /* If a conversion function is given */
  3835.     char * pp;
  3836.     zq = atxbuf;            /* do the conversion. */
  3837.     pp = atxbuf;
  3838.     atxn = CMDBL;
  3839.     if ((x = (*f)(s,&zq,&atxn)) < 0) return(-2);
  3840.     if (!*pp)
  3841.       pp = xdef;
  3842.     if (setatm(pp,0) < 0) {
  3843.         if (!quiet) printf("?Evaluated date too long\n");
  3844.         return(-9);
  3845.     }
  3846.     s = atxbuf;
  3847.     }
  3848.     rc = cmcvtdate(s,1);
  3849.     if (rc < 0) {
  3850.     if (!quiet) printf("Invalid date or time - \"%s\"\n", o);
  3851.     return(-9);
  3852.     }
  3853.     *xp = cmdatebuf;
  3854.     return(rc);
  3855. }
  3856.  
  3857. #ifdef CK_RECALL            /* Command-recall functions */
  3858.  
  3859. /*  C M R I N I  --  Initialize or change size of command recall buffer */
  3860.  
  3861. int
  3862. cmrini(n) int n; {
  3863.     int i;
  3864.     if (recall && in_recall) {        /* Free old storage, if any */
  3865.     for (i = 0; i < cm_recall; i++) {
  3866.         if (recall[i]) {
  3867.         free(recall[i]);
  3868.         recall[i] = NULL;
  3869.         }
  3870.     }
  3871.     free(recall);
  3872.     recall = NULL;
  3873.     }
  3874.     cm_recall = n;            /* Set new size */
  3875.     rlast = current = -1;        /* Initialize pointers */
  3876.     if (n > 0) {
  3877.     recall = (char **)malloc((cm_recall + 1) * sizeof(char *));
  3878.     if (!recall)
  3879.       return(1);
  3880.     for (i = 0; i < cm_recall; i++) {
  3881.         recall[i] = NULL;
  3882.     }
  3883.     in_recall = 1;            /* Recall buffers init'd */
  3884.     }
  3885.     return(0);
  3886. }
  3887.  
  3888. /*  C M A D D N E X T  --  Force addition of next command */
  3889.  
  3890. VOID
  3891. cmaddnext() {
  3892.     if (on_recall && in_recall) {    /* Even if it doesn't come */
  3893.     force_add = 1;            /* from the keyboard */
  3894.     no_recall = 0;
  3895.     }
  3896. }
  3897.  
  3898. /*  C M G E T C M D  --  Find most recent matching command  */
  3899.  
  3900. char *
  3901. cmgetcmd(s) char * s; {
  3902.     int i;
  3903.     for (i = current; i >= 0; i--) {    /* Search backward thru history list */
  3904.     if (!recall[i]) continue;    /* This one's null, skip it */
  3905.     if (ckmatch(s,recall[i],0,1))    /* Match? */
  3906.       return(recall[i]);        /* Yes, return pointer */
  3907.     }
  3908.     return(NULL);            /* No match, return NULL pointer */
  3909. }
  3910.  
  3911. /*  A D D C M D  --  Add a command to the recall buffer  */
  3912.  
  3913. VOID
  3914. addcmd(s) char * s; {
  3915.     int len;
  3916.  
  3917.     if (!s) s = cmdbuf;
  3918.     len = strlen(s);
  3919.  
  3920. #ifdef CKSYSLOG
  3921.     /* Log all interactive commands */
  3922.     /* Logging macros & TAKE files is way too much */
  3923.     if (ckxlogging) {
  3924.     if (ckxsyslog >= SYSLG_CX || ckxsyslog >= SYSLG_CM && !cmdsrc())
  3925.       cksyslog(SYSLG_CX, 1, "command", s, NULL);
  3926.     }
  3927. #endif /* CKSYSLOG */
  3928.  
  3929.     if ((!cmdsrc() || force_add) &&    /* Reading commands from keyboard? */
  3930.     (on_recall) &&            /* Recall is turned on? */
  3931.     (cm_recall > 0) &&        /* Saving commands? */
  3932.     !no_recall &&            /* Not not saving this command? */
  3933.     len > 0) {            /* Non-null command? */
  3934.  
  3935.     force_add = 0;
  3936.  
  3937.         if (rlast >= cm_recall - 1) {    /* Yes, buffer full? */
  3938.         int i;            /* Yes. */
  3939.         if (recall[0]) {        /* Discard oldest command */
  3940.         free(recall[0]);
  3941.         recall[0] = NULL;
  3942.         }
  3943.         for (i = 0; i < rlast; i++) { /* The rest */
  3944.         recall[i] = recall[i+1]; /* move back */
  3945.         }
  3946.         rlast--;            /* Now we have one less */
  3947.     }
  3948.         rlast++;            /* Index of last command in buffer */
  3949.     current = rlast;        /* Also now the current command */
  3950.     if (current >= cm_recall) {
  3951.         printf("Oops, command recall error\n");
  3952.     } else {
  3953.         recall[current] = malloc(len+1);
  3954.         if (recall[current])
  3955.           strcpy(recall[current],s);
  3956.     }
  3957.     }
  3958. }
  3959. #endif /* CK_RECALL */
  3960.  
  3961. int
  3962. cmgetlc(s) char * s; {            /* Get leading char */
  3963.     char c;
  3964.     while ((c = *s++) <= SP) ;
  3965.     return(c);
  3966. }
  3967.  
  3968.  
  3969. /*  C M C F M  --  Parse command confirmation (end of line)  */
  3970.  
  3971. /*
  3972.  Returns
  3973.    -2: User typed anything but whitespace or newline
  3974.    -1: Reparse needed
  3975.     0: Confirmation was received
  3976. */
  3977. int
  3978. cmcfm() {
  3979.     int x, xc;
  3980.     debug(F101,"cmcfm: cmflgs","",cmflgs);
  3981.     debug(F110,"cmcfm: atmbuf",atmbuf,0);
  3982.     inword = xc = cc = 0;
  3983.  
  3984.     setatm("",0);            /* (Probably unnecessary) */
  3985.  
  3986.     while (cmflgs != 1) {
  3987.         x = gtword(0);
  3988.         xc += cc;
  3989.  
  3990.         switch (x) {
  3991.       case -9:
  3992.         printf("Command or field too long\n");
  3993.       case -4:            /* EOF */
  3994.       case -2:
  3995.       case -1:
  3996.         return(x);
  3997.       case 1:            /* End of line */
  3998.         if (xc > 0) {
  3999.         if (xcmfdb) {
  4000.             return(-6);
  4001.         } else {
  4002.             printf("?Not confirmed - %s\n",atmbuf);
  4003.             return(-9);
  4004.         }
  4005.         } else break;        /* Finish up below */
  4006.       case 2:            /* ESC */
  4007.         if (xc == 0) {
  4008.         bleep(BP_WARN);
  4009.         continue;        /* or fall thru. */
  4010.         }
  4011.       case 0:            /* Space */
  4012.         if (xc == 0)        /* If no chars typed, continue, */
  4013.           continue;            /* else fall thru. */
  4014.         /* else fall thru... */
  4015.  
  4016.       case 3:            /* Question mark */
  4017.         if (xc > 0) {
  4018.         if (xcmfdb) {
  4019.             return(-6);
  4020.         } else {
  4021.             printf("?Not confirmed - %s\n",atmbuf);
  4022.             return(-9);
  4023.         }
  4024.         }
  4025.         printf(
  4026.            "\n Press the Return or Enter key to confirm the command\n");
  4027.         printf("%s%s",cmprom,cmdbuf);
  4028.         fflush(stdout);
  4029.         continue;
  4030.     }
  4031.     }
  4032. #ifdef CK_RECALL
  4033.     addcmd(cmdbuf);
  4034. #endif /* CK_RECALL */
  4035.     return(0);
  4036. }
  4037.  
  4038.  
  4039. /* The following material supports chained parsing functions. */
  4040. /* See ckucmd.h for FDB and OFDB definitions. */
  4041.  
  4042. struct OFDB cmresult = {        /* Universal cmfdb result holder */
  4043.     NULL,
  4044.     0,
  4045.     NULL,
  4046.     0
  4047. };
  4048.  
  4049. VOID
  4050. cmfdbi(p,fc,s1,s2,s3,n1,n2,f,k,nxt)    /* Initialize an FDB */
  4051.     struct FDB * p;
  4052.     int fc;
  4053.     char * s1, * s2, * s3;
  4054.     int n1, n2;
  4055.     xx_strp f;
  4056.     struct keytab * k;
  4057.     struct FDB * nxt; {
  4058.  
  4059.     p->fcode = fc;
  4060.     p->hlpmsg = s1;
  4061.     p->dflt = s2;
  4062.     p->sdata = s3;
  4063.     p->ndata1 = n1;
  4064.     p->ndata2 = n2;
  4065.     p->spf = f;
  4066.     p->kwdtbl = k;
  4067.     p->nxtfdb = nxt;
  4068. }
  4069.  
  4070. /*  C M F D B  --  Parse a field with several possible functions  */
  4071.  
  4072. int
  4073. cmfdb(fdbin) struct FDB * fdbin; {
  4074. #ifndef NOSPL
  4075.     extern int x_ifnum;                 /* IF NUMERIC - disables warnings */
  4076. #endif /* NOSPL */
  4077.     struct FDB * in = fdbin;
  4078.     struct OFDB * out = &cmresult;
  4079.     int x = 0, n;
  4080.     char *s, *xp, *m = NULL;
  4081.     int errbits = 0;
  4082.  
  4083.     xp = bp;
  4084.  
  4085.     out->fcode = -1;            /* Initialize output struct */
  4086.     out->fdbaddr = NULL;
  4087.     out->sresult = NULL;
  4088.     out->nresult = 0;
  4089. /*
  4090.   Currently we make one trip through the FDBs.  So if the user types Esc or
  4091.   Tab at the beginning of a field, only the first FDB is examined for a
  4092.   default.  If the user types ?, help is given only for one FDB.  We should
  4093.   search through the FDBs for all matching possibilities -- and in particular
  4094.   display the pertinent context-sensitive help for each function, rather than
  4095.   the only the first one that works, and then rewind the FDB pointer so we
  4096.   are not locked out of the earlier ones.
  4097. */
  4098.     cmfldflgs = 0;
  4099.     while (1) {                /* Loop through the chain of FDBs */
  4100.     nomsg = 1;
  4101.     xcmfdb = 1;
  4102.     s = NULL;
  4103.     n = 0;
  4104.     debug(F101,"cmfdb in->fcode","",in->fcode);
  4105.     switch (in->fcode) {        /* Current parsing function code */
  4106.       case _CMNUM:
  4107. #ifndef NOSPL
  4108.             x_ifnum = 1;                /* Disables warning messages */
  4109. #endif /* NOSPL */
  4110.         x = cmnum(in->hlpmsg,in->dflt,10,&n,in->spf);
  4111. #ifndef NOSPL
  4112.             x_ifnum = 0;
  4113. #endif /* NOSPL */
  4114.         debug(F101,"cmfdb cmnum","",x);
  4115.         if (x < 0) errbits |= 1;
  4116.         break;
  4117.       case _CMOFI:
  4118.         x = cmofi(in->hlpmsg,in->dflt,&s,in->spf);
  4119.         debug(F101,"cmfdb cmofi","",x);
  4120.         if (x < 0) errbits |= 2;
  4121.         break;
  4122.       case _CMIFI:
  4123.         x = cmifi2(in->hlpmsg,
  4124.                in->dflt,
  4125.                &s,
  4126.                &n,
  4127.                in->ndata1,
  4128.                in->sdata,
  4129.                in->spf,
  4130.                in->ndata2
  4131.                );
  4132.         debug(F101,"cmfdb cmifi2 x","",x);
  4133.         debug(F101,"cmfdb cmifi2 n","",n);
  4134.         if (x < 0) errbits |= 4;
  4135.         break;
  4136.       case _CMFLD:
  4137.         cmfldflgs = in->ndata1;
  4138.         x = cmfld(in->hlpmsg,in->dflt,&s,in->spf);
  4139.         debug(F101,"cmfdb cmfld","",x);
  4140.         if (x < 0) errbits |= 8;
  4141.         break;
  4142.       case _CMTXT:
  4143.         x = cmtxt(in->hlpmsg,in->dflt,&s,in->spf);
  4144.         debug(F101,"cmfdb cmtxt","",x);
  4145.         if (x < 0) errbits |= 16;
  4146.         break;
  4147.       case _CMKEY:
  4148.         x = cmkey2(in->kwdtbl,
  4149.                in->ndata1,
  4150.                in->hlpmsg,in->dflt,in->sdata,in->spf,in->ndata2);
  4151.         debug(F101,"cmfdb cmkey","",x);
  4152.         if (x < 0) errbits |= ((in->ndata2 & 4) ? 32 : 64);
  4153.         break;
  4154.       case _CMCFM:
  4155.         x = cmcfm();
  4156.         debug(F101,"cmfdb cmcfm","",x);
  4157.         if (x < 0) errbits |= 128;
  4158.         break;
  4159.       default:
  4160.         debug(F101,"cmfdb - unexpected function code","",in->fcode);
  4161.         printf("?cmfdb - unexpected function code: %d\n",in->fcode);
  4162.     }
  4163.     debug(F101,"cmfdb x","",x);
  4164.     debug(F101,"cmfdb cmflgs","",cmflgs);
  4165.     debug(F101,"cmfdb crflag","",crflag);
  4166.     debug(F101,"cmfdb qmflag","",qmflag);
  4167.     debug(F101,"cmfdb esflag","",esflag);
  4168.  
  4169.     if (x > -1) {            /* Success */
  4170.         out->fcode = in->fcode;    /* Fill in output struct */
  4171.         out->fdbaddr = in;
  4172.         out->sresult = s;
  4173.         out->nresult = (in->fcode == _CMKEY) ? x : n;
  4174.         out->kflags = (in->fcode == _CMKEY) ? cmkwflgs : 0;
  4175.         debug(F101,"cmfdb out->nresult","",out->nresult);
  4176.         nomsg = 0;
  4177.         xcmfdb = 0;
  4178.         debug(F111,"cmfdb cmdbuf & crflag",cmdbuf,crflag);
  4179.         if (crflag) {
  4180.         cmflgs = 1;
  4181. #ifdef CK_RECALL
  4182.         debug(F101,"cmfdb code","",in->fcode);
  4183.         if (in->fcode != _CMCFM)
  4184.           addcmd(cmdbuf);
  4185. #endif /* CK_RECALL */
  4186.         }
  4187.         return(x);            /* and return */
  4188.     }
  4189.     in = in->nxtfdb;        /* Failed, get next parsing function */
  4190.     nomsg = 0;
  4191.     xcmfdb = 0;
  4192.     if (!in) {            /* No more */
  4193.         debug(F101,"cmfdb failure x","",x);
  4194.         debug(F101,"cmfdb failure errbits","",errbits);
  4195.         if (x == -6)
  4196.           x = -9;
  4197.         if (x == -9) {
  4198.         /* Make informative messages for a few common cases */
  4199.         switch (errbits) {
  4200.           case 4+32: m = "Does not match filename or switch"; break;
  4201.           case 4+64: m = "Does not match filename or keyword"; break;
  4202.           case 1+32: m = "Not a number or valid keyword"; break;
  4203.           case 1+64: m = "Not a number or valid switch"; break;
  4204.           default: m = "Not valid in this position";
  4205.         }
  4206.         printf("?%s: \"%s\"\n",m, atmbuf);
  4207.         }
  4208.         return(x);
  4209.     }
  4210.     if (x != -2 && x != -6 && x != -9 && x != -3) /* Editing or somesuch */
  4211.       return(x);            /* Go back and reparse */
  4212.     pp = np = bp = xp;        /* Back up pointers */
  4213.     cmflgs = -1;            /* Force a reparse */
  4214.  
  4215.  
  4216. #ifndef NOSPL
  4217.     if (!askflag) {            /* If not executing ASK-class cmd... */
  4218. #endif /* NOSPL */
  4219.         if (crflag) {        /* If CR was typed, put it back */
  4220.         pushc = LF;        /* But as a linefeed */
  4221.         } else if (qmflag) {    /* Ditto for Question mark */
  4222.         pushc = '?';
  4223.         } else if (esflag) {    /* and Escape or Tab */
  4224.         pushc = ESC;
  4225.         }
  4226. #ifndef NOSPL
  4227.     }
  4228. #endif /* NOSPL */
  4229.     }
  4230. }
  4231.  
  4232. #ifdef OLDHELP
  4233. /* Keyword help routines */
  4234.  
  4235. /*  C L R H L P -- Initialize/Clear the help line buffer  */
  4236.  
  4237. static VOID
  4238. clrhlp() {                              /* Clear the help buffer */
  4239.     hlpbuf[0] = NUL;
  4240.     hh = hx = 0;
  4241. }
  4242.  
  4243.  
  4244. /*  A D D H L P  --  Add a string to the help line buffer  */
  4245.  
  4246. static VOID
  4247. addhlp(s) char *s; {                    /* Add a word to the help buffer */
  4248.     int j;
  4249.  
  4250.     hh++;                               /* Count this column */
  4251.  
  4252.     for (j = 0; (j < hc) && (*s != NUL); j++) { /* Fill the column */
  4253.         hlpbuf[hx++] = *s++;
  4254.     }
  4255.     if (*s != NUL)                      /* Still some chars left in string? */
  4256.         hlpbuf[hx-1] = '+';             /* Mark as too long for column. */
  4257.  
  4258.     if (hh < (hw / hc)) {               /* Pad col with spaces if necessary */
  4259.         for (; j < hc; j++) {
  4260.             hlpbuf[hx++] = SP;
  4261.         }
  4262.     } else {                            /* If last column, */
  4263.         hlpbuf[hx++] = NUL;             /* no spaces. */
  4264.         dmphlp();                       /* Print it. */
  4265.         return;
  4266.     }
  4267. }
  4268.  
  4269. /*  D M P H L P  --  Dump the help line buffer  */
  4270.  
  4271. static VOID
  4272. dmphlp() {                              /* Print the help buffer */
  4273.     hlpbuf[hx++] = NUL;
  4274.     if ( hlpbuf[0] )
  4275.        printf(" %s\n",hlpbuf);
  4276.     clrhlp();
  4277. }
  4278. #endif /* OLDHELP */
  4279.  
  4280. /*  G T W O R D  --  Gets a "word" from the command input stream  */
  4281.  
  4282. /*
  4283. Usage: retcode = gtword(brk);
  4284.   brk = 0 for normal word breaks (space, CR, Esc, ?)
  4285.   brk = 1 to add / : = (for parsing switches)
  4286.  
  4287. Returns:
  4288. -10 Timelimit set and timed out
  4289.  -9 if input was too long
  4290.  -4 if end of file (e.g. pipe broken)
  4291.  -3 if null field
  4292.  -2 if command buffer overflows
  4293.  -1 if user did some deleting
  4294.   0 if word terminates with SP or tab
  4295.   1 if ... CR
  4296.   2 if ... ESC
  4297.   3 if ... ? (question mark)
  4298.   4 if ... : or = and called with brk != 0
  4299.  
  4300. With:
  4301.   pp pointing to beginning of word in buffer
  4302.   bp pointing to after current position
  4303.   atmbuf containing a copy of the word
  4304.   cc containing the number of characters in the word copied to atmbuf
  4305. */
  4306.  
  4307. int
  4308. ungword() {                /* Unget a word */
  4309.     debug(F101,"ungword cmflgs","",cmflgs);
  4310.     if (ungw) return(0);
  4311.     cmfsav = cmflgs;
  4312.     ungw = 1;
  4313.     cmflgs = 0;
  4314.     return(0);
  4315. }
  4316.  
  4317. /* Un-un-get word.  Undo ungword() if it has been done. */
  4318.  
  4319. VOID
  4320. unungw() {
  4321.     debug(F110,"unungw atmbuf",atmbuf,cmflgs);
  4322.     if (ungw) {
  4323.     ungw = 0;
  4324.     cmflgs = cmfsav;
  4325.     atmbuf[0] = NUL;
  4326.     }
  4327. }
  4328.  
  4329. static int
  4330. gtword(brk) int brk; {
  4331.     int c;                              /* Current char */
  4332.     int quote = 0;                      /* Flag for quote character */
  4333.     int echof = 0;                      /* Flag for whether to echo */
  4334.     int comment = 0;            /* Flag for in comment */
  4335.     char *cp = NULL;            /* Comment pointer */
  4336.     int eintr = 0;
  4337.     int bracelvl = 0;            /* nested brace counter [jrs] */
  4338.     int iscontd = 0;
  4339.     char lastchar = NUL;
  4340.     char prevchar = NUL;
  4341.     char lbrace, rbrace;
  4342.  
  4343. #ifdef RTU
  4344.     extern int rtu_bug;
  4345. #endif /* RTU */
  4346.  
  4347. #ifdef IKSD
  4348.     extern int inserver;
  4349. #endif /* IKSD */
  4350. #ifdef CK_LOGIN
  4351.     extern int x_logged;
  4352. #endif /* CK_LOGIN */
  4353.  
  4354.     extern int kstartactive;
  4355.  
  4356. #ifdef datageneral
  4357.     extern int termtype;                /* DG terminal type flag */
  4358.     extern int con_reads_mt;            /* Console read asynch is active */
  4359.     if (con_reads_mt) connoi_mt();      /* Task would interfere w/cons read */
  4360. #endif /* datageneral */
  4361.  
  4362.     if (cmfldflgs & 1) {
  4363.     lbrace = '(';
  4364.     rbrace = ')';
  4365.     } else {
  4366.     lbrace = '{';
  4367.     rbrace = '}';
  4368.     }
  4369.     crflag = 0;
  4370.     qmflag = 0;
  4371.     esflag = 0;
  4372.  
  4373.     if (swarg) {            /* No leading space for switch args */
  4374.     inword = 1;
  4375.     swarg = 0;
  4376.     }
  4377.     debug(F000,"gtword brkchar","",brkchar);
  4378.     debug(F101,"gtword brk","",brk);
  4379.     if (ungw) {                /* Have a word saved? */
  4380.     int x;
  4381.     debug(F110,"gtword ungetting from pp",pp,0);
  4382.     while (*pp++ == SP) ;
  4383.     if (setatm(pp,2) < 0) {
  4384.         printf("?Saved word too long\n");
  4385.         return(-9);
  4386.     }
  4387.     strncpy(atmbuf,pp,ATMBL);
  4388.     atmbuf[ATMBL] = NUL;
  4389.     x = strlen(atmbuf);
  4390.     while (x > 0 && atmbuf[x-1] == SP) /* Trim trailing spaces */
  4391.       atmbuf[--x] = NUL;
  4392.     ungw = 0;
  4393.     cmflgs = cmfsav;
  4394.     debug(F111,"gtword returning atmbuf",atmbuf,cmflgs);
  4395.     return(cmflgs);
  4396.     }
  4397.     pp = np;                            /* Start of current field */
  4398.  
  4399.     debug(F110,"gtword cmdbuf",cmdbuf,0);
  4400.     debug(F110,"gtword bp",bp,0);
  4401.     debug(F110,"gtword pp",pp,0);
  4402.  
  4403.     while (bp < cmdbuf+CMDBL) {         /* Big get-a-character loop */
  4404.     echof = 0;            /* Assume we don't echo because */
  4405.     chsrc = 0;            /* character came from reparse buf. */
  4406. #ifdef BS_DIRSEP
  4407. CMDIRPARSE:
  4408. #endif /* BS_DIRSEP */
  4409.     c = *bp;
  4410.         if (!c) {            /* If no char waiting in reparse buf */
  4411.         if (dpx && (!pushc
  4412. #ifndef NOSPL
  4413.             || askflag
  4414. #endif /* NOSPL */
  4415.             )) /* get from tty, set echo flag */
  4416.           echof = 1;
  4417.         debug(F101,"gtword timelimit","",timelimit);
  4418.         c = cmdgetc(timelimit);    /* Read a command character. */
  4419.         debug(F101,"gtword c","",c);
  4420.         debug(F111,"gtword dpx,echof",ckitoa(dpx),echof);
  4421.         if (timelimit && c < -1) {    /* Timed out */
  4422.         return(-10);
  4423.         }
  4424.  
  4425. #ifndef NOXFER
  4426. /*
  4427.   The following allows packet recognition in the command parser.
  4428.   Presently it works only for Kermit packets, and if our current protocol
  4429.   happens to be anything besides Kermit, we simply force it to Kermit.
  4430.   We don't use the APC mechanism here for mechanical reasons, and also
  4431.   because this way, it works even with minimally configured interactive
  4432.   versions.  Add Zmodem later...
  4433. */
  4434. #ifdef CK_AUTODL
  4435.         if (!local && cmdadl    /* Autodownload enabled? */
  4436. #ifdef IKS_OPTION
  4437.         || TELOPT_SB(TELOPT_KERMIT).kermit.me_start
  4438. #endif /* IKS_OPTION */
  4439.         ) {
  4440.         int k;
  4441.         k = kstart((CHAR)c);    /* Kermit S or I packet? */
  4442.         if (k) {
  4443.             int ksign = 0;
  4444.             if (k < 0) {    /* Minus-Protocol? */
  4445. #ifdef NOSERVER
  4446.             goto noserver;    /* Need server mode for this */
  4447. #else
  4448.             ksign = 1;    /* Remember */
  4449.             k = 0 - k;    /* Convert to actual protocol */
  4450.             justone = 1;    /* Flag for protocol module */
  4451. #endif /* NOSERVER */
  4452.             } else
  4453.               justone = 0;
  4454.             k--;        /* Adjust kstart's return value */
  4455.             if (k == PROTO_K) {
  4456.             extern int protocol, g_proto;
  4457.             extern CHAR sstate;
  4458.             g_proto = protocol;
  4459.             protocol = PROTO_K; /* Crude... */
  4460.             sstate = ksign ? 'x' : 'v';
  4461.             cmdbuf[0] = NUL;
  4462.             return(-3);
  4463.             }
  4464.         }
  4465.         }
  4466. #ifdef NOSERVER
  4467.       noserver:
  4468. #endif /* NOSERVER */
  4469. #endif /* CK_AUTODL */
  4470. #endif /* NOXFER */
  4471.  
  4472.         chsrc = 1;            /* Remember character source is tty. */
  4473.         brkchar = c;
  4474.  
  4475. #ifdef IKSD
  4476.             if (inserver && c < 0) {    /* End of session? */
  4477.                 debug(F111,"gtword c < 0","exiting",c);
  4478.                 return(-4);             /* Cleanup and terminate */
  4479.             }
  4480. #endif /* IKSD */
  4481.  
  4482. #ifdef OS2
  4483.            if (c < 0) {            /* Error */
  4484.            if (c == -3) {        /* Empty word? */
  4485.            if (blocklvl > 0)    /* In a block */
  4486.              continue;        /* so keep looking for block end */
  4487.            else
  4488.              return(-3);    /* Otherwise say we got nothing */
  4489.            } else {            /* Not empty word */
  4490.            return(-4);        /* So some kind of i/o error */
  4491.            }
  4492.            }
  4493. #else
  4494. #ifdef MAC
  4495.        if (c == -3)            /* Empty word... */
  4496.          if (blocklvl > 0)
  4497.            continue;
  4498.          else
  4499.            return(-3);
  4500. #endif /* MAC */
  4501. #endif /* OS2 */
  4502.        if (c == EOF) {        /* This can happen if stdin not tty. */
  4503. #ifdef EINTR
  4504. /*
  4505.   Some operating and/or C runtime systems return EINTR for no good reason,
  4506.   when the end of the standard input "file" is encountered.  In cases like
  4507.   this, we get into an infinite loop; hence the eintr counter, which is reset
  4508.   to 0 upon each call to this routine.
  4509. */
  4510.         debug(F101,"gtword EOF","",errno);
  4511.         if (errno == EINTR && ++eintr < 4) /* When bg'd process is */
  4512.           continue;        /* fg'd again. */
  4513. #endif /* EINTR */
  4514.         return(-4);
  4515.         }
  4516.         c &= cmdmsk;        /* Strip any parity bit */
  4517.     }                /* if desired. */
  4518.  
  4519. /* Now we have the next character */
  4520.  
  4521.     debug(F000,"gtword char","",c);
  4522.  
  4523.     if (quote && (c == CR || c == LF)) { /* Enter key following quote */
  4524.         *bp++ = CMDQ;        /* Double it */
  4525.         *bp = NUL;
  4526.         quote = 0;
  4527.     }
  4528.         if (quote == 0) {        /* If this is not a quoted character */
  4529.             if (c == CMDQ) {        /* Got the quote character itself */
  4530.         if (!comment && quoting)
  4531.           quote = 1;        /* Flag it if not in a comment */
  4532.             }
  4533.         if (c == FF) {        /* Formfeed. */
  4534.                 c = NL;                 /* Replace with newline */
  4535.         cmdclrscn();        /* Clear the screen */
  4536.             }
  4537.         if (c == HT) {        /* Tab */
  4538.         if (comment)        /* If in comment, */
  4539.           c = SP;        /* substitute space */
  4540.         else            /* otherwise */
  4541.           c = ESC;        /* substitute ESC (for completion) */
  4542.         }
  4543.         if (c == ';' || c == '#') { /* Trailing comment */
  4544.         if (inword == 0 && quoting) { /* If not in a word */
  4545.             comment = 1;    /* start a comment. */
  4546.             cp = bp;        /* remember where it starts. */
  4547.         }
  4548.         }
  4549.         if (!kstartactive &&    /* Not in possible Kermit packet */
  4550.         !comment && c == SP) {    /* Space not in comment */
  4551.                 *bp++ = (char) c;    /* deposit in buffer if not already */
  4552.         debug(F101,"gtword echof 2","",echof);
  4553. #ifdef BEBOX
  4554.                 if (echof) {
  4555.                     putchar(c);        /* echo it. */
  4556.                     fflush(stdout);
  4557.                     fflush(stderr);
  4558.                 }
  4559. #else
  4560.                 if (echof) {        /* echo it. */
  4561.             putchar((CHAR)c);
  4562.             if (timelimit)
  4563.               fflush(stdout);
  4564.         }
  4565. #endif /* BEBOX */
  4566.                 if (inword == 0) {      /* If leading, gobble it. */
  4567.                     pp++;
  4568.                     continue;
  4569.                 } else {                /* If terminating, return. */
  4570.             if ((*pp != lbrace) || (bracelvl == 0)) {
  4571.             np = bp;
  4572.             cmbptr = np;
  4573.             if (setatm(pp,0) < 0) {
  4574.                 printf("?Field too long error 1\n");
  4575.                 debug(F111,"gtword too long #1",pp,strlen(pp));
  4576.                 return(-9);
  4577.             }
  4578.             brkchar = c;
  4579.             inword = cmflgs = 0;
  4580.             return(0);
  4581.             }
  4582.                     continue;
  4583.                 }
  4584.             }
  4585.         if (!kstartactive && !comment && brk && (c == '=' || c == ':')) {
  4586.                 *bp++ = (char) c;
  4587. #ifdef BEBOX
  4588.                 if (echof) {
  4589.                     putchar(c);        /* echo it. */
  4590.                     fflush(stdout);
  4591.                     fflush(stderr);
  4592.                 }
  4593. #else
  4594.         if (echof) {
  4595.             putchar((CHAR)c);
  4596.             if (timelimit)
  4597.               fflush(stdout);
  4598.         }
  4599. #endif /* BEBOX */
  4600.         if ((*pp != lbrace) || (bracelvl == 0)) {
  4601.             np = bp;
  4602.             cmbptr = np;
  4603.             if (setatm(pp,0) < 0) {
  4604.             printf("?Field too long error 1\n");
  4605.             debug(F111,"gtword too long #1",pp,strlen(pp));
  4606.             return(-9);
  4607.             }
  4608.             inword = cmflgs = 0;
  4609.             brkchar = c;
  4610.             return(4);
  4611.         }
  4612.             }
  4613.             if (c == lbrace)
  4614.               bracelvl++;
  4615.             if (c == rbrace) {
  4616.                 bracelvl--;
  4617.                 if (linebegin)
  4618.           blocklvl--;
  4619.             }
  4620.             if (c == LF || c == CR) {    /* CR or LF. */
  4621.         if (echof) {
  4622.                     cmdnewl((char)c);    /* echo it. */
  4623. #ifdef BEBOX
  4624.                     fflush(stdout);
  4625.                     fflush(stderr);
  4626. #endif /* BEBOX */
  4627.                 }
  4628.         {
  4629.             /* Trim trailing comment and whitespace */
  4630.             char *qq;
  4631.             if (comment) {    /* Erase comment */
  4632.             while (bp >= cp) /* Back to comment pointer */
  4633.               *bp-- = NUL;
  4634.             bp++;
  4635.             pp = bp;    /* Adjust other pointers */
  4636.             inword = 0;    /* and flags */
  4637.             comment = 0;
  4638.             cp = NULL;
  4639.             }
  4640.             qq = inword ? pp : (char *)cmdbuf;
  4641.             /* Erase trailing whitespace */
  4642.             while (bp > qq && (*(bp-1) == SP || *(bp-1) == HT)) {
  4643.             bp--;
  4644.             debug(F000,"erasing","",*bp);
  4645.             *bp = NUL;
  4646.             }
  4647.             lastchar = (bp > qq) ? *(bp-1) : NUL;
  4648.             prevchar = (bp > qq+1) ? *(bp-2) : NUL;
  4649.         }
  4650.         if (linebegin && blocklvl > 0) /* Blank line in {...} block */
  4651.           continue;
  4652.  
  4653.         linebegin = 1;        /* At beginning of next line */
  4654.         iscontd = prevchar != CMDQ &&
  4655.           (lastchar == '-' || lastchar == lbrace);
  4656.         debug(F101,"gtword iscontd","",iscontd);
  4657.  
  4658.                 if (iscontd) {        /* If line is continued... */
  4659.                     if (chsrc) {    /* If reading from tty, */
  4660.                         if (*(bp-1) == lbrace) { /* Check for "begin block" */
  4661.                             *bp++ = SP;    /* Insert a space for neatness */
  4662.                             blocklvl++;    /* Count block nesting level */
  4663.                         } else {    /* Or hyphen */
  4664.                 bp--;    /* Overwrite the hyphen */
  4665.                         }
  4666.                         *bp = NUL;    /* erase the dash, */
  4667.                         continue;    /* and go back for next char now. */
  4668.                     }
  4669.         } else if (blocklvl > 0) { /* No continuation character */
  4670.             if (chsrc) {    /* But we're in a "block" */
  4671.             *bp++ = ',';    /* Add comma */
  4672.             *bp = NUL;
  4673.             continue;
  4674.             }
  4675.         } else {        /* No continuation, end of command. */
  4676.             *bp = NUL;        /* Terminate the command string. */
  4677.             if (comment) {    /* If we're in a comment, */
  4678.             comment = 0;    /* Say we're not any more, */
  4679.             *cp = NUL;    /* cut it off. */
  4680.             }
  4681.             np = bp;        /* Where to start next field. */
  4682.             cmbptr = np;
  4683.             if (setatm(pp,0) < 0) { /* Copy field to atom buffer */
  4684.             debug(F111,"gtword too long #2",pp,strlen(pp));
  4685.             printf("?Field too long error 2\n");
  4686.             return(-9);
  4687.             }
  4688.             inword = 0;        /* Not in a word any more. */
  4689.             crflag = 1;
  4690.                     debug(F110,"gtword","crflag is set",0);
  4691.             return(cmflgs = 1);
  4692.         }
  4693.             }
  4694.  
  4695.         /* Question mark */
  4696.  
  4697.             if ((c == '?')
  4698.         && quoting
  4699.         && !kstartactive
  4700.         && !comment
  4701.         && cmdsrc() == 0    /* Commands coming from terminal */
  4702.         && chsrc != 0        /* and NOT from reparse buffer! */
  4703.         ) {
  4704.                 putchar((CHAR)c);
  4705.                 *bp = NUL;
  4706.                 if (setatm(pp,0) < 0) {
  4707.             debug(F111,"gtword too long #3",pp,strlen(pp));
  4708.             printf("?Too long #3\n");
  4709.             return(-9);
  4710.         }
  4711.         qmflag = 1;
  4712.                 return(cmflgs = 3);
  4713.             }
  4714.             if (c == ESC) {        /* ESC */
  4715.         if (!comment) {
  4716.             *bp = NUL;
  4717.             if (setatm(pp,0) < 0) {
  4718.             debug(F111,"gtword too long #4",pp,strlen(pp));
  4719.             printf("?Too long #4\n");
  4720.             return(-9);
  4721.             }
  4722.             esflag = 1;
  4723.             return(cmflgs = 2);
  4724.         } else {
  4725.             bleep(BP_WARN);
  4726.             continue;
  4727.         }
  4728.             }
  4729.             if (c == BS || c == RUB) {  /* Character deletion */
  4730.                 if (bp > cmdbuf) {      /* If still in buffer... */
  4731.             cmdchardel();    /* erase it. */
  4732.                     bp--;               /* point behind it, */
  4733. #ifdef COMMENT
  4734.                     if (*bp == SP) inword = 0; /* Flag if current field gone */
  4735. #else
  4736. /* fixed by Ulli Schlueter */
  4737.                     if (*bp == lbrace) bracelvl--; /* Adjust brace count */
  4738.                     if (*bp == rbrace) bracelvl++;
  4739.                     if ((*bp == SP) &&       /* Flag if current field gone */
  4740.             (*pp != lbrace || bracelvl == 0))
  4741.               inword = 0;
  4742. #endif /* COMMENT */
  4743.                     *bp = NUL;          /* Erase character from buffer. */
  4744.                 } else {                /* Otherwise, */
  4745.             bleep(BP_WARN);
  4746.                     cmres();            /* and start parsing a new command. */
  4747.             *bp = *atmbuf = NUL;
  4748.                 }
  4749.                 if (pp < bp) continue;
  4750.                 else return(cmflgs = -1);
  4751.             }
  4752.             if (c == LDEL) {            /* ^U, line deletion */
  4753.                 while ((bp--) > cmdbuf) {
  4754.                     cmdchardel();
  4755.                     *bp = NUL;
  4756.                 }
  4757.                 cmres();                /* Restart the command. */
  4758.         *bp = *atmbuf = NUL;
  4759.                 inword = 0;
  4760.                 return(cmflgs = -1);
  4761.             }
  4762.             if (c == WDEL) {            /* ^W, word deletion */
  4763.                 if (bp <= cmdbuf) {     /* Beep if nothing to delete */
  4764.             bleep(BP_WARN);
  4765.                     cmres();
  4766.             *bp = *atmbuf = NUL;
  4767.                     return(cmflgs = -1);
  4768.                 }
  4769.                 bp--;
  4770.         /* Back up over any trailing nonalphanums */
  4771.         /* This is dependent on ASCII collating sequence */
  4772.         /* but isalphanum() is not available everywhere. */
  4773.                 for ( ; (bp >= cmdbuf) &&
  4774.              (*bp < '0') ||
  4775.              (*bp > '9' && *bp < '@') ||
  4776.              (*bp > 'Z' && *bp < 'a') ||
  4777.              (*bp > 'z') ; bp--) {
  4778.                     cmdchardel();
  4779.                     *bp = NUL;
  4780.                 }
  4781.         /* Now delete back to rightmost remaining nonalphanum */
  4782.                 for ( ; (bp >= cmdbuf) && (*bp) ; bp--) {
  4783.             if ((*bp < '0') ||
  4784.             (*bp > '9' && *bp < '@') ||
  4785.             (*bp > 'Z' && *bp < 'a') ||
  4786.             (*bp > 'z'))
  4787.               break;
  4788.                     cmdchardel();
  4789.                     *bp = NUL;
  4790.                 }
  4791.                 bp++;
  4792.                 inword = 0;
  4793.                 return(cmflgs = -1);
  4794.             }
  4795.             if (c == RDIS) {            /* ^R, redisplay */
  4796. #ifdef COMMENT
  4797.                 *bp = NUL;
  4798.                 printf("\n%s%s",cmprom,cmdbuf);
  4799. #else
  4800.         char *cpx; char cx;
  4801.                 *bp = NUL;
  4802.                 printf("\n%s",cmprom);
  4803.         cpx = cmdbuf;
  4804.         while (cx = *cpx++) {
  4805. #ifdef isprint
  4806.             putchar((CHAR) (isprint(cx) ? cx : '^'));
  4807. #else
  4808.             putchar((CHAR) ((cx >= SP && cx < DEL) ? cx : '^'));
  4809. #endif /* isprint */
  4810.         }
  4811. #endif /* COMMENT */
  4812.         fflush(stdout);
  4813.                 continue;
  4814.             }
  4815. #ifdef CK_RECALL
  4816.         if (chsrc && on_recall &&    /* Reading commands from keyboard? */
  4817.         (cm_recall > 0) &&    /* Saving commands? */
  4818.         (c == C_UP || c == C_UP2)) { /* Go up one */
  4819.         if (current < 0) {    /* Nowhere to go, */
  4820.             bleep(BP_WARN);
  4821.             continue;
  4822.         }
  4823.         if (recall[current]) {
  4824.             if (!strcmp(recall[current],cmdbuf)) {
  4825.             if (current > 0) {
  4826.                 current--;
  4827.             } else {
  4828.                 bleep(BP_WARN);
  4829.                 continue;
  4830.             }
  4831.             }
  4832.         }
  4833.         if (recall[current]) { /* We have a previous command */
  4834.             while ((bp--) > cmdbuf) { /* Erase current line */
  4835.             cmdchardel();
  4836.             *bp = NUL;
  4837.             }
  4838.             ckstrncpy(cmdbuf,recall[current],CMDBL);
  4839. #ifdef OSK
  4840.             fflush(stdout);
  4841.             write(fileno(stdout), "\r", 1);
  4842.             printf("%s%s",cmprom,cmdbuf);
  4843. #else
  4844.             printf("\r%s%s",cmprom,cmdbuf);
  4845. #endif /* OSK */
  4846.             current--;
  4847.         }
  4848.         return(cmflgs = -1);    /* Force a reparse */
  4849.         }
  4850.         if (chsrc && on_recall &&    /* Reading commands from keyboard? */
  4851.         (cm_recall > 0) &&    /* Saving commands? */
  4852.         (c == C_DN)) {        /* Down one */
  4853.         if (current + 1 > rlast) { /* Already at bottom, just beep */
  4854.             bleep(BP_WARN);
  4855.             continue;
  4856.         }
  4857.         current++;        /* OK to go down */
  4858.         if (recall[current]) {
  4859.             if (!strcmp(recall[current],cmdbuf)) {
  4860.             if (current + 1 > rlast) { /* At bottom, beep */
  4861.                 bleep(BP_WARN);
  4862.                 continue;
  4863.             } else
  4864.               current++;
  4865.             }
  4866.         }
  4867.         if (recall[current]) {
  4868.             while ((bp--) > cmdbuf) { /* Erase current line */
  4869.             cmdchardel();
  4870.             *bp = NUL;
  4871.             }
  4872.             ckstrncpy(cmdbuf,recall[current],CMDBL);
  4873. #ifdef OSK
  4874.             fflush(stdout);
  4875.             write(fileno(stdout), "\r", 1);
  4876.             printf("%s%s",cmprom,cmdbuf);
  4877. #else
  4878.             printf("\r%s%s",cmprom,cmdbuf);
  4879. #endif /* OSK */
  4880.             return(cmflgs = -1); /* Force reparse */
  4881.         }
  4882.         }
  4883. #endif /* CK_RECALL */
  4884.  
  4885.         if (c < SP && quote == 0) { /* Any other unquoted control char */
  4886.         if (!chsrc) {        /* If cmd file, point past it */
  4887.             bp++;
  4888.         } else {
  4889.             bleep(BP_WARN);
  4890.         }
  4891.         continue;        /* continue, don't put in buffer */
  4892.         }
  4893.         linebegin = 0;        /* Not at beginning of line */
  4894. #ifdef BEBOX
  4895.         if (echof) {
  4896.                 cmdecho((char) c, 0);    /* Echo what was typed. */
  4897.                 fflush (stdout);
  4898.                 fflush(stderr);
  4899.             }
  4900. #else
  4901.             if (echof) cmdecho((char) c, 0); /* Echo what was typed. */
  4902. #endif /* BEBOX */
  4903.         } else {            /* This character was quoted. */
  4904.         int qf = 1;
  4905.         quote = 0;            /* Unset the quote flag. */
  4906.         debug(F000,"gtword quote 0","",c);
  4907.         /* Quote character at this level is only for SP, ?, and controls */
  4908.             /* If anything else was quoted, leave quote in, and let */
  4909.         /* the command-specific parsing routines handle it, e.g. \007 */
  4910.         if (c > 32 && c != '?' && c != RUB && chsrc != 0) {
  4911.         debug(F000,"gtword quote 1","",c);
  4912.         *bp++ = CMDQ;        /* Deposit \ if it came from tty */
  4913.         qf = 0;            /* and don't erase it from screen */
  4914.         linebegin = 0;        /* Not at beginning of line */
  4915. #ifdef BS_DIRSEP
  4916. /*
  4917.   This is a hack to handle "cd \" or "cd foo\" on OS/2 and similar systems.
  4918.   If we were called from cmdir() and the previous character was the quote
  4919.   character, i.e. backslash, and this character is the command terminator,
  4920.   then we stuff an extra backslash into the buffer without echoing, then
  4921.   we stuff the carriage return back in again, and go back and process it,
  4922.   this time with the quote flag off.
  4923. */
  4924.         } else if (dirnamflg && (c == CR || c == LF || c == SP)) {
  4925.         debug(F000,"gtword quote 2","",c);
  4926.         *bp++ = CMDQ;
  4927.         linebegin = 0;        /* Not at beginning of line */
  4928.         *bp = (c == SP ? SP : CR);
  4929.         goto CMDIRPARSE ;
  4930. #endif /* BS_DIRSEP */
  4931.         } else {
  4932.         debug(F000,"gtword quote 3","",c);
  4933.         }
  4934. #ifdef BEBOX
  4935.         if (echof) {
  4936.                 cmdecho((char) c, qf);    /* Echo what was typed. */
  4937.                 fflush (stdout);
  4938.                 fflush(stderr);
  4939.             }
  4940. #else
  4941.         if (echof) cmdecho((char) c, qf); /* Now echo quoted character */
  4942. #endif /* BEBOX */
  4943.         debug(F111,"gtword quote",cmdbuf,c);
  4944.     }
  4945. #ifdef COMMENT
  4946.         if (echof) cmdecho((char) c,quote); /* Echo what was typed. */
  4947. #endif /* COMMENT */
  4948.         if (!comment) inword = 1;    /* Flag we're in a word. */
  4949.     if (quote) continue;        /* Don't deposit quote character. */
  4950.         if (c != NL) {            /* Deposit command character. */
  4951.         *bp++ = (char) c;        /* and make sure there is a NUL */
  4952. #ifdef COMMENT
  4953.         *bp = NUL;            /* after it */
  4954. #endif /* COMMENT */
  4955.     }
  4956.     }                                   /* End of big while */
  4957.     bleep(BP_WARN);
  4958.     printf("?Command too long, maximum length: %d.\n",CMDBL);
  4959.     cmflgs = -2;
  4960.     return(-9);
  4961. }
  4962.  
  4963. /* Utility functions */
  4964.  
  4965. /* A D D B U F  -- Add the string pointed to by cp to the command buffer  */
  4966.  
  4967. static int
  4968. addbuf(cp) char *cp; {
  4969.     int len = 0;
  4970.     while ((*cp != NUL) && (bp < cmdbuf+CMDBL)) {
  4971.         *bp++ = *cp++;                  /* Copy and */
  4972.         len++;                          /* count the characters. */
  4973.     }
  4974.     *bp++ = SP;                         /* Put a space at the end */
  4975.     *bp = NUL;                          /* Terminate with a null */
  4976.     np = bp;                            /* Update the next-field pointer */
  4977.     cmbptr = np;
  4978.     return(len);                        /* Return the length */
  4979. }
  4980.  
  4981. /*  S E T A T M  --  Deposit a token in the atom buffer.  */
  4982. /*
  4983.   Break on space, newline, carriage return, or NUL.
  4984.   Call with:
  4985.     cp = Pointer to string to copy to atom buffer.
  4986.     fcode = 0 means break on whitespace or EOL.
  4987.     fcode = 1 means don't break on space.
  4988.     fcode = 2 means break on space, ':', or '='.
  4989.   Null-terminate the result.
  4990.   If the source pointer is the atom buffer itself, do nothing.
  4991.   (no longer true.  now we copy the buffer, edit it, and copy it back.)
  4992.   Return length of token, and also set global "cc" to this length.
  4993.   Return -1 if token was too long.
  4994. */
  4995. static int
  4996. setatm(cp,fcode) char *cp; int fcode; {
  4997.     char *ap, *xp;
  4998.     int  bracelvl, n;
  4999.     char lbrace, rbrace;
  5000.  
  5001.     if (cmfldflgs & 1) {
  5002.     lbrace = '(';
  5003.     rbrace = ')';
  5004.     } else {
  5005.     lbrace = '{';
  5006.     rbrace = '}';
  5007.     }
  5008.     cc = 0;                /* Character counter */
  5009.     ap = atmbuf;            /* Address of atom buffer */
  5010.  
  5011.     if ((int) strlen(cp) > ATMBL)
  5012.       return(-1);
  5013.  
  5014.     if (cp == ap) {            /* In case source is atom buffer */
  5015.     xp = atybuf;            /* make a copy */
  5016.     strncpy(xp,ap,ATMBL);        /* so we can copy it back, edited. */
  5017.     cp = xp;
  5018.     }
  5019.     *ap = NUL;                /* Zero the atom buffer */
  5020.     if (fcode == 1) {            /* Trim trailing blanks */
  5021.     n = strlen(cp);
  5022.     while (--n >= 0)
  5023.       if (cp[n] != SP) break;
  5024.     cp[n+1] = NUL;
  5025.     }
  5026.     while (*cp == SP) cp++;        /* Trim leading spaces */
  5027.     bracelvl = 0;
  5028.     while (*cp) {
  5029.         if (*cp == lbrace) bracelvl++;
  5030.         if (*cp == rbrace) bracelvl--;
  5031.     if (bracelvl < 0) bracelvl = 0;
  5032.     if (bracelvl == 0) {
  5033.         if ((*cp == SP || *cp == HT) && (fcode != 1)) break;
  5034.         if ((fcode == 2) && (*cp == '=' || *cp == ':')) break;
  5035.         if (*cp == LF || *cp == CR) break;
  5036.     }
  5037.         *ap++ = *cp++;
  5038.         cc++;
  5039.     }
  5040.     *ap = NUL;                /* Terminate the string. */
  5041.     return(cc);                         /* Return length. */
  5042. }
  5043.  
  5044. /*
  5045.   These functions attempt to hide system dependencies from the mainline
  5046.   code in gtword().  Dummy arg for cmdgetc() needed for compatibility with
  5047.   coninc(), ttinc(), etc, since a pointer to this routine can be passed in
  5048.   place of those to tn_doop().
  5049.  
  5050.   No longer static.  Used by askmore().  Fri Aug 20 15:03:34 1999.
  5051. */
  5052. int
  5053. cmdgetc(timelimit) int timelimit; {    /* Get a character from the tty. */
  5054.     int c;
  5055. #ifdef IKSD
  5056.     extern int inserver;
  5057. #endif /* IKSD */
  5058. #ifdef CK_LOGIN
  5059.     extern int x_logged;
  5060. #endif /* CK_LOGIN */
  5061. #ifdef TNCODE
  5062.     static int got_cr = 0;
  5063.     extern int ckxech;
  5064.     int tx = 0, is_tn = 0;
  5065. #endif /* TNCODE */
  5066.  
  5067.     if (pushc
  5068. #ifndef NOSPL
  5069.     && !askflag
  5070. #endif /* NOSPL */
  5071.     ) {
  5072.         debug(F111,"cmdgetc()","pushc",pushc);
  5073.     c = pushc;
  5074.     pushc = NUL;
  5075.     if (xcmfdb && c == '?')        /* Don't echo ? twice if chaining. */
  5076.       cmdchardel();
  5077.     return(c);
  5078.     }
  5079. #ifdef datageneral
  5080.     {
  5081.     char ch;
  5082.     c = dgncinb(0,&ch,1);        /* -1 is EOF, -2 TO,
  5083.                                          * -c is AOS/VS error */
  5084.     if (c == -2) {            /* timeout was enabled? */
  5085.         resto(channel(0));        /* reset timeouts */
  5086.         c = dgncinb(0,&ch,1);    /* retry this now! */
  5087.     }
  5088.     if (c < 0) return(-4);        /* EOF or some error */
  5089.     else c = (int) ch & 0177;    /* Get char without parity */
  5090. /*    echof = 1; */
  5091.     }
  5092. #else /* Not datageneral */
  5093. #ifndef MINIX2
  5094.     if (
  5095. #ifdef IKSD
  5096.     (!local && inserver) ||
  5097. #endif /* IKSD */
  5098.     timelimit > 0) {
  5099. #ifdef TNCODE
  5100.           GETNEXTCH:
  5101.             is_tn = !pushc && !local && sstelnet;
  5102. #endif /* TNCODE */
  5103. #ifdef COMMENT
  5104.         c = coninc(timelimit > 0 ? 1 : 0);
  5105. #else /* COMMENT */
  5106.         /* This is likely to break the asktimeout... */
  5107.         c = coninc(timelimit);
  5108. #endif /* COMMENT */
  5109.         /* debug(F101,"cmdgetc coninc","",c); */
  5110. #ifdef TNCODE
  5111.             if (c >= 0 && is_tn) {    /* Server-side Telnet */
  5112.                 switch (c) {
  5113.           case IAC:
  5114.                     debug(F111,"gtword IAC","c",c);
  5115.                     got_cr = 0;
  5116.                     if ((tx = tn_doop((CHAR)(c & 0xff),ckxech,coninc)) == 0) {
  5117.                         goto GETNEXTCH;
  5118.                     } else if (tx <= -1) { /* I/O error */
  5119.                         /* If there was a fatal I/O error then ttclos()    */
  5120.                         /* has been called and the next GETNEXTCH attempt  */
  5121.                         /* will be !is_tn since ttclos() sets sstelnet = 0 */
  5122.                         doexit(BAD_EXIT,-1); /* (or return(-4)? */
  5123.                     } else if (tx == 1) { /* ECHO change */
  5124.                         ckxech = dpx = 1; /* Get next char */
  5125.                         goto GETNEXTCH;
  5126.                     } else if (tx == 2) { /* ECHO change */
  5127.                         ckxech = dpx = 0; /* Get next char */
  5128.                         goto GETNEXTCH;
  5129.                     } else if (tx == 3) { /* Quoted IAC */
  5130.                         c = 255;    /* proceeed with it. */
  5131.                     }
  5132. #ifdef IKS_OPTION
  5133.                     else if (tx == 4) {    /* IKS State Change */
  5134.                         goto GETNEXTCH;
  5135.                     }
  5136. #endif /* IKS_OPTION */
  5137.                     else if (tx == 6) {    /* Remote Logout */
  5138.             doexit(GOOD_EXIT,0);
  5139.                     } else {
  5140.             goto GETNEXTCH;    /* Unknown, get next char */
  5141.             }
  5142.                     break;
  5143. #ifdef COMMENT
  5144.                   case CR:
  5145.                     if (!TELOPT_U(TELOPT_BINARY)) {
  5146.             if ( got_cr ) {
  5147.                 /* This means the sender is violating Telnet   */
  5148.                 /* protocol because we received two CRs in a   */
  5149.                 /* row without getting either LF or NUL.       */
  5150.                 /* This will not solve the problem but it      */
  5151.                 /* will at least allow two CRs to do something */
  5152.                 /* whereas before the user would have to guess */
  5153.                 /* to send LF or NUL after the CR.             */
  5154.                 debug(F100,"gtword CR telnet error","",0);
  5155.                 c = LF;
  5156.             } else {
  5157.                 debug(F100,"gtword skipping CR","",0);
  5158.                 got_cr = 1;    /* Remember a CR was received */
  5159.                 goto GETNEXTCH;
  5160.             }
  5161.                     } else {
  5162.             debug(F100,"gtword CR to LF","",0);
  5163.             c = LF;
  5164.                     }
  5165.                     break;
  5166.                   case LF:
  5167.                     if (!TELOPT_U(TELOPT_BINARY)) {
  5168.             got_cr = 0;
  5169.             debug(F100,"gtword LF","",0);
  5170.                     } else {
  5171.             if (got_cr) {
  5172.                 got_cr = 0;
  5173.                 debug(F100,"gtword skipping LF","",0);
  5174.                 goto GETNEXTCH;
  5175.             }
  5176.                     }
  5177.                     break;
  5178.                   case NUL:
  5179.                     if (!TELOPT_U(TELOPT_BINARY) && got_cr) {
  5180.             c = LF;
  5181.             debug(F100,"gtword NUL to LF","",0);
  5182.                     } else {
  5183.             debug(F100,"gtword NUL","",0);
  5184.                     }
  5185.                     got_cr = 0;
  5186.                     break;
  5187. #else /* COMMENT */
  5188.                   case CR:
  5189.                     if ( !TELOPT_U(TELOPT_BINARY) && got_cr ) {
  5190.                         /* This means the sender is violating Telnet   */
  5191.                         /* protocol because we received two CRs in a   */
  5192.                         /* row without getting either LF or NUL.       */
  5193.                         /* This will not solve the problem but it      */
  5194.                         /* will at least allow two CRs to do something */
  5195.                         /* whereas before the user would have to guess */
  5196.                         /* to send LF or NUL after the CR.             */
  5197.                         debug(F100,"gtword CR telnet error","",0);
  5198.                     } else {
  5199.                         got_cr = 1;    /* Remember a CR was received */
  5200.                     }
  5201.                     debug(F100,"gtword CR to LF","",0);
  5202.                     c = LF;
  5203.             break;
  5204.                   case LF:
  5205.                     if (got_cr) {
  5206.                         got_cr = 0;
  5207.                         debug(F100,"gtword skipping LF","",0);
  5208.                         goto GETNEXTCH;
  5209.                     }
  5210.             break;
  5211.                   case NUL:
  5212.                     if (got_cr) {
  5213.                         got_cr = 0;
  5214.                         debug(F100,"gtword skipping NUL","",0);
  5215.                         goto GETNEXTCH;
  5216.                     } else {
  5217.                       debug(F100,"gtword NUL","",0);
  5218.                     }
  5219.                     break;
  5220. #endif /* COMMENT */
  5221. #ifdef IKSD
  5222.           case ETX:        /* Ctrl-C... */
  5223.                   case EOT:        /* EOT = EOF */
  5224.                       debug(F000,"gtword","",c);
  5225.                       if (inserver
  5226. #ifdef CK_LOGIN
  5227.               && !x_logged
  5228. #endif /* CK_LOGIN */
  5229.               )
  5230.                           return(-4);
  5231.             break;
  5232. #endif /* IKSD */
  5233.           default:
  5234.                       got_cr = 0;
  5235.                 }
  5236.             }
  5237. #endif /* TNCODE */
  5238.     } else {
  5239.     /* debug(F100,"cmdgetc getchar 1","",0); */
  5240. #ifdef OS2
  5241.     c = coninc(0);
  5242. #else /* OS2 */
  5243.     c = getchar();
  5244.     /* debug(F101,"cmdgetc getchar 2","",c); */
  5245. #endif /* OS2 */
  5246.     }
  5247. #else  /* MINIX2 */
  5248. #undef getc
  5249.     c = getc(stdin);
  5250. #endif /* MINIX2 */
  5251. #ifdef RTU
  5252.     if (rtu_bug) {
  5253.     c = getchar();            /* RTU doesn't discard the ^Z */
  5254.     rtu_bug = 0;
  5255.     }
  5256. #endif /* RTU */
  5257. #endif /* datageneral */
  5258.     return(c);                /* Return what we got */
  5259. }
  5260.  
  5261. static VOID
  5262. cmdclrscn() {                /* Clear the screen */
  5263.     ck_cls();
  5264. }
  5265.  
  5266. static VOID                /* What to echo at end of command */
  5267. #ifdef CK_ANSIC
  5268. cmdnewl(char c)
  5269. #else
  5270. cmdnewl(c) char c;
  5271. #endif /* CK_ANSIC */
  5272. /* cmdnewl */ {
  5273. #ifdef OS2
  5274. #ifdef IKSD
  5275.     extern int inserver;
  5276.     if (inserver && c == LF)
  5277.       putchar(CR);
  5278. #endif /* IKSD */
  5279. #endif /* OS2 */
  5280.  
  5281.     putchar(c);                /* c is the terminating character */
  5282.  
  5283. #ifdef WINTCP                /* what is this doing here? */
  5284.     if (c == CR) putchar(NL);
  5285. #endif /* WINTCP */
  5286.  
  5287. /*
  5288.   A.A. Chernov, who sent in changes for FreeBSD, said we also needed this
  5289.   for SVORPOSIX because "setup terminal by termios and curses does
  5290.   not convert \r to \n, so additional \n needed in newline function."  But
  5291.   it is also very likely to result in unwanted blank lines.
  5292. */
  5293. #ifdef BSD44
  5294.     if (c == CR) putchar(NL);
  5295. #endif /* BSD44 */
  5296.  
  5297. #ifdef COMMENT
  5298.     /* OS2 no longer needs this as all CR are converted to NL in coninc() */
  5299.     /* This eliminates the ugly extra blank lines discussed above.        */
  5300. #ifdef OS2
  5301.     if (c == CR) putchar(NL);
  5302. #endif /* OS2 */
  5303. #endif /* COMMENT */
  5304. #ifdef aegis
  5305.     if (c == CR) putchar(NL);
  5306. #endif /* aegis */
  5307. #ifdef AMIGA
  5308.     if (c == CR) putchar(NL);
  5309. #endif /* AMIGA */
  5310. #ifdef datageneral
  5311.     if (c == CR) putchar(NL);
  5312. #endif /* datageneral */
  5313. #ifdef GEMDOS
  5314.     if (c == CR) putchar(NL);
  5315. #endif /* GEMDOS */
  5316. #ifdef STRATUS
  5317.     if (c == CR) putchar(NL);
  5318. #endif /* STRATUS */
  5319. }
  5320.  
  5321. static VOID
  5322. cmdchardel() {                /* Erase a character from the screen */
  5323.     if (!dpx) return;
  5324. #ifdef datageneral
  5325.     /* DG '\b' is EM (^y or \031) */
  5326.     if (termtype == 1)
  5327.       /* Erase a character from non-DG screen, */
  5328.       dgncoub(1,"\010 \010",3);
  5329.     else
  5330. #endif /* datageneral */
  5331.       printf("\b \b");
  5332. #ifdef GEMDOS
  5333.     fflush(stdout);
  5334. #else
  5335. #ifdef BEBOX
  5336.     fflush(stdout);
  5337. #endif /* BEBOX */
  5338. #endif /* GEMDOS */
  5339. }
  5340.  
  5341. static VOID
  5342. #ifdef CK_ANSIC
  5343. cmdecho(char c, int quote)
  5344. #else
  5345. cmdecho(c,quote) char c; int quote;
  5346. #endif /* CK_ANSIC */
  5347. { /* cmdecho */
  5348.     if (!dpx) return;
  5349.     /* Echo tty input character c */
  5350.     if (quote) {
  5351.     putchar(BS);
  5352.     putchar(SP);
  5353.     putchar(BS);
  5354. #ifdef isprint
  5355.     putchar((CHAR) (isprint(c) ? c : '^' ));
  5356. #else
  5357.     putchar((CHAR) ((c >= SP && c < DEL) ? c : '^'));
  5358. #endif /* isprint */
  5359.     } else putchar(c);
  5360. #ifdef OS2
  5361.     if (quote==1 && c==CR) putchar((CHAR) NL);
  5362. #endif /* OS2 */
  5363.     if (timelimit)
  5364.       fflush(stdout);
  5365. }
  5366.  
  5367. /* Return pointer to current position in command buffer. */
  5368.  
  5369. char *
  5370. cmpeek() {
  5371.     return(np);
  5372. }
  5373. #endif /* NOICP */
  5374.  
  5375.  
  5376. #ifdef NOICP
  5377. #include "ckcdeb.h"
  5378. #include "ckucmd.h"
  5379. #include "ckcasc.h"
  5380. #endif /* NOICP */
  5381.  
  5382. /*  X X E S C  --  Interprets backslash codes  */
  5383. /*  Returns the int value of the backslash code if it is > -1 and < 256 */
  5384. /*  and updates the string pointer to first character after backslash code. */
  5385. /*  If the argument is invalid, leaves pointer unchanged and returns -1. */
  5386.  
  5387. int
  5388. xxesc(s) char **s; {            /* Expand backslash escapes */
  5389.     int x, y, brace, radix;        /* Returns the int value */
  5390.     char hd = '9';            /* Highest digit in radix */
  5391.     char *p;
  5392.  
  5393.     p = *s;                /* pointer to beginning */
  5394.     if (!p) return(-1);            /* watch out for null pointer */
  5395.     x = *p++;                /* character at beginning */
  5396.     if (x != CMDQ) return(-1);        /* make sure it's a backslash code */
  5397.  
  5398.     x = *p;                /* it is, get the next character */
  5399.     if (x == '{') {            /* bracketed quantity? */
  5400.     p++;                /* begin past bracket */
  5401.     x = *p;
  5402.     brace = 1;
  5403.     } else brace = 0;
  5404.     switch (x) {            /* Start interpreting */
  5405.       case 'd':                /* Decimal radix indicator */
  5406.       case 'D':
  5407.     p++;                /* Just point past it and fall thru */
  5408.       case '0':                /* Starts with digit */
  5409.       case '1':
  5410.       case '2':  case '3':  case '4':  case '5':
  5411.       case '6':  case '7':  case '8':  case '9':
  5412.     radix = 10;            /* Decimal */
  5413.     hd = '9';            /* highest valid digit */
  5414.     break;
  5415.       case 'o':                /* Starts with o or O */
  5416.       case 'O':
  5417.     radix = 8;            /* Octal */
  5418.     hd = '7';            /* highest valid digit */
  5419.     p++;                /* point past radix indicator */
  5420.     break;
  5421.       case 'x':                /* Starts with x or X */
  5422.       case 'X':
  5423.     radix = 16;            /* Hexadecimal */
  5424.     p++;                /* point past radix indicator */
  5425.     break;
  5426.       default:                /* All others */
  5427. #ifdef COMMENT
  5428.     *s = p+1;            /* Treat as quote of next char */
  5429.     return(*p);
  5430. #else
  5431.     return(-1);
  5432. #endif /* COMMENT */
  5433.     }
  5434.     /* For OS/2, there are "wide" characters required for the keyboard
  5435.      * binding, i.e \644 and similar codes larger than 255 (byte).
  5436.      * For this purpose, give up checking for < 256. If someone means
  5437.      * \266 should result in \26 followed by a "6" character, he should
  5438.      * always write \{26}6 anyway.  Now, return only the lower byte of
  5439.      * the result, i.e. 10, but eat up the whole \266 sequence and
  5440.      * put the wide result 266 into a global variable.  Yes, that's not
  5441.      * the most beautiful programming style but requires the least
  5442.      * amount of changes to other routines.
  5443.      */
  5444.     if (radix <= 10) {            /* Number in radix 8 or 10 */
  5445.     for ( x = y = 0;
  5446.            (*p) && (*p >= '0') && (*p <= hd)
  5447. #ifdef OS2
  5448.                    && (y < 5) && (x*radix < KMSIZE);
  5449.               /* the maximum needed value \8196 is 4 digits long */
  5450.               /* while as octal it requires \1377, i.e. 5 digits */
  5451. #else
  5452.                    && (y < 3) && (x*radix < 256);
  5453. #endif /* OS2 */
  5454.           p++,y++) {
  5455.         x = x * radix + (int) *p - 48;
  5456.     }
  5457. #ifdef OS2
  5458.         wideresult = x;            /* Remember wide result */
  5459.         x &= 255;
  5460. #endif /* OS2 */
  5461.     if (y == 0 || x > 255) {    /* No valid digits? */
  5462.         *s = p;            /* point after it */
  5463.         return(-1);            /* return failure. */
  5464.     }
  5465.     } else if (radix == 16) {        /* Special case for hex */
  5466.     if ((x = unhex(*p++)) < 0) { *s = p - 1; return(-1); }
  5467.     if ((y = unhex(*p++)) < 0) { *s = p - 2; return(-1); }
  5468.     x = ((x << 4) & 0xF0) | (y & 0x0F);
  5469. #ifdef OS2
  5470.         wideresult = x;
  5471.         if ((y = unhex(*p)) >= 0) {
  5472.            p++;
  5473.        wideresult = ((x << 4) & 0xFF0) | (y & 0x0F);
  5474.            x = wideresult & 255;
  5475.         }
  5476. #endif /* OS2 */
  5477.     } else x = -1;
  5478.     if (brace && *p == '}' && x > -1)    /* Point past closing brace, if any */
  5479.       p++;
  5480.     *s = p;                /* Point to next char after sequence */
  5481.     return(x);                /* Return value of sequence */
  5482. }
  5483.  
  5484. int                    /* Convert hex string to int */
  5485. #ifdef CK_ANSIC
  5486. unhex(char x)
  5487. #else
  5488. unhex(x) char x;
  5489. #endif /* CK_ANSIC */
  5490. /* unhex */ {
  5491.  
  5492.     if (x >= '0' && x <= '9')        /* 0-9 is offset by hex 30 */
  5493.       return(x - 0x30);
  5494.     else if (x >= 'A' && x <= 'F')    /* A-F offset by hex 37 */
  5495.       return(x - 0x37);
  5496.     else if (x >= 'a' && x <= 'f')    /* a-f offset by hex 57 */
  5497.       return(x - 0x57);            /* (obviously ASCII dependent) */
  5498.     else return(-1);
  5499. }
  5500.  
  5501. /*  L O O K U P  --  Lookup the string in the given array of strings  */
  5502.  
  5503. /*
  5504.  Call this way:  v = lookup(table,word,n,&x);
  5505.  
  5506.    table - a 'struct keytab' table.
  5507.    word  - the target string to look up in the table.
  5508.    n     - the number of elements in the table.
  5509.    x     - address of an integer for returning the table array index,
  5510.            or NULL if you don't need a table index.
  5511.  
  5512.  The keyword table must be arranged in ascending alphabetical order.
  5513.  Alphabetic case doesn't matter.
  5514.  
  5515.  Returns the keyword's associated value (zero or greater) if found,
  5516.  with the variable x set to the keyword-table index, or:
  5517.  
  5518.   -3 if nothing to look up (target was null),
  5519.   -2 if ambiguous,
  5520.   -1 if not found.
  5521.  
  5522.  A match is successful if the target matches a keyword exactly, or if
  5523.  the target is a prefix of exactly one keyword.  It is ambiguous if the
  5524.  target matches two or more keywords from the table.
  5525. */
  5526. int
  5527. lookup(table,cmd,n,x) char *cmd; struct keytab table[]; int n, *x; {
  5528.  
  5529.     int i, v, len, cmdlen;
  5530.  
  5531. /* Get length of search object, if it's null return code -3. */
  5532.  
  5533.     if (!cmd)
  5534.       return(-3);
  5535.     if (((cmdlen = (int) strlen(cmd)) == 0) || (n < 1))
  5536.       return(-3);
  5537.  
  5538. /* Not null, look it up */
  5539.  
  5540.     for (i = 0; i < n-1; i++) {
  5541.     len = strlen(table[i].kwd);
  5542.         if ((len == cmdlen && !ckstrcmp(table[i].kwd,cmd,len,0)) ||
  5543.         ((v = !ckstrcmp(table[i].kwd,cmd,cmdlen,0)) &&
  5544.          ckstrcmp(table[i+1].kwd,cmd,cmdlen,0))) {
  5545.         if (x) *x = i;
  5546.         return(table[i].kwval);
  5547.     }
  5548.         if (v) {            /* Ambiguous */
  5549.         if (x) *x = i;        /* Set index of first match */
  5550.         return(-2);
  5551.     }
  5552.     }
  5553.  
  5554. /* Last (or only) element */
  5555.  
  5556.     if (!ckstrcmp(table[n-1].kwd,cmd,cmdlen,0)) {
  5557.         if (x) *x = n-1;
  5558.         return(table[n-1].kwval);
  5559.     } else return(-1);
  5560. }
  5561.  
  5562. /* Like lookup, but requires a full (but case-independent) match */
  5563.  
  5564. int
  5565. xlookup(table,cmd,n,x) struct keytab table[]; char *cmd; int n, *x; {
  5566.     int i, cmdlen;
  5567.  
  5568.     if (!cmd)
  5569.       return(-3);
  5570.     if (((cmdlen = (int) strlen(cmd)) == 0) || (n < 1))
  5571.       return(-3);
  5572.  
  5573.     for (i = 0; i < n; i++) {
  5574.     if (((int)strlen(table[i].kwd) == cmdlen) &&
  5575.         (!ckstrcmp(table[i].kwd,cmd,cmdlen,0))) {
  5576.         if (x) *x = i;
  5577.         return(table[i].kwval);
  5578.     }
  5579.     }
  5580.     return(-1);
  5581. }
  5582.  
  5583. #ifndef NOICP
  5584. int
  5585. cmdsquo(x) int x; {
  5586.     quoting = x;
  5587.     return(1);
  5588. }
  5589.  
  5590. int
  5591. cmdgquo() {
  5592.     return(quoting);
  5593. }
  5594. #endif /* NOICP */
  5595.