![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / ex|
Return to ex_io.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / ex |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char *sccsid = "@(#)ex_io.c 7.17 (Berkeley) 1/2/88";
9: #endif not lint
10:
11: #include "ex.h"
12: #include "ex_argv.h"
13: #include "ex_temp.h"
14: #include "ex_tty.h"
15: #include "ex_vis.h"
16: #include <sys/file.h>
17: #include <sys/exec.h>
18: #include "pathnames.h"
19:
20: /*
21: * File input/output, source, preserve and recover
22: */
23:
24: /*
25: * Following remember where . was in the previous file for return
26: * on file switching.
27: */
28: int altdot;
29: int oldadot;
30: bool wasalt;
31: short isalt;
32:
33: long cntch; /* Count of characters on unit io */
34: #ifndef VMUNIX
35: short cntln; /* Count of lines " */
36: #else
37: int cntln;
38: #endif
39: long cntnull; /* Count of nulls " */
40: long cntodd; /* Count of non-ascii characters " */
41:
42: #ifdef FLOCKFILE
43: /*
44: * The alternate, saved and current file are locked the extent of the
45: * time that they are active. If the saved file is exchanged
46: * with the alternate file, the file descriptors are exchanged
47: * and the lock is not released.
48: */
49: int io_savedfile, io_altfile, io_curr ;
50: int lock_savedfile, lock_altfile, lock_curr ;
51: #endif FLOCKFILE
52:
53: /*
54: * Parse file name for command encoded by comm.
55: * If comm is E then command is doomed and we are
56: * parsing just so user won't have to retype the name.
57: */
58: filename(comm)
59: int comm;
60: {
61: register int c = comm, d;
62: register int i;
63: #ifdef FLOCKFILE
64: int lock ;
65:
66: lock = 0 ;
67: #endif FLOCKFILE
68:
69: d = ex_getchar();
70: if (endcmd(d)) {
71: if (savedfile[0] == 0 && comm != 'f')
72: error("No file|No current filename");
73: CP(file, savedfile);
74: #ifdef FLOCKFILE
75: if (io_curr && io_curr != io_savedfile) close(io_curr) ;
76: lock = lock_curr = lock_savedfile ;
77: io_curr = io_savedfile ;
78: #endif FLOCKFILE
79: wasalt = (isalt > 0) ? isalt-1 : 0;
80: isalt = 0;
81: oldadot = altdot;
82: if (c == 'e' || c == 'E')
83: altdot = lineDOT();
84: if (d == EOF)
85: ungetchar(d);
86: } else {
87: ungetchar(d);
88: getone();
89: eol();
90: if (savedfile[0] == 0 && c != 'E' && c != 'e') {
91: c = 'e';
92: edited = 0;
93: }
94: wasalt = strcmp(file, altfile) == 0;
95: oldadot = altdot;
96: switch (c) {
97:
98: case 'f':
99: edited = 0;
100: /* fall into ... */
101:
102: case 'e':
103: if (savedfile[0]) {
104: #ifdef FLOCKFILE
105: if (strcmp(file,savedfile) == 0) break ;
106: #endif FLOCKFILE
107: altdot = lineDOT();
108: CP(altfile, savedfile);
109: #ifdef FLOCKFILE
110: if (io_altfile) close (io_altfile) ;
111: io_altfile = io_savedfile ;
112: lock_altfile = lock_savedfile ;
113: io_savedfile = 0 ;
114: #endif FLOCKFILE
115: }
116: CP(savedfile, file);
117: #ifdef FLOCKFILE
118: io_savedfile = io_curr ;
119: lock_savedfile = lock_curr ;
120: io_curr = 0 ; lock = lock_curr = 0 ;
121: #endif FLOCKFILE
122: break;
123:
124: default:
125: if (file[0]) {
126: #ifdef FLOCKFILE
127: if (wasalt) break ;
128: #endif
129: if (c != 'E')
130: altdot = lineDOT();
131: CP(altfile, file);
132: #ifdef FLOCKFILE
133: if (io_altfile
134: && io_altfile != io_curr) close (io_altfile) ;
135: io_altfile = io_curr ;
136: lock_altfile = lock_curr ;
137: io_curr = 0 ; lock = lock_curr = 0 ;
138: #endif FLOCKFILE
139: }
140: break;
141: }
142: }
143: if (hush && comm != 'f' || comm == 'E')
144: return;
145: if (file[0] != 0) {
146: lprintf("\"%s\"", file);
147: if (comm == 'f') {
148: if (value(READONLY))
149: ex_printf(" [Read only]");
150: if (!edited)
151: ex_printf(" [Not edited]");
152: if (tchng)
153: ex_printf(" [Modified]");
154: #ifdef FLOCKFILE
155: if (lock == LOCK_SH)
156: ex_printf(" [Shared lock]") ;
157: else if (lock == LOCK_EX)
158: ex_printf(" [Exclusive lock]") ;
159: #endif FLOCKFILE
160: }
161: flush();
162: } else
163: ex_printf("No file ");
164: if (comm == 'f') {
165: if (!(i = lineDOL()))
166: i++;
167: ex_printf(" line %d of %d --%ld%%--", lineDOT(), lineDOL(),
168: (long) 100 * lineDOT() / i);
169: }
170: }
171:
172: /*
173: * Get the argument words for a command into genbuf
174: * expanding # and %.
175: */
176: getargs()
177: {
178: register int c;
179: register char *cp, *fp;
180: static char fpatbuf[32]; /* hence limit on :next +/pat */
181:
182: pastwh();
183: if (peekchar() == '+') {
184: for (cp = fpatbuf;;) {
185: c = *cp++ = ex_getchar();
186: if (cp >= &fpatbuf[sizeof(fpatbuf)])
187: error("Pattern too long");
188: if (c == '\\' && isspace(peekchar()))
189: c = ex_getchar();
190: if (c == EOF || isspace(c)) {
191: ungetchar(c);
192: *--cp = 0;
193: firstpat = &fpatbuf[1];
194: break;
195: }
196: }
197: }
198: if (skipend())
199: return (0);
200: CP(genbuf, "echo "); cp = &genbuf[5];
201: for (;;) {
202: c = ex_getchar();
203: if (endcmd(c)) {
204: ungetchar(c);
205: break;
206: }
207: switch (c) {
208:
209: case '\\':
210: if (any(peekchar(), "#%|"))
211: c = ex_getchar();
212: /* fall into... */
213:
214: default:
215: if (cp > &genbuf[LBSIZE - 2])
216: flong:
217: error("Argument buffer overflow");
218: *cp++ = c;
219: break;
220:
221: case '#':
222: fp = altfile;
223: if (*fp == 0)
224: error("No alternate filename@to substitute for #");
225: goto filexp;
226:
227: case '%':
228: fp = savedfile;
229: if (*fp == 0)
230: error("No current filename@to substitute for %%");
231: filexp:
232: while (*fp) {
233: if (cp > &genbuf[LBSIZE - 2])
234: goto flong;
235: *cp++ = *fp++;
236: }
237: break;
238: }
239: }
240: *cp = 0;
241: return (1);
242: }
243:
244: /*
245: * Glob the argument words in genbuf, or if no globbing
246: * is implied, just split them up directly.
247: */
248: glob(gp)
249: struct glob *gp;
250: {
251: int pvec[2];
252: register char **argv = gp->argv;
253: register char *cp = gp->argspac;
254: register int c;
255: char ch;
256: int nleft = NCARGS;
257:
258: gp->argc0 = 0;
259: if (gscan() == 0) {
260: register char *v = genbuf + 5; /* strlen("echo ") */
261:
262: for (;;) {
263: while (isspace(*v))
264: v++;
265: if (!*v)
266: break;
267: *argv++ = cp;
268: while (*v && !isspace(*v))
269: *cp++ = *v++;
270: *cp++ = 0;
271: gp->argc0++;
272: }
273: *argv = 0;
274: return;
275: }
276: if (pipe(pvec) < 0)
277: error("Can't make pipe to glob");
278: pid = vfork();
279: io = pvec[0];
280: if (pid < 0) {
281: close(pvec[1]);
282: error("Can't fork to do glob");
283: }
284: if (pid == 0) {
285: int oerrno;
286:
287: if (genbuf) {
288: register char *ccp = genbuf;
289: while (*ccp)
290: *ccp++ &= TRIM;
291: }
292: close(1);
293: dup(pvec[1]);
294: close(pvec[0]);
295: close(2); /* so errors don't mess up the screen */
296: ignore(open(_PATH_DEVNULL, 1));
297: execl(svalue(SHELL), "sh", "-c", genbuf, 0);
298: oerrno = errno;
299: close(1);
300: dup(2);
301: errno = oerrno;
302: filioerr(svalue(SHELL));
303: }
304: close(pvec[1]);
305: do {
306: *argv = cp;
307: for (;;) {
308: if (read(io, &ch, 1) != 1) {
309: close(io);
310: c = -1;
311: } else
312: c = ch & TRIM;
313: if (c <= 0 || isspace(c))
314: break;
315: *cp++ = c;
316: if (--nleft <= 0)
317: error("Arg list too long");
318: }
319: if (cp != *argv) {
320: --nleft;
321: *cp++ = 0;
322: gp->argc0++;
323: if (gp->argc0 >= NARGS)
324: error("Arg list too long");
325: argv++;
326: }
327: } while (c >= 0);
328: waitfor();
329: if (gp->argc0 == 0)
330: error("No match");
331: }
332:
333: /*
334: * Scan genbuf for shell metacharacters.
335: * Set is union of v7 shell and csh metas.
336: */
337: gscan()
338: {
339: #ifndef vms /* Never have meta-characters in vms */
340: register char *cp;
341:
342: for (cp = genbuf; *cp; cp++)
343: if (any(*cp, "~{[*?$`'\"\\"))
344: return (1);
345: #endif
346: return (0);
347: }
348:
349: /*
350: * Parse one filename into file.
351: */
352: struct glob G;
353: getone()
354: {
355: register char *str;
356:
357: if (getargs() == 0)
358: error("Missing filename");
359: glob(&G);
360: if (G.argc0 > 1)
361: error("Ambiguous|Too many file names");
362: str = G.argv[G.argc0 - 1];
363: if (strlen(str) > FNSIZE - 4)
364: error("Filename too long");
365: CP(file, str);
366: }
367:
368: /*
369: * Read a file from the world.
370: * C is command, 'e' if this really an edit (or a recover).
371: */
372: rop(c)
373: int c;
374: {
375: register int i;
376: struct stat stbuf;
377: struct exec head;
378: static int ovro; /* old value(READONLY) */
379: static int denied; /* 1 if READONLY was set due to file permissions */
380: #ifdef FLOCKFILE
381: int *lp, *iop;
382: #endif FLOCKFILE
383:
384: io = open(file, 0);
385: if (io < 0) {
386: if (c == 'e' && errno == ENOENT) {
387: edited++;
388: /*
389: * If the user just did "ex foo" he is probably
390: * creating a new file. Don't be an error, since
391: * this is ugly, and it screws up the + option.
392: */
393: if (!seenprompt) {
394: ex_printf(" [New file]");
395: noonl();
396: return;
397: }
398: }
399: syserror();
400: }
401: if (fstat(io, &stbuf))
402: syserror();
403: switch (stbuf.st_mode & S_IFMT) {
404:
405: case S_IFBLK:
406: error(" Block special file");
407:
408: case S_IFCHR:
409: if (isatty(io))
410: error(" Teletype");
411: if (samei(&stbuf, _PATH_DEVNULL))
412: break;
413: error(" Character special file");
414:
415: case S_IFDIR:
416: error(" Directory");
417:
418: case S_IFREG:
419: #ifdef CRYPT
420: if (xflag)
421: break;
422: #endif
423: i = read(io, (char *)&head, sizeof(head));
424: (void)lseek(io, 0L, L_SET);
425: if (i != sizeof(head))
426: break;
427: #ifndef vms
428: switch ((int)head.a_magic) {
429:
430: case 0405: /* data overlay on exec */
431: case OMAGIC: /* unshared */
432: case NMAGIC: /* shared text */
433: case 0411: /* separate I/D */
434: case ZMAGIC: /* VM/Unix demand paged */
435: case 0430: /* PDP-11 Overlay shared */
436: case 0431: /* PDP-11 Overlay sep I/D */
437: error(" Executable");
438:
439: /*
440: * We do not forbid the editing of portable archives
441: * because it is reasonable to edit them, especially
442: * if they are archives of text files. This is
443: * especially useful if you archive source files together
444: * and copy them to another system with ~%take, since
445: * the files sometimes show up munged and must be fixed.
446: */
447: case 0177545:
448: case 0177555:
449: error(" Archive");
450: case 070707:
451: error(" Cpio file");
452:
453: default:
454: {
455: char *bp = (char *)&head;
456: if ((u_char)bp[0] == (u_char)'\037' &&
457: (u_char)bp[1] == (u_char)'\235')
458: error(" Compressed file");
459: if (!strncmp(bp, "!<arch>\n__.SYMDEF", 17)
460: || !strncmp(bp, "!<arch>\n", 8))
461: error(" Archive");
462: }
463: break;
464: }
465: #endif
466: }
467: if (c != 'r') {
468: if (value(READONLY) && denied) {
469: value(READONLY) = ovro;
470: denied = 0;
471: }
472: if ((stbuf.st_mode & 0222) == 0 || access(file, 2) < 0) {
473: ovro = value(READONLY);
474: denied = 1;
475: value(READONLY) = 1;
476: }
477: }
478: if (value(READONLY)) {
479: ex_printf(" [Read only]");
480: flush();
481: }
482: #ifdef FLOCKFILE
483: /*
484: * Attempt to lock the file. We use an sharable lock if reading
485: * the file, and an exclusive lock if editting a file.
486: * The lock will be released when the file is no longer being
487: * referenced. At any time, the editor can have as many as
488: * three files locked, and with different lock statuses.
489: */
490: /*
491: * if this is either the saved or alternate file or current file,
492: * point to the appropriate descriptor and file lock status.
493: */
494: if (strcmp (file,savedfile) == 0) {
495: if (!io_savedfile) io_savedfile = dup(io) ;
496: lp = &lock_savedfile ; iop = &io_savedfile ;
497: } else if (strcmp (file,altfile) == 0) {
498: if (!io_altfile) io_altfile = dup(io) ;
499: lp = &lock_altfile ; iop = &io_altfile ;
500: } else {
501: /* throw away current lock, accquire new current lock */
502: if (io_curr) close (io_curr) ;
503: io_curr = dup(io) ;
504: lp = &lock_curr ; iop = &io_curr ;
505: lock_curr = 0 ;
506: }
507: if (c == 'r' || value(READONLY) || *lp == 0) {
508: /* if we have a lock already, don't bother */
509: if (!*lp) {
510: /* try for a shared lock */
511: if (flock(*iop, LOCK_SH|LOCK_NB) < 0
512: && errno == EWOULDBLOCK) {
513: ex_printf (
514: " [FILE BEING MODIFIED BY ANOTHER PROCESS]") ;
515: flush();
516: goto fail_lock ;
517: } else *lp = LOCK_SH ;
518: }
519: }
520: if ( c != 'r' && !value(READONLY) && *lp != LOCK_EX) {
521: /* if we are editting the file, upgrade to an exclusive lock. */
522: if (flock(*iop, LOCK_EX|LOCK_NB) < 0 && errno == EWOULDBLOCK) {
523: ex_printf (" [File open by another process]") ;
524: flush();
525: } else *lp = LOCK_EX ;
526: }
527: fail_lock:
528: #endif FLOCKFILE
529: if (c == 'r')
530: setdot();
531: else
532: setall();
533: if (FIXUNDO && inopen && c == 'r')
534: undap1 = undap2 = dot + 1;
535: rop2();
536: rop3(c);
537: }
538:
539: rop2()
540: {
541: line *first, *last, *a;
542: struct stat statb;
543:
544: deletenone();
545: clrstats();
546: first = addr2 + 1;
547: if (fstat(io, &statb) < 0)
548: bsize = LBSIZE;
549: else {
550: bsize = statb.st_blksize;
551: if (bsize <= 0)
552: bsize = LBSIZE;
553: }
554: ignore(append(getfile, addr2));
555: last = dot;
556: /*
557: * if the modeline variable is set,
558: * check the first and last five lines of the file
559: * for a mode line.
560: */
561: if (value(MODELINE)) {
562: for (a=first; a<=last; a++) {
563: if (a==first+5 && last-first > 10)
564: a = last - 4;
565: getline(*a);
566: checkmodeline(linebuf);
567: }
568: }
569: }
570:
571: rop3(c)
572: int c;
573: {
574:
575: if (iostats() == 0 && c == 'e')
576: edited++;
577: if (c == 'e') {
578: if (wasalt || firstpat) {
579: register line *addr = zero + oldadot;
580:
581: if (addr > dol)
582: addr = dol;
583: if (firstpat) {
584: globp = (*firstpat) ? firstpat : "$";
585: commands(1,1);
586: firstpat = 0;
587: } else if (addr >= one) {
588: if (inopen)
589: dot = addr;
590: markpr(addr);
591: } else
592: goto other;
593: } else
594: other:
595: if (dol > zero) {
596: if (inopen)
597: dot = one;
598: markpr(one);
599: }
600: if(FIXUNDO)
601: undkind = UNDNONE;
602: if (inopen) {
603: vcline = 0;
604: vreplace(0, LINES, lineDOL());
605: }
606: }
607: }
608:
609: /*
610: * Are these two really the same inode?
611: */
612: samei(sp, cp)
613: struct stat *sp;
614: char *cp;
615: {
616: struct stat stb;
617:
618: if (stat(cp, &stb) < 0 || sp->st_dev != stb.st_dev)
619: return (0);
620: return (sp->st_ino == stb.st_ino);
621: }
622:
623: /* Returns from edited() */
624: #define EDF 0 /* Edited file */
625: #define NOTEDF -1 /* Not edited file */
626: #define PARTBUF 1 /* Write of partial buffer to Edited file */
627:
628: /*
629: * Write a file.
630: */
631: wop(dofname)
632: bool dofname; /* if 1 call filename, else use savedfile */
633: {
634: register int c, exclam, nonexist;
635: line *saddr1, *saddr2;
636: struct stat stbuf;
637: #ifdef FLOCKFILE
638: int *lp, *iop ;
639: #endif FLOCKFILE
640:
641: c = 0;
642: exclam = 0;
643: if (dofname) {
644: if (peekchar() == '!')
645: exclam++, ignchar();
646: ignore(skipwh());
647: while (peekchar() == '>')
648: ignchar(), c++, ignore(skipwh());
649: if (c != 0 && c != 2)
650: error("Write forms are 'w' and 'w>>'");
651: filename('w');
652: } else {
653: if (savedfile[0] == 0)
654: error("No file|No current filename");
655: saddr1=addr1;
656: saddr2=addr2;
657: addr1=one;
658: addr2=dol;
659: CP(file, savedfile);
660: if (inopen) {
661: vclrech(0);
662: splitw++;
663: }
664: lprintf("\"%s\"", file);
665: }
666: nonexist = stat(file, &stbuf);
667: #ifdef FLOCKFILE
668: /*
669: * if this is either the saved or alternate file or current file,
670: * point to the appropriate descriptor and file lock status.
671: */
672: if (strcmp (file,savedfile) == 0) {
673: lp = &lock_savedfile ; iop = &io_savedfile ;
674: } else if (strcmp (file,altfile) == 0) {
675: lp = &lock_altfile ; iop = &io_altfile ;
676: } else {
677: lp = &lock_curr ; iop = &io_curr ;
678: }
679: if (!*iop && !nonexist){
680: *lp = 0 ;
681: if ((*iop = open(file, 1)) < 0) *iop = 0 ;
682: }
683: #endif FLOCKFILE
684: switch (c) {
685:
686: case 0:
687: if (!exclam && (!value(WRITEANY) || value(READONLY)))
688: switch (edfile()) {
689:
690: case NOTEDF:
691: if (nonexist)
692: break;
693: if ((stbuf.st_mode & S_IFMT) == S_IFCHR) {
694: if (samei(&stbuf, _PATH_DEVNULL))
695: break;
696: if (samei(&stbuf, _PATH_TTY))
697: break;
698: }
699: io = open(file, 1);
700: if (io < 0)
701: syserror();
702: if (!isatty(io))
703: serror(" File exists| File exists - use \"w! %s\" to overwrite", file);
704: close(io);
705: break;
706:
707: case EDF:
708: if (value(READONLY))
709: error(" File is read only");
710: break;
711:
712: case PARTBUF:
713: if (value(READONLY))
714: error(" File is read only");
715: error(" Use \"w!\" to write partial buffer");
716: }
717: cre:
718: /*
719: synctmp();
720: */
721: #ifdef FLOCKFILE
722: if (*iop && !*lp != LOCK_EX && !exclam) {
723: /*
724: * upgrade to a exclusive lock. if can't get, someone else
725: * has the exclusive lock. bitch to the user.
726: */
727: if (flock(*iop, LOCK_EX|LOCK_NB) < 0 && errno == EWOULDBLOCK)
728: error (" File being modified by another process - use \"w!\" to write");
729: else *lp = LOCK_EX ;
730: }
731: #endif FLOCKFILE
732: #ifdef V6
733: io = creat(file, 0644);
734: #else
735: io = creat(file, 0666);
736: #ifdef vms /* to retain file protection modes on newer version of file */
737: if (!nonexist)
738: chmod(file, stbuf.st_mode & 0777);
739: #endif
740: #endif
741: if (io < 0)
742: syserror();
743: writing = 1;
744: if (hush == 0)
745: if (nonexist)
746: ex_printf(" [New file]");
747: else if (value(WRITEANY) && edfile() != EDF)
748: ex_printf(" [Existing file]");
749: #ifdef FLOCKFILE
750: if (!*iop)
751: *iop = dup(io) ;
752: #endif FLOCKFILE
753: break;
754:
755: case 2:
756: io = open(file, 1);
757: if (io < 0) {
758: if (exclam || value(WRITEANY))
759: goto cre;
760: syserror();
761: }
762: lseek(io, 0l, 2);
763: #ifdef FLOCKFILE
764: if (!*iop) *iop = dup(io) ;
765: if (*lp != LOCK_EX && !exclam) {
766: /*
767: * upgrade to a exclusive lock. if can't get,
768: * someone else has the exclusive lock.
769: * bitch to the user.
770: */
771: if (flock(*iop, LOCK_SH|LOCK_NB) < 0
772: && errno == EWOULDBLOCK)
773: error (
774: " File being modified by another process - use \"w!>>\" to write");
775: else *lp = LOCK_EX ;
776: }
777: #endif FLOCKFILE
778: break;
779: }
780: #ifdef FLOCKFILE
781: if (flock(*iop, LOCK_EX|LOCK_NB) >= 0)
782: *lp = LOCK_EX ;
783: #endif FLOCKFILE
784: putfile(0);
785: #ifndef vms
786: (void) fsync(io);
787: #endif
788: ignore(iostats());
789: if (c != 2 && addr1 == one && addr2 == dol) {
790: if (eq(file, savedfile))
791: edited = 1;
792: ex_sync();
793: }
794: if (!dofname) {
795: addr1 = saddr1;
796: addr2 = saddr2;
797: }
798: writing = 0;
799: }
800:
801: /*
802: * Is file the edited file?
803: * Work here is that it is not considered edited
804: * if this is a partial buffer, and distinguish
805: * all cases.
806: */
807: edfile()
808: {
809:
810: if (!edited || !eq(file, savedfile))
811: return (NOTEDF);
812: return (addr1 == one && addr2 == dol ? EDF : PARTBUF);
813: }
814:
815: /*
816: * Extract the next line from the io stream.
817: */
818: char *nextip;
819:
820: getfile()
821: {
822: register short c;
823: register char *lp, *fp;
824:
825: lp = linebuf;
826: fp = nextip;
827: do {
828: if (--ninbuf < 0) {
829: ninbuf = read(io, genbuf, (int) bsize) - 1;
830: if (ninbuf < 0) {
831: if (lp != linebuf) {
832: lp++;
833: ex_printf(" [Incomplete last line]");
834: break;
835: }
836: return (EOF);
837: }
838: #ifdef CRYPT
839: if (kflag) {
840: fp = genbuf;
841: while(fp < &genbuf[ninbuf]) {
842: if (*fp++ & 0200) {
843: crblock(perm, genbuf, ninbuf+1,
844: cntch);
845: break;
846: }
847: }
848: }
849: #endif
850: fp = genbuf;
851: cntch += ninbuf+1;
852: }
853: if (lp >= &linebuf[LBSIZE]) {
854: error(" Line too long");
855: }
856: c = *fp++;
857: if (c == 0) {
858: cntnull++;
859: continue;
860: }
861: if (c & QUOTE) {
862: cntodd++;
863: c &= TRIM;
864: if (c == 0)
865: continue;
866: }
867: *lp++ = c;
868: } while (c != '\n');
869: *--lp = 0;
870: nextip = fp;
871: cntln++;
872: return (0);
873: }
874:
875: /*
876: * Write a range onto the io stream.
877: */
878: /* ARGSUSED */
879: putfile(isfilter)
880: int isfilter;
881: {
882: line *a1;
883: register char *fp, *lp;
884: register int nib;
885: struct stat statb;
886:
887: a1 = addr1;
888: clrstats();
889: cntln = addr2 - a1 + 1;
890: if (cntln == 0)
891: return;
892: if (fstat(io, &statb) < 0)
893: bsize = LBSIZE;
894: else {
895: bsize = statb.st_blksize;
896: if (bsize <= 0)
897: bsize = LBSIZE;
898: }
899: nib = bsize;
900: fp = genbuf;
901: do {
902: getline(*a1++);
903: lp = linebuf;
904: for (;;) {
905: if (--nib < 0) {
906: nib = fp - genbuf;
907: #ifdef CRYPT
908: if(kflag && !isfilter)
909: crblock(perm, genbuf, nib, cntch);
910: #endif
911: if (write(io, genbuf, nib) != nib) {
912: wrerror();
913: }
914: cntch += nib;
915: nib = bsize - 1;
916: fp = genbuf;
917: }
918: if ((*fp++ = *lp++) == 0) {
919: fp[-1] = '\n';
920: break;
921: }
922: }
923: } while (a1 <= addr2);
924: nib = fp - genbuf;
925: #ifdef CRYPT
926: if(kflag && !isfilter)
927: crblock(perm, genbuf, nib, cntch);
928: #endif
929: if (write(io, genbuf, nib) != nib) {
930: wrerror();
931: }
932: cntch += nib;
933: }
934:
935: /*
936: * A write error has occurred; if the file being written was
937: * the edited file then we consider it to have changed since it is
938: * now likely scrambled.
939: */
940: wrerror()
941: {
942:
943: if (eq(file, savedfile) && edited)
944: change();
945: syserror();
946: }
947:
948: /*
949: * Source command, handles nested sources.
950: * Traps errors since it mungs unit 0 during the source.
951: */
952: short slevel;
953: short ttyindes;
954:
955: source(fil, okfail)
956: char *fil;
957: bool okfail;
958: {
959: jmp_buf osetexit;
960: register int saveinp, ointty, oerrno;
961: char *saveglobp;
962: short savepeekc;
963:
964: signal(SIGINT, SIG_IGN);
965: saveinp = dup(0);
966: savepeekc = peekc;
967: saveglobp = globp;
968: peekc = 0; globp = 0;
969: if (saveinp < 0)
970: error("Too many nested sources");
971: if (slevel <= 0)
972: ttyindes = saveinp;
973: close(0);
974: if (open(fil, 0) < 0) {
975: oerrno = errno;
976: setrupt();
977: dup(saveinp);
978: close(saveinp);
979: errno = oerrno;
980: if (!okfail)
981: filioerr(fil);
982: return;
983: }
984: slevel++;
985: ointty = intty;
986: intty = isatty(0);
987: oprompt = value(PROMPT);
988: value(PROMPT) &= intty;
989: getexit(osetexit);
990: setrupt();
991: if (setexit() == 0)
992: commands(1, 1);
993: else if (slevel > 1) {
994: close(0);
995: dup(saveinp);
996: close(saveinp);
997: slevel--;
998: resexit(osetexit);
999: reset();
1000: }
1001: intty = ointty;
1002: value(PROMPT) = oprompt;
1003: close(0);
1004: dup(saveinp);
1005: close(saveinp);
1006: globp = saveglobp;
1007: peekc = savepeekc;
1008: slevel--;
1009: resexit(osetexit);
1010: }
1011:
1012: /*
1013: * Clear io statistics before a read or write.
1014: */
1015: clrstats()
1016: {
1017:
1018: ninbuf = 0;
1019: cntch = 0;
1020: cntln = 0;
1021: cntnull = 0;
1022: cntodd = 0;
1023: }
1024:
1025: /*
1026: * Io is finished, close the unit and print statistics.
1027: */
1028: iostats()
1029: {
1030:
1031: close(io);
1032: io = -1;
1033: if (hush == 0) {
1034: if (value(TERSE))
1035: ex_printf(" %d/%D", cntln, cntch);
1036: else
1037: ex_printf(" %d line%s, %D character%s", cntln, plural((long) cntln),
1038: cntch, plural(cntch));
1039: if (cntnull || cntodd) {
1040: ex_printf(" (");
1041: if (cntnull) {
1042: ex_printf("%D null", cntnull);
1043: if (cntodd)
1044: ex_printf(", ");
1045: }
1046: if (cntodd)
1047: ex_printf("%D non-ASCII", cntodd);
1048: ex_putchar(')');
1049: }
1050: noonl();
1051: flush();
1052: }
1053: return (cntnull != 0 || cntodd != 0);
1054: }
1055:
1056: #ifdef USG
1057: # define index strchr
1058: # define rindex strrchr
1059: #endif
1060: #ifdef USG3TTY
1061: # define index strchr
1062: # define rindex strrchr
1063: #endif
1064: #ifdef vms
1065: # define index strchr
1066: # define rindex strrchr
1067: #endif
1068:
1069: checkmodeline(l)
1070: char *l;
1071: {
1072: char *beg, *end;
1073: char cmdbuf[1024];
1074: char *index(), *rindex(), *strncpy();
1075:
1076: beg = index(l, ':');
1077: if (beg == NULL)
1078: return;
1079: if (&beg[-3] < l)
1080: return;
1081: if (!( ( (beg[-3] == ' ' || beg[-3] == '\t')
1082: && beg[-2] == 'e'
1083: && beg[-1] == 'x')
1084: || ( (beg[-3] == ' ' || beg[-3] == '\t')
1085: && beg[-2] == 'v'
1086: && beg[-1] == 'i'))) return;
1087: strncpy(cmdbuf, beg+1, sizeof cmdbuf);
1088: end = rindex(cmdbuf, ':');
1089: if (end == NULL)
1090: return;
1091: *end = 0;
1092: globp = cmdbuf;
1093: commands(1, 1);
1094: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.