![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove|
Return to io.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove |
1.1 root 1: /***************************************************************************
2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
3: * is provided to you without charge, and with no warranty. You may give *
4: * away copies of JOVE, including sources, provided that this notice is *
5: * included in all the files. *
6: ***************************************************************************/
7:
8: #include "jove.h"
9: #include "io.h"
10: #include "termcap.h"
11:
12: #ifdef IPROCS
13: # include <signal.h>
14: #endif
15:
16: #ifdef MAC
17: # include "mac.h"
18: #else
19: # include <sys/stat.h>
20: #endif
21:
22: #ifdef UNIX
23: #include <sys/file.h>
24: #ifdef YP_PASSWD
25: #include <rpcsvc/ypclnt.h>
26: #endif
27: #endif
28:
29: #ifdef MSDOS
30: #include <fcntl.h>
31: #include <io.h>
32: #ifdef CHDIR
33: #include <direct.h>
34: #include <dos.h>
35: #endif
36: #endif /* MSDOS */
37: #include <errno.h>
38:
39: #ifdef MAC
40: # undef private
41: # define private
42: #endif
43:
44: #ifdef LINT_ARGS
45: private struct block
46: * b_unlink(struct block *),
47: * lookup(short);
48:
49: private char
50: * dbackup(char *, char *, char),
51: #if defined(MSDOS) && defined(CHDIR)
52: * fixpath(char *),
53: #endif
54: * getblock(disk_line, int);
55:
56: private void
57: #if defined(MSDOS) && defined(CHDIR)
58: abspath(char *, char *),
59: #endif
60: fake_blkio(struct block *, int (*)()),
61: LRUunlink(struct block *),
62: real_blkio(struct block *, int (*)());
63:
64: private int
65: #if defined(MSDOS) && defined(CHDIR)
66: Dchdir(char *),
67: #endif
68: dfollow(char *, char *);
69:
70: #else
71: private struct block
72: * b_unlink(),
73: * lookup();
74:
75: private char
76: * dbackup(),
77: #if defined(MSDOS) && defined(CHDIR)
78: * fixpath(),
79: #endif
80: * getblock();
81:
82: private void
83: #if defined(MSDOS) && defined(CHDIR)
84: abspath(),
85: #endif
86: fake_blkio(),
87: LRUunlink(),
88: real_blkio();
89:
90: private int
91: #if defined(MSDOS) && defined(CHDIR)
92: Dchdir(),
93: #endif
94: dfollow();
95: #endif /* LINT_ARGS */
96:
97: #ifdef MAC
98: # undef private
99: # define private static
100: #endif
101:
102:
103: #ifndef W_OK
104: # define W_OK 2
105: # define F_OK 0
106: #endif
107:
108: long io_chars; /* number of chars in this open_file */
109: int io_lines; /* number of lines in this open_file */
110:
111: #if defined(VMUNIX)||defined(MSDOS)
112: char iobuff[LBSIZE],
113: genbuf[LBSIZE],
114: linebuf[LBSIZE];
115: #else
116: char *iobuff,
117: *genbuf,
118: *linebuf;
119: #endif
120:
121: #ifdef BACKUPFILES
122: int BkupOnWrite = 0;
123: #endif
124:
125: void
126: close_file(fp)
127: File *fp;
128: {
129: if (fp) {
130: if (fp->f_flags & F_TELLALL)
131: add_mess(" %d lines, %D characters.",
132: io_lines,
133: io_chars);
134: f_close(fp);
135: }
136: }
137:
138: /* Write the region from line1/char1 to line2/char2 to FP. This
139: never CLOSES the file since we don't know if we want to. */
140:
141: int EndWNewline = 1;
142:
143: void
144: putreg(fp, line1, char1, line2, char2, makesure)
145: register File *fp;
146: Line *line1,
147: *line2;
148: {
149: register int c;
150: register char *lp;
151:
152: if (makesure)
153: (void) fixorder(&line1, &char1, &line2, &char2);
154: while (line1 != line2->l_next) {
155: lp = lcontents(line1) + char1;
156: if (line1 == line2) {
157: fputnchar(lp, (char2 - char1), fp);
158: io_chars += (char2 - char1);
159: } else while (c = *lp++) {
160: putc(c, fp);
161: io_chars += 1;
162: }
163: if (line1 != line2) {
164: io_lines += 1;
165: io_chars += 1;
166: #ifdef MSDOS
167: putc('\r', fp);
168: #endif /* MSDOS */
169: putc('\n', fp);
170: }
171: line1 = line1->l_next;
172: char1 = 0;
173: }
174: flush(fp);
175: }
176:
177: void
178: read_file(file, is_insert)
179: char *file;
180: {
181: Bufpos save;
182: File *fp;
183: if (!is_insert) {
184: curbuf->b_ntbf = 0;
185: set_ino(curbuf);
186: }
187: fp = open_file(file, iobuff, F_READ, !COMPLAIN, !QUIET);
188: if (fp == NIL) {
189: if (!is_insert && errno == ENOENT)
190: s_mess("(new file)");
191: else
192: s_mess(IOerr("open", file));
193: return;
194: }
195: DOTsave(&save);
196: dofread(fp);
197: if (is_insert && io_chars > 0) {
198: modify();
199: set_mark();
200: }
201: SetDot(&save);
202: getDOT();
203: close_file(fp);
204: }
205:
206: void
207: dofread(fp)
208: register File *fp;
209: {
210: char end[LBSIZE];
211: int xeof = 0;
212: Line *savel = curline;
213: int savec = curchar;
214: extern disk_line f_getputl();
215:
216: strcpy(end, linebuf + curchar);
217: xeof = f_gets(fp, linebuf + curchar, LBSIZE - curchar);
218: SavLine(curline, linebuf);
219: if (!xeof) do {
220: curline = listput(curbuf, curline);
221: xeof = f_getputl(curline, fp);
222: } while (!xeof);
223: getDOT();
224: linecopy(linebuf, (curchar = strlen(linebuf)), end);
225: SavLine(curline, linebuf);
226: IFixMarks(savel, savec, curline, curchar);
227: }
228:
229: void
230: SaveFile()
231: {
232: if (IsModified(curbuf)) {
233: if (curbuf->b_fname == 0)
234: WriteFile();
235: else {
236: filemunge(curbuf->b_fname);
237: #ifndef MAC
238: #ifndef MSDOS /* not sure - kg - */
239: chk_mtime(curbuf, curbuf->b_fname, "save");
240: #endif /* MSDOS */
241: #endif /* MAC */
242: file_write(curbuf->b_fname, 0);
243: unmodify();
244: }
245: } else
246: message("No changes need to be written.");
247: }
248:
249: char *HomeDir; /* home directory */
250: int HomeLen = -1; /* length of home directory string */
251:
252: #ifndef CHDIR
253:
254: char *
255: pr_name(fname, okay_home)
256: char *fname;
257: {
258: if (fname == 0)
259: return 0;
260:
261: if (okay_home == YES && strncmp(fname, HomeDir, HomeLen) == 0) {
262: static char name_buf[100];
263:
264: sprintf(name_buf, "~%s", fname + HomeLen);
265: return name_buf;
266: }
267:
268: return fname;
269: }
270:
271: #else
272:
273: #define NDIRS 5
274:
275: private char *DirStack[NDIRS] = {0};
276: private int DirSP = 0; /* Directory stack pointer */
277: #define PWD (DirStack[DirSP])
278:
279: char *
280: pwd()
281: {
282: return PWD;
283: }
284:
285: char *
286: pr_name(fname, okay_home)
287: char *fname;
288: {
289: int n;
290:
291: if (fname == 0)
292: return 0;
293: n = numcomp(fname, PWD);
294:
295: if ((PWD[n] == 0) && /* Matched to end of PWD */
296: (fname[n] == '/'))
297: return fname + n + 1;
298:
299: if (okay_home == YES && strcmp(HomeDir, "/") != 0 && strncmp(fname, HomeDir, HomeLen) == 0) {
300: static char name_buf[100];
301:
302: sprintf(name_buf, "~%s", fname + HomeLen);
303: return name_buf;
304: }
305:
306: return fname; /* return entire path name */
307: }
308:
309: extern unsigned int fmask;
310:
311: Chdir()
312: {
313: char dirbuf[FILESIZE];
314:
315: #ifdef MSDOS
316: fmask = 0x10;
317: #endif
318: (void) ask_file((char *) 0, PWD, dirbuf);
319: #ifdef MSDOS
320: fmask = 0x13;
321: if (Dchdir(dirbuf) == -1)
322: #else
323: if (chdir(dirbuf) == -1)
324: #endif
325: {
326: s_mess("cd: cannot change into %s.", dirbuf);
327: return;
328: }
329: UpdModLine = YES;
330: setCWD(dirbuf);
331: prCWD();
332: #ifdef MAC
333: Bufchange++;
334: #endif
335: }
336:
337: #ifdef UNIX
338: #ifndef JOB_CONTROL
339: char *
340: getwd(buffer)
341: char *buffer;
342: {
343: Buffer *old = curbuf;
344: char *ret_val;
345:
346: SetBuf(do_select((Window *) 0, "pwd-output"));
347: curbuf->b_type = B_PROCESS;
348: (void) UnixToBuf("pwd-output", NO, 0, YES, "/bin/pwd", (char *) 0);
349: ToFirst();
350: strcpy(buffer, linebuf);
351: SetBuf(old);
352: return buffer;
353: }
354: #endif
355: #endif /* UNIX */
356:
357: setCWD(d)
358: char *d;
359: {
360: if (PWD == 0)
361: PWD = malloc((unsigned) strlen(d) + 1);
362: else {
363: extern char *ralloc();
364:
365: PWD = ralloc(PWD, strlen(d) + 1);
366: }
367: strcpy(PWD, d);
368: }
369:
370: getCWD()
371: {
372: char *cwd;
373: char pathname[FILESIZE];
374: #if defined(UNIX) && defined(JOB_CONTROL)
375: extern char *getwd();
376: #endif
377: #if defined(MSDOS)
378: extern char *getcwd();
379: #endif
380:
381: #ifndef MSDOS
382: cwd = getenv("CWD");
383: if (cwd == 0)
384: cwd = getenv("PWD");
385: if (cwd == 0)
386: cwd = getwd(pathname);
387: #else /* MSDOS */
388: cwd = fixpath(getcwd(pathname, FILESIZE));
389: #endif /* MSDOS */
390:
391: setCWD(cwd);
392: }
393:
394: prDIRS()
395: {
396: register int i;
397:
398: s_mess(": %f ");
399: for (i = DirSP; i >= 0; i--)
400: add_mess("%s ", pr_name(DirStack[i], YES));
401: }
402:
403: prCWD()
404: {
405: s_mess(": %f => \"%s\"", PWD);
406: }
407:
408: Pushd()
409: {
410: char *newdir,
411: dirbuf[FILESIZE];
412:
413: #ifdef MSDOS
414: fmask = 0x10;
415: #endif
416: newdir = ask_file((char *) 0, NullStr, dirbuf);
417: #ifdef MSDOS
418: fmask = 0x13;
419: #endif
420: UpdModLine = YES;
421: if (*newdir == 0) { /* Wants to swap top two entries */
422: char *old_top;
423:
424: if (DirSP == 0)
425: complain("pushd: no other directory.");
426: old_top = PWD;
427: DirStack[DirSP] = DirStack[DirSP - 1];
428: DirStack[DirSP - 1] = old_top;
429: #ifdef MSDOS
430: (void) Dchdir(PWD);
431: #else
432: (void) chdir(PWD);
433: #endif
434: } else {
435: #ifdef MSDOS
436: if (Dchdir(dirbuf) == -1) {
437: #else
438: if (chdir(dirbuf) == -1) {
439: #endif
440: s_mess("pushd: cannot change into %s.", dirbuf);
441: return;
442: }
443:
444: if (DirSP + 1 >= NDIRS)
445: complain("pushd: full stack; max of %d pushes.", NDIRS);
446: DirSP += 1;
447: setCWD(dirbuf);
448: }
449: prDIRS();
450: }
451:
452: Popd()
453: {
454: if (DirSP == 0)
455: complain("popd: directory stack is empty.");
456: UpdModLine = YES;
457: free(PWD);
458: PWD = 0;
459: DirSP -= 1;
460: #ifdef MSDOS
461: (void) Dchdir(PWD); /* If this doesn't work, we's in deep shit. */
462: #else
463: (void) chdir(PWD); /* If this doesn't work, we's in deep shit. */
464: #endif
465: prDIRS();
466: }
467:
468: private char *
469: dbackup(base, offset, c)
470: register char *base,
471: *offset,
472: c;
473: {
474: while (offset > base && *--offset != c)
475: ;
476: return offset;
477: }
478:
479: private
480: dfollow(file, into)
481: char *file,
482: *into;
483: {
484: char *dp,
485: #ifdef MSDOS
486: filefix[FILESIZE],
487: #endif
488: *sp;
489:
490: #ifndef MSDOS
491: if (*file == '/') { /* Absolute pathname */
492: strcpy(into, "/");
493: file += 1;
494: } else
495: strcpy(into, PWD);
496: #else
497: abspath(file, filefix); /* convert to absolute pathname */
498: strcpy(into, filefix); /* and forget about drives */
499: into[3] = 0;
500: into = &(into[2]);
501: file = &(filefix[3]);
502: #endif
503: dp = into + strlen(into);
504:
505: sp = file;
506: do {
507: if (*file == 0)
508: break;
509: if (sp = index(file, '/'))
510: *sp = 0;
511: if (strcmp(file, ".") == 0)
512: ; /* So it will get to the end of the loop */
513: else if (strcmp(file, "..") == 0) {
514: *(dp = dbackup(into, dp, '/')) = 0;
515: if (dp == into)
516: strcpy(into, "/"), dp = into + 1;
517: } else {
518: if (into[strlen(into) - 1] != '/')
519: (void) strcat(into, "/"), dp += 1;
520: (void) strcat(into, file);
521: dp += strlen(file); /* stay at the end */
522: }
523: file = sp + 1;
524: } while (sp != 0);
525: }
526:
527: #endif /* CHDIR */
528:
529: #ifdef UNIX
530:
531: #ifdef !NOGETPWENT
532:
533: #include <pwd.h>
534: private
535: get_hdir(user, buf)
536: register char *user,
537: *buf;
538: {
539: register struct passwd *pw;
540:
541: setpwent();
542: while ((pw = getpwent()) != (struct passwd *)NULL)
543: if (strcmp(pw->pw_name, user) == 0) {
544: strncpy(buf, pw->pw_dir, FILESIZE);
545: buf[FILESIZE-1] = '\0';
546: endpwent();
547: return;
548: }
549: endpwent();
550: complain("[unknown user: %s]", user);
551: }
552:
553: #else /* NOGETPWENT */
554:
555: private
556: get_hdir(user, buf)
557: register char *user,
558: *buf;
559: {
560: char fbuf[LBSIZE],
561: pattern[100];
562: register int u_len;
563: File *fp;
564:
565: u_len = strlen(user);
566: fp = open_file("/etc/passwd", fbuf, F_READ, COMPLAIN, QUIET);
567: sprintf(pattern, "%s:[^:]*:[^:]*:[^:]*:[^:]*:\\([^:]*\\):", user);
568: while (f_gets(fp, genbuf, LBSIZE) != EOF)
569: if ((strncmp(genbuf, user, u_len) == 0) &&
570: (LookingAt(pattern, genbuf, 0))) {
571: putmatch(1, buf, FILESIZE);
572: close_file(fp);
573: return;
574: }
575: f_close(fp);
576: complain("[unknown user: %s]", user);
577: }
578:
579: #endif /* NOGETPWENT */
580: #endif /* UNIX */
581:
582: void
583: PathParse(name, intobuf)
584: char *name,
585: *intobuf;
586: {
587: char localbuf[FILESIZE];
588:
589: intobuf[0] = localbuf[0] = '\0';
590: if (*name == '\0')
591: return;
592: if (*name == '~') {
593: if (name[1] == '/' || name[1] == '\0') {
594: strcpy(localbuf, HomeDir);
595: name += 1;
596: #if !(defined(MSDOS) || defined(MAC)) /* may add for mac in future */
597: } else {
598: char *uendp = index(name, '/'),
599: unamebuf[30];
600:
601: if (uendp == 0)
602: uendp = name + strlen(name);
603: name = name + 1;
604: null_ncpy(unamebuf, name, uendp - name);
605: get_hdir(unamebuf, localbuf);
606: name = uendp;
607: #endif
608: }
609: }
610: #ifndef MSDOS
611: else if (*name == '\\')
612: name += 1;
613: #endif /* MSDOS */
614: (void) strcat(localbuf, name);
615: #ifdef CHDIR
616: dfollow(localbuf, intobuf);
617: #else
618: strcpy(intobuf, localbuf);
619: #endif
620: }
621:
622: void
623: filemunge(newname)
624: char *newname;
625: {
626: struct stat stbuf;
627:
628: if (newname == 0)
629: return;
630: if (stat(newname, &stbuf))
631: return;
632: #ifndef MSDOS
633: if (((stbuf.st_dev != curbuf->b_dev) ||
634: (stbuf.st_ino != curbuf->b_ino)) &&
635: #else /* MSDOS */
636: if ( /* (stbuf.st_ino != curbuf->b_ino) && */
637: #endif /* MSDOS */
638: #ifndef MAC
639: ((stbuf.st_mode & S_IFMT) != S_IFCHR) &&
640: #endif
641: (strcmp(newname, curbuf->b_fname) != 0)) {
642: rbell();
643: confirm("\"%s\" already exists; overwrite it? ", newname);
644: }
645: }
646:
647: void
648: WrtReg()
649: {
650: DoWriteReg(NO);
651: }
652:
653: void
654: AppReg()
655: {
656: DoWriteReg(YES);
657: }
658:
659: int CreatMode = DFLT_MODE;
660:
661: void
662: DoWriteReg(app)
663: {
664: char fnamebuf[FILESIZE],
665: *fname;
666: Mark *mp = CurMark();
667: File *fp;
668:
669: /* Won't get here if there isn't a Mark */
670: fname = ask_file((char *) 0, (char *) 0, fnamebuf);
671:
672: #ifdef BACKUPFILES
673: if (app == NO) {
674: filemunge(fname);
675:
676: if (BkupOnWrite)
677: file_backup(fname);
678: }
679: #else
680: if (!app)
681: filemunge(fname);
682: #endif
683:
684: fp = open_file(fname, iobuff, app ? F_APPEND : F_WRITE, COMPLAIN, !QUIET);
685: putreg(fp, mp->m_line, mp->m_char, curline, curchar, YES);
686: close_file(fp);
687: }
688:
689: int OkayBadChars = 0;
690:
691: void
692: WriteFile()
693: {
694: char *fname,
695: fnamebuf[FILESIZE];
696: #ifdef MAC
697: if (Macmode) {
698: if(!(fname = pfile(fnamebuf))) return;
699: }
700: else
701: #endif /* MAC */
702:
703: fname = ask_file((char *) 0, curbuf->b_fname, fnamebuf);
704: /* Don't allow bad characters when creating new files. */
705: if (!OkayBadChars && strcmp(curbuf->b_fname, fnamebuf) != 0) {
706: #ifdef UNIX
707: static char *badchars = "!$^&*()~`{}\"'\\|<>? ";
708: #endif /* UNIX */
709: #ifdef MSDOS
710: static char *badchars = "*|<>? ";
711: #endif /* MSDOS */
712: #ifdef MAC
713: static char *badchars = ":";
714: #endif /* MAC */
715: register char *cp = fnamebuf;
716: register int c;
717:
718: while (c = *cp++ & CHARMASK) /* avoid sign extension... */
719: if (c < ' ' || c == '\177' || index(badchars, c))
720: complain("'%p': bad character in filename.", c);
721: }
722:
723: #ifndef MAC
724: #ifndef MSDOS
725: chk_mtime(curbuf, fname, "write");
726: #endif /* MSDOS */
727: #endif /* MAC */
728: filemunge(fname);
729: curbuf->b_type = B_FILE; /* in case it wasn't before */
730: setfname(curbuf, fname);
731: file_write(fname, 0);
732: unmodify();
733: }
734:
735: /* Open file FNAME supplying the buffer IO routine with buffer BUF.
736: HOW is F_READ, F_WRITE or F_APPEND. IFBAD == COMPLAIN means that
737: if we fail at opening the file, call complain. LOUDNESS says
738: whether or not to print the "reading ..." message on the message
739: line.
740:
741: NOTE: This opens the pr_name(fname, NO) of fname. That is, FNAME
742: is usually an entire pathname, which can be slow when the
743: pathname is long and there are lots of symbolic links along
744: the way (which has become very common in my experience). So,
745: this speeds up opens file names in the local directory. It
746: will not speed up things like "../scm/foo.scm" simple because
747: by the time we get here that's already been expanded to an
748: absolute pathname. But this is a start.
749: */
750:
751: File *
752: open_file(fname, buf, how, ifbad, loudness)
753: register char *fname;
754: char *buf;
755: register int how;
756: {
757: register File *fp;
758:
759: io_chars = 0;
760: io_lines = 0;
761:
762: fp = f_open(pr_name(fname, NO), how, buf, LBSIZE);
763: if (fp == NIL) {
764: message(IOerr((how == F_READ) ? "open" : "create", fname));
765: if (ifbad == COMPLAIN)
766: complain((char *) 0);
767: } else {
768: int readonly = FALSE;
769: #ifndef MAC
770: if (access(pr_name(fname, NO), W_OK) == -1 && errno != ENOENT)
771: readonly = TRUE;
772: #endif
773: if (loudness != QUIET) {
774: fp->f_flags |= F_TELLALL;
775: f_mess("\"%s\"%s", pr_name(fname, YES),
776: readonly ? " [Read only]" : NullStr);
777: }
778: }
779: return fp;
780: }
781:
782: #ifndef MSDOS
783: /* Check to see if the file has been modified since it was
784: last written. If so, make sure they know what they're
785: doing.
786:
787: I hate to use another stat(), but to use confirm we gotta
788: do this before we open the file.
789:
790: NOTE: This stats FNAME after converting it to a path-relative
791: name. I can't see why this would cause a problem ...
792: */
793:
794: chk_mtime(thisbuf, fname, how)
795: Buffer *thisbuf;
796: char *fname,
797: *how;
798: {
799: struct stat stbuf;
800: Buffer *b;
801: char *mesg = "Shall I go ahead and %s anyway? ";
802:
803: if ((thisbuf->b_mtime != 0) && /* if we care ... */
804: (b = file_exists(fname)) && /* we already have this file */
805: (b == thisbuf) && /* and it's the current buffer */
806: (stat(pr_name(fname, NO), &stbuf) != -1) && /* and we can stat it */
807: (stbuf.st_mtime != b->b_mtime)) { /* and there's trouble. */
808: rbell();
809: redisplay(); /* Ring that bell! */
810: TOstart("Warning", TRUE);
811: Typeout("\"%s\" now saved on disk is not what you last", pr_name(fname, YES));
812: Typeout("visited or saved. Probably someone else is editing");
813: Typeout("your file at the same time.");
814: if (how) {
815: Typeout("");
816: Typeout("Type \"y\" if I should %s, anyway.", how);
817: f_mess(mesg, how);
818: }
819: TOstop();
820: if (how)
821: confirm(mesg, how);
822: }
823: }
824:
825: #endif /* MSDOS */
826:
827: void
828: file_write(fname, app)
829: char *fname;
830: {
831: File *fp;
832:
833: #ifdef BACKUPFILES
834: if (!app && BkupOnWrite)
835: file_backup(fname);
836: #endif
837:
838: fp = open_file(fname, iobuff, app ? F_APPEND : F_WRITE, COMPLAIN, !QUIET);
839:
840: if (EndWNewline) { /* Make sure file ends with a newLine */
841: Bufpos save;
842:
843: DOTsave(&save);
844: ToLast();
845: if (length(curline)) /* Not a blank Line */
846: LineInsert(1);
847: SetDot(&save);
848: }
849: putreg(fp, curbuf->b_first, 0, curbuf->b_last, length(curbuf->b_last), NO);
850: set_ino(curbuf);
851: close_file(fp);
852: }
853:
854: void
855: ReadFile()
856: {
857: Buffer *bp;
858: char *fname,
859: fnamebuf[FILESIZE];
860: int lineno;
861:
862: #ifdef MAC
863: if(Macmode) {
864: if(!(fname = gfile(fnamebuf))) return;
865: }
866: else
867: #endif /* MAC */
868: fname = ask_file((char *) 0, curbuf->b_fname, fnamebuf);
869: #if !(defined(MSDOS) || defined(MAC))
870: chk_mtime(curbuf, fname, "read");
871: #endif /* MSDOS || MAC */
872:
873: if (IsModified(curbuf)) {
874: char *y_or_n;
875: int c;
876:
877: for (;;) {
878: rbell();
879: y_or_n = ask(NullStr, "Shall I make your changes to \"%s\" permanent? ", curbuf->b_name);
880: c = CharUpcase(*y_or_n);
881: if (c == 'Y' || c == 'N')
882: break;
883: }
884: if (c == 'Y')
885: SaveFile();
886: }
887:
888: if ((bp = file_exists(fnamebuf)) &&
889: (bp == curbuf))
890: lineno = pnt_line() - 1;
891: else
892: lineno = 0;
893:
894: unmodify();
895: initlist(curbuf);
896: setfname(curbuf, fname);
897: read_file(fname, 0);
898: SetLine(next_line(curbuf->b_first, lineno));
899: }
900:
901: void
902: InsFile()
903: {
904: char *fname,
905: fnamebuf[FILESIZE];
906: #ifdef MAC
907: if(Macmode) {
908: if(!(fname = gfile(fnamebuf))) return;
909: }
910: else
911: #endif /* MAC */
912: fname = ask_file((char *) 0, curbuf->b_fname, fnamebuf);
913: read_file(fname, 1);
914: }
915:
916: #include "temp.h"
917:
918: int DOLsave = 0; /* Do Lsave flag. If lines aren't being save
919: when you think they should have been, this
920: flag is probably not being set, or is being
921: cleared before lsave() was called. */
922:
923: private int nleft, /* number of good characters left in current block */
924: tmpfd = -1;
925: disk_line DFree = 1;
926: /* pointer to end of tmp file */
927: private char *tfname;
928:
929: void
930: tmpinit()
931: {
932: char buf[FILESIZE];
933:
934: #ifdef MAC
935: sprintf(buf, "%s/%s", HomeDir, d_tempfile);
936: #else
937: sprintf(buf, "%s/%s", TmpFilePath, d_tempfile);
938: #endif
939: tfname = copystr(buf);
940: tfname = mktemp(tfname);
941: (void) close(creat(tfname, 0600));
942: #ifndef MSDOS
943: tmpfd = open(tfname, 2);
944: #else /* MSDOS */
945: tmpfd = open(tfname, 0x8002); /* MSDOS fix */
946: #endif /* MSDOS */
947: if (tmpfd == -1)
948: complain("Warning: cannot create tmp file!");
949: }
950:
951: void
952: tmpclose()
953: {
954: if (tmpfd == -1)
955: return;
956: (void) close(tmpfd);
957: tmpfd = -1;
958: (void) unlink(tfname);
959: }
960:
961: /* get a line at `tl' in the tmp file into `buf' which should be LBSIZE
962: long */
963:
964: int Jr_Len; /* length of Just Read Line */
965:
966: #ifdef MAC /* The Lighspeed compiler can't copy with static here */
967: char *getblock();
968: #else
969: private char *getblock();
970: #endif
971: void
972: getline(addr, buf)
973: disk_line addr;
974: register char *buf;
975: {
976: register char *bp,
977: *lp;
978:
979: lp = buf;
980: bp = getblock(addr >> 1, READ);
981: while (*lp++ = *bp++)
982: ;
983: Jr_Len = (lp - buf) - 1;
984: }
985:
986: /* Put `buf' and return the disk address */
987:
988: disk_line
989: putline(buf)
990: char *buf;
991: {
992: register char *bp,
993: *lp;
994: register int nl;
995: disk_line free_ptr;
996:
997: lp = buf;
998: free_ptr = DFree;
999: bp = getblock(free_ptr, WRITE);
1000: nl = nleft;
1001: free_ptr = blk_round(free_ptr);
1002: while (*bp = *lp++) {
1003: if (*bp++ == '\n') {
1004: *--bp = 0;
1005: break;
1006: }
1007: if (--nl == 0) {
1008: free_ptr = forward_block(free_ptr);
1009: DFree = free_ptr;
1010: bp = getblock(free_ptr, WRITE);
1011: lp = buf; /* start over ... */
1012: nl = nleft;
1013: }
1014: }
1015: free_ptr = DFree;
1016: DFree += (((lp - buf) + CH_SIZE - 1) / CH_SIZE);
1017: /* (lp - buf) includes the null */
1018: return (free_ptr << 1);
1019: }
1020:
1021: /* The theory is that critical section of code inside this procedure
1022: will never cause a problem to occur. Basically, we need to ensure
1023: that two blocks are in memory at the same time, but I think that
1024: this can never screw up. */
1025:
1026: #define lockblock(addr)
1027: #define unlockblock(addr)
1028:
1029: disk_line
1030: f_getputl(line, fp)
1031: Line *line;
1032: register File *fp;
1033: {
1034: register char *bp;
1035: register int c,
1036: nl,
1037: max = LBSIZE;
1038: disk_line free_ptr;
1039: char *base;
1040: #ifdef MSDOS
1041: char crleft = 0;
1042: #endif /* MSDOS */
1043:
1044: free_ptr = DFree;
1045: base = bp = getblock(free_ptr, WRITE);
1046: nl = nleft;
1047: free_ptr = blk_round(free_ptr);
1048: while (--max > 0) {
1049: #ifdef MSDOS
1050: if (crleft) {
1051: c = crleft;
1052: crleft = 0;
1053: } else
1054: #endif /* MSDOS */
1055: c = getc(fp);
1056: if (c == EOF || c == '\n')
1057: break;
1058: #ifdef MSDOS
1059: if (c == '\r')
1060: if ((crleft = getc(fp)) == '\n') {
1061: crleft = 0;
1062: break;
1063: }
1064: #endif /* MSDOS */
1065: if (--nl == 0) {
1066: char *newbp;
1067: int nbytes;
1068:
1069: lockblock(free_ptr);
1070: DFree = free_ptr = forward_block(free_ptr);
1071: nbytes = bp - base;
1072: newbp = getblock(free_ptr, WRITE);
1073: nl = nleft;
1074: byte_copy(base, newbp, nbytes);
1075: bp = newbp + nbytes;
1076: base = newbp;
1077: unlockblock(free_ptr);
1078: }
1079: *bp++ = c;
1080: }
1081: *bp++ = '\0';
1082: free_ptr = DFree;
1083: DFree += (((bp - base) + CH_SIZE - 1) / CH_SIZE);
1084: line->l_dline = (free_ptr << 1);
1085: if (max == 0) {
1086: add_mess(" [Line too long]");
1087: rbell();
1088: return EOF;
1089: }
1090: if (c == EOF) {
1091: if (--bp != base)
1092: add_mess(" [Incomplete last line]");
1093: return EOF;
1094: }
1095: io_lines += 1;
1096: return 0;
1097: }
1098:
1099: typedef struct block {
1100: short b_dirty,
1101: b_bno;
1102: char b_buf[BUFSIZ];
1103: struct block
1104: *b_LRUnext,
1105: *b_LRUprev,
1106: *b_HASHnext;
1107: } Block;
1108:
1109: #define HASHSIZE 7 /* Primes work best (so I'm told) */
1110: #define B_HASH(bno) (bno % HASHSIZE)
1111:
1112: #ifdef MAC
1113: private Block *b_cache,
1114: #else
1115: private Block b_cache[NBUF],
1116: #endif
1117: *bht[HASHSIZE] = {0}, /* Block hash table */
1118: *f_block = 0,
1119: *l_block = 0;
1120: private int max_bno = -1,
1121: NBlocks;
1122:
1123: #ifdef MAC
1124: void (*blkio)();
1125: #else
1126: #ifdef LINT_ARGS
1127: private int (*blkio)(Block *, int (*)());
1128: #else
1129: private int (*blkio)();
1130: #endif
1131: #endif /* MAC */
1132:
1133: #ifdef MAC
1134: make_cache() /* Only 32K of static space on Mac, so... */
1135: {
1136: return((b_cache = (Block *) calloc(NBUF,sizeof(Block))) == 0 ? 0 : 1);
1137: }
1138: #endif /* MAC */
1139:
1140: extern int read(), write();
1141:
1142: private void
1143: real_blkio(b, iofcn)
1144: register Block *b;
1145: #ifdef MAC
1146: register int (*iofcn)();
1147: #else
1148: #ifdef LINT_ARGS
1149: register int (*iofcn)(int, char *, unsigned int);
1150: #else
1151: register int (*iofcn)();
1152: #endif
1153: #endif /* MAC */
1154: {
1155: (void) lseek(tmpfd, (long) ((unsigned) b->b_bno) * BUFSIZ, 0);
1156: if ((*iofcn)(tmpfd, b->b_buf, BUFSIZ) != BUFSIZ)
1157: error("[Tmp file %s error; to continue editing would be dangerous]", (iofcn == read) ? "READ" : "WRITE");
1158: }
1159:
1160: private void
1161: fake_blkio(b, iofcn)
1162: register Block *b;
1163: register int (*iofcn)();
1164: {
1165: tmpinit();
1166: blkio = real_blkio;
1167: real_blkio(b, iofcn);
1168: }
1169:
1170: void
1171: d_cache_init()
1172: {
1173: register Block *bp, /* Block pointer */
1174: **hp; /* Hash pointer */
1175: register short bno;
1176:
1177: for (bp = b_cache, bno = NBUF; --bno >= 0; bp++) {
1178: NBlocks += 1;
1179: bp->b_dirty = 0;
1180: bp->b_bno = bno;
1181: if (l_block == 0)
1182: l_block = bp;
1183: bp->b_LRUprev = 0;
1184: bp->b_LRUnext = f_block;
1185: if (f_block != 0)
1186: f_block->b_LRUprev = bp;
1187: f_block = bp;
1188:
1189: bp->b_HASHnext = *(hp = &bht[B_HASH(bno)]);
1190: *hp = bp;
1191: }
1192: blkio = fake_blkio;
1193: }
1194:
1195: void
1196: SyncTmp()
1197: {
1198: register Block *b;
1199: #ifdef IBMPC
1200: register int bno = 0;
1201: Block *lookup();
1202:
1203: /* sync the blocks in order, for floppy disks */
1204: for (bno = 0; bno <= max_bno; ) {
1205: if ((b = lookup(bno++)) && b->b_dirty) {
1206: (*blkio)(b, write);
1207: b->b_dirty = 0;
1208: }
1209: }
1210: #else
1211: for (b = f_block; b != 0; b = b->b_LRUnext)
1212: if (b->b_dirty) {
1213: (*blkio)(b, write);
1214: b->b_dirty = 0;
1215: }
1216: #endif
1217: }
1218:
1219: private Block *
1220: lookup(bno)
1221: register short bno;
1222: {
1223: register Block *bp;
1224:
1225: for (bp = bht[B_HASH(bno)]; bp != 0; bp = bp->b_HASHnext)
1226: if (bp->b_bno == bno)
1227: break;
1228: return bp;
1229: }
1230:
1231: private void
1232: LRUunlink(b)
1233: register Block *b;
1234: {
1235: if (b->b_LRUprev == 0)
1236: f_block = b->b_LRUnext;
1237: else
1238: b->b_LRUprev->b_LRUnext = b->b_LRUnext;
1239: if (b->b_LRUnext == 0)
1240: l_block = b->b_LRUprev;
1241: else
1242: b->b_LRUnext->b_LRUprev = b->b_LRUprev;
1243: }
1244:
1245: private Block *
1246: b_unlink(bp)
1247: register Block *bp;
1248: {
1249: register Block *hp,
1250: *prev = 0;
1251:
1252: LRUunlink(bp);
1253: /* Now that we have the block, we remove it from its position
1254: in the hash table, so we can THEN put it somewhere else with
1255: it's new block assignment. */
1256:
1257: for (hp = bht[B_HASH(bp->b_bno)]; hp != 0; prev = hp, hp = hp->b_HASHnext)
1258: if (hp == bp)
1259: break;
1260: if (hp == 0) {
1261: printf("\rBlock %d missing!", bp->b_bno);
1262: finish(0);
1263: }
1264: if (prev)
1265: prev->b_HASHnext = hp->b_HASHnext;
1266: else
1267: bht[B_HASH(bp->b_bno)] = hp->b_HASHnext;
1268:
1269: if (bp->b_dirty) { /* do, now, the delayed write */
1270: (*blkio)(bp, write);
1271: bp->b_dirty = 0;
1272: }
1273:
1274: return bp;
1275: }
1276:
1277: /* Get a block which contains at least part of the line with the address
1278: atl. Returns a pointer to the block and sets the global variable
1279: nleft (number of good characters left in the buffer). */
1280:
1281: private char *
1282: getblock(atl, iof)
1283: disk_line atl;
1284: {
1285: register int bno,
1286: off;
1287: register Block *bp;
1288: static Block *lastb = 0;
1289:
1290: bno = da_to_bno(atl);
1291: off = da_to_off(atl);
1292: if (da_too_huge(atl))
1293: error("Tmp file too large. Get help!");
1294: nleft = BUFSIZ - off;
1295: if (lastb != 0 && lastb->b_bno == bno) {
1296: lastb->b_dirty |= iof;
1297: return lastb->b_buf + off;
1298: }
1299:
1300: /* The requested block already lives in memory, so we move
1301: it to the end of the LRU list (making it Most Recently Used)
1302: and then return a pointer to it. */
1303: if (bp = lookup(bno)) {
1304: if (bp != l_block) {
1305: LRUunlink(bp);
1306: if (l_block == 0)
1307: f_block = l_block = bp;
1308: else
1309: l_block->b_LRUnext = bp;
1310: bp->b_LRUprev = l_block;
1311: l_block = bp;
1312: bp->b_LRUnext = 0;
1313: }
1314: if (bp->b_bno > max_bno)
1315: max_bno = bp->b_bno;
1316: bp->b_dirty |= iof;
1317: lastb = bp;
1318: return bp->b_buf + off;
1319: }
1320:
1321: /* The block we want doesn't reside in memory so we take the
1322: least recently used clean block (if there is one) and use
1323: it. */
1324: bp = f_block;
1325: if (bp->b_dirty) /* The best block is dirty ... */
1326: SyncTmp();
1327:
1328: bp = b_unlink(bp);
1329: if (l_block == 0)
1330: l_block = f_block = bp;
1331: else
1332: l_block->b_LRUnext = bp; /* Place it at the end ... */
1333: bp->b_LRUprev = l_block;
1334: l_block = bp;
1335: bp->b_LRUnext = 0; /* so it's Most Recently Used */
1336:
1337: bp->b_dirty = iof;
1338: bp->b_bno = bno;
1339: bp->b_HASHnext = bht[B_HASH(bno)];
1340: bht[B_HASH(bno)] = bp;
1341:
1342: /* Get the current contents of the block UNLESS this is a new
1343: block that's never been looked at before, i.e., it's past
1344: the end of the tmp file. */
1345:
1346: if (bp->b_bno <= max_bno)
1347: (*blkio)(bp, read);
1348: else
1349: max_bno = bno;
1350:
1351: lastb = bp;
1352: return bp->b_buf + off;
1353: }
1354:
1355: char *
1356: lbptr(line)
1357: Line *line;
1358: {
1359: return getblock(line->l_dline >> 1, READ);
1360: }
1361:
1362: /* save the current contents of linebuf, if it has changed */
1363:
1364: void
1365: lsave()
1366: {
1367: if (curbuf == 0 || !DOLsave) /* Nothing modified recently */
1368: return;
1369:
1370: if (strcmp(lbptr(curline), linebuf) != 0)
1371: SavLine(curline, linebuf); /* Put linebuf on the disk. */
1372: DOLsave = 0;
1373: }
1374:
1375: #ifdef BACKUPFILES
1376: void
1377: file_backup(fname)
1378: char *fname;
1379: {
1380: #ifndef MSDOS
1381: char *s;
1382: register int i;
1383: int fd1,
1384: fd2;
1385: char tmp1[BUFSIZ],
1386: tmp2[BUFSIZ];
1387: struct stat buf;
1388: int mode;
1389:
1390: strcpy(tmp1, fname);
1391: if ((s = rindex(tmp1, '/')) == NULL)
1392: sprintf(tmp2, "#%s", fname);
1393: else {
1394: *s++ = '\0';
1395: sprintf(tmp2, "%s/#%s", tmp1, s);
1396: }
1397:
1398: if ((fd1 = open(fname, 0)) < 0)
1399: return;
1400:
1401: /* create backup file with same mode as input file */
1402: #ifndef MAC
1403: if (fstat(fd1, &buf) != 0)
1404: mode = CreatMode;
1405: else
1406: #endif
1407: mode = buf.st_mode;
1408:
1409: if ((fd2 = creat(tmp2, mode)) < 0) {
1410: (void) close(fd1);
1411: return;
1412: }
1413: while ((i = read(fd1, tmp1, sizeof(tmp1))) > 0)
1414: write(fd2, tmp1, i);
1415: #ifdef BSD4_2
1416: (void) fsync(fd2);
1417: #endif
1418: (void) close(fd2);
1419: (void) close(fd1);
1420: #else /* MSDOS */
1421: char *dot,
1422: *slash,
1423: tmp[FILESIZE];
1424:
1425: strcpy(tmp, fname);
1426: slash = basename(tmp);
1427: if (dot = rindex(slash, '.')) {
1428: if (!stricmp(dot,".bak"))
1429: return;
1430: else *dot = 0;
1431: }
1432: strcat(tmp, ".bak");
1433: unlink(tmp);
1434: rename(fname, tmp);
1435: #endif /* MSDOS */
1436: }
1437: #endif
1438:
1439: #if defined(MSDOS) && defined (CHDIR)
1440:
1441: private int /* chdir + drive */
1442: Dchdir(to)
1443: char *to;
1444: {
1445: unsigned d, dd, n;
1446:
1447: if (to[1] == ':') {
1448: d = to[0];
1449: if (d >= 'a') d = d - 'a' + 1;
1450: if (d >= 'A') d = d - 'A' + 1;
1451: _dos_getdrive(&dd);
1452: if (dd != d)
1453: _dos_setdrive(d, &n);
1454: if (to[2] == 0)
1455: return 0;
1456: }
1457: return chdir(to);
1458: }
1459:
1460: private char *
1461: fixpath(p)
1462: char *p;
1463: {
1464: char *pp = p;
1465:
1466: while (*p) {
1467: if (*p == '\\')
1468: *p = '/';
1469: p++;
1470: }
1471: return(strlwr(pp));
1472: }
1473:
1474:
1475: private void
1476: abspath(so, dest)
1477: char *so, *dest;
1478: {
1479: char cwd[FILESIZE], cwdD[3], cwdDIR[FILESIZE], cwdF[9], cwdEXT[5],
1480: soD[3], soDIR[FILESIZE], soF[9], soEXT[5];
1481: char *drive, *path;
1482:
1483: _splitpath(fixpath(so), soD, soDIR, soF, soEXT);
1484: getcwd(cwd, FILESIZE);
1485: if (*soD != 0) {
1486: Dchdir(soD); /* this is kinda messy */
1487: getcwd(cwdDIR, FILESIZE); /* should probably just */
1488: Dchdir(cwd); /* call DOS to do it */
1489: strcpy(cwd, cwdDIR);
1490: }
1491: (void) fixpath(cwd);
1492: if (cwd[strlen(cwd)-1] != '/')
1493: strcat(cwd, "/x.x"); /* need dummy filename */
1494:
1495: _splitpath(fixpath(cwd), cwdD, cwdDIR, cwdF, cwdEXT);
1496:
1497: drive = (*soD == 0) ? cwdD : soD;
1498:
1499: if (*soDIR != '/')
1500: path = strcat(cwdDIR, soDIR);
1501: else
1502: path = soDIR;
1503: _makepath(dest, drive, path, soF, soEXT);
1504: fixpath(dest); /* can't do it often enough */
1505: }
1506:
1507: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.