![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / lbin / mailx|
Return to lex.c CVS log | Up to [Research Unix] / researchv10no / lbin / mailx |
1.1 root 1: #ident "@(#)lex.c 1.5 'attmail mail(1) command'"
2: #ident "@(#)mailx:lex.c 1.21.3.1"
3: /* Copyright (c) 1984 AT&T */
4: /* All Rights Reserved */
5:
6: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T */
7: /* The copyright notice above does not evidence any */
8: /* actual or intended publication of such source code. */
9:
10: #ident "@(#)mailx:lex.c 1.21.1.1"
11:
12: #include "rcv.h"
13:
14: /*
15: * mailx -- a modified version of a University of California at Berkeley
16: * mail program
17: *
18: * Lexical processing of commands.
19: */
20:
21: #ifdef SIGCONT
22: static void contin();
23: #endif
24: static int isprefix();
25: static struct cmd *lex();
26: static int Passeren();
27: static void setmsize();
28:
29: /*
30: * Set up editing on the given file name.
31: * If isedit is true, we are considered to be editing the file,
32: * otherwise we are reading our mail which has signficance for
33: * mbox and so forth.
34: */
35:
36: setfile(name, isedit)
37: char *name;
38: int isedit;
39: {
40: FILE *ibuf;
41: int i;
42: static int shudclob;
43: static char efile[PATHSIZE];
44: char fortest[128];
45: struct stat stbuf;
46:
47: if ((ibuf = fopen(name, "r")) == NULL) {
48: if (exitflg)
49: exit(1); /* no mail, return error */
50: if (isedit)
51: perror(name);
52: else if (!Hflag) {
53: if (strrchr(name,'/') == NOSTR)
54: fprintf(stderr, "No mail.\n");
55: else
56: fprintf(stderr, "No mail for %s\n", strrchr(name,'/')+1);
57: }
58: return(-1);
59: }
60: fstat(fileno(ibuf), &stbuf);
61: if (stbuf.st_size == 0L) {
62: if (exitflg)
63: exit(1); /* no mail, return error */
64: if (isedit)
65: fprintf(stderr, "%s: empty file\n", name);
66: else if (!Hflag) {
67: if (strrchr(name,'/') == NOSTR)
68: fprintf(stderr, "No mail.\n");
69: else
70: fprintf(stderr, "No mail for %s\n", strrchr(name,'/')+1);
71: }
72: fclose(ibuf);
73: return(-1);
74: }
75:
76: fgets(fortest, sizeof fortest, ibuf);
77: fseek(ibuf, 0L, 0);
78: if (strncmp(fortest, "Forward to ", 11) == 0) {
79: if (exitflg)
80: exit(1); /* no mail, return error */
81: fprintf(stderr, "Your mail is being forwarded to %s", fortest+11);
82: fclose(ibuf);
83: return (-1);
84: }
85: if (exitflg)
86: exit(0); /* there is mail, return success */
87:
88: /*
89: * Looks like all will be well. Must hold signals
90: * while we are reading the new file, else we will ruin
91: * the message[] data structure.
92: * Copy the messages into /tmp and set pointers.
93: */
94:
95: if (shudclob) {
96: holdsigs();
97: if (edit)
98: edstop();
99: else {
100: quit();
101: Verhogen();
102: }
103: relsesigs();
104: }
105:
106: readonly = 0;
107: if (!isedit)
108: readonly = Passeren()==-1;
109: lock(name); /* adb */
110: fstat(fileno(ibuf), &stbuf);
111: utimep->actime = stbuf.st_atime;
112: utimep->modtime = stbuf.st_mtime;
113:
114: holdsigs();
115: if (!readonly)
116: if ((i = open(name, 1)) < 0) /* adb */
117: readonly++;
118: else
119: close(i);
120: if (shudclob) {
121: fclose(itf);
122: fclose(otf);
123: free(message);
124: space=0;
125: }
126: shudclob = 1;
127: edit = isedit;
128: strncpy(efile, name, PATHSIZE);
129: editfile = efile;
130: if (name != mailname)
131: strcpy(mailname, name);
132: mailsize = fsize(ibuf);
133: if ((otf = fopen(tempMesg, "w")) == NULL) {
134: perror(tempMesg);
135: if (!edit)
136: Verhogen();
137: exit(1);
138: }
139: if ((itf = fopen(tempMesg, "r")) == NULL) {
140: perror(tempMesg);
141: if (!edit)
142: Verhogen();
143: exit(1);
144: }
145: removefile(tempMesg);
146: setptr(ibuf);
147: setmsize(msgCount);
148: unlock(); /* adb */
149: fclose(ibuf);
150: relsesigs();
151: sawcom = 0;
152: return(0);
153: }
154:
155: /* semaphore stuff is changed in V9/V10. adb */
156: /* global to semaphores */
157: static char semaphore[128];
158:
159: /*
160: * return -1 if file is already being read, 0 otherwise
161: */
162: static
163: Passeren()
164: {
165: char file[128];
166: struct stat sbuf;
167: FILE *fp;
168: int pid;
169: extern char *getenv();
170: char *home = getenv("HOME");
171:
172: if (home == NULL)
173: return 0;
174: (void)strcpy(file, home);
175: (void)strcat(file, "/.Maillock");
176: if (stat(file, &sbuf) >= 0) {
177:
178: /* lock file exists */
179: fp = fopen(file, "r");
180: if (fp != NULL) {
181: fscanf(fp, "%d", &pid);
182: fclose(fp);
183: }
184: if (fp == NULL || kill(pid, 0)==0) {
185: fprintf(stderr,"WARNING: You are already reading mail.\n");
186: fprintf(stderr, "\tThis instance of mail is read only.\n");
187: return -1;
188: }
189: }
190:
191: /* create a semaphore file */
192: strcpy(semaphore, file);
193: Verhogen();
194: fp = fopen(semaphore, "w");
195: if (fp == NULL)
196: return 0; /* nothing else we can do */
197: fprintf(fp, "%d somewhere", getpid());
198: fclose(fp);
199: return 0;
200: }
201:
202: void
203: Verhogen()
204: {
205: unlink(semaphore);
206: }
207:
208: /*
209: * Interpret user commands one by one. If standard input is not a tty,
210: * print no prompt.
211: */
212:
213: static int *msgvec;
214: static int shudprompt;
215:
216: void
217: commands()
218: {
219: int eofloop;
220: register int n;
221: char linebuf[LINESIZE];
222: struct stat minfo;
223: FILE *ibuf;
224: FILE *lockopen(); /* adb */
225:
226: #ifdef SIGCONT
227: # ifdef preSVr4
228: sigset(SIGCONT, SIG_DFL);
229: # else
230: {
231: struct sigaction nsig;
232: nsig.sa_handler = SIG_DFL;
233: sigemptyset(&nsig.sa_mask);
234: nsig.sa_flags = SA_RESTART;
235: (void) sigaction(SIGCONT, &nsig, (struct sigaction*)0);
236: }
237: # endif
238: #endif
239: if (rcvmode && !sourcing) {
240: if (sigset(SIGINT, SIG_IGN) != (void (*)())SIG_IGN) /* adb */
241: sigset(SIGINT, stop);
242: if (sigset(SIGHUP, SIG_IGN) != (void (*)())SIG_IGN) /* adb */
243: sigset(SIGHUP, hangup);
244: }
245: for (;;) {
246: setjmp(srbuf);
247:
248: /*
249: * Print the prompt, if needed. Clear out
250: * string space, and flush the output.
251: */
252:
253: if (!rcvmode && !sourcing)
254: return;
255: eofloop = 0;
256: top:
257: if ((shudprompt = (intty && !sourcing)) != 0) {
258: if (prompt==NOSTR)
259: prompt = "? ";
260: #ifdef SIGCONT
261: # ifdef preSVr4
262: sigset(SIGCONT, contin);
263: # else
264: {
265: struct sigaction nsig;
266: nsig.sa_handler = contin;
267: sigemptyset(&nsig.sa_mask);
268: nsig.sa_flags = SA_RESTART;
269: (void) sigaction(SIGCONT, &nsig, (struct sigaction*)0);
270: }
271: # endif
272: #endif
273: if (stat(mailname, &minfo) >=0 && minfo.st_size > mailsize) {
274: int OmsgCount, i;
275: OmsgCount = msgCount;
276: fseek(otf, 0L, 2);
277: holdsigs();
278: if ( (ibuf = lockopen(mailname, "r", 0666, -1, -1)) == NULL ) { /* adb */
279: fprintf(stderr,"Can't reopen %s\n",mailname);
280: exit(1);
281: /* NOTREACHED */
282: }
283: fseek(ibuf, mailsize, 0);
284: setptr(ibuf);
285: setmsize(msgCount);
286: stat(mailname, &minfo);
287: mailsize = minfo.st_size;
288: lockclose(ibuf); /* adb */
289: /* unlockmail(); adb */
290: if (msgCount-OmsgCount > 0) {
291: printf("New mail has arrived.\n");
292: printf("Loaded %d new message%s\n",
293: msgCount-OmsgCount,
294: plural(msgCount-OmsgCount));
295: if (value("header") != NOSTR)
296: for (i = OmsgCount+1;
297: i <= msgCount; i++) {
298: printhead(i);
299: sreset();
300: }
301: }
302: relsesigs();
303: }
304: printf("%s", prompt);
305: }
306: flush();
307: sreset();
308:
309: /*
310: * Read a line of commands from the current input
311: * and handle end of file specially.
312: */
313:
314: n = 0;
315: for (;;) {
316: if (readline(input, &linebuf[n]) <= 0) {
317: if (n != 0)
318: break;
319: if (loading)
320: return;
321: if (sourcing) {
322: unstack();
323: goto more;
324: }
325: if (value("ignoreeof") != NOSTR && shudprompt) {
326: if (++eofloop < 25) {
327: printf("Use \"quit\" to quit.\n");
328: goto top;
329: }
330: }
331: if (edit)
332: edstop();
333: return;
334: }
335: if ((n = strlen(linebuf)) == 0)
336: break;
337: n--;
338: if (linebuf[n] != '\\')
339: break;
340: linebuf[n++] = ' ';
341: }
342: #ifdef SIGCONT
343: # ifdef preSVr4
344: sigset(SIGCONT, SIG_DFL);
345: # else
346: {
347: struct sigaction nsig;
348: nsig.sa_handler = SIG_DFL;
349: sigemptyset(&nsig.sa_mask);
350: nsig.sa_flags = SA_RESTART;
351: (void) sigaction(SIGCONT, &nsig, (struct sigaction*)0);
352: }
353: # endif
354: #endif
355: if (execute(linebuf, 0))
356: return;
357: more: ;
358: }
359: }
360:
361: /*
362: * Execute a single command. If the command executed
363: * is "quit," then return non-zero so that the caller
364: * will know to return back to main, if he cares.
365: * Contxt is non-zero if called while composing mail.
366: */
367:
368: execute(linebuf, contxt)
369: char linebuf[];
370: {
371: char word[LINESIZE];
372: char *arglist[MAXARGC];
373: struct cmd *com;
374: register char *cp, *cp2;
375: register int c, e;
376: int muvec[2];
377:
378: /*
379: * Strip the white space away from the beginning
380: * of the command, then scan out a word, which
381: * consists of anything except digits and white space.
382: *
383: * Handle |, ! and # differently to get the correct
384: * lexical conventions.
385: */
386:
387: cp = linebuf;
388: while (any(*cp, " \t"))
389: cp++;
390: cp2 = word;
391: if (any(*cp, "!|#"))
392: *cp2++ = *cp++;
393: else
394: while (*cp && !any(*cp, " \t0123456789$^.:/-+*'\""))
395: *cp2++ = *cp++;
396: *cp2 = '\0';
397:
398: /*
399: * Look up the command; if not found, complain.
400: * Normally, a blank command would map to the
401: * first command in the table; while sourcing,
402: * however, we ignore blank lines to eliminate
403: * confusion.
404: */
405:
406: if (sourcing && equal(word, ""))
407: return(0);
408: com = lex(word);
409: if (com == NONE) {
410: printf("Unknown command: \"%s\"\n", word);
411: if (loading) {
412: cond = CANY;
413: return(1);
414: }
415: if (sourcing) {
416: cond = CANY;
417: unstack();
418: }
419: return(0);
420: }
421:
422: /*
423: * See if we should execute the command -- if a conditional
424: * we always execute it, otherwise, check the state of cond.
425: */
426:
427: if ((com->c_argtype & F) == 0)
428: if (cond == CRCV && !rcvmode || cond == CSEND && rcvmode)
429: return(0);
430:
431: /*
432: * Special case so that quit causes a return to
433: * main, who will call the quit code directly.
434: * If we are in a source file, just unstack.
435: */
436:
437: if (com->c_func == edstop && sourcing) {
438: if (loading)
439: return(1);
440: unstack();
441: return(0);
442: }
443: if (!edit && com->c_func == edstop) {
444: sigset(SIGINT, SIG_IGN);
445: return(1);
446: }
447:
448: /*
449: * Process the arguments to the command, depending
450: * on the type he expects. Default to an error.
451: * If we are sourcing an interactive command, it's
452: * an error.
453: */
454:
455: if (!rcvmode && (com->c_argtype & M) == 0) {
456: printf("May not execute \"%s\" while sending\n",
457: com->c_name);
458: if (loading)
459: return(1);
460: if (sourcing)
461: unstack();
462: return(0);
463: }
464: if (sourcing && com->c_argtype & I) {
465: printf("May not execute \"%s\" while sourcing\n",
466: com->c_name);
467: if (loading)
468: return(1);
469: unstack();
470: return(0);
471: }
472: if (readonly && com->c_argtype & W) {
473: printf("May not execute \"%s\" -- message file is read only\n",
474: com->c_name);
475: if (loading)
476: return(1);
477: if (sourcing)
478: unstack();
479: return(0);
480: }
481: if (contxt && com->c_argtype & R) {
482: printf("Cannot recursively invoke \"%s\"\n", com->c_name);
483: return(0);
484: }
485: e = 1;
486: switch (com->c_argtype & ~(F|P|I|M|T|W|R)) {
487: case MSGLIST:
488: /*
489: * A message list defaulting to nearest forward
490: * legal message.
491: */
492: if (msgvec == 0) {
493: printf("Illegal use of \"message list\"\n");
494: return(-1);
495: }
496: if ((c = getmsglist(cp, msgvec, com->c_msgflag)) < 0)
497: break;
498: if (c == 0)
499: if (msgCount == 0)
500: *msgvec = NULL;
501: else {
502: *msgvec = first(com->c_msgflag,
503: com->c_msgmask);
504: msgvec[1] = NULL;
505: }
506: if (*msgvec == NULL) {
507: printf("No applicable messages\n");
508: break;
509: }
510: e = (*com->c_func)(msgvec);
511: break;
512:
513: case NDMLIST:
514: /*
515: * A message list with no defaults, but no error
516: * if none exist.
517: */
518: if (msgvec == 0) {
519: printf("Illegal use of \"message list\"\n");
520: return(-1);
521: }
522: if (getmsglist(cp, msgvec, com->c_msgflag) < 0)
523: break;
524: e = (*com->c_func)(msgvec);
525: break;
526:
527: case STRLIST:
528: /*
529: * Just the straight string, with
530: * leading blanks removed.
531: */
532: while (any(*cp, " \t"))
533: cp++;
534: e = (*com->c_func)(cp);
535: break;
536:
537: case RAWLIST:
538: /*
539: * A vector of strings, in shell style.
540: */
541: if ((c = getrawlist(cp, arglist)) < 0)
542: break;
543: if (c < com->c_minargs) {
544: printf("%s requires at least %d arg(s)\n",
545: com->c_name, com->c_minargs);
546: break;
547: }
548: if (c > com->c_maxargs) {
549: printf("%s takes no more than %d arg(s)\n",
550: com->c_name, com->c_maxargs);
551: break;
552: }
553: e = (*com->c_func)(arglist);
554: break;
555:
556: case NOLIST:
557: /*
558: * Just the constant zero, for exiting,
559: * eg.
560: */
561: e = (*com->c_func)(0);
562: break;
563:
564: default:
565: panic("Unknown argtype");
566: }
567:
568: /*
569: * Exit the current source file on
570: * error.
571: */
572:
573: if (e && loading)
574: return(1);
575: if (e && sourcing)
576: unstack();
577: if (com->c_func == edstop)
578: return(1);
579: if (value("autoprint") != NOSTR && com->c_argtype & P)
580: if ((dot->m_flag & MDELETED) == 0) {
581: muvec[0] = dot - &message[0] + 1;
582: muvec[1] = 0;
583: type(muvec);
584: }
585: if (!sourcing && (com->c_argtype & T) == 0)
586: sawcom = 1;
587: return(0);
588: }
589:
590: #ifdef SIGCONT
591: /*
592: * When we wake up after ^Z, reprint the prompt.
593: */
594: static void
595: contin()
596: {
597: if (shudprompt)
598: printf("%s", prompt);
599: fflush(stdout);
600: }
601: #endif
602:
603: /*
604: * Branch here on hangup signal and simulate quit.
605: */
606: void
607: hangup()
608: {
609:
610: holdsigs();
611: sigignore(SIGHUP);
612: if (edit) {
613: if (setjmp(srbuf))
614: exit(0);
615: edstop();
616: } else {
617: Verhogen();
618: if (value("exit") != NOSTR)
619: exit(1);
620: else
621: quit();
622: }
623: exit(0);
624: }
625:
626: /*
627: * Set the size of the message vector used to construct argument
628: * lists to message list functions.
629: */
630:
631: static void
632: setmsize(sz)
633: {
634:
635: if (msgvec != (int *) 0)
636: free(msgvec);
637: if (sz < 1)
638: sz = 1; /* need at least one cell for terminating 0 */
639: msgvec = (int *) calloc((unsigned) (sz + 1), sizeof *msgvec);
640: }
641:
642: /*
643: * Find the correct command in the command table corresponding
644: * to the passed command "word"
645: */
646:
647: static struct cmd *
648: lex(word)
649: char word[];
650: {
651: register struct cmd *cp;
652:
653: for (cp = &cmdtab[0]; cp->c_name != NOSTR; cp++)
654: if (isprefix(word, cp->c_name))
655: return(cp);
656: return(NONE);
657: }
658:
659: /*
660: * Determine if as1 is a valid prefix of as2.
661: */
662: static int
663: isprefix(as1, as2)
664: char *as1, *as2;
665: {
666: register char *s1, *s2;
667:
668: s1 = as1;
669: s2 = as2;
670: while (*s1++ == *s2)
671: if (*s2++ == '\0')
672: return(1);
673: return(*--s1 == '\0');
674: }
675:
676: /*
677: * The following gets called on receipt of a rubout. This is
678: * to abort printout of a command, mainly.
679: * Dispatching here when command() is inactive crashes rcv.
680: * Close all open files except 0, 1, 2, and the temporary.
681: * The special call to getuserid() is needed so it won't get
682: * annoyed about losing its open file.
683: * Also, unstack all source files.
684: */
685:
686: static int inithdr; /* am printing startup headers */
687:
688: void
689: stop(s)
690: {
691: register NODE *head;
692:
693: noreset = 0;
694: if (!inithdr)
695: sawcom++;
696: inithdr = 0;
697: while (sourcing)
698: unstack();
699: getuserid((char *) 0);
700: if ( !maxfiles )
701: if ( (maxfiles=ulimit(4, 0)) < 0 )
702: maxfiles = _NFILE;
703: for (head = fplist; head != (NODE *)NULL; head = head->next) {
704: if (head->fp == stdin || head->fp == stdout)
705: continue;
706: if (head->fp == itf || head->fp == otf)
707: continue;
708: if (head->fp == stderr)
709: continue;
710: if (head->fp == pipef) {
711: npclose(pipef);
712: pipef = NULL;
713: continue;
714: }
715: fclose(head->fp);
716: }
717: if (image >= 0) {
718: close(image);
719: image = -1;
720: }
721: clrbuf(stdout);
722: if (s) {
723: printf("Interrupt\n");
724: sigrelse(s);
725: }
726: longjmp(srbuf, 1);
727: }
728:
729: /*
730: * Announce the presence of the current mailx version,
731: * give the message count, and print a header listing.
732: */
733:
734: static char *greeting = "%s Type ? for help.\n";
735:
736: void
737: announce()
738: {
739: int vec[2], mdot;
740:
741: if (!Hflag && value("quiet")==NOSTR)
742: printf(greeting, version);
743: mdot = newfileinfo();
744: vec[0] = mdot;
745: vec[1] = 0;
746: dot = &message[mdot - 1];
747: if (msgCount > 0 && !noheader) {
748: inithdr++;
749: headers(vec);
750: inithdr = 0;
751: }
752: }
753:
754: /*
755: * Announce information about the file we are editing.
756: * Return a likely place to set dot.
757: */
758: newfileinfo()
759: {
760: register struct message *mp;
761: register int u, n, mdot, d, s;
762: char fname[BUFSIZ], zname[BUFSIZ], *ename;
763:
764: if (Hflag)
765: return(1);
766: for (mp = &message[0]; mp < &message[msgCount]; mp++)
767: if (mp->m_flag & MNEW)
768: break;
769: if (mp >= &message[msgCount])
770: for (mp = &message[0]; mp < &message[msgCount]; mp++)
771: if ((mp->m_flag & MREAD) == 0)
772: break;
773: if (mp < &message[msgCount])
774: mdot = mp - &message[0] + 1;
775: else
776: mdot = 1;
777: s = d = 0;
778: for (mp = &message[0], n = 0, u = 0; mp < &message[msgCount]; mp++) {
779: if (mp->m_flag & MNEW)
780: n++;
781: if ((mp->m_flag & MREAD) == 0)
782: u++;
783: if (mp->m_flag & MDELETED)
784: d++;
785: if (mp->m_flag & MSAVED)
786: s++;
787: }
788: ename=origname;
789: if (getfold(fname) >= 0) {
790: strcat(fname, "/");
791: if (strncmp(fname, mailname, strlen(fname)) == 0) {
792: sprintf(zname, "+%s", mailname + strlen(fname));
793: ename = zname;
794: }
795: }
796: printf("\"%s\": ", ename);
797: if (msgCount == 1)
798: printf("1 message");
799: else
800: printf("%d messages", msgCount);
801: if (n > 0)
802: printf(" %d new", n);
803: if (u-n > 0)
804: printf(" %d unread", u);
805: if (d > 0)
806: printf(" %d deleted", d);
807: if (s > 0)
808: printf(" %d saved", s);
809: if (readonly)
810: printf(" [Read only]");
811: printf("\n");
812: return(mdot);
813: }
814:
815: /*
816: * Print the current version number.
817: */
818:
819: pversion(e)
820: char *e;
821: {
822: (void) e;
823: printf("%s\n", version);
824: return(0);
825: }
826:
827: /*
828: * Load a file of user definitions.
829: */
830: void
831: load(name)
832: char *name;
833: {
834: register FILE *in, *oldin;
835:
836: if ((in = fopen(name, "r")) == NULL)
837: return;
838: oldin = input;
839: input = in;
840: loading = 1;
841: sourcing = 1;
842: commands();
843: loading = 0;
844: sourcing = 0;
845: input = oldin;
846: fclose(in);
847: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.