# 2.11BSD#431 - /usr/src/new/kermit5.188/ckucmd.c

##### Functions

    addbuf            X
    addhlp            X
    chknum            X
    chktok            X
    clrhlp            X
    cmcfm             X
    cmdchardel        X
    cmdclrscn         X
    cmdecho           X
    cmdgetc           X
    cmdir             X
    cmdnewl           X
    cmfld             X
    cmifi             X
    cmini             X
    cmkey             X
    cmkey2            X
    cmnum             X
    cmofi             X
    cmpop             X
    cmpush            X
    cmres             X
    cmsavp            X
    cmsetp            X
    cmsetup           X
    cmtxt             X
    dmphlp            X
    gtword            X
    lookup            X
    lower             X
    popcmd            X
    prompt            X
    pushcmd           X
    rdigits           X
    setatm            X
    stripq            X
    ungword           X
    unhex             X
    untab             X
    xxesc             X

##### Variables

    VOID              X
    atmbuf            X
    atxbuf            X
    atxn              X
    atybuf            X
    cmdbuf            X
    cmddep            X
    cmdmsk            X
    cmdv              X
    cmflgs            X
    cmfsav            X
    cmp               X
    cmp_b             X
    cmp_c             X
    cmp_i             X
    cmprom            X
    cmprxx            X
    dfprom            X
    filbuf            X
    hlpbuf            X
    savbuf            X

##### Macros

    PROML             X
    cc                X
    putchar           X

##### struct's

    cmp               X

       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 (fdc@columbia.edu, FDCCU@CUVMA.BITNET),
      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: }

#### Defined functions

addbuf defined in line 1805; used 7 times

- in line 152, 777, 869, 1106, 1202, 1321, 1369

addhlp defined in line 1500; used 3 times

- in line 148, 926, 1404

chknum defined in line 2131; used 13 times

- in line 569, 591
- in /usr/src/new/kermit5.188/ckuus4.c line 1984, 2011, 2058(2), 2123, 2161
- in /usr/src/new/kermit5.188/ckuus5.c line 3325, 3443
- in /usr/src/new/kermit5.188/ckuus6.c line 1678, 1699, 1723

chktok defined in line 1424; used 2 times

- in /usr/src/new/kermit5.188/ckuus5.c line 904
- in /usr/src/new/kermit5.188/ckuusr.c line 1392

clrhlp defined in line 1491; used 4 times

- in line 149, 920, 1399, 1530

cmcfm defined in line 1440; used 142 times

- in /usr/src/new/kermit5.188/ckuus2.c line 848, 1042, 1288, 1300, 1314, 1338, 1637, 1889, 1955
- in /usr/src/new/kermit5.188/ckuus3.c line 550, 648, 666, 694, 709, 738, 753, 776, 791, 825, 848, 858, 907, 921, 956, 971, 990, 1001, 1014, 1085, 1152, 1169, 1201, 1215, 1229, 1238, 1276
- in /usr/src/new/kermit5.188/ckuus4.c line 863
- in /usr/src/new/kermit5.188/ckuus5.c line 2336, 2417, 2452, 3713
- in /usr/src/new/kermit5.188/ckuus6.c line 267, 322, 374, 553, 621, 721, 899, 963, 1055, 1073, 1089, 1114, 1291, 1315
- in /usr/src/new/kermit5.188/ckuus7.c line 467, 496, 514, 628, 677, 695, 704, 713, 742, 750, 765, 781, 797, 828, 845, 904, 929, 959, 965, 971, 977, 993, 1009, 1018, 1024, 1379, 1441, 1507, 1543, 1555, 1563, 1573, 1580, 1595, 1603, 1611, 1620, 1629, 1638, 1646, 1655, 1664, 1673, 1682, 1691, 1701, 1710, 1719, 1728, 1738, 1748, 1758, 1796, 1806, 1882-1887(2), 1961
- in /usr/src/new/kermit5.188/ckuusr.c line 995, 1001, 1016, 1040, 1058, 1083, 1125, 1133, 1139, 1303, 1316, 1335, 1343, 1420, 1438, 1502, 1537, 1581, 1671, 1756, 1765, 1775, 1797, 1822, 1846, 1870-1875(2), 1884, 1948, 1954

