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