![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckuus4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / ckermit|
Return to ckuus4.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / ckermit |
1.1 root 1: #ifndef NOICP
2:
3: /* C K U U S 4 -- "User Interface" for Unix Kermit, part 4 */
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: /*
17: File ckuus4.c -- Functions moved from other ckuus*.c modules to even
18: out their sizes.
19: */
20: #include "ckcdeb.h"
21: #include "ckcasc.h"
22: #include "ckcker.h"
23: #include "ckuusr.h"
24: #include "ckuver.h"
25: #include "ckcnet.h" /* Network symbols */
26:
27: #ifndef NOCSETS /* Character sets */
28: #include "ckcxla.h"
29: #endif /* NOCSETS */
30:
31: #ifndef AMIGA
32: #ifndef MAC
33: #include <signal.h>
34: #include <setjmp.h>
35: #endif /* MAC */
36: #endif /* AMIGA */
37:
38: #ifdef SUNX25
39: extern int revcall, closgr, cudata, npadx3;
40: int x25ver;
41: extern char udata[MAXCUDATA];
42: extern CHAR padparms[MAXPADPARMS+1];
43: extern struct keytab padx3tab[];
44: #endif /* SUNX25 */
45:
46: #ifdef NETCONN
47: extern char ipaddr[];
48: #ifdef TNCODE
49: extern int tn_duplex, tn_nlm;
50: extern char *tn_term;
51: #endif /* TNCODE */
52: #endif /* NETCONN */
53:
54: #ifndef NOSPL
55: /* This needs to be internationalized... */
56: static
57: char *months[] = {
58: "Jan", "Feb", "Mar", "Apr", "May", "Jun",
59: "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
60: };
61:
62: static
63: char *wkdays[] = {
64: "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
65: };
66: #endif /* NOSPL */
67:
68: #ifdef UNIX
69: extern int ttyfd;
70: #endif /* UNIX */
71: #ifdef OS2
72: extern int ttyfd;
73: #endif /* OS2 */
74:
75: _PROTOTYP( static VOID shods, (char *) );
76:
77: extern struct keytab colxtab[];
78:
79: extern CHAR
80: eol, mypadc, mystch, padch, seol, stchr;
81:
82: extern char
83: kermrc[], ttname[],
84: *ckxsys, *versio, **xargv, *zinptr;
85:
86: extern int
87: atcapr, autopar, bctr, bctu, bgset, bigrbsiz, bigsbsiz, binary, carrier,
88: cdtimo, cmask, crunched, delay, duplex, ebq, ebqflg, escape, flow, fmask,
89: fncact, fncnv, incase, inecho, keep, local, lscapr, lscapu,
90: maxrps, maxsps, maxtry, mdmspd, mdmtyp, mypadn, ncolx,
91: nettype, network, nmac, noinit, npad, parity, pktlog, pkttim, rcflag,
92: retrans, rpackets, rptflg, rptq, rtimo, seslog, sessft, sosi, spackets,
93: spsiz, spsizf, spsizr, srvtim, stayflg, success, timeouts, tralog,
94: tsecs, ttnproto, turn, turnch, urpsiz, wmax, wslotn, wslotr, xargc, xargs,
95: zincnt, fdispla, tlevel, xitsta, spmax, insilence, cmdmsk, timint, timef;
96:
97: #ifdef VMS
98: extern int frecl;
99: #endif /* VMS */
100:
101: extern long
102: ffc, filcnt, rptn, speed, tfc, tlci, tlco, vernum;
103:
104: #ifndef NOSPL
105: extern char fspec[], myhost[];
106: #endif /* NOSPL */
107:
108: extern char *tfnam[]; /* Command file names */
109:
110: #ifdef DCMDBUF
111: extern struct cmdptr *cmdstk;
112: extern char *line;
113: #else
114: extern struct cmdptr cmdstk[];
115: extern char line[];
116: #endif /* DCMDBUF */
117:
118: extern char pktfil[], /* Packet log file name */
119: #ifdef DEBUG
120: debfil[], /* Debug log file name */
121: #endif /* DEBUG */
122: #ifdef TLOG
123: trafil[], /* Transaction log file name */
124: #endif /* TLOG */
125: sesfil[]; /* Session log file name */
126:
127: #ifndef NOXMIT /* TRANSMIT command variables */
128: extern char xmitbuf[];
129: extern int xmitf, xmitl, xmitp, xmitx, xmits, xmitw;
130: #endif /* NOXMIT */
131:
132: #ifndef NOSPL
133: /* Script programming language items */
134: extern char **a_ptr[]; /* Arrays */
135: extern int a_dim[];
136: extern char inpbuf[], inchar[]; /* Buffers for INPUT and REINPUT */
137: extern char *inpbp; /* And pointer to same */
138: static char *inpbps = inpbuf; /* And another */
139: extern int incount; /* INPUT character count */
140: extern int maclvl; /* Macro invocation level */
141: extern struct mtab *mactab; /* Macro table */
142: extern char *mrval[];
143: extern int macargc[], cmdlvl;
144: extern char *m_arg[MACLEVEL][10]; /* You have to put in the dimensions */
145: extern char *g_var[GVARS]; /* for external 2-dimensional arrays. */
146: #ifdef DCMDBUF
147: extern int *count;
148: #else
149: extern int count[];
150: #endif /* DCMDBUF */
151: #endif /* NOSPL */
152:
153: #ifdef UNIX
154: extern int haslock; /* For UUCP locks */
155: extern char flfnam[];
156: extern int maxnam, maxpath; /* Longest name, path length */
157: #endif /* UNIX */
158:
159: #ifndef NODIAL
160: /* DIAL-related variables */
161: extern int nmdm, dialhng, dialtmo, dialksp, dialdpy, dialmnp, dialmhu;
162: extern char *dialnum, *dialdir, *dialnpr;
163: extern struct keytab mdmtab[];
164: #endif /* NODIAL */
165:
166: #ifndef NOCSETS
167: /* Translation stuff */
168: extern int fcharset, tcharset, tslevel, language, nlng, tcsr, tcsl;
169: extern struct keytab lngtab[];
170: extern struct csinfo fcsinfo[], tcsinfo[];
171: extern struct langinfo langs[];
172: #ifdef CK_ANSIC
173: extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* Character set */
174: extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* translation functions */
175: #else
176: extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])(); /* Character set */
177: extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(); /* translation functions. */
178: #endif /* CK_ANSIC */
179: #endif /* NOCSETS */
180:
181: #ifndef NOSPL
182: /* Built-in variable names, maximum length VNAML (20 characters) */
183:
184: struct keytab vartab[] = {
185: "argc", VN_ARGC, 0,
186: "args", VN_ARGS, 0,
187: "cmdfile", VN_CMDF, 0,
188: "cmdlevel", VN_CMDL, 0,
189: "cmdsource", VN_CMDS, 0,
190: "count", VN_COUN, 0,
191: "cpu", VN_CPU, 0,
192: "date", VN_DATE, 0,
193: "day", VN_DAY, 0, /* Edit 181 */
194: "directory", VN_DIRE, 0,
195: "exitstatus",VN_EXIT, 0,
196: "filespec", VN_FILE, 0,
197: "fsize", VN_FFC, 0,
198: "home", VN_HOME, 0,
199: "host", VN_HOST, 0,
200: "input", VN_IBUF, 0,
201: "inchar", VN_ICHR, 0,
202: "incount", VN_ICNT, 0,
203: "line", VN_LINE, 0,
204: "local", VN_LCL, 0,
205: "macro", VN_MAC, 0,
206: "ndate", VN_NDAT, 0,
207: "nday", VN_NDAY, 0,
208: "ntime", VN_NTIM, 0,
209: "platform", VN_SYSV, 0,
210: "program", VN_PROG, 0,
211: "return", VN_RET, 0,
212: "speed", VN_SPEE, 0,
213: "status", VN_SUCC, 0,
214: "system", VN_SYST, 0,
215: "tfsize", VN_TFC, 0,
216: "time", VN_TIME, 0,
217: #ifdef UNIX
218: "ttyfd", VN_TTYF, 0,
219: #endif /* UNIX */
220: #ifdef OS2
221: "ttyfd", VN_TTYF, 0,
222: #endif /* OS2 */
223: "version", VN_VERS, 0
224: };
225: int nvars = (sizeof(vartab) / sizeof(struct keytab));
226: #endif /* NOSPL */
227:
228: #ifndef NOSPL
229: struct keytab fnctab[] = { /* Function names */
230: "character", FN_CHR, 0, /* Character from code */
231: "code", FN_COD, 0, /* Code from character */
232: "contents", FN_CON, 0, /* Definition (contents) of variable */
233: "definition", FN_DEF, 0, /* Return definition of given macro */
234: "evaluate", FN_EVA, 0, /* Evaluate given arith expression */
235: "execute", FN_EXE, 0, /* Execute given macro */
236: "files", FN_FC, 0, /* File count */
237: "index", FN_IND, 0, /* Index (string search) */
238: "length", FN_LEN, 0, /* Return length of argument */
239: "literal", FN_LIT, 0, /* Return argument literally */
240: "lower", FN_LOW, 0, /* Return lowercased argument */
241: "lpad", FN_LPA, 0, /* Return left-padded argument */
242: "maximum", FN_MAX, 0, /* Return maximum of two arguments */
243: "minimim", FN_MIN, 0, /* Return minimum of two arguments */
244: #ifdef COMMENT
245: /* not needed because \feval() has it */
246: "modulus", FN_MOD, 0, /* Return modulus of two arguments */
247: #endif /* COMMENT */
248: "nextfile", FN_FIL, 0, /* Next file in list */
249: "repeat", FN_REP, 0, /* Repeat argument given # of times */
250: #ifndef NOFRILLS
251: "reverse", FN_REV, 0, /* Reverse the argument string */
252: #endif /* NOFRILLS */
253: "right", FN_RIG, 0, /* Rightmost n characters */
254: "rpad", FN_RPA, 0, /* Right-pad the argument */
255: "substring", FN_SUB, 0, /* Extract substring from argument */
256: "upper", FN_UPP, 0 /* Return uppercased argument */
257: };
258: int nfuncs = (sizeof(fnctab) / sizeof(struct keytab));
259: #endif /* NOSPL */
260:
261: #ifndef NOSPL /* Buffer for expansion of */
262: #define VVBUFL 60 /* built-in variables. */
263: char vvbuf[VVBUFL];
264: #endif /* NOSPL */
265:
266: struct keytab disptb[] = { /* Log file disposition */
267: "append", 1, 0,
268: "new", 0, 0
269: };
270:
271: /* P R E S C A N -- Quick look thru command-line args for init file name */
272: /* Also for -d (debug), -z (force foreground), -S (stay) */
273:
274: VOID
275: prescan() {
276: int yargc; char **yargv;
277: char x;
278:
279: yargc = xargc;
280: yargv = xargv;
281: strcpy(kermrc,KERMRC); /* Default init file name */
282: #ifndef NOCMDL
283: while (--yargc > 0) { /* Look for -y on command line */
284: yargv++;
285: if (**yargv == '-') { /* Option starting with dash */
286: x = *(*yargv+1); /* Get option letter */
287: if (x == 'Y') { /* Is it Y (= no init file?) */
288: noinit = 1;
289: continue;
290: } else if (x == 'y') { /* Is it y? */
291: yargv++, yargc--; /* Yes, count and check argument */
292: if (yargc < 1) fatal("missing name in -y");
293: strcpy(kermrc,*yargv); /* Replace init file name */
294: rcflag = 1; /* Flag that this has been done */
295: continue;
296: } else if (x == 'd') { /* Do this early as possible! */
297: debopn("debug.log",0);
298: continue;
299: } else if (x == 'z') { /* = SET BACKGROUND OFF */
300: bgset = 0;
301: continue;
302: } else if (x == 'S') {
303: stayflg = 1;
304: continue;
305: }
306: }
307: }
308: #endif /* NOCMDL */
309: }
310:
311: static int tr_int; /* Flag if TRANSMIT interrupted */
312:
313: #ifndef MAC
314: SIGTYP
315: trtrap(foo) int foo; { /* TRANSMIT interrupt trap */
316: #ifdef __EMX__
317: signal(SIGINT, SIG_ACK);
318: #endif
319: tr_int = 1; /* (Need arg for ANSI C) */
320: SIGRETURN;
321: }
322: #endif /* MAC */
323: /* G E T T C S -- Get Transfer (Intermediate) Character Set */
324:
325: /*
326: Given two file character sets, this routine picks out the appropriate
327: "transfer" character set to use for translating between them.
328: The transfer character set number is returned.
329:
330: Translation between two file character sets is done, for example,
331: by the CONNECT, TRANSMIT, and TRANSLATE commands.
332:
333: Translation between Kanji character sets is not yet supported.
334: */
335: int
336: gettcs(cs1,cs2) int cs1, cs2; {
337: #ifdef NOCSETS /* No character-set support */
338: return(0); /* so no translation */
339: #else
340: int tcs = TC_TRANSP;
341: #ifdef KANJI
342: /* Kanji not supported yet */
343: if (fcsinfo[cs1].alphabet == AL_JAPAN ||
344: fcsinfo[cs2].alphabet == AL_JAPAN )
345: tcs = TC_TRANSP;
346: else
347: #endif /* KANJI */
348: #ifdef CYRILLIC
349: /*
350: I can't remember why we don't test both sets here, but I think there
351: must have been a reason...
352: */
353: if (fcsinfo[cs2].alphabet == AL_CYRIL)
354: tcs = TC_CYRILL;
355: else
356: #endif /* CYRILLIC */
357: #ifdef LATIN2
358: if (cs1 == FC_2LATIN || cs1 == FC_2LATIN ||
359: cs1 == FC_CP852 || cs1 == FC_CP852 )
360: tcs = TC_2LATIN;
361: else
362: #endif /* LATIN2 */
363: tcs = TC_1LATIN;
364: return(tcs);
365: #endif /* NOCSETS */
366: }
367:
368: #ifndef NOXMIT
369: /* T R A N S M I T -- Raw upload */
370:
371: /* Obey current line, duplex, parity, flow, text/binary settings. */
372: /* Returns 0 upon apparent success, 1 on obvious failure. */
373:
374: /***
375: Things to add:
376: . Make both text and binary mode obey set file bytesize.
377: . Maybe allow user to specify terminators other than CR?
378: . Maybe allow user to specify prompts other than single characters?
379: ***/
380:
381: /* T R A N S M I T -- Raw upload */
382:
383: /* s is the filename, t is the turnaround (prompt) character */
384:
385: /*
386: Maximum number of characters to buffer.
387: Must be less than LINBUFSIZ
388: */
389: #define XMBUFS 120
390:
391: int
392: #ifdef CK_ANSIC
393: transmit(char * s, char t)
394: #else
395: transmit(s,t) char *s; char t;
396: #endif /* CK_ANSIC */
397: /* transmit */ {
398: #ifdef MAC
399: extern char sstate;
400: int count = 100;
401: #else
402: SIGTYP (* oldsig)(); /* For saving old interrupt trap. */
403: #endif /* MAC */
404: long zz;
405: int z = 1; /* Return code. 0=fail, 1=succeed. */
406: int x, c, i; /* Workers... */
407: int myflow;
408: CHAR csave;
409: char *p;
410:
411: #ifndef NOCSETS
412: int tcs = TC_TRANSP; /* Intermediate (xfer) char set */
413: int langsv = L_USASCII; /* Save current language */
414:
415: _PROTOTYP ( CHAR (*sxo), (CHAR) ) = NULL; /* Translation functions */
416: _PROTOTYP ( CHAR (*rxo), (CHAR) ) = NULL;
417: _PROTOTYP ( CHAR (*sxi), (CHAR) ) = NULL;
418: _PROTOTYP ( CHAR (*rxi), (CHAR) ) = NULL;
419: #endif /* NOCSETS */
420:
421: if (zopeni(ZIFILE,s) == 0) { /* Open the file to be transmitted */
422: printf("?Can't open file %s\n",s);
423: return(0);
424: }
425: x = -1; /* Open the communication line */
426: if (ttopen(ttname,&x,mdmtyp,cdtimo) < 0) { /* (no harm if already open) */
427: printf("Can't open device %s\n",ttname);
428: return(0);
429: }
430: zz = x ? speed : -1L;
431: if (binary) { /* Binary file transmission */
432: myflow = (flow == FLO_XONX) ? FLO_NONE : flow;
433: if (ttvt(zz,myflow) < 0) { /* So no Xon/Xoff! */
434: printf("Can't condition line\n");
435: return(0);
436: }
437: } else {
438: if (ttpkt(zz,flow,parity) < 0) { /* Put the line in "packet mode" */
439: printf("Can't condition line\n"); /* so Xon/Xoff will work, etc. */
440: return(0);
441: }
442: }
443:
444: #ifndef NOCSETS
445: tcs = gettcs(tcsr,tcsl); /* Get intermediate set. */
446:
447: /* Set up character set translations */
448: if (binary == 0) {
449:
450: if (tcsr == tcsl || binary) { /* Remote and local sets the same? */
451: sxo = rxo = NULL; /* Or file type is not text? */
452: sxi = rxi = NULL;
453: } else { /* Otherwise, set up */
454: sxo = xls[tcs][tcsl]; /* translation function */
455: rxo = xlr[tcs][tcsr]; /* pointers for output functions */
456: sxi = xls[tcs][tcsr]; /* and for input functions. */
457: rxi = xlr[tcs][tcsl];
458: }
459: /*
460: This is to prevent use of zmstuff() and zdstuff() by translation functions.
461: They only work with disk i/o, not with communication i/o. Luckily Russian
462: translation functions don't do any stuffing...
463: */
464: langsv = language;
465: language = L_USASCII;
466: }
467: #endif /* NOCSETS */
468:
469: i = 0; /* Beginning of buffer. */
470: #ifndef MAC
471: #ifndef AMIGA
472: oldsig = signal(SIGINT, trtrap); /* Save current interrupt trap. */
473: #endif /* AMIGA */
474: #endif /* MAC */
475: tr_int = 0; /* Have not been interrupted (yet). */
476: z = 1; /* Return code presumed good. */
477: #ifdef VMS
478: conres();
479: #endif /* VMS */
480:
481: c = 0; /* Initial condition */
482: while (c > -1) { /* Loop for all characters in file */
483: #ifdef MAC
484: /*
485: * It is expensive to run the miniparser so don't do it for
486: * every character.
487: */
488: if (--count < 0) {
489: count = 100;
490: miniparser(1);
491: if (sstate == 'a') {
492: sstate = '\0';
493: z = 0;
494: break;
495: }
496: }
497: #else /* Not MAC */
498: if (tr_int) { /* Interrupted? */
499: printf("^C...\n"); /* Print message */
500: z = 0;
501: break;
502: }
503: #endif /* MAC */
504: c = zminchar(); /* Get a file character */
505: debug(F101,"transmit char","",c);
506: if (c == -1) /* Test for end-of-file */
507: break;
508: c &= fmask; /* Apply SET FILE BYTESIZE mask */
509:
510: if (binary) { /* If binary file, */
511: if (ttoc(dopar((char) c)) < 0) { /* else just send the char */
512: printf("?Can't transmit character\n");
513: z = 0;
514: break;
515: }
516: if (xmitw) msleep(xmitw); /* Pause if requested */
517: if (xmitx) { /* SET TRANSMIT ECHO ON? */
518: if (duplex) { /* Yes, for half duplex */
519: conoc((char)(c & cmdmsk)); /* echo locally. */
520: } else { /* For full duplex, */
521: int i, n; /* display whatever is there. */
522: n = ttchk(); /* How many chars are waiting? */
523: for (i = 0; i < n; i++) { /* Read and echo that many. */
524: x = ttinc(1); /* Timed read just in case. */
525: if (x > -1) { /* If no timeout */
526: if (parity) x &= 0x7f;
527: conoc((char)(x & cmdmsk)); /* display the char, */
528: } else break; /* otherwise stop reading. */
529: }
530: }
531: } else ttflui(); /* Not echoing, just flush input. */
532:
533: } else { /* Text mode, line at a time. */
534:
535: if (c == '\n') { /* Got a line */
536: if (i == 0) { /* Blank line? */
537: if (xmitf) /* Yes, insert fill if asked. */
538: line[i++] = dopar((char) xmitf);
539: }
540: if (i == 0 || line[i-1] != dopar(CR))
541: line[i++] = dopar(CR); /* Terminate it with CR */
542: if (
543: xmitl
544: #ifdef TNCODE
545: || (network && ttnproto == NP_TELNET && tn_nlm)
546: #endif /* TNCODE */
547: )
548: line[i++] = dopar(LF); /* Include LF if asked */
549:
550: } else if (c != -1) { /* Not a newline, regular character */
551: csave = c; /* Remember untranslated version */
552: #ifndef NOCSETS
553: /* Translate character sets */
554: if (sxo) c = (*sxo)((CHAR)c); /* From local to intermediate */
555: if (rxo) c = (*rxo)((CHAR)c); /* From intermediate to remote */
556: #endif /* NOCSETS */
557:
558: if (xmits && parity && (c & 0200)) { /* If shifting */
559: line[i++] = dopar(SO); /* needs to be done, */
560: line[i++] = dopar((char)c); /* do it here, */
561: line[i++] = dopar(SI); /* crudely. */
562: } else {
563: line[i++] = dopar((char)c); /* else, just char itself */
564: }
565: }
566:
567: /* Send characters if buffer full, or at end of line, or at end of file */
568:
569: if (i >= XMBUFS || c == '\n' || c == -1) {
570: p = line;
571: line[i] = '\0';
572: debug(F111,"transmit buf",p,i);
573: if (ttol((CHAR *)p,i) < 0) { /* try to send it. */
574: printf("Can't send buffer\n");
575: z = 0;
576: break;
577: }
578: i = 0; /* Reset buffer pointer. */
579:
580: /* Worry about echoing here. "xmitx" is SET TRANSMIT ECHO flag. */
581:
582: if (duplex && xmitx) { /* If local echo, echo it */
583: if (parity || cmdmsk == 0x7f) { /* Strip off high bits */
584: char *s = p; /* if necessary */
585: while (*s) {
586: *s &= 0x7f;
587: s++;
588: }
589: conoll(p);
590: }
591: }
592: if (xmitw) /* Give receiver time to digest. */
593: msleep(xmitw);
594: if (t != 0 && c == '\n') { /* Want a turnaround character */
595: x = 0; /* Wait for it */
596: while (x != t) {
597: if ((x = ttinc(1)) < 0) break;
598: if (xmitx && !duplex) { /* Echo any echoes */
599: if (parity) x &= 0x7f;
600: #ifndef NOCSETS
601: if (sxi) x = (*sxi)((CHAR)x); /* But translate */
602: if (rxi) x = (*rxi)((CHAR)x); /* them first... */
603: #endif /* NOCSETS */
604: conoc((char) x);
605: }
606: }
607: } else if (xmitx && !duplex) { /* Otherwise, */
608: while (ttchk() > 0) { /* echo for as long as */
609: if ((x = ttinc(0)) < 0) break; /* anything is there. */
610: if (parity) x &= 0x7f;
611: #ifndef NOCSETS
612: if (sxi) x = (*sxi)((CHAR)x); /* Translate first */
613: if (rxi) x = (*rxi)((CHAR)x);
614: #endif /* NOCSETS */
615: conoc((char)x);
616: }
617: } else ttflui(); /* Otherwise just flush input buffer */
618: } /* End of buffer-dumping block */
619: } /* End of text mode */
620: } /* End of character-reading loop */
621:
622: if (*xmitbuf) { /* Anything to send at EOF? */
623: p = xmitbuf; /* Yes, point to string. */
624: while (*p) /* Send it. */
625: ttoc(dopar(*p++)); /* Don't worry about echo here. */
626: }
627:
628: #ifndef AMIGA
629: #ifndef MAC
630: signal(SIGINT,oldsig); /* Put old signal action back. */
631: #endif /* MAC */
632: #endif /* AMIGA */
633: #ifdef VMS
634: concb(escape); /* Put terminal back, */
635: #endif /* VMS */
636: zclose(ZIFILE); /* Close file, */
637: #ifndef NOCSETS
638: language = langsv; /* restore language, */
639: #endif /* NOCSETS */
640: return(z); /* and return successfully. */
641: }
642: #endif /* NOXMIT */
643:
644: #ifdef MAC
645: /*
646: This code is not used any more, except on the Macintosh. Instead we call
647: system to do the typing. Revive this code if your system can't be called
648: to do this.
649: */
650:
651: /* D O T Y P E -- Type a file */
652:
653: int
654: dotype(s) char *s; {
655:
656: #ifdef MAC
657: extern char sstate;
658: int count = 100;
659: #else
660: SIGTYP (* oldsig)(); /* For saving old interrupt trap. */
661: #endif /* MAC */
662: int z; /* Return code. */
663: int c; /* Worker. */
664:
665: if (zopeni(ZIFILE,s) == 0) { /* Open the file to be typed */
666: printf("?Can't open %s\n",s);
667: return(0);
668: }
669: #ifndef AMIGA
670: #ifndef MAC
671: oldsig = signal(SIGINT, trtrap); /* Save current interrupt trap. */
672: #endif /* MAC */
673: #endif /* AMIGA */
674:
675: tr_int = 0; /* Have not been interrupted (yet). */
676: z = 1; /* Return code presumed good. */
677:
678: #ifdef VMS
679: conoc(CR); /* On VMS, display blank line first */
680: conoc(LF);
681: conres(); /* So Ctrl-C/Y will work */
682: #endif /* VMS */
683: while ((c = zminchar()) != -1) { /* Loop for all characters in file */
684: #ifdef MAC
685: /*
686: * It is expensive to run the miniparser so don't do it for
687: * every character.
688: */
689: if (--count < 0) {
690: count = 100;
691: miniparser(1);
692: if (sstate == 'a') {
693: sstate = '\0';
694: z = 0;
695: break;
696: }
697: }
698: putchar(c);
699: #else /* Not MAC */
700: if (tr_int) { /* Interrupted? */
701: printf("^C...\n"); /* Print message */
702: z = 0;
703: break;
704: }
705: conoc(c); /* Echo character on screen */
706: #endif /* MAC */
707: }
708: #ifndef AMIGA
709: #ifndef MAC
710: signal(SIGINT,oldsig); /* put old signal action back. */
711: #endif /* MAC */
712: #endif /* AMIGA */
713:
714: tr_int = 0;
715: #ifdef VMS
716: concb(escape); /* Get back in command-parsing mode, */
717: #endif /* VMS */
718: zclose(ZIFILE); /* close file, */
719: return(z); /* and return successfully. */
720: }
721: #endif /* MAC */
722:
723: #ifndef NOCSETS
724:
725: _PROTOTYP( CHAR (*sxx), (CHAR) ); /* Local translation function */
726: _PROTOTYP( CHAR (*rxx), (CHAR) ); /* Local translation function */
727: _PROTOTYP( CHAR zl1as, (CHAR) ); /* Latin-1 to ascii */
728: _PROTOTYP( CHAR xl1as, (CHAR) ); /* ditto */
729:
730: /* X L A T E -- Translate a local file from one character set to another */
731:
732: /*
733: Translates input file (fin) from character set csin to character set csout
734: and puts the result in the output file (fout). The two character sets are
735: file character sets from fcstab.
736: */
737:
738: int
739: xlate(fin, fout, csin, csout) char *fin, *fout; int csin, csout; {
740:
741: #ifndef MAC
742: SIGTYP (* oldsig)(); /* For saving old interrupt trap. */
743: #endif /* MAC */
744: int filecode; /* Code for output file */
745:
746: int z = 1; /* Return code. */
747: int c, tcs; /* Workers */
748:
749: if (zopeni(ZIFILE,fin) == 0) { /* Open the file to be translated */
750: printf("?Can't open input file %s\n",fin);
751: return(0);
752: }
753: #ifdef MAC
754: /*
755: If user specified no output file, it goes to the screen. For the Mac,
756: this must be done a special way (result goes to a new window); the Mac
757: doesn't have a "controlling terminal" device name.
758: */
759: filecode = !strcmp(fout,CTTNAM) ? ZCTERM : ZOFILE;
760: #else
761: filecode = ZOFILE;
762: #endif /* MAC */
763:
764: if (zopeno(filecode,fout,NULL,NULL) == 0) { /* And the output file */
765: printf("?Can't open output file %s\n",fout);
766: return(0);
767: }
768: #ifndef AMIGA
769: #ifndef MAC
770: oldsig = signal(SIGINT, trtrap); /* Save current interrupt trap. */
771: #endif /* MAC */
772: #endif /* AMIGA */
773:
774: tr_int = 0; /* Have not been interrupted (yet). */
775: z = 1; /* Return code presumed good. */
776:
777: tcs = gettcs(csin,csout); /* Get intermediate set. */
778:
779: printf("%s (%s) => %s (%s)\n", /* Say what we're doing. */
780: fin, fcsinfo[csin].name,
781: fout,fcsinfo[csout].name
782: );
783: printf("via %s", tcsinfo[tcs].name);
784: if (language)
785: printf(", language: %s\n",langs[language].description);
786: printf("\n\n");
787:
788: if (csin == csout) { /* Input and output sets the same? */
789: sxx = rxx = NULL; /* If so, no translation. */
790: } else { /* Otherwise, set up */
791: sxx = xls[tcs][csin]; /* translation function */
792: rxx = xlr[tcs][csout]; /* pointers. */
793: if (rxx == zl1as) rxx = xl1as;
794: }
795: while ((c = zminchar()) != -1) { /* Loop for all characters in file */
796: if (tr_int) { /* Interrupted? */
797: printf("^C...\n"); /* Print message */
798: z = 0;
799: break;
800: }
801: if (sxx) c = (*sxx)((CHAR)c); /* From fcs1 to tcs */
802: if (rxx) c = (*rxx)((CHAR)c); /* from tcs to fcs2 */
803:
804: if (zchout(ZOFILE,(char)c) < 0) { /* Output the translated character */
805: printf("File output error\n");
806: z = 0;
807: break;
808: }
809: }
810: #ifndef AMIGA
811: #ifndef MAC
812: signal(SIGINT,oldsig); /* put old signal action back. */
813: #endif /* MAC */
814: #endif /* AMIGA */
815:
816: tr_int = 0;
817: zclose(ZIFILE); /* close files, */
818: zclose(ZOFILE);
819: return(z); /* and return successfully. */
820: }
821: #endif /* NOCSETS */
822:
823: /* D O L O G -- Do the log command */
824:
825: int
826: dolog(x) int x; {
827: int y, disp; char *s;
828:
829: switch (x) {
830:
831: #ifdef DEBUG
832: case LOGD:
833: y = cmofi("Name of debugging log file","debug.log",&s,xxstring);
834: break;
835: #endif /* DEBUG */
836:
837: case LOGP:
838: y = cmofi("Name of packet log file","packet.log",&s,xxstring);
839: break;
840:
841: case LOGS:
842: y = cmofi("Name of session log file","session.log",&s,xxstring);
843: break;
844:
845: #ifdef TLOG
846: case LOGT:
847: y = cmofi("Name of transaction log file","transact.log",&s,
848: xxstring);
849: break;
850: #endif /* TLOG */
851:
852: default:
853: printf("\n?Unknown log designator - %d\n",x);
854: return(-2);
855: }
856: if (y < 0) return(y);
857:
858: strcpy(line,s);
859: s = line;
860: if ((y = cmkey(disptb,2,"Disposition","new",xxstring)) < 0)
861: return(y);
862: disp = y;
863: if ((y = cmcfm()) < 0) return(y);
864:
865: switch (x) {
866:
867: #ifdef DEBUG
868: case LOGD:
869: return(deblog = debopn(s,disp));
870: #endif /* DEBUG */
871:
872: case LOGP:
873: return(pktlog = pktopn(s,disp));
874:
875: case LOGS:
876: return(seslog = sesopn(s,disp));
877:
878: #ifdef TLOG
879: case LOGT:
880: return(tralog = traopn(s,disp));
881: #endif /* TLOG */
882:
883: default:
884: return(-2);
885: }
886: }
887:
888: int
889: pktopn(s,disp) char *s; int disp; {
890: extern char pktfil[];
891: static struct filinfo xx;
892: int y;
893:
894: zclose(ZPFILE);
895: if(s[0] == '\0') return(0);
896: if (disp) {
897: xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0;
898: xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = '\0';
899: xx.lblopts = 0;
900: y = zopeno(ZPFILE,s,NULL,&xx);
901: } else y = zopeno(ZPFILE,s,NULL,NULL);
902: if (y > 0)
903: strcpy(pktfil,s);
904: else
905: *pktfil = '\0';
906: return(y);
907: }
908:
909: int
910: traopn(s,disp) char *s; int disp; {
911: #ifdef TLOG
912: extern char trafil[];
913: static struct filinfo xx;
914: int y;
915:
916: zclose(ZTFILE);
917: if(s[0] == '\0') return(0);
918: if (disp) {
919: xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0;
920: xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = '\0';
921: xx.lblopts = 0;
922: y = zopeno(ZTFILE,s,NULL,&xx);
923: } else y = zopeno(ZTFILE,s,NULL,NULL);
924: if (y > 0) {
925: strcpy(trafil,s);
926: tlog(F110,"Transaction Log:",versio,0L);
927: #ifndef MAC
928: tlog(F100,ckxsys,"",0L);
929: #endif /* MAC */
930: ztime(&s);
931: tlog(F100,s,"",0L);
932: } else *trafil = '\0';
933: return(y);
934: #else
935: return(0);
936: #endif
937: }
938:
939: int
940: sesopn(s,disp) char * s; int disp; {
941: extern char sesfil[];
942: static struct filinfo xx;
943: int y;
944:
945: zclose(ZSFILE);
946: if(s[0] == '\0') return(0);
947: if (disp) {
948: xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0;
949: xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = '\0';
950: xx.lblopts = 0;
951: y = zopeno(ZSFILE,s,NULL,&xx);
952: } else y = zopeno(ZSFILE,s,NULL,NULL);
953: if (y > 0)
954: strcpy(sesfil,s);
955: else
956: *sesfil = '\0';
957: return(y);
958: }
959:
960: int
961: debopn(s,disp) char *s; int disp; {
962: #ifdef DEBUG
963: char *tp;
964: static struct filinfo xx;
965:
966: zclose(ZDFILE);
967:
968: if (disp) {
969: xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0;
970: xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = '\0';
971: xx.lblopts = 0;
972: deblog = zopeno(ZDFILE,s,NULL,&xx);
973: } else deblog = zopeno(ZDFILE,s,NULL,NULL);
974: if (deblog > 0) {
975: strcpy(debfil,s);
976: debug(F110,"Debug Log ",versio,0);
977: #ifndef MAC
978: debug(F100,ckxsys,"",0);
979: #endif /* MAC */
980: ztime(&tp);
981: debug(F100,tp,"",0);
982: } else *debfil = '\0';
983: return(deblog);
984: #else
985: return(0);
986: #endif
987: }
988:
989: #ifndef NOSHOW
990:
991: /* S H O P A R -- Show Parameters */
992:
993: #ifdef SUNX25
994: VOID
995: shox25() {
996: if (nettype == NET_SX25) {
997: printf("SunLink X.25 V%d.%d",x25ver / 10,x25ver % 10);
998: if (ttnproto == NP_X3) printf(", PAD X.3, X.28, X.29 protocol,");
999: printf("\n Reverse charge call %s",
1000: revcall ? "selected" : "not selected");
1001: printf (", Closed user group ");
1002: if (closgr > -1)
1003: printf ("%d",closgr);
1004: else
1005: printf ("not selected");
1006: printf (",");
1007: printf("\n Call user data %s.\n", cudata ? udata : "not selected");
1008: }
1009: }
1010: #endif /* SUNX25 */
1011:
1012: VOID
1013: shoparc() {
1014: int i; char *s;
1015: long zz;
1016:
1017: puts("Communications Parameters:");
1018:
1019: if (network) {
1020: printf(" Host: %s",ttname);
1021: } else {
1022: printf(" Line: %s, speed: ",ttname);
1023: if ((zz = ttgspd()) < 0) {
1024: printf("unknown");
1025: } else {
1026: if (speed == 8880) printf("75/1200"); else printf("%ld",zz);
1027: }
1028: }
1029: printf(", mode: ");
1030: if (local) printf("local"); else printf("remote");
1031: if (network == 0) {
1032: #ifndef NODIAL
1033: for (i = 0; i < nmdm; i++) {
1034: if (mdmtab[i].kwval == mdmtyp) {
1035: printf(", modem: %s",mdmtab[i].kwd);
1036: break;
1037: }
1038: }
1039: #endif /* NODIAL */
1040: } else {
1041: if (nettype == NET_TCPA) printf(", TCP/IP");
1042: if (nettype == NET_TCPB) printf(", TCP/IP");
1043: if (nettype == NET_DEC) {
1044: if ( ttnproto == NP_LAT ) printf(", DECnet LAT");
1045: else if ( ttnproto == NP_CTERM ) printf(", DECnet CTERM");
1046: else printf(", DECnet");
1047: }
1048: if (nettype == NET_PIPE) printf(", Named Pipe");
1049: #ifdef SUNX25
1050: shox25();
1051: #endif /* SUNX25 */
1052: if (ttnproto == NP_TELNET) printf(", telnet protocol");
1053: }
1054: if (local) {
1055: i = parity ? 7 : 8;
1056: if (i == 8) i = (cmask == 0177) ? 7 : 8;
1057: printf("\n Terminal bits: %d, p",i);
1058: } else printf("\n P");
1059: printf("arity: %s",parnam((char)parity));
1060: printf(", duplex: ");
1061: if (duplex) printf("half, "); else printf("full, ");
1062: printf("flow: ");
1063: if (flow == FLO_KEEP) printf("keep");
1064: else if (flow == FLO_XONX) printf("xon/xoff");
1065: else if (flow == FLO_NONE) printf("none");
1066: else if (flow == FLO_DTRT) printf("dtr/cts");
1067: else if (flow == FLO_RTSC) printf("rts/cts");
1068: else if (flow == FLO_DTRC) printf("dtr/cd");
1069: else printf("%d",flow);
1070: printf(", handshake: ");
1071: if (turn) printf("%d\n",turnch); else printf("none\n");
1072: if (local && !network) { /* Lockfile & carrier stuff */
1073: if (carrier == CAR_OFF) s = "off";
1074: else if (carrier == CAR_ON) s = "on";
1075: else if (carrier == CAR_AUT) s = "auto";
1076: else s = "unknown";
1077: printf(" Carrier: %s", s);
1078: if (carrier == CAR_ON) {
1079: if (cdtimo) printf(", timeout: %d sec", cdtimo);
1080: else printf(", timeout: none");
1081: }
1082: #ifdef UNIX
1083: if (haslock && *flfnam) { /* Lockfiles only apply to UNIX... */
1084: printf(", lockfile: %s",flfnam);
1085: }
1086: #endif /* UNIX */
1087: printf("\n Escape character: %d (^%c)\n",escape,ctl(escape));
1088: }
1089: }
1090:
1091: #ifdef TNCODE
1092: static VOID
1093: shotel() {
1094: printf("SET TELNET parameters:\n echo: %s\n newline-mode: %s\n",
1095: tn_duplex ? "local" : "remote", tn_nlm ? "on" : "off");
1096: printf(" terminal-type: ");
1097: if (tn_term) printf("%s\n",tn_term);
1098: else {
1099: char *p;
1100: p = getenv("TERM");
1101: if (p)
1102: printf("none (%s will be used)\n",p);
1103: else printf("none\n");
1104: }
1105: }
1106: #endif /* TNCODE */
1107:
1108: VOID
1109: shonet() {
1110: #ifndef NETCONN
1111: printf("\nNo networks are supported in this version of C-Kermit\n");
1112: #else
1113: printf("\nSupported networks:\n");
1114:
1115: #ifdef VMS
1116:
1117: #ifdef MULTINET
1118: printf(" TGV MultiNet TCP/IP");
1119: #else
1120: #ifdef WINTCP
1121: printf(" WOLLONGONG WIN/TCP");
1122: #else
1123: #ifdef DEC_TCPIP
1124: printf(" DEC TCP/IP Services for (Open)VMS");
1125: #else
1126: printf(" None");
1127: #endif /* DEC_TCPIP */
1128: #endif /* WINTCP */
1129: #endif /* MULTINET */
1130: #ifdef TNCODE
1131: printf(", TELNET protocol\n\n");
1132: shotel();
1133: #endif /* TNCODE */
1134: printf("\n");
1135:
1136: #else /* Not VMS */
1137:
1138: #ifdef SUNX25
1139: printf(" SunLink X.25\n");
1140: #endif /* SUNX25 */
1141: #ifdef DECNET
1142: printf(" DECnet\n");
1143: #endif /* DECNET */
1144: #ifdef NPIPE
1145: printf(" LAN Manager Named Pipe\n");
1146: #endif /* DECNET */
1147: #ifdef TCPSOCKET
1148: printf(" TCP/IP");
1149: #ifdef TNCODE
1150: printf(", TELNET protocol\n\n");
1151: shotel();
1152: #endif /* TNCODE */
1153: #endif /* TCPSOCKET */
1154: printf("\n");
1155:
1156: #endif /* VMS */
1157:
1158: printf("Current network type:\n");
1159: if (nettype == NET_TCPA || nettype == NET_TCPB)
1160: printf(" TCP/IP\n");
1161: #ifdef SUNX25
1162: else if (nettype == NET_SX25) printf(" X.25\n");
1163: #endif /* SUNX25 */
1164: #ifdef DECNET
1165: else if (nettype == NET_DEC) printf(" DECnet\n");
1166: #endif /* DECNET */
1167:
1168: printf("\nActive SET HOST connection:\n");
1169: if (network) {
1170: printf(" %s",ttname);
1171: if (*ipaddr) printf(" [%s]",ipaddr);
1172: printf("\n Via: ");
1173: if (nettype == NET_TCPA || nettype == NET_TCPB) printf("TCP/IP\n");
1174: else if (nettype == NET_SX25) printf("SunLink X.25\n");
1175: else if (nettype == NET_DEC) {
1176: if ( ttnproto == NP_LAT ) printf("DECnet LAT\n");
1177: else if ( ttnproto == NP_CTERM ) printf("DECnet CTERM\n");
1178: else printf("DECnet\n");
1179: }
1180: else if (nettype == NET_PIPE) printf("LAN Manager Named Pipe\n");
1181: #ifdef SUNX25
1182: if (nettype == NET_SX25) shox25();
1183: #endif /* SUNX25 */
1184: #ifdef TNCODE
1185: if (ttnproto == NP_TELNET) {
1186: printf(" TELNET protocol\n");
1187: printf(" Echoing is currently %s\n",duplex ? "local" : "remote");
1188: }
1189: #endif /* TNCODE */
1190: } else printf(" None\n");
1191: printf("\n");
1192: #endif /* NETCONN */
1193: }
1194:
1195: #ifndef NODIAL
1196:
1197: VOID
1198: shodial() {
1199: if (mdmtyp >= 0 || local != 0) doshodial();
1200: }
1201:
1202: static VOID
1203: shods(s) char *s; { /* Show a dial-related string */
1204: char c;
1205: if (s == NULL || !(*s)) { /* Empty? */
1206: printf("(none)\n");
1207: } else { /* Not empty. */
1208: while (c = *s++) /* Can contain controls */
1209: if (c > 31 && c < 127) { putchar(c); } /* so display them */
1210: else printf("\\{%d}",c); /* in backslash notation */
1211: printf("\n");
1212: }
1213: }
1214:
1215: int
1216: doshodial() {
1217: printf(" Dial directory: %s\n",dialdir ? dialdir : "(none)");
1218: printf(" Dial hangup: %s, dial modem-hangup: %s\n",
1219: dialhng ? "on" : "off", dialmhu ? "on" : "off") ;
1220: printf(" Dial kermit-spoof: %s",dialksp ? "on" : "off");
1221: printf(", dial display: %s\n",dialdpy ? "on" : "off");
1222: printf(" Dial speed-matching: %s",mdmspd ? "on" : "off");
1223: printf(", dial mnp-enable: %s\n",dialmnp ? "on" : "off");
1224: printf(" Dial init-string: ");
1225: shods(getdws(mdmtyp)); /* Ask dial module for it */
1226: printf(" Dial dial-command: ");
1227: shods(getdcs(mdmtyp)); /* Ask dial module for it */
1228: printf(" Dial prefix: ");
1229: shods(dialnpr);
1230: printf(" Dial timeout: ");
1231: if (dialtmo > 0)
1232: printf("%d sec", dialtmo);
1233: else
1234: printf("0 (auto)");
1235: printf(", Redial number: %s\n",dialnum ? dialnum : "(none)");
1236: return(0);
1237: }
1238: #endif /* NODIAL */
1239:
1240: #ifdef SUNX25
1241: VOID
1242: shopad() {
1243: int i;
1244: printf("\nX.3 PAD Parameters:\n");
1245: for (i = 0; i < npadx3; i++)
1246: printf(" [%d] %s %d\n",padx3tab[i].kwval,padx3tab[i].kwd,
1247: padparms[padx3tab[i].kwval]);
1248: }
1249: #endif /* SUNX25 */
1250:
1251: /* Show File Parameters */
1252:
1253: VOID
1254: shoparf() {
1255: char *s; int i;
1256: printf("\nFile parameters: ");
1257: #ifdef COMMENT
1258: printf("Blocksize: %5d ",fblksiz);
1259: #endif /* COMMENT */
1260: printf(" Attributes: ");
1261: if (atcapr) printf("on"); else printf("off");
1262: #ifdef VMS
1263: printf(" Record-Length: %5d",frecl);
1264: #endif /* VMS */
1265: printf("\n Names: ");
1266: printf("%-12s",(fncnv) ? "converted" : "literal");
1267: #ifdef DEBUG
1268: #ifndef MAC
1269: printf(" Debugging Log: ");
1270: if (deblog) printf("%s",debfil); else printf("none");
1271: #endif /* MAC */
1272: #endif /* DEBUG */
1273:
1274: printf("\n Type: ");
1275: switch (binary) {
1276: case XYFT_T: s = "text"; break;
1277: #ifdef VMS
1278: case XYFT_B: s = "binary fixed"; break;
1279: case XYFT_I: s = "image"; break;
1280: case XYFT_L: s = "labeled"; break;
1281: case XYFT_U: s = "binary undef"; break;
1282: #else
1283: case XYFT_B: s = "binary"; break;
1284: #endif /* VMS */
1285: default: s = "?"; break;
1286: }
1287: printf("%-12s",s);
1288: #ifdef COMMENT
1289: printf(" Organization: ");
1290: switch (forg) {
1291: case XYFO_I: printf("%-10s","indexed"); break;
1292: case XYFO_R: printf("%-10s","relative"); break;
1293: case XYFO_S: printf("%-10s","sequential"); break;
1294: }
1295: #endif /* COMMENT */
1296: #ifndef MAC
1297: printf(" Packet Log: ");
1298: if (pktlog) printf(pktfil); else printf("none");
1299: #endif /* MAC */
1300: #ifdef UNIX
1301: printf(" Longest filename: %d",maxnam);
1302: #endif /* UNIX */
1303: printf("\n Collide: ");
1304: for (i = 0; i < ncolx; i++)
1305: if (colxtab[i].kwval == fncact) break;
1306: printf("%-12s", (i == ncolx) ? "unknown" : colxtab[i].kwd);
1307:
1308: #ifdef COMMENT
1309: printf(" Format: ");
1310: switch (frecfm) {
1311: case XYFF_F: printf("%-10s","fixed"); break;
1312: case XYFF_VB: printf("%-10s","rcw"); break;
1313: case XYFF_S: printf("%-10s","stream"); break;
1314: case XYFF_U: printf("%-10s","undefined"); break;
1315: case XYFF_V: printf("%-10s","variable"); break;
1316: }
1317: #endif /* COMMENT */
1318: #ifndef MAC
1319: printf(" Session Log: ");
1320: if (seslog) printf(sesfil); else printf("none");
1321: #endif /* MAC */
1322: #ifdef UNIX
1323: printf(" Longest pathname: %d",maxpath);
1324: #endif /* UNIX */
1325: printf("\n Display: ");
1326: switch (fdispla) {
1327: case XYFD_N: printf("%-12s","none"); break;
1328: case XYFD_R: printf("%-12s","serial"); break;
1329: case XYFD_C: printf("%-12s","fullscreen"); break;
1330: case XYFD_S: printf("%-12s","crt"); break;
1331: }
1332: #ifdef COMMENT
1333: printf("Carriage-Control: ");
1334: switch (fcctrl) {
1335: case XYFP_F: printf("%-10s","fortran"); break;
1336: case XYFP_N: printf("%-10s","newline"); break;
1337: case XYFP_P: printf("%-10s","machine"); break;
1338: case XYFP_X: printf("%-10s","none"); break;
1339: }
1340: #endif /* COMMENT */
1341: #ifdef TLOG
1342: #ifndef MAC
1343: printf(" Transaction Log: ");
1344: if (tralog) printf(trafil); else printf("none");
1345: #endif /* MAC */
1346: #endif /* TLOG */
1347: #ifndef NOCSETS
1348: if (binary == XYFT_T) {
1349: shocharset();
1350: } else
1351: #endif /* NOCSETS */
1352: printf("\n");
1353: printf("\nFile Byte Size: %d",(fmask == 0177) ? 7 : 8);
1354: printf(", Incomplete Files: ");
1355: if (keep) printf("keep"); else printf("discard");
1356: #ifdef KERMRC
1357: printf(", Init file: %s",kermrc);
1358: #endif /* KERMRC */
1359: printf("\n");
1360: }
1361:
1362: VOID
1363: shoparp() {
1364: printf("\nProtocol Parameters: Send Receive");
1365: if (timef)
1366: printf("\n Timeout (used=%2d):%7d*%8d ", timint, rtimo, pkttim);
1367: else
1368: printf("\n Timeout (used=%2d):%7d%9d ", timint, rtimo, pkttim);
1369: #ifndef NOSERVER
1370: printf(" Server Timeout:%4d\n",srvtim);
1371: #endif /* NOSERVER */
1372: printf( " Padding: %11d%9d", npad, mypadn);
1373: if (bctr == 4)
1374: printf(" Block Check: blank-free-2\n");
1375: else
1376: printf(" Block Check: %6d\n",bctr);
1377: printf( " Pad Character:%11d%9d", padch, mypadc);
1378: printf(" Delay: %6d\n",delay);
1379: printf( " Packet Start: %11d%9d", mystch, stchr);
1380: printf(" Max Retries: %6d\n",maxtry);
1381: printf( " Packet End: %11d%9d", seol, eol);
1382: if (ebqflg)
1383: printf(" 8th-Bit Prefix: '%c'",ebq);
1384: #ifdef COMMENT
1385: /*
1386: This is confusing.
1387: */
1388: printf( "\n Packet Length:%11d", spsizf ? spsizr : spsiz);
1389: printf( spsizf ? "*" : " " ); printf("%8d", urpsiz);
1390: printf( (urpsiz > 94) ? " (94)" : " ");
1391: #else
1392: printf( "\n Packet Length:%11d ", spmax);
1393: printf("%8d ", urpsiz);
1394: #endif /* COMMENT */
1395: if (rptflg)
1396: printf(" Repeat Prefix: '%c'",rptq);
1397: printf( "\n Maximum Length: %9d%9d", maxsps, maxrps);
1398: printf(" Window Size:%7d set, %d used\n",wslotr,wmax);
1399: printf( " Buffer Size: %11d%9d", bigsbsiz, bigrbsiz);
1400: printf(" Locking-Shift: ");
1401: if (lscapu == 2) {
1402: printf("forced\n");
1403: } else {
1404: printf("%s", (lscapr ? "enabled" : "disabled"));
1405: if (lscapr) printf(",%s%s", (lscapu ? " " : " not "), "used");
1406: printf("\n");
1407: }
1408: }
1409:
1410: #ifndef NOCSETS
1411: VOID
1412: shoparl() {
1413: #ifdef COMMENT
1414: int i;
1415: /* Misleading... */
1416: printf("\nAvailable Languages:\n");
1417: for (i = 0; i < MAXLANG; i++) {
1418: printf(" %s\n",langs[i].description);
1419: }
1420: #else
1421: printf("\nLanguage-specific translation rules: %s\n",
1422: language == L_USASCII ? "none" : langs[language].description);
1423: shocharset();
1424: printf("\n\n");
1425: #endif /* COMMENT */
1426: }
1427:
1428: VOID
1429: shocharset() {
1430: int x;
1431: printf("\n File Character-Set: %s (",fcsinfo[fcharset].name);
1432: if ((x = fcsinfo[fcharset].size) == 128) printf("7-bit)");
1433: else if (x == 256) printf("8-bit)");
1434: else printf("(multibyte)");
1435: printf("\n Transfer Character-Set");
1436: #ifdef COMMENT
1437: if (tslevel == TS_L2)
1438: printf(": (international)");
1439: else
1440: #endif /* COMMENT */
1441: if (tcharset == TC_TRANSP)
1442: printf(": Transparent");
1443: else
1444: printf(": %s",tcsinfo[tcharset].name);
1445: }
1446: #endif /* NOCSETS */
1447:
1448: VOID
1449: shopar() {
1450: #ifndef MAC
1451: printf("\n%s,%s\n",versio,ckxsys);
1452: #endif /* MAC */
1453: shoparc();
1454: shoparp();
1455: shoparf();
1456: }
1457: #endif /* NOSHOW */
1458:
1459: /* D O S T A T -- Display file transfer statistics. */
1460:
1461: int
1462: dostat() {
1463: printf("\nMost recent transaction --\n");
1464: printf("\n files: %ld\n",filcnt);
1465: printf(" characters last file : %ld\n",ffc);
1466: printf(" total file characters : %ld\n",tfc);
1467: printf(" communication line in : %ld\n",tlci);
1468: printf(" communication line out : %ld\n",tlco);
1469: printf(" packets sent : %d\n", spackets);
1470: printf(" packets received : %d\n", rpackets);
1471: printf(" damaged packets rec'd : %d\n", crunched);
1472: printf(" timeouts : %d\n", timeouts);
1473: printf(" retransmissions : %d\n", retrans);
1474: if (filcnt > 0) {
1475: printf(" parity : %s",parnam((char)parity));
1476: if (autopar) printf(" (detected automatically)");
1477: printf("\n 8th bit prefixing : ");
1478: if (ebqflg) printf("yes [%c]\n",ebq); else printf("no\n");
1479: printf(" locking shifts : %s\n", lscapu ? "yes" : "no");
1480: printf(" window slots used : %d of %d\n", wmax, wslotr);
1481: printf(" packet length : %d (send), %d (receive)\n",
1482: spmax, urpsiz);
1483: printf(" compression : ");
1484: if (rptflg) printf("yes [%c] (%d)\n",rptq,rptn); else printf("no\n");
1485: if (bctu == 4)
1486: printf(" block check type used : blank-free-2\n");
1487: else
1488: printf(" block check type used : %d\n",bctu);
1489: printf(" elapsed time : %d sec\n",tsecs);
1490: if (speed <= 0L) speed = ttgspd();
1491: if (speed > 0L) {
1492: if (speed == 8880)
1493: printf(" transmission rate : 75/1200 bps\n");
1494: else
1495: printf(" transmission rate : %ld bps\n",speed);
1496: }
1497: if (tsecs > 0) {
1498: long lx;
1499: lx = (tfc * 10L) / (long) tsecs;
1500: printf(" effective data rate : %ld cps\n",lx/10L);
1501: if (speed > 0L && speed != 8880L && network == 0) {
1502: lx = (lx * 100L) / speed;
1503: printf(" efficiency (percent) : %ld\n",lx);
1504: }
1505: #ifdef COMMENT
1506: lx = (tlci * 10L) / (long) tsecs;
1507: printf(" throughput (in) : %ld cps\n",lx/10l);
1508: lx = (tlco * 10L) / (long) tsecs;
1509: printf(" throughput (out) : %ld cps\n",lx/10l);
1510: #endif /* COMMENT */
1511: }
1512: }
1513: return(1);
1514: }
1515:
1516: /* D O C O N E C T -- Do the connect command */
1517:
1518: /* Note, we don't call this directly from dial, because we need to give */
1519: /* the user a chance to change parameters (e.g. parity) after the */
1520: /* connection is made. */
1521:
1522: int
1523: doconect() {
1524: int x;
1525: conres(); /* Put console back to normal */
1526: x = conect(); /* Connect */
1527: concb((char)escape); /* Put console into cbreak mode, */
1528: return(x); /* for more command parsing. */
1529: }
1530:
1531: #ifndef NOSPL
1532: /* The INPUT command */
1533:
1534: #ifdef NETCONN
1535: extern int tn_init;
1536: #ifndef IAC
1537: #define IAC 255
1538: #endif /* IAC */
1539: #endif /* NETCONN */
1540:
1541: int
1542: doinput(timo,s) int timo; char *s; {
1543: int x, y, i, t, icn, anychar;
1544: int lastchar = 0;
1545: char *xp, *xq = (char *)0;
1546: CHAR c;
1547:
1548: if (local) { /* Put line in "ttvt" mode */
1549: y = ttvt(speed,flow); /* if not already. */
1550: if (y < 0) {
1551: printf("?Can't condition line for INPUT\n");
1552: return(0); /* Watch out for failure. */
1553: }
1554: }
1555: if (!s) s = "";
1556: y = (int)strlen(s); /* If search string is empty */
1557: anychar = (y < 1); /* any input character will do. */
1558: debug(F111,"doinput",s,y);
1559: if (timo <= 0) timo = 1; /* Give at least 1 second timeout */
1560:
1561: x = 0; /* Return code, assume failure */
1562: i = 0; /* String pattern match position */
1563:
1564: if (!incase) { /* INPUT CASE = IGNORE? */
1565: xp = malloc(y+2); /* Make a separate copy of the */
1566: if (!xp) { /* input string for editing. */
1567: printf("?malloc error 5\n");
1568: return(x);
1569: } else xq = xp; /* Save pointer to beginning */
1570:
1571: while (*s) { /* Convert to lowercase */
1572: *xp = *s;
1573: if (isupper(*xp)) *xp = tolower(*xp);
1574: xp++; s++;
1575: }
1576: *xp = NUL; /* Terminate the search string. */
1577: s = xq; /* Point back to beginning. */
1578: }
1579: inpbps = inpbp; /* Save current pointer. */
1580: rtimer(); /* Reset timer. */
1581: t = 0; /* Time is 0. */
1582: incount = 0; /* Character counter */
1583: while (1) { /* Character-getting loop */
1584: if (local) { /* One case for local */
1585: y = ttinc(1); /* Get character from comm line. */
1586: debug(F101,"input ttinc(1) returns","",y);
1587: if (icn = conchk()) { /* Interrupted from keyboard? */
1588: debug(F101,"input interrupted from keyboard","",icn);
1589: while (icn--) coninc(0); /* Yes, read what was typed. */
1590: break; /* And fail. */
1591: }
1592: } else { /* Another for remote */
1593: y = coninc(1);
1594: debug(F101,"input coninc(1) returns","",y);
1595: }
1596: if (y > -1) { /* A character arrived */
1597: #ifdef TNCODE
1598: /* Check for telnet protocol negotiation */
1599: if (network && (ttnproto == NP_TELNET) && ((y & 0xff) == IAC)) {
1600: switch (tn_doop((CHAR)(y & 0xff),duplex,ttinc)) {
1601: case 2: duplex = 0; continue;
1602: case 1: duplex = 1;
1603: default: continue;
1604: }
1605: }
1606: #endif /* TNCODE */
1607:
1608: /* Real input character to be checked */
1609:
1610: c = cmask & (CHAR) y; /* Mask off parity */
1611:
1612: inchar[0] = c; /* Remember character for \v(inchar) */
1613: lastchar = gtimer(); /* Remember when it came. */
1614:
1615: if (c == '\0') { /* NUL, we can't use it */
1616: if (anychar) { /* Any character will do? */
1617: x = 1; /* Yes, done. */
1618: incount = 1; /* This must be the first and only. */
1619: break;
1620: } else continue; /* Otherwise continue INPUTting */
1621: }
1622:
1623: *inpbp++ = c; /* Store char in circular buffer */
1624: incount++; /* Count it for \v(incount) */
1625:
1626: if (inpbp >= inpbuf + INPBUFSIZ) { /* Time to wrap around? */
1627: inpbp = inpbuf; /* Yes. */
1628: *(inpbp+INPBUFSIZ) = NUL; /* Make sure it's null-terminated. */
1629: }
1630: #ifdef MAC
1631: {
1632: extern char *ttermw; /* fake pointer cast */
1633: if (inecho) {
1634: outchar(ttermw, c); /* echo to terminal window */
1635: /* this might be too much overhead to do here ? */
1636: updatecommand(ttermw);
1637: }
1638: }
1639: #else /* Not MAC */
1640: if (inecho) conoc(c); /* Echo and log the input character */
1641: #endif /* MAC */
1642: if (seslog) {
1643: #ifdef UNIX
1644: if (sessft != 0 || c != '\r')
1645: #endif /* UNIX */
1646: if (zchout(ZSFILE,c) < 0) seslog = 0;
1647: }
1648: if (anychar) { /* Any character will do? */
1649: x = 1;
1650: break;
1651: }
1652: if (!incase) { /* Ignore alphabetic case? */
1653: if (isupper(c)) c = tolower(c); /* Yes */
1654: }
1655: debug(F000,"doinput char","",c);
1656: debug(F000,"compare char","",s[i]);
1657: if (c == s[i]) { /* Check for match */
1658: i++; /* Got one, go to next character */
1659: } else { /* Don't have a match */
1660: int j, size;
1661: for (j = i; i-- > 0; ) { /* [jrs] search backwards */
1662: if (c == s[i]) {
1663: size = j - i;
1664: if (strncmp(s,&s[j-i],i-size)== 0)
1665: break;
1666: }
1667: }
1668: i++; /* [jrs] count last char matched */
1669: } /* [jrs] or return to zero from -1 */
1670: if (s[i] == '\0') { /* Matched all the way to end? */
1671: x = 1; /* Yes, */
1672: break; /* done. */
1673: }
1674: }
1675: if ((t = gtimer()) > timo) /* Did not match, timer exceeded? */
1676: break;
1677: else if (insilence > 0 && (t - lastchar) > insilence)
1678: break;
1679: } /* Still have time left, continue. */
1680: if (!incase) if (xq) free(xq); /* Done, free dynamic memory. */
1681: return(x); /* Return the return code. */
1682: }
1683: #endif /* NOSPL */
1684:
1685: #ifndef NOSPL
1686: /* REINPUT Command */
1687:
1688: /* Note, the timeout parameter is required, but ignored. */
1689: /* Syntax is compatible with MS-DOS Kermit except timeout can't be omitted. */
1690: /* This function only looks at the characters already received */
1691: /* and does not read any new characters from the communication line. */
1692:
1693: int
1694: doreinp(timo,s) int timo; char *s; {
1695: int x, y, i;
1696: char *xx, *xp, *xq = (char *)0;
1697: CHAR c;
1698:
1699: y = (int)strlen(s);
1700: debug(F111,"doreinput",s,y);
1701:
1702: x = 0; /* Return code, assume failure */
1703: i = 0; /* String pattern match position */
1704:
1705: if (!incase) { /* INPUT CASE = IGNORE? */
1706: xp = malloc(y+2); /* Make a separate copy of the */
1707: if (!xp) { /* search string. */
1708: printf("?malloc error 6\n");
1709: return(x);
1710: } else xq = xp; /* Keep pointer to beginning. */
1711: while (*s) { /* Yes, convert to lowercase */
1712: *xp = *s;
1713: if (isupper(*xp)) *xp = tolower(*xp);
1714: xp++; s++;
1715: }
1716: *xp = NUL; /* Terminate it! */
1717: s = xq; /* Move search pointer to it. */
1718: }
1719: xx = inpbp; /* Current INPUT buffer pointer */
1720: do {
1721: c = *xx++; /* Get next character */
1722: if (xx >= inpbuf + INPBUFSIZ) xx = inpbuf; /* Wrap around */
1723: if (!incase) { /* Ignore alphabetic case? */
1724: if (isupper(c)) c = tolower(c); /* Yes */
1725: }
1726: debug(F000,"doreinp char","",c);
1727: debug(F000,"compare char","",s[i]);
1728: if (c == s[i]) { /* Check for match */
1729: i++; /* Got one, go to next character */
1730: } else { /* Don't have a match */
1731: int j, size;
1732: for (j = i; i-- > 0; ) { /* [jrs] search backwards for it */
1733: if (c == s[i]) {
1734: size = j - i;
1735: if (strncmp(s,&s[j-i],i-size)== 0)
1736: break;
1737: }
1738: }
1739: i++; /* [jrs] count last char matched */
1740: } /* [jrs] or return to zero from -1 */
1741: if (s[i] == '\0') { /* Matched all the way to end? */
1742: x = 1; /* Yes, */
1743: break; /* done. */
1744: }
1745: } while (xx != inpbp); /* Until back where we started. */
1746:
1747: if (!incase) if (xq) free(xq); /* Free this if it was malloc'd. */
1748: return(x); /* Return search result. */
1749: }
1750: #ifndef NOSPL
1751:
1752: #endif /* NOSPL */
1753: /* X X S T R I N G -- Interpret strings containing backslash escapes */
1754:
1755: /*
1756: Copies result to new string.
1757: strips enclosing braces or doublequotes.
1758: interprets backslash escapes.
1759: returns 0 on success, nonzero on failure.
1760: tries to be compatible with MS-DOS Kermit.
1761:
1762: Syntax of input string:
1763: string = chars | "chars" | {chars}
1764: chars = (c*e*)*
1765: where c = any printable character, ascii 32-126
1766: and e = a backslash escape
1767: and * means 0 or more repetitions of preceding quantity
1768: backslash escape = \operand
1769: operand = {number} | number | fname(operand) | v(name) | $(name) | m(name)
1770: number = [r]n[n[n]]], i.e. an optional radix code followed by 1-3 digits
1771: radix code is oO (octal), hHxX (hex), dD or none (decimal).
1772: */
1773:
1774: #ifndef NOFRILLS
1775: int
1776: yystring(s,s2) char *s; char **s2; { /* Reverse a string */
1777: int x;
1778: static char *new;
1779: new = *s2;
1780: if (!s || !new) return(-1); /* Watch out for null pointers. */
1781: if ((x = (int)strlen(s)) == 0) { /* Recursion done. */
1782: *new = '\0';
1783: return(0);
1784: }
1785: x--; /* Otherwise, call self */
1786: *new++ = s[x]; /* to reverse rest of string. */
1787: s[x] = 0;
1788: return(yystring(s,&new));
1789: }
1790: #endif /* NOFRILLS */
1791:
1792: #define FNVALL 1000
1793: char fnval[FNVALL+2]; /* Return value */
1794:
1795: char * /* Evaluate builtin function */
1796: fneval(fn,argp,argn) char *fn, *argp[]; int argn; {
1797: int i, j, k, len1, len2, n, x, y;
1798: char *bp[FNARGS]; /* Pointers to malloc'd strings */
1799: char *p, *s;
1800:
1801: if (!fn) fn = ""; /* Paranoia */
1802: debug(F111,"fneval",fn,argn);
1803: debug(F110,"fneval",argp[0],0);
1804: y = lookup(fnctab,fn,nfuncs,&x);
1805: if (y < 0) /* bad function name */
1806: return(""); /* so value is null */
1807:
1808: #ifdef DEBUG
1809: if (deblog) {
1810: int j;
1811: for (j = 0; j < argn; j++)
1812: debug(F111,"fneval function arg",argp[j],j);
1813: }
1814: #endif /* DEBUG */
1815:
1816: if (y == FN_LIT) /* literal(arg1) */
1817: return(argp[0] ? argp[0] : ""); /* return a pointer to arg itself */
1818:
1819: if (y == FN_CON) { /* Contents of variable, unexpanded. */
1820: char c;
1821: if (!(p = argp[0]) || !*p) return("");
1822: if (*p == CMDQ) p++;
1823: if ((c = *p) == '%') { /* Scalar variable. */
1824: c = *++p; /* Get ID character. */
1825: p = ""; /* Assume definition is empty */
1826: if (!c) return(p); /* Double paranoia */
1827: if (c >= '0' && c <= '9') { /* Digit for macro arg */
1828: c -= '0'; /* convert character to integer */
1829: if (maclvl < 0) /* Digit variables are global */
1830: p = g_var[c]; /* if no macro is active */
1831: else /* otherwise */
1832: p = m_arg[maclvl][c]; /* they're on the stack */
1833: } else {
1834: if (isupper(c)) c -= ('a'-'A');
1835: p = g_var[c]; /* Letter for global variable */
1836: }
1837: return(p ? p : "");
1838: }
1839: if (c == '&') { /* Array reference. */
1840: int vbi, d;
1841: if (arraynam(p,&vbi,&d) < 0) /* Get name and subscript */
1842: return("");
1843: if (chkarray(vbi,d) > 0) { /* Array is declared? */
1844: vbi -= 'a'; /* Convert name to index */
1845: if (a_dim[vbi] >= d) { /* If subscript in range */
1846: char **ap;
1847: ap = a_ptr[vbi]; /* get data pointer */
1848: if (ap) { /* and if there is one */
1849: return(ap[d]); /* return what it points to */
1850: }
1851: }
1852: }
1853: return(p ? p : ""); /* Otherwise its enexpanded value. */
1854: }
1855: }
1856:
1857: for (i = 0; i < argn; i++) { /* Not literal, expand the args */
1858: n = 1024; /* allow 1K per expanded arg, yow! */
1859: bp[i] = s = malloc(n); /* get the new space */
1860: if (bp[i] == NULL) { /* handle failure to get space */
1861: for (k = 0; k < i; k++) if (bp[k]) free(bp[k]);
1862: debug(F101,"fneval malloc failure, arg","",i);
1863: return("");
1864: }
1865: p = argp[i] ? argp[i] : ""; /* Point to this argument */
1866:
1867: /*
1868: Trim leading and trailing spaces from the original argument, before
1869: evaluation. This code new to edit 184.
1870: */
1871: if (y != FN_REP || i != 0) { /* Don't trim 1st REPEAT argument */
1872: int j; /* All others... */
1873: while (*p == SP || *p == HT) /* Point past leading whitespace */
1874: p++;
1875: j = (int) strlen(p) - 1; /* Trim trailing whitespace */
1876: while (j > 0 && (*(p + j) == SP || *(p + j) == HT))
1877: *(p + j--) = NUL;
1878: }
1879:
1880: /* Now evaluate the argument */
1881:
1882: if (xxstring(p,&s,&n) < 0) { /* Expand arg into new space */
1883: debug(F101,"fneval xxstring fails, arg","",i);
1884: for (k = 0; k <= i; k++) /* Free up previous space on error */
1885: if (bp[k]) free(bp[k]);
1886: return(""); /* and return null string. */
1887: }
1888: debug(F111,"fneval arg",bp[i],i);
1889: }
1890:
1891: #ifdef DEBUG
1892: if (deblog) {
1893: int j;
1894: for (j = 0; j < argn; j++) {
1895: debug(F111,"fneval arg post eval",argp[j],j);
1896: debug(F111,"fneval evaluated arg",bp[j],j);
1897: }
1898: }
1899: #endif /* DEBUG */
1900:
1901: switch (y) { /* Do function on expanded args */
1902:
1903: case FN_DEF:
1904: k = mlook(mactab,bp[0],nmac); /* def(arg1) - Return a macro def */
1905: p = (k > -1) ? mactab[k].mval : "";
1906: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
1907: return(p ? p : "");
1908:
1909: case FN_EVA: /* eval(arg1) */
1910: p = evala(bp[0]);
1911: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
1912: return(p ? p : "");
1913:
1914: case FN_EXE: /* execute(arg1) */
1915: j = (int)strlen(s = bp[0]); /* Length of macro invocation */
1916: p = ""; /* Initialize return value to null */
1917: if (j) { /* If there is a macro to execute */
1918: while (*s == SP) s++,j--; /* strip leading spaces */
1919: p = s; /* remember beginning of macro name */
1920: for (i = 0; i < j; i++) { /* find end of macro name */
1921: if (*s == SP) break;
1922: s++;
1923: }
1924: if (*s == SP) { /* if there was a space after */
1925: *s++ = NUL; /* terminate the macro name */
1926: while (*s == SP) s++; /* skip past any extra spaces */
1927: } else s = ""; /* maybe there are no arguments */
1928: if (p && *p)
1929: k = mlook(mactab,p,nmac); /* Look up the macro name */
1930: else k = -1;
1931:
1932: p = ""; /* Initialize return value */
1933: if (k >= 0) { /* If macro found in table */
1934: if ((j = dodo(k,s)) > 0) { /* Go set it up (like DO cmd) */
1935: if (cmpush() > -1) { /* Push command parser state */
1936: extern int ifc;
1937: int ifcsav = ifc; /* Push IF condition on stack */
1938: k = parser(1); /* Call parser to execute the macro */
1939: cmpop(); /* Pop command parser */
1940: ifc = ifcsav; /* Restore IF condition */
1941: if (k == 0) { /* No errors, ignore action cmds. */
1942: p = mrval[maclvl+1]; /* If OK, set return value. */
1943: if (p == NULL) p = "";
1944: }
1945: } else { /* Can't push any more */
1946: debug(F100,"fexec pushed too deep","",0);
1947: printf("\n?\\fexec() too deeply nested\n");
1948: while (cmpop() > -1) ;
1949: p = "";
1950: }
1951: }
1952: }
1953: }
1954: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
1955: return(p ? p : "");
1956:
1957: case FN_FC: /* File count. */
1958: p = fnval;
1959: *p = NUL;
1960: if (argn > 0) {
1961: k = zxpand(bp[0]);
1962: sprintf(fnval,"%d",k);
1963: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
1964: }
1965: return(p);
1966:
1967: case FN_FIL: /* Next file in list. */
1968: p = fnval; /* (no args) */
1969: *p = NUL;
1970: znext(p);
1971: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
1972: return(p ? p : "");
1973:
1974: case FN_IND: /* index(arg1,arg2) */
1975: if (argn > 1) { /* Only works if we have 2 args */
1976: int start;
1977: len1 = (int)strlen(bp[0]); /* length of string to look for */
1978: len2 = (int)strlen(s = bp[1]); /* length of string to look in */
1979: if (len1 < 0) return(""); /* paranoia */
1980: if (len2 < 0) return("");
1981: j = len2 - len1; /* length difference */
1982: start = 0; /* starting position */
1983: if (argn > 2) {
1984: if (chknum(bp[2])) {
1985: start = atoi(bp[2]) - 1;
1986: if (start < 0) start = 0;
1987: }
1988: }
1989: if (j < 0 || start > j) { /* search string is longer */
1990: p = "0";
1991: } else {
1992: if (!incase) { /* input case ignore? */
1993: lower(bp[0]);
1994: lower(bp[1]);
1995: }
1996: s = bp[1] + start; /* Point to beginning of target */
1997: p = "0";
1998: for (i = 0; i <= (j - start); i++) { /* Now compare */
1999: if (!strncmp(bp[0],s++,len1)) {
2000: sprintf(fnval,"%d",i+1+start);
2001: p = fnval;
2002: break;
2003: }
2004: }
2005: }
2006: } else p = "0";
2007: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
2008: return(p);
2009:
2010: case FN_CHR: /* character(arg1) */
2011: if (chknum(bp[0])) { /* Must be numeric */
2012: i = atoi(bp[0]);
2013: if (i >= 0 && i < 256) { /* Must be an 8-bit value */
2014: p = fnval;
2015: *p++ = i;
2016: *p = NUL;
2017: p = fnval;
2018: } else p = ""; /* Otherwise return null */
2019: } else p = ""; /* Otherwise return null */
2020: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
2021: return(p);
2022:
2023: case FN_COD: /* code(char) */
2024: p = "";
2025: if ((int)strlen(bp[0]) > 0) {
2026: p = fnval;
2027: i = *bp[0];
2028: sprintf(p,"%d",(i & 0xff));
2029: }
2030: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
2031: return(p);
2032:
2033: case FN_LEN: /* length(arg1) */
2034: p = fnval;
2035: sprintf(p,"%d",(int)strlen(bp[0]));
2036: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
2037: return(p);
2038:
2039: case FN_LOW: /* lower(arg1) */
2040: s = bp[0];
2041: p = fnval;
2042:
2043: while (*s) {
2044: if (isupper(*s))
2045: *p = tolower(*s);
2046: else
2047: *p = *s;
2048: p++; s++;
2049: }
2050: *p = NUL;
2051: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
2052: p = fnval;
2053: return(p);
2054:
2055: case FN_MAX: /* max(arg1,arg2) */
2056: case FN_MIN: /* min(arg1,arg2) */
2057: case FN_MOD: /* mod(arg1,arg2) */
2058: if (chknum(bp[0]) && chknum(bp[1])) {
2059: i = atoi(bp[0]);
2060: j = atoi(bp[1]);
2061: switch (y) {
2062: case FN_MAX:
2063: if (j < i) j = i;
2064: break;
2065: case FN_MIN:
2066: if (j > i) j = i;
2067: break;
2068: case FN_MOD:
2069: j = i % j;
2070: break;
2071: }
2072: p = fnval;
2073: sprintf(p,"%d",j);
2074: } else p = "";
2075: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
2076: return(p);
2077:
2078: case FN_SUB: /* substr(arg1,arg2,arg3) */
2079: case FN_RIG: /* right(arg1,arg2) */
2080: if (((argn > 1) && (int)strlen(bp[1]) && !rdigits(bp[1])) ||
2081: ((y == FN_SUB) &&
2082: ((argn > 2) && (int)strlen(bp[2]) && !rdigits(bp[2])))) {
2083: p = ""; /* if either, return null */
2084: } else {
2085: int lx;
2086: p = fnval; /* pointer to result */
2087: lx = strlen(bp[0]); /* length of arg1 */
2088: if (y == FN_SUB) { /* substring */
2089: k = (argn > 2) ? atoi(bp[2]) : 1023; /* length */
2090: j = (argn > 1) ? atoi(bp[1]) : 1; /* start pos for substr */
2091: } else { /* right */
2092: k = (argn > 1) ? atoi(bp[1]) : lx; /* length */
2093: j = lx - k + 1; /* start pos for right */
2094: if (j < 1) j = 1;
2095: }
2096: if (k > 0 && j <= lx) { /* if start pos in range */
2097: s = bp[0]+j-1; /* point to source string */
2098: for (i = 0; (i < k) && (*p++ = *s++); i++) ; /* copy */
2099: }
2100: *p = NUL; /* terminate the result */
2101: p = fnval; /* and point to it. */
2102: }
2103: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); /* Free temp mem */
2104: return(p);
2105:
2106: case FN_UPP: /* upper(arg1) */
2107: s = bp[0];
2108: p = fnval;
2109: while (*s) {
2110: if (islower(*s))
2111: *p = toupper(*s);
2112: else
2113: *p = *s;
2114: p++; s++;
2115: }
2116: *p = NUL;
2117: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
2118: p = fnval;
2119: return(p);
2120:
2121: case FN_REP: /* Repeat */
2122: p = ""; /* Return value */
2123: if (chknum(bp[1])) { /* Repeat count */
2124: n = atoi(bp[1]);
2125: if (n > 0) { /* Make n copies */
2126: p = fnval;
2127: *p = '\0';
2128: k = (int)strlen(bp[0]); /* Make sure string has some length */
2129: if (k > 0) {
2130: for (i = 0; i < n; i++) {
2131: s = bp[0];
2132: for (j = 0; j < k; j++) {
2133: if ((p - fnval) >= FNVALL) { /* Protect against */
2134: p = ""; /* core dumps... */
2135: break;
2136: } else *p++ = *s++;
2137: }
2138: }
2139: *p = NUL;
2140: }
2141: }
2142: }
2143: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
2144: p = fnval;
2145: return(p);
2146:
2147: #ifndef NOFRILLS
2148: case FN_REV:
2149: p = fnval;
2150: yystring(bp[0],&p);
2151: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
2152: return(p);
2153: #endif /* NOFRILLS */
2154:
2155: case FN_RPA: /* RPAD and LPAD */
2156: case FN_LPA:
2157: *fnval = NUL; /* Return value */
2158: if (argn == 1) { /* If a number wasn't given */
2159: p = fnval; /* just return the original string */
2160: strncpy(p,bp[0],FNVALL);
2161: } else if (chknum(bp[1])) { /* Repeat count */
2162: char pc;
2163: n = atoi(bp[1]);
2164: if (n >= 0) { /* Pad it out */
2165: p = fnval;
2166: k = (int)strlen(bp[0]); /* Length of string to be padded */
2167: pc = (argn < 3) ? SP : *bp[2]; /* Padding character */
2168: if (n > FNVALL) n = FNVALL-1; /* protect against overruns */
2169: if (k > FNVALL) k = FNVALL-1; /* and silly args. */
2170: if (k > n) k = n;
2171: if (y == FN_RPA) { /* RPAD */
2172: strncpy(p,bp[0],k);
2173: p += k;
2174: for (i = k; i < n; i++)
2175: *p++ = pc;
2176: } else { /* LPAD */
2177: n -= k;
2178: for (i = 0; i < n; i++)
2179: *p++ = pc;
2180: strncpy(p,bp[0],k);
2181: p += k;
2182: }
2183: *p = NUL;
2184: }
2185: }
2186: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
2187: p = fnval;
2188: return(p);
2189:
2190: default:
2191: return("");
2192: }
2193: }
2194: #endif /* NOSPL */
2195:
2196: #ifndef NOSPL
2197:
2198: char * /* Evaluate builtin variable */
2199: nvlook(s) char *s; {
2200: int x, y;
2201: long z;
2202: char *p;
2203:
2204: x = 30;
2205: p = vvbuf;
2206: if (xxstring(s,&p,&x) < 0) {
2207: y = -1;
2208: } else {
2209: s = vvbuf;
2210: if ((y = lookup(vartab,s,nvars,&x)) < 0) return(NULL);
2211: }
2212: switch (y) {
2213: case VN_ARGC: /* ARGC */
2214: sprintf(vvbuf,"%d",macargc[maclvl]);
2215: return(vvbuf);
2216:
2217: case VN_ARGS: /* ARGS */
2218: sprintf(vvbuf,"%d",xargs);
2219: return(vvbuf);
2220:
2221: case VN_COUN: /* COUNT */
2222: sprintf(vvbuf,"%d",count[cmdlvl]);
2223: return(vvbuf);
2224:
2225: case VN_DATE: /* DATE */
2226: ztime(&p); /* Get "asctime" string */
2227: if (p == NULL || *p == NUL) return(NULL);
2228: vvbuf[0] = p[8]; /* dd */
2229: vvbuf[1] = p[9];
2230: vvbuf[2] = SP;
2231: vvbuf[3] = p[4]; /* mmm */
2232: vvbuf[4] = p[5];
2233: vvbuf[5] = p[6];
2234: vvbuf[6] = SP;
2235: for (x = 20; x < 24; x++) /* yyyy */
2236: vvbuf[x - 13] = p[x];
2237: vvbuf[11] = NUL;
2238: return(vvbuf);
2239:
2240: case VN_NDAT: /* Numeric date */
2241: ztime(&p); /* Get "asctime" string */
2242: if (p == NULL || *p == NUL) return(NULL);
2243: for (x = 20; x < 24; x++) /* yyyy */
2244: vvbuf[x - 20] = p[x];
2245: vvbuf[6] = (p[8] == ' ') ? '0' : p[8]; vvbuf[7] = p[9]; /* dd */
2246: for (x = 0; x < 12; x++) /* mm */
2247: if (!strncmp(p+4,months[x],3)) break;
2248: if (x == 12) {
2249: vvbuf[4] = vvbuf[5] = '?';
2250: } else {
2251: x++;
2252: vvbuf[4] = (x < 10) ? '0' : '1';
2253: vvbuf[5] = (x % 10) + 48;
2254: }
2255: vvbuf[8] = NUL;
2256: return(vvbuf);
2257:
2258: case VN_DIRE: /* DIRECTORY */
2259: return(zgtdir());
2260:
2261: case VN_FILE: /* filespec */
2262: return(fspec);
2263:
2264: case VN_HOST: /* host name */
2265: if (*myhost) { /* If known */
2266: return(myhost); /* return it. */
2267: } else { /* Otherwise */
2268: strcpy(vvbuf,"unknown"); /* just say "unknown" */
2269: return(vvbuf);
2270: }
2271:
2272: case VN_SYST: /* System type */
2273: #ifdef UNIX
2274: strcpy(vvbuf,"UNIX");
2275: #else
2276: #ifdef VMS
2277: strcpy(vvbuf,"VMS");
2278: #else
2279: #ifdef OSK
2280: strcpy(vvbuf,"OS9/68K");
2281: #else
2282: #ifdef AMIGA
2283: strcpy(vvbuf,"Amiga");
2284: #else
2285: #ifdef MAC
2286: strcpy(vvbuf,"Macintosh");
2287: #else
2288: #ifdef OS2
2289: strcpy(vvbuf,"OS/2");
2290: #else
2291: #ifdef datageneral
2292: strcpy(vvbuf,"AOS/VS");
2293: #else
2294: #ifdef GEMDOS
2295: strcpy(vvbuf,"Atari_ST");
2296: #else
2297: strcpy(vvbuf,"unknown");
2298: #endif /* GEMDOS */
2299: #endif /* datageneral */
2300: #endif /* OS2 */
2301: #endif /* MAC */
2302: #endif /* AMIGA */
2303: #endif /* OSK */
2304: #endif /* VMS */
2305: #endif /* UNIX */
2306: return(vvbuf);
2307:
2308: case VN_SYSV: /* System herald */
2309: for (x = y = 0; x < VVBUFL; x++) {
2310: if (ckxsys[x] == SP && y == 0) continue;
2311: vvbuf[y++] = (ckxsys[x] == SP) ? '_' : ckxsys[x];
2312: }
2313: vvbuf[y] = NUL;
2314: return(vvbuf);
2315:
2316: case VN_TIME: /* TIME. Assumes that ztime returns */
2317: ztime(&p); /* "Thu Feb 8 12:00:00 1990" */
2318: if (p == NULL || *p == NUL) /* like asctime()! */
2319: return(NULL);
2320: for (x = 11; x < 19; x++) /* copy hh:mm:ss */
2321: vvbuf[x - 11] = p[x]; /* to vvbuf */
2322: vvbuf[8] = NUL; /* terminate */
2323: return(vvbuf); /* and return it */
2324:
2325: case VN_NTIM: /* Numeric time */
2326: ztime(&p); /* "Thu Feb 8 12:00:00 1990" */
2327: if (p == NULL || *p == NUL) /* like asctime()! */
2328: return(NULL);
2329: z = atol(p+11) * 3600L + atol(p+14) * 60L + atol(p+17);
2330: sprintf(vvbuf,"%ld",z);
2331: return(vvbuf);
2332:
2333: #ifdef UNIX
2334: case VN_TTYF: /* TTY file descriptor */
2335: sprintf(vvbuf,"%d",ttyfd);
2336: return(vvbuf);
2337: #else
2338: #ifdef OS2
2339: case VN_TTYF: /* TTY file descriptor */
2340: sprintf(vvbuf,"%d",ttyfd);
2341: return(vvbuf);
2342: #endif /* OS2 */
2343: #endif /* UNIX */
2344:
2345: case VN_VERS: /* Numeric Kermit version number */
2346: sprintf(vvbuf,"%ld",vernum);
2347: return(vvbuf);
2348:
2349: case VN_HOME: /* Home directory */
2350: #ifdef UNIX
2351: sprintf(vvbuf,"%s/",zhome());
2352: return(vvbuf);
2353: #else
2354: return(zhome());
2355: #endif /* UNIX */
2356:
2357: case VN_IBUF: /* INPUT buffer */
2358: return(inpbuf);
2359:
2360: case VN_ICHR: /* INPUT character */
2361: inchar[1] = NUL;
2362: return((char *)inchar);
2363:
2364: case VN_ICNT: /* INPUT character count */
2365: sprintf(vvbuf,"%d",incount);
2366: return(vvbuf);
2367:
2368: case VN_SPEE: { /* Transmission SPEED */
2369: long t;
2370: t = ttgspd();
2371: if (t < 0L)
2372: sprintf(vvbuf,"unknown");
2373: else
2374: sprintf(vvbuf,"%ld",t);
2375: return(vvbuf);
2376: }
2377: case VN_SUCC: /* SUCCESS flag */
2378: sprintf(vvbuf,"%d",(success == 0) ? 1 : 0);
2379: return(vvbuf);
2380:
2381: case VN_LINE: /* LINE */
2382: p = (char *) ttname;
2383: return(p);
2384:
2385: case VN_PROG: /* Program name */
2386: #ifdef MAC
2387: return("Mac-Kermit");
2388: #else
2389: return("C-Kermit");
2390: #endif /* MAC */
2391:
2392: case VN_RET: /* Value of most recent RETURN */
2393: p = mrval[maclvl+1];
2394: if (p == NULL) p = "";
2395: return(p);
2396:
2397: case VN_FFC: /* Size of most recent file */
2398: sprintf(vvbuf, "%ld", ffc);
2399: return(vvbuf);
2400:
2401: case VN_TFC: /* Size of most recent file group */
2402: sprintf(vvbuf, "%ld", tfc);
2403: return(vvbuf);
2404:
2405: case VN_CPU: /* CPU type */
2406: #ifdef CKCPU
2407: return(CKCPU);
2408: #else
2409: return("unknown");
2410: #endif /* CKCPU */
2411:
2412: case VN_CMDL: /* Command level */
2413: sprintf(vvbuf, "%d", cmdlvl);
2414: return(vvbuf);
2415:
2416: case VN_DAY: /* Day of week */
2417: case VN_NDAY:
2418: /*
2419: Depends on ztime() returning ENGLISH asctime()-format string!
2420: asctime() format is: "Thu Feb 8 12:00:00 1990".
2421: Needs updating to accommodate non-English asctime() strings.
2422: */
2423: ztime(&p);
2424: if (p != NULL && *p != NUL) { /* ztime() succeeded. */
2425: if (y == VN_DAY) { /* String day. */
2426: strncpy(vvbuf,p,3);
2427: } else { /* Numeric day. */
2428: for (x = 0; x < 7; x++) /* Look up day string in table */
2429: if (!strncmp(p,wkdays[x],3))
2430: break;
2431: if (x > 6) x = -1; /* Not found */
2432: sprintf(vvbuf,"%d",x); /* Return the number */
2433: }
2434: } else vvbuf[0] = NUL; /* ztime() failed. */
2435: return(vvbuf); /* Return what we got. */
2436:
2437: case VN_LCL: /* Local (vs remote) mode */
2438: strcpy(vvbuf, local ? "1" : "0");
2439: return(vvbuf);
2440:
2441: case VN_CMDS: /* Command source */
2442: if (cmdstk[cmdlvl].src == CMD_KB)
2443: strcpy(vvbuf,"prompt");
2444: else if (cmdstk[cmdlvl].src == CMD_MD)
2445: strcpy(vvbuf,"macro");
2446: else if (cmdstk[cmdlvl].src == CMD_TF)
2447: strcpy(vvbuf,"file");
2448: else strcpy(vvbuf,"unknown");
2449: return(vvbuf);
2450:
2451: case VN_CMDF: /* Current command file name */
2452: return(tfnam[tlevel] ? tfnam[tlevel] : "");
2453:
2454: case VN_MAC: /* Current macro name */
2455: return((maclvl > -1) ? m_arg[maclvl][0] : "");
2456:
2457: case VN_EXIT:
2458: sprintf(vvbuf,"%d",xitsta);
2459: return(vvbuf);
2460:
2461: default:
2462: return(NULL);
2463: }
2464: }
2465: #endif /* NOSPL */
2466:
2467: /*
2468: X X S T R I N G -- Expand variables and backslash codes.
2469:
2470: int xxtstring(s,&s2,&n);
2471:
2472: Expands \ escapes via recursive descent.
2473: Argument s is a pointer to string to expand (source).
2474: Argument s2 is the address of where to put result (destination).
2475: Argument n is the length of the destination string (to prevent overruns).
2476: Returns -1 on failure, 0 on success,
2477: with destination string null-terminated and s2 pointing to the
2478: terminating null, so that subsequent characters can be added.
2479: */
2480:
2481: #define XXDEPLIM 100 /* Recursion depth limit */
2482:
2483: int
2484: xxstring(s,s2,n) char *s; char **s2; int *n; {
2485: int x, /* Current character */
2486: y, /* Worker */
2487: pp, /* Paren level */
2488: argn, /* Function argument counter */
2489: n2, /* Local copy of n */
2490: d, /* Array dimension */
2491: vbi, /* Variable id (integer form) */
2492: argl; /* String argument length */
2493:
2494: char vb, /* Variable id (char form) */
2495: *vp, /* Pointer to variable definition */
2496: *new, /* Local pointer to target string */
2497: *p, /* Worker */
2498: *q; /* Worker */
2499: char *r = (char *)0; /* For holding function args */
2500: char *r2 = (char *)0;
2501:
2502: #ifndef NOSPL
2503: char vnambuf[VNAML]; /* Buffer for variable/function name */
2504: char *argp[FNARGS]; /* Pointers to function args */
2505: #endif /* NOSPL */
2506:
2507: static int depth = 0; /* Call depth, avoid overflow */
2508:
2509: n2 = *n; /* Make local copies of args */
2510: new = *s2; /* for one less level of indirection */
2511:
2512: depth++; /* Sink to a new depth */
2513: if (depth > XXDEPLIM) { /* Too deep? */
2514: printf("?definition is circular or too deep\n");
2515: depth = 0;
2516: *new = NUL;
2517: return(-1);
2518: }
2519: if (!s || !new) { /* Watch out for null pointers */
2520: depth = 0;
2521: *new = NUL;
2522: return(-1);
2523: }
2524: argl = (int)strlen(s); /* Get length of source string */
2525: debug(F111,"xxstring",s,argl);
2526: if (argl < 0) { /* Watch out for garbage */
2527: depth = 0;
2528: *new = NUL;
2529: return(-1);
2530: }
2531: while ( x = *s ) { /* Loop for all characters */
2532: if (x != CMDQ) { /* Is it the command-quote char? */
2533: *new++ = *s++; /* No, normal char, just copy */
2534: if (n2-- < 0) { /* and count it, careful of overflow */
2535: return(-1);
2536: }
2537: continue;
2538: }
2539:
2540: /* We have the command-quote character. */
2541:
2542: x = *(s+1); /* Get the following character. */
2543: switch (x) { /* Act according to variable type */
2544: #ifndef NOSPL
2545: case '%': /* Variable */
2546: s += 2; /* Get the letter or digit */
2547: vb = *s++; /* and move source pointer past it */
2548: vp = NULL; /* Assume definition is empty */
2549: if (vb >= '0' && vb <= '9') { /* Digit for macro arg */
2550: if (maclvl < 0) /* Digit variables are global */
2551: vp = g_var[vb]; /* if no macro is active */
2552: else /* otherwise */
2553: vp = m_arg[maclvl][vb - '0']; /* they're on the stack */
2554: } else {
2555: if (isupper(vb)) vb -= ('a'-'A');
2556: vp = g_var[vb]; /* Letter for global variable */
2557: }
2558: if (vp) { /* If definition not empty */
2559: if (xxstring(vp,&new,&n2) < 0) { /* call self to evaluate it */
2560: return(-1); /* Pass along failure */
2561: }
2562: }
2563: break;
2564: case '&': /* An array reference */
2565: if (arraynam(s,&vbi,&d) < 0) { /* Get name and subscript */
2566: return(-1);
2567: }
2568: pp = 0; /* Bracket counter */
2569: while (*s) { /* Advance source pointer */
2570: if (*s == '[') pp++;
2571: if (*s == ']' && --pp == 0) break;
2572: s++;
2573: }
2574: if (*s == ']') s++; /* past the closing bracket. */
2575: if (chkarray(vbi,d) > 0) { /* Array is declared? */
2576: vbi -= 96; /* Convert name to index */
2577: if (a_dim[vbi] >= d) { /* If subscript in range */
2578: char **ap;
2579: ap = a_ptr[vbi]; /* get data pointer */
2580: if (ap) { /* and if there is one */
2581: if (ap[d]) { /* If definition not empty */
2582: if (xxstring(ap[d],&new,&n2) < 0) { /* evaluate */
2583: return(-1); /* Pass along failure */
2584: }
2585: }
2586: }
2587: }
2588: }
2589: break;
2590:
2591: case 'F': /* A builtin function */
2592: case 'f':
2593: q = vnambuf; /* Copy the name */
2594: y = 0; /* into a separate buffer */
2595: s+=2; /* point past 'F' */
2596: while (y++ < VNAML) {
2597: if (*s == '(') { s++; break; } /* Look for open paren */
2598: if ((*q = *s) == NUL) break; /* or end of string */
2599: s++; q++;
2600: }
2601: *q = NUL; /* Terminate function name */
2602: if (y >= VNAML) { /* Handle pathological case */
2603: while (*s && (*s != '(')) /* of very long string entered */
2604: s++; /* as function name. */
2605: if (*s == ')') s++; /* Skip past it. */
2606: }
2607: r = r2 = malloc(argl+2); /* And make a place to copy args */
2608: debug(F101,"xxstring r2","",r2);
2609: if (!r2) { /* Watch out for malloc failure */
2610: depth = 0;
2611: *new = NUL;
2612: return(-1);
2613: }
2614: argn = 0; /* Argument counter */
2615: argp[argn++] = r; /* Point to first argument */
2616: y = 0; /* Completion flag */
2617: pp = 1; /* Paren level (already have one). */
2618: while (*r = *s) { /* Copy each argument, char by char. */
2619: if (*r == '(') pp++; /* Count an opening paren. */
2620: if (*r == ')') { /* Closing paren, count it. */
2621: if (--pp == 0) { /* Final one? */
2622: *r = NUL; /* Make it a terminating null */
2623: s++;
2624: y = 1; /* Flag we've got all the args */
2625: break;
2626: }
2627: }
2628: if (*r == ',') { /* Comma */
2629: if (pp == 1) { /* If not within ()'s, */
2630: *r = NUL; /* new arg, skip past it, */
2631: argp[argn++] = r+1; /* point to new arg. */
2632: if (argn == FNARGS) /* Too many args */
2633: break;
2634: } /* Otherwise just skip past */
2635: }
2636: s++; r++; /* Advance pointers */
2637: }
2638: debug(F110,"xxstring function name",vnambuf,0);
2639: if (!y) { /* If we didn't find closing paren */
2640: debug(F101,"xxstring r2 before free","",r2);
2641: if (r2) free(r2); /* free the temporary storage */
2642: return(-1); /* and return failure. */
2643: }
2644: #ifdef DEBUG
2645: if (deblog)
2646: for (y = 0; y < argn; y++)
2647: debug(F111,"xxstring function arg",argp[y],y);
2648: #endif /* DEBUG */
2649: vp = fneval(vnambuf,argp,argn); /* Evaluate the function. */
2650: if (vp) { /* If definition not empty */
2651: while (*new++ = *vp++) /* copy it to output string */
2652: if (n2-- < 0) return(-1); /* mindful of overflow */
2653: new--; /* Back up over terminating null */
2654: n2++; /* to allow for further deposits. */
2655: }
2656: if (r2) {
2657: debug(F101,"xxstring freeing r2","",r2);
2658: free(r2); /* Now free the temporary storage */
2659: r2 = NULL;
2660: }
2661: break;
2662: case '$': /* An environment variable */
2663: case 'V': /* Or a named builtin variable. */
2664: case 'v':
2665: case 'M': /* Or a macro = long variable */
2666: case 'm':
2667: p = s+2; /* $/V/M must be followed by (name) */
2668: if (*p != '(') { /* as in \$(HOME) or \V(count) */
2669: *new++ = *s++; /* If not, just copy it */
2670: if (n2-- < 0) {
2671: return(-1);
2672: }
2673: break;
2674: }
2675: p++; /* Point to 1st char of name */
2676: q = vnambuf; /* Copy the name */
2677: y = 0; /* into a separate buffer */
2678: while (y++ < VNAML) { /* Watch out for name too long */
2679: if (*p == ')') { /* Name properly terminated with ')' */
2680: p++; /* Move source pointer past ')' */
2681: break;
2682: }
2683: if ((*q = *p) == NUL) /* String ends before ')' */
2684: break;
2685: p++; q++; /* Advance pointers */
2686: }
2687: *q = NUL; /* Terminate the variable name */
2688: if (y >= VNAML) { /* Handle pathological case */
2689: while (*p && (*p != ')')) /* of very long string entered */
2690: p++; /* as variable name. */
2691: if (*p == ')') p++; /* Skip ahead to the end of it. */
2692: }
2693: s = p; /* Adjust global source pointer */
2694: p = malloc((int)strlen(vnambuf) + 1); /* Make temporary space */
2695: if (p) { /* If we got the space */
2696: vp = vnambuf; /* Point to original */
2697: strcpy(p,vp); /* Make a copy of it */
2698: y = VNAML; /* Length of name buffer */
2699: xxstring(p,&vp,&y); /* Evaluate the copy */
2700: free(p); /* Free the temporary space */
2701: }
2702: debug(F110,"xxstring vname",vnambuf,0);
2703: if (x == '$') { /* Look up its value */
2704: vp = getenv(vnambuf); /* This way for environment variable */
2705: } else if (x == 'm' || x == 'M') { /* or this way for macro */
2706: y = mlook(mactab,vnambuf,nmac); /* contents (= long variable */
2707: vp = (y > -1) ? mactab[y].mval : ""; /* name)... */
2708: } else { /* or */
2709: vp = nvlook(vnambuf); /* this way for builtin variable */
2710: }
2711: if (vp) { /* If definition not empty */
2712: while (*new++ = *vp++) /* copy it to output string. */
2713: if (n2-- < 0) {
2714: return(-1);
2715: }
2716: new--; /* Back up over terminating null */
2717: n2++; /* to allow for further deposits. */
2718: }
2719: break;
2720: #endif /* NOSPL */ /* Handle \nnn even if NOSPL. */
2721: default: /* Maybe it's a backslash code */
2722: y = xxesc(&s); /* Go interpret it */
2723: if (y < 0) { /* Upon failure */
2724: *new++ = x; /* Just quote the next character */
2725: s += 2; /* Move past the pair */
2726: n2 -= 2;
2727: if (n2 < 0) {
2728: return(-1);
2729: }
2730: continue; /* and go back for more */
2731: } else {
2732: *new++ = y; /* else deposit interpreted value */
2733: if (n2-- < 0) {
2734: return(-1);
2735: }
2736: }
2737: }
2738: }
2739: *new = NUL; /* Terminate the new string */
2740: depth--; /* Adjust stack depth gauge */
2741: *s2 = new; /* Copy results back into */
2742: *n = n2; /* the argument addresses */
2743: return(0); /* and return. */
2744: }
2745: #endif /* NOICP */
2746:
2747:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.