cmdchardel defined in line 1960; used 7 times

- in line 156, 839, 860, 1707, 1721, 1738-1742(2)

cmdclrscn defined in line 1906; used 1 times

- in line 1634

cmdecho defined in line 1976; used 4 times

- in line 157, 1774, 1785-1789(2)

cmdgetc defined in line 1862; used 2 times

- in line 154, 1605

cmdir defined in line 961; used 4 times

- in /usr/src/new/kermit5.188/ckuus5.c line 3700-3703(2)
- in /usr/src/new/kermit5.188/ckuus6.c line 618
- in /usr/src/new/kermit5.188/ckuusr.c line 1750

cmdnewl defined in line 1932; used 2 times

- in line 155, 1663

cmfld defined in line 1047; used 23 times

- in line 564, 623
- in /usr/src/new/kermit5.188/ckuus3.c line 898
- in /usr/src/new/kermit5.188/ckuus5.c line 2409
- in /usr/src/new/kermit5.188/ckuus6.c line 255, 359, 395-397(2), 778, 1524, 1596, 1610, 1623, 1661, 1681, 1713
- in /usr/src/new/kermit5.188/ckuus7.c line 1415-1420(2), 1935, 1952
- in /usr/src/new/kermit5.188/ckuusr.c line 1076, 1431, 1496

cmifi defined in line 671; used 12 times

- in /usr/src/new/kermit5.188/ckuus6.c line 707, 944, 1043
- in /usr/src/new/kermit5.188/ckuus7.c line 615, 1453
- in /usr/src/new/kermit5.188/ckuusr.c line 1280, 1565, 1634, 1811, 1835, 1857, 1930

cmini defined in line 273; used 14 times

- in line 407
- in /usr/src/new/kermit5.188/ckuus5.c line 796, 819, 836, 890, 1005, 1511
- in /usr/src/new/kermit5.188/ckuus6.c line 305-307(2), 318, 760, 1250, 1276, 1745

cmkey defined in line 1239; used 88 times

- in /usr/src/new/kermit5.188/ckuus2.c line 1166, 1191
- in /usr/src/new/kermit5.188/ckuus3.c line 549, 647, 664, 692, 708, 752, 771, 784-788(2), 840, 857, 920, 955, 962, 978, 988, 1000, 1013, 1073, 1110, 1121, 1150, 1165, 1197-1200(2), 1213, 1228, 1236
- in /usr/src/new/kermit5.188/ckuus4.c line 860
- in /usr/src/new/kermit5.188/ckuus6.c line 314, 904, 1031, 1502
- in /usr/src/new/kermit5.188/ckuus7.c line 466, 549, 660, 668, 702, 710, 739, 762, 778, 794, 809, 823, 842, 867, 890, 917, 923-926(2), 957, 964, 970, 976, 989, 1006, 1016, 1023, 1042, 1049, 1213, 1288, 1536-1540(2), 1560, 1578, 1588, 1769, 1805, 1875, 1881-1886(2), 2001
- in /usr/src/new/kermit5.188/ckuusr.c line 1009, 1052, 1119, 1163, 1230, 1508, 1550, 1685, 1714, 1942-1944(2), 1979

cmkey2 defined in line 1244; used 3 times

- in line 1242
- in /usr/src/new/kermit5.188/ckuus5.c line 901
- in /usr/src/new/kermit5.188/ckuusr.c line 1389

cmnum defined in line 556; used 60 times

- in /usr/src/new/kermit5.188/ckuus3.c line 566, 722, 730, 773, 823, 841, 881, 930, 964, 1058, 1078, 1244
- in /usr/src/new/kermit5.188/ckuus6.c line 373, 796, 805, 814, 889-893(3)
- in /usr/src/new/kermit5.188/ckuus7.c line 597, 675, 689, 748, 812, 897, 1054, 1061, 1143, 1161, 1168, 1178, 1191, 1227, 1237, 1245, 1567, 1593-1598(2), 1606, 1614, 1623, 1632, 1641, 1650, 1659, 1668, 1677, 1686, 1695, 1705, 1714, 1723, 1732, 1742, 1752, 1878, 1893
- in /usr/src/new/kermit5.188/ckuusr.c line 1311, 1453, 1780

