![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to file.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 / me|
Return to file.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / me |
1.1 root 1: /*
2: * The routines in this file handle the reading and writing of disk files.
3: * All of details about the reading and writing of the disk are in "fileio.c".
4: */
5: #include <stdio.h>
6: #include "ed.h"
7:
8: /*
9: * Read a file into the current buffer.
10: * This is really easy; all you do it find the name of the file and call
11: * the standard "read a file into the current buffer" code.
12: * Bound to "C-X C-R".
13: */
14: fileread(f, n)
15: {
16: register int s;
17: uchar fname[NFILEN];
18:
19: if ((s=mlreply("Read file: ", fname, NFILEN)) != TRUE)
20: return (s);
21: #if GEM
22: fixname(fname);
23: #endif
24: return (readin(fname));
25: }
26:
27: /*
28: * Select a file for editing.
29: * Look around to see if you can find the file in another buffer;
30: * if you can find it just switch to the buffer. If you cannot find
31: * the file, create a new buffer, read in the text, and switch to the
32: * new buffer.
33: * Bound to C-X C-V.
34: */
35: filevisit(f, n)
36: {
37: uchar fname[NFILEN];
38: int s;
39:
40: if ((s=mlreply("Visit file: ", fname, NFILEN)) != TRUE)
41: return (s);
42: #if GEM
43: fixname(fname);
44: #endif
45: return visitfile(fname);
46: }
47:
48: /* Real file visit routine... */
49: visitfile(fname)
50: uchar fname[];
51: {
52: register BUFFER *bp;
53: register WINDOW *wp;
54: register LINE *lp;
55: register int i;
56: register int s;
57: uchar bname[NBUFN];
58:
59: for (bp=bheadp; bp!=NULL; bp=bp->b_bufp) {
60: if ((bp->b_flag&BFTEMP)==0 && strcmp(bp->b_fname, fname)==0) {
61: if (--curbp->b_nwnd == 0) {
62: curbp->b_dotp = curwp->w_dotp;
63: curbp->b_doto = curwp->w_doto;
64: curbp->b_markp = curwp->w_markp;
65: curbp->b_marko = curwp->w_marko;
66: }
67: curbp = bp;
68: curwp->w_bufp = bp;
69: if (bp->b_nwnd++ == 0) {
70: curwp->w_dotp = bp->b_dotp;
71: curwp->w_doto = bp->b_doto;
72: curwp->w_markp = bp->b_markp;
73: curwp->w_marko = bp->b_marko;
74: } else {
75: wp = wheadp;
76: while (wp != NULL) {
77: if (wp!=curwp && wp->w_bufp==bp) {
78: curwp->w_dotp = wp->w_dotp;
79: curwp->w_doto = wp->w_doto;
80: curwp->w_markp = wp->w_markp;
81: curwp->w_marko = wp->w_marko;
82: break;
83: }
84: wp = wp->w_wndp;
85: }
86: }
87: lp = curwp->w_dotp;
88: i = curwp->w_ntrows/2;
89: while (i-- && lback(lp)!=curbp->b_linep)
90: lp = lback(lp);
91: curwp->w_linep = lp;
92: curwp->w_flag |= WFMODE|WFHARD;
93: mlwrite("[Old buffer]");
94: return (TRUE);
95: }
96: }
97: makename(bname, fname); /* New buffer name. */
98: while ((bp=bfind(bname, FALSE, 0)) != NULL) {
99: s = mlreply("Buffer name: ", bname, NBUFN);
100: #if GEM
101: fixname(bname);
102: #endif
103: if (s == ABORT) /* ^G to just quit */
104: return (s);
105: if (s == FALSE) { /* CR to clobber it */
106: makename(bname, fname);
107: break;
108: }
109: }
110: if (bp==NULL && (bp=bfind(bname, TRUE, 0))==NULL) {
111: mlwrite("Cannot create buffer");
112: return (FALSE);
113: }
114: if (--curbp->b_nwnd == 0) { /* Undisplay. */
115: curbp->b_dotp = curwp->w_dotp;
116: curbp->b_doto = curwp->w_doto;
117: curbp->b_markp = curwp->w_markp;
118: curbp->b_marko = curwp->w_marko;
119: }
120: curbp = bp; /* Switch to it. */
121: curwp->w_bufp = bp;
122: curbp->b_nwnd++;
123: return (readin(fname)); /* Read it in. */
124: }
125:
126: /*
127: * Read file "fname" into the current buffer, blowing away any text found
128: * there. Called by both the read and visit commands. Return the final
129: * status of the read. Also called by the mainline, to read in a file
130: * specified on the command line as an argument.
131: */
132: readin(fname)
133: uchar fname[];
134: {
135: register LINE *lp1;
136: register LINE *lp2;
137: register int i;
138: register WINDOW *wp;
139: register BUFFER *bp;
140: register int s;
141: register int nbytes;
142: register int nline;
143: uchar line[NLINE];
144:
145: mlwrite(" ");
146: bp = curbp; /* Cheap. */
147: if ((s=bclear(bp)) != TRUE) /* Might be old. */
148: return (s);
149: bp->b_flag &= ~(BFTEMP|BFCHG|BFTRUNC);
150: strcpy(bp->b_fname, fname);
151: switch (s=ffropen(fname)) { /* file open */
152: case FIOERR: /* file exists but cannot read */
153: mlwrite("[Cannot read %s]", fname);
154: goto out;
155: case FIOFNF: /* File not found. */
156: mlwrite("[New file: %s]", fname);
157: goto out;
158: }
159: mlwrite("[Reading file %s]", fname);
160: nline = 0;
161: while ((s=ffgetline(line, NLINE)) == FIOSUC) {
162: nbytes = strlen(line);
163: if ((lp1=lalloc(nbytes)) == NULL) {
164: mlwrite("File too large for available memory!");
165: bp->b_flag |= BFTRUNC; /* Mark buffer truncated */
166: s = FIOERR; /* Keep message on the */
167: break; /* display. */
168: }
169: lp2 = lback(curbp->b_linep);
170: lforw(lp2) = lp1;
171: lforw(lp1) = curbp->b_linep;
172: lback(lp1) = lp2;
173: lback(curbp->b_linep) = lp1;
174: lp1->l_lnumber = ++nline;
175: #ifdef SLOW
176: for (i=0; i<nbytes; ++i)
177: lputc(lp1, i, line[i]);
178: #else
179: strncpy(lp1->l_text, line, nbytes);
180: #endif
181: }
182: ffclose(); /* Ignore errors. */
183: if (s == FIOEOF) { /* Don't zap message! */
184: if (nline == 1)
185: mlwrite("[Read 1 line]");
186: else
187: mlwrite("[Read %d lines]", nline);
188: }
189: out:
190: for (wp=wheadp; wp!=NULL; wp=wp->w_wndp) {
191: if (wp->w_bufp == curbp) {
192: wp->w_linep = lforw(curbp->b_linep);
193: wp->w_dotp = lforw(curbp->b_linep);
194: wp->w_doto = 0;
195: wp->w_markp = NULL;
196: wp->w_marko = 0;
197: wp->w_flag |= WFMODE|WFHARD;
198: }
199: }
200: if (s == FIOERR) /* False if error. */
201: return (FALSE);
202: return (TRUE);
203: }
204:
205: /*
206: * Take a file name, and from it fabricate a buffer name.
207: * This routine knows about the syntax of file names on the target system.
208: * I suppose that this information could be put in a better place than a
209: * line of code.
210: */
211: makename(bname, fname)
212: uchar bname[];
213: uchar fname[];
214: {
215: register uchar *cp1;
216: register uchar *cp2;
217:
218: cp1 = &fname[0];
219: while (*cp1 != 0)
220: ++cp1;
221: #if VMS
222: while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!=']')
223: --cp1;
224: #endif
225: #if CPM
226: while (cp1!=&fname[0] && cp1[-1]!=':')
227: --cp1;
228: #endif
229: #if MSDOS || GEM
230: while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!='\\')
231: --cp1;
232: #endif
233: #if V7
234: while (cp1!=&fname[0] && cp1[-1]!='/')
235: --cp1;
236: #endif
237: cp2 = &bname[0];
238: while (cp2!=&bname[NBUFN-1] && *cp1!=0 && *cp1!=';')
239: *cp2++ = *cp1++;
240: *cp2 = 0;
241: }
242:
243: /*
244: * Ask for a file name, and write the contents of the current buffer to
245: * that file. Update the remembered file name and clear the buffer changed
246: * flag. This handling of file names is different from the earlier versions,
247: * and is more compatable with Gosling EMACS than with ITS EMACS.
248: * Bound to "C-X C-W".
249: */
250: filewrite(f, n)
251: {
252: register WINDOW *wp;
253: register int s;
254: uchar fname[NFILEN];
255:
256: if ((s=mlreply("Write file: ", fname, NFILEN)) != TRUE)
257: return (s);
258: #if GEM
259: fixname(fname);
260: #endif
261: if ((s=writeout(fname)) == TRUE) {
262: strcpy(curbp->b_fname, fname);
263: curbp->b_flag &= ~BFCHG;
264: wp = wheadp; /* Update mode lines. */
265: while (wp != NULL) {
266: if (wp->w_bufp == curbp)
267: wp->w_flag |= WFMODE;
268: wp = wp->w_wndp;
269: }
270: }
271: return (s);
272: }
273:
274: /*
275: * Save the contents of the current buffer in its associatd file. No nothing
276: * if nothing has changed (this may be a bug, not a feature). Error if there is
277: * no remembered file name for the buffer. Bound to "C-X C-S".
278: * May get called by "C-Z".
279: */
280: filesave(f, n)
281: {
282: register WINDOW *wp;
283: register int s;
284:
285: if ((curbp->b_flag&BFCHG) == 0) /* Return, no changes. */
286: return (TRUE);
287: if (curbp->b_fname[0] == 0) { /* Must have a name. */
288: mlwrite("No file name");
289: return (FALSE);
290: }
291: if ((curbp->b_flag & BFTRUNC) != 0) { /* If file was truncated... */
292: if (mlyesno("File was truncated -- write it anyway") != TRUE)
293: return (FALSE);
294: }
295: if ((s=writeout(curbp->b_fname)) == TRUE) {
296: curbp->b_flag &= ~(BFCHG|BFTRUNC);
297: wp = wheadp; /* Update mode lines. */
298: while (wp != NULL) {
299: if (wp->w_bufp == curbp)
300: wp->w_flag |= WFMODE;
301: wp = wp->w_wndp;
302: }
303: }
304: return (s);
305: }
306:
307: /*
308: * This function performs the details of file writing.
309: * Uses the file management routines in the "fileio.c" package.
310: * The number of lines written is displayed. Sadly, it looks inside a LINE;
311: * provide a macro for this. Most of the grief is error checking of some sort.
312: */
313: writeout(fn)
314: uchar *fn;
315: {
316: register int s;
317: register LINE *lp;
318: register int nline;
319:
320: if ((s=ffwopen(fn, "w")) != FIOSUC) /* Open writes message. */
321: return (FALSE);
322: lp = lforw(curbp->b_linep); /* First line. */
323: nline = 0; /* Number of lines. */
324: while (lp != curbp->b_linep) {
325: if ((s=ffputline(&lp->l_text[0], llength(lp))) != FIOSUC)
326: break;
327: ++nline;
328: lp = lforw(lp);
329: }
330: if (s == FIOSUC) { /* No write error. */
331: s = ffclose();
332: if (s == FIOSUC) { /* No close error. */
333: curbp->b_flag |= BFWRITE; /* Written... */
334: if (nline == 1)
335: mlwrite("[Wrote 1 line]");
336: else
337: mlwrite("[Wrote %d lines]", nline);
338: }
339: } else /* Ignore close error */
340: ffclose(); /* if a write error. */
341:
342: sync(); /* protect filesystem */
343:
344: if (s != FIOSUC) /* Some sort of error. */
345: return (FALSE);
346: return (TRUE);
347: }
348:
349: /*
350: * The command allows the user to modify the file name associated with
351: * the current buffer. It is like the "f" command in UNIX "ed".
352: * The operation is simple; just zap the name in the BUFFER structure,
353: * and mark the windows as needing an update. You can type a blank line at
354: * the prompt if you wish.
355: */
356: filename(f, n)
357: {
358: register WINDOW *wp;
359: register int s;
360: uchar fname[NFILEN];
361:
362: if ((s=mlreply("Name: ", fname, NFILEN)) == ABORT)
363: return (s);
364: #if GEM
365: fixname(fname);
366: #endif
367: if (s == FALSE)
368: strcpy(curbp->b_fname, "");
369: else
370: strcpy(curbp->b_fname, fname);
371: wp = wheadp; /* Update mode lines. */
372: while (wp != NULL) {
373: if (wp->w_bufp == curbp)
374: wp->w_flag |= WFMODE;
375: wp = wp->w_wndp;
376: }
377: return (TRUE);
378: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.