![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cut.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis|
Return to cut.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis |
1.1 root 1: /* cut.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 16820 SW Tallac Way
6: * Beaverton, OR 97006
7: * [email protected], or ...uunet!tektronix!psueea!jove!kirkenda
8: */
9:
10:
11: /* This file contains function which manipulate the cut buffers. */
12:
13: #include "config.h"
14: #include "vi.h"
15: #if TURBOC
16: #include <process.h> /* needed for getpid */
17: #endif
18: #if TOS
19: #include <osbind.h>
20: #define rename(a,b) Frename(0,a,b)
21: #endif
22:
23: # define NANNONS 9 /* number of annonymous buffers */
24:
25: static struct cutbuf
26: {
27: short *phys; /* pointer to an array of #s of BLKs containing text */
28: int nblks; /* number of blocks in phys[] array */
29: int start; /* offset into first block of start of cut */
30: int end; /* offset into last block of end of cut */
31: int fd; /* fd of tmp file, or -1 to use tmpfd */
32: char lnmode; /* boolean: line-mode cut? (as opposed to char-mode) */
33: }
34: named[27], /* cut buffers "a through "z and ". */
35: annon[NANNONS]; /* annonymous cut buffers */
36:
37: static char cbname; /* name chosen for next cut/paste operation */
38:
39:
40: #ifndef NO_RECYCLE
41: /* This function builds a list of all blocks needed in the current tmp file
42: * for the contents of cut buffers.
43: * !!! WARNING: if you have more than ~450000 bytes of text in all of the
44: * cut buffers, then this will fail disastrously, because buffer overflow
45: * is *not* allowed for.
46: */
47: int cutneeds(need)
48: BLK *need; /* this is where we deposit the list */
49: {
50: struct cutbuf *cb; /* used to count through cut buffers */
51: int i; /* used to count through blocks of a cut buffer */
52: int n; /* total number of blocks in list */
53:
54: n = 0;
55:
56: /* first the named buffers... */
57: for (cb = named; cb < &named[27]; cb++)
58: {
59: if (cb->fd > 0)
60: continue;
61:
62: for (i = cb->nblks; i-- > 0; )
63: {
64: need->n[n++] = cb->phys[i];
65: }
66: }
67:
68: /* then the anonymous buffers */
69: for (cb = annon; cb < &annon[NANNONS]; cb++)
70: {
71: if (cb->fd > 0)
72: continue;
73:
74: for (i = cb->nblks; i-- > 0; )
75: {
76: need->n[n++] = cb->phys[i];
77: }
78: }
79:
80: return n;
81: }
82: #endif
83:
84: /* This function frees a cut buffer */
85: static void cutfree(buf)
86: struct cutbuf *buf;
87: {
88: char cutfname[50];
89: int i;
90:
91: /* return immediately if the buffer is already empty */
92: if (buf->nblks <= 0)
93: {
94: return;
95: }
96:
97: /* else free up stuff */
98: buf->nblks = 0;
99: #ifdef DEBUG
100: if (!buf->phys)
101: msg("cutfree() tried to free an NULL buf->phys pointer.");
102: #endif
103: free((char *)buf->phys);
104:
105: /* see if anybody else needs this tmp file */
106: if (buf->fd >= 0)
107: {
108: for (i = 0; i < 27; i++)
109: {
110: if (named[i].nblks > 0 && named[i].fd == buf->fd)
111: {
112: break;
113: }
114: }
115: }
116:
117: /* if nobody else needs it, then discard the tmp file */
118: if (buf->fd >= 0 && i == 27)
119: {
120: close(buf->fd);
121: #if MSDOS || TOS
122: strcpy(cutfname, o_directory);
123: if ((i = strlen(cutfname)) && !strchr(":/\\", cutfname[i-1]))
124: cutfname[i++]=SLASH;
125: sprintf(cutfname+i, CUTNAME+3, getpid(), buf->fd);
126: #else
127: sprintf(cutfname, CUTNAME, o_directory, getpid(), buf->fd);
128: #endif
129: unlink(cutfname);
130: }
131: }
132:
133: /* This function is called when we are about to abort a tmp file. If any
134: * cut buffers still need the file, then a copy of the file should be
135: * created for use by the cut buffers.
136: *
137: * To minimize the number of extra files lying around, only named cut buffers
138: * are preserved in a file switch; the annonymous buffers just go away.
139: */
140: void cutswitch(tmpname)
141: char *tmpname; /* name of the tmp file */
142: {
143: char cutfname[50]; /* used to build a new name for the tmp file */
144: int fd; /* a new fd for the current tmp file */
145: int i;
146: #if MSDOS || TOS
147: int j;
148: #endif
149:
150: /* discard all annonymous cut buffers */
151: for (i = 0; i < NANNONS; i++)
152: {
153: cutfree(&annon[i]);
154: }
155:
156: /* find the first named buffer that uses this tmp file */
157: for (i = 0; i < 27; i++)
158: {
159: if (named[i].nblks > 0 && named[i].fd < 0)
160: {
161: break;
162: }
163: }
164:
165: /* if none of them use this tmp file, then we're done */
166: if (i == 27)
167: {
168: return;
169: }
170:
171: /* else we'll need this file and an fd a little longer */
172: #if MSDOS || TOS
173: strcpy(cutfname, o_directory);
174: if ((j = strlen(cutfname)) && !strchr(":/\\", cutfname[j-1]))
175: cutfname[j++]=SLASH;
176: close(tmpfd);
177: fd = open(tmpname, O_RDONLY|O_BINARY);
178: close(fd);
179: sprintf(cutfname+j, CUTNAME+3, getpid(), fd);
180: rename(tmpname, cutfname);
181: fd = open(cutfname, O_RDONLY|O_BINARY);
182: tmpfd = -1; /* we'll try to close this in tmp.c, but who cares? */
183: #else
184: fd = dup(tmpfd);
185: # if OSK
186: sprintf(cutfname, CUTNAME, "", getpid(), fd);
187: if (!link(tmpname, &cutfname[1])) /* skip slash */
188: unlink(tmpname);
189: # else
190: sprintf(cutfname, CUTNAME, o_directory, getpid(), fd);
191: link(tmpname, cutfname) || unlink(tmpname);
192: # endif
193: #endif
194:
195: /* have all cut buffers use the new fd instead */
196: for (; i < 27; i++)
197: {
198: if (named[i].nblks > 0 && named[i].fd < 0)
199: {
200: named[i].fd = fd;
201: }
202: }
203: }
204:
205: /* This function should be called just before termination of vi */
206: void cutend()
207: {
208: int i;
209:
210: /* free all named cut buffers, since they might be forcing an older
211: * tmp file to be retained.
212: */
213: for (i = 0; i < 27; i++)
214: {
215: cutfree(&named[i]);
216: }
217: }
218:
219:
220: /* This function is used to select the cut buffer to be used next */
221: void cutname(name)
222: int name; /* a single character */
223: {
224: cbname = name;
225: }
226:
227:
228:
229:
230: /* This function copies a selected segment of text to a cut buffer */
231: void cut(from, to)
232: MARK from; /* start of text to cut */
233: MARK to; /* end of text to cut */
234: {
235: int first; /* logical number of first block in cut */
236: int last; /* logical number of last block used in cut */
237: long line; /* a line number */
238: int lnmode; /* boolean: will this be a line-mode cut? */
239: MARK delthru;/* end of text temporarily inserted for apnd */
240: REG struct cutbuf *cb;
241: REG long l;
242: REG int i;
243: REG char *scan;
244: char *blkc;
245:
246: /* detect whether this must be a line-mode cut or char-mode cut */
247: if (markidx(from) == 0 && markidx(to) == 0)
248: lnmode = TRUE;
249: else
250: lnmode = FALSE;
251:
252: /* by default, we don't "delthru" anything */
253: delthru = MARK_UNSET;
254:
255: /* decide which cut buffer to use */
256: if (!cbname)
257: {
258: /* free up the last annonymous cut buffer */
259: cutfree(&annon[NANNONS - 1]);
260:
261: /* shift the annonymous cut buffers */
262: for (i = NANNONS - 1; i > 0; i--)
263: {
264: annon[i] = annon[i - 1];
265: }
266:
267: /* use the first annonymous cut buffer */
268: cb = annon;
269: cb->nblks = 0;
270: }
271: else if (cbname >= 'a' && cbname <= 'z')
272: {
273: cb = &named[cbname - 'a'];
274: cutfree(cb);
275: }
276: #ifndef CRUNCH
277: else if (cbname >= 'A' && cbname <= 'Z')
278: {
279: cb = &named[cbname - 'A'];
280: if (cb->nblks > 0)
281: {
282: /* resolve linemode/charmode differences */
283: if (!lnmode && cb->lnmode)
284: {
285: from &= ~(BLKSIZE - 1);
286: if (markidx(to) != 0 || to == from)
287: {
288: to = to + BLKSIZE - markidx(to);
289: }
290: lnmode = TRUE;
291: }
292:
293: /* insert the old cut-buffer before the new text */
294: mark[28] = to;
295: delthru = paste(from, FALSE, TRUE);
296: if (delthru == MARK_UNSET)
297: {
298: return;
299: }
300: delthru++;
301: to = mark[28];
302: }
303: cutfree(cb);
304: }
305: #endif /* not CRUNCH */
306: else if (cbname == '.')
307: {
308: cb = &named[26];
309: cutfree(cb);
310: }
311: else
312: {
313: msg("Invalid cut buffer name: \"%c", cbname);
314: cbname = '\0';
315: return;
316: }
317: cbname = '\0';
318: cb->fd = -1;
319:
320: /* detect whether we're doing a line mode cut */
321: cb->lnmode = lnmode;
322:
323: /* ---------- */
324:
325: /* Reporting... */
326: if (markidx(from) == 0 && markidx(to) == 0)
327: {
328: rptlines = markline(to) - markline(from);
329: rptlabel = "yanked";
330: }
331:
332: /* ---------- */
333:
334: /* make sure each block has a physical disk address */
335: blksync();
336:
337: /* find the first block in the cut */
338: line = markline(from);
339: for (first = 1; line > lnum[first]; first++)
340: {
341: }
342:
343: /* fetch text of the block containing that line */
344: blkc = scan = blkget(first)->c;
345:
346: /* find the mark in the block */
347: for (l = lnum[first - 1]; ++l < line; )
348: {
349: while (*scan++ != '\n')
350: {
351: }
352: }
353: scan += markidx(from);
354:
355: /* remember the offset of the start */
356: cb->start = scan - blkc;
357:
358: /* ---------- */
359:
360: /* find the last block in the cut */
361: line = markline(to);
362: for (last = first; line > lnum[last]; last++)
363: {
364: }
365:
366: /* fetch text of the block containing that line */
367: if (last != first)
368: {
369: blkc = scan = blkget(last)->c;
370: }
371: else
372: {
373: scan = blkc;
374: }
375:
376: /* find the mark in the block */
377: for (l = lnum[last - 1]; ++l < line; )
378: {
379: while (*scan++ != '\n')
380: {
381: }
382: }
383: if (markline(to) <= nlines)
384: {
385: scan += markidx(to);
386: }
387:
388: /* remember the offset of the end */
389: cb->end = scan - blkc;
390:
391: /* ------- */
392:
393: /* remember the physical block numbers of all included blocks */
394: cb->nblks = last - first;
395: if (cb->end > 0)
396: {
397: cb->nblks++;
398: }
399: #ifdef lint
400: cb->phys = (short *)0;
401: #else
402: cb->phys = (short *)malloc((unsigned)(cb->nblks * sizeof(short)));
403: #endif
404: for (i = 0; i < cb->nblks; i++)
405: {
406: cb->phys[i] = hdr.n[first++];
407: }
408:
409: #ifndef CRUNCH
410: /* if we temporarily inserted text for appending, then delete that
411: * text now -- before the user sees it.
412: */
413: if (delthru)
414: {
415: line = rptlines;
416: delete(from, delthru);
417: rptlines = line;
418: rptlabel = "yanked";
419: }
420: #endif /* not CRUNCH */
421: }
422:
423:
424: static void readcutblk(cb, blkno)
425: struct cutbuf *cb;
426: int blkno;
427: {
428: int fd; /* either tmpfd or cb->fd */
429:
430: /* decide which fd to use */
431: if (cb->fd >= 0)
432: {
433: fd = cb->fd;
434: }
435: else
436: {
437: fd = tmpfd;
438: }
439:
440: /* get the block */
441: lseek(fd, (long)cb->phys[blkno] * (long)BLKSIZE, 0);
442: if (read(fd, tmpblk.c, (unsigned)BLKSIZE) != BLKSIZE)
443: {
444: msg("Error reading back from tmp file for pasting!");
445: }
446: }
447:
448:
449: /* This function inserts text from a cut buffer, and returns the MARK where
450: * insertion ended. Return MARK_UNSET on errors.
451: */
452: MARK paste(at, after, retend)
453: MARK at; /* where to insert the text */
454: int after; /* boolean: insert after mark? (rather than before) */
455: int retend; /* boolean: return end of text? (rather than start) */
456: {
457: REG struct cutbuf *cb;
458: REG int i;
459:
460: /* decide which cut buffer to use */
461: if (cbname >= 'A' && cbname <= 'Z')
462: {
463: cb = &named[cbname - 'A'];
464: }
465: else if (cbname >= 'a' && cbname <= 'z')
466: {
467: cb = &named[cbname - 'a'];
468: }
469: else if (cbname >= '1' && cbname <= '9')
470: {
471: cb = &annon[cbname - '1'];
472: }
473: else if (cbname == '.')
474: {
475: cb = &named[26];
476: }
477: else if (!cbname)
478: {
479: cb = annon;
480: }
481: else
482: {
483: msg("Invalid cut buffer name: \"%c", cbname);
484: cbname = '\0';
485: return MARK_UNSET;
486: }
487:
488: /* make sure it isn't empty */
489: if (cb->nblks == 0)
490: {
491: if (cbname)
492: msg("Cut buffer \"%c is empty", cbname);
493: else
494: msg("Cut buffer is empty");
495: cbname = '\0';
496: return MARK_UNSET;
497: }
498: cbname = '\0';
499:
500: /* adjust the insertion MARK for "after" and line-mode cuts */
501: if (cb->lnmode)
502: {
503: at &= ~(BLKSIZE - 1);
504: if (after)
505: {
506: at += BLKSIZE;
507: }
508: }
509: else if (after)
510: {
511: /* careful! if markidx(at) == 0 we might be pasting into an
512: * empty line -- so we can't blindly increment "at".
513: */
514: if (markidx(at) == 0)
515: {
516: pfetch(markline(at));
517: if (plen != 0)
518: {
519: at++;
520: }
521: }
522: else
523: {
524: at++;
525: }
526: }
527:
528: /* put a copy of the "at" mark in the mark[] array, so it stays in
529: * sync with changes made via add().
530: */
531: mark[27] = at;
532:
533: /* simple one-block paste? */
534: if (cb->nblks == 1)
535: {
536: /* get the block */
537: readcutblk(cb, 0);
538:
539: /* isolate the text we need within it */
540: if (cb->end)
541: {
542: tmpblk.c[cb->end] = '\0';
543: }
544:
545: /* insert it */
546: ChangeText
547: {
548: add(at, &tmpblk.c[cb->start]);
549: }
550: }
551: else
552: {
553: /* multi-block paste */
554:
555: ChangeText
556: {
557: i = cb->nblks - 1;
558:
559: /* add text from the last block first */
560: if (cb->end > 0)
561: {
562: readcutblk(cb, i);
563: tmpblk.c[cb->end] = '\0';
564: add(at, tmpblk.c);
565: i--;
566: }
567:
568: /* add intervening blocks */
569: while (i > 0)
570: {
571: readcutblk(cb, i);
572: add(at, tmpblk.c);
573: i--;
574: }
575:
576: /* add text from the first cut block */
577: readcutblk(cb, 0);
578: add(at, &tmpblk.c[cb->start]);
579: }
580: }
581:
582: /* Reporting... */
583: rptlines = markline(mark[27]) - markline(at);
584: rptlabel = "pasted";
585:
586: /* return the mark at the beginning/end of inserted text */
587: if (retend)
588: {
589: return mark[27] - 1L;
590: }
591: return at;
592: }
593:
594:
595:
596:
597: #ifndef NO_AT
598:
599: /* This function copies characters from a cut buffer into a string.
600: * It returns the number of characters in the cut buffer. If the cut
601: * buffer is too large to fit in the string (i.e. if cb2str() returns
602: * a number >= size) then the characters will not have been copied.
603: * It returns 0 if the cut buffer is empty, and -1 for invalid cut buffers.
604: */
605: int cb2str(name, buf, size)
606: int name; /* the name of a cut-buffer to get: a-z only! */
607: char *buf; /* where to put the string */
608: unsigned size; /* size of buf */
609: {
610: REG struct cutbuf *cb;
611: REG char *src;
612: REG char *dest;
613:
614: /* decide which cut buffer to use */
615: if (name >= 'a' && name <= 'z')
616: {
617: cb = &named[name - 'a'];
618: }
619: else
620: {
621: return -1;
622: }
623:
624: /* if the buffer is empty, return 0 */
625: if (cb->nblks == 0)
626: {
627: return 0;
628: }
629:
630: /* !!! if not a single-block cut, then fail */
631: if (cb->nblks != 1)
632: {
633: return size;
634: }
635:
636: /* if too big, return the size now, without doing anything */
637: if (cb->end - cb->start >= size)
638: {
639: return cb->end - cb->start;
640: }
641:
642: /* get the block */
643: readcutblk(cb, 0);
644:
645: /* isolate the string within that blk */
646: if (cb->start == 0)
647: {
648: tmpblk.c[cb->end] = '\0';
649: }
650: else
651: {
652: for (dest = tmpblk.c, src = dest + cb->start; src < tmpblk.c + cb->end; )
653: {
654: *dest++ = *src++;
655: }
656: *dest = '\0';
657: }
658:
659: /* copy the string into the buffer */
660: if (buf != tmpblk.c)
661: {
662: strcpy(buf, tmpblk.c);
663: }
664:
665: /* return the length */
666: return cb->end - cb->start;
667: }
668: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.