cmofi defined in line 612; used 11 times

- in /usr/src/new/kermit5.188/ckuus4.c line 833-847(4)
- in /usr/src/new/kermit5.188/ckuus6.c line 956, 1099, 1186, 1238, 1280
- in /usr/src/new/kermit5.188/ckuusr.c line 1534, 1946

cmpop defined in line 411; used 3 times

- in /usr/src/new/kermit5.188/ckuus4.c line 1939, 1948
- in /usr/src/new/kermit5.188/ckuus5.c line 1509

cmpush defined in line 301; used 1 times

- in /usr/src/new/kermit5.188/ckuus4.c line 1935

cmres defined in line 258; used 12 times

- in line 241, 252, 278, 1713, 1724, 1732
- in /usr/src/new/kermit5.188/ckuus5.c line 900
- in /usr/src/new/kermit5.188/ckuus6.c line 1160, 1185, 1206, 1236
- in /usr/src/new/kermit5.188/ckuusr.c line 963

cmsavp defined in line 197; used 2 times

- in /usr/src/new/kermit5.188/ckuus6.c line 294, 1248

cmsetp defined in line 189; used 16 times

- in line 214
- in /usr/src/new/kermit5.188/ckuus3.c line 1053
- in /usr/src/new/kermit5.188/ckuus5.c line 395-397(2), 3734
- in /usr/src/new/kermit5.188/ckuus6.c line 302, 324, 338-342(2), 348, 1249, 1258-1263(2), 1275, 1287-1292(2)

cmsetup defined in line 173; used 1 times

- in /usr/src/new/kermit5.188/ckuus5.c line 349

cmtxt defined in line 1140; used 59 times

- in /usr/src/new/kermit5.188/ckuus3.c line 575, 796, 1029-1031(2)
- in /usr/src/new/kermit5.188/ckuus6.c line 289, 331, 412, 423, 429, 566, 599, 611-615(2), 765, 831, 1065, 1081, 1161, 1207, 1254, 1751, 1760, 1807
- in /usr/src/new/kermit5.188/ckuus7.c line 527, 558, 1216, 1300, 1359, 1370, 1386, 1401, 1425, 1463, 1480, 1487, 1500, 1547, 1925, 2012
- in /usr/src/new/kermit5.188/ckuusr.c line 899, 1033, 1137, 1144, 1169, 1176, 1196, 1291, 1355, 1458, 1523, 1577, 1594, 1703, 1724, 1733, 1746, 1782, 1967, 1983

dmphlp defined in line 1526; used 4 times

- in line 150, 929, 1406, 1518

gtword defined in line 1565; used 12 times

- in line 151, 685, 937, 971, 1034, 1055, 1123, 1157, 1219, 1256, 1421, 1452

lookup defined in line 2195; used 7 times

- in line 1284, 1336, 1381
- in /usr/src/new/kermit5.188/ckuus4.c line 1804, 2210
- in /usr/src/new/kermit5.188/ckuus6.c line 540
- in /usr/src/new/kermit5.188/ckuusy.c line 359

lower defined in line 2160; used 6 times

- in line 2202
- in /usr/src/new/kermit5.188/ckuus4.c line 1993-1994(2)
- in /usr/src/new/kermit5.188/ckuus5.c line 1161, 1186, 1315

popcmd defined in line 248; never used
prompt defined in line 210; used 8 times

- in /usr/src/new/kermit5.188/ckuus5.c line 889
- in /usr/src/new/kermit5.188/ckuus6.c line 311, 762, 1252, 1278, 1747
- in /usr/src/new/kermit5.188/ckuusx.c line 623, 651

pushcmd defined in line 238; used 4 times

- in /usr/src/new/kermit5.188/ckuus6.c line 756-758(2), 1740-1743(2)

rdigits defined in line 1849; used 2 times

- in /usr/src/new/kermit5.188/ckuus4.c line 2080-2082(2)

setatm defined in line 1824; used 28 times

