![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tmp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / vi|
Return to tmp.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /* tmp.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 14407 SW Teal Blvd. #C
6: * Beaverton, OR 97005
7: * [email protected]
8: */
9:
10:
11: /* This file contains functions which create & readback a TMPFILE */
12:
13:
14: #include "config.h"
15: #include "vi.h"
16: #if TOS
17: # include <stat.h>
18: #else
19: # if OSK
20: # include "osk.h"
21: # else
22: # if AMIGA
23: # include "amistat.h"
24: # else
25: # include <sys/stat.h>
26: # endif
27: # endif
28: #endif
29: #if TURBOC
30: # include <process.h>
31: #endif
32:
33: #ifndef NO_MODELINES
34: static void do_modelines(l, stop)
35: long l; /* line number to start at */
36: long stop; /* line number to stop at */
37: {
38: char *str; /* used to scan through the line */
39: char *start; /* points to the start of the line */
40: char buf[80];
41:
42: /* if modelines are disabled, then do nothing */
43: if (!*o_modelines)
44: {
45: return;
46: }
47:
48: /* for each line... */
49: for (; l <= stop; l++)
50: {
51: /* for each position in the line.. */
52: for (str = fetchline(l); *str; str++)
53: {
54: /* if it is the start of a modeline command... */
55: if ((str[0] == 'e' && str[1] == 'x'
56: || str[0] == 'v' && str[1] == 'i')
57: && str[2] == ':')
58: {
59: start = str += 3;
60:
61: /* find the end */
62: for (str = start + strlen(start); *--str != ':'; )
63: {
64: }
65:
66: /* if it is a well-formed modeline, execute it */
67: if (str > start && str - start < sizeof buf)
68: {
69: strncpy(buf, start, (int)(str - start));
70: exstring(buf, str - start, '\\');
71: break;
72: }
73: }
74: }
75: }
76: }
77: #endif
78:
79:
80: /* The FAIL() macro prints an error message and then exits. */
81: #define FAIL(why,arg) mode = MODE_EX; msg(why, arg); endwin(); exit(9)
82:
83: /* This is the name of the temp file */
84: static char tmpname[80];
85:
86: /* This function creates the temp file and copies the original file into it.
87: * Returns if successful, or stops execution if it fails.
88: */
89: int tmpstart(filename)
90: char *filename; /* name of the original file */
91: {
92: int origfd; /* fd used for reading the original file */
93: struct stat statb; /* stat buffer, used to examine inode */
94: REG BLK *this; /* pointer to the current block buffer */
95: REG BLK *next; /* pointer to the next block buffer */
96: int inbuf; /* number of characters in a buffer */
97: int nread; /* number of bytes read */
98: REG int j, k;
99: int i;
100: long nbytes;
101:
102: /* switching to a different file certainly counts as a change */
103: changes++;
104: redraw(MARK_UNSET, FALSE);
105:
106: /* open the original file for reading */
107: *origname = '\0';
108: if (filename && *filename)
109: {
110: strcpy(origname, filename);
111: origfd = open(origname, O_RDONLY);
112: if (origfd < 0 && errno != ENOENT)
113: {
114: msg("Can't open \"%s\"", origname);
115: return tmpstart("");
116: }
117: if (origfd >= 0)
118: {
119: if (stat(origname, &statb) < 0)
120: {
121: FAIL("Can't stat \"%s\"", origname);
122: }
123: #if TOS
124: if (origfd >= 0 && (statb.st_mode & S_IJDIR))
125: #else
126: # if OSK
127: if (origfd >= 0 && (statb.st_mode & S_IFDIR))
128: # else
129: if (origfd >= 0 && (statb.st_mode & S_IFMT) != S_IFREG)
130: # endif
131: #endif
132: {
133: msg("\"%s\" is not a regular file", origname);
134: return tmpstart("");
135: }
136: }
137: else
138: {
139: stat(".", &statb);
140: }
141: if (origfd >= 0)
142: {
143: origtime = statb.st_mtime;
144: #if OSK
145: if (*o_readonly || !(statb.st_mode &
146: ((getuid() >> 16) == 0 ? S_IOWRITE | S_IWRITE :
147: ((statb.st_gid != (getuid() >> 16) ? S_IOWRITE : S_IWRITE)))))
148: #endif
149: #if AMIGA || MSDOS
150: if (*o_readonly || !(statb.st_mode & S_IWRITE))
151: #endif
152: #if TOS
153: # ifdef __GNUC__
154: if (*o_readonly || !(statb.st_mode & S_IWRITE))
155: # else
156: if (*o_readonly || (statb.st_mode & S_IJRON))
157: # endif
158: #endif
159: #if ANY_UNIX
160: if (*o_readonly || !(statb.st_mode &
161: ((geteuid() == 0) ? 0222 :
162: ((statb.st_uid != geteuid() ? 0022 : 0200)))))
163: #endif
164: #if VMS
165: if (*o_readonly)
166: #endif
167: {
168: setflag(file, READONLY);
169: }
170: }
171: else
172: {
173: origtime = 0L;
174: }
175: }
176: else
177: {
178: setflag(file, NOFILE);
179: origfd = -1;
180: origtime = 0L;
181: stat(".", &statb);
182: }
183:
184: /* make a name for the tmp file */
185: tmpnum++;
186: #if MSDOS || TOS
187: /* MS-Dos doesn't allow multiple slashes, but supports drives
188: * with current directories.
189: * This relies on TMPNAME beginning with "%s\\"!!!!
190: */
191: strcpy(tmpname, o_directory);
192: if ((i = strlen(tmpname)) && !strchr(":/\\", tmpname[i-1]))
193: tmpname[i++]=SLASH;
194: sprintf(tmpname+i, TMPNAME+3, getpid(), tmpnum);
195: #else
196: sprintf(tmpname, TMPNAME, o_directory, getpid(), tmpnum);
197: #endif
198:
199: /* make sure nobody else is editing the same file */
200: if (access(tmpname, 0) == 0)
201: {
202: FAIL("Temp file \"%s\" already exists?", tmpname);
203: }
204:
205: /* create the temp file */
206: #if ANY_UNIX
207: close(creat(tmpname, 0600)); /* only we can read it */
208: #else
209: close(creat(tmpname, FILEPERMS)); /* anybody body can read it, alas */
210: #endif
211: tmpfd = open(tmpname, O_RDWR | O_BINARY);
212: if (tmpfd < 0)
213: {
214: FAIL("Can't create temp file... Does directory \"%s\" exist?", o_directory);
215: return 1;
216: }
217:
218: /* allocate space for the header in the file */
219: write(tmpfd, hdr.c, (unsigned)BLKSIZE);
220: write(tmpfd, tmpblk.c, (unsigned)BLKSIZE);
221:
222: #ifndef NO_RECYCLE
223: /* initialize the block allocator */
224: /* This must already be done here, before the first attempt
225: * to write to the new file! GB */
226: garbage();
227: #endif
228:
229: /* initialize lnum[] */
230: for (i = 1; i < MAXBLKS; i++)
231: {
232: lnum[i] = INFINITY;
233: }
234: lnum[0] = 0;
235:
236: /* if there is no original file, then create a 1-line file */
237: if (origfd < 0)
238: {
239: hdr.n[0] = 0; /* invalid inode# denotes new file */
240:
241: this = blkget(1); /* get the new text block */
242: strcpy(this->c, "\n"); /* put a line in it */
243:
244: lnum[1] = 1L; /* block 1 ends with line 1 */
245: nlines = 1L; /* there is 1 line in the file */
246: nbytes = 1L;
247:
248: if (*origname)
249: {
250: msg("\"%s\" [NEW FILE] 1 line, 1 char", origname);
251: }
252: else
253: {
254: msg("\"[NO FILE]\" 1 line, 1 char");
255: }
256: }
257: else /* there is an original file -- read it in */
258: {
259: nbytes = nlines = 0;
260:
261: /* preallocate 1 "next" buffer */
262: i = 1;
263: next = blkget(i);
264: inbuf = 0;
265:
266: /* loop, moving blocks from orig to tmp */
267: for (;;)
268: {
269: /* "next" buffer becomes "this" buffer */
270: this = next;
271:
272: /* read [more] text into this block */
273: nread = tread(origfd, &this->c[inbuf], BLKSIZE - 1 - inbuf);
274: if (nread < 0)
275: {
276: close(origfd);
277: close(tmpfd);
278: tmpfd = -1;
279: unlink(tmpname);
280: FAIL("Error reading \"%s\"", origname);
281: }
282:
283: /* convert NUL characters to something else */
284: for (j = k = inbuf; k < inbuf + nread; k++)
285: {
286: if (!this->c[k])
287: {
288: setflag(file, HADNUL);
289: this->c[j++] = 0x80;
290: }
291: #ifndef CRUNCH
292: else if (*o_beautify && this->c[k] < ' ' && this->c[k] >= 1)
293: {
294: if (this->c[k] == '\t'
295: || this->c[k] == '\n'
296: || this->c[k] == '\f')
297: {
298: this->c[j++] = this->c[k];
299: }
300: else if (this->c[k] == '\b')
301: {
302: /* delete '\b', but complain */
303: setflag(file, HADBS);
304: }
305: /* else silently delete control char */
306: }
307: #endif
308: else
309: {
310: this->c[j++] = this->c[k];
311: }
312: }
313: inbuf = j;
314:
315: /* if the buffer is empty, quit */
316: if (inbuf == 0)
317: {
318: goto FoundEOF;
319: }
320:
321: #if MSDOS || TOS
322: /* BAH! MS text mode read fills inbuf, then compresses eliminating \r
323: but leaving garbage at end of buf. The same is true for TURBOC. GB. */
324:
325: memset(this->c + inbuf, '\0', BLKSIZE - inbuf);
326: #endif
327:
328: /* search backward for last newline */
329: for (k = inbuf; --k >= 0 && this->c[k] != '\n';)
330: {
331: }
332: if (k++ < 0)
333: {
334: if (inbuf >= BLKSIZE - 1)
335: {
336: k = 80;
337: }
338: else
339: {
340: k = inbuf;
341: }
342: }
343:
344: /* allocate next buffer */
345: next = blkget(++i);
346:
347: /* move fragmentary last line to next buffer */
348: inbuf -= k;
349: for (j = 0; k < BLKSIZE; j++, k++)
350: {
351: next->c[j] = this->c[k];
352: this->c[k] = 0;
353: }
354:
355: /* if necessary, add a newline to this buf */
356: for (k = BLKSIZE - inbuf; --k >= 0 && !this->c[k]; )
357: {
358: }
359: if (this->c[k] != '\n')
360: {
361: setflag(file, ADDEDNL);
362: this->c[k + 1] = '\n';
363: }
364:
365: /* count the lines in this block */
366: for (k = 0; k < BLKSIZE && this->c[k]; k++)
367: {
368: if (this->c[k] == '\n')
369: {
370: nlines++;
371: }
372: nbytes++;
373: }
374: lnum[i - 1] = nlines;
375: }
376: FoundEOF:
377:
378: /* if this is a zero-length file, add 1 line */
379: if (nlines == 0)
380: {
381: this = blkget(1); /* get the new text block */
382: strcpy(this->c, "\n"); /* put a line in it */
383:
384: lnum[1] = 1; /* block 1 ends with line 1 */
385: nlines = 1; /* there is 1 line in the file */
386: nbytes = 1;
387: }
388:
389: #if MSDOS || TOS
390: /* each line has an extra CR that we didn't count yet */
391: nbytes += nlines;
392: #endif
393:
394: /* report the number of lines in the file */
395: msg("\"%s\" %s %ld line%s, %ld char%s",
396: origname,
397: (tstflag(file, READONLY) ? "[READONLY]" : ""),
398: nlines,
399: nlines == 1 ? "" : "s",
400: nbytes,
401: nbytes == 1 ? "" : "s");
402: }
403:
404: /* initialize the cursor to start of line 1 */
405: cursor = MARK_FIRST;
406:
407: /* close the original file */
408: close(origfd);
409:
410: /* any other messages? */
411: if (tstflag(file, HADNUL))
412: {
413: msg("This file contained NULs. They've been changed to \\x80 chars");
414: }
415: if (tstflag(file, ADDEDNL))
416: {
417: msg("Newline characters have been inserted to break up long lines");
418: }
419: #ifndef CRUNCH
420: if (tstflag(file, HADBS))
421: {
422: msg("Backspace characters deleted due to ':set beautify'");
423: }
424: #endif
425:
426: storename(origname);
427:
428: #ifndef NO_MODELINES
429: if (nlines > 10)
430: {
431: do_modelines(1L, 5L);
432: do_modelines(nlines - 4L, nlines);
433: }
434: else
435: {
436: do_modelines(1L, nlines);
437: }
438: #endif
439:
440: /* force all blocks out onto the disk, to support file recovery */
441: blksync();
442:
443: return 0;
444: }
445:
446:
447:
448: /* This function copies the temp file back onto an original file.
449: * Returns TRUE if successful, or FALSE if the file could NOT be saved.
450: */
451: int tmpsave(filename, bang)
452: char *filename; /* the name to save it to */
453: int bang; /* forced write? */
454: {
455: int fd; /* fd of the file we're writing to */
456: REG int len; /* length of a text block */
457: REG BLK *this; /* a text block */
458: long bytes; /* byte counter */
459: REG int i;
460:
461: /* if no filename is given, assume the original file name */
462: if (!filename || !*filename)
463: {
464: filename = origname;
465: }
466:
467: /* if still no file name, then fail */
468: if (!*filename)
469: {
470: msg("Don't know a name for this file -- NOT WRITTEN");
471: return FALSE;
472: }
473:
474: /* can't rewrite a READONLY file */
475: if (!strcmp(filename, origname) && tstflag(file, READONLY) && !bang)
476: {
477: msg("\"%s\" [READONLY] -- NOT WRITTEN", filename);
478: return FALSE;
479: }
480:
481: /* open the file */
482: if (*filename == '>' && filename[1] == '>')
483: {
484: filename += 2;
485: while (*filename == ' ' || *filename == '\t')
486: {
487: filename++;
488: }
489: #ifdef O_APPEND
490: fd = open(filename, O_WRONLY|O_APPEND);
491: #else
492: fd = open(filename, O_WRONLY);
493: lseek(fd, 0L, 2);
494: #endif
495: }
496: else
497: {
498: /* either the file must not exist, or it must be the original
499: * file, or we must have a bang, or "writeany" must be set.
500: */
501: if (strcmp(filename, origname) && access(filename, 0) == 0 && !bang
502: #ifndef CRUNCH
503: && !*o_writeany
504: #endif
505: )
506: {
507: msg("File already exists - Use :w! to overwrite");
508: return FALSE;
509: }
510: #if VMS
511: /* Create a new VMS version of this file. */
512: {
513: char *strrchr(), *ptr = strrchr(filename,';');
514: if (ptr) *ptr = '\0'; /* Snip off any ;number in the name */
515: }
516: #endif
517: fd = creat(filename, FILEPERMS);
518: }
519: if (fd < 0)
520: {
521: msg("Can't write to \"%s\" -- NOT WRITTEN", filename);
522: return FALSE;
523: }
524:
525: /* write each text block to the file */
526: bytes = 0L;
527: for (i = 1; i < MAXBLKS && (this = blkget(i)) && this->c[0]; i++)
528: {
529: for (len = 0; len < BLKSIZE && this->c[len]; len++)
530: {
531: }
532: if (twrite(fd, this->c, len) < len)
533: {
534: msg("Trouble writing to \"%s\"", filename);
535: if (!strcmp(filename, origname))
536: {
537: setflag(file, MODIFIED);
538: }
539: close(fd);
540: return FALSE;
541: }
542: bytes += len;
543: }
544:
545: /* reset the "modified" flag, but not the "undoable" flag */
546: clrflag(file, MODIFIED);
547: significant = FALSE;
548: if (!strcmp(origname, filename))
549: {
550: exitcode |= 1;
551: }
552:
553: /* report lines & characters */
554: #if MSDOS || TOS
555: bytes += nlines; /* for the inserted carriage returns */
556: #endif
557: msg("Wrote \"%s\" %ld lines, %ld characters", filename, nlines, bytes);
558:
559: /* close the file */
560: close(fd);
561:
562: return TRUE;
563: }
564:
565:
566: /* This function deletes the temporary file. If the file has been modified
567: * and "bang" is FALSE, then it returns FALSE without doing anything; else
568: * it returns TRUE.
569: *
570: * If the "autowrite" option is set, then instead of returning FALSE when
571: * the file has been modified and "bang" is false, it will call tmpend().
572: */
573: int tmpabort(bang)
574: int bang;
575: {
576: /* if there is no file, return successfully */
577: if (tmpfd < 0)
578: {
579: return TRUE;
580: }
581:
582: /* see if we must return FALSE -- can't quit */
583: if (!bang && tstflag(file, MODIFIED))
584: {
585: /* if "autowrite" is set, then act like tmpend() */
586: if (*o_autowrite)
587: return tmpend(bang);
588: else
589: return FALSE;
590: }
591:
592: /* delete the tmp file */
593: cutswitch();
594: strcpy(prevorig, origname);
595: prevline = markline(cursor);
596: *origname = '\0';
597: origtime = 0L;
598: blkinit();
599: nlines = 0;
600: initflags();
601: return TRUE;
602: }
603:
604: /* This function saves the file if it has been modified, and then deletes
605: * the temporary file. Returns TRUE if successful, or FALSE if the file
606: * needs to be saved but can't be. When it returns FALSE, it will not have
607: * deleted the tmp file, either.
608: */
609: int tmpend(bang)
610: int bang;
611: {
612: /* save the file if it has been modified */
613: if (tstflag(file, MODIFIED) && !tmpsave((char *)0, FALSE) && !bang)
614: {
615: return FALSE;
616: }
617:
618: /* delete the tmp file */
619: tmpabort(TRUE);
620:
621: return TRUE;
622: }
623:
624:
625: /* If the tmp file has been changed, then this function will force those
626: * changes to be written to the disk, so that the tmp file will survive a
627: * system crash or power failure.
628: */
629: #if AMIGA || MSDOS || TOS
630: sync()
631: {
632: /* MS-DOS and TOS don't flush their buffers until the file is closed,
633: * so here we close the tmp file and then immediately reopen it.
634: */
635: close(tmpfd);
636: tmpfd = open(tmpname, O_RDWR | O_BINARY);
637: return 0;
638: }
639: #endif
640:
641:
642: /* This function stores the file's name in the second block of the temp file.
643: * SLEAZE ALERT! SLEAZE ALERT! The "tmpblk" buffer is probably being used
644: * to store the arguments to a command, so we can't use it here. Instead,
645: * we'll borrow the buffer that is used for "shift-U".
646: */
647: int
648: storename(name)
649: char *name; /* the name of the file - normally origname */
650: {
651: #ifndef CRUNCH
652: int len;
653: char *ptr;
654: #endif
655:
656: /* we're going to clobber the U_text buffer, so reset U_line */
657: U_line = 0L;
658:
659: if (!name)
660: {
661: strncpy(U_text, "", BLKSIZE);
662: U_text[1] = 127;
663: }
664: #ifndef CRUNCH
665: else if (*name != SLASH)
666: {
667: /* get the directory name */
668: ptr = getcwd(U_text, BLKSIZE);
669: if (ptr != U_text)
670: {
671: strcpy(U_text, ptr);
672: }
673:
674: /* append a slash to the directory name */
675: len = strlen(U_text);
676: U_text[len++] = SLASH;
677:
678: /* append the filename, padded with heaps o' NULs */
679: strncpy(U_text + len, *name ? name : "foo", BLKSIZE - len);
680: }
681: #endif
682: else
683: {
684: /* copy the filename into U_text */
685: strncpy(U_text, *name ? name : "foo", BLKSIZE);
686: }
687:
688: if (tmpfd >= 0)
689: {
690: /* write the name out to second block of the temp file */
691: lseek(tmpfd, (long)BLKSIZE, 0);
692: write(tmpfd, U_text, (unsigned)BLKSIZE);
693: }
694: return 0;
695: }
696:
697:
698:
699: /* This function handles deadly signals. It restores sanity to the terminal
700: * preserves the current temp file, and deletes any old temp files.
701: */
702: int deathtrap(sig)
703: int sig; /* the deadly signal that we caught */
704: {
705: char *why;
706:
707: /* restore the terminal's sanity */
708: endwin();
709:
710: #ifdef CRUNCH
711: why = "-Elvis died";
712: #else
713: /* give a more specific description of how Elvis died */
714: switch (sig)
715: {
716: # ifdef SIGHUP
717: case SIGHUP: why = "-the modem lost its carrier"; break;
718: # endif
719: # ifndef DEBUG
720: # ifdef SIGILL
721: case SIGILL: why = "-Elvis hit an illegal instruction"; break;
722: # endif
723: # ifdef SIGBUS
724: case SIGBUS: why = "-Elvis had a bus error"; break;
725: # endif
726: # ifdef SIGSEGV
727: # if !TOS
728: case SIGSEGV: why = "-Elvis had a segmentation violation"; break;
729: # endif
730: # endif
731: # ifdef SIGSYS
732: case SIGSYS: why = "-Elvis munged a system call"; break;
733: # endif
734: # endif /* !DEBUG */
735: # ifdef SIGPIPE
736: case SIGPIPE: why = "-the pipe reader died"; break;
737: # endif
738: # ifdef SIGTERM
739: case SIGTERM: why = "-Elvis was terminated"; break;
740: # endif
741: # if !MINIX
742: # ifdef SIGUSR1
743: case SIGUSR1: why = "-Elvis was killed via SIGUSR1"; break;
744: # endif
745: # ifdef SIGUSR2
746: case SIGUSR2: why = "-Elvis was killed via SIGUSR2"; break;
747: # endif
748: # endif
749: default: why = "-Elvis died"; break;
750: }
751: #endif
752:
753: /* if we had a temp file going, then preserve it */
754: if (tmpnum > 0 && tmpfd >= 0)
755: {
756: close(tmpfd);
757: sprintf(tmpblk.c, "%s \"%s\" %s", PRESERVE, why, tmpname);
758: system(tmpblk.c);
759: }
760:
761: /* delete any old temp files */
762: cutend();
763:
764: /* exit with the proper exit status */
765: exit(sig);
766: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.