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