2 * Copyright (c) 1992, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1992, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
7 * See the LICENSE file for redistribution information.
13 static const char sccsid
[] = "$Id: cut.c,v 10.16 2000/07/16 15:37:24 skimo Exp $ (Berkeley) $Date: 2000/07/16 15:37:24 $";
16 #include <sys/types.h>
17 #include <sys/queue.h>
19 #include <bitstring.h>
30 static void cb_rotate
__P((SCR
*));
34 * Put a range of lines/columns into a TEXT buffer.
36 * There are two buffer areas, both found in the global structure. The first
37 * is the linked list of all the buffers the user has named, the second is the
38 * unnamed buffer storage. There is a pointer, too, which is the current
39 * default buffer, i.e. it may point to the unnamed buffer or a named buffer
40 * depending on into what buffer the last text was cut. Logically, in both
41 * delete and yank operations, if the user names a buffer, the text is cut
42 * into it. If it's a delete of information on more than a single line, the
43 * contents of the numbered buffers are rotated up one, the contents of the
44 * buffer named '9' are discarded, and the text is cut into the buffer named
45 * '1'. The text is always cut into the unnamed buffer.
47 * In all cases, upper-case buffer names are the same as lower-case names,
48 * with the exception that they cause the buffer to be appended to instead
49 * of replaced. Note, however, that if text is appended to a buffer, the
50 * default buffer only contains the appended text, not the entire contents
54 * The contents of the default buffer would disappear after most operations
55 * in historic vi. It's unclear that this is useful, so we don't bother.
57 * When users explicitly cut text into the numeric buffers, historic vi became
58 * genuinely strange. I've never been able to figure out what was supposed to
59 * happen. It behaved differently if you deleted text than if you yanked text,
60 * and, in the latter case, the text was appended to the buffer instead of
61 * replacing the contents. Hopefully it's not worth getting right, and here
62 * we just treat the numeric buffers like any other named buffer.
64 * PUBLIC: int cut __P((SCR *, CHAR_T *, MARK *, MARK *, int));
67 cut(sp
, namep
, fm
, tm
, flags
)
76 int append
, copy_one
, copy_def
;
79 * If the user specified a buffer, put it there. (This may require
80 * a copy into the numeric buffers. We do the copy so that we don't
81 * have to reference count and so we don't have to deal with things
82 * like appends to buffers that are used multiple times.)
84 * Otherwise, if it's supposed to be put in a numeric buffer (usually
85 * a delete) put it there. The rules for putting things in numeric
86 * buffers were historically a little strange. There were three cases.
88 * 1: Some motions are always line mode motions, which means
89 * that the cut always goes into the numeric buffers.
90 * 2: Some motions aren't line mode motions, e.g. d10w, but
91 * can cross line boundaries. For these commands, if the
92 * cut crosses a line boundary, it goes into the numeric
93 * buffers. This includes most of the commands.
94 * 3: Some motions aren't line mode motions, e.g. d`<char>,
95 * but always go into the numeric buffers, regardless. This
96 * was the commands: % ` / ? ( ) N n { } -- and nvi adds ^A.
98 * Otherwise, put it in the unnamed buffer.
100 append
= copy_one
= copy_def
= 0;
103 if (LF_ISSET(CUT_NUMREQ
) || LF_ISSET(CUT_NUMOPT
) &&
104 (LF_ISSET(CUT_LINEMODE
) || fm
->lno
!= tm
->lno
)) {
108 if ((append
= isupper(name
)) == 1) {
111 name
= tolower(name
);
113 namecb
: CBNAME(sp
, cbp
, name
);
114 } else if (LF_ISSET(CUT_NUMREQ
) || LF_ISSET(CUT_NUMOPT
) &&
115 (LF_ISSET(CUT_LINEMODE
) || fm
->lno
!= tm
->lno
)) {
120 cbp
= &sp
->gp
->dcb_store
;
124 * If this is a new buffer, create it and add it into the list.
125 * Otherwise, if it's not an append, free its current contents.
128 CALLOC_RET(sp
, cbp
, CB
*, 1, sizeof(CB
));
130 CIRCLEQ_INIT(&cbp
->textq
);
131 LIST_INSERT_HEAD(&sp
->gp
->cutq
, cbp
, q
);
132 } else if (!append
) {
133 text_lfree(&cbp
->textq
);
139 #define ENTIRE_LINE 0
140 /* In line mode, it's pretty easy, just cut the lines. */
141 if (LF_ISSET(CUT_LINEMODE
)) {
142 cbp
->flags
|= CB_LMODE
;
143 for (lno
= fm
->lno
; lno
<= tm
->lno
; ++lno
)
144 if (cut_line(sp
, lno
, 0, 0, cbp
))
148 * Get the first line. A length of 0 causes cut_line
149 * to cut from the MARK to the end of the line.
151 if (cut_line(sp
, fm
->lno
, fm
->cno
, fm
->lno
!= tm
->lno
?
152 ENTIRE_LINE
: (tm
->cno
- fm
->cno
) + 1, cbp
))
155 /* Get the intermediate lines. */
156 for (lno
= fm
->lno
; ++lno
< tm
->lno
;)
157 if (cut_line(sp
, lno
, 0, ENTIRE_LINE
, cbp
))
160 /* Get the last line. */
161 if (tm
->lno
!= fm
->lno
&&
162 cut_line(sp
, lno
, 0, tm
->cno
+ 1, cbp
))
166 append
= 0; /* Only append to the named buffer. */
167 sp
->gp
->dcbp
= cbp
; /* Repoint the default buffer on each pass. */
169 if (copy_one
) { /* Copy into numeric buffer 1. */
171 CBNAME(sp
, cbp
, name
);
175 if (copy_def
) { /* Copy into the default buffer. */
176 cbp
= &sp
->gp
->dcb_store
;
183 text_lfree(&cbp
->textq
);
191 * Rotate the numbered buffers up one.
200 for (cbp
= sp
->gp
->cutq
.lh_first
; cbp
!= NULL
; cbp
= cbp
->q
.le_next
)
230 if (del_cbp
!= NULL
) {
231 LIST_REMOVE(del_cbp
, q
);
232 text_lfree(&del_cbp
->textq
);
239 * Cut a portion of a single line.
241 * PUBLIC: int cut_line __P((SCR *, db_recno_t, size_t, size_t, CB *));
244 cut_line(sp
, lno
, fcno
, clen
, cbp
)
255 if (db_get(sp
, lno
, DBG_FATAL
, &p
, &len
))
258 /* Create a TEXT structure that can hold the entire line. */
259 if ((tp
= text_init(sp
, NULL
, 0, len
)) == NULL
)
263 * If the line isn't empty and it's not the entire line,
264 * copy the portion we want, and reset the TEXT length.
269 MEMCPYW(tp
->lb
, p
+ fcno
, clen
);
273 /* Append to the end of the cut buffer. */
274 CIRCLEQ_INSERT_TAIL(&cbp
->textq
, tp
, q
);
282 * Discard all cut buffers.
284 * PUBLIC: void cut_close __P((GS *));
292 /* Free cut buffer list. */
293 while ((cbp
= gp
->cutq
.lh_first
) != NULL
) {
294 if (cbp
->textq
.cqh_first
!= (void *)&cbp
->textq
)
295 text_lfree(&cbp
->textq
);
300 /* Free default cut storage. */
301 cbp
= &gp
->dcb_store
;
302 if (cbp
->textq
.cqh_first
!= (void *)&cbp
->textq
)
303 text_lfree(&cbp
->textq
);
308 * Allocate a new TEXT structure.
310 * PUBLIC: TEXT *text_init __P((SCR *, const CHAR_T *, size_t, size_t));
313 text_init(sp
, p
, len
, total_len
)
316 size_t len
, total_len
;
320 CALLOC(sp
, tp
, TEXT
*, 1, sizeof(TEXT
));
323 /* ANSI C doesn't define a call to malloc(3) for 0 bytes. */
324 if ((tp
->lb_len
= total_len
* sizeof(CHAR_T
)) != 0) {
325 MALLOC(sp
, tp
->lb
, CHAR_T
*, tp
->lb_len
* sizeof(CHAR_T
));
326 if (tp
->lb
== NULL
) {
330 if (p
!= NULL
&& len
!= 0)
331 MEMCPYW(tp
->lb
, p
, len
);
339 * Free a chain of text structures.
341 * PUBLIC: void text_lfree __P((TEXTH *));
349 while ((tp
= headp
->cqh_first
) != (void *)headp
) {
350 CIRCLEQ_REMOVE(headp
, tp
, q
);
357 * Free a text structure.
359 * PUBLIC: void text_free __P((TEXT *));