- in line 153, 634, 687, 717, 778, 796, 850, 870, 894, 973, 1015, 1057, 1073, 1079-1083(2), 1108, 1255, 1276, 1282, 1322, 1334, 1379, 1449, 1587, 1657, 1684, 1692, 1698

stripq defined in line 519; never used
test defined in line 165; used 5 times

- in line 158, 1355-1359(2), 1394, 1402

ungword defined in line 1555; used 3 times

- in line 1294
- in /usr/src/new/kermit5.188/ckuus5.c line 906
- in /usr/src/new/kermit5.188/ckuusr.c line 1394

unhex defined in line 2109; used 4 times

- in line 4, 2091-2096(3)

untab defined in line 532; used 1 times

- in /usr/src/new/kermit5.188/ckuus5.c line 688

xxesc defined in line 2012; used 4 times

- in line 573
- in /usr/src/new/kermit5.188/ckucon.c line 1300
- in /usr/src/new/kermit5.188/ckuus4.c line 2722
- in /usr/src/new/kermit5.188/ckuusx.c line 349

#### Defined variables

VOID defined in line 1932; never used
atmbuf defined in line 132; used 63 times

- in line 179, 276, 351-352(2), 386-387(2), 455, 491, 567, 584, 635, 690-694(2), 718, 797, 817-820(2), 851-852(2), 872, 895, 913-916(2), 938, 975-978(2), 987, 1016, 1059-1063(2), 1074, 1080, 1155, 1163, 1263, 1280-1287(3), 1293, 1302, 1324, 1333-1337(3), 1343, 1378-1381(2), 1401, 1408, 1428, 1445, 1462, 1475, 1590, 1714, 1725, 1733, 1829
- in /usr/src/new/kermit5.188/ckuus5.c line 963, 975
- in /usr/src/new/kermit5.188/ckuus6.c line 800, 809, 819

atxbuf defined in line 134; used 37 times

- in line 180, 356-357(2), 391-392(2), 460, 496, 585-588(2), 626-629(2), 706-711(3), 785-791(3), 887-890(2), 991-995(3), 1076-1079(2), 1180-1185(3), 1278-1282(3), 1331-1334(2), 1376-1379(2)
- in /usr/src/new/kermit5.188/ckuus7.c line 488, 2005-2010(2)

atxn defined in line 135; used 26 times

- in line 316, 325, 419, 428, 586-587(2), 627-628(2), 707-708(2), 786-787(2), 888-889(2), 992-993(2), 1077-1078(2), 1181-1183(2), 1279-1280(2), 1332-1333(2), 1377-1378(2)

atybuf defined in line 136; used 8 times

- in line 181, 361-362(2), 396-397(2), 465, 501, 1832

bp defined in line 142; used 64 times

- in line 261, 275(4), 319, 328, 422, 431, 840, 847-848(2), 861, 1596-1603(4), 1646-1650(2), 1656, 1664-1683(11), 1691, 1697, 1706-1745(21), 1751-1755(2), 1770, 1782, 1793, 1808-1814(5)

cmdbuf defined in line 130; used 67 times

- in line 175, 250, 261, 275(2), 336-337(2), 371-372(2), 440, 476, 849, 932, 1030, 1119, 1212, 1371, 1413, 1479, 1595-1599(3), 1706, 1720, 1730, 1737-1741(2), 1752-1757(2), 1786, 1808
- in /usr/src/new/kermit5.188/ckuus2.c line 1289, 1869, 1956
- in /usr/src/new/kermit5.188/ckuus3.c line 1277
- in /usr/src/new/kermit5.188/ckuus5.c line 847, 859, 868, 875, 920, 967-978(5), 984, 991-1002(4), 1465
- in /usr/src/new/kermit5.188/ckuus6.c line 1155, 1181-1184(2), 1201, 1231-1237(3), 1795
- in /usr/src/new/kermit5.188/ckuus7.c line 948, 1508
- in /usr/src/new/kermit5.188/ckuusr.c line 959, 1406
- in /usr/src/new/kermit5.188/ckuusx.c line 250-251(2), 625, 653

cmddep defined in line 299; used 106 times

- in line 305-308(3), 314-330(14), 338-403(14), 413-433(16), 439-514(59)

