Annotation of src/usr.bin/mg/line.c, Revision 1.50
1.50 ! kjell 1: /* $OpenBSD: line.c,v 1.49 2009/11/12 16:37:14 millert Exp $ */
1.23 kjell 2:
3: /* This file is in the public domain. */
1.5 niklas 4:
1.1 deraadt 5: /*
6: * Text line handling.
1.8 mickey 7: *
1.4 millert 8: * The functions in this file are a general set of line management
1.8 mickey 9: * utilities. They are the only routines that touch the text. They
10: * also touch the buffer and window structures to make sure that the
11: * necessary updating gets done. There are routines in this file that
1.4 millert 12: * handle the kill buffer too. It isn't here for any good reason.
1.1 deraadt 13: *
1.8 mickey 14: * Note that this code only updates the dot and mark values in the window
15: * list. Since all the code acts on the current window, the buffer that
16: * we are editing must be displayed, which means that "b_nwnd" is non-zero,
17: * which means that the dot and mark values in the buffer headers are
1.1 deraadt 18: * nonsense.
19: */
20:
1.4 millert 21: #include "def.h"
22:
1.32 kjell 23: #include <stdlib.h>
24: #include <string.h>
25:
1.4 millert 26: /*
1.9 vincent 27: * Allocate a new line of size `used'. lrealloc() can be called if the line
28: * ever needs to grow beyond that.
1.1 deraadt 29: */
1.28 deraadt 30: struct line *
1.9 vincent 31: lalloc(int used)
1.3 millert 32: {
1.28 deraadt 33: struct line *lp;
1.1 deraadt 34:
1.22 db 35: if ((lp = malloc(sizeof(*lp))) == NULL)
36: return (NULL);
1.9 vincent 37: lp->l_text = NULL;
38: lp->l_size = 0;
39: lp->l_used = used; /* XXX */
40: if (lrealloc(lp, used) == FALSE) {
41: free(lp);
1.22 db 42: return (NULL);
1.1 deraadt 43: }
1.22 db 44: return (lp);
1.1 deraadt 45: }
46:
1.9 vincent 47: int
1.28 deraadt 48: lrealloc(struct line *lp, int newsize)
1.1 deraadt 49: {
1.9 vincent 50: char *tmp;
1.1 deraadt 51:
1.18 millert 52: if (lp->l_size < newsize) {
53: if ((tmp = realloc(lp->l_text, newsize)) == NULL)
1.22 db 54: return (FALSE);
1.18 millert 55: lp->l_text = tmp;
56: lp->l_size = newsize;
57: }
1.22 db 58: return (TRUE);
1.1 deraadt 59: }
60:
61: /*
1.4 millert 62: * Delete line "lp". Fix all of the links that might point to it (they are
1.8 mickey 63: * moved to offset 0 of the next line. Unlink the line from whatever buffer
64: * it might be in, and release the memory. The buffers are updated too; the
1.4 millert 65: * magic conditions described in the above comments don't hold here.
1.1 deraadt 66: */
1.6 art 67: void
1.28 deraadt 68: lfree(struct line *lp)
1.3 millert 69: {
1.28 deraadt 70: struct buffer *bp;
71: struct mgwin *wp;
1.1 deraadt 72:
1.3 millert 73: for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
1.1 deraadt 74: if (wp->w_linep == lp)
75: wp->w_linep = lp->l_fp;
1.3 millert 76: if (wp->w_dotp == lp) {
77: wp->w_dotp = lp->l_fp;
78: wp->w_doto = 0;
1.1 deraadt 79: }
80: if (wp->w_markp == lp) {
81: wp->w_markp = lp->l_fp;
82: wp->w_marko = 0;
83: }
84: }
1.3 millert 85: for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
1.1 deraadt 86: if (bp->b_nwnd == 0) {
1.3 millert 87: if (bp->b_dotp == lp) {
1.1 deraadt 88: bp->b_dotp = lp->l_fp;
89: bp->b_doto = 0;
90: }
91: if (bp->b_markp == lp) {
92: bp->b_markp = lp->l_fp;
93: bp->b_marko = 0;
94: }
95: }
96: }
97: lp->l_bp->l_fp = lp->l_fp;
98: lp->l_fp->l_bp = lp->l_bp;
1.9 vincent 99: if (lp->l_text != NULL)
100: free(lp->l_text);
101: free(lp);
1.1 deraadt 102: }
103:
104: /*
1.8 mickey 105: * This routine is called when a character changes in place in the current
106: * buffer. It updates all of the required flags in the buffer and window
107: * system. The flag used is passed as an argument; if the buffer is being
108: * displayed in more than 1 window we change EDIT to HARD. Set MODE if the
1.4 millert 109: * mode line needs to be updated (the "*" has to be set).
1.1 deraadt 110: */
1.6 art 111: void
1.15 vincent 112: lchange(int flag)
1.3 millert 113: {
1.28 deraadt 114: struct mgwin *wp;
1.1 deraadt 115:
1.4 millert 116: /* update mode lines if this is the first change. */
117: if ((curbp->b_flag & BFCHG) == 0) {
118: flag |= WFMODE;
1.1 deraadt 119: curbp->b_flag |= BFCHG;
120: }
1.3 millert 121: for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
1.1 deraadt 122: if (wp->w_bufp == curbp) {
1.47 kjell 123: wp->w_rflag |= flag;
1.3 millert 124: if (wp != curwp)
1.47 kjell 125: wp->w_rflag |= WFFULL;
1.1 deraadt 126: }
127: }
128: }
129:
130: /*
1.20 vincent 131: * Insert "n" bytes from "s" at the current location of dot.
132: * In the easy case all that happens is the text is stored in the line.
133: * In the hard case, the line has to be reallocated. When the window list
134: * is updated, take special care; I screwed it up once. You always update
135: * dot in the current window. You update mark and a dot in another window
136: * if it is greater than the place where you did the insert. Return TRUE
137: * if all is well, and FALSE on errors.
138: */
139: int
140: linsert_str(const char *s, int n)
141: {
1.28 deraadt 142: struct line *lp1;
143: struct mgwin *wp;
1.20 vincent 144: RSIZE i;
1.45 kjell 145: int doto, k;
146:
147: if ((k = checkdirty(curbp)) != TRUE)
148: return (k);
1.20 vincent 149:
150: if (curbp->b_flag & BFREADONLY) {
151: ewprintf("Buffer is read only");
1.22 db 152: return (FALSE);
1.20 vincent 153: }
154:
155: if (!n)
156: return (TRUE);
157:
1.39 kjell 158: lchange(WFFULL);
1.20 vincent 159:
160: /* current line */
161: lp1 = curwp->w_dotp;
162:
163: /* special case for the end */
1.41 kjell 164: if (lp1 == curbp->b_headp) {
1.28 deraadt 165: struct line *lp2, *lp3;
1.20 vincent 166:
167: /* now should only happen in empty buffer */
168: if (curwp->w_doto != 0)
169: panic("bug: linsert_str");
170: /* allocate a new line */
171: if ((lp2 = lalloc(n)) == NULL)
1.22 db 172: return (FALSE);
1.20 vincent 173: /* previous line */
174: lp3 = lp1->l_bp;
175: /* link in */
176: lp3->l_fp = lp2;
177: lp2->l_fp = lp1;
178: lp1->l_bp = lp2;
179: lp2->l_bp = lp3;
180: for (i = 0; i < n; ++i)
181: lp2->l_text[i] = s[i];
182: for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
183: if (wp->w_linep == lp1)
184: wp->w_linep = lp2;
185: if (wp->w_dotp == lp1)
186: wp->w_dotp = lp2;
187: if (wp->w_markp == lp1)
188: wp->w_markp = lp2;
189: }
190: undo_add_insert(lp2, 0, n);
191: curwp->w_doto = n;
1.22 db 192: return (TRUE);
1.20 vincent 193: }
194: /* save for later */
195: doto = curwp->w_doto;
196:
197: if ((lp1->l_used + n) > lp1->l_size) {
198: if (lrealloc(lp1, lp1->l_used + n) == FALSE)
1.22 db 199: return (FALSE);
1.20 vincent 200: }
201: lp1->l_used += n;
202: if (lp1->l_used != n)
203: memmove(&lp1->l_text[doto + n], &lp1->l_text[doto],
204: lp1->l_used - n - doto);
205:
206: /* Add the characters */
207: for (i = 0; i < n; ++i)
208: lp1->l_text[doto + i] = s[i];
209: for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
210: if (wp->w_dotp == lp1) {
211: if (wp == curwp || wp->w_doto > doto)
212: wp->w_doto += n;
213: }
214: if (wp->w_markp == lp1) {
215: if (wp->w_marko > doto)
216: wp->w_marko += n;
217: }
218: }
219: undo_add_insert(curwp->w_dotp, doto, n);
1.22 db 220: return (TRUE);
1.20 vincent 221: }
222:
223: /*
1.8 mickey 224: * Insert "n" copies of the character "c" at the current location of dot.
225: * In the easy case all that happens is the text is stored in the line.
226: * In the hard case, the line has to be reallocated. When the window list
227: * is updated, take special care; I screwed it up once. You always update
1.4 millert 228: * dot in the current window. You update mark and a dot in another window
229: * if it is greater than the place where you did the insert. Return TRUE
1.1 deraadt 230: * if all is well, and FALSE on errors.
231: */
1.4 millert 232: int
1.15 vincent 233: linsert(int n, int c)
1.1 deraadt 234: {
1.28 deraadt 235: struct line *lp1;
236: struct mgwin *wp;
1.4 millert 237: RSIZE i;
238: int doto;
1.45 kjell 239: int s;
1.1 deraadt 240:
1.20 vincent 241: if (!n)
242: return (TRUE);
243:
1.45 kjell 244: if ((s = checkdirty(curbp)) != TRUE)
245: return (s);
246:
1.15 vincent 247: if (curbp->b_flag & BFREADONLY) {
248: ewprintf("Buffer is read only");
1.22 db 249: return (FALSE);
1.15 vincent 250: }
251:
1.1 deraadt 252: lchange(WFEDIT);
1.4 millert 253:
254: /* current line */
255: lp1 = curwp->w_dotp;
1.15 vincent 256:
1.4 millert 257: /* special case for the end */
1.41 kjell 258: if (lp1 == curbp->b_headp) {
1.28 deraadt 259: struct line *lp2, *lp3;
1.11 deraadt 260:
1.4 millert 261: /* now should only happen in empty buffer */
1.1 deraadt 262: if (curwp->w_doto != 0) {
263: ewprintf("bug: linsert");
1.22 db 264: return (FALSE);
1.1 deraadt 265: }
1.4 millert 266: /* allocate a new line */
1.9 vincent 267: if ((lp2 = lalloc(n)) == NULL)
1.22 db 268: return (FALSE);
1.4 millert 269: /* previous line */
270: lp3 = lp1->l_bp;
271: /* link in */
272: lp3->l_fp = lp2;
1.1 deraadt 273: lp2->l_fp = lp1;
274: lp1->l_bp = lp2;
275: lp2->l_bp = lp3;
1.3 millert 276: for (i = 0; i < n; ++i)
1.1 deraadt 277: lp2->l_text[i] = c;
1.3 millert 278: for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
1.1 deraadt 279: if (wp->w_linep == lp1)
280: wp->w_linep = lp2;
281: if (wp->w_dotp == lp1)
282: wp->w_dotp = lp2;
283: if (wp->w_markp == lp1)
284: wp->w_markp = lp2;
285: }
1.16 vincent 286: undo_add_insert(lp2, 0, n);
1.1 deraadt 287: curwp->w_doto = n;
1.22 db 288: return (TRUE);
1.1 deraadt 289: }
1.4 millert 290: /* save for later */
291: doto = curwp->w_doto;
1.9 vincent 292:
293: if ((lp1->l_used + n) > lp1->l_size) {
294: if (lrealloc(lp1, lp1->l_used + n) == FALSE)
1.22 db 295: return (FALSE);
1.11 deraadt 296: }
1.9 vincent 297: lp1->l_used += n;
1.11 deraadt 298: if (lp1->l_used != n)
1.9 vincent 299: memmove(&lp1->l_text[doto + n], &lp1->l_text[doto],
300: lp1->l_used - n - doto);
301:
1.4 millert 302: /* Add the characters */
303: for (i = 0; i < n; ++i)
1.9 vincent 304: lp1->l_text[doto + i] = c;
1.3 millert 305: for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
1.1 deraadt 306: if (wp->w_dotp == lp1) {
1.3 millert 307: if (wp == curwp || wp->w_doto > doto)
1.1 deraadt 308: wp->w_doto += n;
309: }
310: if (wp->w_markp == lp1) {
311: if (wp->w_marko > doto)
312: wp->w_marko += n;
313: }
314: }
1.16 vincent 315: undo_add_insert(curwp->w_dotp, doto, n);
1.22 db 316: return (TRUE);
1.1 deraadt 317: }
318:
1.44 kjell 319: /*
320: * Do the work of inserting a newline at the given line/offset.
321: * If mark is on the current line, we may have to move the markline
322: * to keep line numbers in sync.
323: * lnewline_at assumes the current buffer is writable. Checking for
324: * this fact should be done by the caller.
325: */
1.4 millert 326: int
1.28 deraadt 327: lnewline_at(struct line *lp1, int doto)
1.1 deraadt 328: {
1.28 deraadt 329: struct line *lp2;
1.21 vincent 330: int nlen;
1.28 deraadt 331: struct mgwin *wp;
1.1 deraadt 332:
1.39 kjell 333: lchange(WFFULL);
1.14 vincent 334:
1.44 kjell 335: curwp->w_bufp->b_lines++;
336: /* Check if mark is past dot (even on current line) */
337: if (curwp->w_markline > curwp->w_dotline ||
338: (curwp->w_dotline == curwp->w_markline &&
339: curwp->w_marko >= doto))
340: curwp->w_markline++;
341: curwp->w_dotline++;
342:
1.35 kjell 343: /* If start of line, allocate a new line instead of copying */
1.4 millert 344: if (doto == 0) {
345: /* new first part */
1.35 kjell 346: if ((lp2 = lalloc(0)) == NULL)
347: return (FALSE);
1.1 deraadt 348: lp2->l_bp = lp1->l_bp;
349: lp1->l_bp->l_fp = lp2;
350: lp2->l_fp = lp1;
351: lp1->l_bp = lp2;
1.3 millert 352: for (wp = wheadp; wp != NULL; wp = wp->w_wndp)
353: if (wp->w_linep == lp1)
354: wp->w_linep = lp2;
1.46 kjell 355: undo_add_boundary(FFRAND, 1);
1.35 kjell 356: undo_add_insert(lp2, 0, 1);
1.46 kjell 357: undo_add_boundary(FFRAND, 1);
1.35 kjell 358: return (TRUE);
1.1 deraadt 359: }
1.4 millert 360:
361: /* length of new part */
362: nlen = llength(lp1) - doto;
363:
364: /* new second half line */
1.35 kjell 365: if ((lp2 = lalloc(nlen)) == NULL)
366: return (FALSE);
1.3 millert 367: if (nlen != 0)
368: bcopy(&lp1->l_text[doto], &lp2->l_text[0], nlen);
1.1 deraadt 369: lp1->l_used = doto;
370: lp2->l_bp = lp1;
371: lp2->l_fp = lp1->l_fp;
372: lp1->l_fp = lp2;
373: lp2->l_fp->l_bp = lp2;
1.4 millert 374: /* Windows */
375: for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
1.1 deraadt 376: if (wp->w_dotp == lp1 && wp->w_doto >= doto) {
377: wp->w_dotp = lp2;
378: wp->w_doto -= doto;
379: }
380: if (wp->w_markp == lp1 && wp->w_marko >= doto) {
381: wp->w_markp = lp2;
382: wp->w_marko -= doto;
383: }
384: }
1.46 kjell 385: undo_add_boundary(FFRAND, 1);
1.24 kjell 386: undo_add_insert(lp1, llength(lp1), 1);
1.46 kjell 387: undo_add_boundary(FFRAND, 1);
1.35 kjell 388: return (TRUE);
1.1 deraadt 389: }
390:
391: /*
1.21 vincent 392: * Insert a newline into the buffer at the current location of dot in the
393: * current window.
394: */
395: int
396: lnewline(void)
397: {
1.45 kjell 398: int s;
399:
400: if ((s = checkdirty(curbp)) != TRUE)
401: return (s);
1.21 vincent 402: if (curbp->b_flag & BFREADONLY) {
403: ewprintf("Buffer is read only");
1.22 db 404: return (FALSE);
1.21 vincent 405: }
1.22 db 406: return (lnewline_at(curwp->w_dotp, curwp->w_doto));
1.21 vincent 407: }
408:
409: /*
1.36 kjell 410: * This function deletes "n" bytes, starting at dot. (actually, n+1, as the
411: * newline is included) It understands how to deal with end of lines, etc.
412: * It returns TRUE if all of the characters were deleted, and FALSE if
413: * they were not (because dot ran into the end of the buffer).
414: * The "kflag" indicates either no insertion, or direction of insertion
415: * into the kill buffer.
1.1 deraadt 416: */
1.4 millert 417: int
1.15 vincent 418: ldelete(RSIZE n, int kflag)
1.3 millert 419: {
1.28 deraadt 420: struct line *dotp;
1.36 kjell 421: RSIZE chunk;
1.28 deraadt 422: struct mgwin *wp;
1.36 kjell 423: int doto;
424: char *cp1, *cp2;
425: size_t len;
1.49 millert 426: char *sv = NULL;
1.36 kjell 427: int end;
1.45 kjell 428: int s;
1.49 millert 429: int rval = FALSE;
1.1 deraadt 430:
1.45 kjell 431: if ((s = checkdirty(curbp)) != TRUE)
432: return (s);
1.15 vincent 433: if (curbp->b_flag & BFREADONLY) {
434: ewprintf("Buffer is read only");
1.49 millert 435: goto out;
1.15 vincent 436: }
1.32 kjell 437: len = n;
438: if ((sv = calloc(1, len + 1)) == NULL)
1.49 millert 439: goto out;
1.32 kjell 440: end = 0;
1.15 vincent 441:
1.48 kjell 442: undo_add_delete(curwp->w_dotp, curwp->w_doto, n, (kflag & KREG));
1.15 vincent 443:
1.1 deraadt 444: while (n != 0) {
445: dotp = curwp->w_dotp;
446: doto = curwp->w_doto;
1.4 millert 447: /* Hit the end of the buffer */
1.41 kjell 448: if (dotp == curbp->b_headp)
1.49 millert 449: goto out;
1.4 millert 450: /* Size of the chunk */
451: chunk = dotp->l_used - doto;
1.20 vincent 452:
1.1 deraadt 453: if (chunk > n)
454: chunk = n;
1.4 millert 455: /* End of line, merge */
456: if (chunk == 0) {
1.42 kjell 457: if (dotp == blastlp(curbp))
1.49 millert 458: goto out;
1.39 kjell 459: lchange(WFFULL);
1.32 kjell 460: if (ldelnewline() == FALSE)
1.49 millert 461: goto out;
1.32 kjell 462: end = strlcat(sv, "\n", len + 1);
1.1 deraadt 463: --n;
464: continue;
465: }
466: lchange(WFEDIT);
1.4 millert 467: /* Scrunch text */
468: cp1 = &dotp->l_text[doto];
1.32 kjell 469: memcpy(&sv[end], cp1, chunk);
470: end += chunk;
471: sv[end] = '\0';
1.20 vincent 472: for (cp2 = cp1 + chunk; cp2 < &dotp->l_text[dotp->l_used];
473: cp2++)
474: *cp1++ = *cp2;
1.4 millert 475: dotp->l_used -= (int)chunk;
1.3 millert 476: for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
477: if (wp->w_dotp == dotp && wp->w_doto >= doto) {
478: /* NOSTRICT */
1.1 deraadt 479: wp->w_doto -= chunk;
480: if (wp->w_doto < doto)
481: wp->w_doto = doto;
482: }
1.3 millert 483: if (wp->w_markp == dotp && wp->w_marko >= doto) {
484: /* NOSTRICT */
1.1 deraadt 485: wp->w_marko -= chunk;
486: if (wp->w_marko < doto)
487: wp->w_marko = doto;
488: }
489: }
490: n -= chunk;
491: }
1.34 kjell 492: if (kchunk(sv, (RSIZE)len, kflag) != TRUE)
1.49 millert 493: goto out;
494: rval = TRUE;
495: out:
1.32 kjell 496: free(sv);
1.49 millert 497: return (rval);
1.1 deraadt 498: }
499:
500: /*
1.8 mickey 501: * Delete a newline and join the current line with the next line. If the next
1.4 millert 502: * line is the magic header line always return TRUE; merging the last line
1.8 mickey 503: * with the header line can be thought of as always being a successful
504: * operation. Even if nothing is done, this makes the kill buffer work
1.44 kjell 505: * "right". If the mark is past the dot (actually, markline > dotline),
506: * decrease the markline accordingly to keep line numbers in sync.
507: * Easy cases can be done by shuffling data around. Hard cases
1.8 mickey 508: * require that lines be moved about in memory. Return FALSE on error and
1.40 kjell 509: * TRUE if all looks ok. We do not update w_dotline here, as deletes are done
510: * after moves.
1.1 deraadt 511: */
1.4 millert 512: int
1.15 vincent 513: ldelnewline(void)
1.3 millert 514: {
1.28 deraadt 515: struct line *lp1, *lp2, *lp3;
516: struct mgwin *wp;
1.45 kjell 517: int s;
1.1 deraadt 518:
1.45 kjell 519: if ((s = checkdirty(curbp)) != TRUE)
520: return (s);
1.15 vincent 521: if (curbp->b_flag & BFREADONLY) {
522: ewprintf("Buffer is read only");
1.22 db 523: return (FALSE);
1.15 vincent 524: }
525:
1.1 deraadt 526: lp1 = curwp->w_dotp;
527: lp2 = lp1->l_fp;
1.4 millert 528: /* at the end of the buffer */
1.41 kjell 529: if (lp2 == curbp->b_headp)
1.22 db 530: return (TRUE);
1.44 kjell 531: /* Keep line counts in sync */
1.40 kjell 532: curwp->w_bufp->b_lines--;
1.44 kjell 533: if (curwp->w_markline > curwp->w_dotline)
534: curwp->w_markline--;
1.1 deraadt 535: if (lp2->l_used <= lp1->l_size - lp1->l_used) {
536: bcopy(&lp2->l_text[0], &lp1->l_text[lp1->l_used], lp2->l_used);
1.3 millert 537: for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
1.1 deraadt 538: if (wp->w_linep == lp2)
539: wp->w_linep = lp1;
540: if (wp->w_dotp == lp2) {
1.3 millert 541: wp->w_dotp = lp1;
1.1 deraadt 542: wp->w_doto += lp1->l_used;
543: }
544: if (wp->w_markp == lp2) {
1.3 millert 545: wp->w_markp = lp1;
1.1 deraadt 546: wp->w_marko += lp1->l_used;
547: }
548: }
549: lp1->l_used += lp2->l_used;
550: lp1->l_fp = lp2->l_fp;
551: lp2->l_fp->l_bp = lp1;
1.37 kjell 552: free(lp2);
1.22 db 553: return (TRUE);
1.1 deraadt 554: }
1.3 millert 555: if ((lp3 = lalloc(lp1->l_used + lp2->l_used)) == NULL)
1.22 db 556: return (FALSE);
1.1 deraadt 557: bcopy(&lp1->l_text[0], &lp3->l_text[0], lp1->l_used);
558: bcopy(&lp2->l_text[0], &lp3->l_text[lp1->l_used], lp2->l_used);
559: lp1->l_bp->l_fp = lp3;
560: lp3->l_fp = lp2->l_fp;
561: lp2->l_fp->l_bp = lp3;
562: lp3->l_bp = lp1->l_bp;
1.3 millert 563: for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
564: if (wp->w_linep == lp1 || wp->w_linep == lp2)
1.1 deraadt 565: wp->w_linep = lp3;
566: if (wp->w_dotp == lp1)
1.3 millert 567: wp->w_dotp = lp3;
1.1 deraadt 568: else if (wp->w_dotp == lp2) {
1.3 millert 569: wp->w_dotp = lp3;
1.1 deraadt 570: wp->w_doto += lp1->l_used;
571: }
572: if (wp->w_markp == lp1)
1.3 millert 573: wp->w_markp = lp3;
1.1 deraadt 574: else if (wp->w_markp == lp2) {
1.3 millert 575: wp->w_markp = lp3;
1.1 deraadt 576: wp->w_marko += lp1->l_used;
577: }
578: }
1.37 kjell 579: free(lp1);
580: free(lp2);
1.22 db 581: return (TRUE);
1.1 deraadt 582: }
1.9 vincent 583:
1.1 deraadt 584: /*
1.8 mickey 585: * Replace plen characters before dot with argument string. Control-J
586: * characters in st are interpreted as newlines. There is a casehack
587: * disable flag (normally it likes to match case of replacement to what
1.4 millert 588: * was there).
1.1 deraadt 589: */
1.4 millert 590: int
1.27 kjell 591: lreplace(RSIZE plen, char *st)
1.4 millert 592: {
593: RSIZE rlen; /* replacement length */
1.45 kjell 594: int s;
1.15 vincent 595:
1.45 kjell 596: if ((s = checkdirty(curbp)) != TRUE)
597: return (s);
1.15 vincent 598: if (curbp->b_flag & BFREADONLY) {
599: ewprintf("Buffer is read only");
1.22 db 600: return (FALSE);
1.15 vincent 601: }
1.46 kjell 602: undo_boundary_enable(FFRAND, 0);
1.25 deraadt 603:
1.6 art 604: (void)backchar(FFARG | FFRAND, (int)plen);
1.24 kjell 605: (void)ldelete(plen, KNONE);
1.15 vincent 606:
1.1 deraadt 607: rlen = strlen(st);
1.24 kjell 608: region_put_data(st, rlen);
1.39 kjell 609: lchange(WFFULL);
1.1 deraadt 610:
1.46 kjell 611: undo_boundary_enable(FFRAND, 1);
1.29 kjell 612: return (TRUE);
1.38 kjell 613: }
614:
615: /*
616: * Allocate and return the supplied line as a C string
617: */
618: char *
619: linetostr(const struct line *ln)
620: {
1.50 ! kjell 621: int len;
1.38 kjell 622: char *line;
623:
624: len = llength(ln);
1.50 ! kjell 625: if (len == INT_MAX) /* (len + 1) overflow */
1.38 kjell 626: return (NULL);
627:
628: if ((line = malloc(len + 1)) == NULL)
629: return (NULL);
630:
631: (void)memcpy(line, ltext(ln), len);
632: line[len] = '\0';
633:
634: return (line);
1.1 deraadt 635: }