1 | #include "ckcsym.h" |
---|
2 | |
---|
3 | #ifndef NOICP |
---|
4 | |
---|
5 | /* C K U U S 5 -- "User Interface" for C-Kermit, part 5 */ |
---|
6 | |
---|
7 | /* |
---|
8 | Author: Frank da Cruz <fdc@columbia.edu>, |
---|
9 | Columbia University Academic Information Systems, New York City. |
---|
10 | |
---|
11 | Copyright (C) 1985, 1996, Trustees of Columbia University in the City of New |
---|
12 | York. The C-Kermit software may not be, in whole or in part, licensed or |
---|
13 | sold for profit as a software product itself, nor may it be included in or |
---|
14 | distributed with commercial products or otherwise distributed by commercial |
---|
15 | concerns to their clients or customers without written permission of the |
---|
16 | Office of Kermit Development and Distribution, Columbia University. This |
---|
17 | copyright notice must not be removed, altered, or obscured. |
---|
18 | */ |
---|
19 | |
---|
20 | /* Includes */ |
---|
21 | |
---|
22 | #include "ckcdeb.h" |
---|
23 | #include "ckcasc.h" |
---|
24 | #include "ckcker.h" |
---|
25 | #include "ckuusr.h" |
---|
26 | #include "ckcnet.h" |
---|
27 | #ifndef NOCSETS |
---|
28 | #include "ckcxla.h" |
---|
29 | #endif /* NOCSETS */ |
---|
30 | #ifdef MAC |
---|
31 | #include "ckmasm.h" |
---|
32 | #endif /* MAC */ |
---|
33 | |
---|
34 | #ifdef OS2 |
---|
35 | #include "ckoetc.h" |
---|
36 | #ifndef NT |
---|
37 | #define INCL_NOPM |
---|
38 | #define INCL_VIO /* Needed for ckocon.h */ |
---|
39 | #include <os2.h> |
---|
40 | #else /* NT */ |
---|
41 | #define APIRET ULONG |
---|
42 | extern int DialerHandle; |
---|
43 | extern int StartedFromDialer; |
---|
44 | #endif /* NT */ |
---|
45 | #include "ckouni.h" |
---|
46 | #include "ckocon.h" |
---|
47 | #include "ckokey.h" |
---|
48 | #ifdef putchar |
---|
49 | #undef putchar |
---|
50 | #endif /* putchar */ |
---|
51 | #define putchar(x) conoc(x) |
---|
52 | extern int cursor_save ; |
---|
53 | extern bool cursorena[] ; |
---|
54 | #endif /* OS2 */ |
---|
55 | |
---|
56 | /* For formatted screens, "more?" prompting, etc. */ |
---|
57 | |
---|
58 | #ifdef FT18 |
---|
59 | #define isxdigit(c) isdigit(c) |
---|
60 | #endif /* FT18 */ |
---|
61 | |
---|
62 | #ifdef STRATUS /* Stratus Computer, Inc. VOS */ |
---|
63 | #ifdef putchar |
---|
64 | #undef putchar |
---|
65 | #endif /* putchar */ |
---|
66 | #define putchar(x) conoc(x) |
---|
67 | #ifdef getchar |
---|
68 | #undef getchar |
---|
69 | #endif /* getchar */ |
---|
70 | #define getchar(x) coninc(0) |
---|
71 | #endif /* STRATUS */ |
---|
72 | |
---|
73 | /* External variables */ |
---|
74 | |
---|
75 | extern int carrier, cdtimo, local, quiet, backgrd, bgset, sosi, suspend, |
---|
76 | displa, binary, deblog, escape, xargs, flow, cmdmsk, bye_active, |
---|
77 | duplex, ckxech, pktlog, seslog, tralog, what, protocol, |
---|
78 | keep, warn, tlevel, cwdf, nfuncs, unkcs, msgflg, remfile, rempipe, remappd, |
---|
79 | mdmtyp, zincnt, cmask, rcflag, success, xitsta, pflag, lf_opts, tnlm, tn_nlm, |
---|
80 | xfrcan, xfrchr, xfrnum, xitwarn, debses, pktpaus, moving, autodl, xaskmore; |
---|
81 | |
---|
82 | extern int ngetpath, exitonclose; |
---|
83 | extern char * getpath[]; |
---|
84 | |
---|
85 | #ifndef NOSERVER |
---|
86 | extern char * x_user, * x_passwd, * x_acct; |
---|
87 | #endif /* NOSERVER */ |
---|
88 | |
---|
89 | #ifndef NOSPL |
---|
90 | extern int cfilef, DeleteStartupFile; |
---|
91 | extern char cmdfil[]; |
---|
92 | |
---|
93 | struct localvar * localhead[MACLEVEL]; |
---|
94 | struct localvar * localtail = NULL; |
---|
95 | struct localvar * localnext = NULL; |
---|
96 | |
---|
97 | _PROTOTYP( static char gettok, (void) ); |
---|
98 | _PROTOTYP( static VOID factor, (void) ); |
---|
99 | _PROTOTYP( static VOID term, (void) ); |
---|
100 | _PROTOTYP( static VOID termp, (void) ); |
---|
101 | _PROTOTYP( static VOID exprp, (void) ); |
---|
102 | _PROTOTYP( static VOID expr, (void) ); |
---|
103 | _PROTOTYP( static VOID simple, (void) ); |
---|
104 | _PROTOTYP( static VOID simpler, (void) ); |
---|
105 | _PROTOTYP( static VOID simplest, (void) ); |
---|
106 | _PROTOTYP( static long xparse, (void) ); |
---|
107 | #endif /* NOSPL */ |
---|
108 | |
---|
109 | #ifdef MAC |
---|
110 | char * ckprompt = "Mac-Kermit>"; /* Default prompt for Macintosh */ |
---|
111 | #else /* Not MAC */ |
---|
112 | #ifdef NOSPL |
---|
113 | #ifdef NT |
---|
114 | char * ckprompt = "K-95> "; /* Default prompt for Win32 */ |
---|
115 | #else |
---|
116 | char * ckprompt = "C-Kermit>"; |
---|
117 | #endif /* NT */ |
---|
118 | #else /* NOSPL */ |
---|
119 | #ifdef NT |
---|
120 | char * ckprompt = "[\\v(dir)] K-95> "; /* Default prompt for Windows NT */ |
---|
121 | #else |
---|
122 | #ifdef VMS |
---|
123 | char * ckprompt = "\\v(dir) C-Kermit>"; /* Default prompt VMS */ |
---|
124 | #else |
---|
125 | char * ckprompt = "[\\v(dir)] C-Kermit>"; /* Default prompt for others */ |
---|
126 | #endif /* VMS */ |
---|
127 | #endif /* NT */ |
---|
128 | #endif /* NOSPL */ |
---|
129 | #endif /* MAC */ |
---|
130 | |
---|
131 | #ifndef CCHMAXPATH |
---|
132 | #define CCHMAXPATH 257 |
---|
133 | #endif /* CCHMAXPATH */ |
---|
134 | char inidir[CCHMAXPATH] = { NUL, NUL }; /* Directory INI file executed from */ |
---|
135 | |
---|
136 | #ifdef TCPSOCKET |
---|
137 | extern int tn_b_nlm; /* TELNET BINARY newline mode */ |
---|
138 | extern int me_binary, u_binary; |
---|
139 | #endif /* TCPSOCKET */ |
---|
140 | |
---|
141 | #ifndef NOKVERBS |
---|
142 | extern struct keytab kverbs[]; /* Table of \Kverbs */ |
---|
143 | extern int nkverbs; /* Number of \Kverbs */ |
---|
144 | #endif /* NOKVERBS */ |
---|
145 | |
---|
146 | #ifndef NOPUSH |
---|
147 | extern int nopush; |
---|
148 | #endif /* NOPUSH */ |
---|
149 | |
---|
150 | #ifdef CK_RECALL |
---|
151 | extern int cm_recall; |
---|
152 | #endif /* CK_RECALL */ |
---|
153 | |
---|
154 | extern char *ccntab[]; |
---|
155 | extern char *printfile; |
---|
156 | extern int printpipe; |
---|
157 | |
---|
158 | #ifdef OS2 |
---|
159 | _PROTOTYP (int os2getcp, (void) ); |
---|
160 | _PROTOTYP (int os2getcplist, (int *, int) ); |
---|
161 | #ifdef OS2MOUSE |
---|
162 | extern int tt_mouse; |
---|
163 | #endif /* OS2MOUSE */ |
---|
164 | extern int tt_update, tt_updmode, tt_font, updmode; |
---|
165 | extern struct keytab termfont[]; |
---|
166 | extern int ntermfont; |
---|
167 | extern unsigned char colornormal, colorunderline, colorstatus, |
---|
168 | colorhelp, colorselect, colorborder, colorgraphic, colordebug, |
---|
169 | colorreverse; |
---|
170 | extern int priority; |
---|
171 | extern struct keytab prtytab[]; |
---|
172 | extern int nprty; |
---|
173 | char * cmdmac = NULL; |
---|
174 | #endif /* OS2 */ |
---|
175 | |
---|
176 | #ifdef VMS |
---|
177 | _PROTOTYP (int zkermini, (char *, int, char *) ); |
---|
178 | #endif /* VMS */ |
---|
179 | |
---|
180 | #ifndef NOFRILLS |
---|
181 | extern int en_asg, en_cwd, en_cpy, en_del, en_dir, en_fin, en_bye, en_ret, |
---|
182 | en_get, en_hos, en_que, en_ren, en_sen, en_set, en_spa, en_typ, en_who, |
---|
183 | en_mai, en_pri; |
---|
184 | #endif /* NOFRILLS */ |
---|
185 | extern long vernum; |
---|
186 | extern int srvtim, srvdis, inecho, insilence, inbufsize, nvars, verwho; |
---|
187 | extern char *protv, *fnsv, *cmdv, *userv, *ckxv, *ckzv, *ckzsys, *xlav, |
---|
188 | *cknetv, *clcmds; |
---|
189 | #ifdef OS2 |
---|
190 | extern char *ckonetv; |
---|
191 | #ifdef CK_NETBIOS |
---|
192 | extern char *ckonbiv; |
---|
193 | #endif /* CK_NETBIOS */ |
---|
194 | #ifdef OS2MOUSE |
---|
195 | extern char *ckomouv; |
---|
196 | #endif /* OS2MOUSE */ |
---|
197 | #endif /* OS2 */ |
---|
198 | extern char *connv, *dialv, *loginv, *nvlook(); |
---|
199 | |
---|
200 | #ifndef NOSCRIPT |
---|
201 | extern int secho; |
---|
202 | #endif /* NOSCRIPT */ |
---|
203 | |
---|
204 | #ifndef NODIAL |
---|
205 | extern int nmdm, dirline; |
---|
206 | extern struct keytab mdmtab[]; |
---|
207 | #endif /* NODIAL */ |
---|
208 | |
---|
209 | #ifdef NETCONN |
---|
210 | extern int network, ttnproto; |
---|
211 | #endif /* NETCONN */ |
---|
212 | |
---|
213 | #ifdef OS2 |
---|
214 | /* SET TERMINAL items... */ |
---|
215 | extern int tt_type, tt_arrow, tt_keypad, tt_wrap, tt_answer, tt_scrsize[]; |
---|
216 | extern int tt_bell, tt_roll[], tt_ctstmo, tt_cursor, tt_pacing; |
---|
217 | extern char answerback[]; |
---|
218 | #ifdef COMMENT |
---|
219 | extern int tt_hide; |
---|
220 | #endif /* COMMENT */ |
---|
221 | extern struct tt_info_rec tt_info[]; /* Indexed by terminal type */ |
---|
222 | extern int max_tt; |
---|
223 | #endif /* OS2 */ |
---|
224 | |
---|
225 | #ifdef CK_TTGWSIZ |
---|
226 | _PROTOTYP( int ttgwsiz, (void) ); |
---|
227 | #endif /* CK_TTGWSIZ */ |
---|
228 | _PROTOTYP( VOID shotrm, (void) ); |
---|
229 | _PROTOTYP( VOID shofea, (void) ); |
---|
230 | |
---|
231 | #ifdef OS2 |
---|
232 | extern int tt_rows[], tt_cols[]; |
---|
233 | #else /* OS2 */ |
---|
234 | extern int tt_rows, tt_cols; |
---|
235 | #endif /* OS2 */ |
---|
236 | int cmd_rows = 24, cmd_cols = 80; |
---|
237 | |
---|
238 | #ifdef CK_TMPDIR |
---|
239 | extern int f_tmpdir; /* Directory changed temporarily */ |
---|
240 | extern char savdir[]; /* Temporary directory */ |
---|
241 | #endif /* CK_TMPDIR */ |
---|
242 | |
---|
243 | #ifndef NOLOCAL |
---|
244 | extern int tt_crd, tt_escape; |
---|
245 | #endif /* NOLOCAL */ |
---|
246 | |
---|
247 | #ifndef NOCSETS |
---|
248 | extern int language, nfilc, tcsr, tcsl; |
---|
249 | extern struct keytab fcstab[]; |
---|
250 | extern struct csinfo fcsinfo[]; |
---|
251 | #ifndef MAC |
---|
252 | extern struct keytab ttcstab[]; |
---|
253 | #endif /* MAC */ |
---|
254 | #endif /* NOCSETS */ |
---|
255 | |
---|
256 | extern int atcapr, |
---|
257 | atenci, atenco, atdati, atdato, atleni, atleno, atblki, atblko, |
---|
258 | attypi, attypo, atsidi, atsido, atsysi, atsyso, atdisi, atdiso; |
---|
259 | |
---|
260 | #ifdef STRATUS |
---|
261 | extern int atfrmi, atfrmo, atcrei, atcreo, atacti, atacto; |
---|
262 | #endif /* STRATUS */ |
---|
263 | |
---|
264 | extern long speed; |
---|
265 | |
---|
266 | extern char *DIRCMD, *PWDCMD, *DELCMD; |
---|
267 | #ifndef NOXMIT |
---|
268 | extern int xmitf, xmitl, xmitp, xmitx, xmits, xmitw; |
---|
269 | extern char xmitbuf[]; |
---|
270 | #endif /* NOXMIT */ |
---|
271 | |
---|
272 | extern char **xargv, *versio, *ckxsys, *dftty, *cmarg, *lp; |
---|
273 | |
---|
274 | #ifdef DCMDBUF |
---|
275 | extern char *cmdbuf, *atmbuf; /* Command buffers */ |
---|
276 | #ifndef NOSPL |
---|
277 | extern char *savbuf; /* Command buffers */ |
---|
278 | #endif /* NOSPL */ |
---|
279 | #else |
---|
280 | extern char cmdbuf[], atmbuf[]; /* Command buffers */ |
---|
281 | #ifndef NOSPL |
---|
282 | extern char savbuf[]; /* Command buffers */ |
---|
283 | #endif /* NOSPL */ |
---|
284 | #endif /* DCMDBUF */ |
---|
285 | |
---|
286 | extern char toktab[], ttname[], psave[]; |
---|
287 | extern CHAR sstate, feol; |
---|
288 | extern int cmflgs, techo, repars, ncmd; |
---|
289 | extern struct keytab cmdtab[]; |
---|
290 | |
---|
291 | #ifndef NOSETKEY |
---|
292 | KEY *keymap; |
---|
293 | #ifndef OS2 |
---|
294 | #define mapkey(x) keymap[x] |
---|
295 | #endif /* OS2 */ |
---|
296 | MACRO *macrotab; |
---|
297 | _PROTOTYP( VOID shostrdef, (CHAR *) ); |
---|
298 | #endif /* NOSETKEY */ |
---|
299 | |
---|
300 | #ifndef NOSPL |
---|
301 | extern struct mtab *mactab; |
---|
302 | extern struct keytab vartab[], fnctab[]; |
---|
303 | extern int cmdlvl, maclvl, nmac, mecho; |
---|
304 | #endif /* NOSPL */ |
---|
305 | |
---|
306 | FILE *tfile[MAXTAKE]; /* TAKE file stack */ |
---|
307 | char *tfnam[MAXTAKE]; |
---|
308 | int tfline[MAXTAKE]; |
---|
309 | |
---|
310 | #ifdef DCMDBUF /* Initialization filespec */ |
---|
311 | char *kermrc = NULL; |
---|
312 | #else |
---|
313 | char kermrcb[KERMRCL]; |
---|
314 | char *kermrc = kermrcb; |
---|
315 | #endif /* DCMDBUF */ |
---|
316 | |
---|
317 | int noherald = 0; |
---|
318 | int cm_retry = 1; /* Command retry enabled */ |
---|
319 | xx_strp xxstring = zzstring; |
---|
320 | |
---|
321 | #ifndef NOSPL |
---|
322 | |
---|
323 | extern long ck_alarm; |
---|
324 | extern char alrm_date[], alrm_time[]; |
---|
325 | |
---|
326 | extern int query; /* QUERY active */ |
---|
327 | |
---|
328 | /* Local declarations */ |
---|
329 | |
---|
330 | static int nulcmd = 0; /* Flag for next cmd to be ignored */ |
---|
331 | |
---|
332 | /* Definitions for predefined macros */ |
---|
333 | |
---|
334 | /* First, the single-line macros, installed with addmac()... */ |
---|
335 | |
---|
336 | /* IBM-LINEMODE macro */ |
---|
337 | char *m_ibm = "set parity mark, set dupl half, set handsh xon, set flow none"; |
---|
338 | |
---|
339 | /* FATAL macro */ |
---|
340 | char *m_fat = "if def \\%1 echo \\%1, if not = \\v(local) 0 hangup, stop 1"; |
---|
341 | |
---|
342 | #ifdef CK_SPEED |
---|
343 | #ifdef pdp11 |
---|
344 | char *m_fast = "set win 3, set rec pack 1024, set prefix minimal"; |
---|
345 | #else |
---|
346 | #ifdef BIGBUFOK |
---|
347 | char *m_fast = "set win 20, set rec pack 4096, set prefix minimal"; |
---|
348 | #else |
---|
349 | char *m_fast = "set win 4, set rec pack 2200, set prefix minimal"; |
---|
350 | #endif /* BIGBUFOK */ |
---|
351 | #endif /* pdp11 */ |
---|
352 | #ifdef pdp11 |
---|
353 | char *m_cautious = "set win 2, set rec pack 512, set prefixing cautious"; |
---|
354 | #else |
---|
355 | char *m_cautious = "set win 4, set rec pack 1000, set prefixing cautious"; |
---|
356 | #endif /* pdp11 */ |
---|
357 | char *m_robust = "set win 1, set rec pack 90, set prefixing all"; |
---|
358 | #else |
---|
359 | #ifdef BIGBUFOK |
---|
360 | char *m_fast = "set win 20, set rec pack 4096"; |
---|
361 | #else |
---|
362 | char *m_fast = "set win 4, set rec pack 2200"; |
---|
363 | #endif /* BIGBUFOK */ |
---|
364 | char *m_cautious = "set win 4, set rec pack 1000"; |
---|
365 | char *m_robust = "set win 1, set rec pack 90"; |
---|
366 | #endif /* CK_SPEED */ |
---|
367 | |
---|
368 | /* Now the multiline macros, defined with addmmac()... */ |
---|
369 | |
---|
370 | /* FOR macro */ |
---|
371 | char *for_def[] = { "_assign _for\\v(cmdlevel) { _getargs,", |
---|
372 | "define \\\\\\%1 \\feval(\\%2),:_..top,if \\%5 \\\\\\%1 \\%3 goto _..bot,", |
---|
373 | "\\%6,:_..inc,incr \\\\\\%1 \\%4,goto _..top,:_..bot,_putargs},", |
---|
374 | "def break goto _..bot, def continue goto _..inc,", |
---|
375 | "do _for\\v(cmdlevel) \\%1 \\%2 \\%3 \\%4 { \\%5 },_assign _for\\v(cmdlevel)", |
---|
376 | ""}; |
---|
377 | |
---|
378 | /* WHILE macro */ |
---|
379 | char *whil_def[] = { "_assign _whi\\v(cmdlevel) {_getargs,", |
---|
380 | ":_..inc,\\%1,\\%2,goto _..inc,:_..bot,_putargs},", |
---|
381 | "_def break goto _..bot, _def continue goto _..inc,", |
---|
382 | "do _whi\\v(cmdlevel),_assign _whi\\v(cmdlevel)", |
---|
383 | ""}; |
---|
384 | |
---|
385 | /* SWITCH macro */ |
---|
386 | char *sw_def[] = { "_assign _sw_\\v(cmdlevel) {_getargs,", |
---|
387 | "_forward \\%1,\\%2,:_..bot,_putargs},_def break goto _..bot,", |
---|
388 | "do _sw_\\v(cmdlevel),_assign _sw_\\v(cmdlevel)", |
---|
389 | ""}; |
---|
390 | |
---|
391 | /* XIF macro */ |
---|
392 | char *xif_def[] = { |
---|
393 | "_assign _if\\v(cmdlevel) {_getargs,\\%1,_putargs},", |
---|
394 | "do _if\\v(cmdlevel),_assign _if\\v(cmdlevel)", |
---|
395 | ""}; |
---|
396 | |
---|
397 | /* |
---|
398 | Variables declared here for use by other ckuus*.c modules. |
---|
399 | Space is allocated here to save room in ckuusr.c. |
---|
400 | */ |
---|
401 | #ifdef DCMDBUF |
---|
402 | struct cmdptr *cmdstk; |
---|
403 | int *ifcmd, *count, *iftest, *intime, *inpcas, *takerr, *merror; |
---|
404 | #else |
---|
405 | struct cmdptr cmdstk[CMDSTKL]; |
---|
406 | int ifcmd[CMDSTKL], count[CMDSTKL], iftest[CMDSTKL], intime[CMDSTKL], |
---|
407 | inpcas[CMDSTKL], takerr[CMDSTKL], merror[CMDSTKL]; |
---|
408 | #endif /* DCMDBUF */ |
---|
409 | |
---|
410 | char *m_arg[MACLEVEL][NARGS]; |
---|
411 | char *g_var[GVARS], *macp[MACLEVEL], *mrval[MACLEVEL]; |
---|
412 | int macargc[MACLEVEL]; |
---|
413 | char *macx[MACLEVEL]; |
---|
414 | extern char varnam[]; |
---|
415 | |
---|
416 | /* Dimension must be 'z' - ARRAYBASE + 1 */ |
---|
417 | |
---|
418 | char **a_ptr[28]; /* Array pointers, for arrays a-z */ |
---|
419 | int a_dim[28]; /* Dimensions for each array */ |
---|
420 | |
---|
421 | char * inpbuf = NULL; /* Buffer for INPUT and REINPUT */ |
---|
422 | extern char * inpbp; /* Global/static pointer to it */ |
---|
423 | char inchar[2] = { NUL, NUL }; /* Last character that was INPUT */ |
---|
424 | int incount = 0; /* INPUT character count */ |
---|
425 | extern int instatus; /* INPUT status */ |
---|
426 | static char * i_text[] = { /* INPUT status text */ |
---|
427 | "success", "timeout", "interrupted", "internal error", "i/o error" |
---|
428 | }; |
---|
429 | |
---|
430 | char lblbuf[LBLSIZ]; /* Buffer for labels */ |
---|
431 | #else |
---|
432 | int takerr[MAXTAKE]; |
---|
433 | #endif /* NOSPL */ |
---|
434 | |
---|
435 | int pacing = 0; /* OUTPUT pacing */ |
---|
436 | |
---|
437 | #ifdef DCMDBUF |
---|
438 | char *line; /* Character buffer for anything */ |
---|
439 | char *tmpbuf; |
---|
440 | #else |
---|
441 | char line[LINBUFSIZ]; |
---|
442 | char tmpbuf[TMPBUFSIZ]; /* Temporary buffer */ |
---|
443 | #endif /* DCMDBUF */ |
---|
444 | char *tp; /* Temporary buffer pointer */ |
---|
445 | |
---|
446 | #ifdef CK_APC /* Application Program Command (APC) */ |
---|
447 | int apcactive = APC_INACTIVE; |
---|
448 | int apcstatus = APC_OFF; /* OFF by default everywhere */ |
---|
449 | #ifdef DCMDBUF |
---|
450 | char *apcbuf; |
---|
451 | #else |
---|
452 | char apcbuf[APCBUFLEN]; |
---|
453 | #endif /* DCMDBUF */ |
---|
454 | #endif /* CK_APC */ |
---|
455 | |
---|
456 | extern char pktfil[], |
---|
457 | #ifdef DEBUG |
---|
458 | debfil[], |
---|
459 | #endif /* DEBUG */ |
---|
460 | #ifdef TLOG |
---|
461 | trafil[], |
---|
462 | #endif /* TLOG */ |
---|
463 | sesfil[]; |
---|
464 | |
---|
465 | #ifndef NOFRILLS |
---|
466 | extern int rmailf, rprintf; /* REMOTE MAIL & PRINT items */ |
---|
467 | extern char optbuf[]; |
---|
468 | #endif /* NOFRILLS */ |
---|
469 | |
---|
470 | char *homdir = ""; /* Pointer to home directory string */ |
---|
471 | |
---|
472 | char numbuf[20]; /* Buffer for numeric strings. */ |
---|
473 | int noinit = 0; /* Flag for skipping init file */ |
---|
474 | |
---|
475 | #ifndef NOSPL |
---|
476 | _PROTOTYP( VOID freelocal, (int) ); |
---|
477 | _PROTOTYP( static long expon, (long, long) ); |
---|
478 | _PROTOTYP( static long gcd, (long, long) ); |
---|
479 | _PROTOTYP( static long fact, (long) ); |
---|
480 | |
---|
481 | int /* Initialize macro data structures. */ |
---|
482 | macini() { /* Allocate mactab and preset the first element. */ |
---|
483 | int i; |
---|
484 | if (!(mactab = (struct mtab *) malloc(sizeof(struct mtab) * MAC_MAX))) |
---|
485 | return(-1); |
---|
486 | mactab[0].kwd = NULL; |
---|
487 | mactab[0].mval = NULL; |
---|
488 | mactab[0].flgs = 0; |
---|
489 | for (i = 0; i < MACLEVEL; i++) |
---|
490 | localhead[i] = NULL; |
---|
491 | return(0); |
---|
492 | } |
---|
493 | #endif /* NOSPL */ |
---|
494 | |
---|
495 | /* C M D I N I -- Initialize the interactive command parser */ |
---|
496 | |
---|
497 | static int cmdinited = 0; |
---|
498 | |
---|
499 | VOID |
---|
500 | cmdini() { |
---|
501 | int i, x, y, z, n; |
---|
502 | #ifndef NOSPL |
---|
503 | /* |
---|
504 | On stack to allow recursion! |
---|
505 | */ |
---|
506 | char vnambuf[VNAML]; /* Buffer for variable names */ |
---|
507 | #endif /* NOSPL */ |
---|
508 | |
---|
509 | if (cmdinited) |
---|
510 | return; |
---|
511 | |
---|
512 | #ifndef NOSETKEY /* Allocate & initialize the keymap */ |
---|
513 | if (!(keymap = (KEY *) malloc(sizeof(KEY)*KMSIZE))) |
---|
514 | fatal("cmdini: no memory for keymap"); |
---|
515 | if (!(macrotab = (MACRO *) malloc(sizeof(MACRO)*KMSIZE))) |
---|
516 | fatal("cmdini: no memory for macrotab"); |
---|
517 | for (i = 0; i < KMSIZE; i++) { |
---|
518 | keymap[i] = (KEY) i; |
---|
519 | macrotab[i] = NULL; |
---|
520 | } |
---|
521 | #endif /* NOSETKEY */ |
---|
522 | |
---|
523 | #ifndef NOSPL |
---|
524 | if (!inpbuf) { |
---|
525 | if (!(inpbuf = (char *) malloc(INPBUFSIZ+1))) |
---|
526 | fatal("cmdini: no memory for INPUT buffer"); |
---|
527 | } |
---|
528 | for (x = 0; x < INPBUFSIZ; x++) |
---|
529 | inpbuf[x] = NUL; |
---|
530 | inpbp = inpbuf; |
---|
531 | inbufsize = INPBUFSIZ; |
---|
532 | #endif /* NOSPL */ |
---|
533 | |
---|
534 | #ifdef DCMDBUF |
---|
535 | if (cmsetup() < 0) fatal("Can't allocate command buffers!"); |
---|
536 | #ifndef NOSPL |
---|
537 | if (!(cmdstk = (struct cmdptr *) malloc(sizeof(struct cmdptr)*CMDSTKL))) |
---|
538 | fatal("cmdini: no memory for cmdstk"); |
---|
539 | if (!(ifcmd = (int *) malloc(sizeof(int)*CMDSTKL))) |
---|
540 | fatal("cmdini: no memory for ifcmd"); |
---|
541 | if (!(count = (int *) malloc(sizeof(int)*CMDSTKL))) |
---|
542 | fatal("cmdini: no memory for count"); |
---|
543 | if (!(iftest = (int *) malloc(sizeof(int)*CMDSTKL))) |
---|
544 | fatal("cmdini: no memory for iftest"); |
---|
545 | if (!(intime = (int *) malloc(sizeof(int)*CMDSTKL))) |
---|
546 | fatal("cmdini: no memory for intime"); |
---|
547 | if (!(inpcas = (int *) malloc(sizeof(int)*CMDSTKL))) |
---|
548 | fatal("cmdini: no memory for inpcas"); |
---|
549 | if (!(takerr = (int *) malloc(sizeof(int)*CMDSTKL))) |
---|
550 | fatal("cmdini: no memory for takerr"); |
---|
551 | if (!(merror = (int *) malloc(sizeof(int)*CMDSTKL))) |
---|
552 | fatal("cmdini: no memory for merror"); |
---|
553 | if (!kermrc) |
---|
554 | if (!(kermrc = (char *) malloc(KERMRCL+1))) |
---|
555 | fatal("cmdini: no memory for kermrc"); |
---|
556 | #endif /* NOSPL */ |
---|
557 | |
---|
558 | if (!(line = malloc(LINBUFSIZ))) |
---|
559 | fatal("cmdini: no memory for line"); |
---|
560 | if (!(tmpbuf = malloc(LINBUFSIZ))) |
---|
561 | fatal("cmdini: no memory for tmpbuf"); |
---|
562 | |
---|
563 | #ifdef CK_APC |
---|
564 | if (!(apcbuf = malloc(APCBUFLEN))) |
---|
565 | fatal("cmdini: no memory for apcbuf"); |
---|
566 | #endif /* CK_APC */ |
---|
567 | |
---|
568 | #endif /* DCMDBUF */ |
---|
569 | |
---|
570 | #ifdef CK_MINPUT |
---|
571 | { /* Initialize MINPUT pointers */ |
---|
572 | int i; |
---|
573 | extern char *ms[]; |
---|
574 | for (i = 0; i < MINPMAX; i++) |
---|
575 | ms[i] = NULL; |
---|
576 | } |
---|
577 | #endif /* CK_MINPUT */ |
---|
578 | |
---|
579 | #ifndef NOSPL |
---|
580 | if (macini() < 0) |
---|
581 | fatal("Can't allocate macro buffers!"); |
---|
582 | |
---|
583 | ifcmd[0] = 0; /* Command-level related variables. */ |
---|
584 | iftest[0] = 0; /* Initialize variables at top level */ |
---|
585 | count[0] = 0; /* of stack... */ |
---|
586 | intime[0] = 0; |
---|
587 | inpcas[0] = 0; |
---|
588 | takerr[0] = 0; |
---|
589 | merror[0] = 0; |
---|
590 | #endif /* NOSPL */ |
---|
591 | |
---|
592 | #ifdef AMIGA |
---|
593 | if (tlevel < 0) |
---|
594 | concb(escape); |
---|
595 | #endif /* AMIGA */ |
---|
596 | |
---|
597 | #ifndef NOSPL |
---|
598 | cmdlvl = 0; /* Initialize the command stack */ |
---|
599 | cmdstk[cmdlvl].src = CMD_KB; /* Source is console */ |
---|
600 | cmdstk[cmdlvl].lvl = 0; /* Level is 0 */ |
---|
601 | cmdstk[cmdlvl].ccflgs = 0; /* No flags */ |
---|
602 | #endif /* NOSPL */ |
---|
603 | |
---|
604 | tlevel = -1; /* Take file level = keyboard */ |
---|
605 | for (i = 0; i < MAXTAKE; i++) /* Initialize command file names */ |
---|
606 | tfnam[i] = NULL; |
---|
607 | |
---|
608 | #ifdef NT |
---|
609 | /* We tell the difference between Windows NT and 95 at runtime. */ |
---|
610 | if (isWin95()) |
---|
611 | #ifdef NOSPL |
---|
612 | ckprompt = "K-95> "; /* Default prompt for Windows 95 */ |
---|
613 | #else |
---|
614 | ckprompt = "[\\v(dir)] K-95> "; |
---|
615 | #endif /* NOSPL */ |
---|
616 | #endif /* NT */ |
---|
617 | cmsetp(ckprompt); |
---|
618 | |
---|
619 | #ifndef NOSPL |
---|
620 | initmac(); /* Initialize macro table */ |
---|
621 | /* Add one-line macros */ |
---|
622 | addmac("ibm-linemode",m_ibm); /* Add built-in macros. */ |
---|
623 | addmac("fatal",m_fat); /* FATAL macro */ |
---|
624 | y = addmac("fast",m_fast); /* FAST macro */ |
---|
625 | addmac("cautious",m_cautious); /* CAUTIOUS macro */ |
---|
626 | addmac("robust",m_robust); /* ROBUST macro */ |
---|
627 | |
---|
628 | /* Add multiline macros */ |
---|
629 | addmmac("_forx",for_def); /* FOR macro. */ |
---|
630 | addmmac("_xif",xif_def); /* XIF macro. */ |
---|
631 | addmmac("_while",whil_def); /* WHILE macro. */ |
---|
632 | addmmac("_switx",sw_def); /* SWITCH macro. */ |
---|
633 | /* Predefine the macro argument vector */ |
---|
634 | strcpy(vnambuf,"\\&_[10]"); /* Macro argument vector */ |
---|
635 | y = arraynam(vnambuf,&x,&z); /* goes in array \&_[] */ |
---|
636 | if (y > -1) { |
---|
637 | dclarray((char)x,z); /* Declare the array */ |
---|
638 | for (i = 0; i < 10; i++) { /* Fill it */ |
---|
639 | sprintf(vnambuf,"\\&_[%d]",i); /* with NULL pointers */ |
---|
640 | addmac(vnambuf,NULL); |
---|
641 | } |
---|
642 | } |
---|
643 | *vnambuf = NUL; |
---|
644 | /* Fill in command line argument vector */ |
---|
645 | sprintf(vnambuf,"\\&@[%d]",xargs); /* Command line argument vector */ |
---|
646 | y = arraynam(vnambuf,&x,&z); /* goes in array \&@[] */ |
---|
647 | if (y > -1) { |
---|
648 | dclarray((char)x,z); /* Declare the array */ |
---|
649 | for (i = 0; i < xargs; i++) { /* Fill it */ |
---|
650 | sprintf(vnambuf,"\\&@[%d]",i); |
---|
651 | addmac(vnambuf,xargv[i]); |
---|
652 | } |
---|
653 | } |
---|
654 | *vnambuf = NUL; |
---|
655 | #endif /* NOSPL */ |
---|
656 | |
---|
657 | #ifdef CK_TTGWSIZ |
---|
658 | #ifdef OS2 |
---|
659 | ttgcwsz(); |
---|
660 | #else /* OS2 */ |
---|
661 | if (ttgwsiz() > 0) { |
---|
662 | if (tt_rows > 0 && tt_cols > 0) { |
---|
663 | cmd_rows = tt_rows; |
---|
664 | cmd_cols = tt_cols; |
---|
665 | } |
---|
666 | } |
---|
667 | #endif /* OS2 */ |
---|
668 | #endif /* CK_TTGWSIZ */ |
---|
669 | |
---|
670 | /* Get our home directory now. This needed in lots of places. */ |
---|
671 | |
---|
672 | homdir = zhome(); |
---|
673 | cmdinited = 1; |
---|
674 | } |
---|
675 | |
---|
676 | VOID |
---|
677 | doinit() { |
---|
678 | #ifdef OS2 |
---|
679 | char * ptr = 0; |
---|
680 | extern int initvik; |
---|
681 | #endif /* OS2 */ |
---|
682 | |
---|
683 | if (!cmdinited) |
---|
684 | cmdini(); |
---|
685 | |
---|
686 | #ifdef MAC |
---|
687 | return; /* Mac Kermit has no init file */ |
---|
688 | |
---|
689 | #else /* !MAC */ |
---|
690 | |
---|
691 | #ifdef OS2 |
---|
692 | keymapinit(); |
---|
693 | keynaminit(); |
---|
694 | #ifdef OS2MOUSE |
---|
695 | mousemapinit(-1,-1); |
---|
696 | #endif /* OS2MOUSE */ |
---|
697 | initvik = 1; |
---|
698 | #endif /* OS2 */ |
---|
699 | |
---|
700 | /* If skipping init file ('-Y' on Kermit command line), return now. */ |
---|
701 | |
---|
702 | if (noinit) { |
---|
703 | kermrc[0] = '\0'; |
---|
704 | inidir[0] = '\0'; |
---|
705 | /* |
---|
706 | But returning from here results in inidir[] never being set to anything. |
---|
707 | Instead it should be set to wherever the init file *would* have been |
---|
708 | executed from. So this bit of code should be removed, and then we should |
---|
709 | sprinkle "if (noinit)" tests throughout the following code until we have |
---|
710 | set inidir[], and then return without actually taking the init file. |
---|
711 | */ |
---|
712 | return; |
---|
713 | } |
---|
714 | |
---|
715 | #ifdef OS2 |
---|
716 | /* |
---|
717 | The -y init file must be fully specified or in the current directory. |
---|
718 | KERMRC is looked for via INIT, DPATH and PATH in that order. Finally, our |
---|
719 | own executable file path is taken and the .EXE suffix is replaced by .INI |
---|
720 | and this is tried as the initialization file. |
---|
721 | */ |
---|
722 | if (rcflag) { |
---|
723 | strcpy(line, kermrc); |
---|
724 | } else { |
---|
725 | char * env = 0; |
---|
726 | #ifdef NT |
---|
727 | env = getenv("K95.INI"); |
---|
728 | #else |
---|
729 | env = getenv("K2.INI"); |
---|
730 | #endif /* NT */ |
---|
731 | if (!env) |
---|
732 | env = getenv("CKERMIT.INI"); |
---|
733 | if (!env) |
---|
734 | env = getenv("CKERMIT_INI"); |
---|
735 | line[0] = '\0'; |
---|
736 | |
---|
737 | if (env) |
---|
738 | strcpy(line,env); |
---|
739 | if (line[0] == 0) |
---|
740 | _searchenv(kermrc,"INIT",line); |
---|
741 | if (line[0] == 0) |
---|
742 | _searchenv(kermrc,"DPATH",line); |
---|
743 | if (line[0] == 0) |
---|
744 | _searchenv(kermrc,"PATH",line); |
---|
745 | if (line[0] == 0) { |
---|
746 | char *pgmptr = GetLoadPath(); |
---|
747 | if (pgmptr) { |
---|
748 | lp = strrchr(pgmptr, '.'); |
---|
749 | strncpy(line, pgmptr, lp - pgmptr); |
---|
750 | strcpy(line + (lp - pgmptr), ".ini"); |
---|
751 | } |
---|
752 | } |
---|
753 | } |
---|
754 | if ((tfile[0] = fopen(line,"r")) != NULL) { |
---|
755 | tlevel = 0; |
---|
756 | tfline[tlevel] = 0; |
---|
757 | if (tfnam[tlevel] = malloc(strlen(line)+1)) |
---|
758 | strcpy(tfnam[tlevel],line); |
---|
759 | #ifndef NOSPL |
---|
760 | cmdlvl++; |
---|
761 | cmdstk[cmdlvl].src = CMD_TF; |
---|
762 | cmdstk[cmdlvl].lvl = tlevel; |
---|
763 | cmdstk[cmdlvl].ccflgs = 0; |
---|
764 | ifcmd[cmdlvl] = 0; |
---|
765 | iftest[cmdlvl] = 0; |
---|
766 | count[cmdlvl] = count[cmdlvl-1]; /* Inherit from previous level */ |
---|
767 | intime[cmdlvl] = intime[cmdlvl-1]; |
---|
768 | inpcas[cmdlvl] = inpcas[cmdlvl-1]; |
---|
769 | takerr[cmdlvl] = takerr[cmdlvl-1]; |
---|
770 | merror[cmdlvl] = merror[cmdlvl-1]; |
---|
771 | #endif /* NOSPL */ |
---|
772 | debug(F110,"doinit init file",line,0); |
---|
773 | } else { |
---|
774 | debug(F100,"doinit no init file","",0); |
---|
775 | } |
---|
776 | strncpy(kermrc,line,KERMRCL); /* XXXX */ |
---|
777 | for (ptr = kermrc; *ptr; ptr++) /* Convert backslashes to slashes */ |
---|
778 | if (*ptr == '\\') |
---|
779 | *ptr = '/'; |
---|
780 | #else /* not OS2 */ |
---|
781 | lp = line; |
---|
782 | lp[0] = '\0'; |
---|
783 | #ifdef GEMDOS |
---|
784 | zkermini(line, rcflag, kermrc); |
---|
785 | #else |
---|
786 | #ifdef VMS |
---|
787 | zkermini(line,LINBUFSIZ,kermrc); |
---|
788 | #else /* not VMS */ |
---|
789 | if (rcflag) { /* If init file name from cmd line */ |
---|
790 | strcpy(lp,kermrc); /* use it, */ |
---|
791 | } else { /* otherwise... */ |
---|
792 | #ifdef CK_INI_A /* If we've a system-wide init file */ |
---|
793 | /* And it takes precedence over the user's... */ |
---|
794 | strncpy(lp,CK_SYSINI,KERMRCL); /* Use it */ |
---|
795 | if (zchki(lp) < 0) { /* (if it exists...) */ |
---|
796 | #endif /* CK_INI_A */ |
---|
797 | line[0] = NUL; |
---|
798 | if (homdir) { /* Home directory for init file. */ |
---|
799 | strcpy(lp,homdir); |
---|
800 | #ifdef STRATUS |
---|
801 | strcat(lp,">"); /* VOS separates dirs with >'s */ |
---|
802 | #else |
---|
803 | if (lp[0] == '/') strcat(lp,"/"); |
---|
804 | #endif /* STRATUS */ |
---|
805 | } |
---|
806 | strcat(lp,kermrc); /* Append the default file name */ |
---|
807 | #ifdef CK_INI_A |
---|
808 | } |
---|
809 | #endif /* CK_INI_A */ |
---|
810 | } |
---|
811 | #ifdef CK_INI_B /* System-wide init defined? */ |
---|
812 | /* But user's ini file takes precedence */ |
---|
813 | if (zchki(lp) < 0) /* If user doesn't have her own, */ |
---|
814 | strncpy(lp,CK_SYSINI,KERMRCL); /* use system-wide one. */ |
---|
815 | #endif /* CK_INI_B */ |
---|
816 | |
---|
817 | #endif /* VMS */ |
---|
818 | #endif /* GEMDOS */ |
---|
819 | |
---|
820 | #ifdef AMIGA |
---|
821 | reqoff(); /* Disable requestors */ |
---|
822 | #endif /* AMIGA */ |
---|
823 | |
---|
824 | debug(F110,"ini file is",line,0); |
---|
825 | if ((tfile[0] = fopen(line,"r")) != NULL) { /* Try to open init file. */ |
---|
826 | tlevel = 0; |
---|
827 | tfline[tlevel] = 0; |
---|
828 | if (tfnam[tlevel] = malloc(strlen(line)+1)) |
---|
829 | strcpy(tfnam[tlevel],line); |
---|
830 | |
---|
831 | strncpy(kermrc,line,KERMRCL); /* XXXX */ |
---|
832 | |
---|
833 | #ifndef NOSPL |
---|
834 | cmdlvl++; |
---|
835 | ifcmd[cmdlvl] = 0; |
---|
836 | iftest[cmdlvl] = 0; |
---|
837 | count[cmdlvl] = count[cmdlvl-1]; /* Inherit from previous level */ |
---|
838 | intime[cmdlvl] = intime[cmdlvl-1]; |
---|
839 | inpcas[cmdlvl] = inpcas[cmdlvl-1]; |
---|
840 | takerr[cmdlvl] = takerr[cmdlvl-1]; |
---|
841 | merror[cmdlvl] = merror[cmdlvl-1]; |
---|
842 | debug(F101,"open ok","",cmdlvl); |
---|
843 | cmdstk[cmdlvl].src = CMD_TF; |
---|
844 | cmdstk[cmdlvl].lvl = tlevel; |
---|
845 | cmdstk[cmdlvl].ccflgs = 0; |
---|
846 | #endif /* NOSPL */ |
---|
847 | debug(F110,"init file",line,0); |
---|
848 | } |
---|
849 | |
---|
850 | #ifdef datageneral |
---|
851 | /* If CKERMIT.INI not found in home directory, look in searchlist */ |
---|
852 | if (homdir && (tlevel < 0)) { |
---|
853 | strcpy(lp,kermrc); |
---|
854 | if ((tfile[0] = fopen(line,"r")) != NULL) { |
---|
855 | tlevel = 0; |
---|
856 | tfline[tlevel] = 0; |
---|
857 | if (tfnam[tlevel] = malloc(strlen(line)+1)) |
---|
858 | strcpy(tfnam[tlevel],line); |
---|
859 | #ifndef NOSPL |
---|
860 | cmdlvl++; |
---|
861 | cmdstk[cmdlvl].src = CMD_TF; |
---|
862 | cmdstk[cmdlvl].lvl = tlevel; |
---|
863 | cmdstk[cmdlvl].ccflgs = 0; |
---|
864 | ifcmd[cmdlvl] = 0; |
---|
865 | iftest[cmdlvl] = 0; |
---|
866 | count[cmdlvl] = count[cmdlvl-1]; /* Inherit from previous level */ |
---|
867 | intime[cmdlvl] = intime[cmdlvl-1]; |
---|
868 | inpcas[cmdlvl] = inpcas[cmdlvl-1]; |
---|
869 | takerr[cmdlvl] = takerr[cmdlvl-1]; |
---|
870 | merror[cmdlvl] = merror[cmdlvl-1]; |
---|
871 | #endif /* NOSPL */ |
---|
872 | } |
---|
873 | } |
---|
874 | #endif /* datageneral */ |
---|
875 | |
---|
876 | #ifdef AMIGA /* Amiga... */ |
---|
877 | reqpop(); /* Restore requestors */ |
---|
878 | #endif /* AMIGA */ |
---|
879 | #endif /* OS2 */ |
---|
880 | #endif /* MAC */ |
---|
881 | |
---|
882 | /* Assign value to inidir */ |
---|
883 | |
---|
884 | strcpy(inidir, kermrc); |
---|
885 | { |
---|
886 | int x; |
---|
887 | x = strlen(inidir); |
---|
888 | if (x > 0) { |
---|
889 | int i; |
---|
890 | for (i = x - 1; i > 0; i-- ) { |
---|
891 | if (inidir[i] == |
---|
892 | #ifdef MAC |
---|
893 | '/' |
---|
894 | #else |
---|
895 | #ifdef UNIX |
---|
896 | '/' |
---|
897 | #else |
---|
898 | #ifdef OSK |
---|
899 | '/' |
---|
900 | #else |
---|
901 | #ifdef STRATUS |
---|
902 | '>' |
---|
903 | #else |
---|
904 | #ifdef VMS |
---|
905 | ']' || inidir[i] == ':' |
---|
906 | #else |
---|
907 | #ifdef datageneral |
---|
908 | ':' |
---|
909 | #else |
---|
910 | #ifdef OS2 |
---|
911 | '/' || inidir[i+1] == '\\' |
---|
912 | #else |
---|
913 | #ifdef AMIGA |
---|
914 | '/' || inidir[i+1] == ':' |
---|
915 | |
---|
916 | #endif /* AMIGA */ |
---|
917 | #endif /* OS2 */ |
---|
918 | #endif /* datageneral */ |
---|
919 | #endif /* VMS */ |
---|
920 | #endif /* STRATUS */ |
---|
921 | #endif /* OSK */ |
---|
922 | #endif /* UNIX */ |
---|
923 | #endif /* MAC */ |
---|
924 | ) { |
---|
925 | inidir[i+1] = NUL; |
---|
926 | break; |
---|
927 | } |
---|
928 | } |
---|
929 | } |
---|
930 | } |
---|
931 | } |
---|
932 | |
---|
933 | #ifndef NOSPL |
---|
934 | /* |
---|
935 | G E T N C M |
---|
936 | |
---|
937 | Get next command from current macro definition. |
---|
938 | |
---|
939 | Moved to a separate routine in edit 181 to allow multiline GET |
---|
940 | to work when issued in a macro. |
---|
941 | |
---|
942 | Command is copied into string pointed to by argument s, max length n. |
---|
943 | Returns: |
---|
944 | 0 if a string was copied, -1 if there was no string to copy. |
---|
945 | */ |
---|
946 | int |
---|
947 | getncm(s,n) char *s; int n; { |
---|
948 | int y, /* Character counter */ |
---|
949 | #ifdef COMMENT |
---|
950 | quote = 0, |
---|
951 | #endif /* COMMENT */ |
---|
952 | kp = 0, /* Brace up-down counter */ |
---|
953 | pp = 0; /* Parenthesis up-down counter */ |
---|
954 | char *s2; /* Copy of destination pointer */ |
---|
955 | |
---|
956 | s2 = s; /* Initialize string pointers */ |
---|
957 | *s = NUL; /* and destination buffer */ |
---|
958 | |
---|
959 | debug(F101,"getncm dest length","",n); |
---|
960 | |
---|
961 | for (y = 0; /* Loop for n bytes max */ |
---|
962 | macp[maclvl] && *macp[maclvl] && y < n; |
---|
963 | y++, s++, macp[maclvl]++) { |
---|
964 | |
---|
965 | *s = *macp[maclvl]; /* Get next char from macro def */ |
---|
966 | /* debug(F000,"char","",*s); */ |
---|
967 | #ifdef COMMENT |
---|
968 | /* |
---|
969 | The intention here was to allow quoting of commas, braces, etc, |
---|
970 | in macro definitions, e.g. "define rows mode co80\,\%1". And it |
---|
971 | works, but it breaks just about everything else. |
---|
972 | */ |
---|
973 | if (*s == CMDQ && quote == 0) { /* Allow for quoting of */ |
---|
974 | quote = 1; /* braces, commas, etc. */ |
---|
975 | continue; |
---|
976 | } |
---|
977 | #endif /* COMMENT */ |
---|
978 | /* |
---|
979 | Allow braces around macro definition to prevent commas from being turned to |
---|
980 | end-of-lines and also treat any commas within parens as text so that |
---|
981 | multiple-argument functions won't cause the command to break prematurely. |
---|
982 | */ |
---|
983 | #ifdef COMMENT |
---|
984 | if (!quote) { |
---|
985 | #endif /* COMMENT */ |
---|
986 | if (*s == '{') kp++; /* Count braces */ |
---|
987 | if (*s == '}') kp--; |
---|
988 | if (*s == '(') pp++; /* Count parentheses. */ |
---|
989 | if (*s == ')') pp--; |
---|
990 | if (*s == ',' && pp <= 0 && kp <= 0) { |
---|
991 | macp[maclvl]++; /* Comma not in {} or () */ |
---|
992 | debug(F110,"next cmd",s,0); |
---|
993 | kp = pp = 0; /* so we have the next command */ |
---|
994 | break; |
---|
995 | } |
---|
996 | #ifdef COMMENT |
---|
997 | } |
---|
998 | #endif /* COMMENT */ |
---|
999 | } /* Reached end. */ |
---|
1000 | if (*s2 == NUL) { /* If nothing was copied, */ |
---|
1001 | debug(F100,"getncm eom","",0); |
---|
1002 | popclvl(); /* pop command level. */ |
---|
1003 | return(-1); |
---|
1004 | } else { /* otherwise, tack CR onto end */ |
---|
1005 | *s++ = CR; |
---|
1006 | *s = '\0'; |
---|
1007 | if (mecho && pflag) /* If MACRO ECHO ON, echo the cmd */ |
---|
1008 | printf("%s\n",s2); |
---|
1009 | debug(F110,"getncm returns ptr to",s2,0); |
---|
1010 | } |
---|
1011 | return(0); |
---|
1012 | } |
---|
1013 | |
---|
1014 | /* D O M A C -- Define and then execute a macro */ |
---|
1015 | |
---|
1016 | int |
---|
1017 | domac(name, def, flags) char *name, *def; int flags; { |
---|
1018 | int x, m; |
---|
1019 | m = maclvl; /* Current macro stack level */ |
---|
1020 | debug(F101,"domac entry maclvl","",maclvl); |
---|
1021 | x = addmac(name, def); /* Define a new macro */ |
---|
1022 | if (x > -1) { /* If successful, */ |
---|
1023 | dodo(x,NULL, flags); /* start it (increments maclvl). */ |
---|
1024 | while (maclvl > m) { /* Keep going till done with it, */ |
---|
1025 | debug(F101,"domac loop maclvl 1","",maclvl); |
---|
1026 | sstate = (CHAR) parser(1); /* parsing & executing each command, */ |
---|
1027 | debug(F101,"domac loop maclvl 2","",maclvl); |
---|
1028 | if (sstate) proto(); /* including protocol commands. */ |
---|
1029 | } |
---|
1030 | debug(F101,"domac loop exit maclvl","",maclvl); |
---|
1031 | } |
---|
1032 | return(success); |
---|
1033 | } |
---|
1034 | #endif /* NOSPL */ |
---|
1035 | |
---|
1036 | /* |
---|
1037 | G E T N C T |
---|
1038 | |
---|
1039 | Get next command from TAKE (command) file. |
---|
1040 | |
---|
1041 | Call with: |
---|
1042 | s Pointer to buffer to read into |
---|
1043 | n Length of buffer |
---|
1044 | f File descriptor of file to read from |
---|
1045 | flag 0 == keep line terminator on and allow continuation |
---|
1046 | 1 == discard line terminator and don't allow continuation |
---|
1047 | |
---|
1048 | Call with flag == 0 to read a command from a TAKE file; |
---|
1049 | Call with flag != 0 to read a line from a dialing or network directory. |
---|
1050 | |
---|
1051 | In both cases, trailing comments and/or trailing whitespace is stripped. |
---|
1052 | If flag == 0, continued lines are combined into one line. A continued line |
---|
1053 | is one that ends in hypen or backslash, or any line in a "block", which |
---|
1054 | starts with "{" at the end of a line and ends with "}" at the beginning of |
---|
1055 | a line; blocks may be nested. |
---|
1056 | |
---|
1057 | Returns: |
---|
1058 | 0 if a string was copied, |
---|
1059 | -1 on EOF, |
---|
1060 | -2 on malloc failure |
---|
1061 | -3 if line is not properly terminated |
---|
1062 | -4 if (possibly continued) line is too long. */ |
---|
1063 | int |
---|
1064 | getnct(s,n,f,flag) char *s; int n; FILE *f; int flag; { |
---|
1065 | int i, len, buflen; |
---|
1066 | char c, cc, ccl, *s2, *lp, *lp2, *lp3, *lastcomma = NULL; |
---|
1067 | int bc = 0; /* Block counter */ |
---|
1068 | |
---|
1069 | s2 = s; /* Remember original pointer */ |
---|
1070 | buflen = n; /* Remember original buffer length */ |
---|
1071 | |
---|
1072 | debug(F101,"getnct","",n); |
---|
1073 | if (!(lp2 = (char *) malloc(n+n+1))) { /* Get a temporary buffer */ |
---|
1074 | debug(F101,"getnct malloc failure","",0); |
---|
1075 | return(-2); |
---|
1076 | } |
---|
1077 | while (1) { /* Loop to read lines from file */ |
---|
1078 | if (fgets(lp2,n,f) == NULL) { /* Read a line into lp2 */ |
---|
1079 | debug(F100,"getnct fgets EOF","",0); /* EOF */ |
---|
1080 | free(lp2); /* Free temporary storage */ |
---|
1081 | lp2 = NULL; |
---|
1082 | *s = NUL; /* Make destination be empty */ |
---|
1083 | return(-1); /* Return failure code */ |
---|
1084 | } |
---|
1085 | #ifndef NODIAL |
---|
1086 | if (flag) /* Count this line */ |
---|
1087 | dirline++; |
---|
1088 | else |
---|
1089 | #endif /* NODIAL */ |
---|
1090 | tfline[tlevel]++; |
---|
1091 | len = strlen(lp2) - 1; /* Position of line terminator */ |
---|
1092 | debug(F111,"getnct fgets ok",lp2,len); |
---|
1093 | if (len < 0) |
---|
1094 | len = 0; |
---|
1095 | if (techo && pflag) /* If TAKE ECHO ON, */ |
---|
1096 | printf("%3d. %s", /* echo it this line. */ |
---|
1097 | #ifndef NODIAL |
---|
1098 | flag ? dirline : |
---|
1099 | #endif /* NODIAL */ |
---|
1100 | tfline[tlevel], |
---|
1101 | lp2 |
---|
1102 | ); |
---|
1103 | lp3 = lp2; /* Working pointer */ |
---|
1104 | i = len; |
---|
1105 | while (*lp3 == SP || *lp3 == HT) { /* First nonwhitespace character */ |
---|
1106 | i--; |
---|
1107 | lp3++; |
---|
1108 | } |
---|
1109 | if (i == 0 && bc > 0) /* Blank line in {...} block */ |
---|
1110 | continue; |
---|
1111 | |
---|
1112 | /* Isolate, remove, and check terminator */ |
---|
1113 | |
---|
1114 | c = lp2[len]; /* Value of line terminator */ |
---|
1115 | debug(F101,"getnct terminator","",c); |
---|
1116 | if (c < LF || c > CR) { /* It's not a terminator */ |
---|
1117 | debug(F111,"getnct bad line",lp2,c); |
---|
1118 | if (feof(f) && len > 0 && len < n) { |
---|
1119 | /* Kludge Alert... */ |
---|
1120 | printf("Warning: Last line of %s lacks terminator\n", |
---|
1121 | s2 == cmdbuf ? "command file" : "directory file"); |
---|
1122 | c = lp2[++len] = '\n'; /* No big deal - supply one. */ |
---|
1123 | } else { /* Something's wrong, fail. */ |
---|
1124 | free(lp2); |
---|
1125 | lp2 = NULL; |
---|
1126 | return(-3); |
---|
1127 | } |
---|
1128 | } |
---|
1129 | |
---|
1130 | /* Trim trailing whitespace */ |
---|
1131 | |
---|
1132 | for (i = len - 1; i > -1; i--) /* Back up over spaces and tabs */ |
---|
1133 | if (lp2[i] != SP && lp2[i] != HT && lp2[i] != NUL) |
---|
1134 | break; |
---|
1135 | debug(F101,"getnct i","",i); |
---|
1136 | lp2[i+1] = NUL; /* Terminate the string */ |
---|
1137 | debug(F110,"getnct lp2",lp2,0); |
---|
1138 | lp = lp2; /* Make a working pointer */ |
---|
1139 | |
---|
1140 | /* Remove trailing or full-line comment */ |
---|
1141 | |
---|
1142 | while (cc = *lp) { |
---|
1143 | if (cc == ';' || cc == '#') { /* Comment introducer? */ |
---|
1144 | if (lp == lp2) { /* First char on line */ |
---|
1145 | *lp = NUL; |
---|
1146 | break; |
---|
1147 | } else if (*(lp - 1) == SP || *(lp - 1) == HT) { |
---|
1148 | lp--; |
---|
1149 | *lp = NUL; /* Or preceded by whitespace */ |
---|
1150 | break; |
---|
1151 | } |
---|
1152 | } |
---|
1153 | lp++; |
---|
1154 | } |
---|
1155 | if (lp > lp2) |
---|
1156 | lp--; /* Back up over the NUL */ |
---|
1157 | |
---|
1158 | /* Now trim any space that preceded the comment */ |
---|
1159 | |
---|
1160 | while ((*lp == SP || *lp == HT) && lp >= lp2) { |
---|
1161 | *lp = NUL; |
---|
1162 | if (lp <= lp2) |
---|
1163 | break; |
---|
1164 | lp--; |
---|
1165 | } |
---|
1166 | debug(F110,"getnct comment trimmed",lp2,0); |
---|
1167 | |
---|
1168 | len = strlen(lp2); /* Length after trimming */ |
---|
1169 | |
---|
1170 | if (n - len < 2) { /* Check remaining space */ |
---|
1171 | debug(F111,"getnct command too long",s2,buflen); |
---|
1172 | printf("?Line too long, maximum length: %d.\n",buflen); |
---|
1173 | free(lp2); |
---|
1174 | lp2 = NULL; |
---|
1175 | return(-4); |
---|
1176 | } |
---|
1177 | ccl = (len > 0) ? lp2[len-1] : 0; /* Last character in line */ |
---|
1178 | |
---|
1179 | lp = lp2; |
---|
1180 | while (*s++ = *lp++) /* Copy result to target buffer */ |
---|
1181 | n--; /* accounting for length */ |
---|
1182 | s--; /* Back up over the NUL */ |
---|
1183 | |
---|
1184 | /* Check whether this line is continued */ |
---|
1185 | |
---|
1186 | if (flag) /* No line continuation when flag=1 */ |
---|
1187 | break; /* So break out of read-lines loop */ |
---|
1188 | |
---|
1189 | debug(F000,"getnct first char","",*lp3); |
---|
1190 | debug(F000,"getnct last char","",ccl); |
---|
1191 | |
---|
1192 | if (bc > 0 && *lp3 == '}') /* First char on line is '}' */ |
---|
1193 | bc--; /* Decrement block counter */ |
---|
1194 | |
---|
1195 | if (bc == 0 && /* Line is continued if bc > 0 */ |
---|
1196 | #ifdef COMMENT |
---|
1197 | /* Not supported as of C-Kermit 6.0 */ |
---|
1198 | ccl != CMDQ && /* or line ends with CMDQ */ |
---|
1199 | #endif /* COMMENT */ |
---|
1200 | ccl != '-' && /* or line ends with dash */ |
---|
1201 | ccl != '{') /* or line ends with opening brace */ |
---|
1202 | break; /* None of those, we're done. */ |
---|
1203 | |
---|
1204 | if (ccl == '{') { /* Last char on line is '{'? */ |
---|
1205 | bc++; /* Count the block opener. */ |
---|
1206 | } else if (ccl == '-' /* Explicit continue? */ |
---|
1207 | #ifdef COMMENT |
---|
1208 | /* Not supported as of C-Kermit 6.0. */ |
---|
1209 | || ccl == CMDQ |
---|
1210 | #endif /* COMMENT */ |
---|
1211 | ) { |
---|
1212 | s--; /* Yes, back up over terminators */ |
---|
1213 | n++; /* and over continuation character */ |
---|
1214 | } else { /* None of those but (bc > 0) */ |
---|
1215 | lastcomma = s; |
---|
1216 | *s++ = ','; /* and insert a comma */ |
---|
1217 | n--; |
---|
1218 | } |
---|
1219 | debug(F101,"getnct bc","",bc); |
---|
1220 | debug(F100,"getnct continued","",0); |
---|
1221 | } /* read-lines while loop */ |
---|
1222 | |
---|
1223 | if (lastcomma) |
---|
1224 | *lastcomma = SP; |
---|
1225 | if (!flag) /* Tack line terminator back on */ |
---|
1226 | *s++ = c; |
---|
1227 | *s++ = NUL; /* Terminate the string */ |
---|
1228 | untab(s2); /* Done, convert tabs to spaces */ |
---|
1229 | debug(F110,"getnct return",s2,0); |
---|
1230 | free(lp2); /* Free temporary storage */ |
---|
1231 | return(0); /* Return success */ |
---|
1232 | } |
---|
1233 | |
---|
1234 | /* P A R S E R -- Top-level interactive command parser. */ |
---|
1235 | |
---|
1236 | /* |
---|
1237 | Call with: |
---|
1238 | m = 0 for normal behavior: keep parsing and executing commands |
---|
1239 | until an action command is parsed, then return with a |
---|
1240 | Kermit start-state as the value of this function. |
---|
1241 | m = 1 to parse only one command, can also be used to call parser() |
---|
1242 | recursively. |
---|
1243 | m = 2 to read but do not execute one command. |
---|
1244 | In all cases, parser() returns: |
---|
1245 | 0 if no Kermit protocol action required |
---|
1246 | > 0 with a Kermit protocol start-state. |
---|
1247 | < 0 upon error. |
---|
1248 | */ |
---|
1249 | int |
---|
1250 | parser(m) int m; { |
---|
1251 | int tfcode, xx, yy, zz; /* Workers */ |
---|
1252 | |
---|
1253 | #ifndef NOSPL |
---|
1254 | int inlevel; /* Level we were called at */ |
---|
1255 | #endif /* NOSPL */ |
---|
1256 | char *cbp; /* Command buffer pointer */ |
---|
1257 | #ifdef MAC |
---|
1258 | extern char *lfiles; /* Fake extern cast */ |
---|
1259 | #endif /* MAC */ |
---|
1260 | |
---|
1261 | #ifdef AMIGA |
---|
1262 | reqres(); /* restore AmigaDOS requestors */ |
---|
1263 | #endif /* AMIGA */ |
---|
1264 | |
---|
1265 | #ifdef OS2 |
---|
1266 | if ( cursor_save > -1 ) { /* restore cursor if it was */ |
---|
1267 | cursorena[VCMD] = cursor_save ; /* turned off in file xfer */ |
---|
1268 | cursor_save = -1 ; /* mode */ |
---|
1269 | } |
---|
1270 | #endif /* OS2 */ |
---|
1271 | |
---|
1272 | what = W_COMMAND; /* Now we're parsing commands. */ |
---|
1273 | moving = 0; /* We're not MOVE'ing */ |
---|
1274 | if ( /* If at top (interactive) level ... */ |
---|
1275 | #ifndef NOSPL |
---|
1276 | cmdlvl == 0 |
---|
1277 | #else |
---|
1278 | tlevel < 0 |
---|
1279 | #endif /* NOSPL */ |
---|
1280 | ) |
---|
1281 | concb((char)escape); /* ... put console in 'cbreak' mode. */ |
---|
1282 | |
---|
1283 | #ifdef CK_TMPDIR |
---|
1284 | /* If we were cd'd temporarily to another device or directory ... */ |
---|
1285 | if (f_tmpdir) { |
---|
1286 | int x; |
---|
1287 | x = zchdir((char *) savdir); /* ... restore previous directory */ |
---|
1288 | f_tmpdir = 0; /* and remember we did it. */ |
---|
1289 | debug(F111,"parser tmpdir restoring",savdir,x); |
---|
1290 | } |
---|
1291 | #endif /* CK_TMPDIR */ |
---|
1292 | |
---|
1293 | #ifndef NOSPL |
---|
1294 | inlevel = cmdlvl; /* Current macro level */ |
---|
1295 | debug(F101,"&parser entry maclvl","",maclvl); |
---|
1296 | debug(F101,"&parser entry inlevel","",inlevel); |
---|
1297 | debug(F101,"&parser entry tlevel","",tlevel); |
---|
1298 | debug(F101,"&parser entry cmdlvl","",cmdlvl); |
---|
1299 | debug(F101,"&parser entry m","",m); |
---|
1300 | #endif /* NOSPL */ |
---|
1301 | |
---|
1302 | /* |
---|
1303 | sstate becomes nonzero when a command has been parsed that requires some |
---|
1304 | action from the protocol module. Any non-protocol actions, such as local |
---|
1305 | directory listing or terminal emulation, are invoked directly from below. |
---|
1306 | */ |
---|
1307 | sstate = 0; /* Start with no start state. */ |
---|
1308 | #ifndef NOFRILLS |
---|
1309 | rmailf = rprintf = 0; /* MAIL and PRINT modifiers for SEND */ |
---|
1310 | *optbuf = NUL; /* MAIL and PRINT options */ |
---|
1311 | #endif /* NOFRILLS */ |
---|
1312 | #ifndef NOSPL |
---|
1313 | query = 0; /* QUERY not active */ |
---|
1314 | #endif /* NOSPL */ |
---|
1315 | |
---|
1316 | while (sstate == 0) { /* Parse cmds until action requested */ |
---|
1317 | #ifdef WHAT_THE_HECK_IS_THIS |
---|
1318 | int nnn; |
---|
1319 | debug(F100,"top of parse loop","",0); |
---|
1320 | nnn = ttchk(); |
---|
1321 | debug(F101,"APC ttchk p1","",nnn); |
---|
1322 | #endif /* WHAT_THE_HECK_IS_THIS */ |
---|
1323 | |
---|
1324 | remfile = 0; /* Clear these in case REMOTE */ |
---|
1325 | remappd = 0; /* command was interrupted... */ |
---|
1326 | rempipe = 0; |
---|
1327 | |
---|
1328 | /* Take requested action if there was an error in the previous command */ |
---|
1329 | |
---|
1330 | #ifndef MAC |
---|
1331 | conint(trap,stptrap); /* In case we were just fg'd */ |
---|
1332 | bgchk(); /* Check background status */ |
---|
1333 | #endif /* MAC */ |
---|
1334 | |
---|
1335 | debug(F101,"tlevel","",tlevel); |
---|
1336 | |
---|
1337 | #ifndef NOSPL |
---|
1338 | if (success == 0) { |
---|
1339 | if (cmdstk[cmdlvl].src == CMD_TF && takerr[cmdlvl]) { |
---|
1340 | printf("Command file terminated by error.\n"); |
---|
1341 | popclvl(); |
---|
1342 | if (cmdlvl == 0) return(0); |
---|
1343 | } |
---|
1344 | if (cmdstk[cmdlvl].src == CMD_MD && merror[cmdlvl]) { |
---|
1345 | printf("Command error: macro terminated.\n"); |
---|
1346 | popclvl(); |
---|
1347 | if (m && (cmdlvl < inlevel)) |
---|
1348 | return((int) sstate); |
---|
1349 | } |
---|
1350 | } |
---|
1351 | |
---|
1352 | nulcmd = (m == 2); |
---|
1353 | #else |
---|
1354 | if (success == 0 && tlevel > -1 && takerr[tlevel]) { |
---|
1355 | printf("Command file terminated by error.\n"); |
---|
1356 | popclvl(); |
---|
1357 | cmini(ckxech); /* Clear the cmd buffer. */ |
---|
1358 | if (tlevel < 0) /* Just popped out of cmd files? */ |
---|
1359 | return(0); /* End of init file or whatever. */ |
---|
1360 | } |
---|
1361 | #endif /* NOSPL */ |
---|
1362 | |
---|
1363 | #ifdef MAC |
---|
1364 | /* Check for TAKE initiated by menu. */ |
---|
1365 | if ((tlevel == -1) && lfiles) |
---|
1366 | startlfile(); |
---|
1367 | #endif /* MAC */ |
---|
1368 | |
---|
1369 | /* If in TAKE file, check for EOF */ |
---|
1370 | #ifndef NOSPL |
---|
1371 | #ifdef MAC |
---|
1372 | if |
---|
1373 | #else |
---|
1374 | while |
---|
1375 | #endif /* MAC */ |
---|
1376 | ((cmdstk[cmdlvl].src == CMD_TF) /* If end of take file */ |
---|
1377 | && (tlevel > -1) |
---|
1378 | && feof(tfile[tlevel])) { |
---|
1379 | popclvl(); /* pop command level */ |
---|
1380 | cmini(ckxech); /* and clear the cmd buffer. */ |
---|
1381 | if (cmdlvl == 0) { /* Just popped out of all cmd files? */ |
---|
1382 | if ( |
---|
1383 | #ifdef NT |
---|
1384 | StartedFromDialer && |
---|
1385 | #endif /* NT */ |
---|
1386 | cfilef) { /* Delete startup file? */ |
---|
1387 | if (DeleteStartupFile) { |
---|
1388 | debug(F101,"DeleteStartupFile",cmdfil,0); |
---|
1389 | zdelet(cmdfil); |
---|
1390 | } |
---|
1391 | } |
---|
1392 | return(0); /* End of init file or whatever. */ |
---|
1393 | } |
---|
1394 | } |
---|
1395 | #ifdef MAC |
---|
1396 | miniparser(1); |
---|
1397 | if (sstate == 'a') { /* if cmd-. cancel */ |
---|
1398 | debug(F100, "parser: cancel take due to sstate", "", sstate); |
---|
1399 | sstate = '\0'; |
---|
1400 | dostop(); |
---|
1401 | return(0); /* End of init file or whatever. */ |
---|
1402 | } |
---|
1403 | #endif /* MAC */ |
---|
1404 | |
---|
1405 | #else /* NOSPL */ |
---|
1406 | if ((tlevel > -1) && feof(tfile[tlevel])) { /* If end of take */ |
---|
1407 | popclvl(); /* Pop up one level. */ |
---|
1408 | cmini(ckxech); /* and clear the cmd buffer. */ |
---|
1409 | if (tlevel < 0) /* Just popped out of cmd files? */ |
---|
1410 | return(0); /* End of init file or whatever. */ |
---|
1411 | } |
---|
1412 | #endif /* NOSPL */ |
---|
1413 | |
---|
1414 | #ifndef NOSPL |
---|
1415 | if (cmdstk[cmdlvl].src == CMD_MD) { /* Executing a macro? */ |
---|
1416 | debug(F100,"parser macro","",0); |
---|
1417 | maclvl = cmdstk[cmdlvl].lvl; /* Get current level */ |
---|
1418 | debug(F101,"parser maclvl","",maclvl); |
---|
1419 | cbp = cmdbuf; /* Copy next cmd to command buffer. */ |
---|
1420 | *cbp = NUL; |
---|
1421 | if (*savbuf) { /* In case then-part of 'if' command */ |
---|
1422 | strcpy(cbp,savbuf); /* was saved, restore it. */ |
---|
1423 | *savbuf = '\0'; |
---|
1424 | } else { /* Else get next cmd from macro def */ |
---|
1425 | if (getncm(cbp,CMDBL) < 0) { |
---|
1426 | if (m && (cmdlvl < inlevel)) |
---|
1427 | return((int) sstate); |
---|
1428 | else /* if (!m) */ continue; |
---|
1429 | } |
---|
1430 | } |
---|
1431 | debug(F110,"cmdbuf from macro",cmdbuf,0); |
---|
1432 | |
---|
1433 | } else if (cmdstk[cmdlvl].src == CMD_TF) |
---|
1434 | #else |
---|
1435 | if (tlevel > -1) |
---|
1436 | #endif /* NOSPL */ |
---|
1437 | { |
---|
1438 | #ifndef NOSPL |
---|
1439 | if (*savbuf) { /* In case THEN-part of IF command */ |
---|
1440 | strcpy(cmdbuf,savbuf); /* was saved, restore it. */ |
---|
1441 | *savbuf = '\0'; |
---|
1442 | } else |
---|
1443 | #endif /* NOSPL */ |
---|
1444 | |
---|
1445 | /* Get next line from TAKE file */ |
---|
1446 | |
---|
1447 | if ((tfcode = getnct(cmdbuf,CMDBL,tfile[tlevel],0)) < 0) { |
---|
1448 | if (tfcode < -1) { /* Error */ |
---|
1449 | printf("?Error in TAKE command file: %s\n", |
---|
1450 | (tfcode == -2) ? "Memory allocation failure" : |
---|
1451 | "Line too long or contains NUL characters" |
---|
1452 | ); |
---|
1453 | dostop(); |
---|
1454 | } |
---|
1455 | continue; /* -1 means EOF */ |
---|
1456 | } |
---|
1457 | |
---|
1458 | /* If interactive, get next command from user. */ |
---|
1459 | |
---|
1460 | } else { /* User types it in. */ |
---|
1461 | if (pflag) prompt(xxstring); |
---|
1462 | cmini(ckxech); |
---|
1463 | } |
---|
1464 | |
---|
1465 | /* Now we know where next command is coming from. Parse and execute it. */ |
---|
1466 | |
---|
1467 | repars = 1; /* 1 = command needs parsing */ |
---|
1468 | displa = 0; /* Assume no file transfer display */ |
---|
1469 | |
---|
1470 | while (repars) { /* Parse this cmd until entered. */ |
---|
1471 | debug(F101,"parser top of while loop","",0); |
---|
1472 | cmres(); /* Reset buffer pointers. */ |
---|
1473 | |
---|
1474 | #ifdef OS2 |
---|
1475 | #ifdef COMMENT |
---|
1476 | /* we check to see if a macro is waiting to be executed */ |
---|
1477 | /* if so, we call domac on it */ |
---|
1478 | if (cmdmac) { |
---|
1479 | strncpy(cmdbuf, cmdmac, CMDBL); |
---|
1480 | free(cmdmac); |
---|
1481 | cmdmac = NULL; |
---|
1482 | } |
---|
1483 | #endif /* COMMENT */ |
---|
1484 | #endif /* OS2 */ |
---|
1485 | bye_active = 0; |
---|
1486 | xx = cmkey2(cmdtab,ncmd,"Command","",toktab,xxstring,1); |
---|
1487 | debug(F101,"top-level cmkey2","",xx); |
---|
1488 | if (xx == -5) { |
---|
1489 | yy = chktok(toktab); |
---|
1490 | debug(F101,"top-level cmkey token","",yy); |
---|
1491 | ungword(); |
---|
1492 | switch (yy) { |
---|
1493 | case '#': xx = XXCOM; break; /* Comment */ |
---|
1494 | case ';': xx = XXCOM; break; /* Comment */ |
---|
1495 | #ifndef NOSPL |
---|
1496 | case ':': xx = XXLBL; break; /* GOTO label */ |
---|
1497 | #endif /* NOSPL */ |
---|
1498 | |
---|
1499 | #ifndef NOPUSH |
---|
1500 | #ifdef CK_REDIR |
---|
1501 | case '<': |
---|
1502 | #endif /* CK_REDIR */ |
---|
1503 | case '@': |
---|
1504 | case '!': |
---|
1505 | if (!nopush) { |
---|
1506 | switch(yy) { |
---|
1507 | #ifdef CK_REDIR |
---|
1508 | case '<': xx = XXFUN; break; /* REDIRECT */ |
---|
1509 | #endif /* CK_REDIR */ |
---|
1510 | case '@': |
---|
1511 | case '!': xx = XXSHE; break; /* Shell escape */ |
---|
1512 | } |
---|
1513 | } |
---|
1514 | break; |
---|
1515 | #endif /* NOPUSH */ |
---|
1516 | default: |
---|
1517 | printf("\n?Invalid - %s\n",cmdbuf); |
---|
1518 | if (tlevel > -1) { |
---|
1519 | printf("Command file: %s, line %d\n", |
---|
1520 | tfnam[tlevel] ? tfnam[tlevel] : "", |
---|
1521 | tfline[tlevel] |
---|
1522 | ); |
---|
1523 | } |
---|
1524 | xx = -2; |
---|
1525 | } |
---|
1526 | } |
---|
1527 | |
---|
1528 | #ifndef NOSPL |
---|
1529 | /* Special handling for IF..ELSE */ |
---|
1530 | |
---|
1531 | if (ifcmd[cmdlvl]) /* Count stmts after IF */ |
---|
1532 | ifcmd[cmdlvl]++; |
---|
1533 | if (ifcmd[cmdlvl] > 2 && xx != XXELS && xx != XXCOM) |
---|
1534 | ifcmd[cmdlvl] = 0; |
---|
1535 | |
---|
1536 | /* Execute the command and take action based on return code. */ |
---|
1537 | |
---|
1538 | if (nulcmd) { /* Ignoring this command? */ |
---|
1539 | xx = XXCOM; /* Make this command a comment. */ |
---|
1540 | } |
---|
1541 | #endif /* NOSPL */ |
---|
1542 | |
---|
1543 | zz = docmd(xx); /* Parse rest of command & execute. */ |
---|
1544 | debug(F101,"docmd returns","",zz); |
---|
1545 | debug(F110,"cmdbuf",cmdbuf,""); |
---|
1546 | debug(F110,"atmbuf",atmbuf,""); |
---|
1547 | #ifdef MAC |
---|
1548 | if (tlevel > -1) { |
---|
1549 | if (sstate == 'a') { /* if cmd-. cancel */ |
---|
1550 | debug(F110, "parser: cancel take, sstate:", "a", 0); |
---|
1551 | sstate = '\0'; |
---|
1552 | dostop(); |
---|
1553 | return(0); /* End of init file or whatever. */ |
---|
1554 | } |
---|
1555 | } |
---|
1556 | #endif /* MAC */ |
---|
1557 | switch (zz) { |
---|
1558 | case -4: /* EOF (e.g. on redirected stdin) */ |
---|
1559 | doexit(GOOD_EXIT,xitsta); /* ...exit successfully */ |
---|
1560 | case -1: /* Reparse needed */ |
---|
1561 | repars = 1; /* Just set reparse flag and... */ |
---|
1562 | continue; |
---|
1563 | #ifdef OS2 |
---|
1564 | case -7: /* They typed a disk letter */ |
---|
1565 | if (!zchdir((char *)cmdbuf)) { |
---|
1566 | perror((char *)cmdbuf); |
---|
1567 | success = 0; |
---|
1568 | } else success = 1; |
---|
1569 | repars = 0; |
---|
1570 | continue; |
---|
1571 | |
---|
1572 | #endif /* OS2 */ |
---|
1573 | case -6: /* Invalid command given w/no args */ |
---|
1574 | case -2: /* Invalid command given w/args */ |
---|
1575 | #ifdef COMMENT |
---|
1576 | #ifndef NOSPL |
---|
1577 | /* This is going to be really ugly... */ |
---|
1578 | yy = mlook(mactab,atmbuf,nmac); /* Look in macro table */ |
---|
1579 | if (yy > -1) { /* If it's there */ |
---|
1580 | if (zz == -2) { /* insert "do" */ |
---|
1581 | char *mp; |
---|
1582 | mp = malloc((int)strlen(cmdbuf) + 5); |
---|
1583 | if (!mp) { |
---|
1584 | printf("?malloc error 1\n"); |
---|
1585 | return(-2); |
---|
1586 | } |
---|
1587 | sprintf(mp,"do %s ",cmdbuf); |
---|
1588 | strcpy(cmdbuf,mp); |
---|
1589 | free(mp); |
---|
1590 | mp = NULL; |
---|
1591 | } else sprintf(cmdbuf,"do %s %c",atmbuf, CR); |
---|
1592 | if (ifcmd[cmdlvl] == 2) /* This one doesn't count! */ |
---|
1593 | ifcmd[cmdlvl]--; |
---|
1594 | debug(F111,"stuff cmdbuf",cmdbuf,zz); |
---|
1595 | repars = 1; /* Go for reparse */ |
---|
1596 | continue; |
---|
1597 | } else { |
---|
1598 | char *p; |
---|
1599 | int n; |
---|
1600 | p = cmdbuf; |
---|
1601 | lp = line; |
---|
1602 | n = LINBUFSIZ; |
---|
1603 | if (cmflgs == 0) printf("\n"); |
---|
1604 | if (zzstring(p,&lp,&n) > -1) |
---|
1605 | printf("?Invalid: %s\n",line); |
---|
1606 | else |
---|
1607 | printf("?Invalid: %s\n",cmdbuf); |
---|
1608 | } /* (fall thru...) */ |
---|
1609 | #else |
---|
1610 | printf("?Invalid: %s\n",cmdbuf); |
---|
1611 | #endif /* NOSPL */ |
---|
1612 | #else /* Not COMMENT */ |
---|
1613 | printf("?Invalid: %s\n",cmdbuf); |
---|
1614 | #endif /* COMMENT */ |
---|
1615 | |
---|
1616 | case -9: /* Bad, error message already done */ |
---|
1617 | success = 0; |
---|
1618 | debug(F110,"top-level cmkey failed",cmdbuf,0); |
---|
1619 | /* If in background w/ commands coming stdin, terminate */ |
---|
1620 | if (pflag == 0 && tlevel < 0) |
---|
1621 | fatal("Kermit command error in background execution"); |
---|
1622 | /* |
---|
1623 | Command retry feature, edit 190. If we're at interactive prompting level, |
---|
1624 | reprompt the user with as much of the command as didn't fail. |
---|
1625 | */ |
---|
1626 | #ifdef CK_RECALL |
---|
1627 | if (cm_retry && /* If command retry enabled... */ |
---|
1628 | #ifndef NOSPL |
---|
1629 | (cmdlvl == 0) /* and at top (interactive) level... */ |
---|
1630 | |
---|
1631 | #else |
---|
1632 | (tlevel < 0) |
---|
1633 | #endif /* NOSPL */ |
---|
1634 | ) { |
---|
1635 | int len; |
---|
1636 | char *p, *s; |
---|
1637 | len = strlen(cmdbuf); /* Length of command buffer */ |
---|
1638 | p = malloc(len + 1); /* Allocate space for copy */ |
---|
1639 | if (p) { /* If we got the space */ |
---|
1640 | strcpy(p,cmdbuf); /* copy the command buffer. */ |
---|
1641 | /* Chop off final field, the one that failed. */ |
---|
1642 | s = p + len - 1; /* Point to end */ |
---|
1643 | while (*s == SP && s > p) /* Trim blanks */ |
---|
1644 | s--; |
---|
1645 | while (*s != SP && s > p) /* Trim last field */ |
---|
1646 | s--; |
---|
1647 | if (s > p) /* Keep the space */ |
---|
1648 | s++; /* after last good field */ |
---|
1649 | if (s >= p) /* Cut off remainder */ |
---|
1650 | *s = NUL; |
---|
1651 | cmini(ckxech); /* Reinitialize the parser */ |
---|
1652 | strcpy(cmdbuf,p); /* Copy truncated cmd back */ |
---|
1653 | free(p); /* Free temporary storage */ |
---|
1654 | p = NULL; |
---|
1655 | prompt(xxstring); /* Reprint the prompt */ |
---|
1656 | printf("%s",cmdbuf); /* Reprint partial command */ |
---|
1657 | repars = 1; /* Force reparse */ |
---|
1658 | continue; |
---|
1659 | } |
---|
1660 | } else |
---|
1661 | #endif /* CK_RECALL */ |
---|
1662 | if (tlevel > -1) { |
---|
1663 | printf("Command file: %s, line %d\n", |
---|
1664 | tfnam[tlevel] ? tfnam[tlevel] : "", |
---|
1665 | tfline[tlevel] |
---|
1666 | ); |
---|
1667 | } |
---|
1668 | cmini(ckxech); /* (fall thru) */ |
---|
1669 | |
---|
1670 | case -3: /* Empty command OK at top level */ |
---|
1671 | repars = 0; /* Don't need to reparse. */ |
---|
1672 | continue; /* Go back and get another command. */ |
---|
1673 | |
---|
1674 | default: /* Command was successful. */ |
---|
1675 | #ifndef NOSPL |
---|
1676 | debug(F101,"parser preparing to continue","",maclvl); |
---|
1677 | #endif /* NOSPL */ |
---|
1678 | repars = 0; /* Don't need to reparse. */ |
---|
1679 | continue; /* Go back and get another command. */ |
---|
1680 | } |
---|
1681 | } |
---|
1682 | #ifndef NOSPL |
---|
1683 | debug(F101,"parser breaks out of while loop","",maclvl); |
---|
1684 | if (m && (cmdlvl < inlevel)) return((int) sstate); |
---|
1685 | #endif /* NOSPL */ |
---|
1686 | } |
---|
1687 | |
---|
1688 | /* Got an action command, return start state. */ |
---|
1689 | |
---|
1690 | return((int) sstate); |
---|
1691 | } |
---|
1692 | |
---|
1693 | #ifndef NOSPL |
---|
1694 | /* |
---|
1695 | OUTPUT command. |
---|
1696 | Buffering and pacing added by L.I. Kirby, 5A(189), June 1993. |
---|
1697 | */ |
---|
1698 | #define OBSIZE 80 /* Size of local character buffer */ |
---|
1699 | |
---|
1700 | static int obn; /* Buffer offset (high water mark) */ |
---|
1701 | static char obuf[OBSIZE+1]; /* OUTPUT buffer. */ |
---|
1702 | static char *obp; /* Pointer to output buffer. */ |
---|
1703 | _PROTOTYP( static int oboc, (char) ); |
---|
1704 | _PROTOTYP( static int xxout, (char *, int) ); |
---|
1705 | |
---|
1706 | static int |
---|
1707 | #ifdef CK_ANSIC |
---|
1708 | xxout(char *obuf, int obsize) |
---|
1709 | #else |
---|
1710 | xxout(obuf, obsize) char *obuf; int obsize; |
---|
1711 | #endif /* CK_ANSIC */ |
---|
1712 | /* xxout */ { /* OUTPUT command's output function */ |
---|
1713 | int i, rc; |
---|
1714 | |
---|
1715 | debug(F101,"xxout obsize","",obsize); |
---|
1716 | debug(F101,"xxout pacing","",pacing); |
---|
1717 | debug(F111,"xxout string",obuf,strlen(obuf)); |
---|
1718 | |
---|
1719 | rc = 0; /* Initial return code. */ |
---|
1720 | if (!obuf || (obsize <= 0)) /* Nothing to output. */ |
---|
1721 | goto xxout_x; /* Return successfully */ |
---|
1722 | |
---|
1723 | rc = -1; /* Now assume failure */ |
---|
1724 | if (pacing == 0) { /* Is pacing enabled? */ |
---|
1725 | if ((local ? /* No, write entire string at once */ |
---|
1726 | ttol((CHAR *)obuf, obsize) : /* to communications device */ |
---|
1727 | conxo(obsize, obuf)) /* or to console */ |
---|
1728 | != obsize) |
---|
1729 | goto xxout_x; |
---|
1730 | } else { |
---|
1731 | for (i = 0; i < obsize; i++) { /* Write individual chars */ |
---|
1732 | if ((local ? ttoc(obuf[i]) : conoc(obuf[i])) < 0) |
---|
1733 | goto xxout_x; |
---|
1734 | msleep(pacing); |
---|
1735 | } |
---|
1736 | } |
---|
1737 | rc = 0; /* Success */ |
---|
1738 | xxout_x: |
---|
1739 | obn = 0; /* Reset count */ |
---|
1740 | obp = obuf; /* and pointers */ |
---|
1741 | return(rc); /* return our return code */ |
---|
1742 | } |
---|
1743 | |
---|
1744 | #ifdef COMMENT |
---|
1745 | /* |
---|
1746 | Macros for OUTPUT command execution, to make it go faster. |
---|
1747 | */ |
---|
1748 | #define obfls() ((xxout(obuf,obn)<0)?-1:0) |
---|
1749 | #define oboc(c) ((*obp++=(char)(c)),*obp=0,(((++obn)>=OBSIZE)?obfls():0)) |
---|
1750 | |
---|
1751 | #else /* The macros cause some compilers to generate bad code. */ |
---|
1752 | |
---|
1753 | static int |
---|
1754 | #ifdef CK_ANSIC |
---|
1755 | oboc(char c) |
---|
1756 | #else |
---|
1757 | oboc(c) char c; |
---|
1758 | #endif /* CK_ANSIC */ |
---|
1759 | /* oboc */ { /* OUTPUT command's output function */ |
---|
1760 | |
---|
1761 | *obp++ = c; /* Deposit character */ |
---|
1762 | *obp = NUL; /* Flush buffer if it's now full */ |
---|
1763 | |
---|
1764 | return(((++obn) >= OBSIZE) ? xxout(obuf,obn) : 0); |
---|
1765 | } |
---|
1766 | #endif /* COMMENT */ |
---|
1767 | #endif /* NOSPL */ |
---|
1768 | |
---|
1769 | |
---|
1770 | #ifndef NOSPL |
---|
1771 | |
---|
1772 | /* Routines for handling local variables -- also see popclvl(). */ |
---|
1773 | |
---|
1774 | VOID |
---|
1775 | freelocal(m) int m; { /* Free local variables */ |
---|
1776 | struct localvar * v, * tv; /* at macro level m... */ |
---|
1777 | debug(F101,"freelocal level","",m); |
---|
1778 | if (m < 0) return; |
---|
1779 | v = localhead[m]; /* List head for level m */ |
---|
1780 | while (v) { |
---|
1781 | if (v->lv_name) /* Variable name */ |
---|
1782 | free(v->lv_name); |
---|
1783 | if (v->lv_value) /* Value */ |
---|
1784 | free(v->lv_value); |
---|
1785 | tv = v; /* Save pointer to this node */ |
---|
1786 | v = v->lv_next; /* Get next one */ |
---|
1787 | if (tv) /* Free this one */ |
---|
1788 | free(tv); |
---|
1789 | } |
---|
1790 | localhead[m] = (struct localvar *) NULL; /* Done, set list head to NULL */ |
---|
1791 | } |
---|
1792 | |
---|
1793 | int |
---|
1794 | dolocal() { /* Do the LOCAL command */ |
---|
1795 | int i, x, z, len; |
---|
1796 | char * s, * p; |
---|
1797 | char * list[65]; /* Up to 64 variables per line */ |
---|
1798 | struct localvar * v, *prev; |
---|
1799 | |
---|
1800 | if ((x = cmtxt("Variable name(s)","",&s,NULL) < 0)) |
---|
1801 | return(x); |
---|
1802 | |
---|
1803 | xwords(s,64,list,0); /* Break up line into "words" */ |
---|
1804 | /* |
---|
1805 | loop thru variable list. |
---|
1806 | if variable is defined, allocate a node for it, |
---|
1807 | copy its value to the node, |
---|
1808 | and undefine it. |
---|
1809 | */ |
---|
1810 | if (v = localhead[cmdlvl]) { /* Already have some at this level? */ |
---|
1811 | while (v) { /* Find end of list */ |
---|
1812 | prev = v; |
---|
1813 | v = v->lv_next; |
---|
1814 | } |
---|
1815 | } |
---|
1816 | for (i = 1; i < 10 && list[i]; i++) { /* Go through the list */ |
---|
1817 | if (*(list[i]) == CMDQ) { |
---|
1818 | if (parsevar(list[i],&x,&z) < 0) /* Check for valid name */ |
---|
1819 | continue; |
---|
1820 | sprintf(tmpbuf,"\\fcontents(%s)",list[i]); /* Get definition */ |
---|
1821 | } else { /* Macro */ |
---|
1822 | sprintf(tmpbuf,"\\fdefinition(%s)",list[i]); /* Get def */ |
---|
1823 | } |
---|
1824 | s = line; /* Point to destination buffer */ |
---|
1825 | x = LINBUFSIZ; /* Length of destination buffer */ |
---|
1826 | zzstring(tmpbuf,&s,&x); /* Get definition */ |
---|
1827 | |
---|
1828 | /* Name is in list[i], definition is in line[] */ |
---|
1829 | |
---|
1830 | v = (struct localvar *) malloc(sizeof(struct localvar)); |
---|
1831 | if (!v) { |
---|
1832 | printf("?Failure to allocate storage for local variables"); |
---|
1833 | return(-9); |
---|
1834 | } |
---|
1835 | if (!localhead[cmdlvl]) /* If first, set list head */ |
---|
1836 | localhead[cmdlvl] = v; |
---|
1837 | else /* Otherwise link previous to this */ |
---|
1838 | prev->lv_next = v; |
---|
1839 | prev = v; /* And make this previous */ |
---|
1840 | v->lv_next = (struct localvar *) NULL; /* No next yet */ |
---|
1841 | |
---|
1842 | if (!(v->lv_name = (char *) malloc((int) strlen(list[i]) + 1))) |
---|
1843 | goto localbad; |
---|
1844 | strcpy(v->lv_name, list[i]); /* Copy name into new node */ |
---|
1845 | |
---|
1846 | if (*line) { |
---|
1847 | if (!(v->lv_value = (char *) malloc((int) strlen(line) + 1))) |
---|
1848 | goto localbad; |
---|
1849 | strcpy(v->lv_value, line); /* Copy value into new node */ |
---|
1850 | } else |
---|
1851 | v->lv_value = NULL; |
---|
1852 | |
---|
1853 | delmac(list[i]); /* Delete the original macro */ |
---|
1854 | } |
---|
1855 | return(success = 1); |
---|
1856 | |
---|
1857 | localbad: |
---|
1858 | printf("?Failure to allocate storage for local variables"); |
---|
1859 | freelocal(cmdlvl); |
---|
1860 | return(-9); |
---|
1861 | } |
---|
1862 | #endif /* NOSPL */ |
---|
1863 | |
---|
1864 | #ifndef NOSPL |
---|
1865 | /* D O O U T P U T -- Returns 0 on failure, 1 on success */ |
---|
1866 | |
---|
1867 | int |
---|
1868 | dooutput(s) char *s; { |
---|
1869 | |
---|
1870 | int x, xx, y, quote; /* Workers */ |
---|
1871 | |
---|
1872 | debug(F111,"dooutput s",s,(int)strlen(s)); |
---|
1873 | |
---|
1874 | #ifndef NOLOCAL |
---|
1875 | if (local) { /* Condition external line */ |
---|
1876 | y = ttvt(speed,flow); |
---|
1877 | if (y < 0) return(0); |
---|
1878 | } |
---|
1879 | #endif /* NOLOCAL */ |
---|
1880 | if (!cmdgquo()) { /* COMMAND QUOTING OFF */ |
---|
1881 | x = strlen(s); /* Just send the string literally */ |
---|
1882 | xx = local ? ttol((CHAR *)s,x) : conxo(x,s); |
---|
1883 | return(success = (xx == x) ? 1 : 0); |
---|
1884 | } |
---|
1885 | quote = 0; /* Initialize backslash (\) quote */ |
---|
1886 | obn = 0; /* Reset count */ |
---|
1887 | obp = obuf; /* and pointers */ |
---|
1888 | |
---|
1889 | while (x = *s++) { /* Loop through the string */ |
---|
1890 | y = 0; /* Error code, 0 = no error. */ |
---|
1891 | debug(F000,"dooutput","",x); |
---|
1892 | if (quote) { /* This character is quoted */ |
---|
1893 | #ifndef NOKVERBS |
---|
1894 | #define K_BUFLEN 30 |
---|
1895 | #define SEND_BUFLEN 255 |
---|
1896 | #define sendbufd(x) { sendbuf[sendndx++] = x;\ |
---|
1897 | if (sendndx == SEND_BUFLEN) {dooutput(s); sendndx = 0;}} |
---|
1898 | |
---|
1899 | if (x == 'k' || x == 'K') { /* \k or \K */ |
---|
1900 | extern struct keytab kverbs[]; |
---|
1901 | extern int nkverbs; |
---|
1902 | extern char * keydefptr; |
---|
1903 | extern int keymac; |
---|
1904 | extern int keymacx; |
---|
1905 | int x, y, brace = 0; |
---|
1906 | int pause; |
---|
1907 | char * p, * b; |
---|
1908 | char kbuf[K_BUFLEN + 1]; /* Key verb name buffer */ |
---|
1909 | char sendbuf[SEND_BUFLEN +1]; |
---|
1910 | int sendndx = 0; |
---|
1911 | |
---|
1912 | if (xxout(obuf,obn) < 0) /* Flush buffer */ |
---|
1913 | goto outerr; |
---|
1914 | debug(F100,"OUTPUT KVERB","",0); /* Send a KVERB */ |
---|
1915 | { /* Have K verb? */ |
---|
1916 | if (!*s) { |
---|
1917 | break; |
---|
1918 | } |
---|
1919 | /* |
---|
1920 | We assume that the verb name is {braced}, or it extends to the end of the |
---|
1921 | string, s, or it ends with a space, control character, or backslash. |
---|
1922 | */ |
---|
1923 | p = kbuf; /* Copy verb name into local buffer */ |
---|
1924 | x = 0; |
---|
1925 | while ((x++ < K_BUFLEN) && (*s > SP) && (*s != CMDQ)) { |
---|
1926 | if (brace && *s == '}') { |
---|
1927 | break; |
---|
1928 | } |
---|
1929 | *p++ = *s++; |
---|
1930 | } |
---|
1931 | if (*s && !brace) /* If we broke because of \, etc, */ |
---|
1932 | s--; /* back up so we get another look. */ |
---|
1933 | brace = 0; |
---|
1934 | *p = NUL; /* Terminate. */ |
---|
1935 | p = kbuf; /* Point back to beginning */ |
---|
1936 | debug(F110,"dooutput kverb",p,0); |
---|
1937 | y = xlookup(kverbs,p,nkverbs,&x); /* Look it up */ |
---|
1938 | debug(F101,"dooutput lookup",0,y); |
---|
1939 | if (y > -1) { |
---|
1940 | if ( sendndx ) { |
---|
1941 | dooutput( sendbuf ); |
---|
1942 | sendndx = 0; |
---|
1943 | } |
---|
1944 | dokverb(VCMD,y); |
---|
1945 | #ifndef NOSPL |
---|
1946 | } else { /* Is it a macro? */ |
---|
1947 | y = mxlook(mactab,p,nmac); |
---|
1948 | if (y > -1) { |
---|
1949 | cmpush(); |
---|
1950 | keymac = 1; /* Flag for key macro active */ |
---|
1951 | keymacx = y; /* Key macro index */ |
---|
1952 | keydefptr = s; /* Where to resume next time */ |
---|
1953 | debug(F111,"dooutput mxlook",keydefptr,y); |
---|
1954 | parser(1); |
---|
1955 | cmpop(); |
---|
1956 | } |
---|
1957 | #endif /* NOSPL */ |
---|
1958 | } |
---|
1959 | } |
---|
1960 | quote = 0; |
---|
1961 | continue; |
---|
1962 | } else |
---|
1963 | #endif /* NOKVERBS */ |
---|
1964 | if (x == 'n' || x == 'N') { /* \n or \N */ |
---|
1965 | if (xxout(obuf,obn) < 0) /* Flush buffer */ |
---|
1966 | goto outerr; |
---|
1967 | debug(F100,"OUTPUT NUL","",0); /* Send a NUL */ |
---|
1968 | if (local) |
---|
1969 | ttoc(NUL); |
---|
1970 | else |
---|
1971 | conoc(NUL); |
---|
1972 | quote = 0; |
---|
1973 | continue; |
---|
1974 | |
---|
1975 | } else if (x == 'b' || x == 'B') { /* \b or \B */ |
---|
1976 | |
---|
1977 | if (xxout(obuf,obn) < 0) /* Flush buffer first */ |
---|
1978 | goto outerr; |
---|
1979 | debug(F100,"OUTPUT BREAK","",0); |
---|
1980 | #ifndef NOLOCAL |
---|
1981 | ttsndb(); /* Send BREAK signal */ |
---|
1982 | #else |
---|
1983 | if (local) |
---|
1984 | ttoc(NUL); |
---|
1985 | else |
---|
1986 | conoc(NUL); |
---|
1987 | #endif /* NOLOCAL */ |
---|
1988 | quote = 0; /* Turn off quote flag */ |
---|
1989 | continue; /* and not the b or B */ |
---|
1990 | #ifdef CK_LBRK |
---|
1991 | } else if (x == 'l' || x == 'L') { /* \l or \L */ |
---|
1992 | if (xxout(obuf,obn) < 0) /* Flush buffer first */ |
---|
1993 | goto outerr; |
---|
1994 | debug(F100,"OUTPUT Long BREAK","",0); |
---|
1995 | #ifndef NOLOCAL |
---|
1996 | ttsndlb(); /* Send Long BREAK signal */ |
---|
1997 | #else |
---|
1998 | if (local) |
---|
1999 | ttoc(NUL); |
---|
2000 | else |
---|
2001 | conoc(NUL); |
---|
2002 | #endif /* NOLOCAL */ |
---|
2003 | quote = 0; /* Turn off quote flag */ |
---|
2004 | continue; /* and not the l or L */ |
---|
2005 | #endif /* CK_LBRK */ |
---|
2006 | |
---|
2007 | } else if (x == CMDQ) { /* Backslash itself */ |
---|
2008 | debug(F100,"OUTPUT CMDQ","",0); |
---|
2009 | xx = oboc(dopar(CMDQ)); /* Output the backslash. */ |
---|
2010 | if (xx < 0) |
---|
2011 | goto outerr; |
---|
2012 | quote = 0; |
---|
2013 | continue; |
---|
2014 | |
---|
2015 | } else { /* if \ not followed by b or B */ |
---|
2016 | /* Note: Atari ST compiler won't allow macro call in "if ()" */ |
---|
2017 | xx = oboc(dopar(CMDQ)); /* Output the backslash. */ |
---|
2018 | if (xx < 0) |
---|
2019 | goto outerr; |
---|
2020 | quote = 0; /* Turn off quote flag */ |
---|
2021 | } |
---|
2022 | } else if (x == CMDQ) { /* This is the quote character */ |
---|
2023 | quote = 1; /* Go back and get next character */ |
---|
2024 | continue; /* which is quoted */ |
---|
2025 | } |
---|
2026 | xx = oboc(dopar((char)x)); /* Output this character */ |
---|
2027 | debug(F111,"dooutput",obuf,obn); |
---|
2028 | if (xx < 0) |
---|
2029 | goto outerr; |
---|
2030 | if (seslog && duplex) /* Log the character if log is on */ |
---|
2031 | if (zchout(ZSFILE,(char)x) < 0) /* and connection is half duplex */ |
---|
2032 | seslog = 0; |
---|
2033 | if (x == '\015') { /* String contains carriage return */ |
---|
2034 | int stuff = -1, stuff2 = -1; |
---|
2035 | if (tnlm) { /* TERMINAL NEWLINE ON */ |
---|
2036 | stuff = LF; /* Stuff LF */ |
---|
2037 | } |
---|
2038 | #ifdef TNCODE |
---|
2039 | /* TELNET NEWLINE ON/OFF/RAW */ |
---|
2040 | if (network && (ttnproto == NP_TELNET)) { |
---|
2041 | switch (me_binary ? tn_b_nlm : tn_nlm) { /* NVT or BINARY */ |
---|
2042 | case TNL_CR: |
---|
2043 | break; |
---|
2044 | case TNL_CRNUL: |
---|
2045 | stuff2 = stuff; |
---|
2046 | stuff = NUL; |
---|
2047 | break; |
---|
2048 | case TNL_CRLF: |
---|
2049 | stuff2 = stuff; |
---|
2050 | stuff = LF; |
---|
2051 | break; |
---|
2052 | } |
---|
2053 | } |
---|
2054 | #endif /* TNCODE */ |
---|
2055 | if (stuff > -1) { /* Stuffing another character... */ |
---|
2056 | xx = oboc(dopar((CHAR)stuff)); |
---|
2057 | if (xx < 0) |
---|
2058 | goto outerr; |
---|
2059 | if (seslog && duplex) /* Log stuffed char if appropriate */ |
---|
2060 | if (zchout(ZSFILE, (CHAR)stuff) < 0) |
---|
2061 | seslog = 0; |
---|
2062 | } |
---|
2063 | if (stuff2 > -1) { /* Stuffing another character... */ |
---|
2064 | xx = oboc(dopar((CHAR)stuff2)); |
---|
2065 | if (xx < 0) |
---|
2066 | goto outerr; |
---|
2067 | if (seslog && duplex) /* Log stuffed char if appropriate */ |
---|
2068 | if (zchout(ZSFILE, (CHAR)stuff2) < 0) |
---|
2069 | seslog = 0; |
---|
2070 | } |
---|
2071 | if (xxout(obuf,obn) < 0) /* Flushing is required here! */ |
---|
2072 | goto outerr; |
---|
2073 | } |
---|
2074 | } |
---|
2075 | if (quote == 1) /* String ended with backslash */ |
---|
2076 | xx = oboc(dopar(CMDQ)); |
---|
2077 | |
---|
2078 | if (obn > 0) /* OUTPUT done */ |
---|
2079 | if (xxout(obuf,obn) < 0) /* Flush the buffer if necessary. */ |
---|
2080 | goto outerr; |
---|
2081 | return(1); |
---|
2082 | |
---|
2083 | outerr: /* OUTPUT command error handler */ |
---|
2084 | if (msgflg) printf("OUTPUT error\n"); |
---|
2085 | return(0); |
---|
2086 | |
---|
2087 | /* Remove "local" OUTPUT macro defininitions */ |
---|
2088 | |
---|
2089 | #ifdef COMMENT |
---|
2090 | /* No more macros ... */ |
---|
2091 | #undef oboc |
---|
2092 | #undef obfls |
---|
2093 | #endif /* COMMENT */ |
---|
2094 | } |
---|
2095 | #endif /* NOSPL */ |
---|
2096 | |
---|
2097 | /* Display version herald and initial prompt */ |
---|
2098 | |
---|
2099 | VOID |
---|
2100 | herald() { |
---|
2101 | int x = 0; |
---|
2102 | |
---|
2103 | if (noherald || bgset > 0 || (bgset != 0 && backgrd != 0)) x = 1; |
---|
2104 | debug(F101,"herald","",backgrd); |
---|
2105 | if (x == 0) { |
---|
2106 | #ifdef datageneral |
---|
2107 | printf("%s, for%s\n",versio,ckxsys); |
---|
2108 | #else |
---|
2109 | #ifdef OSK |
---|
2110 | printf("%s, for%s\n",versio,ckxsys); |
---|
2111 | #else |
---|
2112 | printf("%s, for%s\n\r",versio,ckxsys); |
---|
2113 | #endif /* OSK */ |
---|
2114 | #endif /* datageneral */ |
---|
2115 | printf(" Copyright (C) 1985, 1996,\n"); |
---|
2116 | printf(" Trustees of Columbia University in the City of New York.\n"); |
---|
2117 | |
---|
2118 | #ifdef OS2 |
---|
2119 | shoreg(); |
---|
2120 | #endif /* OS2 */ |
---|
2121 | |
---|
2122 | if (!quiet && !backgrd) { |
---|
2123 | char *s = NULL; |
---|
2124 | switch (binary) { |
---|
2125 | case XYFT_T: s = "TEXT"; break; |
---|
2126 | #ifdef VMS |
---|
2127 | case XYFT_B: s = "BINARY FIXED"; break; |
---|
2128 | case XYFT_I: s = "IMAGE"; break; |
---|
2129 | case XYFT_L: s = "LABELED"; break; |
---|
2130 | case XYFT_U: s = "BINARY UNDEF"; break; |
---|
2131 | #else |
---|
2132 | #ifdef MAC |
---|
2133 | case XYFT_B: s = "BINARY"; break; |
---|
2134 | case XYFT_M: s = "MACBINARY"; break; |
---|
2135 | #else |
---|
2136 | case XYFT_B: s = "BINARY"; break; |
---|
2137 | #ifdef CK_LABELED |
---|
2138 | case XYFT_L: s = "LABELED"; break; |
---|
2139 | #endif /* CK_LABELED */ |
---|
2140 | #endif /* MAC */ |
---|
2141 | #endif /* VMS */ |
---|
2142 | } |
---|
2143 | if (s) printf("Default file-transfer mode is %s\n", s); |
---|
2144 | #ifdef COMMENT |
---|
2145 | #ifdef NT |
---|
2146 | printf("\n"); |
---|
2147 | printf("StartedFromDialer = %d\n",StartedFromDialer); |
---|
2148 | printf("Window Handle = %ld\n",DialerHandle); |
---|
2149 | printf("\n"); |
---|
2150 | #endif /* NT */ |
---|
2151 | #endif /* COMMENT */ |
---|
2152 | printf("Type ? or HELP for help.\n"); |
---|
2153 | } |
---|
2154 | } |
---|
2155 | } |
---|
2156 | |
---|
2157 | #ifndef NOSPL |
---|
2158 | /* M L O O K -- Lookup the macro name in the macro table */ |
---|
2159 | |
---|
2160 | /* |
---|
2161 | Call this way: v = mlook(table,word,n); |
---|
2162 | |
---|
2163 | table - a 'struct mtab' table. |
---|
2164 | word - the target string to look up in the table. |
---|
2165 | n - the number of elements in the table. |
---|
2166 | |
---|
2167 | The keyword table must be arranged in ascending alphabetical order, and |
---|
2168 | all letters must be lowercase. |
---|
2169 | |
---|
2170 | Returns the table index, 0 or greater, if the name was found, or: |
---|
2171 | |
---|
2172 | -3 if nothing to look up (target was null), |
---|
2173 | -2 if ambiguous, |
---|
2174 | -1 if not found. |
---|
2175 | |
---|
2176 | A match is successful if the target matches a keyword exactly, or if |
---|
2177 | the target is a prefix of exactly one keyword. It is ambiguous if the |
---|
2178 | target matches two or more keywords from the table. |
---|
2179 | */ |
---|
2180 | int |
---|
2181 | mlook(table,cmd,n) struct mtab table[]; char *cmd; int n; { |
---|
2182 | |
---|
2183 | int i, v, cmdlen; |
---|
2184 | |
---|
2185 | /* Lowercase & get length of target, if it's null return code -3. */ |
---|
2186 | |
---|
2187 | if ((((cmdlen = lower(cmd))) == 0) || (n < 1)) return(-3); |
---|
2188 | |
---|
2189 | /* Not null, look it up */ |
---|
2190 | |
---|
2191 | for (i = 0; i < n-1; i++) { |
---|
2192 | if (!strcmp(table[i].kwd,cmd) || |
---|
2193 | ((v = !strncmp(table[i].kwd,cmd,cmdlen)) && |
---|
2194 | strncmp(table[i+1].kwd,cmd,cmdlen))) { |
---|
2195 | return(i); |
---|
2196 | } |
---|
2197 | if (v) return(-2); |
---|
2198 | } |
---|
2199 | |
---|
2200 | /* Last (or only) element */ |
---|
2201 | |
---|
2202 | if (!strncmp(table[n-1].kwd,cmd,cmdlen)) { |
---|
2203 | return(n-1); |
---|
2204 | } else return(-1); |
---|
2205 | } |
---|
2206 | |
---|
2207 | /* mxlook is like mlook, but an exact full-length match is required */ |
---|
2208 | |
---|
2209 | int |
---|
2210 | mxlook(table,cmd,n) char *cmd; struct mtab table[]; int n; { |
---|
2211 | int i, cmdlen; |
---|
2212 | if ((((cmdlen = lower(cmd))) == 0) || (n < 1)) return(-3); |
---|
2213 | for (i = 0; i < n; i++) |
---|
2214 | if (((int)strlen(table[i].kwd) == cmdlen) && |
---|
2215 | (!strncmp(table[i].kwd,cmd,cmdlen))) return(i); |
---|
2216 | return(-1); |
---|
2217 | } |
---|
2218 | |
---|
2219 | /* |
---|
2220 | This routine is for the benefit of those compilers that can't handle |
---|
2221 | long string constants or continued lines within them. Long predefined |
---|
2222 | macros like FOR, WHILE, and XIF have their contents broken up into |
---|
2223 | arrays of string pointers. This routine concatenates them back into a |
---|
2224 | single string again, and then calls the real addmac() routine to enter |
---|
2225 | the definition into the macro table. |
---|
2226 | */ |
---|
2227 | int |
---|
2228 | addmmac(nam,s) char *nam, *s[]; { /* Add a multiline macro definition */ |
---|
2229 | int i, x, y; char *p; |
---|
2230 | x = 0; /* Length counter */ |
---|
2231 | for (i = 0; (y = (int)strlen(s[i])) > 0; i++) { /* Add up total length */ |
---|
2232 | debug(F111,"addmmac line",s[i],y); |
---|
2233 | x += y; |
---|
2234 | } |
---|
2235 | debug(F101,"addmmac lines","",i); |
---|
2236 | debug(F101,"addmmac loop exit","",y); |
---|
2237 | debug(F111,"addmmac length",nam,x); |
---|
2238 | if (x < 0) return(-1); |
---|
2239 | |
---|
2240 | p = malloc(x+1); /* Allocate space for all of it. */ |
---|
2241 | if (!p) { |
---|
2242 | printf("?addmmac malloc error: %s\n",nam); |
---|
2243 | debug(F110,"addmmac malloc error",nam,0); |
---|
2244 | return(-1); |
---|
2245 | } |
---|
2246 | *p = '\0'; /* Start off with null string. */ |
---|
2247 | for (i = 0; *s[i]; i++) /* Concatenate them all together. */ |
---|
2248 | strcat(p,s[i]); |
---|
2249 | y = (int)strlen(p); /* Final precaution. */ |
---|
2250 | debug(F111,"addmmac constructed string",p,y); |
---|
2251 | if (y == x) { |
---|
2252 | y = addmac(nam,p); /* Add result to the macro table. */ |
---|
2253 | } else { |
---|
2254 | debug(F100,"addmmac length mismatch","",0); |
---|
2255 | printf("\n!addmmac internal error!\n"); |
---|
2256 | y = -1; |
---|
2257 | } |
---|
2258 | free(p); /* Free the temporary copy. */ |
---|
2259 | return(y); |
---|
2260 | } |
---|
2261 | |
---|
2262 | /* Here is the real addmac routine. */ |
---|
2263 | |
---|
2264 | /* Returns -1 on failure, 0 on success. */ |
---|
2265 | |
---|
2266 | int |
---|
2267 | addmac(nam,def) char *nam, *def; { /* Add a macro to the macro table */ |
---|
2268 | int i, x, y, z, namlen, deflen; |
---|
2269 | char * p = NULL, c; |
---|
2270 | |
---|
2271 | if (!nam) return(-1); |
---|
2272 | namlen = (int)strlen(nam); /* Get argument lengths */ |
---|
2273 | debug(F111,"addmac nam",nam,namlen); |
---|
2274 | if (!def) { /* Watch out for null pointer */ |
---|
2275 | deflen = 0; |
---|
2276 | debug(F111,"addmac def","(null pointer)",deflen); |
---|
2277 | } else { |
---|
2278 | deflen = (int)strlen(def); |
---|
2279 | debug(F111,"addmac def",def,deflen); |
---|
2280 | } |
---|
2281 | if (deflen < 0) return(-1); /* strlen() failure, fail. */ |
---|
2282 | if (namlen < 1) return(-1); /* No name given, fail. */ |
---|
2283 | |
---|
2284 | if (*nam == CMDQ) nam++; /* Backslash quote? */ |
---|
2285 | if (*nam == '%') { /* Yes, if it's a variable name, */ |
---|
2286 | delmac(nam); /* Delete any old value. */ |
---|
2287 | if (!(c = *(nam + 1))) return(-1); /* Variable name letter or digit */ |
---|
2288 | if (deflen < 1) { /* Null definition */ |
---|
2289 | p = NULL; /* Better not malloc or strcpy! */ |
---|
2290 | } else { /* A substantial definition */ |
---|
2291 | p = malloc(deflen + 1); /* Allocate space for it */ |
---|
2292 | if (!p) { |
---|
2293 | printf("?addmac malloc error 2\n"); |
---|
2294 | return(-1); |
---|
2295 | } else strcpy(p,def); /* Copy definition into new space */ |
---|
2296 | } |
---|
2297 | |
---|
2298 | /* Now p points to the definition, or is a null pointer */ |
---|
2299 | |
---|
2300 | if (p) |
---|
2301 | debug(F110,"addmac p",p,0); |
---|
2302 | else |
---|
2303 | debug(F110,"addmac p","(null pointer)",0); |
---|
2304 | |
---|
2305 | if (c >= '0' && c <= '9') { /* Digit variable */ |
---|
2306 | if (maclvl < 0) { /* Are we calling or in a macro? */ |
---|
2307 | g_var[c] = p; /* No, it's a global "top level" one */ |
---|
2308 | debug(F101,"addmac numeric global maclvl","",maclvl); |
---|
2309 | } else { /* Yes, it's a macro argument */ |
---|
2310 | char **q; |
---|
2311 | m_arg[maclvl][c - '0'] = p; /* Assign the value */ |
---|
2312 | debug(F101,"addmac macro arg maclvl","",maclvl); |
---|
2313 | q = a_ptr[0]; /* Copy pointer to macro arg vector */ |
---|
2314 | q[c - '0'] = p; |
---|
2315 | } |
---|
2316 | } else { /* It's a global variable */ |
---|
2317 | if (c < 33 || c > GVARS) return(-1); |
---|
2318 | if (isupper(c)) c = (char) tolower(c); |
---|
2319 | g_var[c] = p; /* Put pointer in global-var table */ |
---|
2320 | debug(F100,"addmac global","",0); |
---|
2321 | } |
---|
2322 | return(0); |
---|
2323 | } else if (*nam == '&') { /* An array reference? */ |
---|
2324 | char **q; |
---|
2325 | if ((y = arraynam(nam,&x,&z)) < 0) /* If syntax is bad */ |
---|
2326 | return(-1); /* return -1. */ |
---|
2327 | if (chkarray(x,z) < 0) /* If array not declared or */ |
---|
2328 | return(-2); /* subscript out of range, ret -2 */ |
---|
2329 | delmac(nam); /* Delete any current definition. */ |
---|
2330 | x -= ARRAYBASE; /* Convert name letter to index. */ |
---|
2331 | if ((q = a_ptr[x]) == NULL) /* If array not declared, */ |
---|
2332 | return(-3); /* return -3. */ |
---|
2333 | if (deflen > 0) { |
---|
2334 | if ((p = malloc(deflen+1)) == NULL) { /* Allocate space */ |
---|
2335 | printf("addmac macro error 7: %s\n",nam); |
---|
2336 | return(-4); /* for new def, return -4 on fail. */ |
---|
2337 | } |
---|
2338 | strcpy(p,def); /* Copy definition into new space. */ |
---|
2339 | } else p = NULL; |
---|
2340 | q[z] = p; /* Store pointer to it. */ |
---|
2341 | return(0); /* Done. */ |
---|
2342 | } else debug(F110,"addmac macro def",nam,0); |
---|
2343 | |
---|
2344 | /* Not a macro argument or a variable, so it's a macro definition */ |
---|
2345 | |
---|
2346 | lower(nam); /* Lowercase the name */ |
---|
2347 | if (mxlook(mactab,nam,nmac) > -1) /* Look up, requiring exact match */ |
---|
2348 | delmac(nam); /* if it's there, delete it. */ |
---|
2349 | if (deflen < 1) |
---|
2350 | return(0); |
---|
2351 | debug(F111,"addmac table size",nam,nmac); |
---|
2352 | for (y = 0; /* Find the alphabetical slot */ |
---|
2353 | y < MAC_MAX && mactab[y].kwd != NULL && strcmp(nam,mactab[y].kwd) > 0; |
---|
2354 | y++); |
---|
2355 | if (y == MAC_MAX) { /* No more room. */ |
---|
2356 | debug(F101,"addmac table overflow","",y); |
---|
2357 | return(-1); |
---|
2358 | } else debug(F111,"addmac position",nam,y); |
---|
2359 | if (mactab[y].kwd != NULL) { /* Must insert */ |
---|
2360 | for (i = nmac; i > y; i--) { /* Move the rest down one slot */ |
---|
2361 | mactab[i].kwd = mactab[i-1].kwd; |
---|
2362 | mactab[i].mval = mactab[i-1].mval; |
---|
2363 | mactab[i].flgs = mactab[i-1].flgs; |
---|
2364 | } |
---|
2365 | } |
---|
2366 | p = malloc(namlen + 1); /* Allocate space for name */ |
---|
2367 | if (!p) { |
---|
2368 | printf("?addmac malloc error 3: %s\n",nam); |
---|
2369 | return(-1); |
---|
2370 | } |
---|
2371 | strcpy(p,nam); /* Copy name into new space */ |
---|
2372 | mactab[y].kwd = p; /* Add pointer to table */ |
---|
2373 | |
---|
2374 | if (deflen > 0) { /* Same deal for definition */ |
---|
2375 | p = malloc(deflen + 1); /* but watch out for null pointer */ |
---|
2376 | if (p == NULL) { |
---|
2377 | printf("?addmac malloc error 5: %s\n", nam); |
---|
2378 | if (mactab[y].kwd) { |
---|
2379 | free(mactab[y].kwd); |
---|
2380 | mactab[y].kwd = NULL; |
---|
2381 | } |
---|
2382 | return(-1); |
---|
2383 | } else strcpy(p,def); /* Copy the definition */ |
---|
2384 | } else p = NULL; |
---|
2385 | mactab[y].mval = p; |
---|
2386 | mactab[y].flgs = 0; |
---|
2387 | nmac++; /* Count this macro */ |
---|
2388 | return(y); |
---|
2389 | } |
---|
2390 | |
---|
2391 | int |
---|
2392 | delmac(nam) char *nam; { /* Delete the named macro */ |
---|
2393 | int i, x, z; |
---|
2394 | char *p, c; |
---|
2395 | |
---|
2396 | if (!nam) return(0); /* Watch out for null pointer */ |
---|
2397 | debug(F110,"delmac nam",nam,0); |
---|
2398 | if (*nam == CMDQ) nam++; |
---|
2399 | if (*nam == '%') { /* If it's a variable name */ |
---|
2400 | if (!(c = *(nam+1))) return(0); /* Get variable name letter or digit */ |
---|
2401 | p = (char *)0; /* Initialize value pointer */ |
---|
2402 | if (maclvl > -1 && c >= '0' && c <= '9') { /* Digit? */ |
---|
2403 | p = m_arg[maclvl][c - '0']; /* Get pointer from macro-arg table */ |
---|
2404 | m_arg[maclvl][c - '0'] = NULL; /* Zero the table pointer */ |
---|
2405 | } else { /* It's a global variable */ |
---|
2406 | if (c < 33 || c > GVARS) return(0); |
---|
2407 | p = g_var[c]; /* Get pointer from global-var table */ |
---|
2408 | g_var[c] = NULL; /* Zero the table entry */ |
---|
2409 | } |
---|
2410 | if (p) { |
---|
2411 | debug(F110,"delmac def",p,0); |
---|
2412 | free(p); /* Free the storage */ |
---|
2413 | p = NULL; |
---|
2414 | } else debug(F110,"delmac def","(null pointer)",0); |
---|
2415 | return(0); |
---|
2416 | } |
---|
2417 | |
---|
2418 | if (*nam == '&') { /* An array reference? */ |
---|
2419 | char **q; |
---|
2420 | if (arraynam(nam,&x,&z) < 0) /* If syntax is bad */ |
---|
2421 | return(-1); /* return -1. */ |
---|
2422 | x -= ARRAYBASE; /* Convert name to number. */ |
---|
2423 | if ((q = a_ptr[x]) == NULL) /* If array not declared, */ |
---|
2424 | return(-2); /* return -2. */ |
---|
2425 | if (z > a_dim[x]) /* If subscript out of range, */ |
---|
2426 | return(-3); /* return -3. */ |
---|
2427 | if (q[z]) { /* If there is an old value, */ |
---|
2428 | debug(F110,"delman def",q[z],0); |
---|
2429 | if (x != 0) /* Macro arg vector is just a copy */ |
---|
2430 | free(q[z]); /* Others are real so free them */ |
---|
2431 | q[z] = NULL; |
---|
2432 | } else debug(F110,"delmac def","(null pointer)",0); |
---|
2433 | } |
---|
2434 | |
---|
2435 | /* Not a variable or an array, so it must be a macro. */ |
---|
2436 | |
---|
2437 | if ((x = mlook(mactab,nam,nmac)) < 0) { /* Look it up */ |
---|
2438 | debug(F111,"delmac mlook",nam,x); |
---|
2439 | return(x); |
---|
2440 | } |
---|
2441 | if (mactab[x].kwd) { /* Free the storage for the name */ |
---|
2442 | free(mactab[x].kwd); |
---|
2443 | mactab[x].kwd = NULL; |
---|
2444 | } |
---|
2445 | if (mactab[x].mval) { /* and for the definition */ |
---|
2446 | free(mactab[x].mval); |
---|
2447 | mactab[x].mval = NULL; |
---|
2448 | } |
---|
2449 | for (i = x; i < nmac; i++) { /* Now move up the others. */ |
---|
2450 | mactab[i].kwd = mactab[i+1].kwd; |
---|
2451 | mactab[i].mval = mactab[i+1].mval; |
---|
2452 | mactab[i].flgs = mactab[i+1].flgs; |
---|
2453 | } |
---|
2454 | nmac--; /* One less macro */ |
---|
2455 | mactab[nmac].kwd = NULL; /* Delete last item from table */ |
---|
2456 | mactab[nmac].mval = NULL; |
---|
2457 | mactab[nmac].flgs = 0; |
---|
2458 | return(0); |
---|
2459 | } |
---|
2460 | |
---|
2461 | VOID |
---|
2462 | initmac() { /* Init macro & variable tables */ |
---|
2463 | int i, j; |
---|
2464 | |
---|
2465 | nmac = 0; /* No macros */ |
---|
2466 | for (i = 0; i < MAC_MAX; i++) { /* Initialize the macro table */ |
---|
2467 | mactab[i].kwd = NULL; |
---|
2468 | mactab[i].mval = NULL; |
---|
2469 | mactab[i].flgs = 0; |
---|
2470 | } |
---|
2471 | for (i = 0; i < MACLEVEL; i++) { /* Init the macro argument tables */ |
---|
2472 | mrval[i] = NULL; |
---|
2473 | for (j = 0; j < 10; j++) { |
---|
2474 | m_arg[i][j] = NULL; |
---|
2475 | } |
---|
2476 | } |
---|
2477 | for (i = 0; i < GVARS; i++) { /* And the global variables table */ |
---|
2478 | g_var[i] = NULL; |
---|
2479 | } |
---|
2480 | /* And the table of arrays */ |
---|
2481 | for (i = 0; i < (int) 'z' - ARRAYBASE + 1; i++) { |
---|
2482 | a_ptr[i] = (char **) NULL; /* Null pointer for each */ |
---|
2483 | a_dim[i] = 0; /* and a dimension of zero */ |
---|
2484 | } |
---|
2485 | } |
---|
2486 | |
---|
2487 | int |
---|
2488 | popclvl() { /* Pop command level, return cmdlvl */ |
---|
2489 | struct localvar * v; |
---|
2490 | debug(F101,"popclvl cmdlvl","",cmdlvl); |
---|
2491 | if (cmdlvl > 0) { |
---|
2492 | if (v = localhead[cmdlvl]) { /* Did we save any variables? */ |
---|
2493 | while (v) { /* Yes */ |
---|
2494 | if (v->lv_value) /* Copy old ones back */ |
---|
2495 | addmac(v->lv_name,v->lv_value); |
---|
2496 | else |
---|
2497 | delmac(v->lv_name); |
---|
2498 | v = v->lv_next; |
---|
2499 | } |
---|
2500 | freelocal(cmdlvl); /* Free local storage */ |
---|
2501 | } |
---|
2502 | } |
---|
2503 | if (cmdlvl < 1) { /* If we're already at top level */ |
---|
2504 | cmdlvl = 0; /* just make sure all the */ |
---|
2505 | tlevel = -1; /* stack pointers are set right */ |
---|
2506 | maclvl = -1; /* and return */ |
---|
2507 | } else if (cmdstk[cmdlvl].src == CMD_TF) { /* Reading from TAKE file? */ |
---|
2508 | debug(F101,"popclvl tlevel","",tlevel); |
---|
2509 | if (tlevel > -1) { /* Yes, */ |
---|
2510 | fclose(tfile[tlevel]); /* close it */ |
---|
2511 | if (tfnam[tlevel]) { /* free storage for name */ |
---|
2512 | free(tfnam[tlevel]); |
---|
2513 | tfnam[tlevel] = NULL; |
---|
2514 | } |
---|
2515 | tlevel--; /* and pop take level */ |
---|
2516 | cmdlvl--; /* and command level */ |
---|
2517 | } else tlevel = -1; |
---|
2518 | } else if (cmdstk[cmdlvl].src == CMD_MD) { /* In a macro? */ |
---|
2519 | debug(F101,"popclvl maclvl","",maclvl); |
---|
2520 | if (maclvl > -1) { /* Yes, */ |
---|
2521 | int i; |
---|
2522 | char **q; |
---|
2523 | debug(F111,"popclvl mac 1",macx[maclvl],maclvl); |
---|
2524 | debug(F111,"popclvl mac 2",macp[maclvl],maclvl); |
---|
2525 | macp[maclvl] = ""; /* set macro pointer to null string */ |
---|
2526 | debug(F111,"popclvl mac 3",macp[maclvl],maclvl); |
---|
2527 | *cmdbuf = '\0'; /* clear the command buffer */ |
---|
2528 | debug(F111,"popclvl mac 4",mrval[maclvl+1],maclvl); |
---|
2529 | if (mrval[maclvl+1]) { /* Free any deeper return values. */ |
---|
2530 | free(mrval[maclvl+1]); |
---|
2531 | mrval[maclvl+1] = NULL; |
---|
2532 | } |
---|
2533 | debug(F111,"popclvl mac 6",mrval[maclvl+1],maclvl); |
---|
2534 | maclvl--; /* Pop macro level */ |
---|
2535 | cmdlvl--; /* and command level */ |
---|
2536 | q = a_ptr[0]; |
---|
2537 | debug(F101,"popclvl mac 7","",maclvl); |
---|
2538 | if (maclvl > -1) |
---|
2539 | for (i = 0; i < 10; i++) /* Restore previous arg vector */ |
---|
2540 | q[i] = m_arg[maclvl][i]; |
---|
2541 | debug(F111,"popclvl mac 8", |
---|
2542 | (maclvl > -1 && macx[maclvl]) ? macx[maclvl] : "",maclvl); |
---|
2543 | } else maclvl = -1; |
---|
2544 | } |
---|
2545 | #ifndef MAC |
---|
2546 | if (cmdlvl < 1) { /* If back at top level */ |
---|
2547 | conint(trap,stptrap); /* Fix interrupts */ |
---|
2548 | bgchk(); /* Check background status */ |
---|
2549 | concb((char)escape); /* Go into cbreak mode */ |
---|
2550 | } |
---|
2551 | #endif /* MAC */ |
---|
2552 | return(cmdlvl < 1 ? 0 : cmdlvl); /* Return command level */ |
---|
2553 | } |
---|
2554 | #else /* No script programming language */ |
---|
2555 | int popclvl() { /* Just close current take file. */ |
---|
2556 | if (tlevel > -1) { /* if any... */ |
---|
2557 | if (tfnam[tlevel]) { |
---|
2558 | free(tfnam[tlevel]); |
---|
2559 | tfnam[tlevel] = NULL; |
---|
2560 | } |
---|
2561 | fclose(tfile[tlevel--]); |
---|
2562 | } |
---|
2563 | if (tlevel == -1) { /* And if back at top level */ |
---|
2564 | conint(trap,stptrap); /* check and set interrupts */ |
---|
2565 | bgchk(); /* and background status */ |
---|
2566 | concb((char)escape); /* and go back into cbreak mode. */ |
---|
2567 | } |
---|
2568 | return(tlevel + 1); |
---|
2569 | } |
---|
2570 | #endif /* NOSPL */ |
---|
2571 | |
---|
2572 | /* STOP - get back to C-Kermit prompt, no matter where from. */ |
---|
2573 | |
---|
2574 | int |
---|
2575 | dostop() { |
---|
2576 | while (popclvl()) ; /* Pop all macros & take files */ |
---|
2577 | #ifndef NOSPL |
---|
2578 | while (cmpop() > -1); /* And all recursive cmd pkg invocations */ |
---|
2579 | #endif /* NOSPL */ |
---|
2580 | cmini(ckxech); /* Clear the command buffer. */ |
---|
2581 | return(0); |
---|
2582 | } |
---|
2583 | |
---|
2584 | |
---|
2585 | /* Close the given log */ |
---|
2586 | |
---|
2587 | int |
---|
2588 | doclslog(x) int x; { |
---|
2589 | int y; |
---|
2590 | switch (x) { |
---|
2591 | #ifdef DEBUG |
---|
2592 | case LOGD: |
---|
2593 | if (deblog <= 0) { |
---|
2594 | printf("?Debugging log wasn't open\n"); |
---|
2595 | return(0); |
---|
2596 | } |
---|
2597 | debug(F100,"Debug Log Closed","",0L); |
---|
2598 | *debfil = '\0'; |
---|
2599 | deblog = 0; |
---|
2600 | return(zclose(ZDFILE)); |
---|
2601 | #endif /* DEBUG */ |
---|
2602 | |
---|
2603 | case LOGP: |
---|
2604 | if (pktlog <= 0) { |
---|
2605 | printf("?Packet log wasn't open\n"); |
---|
2606 | return(0); |
---|
2607 | } |
---|
2608 | *pktfil = '\0'; |
---|
2609 | pktlog = 0; |
---|
2610 | return(zclose(ZPFILE)); |
---|
2611 | |
---|
2612 | #ifndef NOLOCAL |
---|
2613 | case LOGS: |
---|
2614 | if (seslog <= 0) { |
---|
2615 | printf("?Session log wasn't open\n"); |
---|
2616 | return(0); |
---|
2617 | } |
---|
2618 | *sesfil = '\0'; |
---|
2619 | seslog = 0; |
---|
2620 | return(zclose(ZSFILE)); |
---|
2621 | #endif /* NOLOCAL */ |
---|
2622 | |
---|
2623 | #ifdef TLOG |
---|
2624 | case LOGT: |
---|
2625 | if (tralog <= 0) { |
---|
2626 | printf("?Transaction log wasn't open\n"); |
---|
2627 | return(0); |
---|
2628 | } |
---|
2629 | tlog(F100,"Transaction Log Closed","",0L); |
---|
2630 | *trafil = '\0'; |
---|
2631 | tralog = 0; |
---|
2632 | return(zclose(ZTFILE)); |
---|
2633 | #endif /* TLOG */ |
---|
2634 | |
---|
2635 | #ifndef NOSPL |
---|
2636 | case LOGW: /* WRITE file */ |
---|
2637 | case LOGR: /* READ file */ |
---|
2638 | y = (x == LOGR) ? ZRFILE : ZWFILE; |
---|
2639 | if (chkfn(y) < 1) /* If no file to close */ |
---|
2640 | return(1); /* succeed silently. */ |
---|
2641 | return(zclose(y)); /* Otherwise, close the file. */ |
---|
2642 | #endif /* NOSPL */ |
---|
2643 | |
---|
2644 | default: |
---|
2645 | printf("\n?Unexpected log designator - %d\n", x); |
---|
2646 | return(0); |
---|
2647 | } |
---|
2648 | } |
---|
2649 | |
---|
2650 | static char *nm[] = { "disabled", "local only", "remote only", "enabled" }; |
---|
2651 | |
---|
2652 | static int slc = 0; /* Screen line count */ |
---|
2653 | |
---|
2654 | #ifndef NOSHOW |
---|
2655 | char * |
---|
2656 | showoff(x) int x; { |
---|
2657 | return( x ? "on" : "off"); |
---|
2658 | } |
---|
2659 | |
---|
2660 | #ifndef NOFRILLS |
---|
2661 | #define xxdiff(v,sys) strncmp(v,sys,strlen(sys)) |
---|
2662 | VOID |
---|
2663 | shover() { |
---|
2664 | extern long xvernum; |
---|
2665 | extern char *ck_ver; |
---|
2666 | printf("\nVersions:\n %s\n Numeric: %ld",versio,vernum); |
---|
2667 | if (verwho) printf("-%d",verwho); |
---|
2668 | printf("\n"); |
---|
2669 | if (xvernum) |
---|
2670 | printf("C-Kermit %s\n",ck_ver); |
---|
2671 | printf(xxdiff(ckxv,ckxsys) ? " %s for%s\n" : " %s\n",ckxv,ckxsys); |
---|
2672 | printf(xxdiff(ckzv,ckzsys) ? " %s for%s\n" : " %s\n",ckzv,ckzsys); |
---|
2673 | printf(" %s\n",protv); |
---|
2674 | printf(" %s\n",fnsv); |
---|
2675 | printf(" %s\n %s\n",cmdv,userv); |
---|
2676 | #ifndef NOCSETS |
---|
2677 | printf(" %s\n",xlav); |
---|
2678 | #endif /* NOCSETS */ |
---|
2679 | #ifndef MAC |
---|
2680 | printf(" %s\n",connv); |
---|
2681 | #endif /* MAC */ |
---|
2682 | #ifndef NODIAL |
---|
2683 | printf(" %s\n",dialv); |
---|
2684 | #endif /* NODIAL */ |
---|
2685 | #ifndef NOSCRIPT |
---|
2686 | printf(" %s\n",loginv); |
---|
2687 | #endif /* NOSCRIPT */ |
---|
2688 | #ifdef NETCONN |
---|
2689 | printf(" %s\n",cknetv); |
---|
2690 | #ifdef OS2 |
---|
2691 | printf(" %s\n",ckonetv); |
---|
2692 | #ifdef CK_NETBIOS |
---|
2693 | printf(" %s\n",ckonbiv); |
---|
2694 | #endif /* CK_NETBIOS */ |
---|
2695 | #ifdef OS2MOUSE |
---|
2696 | printf(" %s\n",ckomouv); |
---|
2697 | #endif /* OS2MOUSE */ |
---|
2698 | #endif /* OS2 */ |
---|
2699 | #endif /* NETCONN */ |
---|
2700 | printf("\n"); |
---|
2701 | } |
---|
2702 | |
---|
2703 | VOID |
---|
2704 | shofea() { |
---|
2705 | int flag = 0; |
---|
2706 | int lines = 5; |
---|
2707 | #ifdef OS2 |
---|
2708 | #ifdef NT |
---|
2709 | if (isWin95()) |
---|
2710 | printf("\nWindows 95.\n"); |
---|
2711 | else |
---|
2712 | printf("\nWindows NT.\n"); |
---|
2713 | lines++; |
---|
2714 | #else /* NT */ |
---|
2715 | #ifdef M_I286 |
---|
2716 | printf("\nOS/2 16-bit.\n"); |
---|
2717 | #else |
---|
2718 | printf("\nOS/2 32-bit.\n"); |
---|
2719 | #endif /* M_I286 */ |
---|
2720 | lines++; |
---|
2721 | #endif /* NT */ |
---|
2722 | #endif /* OS2 */ |
---|
2723 | printf("\nMajor optional features included:\n"); |
---|
2724 | lines++; |
---|
2725 | #ifdef NETCONN |
---|
2726 | printf(" Network support (type SHOW NET for further info)\n"); |
---|
2727 | lines++; |
---|
2728 | #endif /* NETCONN */ |
---|
2729 | #ifdef CK_RTSCTS |
---|
2730 | printf(" Hardware flow control\n"); |
---|
2731 | lines++; |
---|
2732 | #endif /* CK_RTSCTS */ |
---|
2733 | |
---|
2734 | #ifdef CK_XYZ |
---|
2735 | #ifdef XYZ_INTERNAL |
---|
2736 | printf(" Built-in XYZMODEM protocols\n"); |
---|
2737 | #else |
---|
2738 | printf(" External XYZMODEM protocol support\n"); |
---|
2739 | #endif /* XYZ_INTERNAL */ |
---|
2740 | lines++; |
---|
2741 | #endif /* CK_XYZ */ |
---|
2742 | |
---|
2743 | #ifndef NOCSETS |
---|
2744 | printf(" Latin-1 (West European) character-set translation\n"); |
---|
2745 | lines++; |
---|
2746 | #ifdef LATIN2 |
---|
2747 | printf(" Latin-2 (East European) character-set translation\n"); |
---|
2748 | lines++; |
---|
2749 | #endif /* LATIN2 */ |
---|
2750 | #ifdef CYRILLIC |
---|
2751 | printf(" Cyrillic (Russian, Ukrainian, etc) character-set translation\n"); |
---|
2752 | lines++; |
---|
2753 | #endif /* CYRILLIC */ |
---|
2754 | #ifdef HEBREW |
---|
2755 | printf(" Hebrew character-set translation\n"); |
---|
2756 | lines++; |
---|
2757 | #endif /* HEBREW */ |
---|
2758 | #ifdef KANJI |
---|
2759 | printf(" Kanji (Japanese) character-set translation\n"); |
---|
2760 | lines++; |
---|
2761 | #endif /* KANJI */ |
---|
2762 | #ifdef CKOUNI |
---|
2763 | if (isunicode()) |
---|
2764 | printf(" Unicode support for ISO-2022 Terminal Emulation\n"); |
---|
2765 | else |
---|
2766 | printf(" Unicode translation for Terminal Character-Sets\n"); |
---|
2767 | #endif /* CKOUNI */ |
---|
2768 | #endif /* NOCSETS */ |
---|
2769 | |
---|
2770 | #ifdef CK_REDIR |
---|
2771 | printf(" REDIRECT command\n"); |
---|
2772 | lines++; |
---|
2773 | #endif /* CK_REDIR */ |
---|
2774 | #ifdef CK_RESEND |
---|
2775 | printf(" RESEND command\n"); |
---|
2776 | lines++; |
---|
2777 | #endif /* CK_RESEND */ |
---|
2778 | |
---|
2779 | #ifdef CK_CURSES |
---|
2780 | printf(" Fullscreen file transfer display\n"); |
---|
2781 | lines++; |
---|
2782 | #endif /* CK_CURSES */ |
---|
2783 | |
---|
2784 | #ifdef CK_SPEED |
---|
2785 | printf(" Control-character unprefixing\n"); |
---|
2786 | lines++; |
---|
2787 | #endif /* CK_SPEED */ |
---|
2788 | |
---|
2789 | #ifdef OS2MOUSE |
---|
2790 | printf(" Mouse support\n"); |
---|
2791 | lines++; |
---|
2792 | #endif /* OS2MOUSE */ |
---|
2793 | |
---|
2794 | #ifdef CK_REXX |
---|
2795 | printf(" REXX script language interface\n"); |
---|
2796 | lines++; |
---|
2797 | #endif /* CK_REXX */ |
---|
2798 | |
---|
2799 | printf("\nMajor optional features not included:\n"); |
---|
2800 | lines++; |
---|
2801 | #ifndef CK_CURSES |
---|
2802 | #ifndef MAC |
---|
2803 | printf(" No fullscreen file transfer display\n"); |
---|
2804 | lines++; |
---|
2805 | flag = 1; |
---|
2806 | #endif /* MAC */ |
---|
2807 | #endif /* CK_CURSES */ |
---|
2808 | #ifdef NOSERVER |
---|
2809 | printf(" No server mode\n"); |
---|
2810 | lines++; |
---|
2811 | flag = 1; |
---|
2812 | #endif /* NOSERVER */ |
---|
2813 | #ifdef NODEBUG |
---|
2814 | printf(" No debugging\n"); |
---|
2815 | lines++; |
---|
2816 | flag = 1; |
---|
2817 | #endif /* NODEBUG */ |
---|
2818 | #ifdef NOTLOG |
---|
2819 | printf(" No transaction log\n"); |
---|
2820 | lines++; |
---|
2821 | flag = 1; |
---|
2822 | #endif /* NOTLOG */ |
---|
2823 | #ifdef NOHELP |
---|
2824 | printf(" No built-in help\n"); |
---|
2825 | lines++; |
---|
2826 | flag = 1; |
---|
2827 | #endif /* NOHELP */ |
---|
2828 | #ifndef NETCONN |
---|
2829 | printf(" No network support\n"); |
---|
2830 | lines++; |
---|
2831 | flag = 1; |
---|
2832 | #endif /* NETCONN */ |
---|
2833 | #ifdef NOMSEND |
---|
2834 | printf(" No MSEND command\n"); |
---|
2835 | lines++; |
---|
2836 | flag = 1; |
---|
2837 | #endif /* NOMSEND */ |
---|
2838 | #ifdef NODIAL |
---|
2839 | printf(" No DIAL command\n"); |
---|
2840 | lines++; |
---|
2841 | flag = 1; |
---|
2842 | #else |
---|
2843 | #ifdef MINIDIAL |
---|
2844 | printf( |
---|
2845 | " No DIAL command for modems other than Hayes, CCITT, and Unknown\n"); |
---|
2846 | lines++; |
---|
2847 | flag = 1; |
---|
2848 | #endif /* MINIDIAL */ |
---|
2849 | #ifndef CK_RTSCTS |
---|
2850 | #ifndef MAC |
---|
2851 | printf(" No hardware flow control\n"); |
---|
2852 | lines++; |
---|
2853 | flag = 1; |
---|
2854 | #endif /* MAC */ |
---|
2855 | #endif /* CK_RTSCTS */ |
---|
2856 | #endif /* NODIAL */ |
---|
2857 | #ifdef NOXMIT |
---|
2858 | printf(" No TRANSMIT command\n"); |
---|
2859 | lines++; |
---|
2860 | flag = 1; |
---|
2861 | #endif /* NOXMIT */ |
---|
2862 | #ifdef NOSCRIPT |
---|
2863 | printf(" No SCRIPT command\n"); |
---|
2864 | lines++; |
---|
2865 | flag = 1; |
---|
2866 | #endif /* NOSCRIPT */ |
---|
2867 | #ifdef NOSPL |
---|
2868 | printf(" No script programming features\n"); |
---|
2869 | lines++; |
---|
2870 | flag = 1; |
---|
2871 | #endif /* NOSPL */ |
---|
2872 | #ifndef CK_XYZ |
---|
2873 | printf(" No built-in XYZMODEM protocols\n"); |
---|
2874 | lines++; |
---|
2875 | flag = 1; |
---|
2876 | #endif /* CK_XYZ */ |
---|
2877 | #ifdef NOCSETS |
---|
2878 | printf(" No character-set translation\n"); |
---|
2879 | lines++; |
---|
2880 | flag = 1; |
---|
2881 | #else |
---|
2882 | #ifndef LATIN2 |
---|
2883 | printf(" No Latin-2 character-set translation\n"); |
---|
2884 | lines++; |
---|
2885 | flag = 1; |
---|
2886 | #endif /* LATIN2 */ |
---|
2887 | #ifdef NOHEBREW |
---|
2888 | printf(" No Hebrew character-set translation\n"); |
---|
2889 | lines++; |
---|
2890 | flag = 1; |
---|
2891 | #endif /* NOHEBREW */ |
---|
2892 | #ifdef NOCYRIL |
---|
2893 | printf(" No Cyrillic character-set translation\n"); |
---|
2894 | lines++; |
---|
2895 | flag = 1; |
---|
2896 | #endif /* NOCYRIL */ |
---|
2897 | #ifndef KANJI |
---|
2898 | printf(" No Kanji character-set translation\n"); |
---|
2899 | lines++; |
---|
2900 | flag = 1; |
---|
2901 | #endif /* KANJI */ |
---|
2902 | #endif /* NOCSETS */ |
---|
2903 | #ifdef NOCMDL |
---|
2904 | printf(" No command-line arguments\n"); |
---|
2905 | lines++; |
---|
2906 | flag = 1; |
---|
2907 | #endif /* NOCMDL */ |
---|
2908 | #ifdef NOFRILLS |
---|
2909 | printf(" No frills\n"); |
---|
2910 | lines++; |
---|
2911 | flag = 1; |
---|
2912 | #endif /* NOFRILLS */ |
---|
2913 | #ifdef NOPUSH |
---|
2914 | printf(" No escape to system\n"); |
---|
2915 | lines++; |
---|
2916 | flag = 1; |
---|
2917 | #endif /* NOPUSH */ |
---|
2918 | #ifdef NOJC |
---|
2919 | #ifdef UNIX |
---|
2920 | printf(" No UNIX job control\n"); |
---|
2921 | lines++; |
---|
2922 | flag = 1; |
---|
2923 | #endif /* UNIX */ |
---|
2924 | #endif /* NOJC */ |
---|
2925 | #ifdef NOSETKEY |
---|
2926 | printf(" No SET KEY command\n"); |
---|
2927 | lines++; |
---|
2928 | flag = 1; |
---|
2929 | #endif /* NOSETKEY */ |
---|
2930 | #ifndef PARSENSE |
---|
2931 | printf(" No automatic parity detection\n"); |
---|
2932 | lines++; |
---|
2933 | flag = 1; |
---|
2934 | #endif /* PARSENSE */ |
---|
2935 | #ifndef CK_SPEED |
---|
2936 | printf(" No control-character unprefixing\n"); |
---|
2937 | lines++; |
---|
2938 | flag = 1; |
---|
2939 | #endif /* CK_SPEED */ |
---|
2940 | #ifndef CK_REDIR |
---|
2941 | printf(" No REDIRECT command\n"); |
---|
2942 | lines++; |
---|
2943 | flag = 1; |
---|
2944 | #endif /* CK_REDIR */ |
---|
2945 | #ifndef CK_RESEND |
---|
2946 | printf(" No RESEND command\n"); |
---|
2947 | lines++; |
---|
2948 | flag = 1; |
---|
2949 | #endif /* CK_RESEND */ |
---|
2950 | #ifdef OS2 |
---|
2951 | #ifdef __32BIT__ |
---|
2952 | #ifndef OS2MOUSE |
---|
2953 | printf(" No Mouse support\n"); |
---|
2954 | lines++; |
---|
2955 | flag = 1; |
---|
2956 | #endif /* __32BIT__ */ |
---|
2957 | #endif /* OS2 */ |
---|
2958 | #endif /* OS2MOUSE */ |
---|
2959 | #ifdef OS2 |
---|
2960 | #ifndef NT |
---|
2961 | #ifndef CK_REXX |
---|
2962 | printf(" No REXX script language interface\n"); |
---|
2963 | lines++; |
---|
2964 | flag = 1; |
---|
2965 | #endif /* CK_REXX */ |
---|
2966 | #endif /* NT */ |
---|
2967 | #endif /* OS2 */ |
---|
2968 | |
---|
2969 | if (flag == 0) { printf(" None\n"); lines++; } |
---|
2970 | /* |
---|
2971 | Print compile-time (-D) options, as well as C preprocessor |
---|
2972 | predefined symbols that might affect us... |
---|
2973 | */ |
---|
2974 | #ifdef __DATE__ /* GNU and other ANSI */ |
---|
2975 | #ifdef __TIME__ |
---|
2976 | printf("\nCompiled %s %s, options:\n", __DATE__, __TIME__); |
---|
2977 | #else |
---|
2978 | printf("\nCompiled %s, options:\n", __DATE__); |
---|
2979 | #endif /* __TIME__ */ |
---|
2980 | #else /* !__DATE__ */ |
---|
2981 | printf("\nCompiler options:\n"); |
---|
2982 | #endif /* __DATE__ */ |
---|
2983 | lines++; |
---|
2984 | |
---|
2985 | #ifdef MAC |
---|
2986 | #ifdef MPW |
---|
2987 | if (!prtopt(&lines,"MPW")) return; |
---|
2988 | #else |
---|
2989 | #ifdef THINK_C |
---|
2990 | if (!prtopt(&lines,"THINK_C")) return; |
---|
2991 | #endif /* THINK_C */ |
---|
2992 | #endif /* MPW */ |
---|
2993 | #endif /* MAC */ |
---|
2994 | |
---|
2995 | #ifdef __386__ |
---|
2996 | if (!prtopt(&lines,"__386__")) return; |
---|
2997 | #endif /* __386__ */ |
---|
2998 | |
---|
2999 | #ifdef DEBUG |
---|
3000 | #ifdef IFDEBUG |
---|
3001 | if (!prtopt(&lines,"IFDEBUG")) return; |
---|
3002 | #else |
---|
3003 | if (!prtopt(&lines,"DEBUG")) return; |
---|
3004 | #endif /* IFDEBUG */ |
---|
3005 | #endif /* DEBUG */ |
---|
3006 | #ifdef TLOG |
---|
3007 | if (!prtopt(&lines,"TLOG")) return; |
---|
3008 | #endif /* TLOG */ |
---|
3009 | #ifdef BIGBUFOK |
---|
3010 | if (!prtopt(&lines,"BIGBUFOK")) return; |
---|
3011 | #endif /* BIGBUFOK */ |
---|
3012 | #ifdef XFRCAN |
---|
3013 | if (!prtopt(&lines,"XFRCAN")) return; |
---|
3014 | #endif /* XFRCAN */ |
---|
3015 | #ifdef CK_SPEED |
---|
3016 | if (!prtopt(&lines,"CK_SPEED")) return; |
---|
3017 | #endif /* CK_SPEED */ |
---|
3018 | #ifdef CK_APC |
---|
3019 | if (!prtopt(&lines,"CK_APC")) return; |
---|
3020 | #endif /* CK_APC */ |
---|
3021 | #ifdef CK_AUTODL |
---|
3022 | if (!prtopt(&lines,"CK_AUTODL")) return; |
---|
3023 | #endif /* CK_AUTODL */ |
---|
3024 | #ifdef CK_MKDIR |
---|
3025 | if (!prtopt(&lines,"CK_MKDIR")) return; |
---|
3026 | #endif /* CK_MKDIR */ |
---|
3027 | #ifdef NOMKDIR |
---|
3028 | if (!prtopt(&lines,"NOMKDIR")) return; |
---|
3029 | #endif /* NOMKDIR */ |
---|
3030 | #ifdef CK_LABELED |
---|
3031 | if (!prtopt(&lines,"CK_LABELED")) return; |
---|
3032 | #endif /* CK_LABELED */ |
---|
3033 | #ifdef NODIAL |
---|
3034 | if (!prtopt(&lines,"NODIAL")) return; |
---|
3035 | #endif /* NODIAL */ |
---|
3036 | #ifdef MINIDIAL |
---|
3037 | if (!prtopt(&lines,"MINIDIAL")) return; |
---|
3038 | #endif /* MINIDIAL */ |
---|
3039 | #ifdef WHATAMI |
---|
3040 | if (!prtopt(&lines,"WHATAMI")) return; |
---|
3041 | #endif /* WHATAMI */ |
---|
3042 | #ifdef DYNAMIC |
---|
3043 | if (!prtopt(&lines,"DYNAMIC")) return; |
---|
3044 | #endif /* IFDEBUG */ |
---|
3045 | #ifndef NOSPL |
---|
3046 | sprintf(line,"CMDDEP=%d",CMDDEP); |
---|
3047 | if (!prtopt(&lines,line)) return; |
---|
3048 | #endif /* NOSPL */ |
---|
3049 | |
---|
3050 | sprintf(line,"CKMAXPATH=%d",CKMAXPATH); |
---|
3051 | if (!prtopt(&lines,line)) return; |
---|
3052 | |
---|
3053 | #ifdef MAXGETPATH |
---|
3054 | sprintf(line,"MAXGETPATH=%d",MAXGETPATH); |
---|
3055 | if (!prtopt(&lines,line)) return; |
---|
3056 | #endif /* MAXGETPATH */ |
---|
3057 | |
---|
3058 | #ifdef CMDBL |
---|
3059 | sprintf(line,"CMDBL=%d",CMDBL); |
---|
3060 | if (!prtopt(&lines,line)) return; |
---|
3061 | #endif /* CMDBL */ |
---|
3062 | |
---|
3063 | #ifdef VNAML |
---|
3064 | sprintf(line,"VNAML=%d",VNAML); |
---|
3065 | if (!prtopt(&lines,line)) return; |
---|
3066 | #endif /* VNAML */ |
---|
3067 | |
---|
3068 | #ifdef ARRAYREFLEN |
---|
3069 | sprintf(line,"ARRAYREFLEN=%d",ARRAYREFLEN); |
---|
3070 | if (!prtopt(&lines,line)) return; |
---|
3071 | #endif /* ARRAYREFLEN */ |
---|
3072 | |
---|
3073 | #ifdef FORDEPTH |
---|
3074 | sprintf(line,"FORDEPTH=%d",FORDEPTH); |
---|
3075 | if (!prtopt(&lines,line)) return; |
---|
3076 | #endif /* FORDEPTH */ |
---|
3077 | |
---|
3078 | #ifdef MAXTAKE |
---|
3079 | sprintf(line,"MAXTAKE=%d",MAXTAKE); |
---|
3080 | if (!prtopt(&lines,line)) return; |
---|
3081 | #endif /* MAXTAKE */ |
---|
3082 | |
---|
3083 | #ifdef MACLEVEL |
---|
3084 | sprintf(line,"MACLEVEL=%d",MACLEVEL); |
---|
3085 | if (!prtopt(&lines,line)) return; |
---|
3086 | #endif /* MACLEVEL */ |
---|
3087 | |
---|
3088 | #ifdef MAC_MAX |
---|
3089 | sprintf(line,"MAC_MAX=%d",MAC_MAX); |
---|
3090 | if (!prtopt(&lines,line)) return; |
---|
3091 | #endif /* MAC_MAX */ |
---|
3092 | |
---|
3093 | #ifdef MINPUTMAX |
---|
3094 | sprintf(line,"MINPUTMAX=%d",MINPUTMAX); |
---|
3095 | if (!prtopt(&lines,line)) return; |
---|
3096 | #endif /* MINPUTMAX */ |
---|
3097 | |
---|
3098 | #ifdef MSENDMAX |
---|
3099 | sprintf(line,"MSENDMAX=%d",MSENDMAX); |
---|
3100 | if (!prtopt(&lines,line)) return; |
---|
3101 | #endif /* MSENDMAX */ |
---|
3102 | |
---|
3103 | #ifdef MAXDDIR |
---|
3104 | sprintf(line,"MAXDDIR=%d",MAXDDIR); |
---|
3105 | if (!prtopt(&lines,line)) return; |
---|
3106 | #endif /* MAXDDIR */ |
---|
3107 | |
---|
3108 | #ifdef MAXDNUMS |
---|
3109 | sprintf(line,"MAXDNUMS=%d",MAXDNUMS); |
---|
3110 | if (!prtopt(&lines,line)) return; |
---|
3111 | #endif /* MAXDNUMS */ |
---|
3112 | |
---|
3113 | #ifdef UNIX |
---|
3114 | if (!prtopt(&lines,"UNIX")) return; |
---|
3115 | #endif /* UNIX */ |
---|
3116 | #ifdef VMS |
---|
3117 | if (!prtopt(&lines,"VMS")) return; |
---|
3118 | #ifdef __VMS_VER |
---|
3119 | sprintf(line,"__VMS_VER=%d",__VMS_VER); |
---|
3120 | if (!prtopt(&lines,line)) return; |
---|
3121 | #endif /* __VMS_VER */ |
---|
3122 | #ifdef VMSV70 |
---|
3123 | if (!prtopt(&lines,"VMSV70")) return; |
---|
3124 | #endif /* VMSV70 */ |
---|
3125 | #endif /* VMS */ |
---|
3126 | #ifdef OLD_VMS |
---|
3127 | if (!prtopt(&lines,"OLD_VMS")) return; |
---|
3128 | #endif /* OLD_VMS */ |
---|
3129 | #ifdef vms |
---|
3130 | if (!prtopt(&lines,"vms")) return; |
---|
3131 | #endif /* vms */ |
---|
3132 | #ifdef VMSSHARE |
---|
3133 | if (!prtopt(&lines,"VMSSHARE")) return; |
---|
3134 | #endif /* VMSSHARE */ |
---|
3135 | #ifdef datageneral |
---|
3136 | if (!prtopt(&lines,"datageneral")) return; |
---|
3137 | #endif /* datageneral */ |
---|
3138 | #ifdef apollo |
---|
3139 | if (!prtopt(&lines,"apollo")) return; |
---|
3140 | #endif /* apollo */ |
---|
3141 | #ifdef aegis |
---|
3142 | if (!prtopt(&lines,"aegis")) return; |
---|
3143 | #endif /* aegis */ |
---|
3144 | #ifdef A986 |
---|
3145 | if (!prtopt(&lines,"A986")) return; |
---|
3146 | #endif /* A986 */ |
---|
3147 | #ifdef AMIGA |
---|
3148 | if (!prtopt(&lines,"AMIGA")) return; |
---|
3149 | #endif /* AMIGA */ |
---|
3150 | #ifdef CONVEX9 |
---|
3151 | if (!prtopt(&lines,"CONVEX9")) return; |
---|
3152 | #endif /* CONVEX9 */ |
---|
3153 | #ifdef CONVEX10 |
---|
3154 | if (!prtopt(&lines,"CONVEX10")) return; |
---|
3155 | #endif /* CONVEX9 */ |
---|
3156 | #ifdef MAC |
---|
3157 | if (!prtopt(&lines,"MAC")) return; |
---|
3158 | #endif /* MAC */ |
---|
3159 | #ifdef AUX |
---|
3160 | if (!prtopt(&lines,"AUX")) return; |
---|
3161 | #endif /* AUX */ |
---|
3162 | #ifdef OS2 |
---|
3163 | if (!prtopt(&lines,"OS2")) return; |
---|
3164 | #ifdef NT |
---|
3165 | if (!prtopt(&lines,"NT")) return; |
---|
3166 | #endif /* NT */ |
---|
3167 | #endif /* OS2 */ |
---|
3168 | #ifdef OSK |
---|
3169 | if (!prtopt(&lines,"OS9")) return; |
---|
3170 | #endif /* OSK */ |
---|
3171 | #ifdef MSDOS |
---|
3172 | if (!prtopt(&lines,"MSDOS")) return; |
---|
3173 | #endif /* MSDOS */ |
---|
3174 | #ifdef DIRENT |
---|
3175 | if (!prtopt(&lines,"DIRENT")) return; |
---|
3176 | #endif /* DIRENT */ |
---|
3177 | #ifdef SDIRENT |
---|
3178 | if (!prtopt(&lines,"SDIRENT")) return; |
---|
3179 | #endif /* SDIRENT */ |
---|
3180 | #ifdef NDIR |
---|
3181 | if (!prtopt(&lines,"NDIR")) return; |
---|
3182 | #endif /* NDIR */ |
---|
3183 | #ifdef XNDIR |
---|
3184 | if (!prtopt(&lines,"XNDIR")) return; |
---|
3185 | #endif /* XNDIR */ |
---|
3186 | #ifdef MATCHDOT |
---|
3187 | if (!prtopt(&lines,"MATCHDOT")) return; |
---|
3188 | #endif /* MATCHDOT */ |
---|
3189 | #ifdef SAVEDUID |
---|
3190 | if (!prtopt(&lines,"SAVEDUID")) return; |
---|
3191 | #endif /* SAVEDUID */ |
---|
3192 | #ifdef RENAME |
---|
3193 | if (!prtopt(&lines,"RENAME")) return; |
---|
3194 | #endif /* RENAME */ |
---|
3195 | #ifdef CK_TMPDIR |
---|
3196 | if (!prtopt(&lines,"CK_TMPDIR")) return; |
---|
3197 | #endif /* CK_TMPDIR */ |
---|
3198 | #ifdef NOCCTRAP |
---|
3199 | if (!prtopt(&lines,"NOCCTRAP")) return; |
---|
3200 | #endif /* NOCCTRAP */ |
---|
3201 | #ifdef CK_NEED_SIG |
---|
3202 | if (!prtopt(&lines,"CK_NEED_SIG")) return; |
---|
3203 | #endif /* CK_NEED_SIG */ |
---|
3204 | #ifdef CK_TTYFD |
---|
3205 | if (!prtopt(&lines,"CK_TTYFD")) return; |
---|
3206 | #endif /* CK_TTYFD */ |
---|
3207 | #ifdef NETCONN |
---|
3208 | if (!prtopt(&lines,"NETCONN")) return; |
---|
3209 | #endif /* NETCONN */ |
---|
3210 | #ifdef TCPSOCKET |
---|
3211 | if (!prtopt(&lines,"TCPSOCKET")) return; |
---|
3212 | #ifdef NOTCPOPTS |
---|
3213 | if (!prtopt(&lines,"NOTCPOPTS")) return; |
---|
3214 | #endif /* NOTCPOPTS */ |
---|
3215 | #ifdef NOLISTEN |
---|
3216 | if (!prtopt(&lines,"NOLISTEN")) return; |
---|
3217 | #endif /* NOLISTEN */ |
---|
3218 | #ifdef SOL_SOCKET |
---|
3219 | if (!prtopt(&lines,"SOL_SOCKET")) return; |
---|
3220 | #endif /* SOL_SOCKET */ |
---|
3221 | #ifdef TCP_NODELAY |
---|
3222 | if (!prtopt(&lines,"TDP_NODELAY")) return; |
---|
3223 | #endif /* TCP_NODELAY */ |
---|
3224 | #ifdef HADDRLIST |
---|
3225 | if (!prtopt(&lines,"HADDRLIST")) return; |
---|
3226 | #endif /* HADDRLIST */ |
---|
3227 | #ifdef CK_SOCKS |
---|
3228 | if (!prtopt(&lines,"CK_SOCKS")) return; |
---|
3229 | #endif /* CK_SOCKS */ |
---|
3230 | #ifdef RLOGCODE |
---|
3231 | if (!prtopt(&lines,"RLOGCODE")) return; |
---|
3232 | #endif /* RLOGCODE */ |
---|
3233 | #ifdef CONGSPD |
---|
3234 | if (!prtopt(&lines,"CONGSPD")) return; |
---|
3235 | #endif /* CONGSPDCK_SOCKS */ |
---|
3236 | #endif /* TCPSOCKET */ |
---|
3237 | #ifdef SUNX25 |
---|
3238 | if (!prtopt(&lines,"SUNX25")) return; |
---|
3239 | #endif /* SUNX25 */ |
---|
3240 | #ifdef DECNET |
---|
3241 | if (!prtopt(&lines,"DECNET")) return; |
---|
3242 | #endif /* DECNET */ |
---|
3243 | #ifdef SUPERLAT |
---|
3244 | if (!prtopt(&lines,"SUPERLAT")) return; |
---|
3245 | #endif /* SUPERLAT */ |
---|
3246 | #ifdef NPIPE |
---|
3247 | if (!prtopt(&lines,"NPIPE")) return; |
---|
3248 | #endif /* NPIPE */ |
---|
3249 | #ifdef CK_NETBIOS |
---|
3250 | if (!prtopt(&lines,"CK_NETBIOS")) return; |
---|
3251 | #endif /* CK_NETBIOS */ |
---|
3252 | #ifdef ATT7300 |
---|
3253 | if (!prtopt(&lines,"ATT7300")) return; |
---|
3254 | #endif /* ATT7300 */ |
---|
3255 | #ifdef ATT6300 |
---|
3256 | if (!prtopt(&lines,"ATT6300")) return; |
---|
3257 | #endif /* ATT6300 */ |
---|
3258 | #ifdef HDBUUCP |
---|
3259 | if (!prtopt(&lines,"HDBUUCP")) return; |
---|
3260 | #endif /* HDBUUCP */ |
---|
3261 | #ifdef NOUUCP |
---|
3262 | if (!prtopt(&lines,"NOUUCP")) return; |
---|
3263 | #endif /* NOUUCP */ |
---|
3264 | #ifdef LONGFN |
---|
3265 | if (!prtopt(&lines,"LONGFN")) return; |
---|
3266 | #endif /* LONGFN */ |
---|
3267 | #ifdef RDCHK |
---|
3268 | if (!prtopt(&lines,"RDCHK")) return; |
---|
3269 | #endif /* RDCHK */ |
---|
3270 | #ifdef SELECT |
---|
3271 | if (!prtopt(&lines,"SELECT")) return; |
---|
3272 | #endif /* SELECT */ |
---|
3273 | #ifdef USLEEP |
---|
3274 | if (!prtopt(&lines,"USLEEP")) return; |
---|
3275 | #endif /* USLEEP */ |
---|
3276 | #ifdef NAP |
---|
3277 | if (!prtopt(&lines,"NAP")) return; |
---|
3278 | #endif /* NAP */ |
---|
3279 | #ifdef NAPHACK |
---|
3280 | if (!prtopt(&lines,"NAPHACK")) return; |
---|
3281 | #endif /* NAPHACK */ |
---|
3282 | #ifdef CK_POLL |
---|
3283 | if (!prtopt(&lines,"CK_POLL")) return; |
---|
3284 | #endif /* CK_POLL */ |
---|
3285 | #ifdef NOIEXTEN |
---|
3286 | if (!prtopt(&lines,"NOIEXTEN")) return; |
---|
3287 | #endif /* NOIEXTEN */ |
---|
3288 | #ifdef EXCELAN |
---|
3289 | if (!prtopt(&lines,"EXCELAN")) return; |
---|
3290 | #endif /* EXCELAN */ |
---|
3291 | #ifdef INTERLAN |
---|
3292 | if (!prtopt(&lines,"INTERLAN")) return; |
---|
3293 | #endif /* INTERLAN */ |
---|
3294 | #ifdef NOFILEH |
---|
3295 | if (!prtopt(&lines,"NOFILEH")) return; |
---|
3296 | #endif /* NOFILEH */ |
---|
3297 | #ifdef NOSYSIOCTLH |
---|
3298 | if (!prtopt(&lines,"NOSYSIOCTLH")) return; |
---|
3299 | #endif /* NOSYSIOCTLH */ |
---|
3300 | #ifdef DCLPOPEN |
---|
3301 | if (!prtopt(&lines,"DCLPOPEN")) return; |
---|
3302 | #endif /* DCLPOPEN */ |
---|
3303 | #ifdef NOSETBUF |
---|
3304 | if (!prtopt(&lines,"NOSETBUF")) return; |
---|
3305 | #endif /* NOSETBUF */ |
---|
3306 | #ifdef NOFDZERO |
---|
3307 | if (!prtopt(&lines,"NOFDZERO")) return; |
---|
3308 | #endif /* NOFDZERO */ |
---|
3309 | #ifdef NOPOPEN |
---|
3310 | if (!prtopt(&lines,"NOPOPEN")) return; |
---|
3311 | #endif /* NOPOPEN */ |
---|
3312 | #ifdef NOPARTIAL |
---|
3313 | if (!prtopt(&lines,"NOPARTIAL")) return; |
---|
3314 | #endif /* NOPARTIAL */ |
---|
3315 | #ifdef NOKVERBS |
---|
3316 | if (!prtopt(&lines,"NOKVERBS")) return; |
---|
3317 | #endif /* NOKVERBS */ |
---|
3318 | #ifdef NOSETREU |
---|
3319 | if (!prtopt(&lines,"NOSETREU")) return; |
---|
3320 | #endif /* NOSETREU */ |
---|
3321 | #ifdef _POSIX_SOURCE |
---|
3322 | if (!prtopt(&lines,"_POSIX_SOURCE")) return; |
---|
3323 | #endif /* _POSIX_SOURCE */ |
---|
3324 | #ifdef LCKDIR |
---|
3325 | if (!prtopt(&lines,"LCKDIR")) return; |
---|
3326 | #endif /* LCKDIR */ |
---|
3327 | #ifdef ACUCNTRL |
---|
3328 | if (!prtopt(&lines,"ACUCNTRL")) return; |
---|
3329 | #endif /* ACUCNTRL */ |
---|
3330 | #ifdef BSD4 |
---|
3331 | if (!prtopt(&lines,"BSD4")) return; |
---|
3332 | #endif /* BSD4 */ |
---|
3333 | #ifdef BSD44 |
---|
3334 | if (!prtopt(&lines,"BSD44")) return; |
---|
3335 | #endif /* BSD44 */ |
---|
3336 | #ifdef BSD41 |
---|
3337 | if (!prtopt(&lines,"BSD41")) return; |
---|
3338 | #endif /* BSD41 */ |
---|
3339 | #ifdef BSD43 |
---|
3340 | if (!prtopt(&lines,"BSD43")) return; |
---|
3341 | #endif /* BSD43 */ |
---|
3342 | #ifdef BSD29 |
---|
3343 | if (!prtopt(&lines,"BSD29")) return; |
---|
3344 | #endif /* BSD29 */ |
---|
3345 | #ifdef BSDI |
---|
3346 | if (!prtopt(&lines,"BSDI")) return; |
---|
3347 | #endif /* BSDI */ |
---|
3348 | #ifdef __bsdi__ |
---|
3349 | if (!prtopt(&lines,"__bsdi__")) return; |
---|
3350 | #endif /* __bsdi__ */ |
---|
3351 | #ifdef __NetBSD__ |
---|
3352 | if (!prtopt(&lines,"__NetBSD__")) return; |
---|
3353 | #endif /* __NetBSD__ */ |
---|
3354 | #ifdef __FreeBSD__ |
---|
3355 | if (!prtopt(&lines,"__FreeBSD__")) return; |
---|
3356 | #endif /* __FreeBSD__ */ |
---|
3357 | #ifdef __linux__ |
---|
3358 | if (!prtopt(&lines,"__linux__")) return; |
---|
3359 | #endif /* __linux__ */ |
---|
3360 | #ifdef LINUX_HI_SPD |
---|
3361 | if (!prtopt(&lines,"LINUX_HI_SPD")) return; |
---|
3362 | #endif /* LINUX_HI_SPD */ |
---|
3363 | #ifdef LYNXOS |
---|
3364 | if (!prtopt(&lines,"LYNXOS")) return; |
---|
3365 | #endif /* LYNXOS */ |
---|
3366 | #ifdef V7 |
---|
3367 | if (!prtopt(&lines,"V7")) return; |
---|
3368 | #endif /* V7 */ |
---|
3369 | #ifdef AIX370 |
---|
3370 | if (!prtopt(&lines,"AIX370")) return; |
---|
3371 | #endif /* AIX370 */ |
---|
3372 | #ifdef RTAIX |
---|
3373 | if (!prtopt(&lines,"RTAIX")) return; |
---|
3374 | #endif /* RTAIX */ |
---|
3375 | #ifdef HPUX |
---|
3376 | if (!prtopt(&lines,"HPUX")) return; |
---|
3377 | #endif /* HPUX */ |
---|
3378 | #ifdef HPUXPRE65 |
---|
3379 | if (!prtopt(&lines,"HPUXPRE65")) return; |
---|
3380 | #endif /* HPUXPRE65 */ |
---|
3381 | #ifdef DGUX |
---|
3382 | if (!prtopt(&lines,"DGUX")) return; |
---|
3383 | #endif /* DGUX */ |
---|
3384 | #ifdef DGUX430 |
---|
3385 | if (!prtopt(&lines,"DGUX430")) return; |
---|
3386 | #endif /* DGUX430 */ |
---|
3387 | #ifdef DGUX540 |
---|
3388 | if (!prtopt(&lines,"DGUX540")) return; |
---|
3389 | #endif /* DGUX540 */ |
---|
3390 | #ifdef sony_news |
---|
3391 | if (!prtopt(&lines,"sony_news")) return; |
---|
3392 | #endif /* sony_news */ |
---|
3393 | #ifdef CIE |
---|
3394 | if (!prtopt(&lines,"CIE")) return; |
---|
3395 | #endif /* CIE */ |
---|
3396 | #ifdef XENIX |
---|
3397 | if (!prtopt(&lines,"XENIX")) return; |
---|
3398 | #endif /* XENIX */ |
---|
3399 | #ifdef SCO_XENIX |
---|
3400 | if (!prtopt(&lines,"SCO_XENIX")) return; |
---|
3401 | #endif /* SCO_XENIX */ |
---|
3402 | #ifdef ISIII |
---|
3403 | if (!prtopt(&lines,"ISIII")) return; |
---|
3404 | #endif /* ISIII */ |
---|
3405 | #ifdef I386IX |
---|
3406 | if (!prtopt(&lines,"I386IX")) return; |
---|
3407 | #endif /* I386IX */ |
---|
3408 | #ifdef RTU |
---|
3409 | if (!prtopt(&lines,"RTU")) return; |
---|
3410 | #endif /* RTU */ |
---|
3411 | #ifdef PROVX1 |
---|
3412 | if (!prtopt(&lines,"PROVX1")) return; |
---|
3413 | #endif /* PROVX1 */ |
---|
3414 | #ifdef PYRAMID |
---|
3415 | if (!prtopt(&lines,"PYRAMID")) return; |
---|
3416 | #endif /* PYRAMID */ |
---|
3417 | #ifdef TOWER1 |
---|
3418 | if (!prtopt(&lines,"TOWER1")) return; |
---|
3419 | #endif /* TOWER1 */ |
---|
3420 | #ifdef UTEK |
---|
3421 | if (!prtopt(&lines,"UTEK")) return; |
---|
3422 | #endif /* UTEK */ |
---|
3423 | #ifdef ZILOG |
---|
3424 | if (!prtopt(&lines,"ZILOG")) return; |
---|
3425 | #endif /* ZILOG */ |
---|
3426 | #ifdef TRS16 |
---|
3427 | if (!prtopt(&lines,"TRS16")) return; |
---|
3428 | #endif /* TRS16 */ |
---|
3429 | #ifdef MINIX |
---|
3430 | if (!prtopt(&lines,"MINIX")) return; |
---|
3431 | #endif /* MINIX */ |
---|
3432 | #ifdef C70 |
---|
3433 | if (!prtopt(&lines,"C70")) return; |
---|
3434 | #endif /* C70 */ |
---|
3435 | #ifdef AIXPS2 |
---|
3436 | if (!prtopt(&lines,"AIXPS2")) return; |
---|
3437 | #endif /* AIXPS2 */ |
---|
3438 | #ifdef AIXRS |
---|
3439 | if (!prtopt(&lines,"AIXRS")) return; |
---|
3440 | #endif /* AIXRS */ |
---|
3441 | #ifdef UTSV |
---|
3442 | if (!prtopt(&lines,"UTSV")) return; |
---|
3443 | #endif /* UTSV */ |
---|
3444 | #ifdef ATTSV |
---|
3445 | if (!prtopt(&lines,"ATTSV")) return; |
---|
3446 | #endif /* ATTSV */ |
---|
3447 | #ifdef SVR3 |
---|
3448 | if (!prtopt(&lines,"SVR3")) return; |
---|
3449 | #endif /* SVR3 */ |
---|
3450 | #ifdef SVR4 |
---|
3451 | if (!prtopt(&lines,"SVR4")) return; |
---|
3452 | #endif /* SVR4 */ |
---|
3453 | #ifdef DELL_SVR4 |
---|
3454 | if (!prtopt(&lines,"DELL_SVR4")) return; |
---|
3455 | #endif /* DELL_SVR4 */ |
---|
3456 | #ifdef ICL_SVR4 |
---|
3457 | if (!prtopt(&lines,"ICL_SVR4")) return; |
---|
3458 | #endif /* ICL_SVR4 */ |
---|
3459 | #ifdef OSF |
---|
3460 | if (!prtopt(&lines,"OSF")) return; |
---|
3461 | #endif /* OSF */ |
---|
3462 | #ifdef OSF1 |
---|
3463 | if (!prtopt(&lines,"OSF1")) return; |
---|
3464 | #endif /* OSF1 */ |
---|
3465 | #ifdef __OSF |
---|
3466 | if (!prtopt(&lines,"__OSF")) return; |
---|
3467 | #endif /* __OSF */ |
---|
3468 | #ifdef __OSF__ |
---|
3469 | if (!prtopt(&lines,"__OSF__")) return; |
---|
3470 | #endif /* __OSF__ */ |
---|
3471 | #ifdef __osf__ |
---|
3472 | if (!prtopt(&lines,"__osf__")) return; |
---|
3473 | #endif /* __osf__ */ |
---|
3474 | #ifdef __OSF1 |
---|
3475 | if (!prtopt(&lines,"__OSF1")) return; |
---|
3476 | #endif /* __OSF1 */ |
---|
3477 | #ifdef __OSF1__ |
---|
3478 | if (!prtopt(&lines,"__OSF1__")) return; |
---|
3479 | #endif /* __OSF1__ */ |
---|
3480 | #ifdef PTX |
---|
3481 | if (!prtopt(&lines,"PTX")) return; |
---|
3482 | #endif /* PTX */ |
---|
3483 | #ifdef POSIX |
---|
3484 | if (!prtopt(&lines,"POSIX")) return; |
---|
3485 | #endif /* POSIX */ |
---|
3486 | #ifdef Plan9 |
---|
3487 | if (!prtopt(&lines,"Plan9")) return; |
---|
3488 | #endif /* Plan9 */ |
---|
3489 | #ifdef SOLARIS |
---|
3490 | if (!prtopt(&lines,"SOLARIS")) return; |
---|
3491 | #endif /* SOLARIS */ |
---|
3492 | #ifdef SUNOS4 |
---|
3493 | if (!prtopt(&lines,"SUNOS4")) return; |
---|
3494 | #endif /* SUNOS4 */ |
---|
3495 | #ifdef SUN4S5 |
---|
3496 | if (!prtopt(&lines,"SUN4S5")) return; |
---|
3497 | #endif /* SUN4S5 */ |
---|
3498 | #ifdef ENCORE |
---|
3499 | if (!prtopt(&lines,"ENCORE")) return; |
---|
3500 | #endif /* ENCORE */ |
---|
3501 | #ifdef ultrix |
---|
3502 | if (!prtopt(&lines,"ultrix")) return; |
---|
3503 | #endif |
---|
3504 | #ifdef sxaE50 |
---|
3505 | if (!prtopt(&lines,"sxaE50")) return; |
---|
3506 | #endif |
---|
3507 | #ifdef mips |
---|
3508 | if (!prtopt(&lines,"mips")) return; |
---|
3509 | #endif |
---|
3510 | #ifdef MIPS |
---|
3511 | if (!prtopt(&lines,"MIPS")) return; |
---|
3512 | #endif |
---|
3513 | #ifdef vax |
---|
3514 | if (!prtopt(&lines,"vax")) return; |
---|
3515 | #endif |
---|
3516 | #ifdef VAX |
---|
3517 | if (!prtopt(&lines,"VAX")) return; |
---|
3518 | #endif |
---|
3519 | #ifdef alpha |
---|
3520 | if (!prtopt(&lines,"alpha")) return; |
---|
3521 | #endif |
---|
3522 | #ifdef ALPHA |
---|
3523 | if (!prtopt(&lines,"ALPHA")) return; |
---|
3524 | #endif |
---|
3525 | #ifdef __ALPHA |
---|
3526 | if (!prtopt(&lines,"__ALPHA")) return; |
---|
3527 | #endif |
---|
3528 | #ifdef __alpha |
---|
3529 | if (!prtopt(&lines,"__alpha")) return; |
---|
3530 | #endif |
---|
3531 | #ifdef __AXP |
---|
3532 | if (!prtopt(&lines,"__AXP")) return; |
---|
3533 | #endif |
---|
3534 | #ifdef AXP |
---|
3535 | if (!prtopt(&lines,"AXP")) return; |
---|
3536 | #endif |
---|
3537 | #ifdef axp |
---|
3538 | if (!prtopt(&lines,"axp")) return; |
---|
3539 | #endif |
---|
3540 | #ifdef __ALPHA__ |
---|
3541 | if (!prtopt(&lines,"__ALPHA__")) return; |
---|
3542 | #endif |
---|
3543 | #ifdef __alpha__ |
---|
3544 | if (!prtopt(&lines,"__alpha__")) return; |
---|
3545 | #endif |
---|
3546 | #ifdef sun |
---|
3547 | if (!prtopt(&lines,"sun")) return; |
---|
3548 | #endif |
---|
3549 | #ifdef sun3 |
---|
3550 | if (!prtopt(&lines,"sun3")) return; |
---|
3551 | #endif |
---|
3552 | #ifdef sun386 |
---|
3553 | if (!prtopt(&lines,"sun386")) return; |
---|
3554 | #endif |
---|
3555 | #ifdef _SUN |
---|
3556 | if (!prtopt(&lines,"_SUN")) return; |
---|
3557 | #endif |
---|
3558 | #ifdef sun4 |
---|
3559 | if (!prtopt(&lines,"sun4")) return; |
---|
3560 | #endif |
---|
3561 | #ifdef sparc |
---|
3562 | if (!prtopt(&lines,"sparc")) return; |
---|
3563 | #endif |
---|
3564 | #ifdef _CRAY |
---|
3565 | if (!prtopt(&lines,"_CRAY")) return; |
---|
3566 | #endif /* _CRAY */ |
---|
3567 | #ifdef NEXT33 |
---|
3568 | if (!prtopt(&lines,"NEXT33")) return; |
---|
3569 | #endif |
---|
3570 | #ifdef NEXT |
---|
3571 | if (!prtopt(&lines,"NEXT")) return; |
---|
3572 | #endif |
---|
3573 | #ifdef NeXT |
---|
3574 | if (!prtopt(&lines,"NeXT")) return; |
---|
3575 | #endif |
---|
3576 | #ifdef MACH |
---|
3577 | if (!prtopt(&lines,"MACH")) return; |
---|
3578 | #endif |
---|
3579 | #ifdef sgi |
---|
3580 | if (!prtopt(&lines,"sgi")) return; |
---|
3581 | #endif |
---|
3582 | #ifdef M_SYS5 |
---|
3583 | if (!prtopt(&lines,"M_SYS5")) return; |
---|
3584 | #endif |
---|
3585 | #ifdef __SYSTEM_FIVE |
---|
3586 | if (!prtopt(&lines,"__SYSTEM_FIVE")) return; |
---|
3587 | #endif |
---|
3588 | #ifdef sysV |
---|
3589 | if (!prtopt(&lines,"sysV")) return; |
---|
3590 | #endif |
---|
3591 | #ifdef M_XENIX /* SCO Xenix V and UNIX/386 */ |
---|
3592 | if (!prtopt(&lines,"M_XENIX")) return; |
---|
3593 | #endif |
---|
3594 | #ifdef M_UNIX /* SCO UNIX */ |
---|
3595 | if (!prtopt(&lines,"M_UNIX")) return; |
---|
3596 | #endif |
---|
3597 | #ifdef _M_UNIX /* SCO UNIX 3.2v4 = ODT 2.0 */ |
---|
3598 | if (!prtopt(&lines,"_M_UNIX")) return; |
---|
3599 | #endif |
---|
3600 | #ifdef M_I586 |
---|
3601 | if (!prtopt(&lines,"M_I586")) return; |
---|
3602 | #endif |
---|
3603 | #ifdef _M_I586 |
---|
3604 | if (!prtopt(&lines,"_M_I586")) return; |
---|
3605 | #endif |
---|
3606 | #ifdef i586 |
---|
3607 | if (!prtopt(&lines,"i586")) return; |
---|
3608 | #endif |
---|
3609 | #ifdef M_I486 |
---|
3610 | if (!prtopt(&lines,"M_I486")) return; |
---|
3611 | #endif |
---|
3612 | #ifdef _M_I486 |
---|
3613 | if (!prtopt(&lines,"_M_I486")) return; |
---|
3614 | #endif |
---|
3615 | #ifdef i486 |
---|
3616 | if (!prtopt(&lines,"i486")) return; |
---|
3617 | #endif |
---|
3618 | #ifdef M_I386 |
---|
3619 | if (!prtopt(&lines,"M_I386")) return; |
---|
3620 | #endif |
---|
3621 | #ifdef _M_I386 |
---|
3622 | if (!prtopt(&lines,"_M_I386")) return; |
---|
3623 | #endif |
---|
3624 | #ifdef i386 |
---|
3625 | if (!prtopt(&lines,"i386")) return; |
---|
3626 | #endif |
---|
3627 | #ifdef i286 |
---|
3628 | if (!prtopt(&lines,"i286")) return; |
---|
3629 | #endif |
---|
3630 | #ifdef M_I286 |
---|
3631 | if (!prtopt(&lines,"M_I286")) return; |
---|
3632 | #endif |
---|
3633 | #ifdef mc68000 |
---|
3634 | if (!prtopt(&lines,"mc68000")) return; |
---|
3635 | #endif |
---|
3636 | #ifdef mc68010 |
---|
3637 | if (!prtopt(&lines,"mc68010")) return; |
---|
3638 | #endif |
---|
3639 | #ifdef mc68020 |
---|
3640 | if (!prtopt(&lines,"mc68020")) return; |
---|
3641 | #endif |
---|
3642 | #ifdef mc68030 |
---|
3643 | if (!prtopt(&lines,"mc68030")) return; |
---|
3644 | #endif |
---|
3645 | #ifdef mc68040 |
---|
3646 | if (!prtopt(&lines,"mc68040")) return; |
---|
3647 | #endif |
---|
3648 | #ifdef M_68000 |
---|
3649 | if (!prtopt(&lines,"M_68000")) return; |
---|
3650 | #endif |
---|
3651 | #ifdef M_68010 |
---|
3652 | if (!prtopt(&lines,"M_68010")) return; |
---|
3653 | #endif |
---|
3654 | #ifdef M_68020 |
---|
3655 | if (!prtopt(&lines,"M_68020")) return; |
---|
3656 | #endif |
---|
3657 | #ifdef M_68030 |
---|
3658 | if (!prtopt(&lines,"M_68030")) return; |
---|
3659 | #endif |
---|
3660 | #ifdef M_68040 |
---|
3661 | if (!prtopt(&lines,"M_68040")) return; |
---|
3662 | #endif |
---|
3663 | #ifdef m68k |
---|
3664 | if (!prtopt(&lines,"m68k")) return; |
---|
3665 | #endif |
---|
3666 | #ifdef m88k |
---|
3667 | if (!prtopt(&lines,"m88k")) return; |
---|
3668 | #endif |
---|
3669 | #ifdef pdp11 |
---|
3670 | if (!prtopt(&lines,"pdp11")) return; |
---|
3671 | #endif |
---|
3672 | #ifdef iAPX |
---|
3673 | if (!prtopt(&lines,"iAPX")) return; |
---|
3674 | #endif |
---|
3675 | #ifdef __hp9000s800 |
---|
3676 | if (!prtopt(&lines,"__hp9000s800")) return; |
---|
3677 | #endif |
---|
3678 | #ifdef __hp9000s700 |
---|
3679 | if (!prtopt(&lines,"__hp9000s700")) return; |
---|
3680 | #endif |
---|
3681 | #ifdef __hp9000s500 |
---|
3682 | if (!prtopt(&lines,"__hp9000s500")) return; |
---|
3683 | #endif |
---|
3684 | #ifdef __hp9000s300 |
---|
3685 | if (!prtopt(&lines,"__hp9000s300")) return; |
---|
3686 | #endif |
---|
3687 | #ifdef __hp9000s200 |
---|
3688 | if (!prtopt(&lines,"__hp9000s200")) return; |
---|
3689 | #endif |
---|
3690 | #ifdef AIX |
---|
3691 | if (!prtopt(&lines,"AIX")) return; |
---|
3692 | #endif |
---|
3693 | #ifdef _AIXFS |
---|
3694 | if (!prtopt(&lines,"_AIXFS")) return; |
---|
3695 | #endif |
---|
3696 | #ifdef u370 |
---|
3697 | if (!prtopt(&lines,"u370")) return; |
---|
3698 | #endif |
---|
3699 | #ifdef u3b |
---|
3700 | if (!prtopt(&lines,"u3b")) return; |
---|
3701 | #endif |
---|
3702 | #ifdef u3b2 |
---|
3703 | if (!prtopt(&lines,"u3b2")) return; |
---|
3704 | #endif |
---|
3705 | #ifdef multimax |
---|
3706 | if (!prtopt(&lines,"multimax")) return; |
---|
3707 | #endif |
---|
3708 | #ifdef balance |
---|
3709 | if (!prtopt(&lines,"balance")) return; |
---|
3710 | #endif |
---|
3711 | #ifdef ibmrt |
---|
3712 | if (!prtopt(&lines,"ibmrt")) return; |
---|
3713 | #endif |
---|
3714 | #ifdef _IBMRT |
---|
3715 | if (!prtopt(&lines,"_IBMRT")) return; |
---|
3716 | #endif |
---|
3717 | #ifdef ibmrs6000 |
---|
3718 | if (!prtopt(&lines,"ibmrs6000")) return; |
---|
3719 | #endif |
---|
3720 | #ifdef _AIX |
---|
3721 | if (!prtopt(&lines,"_AIX")) return; |
---|
3722 | #endif /* _AIX */ |
---|
3723 | #ifdef _IBMR2 |
---|
3724 | if (!prtopt(&lines,"_IBMR2")) return; |
---|
3725 | #endif |
---|
3726 | #ifdef UNIXWARE |
---|
3727 | if (!prtopt(&lines,"UNIXWARE")) return; |
---|
3728 | #endif |
---|
3729 | #ifdef QNX |
---|
3730 | if (!prtopt(&lines,"QNX")) return; |
---|
3731 | #ifdef __QNX__ |
---|
3732 | if (!prtopt(&lines,"__QNX__")) return; |
---|
3733 | #ifdef __16BIT__ |
---|
3734 | if (!prtopt(&lines,"__16BIT__")) return; |
---|
3735 | #endif |
---|
3736 | #ifdef CK_QNX16 |
---|
3737 | if (!prtopt(&lines,"CK_QNX16")) return; |
---|
3738 | #endif |
---|
3739 | #ifdef __32BIT__ |
---|
3740 | if (!prtopt(&lines,"__32BIT__")) return; |
---|
3741 | #endif |
---|
3742 | #ifdef CK_QNX32 |
---|
3743 | if (!prtopt(&lines,"CK_QNX32")) return; |
---|
3744 | #endif |
---|
3745 | #endif /* __QNX__ */ |
---|
3746 | #endif /* QNX */ |
---|
3747 | |
---|
3748 | #ifdef __STRICT_BSD__ |
---|
3749 | if (!prtopt(&lines,"__STRICT_BSD__")) return; |
---|
3750 | #endif |
---|
3751 | #ifdef __STRICT_ANSI__ |
---|
3752 | if (!prtopt(&lines,"__STRICT_ANSI__")) return; |
---|
3753 | #endif |
---|
3754 | #ifdef _ANSI_C_SOURCE |
---|
3755 | if (!prtopt(&lines,"_ANSI_C_SOURCE")) return; |
---|
3756 | #endif |
---|
3757 | #ifdef __STDC__ |
---|
3758 | if (!prtopt(&lines,"__STDC__")) return; |
---|
3759 | #endif |
---|
3760 | #ifdef __DECC |
---|
3761 | if (!prtopt(&lines,"__DECC")) return; |
---|
3762 | #ifdef __DECC_VER |
---|
3763 | sprintf(line,"__DECC_VER=%d",__DECC_VER); |
---|
3764 | if (!prtopt(&lines,line)) return; |
---|
3765 | #endif /* __DECC_VER */ |
---|
3766 | #endif /* __DECC */ |
---|
3767 | #ifdef __GNUC__ /* gcc in ansi mode */ |
---|
3768 | if (!prtopt(&lines,"__GNUC__")) return; |
---|
3769 | #endif |
---|
3770 | #ifdef GNUC /* gcc in traditional mode */ |
---|
3771 | if (!prtopt(&lines,"GNUC")) return; |
---|
3772 | #endif |
---|
3773 | #ifdef __WATCOMC__ |
---|
3774 | if (!prtopt(&lines,"__WATCOMC__")) return; |
---|
3775 | #endif |
---|
3776 | #ifdef CK_ANSIC |
---|
3777 | if (!prtopt(&lines,"CK_ANSIC")) return; |
---|
3778 | #endif |
---|
3779 | #ifdef CK_ANSILIBS |
---|
3780 | if (!prtopt(&lines,"CK_ANSILIBS")) return; |
---|
3781 | #endif |
---|
3782 | #ifdef _XOPEN_SOURCE |
---|
3783 | if (!prtopt(&lines,"_XOPEN_SOURCE")) return; |
---|
3784 | #endif |
---|
3785 | #ifdef _ALL_SOURCE |
---|
3786 | if (!prtopt(&lines,"_ALL_SOURCE")) return; |
---|
3787 | #endif |
---|
3788 | #ifdef _SC_JOB_CONTROL |
---|
3789 | if (!prtopt(&lines,"_SC_JOB_CONTROL")) return; |
---|
3790 | #endif |
---|
3791 | #ifdef _POSIX_JOB_CONTROL |
---|
3792 | if (!prtopt(&lines,"_POSIX_JOB_CONTROL")) return; |
---|
3793 | #endif |
---|
3794 | #ifdef CK_POSIX_SIG |
---|
3795 | if (!prtopt(&lines,"CK_POSIX_SIG")) return; |
---|
3796 | #endif |
---|
3797 | #ifdef SVR3JC |
---|
3798 | if (!prtopt(&lines,"SVR3JC")) return; |
---|
3799 | #endif |
---|
3800 | #ifdef _386BSD |
---|
3801 | if (!prtopt(&lines,"_386BSD")) return; |
---|
3802 | #endif |
---|
3803 | #ifdef _BSD |
---|
3804 | if (!prtopt(&lines,"_BSD")) return; |
---|
3805 | #endif |
---|
3806 | #ifdef TERMIOX |
---|
3807 | if (!prtopt(&lines,"TERMIOX")) return; |
---|
3808 | #endif /* TERMIOX */ |
---|
3809 | #ifdef STERMIOX |
---|
3810 | if (!prtopt(&lines,"STERMIOX")) return; |
---|
3811 | #endif /* STERMIOX */ |
---|
3812 | #ifdef CK_CURSES |
---|
3813 | if (!prtopt(&lines,"CK_CURSES")) return; |
---|
3814 | #endif /* CK_CURSES */ |
---|
3815 | #ifdef CK_NEWTERM |
---|
3816 | if (!prtopt(&lines,"CK_NEWTERM")) return; |
---|
3817 | #endif /* CK_NEWTERM */ |
---|
3818 | #ifdef CK_WREFRESH |
---|
3819 | if (!prtopt(&lines,"CK_WREFRESH")) return; |
---|
3820 | #endif /* CK_WREFRESH */ |
---|
3821 | #ifdef CK_PCT_BAR |
---|
3822 | if (!prtopt(&lines,"CK_PCT_BAR")) return; |
---|
3823 | #endif /* CK_PCT_BAR */ |
---|
3824 | #ifdef CK_DTRCD |
---|
3825 | if (!prtopt(&lines,"CK_DTRCD")) return; |
---|
3826 | #endif /* CK_DTRCD */ |
---|
3827 | #ifdef CK_DTRCTS |
---|
3828 | if (!prtopt(&lines,"CK_DTRCTS")) return; |
---|
3829 | #endif /* CK_DTRCTS */ |
---|
3830 | #ifdef CK_RTSCTS |
---|
3831 | if (!prtopt(&lines,"CK_RTSCTS")) return; |
---|
3832 | #endif /* CK_RTSCTS */ |
---|
3833 | #ifdef POSIX_CRTSCTS |
---|
3834 | if (!prtopt(&lines,"POSIX_CRTSCTS")) return; |
---|
3835 | #endif /* POSIX_CRTSCTS */ |
---|
3836 | #ifdef CK_DSYSINI |
---|
3837 | if (!prtopt(&lines,"CK_DSYSINI")) return; |
---|
3838 | #endif /* CK_DSYSINI */ |
---|
3839 | #ifdef CK_SYSINI |
---|
3840 | if (!prtopt(&lines,"CK_SYSINI")) return; |
---|
3841 | #endif /* CK_SYSINI */ |
---|
3842 | #ifdef CK_INI_A |
---|
3843 | if (!prtopt(&lines,"CK_INI_A")) return; |
---|
3844 | #endif /* CK_INI_A */ |
---|
3845 | #ifdef CK_INI_B |
---|
3846 | if (!prtopt(&lines,"CK_INI_B")) return; |
---|
3847 | #endif /* CK_INI_B */ |
---|
3848 | #ifdef CK_TTGWSIZ |
---|
3849 | if (!prtopt(&lines,"CK_TTGWSIZ")) return; |
---|
3850 | #endif /* CK_TTGWSIZ */ |
---|
3851 | #ifdef CK_NAWS |
---|
3852 | if (!prtopt(&lines,"CK_NAWS")) return; |
---|
3853 | #endif /* CK_NAWS */ |
---|
3854 | #ifdef DCMDBUF |
---|
3855 | if (!prtopt(&lines,"DCMDBUF")) return; |
---|
3856 | #endif /* DCMDBUF */ |
---|
3857 | #ifdef CK_RECALL |
---|
3858 | if (!prtopt(&lines,"CK_RECALL")) return; |
---|
3859 | #endif /* CK_RECALL */ |
---|
3860 | #ifdef CLSOPN |
---|
3861 | if (!prtopt(&lines,"CLSOPN")) return; |
---|
3862 | #endif /* CLSOPN */ |
---|
3863 | #ifdef STRATUS |
---|
3864 | if (!prtopt(&lines,"STRATUS")) return; |
---|
3865 | #endif /* STRATUS */ |
---|
3866 | #ifdef __VOS__ |
---|
3867 | if (!prtopt(&lines,"__VOS__")) return; |
---|
3868 | #endif /* __VOS__ */ |
---|
3869 | #ifdef STRATUSX25 |
---|
3870 | if (!prtopt(&lines,"STRATUSX25")) return; |
---|
3871 | #endif /* STRATUSX25 */ |
---|
3872 | #ifdef OS2MOUSE |
---|
3873 | if (!prtopt(&lines,"OS2MOUSE") ) return; |
---|
3874 | #endif /* OS2MOUSE */ |
---|
3875 | #ifdef CK_REXX |
---|
3876 | if (!prtopt(&lines,"CK_REXX") ) return; |
---|
3877 | #endif /* CK_REXX */ |
---|
3878 | #ifdef CK_TIMERS |
---|
3879 | if (!prtopt(&lines,"CK_TIMERS") ) return; |
---|
3880 | #endif /* CK_TIMERS */ |
---|
3881 | if (!prtopt(&lines,(char *)0)) return; |
---|
3882 | printf("\n\n"); |
---|
3883 | } |
---|
3884 | #endif /* NOFRILLS */ |
---|
3885 | |
---|
3886 | #ifdef CK_LABELED |
---|
3887 | VOID |
---|
3888 | sholbl() { |
---|
3889 | #ifdef VMS |
---|
3890 | printf("VMS Labeled File Features:\n"); |
---|
3891 | printf(" acl %s (ACL info %s)\n", |
---|
3892 | showoff(lf_opts & LBL_ACL), |
---|
3893 | lf_opts & LBL_ACL ? "preserved" : "discarded"); |
---|
3894 | printf(" backup-date %s (backup date/time %s)\n", |
---|
3895 | showoff(lf_opts & LBL_BCK), |
---|
3896 | lf_opts & LBL_BCK ? "preserved" : "discarded"); |
---|
3897 | printf(" name %s (original filename %s)\n", |
---|
3898 | showoff(lf_opts & LBL_NAM), |
---|
3899 | lf_opts & LBL_NAM ? "preserved" : "discarded"); |
---|
3900 | printf(" owner %s (original file owner id %s)\n", |
---|
3901 | showoff(lf_opts & LBL_OWN), |
---|
3902 | lf_opts & LBL_OWN ? "preserved" : "discarded"); |
---|
3903 | printf(" path %s (original file's disk:[directory] %s)\n", |
---|
3904 | showoff(lf_opts & LBL_PTH), |
---|
3905 | lf_opts & LBL_PTH ? "preserved" : "discarded"); |
---|
3906 | #else |
---|
3907 | #ifdef OS2 |
---|
3908 | printf("OS/2 Labeled File features (attributes):\n"); |
---|
3909 | printf(" archive: %s\n", showoff(lf_opts & LBL_ARC)); |
---|
3910 | printf(" extended: %s\n", showoff(lf_opts & LBL_EXT)); |
---|
3911 | printf(" hidden: %s\n", showoff(lf_opts & LBL_HID)); |
---|
3912 | printf(" read-only: %s\n", showoff(lf_opts & LBL_RO )); |
---|
3913 | printf(" system: %s\n", showoff(lf_opts & LBL_SYS)); |
---|
3914 | #endif /* OS2 */ |
---|
3915 | #endif /* VMS */ |
---|
3916 | } |
---|
3917 | #endif /* CK_LABELED */ |
---|
3918 | |
---|
3919 | VOID |
---|
3920 | shotcs(csl,csr) int csl, csr; { /* Show terminal character set */ |
---|
3921 | #ifndef NOCSETS |
---|
3922 | #ifdef OS2 |
---|
3923 | extern struct _vtG G[4], *GL, *GR; |
---|
3924 | |
---|
3925 | printf(" Terminal character-sets:\n"); |
---|
3926 | #ifndef CKOUNI |
---|
3927 | printf(" Local: %s\n", |
---|
3928 | csl == FC_TRANSP ? "transparent" : fcsinfo[csl].keyword ); |
---|
3929 | printf(" Remote: %sG0: %s (%s)\n", |
---|
3930 | GL == &G[0] ? "GL->" : GR == &G[0] ? "GR->" : " ", |
---|
3931 | G[0].designation == FC_TRANSP ? "transparent" : |
---|
3932 | G[0].designation == FC_DECSPEC ? "dec-special" : |
---|
3933 | G[0].designation == FC_DECTECH ? "dec-technical" : |
---|
3934 | fcsinfo[G[0].designation].keyword, |
---|
3935 | G[0].designation == FC_TRANSP ? "" : |
---|
3936 | G[0].size == cs94 ? "94 chars" : |
---|
3937 | G[0].size == cs96 ? "96 chars" : "multi-byte" ); |
---|
3938 | printf(" %sG1: %s (%s)\n", |
---|
3939 | GL == &G[1] ? "GL->" : GR == &G[1] ? "GR->" : " ", |
---|
3940 | G[1].designation == FC_TRANSP ? "transparent" : |
---|
3941 | G[1].designation == FC_DECSPEC ? "dec-special" : |
---|
3942 | G[1].designation == FC_DECTECH ? "dec-technical" : |
---|
3943 | fcsinfo[G[1].designation].keyword, |
---|
3944 | G[1].designation == FC_TRANSP ? "" : |
---|
3945 | G[1].size == cs94 ? "94 chars" : |
---|
3946 | G[1].size == cs96 ? "96 chars" : "multi-byte" ); |
---|
3947 | printf(" %sG2: %s (%s)\n", |
---|
3948 | GL == &G[2] ? "GL->" : GR == &G[2] ? "GR->" : " ", |
---|
3949 | G[2].designation == FC_TRANSP ? "transparent" : |
---|
3950 | G[2].designation == FC_DECSPEC ? "dec-special" : |
---|
3951 | G[2].designation == FC_DECTECH ? "dec-technical" : |
---|
3952 | fcsinfo[G[2].designation].keyword, |
---|
3953 | G[2].designation == FC_TRANSP ? "" : |
---|
3954 | G[2].size == cs94 ? "94 chars" : |
---|
3955 | G[2].size == cs96 ? "96 chars" : "multi-byte" ); |
---|
3956 | printf(" %sG3: %s (%s)\n", |
---|
3957 | GL == &G[3] ? "GL->" : GR == &G[3] ? "GR->" : " ", |
---|
3958 | G[3].designation == FC_TRANSP ? "transparent" : |
---|
3959 | G[3].designation == FC_DECSPEC ? "dec-special" : |
---|
3960 | G[3].designation == FC_DECTECH ? "dec-technical" : |
---|
3961 | fcsinfo[G[3].designation].keyword, |
---|
3962 | G[3].designation == FC_TRANSP ? "" : |
---|
3963 | G[3].size == cs94 ? "94 chars" : |
---|
3964 | G[3].size == cs96 ? "96 chars" : "multi-byte" ); |
---|
3965 | #else /* CKOUNI */ |
---|
3966 | printf(" Local: %s\n", |
---|
3967 | isunicode() ? "Unicode" : |
---|
3968 | csl == TX_TRANSP ? "transparent" : |
---|
3969 | csl == TX_UNDEF ? "undefined" : txrinfo[csl]->keywd ); |
---|
3970 | printf(" Remote: %sG0: %s (%s)\n", |
---|
3971 | GL == &G[0] ? "GL->" : GR == &G[0] ? "GR->" : " ", |
---|
3972 | txrinfo[G[0].designation]->keywd, |
---|
3973 | G[0].size == cs94 ? "94 chars" : |
---|
3974 | G[0].size == cs96 ? "96 chars" : "multi-byte" ); |
---|
3975 | printf(" %sG1: %s (%s)\n", |
---|
3976 | GL == &G[1] ? "GL->" : GR == &G[1] ? "GR->" : " ", |
---|
3977 | txrinfo[G[1].designation]->keywd, |
---|
3978 | G[1].size == cs94 ? "94 chars" : |
---|
3979 | G[1].size == cs96 ? "96 chars" : "multi-byte" ); |
---|
3980 | printf(" %sG2: %s (%s)\n", |
---|
3981 | GL == &G[2] ? "GL->" : GR == &G[2] ? "GR->" : " ", |
---|
3982 | txrinfo[G[2].designation]->keywd, |
---|
3983 | G[2].size == cs94 ? "94 chars" : |
---|
3984 | G[2].size == cs96 ? "96 chars" : "multi-byte" ); |
---|
3985 | printf(" %sG3: %s (%s)\n", |
---|
3986 | GL == &G[3] ? "GL->" : GR == &G[3] ? "GR->" : " ", |
---|
3987 | txrinfo[G[3].designation]->keywd, |
---|
3988 | G[3].size == cs94 ? "94 chars" : |
---|
3989 | G[3].size == cs96 ? "96 chars" : "multi-byte" ); |
---|
3990 | #endif /* CKOUNI */ |
---|
3991 | #else /* OS2 */ |
---|
3992 | #ifndef MAC |
---|
3993 | char *s; |
---|
3994 | #ifdef CK_ANSIC |
---|
3995 | int gettcs(int, int); |
---|
3996 | #else |
---|
3997 | int gettcs(); |
---|
3998 | #endif /* CK_ANSIC */ |
---|
3999 | |
---|
4000 | printf(" Terminal character-set: "); |
---|
4001 | if (csl == csr) { /* No translation */ |
---|
4002 | printf("transparent\n"); |
---|
4003 | } else { /* Translation */ |
---|
4004 | printf("%s (remote) %s (local)\n", |
---|
4005 | fcsinfo[csr].keyword,fcsinfo[csl].keyword); |
---|
4006 | if (csr != csl) { |
---|
4007 | switch(gettcs(csr,csl)) { |
---|
4008 | case TC_USASCII: s = "ascii"; break; |
---|
4009 | case TC_1LATIN: s = "latin1-iso"; break; |
---|
4010 | case TC_2LATIN: s = "latin2-iso"; break; |
---|
4011 | case TC_CYRILL: s = "cyrillic-iso"; break; |
---|
4012 | case TC_JEUC: s = "japanese-euc"; break; |
---|
4013 | case TC_HEBREW: s = "hebrew-iso"; break; |
---|
4014 | default: s = "transparent"; break; |
---|
4015 | } |
---|
4016 | if (strcmp(s,fcsinfo[csl].keyword) && |
---|
4017 | strcmp(s,fcsinfo[csr].keyword)) |
---|
4018 | printf(" (via %s)\n",s); |
---|
4019 | } |
---|
4020 | } |
---|
4021 | #endif /* MAC */ |
---|
4022 | #endif /* OS2 */ |
---|
4023 | #endif /* NOCSETS */ |
---|
4024 | } |
---|
4025 | #endif /* NOSHOW */ |
---|
4026 | |
---|
4027 | #ifndef NOSETKEY |
---|
4028 | VOID |
---|
4029 | shostrdef(s) CHAR * s; { |
---|
4030 | CHAR ch; |
---|
4031 | while (ch = *s++) |
---|
4032 | if (ch < 32 || ch == 127 |
---|
4033 | /* |
---|
4034 | Systems whose native character sets have graphic characters in C1... |
---|
4035 | */ |
---|
4036 | #ifndef NEXT /* NeXT */ |
---|
4037 | #ifndef AUX /* Macintosh */ |
---|
4038 | #ifndef XENIX /* IBM PC */ |
---|
4039 | #ifndef OS2 /* IBM PC */ |
---|
4040 | || (ch > 127 && ch < 160) |
---|
4041 | #endif /* OS2 */ |
---|
4042 | #endif /* XENIX */ |
---|
4043 | #endif /* AUX */ |
---|
4044 | #endif /* NEXT */ |
---|
4045 | ) |
---|
4046 | printf("\\{%d}",ch); /* Display control characters */ |
---|
4047 | else putchar((char) ch); /* in backslash notation */ |
---|
4048 | } |
---|
4049 | |
---|
4050 | VOID |
---|
4051 | shokeycode(c) int c; { |
---|
4052 | KEY ch; |
---|
4053 | CHAR *s; |
---|
4054 | #ifdef NEWMAPKEY |
---|
4055 | con_event km; |
---|
4056 | #else /* NEWMAPKEY */ |
---|
4057 | int km; |
---|
4058 | #endif /* NEWMAPKEY */ |
---|
4059 | |
---|
4060 | #ifdef OS2 |
---|
4061 | extern int mskkeys; |
---|
4062 | |
---|
4063 | if (c >= KMSIZE) { |
---|
4064 | bleep(BP_FAIL); |
---|
4065 | return; |
---|
4066 | } |
---|
4067 | s = keyname(c); |
---|
4068 | printf(" Key code \\%d %s => ", mskkeys ? cktomsk(c) : c, |
---|
4069 | s == NULL ? "" : s); |
---|
4070 | #else /* OS2 */ |
---|
4071 | printf(" Key code \\%d => ", c); |
---|
4072 | #endif /* OS2 */ |
---|
4073 | |
---|
4074 | #ifndef NEWMAPKEY |
---|
4075 | km = mapkey(c); |
---|
4076 | |
---|
4077 | #ifndef NOKVERBS |
---|
4078 | if (IS_KVERB(km)) { /* \Kverb? */ |
---|
4079 | int i, kv; |
---|
4080 | kv = km & ~(F_KVERB); |
---|
4081 | printf("Verb: "); |
---|
4082 | for (i = 0; i < nkverbs; i++) |
---|
4083 | if (kverbs[i].kwval == kv) { |
---|
4084 | printf("\\K%s",kverbs[i].kwd); |
---|
4085 | break; |
---|
4086 | } |
---|
4087 | printf("\n"); |
---|
4088 | } else |
---|
4089 | #endif /* NOKVERBS */ |
---|
4090 | if (IS_CSI(km)) { |
---|
4091 | int xkm = km & 0xFF; |
---|
4092 | if (xkm <= 32 || xkm >= 127) |
---|
4093 | printf("String: \\{27}[\\{%d}\n",xkm); |
---|
4094 | else |
---|
4095 | printf("String: \\{27}[%c\n",xkm); |
---|
4096 | } else if (IS_ESC(km)) { |
---|
4097 | int xkm = km & 0xFF; |
---|
4098 | if (xkm <= 32 || xkm >= 127) |
---|
4099 | printf("String: \\{27}\\{%d}\n",xkm); |
---|
4100 | else |
---|
4101 | printf("String: \\{27}%c\n",xkm); |
---|
4102 | } else if (macrotab[c]) { /* See if there's a macro */ |
---|
4103 | printf("String: "); /* If so, display its definition */ |
---|
4104 | s = macrotab[c]; |
---|
4105 | shostrdef(s); |
---|
4106 | printf("\n"); |
---|
4107 | #ifndef NOKVERBS |
---|
4108 | } else if (km >= 0x100) { /* This means "undefined" */ |
---|
4109 | printf("Undefined\n"); |
---|
4110 | #endif /* NOKVERBS */ |
---|
4111 | } else { /* No macro, show single character */ |
---|
4112 | printf("Character: "); |
---|
4113 | ch = km; |
---|
4114 | if (ch < 32 || ch == 127 || ch > 255 |
---|
4115 | #ifndef NEXT |
---|
4116 | #ifndef AUX |
---|
4117 | #ifndef XENIX |
---|
4118 | #ifndef OS2 |
---|
4119 | || (ch > 127 && ch < 160) |
---|
4120 | #endif /* OS2 */ |
---|
4121 | #endif /* XENIX */ |
---|
4122 | #endif /* AUX */ |
---|
4123 | #endif /* NEXT */ |
---|
4124 | ) |
---|
4125 | /* |
---|
4126 | These used to be %d, but gcc 1.93 & later complain about type mismatches. |
---|
4127 | %u is supposed to be totally portable. |
---|
4128 | */ |
---|
4129 | printf("\\%u",(unsigned int) ch); |
---|
4130 | else printf("%c \\%u",(CHAR) (ch & 0xff),(unsigned int) ch); |
---|
4131 | if (ch == (KEY) c) |
---|
4132 | printf(" (self, no translation)\n"); |
---|
4133 | else |
---|
4134 | printf("\n"); |
---|
4135 | } |
---|
4136 | #else /* NEWMAPKEY */ |
---|
4137 | km = mapkey(c); |
---|
4138 | |
---|
4139 | switch (km.type) { |
---|
4140 | #ifndef NOKVERBS |
---|
4141 | case kverb: { |
---|
4142 | int i, kv; |
---|
4143 | kv = km.kverb.id & ~(F_KVERB); |
---|
4144 | printf("Verb: "); |
---|
4145 | for (i = 0; i < nkverbs; i++) { |
---|
4146 | if (kverbs[i].kwval == kv) { |
---|
4147 | printf("\\K%s",kverbs[i].kwd); |
---|
4148 | break; |
---|
4149 | } |
---|
4150 | } |
---|
4151 | printf("\n"); |
---|
4152 | break; |
---|
4153 | } |
---|
4154 | #endif /* NOKVERBS */ |
---|
4155 | case csi: { |
---|
4156 | int xkm = km.csi.key & 0xFF; |
---|
4157 | if (xkm <= 32 || xkm >= 127) |
---|
4158 | printf("String: \\{27}[\\{%d}\n",xkm); |
---|
4159 | else |
---|
4160 | printf("String: \\{27}[%c\n",xkm); |
---|
4161 | break; |
---|
4162 | } |
---|
4163 | case esc: { |
---|
4164 | int xkm = km.esc.key & 0xFF; |
---|
4165 | if (xkm <= 32 || xkm >= 127) |
---|
4166 | printf("String: \\{27}\\{%d}\n",xkm); |
---|
4167 | else |
---|
4168 | printf("String: \\{27}%c\n",xkm); |
---|
4169 | break; |
---|
4170 | } |
---|
4171 | case macro: { |
---|
4172 | printf("String: "); /* Macro, display its definition */ |
---|
4173 | shostrdef(km.macro.string); |
---|
4174 | printf("\n"); |
---|
4175 | break; |
---|
4176 | } |
---|
4177 | case error: { |
---|
4178 | printf("Undefined\n"); |
---|
4179 | break; |
---|
4180 | } |
---|
4181 | case key: { |
---|
4182 | printf("Character: "); |
---|
4183 | ch = km.key.scancode; |
---|
4184 | if (ch < 32 || ch == 127 || ch > 255 |
---|
4185 | #ifndef NEXT |
---|
4186 | #ifndef AUX |
---|
4187 | #ifndef XENIX |
---|
4188 | #ifndef OS2 |
---|
4189 | || (ch > 127 && ch < 160) |
---|
4190 | #endif /* OS2 */ |
---|
4191 | #endif /* XENIX */ |
---|
4192 | #endif /* AUX */ |
---|
4193 | #endif /* NEXT */ |
---|
4194 | ) |
---|
4195 | /* |
---|
4196 | These used to be %d, but gcc 1.93 & later complain about type mismatches. |
---|
4197 | %u is supposed to be totally portable. |
---|
4198 | */ |
---|
4199 | printf("\\%u",(unsigned int) ch); |
---|
4200 | else printf("%c \\%u",(CHAR) (ch & 0xff),(unsigned int) ch); |
---|
4201 | if (ch == (KEY) c) |
---|
4202 | printf(" (self, no translation)\n"); |
---|
4203 | else |
---|
4204 | printf("\n"); |
---|
4205 | break; |
---|
4206 | } |
---|
4207 | } |
---|
4208 | #endif /* NEWMAPKEY */ |
---|
4209 | } |
---|
4210 | #endif /* NOSETKEY */ |
---|
4211 | |
---|
4212 | #ifndef NOSHOW |
---|
4213 | #ifndef NOLOCAL |
---|
4214 | #ifdef OS2 |
---|
4215 | extern char htab[]; |
---|
4216 | void |
---|
4217 | shotabs() |
---|
4218 | { |
---|
4219 | int i; |
---|
4220 | |
---|
4221 | printf("Tab Stops:\n\n"); |
---|
4222 | for ( i = 1; i <= 70; i++ ) |
---|
4223 | printf("%c",htab[i]=='T'?'T':'-'); |
---|
4224 | printf("\n1.......10........20........30........40........50........60\ |
---|
4225 | ........70\n\n"); |
---|
4226 | for ( ; i <= 140; i++ ) |
---|
4227 | printf("%c",htab[i]=='T'?'T':'-'); |
---|
4228 | printf("\n........80........90.......100.......110.......120.......130\ |
---|
4229 | .......140\n\n"); |
---|
4230 | for ( ; i <= 210; i++ ) |
---|
4231 | printf("%c",htab[i]=='T'?'T':'-'); |
---|
4232 | printf("\n.......150.......160.......170.......180.......190.......200\ |
---|
4233 | .......210\n\n"); |
---|
4234 | for ( ; i <= 255; i++ ) |
---|
4235 | printf("%c",htab[i]=='T'?'T':'-'); |
---|
4236 | printf("\n.......220.......230.......240.......250..255\n"); |
---|
4237 | } |
---|
4238 | |
---|
4239 | #endif /* OS2 */ |
---|
4240 | #endif /* NOLOCAL */ |
---|
4241 | #endif /* NOSHOW */ |
---|
4242 | |
---|
4243 | #ifndef NOSHOW |
---|
4244 | #ifndef NOLOCAL |
---|
4245 | VOID |
---|
4246 | shotrm() { |
---|
4247 | char *s; |
---|
4248 | |
---|
4249 | #ifdef PCFONTS |
---|
4250 | int i; |
---|
4251 | char *font; |
---|
4252 | |
---|
4253 | if ( IsOS2FullScreen() ) { /* Determine the font name */ |
---|
4254 | if ( !os2LoadPCFonts() ) { |
---|
4255 | for ( i=0; i <ntermfont; i++ ) { |
---|
4256 | if ( tt_font == termfont[i].kwval ) { |
---|
4257 | font = termfont[i].kwd; |
---|
4258 | break; |
---|
4259 | } |
---|
4260 | } |
---|
4261 | } else { |
---|
4262 | font = "(DLL not available)"; |
---|
4263 | } |
---|
4264 | } else { |
---|
4265 | font = "(full screen only)"; |
---|
4266 | } |
---|
4267 | #endif /* PCFONTS */ |
---|
4268 | |
---|
4269 | #ifndef OS2 |
---|
4270 | printf("\n"); |
---|
4271 | #endif /* OS2 */ |
---|
4272 | |
---|
4273 | printf("Terminal parameters:\n"); |
---|
4274 | printf(" %19s: %1d%-12s %13s: %1d%-14s\n", |
---|
4275 | "Bytesize: Command", |
---|
4276 | (cmdmsk == 0377) ? 8 : 7, |
---|
4277 | " bits","Terminal", |
---|
4278 | (cmask == 0377) ? 8 : 7," bits"); |
---|
4279 | #ifdef OS2 |
---|
4280 | printf(" %19s: %-13s","Type", |
---|
4281 | (tt_type >= 0 && tt_type <= max_tt) ? |
---|
4282 | tt_info[tt_type].x_name : |
---|
4283 | "unknown" ); |
---|
4284 | if (tt_type >= 0 && tt_type <= max_tt) |
---|
4285 | if (strlen(tt_info[tt_type].x_id)) |
---|
4286 | printf(" %13s: <ESC>%s","ID",tt_info[tt_type].x_id); |
---|
4287 | printf("\n"); |
---|
4288 | #else |
---|
4289 | s = getenv("TERM"); |
---|
4290 | printf(" %19s: %-13s\n","Type", s ? s : "(unknown)"); |
---|
4291 | #endif /* OS2 */ |
---|
4292 | printf(" %19s: %-13s %13s: %-15s\n","Echo", |
---|
4293 | duplex ? "local" : "remote","Locking-shift",showoff(sosi)); |
---|
4294 | printf(" %19s: %-13s %13s: %-15s\n","Newline-mode", |
---|
4295 | showoff(tnlm),"Cr-display",tt_crd ? "crlf" : "normal"); |
---|
4296 | #ifdef OS2 |
---|
4297 | printf(" %19s: %-13s %13s: %-15s\n","Cursor", |
---|
4298 | (tt_cursor == 2) ? "full" : |
---|
4299 | (tt_cursor == 1) ? "half" : "underline", |
---|
4300 | #ifdef CK_AUTODL |
---|
4301 | "autodownload",autodl ? "on" : "off" |
---|
4302 | #else /* CK_AUTODL */ |
---|
4303 | "", "" |
---|
4304 | #endif /* CK_AUTODL */ |
---|
4305 | ); |
---|
4306 | #endif /* OS2 */ |
---|
4307 | #ifdef OS2 |
---|
4308 | printf(" %19s: %-13s %13s: %-15s\n","Arrow-keys", |
---|
4309 | tt_arrow ? "application" : "cursor", |
---|
4310 | "Keypad-mode", tt_keypad ? "application" : "numeric" |
---|
4311 | ); |
---|
4312 | |
---|
4313 | /* Just to make sure we are using current info */ |
---|
4314 | updanswerbk(); |
---|
4315 | |
---|
4316 | /* |
---|
4317 | This line doesn't end with '\n' because the answerback string |
---|
4318 | is terminated with a newline |
---|
4319 | */ |
---|
4320 | printf(" %19s: %-13s %13s: %-15s","Answerback", |
---|
4321 | showoff(tt_answer),"response",answerback); |
---|
4322 | switch ( tt_bell ) { |
---|
4323 | case XYB_NONE: |
---|
4324 | s = "none"; |
---|
4325 | break; |
---|
4326 | case XYB_VIS: |
---|
4327 | s= "visible"; |
---|
4328 | break; |
---|
4329 | case XYB_AUD | XYB_BEEP: |
---|
4330 | s="beep"; |
---|
4331 | break; |
---|
4332 | case XYB_AUD | XYB_SYS: |
---|
4333 | s="system sounds"; |
---|
4334 | break; |
---|
4335 | default: |
---|
4336 | s="(unknown)"; |
---|
4337 | } |
---|
4338 | printf(" %19s: %-13s %13s: %-15s\n","Bell",s, |
---|
4339 | "Wrap",showoff(tt_wrap)); |
---|
4340 | printf(" %19s: %-13d %13s: %-15d\n","Transmit-timeout",tt_ctstmo, |
---|
4341 | "Output-pacing",tt_pacing); |
---|
4342 | printf(" %19s: %-13s %13s: %-15d\n","Roll-mode", |
---|
4343 | tt_roll[VTERM]?"insert":"overwrite","Scrollback", tt_scrsize[VTERM] |
---|
4344 | ); |
---|
4345 | #endif /* OS2 */ |
---|
4346 | |
---|
4347 | #ifdef CK_APC |
---|
4348 | if (apcstatus == APC_ON) s = "on"; |
---|
4349 | else if (apcstatus == APC_OFF) s = "off"; |
---|
4350 | else if (apcstatus == APC_UNCH) s = "unchecked"; |
---|
4351 | printf(" %19s: %-13s %13s: %-15s\n", |
---|
4352 | "APC", s, |
---|
4353 | #ifdef OS2 |
---|
4354 | #ifdef PCFONTS |
---|
4355 | "Font",font |
---|
4356 | #else /* PCFONTS */ |
---|
4357 | "","" |
---|
4358 | #endif /* PCFONTS */ |
---|
4359 | #else |
---|
4360 | #ifdef CK_AUTODL |
---|
4361 | "Autodownload", autodl ? "on" : "off" |
---|
4362 | #else |
---|
4363 | "","" |
---|
4364 | #endif /* CK_AUTODL */ |
---|
4365 | #endif /* OS2 */ |
---|
4366 | ); |
---|
4367 | #endif /* CK_APC */ |
---|
4368 | |
---|
4369 | #ifdef OS2 |
---|
4370 | { |
---|
4371 | char cpbuf[50]; |
---|
4372 | int cplist[8], cps; |
---|
4373 | cps = os2getcplist(cplist, sizeof(cplist)); |
---|
4374 | sprintf(cpbuf,"%3d,%3d,%3d,%3d", |
---|
4375 | cps > 1 ? cplist[1] : 0, cps > 2 ? cplist[2] : 0, |
---|
4376 | cps > 3 ? cplist[3] : 0, cps > 4 ? cplist[4] : 0 ); |
---|
4377 | printf(" %19s: %-13d %13s: %-15s\n","Code-page: active", |
---|
4378 | os2getcp(),"available",cpbuf); |
---|
4379 | } |
---|
4380 | #endif /* OS2 */ |
---|
4381 | |
---|
4382 | #ifdef CK_TTGWSIZ /* Console terminal screen size */ |
---|
4383 | #ifdef OS2 |
---|
4384 | if ( tt_cols[VTERM] < 0 || tt_rows[VTERM] < 0 ) |
---|
4385 | ttgwsiz(); /* Try to get latest size */ |
---|
4386 | printf(" %19s: %-13d %13s: %-15d\n","Height",tt_rows[VTERM], |
---|
4387 | "Width",tt_cols[VTERM]); |
---|
4388 | #else /* OS2 */ |
---|
4389 | ttgwsiz(); /* Try to get latest size */ |
---|
4390 | printf(" %19s: %-13d %13s: %-15d\n","Height",tt_rows, "Width", tt_cols); |
---|
4391 | #endif /* OS2 */ |
---|
4392 | #else |
---|
4393 | #endif /* CK_TTGWSIZ */ |
---|
4394 | |
---|
4395 | #ifdef OS2 |
---|
4396 | if (updmode == tt_updmode) |
---|
4397 | if (updmode == TTU_FAST) |
---|
4398 | s = "fast (fast)"; |
---|
4399 | else |
---|
4400 | s = "smooth (smooth)"; |
---|
4401 | else |
---|
4402 | if (updmode == TTU_FAST) |
---|
4403 | s = "fast (smooth)"; |
---|
4404 | else |
---|
4405 | s = "smooth (fast)"; |
---|
4406 | |
---|
4407 | printf(" %19s: %-13s %13s: %-15d\n","Screen-update: mode",s, |
---|
4408 | "update freq",tt_update); |
---|
4409 | #endif /* OS2 */ |
---|
4410 | printf(" %19s: %-13s %13s: %-15s\n","Debug", |
---|
4411 | showoff(debses),"Session log", seslog? sesfil : "(none)" ); |
---|
4412 | #ifdef OS2 |
---|
4413 | { |
---|
4414 | USHORT row, col; |
---|
4415 | char * colors[16] = { |
---|
4416 | "black","blue","green","cyan","red","magenta","brown","lgray", |
---|
4417 | "dgray","lblue","lgreen","lcyan","lred","lmagent","yellow","white" |
---|
4418 | }; |
---|
4419 | printf("\n Color:"); |
---|
4420 | #ifndef ONETERMUPD |
---|
4421 | GetCurPos( &row, &col ); |
---|
4422 | WrtCharStrAtt("border", 6, row, 9, &colorborder ); |
---|
4423 | WrtCharStrAtt("debug", 5, row, 17, &colordebug ); |
---|
4424 | WrtCharStrAtt("helptext", 8, row, 25, &colorhelp ); |
---|
4425 | WrtCharStrAtt("reverse", 7, row, 34, &colorreverse ); |
---|
4426 | WrtCharStrAtt("select", 6, row, 42, &colorselect ); |
---|
4427 | WrtCharStrAtt("status", 6, row, 50, &colorstatus ); |
---|
4428 | WrtCharStrAtt("terminal", 8, row, 58, &colornormal ); |
---|
4429 | WrtCharStrAtt("underline", 9, row, 67, &colorunderline ); |
---|
4430 | #endif /* ONETERMUPD */ |
---|
4431 | row = VscrnGetCurPos(VCMD)->y+1; |
---|
4432 | VscrnWrtCharStrAtt(VCMD, "border", 6, row, 9, &colorborder ); |
---|
4433 | VscrnWrtCharStrAtt(VCMD, "debug", 5, row, 17, &colordebug ); |
---|
4434 | VscrnWrtCharStrAtt(VCMD, "helptext", 8, row, 25, &colorhelp ); |
---|
4435 | VscrnWrtCharStrAtt(VCMD, "reverse", 7, row, 34, &colorreverse ); |
---|
4436 | VscrnWrtCharStrAtt(VCMD, "select", 6, row, 42, &colorselect ); |
---|
4437 | VscrnWrtCharStrAtt(VCMD, "status", 6, row, 50, &colorstatus ); |
---|
4438 | VscrnWrtCharStrAtt(VCMD, "terminal", 8, row, 58, &colornormal ); |
---|
4439 | VscrnWrtCharStrAtt(VCMD, "underline", 9, row, 67, &colorunderline ); |
---|
4440 | printf( "\n" ); |
---|
4441 | |
---|
4442 | /* Foreground color names */ |
---|
4443 | printf("%6s: %-8s%-8s%-9s%-8s%-8s%-8s%-9s%-9s\n","fore", |
---|
4444 | "", |
---|
4445 | colors[colordebug&0x0F], |
---|
4446 | colors[colorhelp&0x0F], |
---|
4447 | colors[colorreverse&0x0F], |
---|
4448 | colors[colorselect&0x0F], |
---|
4449 | colors[colorstatus&0x0F], |
---|
4450 | colors[colornormal&0x0F], |
---|
4451 | colors[colorunderline&0x0F] ); |
---|
4452 | |
---|
4453 | /* Background color names */ |
---|
4454 | printf("%6s: %-8s%-8s%-9s%-8s%-8s%-8s%-9s%-9s\n","back", |
---|
4455 | colors[colorborder], |
---|
4456 | colors[colordebug>>4], |
---|
4457 | colors[colorhelp>>4], |
---|
4458 | colors[colorreverse>>4], |
---|
4459 | colors[colorselect>>4], |
---|
4460 | colors[colorstatus>>4], |
---|
4461 | colors[colornormal>>4], |
---|
4462 | colors[colorunderline>>4] ); |
---|
4463 | } |
---|
4464 | #endif /* OS2 */ |
---|
4465 | printf("\n"); |
---|
4466 | printf(" CONNECT-mode escape character: %d (Ctrl-%c, %s): %s\n", |
---|
4467 | escape,ctl(escape),(escape == 127 ? "DEL" : ccntab[escape]), |
---|
4468 | nm[tt_escape] |
---|
4469 | ); |
---|
4470 | #ifdef OS2 |
---|
4471 | printf(" See SHOW CHARACTER-SETS for character-set info\n"); |
---|
4472 | #else /* OS2 */ |
---|
4473 | #ifndef NOCSETS |
---|
4474 | shotcs(tcsl,tcsr); /* Show terminal character sets */ |
---|
4475 | #endif /* NOCSETS */ |
---|
4476 | #endif /* OS2 */ |
---|
4477 | |
---|
4478 | #ifdef UNIX |
---|
4479 | #ifndef NOJC |
---|
4480 | printf(" %19s: %-13s\n\n","Suspend", showoff(suspend)); |
---|
4481 | #endif /* NOJC */ |
---|
4482 | #endif /* UNIX */ |
---|
4483 | } |
---|
4484 | #endif /* NOLOCAL */ |
---|
4485 | #endif /* NOSHOW */ |
---|
4486 | |
---|
4487 | #ifndef NOSHOW |
---|
4488 | #ifndef NOLOCAL |
---|
4489 | #ifdef OS2MOUSE |
---|
4490 | |
---|
4491 | void |
---|
4492 | shomou() { |
---|
4493 | int button, event, id, i; |
---|
4494 | char * name = ""; |
---|
4495 | |
---|
4496 | printf("Mouse settings:\n"); |
---|
4497 | printf(" Active: %s\n\n",showoff(tt_mouse)); |
---|
4498 | |
---|
4499 | for ( button = 0; button < MMBUTTONMAX; button++ ) |
---|
4500 | for ( event = 0; event < MMEVENTSIZE; event++ ) |
---|
4501 | if ( mousemap[button][event].type != error ) |
---|
4502 | switch ( mousemap[button][event].type ) { |
---|
4503 | case key: |
---|
4504 | printf(" %s = Character: %c \\%d\n", |
---|
4505 | mousename(button,event), |
---|
4506 | mousemap[button][event].key.scancode, |
---|
4507 | mousemap[button][event].key.scancode ); |
---|
4508 | break; |
---|
4509 | case kverb: |
---|
4510 | id = mousemap[button][event].kverb.id & ~(F_KVERB); |
---|
4511 | if ( id != K_IGNORE ) { |
---|
4512 | for ( i = 0; i< nkverbs; i++) |
---|
4513 | if ( id == kverbs[i].kwval ) { |
---|
4514 | name = kverbs[i].kwd; |
---|
4515 | break; |
---|
4516 | } |
---|
4517 | printf(" %s = Kverb: \\K%s\n", |
---|
4518 | mousename(button,event), |
---|
4519 | name |
---|
4520 | ); |
---|
4521 | } |
---|
4522 | break; |
---|
4523 | case macro: |
---|
4524 | printf(" %s = Macro: ", |
---|
4525 | mousename(button,event) ); |
---|
4526 | shostrdef(mousemap[button][event].macro.string); |
---|
4527 | printf("\n"); |
---|
4528 | break; |
---|
4529 | } |
---|
4530 | } |
---|
4531 | #endif /* OS2MOUSE */ |
---|
4532 | #endif /* NOLOCAL */ |
---|
4533 | #endif /* NOSHOW */ |
---|
4534 | |
---|
4535 | #ifndef NOSHOW |
---|
4536 | #ifdef OS2 |
---|
4537 | static struct keytab shokeytab[] = { /* SHOW KEY modes */ |
---|
4538 | "all", 1, 0, |
---|
4539 | "one", 0, 0 |
---|
4540 | }; |
---|
4541 | static int nshokey = (sizeof(shokeytab) / sizeof(struct keytab)); |
---|
4542 | #endif /* OS2 */ |
---|
4543 | |
---|
4544 | int |
---|
4545 | doshow(x) int x; { |
---|
4546 | int y, i; long zz; |
---|
4547 | char *s; |
---|
4548 | #ifdef OS2 |
---|
4549 | extern int os2gks; |
---|
4550 | #endif /* OS2 */ |
---|
4551 | |
---|
4552 | #ifndef NOSETKEY |
---|
4553 | if (x == SHKEY) { /* SHOW KEY */ |
---|
4554 | int c; |
---|
4555 | #ifdef OS2 |
---|
4556 | if ((x = cmkey(shokeytab,nshokey,"How many keys should be shown?", |
---|
4557 | "one",xxstring)) < 0) return(x); |
---|
4558 | #endif /* OS2 */ |
---|
4559 | if ((y = cmcfm()) < 0) return(y); |
---|
4560 | #ifdef MAC |
---|
4561 | printf("Not implemented\n"); |
---|
4562 | return(0); |
---|
4563 | #else /* Not MAC */ |
---|
4564 | #ifdef OS2 |
---|
4565 | if ( x ) { |
---|
4566 | #ifndef NEWMAPKEY |
---|
4567 | extern KEY * keymap; |
---|
4568 | for ( c = 0; c < KMSIZE; c++ ) |
---|
4569 | if ( mapkey(c) != c || macrotab[c] ) |
---|
4570 | shokeycode(c); |
---|
4571 | #else /* NEWMAPKEY */ |
---|
4572 | con_event evt; |
---|
4573 | for (c = 0; c < KMSIZE; c++) { |
---|
4574 | evt = mapkey(c); |
---|
4575 | if (evt.type != error) { |
---|
4576 | shokeycode(c); |
---|
4577 | } |
---|
4578 | } |
---|
4579 | #endif /* NEWMAPKEY */ |
---|
4580 | } else { |
---|
4581 | #endif /* OS2 */ |
---|
4582 | printf(" Press key: "); |
---|
4583 | #ifdef UNIX |
---|
4584 | #ifdef NOSETBUF |
---|
4585 | fflush(stdout); |
---|
4586 | #endif /* NOSETBUF */ |
---|
4587 | #endif /* UNIX */ |
---|
4588 | conbin((char)escape); /* Put terminal in binary mode */ |
---|
4589 | #ifdef OS2 |
---|
4590 | os2gks = 0; /* Turn off Kverb preprocessing */ |
---|
4591 | #endif /* OS2 */ |
---|
4592 | c = congks(0); /* Get character or scan code */ |
---|
4593 | #ifdef OS2 |
---|
4594 | os2gks = 1; /* Turn on Kverb preprocessing */ |
---|
4595 | #endif /* OS2 */ |
---|
4596 | concb((char)escape); /* Restore terminal to cbreak mode */ |
---|
4597 | if (c < 0) { /* Check for error */ |
---|
4598 | printf("?Error reading key\n"); |
---|
4599 | return(0); |
---|
4600 | } |
---|
4601 | #ifndef OS2 |
---|
4602 | /* |
---|
4603 | Do NOT mask when it can be a raw scan code, perhaps > 255 |
---|
4604 | */ |
---|
4605 | c &= cmdmsk; /* Apply command mask */ |
---|
4606 | #endif /* OS2 */ |
---|
4607 | printf("\n"); |
---|
4608 | shokeycode(c); |
---|
4609 | #ifdef OS2 |
---|
4610 | } |
---|
4611 | #endif /* OS2 */ |
---|
4612 | return(1); |
---|
4613 | #endif /* MAC */ |
---|
4614 | } |
---|
4615 | #ifndef NOKVERBS |
---|
4616 | if (x == SHKVB) { /* SHOW KVERBS */ |
---|
4617 | if ((y = cmcfm()) < 0) return(y); |
---|
4618 | printf("\nThe following %d keyboard verbs are available:\n\n",nkverbs); |
---|
4619 | kwdhelp(kverbs,nkverbs,"","\\K","",3); |
---|
4620 | printf("\n"); |
---|
4621 | return(1); |
---|
4622 | } |
---|
4623 | #ifdef OS2 |
---|
4624 | if (x == SHUDK) { /* SHOW UDKs */ |
---|
4625 | extern void showudk(void); |
---|
4626 | if ((y = cmcfm()) < 0) return(y); |
---|
4627 | showudk(); |
---|
4628 | return(1); |
---|
4629 | } |
---|
4630 | #endif /* OS2 */ |
---|
4631 | #endif /* NOKVERBS */ |
---|
4632 | #endif /* NOSETKEY */ |
---|
4633 | |
---|
4634 | #ifndef NOSPL |
---|
4635 | if (x == SHMAC) { /* SHOW MACRO */ |
---|
4636 | x = cmfld("Macro name, or carriage return to see them all","",&s, |
---|
4637 | NULL); |
---|
4638 | if (x == -3) /* This means they want see all */ |
---|
4639 | *line = '\0'; |
---|
4640 | else if (x < 0) /* Otherwise negative = parse error */ |
---|
4641 | return(x); |
---|
4642 | else /* 0 or greater */ |
---|
4643 | strcpy(line,s); /* means they typed something */ |
---|
4644 | if ((y = cmcfm()) < 0) return(y); /* Get confirmation */ |
---|
4645 | if (*line) { |
---|
4646 | slc = 0; /* Initial SHO MAC line number */ |
---|
4647 | x = mlook(mactab,s,nmac); /* Look up what they typed */ |
---|
4648 | switch (x) { |
---|
4649 | case -3: /* Nothing to look up */ |
---|
4650 | return(0); |
---|
4651 | case -1: /* Not found */ |
---|
4652 | printf("%s - not found\n",s); |
---|
4653 | return(0); |
---|
4654 | case -2: /* Ambiguous, matches more than one */ |
---|
4655 | y = (int)strlen(line); |
---|
4656 | slc = 1; |
---|
4657 | for (x = 0; x < nmac; x++) |
---|
4658 | if (!strncmp(mactab[x].kwd,line,y)) |
---|
4659 | if (shomac(mactab[x].kwd,mactab[x].mval) < 0) break; |
---|
4660 | return(1); |
---|
4661 | default: /* Matches one exactly */ |
---|
4662 | shomac(mactab[x].kwd,mactab[x].mval); |
---|
4663 | return(1); |
---|
4664 | } |
---|
4665 | } else { /* They want to see them all */ |
---|
4666 | printf("Macros:\n"); |
---|
4667 | slc = 1; |
---|
4668 | for (y = 0; y < nmac; y++) |
---|
4669 | if (shomac(mactab[y].kwd,mactab[y].mval) < 0) break; |
---|
4670 | return(1); |
---|
4671 | } |
---|
4672 | } |
---|
4673 | #endif /* NOSPL */ |
---|
4674 | |
---|
4675 | /* |
---|
4676 | Other SHOW commands only have two fields. Get command confirmation here, |
---|
4677 | then handle with big switch() statement. |
---|
4678 | */ |
---|
4679 | if ((y = cmcfm()) < 0) return(y); |
---|
4680 | switch (x) { |
---|
4681 | |
---|
4682 | #ifdef ANYX25 |
---|
4683 | case SHPAD: |
---|
4684 | shopad(); |
---|
4685 | break; |
---|
4686 | #endif /* ANYX25 */ |
---|
4687 | |
---|
4688 | #ifdef NETCONN |
---|
4689 | case SHNET: |
---|
4690 | shonet(); |
---|
4691 | break; |
---|
4692 | #endif /* NETCONN */ |
---|
4693 | |
---|
4694 | case SHPAR: |
---|
4695 | shopar(); |
---|
4696 | break; |
---|
4697 | |
---|
4698 | case SHATT: |
---|
4699 | shoatt(); |
---|
4700 | break; |
---|
4701 | |
---|
4702 | #ifndef NOSPL |
---|
4703 | case SHCOU: |
---|
4704 | printf(" %d\n",count[cmdlvl]); |
---|
4705 | break; |
---|
4706 | #endif /* NOSPL */ |
---|
4707 | |
---|
4708 | #ifndef NOSERVER |
---|
4709 | case SHSER: /* Show Server */ |
---|
4710 | i = 0; |
---|
4711 | #ifndef NOFRILLS |
---|
4712 | printf("Function Status:\n"); |
---|
4713 | i++; |
---|
4714 | printf(" GET %s\n",nm[en_get]); |
---|
4715 | i++; |
---|
4716 | printf(" RETRIEVE %s\n",nm[en_ret]); |
---|
4717 | i++; |
---|
4718 | printf(" SEND %s\n",nm[en_sen]); |
---|
4719 | i++; |
---|
4720 | printf(" MAIL %s\n",nm[en_mai]); |
---|
4721 | i++; |
---|
4722 | printf(" PRINT %s\n",nm[en_pri]); |
---|
4723 | i++; |
---|
4724 | #ifndef NOSPL |
---|
4725 | printf(" REMOTE ASSIGN %s\n",nm[en_asg]); |
---|
4726 | i++; |
---|
4727 | #endif /* NOSPL */ |
---|
4728 | printf(" REMOTE CD/CWD %s\n",nm[en_cwd]); |
---|
4729 | i++; |
---|
4730 | #ifdef ZCOPY |
---|
4731 | printf(" REMOTE COPY %s\n",nm[en_cpy]); |
---|
4732 | i++; |
---|
4733 | #endif /* ZCOPY */ |
---|
4734 | printf(" REMOTE DELETE %s\n",nm[en_del]); |
---|
4735 | printf(" REMOTE DIRECTORY %s\n",nm[en_dir]); |
---|
4736 | printf(" REMOTE HOST %s\n",nm[en_hos]); |
---|
4737 | i += 3; |
---|
4738 | #ifndef NOSPL |
---|
4739 | printf(" REMOTE QUERY %s\n",nm[en_que]); |
---|
4740 | i++; |
---|
4741 | #endif /* NOSPL */ |
---|
4742 | printf(" REMOTE RENAME %s\n",nm[en_ren]); |
---|
4743 | printf(" REMOTE SET %s\n",nm[en_set]); |
---|
4744 | printf(" REMOTE SPACE %s\n",nm[en_spa]); |
---|
4745 | printf(" REMOTE TYPE %s\n",nm[en_typ]); |
---|
4746 | printf(" REMOTE WHO %s\n",nm[en_who]); |
---|
4747 | printf(" BYE %s\n",nm[en_bye]); |
---|
4748 | printf(" FINISH %s\n",nm[en_fin]); |
---|
4749 | i += 7; |
---|
4750 | #endif /* NOFRILLS */ |
---|
4751 | printf("Server timeout: %d\n",srvtim); |
---|
4752 | printf("Server display: %s\n", showoff(srvdis)); |
---|
4753 | printf("Server login: "); |
---|
4754 | if (!x_user) { |
---|
4755 | printf("(none)\n"); |
---|
4756 | } else { |
---|
4757 | char *s; |
---|
4758 | printf("\"%s\", \"%s\", \"%s\"\n", |
---|
4759 | x_user, |
---|
4760 | x_passwd ? x_passwd : "", |
---|
4761 | x_acct ? x_acct : "" |
---|
4762 | ); |
---|
4763 | } |
---|
4764 | printf("Server get-path:"); |
---|
4765 | if (ngetpath == 0) { |
---|
4766 | printf(" (none)\n"); |
---|
4767 | } else { |
---|
4768 | printf("\n"); |
---|
4769 | i += 3; |
---|
4770 | for (x = 0; x < ngetpath; x++) { |
---|
4771 | if (getpath[x]) printf(" %d. %s\n", x, getpath[x]); |
---|
4772 | if (++i > (cmd_rows - 3)) { /* More than a screenful... */ |
---|
4773 | if (!askmore()) |
---|
4774 | break; |
---|
4775 | else |
---|
4776 | i = 0; |
---|
4777 | } |
---|
4778 | } |
---|
4779 | } |
---|
4780 | break; |
---|
4781 | #endif /* NOSERVER */ |
---|
4782 | |
---|
4783 | case SHSTA: /* Status of last command */ |
---|
4784 | printf( " %s\n", success ? "SUCCESS" : "FAILURE" ); |
---|
4785 | return(0); /* Don't change it */ |
---|
4786 | |
---|
4787 | #ifdef MAC |
---|
4788 | case SHSTK: { /* Stack for MAC debugging */ |
---|
4789 | long sp; |
---|
4790 | |
---|
4791 | sp = -1; |
---|
4792 | loadA0 ((char *)&sp); /* set destination address */ |
---|
4793 | SPtoaA0(); /* move SP to destination */ |
---|
4794 | printf("Stack at 0x%x\n", sp); |
---|
4795 | show_queue(); /* more debugging */ |
---|
4796 | break; |
---|
4797 | } |
---|
4798 | #endif /* MAC */ |
---|
4799 | |
---|
4800 | #ifndef NOLOCAL |
---|
4801 | #ifdef OS2 |
---|
4802 | case SHTAB: /* SHOW TABS */ |
---|
4803 | shotabs(); |
---|
4804 | break; |
---|
4805 | #endif /* OS2 */ |
---|
4806 | |
---|
4807 | case SHTER: /* SHOW TERMINAL */ |
---|
4808 | shotrm(); |
---|
4809 | break; |
---|
4810 | |
---|
4811 | #ifdef OS2 |
---|
4812 | case SHVSCRN: /* SHOW Virtual Screen - for debug */ |
---|
4813 | shovscrn(); |
---|
4814 | break; |
---|
4815 | #endif /* OS2 */ |
---|
4816 | |
---|
4817 | #ifdef OS2MOUSE |
---|
4818 | case SHMOU: /* SHOW MOUSE */ |
---|
4819 | shomou(); |
---|
4820 | break; |
---|
4821 | #endif /* OS2MOUSE */ |
---|
4822 | #endif /* NOLOCAL */ |
---|
4823 | |
---|
4824 | #ifndef NOFRILLS |
---|
4825 | case SHVER: |
---|
4826 | shover(); |
---|
4827 | break; |
---|
4828 | #endif /* NOFRILLS */ |
---|
4829 | |
---|
4830 | #ifndef NOSPL |
---|
4831 | case SHBUI: /* Built-in variables */ |
---|
4832 | case SHFUN: /* or built-in functions */ |
---|
4833 | #ifdef CK_TTGWSIZ |
---|
4834 | #ifdef OS2 |
---|
4835 | if (tt_cols[VTERM] < 0 || tt_rows[VTERM] < 0) |
---|
4836 | ttgwsiz(); |
---|
4837 | #else /* OS2 */ |
---|
4838 | if (ttgwsiz() > 0) { /* Get current screen size */ |
---|
4839 | if (tt_rows > 0 && tt_cols > 0) { |
---|
4840 | cmd_rows = tt_rows; |
---|
4841 | cmd_cols = tt_cols; |
---|
4842 | } |
---|
4843 | } |
---|
4844 | #endif /* OS2 */ |
---|
4845 | #endif /* CK_TTGWSIZ */ |
---|
4846 | |
---|
4847 | if (x == SHFUN) { /* Functions */ |
---|
4848 | printf("\nThe following functions are available:\n\n"); |
---|
4849 | kwdhelp(fnctab,nfuncs,"","\\F","()",3); |
---|
4850 | printf("\n"); |
---|
4851 | break; |
---|
4852 | } else { /* Variables */ |
---|
4853 | i = 0; |
---|
4854 | for (y = 0; y < nvars; y++) { |
---|
4855 | char *s; |
---|
4856 | if ((vartab[y].flgs & CM_INV)) |
---|
4857 | continue; |
---|
4858 | s = nvlook(vartab[y].kwd); |
---|
4859 | printf(" \\v(%s) = ",vartab[y].kwd); |
---|
4860 | if (vartab[y].kwval == VN_NEWL) { /* \v(newline) */ |
---|
4861 | while (*s) /* Show control chars symbolically */ |
---|
4862 | printf("\\{%d}",*s++); |
---|
4863 | printf("\n"); |
---|
4864 | } else if ( vartab[y].kwval == VN_IBUF || /* \v(input) */ |
---|
4865 | vartab[y].kwval == VN_QUE || /* \v(query) */ |
---|
4866 | #ifdef OS2 |
---|
4867 | vartab[y].kwval == VN_SELCT || /* \v(select) */ |
---|
4868 | #endif /* OS2 */ |
---|
4869 | (vartab[y].kwval >= VN_M_AAA && /* modem ones */ |
---|
4870 | vartab[y].kwval <= VN_M_ZZZ) |
---|
4871 | ) { |
---|
4872 | int r = 12; /* This one can wrap around */ |
---|
4873 | char buf[10]; |
---|
4874 | while (*s) { |
---|
4875 | if (isprint(*s)) { |
---|
4876 | buf[0] = *s; |
---|
4877 | buf[1] = NUL; |
---|
4878 | r++; |
---|
4879 | } else { |
---|
4880 | sprintf(buf,"\\{%d}",*s); |
---|
4881 | r += (int) strlen(buf); |
---|
4882 | } |
---|
4883 | if (r >= cmd_cols - 1) { |
---|
4884 | printf("\n"); |
---|
4885 | r = 0; |
---|
4886 | i++; |
---|
4887 | } |
---|
4888 | printf("%s",buf); |
---|
4889 | s++; |
---|
4890 | } |
---|
4891 | printf("\n"); |
---|
4892 | } else |
---|
4893 | printf("%s\n",s); |
---|
4894 | if (++i > (cmd_rows - 3)) { /* More than a screenful... */ |
---|
4895 | if ((y >= nvars - 1) || !askmore()) |
---|
4896 | break; |
---|
4897 | else |
---|
4898 | i = 0; |
---|
4899 | } |
---|
4900 | } |
---|
4901 | } |
---|
4902 | break; |
---|
4903 | |
---|
4904 | case SHVAR: /* Global variables */ |
---|
4905 | x = 0; /* Variable count */ |
---|
4906 | slc = 1; /* Screen line count for "more?" */ |
---|
4907 | for (y = 33; y < GVARS; y++) |
---|
4908 | if (g_var[y]) { |
---|
4909 | if (x++ == 0) printf("Global variables:\n"); |
---|
4910 | sprintf(line," \\%%%c",y); |
---|
4911 | if (shomac(line,g_var[y]) < 0) break; |
---|
4912 | } |
---|
4913 | if (!x) printf(" No variables defined\n"); |
---|
4914 | break; |
---|
4915 | |
---|
4916 | case SHARG: /* Args */ |
---|
4917 | if (maclvl > -1) { |
---|
4918 | printf("Macro arguments at level %d\n",maclvl); |
---|
4919 | for (y = 0; y < 10; y++) |
---|
4920 | if (m_arg[maclvl][y]) |
---|
4921 | printf(" \\%%%d = %s\n",y,m_arg[maclvl][y]); |
---|
4922 | } else { |
---|
4923 | printf(" No macro arguments at top level\n"); |
---|
4924 | } |
---|
4925 | break; |
---|
4926 | |
---|
4927 | case SHARR: /* Arrays */ |
---|
4928 | x = 0; |
---|
4929 | for (y = 0; y < (int) 'z' - ARRAYBASE + 1; y++) |
---|
4930 | if (a_ptr[y]) { |
---|
4931 | if (x == 0) printf("Declared arrays:\n"); |
---|
4932 | x = 1; |
---|
4933 | printf(" \\&%c[%d]\n", |
---|
4934 | (y == 1) ? 64 : y + ARRAYBASE, a_dim[y]); |
---|
4935 | } |
---|
4936 | if (!x) printf(" No arrays declared\n"); |
---|
4937 | break; |
---|
4938 | #endif /* NOSPL */ |
---|
4939 | |
---|
4940 | case SHPRO: /* Protocol parameters */ |
---|
4941 | shoparp(); |
---|
4942 | if (protocol == PROTO_K) { |
---|
4943 | #ifdef XFRCAN |
---|
4944 | printf("\n Cancellation: %s",showoff(xfrcan)); |
---|
4945 | if (xfrcan) printf(" %d %d\n", xfrchr, xfrnum); |
---|
4946 | else printf("\n"); |
---|
4947 | #endif /* XFRCAN */ |
---|
4948 | printf(" Send / Receive Pause: %d (msec)\n\n",pktpaus); |
---|
4949 | } |
---|
4950 | break; |
---|
4951 | |
---|
4952 | case SHCOM: /* Communication parameters */ |
---|
4953 | printf("\n"); |
---|
4954 | shoparc(); |
---|
4955 | #ifdef OS2 |
---|
4956 | { |
---|
4957 | int i; |
---|
4958 | char *s = "(unknown)"; |
---|
4959 | for (i = 0; i < nprty; i++) |
---|
4960 | if (prtytab[i].kwval == priority) { |
---|
4961 | s = prtytab[i].kwd; |
---|
4962 | break; |
---|
4963 | } |
---|
4964 | printf(" Priority: %s\n", s ); |
---|
4965 | } |
---|
4966 | #endif /* OS2 */ |
---|
4967 | |
---|
4968 | printf("\n"); |
---|
4969 | #ifdef NETCONN |
---|
4970 | if (!network) { |
---|
4971 | #endif /* NETCONN */ |
---|
4972 | shomdm(); |
---|
4973 | printf("\n"); |
---|
4974 | #ifdef NETCONN |
---|
4975 | } |
---|
4976 | #endif /* NETCONN */ |
---|
4977 | |
---|
4978 | #ifdef COMMENT /* No more space for this! */ |
---|
4979 | #ifndef NODIAL |
---|
4980 | printf("\n"); |
---|
4981 | #ifdef NETCONN |
---|
4982 | if (!network) |
---|
4983 | #endif /* NETCONN */ |
---|
4984 | shodial(); |
---|
4985 | #endif /* NODIAL */ |
---|
4986 | #else |
---|
4987 | #ifndef NODIAL |
---|
4988 | printf("Type SHOW DIAL to see DIAL-related items\n"); |
---|
4989 | #endif /* NODIAL */ |
---|
4990 | #endif /* COMMENT */ |
---|
4991 | break; |
---|
4992 | |
---|
4993 | case SHFIL: /* File parameters */ |
---|
4994 | shoparf(); |
---|
4995 | /* printf("\n"); */ /* (out o' space) */ |
---|
4996 | break; |
---|
4997 | |
---|
4998 | #ifndef NOCSETS |
---|
4999 | case SHLNG: /* Languages */ |
---|
5000 | shoparl(); |
---|
5001 | break; |
---|
5002 | #endif /* NOCSETS */ |
---|
5003 | |
---|
5004 | #ifndef NOSPL |
---|
5005 | case SHSCR: /* Scripts */ |
---|
5006 | printf(" Command Quoting: %s\n", showoff(cmdgquo())); |
---|
5007 | printf(" Take Echo: %s\n", showoff(techo)); |
---|
5008 | printf(" Take Error: %s\n", showoff(takerr[cmdlvl])); |
---|
5009 | printf(" Macro Echo: %s\n", showoff(mecho)); |
---|
5010 | printf(" Macro Error: %s\n", showoff(merror[cmdlvl])); |
---|
5011 | printf(" Input Case: %s\n", inpcas[cmdlvl] ? |
---|
5012 | "Observe" : "Ignore"); |
---|
5013 | printf(" Input Buffer-length: %d\n", inbufsize); |
---|
5014 | printf(" Input Echo: %s\n", showoff(inecho)); |
---|
5015 | printf(" Input Silence: %d (seconds)\n", insilence); |
---|
5016 | printf(" Input Timeout: %s\n", intime[cmdlvl] ? |
---|
5017 | "quit" : "proceed"); |
---|
5018 | if (instatus < 0) |
---|
5019 | printf(" Last INPUT: -1 (INPUT command not yet given)\n"); |
---|
5020 | else |
---|
5021 | printf(" Last INPUT: %d (%s)\n", instatus,i_text[instatus]); |
---|
5022 | printf(" Output Pacing: %d (milliseconds)\n",pacing); |
---|
5023 | #ifndef NOSCRIPT |
---|
5024 | printf(" Script Echo: %s\n", showoff(secho)); |
---|
5025 | #endif /* NOSCRIPT */ |
---|
5026 | printf(" Command buffer: %d\n", CMDBL); |
---|
5027 | printf(" Atom buffer: %d\n", ATMBL); |
---|
5028 | |
---|
5029 | break; |
---|
5030 | #endif /* NOSPL */ |
---|
5031 | |
---|
5032 | #ifndef NOXMIT |
---|
5033 | case SHXMI: |
---|
5034 | printf(" File type: %s\n", binary ? "binary" : "text"); |
---|
5035 | #ifndef OS2 |
---|
5036 | printf(" See SHOW CHARACTER-SETS for character-set info\n"); |
---|
5037 | #else /* OS2 */ |
---|
5038 | #ifndef NOCSETS |
---|
5039 | shotcs(tcsl,tcsr); |
---|
5040 | #endif /* NOCSETS */ |
---|
5041 | #endif /* OS2 */ |
---|
5042 | printf(" Terminal echo: %s\n", duplex ? "local" : "remote"); |
---|
5043 | printf(" Transmit EOF: "); |
---|
5044 | if (*xmitbuf == NUL) { |
---|
5045 | printf("none\n"); |
---|
5046 | } else { |
---|
5047 | char *p; |
---|
5048 | p = xmitbuf; |
---|
5049 | while (*p) { |
---|
5050 | if (*p < SP) |
---|
5051 | printf("^%c",ctl(*p)); |
---|
5052 | else |
---|
5053 | printf("%c",*p); |
---|
5054 | p++; |
---|
5055 | } |
---|
5056 | printf("\n"); |
---|
5057 | } |
---|
5058 | if (xmitf) |
---|
5059 | printf(" Transmit Fill: %d (fill character for blank lines)\n", |
---|
5060 | xmitf); |
---|
5061 | else |
---|
5062 | printf(" Transmit Fill: none\n"); |
---|
5063 | printf(" Transmit Linefeed: %s\n", |
---|
5064 | xmitl ? "on (send linefeeds too)" : "off"); |
---|
5065 | if (xmitp) |
---|
5066 | printf(" Transmit Prompt: %d (host line end character)\n",xmitp); |
---|
5067 | else |
---|
5068 | printf(" Transmit Prompt: none\n"); |
---|
5069 | printf(" Transmit Echo: %s\n", showoff(xmitx)); |
---|
5070 | printf(" Transmit Locking-Shift: %s\n", showoff(xmits)); |
---|
5071 | printf(" Transmit Pause: %d milliseconds\n", xmitw); |
---|
5072 | break; |
---|
5073 | #endif /* NOXMIT */ |
---|
5074 | |
---|
5075 | #ifndef NODIAL |
---|
5076 | case SHMOD: /* SHOW MODEM */ |
---|
5077 | shomodem(); /* Show SET MODEM items */ |
---|
5078 | break; |
---|
5079 | #endif /* NODIAL */ |
---|
5080 | |
---|
5081 | #ifndef MAC |
---|
5082 | case SHDFLT: |
---|
5083 | zsyscmd(PWDCMD); |
---|
5084 | break; |
---|
5085 | #endif /* MAC */ |
---|
5086 | |
---|
5087 | #ifndef NOLOCAL |
---|
5088 | case SHESC: |
---|
5089 | printf(" Escape character: Ctrl-%c (ASCII %d, %s): %s\r\n", |
---|
5090 | ctl(escape), escape, (escape == 127 ? "DEL" : ccntab[escape]), |
---|
5091 | nm[tt_escape] |
---|
5092 | ); |
---|
5093 | break; |
---|
5094 | #endif /* NOLOCAL */ |
---|
5095 | |
---|
5096 | #ifndef NODIAL |
---|
5097 | case SHDIA: /* SHOW DIAL */ |
---|
5098 | shmdmlin(); |
---|
5099 | printf(", speed: "); |
---|
5100 | if ((zz = ttgspd()) < 0) { |
---|
5101 | printf("unknown"); |
---|
5102 | } else { |
---|
5103 | if (zz == 8880) printf("75/1200"); else printf("%ld",zz); |
---|
5104 | } |
---|
5105 | if (carrier == CAR_OFF) s = "off"; |
---|
5106 | else if (carrier == CAR_ON) s = "on"; |
---|
5107 | else if (carrier == CAR_AUT) s = "auto"; |
---|
5108 | else s = "unknown"; |
---|
5109 | printf(", carrier: %s", s); |
---|
5110 | if (carrier == CAR_ON) { |
---|
5111 | if (cdtimo) printf(", timeout: %d sec", cdtimo); |
---|
5112 | else printf(", timeout: none"); |
---|
5113 | } |
---|
5114 | printf("\n"); |
---|
5115 | doshodial(); |
---|
5116 | if (local |
---|
5117 | #ifdef NETCONN |
---|
5118 | && !network |
---|
5119 | #endif /* NETCONN */ |
---|
5120 | ) { |
---|
5121 | printf("Type SHOW MODEM to see modem settings.\n"); |
---|
5122 | printf("Type SHOW COMMUNICATIONS to see modem signals.\n"); |
---|
5123 | } |
---|
5124 | break; |
---|
5125 | #endif /* NODIAL */ |
---|
5126 | |
---|
5127 | #ifdef CK_LABELED |
---|
5128 | case SHLBL: /* Labeled file info */ |
---|
5129 | sholbl(); |
---|
5130 | break; |
---|
5131 | #endif /* CK_LABELED */ |
---|
5132 | |
---|
5133 | case SHCSE: /* Character sets */ |
---|
5134 | #ifdef NOCSETS |
---|
5135 | printf( |
---|
5136 | " Character set translation is not supported in this version of C-Kermit\n"); |
---|
5137 | #else |
---|
5138 | shocharset(); |
---|
5139 | printf("\n Unknown-Char-Set: %s\n", |
---|
5140 | unkcs ? "Keep" : "Discard"); |
---|
5141 | #ifdef OS2 |
---|
5142 | printf("\n"); |
---|
5143 | #endif /* OS2 */ |
---|
5144 | shotcs(tcsl,tcsr); |
---|
5145 | printf("\n"); |
---|
5146 | #endif /* NOCSETS */ |
---|
5147 | break; |
---|
5148 | |
---|
5149 | #ifndef NOFRILLS |
---|
5150 | case SHFEA: /* Features */ |
---|
5151 | shofea(); |
---|
5152 | break; |
---|
5153 | #endif /* NOFRILLS */ |
---|
5154 | |
---|
5155 | #ifdef CK_SPEED |
---|
5156 | case SHCTL: /* Control-Prefix table */ |
---|
5157 | shoctl(); |
---|
5158 | break; |
---|
5159 | #endif /* CK_SPEED */ |
---|
5160 | |
---|
5161 | case SHEXI: |
---|
5162 | printf("\n Exit warning %s\n", xitwarn ? |
---|
5163 | (xitwarn == 1 ? "on" : "always") : "off"); |
---|
5164 | printf(" Exit on-disconnect: %s\n", showoff(exitonclose)); |
---|
5165 | printf(" Current exit status: %d\n\n", xitsta); |
---|
5166 | break; |
---|
5167 | |
---|
5168 | case SHPRT: |
---|
5169 | printf("Printer: %s%s\n", |
---|
5170 | printpipe ? "| " : "", |
---|
5171 | printfile ? printfile : |
---|
5172 | #ifdef OS2 |
---|
5173 | "PRN" |
---|
5174 | #else |
---|
5175 | "(default)" |
---|
5176 | #endif /* OS2 */ |
---|
5177 | ); |
---|
5178 | break; |
---|
5179 | |
---|
5180 | case SHCMD: |
---|
5181 | printf(" Command bytesize: %d bits\n", |
---|
5182 | (cmdmsk == 0377) ? 8 : 7); |
---|
5183 | #ifdef CK_RECALL |
---|
5184 | printf(" Command recall-buffer-size: %d\n",cm_recall); |
---|
5185 | #else |
---|
5186 | printf(" Command recall-buffer not available in this version\n"); |
---|
5187 | #endif /* CK_RECALL */ |
---|
5188 | #ifdef CK_RECALL |
---|
5189 | printf(" Command retry: %s\n",cm_retry ? "on" : "off"); |
---|
5190 | #else |
---|
5191 | printf(" Command retry not available in this version\n"); |
---|
5192 | #endif /* CK_RECALL */ |
---|
5193 | printf(" Command quoting: %s\n", showoff(cmdgquo())); |
---|
5194 | printf(" Command more-prompting: %s\n", showoff(xaskmore)); |
---|
5195 | printf(" Command height: %d\n", cmd_rows); |
---|
5196 | printf(" Command width: %d\n", cmd_cols); |
---|
5197 | printf(" Maximum command length: %d\n", CMDBL); |
---|
5198 | #ifndef NOSPL |
---|
5199 | printf(" Maximum number of macros: %d\n", MAC_MAX); |
---|
5200 | printf(" Macros defined: %d\n", nmac); |
---|
5201 | printf(" Maximum macro depth: %d\n", MACLEVEL); |
---|
5202 | printf(" Maximum TAKE depth: %d\n", MAXTAKE); |
---|
5203 | #endif /* NOSPL */ |
---|
5204 | #ifdef UNIX |
---|
5205 | #ifndef NOJC |
---|
5206 | printf(" Suspend: %s\n", showoff(suspend)); |
---|
5207 | #endif /* NOJC */ |
---|
5208 | #endif /* UNIX */ |
---|
5209 | break; |
---|
5210 | |
---|
5211 | #ifndef NOSPL |
---|
5212 | case SHALRM: |
---|
5213 | if (ck_alarm) |
---|
5214 | printf("Alarm at %s %s\n",alrm_date,alrm_time); |
---|
5215 | else |
---|
5216 | printf("(no alarm set)\n"); |
---|
5217 | break; |
---|
5218 | #endif /* NOSPL */ |
---|
5219 | |
---|
5220 | #ifndef NOMSEND |
---|
5221 | case SHSFL: { |
---|
5222 | extern struct filelist * filehead; |
---|
5223 | if (!filehead) { |
---|
5224 | printf("send-list is empty\n"); |
---|
5225 | } else { |
---|
5226 | struct filelist * flp; |
---|
5227 | char * s; |
---|
5228 | flp = filehead; |
---|
5229 | while (flp) { |
---|
5230 | s = flp->fl_alias; |
---|
5231 | if (!s) s = "(none)"; |
---|
5232 | printf("%s, mode: %s, alias: %s\n", |
---|
5233 | flp->fl_name, |
---|
5234 | gfmode(flp->fl_mode), |
---|
5235 | s |
---|
5236 | ); |
---|
5237 | flp = flp->fl_next; |
---|
5238 | } |
---|
5239 | } |
---|
5240 | } |
---|
5241 | break; |
---|
5242 | |
---|
5243 | #endif /* NOMSEND */ |
---|
5244 | |
---|
5245 | default: |
---|
5246 | printf("\nNothing to show...\n"); |
---|
5247 | return(-2); |
---|
5248 | } |
---|
5249 | return(success = 1); |
---|
5250 | } |
---|
5251 | #endif /* NOSHOW */ |
---|
5252 | |
---|
5253 | VOID |
---|
5254 | shmdmlin() { /* Briefly show modem & line */ |
---|
5255 | #ifndef NODIAL |
---|
5256 | int i; |
---|
5257 | #ifndef MINIDIAL |
---|
5258 | #ifdef OLDTBCODE |
---|
5259 | extern int tbmodel; |
---|
5260 | _PROTOTYP( char * gtbmodel, (void) ); |
---|
5261 | #endif /* OLDTBCODE */ |
---|
5262 | #endif /* MINIDIAL */ |
---|
5263 | #endif /* NODIAL */ |
---|
5264 | if (local) |
---|
5265 | #ifdef OS2 |
---|
5266 | printf(" Port: %s, Modem type: ",ttname); |
---|
5267 | #else |
---|
5268 | printf(" Line: %s, Modem type: ",ttname); |
---|
5269 | #endif /* OS2 */ |
---|
5270 | else |
---|
5271 | printf( |
---|
5272 | #ifdef OS2 |
---|
5273 | " Communication device not yet selected with SET PORT\n Modem type: " |
---|
5274 | #else |
---|
5275 | " Communication device not yet selected with SET LINE\n Modem type: " |
---|
5276 | #endif /* OS2 */ |
---|
5277 | ); |
---|
5278 | #ifndef NODIAL |
---|
5279 | printf("%s",gmdmtyp()); |
---|
5280 | #ifndef MINIDIAL |
---|
5281 | #ifdef OLDTBCODE |
---|
5282 | if (tbmodel) printf(" (%s)",gtbmodel()); /* Telebit model info */ |
---|
5283 | #endif /* OLDTBCODE */ |
---|
5284 | #endif /* MINIDIAL */ |
---|
5285 | #else |
---|
5286 | printf("(disabled)"); |
---|
5287 | #endif /* NODIAL */ |
---|
5288 | } |
---|
5289 | |
---|
5290 | #ifdef GEMDOS |
---|
5291 | isxdigit(c) int c; { |
---|
5292 | return(isdigit(c) || |
---|
5293 | (c >= 'a' && c <= 'f') || |
---|
5294 | (c >= 'A' && c <= 'F')); |
---|
5295 | } |
---|
5296 | #endif /* GEMDOS */ |
---|
5297 | |
---|
5298 | #ifndef NOSHOW |
---|
5299 | #ifndef NOSPL |
---|
5300 | int /* SHO MACROS */ |
---|
5301 | shomac(s1, s2) char *s1, *s2; { |
---|
5302 | int x, n, pp; |
---|
5303 | pp = 0; /* Parenthesis counter */ |
---|
5304 | |
---|
5305 | if (!s1) |
---|
5306 | return(0); |
---|
5307 | else |
---|
5308 | printf("\n%s = ",s1); /* Print blank line and macro name */ |
---|
5309 | slc++; /* Count the line */ |
---|
5310 | n = (int)strlen(s1) + 4; /* Width of current line */ |
---|
5311 | if (!s2) s2 = "(null definition)"; |
---|
5312 | |
---|
5313 | while (x = *s2++) { /* Loop thru definition */ |
---|
5314 | if (x == '(') pp++; /* Treat commas within parens */ |
---|
5315 | if (x == ')') pp--; /* as ordinary text */ |
---|
5316 | if (pp < 0) pp = 0; /* Outside parens, */ |
---|
5317 | if (x == ',' && pp == 0) { /* comma becomes comma-dash-NL. */ |
---|
5318 | putchar(','); |
---|
5319 | putchar('-'); |
---|
5320 | x = '\n'; |
---|
5321 | } |
---|
5322 | putchar(x); /* Output the character */ |
---|
5323 | if (x == '\n') { /* If it was a newline */ |
---|
5324 | #ifdef UNIX |
---|
5325 | #ifdef NOSETBUF |
---|
5326 | fflush(stdout); |
---|
5327 | #endif /* NOSETBUF */ |
---|
5328 | #endif /* UNIX */ |
---|
5329 | putchar(' '); /* Indent the next line 1 space */ |
---|
5330 | while(*s2 == ' ') s2++; /* skip past leading blanks */ |
---|
5331 | n = 2; /* restart the character counter */ |
---|
5332 | slc++; /* and increment the line counter. */ |
---|
5333 | } else if (++n > (cmd_cols - 1)) { /* If line is too wide */ |
---|
5334 | putchar('-'); /* output a dash */ |
---|
5335 | putchar(NL); /* and a newline */ |
---|
5336 | #ifdef UNIX |
---|
5337 | #ifdef NOSETBUF |
---|
5338 | fflush(stdout); |
---|
5339 | #endif /* NOSETBUF */ |
---|
5340 | #endif /* UNIX */ |
---|
5341 | n = 1; /* and restart the char counter */ |
---|
5342 | slc++; /* and increment the line counter */ |
---|
5343 | } |
---|
5344 | if (n < 3 && slc > (cmd_rows - 3)) { /* If new line and screen full */ |
---|
5345 | if (!askmore()) return(-1); /* ask if they want more. */ |
---|
5346 | n = 1; /* They do, start a new line */ |
---|
5347 | slc = 0; /* and restart line counter */ |
---|
5348 | } |
---|
5349 | } |
---|
5350 | putchar(NL); /* End of definition */ |
---|
5351 | if (++slc > (cmd_rows - 3)) { |
---|
5352 | if (!askmore()) return(-1); |
---|
5353 | slc = 0; |
---|
5354 | } |
---|
5355 | return(0); |
---|
5356 | } |
---|
5357 | #endif /* NOSPL */ |
---|
5358 | #endif /* NOSHOW */ |
---|
5359 | |
---|
5360 | #ifndef NOSHOW |
---|
5361 | int |
---|
5362 | shoatt() { |
---|
5363 | printf("Attributes: %s\n", showoff(atcapr)); |
---|
5364 | if (!atcapr) return(0); |
---|
5365 | printf(" Blocksize: %s\n", showoff(atblki)); |
---|
5366 | printf(" Date: %s\n", showoff(atdati)); |
---|
5367 | printf(" Disposition: %s\n", showoff(atdisi)); |
---|
5368 | printf(" Encoding (Character Set): %s\n", showoff(atenci)); |
---|
5369 | printf(" Length: %s\n", showoff(atleni)); |
---|
5370 | printf(" Type (text/binary): %s\n", showoff(attypi)); |
---|
5371 | printf(" System ID: %s\n", showoff(atsidi)); |
---|
5372 | printf(" System Info: %s\n", showoff(atsysi)); |
---|
5373 | #ifdef STRATUS |
---|
5374 | printf(" Format: %s\n", showoff(atfrmi)); |
---|
5375 | printf(" Creator: %s\n", showoff(atcrei)); |
---|
5376 | printf(" Account: %s\n", showoff(atacti)); |
---|
5377 | #endif /* STRATUS */ |
---|
5378 | return(0); |
---|
5379 | } |
---|
5380 | #endif /* NOSHOW */ |
---|
5381 | |
---|
5382 | int x_ifnum = 0; /* Flag for IF NUMERIC active */ |
---|
5383 | |
---|
5384 | #ifndef NOSPL |
---|
5385 | /* Evaluate an arithmetic expression. */ |
---|
5386 | /* Code adapted from ev, by Howie Kaye of Columbia U & others. */ |
---|
5387 | |
---|
5388 | static int xerror; |
---|
5389 | static char *cp; |
---|
5390 | static long tokval; |
---|
5391 | static char curtok; |
---|
5392 | static long expval; |
---|
5393 | |
---|
5394 | #define LONGBITS (8*sizeof (long)) |
---|
5395 | #define NUMBER 'N' |
---|
5396 | #define N_EOT 'E' |
---|
5397 | |
---|
5398 | /* |
---|
5399 | Replacement for strchr() and index(), neither of which seem to be universal. |
---|
5400 | */ |
---|
5401 | |
---|
5402 | static char * |
---|
5403 | #ifdef CK_ANSIC |
---|
5404 | windex(char * s, char c) |
---|
5405 | #else |
---|
5406 | windex(s,c) char *s, c; |
---|
5407 | #endif /* CK_ANSIC */ |
---|
5408 | /* windex */ { |
---|
5409 | while (*s != NUL && *s != c) s++; |
---|
5410 | if (*s == c) return(s); else return(NULL); |
---|
5411 | } |
---|
5412 | |
---|
5413 | /* |
---|
5414 | g e t t o k |
---|
5415 | |
---|
5416 | Returns the next token. If token is a NUMBER, sets tokval appropriately. |
---|
5417 | */ |
---|
5418 | static char |
---|
5419 | gettok() { |
---|
5420 | |
---|
5421 | while (isspace(*cp)) /* Skip past leading spaces */ |
---|
5422 | cp++; |
---|
5423 | |
---|
5424 | switch (*cp) { |
---|
5425 | case '$': /* ??? */ |
---|
5426 | case '+': /* Add */ |
---|
5427 | case '-': /* Subtract or Negate */ |
---|
5428 | case '@': /* Greatest Common Divisor */ |
---|
5429 | case '*': /* Multiply */ |
---|
5430 | case '/': /* Divide */ |
---|
5431 | case '%': /* Modulus */ |
---|
5432 | case '<': /* Left shift */ |
---|
5433 | case '>': /* Right shift */ |
---|
5434 | case '&': /* And */ |
---|
5435 | case '|': /* Or */ |
---|
5436 | case '#': /* Exclusive Or */ |
---|
5437 | case '~': /* Not */ |
---|
5438 | case '^': /* Exponent */ |
---|
5439 | case '!': /* Factorial */ |
---|
5440 | case '(': /* Parens for grouping */ |
---|
5441 | case ')': return(*cp++); /* operator, just return it */ |
---|
5442 | case '\n': |
---|
5443 | case '\0': return(N_EOT); /* End of line, return that */ |
---|
5444 | } |
---|
5445 | if (isxdigit(*cp)) { /* Digit, must be a number */ |
---|
5446 | char tbuf[80],*tp; /* Buffer to accumulate number */ |
---|
5447 | int radix = 10; /* Default radix */ |
---|
5448 | for (tp = tbuf; isxdigit(*cp); cp++) |
---|
5449 | *tp++ = (char) (isupper(*cp) ? tolower(*cp) : *cp); |
---|
5450 | *tp = '\0'; /* End number */ |
---|
5451 | switch(isupper(*cp) ? tolower(*cp) : *cp) { /* Examine break char */ |
---|
5452 | case 'h': |
---|
5453 | case 'x': radix = 16; cp++; break; /* if radix signifier... */ |
---|
5454 | case 'o': |
---|
5455 | case 'q': radix = 8; cp++; break; |
---|
5456 | case 't': radix = 2; cp++; break; |
---|
5457 | } |
---|
5458 | for (tp = tbuf, tokval = 0; *tp != '\0'; tp++) { |
---|
5459 | int dig; |
---|
5460 | dig = *tp - '0'; /* Convert number */ |
---|
5461 | if (dig > 10) dig -= 'a'-'0'-10; |
---|
5462 | if (dig >= radix) { |
---|
5463 | xerror = 1; |
---|
5464 | if (cmdlvl == 0 && !x_ifnum) |
---|
5465 | printf("invalid digit '%c' in number\n",*tp); |
---|
5466 | return(NUMBER); |
---|
5467 | } |
---|
5468 | tokval = radix*tokval + dig; |
---|
5469 | } |
---|
5470 | return(NUMBER); |
---|
5471 | } |
---|
5472 | if (cmdlvl == 0 && !x_ifnum) |
---|
5473 | printf("Invalid character '%c' in input\n",*cp); |
---|
5474 | xerror = 1; |
---|
5475 | cp++; |
---|
5476 | return(gettok()); |
---|
5477 | } |
---|
5478 | |
---|
5479 | static long |
---|
5480 | #ifdef CK_ANSIC |
---|
5481 | expon(long x, long y) |
---|
5482 | #else |
---|
5483 | expon(x,y) long x,y; |
---|
5484 | #endif /* CK_ANSIC */ |
---|
5485 | /* expon */ { |
---|
5486 | long result = 1; |
---|
5487 | int sign = 1; |
---|
5488 | if (y < 0) return(0); |
---|
5489 | if (x < 0) { |
---|
5490 | x = -x; |
---|
5491 | if (y & 1) sign = -1; |
---|
5492 | } |
---|
5493 | while (y != 0) { |
---|
5494 | if (y & 1) result *= x; |
---|
5495 | y >>= 1; |
---|
5496 | if (y != 0) x *= x; |
---|
5497 | } |
---|
5498 | return(result * sign); |
---|
5499 | } |
---|
5500 | |
---|
5501 | /* |
---|
5502 | * factor ::= simple | simple ^ factor |
---|
5503 | * |
---|
5504 | */ |
---|
5505 | _PROTOTYP( static VOID simple, (void) ); |
---|
5506 | |
---|
5507 | static VOID |
---|
5508 | factor() { |
---|
5509 | long oldval; |
---|
5510 | simple(); |
---|
5511 | if (curtok == '^') { |
---|
5512 | oldval = expval; |
---|
5513 | curtok = gettok(); |
---|
5514 | factor(); |
---|
5515 | expval = expon(oldval,expval); |
---|
5516 | } |
---|
5517 | } |
---|
5518 | |
---|
5519 | /* |
---|
5520 | * termp ::= NULL | {*,/,%,&} factor termp |
---|
5521 | * |
---|
5522 | */ |
---|
5523 | static VOID |
---|
5524 | termp() { |
---|
5525 | while (curtok == '*' || curtok == '/' || curtok == '%' || curtok == '&') { |
---|
5526 | long oldval; |
---|
5527 | char op; |
---|
5528 | op = curtok; |
---|
5529 | curtok = gettok(); /* skip past operator */ |
---|
5530 | oldval = expval; |
---|
5531 | factor(); |
---|
5532 | switch(op) { |
---|
5533 | case '*': expval = oldval * expval; break; |
---|
5534 | case '/': |
---|
5535 | if (expval == 0) expval = -1; /* don't divide by 0 */ |
---|
5536 | else expval = oldval / expval; break; |
---|
5537 | case '%': expval = oldval % expval; break; |
---|
5538 | case '&': expval = oldval & expval; break; |
---|
5539 | } |
---|
5540 | } |
---|
5541 | } |
---|
5542 | |
---|
5543 | static long |
---|
5544 | #ifdef CK_ANSIC |
---|
5545 | fact(long x) |
---|
5546 | #else |
---|
5547 | fact(x) long x; |
---|
5548 | #endif /* CK_ANSIC */ |
---|
5549 | /* fact */ { /* factorial */ |
---|
5550 | long result = 1; |
---|
5551 | while (x > 1) |
---|
5552 | result *= x--; |
---|
5553 | return(result); |
---|
5554 | } |
---|
5555 | |
---|
5556 | /* |
---|
5557 | * term ::= factor termp |
---|
5558 | * |
---|
5559 | */ |
---|
5560 | static VOID |
---|
5561 | term() { |
---|
5562 | factor(); |
---|
5563 | termp(); |
---|
5564 | } |
---|
5565 | |
---|
5566 | static long |
---|
5567 | #ifdef CK_ANSIC |
---|
5568 | gcd(long x, long y) |
---|
5569 | #else |
---|
5570 | gcd(x,y) long x,y; |
---|
5571 | #endif /* CK_ANSIC */ |
---|
5572 | /* gcd */ { /* Greatest Common Divisor */ |
---|
5573 | int nshift = 0; |
---|
5574 | if (x < 0) x = -x; |
---|
5575 | if (y < 0) y = -y; /* validate arguments */ |
---|
5576 | if (x == 0 || y == 0) return(x + y); /* this is bogus */ |
---|
5577 | |
---|
5578 | while (!((x & 1) | (y & 1))) { /* get rid of powers of 2 */ |
---|
5579 | nshift++; |
---|
5580 | x >>= 1; |
---|
5581 | y >>= 1; |
---|
5582 | } |
---|
5583 | while (x != 1 && y != 1 && x != 0 && y != 0) { |
---|
5584 | while (!(x & 1)) x >>= 1; /* eliminate unnecessary */ |
---|
5585 | while (!(y & 1)) y >>= 1; /* powers of 2 */ |
---|
5586 | if (x < y) { /* force x to be larger */ |
---|
5587 | long t; |
---|
5588 | t = x; |
---|
5589 | x = y; |
---|
5590 | y = t; |
---|
5591 | } |
---|
5592 | x -= y; |
---|
5593 | } |
---|
5594 | if (x == 0 || y == 0) return((x + y) << nshift); /* gcd is non-zero one */ |
---|
5595 | else return((long) 1 << nshift); /* else gcd is 1 */ |
---|
5596 | } |
---|
5597 | |
---|
5598 | /* |
---|
5599 | * exprp ::= NULL | {+,-,|,...} term exprp |
---|
5600 | * |
---|
5601 | */ |
---|
5602 | static VOID |
---|
5603 | exprp() { |
---|
5604 | while (windex("+-|<>#@",curtok) != NULL) { |
---|
5605 | long oldval; |
---|
5606 | char op; |
---|
5607 | op = curtok; |
---|
5608 | curtok = gettok(); /* skip past operator */ |
---|
5609 | oldval = expval; |
---|
5610 | term(); |
---|
5611 | switch(op) { |
---|
5612 | case '+' : expval = oldval + expval; break; |
---|
5613 | case '-' : expval = oldval - expval; break; |
---|
5614 | case '|' : expval = oldval | expval; break; |
---|
5615 | case '#' : expval = oldval ^ expval; break; |
---|
5616 | case '@' : expval = gcd(oldval,expval); break; |
---|
5617 | case '<' : expval = oldval << expval; break; |
---|
5618 | case '>' : expval = oldval >> expval; break; |
---|
5619 | } |
---|
5620 | } |
---|
5621 | } |
---|
5622 | |
---|
5623 | /* |
---|
5624 | * expr ::= term exprp |
---|
5625 | * |
---|
5626 | */ |
---|
5627 | static VOID |
---|
5628 | expr() { |
---|
5629 | term(); |
---|
5630 | exprp(); |
---|
5631 | } |
---|
5632 | |
---|
5633 | static long |
---|
5634 | xparse() { |
---|
5635 | curtok = gettok(); |
---|
5636 | expr(); |
---|
5637 | #ifdef COMMENT |
---|
5638 | if (curtok == '$') { |
---|
5639 | curtok = gettok(); |
---|
5640 | if (curtok != NUMBER) { |
---|
5641 | if (cmdlvl == 0 && !x_ifnum) |
---|
5642 | printf("illegal radix\n"); |
---|
5643 | return(0); |
---|
5644 | } |
---|
5645 | curtok = gettok(); |
---|
5646 | } |
---|
5647 | #endif /* COMMENT */ |
---|
5648 | if (curtok != N_EOT) { |
---|
5649 | if (cmdlvl == 0 && !x_ifnum) |
---|
5650 | printf("extra characters after expression\n"); |
---|
5651 | xerror = 1; |
---|
5652 | } |
---|
5653 | return(expval); |
---|
5654 | } |
---|
5655 | |
---|
5656 | char * |
---|
5657 | evala(s) char *s; { |
---|
5658 | char *p; /* Return pointer */ |
---|
5659 | long v; /* Numeric value */ |
---|
5660 | |
---|
5661 | if (!s) return(""); |
---|
5662 | xerror = 0; /* Start out with no error */ |
---|
5663 | cp = s; /* Make the argument global */ |
---|
5664 | v = xparse(); /* Parse the string */ |
---|
5665 | p = numbuf; /* Convert long number to string */ |
---|
5666 | sprintf(p,"%ld",v); |
---|
5667 | return(xerror ? "" : p); /* Return empty string on error */ |
---|
5668 | } |
---|
5669 | |
---|
5670 | /* |
---|
5671 | * simplest ::= NUMBER | ( expr ) |
---|
5672 | * |
---|
5673 | */ |
---|
5674 | static VOID |
---|
5675 | simplest() { |
---|
5676 | if (curtok == NUMBER) expval = tokval; |
---|
5677 | else if (curtok == '(') { |
---|
5678 | curtok = gettok(); /* skip over paren */ |
---|
5679 | expr(); |
---|
5680 | if (curtok != ')') { |
---|
5681 | if (cmdlvl == 0 && !x_ifnum) |
---|
5682 | printf("missing right parenthesis\n"); |
---|
5683 | xerror = 1; |
---|
5684 | } |
---|
5685 | } else { |
---|
5686 | if (cmdlvl == 0 && !x_ifnum) |
---|
5687 | printf("operator unexpected\n"); |
---|
5688 | xerror = 1; |
---|
5689 | } |
---|
5690 | curtok = gettok(); |
---|
5691 | } |
---|
5692 | |
---|
5693 | /* |
---|
5694 | * simpler ::= simplest | simplest ! |
---|
5695 | * |
---|
5696 | */ |
---|
5697 | static VOID |
---|
5698 | simpler() { |
---|
5699 | simplest(); |
---|
5700 | if (curtok == '!') { |
---|
5701 | curtok = gettok(); |
---|
5702 | expval = fact(expval); |
---|
5703 | } |
---|
5704 | } |
---|
5705 | |
---|
5706 | /* |
---|
5707 | * simple ::= {-,~} simpler | simpler |
---|
5708 | * |
---|
5709 | */ |
---|
5710 | |
---|
5711 | static VOID |
---|
5712 | simple() { |
---|
5713 | if (curtok == '-' || curtok == '~') { |
---|
5714 | int op = curtok; |
---|
5715 | curtok = gettok(); /* skip over - sign */ |
---|
5716 | simpler(); /* parse the factor again */ |
---|
5717 | expval = op == '-' ? -expval : ~expval; |
---|
5718 | } else simpler(); |
---|
5719 | } |
---|
5720 | #endif /* NOSPL */ |
---|
5721 | |
---|
5722 | #ifndef NOSPL |
---|
5723 | /* D C L A R R A Y -- Declare an array */ |
---|
5724 | |
---|
5725 | int /* Declare an array of size n */ |
---|
5726 | #ifdef CK_ANSIC |
---|
5727 | dclarray(char a, int n) |
---|
5728 | #else |
---|
5729 | dclarray(a,n) char a; int n; |
---|
5730 | #endif /* CK_ANSIC */ |
---|
5731 | /* dclarray */ { |
---|
5732 | char **p; int i, n2; |
---|
5733 | |
---|
5734 | if (a > 63 && a < 91) a += 32; /* Convert letters to lowercase */ |
---|
5735 | if (a < ARRAYBASE || a > 122) /* Verify name */ |
---|
5736 | return(-1); |
---|
5737 | a -= ARRAYBASE; /* Convert name to number */ |
---|
5738 | if ((p = a_ptr[a]) != NULL) { /* Delete old array of same name */ |
---|
5739 | n2 = a_dim[a]; |
---|
5740 | for (i = 0; i <= n2; i++) { /* First delete its elements */ |
---|
5741 | if (p[i]) { |
---|
5742 | free(p[i]); |
---|
5743 | p[i] = NULL; |
---|
5744 | } |
---|
5745 | } |
---|
5746 | free(a_ptr[a]); /* Then the element list */ |
---|
5747 | a_ptr[a] = (char **) NULL; /* Remove pointer to element list */ |
---|
5748 | a_dim[a] = 0; /* Set dimension at zero. */ |
---|
5749 | } |
---|
5750 | if (n == 0) return(0); /* If dimension 0, just deallocate. */ |
---|
5751 | |
---|
5752 | p = (char **) malloc((n+1) * sizeof(char **)); /* Allocate for new array */ |
---|
5753 | if (p == NULL) return(-1); /* Check */ |
---|
5754 | a_ptr[a] = p; /* Save pointer to member list */ |
---|
5755 | a_dim[a] = n; /* Save dimension */ |
---|
5756 | for (i = 0; i <= n; i++) /* Initialize members to null */ |
---|
5757 | p[i] = NULL; |
---|
5758 | return(0); |
---|
5759 | } |
---|
5760 | |
---|
5761 | /* A R R A Y N A M -- Parse an array name */ |
---|
5762 | |
---|
5763 | /* |
---|
5764 | Call with pointer to string that starts with the array reference. |
---|
5765 | String may begin with either \& or just &. |
---|
5766 | On success, |
---|
5767 | Returns letter ID (always lowercase) in argument c, |
---|
5768 | which can also be accent grave (` = 96; '@' is converted to grave); |
---|
5769 | Dimension or subscript in argument n; |
---|
5770 | IMPORTANT: These arguments must be provided by the caller as addresses |
---|
5771 | of ints (not chars), for example: |
---|
5772 | char *s; int x, y; |
---|
5773 | arraynam(s,&x,&y); |
---|
5774 | On failure, returns a negative number, with args n and c set to zero. |
---|
5775 | */ |
---|
5776 | int |
---|
5777 | arraynam(ss,c,n) char *ss; int *c; int *n; { |
---|
5778 | int i, y, pp; |
---|
5779 | char x; |
---|
5780 | char *s, *p, *sx, *vnp; |
---|
5781 | /* On stack to allow for recursive calls... */ |
---|
5782 | char vnbuf[ARRAYREFLEN+1]; /* Entire array reference */ |
---|
5783 | char ssbuf[ARRAYREFLEN+1]; /* Subscript in "plain text" */ |
---|
5784 | char sxbuf[16]; /* Evaluated subscript */ |
---|
5785 | |
---|
5786 | *c = *n = 0; /* Initialize return values */ |
---|
5787 | for (i = 0; i < (int)strlen(ss); i++) /* Check length */ |
---|
5788 | if (ss[i] == ']') |
---|
5789 | break; |
---|
5790 | if (i > ARRAYREFLEN) { |
---|
5791 | printf("?Array reference too long - %s\n",ss); |
---|
5792 | return(-9); |
---|
5793 | } |
---|
5794 | strncpy(vnbuf,ss,ARRAYREFLEN); |
---|
5795 | vnp = vnbuf; |
---|
5796 | if (vnbuf[0] == CMDQ && vnbuf[1] == '&') vnp++; |
---|
5797 | if (*vnp != '&') { |
---|
5798 | printf("?Not an array - %s\n",vnbuf); |
---|
5799 | return(-9); |
---|
5800 | } |
---|
5801 | x = *(vnp + 1); /* Fold case of array name */ |
---|
5802 | /* We don't use isupper & tolower here on purpose because these */ |
---|
5803 | /* would produce undesired effects with accented letters. */ |
---|
5804 | if (x > 63 && x < 91) x = *(vnp + 1) = (char) (x + 32); |
---|
5805 | if ((x < ARRAYBASE) || (x > 122) || (*(vnp+2) != '[')) { |
---|
5806 | printf("?Invalid format for array name - %s\n",vnbuf); |
---|
5807 | return(-9); |
---|
5808 | } |
---|
5809 | *c = x; /* Return the array name */ |
---|
5810 | s = vnp+3; /* Get dimension */ |
---|
5811 | p = ssbuf; |
---|
5812 | pp = 1; /* Bracket counter */ |
---|
5813 | for (i = 0; i < ARRAYREFLEN && *s != NUL; i++) { /* Copy up to ] */ |
---|
5814 | if (*s == '[') pp++; |
---|
5815 | if (*s == ']' && --pp == 0) break; |
---|
5816 | *p++ = *s++; |
---|
5817 | } |
---|
5818 | if (*s != ']') { |
---|
5819 | printf("?No closing bracket on array dimension - %s\n",vnbuf); |
---|
5820 | return(-9); |
---|
5821 | } |
---|
5822 | *p--; /* Trim whitespace from end */ |
---|
5823 | while (*p == SP || *p == HT) |
---|
5824 | p--; |
---|
5825 | p++; |
---|
5826 | *p = NUL; /* Terminate subscript with null */ |
---|
5827 | p = ssbuf; /* Point to beginning of subscript */ |
---|
5828 | while (*p == SP || *p == HT) /* Trim whitespace from beginning */ |
---|
5829 | p++; |
---|
5830 | sx = sxbuf; /* Where to put expanded subscript */ |
---|
5831 | y = 16; |
---|
5832 | zzstring(p,&sx,&y); /* Convert variables, etc. */ |
---|
5833 | |
---|
5834 | p = evala(sxbuf); /* Run it thru \fneval()... */ |
---|
5835 | if (p) if (*p) strcpy(sxbuf,p); /* We know it has to be a number. */ |
---|
5836 | |
---|
5837 | if (!chknum(sxbuf)) { /* Make sure it's all digits */ |
---|
5838 | printf("?Array dimension or subscript must be numeric - %s\n",sxbuf); |
---|
5839 | return(-9); |
---|
5840 | } |
---|
5841 | if ((y = atoi(sxbuf)) < 0) { |
---|
5842 | if (cmflgs == 0) printf("\n"); |
---|
5843 | printf("?Array dimension or subscript must be positive or zero - %s\n", |
---|
5844 | sxbuf); |
---|
5845 | return(-9); |
---|
5846 | } |
---|
5847 | *n = y; /* Return the subscript or dimension */ |
---|
5848 | return(0); |
---|
5849 | } |
---|
5850 | |
---|
5851 | int |
---|
5852 | chkarray(a,i) int a, i; { /* Check if array is declared */ |
---|
5853 | int x; /* and if subscript is in range */ |
---|
5854 | if (a == 64) a = 96; /* Convert atsign to grave accent */ |
---|
5855 | x = a - ARRAYBASE; /* Values must be in range 95-122 */ |
---|
5856 | if (x < 0 || x > 'z' - ARRAYBASE) /* Not in range */ |
---|
5857 | return(-2); |
---|
5858 | if (a_ptr[x] == NULL) return(-1); /* Not declared */ |
---|
5859 | if (i > a_dim[x]) return(-2); /* Declared but out of range. */ |
---|
5860 | return(a_dim[x]); /* All ok, return dimension */ |
---|
5861 | } |
---|
5862 | |
---|
5863 | #ifdef COMMENT /* This isn't used. */ |
---|
5864 | char * |
---|
5865 | arrayval(a,i) int a, i; { /* Return value of \&a[i] */ |
---|
5866 | int x; char **p; /* (possibly NULL) */ |
---|
5867 | if (a == 64) a = 96; /* Convert atsign to grave accent */ |
---|
5868 | x = a - ARRAYBASE; /* Values must be in range 95-122 */ |
---|
5869 | if (x < 0 || x > 27) return(NULL); /* Not in range */ |
---|
5870 | if ((x > 0) && (p = a_ptr[x]) == NULL) /* Array not declared */ |
---|
5871 | return(NULL); |
---|
5872 | if (i > a_dim[x]) /* Subscript out of range. */ |
---|
5873 | return(NULL); |
---|
5874 | return(p[i]); /* All ok, return pointer to value. */ |
---|
5875 | } |
---|
5876 | #endif /* COMMENT */ |
---|
5877 | #endif /* NOSPL */ |
---|
5878 | |
---|
5879 | #ifndef NOSPL |
---|
5880 | /* P A R S E V A R -- Parse a variable name or array reference. */ |
---|
5881 | /* |
---|
5882 | Call with: |
---|
5883 | s = pointer to candidate variable name or array reference. |
---|
5884 | *c = address of integer in which to return variable ID. |
---|
5885 | *i = address of integer in which to return array subscript. |
---|
5886 | Returns: |
---|
5887 | -2: syntax error in variable name or array reference. |
---|
5888 | 1: successful parse of a simple variable, with ID in c. |
---|
5889 | 2: successful parse of an array reference, w/ID in c and subscript in i. |
---|
5890 | */ |
---|
5891 | int |
---|
5892 | parsevar(s,c,i) char *s; int *c, *i; { |
---|
5893 | char *p; |
---|
5894 | int x,y,z; |
---|
5895 | |
---|
5896 | p = s; |
---|
5897 | if (*s == CMDQ) s++; /* Point after backslash */ |
---|
5898 | |
---|
5899 | if (*s != '%' && *s != '&') { /* Make sure it's % or & */ |
---|
5900 | printf("?Not a variable name - %s\n",p); |
---|
5901 | return(-9); |
---|
5902 | } |
---|
5903 | if ((int)strlen(s) < 2) { |
---|
5904 | printf("?Incomplete variable name - %s\n",p); |
---|
5905 | return(-9); |
---|
5906 | } |
---|
5907 | if (*s == '%' && *(s+2) != '\0') { |
---|
5908 | printf("?Only one character after '%%' in variable name, please\n"); |
---|
5909 | return(-9); |
---|
5910 | } |
---|
5911 | if (*s == '&' && *(s+2) != '[') { |
---|
5912 | printf("?Array subscript expected - %s\n",p); |
---|
5913 | return(-9); |
---|
5914 | } |
---|
5915 | if (*s == '%') { /* Simple variable. */ |
---|
5916 | y = *(s+1); /* Get variable ID letter/char */ |
---|
5917 | if (isupper(y)) y -= ('a'-'A'); /* Convert upper to lower case */ |
---|
5918 | *c = y; /* Set the return values. */ |
---|
5919 | *i = -1; /* No array subscript. */ |
---|
5920 | return(1); /* Return 1 = simple variable */ |
---|
5921 | } |
---|
5922 | if (*s == '&') { /* Array reference. */ |
---|
5923 | if (arraynam(s,&x,&z) < 0) { /* Go parse it. */ |
---|
5924 | printf("?Invalid array reference - %s\n",p); |
---|
5925 | return(-9); |
---|
5926 | } |
---|
5927 | if (chkarray(x,z) < 0) { /* Check if declared, etc. */ |
---|
5928 | printf("?Array not declared or subscript out of range\n"); |
---|
5929 | return(-9); |
---|
5930 | } |
---|
5931 | *c = x; /* Return array letter */ |
---|
5932 | *i = z; /* and subscript. */ |
---|
5933 | return(2); |
---|
5934 | } |
---|
5935 | return(-2); /* None of the above. */ |
---|
5936 | } |
---|
5937 | |
---|
5938 | #define VALN 20 |
---|
5939 | |
---|
5940 | /* Get the numeric value of a variable */ |
---|
5941 | /* |
---|
5942 | Call with pointer to variable name, pointer to int for return value. |
---|
5943 | Returns: |
---|
5944 | 0 on success with second arg containing the value. |
---|
5945 | -1 on failure (bad variable syntax, variable not defined or not numeric). |
---|
5946 | */ |
---|
5947 | int |
---|
5948 | varval(s,v) char *s; int *v; { |
---|
5949 | char valbuf[VALN+1]; /* s is pointer to variable name */ |
---|
5950 | char name[256]; |
---|
5951 | char *p; |
---|
5952 | int y; |
---|
5953 | |
---|
5954 | if (*s != CMDQ) { /* Handle macro names too */ |
---|
5955 | sprintf(name,"\\m(%s)", s); |
---|
5956 | s = name; |
---|
5957 | } |
---|
5958 | p = valbuf; /* Expand variable into valbuf. */ |
---|
5959 | y = VALN; |
---|
5960 | if (zzstring(s,&p,&y) < 0) return(-1); |
---|
5961 | p = valbuf; /* Make sure value is numeric */ |
---|
5962 | if (chknum(p)) { /* Convert numeric string to int */ |
---|
5963 | *v = atoi(p); /* OK */ |
---|
5964 | } else { /* Not OK */ |
---|
5965 | p = evala(p); /* Maybe it's an expression */ |
---|
5966 | if (!chknum(p)) /* Did it evaluate? */ |
---|
5967 | return(-1); /* No, failure. */ |
---|
5968 | else /* Yes, */ |
---|
5969 | *v = atoi(p); /* success */ |
---|
5970 | } |
---|
5971 | return(0); |
---|
5972 | } |
---|
5973 | |
---|
5974 | /* Increment or decrement a variable */ |
---|
5975 | /* Returns -1 on failure, 0 on success */ |
---|
5976 | |
---|
5977 | int |
---|
5978 | incvar(s,x,z) char *s; int x; int z; { /* Increment a numeric variable */ |
---|
5979 | char valbuf[VALN+1]; /* s is pointer to variable name */ |
---|
5980 | /* x is amount to increment by */ |
---|
5981 | int n; /* z != 0 means add */ |
---|
5982 | /* z = 0 means subtract */ |
---|
5983 | |
---|
5984 | if (varval(s,&n) < 0) /* Convert numeric string to int */ |
---|
5985 | return(-1); |
---|
5986 | if (z) /* Increment it by the given amount */ |
---|
5987 | n += x; |
---|
5988 | else /* or decrement as requested. */ |
---|
5989 | n -= x; |
---|
5990 | sprintf(valbuf,"%d",n); /* Convert back to numeric string */ |
---|
5991 | addmac(s,valbuf); /* Replace old variable */ |
---|
5992 | return(0); |
---|
5993 | } |
---|
5994 | #endif /* NOSPL */ |
---|
5995 | |
---|
5996 | /* Functions moved here from ckuusr.c to even out the module sizes... */ |
---|
5997 | |
---|
5998 | /* |
---|
5999 | Breaks up string s -- IN PLACE! -- into a list of up to max words. |
---|
6000 | Pointers to each word go into the array list[]. |
---|
6001 | max is the maximum number of words (pointers). |
---|
6002 | If list is NULL, then they are added to the macro table. |
---|
6003 | flag = 0 means the last field is to be one word, like all the other fields, |
---|
6004 | so anything after it is discarded. |
---|
6005 | flag = 1 means the last field extends to the end of the string, even if |
---|
6006 | there are lots of words left, so the last field contains the |
---|
6007 | remainder of the string. |
---|
6008 | */ |
---|
6009 | VOID |
---|
6010 | xwords(s,max,list,flag) char *s; int max; char *list[]; int flag; { |
---|
6011 | char *p; |
---|
6012 | int b, i, k, y, z; |
---|
6013 | #ifndef NOSPL |
---|
6014 | int macro; |
---|
6015 | macro = (list == NULL); |
---|
6016 | debug(F101,"xwords macro","",macro); |
---|
6017 | #endif /* NOSPL */ |
---|
6018 | |
---|
6019 | #ifdef XWORDSDEBUG |
---|
6020 | printf("XWORDS max=%d\n",max); |
---|
6021 | #endif /* XWORDSDEBUG */ |
---|
6022 | p = s; /* Pointer to beginning of string */ |
---|
6023 | b = 0; /* Flag for outer brace removal */ |
---|
6024 | k = 0; /* Flag for in-word */ |
---|
6025 | y = 0; /* Brace nesting level */ |
---|
6026 | z = 0; /* "Word" counter, 0 thru max */ |
---|
6027 | |
---|
6028 | if (list) |
---|
6029 | for (i = 0; i <= max; i++) /* Initialize pointers */ |
---|
6030 | list[i] = NULL; |
---|
6031 | |
---|
6032 | if (flag) max--; |
---|
6033 | |
---|
6034 | while (1) { /* Go thru word list */ |
---|
6035 | if (!s || (*s == '\0')) { /* No more characters? */ |
---|
6036 | if (k != 0) { /* Was I in a word? */ |
---|
6037 | if (z == max) break; /* Yes, only go up to max. */ |
---|
6038 | z++; /* Count this word. */ |
---|
6039 | #ifdef XWORDSDEBUG |
---|
6040 | printf("1 z++ = %d\n", z); |
---|
6041 | #endif /* XWORDSDEBUG */ |
---|
6042 | #ifndef NOSPL |
---|
6043 | if (macro) { /* Doing macro args */ |
---|
6044 | varnam[1] = (char) (z + '0'); /* Assign last argument */ |
---|
6045 | addmac(varnam,p); |
---|
6046 | } else { /* Not doing macro args */ |
---|
6047 | #endif /* NOSPL */ |
---|
6048 | list[z] = p; /* Assign pointer. */ |
---|
6049 | #ifdef XWORDSDEBUG |
---|
6050 | printf("[1]LIST[%d]=\"%s\"\n",z,list[z]); |
---|
6051 | #endif /* XWORDSDEBUG */ |
---|
6052 | #ifndef NOSPL |
---|
6053 | } |
---|
6054 | #endif /* NOSPL */ |
---|
6055 | break; /* And get out. */ |
---|
6056 | } else break; /* Was not in a word */ |
---|
6057 | } |
---|
6058 | if (k == 0 && (*s == SP || *s == HT)) { /* Eat leading blanks */ |
---|
6059 | s++; |
---|
6060 | continue; |
---|
6061 | } else if (*s == '{') { /* An opening brace */ |
---|
6062 | if (k == 0 && y == 0) { /* If leading brace */ |
---|
6063 | p = s+1; /* point past it */ |
---|
6064 | b = 1; /* and flag that we did this */ |
---|
6065 | } |
---|
6066 | k = 1; /* Flag that we're in a word */ |
---|
6067 | y++; /* Count the brace. */ |
---|
6068 | } else if (*s == '}') { /* A closing brace. */ |
---|
6069 | y--; /* Count it. */ |
---|
6070 | if (y == 0 && b != 0) { /* If it matches the leading brace */ |
---|
6071 | *s = SP; /* change it to a space */ |
---|
6072 | b = 0; /* and we're not in braces any more */ |
---|
6073 | } else if (y < 0) k = 1; /* otherwise just start a new word. */ |
---|
6074 | } else if (*s != SP && *s != HT) { /* Nonspace means we're in a word */ |
---|
6075 | if (k == 0) { /* If we weren't in a word before, */ |
---|
6076 | p = s; /* Mark the beginning */ |
---|
6077 | if (flag && z == max) { /* Want last word to be remainder? */ |
---|
6078 | z++; |
---|
6079 | #ifdef XWORDSDEBUG |
---|
6080 | printf("1 z++ = %d\n", z); |
---|
6081 | #endif /* XWORDSDEBUG */ |
---|
6082 | list[z] = p; /* Yes, point to it */ |
---|
6083 | #ifdef XWORDSDEBUG |
---|
6084 | printf("[4]LIST[%d]=\"%s\"\n",z,list[z]); |
---|
6085 | #endif /* XWORDSDEBUG */ |
---|
6086 | break; /* and quit */ |
---|
6087 | } |
---|
6088 | k = 1; /* Set in-word flag */ |
---|
6089 | } |
---|
6090 | } |
---|
6091 | /* If we're not inside a braced quantity, and we are in a word, and */ |
---|
6092 | /* we have hit whitespace, then we have a word. */ |
---|
6093 | if ((y < 1) && (k != 0) && (*s == SP || *s == HT)) { |
---|
6094 | if (!flag || z < max) /* if we don't want to keep rest */ |
---|
6095 | *s = '\0'; /* terminate the arg with null */ |
---|
6096 | k = 0; /* say we're not in a word any more */ |
---|
6097 | y = 0; /* start braces off clean again */ |
---|
6098 | if (z == max) break; /* Only go up to max. */ |
---|
6099 | z++; /* count this arg */ |
---|
6100 | #ifdef XWORDSDEBUG |
---|
6101 | printf("1 z++ = %d\n", z); |
---|
6102 | #endif /* XWORDSDEBUG */ |
---|
6103 | |
---|
6104 | #ifndef NOSPL |
---|
6105 | if (macro) { |
---|
6106 | varnam[1] = (char) (z + '0'); /* compute its name */ |
---|
6107 | addmac(varnam,p); /* add it to the macro table */ |
---|
6108 | } else { |
---|
6109 | #endif /* NOSPL */ |
---|
6110 | list[z] = p; |
---|
6111 | #ifdef XWORDSDEBUG |
---|
6112 | printf("[2]LIST[%d]=\"%s\"\n",z,list[z]); |
---|
6113 | #endif /* XWORDSDEBUG */ |
---|
6114 | #ifndef NOSPL |
---|
6115 | } |
---|
6116 | #endif /* NOSPL */ |
---|
6117 | p = s+1; |
---|
6118 | } |
---|
6119 | s++; /* Point past this character */ |
---|
6120 | } |
---|
6121 | if ((z == 0) && (y > 1)) { /* Extra closing brace(s) at end */ |
---|
6122 | z++; |
---|
6123 | #ifndef NOSPL |
---|
6124 | if (macro) { |
---|
6125 | varnam[1] = z + '0'; /* compute its name */ |
---|
6126 | addmac(varnam,p); /* Add rest of line to last arg */ |
---|
6127 | } else { |
---|
6128 | #endif /* NOSPL */ |
---|
6129 | list[z] = p; |
---|
6130 | #ifdef XWORDSDEBUG |
---|
6131 | printf("[3]LIST[%d]=\"%s\"\n",z,list[z]); |
---|
6132 | #endif /* XWORDSDEBUG */ |
---|
6133 | #ifndef NOSPL |
---|
6134 | } |
---|
6135 | #endif /* NOSPL */ |
---|
6136 | } |
---|
6137 | #ifndef NOSPL |
---|
6138 | if (macro) |
---|
6139 | macargc[maclvl] = z + 1; /* Set \v(argc) variable */ |
---|
6140 | #endif /* NOSPL */ |
---|
6141 | return; |
---|
6142 | } |
---|
6143 | |
---|
6144 | #ifndef NOSPL |
---|
6145 | /* D O D O -- Do a macro */ |
---|
6146 | |
---|
6147 | /* |
---|
6148 | Call with x = macro table index, s = pointer to arguments. |
---|
6149 | Returns 0 on failure, 1 on success. |
---|
6150 | */ |
---|
6151 | |
---|
6152 | int |
---|
6153 | dodo(x,s,flags) int x; char *s; int flags; { |
---|
6154 | int y; |
---|
6155 | |
---|
6156 | debug(F101,"dodo maclvl","",maclvl); |
---|
6157 | if (++maclvl > MACLEVEL) { /* Make sure we have storage */ |
---|
6158 | debug(F101,"dodo maclvl too deep","",maclvl); |
---|
6159 | --maclvl; |
---|
6160 | printf("Macros nested too deeply\n"); |
---|
6161 | return(0); |
---|
6162 | } |
---|
6163 | macp[maclvl] = mactab[x].mval; /* Point to the macro body */ |
---|
6164 | macx[maclvl] = mactab[x].mval; /* Remember where the beginning is */ |
---|
6165 | debug(F111,"do macro",macp[maclvl],maclvl); |
---|
6166 | |
---|
6167 | cmdlvl++; /* Entering a new command level */ |
---|
6168 | if (cmdlvl > CMDSTKL) { /* Too many macros + TAKE files? */ |
---|
6169 | debug(F101,"dodo cmdlvl too deep","",cmdlvl); |
---|
6170 | cmdlvl--; |
---|
6171 | printf("?TAKE files and DO commands nested too deeply\n"); |
---|
6172 | return(0); |
---|
6173 | } |
---|
6174 | #ifdef VMS |
---|
6175 | conres(); /* So Ctrl-C, etc, will work. */ |
---|
6176 | #endif /* VMS */ |
---|
6177 | ifcmd[cmdlvl] = 0; |
---|
6178 | iftest[cmdlvl] = 0; |
---|
6179 | count[cmdlvl] = count[cmdlvl-1]; /* Inherit COUNT from previous level */ |
---|
6180 | intime[cmdlvl] = intime[cmdlvl-1]; /* Inherit previous INPUT TIMEOUT */ |
---|
6181 | inpcas[cmdlvl] = inpcas[cmdlvl-1]; /* and INPUT CASE */ |
---|
6182 | takerr[cmdlvl] = takerr[cmdlvl-1]; /* and TAKE ERROR */ |
---|
6183 | merror[cmdlvl] = merror[cmdlvl-1]; /* and MACRO ERROR */ |
---|
6184 | cmdstk[cmdlvl].src = CMD_MD; /* Say we're in a macro */ |
---|
6185 | cmdstk[cmdlvl].lvl = maclvl; /* and remember the macro level */ |
---|
6186 | cmdstk[cmdlvl].ccflgs = flags; /* set flags */ |
---|
6187 | mrval[maclvl] = NULL; /* Initialize return value */ |
---|
6188 | |
---|
6189 | debug(F110,"do macro",mactab[x].kwd,0); |
---|
6190 | |
---|
6191 | /* Clear old %0..%9 arguments */ |
---|
6192 | |
---|
6193 | addmac("%0",mactab[x].kwd); /* Define %0 = name of macro */ |
---|
6194 | varnam[0] = '%'; |
---|
6195 | varnam[2] = '\0'; |
---|
6196 | for (y = 1; y < 10; y++) { /* Clear args %1..%9 */ |
---|
6197 | varnam[1] = (char) (y + '0'); |
---|
6198 | delmac(varnam); |
---|
6199 | } |
---|
6200 | |
---|
6201 | /* Assign the new args one word per arg, allowing braces to group words */ |
---|
6202 | |
---|
6203 | xwords(s,9,NULL,0); |
---|
6204 | return(1); |
---|
6205 | } |
---|
6206 | |
---|
6207 | /* Insert "literal" quote around each comma-separated command to prevent */ |
---|
6208 | /* its premature expansion. Only do this if object command is surrounded */ |
---|
6209 | /* by braces. */ |
---|
6210 | |
---|
6211 | static char* flit = "\\flit("; |
---|
6212 | |
---|
6213 | int |
---|
6214 | litcmd(src,dest) char **src, **dest; { |
---|
6215 | int bc = 0, pp = 0; |
---|
6216 | char *s, *lp, *ss; |
---|
6217 | char * ppp; |
---|
6218 | |
---|
6219 | s = *src; |
---|
6220 | lp = *dest; |
---|
6221 | ppp = *dest; |
---|
6222 | |
---|
6223 | debug(F110,"litcmd",s,0); |
---|
6224 | |
---|
6225 | while (*s == SP) s++; /* strip extra leading spaces */ |
---|
6226 | debug(F110,"litcmd2",s,0); |
---|
6227 | |
---|
6228 | if (*s == '{') { |
---|
6229 | |
---|
6230 | pp = 0; /* paren counter */ |
---|
6231 | bc = 1; /* count leading brace */ |
---|
6232 | *lp++ = *s++; /* copy it */ |
---|
6233 | debug(F110,"litcmd3",s,0); |
---|
6234 | while (*s == SP) s++; /* strip interior leading spaces */ |
---|
6235 | debug(F110,"litcmd4",s,0); |
---|
6236 | ss = flit; /* point to "\flit(" */ |
---|
6237 | while (*lp++ = *ss++); /* copy it */ |
---|
6238 | |
---|
6239 | debug(F110,"litcmd5",s,0); |
---|
6240 | |
---|
6241 | lp--; /* back up over null */ |
---|
6242 | |
---|
6243 | while (*s) { /* go thru rest of text */ |
---|
6244 | ss = flit; /* point back to start of "\flit(" */ |
---|
6245 | if (*s == '{') bc++; /* count brackets */ |
---|
6246 | if (*s == '(') pp++; /* and parens */ |
---|
6247 | if (*s == ')') pp--; |
---|
6248 | if (*s == '}') { /* Closing brace. */ |
---|
6249 | if (--bc == 0) { /* Final one? */ |
---|
6250 | *lp++ = ')'; /* Add closing paren for "\flit()" */ |
---|
6251 | *lp++ = *s++; |
---|
6252 | break; |
---|
6253 | } |
---|
6254 | } |
---|
6255 | *lp = NUL; |
---|
6256 | debug(F110,"litcmd6",s,0); |
---|
6257 | |
---|
6258 | #ifdef COMMENT |
---|
6259 | /* This was from before \flit() stopped breaking on commas... */ |
---|
6260 | if (*s == ',' && pp == 0) { /* comma not inside of parens */ |
---|
6261 | *lp++ = ')'; /* closing ) of \flit( */ |
---|
6262 | *lp++ = ','; /* insert the comma */ |
---|
6263 | while (*lp++ = *ss++); /* start new "\flit(" */ |
---|
6264 | lp--; /* back up over null */ |
---|
6265 | s++; /* skip over comma in source string */ |
---|
6266 | while (*s++ == SP); /* eat leading spaces again. */ |
---|
6267 | s--; /* back up over nonspace */ |
---|
6268 | continue; |
---|
6269 | } |
---|
6270 | #endif /* COMMENT */ |
---|
6271 | *lp++ = *s++; /* Copy anything but comma here. */ |
---|
6272 | } |
---|
6273 | *lp = NUL; |
---|
6274 | debug(F110,"litcmd7",s,0); |
---|
6275 | |
---|
6276 | } else { /* No brackets around, */ |
---|
6277 | while (*lp++ = *s++) /* just copy. */ |
---|
6278 | ; |
---|
6279 | lp--; |
---|
6280 | debug(F110,"litcmd8",s,0); |
---|
6281 | } |
---|
6282 | debug(F110,"litcmd9",s,0); |
---|
6283 | |
---|
6284 | *src = s; |
---|
6285 | *dest = lp; |
---|
6286 | if (bc) return(-1); |
---|
6287 | else return(0); |
---|
6288 | } |
---|
6289 | #endif /* NOSPL */ |
---|
6290 | |
---|
6291 | int |
---|
6292 | docd() { /* Do the CD command */ |
---|
6293 | int x; |
---|
6294 | extern int quiet; |
---|
6295 | char *s; |
---|
6296 | #ifdef MAC |
---|
6297 | char temp[34]; |
---|
6298 | #endif /* MAC */ |
---|
6299 | |
---|
6300 | #ifdef GEMDOS |
---|
6301 | if ((x = cmdir("Name of local directory, or carriage return",homdir,&s, |
---|
6302 | NULL)) < 0 ) |
---|
6303 | return(x); |
---|
6304 | #else |
---|
6305 | #ifdef OS2 |
---|
6306 | if ((x = cmdir("Name of PC disk and/or directory,\n\ |
---|
6307 | or press the Enter key for the default",homdir,&s, |
---|
6308 | xxstring)) < 0 ) |
---|
6309 | return(x); |
---|
6310 | #else |
---|
6311 | #ifdef MAC |
---|
6312 | strncpy(temp,homdir,32); |
---|
6313 | x = strlen(temp); |
---|
6314 | if (x > 0) if (temp[x-1] != ':') { temp[x] = ':'; temp[x+1] = NUL; } |
---|
6315 | if ((x = cmtxt("Name of Macintosh volume and/or folder,\n\ |
---|
6316 | or press the Return key for the desktop on the boot disk", |
---|
6317 | temp,&s, xxstring)) < 0 ) |
---|
6318 | return(x); |
---|
6319 | #else |
---|
6320 | if ((x = cmdir("Name of local directory, or carriage return",homdir,&s, |
---|
6321 | xxstring)) < 0 ) |
---|
6322 | return(x); |
---|
6323 | #endif /* MAC */ |
---|
6324 | #endif /* OS2 */ |
---|
6325 | #endif /* GEMDOS */ |
---|
6326 | #ifndef MAC |
---|
6327 | if (x == 2) { |
---|
6328 | printf("?Wildcards not allowed in directory name\n"); |
---|
6329 | return(-9); |
---|
6330 | } |
---|
6331 | #endif /* MAC */ |
---|
6332 | strcpy(line,s); /* Make a safe copy */ |
---|
6333 | s = line; |
---|
6334 | #ifndef MAC |
---|
6335 | if ((x = cmcfm()) < 0) /* Get confirmation */ |
---|
6336 | return(x); |
---|
6337 | #endif /* MAC */ |
---|
6338 | |
---|
6339 | #ifdef datageneral |
---|
6340 | x = strlen(line); /* homdir ends in colon, */ |
---|
6341 | if (line[x-1] == ':') /* and "dir" doesn't like that... */ |
---|
6342 | line[x-1] = NUL; |
---|
6343 | #endif /* datageneral */ |
---|
6344 | |
---|
6345 | #ifdef MAC |
---|
6346 | cwdf = 1; |
---|
6347 | if (! zchdir(s)) { |
---|
6348 | cwdf = 0; |
---|
6349 | if (*s != ':') { /* If it failed, */ |
---|
6350 | char *p; /* supply leading colon */ |
---|
6351 | p = malloc((int)strlen(s) + 2); /* and try again... */ |
---|
6352 | if (p) { |
---|
6353 | strcpy(p,":"); |
---|
6354 | strcat(p,s); |
---|
6355 | if (zchdir(p)) |
---|
6356 | cwdf = 1; |
---|
6357 | free(p); |
---|
6358 | p = NULL; |
---|
6359 | } |
---|
6360 | } |
---|
6361 | } |
---|
6362 | if (!cwdf) |
---|
6363 | perror(s); |
---|
6364 | #else |
---|
6365 | if (! zchdir(s)) { |
---|
6366 | cwdf = 0; |
---|
6367 | perror(s); |
---|
6368 | } else cwdf = 1; |
---|
6369 | #endif /* MAC */ |
---|
6370 | if (!quiet && |
---|
6371 | #ifndef NOSPL |
---|
6372 | cmdlvl == 0 |
---|
6373 | #else |
---|
6374 | tlevel == -1 |
---|
6375 | #endif /* NOSPL */ |
---|
6376 | ) |
---|
6377 | printf("%s\n", zgtdir()); |
---|
6378 | return(cwdf); |
---|
6379 | } |
---|
6380 | |
---|
6381 | VOID |
---|
6382 | fixcmd() { /* Fix command parser after interruption */ |
---|
6383 | dostop(); /* Back to top level (also calls conint()). */ |
---|
6384 | bgchk(); /* Check background status */ |
---|
6385 | if (*psave) { /* If old prompt saved, */ |
---|
6386 | cmsetp(psave); /* restore it. */ |
---|
6387 | *psave = NUL; |
---|
6388 | } |
---|
6389 | success = 0; /* Tell parser last command failed */ |
---|
6390 | } |
---|
6391 | |
---|
6392 | int |
---|
6393 | prtopt(lines,s) int * lines; char *s; { /* Print an option */ |
---|
6394 | static int x = 0; /* (used by SHOW FEATURES) */ |
---|
6395 | int y, i; /* Does word wrap. */ |
---|
6396 | if (!s) { x = 0; return(1); } /* Call with null pointer to */ |
---|
6397 | y = (int)strlen(s) + 1; /* reset horizontal position. */ |
---|
6398 | i = *lines; |
---|
6399 | x += y; |
---|
6400 | if ( |
---|
6401 | #ifdef OS2 |
---|
6402 | x > ((cmd_cols > 40) ? (cmd_cols - 1) : 79) |
---|
6403 | #else /* OS2 */ |
---|
6404 | x > ((tt_cols > 40) ? (tt_cols - 1) : 79) |
---|
6405 | #endif /* OS2 */ |
---|
6406 | ) { |
---|
6407 | printf("\n"); |
---|
6408 | if (++i > (cmd_rows - 3)) { |
---|
6409 | if (!askmore()) |
---|
6410 | return(0); |
---|
6411 | else |
---|
6412 | *lines = 0; |
---|
6413 | } |
---|
6414 | printf(" %s",s); |
---|
6415 | x = y; |
---|
6416 | } else printf(" %s",s); |
---|
6417 | return(1); |
---|
6418 | } |
---|
6419 | #endif /* NOICP */ |
---|