![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckuus5.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / e / bin / cku179|
Return to ckuus5.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / cku179 |
1.1 root 1: #ifndef NOICP
2:
3: /* C K U U S 5 -- "User Interface" for Unix Kermit, part 5 */
4:
5: /*
6: Author: Frank da Cruz ([email protected], [email protected]),
7: Columbia University Center for Computing Activities.
8: First released January 1985.
9: Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
10: York. Permission is granted to any individual or institution to use, copy, or
11: redistribute this software so long as it is not sold for profit, provided this
12: copyright notice is retained.
13: */
14:
15: /* Includes */
16:
17: #include "ckcdeb.h"
18: #include "ckcasc.h"
19: #include "ckcker.h"
20: #include "ckuusr.h"
21: #include "ckcnet.h"
22: #ifndef NOCSETS
23: #include "ckcxla.h"
24: #endif /* NOCSETS */
25: #ifdef MAC
26: #include "ckmasm.h"
27: #endif /* MAC */
28:
29: #ifdef FT18
30: #define isxdigit(c) isdigit(c)
31: #endif /* FT18 */
32:
33: #ifdef MAC /* Internal MAC file routines */
34: #define feof mac_feof
35: #define rewind mac_rewind
36: #define fgets mac_fgets
37: #define fopen mac_fopen
38: #define fclose mac_fclose
39:
40: int mac_feof();
41: void mac_rewind();
42: char *mac_fgets();
43: FILE *mac_fopen();
44: int mac_fclose();
45: #endif /* MAC */
46:
47: /* External variables */
48:
49: extern int local, backgrd, bgset, sosi, suspend,
50: displa, binary, deblog, escape, xargs, flow, cmdmsk,
51: duplex, ckxech, pktlog, seslog, tralog, what,
52: keep, warn, quiet, tlevel, cwdf, nfuncs,
53: mdmtyp, zincnt, cmask, rcflag, success, xitsta, pflag, lf_opts, tnlm;
54:
55: #ifndef NOFRILLS
56: extern int en_cwd, en_del, en_dir, en_fin, en_bye,
57: en_get, en_hos, en_sen, en_set, en_spa, en_typ, en_who;
58: #endif /* NOFRILLS */
59: extern long vernum;
60: extern int srvtim, srvdis, incase, inecho, intime, nvars, verwho;
61: extern char *protv, *fnsv, *cmdv, *userv, *ckxv, *ckzv, *ckzsys, *xlav,
62: *cknetv, *clcmds;
63: extern char *connv, *dialv, *loginv, *nvlook();
64:
65: #ifndef NOSCRIPT
66: extern int secho;
67: #endif /* NOSCRIPT */
68:
69: #ifndef NODIAL
70: extern int nmdm;
71: extern struct keytab mdmtab[];
72: #endif /* NODIAL */
73:
74: #ifdef NETCONN
75: extern int tn_init, network, ttnproto;
76: #endif /* NETCONN */
77:
78: #ifdef OS2PM
79: extern int Term_mode;
80: #endif /* OS2 */
81:
82: #ifndef NOCSETS
83: extern int language, nfilc, tcsr, tcsl;
84: extern struct keytab fcstab[];
85: #endif /* NOCSETS */
86:
87: extern int atcapr,
88: atenci, atenco, atdati, atdato, atleni, atleno, atblki, atblko,
89: attypi, attypo, atsidi, atsido, atsysi, atsyso, atdisi, atdiso;
90:
91: extern long speed;
92:
93: extern char *DIRCMD, *PWDCMD, *DELCMD;
94: #ifndef NOXMIT
95: extern int xmitf, xmitl, xmitp, xmitx, xmits, xmitw;
96: extern char xmitbuf[];
97: #endif /* NOXMIT */
98:
99: extern char **xargv, *versio, *ckxsys, *dftty, *cmarg, *homdir, *lp;
100:
101: #ifdef DCMDBUF
102: extern char *cmdbuf, *atmbuf; /* Command buffers */
103: #ifndef NOSPL
104: extern char *savbuf; /* Command buffers */
105: #endif /* NOSPL */
106: #else
107: extern char cmdbuf[], atmbuf[]; /* Command buffers */
108: #ifndef NOSPL
109: extern char savbuf[]; /* Command buffers */
110: #endif /* NOSPL */
111: #endif /* DCMDBUF */
112:
113: extern char toktab[], ttname[], psave[];
114: extern CHAR sstate;
115: extern int cmflgs, techo, terror, repars, ncmd;
116: extern struct keytab cmdtab[];
117:
118: #ifndef MAC
119: #ifndef NOSETKEY
120: KEY *keymap;
121: MACRO *macrotab;
122: #endif /* NOSETKEY */
123: #endif /* MAC */
124:
125: #ifndef NOSPL
126: extern struct mtab *mactab;
127: extern struct keytab vartab[], fnctab[];
128: extern int cmdlvl, maclvl, nmac, mecho, merror;
129: #endif /* NOSPL */
130:
131: FILE *tfile[MAXTAKE]; /* TAKE file stack */
132:
133: #ifndef NOSPL
134: /* Local declarations */
135:
136: int nulcmd = 0; /* Flag for next cmd to be ignored */
137:
138: /* Definitions for built-in macros */
139:
140: /* First, the single line macros, installed with addmac()... */
141:
142: /* IBM-LINEMODE macro */
143: char *m_ibm = "set parity mark, set dupl half, set handsh xon, set flow none";
144:
145: /* FATAL macro */
146: char *m_fat = "if def \\%1 echo \\%1, stop";
147:
148: #ifdef COMMENT
149: /*
150: Long macro definitions were formerly done like this. But some compilers
151: cannot handle continued string constants, others cannot handle string
152: constants that are this long. So these definitions have been broken up
153: into pieces and put into arrays, see below.
154: */
155: char *m_forx = "if def _floop ass \\%9 \\fdef(_floop),else def \\%9,\
156: ass _floop { _getargs,\
157: define \\\\\\%1 \\%2,:top,if \\%5 \\\\\\%1 \\%3 goto bot,\
158: \\%6,:inc, incr \\\\\\%1 \\%4,goto top,:bot,_putargs,return},\
159: def break goto bot, def continue goto inc,\
160: do _floop \\%1 \\%2 \\%3 \\%4 { \\%5 },assign _floop \\fcont(\\%9)";
161:
162: char *m_while = "if def _wloop ass \\%9 \\fdef(_wloop),\
163: ass _wloop {_getargs,:wtest,\\%1,\\%2,goto wtest,:wbot,_putargs,return},\
164: def break goto wbot, def continue goto wtest,\
165: do _wloop,assign _wloop \\fcont(\\%9)";
166:
167: char *m_xif = "ass \\%9 \\fdef(_ify),ass _ify {_getargs, \\%1, _putargs},\
168: do _ify,ass _ify \\fcont(\\%9)";
169: #endif /* COMMENT */
170:
171: /* Now the multiline macros, defined with addmmac()... */
172:
173: /* FOR macro */
174: char *for_def[] = { "if def _floop ass \\%9 \\fdef(_floop),else def \\%9,",
175: "ass _floop { _getargs,",
176: "define \\\\\\%1 \\%2,:top,if \\%5 \\\\\\%1 \\%3 goto bot,",
177: "\\%6,:inc, incr \\\\\\%1 \\%4,goto top,:bot,_putargs,return},",
178: "def break goto bot, def continue goto inc,",
179: "do _floop \\%1 \\%2 \\%3 \\%4 { \\%5 },assign _floop \\fcont(\\%9)",
180: ""};
181:
182: /* WHILE macro */
183: char *whil_def[] = { "if def _wloop ass \\%9 \\fdef(_wloop),",
184: "ass _wloop {_getargs,:wtest,\\%1,\\%2,goto wtest,:wbot,_putargs,return},",
185: "def break goto wbot, def continue goto wtest,",
186: "do _wloop,assign _wloop \\fcont(\\%9)",
187: ""};
188:
189: /* XIF macro */
190: char *xif_def[] = {
191: "ass \\%9 \\fdef(_ify),ass _ify {_getargs, \\%1, _putargs},",
192: "do _ify,ass _ify \\fcont(\\%9)",
193: ""};
194:
195: /* Variables declared here for use by other ckuus*.c modules */
196: /* Space is allocated here to save room in ckuusr.c */
197:
198: #ifdef DCMDBUF
199: struct cmdptr *cmdstk;
200: int *ifcmd, *count, *iftest;
201: #else
202: struct cmdptr cmdstk[CMDSTKL];
203: int ifcmd[CMDSTKL], count[CMDSTKL], iftest[CMDSTKL];
204: #endif /* DCMDBUF */
205:
206: char *m_arg[MACLEVEL][NARGS];
207: char *g_var[GVARS], *macp[MACLEVEL], *mrval[MACLEVEL];
208: int macargc[MACLEVEL];
209: char *macx[MACLEVEL];
210: extern char varnam[];
211:
212: char **a_ptr[27]; /* Array pointers, for arrays a-z */
213: int a_dim[27]; /* Dimensions for each array */
214:
215: char inpbuf[INPBUFSIZ]; /* Buffer for INPUT and REINPUT */
216: char vnambuf[VNAML]; /* Buffer for variable names */
217: char *vnp; /* Pointer to same */
218: char lblbuf[50]; /* Buffer for labels */
219: #endif /* NOSPL */
220:
221: #ifdef DCMDBUF
222: char *line; /* Character buffer for anything */
223: #else
224: char line[LINBUFSIZ];
225: #endif /* DCMDBUF */
226:
227: extern char pktfil[],
228: #ifdef DEBUG
229: debfil[],
230: #endif /* DEBUG */
231: #ifdef TLOG
232: trafil[],
233: #endif /* TLOG */
234: sesfil[],
235: cmdstr[];
236: #ifndef NOFRILLS
237: extern int rmailf, rprintf; /* REMOTE MAIL & PRINT items */
238: extern char optbuf[];
239: #endif /* NOFRILLS */
240:
241: char *homdir; /* Pointer to home directory string */
242:
243: char tmpbuf[50], *tp; /* Temporary buffer */
244: char numbuf[20]; /* Buffer for numeric strings. */
245: char kermrc[100]; /* Name of initialization file */
246: int noinit = 0; /* Flag for skipping init file */
247:
248: #ifndef NOSPL
249: _PROTOTYP( static long expon, (long, long) );
250: _PROTOTYP( static long gcd, (long, long) );
251: _PROTOTYP( static long fact, (long) );
252: int /* Initialize macro data structures. */
253: macini() { /* Allocate mactab and preset the first element. */
254: if (!(mactab = (struct mtab *) malloc(sizeof(struct mtab) * MAC_MAX)))
255: return(-1);
256: mactab[0].kwd = NULL;
257: mactab[0].mval = NULL;
258: mactab[0].flgs = 0;
259: return(0);
260: }
261: #endif /* NOSPL */
262:
263: /* C M D I N I -- Initialize the interactive command parser */
264:
265: VOID
266: cmdini() {
267: int i, x, y, z;
268:
269: #ifndef MAC
270: #ifndef NOSETKEY /* Allocate & initialize the keymap */
271: if (!(keymap = (KEY *) malloc(sizeof(KEY)*KMSIZE)))
272: fatal("cmdini: no memory for keymap");
273: if (!(macrotab = (MACRO *) malloc(sizeof(MACRO)*KMSIZE)))
274: fatal("cmdini: no memory for macrotab");
275: for ( i = 0; i < KMSIZE; i++ ) {
276: keymap[i] = i;
277: macrotab[i] = NULL;
278: }
279: #endif /* NOSETKEY */
280: #endif /* MAC */
281:
282: #ifdef DCMDBUF
283: if (cmsetup() < 0) fatal("Can't allocate command buffers!");
284: #ifndef NOSPL
285: if (!(cmdstk = (struct cmdptr *) malloc(sizeof(struct cmdptr)*CMDSTKL)))
286: fatal("cmdini: no memory for cmdstk");
287: if (!(ifcmd = (int *) malloc(sizeof(int)*CMDSTKL)))
288: fatal("cmdini: no memory for ifcmd");
289: if (!(count = (int *) malloc(sizeof(int)*CMDSTKL)))
290: fatal("cmdini: no memory for count");
291: if (!(iftest = (int *) malloc(sizeof(int)*CMDSTKL)))
292: fatal("cmdini: no memory for iftest");
293: #endif /* NOSPL */
294: if (!(line = malloc(LINBUFSIZ)))
295: fatal("cmdini: no memory for line");
296: #ifdef COMMENT
297: if (!(m_arg = (struct m_arg *) malloc(sizeof(struct m_arg)*MACLEVEL)))
298: fatal("cmdini: no memory for m_arg");
299: #endif /* COMMENT */
300: #endif /* DCMDBUF */
301:
302: #ifndef NOSPL
303: if (macini() < 0) fatal("Can't allocate macro buffers!");
304: #endif /* NOSPL */
305:
306: #ifdef AMIGA
307: if (tlevel < 0)
308: concb(escape);
309: #endif /* AMIGA */
310:
311: #ifndef NOSPL
312: cmdlvl = 0; /* Start at command level 0 */
313: cmdstk[cmdlvl].src = CMD_KB;
314: cmdstk[cmdlvl].lvl = 0;
315: #endif /* NOSPL */
316:
317: tlevel = -1; /* Take file level = keyboard */
318: #ifdef MAC
319: cmsetp("Mac-Kermit>"); /* Set default prompt */
320: #else
321: cmsetp("C-Kermit>"); /* Set default prompt */
322: #endif /* MAC */
323:
324: #ifndef NOSPL
325: initmac(); /* Initialize macro table */
326: /* Add one-line macros */
327: addmac("ibm-linemode",m_ibm); /* Add built-in macros. */
328: addmac("fatal",m_fat); /* FATAL macro. */
329: /* Add multiline macros */
330: addmmac("_forx",for_def); /* FOR macro. */
331: addmmac("_xif",xif_def); /* XIF macro. */
332: addmmac("_while",whil_def); /* WHILE macro. */
333: /* Fill in command line argument vector */
334: sprintf(vnambuf,"\\&@[%d]",xargs); /* Command line argument vector */
335: y = arraynam(vnambuf,&x,&z); /* goes in array \&@[] */
336: if (y > -1) {
337: dclarray((char)x,z); /* Declare the array */
338: for (i = 0; i < xargs; i++) { /* Fill it */
339: sprintf(vnambuf,"\\&@[%d]",i);
340: addmac(vnambuf,xargv[i]);
341: }
342: }
343: *vnambuf = NUL;
344: #endif /* NOSPL */
345:
346: /* If skipping init file ('-Y' on Kermit command line), return now. */
347:
348: if (noinit) return;
349:
350: /* Look for init file in home or current directory. */
351: /* (NOTE - should really use zkermini for this!) */
352: homdir = zhome(); /* (===OS2 change===) */
353: #ifdef OS2
354: /*
355: The -y init file must be fully specified or in the current directory.
356: KERMRC is looked for via INIT, PATH and DPATH in that order. Finally, our
357: own executable file path is taken and the .EXE suffix is replaced by .INI
358: and this is tried as initialization file.
359: */
360: if (rcflag) {
361: strcpy(line, kermrc);
362: } else {
363: _searchenv(kermrc,"INIT",line);
364: if (line[0] == 0)
365: _searchenv(kermrc,"PATH",line);
366: if (line[0] == 0)
367: _searchenv(kermrc,"DPATH",line);
368: if (line[0] == 0) {
369: extern char *_pgmptr;
370: lp = strrchr(_pgmptr, '.');
371: strncpy(line, _pgmptr, lp - _pgmptr);
372: strcpy(line + (lp - _pgmptr), ".ini");
373: }
374: }
375: if ((tfile[0] = fopen(line,"r")) != NULL) {
376: tlevel = 0;
377: #ifndef NOSPL
378: cmdlvl++;
379: cmdstk[cmdlvl].src = CMD_TF;
380: cmdstk[cmdlvl].lvl = tlevel;
381: ifcmd[cmdlvl] = 0;
382: iftest[cmdlvl] = 0;
383: count[cmdlvl] = 0;
384: #endif /* NOSPL */
385: debug(F110,"init file",line,0);
386: } else {
387: debug(F100,"no init file","",0);
388: }
389: #else /* not OS2 */
390: lp = line;
391: lp[0] = '\0';
392: #ifdef VMS
393: zkermini(line,LINBUFSIZ,kermrc);
394: #else /* not VMS */
395: if (rcflag) { /* If init file name from cmd line */
396: strcpy(lp,kermrc); /* use it */
397: } else { /* otherwise */
398: if (homdir) { /* look in home directory for it */
399: strcpy(lp,homdir);
400: if (lp[0] == '/') strcat(lp,"/");
401: }
402: strcat(lp,kermrc); /* and use the default name */
403: }
404: #endif /* VMS */
405:
406: #ifdef AMIGA
407: reqoff(); /* disable requestors */
408: #endif /* AMIGA */
409:
410: debug(F110,"ini file is",line,0);
411: if ((tfile[0] = fopen(line,"r")) != NULL) {
412: tlevel = 0;
413: #ifndef NOSPL
414: cmdlvl++;
415: ifcmd[cmdlvl] = 0;
416: iftest[cmdlvl] = 0;
417: count[cmdlvl] = 0;
418: debug(F101,"open ok","",cmdlvl);
419: cmdstk[cmdlvl].src = CMD_TF;
420: cmdstk[cmdlvl].lvl = tlevel;
421: #endif /* NOSPL */
422: debug(F110,"init file",line,0);
423: }
424: if (homdir && (tlevel < 0)) {
425: strcpy(lp,kermrc);
426: if ((tfile[0] = fopen(line,"r")) != NULL) {
427: tlevel = 0;
428: #ifndef NOSPL
429: cmdlvl++;
430: cmdstk[cmdlvl].src = CMD_TF;
431: cmdstk[cmdlvl].lvl = tlevel;
432: ifcmd[cmdlvl] = 0;
433: iftest[cmdlvl] = 0;
434: count[cmdlvl] = 0;
435: #endif /* NOSPL */
436: }
437: }
438: #endif /* OS2 */
439: #ifdef AMIGA
440: reqpop(); /* Restore requestors */
441: #endif /* AMIGA */
442: }
443:
444: /* P A R S E R -- Top-level interactive command parser. */
445:
446: /*
447: Call with:
448: m = 0 for normal behavior: keep parsing and executing commands
449: until an action command is parsed, then return with a
450: Kermit start-state as the value of this function.
451: m = 1 to parse only one command, can also be used to call parser()
452: recursively.
453: m = 2 to read but do not execute one command.
454: In all cases, parser() returns:
455: 0 if no Kermit protocol action required
456: > 0 with a Kermit protocol start-state.
457: < 0 upon error.
458: */
459: int
460: parser(m) int m; {
461: int y, xx, yy, zz; /* Workers */
462: char ic; /* Interruption character */
463: int icn; /* Interruption character counter */
464: #ifndef NOSPL
465: int inlevel; /* Level we were called at */
466: int pp; /* Paren nesting level */
467: int kp; /* Bracket nesting level */
468: #endif /* NOSPL */
469: char *cbp; /* Command buffer pointer */
470: int cbn; /* Command buffer length */
471: #ifdef MAC
472: extern char *lfiles; /* fake extern cast */
473: #endif /* MAC */
474:
475: #ifdef AMIGA
476: reqres(); /* restore AmigaDOS requestors */
477: #endif /* AMIGA */
478:
479: what = W_COMMAND; /* Now we're parsing commands. */
480: #ifndef NOSPL
481: if (cmdlvl == 0) /* If at top (interactive) level, */
482: #else
483: if (tlevel < 0)
484: #endif /* NOSPL */
485: concb((char)escape); /* put console in cbreak mode. */
486:
487: #ifndef NOSPL
488: ifcmd[0] = 0; /* Command-level related variables */
489: iftest[0] = 0; /* initialize variables at top level */
490: count[0] = 0; /* of stack... */
491: inlevel = maclvl; /* Current macro level */
492: debug(F101,"&parser entry maclvl","",maclvl);
493: debug(F101,"&parser entry inlevel","",inlevel);
494: #endif /* NOSPL */
495:
496: /*
497: sstate becomes nonzero when a command has been parsed that requires some
498: action from the protocol module. Any non-protocol actions, such as local
499: directory listing or terminal emulation, are invoked directly from below.
500: */
501: if (local && pflag) /* Just returned from connect? */
502: printf("\n");
503: sstate = 0; /* Start with no start state. */
504: #ifndef NOFRILLS
505: rmailf = rprintf = 0; /* MAIL and PRINT modifiers for SEND */
506: *optbuf = NUL; /* MAIL and PRINT options */
507: #endif /* NOFRILLS */
508: while (sstate == 0) { /* Parse cmds until action requested */
509: debug(F100,"top of parse loop","",0);
510:
511: /* Take requested action if there was an error in the previous command */
512:
513: #ifndef MAC
514: conint(trap,stptrap); /* In case we were just fg'd */
515: bgchk(); /* Check background status */
516: #endif /* MAC */
517:
518: #ifndef NOSPL /* In case we just reached top level */
519: if (cmdlvl == 0) concb((char)escape);
520: #else
521: if (tlevel < 0) concb((char)escape);
522: #endif /* NOSPL */
523:
524: #ifndef NOSPL
525: if (success == 0) {
526: if (cmdstk[cmdlvl].src == CMD_TF && terror) {
527: printf("Command error: take file terminated.");
528: popclvl();
529: if (cmdlvl == 0) return(0);
530: }
531: if (cmdstk[cmdlvl].src == CMD_MD && merror) {
532: printf("Command error: macro terminated.");
533: popclvl();
534: if (m && (maclvl < inlevel))
535: return((int) sstate);
536: }
537: }
538:
539: nulcmd = (m == 2);
540: #endif /* NOSPL */
541:
542: #ifdef MAC
543: if ((tlevel == -1) && lfiles) /* Check for take initiated by menu. */
544: startlfile();
545: #endif /* MAC */
546:
547: /* If in TAKE file, check for EOF */
548:
549: #ifndef NOSPL
550: #ifdef MAC
551: if
552: #else
553: while
554: #endif /* MAC */
555: ((cmdstk[cmdlvl].src == CMD_TF) /* If end of take file */
556: && (tlevel > -1)
557: && feof(tfile[tlevel])) {
558: popclvl(); /* pop command level */
559: cmini(ckxech); /* and clear the cmd buffer. */
560: if (cmdlvl == 0) /* Just popped out of all cmd files? */
561: return(0); /* End of init file or whatever. */
562: }
563: #ifdef MAC
564: miniparser(1);
565: if (sstate == 'a') { /* if cmd-. cancel */
566: debug(F100, "parser: cancel take due to sstate", "", sstate);
567: sstate = '\0';
568: dostop();
569: return(0); /* End of init file or whatever. */
570: }
571: #endif /* MAC */
572:
573: #else /* NOSPL */
574: if ((tlevel > -1) && feof(tfile[tlevel])) { /* If end of take */
575: popclvl(); /* Pop up one level. */
576: cmini(ckxech); /* and clear the cmd buffer. */
577: if (tlevel < 0) /* Just popped out of cmd files? */
578: return(0); /* End of init file or whatever. */
579: }
580: #endif /* NOSPL */
581:
582: #ifndef NOSPL
583: /* If macro, check for interruption and then get next command */
584:
585: if (cmdstk[cmdlvl].src == CMD_MD) { /* Executing a macro? */
586: debug(F100,"parser macro","",0);
587: if (icn = conchk()) { /* Yes */
588: while (icn--) { /* User typed something */
589: ic = coninc(0);
590: if (ic == CR) { /* Carriage return? */
591: printf(" Interrupted...\n");
592: dostop();
593: } else {
594: putchar(BEL);
595: }
596: }
597: }
598: debug(F101,"parser maclvl","",maclvl);
599: maclvl = cmdstk[cmdlvl].lvl; /* No interrupt, get current level */
600: cbp = cmdbuf; /* Copy next cmd to command buffer. */
601: *cbp = NUL;
602: if (*savbuf) { /* In case then-part of 'if' command */
603: strcpy(cbp,savbuf); /* was saved, restore it. */
604: *savbuf = '\0';
605: } else { /* Else get next cmd from macro def */
606: debug(F111,"macro maclvl", macp[maclvl], maclvl);
607: kp = pp = 0;
608:
609: for (y = 0; /* copy next macro part */
610: *macp[maclvl] && y < CMDBL;
611: y++, cbp++, macp[maclvl]++) {
612:
613: /* Allow braces around macro def to prevent */
614: /* commas from being turned to end-of-lines */
615: /* and also treat any commas within parens */
616: /* as text so that multiple-argument functions */
617: /* won't cause the command to break prematurely. */
618:
619: *cbp = *macp[maclvl]; /* Get next character */
620:
621: if (*cbp == '{') kp++; /* Count braces */
622: if (*cbp == '}') kp--;
623: if (*cbp == '(') pp++; /* Count parentheses. */
624: if (*cbp == ')') pp--;
625: if (*cbp == ',' && pp <= 0 && kp <= 0) {
626: macp[maclvl]++;
627: kp = pp = 0;
628: break;
629: }
630: } /* Reached end. */
631: if (*cmdbuf == NUL) { /* If nothing was copied, */
632: popclvl(); /* pop command level. */
633: debug(F101,"macro level popped","",maclvl);
634: if (m && (maclvl < inlevel))
635: return((int) sstate);
636: else if (!m) continue;
637: } else { /* otherwise, tack CR onto end */
638: *cbp++ = CR; /* NOTE: NOT '\r' !!! */
639: *cbp = '\0';
640: if (mecho && pflag)
641: printf("%s\n",cmdbuf);
642: debug(F110,"cmdbuf",cmdbuf,0);
643: }
644: }
645:
646: /* If TAKE file, get next line */
647:
648: } else if (cmdstk[cmdlvl].src == CMD_TF)
649: #else
650: if (tlevel > -1)
651: #endif /* NOSPL */
652: {
653: debug(F101,"tlevel","",tlevel);
654: cbp = cmdbuf; /* Get the next line. */
655: cbn = CMDBL;
656:
657: /* Loop to get next command line and all continuation lines from take file. */
658:
659: again:
660: #ifndef NOSPL
661: if (*savbuf) { /* In case then-part of 'if' command */
662: strcpy(line,savbuf); /* was saved, restore it. */
663: *savbuf = '\0';
664: } else
665: #endif /* NOSPL */
666: if (fgets(line,cbn,tfile[tlevel]) == NULL) continue;
667: if (icn = conchk()) {
668: while (icn--) { /* User typed something... */
669: ic = coninc(0); /* Look for carriage return */
670: if (ic == CR) {
671: printf(" Interrupted...\n");
672: dostop();
673: } else putchar(BEL); /* Ignore anything else */
674: }
675: }
676: lp = line; /* Got a line, copy it. */
677: debug(F110,"from TAKE file",line,0);
678: { /* Trim trailing whitespace */
679: char c; int i, j;
680: j = (int)strlen(line) - 1; /* Position of line terminator */
681: c = line[j]; /* Value of line terminator */
682: for (i = j - 1; i > -1; i--)
683: if (line[i] != SP && line[i] != HT) break;
684: line[i+1] = c; /* Move after last nonblank char */
685: line[i+2] = NUL; /* Terminate */
686: }
687: while (*cbp++ = *lp++) {
688: if (--cbn < 2) {
689: printf("?Command too long, maximum length: %d.\n",CMDBL);
690: return(dostop());
691: }
692: }
693: if (*(cbp - 3) == CMDQ || *(cbp - 3) == '-') { /* Continued? */
694: cbp -= 3; /* If so, back up pointer, */
695: goto again; /* go back, get next line. */
696: }
697: untab(cmdbuf); /* Convert tabs to spaces */
698: if (techo && pflag) /* "take echo on" */
699: printf("%s",cmdbuf);
700:
701: /* If interactive, get next command from user. */
702:
703: } else { /* User types it in. */
704: if (pflag) prompt(xxstring);
705: cmini(ckxech);
706: }
707:
708: /* Now know where next command is coming from. Parse and execute it. */
709:
710: repars = 1; /* 1 = command needs parsing */
711: displa = 0; /* Assume no file transfer display */
712:
713: while (repars) { /* Parse this cmd until entered. */
714: debug(F101,"parser top of while loop","",0);
715: cmres(); /* Reset buffer pointers. */
716: xx = cmkey2(cmdtab,ncmd,"Command","",toktab,xxstring);
717: debug(F101,"top-level cmkey2","",xx);
718: if (xx == -5) {
719: yy = chktok(toktab);
720: debug(F101,"top-level cmkey token","",yy);
721: ungword();
722: switch (yy) {
723: case '!': xx = XXSHE; break;
724: case '#': xx = XXCOM; break;
725: case ';': xx = XXCOM; break;
726: #ifndef NOSPL
727: case ':': xx = XXLBL; break;
728: #endif /* NOSPL */
729: case '@': xx = XXSHE; break;
730: default:
731: printf("\n?Invalid - %s\n",cmdbuf);
732: xx = -2;
733: }
734: }
735:
736: #ifndef NOSPL
737: /* Special handling for IF..ELSE */
738:
739: if (ifcmd[cmdlvl]) /* Count stmts after IF */
740: ifcmd[cmdlvl]++;
741: if (ifcmd[cmdlvl] > 2 && xx != XXELS && xx != XXCOM)
742: ifcmd[cmdlvl] = 0;
743:
744: /* Execute the command and take action based on return code. */
745:
746: if (nulcmd) { /* Ignoring this command? */
747: xx = XXCOM; /* Make this command a comment. */
748: }
749: #endif /* NOSPL */
750:
751: zz = docmd(xx); /* Parse rest of command & execute. */
752: debug(F101,"docmd returns","",zz);
753: #ifdef MAC
754: if (tlevel > -1) {
755: if (sstate == 'a') { /* if cmd-. cancel */
756: debug(F110, "parser: cancel take, sstate:", "a", 0);
757: sstate = '\0';
758: dostop();
759: return(0); /* End of init file or whatever. */
760: }
761: }
762: #endif /* MAC */
763: switch (zz) {
764: case -4: /* EOF (e.g. on redirected stdin) */
765: doexit(GOOD_EXIT,xitsta); /* ...exit successfully */
766: case -1: /* Reparse needed */
767: repars = 1; /* Just set reparse flag and */
768: continue;
769: case -6: /* Invalid command given w/no args */
770: case -2: /* Invalid command given w/args */
771: #ifndef NOSPL
772: /* This is going to be really ugly... */
773: yy = mlook(mactab,atmbuf,nmac); /* Look in macro table */
774: if (yy > -1) { /* If it's there */
775: if (zz == -2) { /* insert "do" */
776: char *mp;
777: mp = malloc((int)strlen(cmdbuf) + 5);
778: if (!mp) {
779: printf("?malloc error 1\n");
780: return(-2);
781: }
782: sprintf(mp,"do %s ",cmdbuf);
783: strcpy(cmdbuf,mp);
784: free(mp);
785: } else sprintf(cmdbuf,"do %s %c",atmbuf, CR);
786: if (ifcmd[cmdlvl] == 2) /* This one doesn't count! */
787: ifcmd[cmdlvl]--;
788: debug(F111,"stuff cmdbuf",cmdbuf,zz);
789: repars = 1; /* go for reparse */
790: continue;
791: } else {
792: char *p;
793: int n;
794: p = cmdbuf;
795: lp = line;
796: n = LINBUFSIZ;
797: if (cmflgs == 0) printf("\n");
798: if (xxstring(p,&lp,&n) > -1)
799: printf("?Invalid: %s\n",line);
800: else
801: printf("?Invalid: %s\n",cmdbuf);
802: } /* (fall thru...) */
803: #else
804: printf("?Invalid: %s\n",cmdbuf);
805: #endif /* NOSPL */
806:
807: case -9: /* Bad, error message already done */
808: success = 0;
809: debug(F110,"top-level cmkey failed",cmdbuf,0);
810: if (pflag == 0) /* if background, terminate */
811: fatal("Kermit command error in background execution");
812: cmini(ckxech); /* (fall thru) */
813:
814: case -3: /* Empty command OK at top level */
815: repars = 0; /* Don't need to reparse. */
816: continue; /* Go back and get another command. */
817:
818: default: /* Command was successful. */
819: #ifndef NOSPL
820: debug(F101,"parser preparing to continue","",maclvl);
821: #endif /* NOSPL */
822: repars = 0; /* Don't need to reparse. */
823: continue; /* Go back and get another command. */
824: }
825: }
826: #ifndef NOSPL
827: debug(F101,"parser breaks out of while loop","",maclvl);
828: if (m && (maclvl < inlevel)) return((int) sstate);
829: #endif /* NOSPL */
830: }
831:
832: /* Got an action command, return start state. */
833:
834: #ifdef COMMENT
835: /* This is done in ckcpro.w instead, no need to do it twice. */
836: /* Interrupts off only if remote */
837: if (!local) connoi();
838: #endif /* COMMENT */
839: return((int) sstate);
840: }
841:
842: #ifndef NOSPL
843: /* OUTPUT command */
844:
845: int
846: #ifdef CK_ANSIC
847: xxout(char c)
848: #else
849: xxout(c) char c;
850: #endif /* CK_ANSIC */
851: /* xxout */ { /* Function to output a character. */
852: debug(F101,"xxout","",c);
853: if (local) /* If in local mode */
854: return(ttoc(c)); /* then to the external line */
855: else return(conoc(c)); /* otherwise to the console. */
856: }
857:
858: /* Returns 0 on failure, 1 on success */
859:
860: int
861: dooutput(s) char *s; {
862: int x, y, quote;
863:
864: if (local) { /* Condition external line */
865: y = ttvt(speed,flow);
866: if (y < 0) return(0);
867: }
868: quote = 0; /* Initialize backslash (\) quote */
869:
870: #ifdef COMMENT
871: /* This is done automatically in ttopen() now... */
872: #ifdef NETCONN
873: if (network && ttnproto == NP_TELNET) /* If telnet connection, */
874: if (!tn_init++) tn_ini(); /* initialize it if necessary */
875: #endif /* NETCONN */
876: #endif /* COMMENT */
877: while (x = *s++) { /* Loop through the string */
878: y = 0; /* Error code, 0 = no error. */
879: if (x == CMDQ) { /* Look for \b or \B in string */
880: quote = 1; /* Got \ */
881: continue; /* Get next character */
882: } else if (quote) { /* This character is quoted */
883: quote = 0; /* Turn off quote flag */
884: if (x == 'b' || x == 'B') { /* If \b or \B */
885: debug(F100,"OUTPUT BREAK","",0);
886: ttsndb(); /* send BREAK signal */
887: continue; /* and not the b or B */
888: #ifdef UNIX
889: } else if (x == 'l' || x == 'L') { /* If \l or \L */
890: debug(F100,"OUTPUT Long BREAK","",0);
891: ttsndlb(); /* send Long BREAK signal */
892: continue; /* and not the l or L */
893: #endif /* UNIX */
894: } else { /* if \ not followed by b or B */
895: y = xxout(dopar(CMDQ)); /* output the backslash. */
896: }
897: }
898: y = xxout(dopar((char)x)); /* Output this character */
899: if (y < 0) {
900: printf("output error.\n");
901: return(0);
902: }
903: if (seslog && duplex)
904: if (zchout(ZSFILE,(char)x) < 0) seslog = 0;
905: }
906: return(1);
907: }
908: #endif /* NOSPL */
909:
910:
911: /* Display version herald and initial prompt */
912:
913: VOID
914: herald() {
915: int x = 0;
916: if (bgset > 0 || (bgset != 0 && backgrd != 0)) x = 1;
917: debug(F101,"herald","",backgrd);
918: if (x == 0)
919: printf("%s,%s\nType ? or HELP for help\n",versio,ckxsys);
920: }
921: #ifndef NOSPL
922: /* M L O O K -- Lookup the macro name in the macro table */
923:
924: /*
925: Call this way: v = mlook(table,word,n);
926:
927: table - a 'struct mtab' table.
928: word - the target string to look up in the table.
929: n - the number of elements in the table.
930:
931: The keyword table must be arranged in ascending alphabetical order, and
932: all letters must be lowercase.
933:
934: Returns the table index, 0 or greater, if the name was found, or:
935:
936: -3 if nothing to look up (target was null),
937: -2 if ambiguous,
938: -1 if not found.
939:
940: A match is successful if the target matches a keyword exactly, or if
941: the target is a prefix of exactly one keyword. It is ambiguous if the
942: target matches two or more keywords from the table.
943: */
944: int
945: mlook(table,cmd,n) struct mtab table[]; char *cmd; int n; {
946:
947: int i, v, cmdlen;
948:
949: /* Lowercase & get length of target, if it's null return code -3. */
950:
951: if ((((cmdlen = lower(cmd))) == 0) || (n < 1)) return(-3);
952:
953: /* Not null, look it up */
954:
955: for (i = 0; i < n-1; i++) {
956: if (!strcmp(table[i].kwd,cmd) ||
957: ((v = !strncmp(table[i].kwd,cmd,cmdlen)) &&
958: strncmp(table[i+1].kwd,cmd,cmdlen))) {
959: return(i);
960: }
961: if (v) return(-2);
962: }
963:
964: /* Last (or only) element */
965:
966: if (!strncmp(table[n-1].kwd,cmd,cmdlen)) {
967: return(n-1);
968: } else return(-1);
969: }
970:
971: /* mxlook is like mlook, but an exact full-length match is required */
972:
973: int
974: mxlook(table,cmd,n) char *cmd; struct mtab table[]; int n; {
975: int i, cmdlen;
976: if ((((cmdlen = lower(cmd))) == 0) || (n < 1)) return(-3);
977: for (i = 0; i < n; i++)
978: if (((int)strlen(table[i].kwd) == cmdlen) &&
979: (!strncmp(table[i].kwd,cmd,cmdlen))) return(i);
980: return(-1);
981: }
982:
983: /*
984: This routine is for the benefit of those compilers that can't handle
985: long string constants or continued lines within them. Long predefined
986: macros like FOR, WHILE, and XIF have their contents broken up into
987: arrays of string pointers. This routine concatenates them back into a
988: single string again, and then calls the real addmac() routine to enter
989: the definition into the macro table.
990: */
991: int
992: addmmac(nam,s) char *nam, *s[]; { /* Add a multiline macro definition */
993: int i, x, y; char *p;
994: x = 0; /* Length counter */
995: for (i = 0; (y = (int)strlen(s[i])) > 0; i++) { /* Add up total length */
996: debug(F111,"addmmac line",s[i],y);
997: x += y;
998: }
999: debug(F101,"addmmac lines","",i);
1000: debug(F101,"addmmac loop exit","",y);
1001: debug(F111,"addmmac length",nam,x);
1002: if (x < 0) return(-1);
1003:
1004: p = malloc(x+1); /* Allocate space for all of it. */
1005: if (!p) {
1006: printf("?addmmac malloc error: %s\n",nam);
1007: debug(F110,"addmmac malloc error",nam,0);
1008: return(-1);
1009: }
1010: *p = '\0'; /* Start off with null string. */
1011: for (i = 0; *s[i]; i++) /* Concatenate them all together. */
1012: strcat(p,s[i]);
1013: y = (int)strlen(p); /* Final precaution. */
1014: debug(F111,"addmmac constructed string",p,y);
1015: if (y == x) {
1016: y = addmac(nam,p); /* Add result to the macro table. */
1017: } else {
1018: debug(F100,"addmmac length mismatch","",0);
1019: printf("\n!addmmac internal error!\n");
1020: y = -1;
1021: }
1022: free(p); /* Free the temporary copy. */
1023: return(y);
1024: }
1025:
1026: /* Here is the real addmac routine. */
1027:
1028: int
1029: addmac(nam,def) char *nam, *def; { /* Add a macro to the macro table */
1030: int i, x, y, z, namlen, deflen;
1031: char *p, c;
1032:
1033: if (!nam) return(-1);
1034: namlen = (int)strlen(nam); /* Get argument lengths */
1035: debug(F111,"addmac nam",nam,namlen);
1036: if (!def) { /* Watch out for null pointer */
1037: deflen = 0;
1038: debug(F111,"addmac def","(null pointer)",deflen);
1039: } else {
1040: deflen = (int)strlen(def);
1041: debug(F111,"addmac def",def,deflen);
1042: }
1043: if (deflen < 0) return(-1); /* strlen() failure, fail. */
1044: if (namlen < 1) return(-1); /* No name given, fail. */
1045:
1046: if (*nam == CMDQ) nam++; /* Backslash quote? */
1047: if (*nam == '%') { /* Yes, if it's a variable name, */
1048: delmac(nam); /* Delete any old value. */
1049: if (!(c = *(nam + 1))) return(-1); /* Variable name letter or digit */
1050: if (deflen < 1) { /* Null definition */
1051: p = NULL; /* Better not malloc or strcpy! */
1052: } else { /* A substantial definition */
1053: p = malloc(deflen + 1); /* Allocate space for it */
1054: if (!p) {
1055: printf("?addmac malloc error 2\n");
1056: return(-1);
1057: } else strcpy(p,def); /* Copy definition into new space */
1058: }
1059:
1060: /* Now p points to the definition, or is a null pointer */
1061:
1062: if (p)
1063: debug(F110,"addmac p",p,0);
1064: else
1065: debug(F110,"addmac p","(null pointer)",0);
1066:
1067: if (c >= '0' && c <= '9') { /* Digit variable */
1068: if (maclvl < 0) { /* Are we calling or in a macro? */
1069: g_var[c] = p; /* No, it's a global "top level" one */
1070: debug(F101,"addmac numeric global maclvl","",maclvl);
1071: } else { /* Yes, it's a macro argument */
1072: m_arg[maclvl][c - '0'] = p;
1073: debug(F101,"addmac macro arg maclvl","",maclvl);
1074: }
1075: } else { /* It's a global variable */
1076: if (c < 33 || c > GVARS) return(-1);
1077: if (isupper(c)) c = tolower(c);
1078: g_var[c] = p; /* Put pointer in global-var table */
1079: debug(F100,"addmac global","",0);
1080: }
1081: return(0);
1082: } else if (*nam == '&') { /* An array reference? */
1083: char **q;
1084: if ((y = arraynam(nam,&x,&z)) < 0) /* If syntax is bad */
1085: return(-1); /* return -1. */
1086: if (chkarray(x,z) < 0) /* If array not declared or */
1087: return(-2); /* subscript out of range, ret -2 */
1088: delmac(nam); /* Delete any current definition. */
1089: x -= 96; /* Convert name letter to index. */
1090: if ((q = a_ptr[x]) == NULL) /* If array not declared, */
1091: return(-3); /* return -3. */
1092: if (deflen > 0) {
1093: if ((p = malloc(deflen+1)) == NULL) { /* Allocate space */
1094: printf("addmac macro error 7: %s\n",nam);
1095: return(-4); /* for new def, return -4 on fail. */
1096: }
1097: strcpy(p,def); /* Copy definition into new space. */
1098: } else p = NULL;
1099: q[z] = p; /* Store pointer to it. */
1100: return(0); /* Done. */
1101: } else debug(F110,"addmac macro def",nam,0);
1102:
1103: /* Not a macro argument or a variable, so it's a macro definition */
1104:
1105: lower(nam); /* Lowercase the name */
1106: delmac(nam); /* if it's already there, delete it. */
1107: debug(F111,"addmac table size",nam,nmac);
1108: for (y = 0; /* Find the alphabetical slot */
1109: y < MAC_MAX && mactab[y].kwd != NULL && strcmp(nam,mactab[y].kwd) > 0;
1110: y++) ;
1111: if (y == MAC_MAX) { /* No more room. */
1112: debug(F101,"addmac table overflow","",y);
1113: return(-1);
1114: } else debug(F111,"addmac position",nam,y);
1115: if (mactab[y].kwd != NULL) { /* Must insert */
1116: for (i = nmac; i > y; i--) { /* Move the rest down one slot */
1117: mactab[i].kwd = mactab[i-1].kwd;
1118: mactab[i].mval = mactab[i-1].mval;
1119: mactab[i].flgs = mactab[i-1].flgs;
1120: }
1121: }
1122: p = malloc(namlen + 1); /* Allocate space for name */
1123: if (!p) {
1124: printf("?addmac malloc error 3: %s\n",nam);
1125: return(-1);
1126: }
1127: strcpy(p,nam); /* Copy name into new space */
1128: mactab[y].kwd = p; /* Add pointer to table */
1129:
1130: if (deflen > 0) { /* Same deal for definition */
1131: p = malloc(deflen + 1); /* but watch out for null pointer */
1132: if (p == NULL) {
1133: printf("?addmac malloc error 5: %s\n", nam);
1134: free(mactab[y].kwd);
1135: mactab[y].kwd = NULL;
1136: return(-1);
1137: } else strcpy(p,def); /* Copy the definition */
1138: } else p = NULL;
1139: mactab[y].mval = p;
1140: mactab[y].flgs = 0;
1141: nmac++; /* Count this macro */
1142: return(y);
1143: }
1144:
1145: int
1146: delmac(nam) char *nam; { /* Delete the named macro */
1147: int i, x, z;
1148: char *p, c;
1149:
1150: if (!nam) return(0); /* Watch out for null pointer */
1151: debug(F110,"delmac nam",nam,0);
1152: if (*nam == CMDQ) nam++;
1153: if (*nam == '%') { /* If it's a variable name */
1154: if (!(c = *(nam+1))) return(0); /* Get variable name letter or digit */
1155: p = (char *)0; /* Initialize value pointer */
1156: if (maclvl > -1 && c >= '0' && c <= '9') { /* Digit? */
1157: p = m_arg[maclvl][c - '0']; /* Get pointer from macro-arg table */
1158: m_arg[maclvl][c - '0'] = NULL; /* Zero the table pointer */
1159: } else { /* It's a global variable */
1160: if (c < 33 || c > GVARS) return(0);
1161: p = g_var[c]; /* Get pointer from global-var table */
1162: g_var[c] = NULL; /* Zero the table entry */
1163: }
1164: if (p) {
1165: debug(F110,"delmac def",p,0);
1166: free(p); /* Free the storage */
1167: } else debug(F110,"delmac def","(null pointer)",0);
1168: return(0);
1169: }
1170:
1171: if (*nam == '&') { /* An array reference? */
1172: char **q;
1173: if (arraynam(nam,&x,&z) < 0) /* If syntax is bad */
1174: return(-1); /* return -1. */
1175: x -= 96; /* Convert name to number. */
1176: if ((q = a_ptr[x]) == NULL) /* If array not declared, */
1177: return(-2); /* return -2. */
1178: if (z > a_dim[x]) /* If subscript out of range, */
1179: return(-3); /* return -3. */
1180: if (q[z]) { /* If there is an old value, */
1181: debug(F110,"delman def",q[z],0);
1182: free(q[z]); /* delete it. */
1183: q[z] = NULL;
1184: } else debug(F110,"delmac def","(null pointer)",0);
1185: }
1186:
1187: /* Not a variable or an array, so it must be a macro. */
1188:
1189: if ((x = mlook(mactab,nam,nmac)) < 0) return(x); /* Look it up */
1190:
1191: if (mactab[x].kwd) /* Free the storage for the name */
1192: free(mactab[x].kwd);
1193: if (mactab[x].mval) /* and for the definition */
1194: free(mactab[x].mval);
1195:
1196: for (i = x; i < nmac; i++) { /* Now move up the others. */
1197: mactab[i].kwd = mactab[i+1].kwd;
1198: mactab[i].mval = mactab[i+1].mval;
1199: mactab[i].flgs = mactab[i+1].flgs;
1200: }
1201: nmac--; /* One less macro */
1202: mactab[nmac].kwd = NULL; /* Delete last item from table */
1203: mactab[nmac].mval = NULL;
1204: mactab[nmac].flgs = 0;
1205: return(0);
1206: }
1207:
1208: VOID
1209: initmac() { /* Init macro & variable tables */
1210: int i, j;
1211:
1212: nmac = 0; /* No macros */
1213: for (i = 0; i < MAC_MAX; i++) { /* Initialize the macro table */
1214: mactab[i].kwd = NULL;
1215: mactab[i].mval = NULL;
1216: mactab[i].flgs = 0;
1217: }
1218: for (i = 0; i < MACLEVEL; i++) { /* Init the macro argument tables */
1219: mrval[i] = NULL;
1220: for (j = 0; j < 10; j++) {
1221: m_arg[i][j] = NULL;
1222: }
1223: }
1224: for (i = 0; i < GVARS; i++) { /* And the global variables table */
1225: g_var[i] = NULL;
1226: }
1227: for (i = 0; i < 26; i++) { /* And the table of arrays */
1228: a_ptr[i] = (char **) NULL; /* Null pointer for each */
1229: a_dim[i] = 0; /* and a dimension of zero */
1230: }
1231: }
1232:
1233: int
1234: popclvl() { /* Pop command level, return cmdlvl */
1235: if (cmdlvl < 1) { /* If we're already at top level */
1236: cmdlvl = 0; /* just make sure all the */
1237: tlevel = -1; /* stack pointers are set right */
1238: maclvl = -1; /* and return */
1239: } else if (cmdstk[cmdlvl].src == CMD_TF) { /* Reading from TAKE file? */
1240: if (tlevel > -1) { /* Yes, */
1241: fclose(tfile[tlevel--]); /* close it and pop take level */
1242: cmdlvl--; /* pop command level */
1243: } else tlevel = -1;
1244: } else if (cmdstk[cmdlvl].src == CMD_MD) { /* In a macro? */
1245: if (maclvl > -1) { /* Yes, */
1246: macp[maclvl] = ""; /* set macro pointer to null string */
1247: *cmdbuf = '\0'; /* clear the command buffer */
1248: if (mrval[maclvl+1]) { /* Free any deeper return values. */
1249: free(mrval[maclvl+1]);
1250: mrval[maclvl+1] = NULL;
1251: }
1252: maclvl--; /* pop macro level */
1253: cmdlvl--; /* and command level */
1254: } else maclvl = -1;
1255: }
1256: if (cmdlvl < 1) { /* If back at top level */
1257: #ifndef MAC
1258: conint(trap,stptrap); /* Fix interrupts */
1259: bgchk(); /* Check background status */
1260: concb((char)escape); /* Go into cbreak mode */
1261: #endif /* MAC */
1262: }
1263: return(cmdlvl < 1 ? 0 : cmdlvl); /* Return command level */
1264: }
1265: #else /* No script programming language */
1266: int popclvl() { /* Just close current take file. */
1267: if (tlevel > -1) /* if any... */
1268: fclose(tfile[tlevel--]);
1269: if (tlevel == -1) { /* And if back at top level */
1270: conint(trap,stptrap); /* check and set interrupts */
1271: bgchk(); /* and background status */
1272: concb((char)escape); /* and go back into cbreak mode. */
1273: }
1274: return(tlevel + 1);
1275: }
1276: #endif /* NOSPL */
1277:
1278: /* STOP - get back to C-Kermit prompt, no matter where from. */
1279:
1280: int
1281: dostop() {
1282: while ( popclvl() ) ; /* Pop all macros & take files */
1283: #ifndef NOSPL
1284: while (cmpop() > -1) ; /* And all recursive cmd pkg invocations */
1285: #endif /* NOSPL */
1286: cmini(ckxech); /* Clear the command buffer. */
1287: return(0);
1288: }
1289:
1290:
1291: /* Close the given log */
1292:
1293: int
1294: doclslog(x) int x; {
1295: int y;
1296: switch (x) {
1297: #ifdef DEBUG
1298: case LOGD:
1299: if (deblog == 0) {
1300: printf("?Debugging log wasn't open\n");
1301: return(0);
1302: }
1303: *debfil = '\0';
1304: deblog = 0;
1305: return(zclose(ZDFILE));
1306: #endif /* DEBUG */
1307:
1308: case LOGP:
1309: if (pktlog == 0) {
1310: printf("?Packet log wasn't open\n");
1311: return(0);
1312: }
1313: *pktfil = '\0';
1314: pktlog = 0;
1315: return(zclose(ZPFILE));
1316:
1317: case LOGS:
1318: if (seslog == 0) {
1319: printf("?Session log wasn't open\n");
1320: return(0);
1321: }
1322: *sesfil = '\0';
1323: seslog = 0;
1324: return(zclose(ZSFILE));
1325:
1326: #ifdef TLOG
1327: case LOGT:
1328: if (tralog == 0) {
1329: printf("?Transaction log wasn't open\n");
1330: return(0);
1331: }
1332: *trafil = '\0';
1333: tralog = 0;
1334: return(zclose(ZTFILE));
1335: #endif /* TLOG */
1336:
1337: #ifndef NOSPL
1338: case LOGW:
1339: case LOGR:
1340: y = (x == LOGR) ? ZRFILE : ZWFILE;
1341: if (chkfn(y) < 1) {
1342: if (x == LOGW)
1343: printf("?No file to close\n");
1344: return(0);
1345: }
1346: y = zclose(y);
1347: return((x == LOGR) ? 1 : y);
1348: #endif /* NOSPL */
1349:
1350: default:
1351: printf("\n?Unexpected log designator - %ld\n", x);
1352: return(0);
1353: }
1354: }
1355:
1356: #ifndef NOSERVER
1357: #ifndef NOFRILLS
1358: static char *nm[] = { "disabled", "enabled" };
1359: #endif /* NOFRILLS */
1360: #endif /* NOSERVER */
1361:
1362: static int slc = 0; /* Screen line count */
1363:
1364: #ifndef NOFRILLS
1365: #define xxdiff(v,sys) strncmp(v,sys,strlen(sys))
1366: VOID
1367: shover() {
1368: printf("\nVersions:\n %s\n Numeric: %ld",versio,vernum);
1369: if (verwho) printf("-%d",verwho);
1370: printf(xxdiff(ckxv,ckxsys) ? "\n %s for%s\n" : "\n %s\n",ckxv,ckxsys);
1371: printf(xxdiff(ckzv,ckzsys) ? " %s for%s\n" : " %s\n",ckzv,ckzsys);
1372: printf(" %s\n",protv);
1373: printf(" %s\n",fnsv);
1374: printf(" %s\n %s\n",cmdv,userv);
1375: #ifndef NOCSETS
1376: printf(" %s\n",xlav);
1377: #endif /* NOCSETS */
1378: #ifndef MAC
1379: printf(" %s\n",connv);
1380: #endif /* MAC */
1381: #ifndef NODIAL
1382: printf(" %s\n",dialv);
1383: #endif /* NODIAL */
1384: #ifndef NOSCRIPT
1385: printf(" %s\n",loginv);
1386: #endif /* NOSCRIPT */
1387: #ifdef NETCONN
1388: printf(" %s\n",cknetv);
1389: #endif /* NETCONN */
1390:
1391: printf("\nSpecial features:\n");
1392: #ifdef NETCONN
1393: printf(" Network support (type SHOW NET for further info)\n");
1394: #endif /* NETCONN */
1395:
1396: #ifdef KANJI
1397: printf(" Kanji character-set translation\n");
1398: #endif /* KANJI */
1399:
1400: printf("\nFeatures not included:\n");
1401: #ifdef NOSERVER
1402: printf(" No server mode\n");
1403: #endif /* NOSERVER */
1404: #ifdef NODEBUG
1405: printf(" No debugging\n");
1406: #endif /* NODEBUG */
1407: #ifdef NOTLOG
1408: printf(" No transaction log\n");
1409: #endif /* NOTLOG */
1410: #ifdef NOHELP
1411: printf(" No built-in help\n");
1412: #endif /* NOHELP */
1413: #ifndef NETCONN
1414: printf(" No network support\n");
1415: #endif /* NETCONN */
1416: #ifdef NOMSEND
1417: printf(" No MSEND command\n");
1418: #endif /* NOMSEND */
1419: #ifdef NODIAL
1420: printf(" No DIAL command\n");
1421: #endif /* NODIAL */
1422: #ifdef NOXMIT
1423: printf(" No TRANSMIT command\n");
1424: #endif /* NOXMIT */
1425: #ifdef NOSCRIPT
1426: printf(" No SCRIPT command\n");
1427: #endif /* NOSCRIPT */
1428: #ifdef NOSPL
1429: printf(" No script programming features\n");
1430: #endif /* NOSPL */
1431: #ifdef NOCSETS
1432: printf(" No character-set translation\n");
1433: #else
1434: #ifdef NOCYRIL
1435: printf(" No Cyrillic character-set translation\n");
1436: #endif /* NOCYRIL */
1437: #ifndef KANJI
1438: printf(" No Kanji character-set translation\n");
1439: #endif /* KANJI */
1440: #endif /* NOCSETS */
1441: #ifdef NOCMDL
1442: printf(" No command-line arguments\n");
1443: #endif /* NOCMDL */
1444: #ifdef NOFRILLS
1445: printf(" No frills\n");
1446: #endif /* NOFRILLS */
1447: #ifdef NOPUSH
1448: printf(" No escape to system\n");
1449: #endif /* NOPUSH */
1450: #ifdef NOJC
1451: printf(" No UNIX job control\n");
1452: #endif /* NOJC */
1453: #ifdef NOSETKEY
1454: printf(" No SET KEY command\n");
1455: #endif /* NOSETKEY */
1456: #ifdef NOESCSEQ
1457: printf(" No ANSI escape sequence recognition\n");
1458: #endif /* NOESCSEQ */
1459: #ifndef PARSENSE
1460: printf(" No automatic parity detection\n");
1461: #endif /* PARSENSE */
1462: /*
1463: Print all of Kermit's compile-time options, as well as C preprocessor
1464: predefined symbols that might affect us...
1465: */
1466: printf("\nCompiler options:\n");
1467: #ifdef DEBUG
1468: #ifdef IFDEBUG
1469: prtopt(" IFDEBUG");
1470: #else
1471: prtopt(" DEBUG");
1472: #endif /* IFDEBUG */
1473: #endif /* DEBUG */
1474: #ifdef TLOG
1475: prtopt(" TLOG");
1476: #endif /* TLOG */
1477: #ifdef DYNAMIC
1478: prtopt(" DYNAMIC");
1479: #endif /* IFDEBUG */
1480: #ifdef UNIX
1481: prtopt(" UNIX");
1482: #endif /* UNIX */
1483: #ifdef VMS
1484: prtopt(" VMS");
1485: #endif /* VMS */
1486: #ifdef vms
1487: prtopt(" vms");
1488: #endif /* vms */
1489: #ifdef VMSSHARE
1490: prtopt(" VMSSHARE");
1491: #endif /* VMSSHARE */
1492: #ifdef datageneral
1493: prtopt(" datageneral");
1494: #endif /* datageneral */
1495: #ifdef apollo
1496: prtopt(" apollo");
1497: #endif /* apollo */
1498: #ifdef aegis
1499: prtopt(" aegis");
1500: #endif /* aegis */
1501: #ifdef A986
1502: prtopt(" A986");
1503: #endif /* A986 */
1504: #ifdef AMIGA
1505: prtopt(" AMIGA");
1506: #endif /* AMIGA */
1507: #ifdef MAC
1508: prtopt(" MAC");
1509: #endif /* MAC */
1510: #ifdef AUX
1511: prtopt(" AUX");
1512: #endif /* AUX */
1513: #ifdef OS2
1514: prtopt(" OS2");
1515: #endif /* OS2 */
1516: #ifdef OS9
1517: prtopt(" OS9");
1518: #endif /* OS9 */
1519: #ifdef MSDOS
1520: prtopt(" MSDOS");
1521: #endif /* MSDOS */
1522: #ifdef DIRENT
1523: prtopt(" DIRENT");
1524: #endif /* DIRENT */
1525: #ifdef SDIRENT
1526: prtopt(" SDIRENT");
1527: #endif /* SDIRENT */
1528: #ifdef NDIR
1529: prtopt(" NDIR");
1530: #endif /* NDIR */
1531: #ifdef XNDIR
1532: prtopt(" XNDIR");
1533: #endif /* XNDIR */
1534: #ifdef MATCHDOT
1535: prtopt(" MATCHDOT");
1536: #endif /* MATCHDOT */
1537: #ifdef SAVEDUID
1538: prtopt(" SAVEDUID");
1539: #endif /* SAVEDUID */
1540: #ifdef NOCCTRAP
1541: prtopt(" NOCCTRAP");
1542: #endif /* NOCCTRAP */
1543: #ifdef SUNX25
1544: prtopt(" SUNX25");
1545: #endif /* SUNX25 */
1546: #ifdef ATT7300
1547: prtopt(" ATT7300");
1548: #endif /* ATT7300 */
1549: #ifdef ATT6300
1550: prtopt(" ATT6300");
1551: #endif /* ATT6300 */
1552: #ifdef HDBUUCP
1553: prtopt(" HDBUUCP");
1554: #endif /* HDBUUCP */
1555: #ifdef NOUUCP
1556: prtopt(" NOUUCP");
1557: #endif /* NOUUCP */
1558: #ifdef LONGFN
1559: prtopt(" LONGFN");
1560: #endif /* LONGFN */
1561: #ifdef RDCHK
1562: prtopt(" RDCHK");
1563: #endif /* RDCHK */
1564: #ifdef NAP
1565: prtopt(" NAP");
1566: #endif /* NAP */
1567: #ifdef EXCELAN
1568: prtopt(" EXCELAN");
1569: #endif /* EXCELAN */
1570: #ifdef PARAMH
1571: prtopt(" PARAMH");
1572: #endif /* PARAMH */
1573: #ifdef INTERLAN
1574: prtopt(" INTERLAN");
1575: #endif /* INTERLAN */
1576: #ifdef NOFILEH
1577: prtopt(" NOFILEH");
1578: #endif /* NOFILEH */
1579: #ifdef NOSYSIOCTLH
1580: prtopt(" NOSYSIOCTLH");
1581: #endif /* NOSYSIOCTLH */
1582: #ifdef DCLPOPEN
1583: prtopt(" DCLPOPEN");
1584: #endif /* DCLPOPEN */
1585: #ifdef NOPOPEN
1586: prtopt(" NOPOPEN");
1587: #endif /* NOPOPEN */
1588: #ifdef NOPARTIAL
1589: prtopt(" NOPARTIAL");
1590: #endif /* NOPARTIAL */
1591: #ifdef NOSETREU
1592: prtopt(" NOSETREU");
1593: #endif /* NOSETREU */
1594: #ifdef _POSIX_SOURCE
1595: prtopt(" _POSIX_SOURCE");
1596: #endif /* _POSIX_SOURCE */
1597: #ifdef LCKDIR
1598: prtopt(" LCKDIR");
1599: #endif /* LCKDIR */
1600: #ifdef ACUCNTRL
1601: prtopt(" ACUCNTRL");
1602: #endif /* ACUCNTRL */
1603: #ifdef BSD4
1604: prtopt(" BSD4");
1605: #endif /* BSD4 */
1606: #ifdef BSD41
1607: prtopt(" BSD41");
1608: #endif /* BSD41 */
1609: #ifdef BSD43
1610: prtopt(" BSD43");
1611: #endif /* BSD43 */
1612: #ifdef BSD29
1613: prtopt(" BSD29");
1614: #endif /* BSD29 */
1615: #ifdef V7
1616: prtopt(" V7");
1617: #endif /* V7 */
1618: #ifdef AIX370
1619: prtopt(" AIX370");
1620: #endif /* AIX370 */
1621: #ifdef RTAIX
1622: prtopt(" RTAIX");
1623: #endif /* RTAIX */
1624: #ifdef HPUX
1625: prtopt(" HPUX");
1626: #endif /* HPUX */
1627: #ifdef HPUXPRE65
1628: prtopt(" HPUXPRE65");
1629: #endif /* HPUXPRE65 */
1630: #ifdef DGUX
1631: prtopt(" DGUX");
1632: #endif /* DGUX */
1633: #ifdef DGUX540
1634: prtopt(" DGUX540");
1635: #endif /* DGUX540 */
1636: #ifdef sony_news
1637: prtopt(" sony_news");
1638: #endif /* sony_news */
1639: #ifdef CIE
1640: prtopt(" CIE");
1641: #endif /* CIE */
1642: #ifdef XENIX
1643: prtopt(" XENIX");
1644: #endif /* XENIX */
1645: #ifdef SCO_XENIX
1646: prtopt(" SCO_XENIX");
1647: #endif /* SCO_XENIX */
1648: #ifdef ISIII
1649: prtopt(" ISIII");
1650: #endif /* ISIII */
1651: #ifdef I386IX
1652: prtopt(" I386IX");
1653: #endif /* I386IX */
1654: #ifdef RTU
1655: prtopt(" RTU");
1656: #endif /* RTU */
1657: #ifdef PROVX1
1658: prtopt(" PROVX1");
1659: #endif /* PROVX1 */
1660: #ifdef TOWER1
1661: prtopt(" TOWER1");
1662: #endif /* TOWER1 */
1663: #ifdef ZILOG
1664: prtopt(" ZILOG");
1665: #endif /* ZILOG */
1666: #ifdef TRS16
1667: prtopt(" TRS16");
1668: #endif /* TRS16 */
1669: #ifdef MINIX
1670: prtopt(" MINIX");
1671: #endif /* MINIX */
1672: #ifdef C70
1673: prtopt(" C70");
1674: #endif /* C70 */
1675: #ifdef AIXPS2
1676: prtopt(" AIXPS2");
1677: #endif /* AIXPS2 */
1678: #ifdef AIXRS
1679: prtopt(" AIXRS");
1680: #endif /* AIXRS */
1681: #ifdef UTSV
1682: prtopt(" UTSV");
1683: #endif /* UTSV */
1684: #ifdef ATTSV
1685: prtopt(" ATTSV");
1686: #endif /* ATTSV */
1687: #ifdef SVR3
1688: prtopt(" SVR3");
1689: #endif /* SVR3 */
1690: #ifdef SVR4
1691: prtopt(" SVR4");
1692: #endif /* SVR4 */
1693: #ifdef POSIX
1694: prtopt(" POSIX");
1695: #endif /* POSIX */
1696: #ifdef SUNOS4
1697: prtopt(" SUNOS4");
1698: #endif /* SUNOS4 */
1699: #ifdef SUN4S5
1700: prtopt(" SUN4S5");
1701: #endif /* SUN4S5 */
1702: #ifdef ENCORE
1703: prtopt(" ENCORE");
1704: #endif /* ENCORE */
1705: #ifdef ultrix
1706: prtopt(" ultrix");
1707: #endif
1708: #ifdef sxaE50
1709: prtopt(" sxaE50");
1710: #endif
1711: #ifdef mips
1712: prtopt(" mips");
1713: #endif
1714: #ifdef MIPS
1715: prtopt(" MIPS");
1716: #endif
1717: #ifdef vax
1718: prtopt(" vax");
1719: #endif
1720: #ifdef VAX
1721: prtopt(" VAX");
1722: #endif
1723: #ifdef sun
1724: prtopt(" sun");
1725: #endif
1726: #ifdef sun3
1727: prtopt(" sun3");
1728: #endif
1729: #ifdef sun386
1730: prtopt(" sun386");
1731: #endif
1732: #ifdef _SUN
1733: prtopt(" _SUN");
1734: #endif
1735: #ifdef sun4
1736: prtopt(" sun4");
1737: #endif
1738: #ifdef sparc
1739: prtopt(" sparc");
1740: #endif
1741: #ifdef NEXT
1742: prtopt(" NEXT");
1743: #endif
1744: #ifdef NeXT
1745: prtopt(" NeXT");
1746: #endif
1747: #ifdef sgi
1748: prtopt(" sgi");
1749: #endif
1750: #ifdef M_SYS5
1751: prtopt(" M_SYS5");
1752: #endif
1753: #ifdef __SYSTEM_FIVE
1754: prtopt(" __SYSTEM_FIVE");
1755: #endif
1756: #ifdef sysV
1757: prtopt(" sysV");
1758: #endif
1759: #ifdef M_XENIX /* SCO Xenix V and UNIX/386 */
1760: prtopt(" M_XENIX");
1761: #endif
1762: #ifdef M_UNIX
1763: prtopt(" M_UNIX");
1764: #endif
1765: #ifdef M_I386
1766: prtopt(" M_I386");
1767: #endif
1768: #ifdef i386
1769: prtopt(" i386");
1770: #endif
1771: #ifdef i286
1772: prtopt(" i286");
1773: #endif
1774: #ifdef M_I286
1775: prtopt(" M_I286");
1776: #endif
1777: #ifdef mc68000
1778: prtopt(" mc68000");
1779: #endif
1780: #ifdef mc68010
1781: prtopt(" mc68010");
1782: #endif
1783: #ifdef mc68020
1784: prtopt(" mc68020");
1785: #endif
1786: #ifdef mc68030
1787: prtopt(" mc68030");
1788: #endif
1789: #ifdef mc68040
1790: prtopt(" mc68040");
1791: #endif
1792: #ifdef M_68000
1793: prtopt(" M_68000");
1794: #endif
1795: #ifdef M_68010
1796: prtopt(" M_68010");
1797: #endif
1798: #ifdef M_68020
1799: prtopt(" M_68020");
1800: #endif
1801: #ifdef M_68030
1802: prtopt(" M_68030");
1803: #endif
1804: #ifdef M_68040
1805: prtopt(" M_68040");
1806: #endif
1807: #ifdef m68k
1808: prtopt(" m68k");
1809: #endif
1810: #ifdef m88k
1811: prtopt(" m88k");
1812: #endif
1813: #ifdef pdp11
1814: prtopt(" pdp11");
1815: #endif
1816: #ifdef iAPX
1817: prtopt(" iAPX");
1818: #endif
1819: #ifdef __hp9000s800
1820: prtopt(" __hp9000s800");
1821: #endif
1822: #ifdef __hp9000s500
1823: prtopt(" __hp9000s500");
1824: #endif
1825: #ifdef __hp9000s300
1826: prtopt(" __hp9000s300");
1827: #endif
1828: #ifdef __hp9000s200
1829: prtopt(" __hp9000s200");
1830: #endif
1831: #ifdef AIX
1832: prtopt(" AIX");
1833: #endif
1834: #ifdef _AIXFS
1835: prtopt(" _AIXFS");
1836: #endif
1837: #ifdef u370
1838: prtopt(" u370");
1839: #endif
1840: #ifdef u3b
1841: prtopt(" u3b");
1842: #endif
1843: #ifdef u3b2
1844: prtopt(" u3b2");
1845: #endif
1846: #ifdef multimax
1847: prtopt(" multimax");
1848: #endif
1849: #ifdef balance
1850: prtopt(" balance");
1851: #endif
1852: #ifdef ibmrt
1853: prtopt(" ibmrt");
1854: #endif
1855: #ifdef _IBMRT
1856: prtopt(" _IBMRT");
1857: #endif
1858: #ifdef ibmrs6000
1859: prtopt(" ibmrs6000");
1860: #endif
1861: #ifdef _AIX
1862: prtopt(" _AIX");
1863: #endif /* _AIX */
1864: #ifdef _IBMR2
1865: prtopt(" _IBMR2");
1866: #endif
1867: #ifdef __STRICT_BSD__
1868: prtopt(" __STRICT_BSD__");
1869: #endif
1870: #ifdef __STRICT_ANSI__
1871: prtopt(" __STRICT_ANSI__");
1872: #endif
1873: #ifdef _ANSI_C_SOURCE
1874: prtopt(" _ANSI_C_SOURCE");
1875: #endif
1876: #ifdef __STDC__
1877: prtopt(" __STDC__");
1878: #endif
1879: #ifdef __GNUC__ /* gcc in ansi mode */
1880: prtopt(" __GNUC__");
1881: #endif
1882: #ifdef GNUC /* gcc in traditional mode */
1883: prtopt(" GNUC");
1884: #endif
1885: #ifdef CK_ANSIC
1886: prtopt(" CK_ANSIC");
1887: #endif
1888: #ifdef CK_ANSILIBS
1889: prtopt(" CK_ANSILIBS");
1890: #endif
1891: #ifdef _XOPEN_SOURCE
1892: prtopt(" _XOPEN_SOURCE");
1893: #endif
1894: #ifdef _ALL_SOURCE
1895: prtopt(" _ALL_SOURCE");
1896: #endif
1897: #ifdef _SC_JOB_CONTROL
1898: prtopt(" _SC_JOB_CONTROL");
1899: #endif
1900: #ifdef _POSIX_JOB_CONTROL
1901: prtopt(" _POSIX_JOB_CONTROL");
1902: #endif
1903: #ifdef _BSD
1904: prtopt(" _BSD");
1905: #endif
1906: #ifdef TERMIOX
1907: prtopt(" TERMIOX");
1908: #endif /* TERMIOX */
1909: #ifdef STERMIOX
1910: prtopt(" STERMIOX");
1911: #endif /* STERMIOX */
1912: prtopt((char *)0);
1913: printf("\n\n");
1914: }
1915: #endif /* NOFRILLS */
1916:
1917: #ifdef VMS
1918: int
1919: sholbl() {
1920: printf("VMS Labeled File Features:\n");
1921: printf(" acl %s (ACL info %s)\n",
1922: lf_opts & LBL_ACL ? "on " : "off",
1923: lf_opts & LBL_ACL ? "preserved" : "discarded");
1924: printf(" backup-date %s (backup date/time %s)\n",
1925: lf_opts & LBL_BCK ? "on " : "off",
1926: lf_opts & LBL_BCK ? "preserved" : "discarded");
1927: printf(" name %s (original filename %s)\n",
1928: lf_opts & LBL_NAM ? "on " : "off",
1929: lf_opts & LBL_NAM ? "preserved" : "discarded");
1930: printf(" owner %s (original file owner id %s)\n",
1931: lf_opts & LBL_OWN ? "on " : "off",
1932: lf_opts & LBL_OWN ? "preserved" : "discarded");
1933: printf(" path %s (original file's disk:[directory] %s)\n",
1934: lf_opts & LBL_PTH ? "on " : "off",
1935: lf_opts & LBL_PTH ? "preserved" : "discarded");
1936: }
1937: #endif /* VMS */
1938:
1939: #ifndef NOSHOW
1940: int
1941: doshow(x) int x; {
1942: int y;
1943: char *s;
1944:
1945: #ifndef NOSETKEY
1946: if (x == SHKEY) { /* SHOW KEY */
1947: int c;
1948: KEY ch;
1949: CHAR *s;
1950:
1951: if ((y = cmcfm()) < 0) return(y);
1952: #ifdef MAC
1953: printf("Not implemented\n");
1954: return(0);
1955: #else /* Not MAC */
1956: printf(" Press key: ");
1957: conbin((char)escape); /* Put terminal in binary mode */
1958: c = congks(0); /* Get character or scan code */
1959: concb((char)escape); /* Restore terminal to cbreak mode */
1960: if (c < 0) { /* Check for error */
1961: printf("?Error reading key\n");
1962: return(0);
1963: }
1964: #ifndef OS2
1965: /*
1966: Do NOT mask when it can be a raw scan code, perhaps > 255
1967: */
1968: c &= cmdmsk; /* Apply command mask */
1969: #endif /* OS2 */
1970: printf("\n Key code \\%d => ",c);
1971: if (macrotab[c]) { /* See if there's a macro */
1972: printf("String: "); /* If so, display its definition */
1973: s = macrotab[c];
1974: while (ch = *s++)
1975: if (ch < 32 || ch == 127
1976: /*
1977: Systems whose native character sets have graphic characters in C1...
1978: */
1979: #ifndef NEXT /* NeXT */
1980: #ifndef AUX /* Macintosh */
1981: #ifndef XENIX /* IBM PC */
1982: #ifndef OS2 /* IBM PC */
1983: || (ch > 127 && ch < 160)
1984: #endif /* OS2 */
1985: #endif /* XENIX */
1986: #endif /* AUX */
1987: #endif /* NEXT */
1988: )
1989: printf("\\{%d}",ch); /* Display control characters */
1990: else putchar((char) ch); /* in backslash notation */
1991: printf("\n");
1992: } else { /* No macro, show single character */
1993: printf("Character: ");
1994: ch = keymap[c];
1995: if (ch < 32 || ch == 127 || ch > 255
1996: #ifndef NEXT
1997: #ifndef AUX
1998: #ifndef XENIX
1999: #ifndef OS2
2000: || (ch > 127 && ch < 160)
2001: #endif /* OS2 */
2002: #endif /* XENIX */
2003: #endif /* AUX */
2004: #endif /* NEXT */
2005: )
2006: printf("\\%d",(unsigned int) ch);
2007: else printf("%c \\%d",ch,(unsigned int) ch);
2008: }
2009: if (ch == (KEY) c)
2010: printf(" (self, no translation)\n");
2011: else printf("\n");
2012: return(1);
2013: #endif /* MAC */
2014: }
2015: #endif /* NOSETKEY */
2016:
2017: #ifndef NOSPL
2018: if (x == SHMAC) { /* SHOW MACRO */
2019: x = cmfld("Macro name, or carriage return to see them all","",&s,
2020: NULL);
2021: if (x == -3) /* This means they want see all */
2022: *line = '\0';
2023: else if (x < 0) /* Otherwise negative = parse error */
2024: return(x);
2025: else /* 0 or greater */
2026: strcpy(line,s); /* means they typed something */
2027: if ((y = cmcfm()) < 0) return(y); /* Get confirmation */
2028: if (*line) {
2029: slc = 0; /* Initial SHO MAC line number */
2030: x = mlook(mactab,s,nmac); /* Look up what they typed */
2031: switch (x) {
2032: case -3: /* Nothing to look up */
2033: return(0);
2034: case -1: /* Not found */
2035: printf("%s - not found\n",s);
2036: return(0);
2037: case -2: /* Ambiguous, matches more than one */
2038: y = (int)strlen(line);
2039: for (x = 0; x < nmac; x++)
2040: if (!strncmp(mactab[x].kwd,line,y))
2041: if (shomac(mactab[x].kwd,mactab[x].mval) < 0) break;
2042: return(1);
2043: default: /* Matches one exactly */
2044: shomac(mactab[x].kwd,mactab[x].mval);
2045: return(1);
2046: }
2047: } else { /* They want to see them all */
2048: printf("Macros:\n");
2049: slc = 1;
2050: for (y = 0; y < nmac; y++)
2051: if (shomac(mactab[y].kwd,mactab[y].mval) < 0) break;
2052: return(1);
2053: }
2054: }
2055: #endif /* NOSPL */
2056:
2057: /*
2058: Other SHOW commands only have two fields. Get command confirmation here,
2059: then handle with big switch() statement.
2060: */
2061: if ((y = cmcfm()) < 0) return(y);
2062: switch (x) {
2063:
2064: #ifdef SUNX25
2065: case SHPAD:
2066: shopad();
2067: break;
2068: #endif /* SUNX25 */
2069:
2070: #ifdef NETCONN
2071: case SHNET:
2072: shonet();
2073: break;
2074: #endif /* NETCONN */
2075:
2076: case SHPAR:
2077: shopar();
2078: break;
2079:
2080: case SHATT:
2081: shoatt();
2082: break;
2083:
2084: #ifndef NOSPL
2085: case SHCOU:
2086: printf(" %d\n",count[cmdlvl]);
2087: break;
2088: #endif /* NOSPL */
2089:
2090: #ifndef NOSERVER
2091: case SHSER: /* Show Server */
2092: #ifndef NOFRILLS
2093: printf("Function Status:\n");
2094: printf(" GET %s\n",nm[en_get]);
2095: printf(" SEND %s\n",nm[en_sen]);
2096: printf(" REMOTE CD/CWD %s\n",nm[en_cwd]);
2097: printf(" REMOTE DELETE %s\n",nm[en_del]);
2098: printf(" REMOTE DIRECTORY %s\n",nm[en_dir]);
2099: printf(" REMOTE HOST %s\n",nm[en_hos]);
2100: printf(" REMOTE SET %s\n",nm[en_set]);
2101: printf(" REMOTE SPACE %s\n",nm[en_spa]);
2102: printf(" REMOTE TYPE %s\n",nm[en_typ]);
2103: printf(" REMOTE WHO %s\n",nm[en_who]);
2104: printf(" BYE %s\n",nm[en_bye]);
2105: printf(" FINISH %s\n",nm[en_fin]);
2106: #endif /* NOFRILLS */
2107: printf("Server timeout: %d\n",srvtim);
2108: printf("Server display: %s\n\n", srvdis ? "on" : "off");
2109: break;
2110: #endif /* NOSERVER */
2111:
2112: case SHSTA: /* Status of last command */
2113: if (success) printf(" SUCCESS\n"); else printf(" FAILURE\n");
2114: break;
2115:
2116: #ifdef MAC
2117: case SHSTK: { /* Stack for MAC debugging */
2118: long sp;
2119:
2120: sp = -1;
2121: loadA0 ((char *)&sp); /* set destination address */
2122: SPtoaA0(); /* move SP to destination */
2123: printf("Stack at 0x%x\n", sp);
2124: show_queue(); /* more debugging */
2125: break;
2126: }
2127: #endif /* MAC */
2128:
2129: case SHTER:
2130: #ifdef OS2PM
2131: printf(" Terminal type: %s\n",
2132: (Term_mode == VT100) ? "VT100" : "Tektronix");
2133: #endif /* OS2PM */
2134: printf(" Command bytesize: %d bits\n",
2135: (cmdmsk == 0377) ? 8 : 7);
2136: printf(" Terminal bytesize: %d bits\n",
2137: (cmask == 0377) ? 8 : 7);
2138: printf(" Terminal locking-shift: %s\n", sosi ? "on" : "off");
2139: printf(" Terminal newline-mode: %s\n", tnlm ? "on" : "off");
2140: #ifndef NOCSETS
2141: printf(" Terminal character set");
2142: if (tcsl == tcsr) {
2143: printf(": transparent\n");
2144: } else {
2145: s = "unknown";
2146: for (y = 0; y <= nfilc; y++)
2147: if (fcstab[y].kwval == tcsr) {
2148: s = fcstab[y].kwd;
2149: break;
2150: }
2151: printf("s: remote: %s, local: ",s);
2152: s = "unknown";
2153: for (y = 0; y <= nfilc; y++)
2154: if (fcstab[y].kwval == tcsl) {
2155: s = fcstab[y].kwd;
2156: break;
2157: }
2158: printf("%s",s);
2159: if (tcsr != tcsl)
2160: printf(" (via %s)",
2161: #ifdef CYRILLIC
2162: (language == L_RUSSIAN) ? "latin-cyrillic" : "latin1"
2163: #else
2164: "latin1"
2165: #endif /* CYRILLIC */
2166: );
2167: printf("\n");
2168: }
2169: #endif /* NOCSETS */
2170: #ifdef UNIX
2171: printf(" Suspend: %s\n", suspend ? "on" : "off");
2172: #endif /* UNIX */
2173: break;
2174:
2175: #ifndef NOFRILLS
2176: case SHVER:
2177: shover();
2178: break;
2179: #endif /* NOFRILLS */
2180:
2181: #ifndef NOSPL
2182: case SHBUI: /* Built-in variables */
2183: for (y = 0; y < nvars; y++)
2184: printf(" \\v(%s) = %s\n",vartab[y].kwd,nvlook(vartab[y].kwd));
2185: break;
2186:
2187: case SHFUN: /* Functions */
2188: for (y = 0; y < nfuncs; y++)
2189: printf(" \\f%s()\n",fnctab[y].kwd);
2190: break;
2191:
2192: case SHVAR: /* Global variables */
2193: x = 0; /* Variable count */
2194: slc = 1; /* Screen line count for "more?" */
2195: for (y = 33; y < GVARS; y++)
2196: if (g_var[y]) {
2197: if (x++ == 0) printf("Global variables:\n");
2198: sprintf(line," \\%%%c",y);
2199: if (shomac(line,g_var[y]) < 0) break;
2200: }
2201: if (!x) printf(" No variables defined\n");
2202: break;
2203:
2204: case SHARG: /* Args */
2205: if (maclvl > -1) {
2206: printf("Macro arguments at level %d\n",maclvl);
2207: for (y = 0; y < 10; y++)
2208: if (m_arg[maclvl][y])
2209: printf(" \\%%%d = %s\n",y,m_arg[maclvl][y]);
2210: } else {
2211: printf(" No macro arguments at top level\n");
2212: }
2213: break;
2214:
2215: case SHARR: /* Arrays */
2216: x = 0;
2217: for (y = 0; y < 27; y++)
2218: if (a_ptr[y]) {
2219: if (x == 0) printf("Declared arrays:\n");
2220: x = 1;
2221: printf(" \\&%c[%d]\n",(y == 0) ? 64 : y + 96, a_dim[y]);
2222: }
2223: if (!x) printf(" No arrays declared\n");
2224: break;
2225: #endif /* NOSPL */
2226:
2227: case SHPRO: /* Protocol parameters */
2228: shoparp();
2229: printf("\n");
2230: break;
2231:
2232: case SHCOM: /* Communication parameters */
2233: printf("\n");
2234: shoparc();
2235: #ifndef NODIAL
2236: printf("\n");
2237: #ifdef NETCONN
2238: if (!network)
2239: #endif /* NETCONN */
2240: shodial();
2241: #endif /* NODIAL */
2242: printf("\n");
2243: shomdm();
2244: printf("\n");
2245: break;
2246:
2247: case SHFIL: /* File parameters */
2248: shoparf();
2249: printf("\n");
2250: break;
2251:
2252: #ifndef NOCSETS
2253: case SHLNG: /* Languages */
2254: shoparl();
2255: break;
2256: #endif /* NOCSETS */
2257:
2258: #ifndef NOSPL
2259: case SHSCR: /* Scripts */
2260: printf(" Take echo: %s\n", techo ? "On" : "Off");
2261: printf(" Take error: %s\n", terror ? "On" : "Off");
2262: printf(" Macro Echo: %s\n", mecho ? "On" : "Off");
2263: printf(" Macro Error: %s\n", merror ? "On" : "Off");
2264: printf(" Input Case: %s\n", incase ? "Observe" : "Ignore");
2265: printf(" Input Echo: %s\n", inecho ? "On" : "Off");
2266: printf(" Input Timeout: %s\n", intime ? "Quit" : "Proceed");
2267: #ifndef NOSCRIPT
2268: printf(" Script echo: %s\n", secho ? "On" : "Off");
2269: #endif /* NOSCRIPT */
2270: break;
2271: #endif /* NOSPL */
2272:
2273: #ifndef NOXMIT
2274: case SHXMI:
2275: printf(" File type: %s\n", binary ? "binary" : "text");
2276: printf(" Transmit EOF: ");
2277: if (*xmitbuf == NUL) {
2278: printf("none\n");
2279: } else {
2280: char *p;
2281: p = xmitbuf;
2282: while (*p) {
2283: if (*p < SP)
2284: printf("^%c",ctl(*p));
2285: else
2286: printf("%c",*p);
2287: p++;
2288: }
2289: printf("\n");
2290: }
2291: if (xmitf)
2292: printf(" Transmit Fill: %d (fill character for blank lines)\n",
2293: xmitf);
2294: else printf(" Transmit Fill: none\n");
2295: printf(" Transmit Linefeed: %s\n",
2296: xmitl ? "on (send linefeeds too)" : "off");
2297: if (xmitp)
2298: printf(" Transmit Prompt: %d (host line end character)\n",xmitp);
2299: else printf(" Transmit Prompt: none\n");
2300: printf(" Transmit Echo: %s\n",
2301: xmitx ? "on" : "off");
2302: printf(" Transmit Locking-Shift: %s\n",xmits ? "on" : "off");
2303: printf(" Transmit Pause: %d milliseconds\n", xmitw);
2304: break;
2305: #endif /* NOXMIT */
2306:
2307: case SHMOD: /* SHOW MODEM */
2308: shmdmlin();
2309: shomdm();
2310: break;
2311:
2312: #ifndef MAC
2313: case SHDFLT:
2314: zsyscmd(PWDCMD);
2315: break;
2316: #endif /* MAC */
2317:
2318: case SHESC:
2319: printf(" Escape character: %d (^%c)\n",escape,ctl(escape));
2320: break;
2321:
2322: #ifndef NODIAL
2323: case SHDIA:
2324: shmdmlin();
2325: doshodial();
2326: if (local
2327: #ifdef NETCONN
2328: && !network
2329: #endif /* NETCONN */
2330: ) {
2331: printf("%s modem signals:\n",ttname);
2332: shomdm();
2333: }
2334: break;
2335: #endif /* NODIAL */
2336:
2337: #ifdef VMS
2338: case SHLBL:
2339: sholbl();
2340: break;
2341: #endif /* VMS */
2342:
2343: default:
2344: printf("\nNothing to show...\n");
2345: return(-2);
2346: }
2347: return(success = 1);
2348: }
2349:
2350: VOID
2351: shmdmlin() { /* Briefly show modem & line */
2352: int i;
2353: if (local
2354: #ifdef NETCONN
2355: && !network
2356: #endif /* NETCONN */
2357: )
2358: printf("Line: %s, modem: ",ttname);
2359: else
2360: printf(" Communication device not yet selected with SET LINE\nModem: ");
2361: if (
2362: #ifdef NETCONN
2363: !network
2364: #else
2365: 1
2366: #endif /* NETCONN */
2367: ) {
2368: #ifndef NODIAL
2369: for (i = 0; i < nmdm; i++) {
2370: if (mdmtab[i].kwval == mdmtyp) {
2371: printf("%s\n",mdmtab[i].kwd);
2372: break;
2373: }
2374: }
2375: #else
2376: printf("(disabled)\n");
2377: #endif /* NODIAL */
2378: }
2379: }
2380:
2381: #ifndef NOSPL
2382: #define SCRNLEN 21
2383: #define SCRNWID 79
2384: int /* SHO MACROS */
2385: shomac(s1, s2) char *s1, *s2; {
2386: int x, n, pp;
2387: pp = 0;
2388:
2389: if (!s1)
2390: return(0);
2391: else
2392: printf("%s = ",s1); /* Print macro name */
2393: n = (int)strlen(s1) + 3;
2394: if (!s2) s2 = "(null definition)";
2395: while (x = *s2++) { /* Loop thru definition */
2396: if (x == '(') pp++; /* Treat commas within parens */
2397: if (x == ')') pp--; /* as ordinary text */
2398: if (pp < 0) pp = 0; /* Outside parens, */
2399: if (x == ',' && pp == 0) { /* comma becomes comma-dash-NL. */
2400: putchar(',');
2401: x = '\n';
2402: }
2403: putchar(x);
2404: if (x == '\n') {
2405: n = 0;
2406: slc++;
2407: } else if (++n > SCRNWID) {
2408: putchar(NL);
2409: n = 0;
2410: slc++;
2411: }
2412: if (slc > SCRNLEN) {
2413: if (!askmore()) return(-1);
2414: n = 0;
2415: slc = 0;
2416: }
2417: }
2418: putchar(NL);
2419: if (++slc > SCRNLEN) {
2420: if (!askmore()) return(-1);
2421: slc = 0;
2422: }
2423: return(0);
2424: }
2425: #endif /* NOSPL */
2426:
2427: int
2428: shoatt() {
2429: printf("Attributes: %s\n", atcapr ? "On" : "Off");
2430: if (!atcapr) return(0);
2431: printf(" Blocksize: %s\n", atblki ? "On" : "Off");
2432: printf(" Date: %s\n", atdati ? "On" : "Off");
2433: printf(" Disposition: %s\n", atdisi ? "On" : "Off");
2434: printf(" Encoding (Character Set): %s\n", atenci ? "On" : "Off");
2435: printf(" Length: %s\n", atleni ? "On" : "Off");
2436: printf(" Type (text/binary): %s\n", attypi ? "On" : "Off");
2437: printf(" System ID: %s\n", atsidi ? "On" : "Off");
2438: printf(" System Info: %s\n", atsysi ? "On" : "Off");
2439: return(0);
2440: }
2441: #endif /* NOSHOW */
2442:
2443: #ifndef NOSPL
2444: /* Evaluate an arithmetic expression. */
2445: /* Code adapted from ev, by Howie Kaye of Columbia U & others. */
2446:
2447: static int xerror;
2448: static char *cp;
2449: static long tokval;
2450: static char curtok;
2451: static long expval;
2452:
2453: #define LONGBITS (8*sizeof (long))
2454: #define NUMBER 'N'
2455: #define EOT 'E'
2456:
2457: /*
2458: Replacement for strchr() and index(), neither of which seem to be universal.
2459: */
2460:
2461: static char *
2462: #ifdef CK_ANSIC
2463: windex(char * s, char c)
2464: #else
2465: windex(s,c) char *s, c;
2466: #endif /* CK_ANSIC */
2467: /* windex */ {
2468: while (*s != NUL && *s != c) s++;
2469: if (*s == c) return(s); else return(NULL);
2470: }
2471:
2472: /*
2473: g e t t o k
2474:
2475: Returns the next token. If token is a NUMBER, sets tokval appropriately.
2476: */
2477: static char
2478: gettok() {
2479: while (isspace(*cp)) cp++ ;
2480: switch(*cp) {
2481: case '$': /* ??? */
2482: case '+': /* Add */
2483: case '-': /* Subtract or Negate */
2484: case '@': /* Greatest Common Divisor */
2485: case '*': /* Multiply */
2486: case '/': /* Divide */
2487: case '%': /* Modulus */
2488: case '<': /* Left shift */
2489: case '>': /* Right shift */
2490: case '&': /* And */
2491: case '|': /* Or */
2492: case '#': /* Exclusive Or */
2493: case '~': /* Not */
2494: case '^': /* Exponent */
2495: case '!': /* Factorial */
2496: case '(': /* Parens for grouping */
2497: case ')': return(*cp++); /* operator, just return it */
2498: case '\n':
2499: case '\0': return(EOT); /* end of line, return that */
2500: }
2501: if (isxdigit(*cp)) { /* digit, must be a number */
2502: char tbuf[80],*tp; /* buffer to accumulate number */
2503: int radix = 10; /* default radix */
2504: for (tp=tbuf; isxdigit(*cp); cp++)
2505: *tp++ = isupper(*cp) ? tolower(*cp) : *cp;
2506: *tp = '\0'; /* end number */
2507: switch(isupper(*cp) ? tolower(*cp) : *cp) { /* examine break char */
2508: case 'h':
2509: case 'x': radix = 16; cp++; break; /* if radix signifier... */
2510: case 'o':
2511: case 'q': radix = 8; cp++; break;
2512: case 't': radix = 2; cp++; break;
2513: }
2514: for (tp=tbuf,tokval=0; *tp != '\0'; tp++) {
2515: int dig;
2516: dig = *tp - '0'; /* convert number */
2517: if (dig > 10) dig -= 'a'-'0'-10;
2518: if (dig >= radix) {
2519: xerror = 1;
2520: if (cmdlvl == 0)
2521: printf("invalid digit '%c' in number\n",*tp);
2522: return(NUMBER);
2523: }
2524: tokval = radix*tokval + dig;
2525: }
2526: return(NUMBER);
2527: }
2528: if (cmdlvl == 0)
2529: printf("Invalid character '%c' in input\n",*cp);
2530: xerror = 1;
2531: cp++;
2532: return(gettok());
2533: }
2534:
2535: static long
2536: expon(x,y) long x,y; {
2537: long result = 1;
2538: int sign = 1;
2539: if (y < 0) return(0);
2540: if (x < 0) {
2541: x = -x;
2542: if (y & 1) sign = -1;
2543: }
2544: while (y != 0) {
2545: if (y & 1) result *= x;
2546: y >>= 1;
2547: if (y != 0) x *= x;
2548: }
2549: return(result * sign);
2550: }
2551:
2552: /*
2553: * factor ::= simple | simple ^ factor
2554: *
2555: */
2556: _PROTOTYP( static VOID simple, (void) );
2557:
2558: static VOID
2559: factor() {
2560: long oldval;
2561: simple();
2562: if (curtok == '^') {
2563: oldval = expval;
2564: curtok = gettok();
2565: factor();
2566: expval = expon(oldval,expval);
2567: }
2568: }
2569:
2570: /*
2571: * termp ::= NULL | {*,/,%,&} factor termp
2572: *
2573: */
2574: static VOID
2575: termp() {
2576: while (curtok == '*' || curtok == '/' || curtok == '%' || curtok == '&') {
2577: long oldval;
2578: char op;
2579: op = curtok;
2580: curtok = gettok(); /* skip past operator */
2581: oldval = expval;
2582: factor();
2583: switch(op) {
2584: case '*': expval = oldval * expval; break;
2585: case '/': expval = oldval / expval; break;
2586: case '%': expval = oldval % expval; break;
2587: case '&': expval = oldval & expval; break;
2588: }
2589: }
2590: }
2591:
2592: static long
2593: fact(x) long x; { /* factorial */
2594: long result = 1;
2595: while (x > 1)
2596: result *= x--;
2597: return(result);
2598: }
2599:
2600: /*
2601: * term ::= factor termp
2602: *
2603: */
2604: static VOID
2605: term() {
2606: factor();
2607: termp();
2608: }
2609:
2610: static long
2611: gcd(x,y) long x,y; {
2612: int nshift = 0;
2613: if (x < 0) x = -x;
2614: if (y < 0) y = -y; /* validate arguments */
2615: if (x == 0 || y == 0) return(x + y); /* this is bogus */
2616:
2617: while (!((x & 1) | (y & 1))) { /* get rid of powers of 2 */
2618: nshift++;
2619: x >>= 1;
2620: y >>= 1;
2621: }
2622: while (x != 1 && y != 1 && x != 0 && y != 0) {
2623: while (!(x & 1)) x >>= 1; /* eliminate unnecessary */
2624: while (!(y & 1)) y >>= 1; /* powers of 2 */
2625: if (x < y) { /* force x to be larger */
2626: long t;
2627: t = x;
2628: x = y;
2629: y = t;
2630: }
2631: x -= y;
2632: }
2633: if (x == 0 || y == 0) return((x + y) << nshift); /* gcd is non-zero one */
2634: else return((long) 1 << nshift); /* else gcd is 1 */
2635: }
2636:
2637: /*
2638: * exprp ::= NULL | {+,-,|,...} term exprp
2639: *
2640: */
2641: static VOID
2642: exprp() {
2643: while (windex("+-|<>#@",curtok) != NULL) {
2644: long oldval;
2645: char op;
2646: op = curtok;
2647: curtok = gettok(); /* skip past operator */
2648: oldval = expval;
2649: term();
2650: switch(op) {
2651: case '+' : expval = oldval + expval; break;
2652: case '-' : expval = oldval - expval; break;
2653: case '|' : expval = oldval | expval; break;
2654: case '#' : expval = oldval ^ expval; break;
2655: case '@' : expval = gcd(oldval,expval); break;
2656: case '<' : expval = oldval << expval; break;
2657: case '>' : expval = oldval >> expval; break;
2658: }
2659: }
2660: }
2661:
2662: /*
2663: * expr ::= term exprp
2664: *
2665: */
2666: static VOID
2667: expr() {
2668: term();
2669: exprp();
2670: }
2671:
2672: static long
2673: xparse() {
2674: curtok = gettok();
2675: expr();
2676: #ifdef COMMENT
2677: if (curtok == '$') {
2678: curtok = gettok();
2679: if (curtok != NUMBER) {
2680: if (cmdlvl == 0) printf("illegal radix\n");
2681: return(0);
2682: }
2683: curtok = gettok();
2684: }
2685: #endif /* COMMENT */
2686: if (curtok != EOT) {
2687: if (cmdlvl == 0)
2688: printf("extra characters after expression\n");
2689: xerror = 1;
2690: }
2691: return(expval);
2692: }
2693:
2694: char *
2695: evala(s) char *s; {
2696: char *p; /* Return pointer */
2697: long v; /* Numeric value */
2698:
2699: xerror = 0; /* Start out with no error */
2700: cp = s; /* Make the argument global */
2701: v = xparse(); /* Parse the string */
2702: p = numbuf; /* Convert long number to string */
2703: sprintf(p,"%ld",v);
2704: return(xerror ? "" : p); /* Return empty string on error */
2705: }
2706:
2707: /*
2708: * simplest ::= NUMBER | ( expr )
2709: *
2710: */
2711: static VOID
2712: simplest() {
2713: if (curtok == NUMBER) expval = tokval;
2714: else if (curtok == '(') {
2715: curtok = gettok(); /* skip over paren */
2716: expr();
2717: if (curtok != ')') {
2718: if (cmdlvl == 0) printf("missing right parenthesis\n");
2719: xerror = 1;
2720: }
2721: }
2722: else {
2723: if (cmdlvl == 0) printf("operator unexpected\n");
2724: xerror = 1;
2725: }
2726: curtok = gettok();
2727: }
2728:
2729: /*
2730: * simpler ::= simplest | simplest !
2731: *
2732: */
2733: static VOID
2734: simpler() {
2735: simplest();
2736: if (curtok == '!') {
2737: curtok = gettok();
2738: expval = fact(expval);
2739: }
2740: }
2741:
2742: /*
2743: * simple ::= {-,~} simpler | simpler
2744: *
2745: */
2746:
2747: static VOID
2748: simple() {
2749: if (curtok == '-' || curtok == '~') {
2750: int op = curtok;
2751: curtok = gettok(); /* skip over - sign */
2752: simpler(); /* parse the factor again */
2753: expval = op == '-' ? -expval : ~expval;
2754: } else simpler();
2755: }
2756: #endif /* NOSPL */
2757:
2758: #ifndef NOSPL
2759: /* D C L A R R A Y -- Declare an array */
2760:
2761: int /* Declare an array of size n */
2762: #ifdef CK_ANSIC
2763: dclarray(char a, int n)
2764: #else
2765: dclarray(a,n) char a; int n;
2766: #endif /* CK_ANSIC */
2767: /* dclarray */ {
2768: char **p; int i, n2;
2769:
2770: if (a > 63 && a < 96) a += 32; /* Convert to lowercase */
2771: if (a < 96 || a > 122) return(-1); /* Verify name */
2772: a -= 96; /* Convert name to number */
2773: if ((p = a_ptr[a]) != NULL) { /* Delete old array of same name */
2774: n2 = a_dim[a];
2775: for (i = 0; i <= n2; i++) /* First delete its elements */
2776: if (p[i]) free(p[i]);
2777: free(a_ptr[a]); /* Then the element list */
2778: a_ptr[a] = (char **) NULL; /* Remove pointer to element list */
2779: a_dim[a] = 0; /* Set dimension at zero. */
2780: }
2781: if (n == 0) return(0); /* If dimension 0, just deallocate. */
2782:
2783: p = (char **) malloc((n+1) * sizeof(char **)); /* Allocate for new array */
2784: if (p == NULL) return(-1); /* Check */
2785: a_ptr[a] = p; /* Save pointer to member list */
2786: a_dim[a] = n; /* Save dimension */
2787: for (i = 0; i <= n; i++) /* Initialize members to null */
2788: p[i] = NULL;
2789: return(0);
2790: }
2791:
2792: /* A R R A Y N A M -- Parse an array name */
2793:
2794: /*
2795: Call with pointer to string that starts with the array reference.
2796: String may begin with either \& or just &.
2797: On success,
2798: Returns letter ID (always lowercase) in argument c,
2799: which can also be accent grave (` = 96; '@' is converted to grave);
2800: Dimension or subscript in argument n;
2801: IMPORTANT: These arguments must be provided by the caller as addresses
2802: of ints (not chars), for example:
2803: char *s; int x, y;
2804: arraynam(s,&x,&y);
2805: On failure, returns a negative number, with args n and c set to zero.
2806: */
2807: int
2808: arraynam(ss,c,n) char *ss; int *c; int *n; {
2809: int i, y, pp;
2810: char x;
2811: char *s, *p, *sx, *vnp;
2812: char vnbuf[VNAML+1]; /* On stack to allow for */
2813: char ssbuf[VNAML+1]; /* recursive calls... */
2814: char sxbuf[VNAML+1];
2815:
2816: *c = *n = 0; /* Initialize return values */
2817: strncpy(vnbuf,ss,VNAML);
2818: vnp = vnbuf;
2819: if (vnbuf[0] == CMDQ && vnbuf[1] == '&') vnp++;
2820: if (*vnp != '&') {
2821: printf("?Not an array - %s\n",vnbuf);
2822: return(-9);
2823: }
2824: x = *(vnp + 1); /* Fold case of array name */
2825: /* We don't use isupper & tolower here on purpose because these */
2826: /* would produce undesired effects with accented letters. */
2827: if (x > 63 && x < 91) x = *(vnp +1) = x + 32;
2828: if ((x < 96) || (x > 122) || (*(vnp+2) != '[')) {
2829: printf("?Invalid format for array name - %s\n",vnbuf);
2830: return(-9);
2831: }
2832: *c = x; /* Return the array name */
2833: s = vnp+3; /* Get dimension */
2834: p = ssbuf;
2835: pp = 1; /* Bracket counter */
2836: for (i = 0; i < VNAML && *s != NUL; i++) { /* Copy up to ] */
2837: if (*s == '[') pp++;
2838: if (*s == ']' && --pp == 0) break;
2839: *p++ = *s++;
2840: }
2841: if (*s != ']') {
2842: printf("?No closing bracket on array dimension - %s\n",vnbuf);
2843: return(-9);
2844: }
2845: *p = NUL; /* Terminate subscript with null */
2846: p = ssbuf; /* Point to beginning of subscript */
2847: sx = sxbuf; /* Where to put expanded subscript */
2848: y = VNAML-1;
2849: xxstring(p,&sx,&y); /* Convert variables, etc. */
2850: if (!chknum(sxbuf)) { /* Make sure it's all digits */
2851: printf("?Array dimension or subscript must be numeric - %s\n",sxbuf);
2852: return(-9);
2853: }
2854: if ((y = atoi(sxbuf)) < 0) {
2855: if (cmflgs == 0) printf("\n");
2856: printf("?Array dimension or subscript must be positive or zero - %s\n",
2857: sxbuf);
2858: return(-9);
2859: }
2860: *n = y; /* Return the subscript or dimension */
2861: return(0);
2862: }
2863:
2864: int
2865: chkarray(a,i) int a, i; { /* Check if array is declared */
2866: int x; /* and if subscript is in range */
2867: if (a == 64) a = 96; /* Convert atsign to grave accent */
2868: x = a - 96; /* Values must be in range 96-122 */
2869: if (x < 0 || x > 26) return(-2); /* Not in range */
2870: if (a_ptr[x] == NULL) return(-1); /* Not declared */
2871: if (i > a_dim[x]) return(-2); /* Declared but out of range. */
2872: return(a_dim[x]); /* All ok, return dimension */
2873: }
2874:
2875: char *
2876: arrayval(a,i) int a, i; { /* Return value of \&a[i] */
2877: int x; char **p; /* (possibly NULL) */
2878:
2879: if (a == 64) a = 96; /* Convert atsign to grave accent */
2880: x = a - 96; /* Values must be in range 96-122 */
2881: if (x < 0 || x > 26) return(NULL); /* Not in range */
2882: if ((p = a_ptr[x]) == NULL) /* Array not declared */
2883: return(NULL);
2884: if (i > a_dim[x]) /* Subscript out of range. */
2885: return(NULL);
2886: return(p[i]); /* All ok, return pointer to value. */
2887: }
2888: #endif /* NOSPL */
2889:
2890: #ifndef NOSPL
2891: /* P A R S E V A R -- Parse a variable name or array reference. */
2892: /*
2893: Call with:
2894: s = pointer to candidate variable name or array reference.
2895: *c = address of integer in which to return variable ID.
2896: *i = address of integer in which to return array subscript.
2897: Returns:
2898: -2: syntax error in variable name or array reference.
2899: 1: successful parse of a simple variable, with ID in c.
2900: 2: successful parse of an array reference, w/ID in c and subscript in i.
2901: */
2902: int
2903: parsevar(s,c,i) char *s; int *c, *i; {
2904: char *p;
2905: int x,y,z;
2906:
2907: p = s;
2908: if (*s == CMDQ) s++; /* Point after backslash */
2909:
2910: if (*s != '%' && *s != '&') { /* Make sure it's % or & */
2911: printf("?Not a variable name - %s\n",p);
2912: return(-9);
2913: }
2914: if ((int)strlen(s) < 2) {
2915: printf("?Incomplete variable name - %s\n",p);
2916: return(-9);
2917: }
2918: if (*s == '%' && *(s+2) != '\0') {
2919: printf("?Only one character after '%%' in variable name, please\n");
2920: return(-9);
2921: }
2922: if (*s == '&' && *(s+2) != '[') {
2923: printf("?Array subscript expected - %s\n",p);
2924: return(-9);
2925: }
2926: if (*s == '%') { /* Simple variable. */
2927: y = *(s+1); /* Get variable ID letter/char */
2928: if (isupper(y)) y -= ('a'-'A'); /* Convert upper to lower case */
2929: *c = y; /* Set the return values. */
2930: *i = -1; /* No array subscript. */
2931: return(1); /* Return 1 = simple variable */
2932: }
2933: if (*s == '&') { /* Array reference. */
2934: if (arraynam(s,&x,&z) < 0) { /* Go parse it. */
2935: printf("?Invalid array reference - %s\n",p);
2936: return(-9);
2937: }
2938: if (chkarray(x,z) < 0) { /* Check if declared, etc. */
2939: printf("?Array not declared or subscript out of range\n");
2940: return(-9);
2941: }
2942: *c = x; /* Return array letter */
2943: *i = z; /* and subscript. */
2944: return(2);
2945: }
2946: return(-2); /* None of the above. */
2947: }
2948:
2949: #define VALN 20
2950:
2951: /* Get the numeric value of a variable */
2952: /*
2953: Call with pointer to variable name, pointer to int for return value.
2954: Returns:
2955: 0 on success with second arg containing the value.
2956: -1 on failure (bad variable syntax, variable not defined or not numeric).
2957: */
2958: int
2959: varval(s,v) char *s; int *v; {
2960: char valbuf[VALN+1]; /* s is pointer to variable name */
2961: char *p;
2962: int y;
2963:
2964: p = valbuf; /* Expand variable into valbuf. */
2965: y = VALN;
2966: if (xxstring(s,&p,&y) < 0) return(-1);
2967: p = valbuf; /* Make sure value is numeric */
2968: if (!chknum(p)) return(-1);
2969: *v = atoi(p); /* Convert numeric string to int */
2970: return(0);
2971: }
2972:
2973: /* Increment or decrement a variable */
2974: /* Returns -1 on failure, 0 on success, with 4th argument set to result */
2975:
2976: int
2977: incvar(s,x,z,r) char *s; int x, z, *r; { /* Increment a numeric variable */
2978: char valbuf[VALN+1]; /* s is pointer to variable name */
2979: /* x is amount to increment by */
2980: int n; /* z != 0 means add */
2981: /* z = 0 means subtract */
2982:
2983: if (varval(s,&n) < 0) /* Convert numeric string to int */
2984: return(-1);
2985: if (z) /* Increment it by the given amount */
2986: n += x;
2987: else /* or decrement as requested. */
2988: n -= x;
2989: sprintf(valbuf,"%d",n); /* Convert back to numeric string */
2990: addmac(s,valbuf); /* Replace old variable */
2991: *r = n; /* Return the integer value */
2992: return(0);
2993: }
2994: #endif /* NOSPL */
2995:
2996: /* Functions moved here from ckuusr.c to even out the module sizes... */
2997:
2998: #ifndef NOSPL
2999: /* D O D O -- Do a macro */
3000:
3001: /*
3002: Call with x = macro table index, s = pointer to arguments.
3003: Returns 0 on failure, 1 on success.
3004: */
3005:
3006: int
3007: dodo(x,s) int x; char *s; {
3008: char *p;
3009: int b, y, z;
3010:
3011: debug(F101,"dodo maclvl","",maclvl);
3012: if (++maclvl > MACLEVEL) { /* Make sure we have storage */
3013: debug(F101,"dodo maclvl too deep","",maclvl);
3014: --maclvl;
3015: printf("Macros nested too deeply\n");
3016: return(0);
3017: }
3018: macp[maclvl] = mactab[x].mval; /* Point to the macro body */
3019: macx[maclvl] = mactab[x].mval; /* Remember where the beginning is */
3020: debug(F111,"do macro",macp[maclvl],maclvl);
3021:
3022: cmdlvl++; /* Entering a new command level */
3023: if (cmdlvl > CMDSTKL) { /* Too many macros + TAKE files? */
3024: debug(F101,"dodo cmdlvl too deep","",cmdlvl);
3025: cmdlvl--;
3026: printf("?TAKE files and DO commands nested too deeply\n");
3027: return(0);
3028: }
3029: #ifdef VMS
3030: conres(); /* So Ctrl-C, etc, will work. */
3031: #endif
3032: ifcmd[cmdlvl] = 0;
3033: iftest[cmdlvl] = 0;
3034: count[cmdlvl] = 0;
3035: cmdstk[cmdlvl].src = CMD_MD; /* Say we're in a macro */
3036: cmdstk[cmdlvl].lvl = maclvl; /* and remember the macro level */
3037: mrval[maclvl] = NULL; /* Initialize return value */
3038:
3039: debug(F110,"do macro",mactab[x].kwd,0);
3040:
3041: /* Clear old %0..%9 arguments */
3042:
3043: addmac("%0",mactab[x].kwd); /* Define %0 = name of macro */
3044: varnam[0] = '%';
3045: varnam[2] = '\0';
3046: for (y = 1; y < 10; y++) { /* Clear args %1..%9 */
3047: varnam[1] = y + '0';
3048: delmac(varnam);
3049: }
3050:
3051: /* Assign the new args one word per arg, allowing braces to group words */
3052:
3053: p = s; /* Pointer to beginning of arg */
3054: b = 0; /* Flag for outer brace removal */
3055: x = 0; /* Flag for in-word */
3056: y = 0; /* Brace nesting level */
3057: z = 0; /* Argument counter, 0 thru 9 */
3058:
3059: while (1) { /* Go thru argument list */
3060: if (!s || (*s == '\0')) { /* No more characters? */
3061: if (x != 0) {
3062: if (z == 9) break; /* Only go up to 9. */
3063: z++; /* Count it. */
3064: varnam[1] = z + '0'; /* Assign last argument */
3065: addmac(varnam,p);
3066: break; /* And get out. */
3067: } else break;
3068: }
3069: if (x == 0 && *s == ' ') { /* Eat leading blanks */
3070: s++;
3071: continue;
3072: } else if (*s == '{') { /* An opening brace */
3073: if (x == 0 && y == 0) { /* If leading brace */
3074: p = s+1; /* point past it */
3075: b = 1; /* and flag that we did this */
3076: }
3077: x = 1; /* Flag that we're in a word */
3078: y++; /* Count the brace. */
3079: } else if (*s == '}') { /* A closing brace. */
3080: y--; /* Count it. */
3081: if (y == 0 && b != 0) { /* If it matches the leading brace */
3082: *s = ' '; /* change it to a space */
3083: b = 0; /* and we're not in braces any more */
3084: } else if (y < 0) x = 1; /* otherwise just start a new word. */
3085: } else if (*s != ' ') { /* Nonspace means we're in a word */
3086: if (x == 0) p = s; /* Mark the beginning */
3087: x = 1; /* Set in-word flag */
3088: }
3089: /* If we're not inside a braced quantity, and we are in a word, and */
3090: /* we have hit a space, then we have an argument to assign. */
3091: if ((y < 1) && (x != 0) && (*s == ' ')) {
3092: *s = '\0'; /* terminate the arg with null */
3093: x = 0; /* say we're not in a word any more */
3094: y = 0; /* start braces off clean again */
3095: if (z == 9) break; /* Only go up to 9. */
3096: z++; /* count this arg */
3097: varnam[1] = z + '0'; /* compute its name */
3098: addmac(varnam,p); /* add it to the macro table */
3099: p = s+1;
3100: }
3101: s++; /* Point past this character */
3102: }
3103: if ((z == 0) && (y > 1)) { /* Extra closing brace(s) at end */
3104: z++;
3105: varnam[1] = z + '0'; /* compute its name */
3106: addmac(varnam,p); /* Add rest of line to last arg */
3107: }
3108: macargc[maclvl] = z + 1; /* For ARGC variable */
3109: return(1); /* DO command succeeded */
3110: }
3111:
3112: /* Insert "literal" quote around each comma-separated command to prevent */
3113: /* its premature expansion. Only do this if object command is surrounded */
3114: /* by braces. */
3115:
3116: static char* flit = "\\flit(";
3117:
3118: int
3119: litcmd(src,dest) char **src, **dest; {
3120: int bc = 0, pp = 0;
3121: char *s, *lp, *ss;
3122:
3123: s = *src;
3124: lp = *dest;
3125:
3126: while (*s == SP) s++; /* strip extra leading spaces */
3127: if (*s == '{') {
3128:
3129: pp = 0; /* paren counter */
3130: bc = 1; /* count leading brace */
3131: *lp++ = *s++; /* copy it */
3132: while (*s == SP) s++; /* strip interior leading spaces */
3133: ss = flit; /* point to "\flit(" */
3134: while (*lp++ = *ss++) ; /* copy it */
3135: lp--; /* back up over null */
3136: while (*s) { /* go thru rest of text */
3137: ss = flit; /* point back to start of "\flit(" */
3138: if (*s == '{') bc++; /* count brackets */
3139: if (*s == '(') pp++; /* and parens */
3140: if (*s == ')') pp--;
3141: if (*s == '}') { /* Closing brace. */
3142: if (--bc == 0) { /* Final one? */
3143: *lp++ = ')'; /* Add closing paren for "\flit()" */
3144: *lp++ = *s++;
3145: break;
3146: }
3147: }
3148: if (*s == ',' && pp == 0) { /* comma not inside of parens */
3149: *lp++ = ')'; /* closing ) of \flit( */
3150: *lp++ = ','; /* insert the comma */
3151: while (*lp++ = *ss++) ; /* start new "\flit(" */
3152: lp--; /* back up over null */
3153: s++; /* skip over comma in source string */
3154: while (*s++ == SP); /* eat leading spaces again. */
3155: s--; /* back up over nonspace */
3156: continue;
3157: }
3158: *lp++ = *s++; /* Copy anything but comma here. */
3159: }
3160: *lp = NUL;
3161: } else { /* No brackets around, */
3162: while (*lp++ = *s++) ; /* just copy. */
3163: lp--;
3164: }
3165: *src = s;
3166: *dest = lp;
3167: if (bc) return(-1);
3168: else return(0);
3169: }
3170: #endif /* NOSPL */
3171:
3172: int
3173: docd() { /* Do the CD command */
3174: int x;
3175: char *s;
3176:
3177: #ifdef AMIGA
3178: if ((x = cmtxt("Name of local directory, or carriage return","",&s,
3179: xxstring)) < 0)
3180: return(x);
3181: /* if no name, just print directory name */
3182: if (*s) {
3183: if (chdir(s)) {
3184: cwdf = success = 0;
3185: perror(s);
3186: }
3187: success = cwdf = 1;
3188: }
3189: if (getcwd(line, LINBUFSIZ) == NULL)
3190: printf("Current directory name not available.\n");
3191: else
3192: if (pflag &&
3193: #ifndef NOSPL
3194: cmdlvl == 0
3195: #else
3196: tlevel < 0
3197: #endif /* NOSPL */
3198: ) printf("%s\n", line);
3199: #else
3200: if ((x = cmdir("Name of local directory, or carriage return",homdir,&s,
3201: xxstring)) < 0 )
3202: return(x);
3203: if (x == 2) {
3204: printf("?Wildcards not allowed in directory name\n");
3205: return(-9);
3206: }
3207: #ifdef OS2
3208: if ( s!=NUL ) {
3209: if ((int)strlen(s)>=2 && s[1]==':') { /* Disk specifier */
3210: if (zchdsk(*s)) { /* Change disk successful */
3211: if ( (int)strlen(s)>=3 & ( s[2]==CMDQ || isalnum(s[2]) ) ) {
3212: if (chdir(s)) perror(s);
3213: }
3214: } else {
3215: cwdf = success = 0;
3216: perror(s);
3217: }
3218: } else if (chdir(s)) {
3219: cwdf = success = 0;
3220: perror(s);
3221: }
3222: }
3223: printf("%s\n", zgtdir());
3224: success = cwdf = 1;
3225: #else /* Not OS2 */
3226: if (! zchdir(s)) {
3227: cwdf = 0;
3228: perror(s);
3229: } else cwdf = 1;
3230: #ifndef MAC
3231: zsyscmd(PWDCMD); /* assume this works... */
3232: #endif /* MAC */
3233: #endif /* OS2 */
3234: #endif /* AMIGA */
3235: return(cwdf);
3236: }
3237:
3238: VOID
3239: fixcmd() { /* Fix command parser after interruption */
3240: dostop(); /* Back to top level (also calls conint()). */
3241: bgchk(); /* Check background status */
3242: if (*psave) { /* If old prompt saved, */
3243: cmsetp(psave); /* restore it. */
3244: *psave = NUL;
3245: }
3246: success = 0; /* Tell parser last command failed */
3247: }
3248:
3249: VOID
3250: prtopt(s) char *s; { /* Print an option */
3251: static int x = 0; /* (used by SHOW VER) */
3252: int y; /* Does word wrap. */
3253: if (!s) { x = 0; return; } /* Call with null pointer to */
3254: y = (int)strlen(s); /* reset horizontal position. */
3255: x += y;
3256: if (x > 79) {
3257: printf("\n%s",s);
3258: x = y;
3259: } else printf("%s",s);
3260: }
3261:
3262: #endif /* NOICP */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.