![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to EDiskSrc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xmh|
Return to EDiskSrc.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xmh |
1.1 root 1: #ifndef lint
2: static char rcs_id[] = "$Header: EDiskSrc.c,v 1.13 87/09/11 08:19:00 toddb Exp $";
3: #endif lint
4: /*
5: * COPYRIGHT 1987
6: * DIGITAL EQUIPMENT CORPORATION
7: * MAYNARD, MASSACHUSETTS
8: * ALL RIGHTS RESERVED.
9: *
10: * THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND
11: * SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
12: * DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR
13: * ANY PURPOSE. IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
14: *
15: * IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT RIGHTS,
16: * APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN ADDITION TO THAT
17: * SET FORTH ABOVE.
18: *
19: *
20: * Permission to use, copy, modify, and distribute this software and its
21: * documentation for any purpose and without fee is hereby granted, provided
22: * that the above copyright notice appear in all copies and that both that
23: * copyright notice and this permission notice appear in supporting documentation,
24: * and that the name of Digital Equipment Corporation not be used in advertising
25: * or publicity pertaining to distribution of the software without specific,
26: * written prior permission.
27: */
28:
29: /* File: EDiskSource.c */
30:
31: /* This is a rather simplistic text source. It allows editing of a disk file.
32: It divides the file into blocks of BUFSIZE characters. No block is
33: actually read in from disk until referenced; each block will be read at
34: most once. Thus, the entire file can eventually be read into memory and
35: stored there. When the save function is called, everything gets written
36: back. */
37:
38:
39:
40: #include <sys/types.h>
41: #include <sys/stat.h>
42: #include <sys/file.h>
43:
44: #include "xmh.h"
45:
46:
47: /* Private definitions. */
48:
49: #define BUFSIZE 512 /* Number of chars to store in each piece. */
50:
51: extern char *strcpy();
52: extern long lseek();
53:
54: /* The structure corresponding to each piece of the file in memory. */
55:
56: typedef struct {
57: char *buf; /* Pointer to this piece's data. */
58: int length; /* Number of chars used in buf. */
59: int maxlength; /* Number of chars allocated in buf. */
60: long start; /* Position in file corresponding to piece. */
61: } PieceRec, *PiecePtr;
62:
63:
64:
65: /* The master structure for the source. */
66:
67: typedef struct {
68: int file; /* File descriptor. */
69: char *name; /* Name of file. */
70: int length; /* Number of characters in file. */
71: int origlength; /* Number of characters originally in file. */
72: int numpieces; /* How many pieces the file is divided in. */
73: PiecePtr piece; /* Pointer to array of pieces. */
74: short changed; /* If changes have not been written to disk. */
75: short everchanged; /* If changes have ever been made. */
76: short startsvalid; /* True iff the start fields in pieces
77: are correct. */
78: short eversaved; /* If we've ever saved changes to the file. */
79: XtEditType editMode; /* Whether we are editing or read-only. */
80: void (*func)(); /* Function to call when a change is made. */
81: caddr_t param; /* Parameter to pass to above function. */
82: int checkpointed; /* Filename to store checkpoints. */
83: int checkpointchange; /* TRUE if we've changed since checkpointed. */
84: } EDiskRec, *EDiskPtr;
85:
86:
87:
88: /* Refigure the starting location of each piece, which is the sum of the
89: lengths of all the preceding pieces. */
90:
91: static CalculateStarts(data)
92: EDiskPtr data;
93: {
94: int i;
95: PiecePtr piece;
96: long start = 0;
97: for (i = 0, piece = data->piece; i < data->numpieces; i++, piece++) {
98: piece->start = start;
99: start += piece->length;
100: }
101: data->startsvalid = TRUE;
102: }
103:
104:
105:
106: /* Read in the text for the ith piece. */
107:
108: static ReadPiece(data, i)
109: EDiskPtr data;
110: int i;
111: {
112: PiecePtr piece = data->piece + i;
113: piece->maxlength = piece->length;
114: piece->buf = XtMalloc((unsigned) piece->maxlength);
115: (void)lseek(data->file, (long) i * BUFSIZE, 0);
116: (void)read(data->file, piece->buf, piece->length);
117: }
118:
119:
120:
121: /* Figure out which piece corresponds to the given position. If this source
122: has never had any changes, then this is a simple matter of division;
123: otherwise, we have to search for the specified piece. (Currently, this is
124: a simple linear search; a binary one would probably be better.) */
125:
126: static PiecePtr PieceFromPosition(data, position)
127: EDiskPtr data;
128: XtTextPosition position;
129: {
130: int i;
131: PiecePtr piece;
132: if (!data->everchanged) {
133: i = position / BUFSIZE;
134: if (i >= data->numpieces) i = data->numpieces - 1;
135: piece = data->piece + i;
136: } else {
137: if (!data->startsvalid)
138: CalculateStarts(data);
139: for (i = 0, piece = data->piece; i < data->numpieces - 1; i++, piece++)
140: if (position < piece->start + piece->length)
141: break;
142: }
143: if (!piece->buf) ReadPiece(data, i);
144: return piece;
145: }
146:
147:
148: /* Return the given position, coerced to be within the range of legal positions
149: for the given source. */
150:
151: static XtTextPosition CoerceToLegalPosition(data, position)
152: EDiskPtr data;
153: XtTextPosition position;
154: {
155: return (position < 0) ? 0 :
156: ((position > data->length) ? data->length : position);
157: }
158:
159:
160:
161: /* Semi-public definitions */
162:
163: /* Reads in the text for the given range. Will not read past a piece boundary.
164: Returns the position after the last character that was read. */
165:
166: static EDiskReadText(src, position, text, maxRead)
167: XtTextSource *src;
168: XtTextPosition position; /* Starting position to read. */
169: XtTextBlock *text; /* RETURN - the text read. */
170: int maxRead; /* Number of positions to read. */
171: {
172: EDiskPtr data = (EDiskPtr) src->data;
173: PiecePtr piece;
174: int count;
175: text->firstPos = position;
176: if (position < data->length) {
177: piece = PieceFromPosition(data, position);
178: text->ptr = piece->buf + (position - piece->start);
179: count = piece->length - (position - piece->start);
180: text->length = (count < maxRead) ? count : maxRead;
181: }
182: else {
183: text->length = 0;
184: text->ptr = "";
185: }
186: return position + text->length;
187: }
188:
189:
190:
191:
192: /* Replace the text between startPos and endPos with the given text. Returns
193: EDITDONE on success, or EDITERROR if this source is read-only. */
194:
195:
196: static int EDiskReplaceText(src, startPos, endPos, text, delta)
197: XtTextSource *src;
198: XtTextPosition startPos, endPos;
199: XtTextBlock *text;
200: int *delta; /* RETURN - change in length of source. */
201: {
202: EDiskPtr data = (EDiskPtr) src->data;
203: PiecePtr piece, piece2;
204: int oldlength = endPos - startPos;
205: int i;
206: int del = text->length - oldlength;
207: if (del == 0 && oldlength == 0) {
208: *delta = 0;
209: return EDITDONE;
210: }
211: if (data->editMode != XttextEdit)
212: return EDITERROR;
213: data->length += del;
214: piece = PieceFromPosition(data, startPos);
215: if (oldlength > 0) {
216: piece2 = PieceFromPosition(data, endPos - 1);
217: if (piece != piece2) {
218: oldlength = endPos - piece2->start;
219: piece2->length -= oldlength;
220: for (i = 0; i < piece2->length; i++)
221: piece2->buf[i] = piece2->buf[i + oldlength];
222: for (piece2--; piece2 > piece; piece2--)
223: piece2->length = 0;
224: oldlength = piece->length - (startPos - piece->start);
225: del = text->length - oldlength;
226: }
227: }
228: data->changed = data->everchanged = data->checkpointchange = TRUE;
229: data->startsvalid = FALSE;
230: piece->length += del;
231: if (piece->length > piece->maxlength) {
232: do
233: piece->maxlength *= 2;
234: while (piece->length > piece->maxlength);
235: piece->buf = XtRealloc(piece->buf, (unsigned)piece->maxlength);
236: }
237: if (del < 0) /* insert shorter than delete, text getting
238: shorter */
239: for (i = startPos - piece->start; i < piece->length; i++)
240: piece->buf[i] = piece->buf[i - del];
241: else
242: if (del > 0) /* insert longer than delete, text getting
243: longer */
244: for (i = piece->length - del - 1;
245: i >= startPos - piece->start;
246: i--)
247: piece->buf[i + del] = piece->buf[i];
248: if (text->length) /* do insert */
249: for (i = 0; i < text->length; ++i)
250: if ((piece->buf[startPos - piece->start + i] = text->ptr[i]) == CR)
251: piece->buf[startPos - piece->start + i] = LF;
252: *delta = text->length - (endPos - startPos);
253: if (data->func) (*data->func)(data->param);
254: return EDITDONE;
255: }
256:
257:
258: /* Returns the last legal position in the source. */
259:
260: static XtTextPosition EDiskGetLastPos(src)
261: XtTextSource *src;
262: {
263: return ((EDiskPtr) src->data)->length;
264: }
265:
266:
267: /* Sets the last legal position in the source. This is actually an obsolete
268: source request, and is therefore a noop. */
269:
270: /*ARGSUSED*/ /* -- keeps lint from complaining. */
271: static EDiskSetLastPos(src)
272: XtTextSource *src;
273: {
274: }
275:
276:
277: /* Utility macro used in EDiskScan. Used to determine what the next character
278: "after" index is, where "after" is either left or right, depending on
279: what kind of search we're doing. */
280:
281: #define Look(index, c)\
282: { \
283: if ((dir == XtsdLeft && index <= 0) || \
284: (dir == XtsdRight && index >= data->length)) \
285: c = 0; \
286: else { \
287: if (index + doff < piece->start || \
288: index + doff >= piece->start + piece->length) \
289: piece = PieceFromPosition(data, index + doff); \
290: c = piece->buf[index + doff - piece->start]; \
291: } \
292: }
293:
294:
295:
296: /* Scan the source. This gets complicated, but should be explained wherever
297: it is that we documented sources. */
298:
299: static XtTextPosition EDiskScan(src, position, sType, dir, count, include)
300: XtTextSource *src;
301: XtTextPosition position;
302: ScanType sType;
303: ScanDirection dir;
304: int count, include;
305: {
306: EDiskPtr data = (EDiskPtr) src->data;
307: XtTextPosition index;
308: PiecePtr piece;
309: char c;
310: int ddir, doff, i, whiteSpace;
311: ddir = (dir == XtsdRight) ? 1 : -1;
312: doff = (dir == XtsdRight) ? 0 : -1;
313:
314: index = position;
315: piece = data->piece;
316: if (!piece->buf) ReadPiece(data, 0);
317: switch (sType) {
318: case XtstPositions:
319: if (!include && count > 0)
320: count--;
321: index = CoerceToLegalPosition(data, index + count * ddir);
322: break;
323: case XtstWhiteSpace:
324: for (i = 0; i < count; i++) {
325: whiteSpace = -1;
326: while (index >= 0 && index <= data->length) {
327: Look(index, c);
328: if ((c == ' ') || (c == '\t') || (c == '\n')) {
329: if (whiteSpace < 0) whiteSpace = index;
330: } else if (whiteSpace >= 0)
331: break;
332: index += ddir;
333: }
334: }
335: if (!include) {
336: if (whiteSpace < 0 && dir == XtsdRight)
337: whiteSpace = data->length;
338: index = whiteSpace;
339: }
340: index = CoerceToLegalPosition(data, index);
341: break;
342: case XtstEOL:
343: for (i = 0; i < count; i++) {
344: while (index >= 0 && index <= data->length) {
345: Look(index, c);
346: if (c == '\n')
347: break;
348: index += ddir;
349: }
350: if (i < count - 1)
351: index += ddir;
352: }
353: if (include)
354: index += ddir;
355: index = CoerceToLegalPosition(data, index);
356: break;
357: case XtstFile:
358: if (dir == XtsdLeft)
359: index = 0;
360: else
361: index = data->length;
362: break;
363: }
364: return index;
365: }
366:
367:
368: /* Return what the editting mode of this source is. */
369:
370: static XtEditType EDiskGetEditType(src)
371: XtTextSource *src;
372: {
373: EDiskPtr data = (EDiskPtr) src->data;
374: return data->editMode;
375: }
376:
377:
378:
379: /* Public definitions. */
380:
381: /* Create a new text source from the given file, and the given edit mode. */
382:
383: XtTextSource *XtCreateEDiskSource(name, mode)
384: char *name;
385: XtEditType mode;
386: {
387: XtTextSource * src;
388: EDiskPtr data;
389: struct stat stat;
390: int i;
391: src = (XtTextSource *) XtMalloc(sizeof(XtTextSource));
392: src->read = EDiskReadText;
393: src->replace = EDiskReplaceText;
394: src->getLastPos = EDiskGetLastPos;
395: src->setLastPos = EDiskSetLastPos;
396: src->editType = EDiskGetEditType;
397: src->scan = EDiskScan;
398: data = (EDiskPtr) XtMalloc(sizeof(EDiskRec));
399: src->data = (int *) data;
400: data->editMode = mode;
401: data->file = myopen(name, O_RDONLY | O_CREAT, 0666);
402: data->name = strcpy(XtMalloc((unsigned)strlen(name) + 1), name);
403: (void)fstat(data->file, &stat);
404: data->length = data->origlength = stat.st_size;
405: data->numpieces = (data->length + BUFSIZE - 1) / BUFSIZE;
406: if (data->numpieces < 1)
407: data->numpieces = 1;
408: data->piece = (PiecePtr)
409: XtMalloc((unsigned) data->numpieces * sizeof(PieceRec));
410: for (i = 0; i < data->numpieces; i++) {
411: data->piece[i].buf = 0;
412: data->piece[i].length = BUFSIZE;
413: data->piece[i].start = i * BUFSIZE;
414: }
415: data->piece[data->numpieces - 1].length -=
416: data->numpieces * BUFSIZE - data->length;
417: data->startsvalid = TRUE;
418: data->changed = data->everchanged = data->eversaved = FALSE;
419: data->checkpointed = data->checkpointchange = FALSE;
420: data->func = NULL;
421: if (data->length == 0) {
422: data->piece[0].buf = XtMalloc(1);
423: data->piece[0].maxlength = 1;
424: }
425: return src;
426: }
427:
428:
429:
430: /* Change the editing mode of a source. */
431:
432: XtEDiskChangeEditMode(src, editMode)
433: XtTextSource *src;
434: XtEditType editMode;
435: {
436: EDiskPtr data = (EDiskPtr) src->data;
437: data->editMode = editMode;
438: }
439:
440:
441:
442: /* Call the given function with the given parameter whenever the source is
443: changed. */
444:
445: XtEDiskSetCallbackWhenChanged(src, func, param)
446: XtTextSource *src;
447: void (*func)();
448: caddr_t param;
449: {
450: EDiskPtr data = (EDiskPtr) src->data;
451: data->func = func;
452: data->param = param;
453: }
454:
455:
456: /* Return whether any unsaved changes have been made. */
457:
458: XtEDiskChanged(src)
459: XtTextSource *src;
460: {
461: return ((EDiskPtr) src->data)->changed;
462: }
463:
464:
465: /* Save any unsaved changes. */
466:
467: XtEDiskSaveFile(src)
468: XtTextSource *src;
469: {
470: EDiskPtr data = (EDiskPtr) src->data;
471: PiecePtr piece;
472: int i, needlseek;
473: char str[1024];
474: if (!data->changed)
475: return;
476: data->changed = data->checkpointchange = FALSE;
477: if (!data->eversaved) {
478: data->eversaved = TRUE; /* Open file in a mode where we can write. */
479: (void)myclose(data->file);
480: data->file = myopen(data->name, O_RDWR, 0666);
481: }
482: if (!data->startsvalid)
483: CalculateStarts(data);
484: for (i = 0, piece = data->piece; i < data->numpieces; i++, piece++) {
485: if (!(piece->buf) && i * BUFSIZE != piece->start)
486: ReadPiece(data, i);
487: }
488: needlseek = TRUE;
489: for (i = 0, piece = data->piece; i < data->numpieces; i++, piece++) {
490: if (piece->buf) {
491: if (needlseek) {
492: (void) lseek(data->file, (long) piece->start, 0);
493: needlseek = FALSE;
494: }
495: (void) write(data->file, piece->buf, piece->length);
496: }
497: else
498: needlseek = TRUE;
499: }
500: if (data->length < data->origlength)
501: (void)ftruncate(data->file, data->length);
502: data->origlength = data->length;
503: if (data->checkpointed) {
504: (void) sprintf(str, "%s.CKP", data->name);
505: (void) unlink(str);
506: data->checkpointed = FALSE;
507: }
508: }
509:
510:
511: /* Save into a new file. */
512:
513: XtEDiskSaveAsFile(src, filename)
514: XtTextSource *src;
515: char *filename;
516: {
517: EDiskPtr data = (EDiskPtr) src->data;
518: int i;
519: PiecePtr piece;
520: if (strcmp(filename, data->name) != 0) {
521: for (i = 0, piece = data->piece; i < data->numpieces; i++, piece++)
522: if (!(piece->buf))
523: ReadPiece(data, i);
524: data->eversaved = FALSE;
525: data->origlength = 0;
526: data->file = creat(filename, 0666);
527: data->eversaved = TRUE;
528: data->origlength = 0;
529: XtFree(data->name);
530: data->name = strcpy(XtMalloc((unsigned) strlen(filename) + 1),
531: filename);
532: data->changed = TRUE;
533: }
534: XtEDiskSaveFile(src);
535: }
536:
537:
538:
539: /* Checkpoint this file. */
540:
541: XtEDiskMakeCheckpoint(src)
542: XtTextSource *src;
543: {
544: EDiskPtr data = (EDiskPtr) src->data;
545: char name[1024];
546: int fid, i;
547: PiecePtr piece;
548: if (!data->checkpointchange) return; /* No changes to save. */
549: (void) sprintf(name, "%s.CKP", data->name);
550: fid = creat(name, 0600);
551: if (fid < 0) return;
552: for (i = 0, piece = data->piece; i < data->numpieces; i++, piece++) {
553: if (!(piece->buf)) ReadPiece(data, i);
554: (void) write(fid, piece->buf, piece->length);
555: }
556: (void)close(fid);
557: data->checkpointed = TRUE;
558: data->checkpointchange = FALSE;
559: }
560:
561:
562: /* We're done with this source, XtFree its storage. */
563:
564: XtDestroyEDiskSource(src)
565: XtTextSource *src;
566: {
567: EDiskPtr data = (EDiskPtr) src->data;
568: int i;
569: char *ptr;
570: (void)myclose(data->file);
571: for (i=0 ; i<data->numpieces ; i++)
572: if (ptr = data->piece[i].buf) XtFree(ptr);
573: XtFree((char *)data->piece);
574: XtFree((char *)data->name);
575: XtFree((char *)data);
576: XtFree((char *)src);
577: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.