Return to ckucmd.c CVS log

Up to [MW Coherent from dump] / coherent / e / bin / ckermit

Annotation of coherent/e/bin/ckermit/ckucmd.c, revision 1.1

1.1     ! root        1: int cmdmsk = 127; /* Command-terminal-to-C-Kermit character mask */
        !             2: 
        !             3: #include "ckcdeb.h"                     /* Formats for debug(), etc. */
        !             4: _PROTOTYP( int unhex, (char) );
        !             5: 
        !             6: #ifndef NOICP     /* The rest only if interactive command parsing selected */
        !             7: 
        !             8: char *cmdv = "Command package 5A(053), 21 Nov 92";
        !             9:  
        !            10: /*  C K U C M D  --  Interactive command package for Unix  */
        !            11: 
        !            12: /*
        !            13:   Author: Frank da Cruz ([email protected], [email protected]),
        !            14:   Columbia University Center for Computing Activities.
        !            15:   First released January 1985.
        !            16:   Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
        !            17:   York.  Permission is granted to any individual or institution to use this
        !            18:   software as long as it is not sold for profit.  This copyright notice must be
        !            19:   retained.  This software may not be included in commercial products without
        !            20:   written permission of Columbia University.
        !            21: */
        !            22: 
        !            23: /*
        !            24: Modeled after the DECSYSTEM-20 command parser (the COMND JSYS), RIP.
        !            25: Features:
        !            26: . parses and verifies keywords, filenames, text strings, numbers, other data
        !            27: . displays appropriate menu or help message when user types "?"
        !            28: . does keyword and filename completion when user types ESC or TAB
        !            29: . does partial filename completion
        !            30: . accepts any unique abbreviation for a keyword
        !            31: . allows keywords to have attributes, like "invisible" and "abbreviation"
        !            32: . can supply defaults for fields omitted by user
        !            33: . provides command line editing (character, word, and line deletion)
        !            34: . accepts input from keyboard, command files, or redirected stdin
        !            35: . allows for full or half duplex operation, character or line input
        !            36: . settable prompt, protected from deletion
        !            37: 
        !            38: Functions:
        !            39:  cmsetp - Set prompt (cmprom is prompt string)
        !            40:  cmsavp - Save current prompt
        !            41:  prompt - Issue prompt
        !            42:  cmini - Clear the command buffer (before parsing a new command)
        !            43:  cmres - Reset command buffer pointers (before reparsing)
        !            44:  cmkey - Parse a keyword
        !            45:  cmnum - Parse a number
        !            46:  cmifi - Parse an input file name
        !            47:  cmofi - Parse an output file name
        !            48:  cmdir - Parse a directory name (UNIX only)
        !            49:  cmfld - Parse an arbitrary field
        !            50:  cmtxt - Parse a text string
        !            51:  cmcfm - Parse command confirmation (end of line)
        !            52: 
        !            53: Return codes:
        !            54:  -3: no input provided when required
        !            55:  -2: input was invalid (e.g. not a number when a number was required)
        !            56:  -1: reparse required (user deleted into a preceding field)
        !            57:   0 or greater: success
        !            58: See individual functions for greater detail.
        !            59: 
        !            60: Before using these routines, the caller should #include ckucmd.h, and set the
        !            61: program's prompt by calling cmsetp().  If the file parsing functions cmifi,
        !            62: cmofi, or cmdir are to be used, this module must be linked with a ck?fio file
        !            63: system support module for the appropriate system, e.g. ckufio for Unix.  If
        !            64: the caller puts the terminal in character wakeup ("cbreak") mode with no echo,
        !            65: then these functions will provide line editing -- character, word, and line
        !            66: deletion, as well as keyword and filename completion upon ESC and help
        !            67: strings, keyword, or file menus upon '?'.  If the caller puts the terminal
        !            68: into character wakeup/noecho mode, care should be taken to restore it before
        !            69: exit from or interruption of the program.  If the character wakeup mode is not
        !            70: set, the system's own line editor may be used.
        !            71: 
        !            72: NOTE: Contrary to expectations, many #ifdef's have been added to this module.
        !            73: Any operation requiring an #ifdef (like clear screen, get character from
        !            74: keyboard, erase character from screen, etc) should eventually be turned into a
        !            75: call to a function that is defined in ck?tio.c, but then all the ck?tio.c
        !            76: modules would have to be changed...
        !            77: */
        !            78: 
        !            79: /* Includes */
        !            80: 
        !            81: #include "ckcker.h"                    /* (===OS2 addition===) */
        !            82: #include "ckcasc.h"                    /* ASCII character symbols */
        !            83: #include "ckucmd.h"                     /* Command parsing definitions */
        !            84: #include <errno.h>                     /* Error number symbols */
        !            85: 
        !            86: #ifdef OSK
        !            87: #define cc ccount                      /* OS-9/68K compiler bug */
        !            88: #endif /* OSK */
        !            89: 
        !            90: #ifdef GEMDOS                          /* Atari ST */
        !            91: #ifdef putchar
        !            92: #undef putchar
        !            93: #endif /* putchar */
        !            94: #define putchar(x) conoc(x)            /* Why doesn't everyone do this? */
        !            95: #endif /* GEMDOS */
        !            96: 
        !            97: /* Local variables */
        !            98:  
        !            99: static
        !           100: int psetf = 0,                          /* Flag that prompt has been set */
        !           101:     cc = 0,                             /* Character count */
        !           102:     dpx = 0,                            /* Duplex (0 = full) */
        !           103:     inword = 0;                                /* In the middle of getting a word */
        !           104:  
        !           105: static
        !           106: int hw = HLPLW,                         /* Help line width */
        !           107:     hc = HLPCW,                         /* Help line column width */
        !           108:     hh,                                 /* Current help column number */
        !           109:     hx;                                 /* Current help line position */
        !           110:  
        !           111: #define PROML 160                       /* Maximum length for prompt */
        !           112:  
        !           113: char cmprom[PROML+1];                   /* Program's prompt */
        !           114: char cmprxx[PROML+1];                   /* Program's prompt, unevaluated */
        !           115: char *dfprom = "Command? ";             /* Default prompt */
        !           116:  
        !           117: int cmflgs;                             /* Command flags */
        !           118: int cmfsav;                            /* A saved version of them */
        !           119:  
        !           120: #ifdef DCMDBUF
        !           121: char *cmdbuf;                          /* Command buffer */                
        !           122: char *savbuf;                          /* Help string buffer */            
        !           123: char *hlpbuf;                          /* Atom buffer */                   
        !           124: char *atmbuf;                          /* File name buffer */              
        !           125: char *atxbuf;                          /* For expanding the atom buffer */ 
        !           126: int atxn;                              /* Length of expansion buffer */    
        !           127: char *atybuf;                          /* For copying atom buffer */       
        !           128: char *filbuf;                          /* Buffer to save copy of command */
        !           129: #else
        !           130: char cmdbuf[CMDBL+4];                   /* Command buffer */                
        !           131: char hlpbuf[HLPBL+4];                   /* Help string buffer */            
        !           132: char atmbuf[ATMBL+4];                   /* Atom buffer */                   
        !           133: char filbuf[ATMBL+4];                   /* File name buffer */              
        !           134: char atxbuf[CMDBL+4];                   /* For expanding the atom buffer */ 
        !           135: int atxn;                              /* Length of expansion buffer */    
        !           136: char atybuf[ATMBL+4];                   /* For copying atom buffer */       
        !           137: char savbuf[CMDBL+4];                   /* Buffer to save copy of command */
        !           138: #endif /* DCMDBUF */
        !           139:  
        !           140: /* Command buffer pointers */
        !           141:  
        !           142: static char *bp,                        /* Current command buffer position */
        !           143:     *pp,                                /* Start of current field */
        !           144:     *np;                                /* Start of next field */
        !           145:  
        !           146: static int ungw;                       /* For ungetting words */
        !           147: 
        !           148: _PROTOTYP( VOID addhlp, (char *) );
        !           149: _PROTOTYP( VOID clrhlp, (void) );
        !           150: _PROTOTYP( VOID dmphlp, (void) );
        !           151: _PROTOTYP( int gtword, (void) );
        !           152: _PROTOTYP( int addbuf, (char *) );
        !           153: _PROTOTYP( int setatm, (char *) );
        !           154: _PROTOTYP( int cmdgetc, (void) );
        !           155: _PROTOTYP( VOID cmdnewl, (char) );
        !           156: _PROTOTYP( VOID cmdchardel, (void) );
        !           157: _PROTOTYP( VOID cmdecho, (char, int) );
        !           158: _PROTOTYP( static int test, (int, int) );
        !           159: #ifdef GEMDOS
        !           160: _PROTOTYP( extern char *strchr, (char *, int) );
        !           161: #endif /* GEMDOS */
        !           162: 
        !           163: /*  T E S T  --  Bit test  */
        !           164:  
        !           165: static int
        !           166: test(x,m) int x, m; { /*  Returns 1 if any bits from m are on in x, else 0  */
        !           167:     return((x & m) ? 1 : 0);
        !           168: }
        !           169: 
        !           170: /*  C M S E T U P  --  Set up command buffers  */
        !           171: 
        !           172: #ifdef DCMDBUF
        !           173: int
        !           174: cmsetup() {
        !           175:     if (!(cmdbuf = malloc(CMDBL + 4))) return(-1);
        !           176:     if (!(savbuf = malloc(CMDBL + 4))) return(-1);
        !           177:     savbuf[0] = '\0';
        !           178:     if (!(hlpbuf = malloc(HLPBL + 4))) return(-1);
        !           179:     if (!(atmbuf = malloc(ATMBL + 4))) return(-1);
        !           180:     if (!(atxbuf = malloc(CMDBL + 4))) return(-1);
        !           181:     if (!(atybuf = malloc(ATMBL + 4))) return(-1);
        !           182:     if (!(filbuf = malloc(ATMBL + 4))) return(-1);
        !           183:     return(0);
        !           184: }
        !           185: #endif /* DCMDBUF */ 
        !           186: 
        !           187: /*  C M S E T P  --  Set the program prompt.  */
        !           188:  
        !           189: VOID
        !           190: cmsetp(s) char *s; {
        !           191:     strncpy(cmprxx,s,PROML - 1);
        !           192:     cmprxx[PROML] = NUL;
        !           193:     psetf = 1;                          /* Flag that prompt has been set. */
        !           194: }
        !           195: /*  C M S A V P  --  Save a copy of the current prompt.  */
        !           196:  
        !           197: VOID
        !           198: #ifdef CK_ANSIC
        !           199: cmsavp(char s[], int n)
        !           200: #else
        !           201: cmsavp(s,n) char s[]; int n;
        !           202: #endif /* CK_ANSIC */
        !           203: /* cmsavp */ {
        !           204:     strncpy(s,cmprxx,n-1);
        !           205:     s[n-1] = NUL;
        !           206: }
        !           207:  
        !           208: /*  P R O M P T  --  Issue the program prompt.  */
        !           209:  
        !           210: VOID
        !           211: prompt(f) xx_strp f; {
        !           212:     char *sx, *sy; int n;
        !           213: 
        !           214:     if (psetf == 0) cmsetp(dfprom);     /* If no prompt set, set default. */
        !           215: 
        !           216:     sx = cmprxx;                       /* Unevaluated copy */
        !           217:     if (f) {                           /* If conversion function given */
        !           218:        sy = cmprom;                    /* Evaluate it */
        !           219:        n = PROML;
        !           220:        if ((*f)(sx,&sy,&n) < 0)        /* If evaluation failed */
        !           221:          sx = cmprxx;                  /* revert to unevaluated copy */
        !           222:        else
        !           223:          sx = cmprom;
        !           224:     }
        !           225: #ifdef OSK
        !           226:     fputs(sx, stdout);
        !           227: #else
        !           228: #ifdef MAC
        !           229:     printf("%s", sx);
        !           230: #else
        !           231:     printf("\r%s",sx);                 /* Print the prompt. */
        !           232:     fflush(stdout);                    /* Now! */
        !           233: #endif /* MAC */
        !           234: #endif /* OSK */
        !           235: }
        !           236:  
        !           237: #ifndef NOSPL
        !           238: VOID
        !           239: pushcmd() {                            /* For use with IF command. */
        !           240:     strcpy(savbuf,np);                 /* Save the dependent clause,  */
        !           241:     cmres();                           /* and clear the command buffer. */
        !           242:     debug(F110, "pushcmd: savbuf:", savbuf, 0);
        !           243: }
        !           244: #endif /* NOSPL */
        !           245: 
        !           246: #ifdef COMMENT
        !           247: /* no longer used... */
        !           248: VOID
        !           249: popcmd() {
        !           250:     strcpy(cmdbuf,savbuf);             /* Put back the saved material */
        !           251:     *savbuf = '\0';                    /* and clear the save buffer */
        !           252:     cmres();
        !           253: }
        !           254: #endif /* COMMENT */
        !           255: 
        !           256: /*  C M R E S  --  Reset pointers to beginning of command buffer.  */
        !           257:  
        !           258: VOID
        !           259: cmres() {  
        !           260:     inword = cc = 0;                   /* Reset character counter. */
        !           261:     pp = np = bp = cmdbuf;              /* Point to command buffer. */
        !           262:     cmflgs = -5;                        /* Parse not yet started. */
        !           263:     ungw = 0;                          /* Don't need to unget a word. */
        !           264: }
        !           265:  
        !           266: /*  C M I N I  --  Clear the command and atom buffers, reset pointers.  */
        !           267:  
        !           268: /*
        !           269: The argument specifies who is to echo the user's typein --
        !           270:   1 means the cmd package echoes
        !           271:   0 somebody else (system, front end, terminal) echoes
        !           272: */
        !           273: VOID
        !           274: cmini(d) int d; {
        !           275:     for (bp = cmdbuf; bp < cmdbuf+CMDBL; bp++) *bp = NUL;
        !           276:     *atmbuf = NUL;
        !           277:     dpx = d;
        !           278:     cmres();
        !           279: }
        !           280:  
        !           281: #ifndef NOSPL
        !           282: /* The following bits are to allow the command package to call itself */
        !           283: /* in the middle of a parse.  To do this, begin by calling cmpush, and */
        !           284: /* end by calling cmpop. */
        !           285: 
        !           286: #ifdef DCMDBUF
        !           287: struct cmp {
        !           288:     int i[5];                          /* stack for integers */
        !           289:     char *c[3];                                /* stack for pointers */
        !           290:     char *b[8];                                /* stack for buffer contents */
        !           291: };
        !           292: struct cmp *cmp = 0;
        !           293: #else
        !           294: int cmp_i[CMDDEP+1][5];                        /* Stack for integers */
        !           295: char *cmp_c[CMDDEP+1][5];              /* for misc pointers */
        !           296: char *cmp_b[CMDDEP+1][7];              /* for buffer contents pointers */
        !           297: #endif /* DCMDBUF */
        !           298: 
        !           299: int cmddep = -1;                       /* Current stack depth */
        !           300: 
        !           301: int
        !           302: cmpush() {                             /* Save the command environment */
        !           303:     char *cp;                          /* Character pointer */
        !           304: 
        !           305:     if (cmddep >= CMDDEP)              /* Enter a new command depth */
        !           306:       return(-1);
        !           307:     cmddep++;
        !           308:     debug(F101,"&cmpush","",cmddep);
        !           309: 
        !           310: #ifdef DCMDBUF
        !           311:     /* allocate memory for cmp if not already done */
        !           312:     if (!cmp && !(cmp = (struct cmp *) malloc(sizeof(struct cmp)*(CMDDEP+1))))
        !           313:       fatal("cmpush: no memory for cmp");
        !           314:     cmp[cmddep].i[0] = cmflgs;         /* First do the global ints */
        !           315:     cmp[cmddep].i[1] = cmfsav;
        !           316:     cmp[cmddep].i[2] = atxn;
        !           317:     cmp[cmddep].i[3] = ungw;
        !           318: 
        !           319:     cmp[cmddep].c[0] = bp;             /* Then the global pointers */
        !           320:     cmp[cmddep].c[1] = pp;
        !           321:     cmp[cmddep].c[2] = np; 
        !           322: #else
        !           323:     cmp_i[cmddep][0] = cmflgs;         /* First do the global ints */
        !           324:     cmp_i[cmddep][1] = cmfsav;
        !           325:     cmp_i[cmddep][2] = atxn;
        !           326:     cmp_i[cmddep][3] = ungw;
        !           327: 
        !           328:     cmp_c[cmddep][0] = bp;             /* Then the global pointers */
        !           329:     cmp_c[cmddep][1] = pp;
        !           330:     cmp_c[cmddep][2] = np; 
        !           331: #endif /* DCMDBUF */
        !           332: 
        !           333:     /* Now the buffers themselves.  A lot of repititious code... */
        !           334: 
        !           335: #ifdef DCMDBUF
        !           336:     cp = malloc((int)strlen(cmdbuf)+1);        /* 0: Command buffer */
        !           337:     if (cp) strcpy(cp,cmdbuf);
        !           338:     cmp[cmddep].b[0] = cp;
        !           339:     if (cp == NULL) return(-1);
        !           340: 
        !           341:     cp = malloc((int)strlen(savbuf)+1);        /* 1: Save buffer */
        !           342:     if (cp) strcpy(cp,savbuf);
        !           343:     cmp[cmddep].b[1] = cp;
        !           344:     if (cp == NULL) return(-1);
        !           345: 
        !           346:     cp = malloc((int)strlen(hlpbuf)+1);        /* 2: Help string buffer */
        !           347:     if (cp) strcpy(cp,hlpbuf);
        !           348:     cmp[cmddep].b[2] = cp;
        !           349:     if (cp == NULL) return(-1);
        !           350: 
        !           351:     cp = malloc((int)strlen(atmbuf)+1);        /* 3: Atom buffer */
        !           352:     if (cp) strcpy(cp,atmbuf);
        !           353:     cmp[cmddep].b[3] = cp;
        !           354:     if (cp == NULL) return(-1);
        !           355: 
        !           356:     cp = malloc((int)strlen(atxbuf)+1);        /* 4: Expansion buffer */
        !           357:     if (cp) strcpy(cp,atxbuf);
        !           358:     cmp[cmddep].b[4] = cp;
        !           359:     if (cp == NULL) return(-1);
        !           360: 
        !           361:     cp = malloc((int)strlen(atybuf)+1);        /* 5: Atom buffer copy */
        !           362:     if (cp) strcpy(cp,atybuf);
        !           363:     cmp[cmddep].b[5] = cp;
        !           364:     if (cp == NULL) return(-1);
        !           365: 
        !           366:     cp = malloc((int)strlen(filbuf)+1);        /* 6: File name buffer */
        !           367:     if (cp) strcpy(cp,filbuf);
        !           368:     cmp[cmddep].b[6] = cp;
        !           369:     if (cp == NULL) return(-1);
        !           370: #else
        !           371:     cp = malloc((int)strlen(cmdbuf)+1);        /* 0: Command buffer */
        !           372:     if (cp) strcpy(cp,cmdbuf);
        !           373:     cmp_b[cmddep][0] = cp;
        !           374:     if (cp == NULL) return(-1);
        !           375: 
        !           376:     cp = malloc((int)strlen(savbuf)+1);        /* 1: Save buffer */
        !           377:     if (cp) strcpy(cp,savbuf);
        !           378:     cmp_b[cmddep][1] = cp;
        !           379:     if (cp == NULL) return(-1);
        !           380: 
        !           381:     cp = malloc((int)strlen(hlpbuf)+1);        /* 2: Help string buffer */
        !           382:     if (cp) strcpy(cp,hlpbuf);
        !           383:     cmp_b[cmddep][2] = cp;
        !           384:     if (cp == NULL) return(-1);
        !           385: 
        !           386:     cp = malloc((int)strlen(atmbuf)+1);        /* 3: Atom buffer */
        !           387:     if (cp) strcpy(cp,atmbuf);
        !           388:     cmp_b[cmddep][3] = cp;
        !           389:     if (cp == NULL) return(-1);
        !           390: 
        !           391:     cp = malloc((int)strlen(atxbuf)+1);        /* 4: Expansion buffer */
        !           392:     if (cp) strcpy(cp,atxbuf);
        !           393:     cmp_b[cmddep][4] = cp;
        !           394:     if (cp == NULL) return(-1);
        !           395: 
        !           396:     cp = malloc((int)strlen(atybuf)+1);        /* 5: Atom buffer copy */
        !           397:     if (cp) strcpy(cp,atybuf);
        !           398:     cmp_b[cmddep][5] = cp;
        !           399:     if (cp == NULL) return(-1);
        !           400: 
        !           401:     cp = malloc((int)strlen(filbuf)+1);        /* 6: File name buffer */
        !           402:     if (cp) strcpy(cp,filbuf);
        !           403:     cmp_b[cmddep][6] = cp;
        !           404:     if (cp == NULL) return(-1);
        !           405: #endif /* DCMDBUF */
        !           406: 
        !           407:     cmini(dpx);                                /* Initize the command parser */
        !           408:     return(0);
        !           409: }
        !           410: 
        !           411: int
        !           412: cmpop() {                              /* Restore the command environment */
        !           413:     debug(F101,"&cmpop","",cmddep);
        !           414:     if (cmddep < 0) return(-1);                /* Don't pop too much! */
        !           415: 
        !           416: #ifdef DCMDBUF
        !           417:     cmflgs = cmp[cmddep].i[0];         /* First do the global ints */
        !           418:     cmfsav = cmp[cmddep].i[1];
        !           419:     atxn = cmp[cmddep].i[2];
        !           420:     ungw = cmp[cmddep].i[3];
        !           421: 
        !           422:     bp = cmp[cmddep].c[0];             /* Then the global pointers */
        !           423:     pp = cmp[cmddep].c[1];
        !           424:     np = cmp[cmddep].c[2]; 
        !           425: #else
        !           426:     cmflgs = cmp_i[cmddep][0];         /* First do the global ints */
        !           427:     cmfsav = cmp_i[cmddep][1];
        !           428:     atxn = cmp_i[cmddep][2];
        !           429:     ungw = cmp_i[cmddep][3];
        !           430: 
        !           431:     bp = cmp_c[cmddep][0];             /* Then the global pointers */
        !           432:     pp = cmp_c[cmddep][1];
        !           433:     np = cmp_c[cmddep][2]; 
        !           434: #endif /* DCMDBUF */
        !           435: 
        !           436:     /* Now the buffers themselves. */
        !           437: 
        !           438: #ifdef DCMDBUF
        !           439:     if (cmp[cmddep].b[0]) {
        !           440:        strcpy(cmdbuf,cmp[cmddep].b[0]); /* 0: Command buffer */
        !           441:        free(cmp[cmddep].b[0]);
        !           442:        cmp[cmddep].b[0] = NULL;
        !           443:     }
        !           444:     if (cmp[cmddep].b[1]) {
        !           445:        strcpy(savbuf,cmp[cmddep].b[1]); /* 1: Save buffer */
        !           446:        free(cmp[cmddep].b[1]);
        !           447:        cmp[cmddep].b[1] = NULL;
        !           448:     }
        !           449:     if (cmp[cmddep].b[2]) {
        !           450:        strcpy(hlpbuf,cmp[cmddep].b[2]); /* 2: Help buffer */
        !           451:        free(cmp[cmddep].b[2]);
        !           452:        cmp[cmddep].b[2] = NULL;
        !           453:     }
        !           454:     if (cmp[cmddep].b[3]) {
        !           455:        strcpy(atmbuf,cmp[cmddep].b[3]); /* 3: Atomic buffer! */
        !           456:        free(cmp[cmddep].b[3]);
        !           457:        cmp[cmddep].b[3] = NULL;
        !           458:     }
        !           459:     if (cmp[cmddep].b[4]) {
        !           460:        strcpy(atxbuf,cmp[cmddep].b[4]); /* 4: eXpansion buffer */
        !           461:        free(cmp[cmddep].b[4]);
        !           462:        cmp[cmddep].b[4] = NULL;
        !           463:     }
        !           464:     if (cmp[cmddep].b[5]) {
        !           465:        strcpy(atybuf,cmp[cmddep].b[5]); /* 5: Atom buffer copY */
        !           466:        free(cmp[cmddep].b[5]);
        !           467:        cmp[cmddep].b[5] = NULL;
        !           468:     }
        !           469:     if (cmp[cmddep].b[6]) {
        !           470:        strcpy(filbuf,cmp[cmddep].b[6]); /* 6: Filename buffer */
        !           471:        free(cmp[cmddep].b[6]);
        !           472:        cmp[cmddep].b[6] = NULL;
        !           473:     }
        !           474: #else
        !           475:     if (cmp_b[cmddep][0]) {
        !           476:        strcpy(cmdbuf,cmp_b[cmddep][0]); /* 0: Command buffer */
        !           477:        free(cmp_b[cmddep][0]);
        !           478:        cmp_b[cmddep][0] = NULL;
        !           479:     }
        !           480:     if (cmp_b[cmddep][1]) {
        !           481:        strcpy(savbuf,cmp_b[cmddep][1]); /* 1: Save buffer */
        !           482:        free(cmp_b[cmddep][1]);
        !           483:        cmp_b[cmddep][1] = NULL;
        !           484:     }
        !           485:     if (cmp_b[cmddep][2]) {
        !           486:        strcpy(hlpbuf,cmp_b[cmddep][2]); /* 2: Help buffer */
        !           487:        free(cmp_b[cmddep][2]);
        !           488:        cmp_b[cmddep][2] = NULL;
        !           489:     }
        !           490:     if (cmp_b[cmddep][3]) {
        !           491:        strcpy(atmbuf,cmp_b[cmddep][3]); /* 3: Atomic buffer! */
        !           492:        free(cmp_b[cmddep][3]);
        !           493:        cmp_b[cmddep][3] = NULL;
        !           494:     }
        !           495:     if (cmp_b[cmddep][4]) {
        !           496:        strcpy(atxbuf,cmp_b[cmddep][4]); /* 4: eXpansion buffer */
        !           497:        free(cmp_b[cmddep][4]);
        !           498:        cmp_b[cmddep][4] = NULL;
        !           499:     }
        !           500:     if (cmp_b[cmddep][5]) {
        !           501:        strcpy(atybuf,cmp_b[cmddep][5]); /* 5: Atom buffer copY */
        !           502:        free(cmp_b[cmddep][5]);
        !           503:        cmp_b[cmddep][5] = NULL;
        !           504:     }
        !           505:     if (cmp_b[cmddep][6]) {
        !           506:        strcpy(filbuf,cmp_b[cmddep][6]); /* 6: Filename buffer */
        !           507:        free(cmp_b[cmddep][6]);
        !           508:        cmp_b[cmddep][6] = NULL;
        !           509:     }
        !           510: #endif /* DCMDBUF */
        !           511: 
        !           512:     cmddep--;                          /* Rise, rise */
        !           513:     debug(F101,"&cmpop","",cmddep);
        !           514:     return(cmddep);
        !           515: }
        !           516: #endif /* NOSPL */
        !           517: 
        !           518: #ifdef COMMENT
        !           519: VOID
        !           520: stripq(s) char *s; {                    /* Function to strip '\' quotes */
        !           521:     char *t;
        !           522:     while (*s) {
        !           523:         if (*s == CMDQ) {
        !           524:             for (t = s; *t != '\0'; t++) *t = *(t+1);
        !           525:         }
        !           526:         s++;
        !           527:     }
        !           528: }
        !           529: #endif /* COMMENT */
        !           530: 
        !           531: /* Convert tabs to spaces, one for one */
        !           532: VOID
        !           533: untab(s) char *s; {
        !           534:     while (*s) {
        !           535:        if (*s == HT) *s = SP;
        !           536:        s++;
        !           537:     }
        !           538: }
        !           539: 
        !           540: /*  C M N U M  --  Parse a number in the indicated radix  */
        !           541:  
        !           542: /* 
        !           543:  The only radix allowed in unquoted numbers is 10.
        !           544:  Parses unquoted numeric strings in base 10.
        !           545:  Parses backslash-quoted numbers in the radix indicated by the quote:
        !           546:    \nnn = \dnnn = decimal, \onnn = octal, \xnn = Hexadecimal.
        !           547:  If these fail, then if a preprocessing function is supplied, that is applied 
        !           548:  and then a second attempt is made to parse an unquoted decimal string. 
        !           549: 
        !           550:  Returns:
        !           551:    -3 if no input present when required,
        !           552:    -2 if user typed an illegal number,
        !           553:    -1 if reparse needed,
        !           554:     0 otherwise, with argument n set to the number that was parsed
        !           555: */
        !           556: int
        !           557: cmnum(xhlp,xdef,radix,n,f) char *xhlp, *xdef; int radix, *n; xx_strp f; {
        !           558:     int x; char *s, *zp, *zq;
        !           559:  
        !           560:     if (radix != 10) {                  /* Just do base 10 */
        !           561:         printf("cmnum: illegal radix - %d\n",radix);
        !           562:         return(-1);
        !           563:     }
        !           564:     x = cmfld(xhlp,xdef,&s,(xx_strp)0);
        !           565:     debug(F101,"cmnum: cmfld","",x);
        !           566:     if (x < 0) return(x);              /* Parse a field */
        !           567:     zp = atmbuf;
        !           568: 
        !           569:     if (chknum(zp)) {                  /* Check for decimal number */
        !           570:         *n = atoi(zp);                 /* Got one, we're done. */
        !           571:        debug(F101,"cmnum 1st chknum ok","",*n);
        !           572:         return(0);
        !           573:     } else if ((x = xxesc(&zp)) > -1) {        /* Check for backslash escape */
        !           574: 
        !           575: #ifndef OS2
        !           576:        *n = x;
        !           577: #else
        !           578:        *n = wideresult;
        !           579: #endif /* OS2 */
        !           580: 
        !           581:        debug(F101,"cmnum xxesc ok","",*n);
        !           582:        return(*zp ? -2 : 0);
        !           583:     } else if (f) {                    /* If conversion function given */
        !           584:         zp = atmbuf;                   /* Try that */
        !           585:        zq = atxbuf;
        !           586:        atxn = CMDBL;
        !           587:        (*f)(zp,&zq,&atxn);             /* Convert */
        !           588:        zp = atxbuf;
        !           589:     }
        !           590:     debug(F110,"cmnum zp",zp,0);
        !           591:     if (chknum(zp)) {                  /* Check again for decimal number */
        !           592:         *n = atoi(zp);                 /* Got one, we're done. */
        !           593:        debug(F101,"cmnum 2nd chknum ok","",*n);
        !           594:         return(0);
        !           595:     } else {                           /* Not numeric */
        !           596:        return(-2);     
        !           597:     }
        !           598: }
        !           599: 
        !           600: /*  C M O F I  --  Parse the name of an output file  */
        !           601:  
        !           602: /*
        !           603:  Depends on the external function zchko(); if zchko() not available, use
        !           604:  cmfld() to parse output file names.
        !           605:  
        !           606:  Returns
        !           607:    -3 if no input present when required,
        !           608:    -2 if permission would be denied to create the file,
        !           609:    -1 if reparse needed,
        !           610:     0 or 1 otherwise, with xp pointing to name.
        !           611: */
        !           612: int
        !           613: cmofi(xhlp,xdef,xp,f) char *xhlp, *xdef, **xp; xx_strp f; {
        !           614:     int x; char *s, *zq;
        !           615: #ifdef DTILDE
        !           616:     _PROTOTYP( char * tilde_expand, (char *) );
        !           617:     char *dirp;
        !           618: #endif 
        !           619: 
        !           620:     if (*xhlp == NUL) xhlp = "Output file";
        !           621:     *xp = "";
        !           622:  
        !           623:     if ((x = cmfld(xhlp,xdef,&s,(xx_strp)0)) < 0) return(x);
        !           624: 
        !           625:     if (f) {                           /* If a conversion function is given */
        !           626:        zq = atxbuf;
        !           627:        atxn = CMDBL;
        !           628:        if ((x = (*f)(s,&zq,&atxn)) < 0) return(-2);
        !           629:        s = atxbuf;
        !           630:     }
        !           631: 
        !           632: #ifdef DTILDE
        !           633:     dirp = tilde_expand(s);            /* Expand tilde, if any, */
        !           634:     if (*dirp != '\0') setatm(dirp);   /* right in the atom buffer. */
        !           635:     s = atmbuf;
        !           636: #endif
        !           637: 
        !           638:     if (iswild(s)) {
        !           639:         printf("?Wildcards not allowed - %s\n",s);
        !           640:         return(-2);
        !           641:     }
        !           642:     if (strcmp(s,CTTNAM) && (zchko(s) < 0)) { /* ok to write to tty */
        !           643:         printf("?Write permission denied - %s\n",s);
        !           644:         return(-9);
        !           645:     } else {
        !           646:         *xp = s;
        !           647:         return(x);
        !           648:     }
        !           649: }
        !           650: 
        !           651:  
        !           652: /*  C M I F I  --  Parse the name of an existing file  */
        !           653:  
        !           654: /*
        !           655:  This function depends on the external functions:
        !           656:    zchki()  - Check if input file exists and is readable.
        !           657:    zxpand() - Expand a wild file specification into a list.
        !           658:    znext()  - Return next file name from list.
        !           659:  If these functions aren't available, then use cmfld() to parse filenames.
        !           660: */
        !           661: /*
        !           662:  Returns
        !           663:    -4 EOF
        !           664:    -3 if no input present when required,
        !           665:    -2 if file does not exist or is not readable,
        !           666:    -1 if reparse needed,
        !           667:     0 or 1 otherwise, with:
        !           668:         xp pointing to name,
        !           669:         wild = 1 if name contains '*' or '?', 0 otherwise.
        !           670: */
        !           671: int
        !           672: cmifi(xhlp,xdef,xp,wild,f) char *xhlp, *xdef, **xp; int *wild; xx_strp f; {
        !           673:     int i, x, xc; long y; char *sp, *zq, *sv;
        !           674: #ifdef DTILDE
        !           675:     char *tilde_expand(), *dirp;
        !           676: #endif /* DTILDE */
        !           677: 
        !           678: #ifndef NOPARTIAL
        !           679:     extern char *mtchs[];
        !           680: #endif /* NOPARTIAL */
        !           681: 
        !           682:     inword = cc = xc = 0;              /* Initialize counts & pointers */
        !           683:     *xp = "";
        !           684:     if ((x = cmflgs) != 1) {            /* Already confirmed? */
        !           685:         x = gtword();                   /* No, get a word */
        !           686:     } else {
        !           687:         setatm(xdef);                  /* If so, use default, if any. */
        !           688:     }
        !           689: 
        !           690:     *xp = atmbuf;                       /* Point to result. */
        !           691:  
        !           692:     while (1) {
        !           693:         xc += cc;                       /* Count the characters. */
        !           694:         debug(F111,"cmifi gtword",atmbuf,xc);
        !           695:         switch (x) {
        !           696:             case -4:                    /* EOF */
        !           697:             case -2:                    /* Out of space. */
        !           698:             case -1:                    /* Reparse needed */
        !           699:                 return(x);
        !           700:             case 0:                     /* SP or NL */
        !           701:             case 1:
        !           702:                 if (xc == 0) *xp = xdef;     /* If no input, return default. */
        !           703:                 if (**xp == NUL) return(-3); /* If field empty, return -3. */
        !           704: 
        !           705:                if (f) {                /* If a conversion function is given */
        !           706:                    zq = atxbuf;        /* ... */
        !           707:                    atxn = CMDBL;
        !           708:                    if ((x = (*f)(*xp,&zq,&atxn)) < 0) return(-2);
        !           709:                    *xp = atxbuf;
        !           710:                }
        !           711:                debug(F110,"cmifi atxbuf",atxbuf,0);
        !           712: #ifdef COMMENT
        !           713: /* don't need this stuff, zxpand does it now. */
        !           714: #ifdef DTILDE
        !           715: 
        !           716:                dirp = tilde_expand(*xp);    /* Expand tilde, if any, */
        !           717:                if (*dirp != '\0') setatm(dirp); /* right in atom buffer. */
        !           718:                *xp = atmbuf;
        !           719: #endif /* DTILDE */
        !           720: 
        !           721:                 /* If filespec is wild, see if there are any matches */
        !           722: 
        !           723:                 *wild = iswild(*xp);
        !           724:                 debug(F101,"cmifi wild","",*wild);
        !           725:                 if (*wild != 0) {
        !           726: #endif /* COMMENT */
        !           727:                    sv = malloc((int)strlen(*xp)+1); /* Make a safe copy */
        !           728:                    if (!sv) {
        !           729:                        printf("?malloc error 73, cmifi\n");
        !           730:                        return(-9);
        !           731:                    }
        !           732:                    strcpy(sv,*xp);
        !           733:                    debug(F110,"cmifi sv",sv,0);
        !           734:                     y = zxpand(*xp);
        !           735:                    *wild = (y > 1);
        !           736:                    debug(F111,"cmifi sv wild",sv,*wild);
        !           737:                     if (y == 0) {
        !           738:                         printf("?No files match - %s\n",*xp);
        !           739:                         return(-9);
        !           740:                     } else if (y < 0) {
        !           741:                         printf("?Too many files match - %s\n",*xp);
        !           742:                         return(-9);
        !           743:                    } else if (y > 1) return(x);
        !           744: #ifdef COMMENT
        !           745:                 }
        !           746: #endif
        !           747:                 /* If not wild, see if it exists and is readable. */
        !           748:  
        !           749:                debug(F111,"cmifi sv not wild",sv,*wild);
        !           750: 
        !           751:                znext(*xp);             /* Get first (only?) matching file */
        !           752:                 y = zchki(*xp);                /* Check its accessibility */
        !           753:                zxpand(sv);             /* Rewind so next znext() gets 1st */
        !           754:                free(sv);               /* done with this */
        !           755:                 if (y == -3) {
        !           756:                     printf("?Read permission denied - %s\n",*xp);
        !           757:                     return(-9);
        !           758:                 } else if (y == -2) {
        !           759:                     printf("?File not readable - %s\n",*xp);
        !           760:                     return(-9);
        !           761:                 } else if (y < 0) {
        !           762:                     printf("?File not found - %s\n",*xp);
        !           763:                     return(-9);
        !           764:                 }
        !           765:                 return(x);
        !           766: 
        !           767: #ifndef MAC
        !           768:             case 2:                     /* ESC */
        !           769:                debug(F101,"cmifi esc, xc","",xc);
        !           770:                 if (xc == 0) {
        !           771:                     if (*xdef != '\0') {
        !           772:                         printf("%s ",xdef); /* If at beginning of field, */
        !           773: #ifdef GEMDOS
        !           774:                        fflush(stdout);
        !           775: #endif /* GEMDOS */
        !           776:                        inword = cmflgs = 0;
        !           777:                         addbuf(xdef);   /* supply default. */
        !           778:                         setatm(xdef);
        !           779:                     } else {            /* No default */
        !           780:                         putchar(BEL);
        !           781:                     }
        !           782:                     break;
        !           783:                 } 
        !           784:                if (f) {                /* If a conversion function is given */
        !           785:                    zq = atxbuf;        /* ... */
        !           786:                    atxn = CMDBL;
        !           787:                    if ((x = (*f)(*xp,&zq,&atxn)) < 0) return(-2);
        !           788:                     /* reduce cc by number of \\ consumed by conversion */
        !           789:                    /* function (needed for OS/2, where \ is path separator) */
        !           790:                     cc -= (strlen(*xp) - strlen(atxbuf));
        !           791:                    *xp = atxbuf;
        !           792:                }
        !           793: /* #ifdef COMMENT */
        !           794: #ifdef DTILDE
        !           795:                dirp = tilde_expand(*xp);    /* Expand tilde, if any, */
        !           796:                if (*dirp != '\0') setatm(dirp); /* in the atom buffer. */
        !           797:                 *xp = atmbuf;
        !           798: #endif /* DTILDE */
        !           799: /* #endif */
        !           800:                 sp = *xp + cc;
        !           801: #ifdef datageneral
        !           802:                 *sp++ = '+';           /* Data General AOS wildcard */
        !           803: #else
        !           804:                 *sp++ = '*';           /* Others */
        !           805: #endif /* datageneral */
        !           806:                 *sp-- = '\0';
        !           807: #ifdef GEMDOS
        !           808:                if (! strchr(*xp, '.')) /* abde.e -> abcde.e* */
        !           809:                  strcat(*xp, ".*");    /* abc -> abc*.* */
        !           810: #endif /* GEMDOS */
        !           811:                 y = zxpand(*xp);       /* Add wildcard and expand list. */
        !           812:                if (y > 0) strcpy(filbuf,mtchs[0]);
        !           813:                else *filbuf = '\0';
        !           814:                 *sp = '\0';             /* Remove wildcard. */
        !           815:                *wild = (y > 1);
        !           816:                 if (y == 0) {
        !           817:                     printf("?No files match - %s\n",atmbuf);
        !           818:                     return(-9);
        !           819:                 } else if (y < 0) {
        !           820:                     printf("?Too many files match - %s\n",atmbuf);
        !           821:                     return(-9);
        !           822:                 } else if (y > 1) {     /* Not unique. */
        !           823: #ifndef NOPARTIAL
        !           824: /* Partial filename completion */
        !           825:                    int i, j, k; char c;
        !           826:                    k = 0;
        !           827:                    debug(F111,"cmifi partial",filbuf,cc);
        !           828:                    for (i = cc; (c = filbuf[i]); i++) {
        !           829:                        for (j = 1; j < y; j++)
        !           830:                          if (mtchs[j][i] != c) break;
        !           831:                        if (j == y) k++;
        !           832:                        else filbuf[i] = filbuf[i+1] = NUL;
        !           833:                    }
        !           834:                    debug(F111,"cmifi partial k",filbuf,k);
        !           835:                    if (k > 0) {        /* Got more characters */
        !           836:                        sp = filbuf + cc; /* Point to new ones */
        !           837: #ifdef VMS
        !           838:                        for (i = 0; i < cc; i++) {
        !           839:                            cmdchardel(); /* Back up over old partial spec */
        !           840:                            bp--;
        !           841:                        }
        !           842:                        sp = filbuf;    /* Point to new word start */
        !           843:                        debug(F100,"cmifi vms erase ok","",0);
        !           844: #endif /* VMS */
        !           845:                        cc = k;         /* How many new ones we just got */
        !           846:                        printf("%s",sp);        /* Print them */
        !           847:                        while (*bp++ = *sp++) ; /* Copy to command buffer */
        !           848:                        bp--;                   /* Back up over NUL */
        !           849:                        debug(F110,"cmifi partial cmdbuf",cmdbuf,0);
        !           850:                        setatm(filbuf);
        !           851:                        debug(F111,"cmifi partial atmbuf",atmbuf,cc);
        !           852:                        *xp = atmbuf;
        !           853:                    }
        !           854: #endif /* NOPARTIAL */
        !           855:                    putchar(BEL);       /* Beep because not unique. */
        !           856:                 } else {                /* Unique, complete it.  */
        !           857:                     sp = filbuf + cc;   /* Point past what user typed. */
        !           858: #ifdef VMS
        !           859:                    for (i = 0; i < cc; i++) {
        !           860:                        cmdchardel();   /* Back up over old partial spec */
        !           861:                        bp--;
        !           862:                    }
        !           863:                    sp = filbuf;        /* Point to new word start */
        !           864: #endif /* VMS */
        !           865:                     printf("%s ",sp);   /* Complete the name. */
        !           866: #ifdef GEMDOS
        !           867:                    fflush(stdout);
        !           868: #endif /* GEMDOS */
        !           869:                     addbuf(sp);         /* Add the characters to cmdbuf. */
        !           870:                     setatm(filbuf);    /* And to atmbuf. */
        !           871:                    inword = cmflgs = 0;
        !           872:                     *xp = atmbuf;       /* Return pointer to atmbuf. */
        !           873:                     return(0);
        !           874:                 }
        !           875:                 break;
        !           876:  
        !           877:             case 3:                     /* Question mark */
        !           878:                 if (*xhlp == NUL)
        !           879:                  printf(" Input file specification");
        !           880:                 else
        !           881:                  printf(" %s",xhlp);
        !           882: #ifdef GEMDOS
        !           883:                fflush(stdout);
        !           884: #endif /* GEMDOS */
        !           885:                 if (xc > 0) {
        !           886:                    if (f) {            /* If a conversion function is given */
        !           887:                        zq = atxbuf;    /* ... */
        !           888:                        atxn = CMDBL;
        !           889:                        if ((x = (*f)(*xp,&zq,&atxn)) < 0) return(-2);
        !           890:                        *xp = atxbuf;
        !           891:                    }
        !           892: #ifdef DTILDE
        !           893:                    dirp = tilde_expand(*xp);    /* Expand tilde, if any */
        !           894:                    if (*dirp != '\0') setatm(dirp);
        !           895:                    *xp = atmbuf;
        !           896: #endif
        !           897:                    debug(F111,"cmifi ? *xp, cc",*xp,cc);
        !           898:                     sp = *xp + cc;     /* Insert "*" at end */
        !           899: #ifdef datageneral
        !           900:                     *sp++ = '+';        /* Insert +, the DG wild card */
        !           901: #else
        !           902:                     *sp++ = '*';
        !           903: #endif /* datageneral */
        !           904:                     *sp-- = '\0';
        !           905: #ifdef GEMDOS
        !           906:                    if (! strchr(*xp, '.'))     /* abde.e -> abcde.e* */
        !           907:                      strcat(*xp, ".*");        /* abc -> abc*.* */
        !           908: #endif /* GEMDOS */
        !           909:                    debug(F110,"cmifi ? wild",*xp,0);
        !           910:                     y = zxpand(*xp);
        !           911:                     *sp = '\0';
        !           912:                     if (y == 0) {                   
        !           913:                         printf("?No files match - %s\n",atmbuf);
        !           914:                         return(-9);
        !           915:                     } else if (y < 0) {
        !           916:                         printf("?Too many files match - %s\n",atmbuf);
        !           917:                         return(-9);
        !           918:                     } else {
        !           919:                         printf(", one of the following:\n");
        !           920:                         clrhlp();
        !           921:                         for (i = 0; i < y; i++) {
        !           922:                             znext(filbuf);
        !           923: #ifdef VMS
        !           924:                            printf(" %s\n",filbuf); /* VMS names can be long */
        !           925: #else
        !           926:                             addhlp(filbuf);
        !           927: #endif /* VMS */
        !           928:                         }
        !           929:                         dmphlp();
        !           930:                     }
        !           931:                 } else printf("\n");
        !           932:                 printf("%s%s",cmprom,cmdbuf);
        !           933:                fflush(stdout);
        !           934:                 break;
        !           935: #endif /* MAC */
        !           936:         }
        !           937:     x = gtword();
        !           938:     *xp = atmbuf;
        !           939:     }
        !           940: }
        !           941: 
        !           942: /*  C M D I R  --  Parse a directory specification  */
        !           943:  
        !           944: /*
        !           945:  This function depends on the external functions:
        !           946:    zchki()  - Check if input file exists and is readable.
        !           947:  If these functions aren't available, then use cmfld() to parse dir names.
        !           948:  Note: this function quickly cobbled together, mainly by deleting lots of
        !           949:  lines from cmifi().  It seems to work, but various services are missing,
        !           950:  like completion, lists of matching directories on "?", etc.
        !           951: */
        !           952: /*
        !           953:  Returns
        !           954:    -4 EOF
        !           955:    -3 if no input present when required,
        !           956:    -2 if out of space or other internal error,
        !           957:    -1 if reparse needed,
        !           958:     0 or 1, with xp pointing to name, if directory specified,
        !           959:     2 if a wildcard was included.
        !           960: */
        !           961: int
        !           962: cmdir(xhlp,xdef,xp,f) char *xhlp, *xdef, **xp; xx_strp f; {
        !           963:     int x, xc; char *zq;
        !           964: #ifdef DTILDE
        !           965:     char *tilde_expand(), *dirp;
        !           966: #endif /* DTILDE */
        !           967: 
        !           968:     inword = cc = xc = 0;              /* Initialize counts & pointers */
        !           969:     *xp = "";
        !           970:     if ((x = cmflgs) != 1) {            /* Already confirmed? */
        !           971:         x = gtword();                   /* No, get a word */
        !           972:     } else {
        !           973:         setatm(xdef);                  /* If so, use default, if any. */
        !           974:     }
        !           975:     *xp = atmbuf;                       /* Point to result. */
        !           976:     while (1) {
        !           977:         xc += cc;                       /* Count the characters. */
        !           978:         debug(F111,"cmdir gtword",atmbuf,xc);
        !           979:         switch (x) {
        !           980:             case -4:                    /* EOF */
        !           981:             case -2:                    /* Out of space. */
        !           982:             case -1:                    /* Reparse needed */
        !           983:                 return(x);
        !           984:             case 0:                     /* SP or NL */
        !           985:             case 1:
        !           986:                 if (xc == 0) *xp = xdef;     /* If no input, return default. */
        !           987:                else *xp = atmbuf;
        !           988:                 if (**xp == NUL) return(-3); /* If field empty, return -3. */
        !           989: 
        !           990:                if (f) {                /* If a conversion function is given */
        !           991:                    zq = atxbuf;        /* ... */
        !           992:                    atxn = CMDBL;
        !           993:                    if ((x = (*f)(*xp,&zq,&atxn)) < 0) return(-2);
        !           994:                    *xp = atxbuf;
        !           995:                    cc = (int)strlen(atxbuf);
        !           996:                }
        !           997: #ifdef DTILDE
        !           998: /*
        !           999:   This is ugly, and for UNIX only.
        !          1000:   Normally, we wouldn't call tilde_expand from a place like this anyway,
        !          1001:   but rather let zxpand() take care of it.  But in this case we might want 
        !          1002:   a hybrid result -- a string with the tilde expanded, but with wildcards
        !          1003:   left unexpanded.
        !          1004: */
        !          1005:                dirp = tilde_expand(*xp); /* Expand tilde, if any, */
        !          1006:                if (*dirp == '~') {     /* Still starts with tilde? */
        !          1007:                    char *tp;           /* Yes, convert to lowercase */
        !          1008:                    tp = *xp;           /* and try again. */
        !          1009:                    while (*tp) {
        !          1010:                        if (isupper(*tp)) *tp = tolower(*tp);
        !          1011:                        tp++;
        !          1012:                    }
        !          1013:                }
        !          1014:                dirp = tilde_expand(*xp); /* Expand tilde, if any, */
        !          1015:                if (*dirp != '\0') setatm(dirp); /* in the atom buffer. */
        !          1016:                *xp = atmbuf;
        !          1017: #endif /* DTILDE */
        !          1018:                if (iswild(*xp)) return(2);
        !          1019:                else return(x);
        !          1020: 
        !          1021:             case 2:                     /* ESC */
        !          1022:                putchar(BEL);
        !          1023:                break;
        !          1024: 
        !          1025:             case 3:                     /* Question mark */
        !          1026:                 if (*xhlp == NUL)
        !          1027:                     printf(" Directory name");
        !          1028:                 else
        !          1029:                     printf(" %s",xhlp);
        !          1030:                 printf("\n%s%s",cmprom,cmdbuf);
        !          1031:                fflush(stdout);
        !          1032:                 break;
        !          1033:         }
        !          1034:     x = gtword();
        !          1035: /*  *xp = atmbuf;  */
        !          1036:     }
        !          1037: }
        !          1038:  
        !          1039: /*  C M F L D  --  Parse an arbitrary field  */
        !          1040: /*
        !          1041:  Returns
        !          1042:    -3 if no input present when required,
        !          1043:    -2 if field too big for buffer,
        !          1044:    -1 if reparse needed,
        !          1045:     0 otherwise, xp pointing to string result.
        !          1046: */
        !          1047: int
        !          1048: cmfld(xhlp,xdef,xp,f) char *xhlp, *xdef, **xp; xx_strp f; {
        !          1049:     int x, xc;
        !          1050:     char *zq;
        !          1051: 
        !          1052:     inword = cc = xc = 0;              /* Initialize counts & pointers */
        !          1053:     *xp = "";
        !          1054:     if ((x = cmflgs) != 1) {            /* Already confirmed? */
        !          1055:         x = gtword();                   /* No, get a word */
        !          1056:     } else {
        !          1057:         setatm(xdef);                  /* If so, use default, if any. */
        !          1058:     }
        !          1059:     *xp = atmbuf;                       /* Point to result. */
        !          1060:  
        !          1061:     while (1) {
        !          1062:         xc += cc;                       /* Count the characters. */
        !          1063:         debug(F111,"cmfld: gtword",atmbuf,xc);
        !          1064:         debug(F101,"cmfld x","",x);
        !          1065:         switch (x) {
        !          1066:             case -4:                    /* EOF */
        !          1067:             case -2:                    /* Out of space. */
        !          1068:             case -1:                    /* Reparse needed */
        !          1069:                 return(x);
        !          1070:             case 0:                     /* SP or NL */
        !          1071:             case 1:
        !          1072:                 if (xc == 0)           /* If no input, return default. */
        !          1073:                  setatm(xdef);
        !          1074:                *xp = atmbuf;
        !          1075:                if (f) {                /* If a conversion function is given */
        !          1076:                    zq = atxbuf;        /* ... */
        !          1077:                    atxn = CMDBL;
        !          1078:                    if ((*f)(*xp,&zq,&atxn) < 0) return(-2);
        !          1079:                    setatm(atxbuf);
        !          1080:                    *xp = atmbuf;
        !          1081:                }
        !          1082:                 if (**xp == NUL) {     /* If variable evaluates to null */
        !          1083:                    setatm(xdef);       /* Stick in the default again. */
        !          1084:                    if (**xp == NUL) x = -3; /* If still empty, return -3. */
        !          1085:                }
        !          1086: #ifdef COMMENT
        !          1087: /* The following is apparently not necessary. */
        !          1088: /* Remove it if nothing is broken, esp. TAKE file with trailing comments */
        !          1089:                xx = *xp;
        !          1090:                debug(F111,"cmfld before trim",*xp,x);
        !          1091:                for (i = (int)strlen(xx) - 1; i > 0; i--)
        !          1092:                  if (xx[i] != SP)      /* Trim trailing blanks */
        !          1093:                    break;
        !          1094:                  else
        !          1095:                    xx[i] = NUL;
        !          1096:                debug(F111,"cmfld returns",*xp,x); 
        !          1097: #endif /* COMMENT */
        !          1098:                debug(F101,"cmfld: returns","",x);
        !          1099:                 return(x);
        !          1100:             case 2:                     /* ESC */
        !          1101:                 if (xc == 0 && *xdef != NUL) {
        !          1102:                     printf("%s ",xdef); /* If at beginning of field, */
        !          1103: #ifdef GEMDOS
        !          1104:                    fflush(stdout);
        !          1105: #endif /* GEMDOS */
        !          1106:                     addbuf(xdef);       /* supply default. */
        !          1107:                    inword = cmflgs = 0;
        !          1108:                     setatm(xdef);      /* Return as if whole field */
        !          1109:                     return(0);          /* typed, followed by space. */
        !          1110:                 } else {
        !          1111:                     putchar(BEL);       /* Beep if already into field. */
        !          1112:                 }                   
        !          1113:                 break;
        !          1114:             case 3:                     /* Question mark */
        !          1115:                 if (*xhlp == NUL)
        !          1116:                     printf(" Please complete this field");
        !          1117:                 else
        !          1118:                     printf(" %s",xhlp);
        !          1119:                 printf("\n%s%s",cmprom,cmdbuf);
        !          1120:                fflush(stdout);
        !          1121:                 break;
        !          1122:         }
        !          1123:     x = gtword();
        !          1124: /*  *xp = atmbuf; */
        !          1125:     }
        !          1126: }
        !          1127: 
        !          1128:  
        !          1129: /*  C M T X T  --  Get a text string, including confirmation  */
        !          1130:  
        !          1131: /*
        !          1132:   Print help message 'xhlp' if ? typed, supply default 'xdef' if null
        !          1133:   string typed.  Returns
        !          1134:  
        !          1135:    -1 if reparse needed or buffer overflows.
        !          1136:     1 otherwise.
        !          1137:  
        !          1138:   with cmflgs set to return code, and xp pointing to result string.
        !          1139: */
        !          1140: int
        !          1141: cmtxt(xhlp,xdef,xp,f) char *xhlp; char *xdef; char **xp; xx_strp f; {
        !          1142:  
        !          1143:     int x, i;
        !          1144:     char *xx, *zq;
        !          1145:     static int xc;
        !          1146:  
        !          1147:     debug(F101,"cmtxt, cmflgs","",cmflgs);
        !          1148:     inword = cc = 0;                   /* Start atmbuf counter off at 0 */
        !          1149:     if (cmflgs == -1) {                 /* If reparsing, */
        !          1150:         xc = (int)strlen(*xp);         /* get back the total text length, */
        !          1151:     } else {                            /* otherwise, */
        !          1152:         *xp = "";                       /* start fresh. */
        !          1153:         xc = 0;
        !          1154:     }
        !          1155:     *atmbuf = NUL;                      /* And empty the atom buffer. */
        !          1156:     if ((x = cmflgs) != 1) {
        !          1157:         x = gtword();                   /* Get first word. */
        !          1158:         *xp = pp;                       /* Save pointer to it. */
        !          1159:     }
        !          1160:     debug(F101,"cmtxt (*f)","", f);
        !          1161:     while (1) {                                /* Loop for each word in text. */
        !          1162:         xc += cc;                       /* Char count for all words. */
        !          1163:         debug(F111,"cmtxt: gtword",atmbuf,xc);
        !          1164:         debug(F101," x","",x);
        !          1165:         switch (x) {
        !          1166:          case -9:                      /* Buffer overflow */
        !          1167:          case -4:                      /* EOF */
        !          1168: #ifdef MAC
        !          1169:          case -3:                      /* Quit/Timeout */
        !          1170: #endif /* MAC */
        !          1171:          case -2:                      /* Overflow */
        !          1172:          case -1:                      /* Deletion */
        !          1173:            return(x);
        !          1174:          case 0:                       /* Space */
        !          1175:            xc++;                       /* Just count it */
        !          1176:            break;
        !          1177:          case 1:                       /* CR or LF */
        !          1178:            if (xc == 0) *xp = xdef;
        !          1179:            if (f) {                    /* If a conversion function is given */
        !          1180:                zq = atxbuf;            /* Point to the expansion buffer */
        !          1181:                atxn = CMDBL;           /* specify its length */
        !          1182:                debug(F110,"cmtxt calling (*f)",*xp,0);
        !          1183:                if ((x = (*f)(*xp,&zq,&atxn)) < 0) return(-2);
        !          1184:                cc = (int)strlen(atxbuf);
        !          1185:                *xp = atxbuf;           /* and return pointer to it. */
        !          1186:                debug(F111,"cmtxt (*f) returns",*xp,cc);
        !          1187:            }
        !          1188:            xx = *xp;
        !          1189:            for (i = (int)strlen(xx) - 1; i > 0; i--)
        !          1190:              if (xx[i] != SP)          /* Trim trailing blanks */
        !          1191:                break;
        !          1192:              else
        !          1193:                xx[i] = NUL;
        !          1194:            return(x);
        !          1195:          case 2:                       /* ESC */
        !          1196:            if (xc == 0) {
        !          1197:                printf("%s ",xdef);
        !          1198:                inword = cmflgs = 0;
        !          1199: #ifdef GEMDOS
        !          1200:                fflush(stdout);
        !          1201: #endif /* GEMDOS */
        !          1202:                cc = addbuf(xdef);
        !          1203:            } else {
        !          1204:                putchar(BEL);
        !          1205:            }
        !          1206:            break;
        !          1207:          case 3:                       /* Question Mark */
        !          1208:            if (*xhlp == NUL)
        !          1209:              printf(" Text string");
        !          1210:            else
        !          1211:              printf(" %s",xhlp);
        !          1212:            printf("\n%s%s",cmprom,cmdbuf);
        !          1213:            fflush(stdout);
        !          1214:            break;
        !          1215:          default:
        !          1216:            printf("?Unexpected return code from gtword() - %d\n",x);
        !          1217:            return(-2);
        !          1218:         }
        !          1219:         x = gtword();
        !          1220:     }
        !          1221: }
        !          1222: 
        !          1223:  
        !          1224: /*  C M K E Y  --  Parse a keyword  */
        !          1225:  
        !          1226: /*
        !          1227:  Call with:
        !          1228:    table    --  keyword table, in 'struct keytab' format;
        !          1229:    n        --  number of entries in table;
        !          1230:    xhlp     --  pointer to help string;
        !          1231:    xdef     --  pointer to default keyword;
        !          1232:  
        !          1233:  Returns:
        !          1234:    -3       --  no input supplied and no default available
        !          1235:    -2       --  input doesn't uniquely match a keyword in the table
        !          1236:    -1       --  user deleted too much, command reparse required
        !          1237:     n >= 0  --  value associated with keyword
        !          1238: */
        !          1239: int
        !          1240: cmkey(table,n,xhlp,xdef,f)
        !          1241: /* cmkey */  struct keytab table[]; int n; char *xhlp, *xdef; xx_strp f; {
        !          1242:     return(cmkey2(table,n,xhlp,xdef,"",f));
        !          1243: }
        !          1244: int
        !          1245: cmkey2(table,n,xhlp,xdef,tok,f)
        !          1246:     struct keytab table[]; int n; char *xhlp, *xdef; char *tok; xx_strp f; {
        !          1247: 
        !          1248:     int i, tl, y, z, zz, xc;
        !          1249:     char *xp, *zq;
        !          1250:  
        !          1251:     tl = (int)strlen(tok);
        !          1252:     inword = xc = cc = 0;              /* Clear character counters. */
        !          1253:  
        !          1254:     if ((zz = cmflgs) == 1)             /* Command already entered? */
        !          1255:       setatm(xdef);                    /* Yes, copy default into atom buf */
        !          1256:     else zz = gtword();                        /* Otherwise get a command word */
        !          1257:  
        !          1258: debug(F101,"cmkey: table length","",n);
        !          1259: debug(F101," cmflgs","",cmflgs);
        !          1260: debug(F101," zz","",zz);
        !          1261: while (1) {
        !          1262:     xc += cc;
        !          1263:     debug(F111,"cmkey: gtword",atmbuf,xc);
        !          1264:  
        !          1265:     switch(zz) {
        !          1266:         case -4:                        /* EOF */
        !          1267: #ifdef MAC
        !          1268:        case -3:                        /* Quit/Timeout */
        !          1269: #endif /* MAC */
        !          1270:         case -2:                        /* Buffer overflow */
        !          1271:         case -1:                        /* Or user did some deleting. */
        !          1272:             return(cmflgs = zz);
        !          1273:  
        !          1274:         case 0:                         /* User terminated word with space */
        !          1275:         case 1:                         /* or newline */
        !          1276:             if (cc == 0) setatm(xdef); /* Supply default if user typed nada */
        !          1277:            if (f) {                    /* If a conversion function is given */
        !          1278:                zq = atxbuf;            /* apply it */
        !          1279:                atxn = CMDBL;
        !          1280:                if ((*f)(atmbuf,&zq,&atxn) < 0) return(-2);
        !          1281:                debug(F110,"cmkey atxbuf after *f",atxbuf,0);
        !          1282:                setatm(atxbuf);
        !          1283:            }
        !          1284:             y = lookup(table,atmbuf,n,&z); /* Look up the word in the table */
        !          1285:             switch (y) {
        !          1286:                 case -2:               /* Ambiguous */
        !          1287:                     printf("?Ambiguous - %s\n",atmbuf);
        !          1288:                    cmflgs = -2;
        !          1289:                     return(-9);
        !          1290:                 case -1:               /* Not found at all */
        !          1291:                    if (tl) {
        !          1292:                        for (i = 0; i < tl; i++) /* Check for token */
        !          1293:                          if (tok[i] == *atmbuf) { /* Got one */
        !          1294:                              ungword();  /* Put back the following word */
        !          1295:                              return(-5); /* Special return code for token */
        !          1296:                          }
        !          1297:                    }
        !          1298:                    /* Kludge alert... only print error if */
        !          1299:                    /* we were called as cmkey2, but not cmkey... */
        !          1300:                    /* This doesn't seem to always work. */
        !          1301:                    if (tl == 0) {
        !          1302:                        printf("?No keywords match - %s\n",atmbuf); /* cmkey */
        !          1303:                        return(cmflgs = -9);
        !          1304:                    } else { 
        !          1305:                        if (cmflgs == 1) return(cmflgs = -6); /* cmkey2 */
        !          1306:                        else return(cmflgs = -2);
        !          1307:                        /* The -6 code is to let caller try another table */
        !          1308:                    }
        !          1309:                 default:
        !          1310:                     break;
        !          1311:                }
        !          1312:             return(y);
        !          1313:  
        !          1314:         case 2:                         /* User terminated word with ESC */
        !          1315:             if (cc == 0) {
        !          1316:                 if (*xdef != NUL) {     /* Nothing in atmbuf */
        !          1317:                     printf("%s ",xdef); /* Supply default if any */
        !          1318: #ifdef GEMDOS
        !          1319:                    fflush(stdout);
        !          1320: #endif /* GEMDOS */
        !          1321:                     addbuf(xdef);
        !          1322:                     setatm(xdef);
        !          1323:                    inword = cmflgs = 0;
        !          1324:                     debug(F111,"cmkey: default",atmbuf,cc);
        !          1325:                 } else {
        !          1326:                     putchar(BEL);       /* No default, just beep */
        !          1327:                     break;
        !          1328:                 }
        !          1329:             }
        !          1330:            if (f) {                    /* If a conversion function is given */
        !          1331:                zq = atxbuf;            /* apply it */
        !          1332:                atxn = CMDBL;
        !          1333:                if ((*f)(atmbuf,&zq,&atxn) < 0) return(-2);
        !          1334:                setatm(atxbuf);
        !          1335:            }
        !          1336:             y = lookup(table,atmbuf,n,&z); /* Something in atmbuf */
        !          1337:             debug(F111,"cmkey: esc",atmbuf,y);
        !          1338:             if (y == -2) {             /* Ambiguous */
        !          1339:                 putchar(BEL);
        !          1340:                 break;
        !          1341:             }
        !          1342:             if (y == -1) {             /* Not found */
        !          1343:                 /* if (tl == 0) */ printf("?No keywords match - %s\n",atmbuf);
        !          1344:                cmflgs = -2;
        !          1345:                 return(-9);
        !          1346:             }
        !          1347: /*
        !          1348:   See if the keyword just found has the CM_ABR bit set in its flgs field, and
        !          1349:   if so, search forwards in the table for a keyword that has the same kwval
        !          1350:   but does not have CM_ABR (or CM_INV?) set, and then expand using the full
        !          1351:   keyword.  WARNING: This assumes that (a) keywords are in alphabetical order,
        !          1352:   and (b) the CM_ABR bit is set only if the the abbreviated keyword is a true
        !          1353:   abbreviation (left substring) of the full keyword.
        !          1354: */
        !          1355:            if (test(table[z].flgs,CM_ABR)) {
        !          1356:                int zz;
        !          1357:                for (zz = z+1; zz < n; zz++)
        !          1358:                  if ((table[zz].kwval == table[z].kwval) &&
        !          1359:                      (!test(table[zz].flgs,CM_ABR))) {
        !          1360:                      z = zz;
        !          1361:                      break;
        !          1362:                  }
        !          1363:             } 
        !          1364:             xp = table[z].kwd + cc;
        !          1365:             printf("%s ",xp);
        !          1366: #ifdef GEMDOS
        !          1367:            fflush(stdout);
        !          1368: #endif /* GEMDOS */
        !          1369:             addbuf(xp);
        !          1370:            inword = cmflgs = 0;
        !          1371:             debug(F110,"cmkey: addbuf",cmdbuf,0);
        !          1372:             return(y);
        !          1373:  
        !          1374:         case 3:                         /* User typed "?" */
        !          1375:            if (f) {                    /* If a conversion function is given */
        !          1376:                zq = atxbuf;            /* do the conversion now. */
        !          1377:                atxn = CMDBL;
        !          1378:                if ((*f)(atmbuf,&zq,&atxn) < 0) return(-2);
        !          1379:                setatm(atxbuf);
        !          1380:            }
        !          1381:             y = lookup(table,atmbuf,n,&z); /* Look up what we have so far. */
        !          1382: 
        !          1383:            if (y == -1) {
        !          1384:                 /* if (tl == 0) */ printf(" No keywords match\n");
        !          1385:                cmflgs = -2;
        !          1386:                 return(-9);
        !          1387:             }
        !          1388:             if (*xhlp == NUL)
        !          1389:                 printf(" One of the following:\n");
        !          1390:             else
        !          1391:                 printf(" %s, one of the following:\n",xhlp);
        !          1392:  
        !          1393:            if ((y > -1) &&
        !          1394:                !test(table[z].flgs,CM_ABR) &&
        !          1395:                ((z >= n-1) || strncmp(table[z].kwd,table[z+1].kwd,cc))
        !          1396:                 ) {
        !          1397:                printf(" %s\n",table[z].kwd);
        !          1398:            } else {
        !          1399:                clrhlp();
        !          1400:                for (i = 0; i < n; i++) {   
        !          1401:                    if (!strncmp(table[i].kwd,atmbuf,cc)
        !          1402:                        && !test(table[i].flgs,CM_INV)
        !          1403:                        )
        !          1404:                      addhlp(table[i].kwd);
        !          1405:                }
        !          1406:                dmphlp();
        !          1407:            }
        !          1408:            if (*atmbuf == NUL) {
        !          1409:                if (tl == 1)
        !          1410:                  printf("or the token '%c'\n",*tok);
        !          1411:                else if (tl > 1) printf("or one of the tokens '%s'\n",tok);
        !          1412:            }
        !          1413:             printf("%s%s", cmprom, cmdbuf);
        !          1414:            fflush(stdout);
        !          1415:             break;
        !          1416:  
        !          1417:         default:            
        !          1418:             printf("\n%d - Unexpected return code from gtword\n",zz);
        !          1419:             return(cmflgs = -2);
        !          1420:         }
        !          1421:         zz = gtword();
        !          1422:     }
        !          1423: }
        !          1424: int
        !          1425: chktok(tlist) char *tlist; {
        !          1426:     char *p;
        !          1427:     p = tlist;
        !          1428:     while (*p != NUL && *p != *atmbuf) p++;
        !          1429:     return((*p) ? (int) *p : 0);
        !          1430: }
        !          1431: 
        !          1432: /*  C M C F M  --  Parse command confirmation (end of line)  */
        !          1433:  
        !          1434: /*
        !          1435:  Returns
        !          1436:    -2: User typed anything but whitespace or newline
        !          1437:    -1: Reparse needed
        !          1438:     0: Confirmation was received
        !          1439: */
        !          1440: int
        !          1441: cmcfm() {
        !          1442:     int x, xc;
        !          1443:  
        !          1444:     debug(F101,"cmcfm: cmflgs","",cmflgs);
        !          1445:     debug(F110,"cmcfm: atmbuf",atmbuf,0);
        !          1446:     inword = xc = cc = 0;
        !          1447:     if (cmflgs == 1) return(0);
        !          1448: 
        !          1449:     setatm("");                                /* (Probably unnecessary) */
        !          1450:  
        !          1451:     while (1) {
        !          1452:         x = gtword();
        !          1453:         xc += cc;
        !          1454:         switch (x) {
        !          1455:             case -4:                    /* EOF */
        !          1456:             case -2:
        !          1457:             case -1:
        !          1458:                 return(x);
        !          1459:  
        !          1460:             case 1:                     /* End of line */
        !          1461:                 if (xc > 0) {
        !          1462:                     printf("?Not confirmed - %s\n",atmbuf);
        !          1463:                     return(-9);
        !          1464:                 } else return(0);                   
        !          1465:             case 2:                    /* ESC */
        !          1466:                if (xc == 0) {
        !          1467:                    putchar(BEL);       /* beep & continue */
        !          1468:                    continue;           /* or fall thru. */
        !          1469:                }
        !          1470:             case 0:                     /* Space */
        !          1471:                if (xc == 0)            /* If no chars typed, continue, */
        !          1472:                  continue;             /* else fall thru. */
        !          1473:             case 3:                    /* Question mark */
        !          1474:                 if (xc > 0) {
        !          1475:                     printf("?Not confirmed - %s\n",atmbuf);
        !          1476:                     return(-9);
        !          1477:                 }
        !          1478:                 printf("\n Type a carriage return to confirm the command\n");
        !          1479:                 printf("%s%s",cmprom,cmdbuf);
        !          1480:                fflush(stdout);
        !          1481:                 continue;
        !          1482:         }
        !          1483:     }
        !          1484: }
        !          1485: 
        !          1486: /* Keyword help routines */
        !          1487:  
        !          1488:  
        !          1489: /*  C L R H L P -- Initialize/Clear the help line buffer  */
        !          1490:  
        !          1491: VOID
        !          1492: clrhlp() {                              /* Clear the help buffer */
        !          1493:     hlpbuf[0] = NUL;
        !          1494:     hh = hx = 0;
        !          1495: }
        !          1496:  
        !          1497:  
        !          1498: /*  A D D H L P  --  Add a string to the help line buffer  */
        !          1499:  
        !          1500: VOID
        !          1501: addhlp(s) char *s; {                    /* Add a word to the help buffer */
        !          1502:     int j;
        !          1503:  
        !          1504:     hh++;                               /* Count this column */
        !          1505:  
        !          1506:     for (j = 0; (j < hc) && (*s != NUL); j++) { /* Fill the column */
        !          1507:         hlpbuf[hx++] = *s++;
        !          1508:     }
        !          1509:     if (*s != NUL)                      /* Still some chars left in string? */
        !          1510:         hlpbuf[hx-1] = '+';             /* Mark as too long for column. */
        !          1511:  
        !          1512:     if (hh < (hw / hc)) {               /* Pad col with spaces if necessary */
        !          1513:         for (; j < hc; j++) {
        !          1514:             hlpbuf[hx++] = SP;
        !          1515:         }
        !          1516:     } else {                            /* If last column, */
        !          1517:         hlpbuf[hx++] = NUL;             /* no spaces. */
        !          1518:         dmphlp();                       /* Print it. */
        !          1519:         return;
        !          1520:     }
        !          1521: }
        !          1522:  
        !          1523:  
        !          1524: /*  D M P H L P  --  Dump the help line buffer  */
        !          1525:  
        !          1526: VOID
        !          1527: dmphlp() {                              /* Print the help buffer */
        !          1528:     hlpbuf[hx++] = NUL;
        !          1529:     printf(" %s\n",hlpbuf);
        !          1530:     clrhlp();
        !          1531: }
        !          1532: 
        !          1533:  
        !          1534: /*  G T W O R D  --  Gets a "word" from the command input stream  */
        !          1535:  
        !          1536: /*
        !          1537: Usage: retcode = gtword();
        !          1538:  
        !          1539: Returns:
        !          1540:  -4 if end of file (e.g. pipe broken)
        !          1541:  -2 if command buffer overflows
        !          1542:  -1 if user did some deleting
        !          1543:   0 if word terminates with SP or tab
        !          1544:   1 if ... CR
        !          1545:   2 if ... ESC
        !          1546:   3 if ... ? (question mark)
        !          1547:  
        !          1548: With:
        !          1549:   pp pointing to beginning of word in buffer
        !          1550:   bp pointing to after current position
        !          1551:   atmbuf containing a copy of the word
        !          1552:   cc containing the number of characters in the word copied to atmbuf
        !          1553: */
        !          1554: 
        !          1555: int
        !          1556: ungword() {                            /* unget a word */
        !          1557:     if (ungw) return(0);
        !          1558:     cmfsav = cmflgs;
        !          1559:     debug(F101,"ungword cmflgs","",cmflgs);
        !          1560:     ungw = 1;
        !          1561:     cmflgs = 0;
        !          1562:     return(0);
        !          1563: }
        !          1564: 
        !          1565: int
        !          1566: gtword() {
        !          1567:     int c;                              /* Current char */
        !          1568:     int quote = 0;                      /* Flag for quote character */
        !          1569:     int echof = 0;                      /* Flag for whether to echo */
        !          1570:     int chsrc = 0;                     /* Source of character, 1 = tty */
        !          1571:     int comment = 0;                   /* Flag for in comment */
        !          1572:     char *cp = NULL;                   /* Comment pointer */
        !          1573: 
        !          1574: #ifdef RTU
        !          1575:     extern int rtu_bug;
        !          1576: #endif /* RTU */
        !          1577: 
        !          1578: #ifdef datageneral
        !          1579:     extern int termtype;                /* DG terminal type flag */
        !          1580:     extern int con_reads_mt;            /* Console read asynch is active */
        !          1581:     if (con_reads_mt) connoi_mt();      /* Task would interfere w/cons read */
        !          1582: #endif /* datageneral */
        !          1583:  
        !          1584:     if (ungw) {                                /* Have a word saved? */
        !          1585:        debug(F110,"gtword ungetting from pp",pp,0);
        !          1586:        while (*pp++ == SP) ;
        !          1587:        setatm(pp);
        !          1588:        ungw = 0;
        !          1589:        cmflgs = cmfsav;
        !          1590:        debug(F111,"gtword returning atmbuf",atmbuf,cmflgs);
        !          1591:        return(cmflgs);
        !          1592:     }
        !          1593:     pp = np;                            /* Start of current field */
        !          1594: 
        !          1595:     debug(F111,"gtword: cmdbuf",cmdbuf,cmdbuf);
        !          1596:     debug(F111," bp",bp,bp);
        !          1597:     debug(F111," pp",pp,pp);
        !          1598:  
        !          1599:     while (bp < cmdbuf+CMDBL) {         /* Big get-a-character loop */
        !          1600:        echof = 0;                      /* Assume we don't echo because */
        !          1601:        chsrc = 0;                      /* character came from reparse buf. */
        !          1602: 
        !          1603:         if ((c = *bp) == NUL) {         /* If no char waiting in reparse buf */
        !          1604:             if (dpx) echof = 1;         /* must get from tty, set echo flag. */
        !          1605:            c = cmdgetc();              /* Read a character from the tty. */
        !          1606:            chsrc = 1;                  /* Remember character source is tty. */
        !          1607: #ifdef MAC
        !          1608:            if (c == -3)                /* If null command... */
        !          1609:              return(-3);
        !          1610: #endif /* MAC */
        !          1611:             if (c == EOF) {            /* This can happen if stdin not tty. */
        !          1612: #ifdef EINTR
        !          1613:                if (errno == EINTR)     /* This is for when bg'd process is */
        !          1614:                  continue;             /* fg'd again. */
        !          1615: #endif /* EINTR */
        !          1616:                return(-4);
        !          1617:            }
        !          1618:            c &= cmdmsk;                /* Strip any parity bit */
        !          1619:        }                               /* if desired. */
        !          1620: #ifndef MAC
        !          1621:        debug(F000,"gtword char","",c);
        !          1622: #endif /* MAC */
        !          1623: 
        !          1624: /* Now we have the next character */
        !          1625: 
        !          1626:         if (quote == 0) {              /* If this is not a quoted character */
        !          1627:             if (c == CMDQ) {           /* Got the quote character itself */
        !          1628:                if (!comment) quote = 1; /* Flag it if not in a comment */
        !          1629:             }
        !          1630:            if (c == FF) {              /* Formfeed. */
        !          1631:                 c = NL;                 /* Replace with newline */
        !          1632: #ifdef COMMENT
        !          1633: /* No more screen clearing... */
        !          1634:                cmdclrscn();            /* Clear the screen */
        !          1635: #endif /* COMMENT */
        !          1636:             }
        !          1637:            if (c == HT) {              /* Tab */
        !          1638:                if (comment)            /* If in comment, */
        !          1639:                  c = SP;               /* substitute space */
        !          1640:                else                    /* otherwise */
        !          1641:                  c = ESC;              /* substitute ESC (for completion) */
        !          1642:            }
        !          1643:            if (c == ';' || c == '#') { /* Trailing comment */
        !          1644:                if (inword == 0) {      /* If we're not in a word */
        !          1645:                    comment = 1;        /* start a comment. */
        !          1646:                    cp = bp;            /* remember where it starts. */
        !          1647:                }
        !          1648:            }
        !          1649:            if (!comment && c == SP) {  /* Space */
        !          1650:                 *bp++ = c;             /* deposit in buffer if not already */
        !          1651:                 if (echof) putchar(c);  /* echo it. */
        !          1652:                 if (inword == 0) {      /* If leading, gobble it. */
        !          1653:                     pp++;
        !          1654:                     continue;
        !          1655:                 } else {                /* If terminating, return. */
        !          1656:                     np = bp;
        !          1657:                     setatm(pp);
        !          1658:                     inword = cmflgs = 0;
        !          1659:                    return(0);
        !          1660:                 }
        !          1661:             }
        !          1662:             if (c == NL || c == CR) {   /* CR or LF. */
        !          1663:                if (echof) cmdnewl((char)c); /* Echo it. */
        !          1664:                while (bp > pp && (*(bp-1) == SP || *(bp-1) == HT)) /* Trim */
        !          1665:                  bp--;                 /* trailing */
        !          1666:                *bp = NUL;              /* whitespace */
        !          1667:                if (*(bp-1) == '-') {   /* Is this line continued? */
        !          1668:                    if (chsrc) {        /* If reading from tty, */
        !          1669: #ifdef COMMENT
        !          1670:                        bp--, pp--;     /* back up the buffer pointer, */
        !          1671: #else
        !          1672:                        bp--;
        !          1673: #endif /* COMMENT */
        !          1674:                        *bp = NUL;      /* erase the dash, */
        !          1675:                        continue;       /* and go back for next char now. */
        !          1676:                    }
        !          1677:                } else {                /* No, a command has been entered. */
        !          1678:                    *bp = NUL;          /* Terminate the command string. */
        !          1679:                    if (comment) {      /* If we're in a comment, */
        !          1680:                        comment = 0;    /* Say we're not any more, */
        !          1681:                        *cp = NUL;      /* cut it off. */
        !          1682:                    }
        !          1683:                    np = bp;            /* Where to start next field. */
        !          1684:                    setatm(pp);         /* Copy this field to atom buffer. */
        !          1685:                    inword = 0;         /* Not in a word any more. */
        !          1686:                    return(cmflgs = 1);
        !          1687:                }
        !          1688:             }
        !          1689:             if (!comment && echof && (c == '?')) { /* Question mark */
        !          1690:                 putchar(c);
        !          1691:                 *bp = NUL;
        !          1692:                 setatm(pp);
        !          1693:                 return(cmflgs = 3);
        !          1694:             }
        !          1695:             if (c == ESC) {            /* ESC */
        !          1696:                if (!comment) {
        !          1697:                    *bp = NUL;
        !          1698:                    setatm(pp);
        !          1699:                    return(cmflgs = 2);
        !          1700:                } else {
        !          1701:                    putchar(BEL);
        !          1702:                    continue;
        !          1703:                }
        !          1704:             }
        !          1705:             if (c == BS || c == RUB) {  /* Character deletion */
        !          1706:                 if (bp > cmdbuf) {      /* If still in buffer... */
        !          1707:                    cmdchardel();       /* erase it. */
        !          1708:                     bp--;               /* point behind it, */
        !          1709:                     if (*bp == SP) inword = 0; /* Flag if current field gone */
        !          1710:                     *bp = NUL;          /* Erase character from buffer. */
        !          1711:                 } else {                /* Otherwise, */
        !          1712:                     putchar(BEL);       /* beep, */
        !          1713:                     cmres();            /* and start parsing a new command. */
        !          1714:                    *bp = *atmbuf = NUL;
        !          1715:                 }
        !          1716:                 if (pp < bp) continue;
        !          1717:                 else return(cmflgs = -1);
        !          1718:             }
        !          1719:             if (c == LDEL) {            /* ^U, line deletion */
        !          1720:                 while ((bp--) > cmdbuf) {
        !          1721:                     cmdchardel();
        !          1722:                     *bp = NUL;
        !          1723:                 }
        !          1724:                 cmres();                /* Restart the command. */
        !          1725:                *bp = *atmbuf = NUL;
        !          1726:                 inword = 0;
        !          1727:                 return(cmflgs = -1);
        !          1728:             }
        !          1729:             if (c == WDEL) {            /* ^W, word deletion */
        !          1730:                 if (bp <= cmdbuf) {     /* Beep if nothing to delete */
        !          1731:                     putchar(BEL);
        !          1732:                     cmres();
        !          1733:                    *bp = *atmbuf = NUL;
        !          1734:                     return(cmflgs = -1);
        !          1735:                 }
        !          1736:                 bp--;
        !          1737:                 for ( ; (bp >= cmdbuf) && (*bp == SP) ; bp--) {
        !          1738:                     cmdchardel();
        !          1739:                     *bp = NUL;
        !          1740:                 }
        !          1741:                 for ( ; (bp >= cmdbuf) && (*bp != SP) ; bp--) {
        !          1742:                     cmdchardel();
        !          1743:                     *bp = NUL;
        !          1744:                 }
        !          1745:                 bp++;
        !          1746:                 inword = 0;
        !          1747:                 return(cmflgs = -1);
        !          1748:             }
        !          1749:             if (c == RDIS) {            /* ^R, redisplay */
        !          1750: #ifdef COMMENT
        !          1751:                 *bp = NUL;
        !          1752:                 printf("\n%s%s",cmprom,cmdbuf);
        !          1753: #else
        !          1754:                char *cpx; char cx;
        !          1755:                 *bp = NUL;
        !          1756:                 printf("\n%s",cmprom);
        !          1757:                cpx = cmdbuf;
        !          1758:                while (cx = *cpx++) {
        !          1759: #ifdef isprint
        !          1760:                    putchar(isprint(cx) ? cx : '^');
        !          1761: #else
        !          1762:                    putchar((cx >= SP && cx < DEL) ? cx : '^');
        !          1763: #endif /* isprint */
        !          1764:                }
        !          1765: #endif /* COMMENT */
        !          1766:                fflush(stdout);
        !          1767:                 continue;
        !          1768:             }
        !          1769:            if (c < SP && quote == 0) { /* Any other unquoted control char */
        !          1770:                if (!chsrc) bp++;       /* If cmd file, point past it */
        !          1771:                else putchar(BEL);      /* otherwise just beep and */
        !          1772:                continue;               /* continue, don't put in buffer */
        !          1773:            }
        !          1774:            if (echof) cmdecho((char) c, 0); /* Echo what was typed. */
        !          1775:         } else {                       /* This character was quoted. */
        !          1776:            int qf = 1;
        !          1777:            quote = 0;                  /* Unset the quote flag. */
        !          1778:            /* Quote character at this level is only for SP, ?, and controls */
        !          1779:             /* If anything else was quoted, leave quote in, and let */
        !          1780:            /* the command-specific parsing routines handle it, e.g. \007 */
        !          1781:            if (c > 32 && c != '?' && c != RUB && chsrc != 0) {
        !          1782:                *bp++ = CMDQ;           /* Deposit \ if it came from tty */
        !          1783:                qf = 0;                 /* and don't erase it from screen */
        !          1784:            }
        !          1785:            if (echof) cmdecho((char) c, qf); /* Now echo quoted character */
        !          1786:            debug(F000,"gtword quote",cmdbuf,c);
        !          1787:        }
        !          1788: #ifdef COMMENT
        !          1789:         if (echof) cmdecho((char) c,quote); /* Echo what was typed. */
        !          1790: #endif /* COMMENT */
        !          1791:         if (!comment) inword = 1;      /* Flag we're in a word. */
        !          1792:        if (quote) continue;            /* Don't deposit quote character. */
        !          1793:         if (c != NL) *bp++ = c;                /* Deposit command character. */
        !          1794:     }                                   /* End of big while */
        !          1795:     putchar(BEL);                       /* Get here if... */
        !          1796:     printf("?Command too long, maximum length: %d.\n",CMDBL);
        !          1797:     cmflgs = -2;
        !          1798:     return(-9);
        !          1799: }
        !          1800: 
        !          1801: /* Utility functions */
        !          1802:  
        !          1803: /* A D D B U F  -- Add the string pointed to by cp to the command buffer  */
        !          1804:  
        !          1805: int
        !          1806: addbuf(cp) char *cp; {
        !          1807:     int len = 0;
        !          1808:     while ((*cp != NUL) && (bp < cmdbuf+CMDBL)) {
        !          1809:         *bp++ = *cp++;                  /* Copy and */
        !          1810:         len++;                          /* count the characters. */
        !          1811:     }   
        !          1812:     *bp++ = SP;                         /* Put a space at the end */
        !          1813:     *bp = NUL;                          /* Terminate with a null */
        !          1814:     np = bp;                            /* Update the next-field pointer */
        !          1815:     return(len);                        /* Return the length */
        !          1816: }
        !          1817:  
        !          1818: /*  S E T A T M  --  Deposit a token in the atom buffer.  */
        !          1819: /*  Break on space, newline, carriage return, or null. */
        !          1820: /*  Null-terminate the result. */
        !          1821: /*  If the source pointer is the atom buffer itself, do nothing. */
        !          1822: /*  Return length of token, and also set global "cc" to this length. */
        !          1823: 
        !          1824: int
        !          1825: setatm(cp) char *cp; {
        !          1826:     char *ap, *xp;
        !          1827: 
        !          1828:     cc = 0;                            /* Character counter */
        !          1829:     ap = atmbuf;                       /* Address of atom buffer */
        !          1830: 
        !          1831:     if (cp == ap) {                    /* In case source is atom buffer */
        !          1832:        xp = atybuf;                    /* make a copy */
        !          1833:        strcpy(xp,ap);                  /* so we can copy it back, edited. */
        !          1834:        cp = xp;
        !          1835:     }
        !          1836:     *ap = NUL;                         /* Zero the atom buffer */
        !          1837: 
        !          1838:     while (*cp == SP) cp++;            /* Trim leading spaces */
        !          1839:     while ((*cp != SP) && (*cp != NL) && (*cp != NUL) && (*cp != CR)) {
        !          1840:         *ap++ = *cp++;                 /* Copy up to SP, NL, CR, or end */
        !          1841:         cc++;                          /* and count */
        !          1842:     }
        !          1843:     *ap = NUL;                         /* Terminate the string. */
        !          1844:     return(cc);                         /* Return length. */
        !          1845: }
        !          1846:  
        !          1847: /*  R D I G I T S  -- Verify that all the characters in line ARE DIGITS  */
        !          1848:  
        !          1849: int
        !          1850: rdigits(s) char *s; {
        !          1851:     while (*s) {
        !          1852:         if (!isdigit(*s)) return(0);
        !          1853:         s++;
        !          1854:     }
        !          1855:     return(1);
        !          1856: }
        !          1857: 
        !          1858: /* These functions attempt to hide system dependencies from the mainline */
        !          1859: /* code in gtword().  Ultimately they should be moved to ck?tio.c, where */
        !          1860: /* ? = each and every system supported by C-Kermit. */
        !          1861: 
        !          1862: int
        !          1863: cmdgetc() {                            /* Get a character from the tty. */
        !          1864:     int c;
        !          1865: 
        !          1866: #ifdef datageneral
        !          1867:     {
        !          1868:        char ch;
        !          1869:        c = dgncinb(0,&ch,1);           /* -1 is EOF, -2 TO, 
        !          1870:                                          * -c is AOS/VS error */
        !          1871:        if (c == -2) {                  /* timeout was enabled? */
        !          1872:            resto(channel(0));          /* reset timeouts */
        !          1873:            c = dgncinb(0,&ch,1);       /* retry this now! */
        !          1874:        }
        !          1875:        if (c < 0) return(-4);          /* EOF or some error */
        !          1876:        else c = (int) ch & 0177;       /* Get char without parity */
        !          1877: /*     echof = 1; */
        !          1878:     }
        !          1879: #else /* Not datageneral */
        !          1880: #ifdef GEMDOS
        !          1881:     c = isatty(0) ? coninc(0) : getchar();
        !          1882: #else
        !          1883: #ifdef OS2
        !          1884:     c = isatty(0) ? coninc(0) : getchar();
        !          1885:     if (c < 0) return(-4);
        !          1886: #else /* Not OS2 */
        !          1887:     c = getchar();                     /* or from tty. */
        !          1888: #ifdef RTU
        !          1889:     if (rtu_bug) {
        !          1890:        c = getchar();                  /* RTU doesn't discard the ^Z */
        !          1891:        rtu_bug = 0;
        !          1892:     }
        !          1893: #endif /* RTU */
        !          1894: #endif /* OS2 */
        !          1895: #endif /* GEMDOS */
        !          1896: #endif /* datageneral */
        !          1897:     return(c);                         /* Return what we got */
        !          1898: }
        !          1899: 
        !          1900: 
        !          1901: #ifdef COMMENT
        !          1902: /*
        !          1903:   No more screen clearing.  If you wanna clear the screen, define a macro
        !          1904:   to do it, like "define cls write screen \27[;H\27[2J".
        !          1905: */
        !          1906: cmdclrscn() {                          /* Clear the screen */
        !          1907: 
        !          1908: #ifdef aegis
        !          1909:     putchar(FF);
        !          1910: #else
        !          1911: #ifdef AMIGA
        !          1912:     putchar(FF);
        !          1913: #else
        !          1914: #ifdef OSK
        !          1915:     putchar(FF);
        !          1916: #else
        !          1917: #ifdef datageneral
        !          1918:     putchar(FF);
        !          1919: #else
        !          1920: #ifdef OS2
        !          1921:     zsystem("cls");
        !          1922: #else
        !          1923:     zsystem("clear");
        !          1924: #endif /* OS2 */
        !          1925: #endif /* datageneral */
        !          1926: #endif /* OSK */
        !          1927: #endif /* AMIGA */
        !          1928: #endif /* aegis */
        !          1929: }
        !          1930: #endif /* COMMENT */
        !          1931: 
        !          1932: VOID                                   /* What to echo at end of command */
        !          1933: #ifdef CK_ANSIC
        !          1934: cmdnewl(char c)
        !          1935: #else
        !          1936: cmdnewl(c) char c;
        !          1937: #endif /* CK_ANSIC */
        !          1938: /* cmdnewl */ {
        !          1939:     putchar(c);                                /* c is the terminating character */
        !          1940: #ifdef WINTCP
        !          1941:     if (c == CR) putchar(NL);
        !          1942: #endif /* WINTCP */
        !          1943: #ifdef OS2
        !          1944:     if (c == CR) putchar(NL);
        !          1945: #endif /* OS2 */
        !          1946: #ifdef aegis
        !          1947:     if (c == CR) putchar(NL);
        !          1948: #endif /* aegis */
        !          1949: #ifdef AMIGA
        !          1950:     if (c == CR) putchar(NL);
        !          1951: #endif /* AMIGA */
        !          1952: #ifdef datageneral
        !          1953:     if (c == CR) putchar(NL);
        !          1954: #endif /* datageneral */
        !          1955: #ifdef GEMDOS
        !          1956:     if (c == CR) putchar(NL);
        !          1957: #endif /* GEMDOS */
        !          1958: }
        !          1959: 
        !          1960: VOID
        !          1961: cmdchardel() {                         /* Erase a character from the screen */
        !          1962:     if (!dpx) return;
        !          1963: #ifdef datageneral
        !          1964:     /* DG '\b' is EM (^y or \031) */
        !          1965:     if (termtype == 1)
        !          1966:       /* Erase a character from non-DG screen, */
        !          1967:       dgncoub(1,"\010 \010",3);
        !          1968:     else
        !          1969: #endif
        !          1970:       printf("\b \b");
        !          1971: #ifdef GEMDOS
        !          1972:     fflush(stdout);
        !          1973: #endif /* GEMDOS */
        !          1974: }
        !          1975: 
        !          1976: VOID
        !          1977: #ifdef CK_ANSIC
        !          1978: cmdecho(char c, int quote)
        !          1979: #else
        !          1980: cmdecho(c,quote) char c; int quote;
        !          1981: #endif /* CK_ANSIC */
        !          1982: { /* cmdecho */
        !          1983:     if (!dpx) return;
        !          1984:     /* Echo tty input character c */
        !          1985:     if (quote) {
        !          1986:        putchar(BS); putchar(SP); putchar(BS); 
        !          1987: #ifdef isprint
        !          1988:        putchar( isprint(c) ? c : '^' );
        !          1989: #else
        !          1990:        putchar((c >= SP && c < DEL) ? c : '^');
        !          1991: #endif /* isprint */
        !          1992:     } else putchar(c);
        !          1993: #ifdef OS2
        !          1994:     if (quote==1 && c==CR) putchar(NL);
        !          1995: #endif /* OS2 */
        !          1996: }
        !          1997: 
        !          1998: #endif /* NOICP */
        !          1999: 
        !          2000: #ifdef NOICP
        !          2001: #include "ckcdeb.h"
        !          2002: #include "ckucmd.h"
        !          2003: #include "ckcasc.h"
        !          2004: /*** #include <ctype.h> (ckcdeb.h already includes this) ***/
        !          2005: #endif /* NOICP */
        !          2006: 
        !          2007: /*  X X E S C  --  Interprets backslash codes  */
        !          2008: /*  Returns the int value of the backslash code if it is > -1 and < 256 */
        !          2009: /*  and updates the string pointer to first character after backslash code. */
        !          2010: /*  If the argument is invalid, leaves pointer unchanged and returns -1. */
        !          2011: 
        !          2012: int
        !          2013: xxesc(s) char **s; {                   /* Expand backslash escapes */
        !          2014:     int x, y, brace, radix;            /* Returns the int value */
        !          2015:     char hd = '9';                     /* Highest digit in radix */
        !          2016:     char *p;
        !          2017: 
        !          2018:     p = *s;                            /* pointer to beginning */
        !          2019:     if (!p) return(-1);                        /* watch out for null pointer */
        !          2020:     x = *p++;                          /* character at beginning */
        !          2021:     if (x != CMDQ) return(-1);         /* make sure it's a backslash code */
        !          2022: 
        !          2023:     x = *p;                            /* it is, get the next character */
        !          2024:     if (x == '{') {                    /* bracketed quantity? */
        !          2025:        p++;                            /* begin past bracket */
        !          2026:        x = *p;
        !          2027:        brace = 1;
        !          2028:     } else brace = 0;
        !          2029:     switch (x) {                       /* Start interpreting */
        !          2030:       case 'd':                                /* Decimal radix indicator */
        !          2031:       case 'D':
        !          2032:        p++;                            /* Just point past it and fall thru */
        !          2033:       case '0':                                /* Starts with digit */
        !          2034:       case '1':
        !          2035:       case '2':  case '3':  case '4':  case '5':
        !          2036:       case '6':  case '7':  case '8':  case '9':
        !          2037:        radix = 10;                     /* Decimal */
        !          2038:        hd = '9';                       /* highest valid digit */
        !          2039:        break;
        !          2040:       case 'o':                                /* Starts with o or O */
        !          2041:       case 'O':
        !          2042:        radix = 8;                      /* Octal */
        !          2043:        hd = '7';                       /* highest valid digit */
        !          2044:        p++;                            /* point past radix indicator */
        !          2045:        break;
        !          2046:       case 'x':                                /* Starts with x or X */
        !          2047:       case 'X':
        !          2048:        radix = 16;                     /* Hexadecimal */
        !          2049:        p++;                            /* point past radix indicator */
        !          2050:        break;
        !          2051:       default:                         /* All others */
        !          2052: #ifdef COMMENT
        !          2053:        *s = p+1;                       /* Treat as quote of next char */
        !          2054:        return(*p);
        !          2055: #else
        !          2056:        return(-1);
        !          2057: #endif /* COMMENT */
        !          2058:     }
        !          2059:     /* For OS/2, there are "wide" characters required for the keyboard
        !          2060:      * binding, i.e \644 and similar codes larger than 255 (byte).
        !          2061:      * For this purpose, give up checking for < 256. If someone means
        !          2062:      * \266 should result in \26 followed by a "6" character, he should
        !          2063:      * always write \{26}6 anyway.  Now, return only the lower byte of
        !          2064:      * the result, i.e. 10, but eat up the whole \266 sequence and
        !          2065:      * put the wide result 266 into a global variable.  Yes, that's not
        !          2066:      * the most beautiful programming style but requires the least
        !          2067:      * amount of changes to other routines.
        !          2068:      */
        !          2069:     if (radix <= 10) {                 /* Number in radix 8 or 10 */
        !          2070:        for ( x = y = 0;
        !          2071:              (*p) && (*p >= '0') && (*p <= hd)
        !          2072: #ifdef OS2
        !          2073:                    && (y < 4) && (x*radix < 768);
        !          2074:               /* the maximum needed value \767 is still only 3 digits long */
        !          2075:               /* while as octal it requires \1377, i.e. 4 digits */
        !          2076: #else
        !          2077:                    && (y < 3) && (x*radix < 256);
        !          2078: #endif /* OS2 */
        !          2079:              p++,y++) {
        !          2080:            x = x * radix + (int) *p - 48;
        !          2081:        }
        !          2082: #ifdef OS2
        !          2083:         wideresult = x;                        /* Remember wide result */
        !          2084:         x &= 255;
        !          2085: #endif /* OS2 */
        !          2086:        if (y == 0 || x > 255) {        /* No valid digits? */
        !          2087:            *s = p;                     /* point after it */
        !          2088:            return(-1);                 /* return failure. */
        !          2089:        }
        !          2090:     } else if (radix == 16) {          /* Special case for hex */
        !          2091:        if ((x = unhex(*p++)) < 0) { *s = p - 1; return(-1); }
        !          2092:        if ((y = unhex(*p++)) < 0) { *s = p - 2; return(-1); }
        !          2093:        x = ((x << 4) & 0xF0) | (y & 0x0F);
        !          2094: #ifdef OS2
        !          2095:         wideresult = x;
        !          2096:         if ((y = unhex(*p)) >= 0) {
        !          2097:            p++;
        !          2098:           wideresult = ((x << 4) & 0xFF0) | (y & 0x0F);
        !          2099:            x = wideresult & 255;
        !          2100:         }
        !          2101: #endif /* OS2 */
        !          2102:     } else x = -1;
        !          2103:     if (brace && *p == '}' && x > -1)  /* Point past closing brace, if any */
        !          2104:       p++;
        !          2105:     *s = p;                            /* Point to next char after sequence */
        !          2106:     return(x);                         /* Return value of sequence */
        !          2107: }
        !          2108: 
        !          2109: int                                    /* Convert hex string to int */
        !          2110: #ifdef CK_ANSIC
        !          2111: unhex(char x)
        !          2112: #else
        !          2113: unhex(x) char x;
        !          2114: #endif /* CK_ANSIC */
        !          2115: /* unhex */ {
        !          2116: 
        !          2117:     if (x >= '0' && x <= '9')          /* 0-9 is offset by hex 30 */
        !          2118:       return(x - 0x30);
        !          2119:     else if (x >= 'A' && x <= 'F')     /* A-F offset by hex 37 */
        !          2120:       return(x - 0x37);
        !          2121:     else if (x >= 'a' && x <= 'f')     /* a-f offset by hex 57 */
        !          2122:       return(x - 0x57);                        /* (obviously ASCII dependent) */
        !          2123:     else return(-1);
        !          2124: }
        !          2125: 
        !          2126: /* See if argument string is numeric */
        !          2127: /* Returns 1 if OK, zero if not OK */
        !          2128: /* If OK, string should be acceptable to atoi() */
        !          2129: /* Allows leading space, sign */
        !          2130: 
        !          2131: int
        !          2132: chknum(s) char *s; {                   /* Check Numeric String */
        !          2133:     int x = 0;                         /* Flag for past leading space */
        !          2134:     int y = 0;                         /* Flag for digit seen */
        !          2135:     char c;
        !          2136:     debug(F110,"chknum",s,0);
        !          2137:     while (c = *s++) {                 /* For each character in the string */
        !          2138:        switch (c) {
        !          2139:          case SP:                      /* Allow leading spaces */
        !          2140:          case HT:
        !          2141:            if (x == 0) continue;
        !          2142:            else return(0);
        !          2143:          case '+':                     /* Allow leading sign */
        !          2144:          case '-':
        !          2145:            if (x == 0) x = 1;
        !          2146:            else return(0);
        !          2147:            break;
        !          2148:          default:                      /* After that, only decimal digits */
        !          2149:            if (c >= '0' && c <= '9') {
        !          2150:                x = y = 1;
        !          2151:                continue;
        !          2152:            } else return(0);
        !          2153:        }
        !          2154:     }
        !          2155:     return(y);
        !          2156: }
        !          2157: 
        !          2158: /*  L O W E R  --  Lowercase a string  */
        !          2159:  
        !          2160: int
        !          2161: lower(s) char *s; {
        !          2162:     int n = 0;
        !          2163:     while (*s) {
        !          2164:         if (isupper(*s)) *s = tolower(*s);
        !          2165:         s++, n++;
        !          2166:     }
        !          2167:     return(n);
        !          2168: }
        !          2169: 
        !          2170: /*  L O O K U P  --  Lookup the string in the given array of strings  */
        !          2171:  
        !          2172: /*
        !          2173:  Call this way:  v = lookup(table,word,n,&x);
        !          2174:  
        !          2175:    table - a 'struct keytab' table.
        !          2176:    word  - the target string to look up in the table.
        !          2177:    n     - the number of elements in the table.
        !          2178:    x     - address of an integer for returning the table array index.
        !          2179:  
        !          2180:  The keyword table must be arranged in ascending alphabetical order, and
        !          2181:  all letters must be lowercase.
        !          2182:  
        !          2183:  Returns the keyword's associated value ( zero or greater ) if found,
        !          2184:  with the variable x set to the array index, or:
        !          2185:  
        !          2186:   -3 if nothing to look up (target was null),
        !          2187:   -2 if ambiguous,
        !          2188:   -1 if not found.
        !          2189:  
        !          2190:  A match is successful if the target matches a keyword exactly, or if
        !          2191:  the target is a prefix of exactly one keyword.  It is ambiguous if the
        !          2192:  target matches two or more keywords from the table.
        !          2193: */
        !          2194:  
        !          2195: int
        !          2196: lookup(table,cmd,n,x) char *cmd; struct keytab table[]; int n, *x; {
        !          2197:  
        !          2198:     int i, v, cmdlen;
        !          2199:  
        !          2200: /* Lowercase & get length of target, if it's null return code -3. */
        !          2201:  
        !          2202:     if ((((cmdlen = lower(cmd))) == 0) || (n < 1)) return(-3);
        !          2203:  
        !          2204: /* Not null, look it up */
        !          2205:  
        !          2206:     for (i = 0; i < n-1; i++) {
        !          2207:         if (!strcmp(table[i].kwd,cmd) ||
        !          2208:            ((v = !strncmp(table[i].kwd,cmd,cmdlen)) &&
        !          2209:              strncmp(table[i+1].kwd,cmd,cmdlen))) {
        !          2210:                 *x = i;
        !          2211:                 return(table[i].kwval);
        !          2212:              }
        !          2213:         if (v) return(-2);
        !          2214:     }   
        !          2215:  
        !          2216: /* Last (or only) element */
        !          2217:  
        !          2218:     if (!strncmp(table[n-1].kwd,cmd,cmdlen)) {
        !          2219:         *x = n-1;
        !          2220:         return(table[n-1].kwval);
        !          2221:     } else return(-1);
        !          2222: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.