cmdmsk defined in line 1; used 15 times

- in line 1618
- in /usr/src/new/kermit5.188/ckucon.c line 515, 698, 990, 996, 1081, 1250, 1297
- in /usr/src/new/kermit5.188/ckuus3.c line 849-850(2)
- in /usr/src/new/kermit5.188/ckuus4.c line 519, 527, 583
- in /usr/src/new/kermit5.188/ckuus5.c line 2358, 2522

cmdv defined in line 8; used 1 times

- in /usr/src/new/kermit5.188/ckuus5.c line 1596

cmflgs defined in line 117; used 47 times

- in line 262, 314, 323, 417, 426, 684, 776, 871, 970, 1054, 1107, 1147-1149(2), 1156, 1198, 1254-1259(2), 1272, 1288, 1303-1306(4), 1323, 1344, 1370, 1385, 1419, 1444-1447(2), 1558-1561(3), 1589-1591(3), 1658, 1686, 1693, 1699, 1717, 1727, 1734, 1747, 1797
- in /usr/src/new/kermit5.188/ckuus5.c line 987, 3330

cmfsav defined in line 118; used 6 times

- in line 315, 324, 418, 427, 1558, 1589

cmp defined in line 292; used 51 times

- in line 312-321(9), 338-368(7), 417-424(7), 439-472(28)

cmp_b defined in line 296; used 35 times

- in line 373-403(7), 475-508(28)

cmp_c defined in line 295; used 6 times

- in line 328-330(3), 431-433(3)

cmp_i defined in line 294; used 8 times

- in line 323-326(4), 426-429(4)

cmprom defined in line 113; used 10 times

- in line 218-223(2), 932, 1030, 1119, 1212, 1413, 1479, 1752-1756(2)

cmprxx defined in line 114; used 5 times

- in line 191-192(2), 204, 216-221(2)

dfprom defined in line 115; used 1 times

- in line 214

filbuf defined in line 133; used 23 times

- in line 182, 366-367(2), 401-402(2), 470, 506, 812-813(2), 827-836(6), 842, 850, 857, 863, 870, 922-926(3)

hlpbuf defined in line 131; used 14 times

- in line 178, 346-347(2), 381-382(2), 450, 486, 1493, 1507-1517(4), 1528-1529(2)

hw defined in line 106; used 1 times

- in line 1512

np defined in line 144; used 10 times

- in line 240, 261, 321, 330, 424, 433, 1593, 1656, 1683, 1814

pp defined in line 143; used 20 times

- in line 261, 320, 329, 423, 432, 1158, 1585-1587(3), 1593-1597(3), 1653-1657(2), 1664, 1670, 1684, 1692, 1698, 1716

psetf defined in line 100; used 2 times

- in line 193, 214

savbuf defined in line 137; used 18 times

- in line 176-177(2), 240-242(2), 250-251(2), 341-342(2), 376-377(2), 445, 481
- in /usr/src/new/kermit5.188/ckuus5.c line 849-851(3), 867-869(3)

ungw defined in line 146; used 9 times

- in line 263, 317, 326, 420, 429, 1557-1560(2), 1584-1588(2)

#### Defined struct's

cmp defined in line 287; used 6 times

- in line 292(2), 312(4)

#### Defined macros

PROML defined in line 111; used 5 times

- in line 113-114(2), 191-192(2), 219

cc defined in line 87; used 39 times

- in line 101, 260, 682, 693, 790, 800, 827-828(2), 836-838(2), 845, 851, 857-859(2), 897-898(2), 968, 977, 995, 1052, 1062, 1148, 1162, 1184-1186(2), 1202, 1252, 1262, 1276, 1315, 1324, 1364, 1395, 1401, 1446, 1453, 1828, 1841-1844(2)

putchar defined in line 94; used 37 times

- in line 91-92(2), 780, 855, 1022, 1111, 1204, 1326, 1339, 1467, 1651, 1690, 1701, 1712, 1731, 1760-1762(2), 1771, 1795, 1909-1918(4), 1939-1956(7), 1986-1994(7)

Last modified: 1992-11-24 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 5922 |