yank.c revision 1.11
1/* $OpenBSD: yank.c,v 1.11 2014/03/20 07:47:29 lum Exp $ */ 2 3/* This file is in the public domain. */ 4 5/* 6 * kill ring functions 7 */ 8 9#include "def.h" 10 11#include <string.h> 12 13#ifndef KBLOCK 14#define KBLOCK 256 /* Kill buffer block size. */ 15#endif 16 17static char *kbufp = NULL; /* Kill buffer data. */ 18static RSIZE kused = 0; /* # of bytes used in KB. */ 19static RSIZE ksize = 0; /* # of bytes allocated in KB. */ 20static RSIZE kstart = 0; /* # of first used byte in KB. */ 21 22static int kgrow(int); 23 24/* 25 * Delete all of the text saved in the kill buffer. Called by commands when 26 * a new kill context is created. The kill buffer array is released, just in 27 * case the buffer has grown to an immense size. No errors. 28 */ 29void 30kdelete(void) 31{ 32 if (kbufp != NULL) { 33 free(kbufp); 34 kbufp = NULL; 35 kstart = kused = ksize = 0; 36 } 37} 38 39/* 40 * Insert a character to the kill buffer, enlarging the buffer if there 41 * isn't any room. Always grow the buffer in chunks, on the assumption 42 * that if you put something in the kill buffer you are going to put more 43 * stuff there too later. Return TRUE if all is well, and FALSE on errors. 44 * Print a message on errors. Dir says whether to put it at back or front. 45 * This call is ignored if KNONE is set. 46 */ 47int 48kinsert(int c, int dir) 49{ 50 if (dir == KNONE) 51 return (TRUE); 52 if (kused == ksize && dir == KFORW && kgrow(dir) == FALSE) 53 return (FALSE); 54 if (kstart == 0 && dir == KBACK && kgrow(dir) == FALSE) 55 return (FALSE); 56 if (dir == KFORW) 57 kbufp[kused++] = c; 58 else if (dir == KBACK) 59 kbufp[--kstart] = c; 60 else 61 panic("broken kinsert call"); /* Oh shit! */ 62 return (TRUE); 63} 64 65/* 66 * kgrow - just get more kill buffer for the callee. If dir = KBACK 67 * we are trying to get space at the beginning of the kill buffer. 68 */ 69static int 70kgrow(int dir) 71{ 72 int nstart; 73 char *nbufp; 74 75 if ((unsigned)(ksize + KBLOCK) <= (unsigned)ksize) { 76 /* probably 16 bit unsigned */ 77 dobeep(); 78 ewprintf("Kill buffer size at maximum"); 79 return (FALSE); 80 } 81 if ((nbufp = malloc((unsigned)(ksize + KBLOCK))) == NULL) { 82 dobeep(); 83 ewprintf("Can't get %ld bytes", (long)(ksize + KBLOCK)); 84 return (FALSE); 85 } 86 nstart = (dir == KBACK) ? (kstart + KBLOCK) : (KBLOCK / 4); 87 bcopy(&(kbufp[kstart]), &(nbufp[nstart]), (int)(kused - kstart)); 88 if (kbufp != NULL) 89 free(kbufp); 90 kbufp = nbufp; 91 ksize += KBLOCK; 92 kused = kused - kstart + nstart; 93 kstart = nstart; 94 return (TRUE); 95} 96 97/* 98 * This function gets characters from the kill buffer. If the character 99 * index "n" is off the end, it returns "-1". This lets the caller just 100 * scan along until it gets a "-1" back. 101 */ 102int 103kremove(int n) 104{ 105 if (n < 0 || n + kstart >= kused) 106 return (-1); 107 return (CHARMASK(kbufp[n + kstart])); 108} 109 110/* 111 * Copy a string into the kill buffer. kflag gives direction. 112 * if KNONE, do nothing. 113 */ 114int 115kchunk(char *cp1, RSIZE chunk, int kflag) 116{ 117 /* 118 * HACK - doesn't matter, and fixes back-over-nl bug for empty 119 * kill buffers. 120 */ 121 if (kused == kstart) 122 kflag = KFORW; 123 124 if (kflag & KFORW) { 125 while (ksize - kused < chunk) 126 if (kgrow(kflag) == FALSE) 127 return (FALSE); 128 bcopy(cp1, &(kbufp[kused]), (int)chunk); 129 kused += chunk; 130 } else if (kflag & KBACK) { 131 while (kstart < chunk) 132 if (kgrow(kflag) == FALSE) 133 return (FALSE); 134 bcopy(cp1, &(kbufp[kstart - chunk]), (int)chunk); 135 kstart -= chunk; 136 } 137 138 return (TRUE); 139} 140 141/* 142 * Kill line. If called without an argument, it kills from dot to the end 143 * of the line, unless it is at the end of the line, when it kills the 144 * newline. If called with an argument of 0, it kills from the start of the 145 * line to dot. If called with a positive argument, it kills from dot 146 * forward over that number of newlines. If called with a negative argument 147 * it kills any text before dot on the current line, then it kills back 148 * abs(arg) lines. 149 */ 150/* ARGSUSED */ 151int 152killline(int f, int n) 153{ 154 struct line *nextp; 155 RSIZE chunk; 156 int i, c; 157 158 /* clear kill buffer if last wasn't a kill */ 159 if ((lastflag & CFKILL) == 0) 160 kdelete(); 161 thisflag |= CFKILL; 162 if (!(f & FFARG)) { 163 for (i = curwp->w_doto; i < llength(curwp->w_dotp); ++i) 164 if ((c = lgetc(curwp->w_dotp, i)) != ' ' && c != '\t') 165 break; 166 if (i == llength(curwp->w_dotp)) 167 chunk = llength(curwp->w_dotp) - curwp->w_doto + 1; 168 else { 169 chunk = llength(curwp->w_dotp) - curwp->w_doto; 170 if (chunk == 0) 171 chunk = 1; 172 } 173 } else if (n > 0) { 174 chunk = llength(curwp->w_dotp) - curwp->w_doto; 175 nextp = lforw(curwp->w_dotp); 176 if (nextp != curbp->b_headp) 177 chunk++; /* newline */ 178 if (nextp == curbp->b_headp) 179 goto done; /* EOL */ 180 i = n; 181 while (--i) { 182 chunk += llength(nextp); 183 nextp = lforw(nextp); 184 if (nextp != curbp->b_headp) 185 chunk++; /* newline */ 186 if (nextp == curbp->b_headp) 187 break; /* EOL */ 188 } 189 } else { 190 /* n <= 0 */ 191 chunk = curwp->w_doto; 192 curwp->w_doto = 0; 193 i = n; 194 while (i++) { 195 if (lforw(curwp->w_dotp)) 196 chunk++; 197 curwp->w_dotp = lback(curwp->w_dotp); 198 curwp->w_rflag |= WFMOVE; 199 chunk += llength(curwp->w_dotp); 200 } 201 } 202 /* 203 * KFORW here is a bug. Should be KBACK/KFORW, but we need to 204 * rewrite the ldelete code (later)? 205 */ 206done: 207 if (chunk) 208 return (ldelete(chunk, KFORW)); 209 return (TRUE); 210} 211 212/* 213 * Yank text back from the kill buffer. This is really easy. All of the work 214 * is done by the standard insert routines. All you do is run the loop, and 215 * check for errors. The blank lines are inserted with a call to "newline" 216 * instead of a call to "lnewline" so that the magic stuff that happens when 217 * you type a carriage return also happens when a carriage return is yanked 218 * back from the kill buffer. An attempt has been made to fix the cosmetic 219 * bug associated with a yank when dot is on the top line of the window 220 * (nothing moves, because all of the new text landed off screen). 221 */ 222/* ARGSUSED */ 223int 224yank(int f, int n) 225{ 226 struct line *lp; 227 int c, i, nline; 228 229 if (n < 0) 230 return (FALSE); 231 232 /* newline counting */ 233 nline = 0; 234 235 undo_boundary_enable(FFRAND, 0); 236 while (n--) { 237 /* mark around last yank */ 238 isetmark(); 239 i = 0; 240 while ((c = kremove(i)) >= 0) { 241 if (c == '\n') { 242 if (newline(FFRAND, 1) == FALSE) 243 return (FALSE); 244 ++nline; 245 } else { 246 if (linsert(1, c) == FALSE) 247 return (FALSE); 248 } 249 ++i; 250 } 251 } 252 /* cosmetic adjustment */ 253 lp = curwp->w_linep; 254 255 /* if offscreen insert */ 256 if (curwp->w_dotp == lp) { 257 while (nline-- && lback(lp) != curbp->b_headp) 258 lp = lback(lp); 259 /* adjust framing */ 260 curwp->w_linep = lp; 261 curwp->w_rflag |= WFFULL; 262 } 263 undo_boundary_enable(FFRAND, 1); 264 return (TRUE); 265} 266 267