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