1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
11 * ops.c: implementation of various operators: op_shift, op_delete, op_tilde,
12 * op_change, op_yank, do_put, do_join
18 * Number of registers.
19 * 0 = unnamed register, for normal yanks and puts
20 * 1..9 = registers '1' to '9', for deletes
21 * 10..35 = registers 'a' to 'z'
22 * 36 = delete register '-'
23 * 37 = Selection register '*'. Only if FEAT_CLIPBOARD defined
24 * 38 = Clipboard register '+'. Only if FEAT_CLIPBOARD and FEAT_X11 defined
27 * Symbolic names for some registers.
29 #define DELETION_REGISTER 36
31 # define STAR_REGISTER 37
33 # define PLUS_REGISTER 38
35 # define PLUS_REGISTER STAR_REGISTER /* there is only one */
39 # define TILDE_REGISTER (PLUS_REGISTER + 1)
44 # define NUM_REGISTERS (TILDE_REGISTER + 1)
46 # define NUM_REGISTERS (PLUS_REGISTER + 1)
49 # define NUM_REGISTERS 37
53 * Each yank register is an array of pointers to lines.
57 char_u
**y_array
; /* pointer to array of line pointers */
58 linenr_T y_size
; /* number of lines in y_array */
59 char_u y_type
; /* MLINE, MCHAR or MBLOCK */
61 colnr_T y_width
; /* only set if y_type == MBLOCK */
63 } y_regs
[NUM_REGISTERS
];
65 static struct yankreg
*y_current
; /* ptr to current yankreg */
66 static int y_append
; /* TRUE when appending */
67 static struct yankreg
*y_previous
= NULL
; /* ptr to last written yankreg */
70 * structure used by block_prep, op_delete and op_yank for blockwise operators
71 * also op_change, op_shift, op_insert, op_replace - AKelly
75 int startspaces
; /* 'extra' cols before first char */
76 int endspaces
; /* 'extra' cols after last char */
77 int textlen
; /* chars in block */
78 char_u
*textstart
; /* pointer to 1st char (partially) in block */
79 colnr_T textcol
; /* index of chars (partially) in block */
80 colnr_T start_vcol
; /* start col of 1st char wholly inside block */
81 colnr_T end_vcol
; /* start col of 1st char wholly after block */
82 #ifdef FEAT_VISUALEXTRA
83 int is_short
; /* TRUE if line is too short to fit in block */
84 int is_MAX
; /* TRUE if curswant==MAXCOL when starting */
85 int is_oneChar
; /* TRUE if block within one character */
86 int pre_whitesp
; /* screen cols of ws before block */
87 int pre_whitesp_c
; /* chars of ws before block */
88 colnr_T end_char_vcols
; /* number of vcols of post-block char */
90 colnr_T start_char_vcols
; /* number of vcols of pre-block char */
93 #ifdef FEAT_VISUALEXTRA
94 static void shift_block
__ARGS((oparg_T
*oap
, int amount
));
95 static void block_insert
__ARGS((oparg_T
*oap
, char_u
*s
, int b_insert
, struct block_def
*bdp
));
97 static int stuff_yank
__ARGS((int, char_u
*));
98 static void put_reedit_in_typebuf
__ARGS((int silent
));
99 static int put_in_typebuf
__ARGS((char_u
*s
, int esc
, int colon
,
101 static void stuffescaped
__ARGS((char_u
*arg
, int literally
));
103 static void mb_adjust_opend
__ARGS((oparg_T
*oap
));
105 static void free_yank
__ARGS((long));
106 static void free_yank_all
__ARGS((void));
107 static int yank_copy_line
__ARGS((struct block_def
*bd
, long y_idx
));
108 #ifdef FEAT_CLIPBOARD
109 static void copy_yank_reg
__ARGS((struct yankreg
*reg
));
110 # if defined(FEAT_VISUAL) || defined(FEAT_EVAL)
111 static void may_set_selection
__ARGS((void));
114 static void dis_msg
__ARGS((char_u
*p
, int skip_esc
));
116 static void block_prep
__ARGS((oparg_T
*oap
, struct block_def
*, linenr_T
, int));
118 #if defined(FEAT_CLIPBOARD) || defined(FEAT_EVAL)
119 static void str_to_reg
__ARGS((struct yankreg
*y_ptr
, int type
, char_u
*str
, long len
, long blocklen
));
121 static int ends_in_white
__ARGS((linenr_T lnum
));
123 static int same_leader
__ARGS((linenr_T lnum
, int, char_u
*, int, char_u
*));
124 static int fmt_check_par
__ARGS((linenr_T
, int *, char_u
**, int do_comments
));
126 static int fmt_check_par
__ARGS((linenr_T
));
130 * The names of operators.
131 * IMPORTANT: Index must correspond with defines in vim.h!!!
132 * The third field indicates whether the operator always works on lines.
134 static char opchars
[][3] =
136 {NUL
, NUL
, FALSE
}, /* OP_NOP */
137 {'d', NUL
, FALSE
}, /* OP_DELETE */
138 {'y', NUL
, FALSE
}, /* OP_YANK */
139 {'c', NUL
, FALSE
}, /* OP_CHANGE */
140 {'<', NUL
, TRUE
}, /* OP_LSHIFT */
141 {'>', NUL
, TRUE
}, /* OP_RSHIFT */
142 {'!', NUL
, TRUE
}, /* OP_FILTER */
143 {'g', '~', FALSE
}, /* OP_TILDE */
144 {'=', NUL
, TRUE
}, /* OP_INDENT */
145 {'g', 'q', TRUE
}, /* OP_FORMAT */
146 {':', NUL
, TRUE
}, /* OP_COLON */
147 {'g', 'U', FALSE
}, /* OP_UPPER */
148 {'g', 'u', FALSE
}, /* OP_LOWER */
149 {'J', NUL
, TRUE
}, /* DO_JOIN */
150 {'g', 'J', TRUE
}, /* DO_JOIN_NS */
151 {'g', '?', FALSE
}, /* OP_ROT13 */
152 {'r', NUL
, FALSE
}, /* OP_REPLACE */
153 {'I', NUL
, FALSE
}, /* OP_INSERT */
154 {'A', NUL
, FALSE
}, /* OP_APPEND */
155 {'z', 'f', TRUE
}, /* OP_FOLD */
156 {'z', 'o', TRUE
}, /* OP_FOLDOPEN */
157 {'z', 'O', TRUE
}, /* OP_FOLDOPENREC */
158 {'z', 'c', TRUE
}, /* OP_FOLDCLOSE */
159 {'z', 'C', TRUE
}, /* OP_FOLDCLOSEREC */
160 {'z', 'd', TRUE
}, /* OP_FOLDDEL */
161 {'z', 'D', TRUE
}, /* OP_FOLDDELREC */
162 {'g', 'w', TRUE
}, /* OP_FORMAT2 */
163 {'g', '@', FALSE
}, /* OP_FUNCTION */
167 * Translate a command name into an operator type.
168 * Must only be called with a valid operator name!
171 get_op_type(char1
, char2
)
177 if (char1
== 'r') /* ignore second character */
179 if (char1
== '~') /* when tilde is an operator */
182 if (opchars
[i
][0] == char1
&& opchars
[i
][1] == char2
)
187 #if defined(FEAT_VISUAL) || defined(PROTO)
189 * Return TRUE if operator "op" always works on whole lines.
195 return opchars
[op
][2];
200 * Get first operator command character.
201 * Returns 'g' or 'z' if there is another command character.
207 return opchars
[optype
][0];
211 * Get second operator command character.
214 get_extra_op_char(optype
)
217 return opchars
[optype
][1];
221 * op_shift - handle a shift operation
224 op_shift(oap
, curs_top
, amount
)
236 if (u_save((linenr_T
)(oap
->start
.lnum
- 1),
237 (linenr_T
)(oap
->end
.lnum
+ 1)) == FAIL
)
242 block_col
= curwin
->w_cursor
.col
;
245 for (i
= oap
->line_count
; --i
>= 0; )
247 first_char
= *ml_get_curline();
248 if (first_char
== NUL
) /* empty line */
249 curwin
->w_cursor
.col
= 0;
250 #ifdef FEAT_VISUALEXTRA
251 else if (oap
->block_mode
)
252 shift_block(oap
, amount
);
255 /* Move the line right if it doesn't start with '#', 'smartindent'
256 * isn't set or 'cindent' isn't set or '#' isn't in 'cino'. */
257 #if defined(FEAT_SMARTINDENT) || defined(FEAT_CINDENT)
258 if (first_char
!= '#' || !preprocs_left())
261 shift_line(oap
->op_type
== OP_LSHIFT
, p_sr
, amount
, FALSE
);
263 ++curwin
->w_cursor
.lnum
;
266 changed_lines(oap
->start
.lnum
, 0, oap
->end
.lnum
+ 1, 0L);
271 curwin
->w_cursor
.lnum
= oap
->start
.lnum
;
272 curwin
->w_cursor
.col
= block_col
;
276 if (curs_top
) /* put cursor on first line, for ">>" */
278 curwin
->w_cursor
.lnum
= oap
->start
.lnum
;
279 beginline(BL_SOL
| BL_FIX
); /* shift_line() may have set cursor.col */
282 --curwin
->w_cursor
.lnum
; /* put cursor on last line, for ":>" */
284 if (oap
->line_count
> p_report
)
286 if (oap
->op_type
== OP_RSHIFT
)
290 if (oap
->line_count
== 1)
293 sprintf((char *)IObuff
, _("1 line %sed 1 time"), s
);
295 sprintf((char *)IObuff
, _("1 line %sed %d times"), s
, amount
);
300 sprintf((char *)IObuff
, _("%ld lines %sed 1 time"),
303 sprintf((char *)IObuff
, _("%ld lines %sed %d times"),
304 oap
->line_count
, s
, amount
);
310 * Set "'[" and "']" marks.
312 curbuf
->b_op_start
= oap
->start
;
313 curbuf
->b_op_end
.lnum
= oap
->end
.lnum
;
314 curbuf
->b_op_end
.col
= (colnr_T
)STRLEN(ml_get(oap
->end
.lnum
));
315 if (curbuf
->b_op_end
.col
> 0)
316 --curbuf
->b_op_end
.col
;
320 * shift the current line one shiftwidth left (if left != 0) or right
321 * leaves cursor on first blank in the line
324 shift_line(left
, round
, amount
, call_changed_bytes
)
328 int call_changed_bytes
; /* call changed_bytes() */
332 int p_sw
= (int)curbuf
->b_p_sw
;
334 count
= get_indent(); /* get current indent */
336 if (round
) /* round off indent */
338 i
= count
/ p_sw
; /* number of p_sw rounded down */
339 j
= count
% p_sw
; /* extra spaces */
340 if (j
&& left
) /* first remove extra spaces */
352 else /* original vi indent */
356 count
-= p_sw
* amount
;
361 count
+= p_sw
* amount
;
366 if (State
& VREPLACE_FLAG
)
367 change_indent(INDENT_SET
, count
, FALSE
, NUL
, call_changed_bytes
);
370 (void)set_indent(count
, call_changed_bytes
? SIN_CHANGED
: 0);
373 #if defined(FEAT_VISUALEXTRA) || defined(PROTO)
375 * Shift one line of the current block one shiftwidth right or left.
376 * Leaves cursor on first character in block.
379 shift_block(oap
, amount
)
383 int left
= (oap
->op_type
== OP_LSHIFT
);
384 int oldstate
= State
;
387 int oldcol
= curwin
->w_cursor
.col
;
388 int p_sw
= (int)curbuf
->b_p_sw
;
389 int p_ts
= (int)curbuf
->b_p_ts
;
395 #ifdef FEAT_RIGHTLEFT
398 p_ri
= 0; /* don't want revins in ident */
401 State
= INSERT
; /* don't want REPLACE for State */
402 block_prep(oap
, &bd
, curwin
->w_cursor
.lnum
, TRUE
);
406 /* total is number of screen columns to be inserted/removed */
407 total
= amount
* p_sw
;
408 oldp
= ml_get_curline();
415 * 3. Divvy into TABs & spp
416 * 4. Construct new string
418 total
+= bd
.pre_whitesp
; /* all virtual WS upto & incl a split TAB */
419 ws_vcol
= bd
.start_vcol
- bd
.pre_whitesp
;
424 bd
.textstart
+= (*mb_ptr2len
)(bd
.textstart
);
429 for ( ; vim_iswhite(*bd
.textstart
); )
431 incr
= lbr_chartabsize_adv(&bd
.textstart
, (colnr_T
)(bd
.start_vcol
));
433 bd
.start_vcol
+= incr
;
435 /* OK, now total=all the VWS reqd, and textstart points at the 1st
436 * non-ws char in the block. */
438 i
= ((ws_vcol
% p_ts
) + total
) / p_ts
; /* number of tabs */
440 j
= ((ws_vcol
% p_ts
) + total
) % p_ts
; /* number of spp */
443 /* if we're splitting a TAB, allow for it */
444 bd
.textcol
-= bd
.pre_whitesp_c
- (bd
.startspaces
!= 0);
445 len
= (int)STRLEN(bd
.textstart
) + 1;
446 newp
= alloc_check((unsigned)(bd
.textcol
+ i
+ j
+ len
));
449 vim_memset(newp
, NUL
, (size_t)(bd
.textcol
+ i
+ j
+ len
));
450 mch_memmove(newp
, oldp
, (size_t)bd
.textcol
);
451 copy_chars(newp
+ bd
.textcol
, (size_t)i
, TAB
);
452 copy_spaces(newp
+ bd
.textcol
+ i
, (size_t)j
);
454 mch_memmove(newp
+ bd
.textcol
+ i
+ j
, bd
.textstart
, (size_t)len
);
458 colnr_T destination_col
; /* column to which text in block will
460 char_u
*verbatim_copy_end
; /* end of the part of the line which is
462 colnr_T verbatim_copy_width
;/* the (displayed) width of this part
464 unsigned fill
; /* nr of spaces that replace a TAB */
465 unsigned new_line_len
; /* the length of the line after the
467 size_t block_space_width
;
469 char_u
*non_white
= bd
.textstart
;
470 colnr_T non_white_col
;
473 * Firstly, let's find the first non-whitespace character that is
474 * displayed after the block's start column and the character's column
475 * number. Also, let's calculate the width of all the whitespace
476 * characters that are displayed in the block and precede the searched
477 * non-whitespace character.
480 /* If "bd.startspaces" is set, "bd.textstart" points to the character,
481 * the part of which is displayed at the block's beginning. Let's start
482 * searching from the next character. */
484 mb_ptr_adv(non_white
);
486 /* The character's column is in "bd.start_vcol". */
487 non_white_col
= bd
.start_vcol
;
489 while (vim_iswhite(*non_white
))
491 incr
= lbr_chartabsize_adv(&non_white
, non_white_col
);
492 non_white_col
+= incr
;
495 block_space_width
= non_white_col
- oap
->start_vcol
;
496 /* We will shift by "total" or "block_space_width", whichever is less.
498 shift_amount
= (block_space_width
< (size_t)total
499 ? block_space_width
: (size_t)total
);
501 /* The column to which we will shift the text. */
502 destination_col
= (colnr_T
)(non_white_col
- shift_amount
);
504 /* Now let's find out how much of the beginning of the line we can
505 * reuse without modification. */
506 verbatim_copy_end
= bd
.textstart
;
507 verbatim_copy_width
= bd
.start_vcol
;
509 /* If "bd.startspaces" is set, "bd.textstart" points to the character
510 * preceding the block. We have to subtract its width to obtain its
513 verbatim_copy_width
-= bd
.start_char_vcols
;
514 while (verbatim_copy_width
< destination_col
)
516 incr
= lbr_chartabsize(verbatim_copy_end
, verbatim_copy_width
);
517 if (verbatim_copy_width
+ incr
> destination_col
)
519 verbatim_copy_width
+= incr
;
520 mb_ptr_adv(verbatim_copy_end
);
523 /* If "destination_col" is different from the width of the initial
524 * part of the line that will be copied, it means we encountered a tab
525 * character, which we will have to partly replace with spaces. */
526 fill
= destination_col
- verbatim_copy_width
;
528 /* The replacement line will consist of:
529 * - the beginning of the original line up to "verbatim_copy_end",
530 * - "fill" number of spaces,
531 * - the rest of the line, pointed to by non_white. */
532 new_line_len
= (unsigned)(verbatim_copy_end
- oldp
)
534 + (unsigned)STRLEN(non_white
) + 1;
536 newp
= alloc_check(new_line_len
);
539 mch_memmove(newp
, oldp
, (size_t)(verbatim_copy_end
- oldp
));
540 copy_spaces(newp
+ (verbatim_copy_end
- oldp
), (size_t)fill
);
541 STRMOVE(newp
+ (verbatim_copy_end
- oldp
) + fill
, non_white
);
543 /* replace the line */
544 ml_replace(curwin
->w_cursor
.lnum
, newp
, FALSE
);
545 changed_bytes(curwin
->w_cursor
.lnum
, (colnr_T
)bd
.textcol
);
547 curwin
->w_cursor
.col
= oldcol
;
548 #ifdef FEAT_RIGHTLEFT
554 #ifdef FEAT_VISUALEXTRA
556 * Insert string "s" (b_insert ? before : after) block :AKelly
557 * Caller must prepare for undo.
560 block_insert(oap
, s
, b_insert
, bdp
)
564 struct block_def
*bdp
;
567 int count
= 0; /* extra spaces to replace a cut TAB */
568 int spaces
= 0; /* non-zero if cutting a TAB */
569 colnr_T offset
; /* pointer along new line */
570 unsigned s_len
; /* STRLEN(s) */
571 char_u
*newp
, *oldp
; /* new, old lines */
572 linenr_T lnum
; /* loop var */
573 int oldstate
= State
;
575 State
= INSERT
; /* don't want REPLACE for State */
576 s_len
= (unsigned)STRLEN(s
);
578 for (lnum
= oap
->start
.lnum
+ 1; lnum
<= oap
->end
.lnum
; lnum
++)
580 block_prep(oap
, bdp
, lnum
, TRUE
);
581 if (bdp
->is_short
&& b_insert
)
582 continue; /* OP_INSERT, line ends before block start */
588 p_ts
= bdp
->start_char_vcols
;
589 spaces
= bdp
->startspaces
;
591 count
= p_ts
- 1; /* we're cutting a TAB */
592 offset
= bdp
->textcol
;
596 p_ts
= bdp
->end_char_vcols
;
597 if (!bdp
->is_short
) /* spaces = padding after block */
599 spaces
= (bdp
->endspaces
? p_ts
- bdp
->endspaces
: 0);
601 count
= p_ts
- 1; /* we're cutting a TAB */
602 offset
= bdp
->textcol
+ bdp
->textlen
- (spaces
!= 0);
604 else /* spaces = padding to block edge */
606 /* if $ used, just append to EOL (ie spaces==0) */
608 spaces
= (oap
->end_vcol
- bdp
->end_vcol
) + 1;
610 offset
= bdp
->textcol
+ bdp
->textlen
;
614 newp
= alloc_check((unsigned)(STRLEN(oldp
)) + s_len
+ count
+ 1);
618 /* copy up to shifted part */
619 mch_memmove(newp
, oldp
, (size_t)(offset
));
622 /* insert pre-padding */
623 copy_spaces(newp
+ offset
, (size_t)spaces
);
625 /* copy the new text */
626 mch_memmove(newp
+ offset
+ spaces
, s
, (size_t)s_len
);
629 if (spaces
&& !bdp
->is_short
)
631 /* insert post-padding */
632 copy_spaces(newp
+ offset
+ spaces
, (size_t)(p_ts
- spaces
));
633 /* We're splitting a TAB, don't copy it. */
635 /* We allowed for that TAB, remember this now */
641 STRMOVE(newp
+ offset
, oldp
);
643 ml_replace(lnum
, newp
, FALSE
);
645 if (lnum
== oap
->end
.lnum
)
647 /* Set "']" mark to the end of the block instead of the end of
648 * the insert in the first line. */
649 curbuf
->b_op_end
.lnum
= oap
->end
.lnum
;
650 curbuf
->b_op_end
.col
= offset
;
654 changed_lines(oap
->start
.lnum
+ 1, 0, oap
->end
.lnum
+ 1, 0L);
660 #if defined(FEAT_LISP) || defined(FEAT_CINDENT) || defined(PROTO)
662 * op_reindent - handle reindenting a block of lines.
665 op_reindent(oap
, how
)
667 int (*how
) __ARGS((void));
672 linenr_T first_changed
= 0;
673 linenr_T last_changed
= 0;
674 linenr_T start_lnum
= curwin
->w_cursor
.lnum
;
676 /* Don't even try when 'modifiable' is off. */
679 EMSG(_(e_modifiable
));
683 for (i
= oap
->line_count
; --i
>= 0 && !got_int
; )
685 /* it's a slow thing to do, so give feedback so there's no worry that
686 * the computer's just hung. */
689 && (i
% 50 == 0 || i
== oap
->line_count
- 1)
690 && oap
->line_count
> p_report
)
691 smsg((char_u
*)_("%ld lines to indent... "), i
);
694 * Be vi-compatible: For lisp indenting the first line is not
695 * indented, unless there is only one line.
698 if (i
!= oap
->line_count
- 1 || oap
->line_count
== 1
699 || how
!= get_lisp_indent
)
702 l
= skipwhite(ml_get_curline());
703 if (*l
== NUL
) /* empty or blank line */
706 count
= how(); /* get the indent for this line */
708 if (set_indent(count
, SIN_UNDO
))
710 /* did change the indent, call changed_lines() later */
711 if (first_changed
== 0)
712 first_changed
= curwin
->w_cursor
.lnum
;
713 last_changed
= curwin
->w_cursor
.lnum
;
716 ++curwin
->w_cursor
.lnum
;
717 curwin
->w_cursor
.col
= 0; /* make sure it's valid */
720 /* put cursor on first non-blank of indented line */
721 curwin
->w_cursor
.lnum
= start_lnum
;
722 beginline(BL_SOL
| BL_FIX
);
724 /* Mark changed lines so that they will be redrawn. When Visual
725 * highlighting was present, need to continue until the last line. When
726 * there is no change still need to remove the Visual highlighting. */
727 if (last_changed
!= 0)
728 changed_lines(first_changed
, 0,
730 oap
->is_VIsual
? start_lnum
+ oap
->line_count
:
732 last_changed
+ 1, 0L);
734 else if (oap
->is_VIsual
)
735 redraw_curbuf_later(INVERTED
);
738 if (oap
->line_count
> p_report
)
740 i
= oap
->line_count
- (i
+ 1);
742 MSG(_("1 line indented "));
744 smsg((char_u
*)_("%ld lines indented "), i
);
746 /* set '[ and '] marks */
747 curbuf
->b_op_start
= oap
->start
;
748 curbuf
->b_op_end
= oap
->end
;
750 #endif /* defined(FEAT_LISP) || defined(FEAT_CINDENT) */
752 #if defined(FEAT_EVAL) || defined(PROTO)
754 * Keep the last expression line here, for repeating.
756 static char_u
*expr_line
= NULL
;
759 * Get an expression for the "\"=expr1" or "CTRL-R =expr1"
760 * Returns '=' when OK, NUL otherwise.
767 new_line
= getcmdline('=', 0L, 0);
768 if (new_line
== NULL
)
770 if (*new_line
== NUL
) /* use previous line */
773 set_expr_line(new_line
);
778 * Set the expression for the '=' register.
779 * Argument must be an allocated string.
782 set_expr_line(new_line
)
786 expr_line
= new_line
;
790 * Get the result of the '=' register expression.
791 * Returns a pointer to allocated memory, or NULL for failure.
798 static int nested
= 0;
800 if (expr_line
== NULL
)
803 /* Make a copy of the expression, because evaluating it may cause it to be
805 expr_copy
= vim_strsave(expr_line
);
806 if (expr_copy
== NULL
)
809 /* When we are invoked recursively limit the evaluation to 10 levels.
810 * Then return the string as-is. */
815 rv
= eval_to_string(expr_copy
, NULL
, TRUE
);
822 * Get the '=' register expression itself, without evaluating it.
827 if (expr_line
== NULL
)
829 return vim_strsave(expr_line
);
831 #endif /* FEAT_EVAL */
834 * Check if 'regname' is a valid name of a yank register.
835 * Note: There is no check for 0 (default register), caller should do this
838 valid_yank_reg(regname
, writing
)
840 int writing
; /* if TRUE check for writable registers */
842 if ( (regname
> 0 && ASCII_ISALNUM(regname
))
843 || (!writing
&& vim_strchr((char_u
*)
853 #ifdef FEAT_CLIPBOARD
858 || (!writing
&& regname
== '~')
866 * Set y_current and y_append, according to the value of "regname".
867 * Cannot handle the '_' register.
868 * Must only be called with a valid register name!
870 * If regname is 0 and writing, use register 0
871 * If regname is 0 and reading, use previous register
874 get_yank_register(regname
, writing
)
881 if ((regname
== 0 || regname
== '"') && !writing
&& y_previous
!= NULL
)
883 y_current
= y_previous
;
889 else if (ASCII_ISLOWER(i
))
890 i
= CharOrdLow(i
) + 10;
891 else if (ASCII_ISUPPER(i
))
893 i
= CharOrdUp(i
) + 10;
896 else if (regname
== '-')
897 i
= DELETION_REGISTER
;
898 #ifdef FEAT_CLIPBOARD
899 /* When selection is not available, use register 0 instead of '*' */
900 else if (clip_star
.available
&& regname
== '*')
902 /* When clipboard is not available, use register 0 instead of '+' */
903 else if (clip_plus
.available
&& regname
== '+')
907 else if (!writing
&& regname
== '~')
910 else /* not 0-9, a-z, A-Z or '-': use register 0 */
912 y_current
= &(y_regs
[i
]);
913 if (writing
) /* remember the register we write into for do_put() */
914 y_previous
= y_current
;
917 #if defined(FEAT_CLIPBOARD) || defined(PROTO)
919 * When "regname" is a clipboard register, obtain the selection. If it's not
920 * available return zero, otherwise return "regname".
923 may_get_selection(regname
)
928 if (!clip_star
.available
)
931 clip_get_selection(&clip_star
);
933 else if (regname
== '+')
935 if (!clip_plus
.available
)
938 clip_get_selection(&clip_plus
);
944 #if defined(FEAT_VISUAL) || defined(PROTO)
946 * Obtain the contents of a "normal" register. The register is made empty.
947 * The returned pointer has allocated memory, use put_register() later.
950 get_register(name
, copy
)
952 int copy
; /* make a copy, if FALSE make register empty. */
957 #ifdef FEAT_CLIPBOARD
958 /* When Visual area changed, may have to update selection. Obtain the
960 if (name
== '*' && clip_star
.available
)
962 if (clip_isautosel())
963 clip_update_selection();
964 may_get_selection(name
);
968 get_yank_register(name
, 0);
969 reg
= (struct yankreg
*)alloc((unsigned)sizeof(struct yankreg
));
975 /* If we run out of memory some or all of the lines are empty. */
976 if (reg
->y_size
== 0)
979 reg
->y_array
= (char_u
**)alloc((unsigned)(sizeof(char_u
*)
981 if (reg
->y_array
!= NULL
)
983 for (i
= 0; i
< reg
->y_size
; ++i
)
984 reg
->y_array
[i
] = vim_strsave(y_current
->y_array
[i
]);
988 y_current
->y_array
= NULL
;
994 * Put "reg" into register "name". Free any previous contents and "reg".
997 put_register(name
, reg
)
1001 get_yank_register(name
, 0);
1003 *y_current
= *(struct yankreg
*)reg
;
1006 # ifdef FEAT_CLIPBOARD
1007 /* Send text written to clipboard register to the clipboard. */
1008 may_set_selection();
1013 #if defined(FEAT_MOUSE) || defined(PROTO)
1015 * return TRUE if the current yank register has type MLINE
1018 yank_register_mline(regname
)
1021 if (regname
!= 0 && !valid_yank_reg(regname
, FALSE
))
1023 if (regname
== '_') /* black hole is always empty */
1025 get_yank_register(regname
, FALSE
);
1026 return (y_current
->y_type
== MLINE
);
1031 * Start or stop recording into a yank register.
1033 * Return FAIL for failure, OK otherwise.
1041 struct yankreg
*old_y_previous
, *old_y_current
;
1044 if (Recording
== FALSE
) /* start recording */
1046 /* registers 0-9, a-z and " are allowed */
1047 if (c
< 0 || (!ASCII_ISALNUM(c
) && c
!= '"'))
1057 else /* stop recording */
1060 * Get the recorded key hits. K_SPECIAL and CSI will be escaped, this
1061 * needs to be removed again to put it in a register. exec_reg then
1062 * adds the escaping back later.
1071 /* Remove escaping for CSI and K_SPECIAL in multi-byte chars. */
1072 vim_unescape_csi(p
);
1075 * We don't want to change the default register here, so save and
1076 * restore the current register name.
1078 old_y_previous
= y_previous
;
1079 old_y_current
= y_current
;
1081 retval
= stuff_yank(regname
, p
);
1083 y_previous
= old_y_previous
;
1084 y_current
= old_y_current
;
1091 * Stuff string "p" into yank register "regname" as a single line (append if
1092 * uppercase). "p" must have been alloced.
1094 * return FAIL for failure, OK otherwise
1097 stuff_yank(regname
, p
)
1104 /* check for read-only register */
1105 if (regname
!= 0 && !valid_yank_reg(regname
, TRUE
))
1110 if (regname
== '_') /* black hole: don't do anything */
1115 get_yank_register(regname
, TRUE
);
1116 if (y_append
&& y_current
->y_array
!= NULL
)
1118 pp
= &(y_current
->y_array
[y_current
->y_size
- 1]);
1119 lp
= lalloc((long_u
)(STRLEN(*pp
) + STRLEN(p
) + 1), TRUE
);
1134 if ((y_current
->y_array
=
1135 (char_u
**)alloc((unsigned)sizeof(char_u
*))) == NULL
)
1140 y_current
->y_array
[0] = p
;
1141 y_current
->y_size
= 1;
1142 y_current
->y_type
= MCHAR
; /* used to be MLINE, why? */
1147 static int execreg_lastc
= NUL
;
1150 * execute a yank register: copy it into the stuff buffer
1152 * return FAIL for failure, OK otherwise
1155 do_execreg(regname
, colon
, addcr
, silent
)
1157 int colon
; /* insert ':' before each line */
1158 int addcr
; /* always add '\n' to end of line */
1159 int silent
; /* set "silent" flag in typeahead buffer */
1166 if (regname
== '@') /* repeat previous one */
1168 if (execreg_lastc
== NUL
)
1170 EMSG(_("E748: No previously used register"));
1173 regname
= execreg_lastc
;
1175 /* check for valid regname */
1176 if (regname
== '%' || regname
== '#' || !valid_yank_reg(regname
, FALSE
))
1178 emsg_invreg(regname
);
1181 execreg_lastc
= regname
;
1183 #ifdef FEAT_CLIPBOARD
1184 regname
= may_get_selection(regname
);
1187 if (regname
== '_') /* black hole: don't stuff anything */
1191 if (regname
== ':') /* use last command line */
1193 if (last_cmdline
== NULL
)
1195 EMSG(_(e_nolastcmd
));
1198 vim_free(new_last_cmdline
); /* don't keep the cmdline containing @: */
1199 new_last_cmdline
= NULL
;
1200 /* Escape all control characters with a CTRL-V */
1201 p
= vim_strsave_escaped_ext(last_cmdline
,
1202 (char_u
*)"\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037", Ctrl_V
, FALSE
);
1205 /* When in Visual mode "'<,'>" will be prepended to the command.
1206 * Remove it when it's already there. */
1207 if (VIsual_active
&& STRNCMP(p
, "'<,'>", 5) == 0)
1208 retval
= put_in_typebuf(p
+ 5, TRUE
, TRUE
, silent
);
1210 retval
= put_in_typebuf(p
, TRUE
, TRUE
, silent
);
1216 else if (regname
== '=')
1218 p
= get_expr_line();
1221 retval
= put_in_typebuf(p
, TRUE
, colon
, silent
);
1225 else if (regname
== '.') /* use last inserted text */
1227 p
= get_last_insert_save();
1230 EMSG(_(e_noinstext
));
1233 retval
= put_in_typebuf(p
, FALSE
, colon
, silent
);
1238 get_yank_register(regname
, FALSE
);
1239 if (y_current
->y_array
== NULL
)
1242 /* Disallow remaping for ":@r". */
1243 remap
= colon
? REMAP_NONE
: REMAP_YES
;
1246 * Insert lines into typeahead buffer, from last one to first one.
1248 put_reedit_in_typebuf(silent
);
1249 for (i
= y_current
->y_size
; --i
>= 0; )
1253 /* insert NL between lines and after last line if type is MLINE */
1254 if (y_current
->y_type
== MLINE
|| i
< y_current
->y_size
- 1
1257 if (ins_typebuf((char_u
*)"\n", remap
, 0, TRUE
, silent
) == FAIL
)
1260 escaped
= vim_strsave_escape_csi(y_current
->y_array
[i
]);
1261 if (escaped
== NULL
)
1263 retval
= ins_typebuf(escaped
, remap
, 0, TRUE
, silent
);
1267 if (colon
&& ins_typebuf((char_u
*)":", remap
, 0, TRUE
, silent
)
1271 Exec_reg
= TRUE
; /* disable the 'q' command */
1277 * If "restart_edit" is not zero, put it in the typeahead buffer, so that it's
1278 * used only after other typeahead has been processed.
1281 put_reedit_in_typebuf(silent
)
1286 if (restart_edit
!= NUL
)
1288 if (restart_edit
== 'V')
1296 buf
[0] = restart_edit
== 'I' ? 'i' : restart_edit
;
1299 if (ins_typebuf(buf
, REMAP_NONE
, 0, TRUE
, silent
) == OK
)
1305 * Insert register contents "s" into the typeahead buffer, so that it will be
1307 * When "esc" is TRUE it is to be taken literally: Escape CSI characters and
1311 put_in_typebuf(s
, esc
, colon
, silent
)
1314 int colon
; /* add ':' before the line */
1319 put_reedit_in_typebuf(silent
);
1321 retval
= ins_typebuf((char_u
*)"\n", REMAP_NONE
, 0, TRUE
, silent
);
1327 p
= vim_strsave_escape_csi(s
);
1333 retval
= ins_typebuf(p
, esc
? REMAP_NONE
: REMAP_YES
,
1338 if (colon
&& retval
== OK
)
1339 retval
= ins_typebuf((char_u
*)":", REMAP_NONE
, 0, TRUE
, silent
);
1344 * Insert a yank register: copy it into the Read buffer.
1345 * Used by CTRL-R command and middle mouse button in insert mode.
1347 * return FAIL for failure, OK otherwise
1350 insert_reg(regname
, literally
)
1352 int literally
; /* insert literally, not as if typed */
1360 * It is possible to get into an endless loop by having CTRL-R a in
1361 * register a and then, in insert mode, doing CTRL-R a.
1362 * If you hit CTRL-C, the loop will be broken here.
1368 /* check for valid regname */
1369 if (regname
!= NUL
&& !valid_yank_reg(regname
, FALSE
))
1372 #ifdef FEAT_CLIPBOARD
1373 regname
= may_get_selection(regname
);
1376 if (regname
== '.') /* insert last inserted text */
1377 retval
= stuff_inserted(NUL
, 1L, TRUE
);
1378 else if (get_spec_reg(regname
, &arg
, &allocated
, TRUE
))
1382 stuffescaped(arg
, literally
);
1386 else /* name or number register */
1388 get_yank_register(regname
, FALSE
);
1389 if (y_current
->y_array
== NULL
)
1393 for (i
= 0; i
< y_current
->y_size
; ++i
)
1395 stuffescaped(y_current
->y_array
[i
], literally
);
1397 * Insert a newline between lines and after last line if
1400 if (y_current
->y_type
== MLINE
|| i
< y_current
->y_size
- 1)
1401 stuffcharReadbuff('\n');
1410 * Stuff a string into the typeahead buffer, such that edit() will insert it
1411 * literally ("literally" TRUE) or interpret is as typed characters.
1414 stuffescaped(arg
, literally
)
1423 /* Stuff a sequence of normal ASCII characters, that's fast. Also
1424 * stuff K_SPECIAL to get the effect of a special key when "literally"
1429 && *arg
< DEL
/* EBCDIC: chars above space are normal */
1432 || (*arg
== K_SPECIAL
&& !literally
))
1435 stuffReadbuffLen(start
, (long)(arg
- start
));
1437 /* stuff a single special character */
1442 c
= mb_ptr2char_adv(&arg
);
1446 if (literally
&& ((c
< ' ' && c
!= TAB
) || c
== DEL
))
1447 stuffcharReadbuff(Ctrl_V
);
1448 stuffcharReadbuff(c
);
1454 * If "regname" is a special register, return TRUE and store a pointer to its
1458 get_spec_reg(regname
, argp
, allocated
, errmsg
)
1461 int *allocated
; /* return: TRUE when value was allocated */
1462 int errmsg
; /* give error message when failing */
1470 case '%': /* file name */
1472 check_fname(); /* will give emsg if not set */
1473 *argp
= curbuf
->b_fname
;
1476 case '#': /* alternate file name */
1477 *argp
= getaltfname(errmsg
); /* may give emsg if not set */
1481 case '=': /* result of expression */
1482 *argp
= get_expr_line();
1487 case ':': /* last command line */
1488 if (last_cmdline
== NULL
&& errmsg
)
1489 EMSG(_(e_nolastcmd
));
1490 *argp
= last_cmdline
;
1493 case '/': /* last search-pattern */
1494 if (last_search_pat() == NULL
&& errmsg
)
1495 EMSG(_(e_noprevre
));
1496 *argp
= last_search_pat();
1499 case '.': /* last inserted text */
1500 *argp
= get_last_insert_save();
1502 if (*argp
== NULL
&& errmsg
)
1503 EMSG(_(e_noinstext
));
1506 #ifdef FEAT_SEARCHPATH
1507 case Ctrl_F
: /* Filename under cursor */
1508 case Ctrl_P
: /* Path under cursor, expand via "path" */
1511 *argp
= file_name_at_cursor(FNAME_MESS
| FNAME_HYP
1512 | (regname
== Ctrl_P
? FNAME_EXP
: 0), 1L, NULL
);
1517 case Ctrl_W
: /* word under cursor */
1518 case Ctrl_A
: /* WORD (mnemonic All) under cursor */
1521 cnt
= find_ident_under_cursor(argp
, regname
== Ctrl_W
1522 ? (FIND_IDENT
|FIND_STRING
) : FIND_STRING
);
1523 *argp
= cnt
? vim_strnsave(*argp
, cnt
) : NULL
;
1527 case '_': /* black hole: always empty */
1528 *argp
= (char_u
*)"";
1536 * Paste a yank register into the command line.
1537 * Only for non-special registers.
1538 * Used by CTRL-R command in command-line mode
1539 * insert_reg() can't be used here, because special characters from the
1540 * register contents will be interpreted as commands.
1542 * return FAIL for failure, OK otherwise
1545 cmdline_paste_reg(regname
, literally
, remcr
)
1547 int literally
; /* Insert text literally instead of "as typed" */
1548 int remcr
; /* don't add trailing CR */
1552 get_yank_register(regname
, FALSE
);
1553 if (y_current
->y_array
== NULL
)
1556 for (i
= 0; i
< y_current
->y_size
; ++i
)
1558 cmdline_paste_str(y_current
->y_array
[i
], literally
);
1560 /* Insert ^M between lines and after last line if type is MLINE.
1561 * Don't do this when "remcr" is TRUE and the next line is empty. */
1562 if (y_current
->y_type
== MLINE
1563 || (i
< y_current
->y_size
- 1
1565 && i
== y_current
->y_size
- 2
1566 && *y_current
->y_array
[i
+ 1] == NUL
)))
1567 cmdline_paste_str((char_u
*)"\r", literally
);
1569 /* Check for CTRL-C, in case someone tries to paste a few thousand
1570 * lines and gets bored. */
1578 #if defined(FEAT_CLIPBOARD) || defined(PROTO)
1580 * Adjust the register name pointed to with "rp" for the clipboard being
1581 * used always and the clipboard being available.
1587 /* If no reg. specified, and "unnamed" is in 'clipboard', use '*' reg. */
1588 if (*rp
== 0 && clip_unnamed
)
1590 if (!clip_star
.available
&& *rp
== '*')
1592 if (!clip_plus
.available
&& *rp
== '+')
1598 * op_delete - handle a delete operation
1600 * return FAIL if undo failed, OK otherwise.
1610 char_u
*newp
, *oldp
;
1611 struct block_def bd
;
1613 linenr_T old_lcount
= curbuf
->b_ml
.ml_line_count
;
1614 int did_yank
= FALSE
;
1616 if (curbuf
->b_ml
.ml_flags
& ML_EMPTY
) /* nothing to do */
1619 /* Nothing to delete, return here. Do prepare undo, for op_change(). */
1621 return u_save_cursor();
1623 if (!curbuf
->b_p_ma
)
1625 EMSG(_(e_modifiable
));
1629 #ifdef FEAT_CLIPBOARD
1630 adjust_clip_reg(&oap
->regname
);
1635 mb_adjust_opend(oap
);
1639 * Imitate the strange Vi behaviour: If the delete spans more than one line
1640 * and motion_type == MCHAR and the result is a blank line, make the delete
1641 * linewise. Don't do this for the change command or Visual mode.
1643 if ( oap
->motion_type
== MCHAR
1648 && oap
->line_count
> 1
1649 && oap
->op_type
== OP_DELETE
)
1651 ptr
= ml_get(oap
->end
.lnum
) + oap
->end
.col
+ oap
->inclusive
;
1652 ptr
= skipwhite(ptr
);
1653 if (*ptr
== NUL
&& inindent(0))
1654 oap
->motion_type
= MLINE
;
1658 * Check for trying to delete (e.g. "D") in an empty line.
1659 * Note: For the change operator it is ok.
1661 if ( oap
->motion_type
== MCHAR
1662 && oap
->line_count
== 1
1663 && oap
->op_type
== OP_DELETE
1664 && *ml_get(oap
->start
.lnum
) == NUL
)
1667 * It's an error to operate on an empty region, when 'E' included in
1668 * 'cpoptions' (Vi compatible).
1670 #ifdef FEAT_VIRTUALEDIT
1672 /* Virtual editing: Nothing gets deleted, but we set the '[ and ']
1673 * marks as if it happened. */
1676 if (vim_strchr(p_cpo
, CPO_EMPTYREGION
) != NULL
)
1682 * Do a yank of whatever we're about to delete.
1683 * If a yank register was specified, put the deleted text into that register.
1684 * For the black hole register '_' don't yank anything.
1686 if (oap
->regname
!= '_')
1688 if (oap
->regname
!= 0)
1690 /* check for read-only register */
1691 if (!valid_yank_reg(oap
->regname
, TRUE
))
1696 get_yank_register(oap
->regname
, TRUE
); /* yank into specif'd reg. */
1697 if (op_yank(oap
, TRUE
, FALSE
) == OK
) /* yank without message */
1702 * Put deleted text into register 1 and shift number registers if the
1703 * delete contains a line break, or when a regname has been specified.
1705 if (oap
->regname
!= 0 || oap
->motion_type
== MLINE
1706 || oap
->line_count
> 1 || oap
->use_reg_one
)
1708 y_current
= &y_regs
[9];
1709 free_yank_all(); /* free register nine */
1710 for (n
= 9; n
> 1; --n
)
1711 y_regs
[n
] = y_regs
[n
- 1];
1712 y_previous
= y_current
= &y_regs
[1];
1713 y_regs
[1].y_array
= NULL
; /* set register one to empty */
1714 if (op_yank(oap
, TRUE
, FALSE
) == OK
)
1718 /* Yank into small delete register when no register specified and the
1719 * delete is within one line. */
1720 if (oap
->regname
== 0 && oap
->motion_type
!= MLINE
1721 && oap
->line_count
== 1)
1724 get_yank_register(oap
->regname
, TRUE
);
1725 if (op_yank(oap
, TRUE
, FALSE
) == OK
)
1731 * If there's too much stuff to fit in the yank register, then get a
1732 * confirmation before doing the delete. This is crude, but simple.
1733 * And it avoids doing a delete of something we can't put back if we
1738 int msg_silent_save
= msg_silent
;
1740 msg_silent
= 0; /* must display the prompt */
1741 n
= ask_yesno((char_u
*)_("cannot yank; delete anyway"), TRUE
);
1742 msg_silent
= msg_silent_save
;
1755 if (oap
->block_mode
)
1757 if (u_save((linenr_T
)(oap
->start
.lnum
- 1),
1758 (linenr_T
)(oap
->end
.lnum
+ 1)) == FAIL
)
1761 for (lnum
= curwin
->w_cursor
.lnum
; lnum
<= oap
->end
.lnum
; ++lnum
)
1763 block_prep(oap
, &bd
, lnum
, TRUE
);
1764 if (bd
.textlen
== 0) /* nothing to delete */
1767 /* Adjust cursor position for tab replaced by spaces and 'lbr'. */
1768 if (lnum
== curwin
->w_cursor
.lnum
)
1770 curwin
->w_cursor
.col
= bd
.textcol
+ bd
.startspaces
;
1771 # ifdef FEAT_VIRTUALEDIT
1772 curwin
->w_cursor
.coladd
= 0;
1776 /* n == number of chars deleted
1777 * If we delete a TAB, it may be replaced by several characters.
1778 * Thus the number of characters may increase!
1780 n
= bd
.textlen
- bd
.startspaces
- bd
.endspaces
;
1781 oldp
= ml_get(lnum
);
1782 newp
= alloc_check((unsigned)STRLEN(oldp
) + 1 - n
);
1785 /* copy up to deleted part */
1786 mch_memmove(newp
, oldp
, (size_t)bd
.textcol
);
1788 copy_spaces(newp
+ bd
.textcol
,
1789 (size_t)(bd
.startspaces
+ bd
.endspaces
));
1790 /* copy the part after the deleted part */
1791 oldp
+= bd
.textcol
+ bd
.textlen
;
1792 STRMOVE(newp
+ bd
.textcol
+ bd
.startspaces
+ bd
.endspaces
, oldp
);
1793 /* replace the line */
1794 ml_replace(lnum
, newp
, FALSE
);
1798 changed_lines(curwin
->w_cursor
.lnum
, curwin
->w_cursor
.col
,
1799 oap
->end
.lnum
+ 1, 0L);
1800 oap
->line_count
= 0; /* no lines deleted */
1804 if (oap
->motion_type
== MLINE
)
1806 if (oap
->op_type
== OP_CHANGE
)
1808 /* Delete the lines except the first one. Temporarily move the
1809 * cursor to the next line. Save the current line number, if the
1810 * last line is deleted it may be changed.
1812 if (oap
->line_count
> 1)
1814 lnum
= curwin
->w_cursor
.lnum
;
1815 ++curwin
->w_cursor
.lnum
;
1816 del_lines((long)(oap
->line_count
- 1), TRUE
);
1817 curwin
->w_cursor
.lnum
= lnum
;
1819 if (u_save_cursor() == FAIL
)
1821 if (curbuf
->b_p_ai
) /* don't delete indent */
1823 beginline(BL_WHITE
); /* cursor on first non-white */
1824 did_ai
= TRUE
; /* delete the indent when ESC hit */
1825 ai_col
= curwin
->w_cursor
.col
;
1828 beginline(0); /* cursor in column 0 */
1829 truncate_line(FALSE
); /* delete the rest of the line */
1830 /* leave cursor past last char in line */
1831 if (oap
->line_count
> 1)
1832 u_clearline(); /* "U" command not possible after "2cc" */
1836 del_lines(oap
->line_count
, TRUE
);
1837 beginline(BL_WHITE
| BL_FIX
);
1838 u_clearline(); /* "U" command not possible after "dd" */
1843 #ifdef FEAT_VIRTUALEDIT
1848 /* For virtualedit: break the tabs that are partly included. */
1849 if (gchar_pos(&oap
->start
) == '\t')
1851 if (u_save_cursor() == FAIL
) /* save first line for undo */
1853 if (oap
->line_count
== 1)
1854 endcol
= getviscol2(oap
->end
.col
, oap
->end
.coladd
);
1855 coladvance_force(getviscol2(oap
->start
.col
, oap
->start
.coladd
));
1856 oap
->start
= curwin
->w_cursor
;
1857 if (oap
->line_count
== 1)
1860 oap
->end
.col
= curwin
->w_cursor
.col
;
1861 oap
->end
.coladd
= curwin
->w_cursor
.coladd
;
1862 curwin
->w_cursor
= oap
->start
;
1866 /* Break a tab only when it's included in the area. */
1867 if (gchar_pos(&oap
->end
) == '\t'
1868 && (int)oap
->end
.coladd
< oap
->inclusive
)
1870 /* save last line for undo */
1871 if (u_save((linenr_T
)(oap
->end
.lnum
- 1),
1872 (linenr_T
)(oap
->end
.lnum
+ 1)) == FAIL
)
1874 curwin
->w_cursor
= oap
->end
;
1875 coladvance_force(getviscol2(oap
->end
.col
, oap
->end
.coladd
));
1876 oap
->end
= curwin
->w_cursor
;
1877 curwin
->w_cursor
= oap
->start
;
1882 if (oap
->line_count
== 1) /* delete characters within one line */
1884 if (u_save_cursor() == FAIL
) /* save line for undo */
1887 /* if 'cpoptions' contains '$', display '$' at end of change */
1888 if ( vim_strchr(p_cpo
, CPO_DOLLAR
) != NULL
1889 && oap
->op_type
== OP_CHANGE
1890 && oap
->end
.lnum
== curwin
->w_cursor
.lnum
1895 display_dollar(oap
->end
.col
- !oap
->inclusive
);
1897 n
= oap
->end
.col
- oap
->start
.col
+ 1 - !oap
->inclusive
;
1899 #ifdef FEAT_VIRTUALEDIT
1902 /* fix up things for virtualedit-delete:
1903 * break the tabs which are going to get in our way
1905 char_u
*curline
= ml_get_curline();
1906 int len
= (int)STRLEN(curline
);
1908 if (oap
->end
.coladd
!= 0
1909 && (int)oap
->end
.col
>= len
- 1
1910 && !(oap
->start
.coladd
&& (int)oap
->end
.col
>= len
- 1))
1912 /* Delete at least one char (e.g, when on a control char). */
1913 if (n
== 0 && oap
->start
.coladd
!= oap
->end
.coladd
)
1916 /* When deleted a char in the line, reset coladd. */
1917 if (gchar_cursor() != NUL
)
1918 curwin
->w_cursor
.coladd
= 0;
1921 (void)del_bytes((long)n
, !virtual_op
, oap
->op_type
== OP_DELETE
1927 else /* delete characters between lines */
1931 /* save deleted and changed lines for undo */
1932 if (u_save((linenr_T
)(curwin
->w_cursor
.lnum
- 1),
1933 (linenr_T
)(curwin
->w_cursor
.lnum
+ oap
->line_count
)) == FAIL
)
1936 truncate_line(TRUE
); /* delete from cursor to end of line */
1938 curpos
= curwin
->w_cursor
; /* remember curwin->w_cursor */
1939 ++curwin
->w_cursor
.lnum
;
1940 del_lines((long)(oap
->line_count
- 2), FALSE
);
1942 /* delete from start of line until op_end */
1943 curwin
->w_cursor
.col
= 0;
1944 (void)del_bytes((long)(oap
->end
.col
+ 1 - !oap
->inclusive
),
1945 !virtual_op
, oap
->op_type
== OP_DELETE
1950 curwin
->w_cursor
= curpos
; /* restore curwin->w_cursor */
1952 (void)do_join(FALSE
);
1956 msgmore(curbuf
->b_ml
.ml_line_count
- old_lcount
);
1958 #ifdef FEAT_VIRTUALEDIT
1962 if (oap
->block_mode
)
1964 curbuf
->b_op_end
.lnum
= oap
->end
.lnum
;
1965 curbuf
->b_op_end
.col
= oap
->start
.col
;
1969 curbuf
->b_op_end
= oap
->start
;
1970 curbuf
->b_op_start
= oap
->start
;
1977 * Adjust end of operating area for ending on a multi-byte character.
1978 * Used for deletion.
1981 mb_adjust_opend(oap
)
1988 p
= ml_get(oap
->end
.lnum
);
1989 oap
->end
.col
+= mb_tail_off(p
, p
+ oap
->end
.col
);
1994 #if defined(FEAT_VISUALEXTRA) || defined(PROTO)
1996 * Replace a whole area with one character.
2007 char_u
*newp
, *oldp
;
2009 struct block_def bd
;
2011 if ((curbuf
->b_ml
.ml_flags
& ML_EMPTY
) || oap
->empty
)
2012 return OK
; /* nothing to do */
2016 mb_adjust_opend(oap
);
2019 if (u_save((linenr_T
)(oap
->start
.lnum
- 1),
2020 (linenr_T
)(oap
->end
.lnum
+ 1)) == FAIL
)
2024 * block mode replace
2026 if (oap
->block_mode
)
2028 bd
.is_MAX
= (curwin
->w_curswant
== MAXCOL
);
2029 for ( ; curwin
->w_cursor
.lnum
<= oap
->end
.lnum
; ++curwin
->w_cursor
.lnum
)
2031 curwin
->w_cursor
.col
= 0; /* make sure cursor position is valid */
2032 block_prep(oap
, &bd
, curwin
->w_cursor
.lnum
, TRUE
);
2033 if (bd
.textlen
== 0 && (!virtual_op
|| bd
.is_MAX
))
2034 continue; /* nothing to replace */
2036 /* n == number of extra chars required
2037 * If we split a TAB, it may be replaced by several characters.
2038 * Thus the number of characters may increase!
2040 #ifdef FEAT_VIRTUALEDIT
2041 /* If the range starts in virtual space, count the initial
2042 * coladd offset as part of "startspaces" */
2043 if (virtual_op
&& bd
.is_short
&& *bd
.textstart
== NUL
)
2047 vpos
.lnum
= curwin
->w_cursor
.lnum
;
2048 getvpos(&vpos
, oap
->start_vcol
);
2049 bd
.startspaces
+= vpos
.coladd
;
2054 /* allow for pre spaces */
2055 n
= (bd
.startspaces
? bd
.start_char_vcols
- 1 : 0);
2057 /* allow for post spp */
2059 #ifdef FEAT_VIRTUALEDIT
2062 && bd
.end_char_vcols
> 0) ? bd
.end_char_vcols
- 1 : 0;
2063 /* Figure out how many characters to replace. */
2064 numc
= oap
->end_vcol
- oap
->start_vcol
+ 1;
2065 if (bd
.is_short
&& (!virtual_op
|| bd
.is_MAX
))
2066 numc
-= (oap
->end_vcol
- bd
.end_vcol
) + 1;
2069 /* A double-wide character can be replaced only up to half the
2071 if ((*mb_char2cells
)(c
) > 1)
2073 if ((numc
& 1) && !bd
.is_short
)
2081 /* Compute bytes needed, move character count to num_chars. */
2083 numc
*= (*mb_char2len
)(c
);
2085 /* oldlen includes textlen, so don't double count */
2086 n
+= numc
- bd
.textlen
;
2088 oldp
= ml_get_curline();
2089 oldlen
= STRLEN(oldp
);
2090 newp
= alloc_check((unsigned)oldlen
+ 1 + n
);
2093 vim_memset(newp
, NUL
, (size_t)(oldlen
+ 1 + n
));
2094 /* copy up to deleted part */
2095 mch_memmove(newp
, oldp
, (size_t)bd
.textcol
);
2096 oldp
+= bd
.textcol
+ bd
.textlen
;
2097 /* insert pre-spaces */
2098 copy_spaces(newp
+ bd
.textcol
, (size_t)bd
.startspaces
);
2099 /* insert replacement chars CHECK FOR ALLOCATED SPACE */
2103 n
= (int)STRLEN(newp
);
2104 while (--num_chars
>= 0)
2105 n
+= (*mb_char2bytes
)(c
, newp
+ n
);
2109 copy_chars(newp
+ STRLEN(newp
), (size_t)numc
, c
);
2112 /* insert post-spaces */
2113 copy_spaces(newp
+ STRLEN(newp
), (size_t)bd
.endspaces
);
2114 /* copy the part after the changed part */
2115 STRMOVE(newp
+ STRLEN(newp
), oldp
);
2117 /* replace the line */
2118 ml_replace(curwin
->w_cursor
.lnum
, newp
, FALSE
);
2124 * MCHAR and MLINE motion replace.
2126 if (oap
->motion_type
== MLINE
)
2129 curwin
->w_cursor
.col
= 0;
2130 oap
->end
.col
= (colnr_T
)STRLEN(ml_get(oap
->end
.lnum
));
2134 else if (!oap
->inclusive
)
2137 while (ltoreq(curwin
->w_cursor
, oap
->end
))
2143 if ((*mb_char2len
)(c
) > 1 || (*mb_char2len
)(n
) > 1)
2145 /* This is slow, but it handles replacing a single-byte
2146 * with a multi-byte and the other way around. */
2147 oap
->end
.col
+= (*mb_char2len
)(c
) - (*mb_char2len
)(n
);
2152 /* Backup to the replaced character. */
2158 #ifdef FEAT_VIRTUALEDIT
2163 if (curwin
->w_cursor
.lnum
== oap
->end
.lnum
)
2165 /* oap->end has to be recalculated when
2167 end_vcol
= getviscol2(oap
->end
.col
,
2170 coladvance_force(getviscol());
2171 if (curwin
->w_cursor
.lnum
== oap
->end
.lnum
)
2172 getvpos(&oap
->end
, end_vcol
);
2175 pchar(curwin
->w_cursor
, c
);
2178 #ifdef FEAT_VIRTUALEDIT
2179 else if (virtual_op
&& curwin
->w_cursor
.lnum
== oap
->end
.lnum
)
2181 int virtcols
= oap
->end
.coladd
;
2183 if (curwin
->w_cursor
.lnum
== oap
->start
.lnum
2184 && oap
->start
.col
== oap
->end
.col
&& oap
->start
.coladd
)
2185 virtcols
-= oap
->start
.coladd
;
2187 /* oap->end has been trimmed so it's effectively inclusive;
2188 * as a result an extra +1 must be counted so we don't
2189 * trample the NUL byte. */
2190 coladvance_force(getviscol2(oap
->end
.col
, oap
->end
.coladd
) + 1);
2191 curwin
->w_cursor
.col
-= (virtcols
+ 1);
2192 for (; virtcols
>= 0; virtcols
--)
2194 pchar(curwin
->w_cursor
, c
);
2195 if (inc(&curwin
->w_cursor
) == -1)
2201 /* Advance to next character, stop at the end of the file. */
2202 if (inc_cursor() == -1)
2207 curwin
->w_cursor
= oap
->start
;
2209 changed_lines(oap
->start
.lnum
, oap
->start
.col
, oap
->end
.lnum
+ 1, 0L);
2211 /* Set "'[" and "']" marks. */
2212 curbuf
->b_op_start
= oap
->start
;
2213 curbuf
->b_op_end
= oap
->end
;
2219 static int swapchars
__ARGS((int op_type
, pos_T
*pos
, int length
));
2222 * Handle the (non-standard vi) tilde operator. Also for "gu", "gU" and "g?".
2230 struct block_def bd
;
2232 int did_change
= FALSE
;
2234 if (u_save((linenr_T
)(oap
->start
.lnum
- 1),
2235 (linenr_T
)(oap
->end
.lnum
+ 1)) == FAIL
)
2240 if (oap
->block_mode
) /* Visual block mode */
2242 for (; pos
.lnum
<= oap
->end
.lnum
; ++pos
.lnum
)
2246 block_prep(oap
, &bd
, pos
.lnum
, FALSE
);
2247 pos
.col
= bd
.textcol
;
2248 one_change
= swapchars(oap
->op_type
, &pos
, bd
.textlen
);
2249 did_change
|= one_change
;
2251 # ifdef FEAT_NETBEANS_INTG
2252 if (usingNetbeans
&& one_change
)
2254 char_u
*ptr
= ml_get_buf(curbuf
, pos
.lnum
, FALSE
);
2256 netbeans_removed(curbuf
, pos
.lnum
, bd
.textcol
,
2258 netbeans_inserted(curbuf
, pos
.lnum
, bd
.textcol
,
2259 &ptr
[bd
.textcol
], bd
.textlen
);
2264 changed_lines(oap
->start
.lnum
, 0, oap
->end
.lnum
+ 1, 0L);
2266 else /* not block mode */
2269 if (oap
->motion_type
== MLINE
)
2273 oap
->end
.col
= (colnr_T
)STRLEN(ml_get(oap
->end
.lnum
));
2277 else if (!oap
->inclusive
)
2280 if (pos
.lnum
== oap
->end
.lnum
)
2281 did_change
= swapchars(oap
->op_type
, &pos
,
2282 oap
->end
.col
- pos
.col
+ 1);
2286 did_change
|= swapchars(oap
->op_type
, &pos
,
2287 pos
.lnum
== oap
->end
.lnum
? oap
->end
.col
+ 1:
2288 (int)STRLEN(ml_get_pos(&pos
)));
2289 if (ltoreq(oap
->end
, pos
) || inc(&pos
) == -1)
2294 changed_lines(oap
->start
.lnum
, oap
->start
.col
, oap
->end
.lnum
+ 1,
2296 #ifdef FEAT_NETBEANS_INTG
2297 if (usingNetbeans
&& did_change
)
2303 while (pos
.lnum
< oap
->end
.lnum
)
2305 ptr
= ml_get_buf(curbuf
, pos
.lnum
, FALSE
);
2306 count
= (int)STRLEN(ptr
) - pos
.col
;
2307 netbeans_removed(curbuf
, pos
.lnum
, pos
.col
, (long)count
);
2308 netbeans_inserted(curbuf
, pos
.lnum
, pos
.col
,
2309 &ptr
[pos
.col
], count
);
2313 ptr
= ml_get_buf(curbuf
, pos
.lnum
, FALSE
);
2314 count
= oap
->end
.col
- pos
.col
+ 1;
2315 netbeans_removed(curbuf
, pos
.lnum
, pos
.col
, (long)count
);
2316 netbeans_inserted(curbuf
, pos
.lnum
, pos
.col
,
2317 &ptr
[pos
.col
], count
);
2324 if (!did_change
&& oap
->is_VIsual
)
2325 /* No change: need to remove the Visual selection */
2326 redraw_curbuf_later(INVERTED
);
2330 * Set '[ and '] marks.
2332 curbuf
->b_op_start
= oap
->start
;
2333 curbuf
->b_op_end
= oap
->end
;
2335 if (oap
->line_count
> p_report
)
2337 if (oap
->line_count
== 1)
2338 MSG(_("1 line changed"));
2340 smsg((char_u
*)_("%ld lines changed"), oap
->line_count
);
2345 * Invoke swapchar() on "length" bytes at position "pos".
2346 * "pos" is advanced to just after the changed characters.
2347 * "length" is rounded up to include the whole last multi-byte character.
2348 * Also works correctly when the number of bytes changes.
2349 * Returns TRUE if some character was changed.
2352 swapchars(op_type
, pos
, length
)
2360 for (todo
= length
; todo
> 0; --todo
)
2364 /* we're counting bytes, not characters */
2365 todo
-= (*mb_ptr2len
)(ml_get_pos(pos
)) - 1;
2367 did_change
|= swapchar(op_type
, pos
);
2368 if (inc(pos
) == -1) /* at end of file */
2375 * If op_type == OP_UPPER: make uppercase,
2376 * if op_type == OP_LOWER: make lowercase,
2377 * if op_type == OP_ROT13: do rot13 encoding,
2378 * else swap case of character at 'pos'
2379 * returns TRUE when something actually changed.
2382 swapchar(op_type
, pos
)
2391 /* Only do rot13 encoding for ASCII characters. */
2392 if (c
>= 0x80 && op_type
== OP_ROT13
)
2396 if (op_type
== OP_UPPER
&& c
== 0xdf
2397 && (enc_latin1like
|| STRCMP(p_enc
, "iso-8859-2") == 0))
2399 pos_T sp
= curwin
->w_cursor
;
2401 /* Special handling of German sharp s: change to "SS". */
2402 curwin
->w_cursor
= *pos
;
2406 curwin
->w_cursor
= sp
;
2410 if (enc_dbcs
!= 0 && c
>= 0x100) /* No lower/uppercase letter */
2416 if (op_type
== OP_ROT13
)
2418 else if (op_type
!= OP_LOWER
)
2421 else if (MB_ISUPPER(c
))
2423 if (op_type
== OP_ROT13
)
2425 else if (op_type
!= OP_UPPER
)
2431 if (enc_utf8
&& (c
>= 0x80 || nc
>= 0x80))
2433 pos_T sp
= curwin
->w_cursor
;
2435 curwin
->w_cursor
= *pos
;
2438 curwin
->w_cursor
= sp
;
2448 #if defined(FEAT_VISUALEXTRA) || defined(PROTO)
2450 * op_insert - Insert and append operators for Visual mode.
2453 op_insert(oap
, count1
)
2457 long ins_len
, pre_textlen
= 0;
2458 char_u
*firstline
, *ins_text
;
2459 struct block_def bd
;
2462 /* edit() changes this - record it for OP_APPEND */
2463 bd
.is_MAX
= (curwin
->w_curswant
== MAXCOL
);
2465 /* vis block is still marked. Get rid of it now. */
2466 curwin
->w_cursor
.lnum
= oap
->start
.lnum
;
2467 update_screen(INVERTED
);
2469 if (oap
->block_mode
)
2471 #ifdef FEAT_VIRTUALEDIT
2472 /* When 'virtualedit' is used, need to insert the extra spaces before
2473 * doing block_prep(). When only "block" is used, virtual edit is
2474 * already disabled, but still need it when calling
2475 * coladvance_force(). */
2476 if (curwin
->w_cursor
.coladd
> 0)
2478 int old_ve_flags
= ve_flags
;
2481 if (u_save_cursor() == FAIL
)
2483 coladvance_force(oap
->op_type
== OP_APPEND
2484 ? oap
->end_vcol
+ 1 : getviscol());
2485 if (oap
->op_type
== OP_APPEND
)
2486 --curwin
->w_cursor
.col
;
2487 ve_flags
= old_ve_flags
;
2490 /* Get the info about the block before entering the text */
2491 block_prep(oap
, &bd
, oap
->start
.lnum
, TRUE
);
2492 firstline
= ml_get(oap
->start
.lnum
) + bd
.textcol
;
2493 if (oap
->op_type
== OP_APPEND
)
2494 firstline
+= bd
.textlen
;
2495 pre_textlen
= (long)STRLEN(firstline
);
2498 if (oap
->op_type
== OP_APPEND
)
2501 #ifdef FEAT_VIRTUALEDIT
2502 && curwin
->w_cursor
.coladd
== 0
2506 /* Move the cursor to the character right of the block. */
2507 curwin
->w_set_curswant
= TRUE
;
2508 while (*ml_get_cursor() != NUL
2509 && (curwin
->w_cursor
.col
< bd
.textcol
+ bd
.textlen
))
2510 ++curwin
->w_cursor
.col
;
2511 if (bd
.is_short
&& !bd
.is_MAX
)
2513 /* First line was too short, make it longer and adjust the
2514 * values in "bd". */
2515 if (u_save_cursor() == FAIL
)
2517 for (i
= 0; i
< bd
.endspaces
; ++i
)
2519 bd
.textlen
+= bd
.endspaces
;
2524 curwin
->w_cursor
= oap
->end
;
2527 /* Works just like an 'i'nsert on the next character. */
2528 if (!lineempty(curwin
->w_cursor
.lnum
)
2529 && oap
->start_vcol
!= oap
->end_vcol
)
2534 edit(NUL
, FALSE
, (linenr_T
)count1
);
2536 /* If user has moved off this line, we don't know what to do, so do
2538 * Also don't repeat the insert when Insert mode ended with CTRL-C. */
2539 if (curwin
->w_cursor
.lnum
!= oap
->start
.lnum
|| got_int
)
2542 if (oap
->block_mode
)
2544 struct block_def bd2
;
2547 * Spaces and tabs in the indent may have changed to other spaces and
2548 * tabs. Get the starting column again and correct the length.
2549 * Don't do this when "$" used, end-of-line will have changed.
2551 block_prep(oap
, &bd2
, oap
->start
.lnum
, TRUE
);
2552 if (!bd
.is_MAX
|| bd2
.textlen
< bd
.textlen
)
2554 if (oap
->op_type
== OP_APPEND
)
2556 pre_textlen
+= bd2
.textlen
- bd
.textlen
;
2560 bd
.textcol
= bd2
.textcol
;
2561 bd
.textlen
= bd2
.textlen
;
2565 * Subsequent calls to ml_get() flush the firstline data - take a
2566 * copy of the required string.
2568 firstline
= ml_get(oap
->start
.lnum
) + bd
.textcol
;
2569 if (oap
->op_type
== OP_APPEND
)
2570 firstline
+= bd
.textlen
;
2571 if ((ins_len
= (long)STRLEN(firstline
) - pre_textlen
) > 0)
2573 ins_text
= vim_strnsave(firstline
, (int)ins_len
);
2574 if (ins_text
!= NULL
)
2576 /* block handled here */
2577 if (u_save(oap
->start
.lnum
,
2578 (linenr_T
)(oap
->end
.lnum
+ 1)) == OK
)
2579 block_insert(oap
, ins_text
, (oap
->op_type
== OP_INSERT
),
2582 curwin
->w_cursor
.col
= oap
->start
.col
;
2592 * op_change - handle a change operation
2594 * return TRUE if edit() returns because of a CTRL-O command
2602 #ifdef FEAT_VISUALEXTRA
2606 long pre_textlen
= 0;
2607 long pre_indent
= 0;
2609 char_u
*ins_text
, *newp
, *oldp
;
2610 struct block_def bd
;
2614 if (oap
->motion_type
== MLINE
)
2617 #ifdef FEAT_SMARTINDENT
2618 if (!p_paste
&& curbuf
->b_p_si
2619 # ifdef FEAT_CINDENT
2623 can_si
= TRUE
; /* It's like opening a new line, do si */
2627 /* First delete the text in the region. In an empty buffer only need to
2629 if (curbuf
->b_ml
.ml_flags
& ML_EMPTY
)
2631 if (u_save_cursor() == FAIL
)
2634 else if (op_delete(oap
) == FAIL
)
2637 if ((l
> curwin
->w_cursor
.col
) && !lineempty(curwin
->w_cursor
.lnum
)
2641 #ifdef FEAT_VISUALEXTRA
2642 /* check for still on same line (<CR> in inserted text meaningless) */
2643 /* skip blank lines too */
2644 if (oap
->block_mode
)
2646 # ifdef FEAT_VIRTUALEDIT
2647 /* Add spaces before getting the current line length. */
2648 if (virtual_op
&& (curwin
->w_cursor
.coladd
> 0
2649 || gchar_cursor() == NUL
))
2650 coladvance_force(getviscol());
2652 firstline
= ml_get(oap
->start
.lnum
);
2653 pre_textlen
= (long)STRLEN(firstline
);
2654 pre_indent
= (long)(skipwhite(firstline
) - firstline
);
2655 bd
.textcol
= curwin
->w_cursor
.col
;
2659 #if defined(FEAT_LISP) || defined(FEAT_CINDENT)
2660 if (oap
->motion_type
== MLINE
)
2664 retval
= edit(NUL
, FALSE
, (linenr_T
)1);
2666 #ifdef FEAT_VISUALEXTRA
2668 * In Visual block mode, handle copying the new text to all lines of the
2670 * Don't repeat the insert when Insert mode ended with CTRL-C.
2672 if (oap
->block_mode
&& oap
->start
.lnum
!= oap
->end
.lnum
&& !got_int
)
2674 /* Auto-indenting may have changed the indent. If the cursor was past
2675 * the indent, exclude that indent change from the inserted text. */
2676 firstline
= ml_get(oap
->start
.lnum
);
2677 if (bd
.textcol
> (colnr_T
)pre_indent
)
2679 long new_indent
= (long)(skipwhite(firstline
) - firstline
);
2681 pre_textlen
+= new_indent
- pre_indent
;
2682 bd
.textcol
+= new_indent
- pre_indent
;
2685 ins_len
= (long)STRLEN(firstline
) - pre_textlen
;
2688 /* Subsequent calls to ml_get() flush the firstline data - take a
2689 * copy of the inserted text. */
2690 if ((ins_text
= alloc_check((unsigned)(ins_len
+ 1))) != NULL
)
2692 vim_strncpy(ins_text
, firstline
+ bd
.textcol
, (size_t)ins_len
);
2693 for (linenr
= oap
->start
.lnum
+ 1; linenr
<= oap
->end
.lnum
;
2696 block_prep(oap
, &bd
, linenr
, TRUE
);
2697 if (!bd
.is_short
|| virtual_op
)
2699 # ifdef FEAT_VIRTUALEDIT
2702 /* If the block starts in virtual space, count the
2703 * initial coladd offset as part of "startspaces" */
2707 (void)getvpos(&vpos
, oap
->start_vcol
);
2712 oldp
= ml_get(linenr
);
2713 newp
= alloc_check((unsigned)(STRLEN(oldp
)
2714 # ifdef FEAT_VIRTUALEDIT
2720 /* copy up to block start */
2721 mch_memmove(newp
, oldp
, (size_t)bd
.textcol
);
2722 offset
= bd
.textcol
;
2723 # ifdef FEAT_VIRTUALEDIT
2724 copy_spaces(newp
+ offset
, (size_t)vpos
.coladd
);
2725 offset
+= vpos
.coladd
;
2727 mch_memmove(newp
+ offset
, ins_text
, (size_t)ins_len
);
2730 STRMOVE(newp
+ offset
, oldp
);
2731 ml_replace(linenr
, newp
, FALSE
);
2736 changed_lines(oap
->start
.lnum
+ 1, 0, oap
->end
.lnum
+ 1, 0L);
2747 * set all the yank registers to empty (called from main())
2754 for (i
= 0; i
< NUM_REGISTERS
; ++i
)
2755 y_regs
[i
].y_array
= NULL
;
2758 #if defined(EXITFREE) || defined(PROTO)
2764 for (i
= 0; i
< NUM_REGISTERS
; ++i
)
2766 y_current
= &y_regs
[i
];
2767 if (y_current
->y_array
!= NULL
)
2774 * Free "n" lines from the current yank register.
2775 * Called for normal freeing and in case of error.
2781 if (y_current
->y_array
!= NULL
)
2785 for (i
= n
; --i
>= 0; )
2787 #ifdef AMIGA /* only for very slow machines */
2788 if ((i
& 1023) == 1023) /* this may take a while */
2791 * This message should never cause a hit-return message.
2792 * Overwrite this message with any next message.
2795 smsg((char_u
*)_("freeing %ld lines"), i
+ 1);
2801 vim_free(y_current
->y_array
[i
]);
2803 vim_free(y_current
->y_array
);
2804 y_current
->y_array
= NULL
;
2815 free_yank(y_current
->y_size
);
2819 * Yank the text between "oap->start" and "oap->end" into a yank register.
2820 * If we are to append (uppercase register), we first yank into a new yank
2821 * register and then concatenate the old and the new one (so we keep the old
2822 * one in case of out-of-memory).
2824 * return FAIL for failure, OK otherwise
2827 op_yank(oap
, deleting
, mess
)
2832 long y_idx
; /* index in y_array[] */
2833 struct yankreg
*curr
; /* copy of y_current */
2834 struct yankreg newreg
; /* new yank register when appending */
2836 linenr_T lnum
; /* current line number */
2838 int yanktype
= oap
->motion_type
;
2839 long yanklines
= oap
->line_count
;
2840 linenr_T yankendlnum
= oap
->end
.lnum
;
2843 struct block_def bd
;
2845 /* check for read-only register */
2846 if (oap
->regname
!= 0 && !valid_yank_reg(oap
->regname
, TRUE
))
2851 if (oap
->regname
== '_') /* black hole: nothing to do */
2854 #ifdef FEAT_CLIPBOARD
2855 if (!clip_star
.available
&& oap
->regname
== '*')
2857 else if (!clip_plus
.available
&& oap
->regname
== '+')
2861 if (!deleting
) /* op_delete() already set y_current */
2862 get_yank_register(oap
->regname
, TRUE
);
2865 /* append to existing contents */
2866 if (y_append
&& y_current
->y_array
!= NULL
)
2867 y_current
= &newreg
;
2869 free_yank_all(); /* free previously yanked lines */
2872 * If the cursor was in column 1 before and after the movement, and the
2873 * operator is not inclusive, the yank is always linewise.
2875 if ( oap
->motion_type
== MCHAR
2876 && oap
->start
.col
== 0
2879 && (!oap
->is_VIsual
|| *p_sel
== 'o')
2882 && oap
->end
.col
== 0
2890 y_current
->y_size
= yanklines
;
2891 y_current
->y_type
= yanktype
; /* set the yank register type */
2893 y_current
->y_width
= 0;
2895 y_current
->y_array
= (char_u
**)lalloc_clear((long_u
)(sizeof(char_u
*) *
2898 if (y_current
->y_array
== NULL
)
2905 lnum
= oap
->start
.lnum
;
2908 if (oap
->block_mode
)
2910 /* Visual block mode */
2911 y_current
->y_type
= MBLOCK
; /* set the yank register type */
2912 y_current
->y_width
= oap
->end_vcol
- oap
->start_vcol
;
2914 if (curwin
->w_curswant
== MAXCOL
&& y_current
->y_width
> 0)
2915 y_current
->y_width
--;
2919 for ( ; lnum
<= yankendlnum
; lnum
++, y_idx
++)
2921 switch (y_current
->y_type
)
2925 block_prep(oap
, &bd
, lnum
, FALSE
);
2926 if (yank_copy_line(&bd
, y_idx
) == FAIL
)
2932 if ((y_current
->y_array
[y_idx
] =
2933 vim_strsave(ml_get(lnum
))) == NULL
)
2939 colnr_T startcol
= 0, endcol
= MAXCOL
;
2940 #ifdef FEAT_VIRTUALEDIT
2941 int is_oneChar
= FALSE
;
2948 if (lnum
== oap
->start
.lnum
)
2950 startcol
= oap
->start
.col
;
2951 #ifdef FEAT_VIRTUALEDIT
2954 getvcol(curwin
, &oap
->start
, &cs
, NULL
, &ce
);
2955 if (ce
!= cs
&& oap
->start
.coladd
> 0)
2957 /* Part of a tab selected -- but don't
2958 * double-count it. */
2959 bd
.startspaces
= (ce
- cs
+ 1)
2960 - oap
->start
.coladd
;
2967 if (lnum
== oap
->end
.lnum
)
2969 endcol
= oap
->end
.col
;
2970 #ifdef FEAT_VIRTUALEDIT
2973 getvcol(curwin
, &oap
->end
, &cs
, NULL
, &ce
);
2974 if (p
[endcol
] == NUL
|| (cs
+ oap
->end
.coladd
< ce
2976 /* Don't add space for double-wide
2977 * char; endcol will be on last byte
2978 * of multi-byte char. */
2979 && (*mb_head_off
)(p
, p
+ endcol
) == 0
2983 if (oap
->start
.lnum
== oap
->end
.lnum
2984 && oap
->start
.col
== oap
->end
.col
)
2986 /* Special case: inside a single char */
2988 bd
.startspaces
= oap
->end
.coladd
2989 - oap
->start
.coladd
+ oap
->inclusive
;
2994 bd
.endspaces
= oap
->end
.coladd
2996 endcol
-= oap
->inclusive
;
3002 if (startcol
> endcol
3003 #ifdef FEAT_VIRTUALEDIT
3010 if (endcol
== MAXCOL
)
3011 endcol
= (colnr_T
)STRLEN(p
);
3012 bd
.textlen
= endcol
- startcol
+ oap
->inclusive
;
3014 bd
.textstart
= p
+ startcol
;
3015 if (yank_copy_line(&bd
, y_idx
) == FAIL
)
3023 if (curr
!= y_current
) /* append the new block to the old block */
3025 new_ptr
= (char_u
**)lalloc((long_u
)(sizeof(char_u
*) *
3026 (curr
->y_size
+ y_current
->y_size
)), TRUE
);
3027 if (new_ptr
== NULL
)
3029 for (j
= 0; j
< curr
->y_size
; ++j
)
3030 new_ptr
[j
] = curr
->y_array
[j
];
3031 vim_free(curr
->y_array
);
3032 curr
->y_array
= new_ptr
;
3034 if (yanktype
== MLINE
) /* MLINE overrides MCHAR and MBLOCK */
3035 curr
->y_type
= MLINE
;
3037 /* Concatenate the last line of the old block with the first line of
3038 * the new block, unless being Vi compatible. */
3039 if (curr
->y_type
== MCHAR
&& vim_strchr(p_cpo
, CPO_REGAPPEND
) == NULL
)
3041 pnew
= lalloc((long_u
)(STRLEN(curr
->y_array
[curr
->y_size
- 1])
3042 + STRLEN(y_current
->y_array
[0]) + 1), TRUE
);
3045 y_idx
= y_current
->y_size
- 1;
3048 STRCPY(pnew
, curr
->y_array
[--j
]);
3049 STRCAT(pnew
, y_current
->y_array
[0]);
3050 vim_free(curr
->y_array
[j
]);
3051 vim_free(y_current
->y_array
[0]);
3052 curr
->y_array
[j
++] = pnew
;
3057 while (y_idx
< y_current
->y_size
)
3058 curr
->y_array
[j
++] = y_current
->y_array
[y_idx
++];
3060 vim_free(y_current
->y_array
);
3063 if (mess
) /* Display message about yank? */
3065 if (yanktype
== MCHAR
3071 /* Some versions of Vi use ">=" here, some don't... */
3072 if (yanklines
> p_report
)
3074 /* redisplay now, so message is not deleted */
3075 update_topline_redraw();
3079 if (oap
->block_mode
)
3080 MSG(_("block of 1 line yanked"));
3083 MSG(_("1 line yanked"));
3086 else if (oap
->block_mode
)
3087 smsg((char_u
*)_("block of %ld lines yanked"), yanklines
);
3090 smsg((char_u
*)_("%ld lines yanked"), yanklines
);
3095 * Set "'[" and "']" marks.
3097 curbuf
->b_op_start
= oap
->start
;
3098 curbuf
->b_op_end
= oap
->end
;
3099 if (yanktype
== MLINE
3105 curbuf
->b_op_start
.col
= 0;
3106 curbuf
->b_op_end
.col
= MAXCOL
;
3109 #ifdef FEAT_CLIPBOARD
3111 * If we were yanking to the '*' register, send result to clipboard.
3112 * If no register was specified, and "unnamed" in 'clipboard', make a copy
3113 * to the '*' register.
3115 if (clip_star
.available
3116 && (curr
== &(y_regs
[STAR_REGISTER
])
3117 || (!deleting
&& oap
->regname
== 0 && clip_unnamed
)))
3119 if (curr
!= &(y_regs
[STAR_REGISTER
]))
3120 /* Copy the text from register 0 to the clipboard register. */
3121 copy_yank_reg(&(y_regs
[STAR_REGISTER
]));
3123 clip_own_selection(&clip_star
);
3124 clip_gen_set_selection(&clip_star
);
3129 * If we were yanking to the '+' register, send result to selection.
3130 * Also copy to the '*' register, in case auto-select is off.
3132 else if (clip_plus
.available
&& curr
== &(y_regs
[PLUS_REGISTER
]))
3134 /* No need to copy to * register upon 'unnamed' now - see below */
3135 clip_own_selection(&clip_plus
);
3136 clip_gen_set_selection(&clip_plus
);
3137 if (!clip_isautosel())
3139 copy_yank_reg(&(y_regs
[STAR_REGISTER
]));
3140 clip_own_selection(&clip_star
);
3141 clip_gen_set_selection(&clip_star
);
3149 fail
: /* free the allocated lines */
3150 free_yank(y_idx
+ 1);
3156 yank_copy_line(bd
, y_idx
)
3157 struct block_def
*bd
;
3162 if ((pnew
= alloc(bd
->startspaces
+ bd
->endspaces
+ bd
->textlen
+ 1))
3165 y_current
->y_array
[y_idx
] = pnew
;
3166 copy_spaces(pnew
, (size_t)bd
->startspaces
);
3167 pnew
+= bd
->startspaces
;
3168 mch_memmove(pnew
, bd
->textstart
, (size_t)bd
->textlen
);
3169 pnew
+= bd
->textlen
;
3170 copy_spaces(pnew
, (size_t)bd
->endspaces
);
3171 pnew
+= bd
->endspaces
;
3176 #ifdef FEAT_CLIPBOARD
3178 * Make a copy of the y_current register to register "reg".
3182 struct yankreg
*reg
;
3184 struct yankreg
*curr
= y_current
;
3190 y_current
->y_array
= (char_u
**)lalloc_clear(
3191 (long_u
)(sizeof(char_u
*) * y_current
->y_size
), TRUE
);
3192 if (y_current
->y_array
== NULL
)
3193 y_current
->y_size
= 0;
3195 for (j
= 0; j
< y_current
->y_size
; ++j
)
3196 if ((y_current
->y_array
[j
] = vim_strsave(curr
->y_array
[j
])) == NULL
)
3199 y_current
->y_size
= 0;
3207 * Put contents of register "regname" into the text.
3208 * Caller must check "regname" to be valid!
3209 * "flags": PUT_FIXINDENT make indent look nice
3210 * PUT_CURSEND leave cursor after end of new text
3211 * PUT_LINE force linewise put (":put")
3214 do_put(regname
, dir
, count
, flags
)
3216 int dir
; /* BACKWARD for 'P', FORWARD for 'p' */
3221 char_u
*newp
, *oldp
;
3223 int totlen
= 0; /* init for gcc */
3226 long i
; /* index in y_array[] */
3236 struct block_def bd
;
3238 char_u
**y_array
= NULL
;
3242 int orig_indent
= 0; /* init for gcc */
3243 int indent_diff
= 0; /* init for gcc */
3244 int first_indent
= TRUE
;
3247 char_u
*insert_string
= NULL
;
3248 int allocated
= FALSE
;
3251 #ifdef FEAT_CLIPBOARD
3252 /* Adjust register name for "unnamed" in 'clipboard'. */
3253 adjust_clip_reg(®name
);
3254 (void)may_get_selection(regname
);
3257 if (flags
& PUT_FIXINDENT
)
3258 orig_indent
= get_indent();
3260 curbuf
->b_op_start
= curwin
->w_cursor
; /* default for '[ mark */
3261 curbuf
->b_op_end
= curwin
->w_cursor
; /* default for '] mark */
3264 * Using inserted text works differently, because the register includes
3265 * special characters (newlines, etc.).
3269 (void)stuff_inserted((dir
== FORWARD
? (count
== -1 ? 'o' : 'a') :
3270 (count
== -1 ? 'O' : 'i')), count
, FALSE
);
3271 /* Putting the text is done later, so can't really move the cursor to
3272 * the next character. Use "l" to simulate it. */
3273 if ((flags
& PUT_CURSEND
) && gchar_cursor() != NUL
)
3274 stuffcharReadbuff('l');
3279 * For special registers '%' (file name), '#' (alternate file name) and
3280 * ':' (last command line), etc. we have to create a fake yank register.
3282 if (get_spec_reg(regname
, &insert_string
, &allocated
, TRUE
))
3284 if (insert_string
== NULL
)
3288 if (insert_string
!= NULL
)
3294 /* For the = register we need to split the string at NL
3296 /* Loop twice: count the number of lines and save them. */
3300 ptr
= insert_string
;
3303 if (y_array
!= NULL
)
3304 y_array
[y_size
] = ptr
;
3306 ptr
= vim_strchr(ptr
, '\n');
3309 if (y_array
!= NULL
)
3312 /* A trailing '\n' makes the string linewise */
3320 if (y_array
!= NULL
)
3322 y_array
= (char_u
**)alloc((unsigned)
3323 (y_size
* sizeof(char_u
*)));
3324 if (y_array
== NULL
)
3331 y_size
= 1; /* use fake one-line yank register */
3332 y_array
= &insert_string
;
3337 get_yank_register(regname
, FALSE
);
3339 y_type
= y_current
->y_type
;
3341 y_width
= y_current
->y_width
;
3343 y_size
= y_current
->y_size
;
3344 y_array
= y_current
->y_array
;
3348 if (y_type
== MLINE
)
3350 if (flags
& PUT_LINE_SPLIT
)
3352 /* "p" or "P" in Visual mode: split the lines to put the text in
3354 if (u_save_cursor() == FAIL
)
3356 ptr
= vim_strsave(ml_get_cursor());
3359 ml_append(curwin
->w_cursor
.lnum
, ptr
, (colnr_T
)0, FALSE
);
3362 ptr
= vim_strnsave(ml_get_curline(), curwin
->w_cursor
.col
);
3365 ml_replace(curwin
->w_cursor
.lnum
, ptr
, FALSE
);
3369 if (flags
& PUT_LINE_FORWARD
)
3371 /* Must be "p" for a Visual block, put lines below the block. */
3372 curwin
->w_cursor
= curbuf
->b_visual
.vi_end
;
3375 curbuf
->b_op_start
= curwin
->w_cursor
; /* default for '[ mark */
3376 curbuf
->b_op_end
= curwin
->w_cursor
; /* default for '] mark */
3380 if (flags
& PUT_LINE
) /* :put command or "p" in Visual line mode. */
3383 if (y_size
== 0 || y_array
== NULL
)
3385 EMSG2(_("E353: Nothing in register %s"),
3386 regname
== 0 ? (char_u
*)"\"" : transchar(regname
));
3391 if (y_type
== MBLOCK
)
3393 lnum
= curwin
->w_cursor
.lnum
+ y_size
+ 1;
3394 if (lnum
> curbuf
->b_ml
.ml_line_count
)
3395 lnum
= curbuf
->b_ml
.ml_line_count
+ 1;
3396 if (u_save(curwin
->w_cursor
.lnum
- 1, lnum
) == FAIL
)
3401 if (y_type
== MLINE
)
3403 lnum
= curwin
->w_cursor
.lnum
;
3405 /* Correct line number for closed fold. Don't move the cursor yet,
3406 * u_save() uses it. */
3407 if (dir
== BACKWARD
)
3408 (void)hasFolding(lnum
, &lnum
, NULL
);
3410 (void)hasFolding(lnum
, NULL
, &lnum
);
3414 if (u_save(lnum
- 1, lnum
) == FAIL
)
3418 curwin
->w_cursor
.lnum
= lnum
- 1;
3420 curwin
->w_cursor
.lnum
= lnum
;
3421 curbuf
->b_op_start
= curwin
->w_cursor
; /* for mark_adjust() */
3424 else if (u_save_cursor() == FAIL
)
3427 yanklen
= (int)STRLEN(y_array
[0]);
3429 #ifdef FEAT_VIRTUALEDIT
3430 if (ve_flags
== VE_ALL
&& y_type
== MCHAR
)
3432 if (gchar_cursor() == TAB
)
3434 /* Don't need to insert spaces when "p" on the last position of a
3435 * tab or "P" on the first position. */
3437 ? (int)curwin
->w_cursor
.coladd
< curbuf
->b_p_ts
- 1
3438 : curwin
->w_cursor
.coladd
> 0)
3439 coladvance_force(getviscol());
3441 curwin
->w_cursor
.coladd
= 0;
3443 else if (curwin
->w_cursor
.coladd
> 0 || gchar_cursor() == NUL
)
3444 coladvance_force(getviscol() + (dir
== FORWARD
));
3448 lnum
= curwin
->w_cursor
.lnum
;
3449 col
= curwin
->w_cursor
.col
;
3455 if (y_type
== MBLOCK
)
3457 char c
= gchar_cursor();
3458 colnr_T endcol2
= 0;
3460 if (dir
== FORWARD
&& c
!= NUL
)
3462 #ifdef FEAT_VIRTUALEDIT
3463 if (ve_flags
== VE_ALL
)
3464 getvcol(curwin
, &curwin
->w_cursor
, &col
, NULL
, &endcol2
);
3467 getvcol(curwin
, &curwin
->w_cursor
, NULL
, NULL
, &col
);
3471 /* move to start of next multi-byte character */
3472 curwin
->w_cursor
.col
+= (*mb_ptr2len
)(ml_get_cursor());
3475 #ifdef FEAT_VIRTUALEDIT
3476 if (c
!= TAB
|| ve_flags
!= VE_ALL
)
3478 ++curwin
->w_cursor
.col
;
3482 getvcol(curwin
, &curwin
->w_cursor
, &col
, NULL
, &endcol2
);
3484 #ifdef FEAT_VIRTUALEDIT
3485 col
+= curwin
->w_cursor
.coladd
;
3486 if (ve_flags
== VE_ALL
3487 && (curwin
->w_cursor
.coladd
> 0
3488 || endcol2
== curwin
->w_cursor
.col
))
3490 if (dir
== FORWARD
&& c
== NUL
)
3492 if (dir
!= FORWARD
&& c
!= NUL
)
3493 ++curwin
->w_cursor
.col
;
3496 if (dir
== BACKWARD
&& curwin
->w_cursor
.col
)
3497 curwin
->w_cursor
.col
--;
3498 if (dir
== FORWARD
&& col
- 1 == endcol2
)
3499 curwin
->w_cursor
.col
++;
3502 curwin
->w_cursor
.coladd
= 0;
3505 for (i
= 0; i
< y_size
; ++i
)
3515 /* add a new line */
3516 if (curwin
->w_cursor
.lnum
> curbuf
->b_ml
.ml_line_count
)
3518 if (ml_append(curbuf
->b_ml
.ml_line_count
, (char_u
*)"",
3519 (colnr_T
)1, FALSE
) == FAIL
)
3523 /* get the old line and advance to the position to insert at */
3524 oldp
= ml_get_curline();
3525 oldlen
= (int)STRLEN(oldp
);
3526 for (ptr
= oldp
; vcol
< col
&& *ptr
; )
3528 /* Count a tab for what it's worth (if list mode not on) */
3529 incr
= lbr_chartabsize_adv(&ptr
, (colnr_T
)vcol
);
3532 bd
.textcol
= (colnr_T
)(ptr
- oldp
);
3534 shortline
= (vcol
< col
) || (vcol
== col
&& !*ptr
) ;
3536 if (vcol
< col
) /* line too short, padd with spaces */
3537 bd
.startspaces
= col
- vcol
;
3538 else if (vcol
> col
)
3540 bd
.endspaces
= vcol
- col
;
3541 bd
.startspaces
= incr
- bd
.endspaces
;
3546 bd
.textcol
-= (*mb_head_off
)(oldp
, oldp
+ bd
.textcol
);
3548 if (oldp
[bd
.textcol
] != TAB
)
3550 /* Only a Tab can be split into spaces. Other
3551 * characters will have to be moved to after the
3552 * block, causing misalignment. */
3558 yanklen
= (int)STRLEN(y_array
[i
]);
3560 /* calculate number of spaces required to fill right side of block*/
3561 spaces
= y_width
+ 1;
3562 for (j
= 0; j
< yanklen
; j
++)
3563 spaces
-= lbr_chartabsize(&y_array
[i
][j
], 0);
3567 /* insert the new text */
3568 totlen
= count
* (yanklen
+ spaces
) + bd
.startspaces
+ bd
.endspaces
;
3569 newp
= alloc_check((unsigned)totlen
+ oldlen
+ 1);
3572 /* copy part up to cursor to new line */
3574 mch_memmove(ptr
, oldp
, (size_t)bd
.textcol
);
3576 /* may insert some spaces before the new text */
3577 copy_spaces(ptr
, (size_t)bd
.startspaces
);
3578 ptr
+= bd
.startspaces
;
3579 /* insert the new text */
3580 for (j
= 0; j
< count
; ++j
)
3582 mch_memmove(ptr
, y_array
[i
], (size_t)yanklen
);
3585 /* insert block's trailing spaces only if there's text behind */
3586 if ((j
< count
- 1 || !shortline
) && spaces
)
3588 copy_spaces(ptr
, (size_t)spaces
);
3592 /* may insert some spaces after the new text */
3593 copy_spaces(ptr
, (size_t)bd
.endspaces
);
3594 ptr
+= bd
.endspaces
;
3595 /* move the text after the cursor to the end of the line. */
3596 mch_memmove(ptr
, oldp
+ bd
.textcol
+ delcount
,
3597 (size_t)(oldlen
- bd
.textcol
- delcount
+ 1));
3598 ml_replace(curwin
->w_cursor
.lnum
, newp
, FALSE
);
3600 ++curwin
->w_cursor
.lnum
;
3602 curwin
->w_cursor
.col
+= bd
.startspaces
;
3605 changed_lines(lnum
, 0, curwin
->w_cursor
.lnum
, nr_lines
);
3608 curbuf
->b_op_start
= curwin
->w_cursor
;
3609 curbuf
->b_op_start
.lnum
= lnum
;
3611 /* adjust '] mark */
3612 curbuf
->b_op_end
.lnum
= curwin
->w_cursor
.lnum
- 1;
3613 curbuf
->b_op_end
.col
= bd
.textcol
+ totlen
- 1;
3614 # ifdef FEAT_VIRTUALEDIT
3615 curbuf
->b_op_end
.coladd
= 0;
3617 if (flags
& PUT_CURSEND
)
3621 curwin
->w_cursor
= curbuf
->b_op_end
;
3622 curwin
->w_cursor
.col
++;
3624 /* in Insert mode we might be after the NUL, correct for that */
3625 len
= (colnr_T
)STRLEN(ml_get_curline());
3626 if (curwin
->w_cursor
.col
> len
)
3627 curwin
->w_cursor
.col
= len
;
3630 curwin
->w_cursor
.lnum
= lnum
;
3636 * Character or Line mode
3638 if (y_type
== MCHAR
)
3640 /* if type is MCHAR, FORWARD is the same as BACKWARD on the next
3642 if (dir
== FORWARD
&& gchar_cursor() != NUL
)
3647 int bytelen
= (*mb_ptr2len
)(ml_get_cursor());
3649 /* put it on the next of the multi-byte character. */
3653 curwin
->w_cursor
.col
+= bytelen
;
3654 curbuf
->b_op_end
.col
+= bytelen
;
3663 ++curwin
->w_cursor
.col
;
3664 ++curbuf
->b_op_end
.col
;
3668 curbuf
->b_op_start
= curwin
->w_cursor
;
3671 * Line mode: BACKWARD is the same as FORWARD on the previous line
3673 else if (dir
== BACKWARD
)
3675 new_cursor
= curwin
->w_cursor
;
3678 * simple case: insert into current line
3680 if (y_type
== MCHAR
&& y_size
== 1)
3682 totlen
= count
* yanklen
;
3685 oldp
= ml_get(lnum
);
3686 newp
= alloc_check((unsigned)(STRLEN(oldp
) + totlen
+ 1));
3688 goto end
; /* alloc() will give error message */
3689 mch_memmove(newp
, oldp
, (size_t)col
);
3691 for (i
= 0; i
< count
; ++i
)
3693 mch_memmove(ptr
, y_array
[0], (size_t)yanklen
);
3696 STRMOVE(ptr
, oldp
+ col
);
3697 ml_replace(lnum
, newp
, FALSE
);
3698 /* Put cursor on last putted char. */
3699 curwin
->w_cursor
.col
+= (colnr_T
)(totlen
- 1);
3701 curbuf
->b_op_end
= curwin
->w_cursor
;
3702 /* For "CTRL-O p" in Insert mode, put cursor after last char */
3703 if (totlen
&& (restart_edit
!= 0 || (flags
& PUT_CURSEND
)))
3704 ++curwin
->w_cursor
.col
;
3705 changed_bytes(lnum
, col
);
3710 * Insert at least one line. When y_type is MCHAR, break the first
3713 for (cnt
= 1; cnt
<= count
; ++cnt
)
3716 if (y_type
== MCHAR
)
3719 * Split the current line in two at the insert position.
3720 * First insert y_array[size - 1] in front of second line.
3721 * Then append y_array[0] to first line.
3723 lnum
= new_cursor
.lnum
;
3724 ptr
= ml_get(lnum
) + col
;
3725 totlen
= (int)STRLEN(y_array
[y_size
- 1]);
3726 newp
= alloc_check((unsigned)(STRLEN(ptr
) + totlen
+ 1));
3729 STRCPY(newp
, y_array
[y_size
- 1]);
3731 /* insert second line */
3732 ml_append(lnum
, newp
, (colnr_T
)0, FALSE
);
3735 oldp
= ml_get(lnum
);
3736 newp
= alloc_check((unsigned)(col
+ yanklen
+ 1));
3739 /* copy first part of line */
3740 mch_memmove(newp
, oldp
, (size_t)col
);
3741 /* append to first line */
3742 mch_memmove(newp
+ col
, y_array
[0], (size_t)(yanklen
+ 1));
3743 ml_replace(lnum
, newp
, FALSE
);
3745 curwin
->w_cursor
.lnum
= lnum
;
3749 for (; i
< y_size
; ++i
)
3751 if ((y_type
!= MCHAR
|| i
< y_size
- 1)
3752 && ml_append(lnum
, y_array
[i
], (colnr_T
)0, FALSE
)
3757 if (flags
& PUT_FIXINDENT
)
3759 old_pos
= curwin
->w_cursor
;
3760 curwin
->w_cursor
.lnum
= lnum
;
3762 if (cnt
== count
&& i
== y_size
- 1)
3763 lendiff
= (int)STRLEN(ptr
);
3764 #if defined(FEAT_SMARTINDENT) || defined(FEAT_CINDENT)
3765 if (*ptr
== '#' && preprocs_left())
3766 indent
= 0; /* Leave # lines at start */
3770 indent
= 0; /* Ignore empty lines */
3771 else if (first_indent
)
3773 indent_diff
= orig_indent
- get_indent();
3774 indent
= orig_indent
;
3775 first_indent
= FALSE
;
3777 else if ((indent
= get_indent() + indent_diff
) < 0)
3779 (void)set_indent(indent
, 0);
3780 curwin
->w_cursor
= old_pos
;
3781 /* remember how many chars were removed */
3782 if (cnt
== count
&& i
== y_size
- 1)
3783 lendiff
-= (int)STRLEN(ml_get(lnum
));
3790 if (y_type
== MLINE
)
3792 curbuf
->b_op_start
.col
= 0;
3794 curbuf
->b_op_start
.lnum
++;
3796 mark_adjust(curbuf
->b_op_start
.lnum
+ (y_type
== MCHAR
),
3797 (linenr_T
)MAXLNUM
, nr_lines
, 0L);
3799 /* note changed text for displaying and folding */
3800 if (y_type
== MCHAR
)
3801 changed_lines(curwin
->w_cursor
.lnum
, col
,
3802 curwin
->w_cursor
.lnum
+ 1, nr_lines
);
3804 changed_lines(curbuf
->b_op_start
.lnum
, 0,
3805 curbuf
->b_op_start
.lnum
, nr_lines
);
3807 /* put '] mark at last inserted character */
3808 curbuf
->b_op_end
.lnum
= lnum
;
3809 /* correct length for change in indent */
3810 col
= (colnr_T
)STRLEN(y_array
[y_size
- 1]) - lendiff
;
3812 curbuf
->b_op_end
.col
= col
- 1;
3814 curbuf
->b_op_end
.col
= 0;
3816 if (flags
& PUT_CURSLINE
)
3818 /* ":put": put cursor on last inserted line */
3819 curwin
->w_cursor
.lnum
= lnum
;
3820 beginline(BL_WHITE
| BL_FIX
);
3822 else if (flags
& PUT_CURSEND
)
3824 /* put cursor after inserted text */
3825 if (y_type
== MLINE
)
3827 if (lnum
>= curbuf
->b_ml
.ml_line_count
)
3828 curwin
->w_cursor
.lnum
= curbuf
->b_ml
.ml_line_count
;
3830 curwin
->w_cursor
.lnum
= lnum
+ 1;
3831 curwin
->w_cursor
.col
= 0;
3835 curwin
->w_cursor
.lnum
= lnum
;
3836 curwin
->w_cursor
.col
= col
;
3839 else if (y_type
== MLINE
)
3841 /* put cursor on first non-blank in first inserted line */
3842 curwin
->w_cursor
.col
= 0;
3844 ++curwin
->w_cursor
.lnum
;
3845 beginline(BL_WHITE
| BL_FIX
);
3847 else /* put cursor on first inserted character */
3848 curwin
->w_cursor
= new_cursor
;
3853 curwin
->w_set_curswant
= TRUE
;
3857 vim_free(insert_string
);
3861 /* If the cursor is past the end of the line put it at the end. */
3862 adjust_cursor_eol();
3866 * When the cursor is on the NUL past the end of the line and it should not be
3867 * there move it left.
3872 if (curwin
->w_cursor
.col
> 0
3873 && gchar_cursor() == NUL
3874 #ifdef FEAT_VIRTUALEDIT
3875 && (ve_flags
& VE_ONEMORE
) == 0
3877 && !(restart_edit
|| (State
& INSERT
)))
3879 /* Put the cursor on the last character in the line. */
3882 #ifdef FEAT_VIRTUALEDIT
3883 if (ve_flags
== VE_ALL
)
3887 /* Coladd is set to the width of the last character. */
3888 getvcol(curwin
, &curwin
->w_cursor
, &scol
, NULL
, &ecol
);
3889 curwin
->w_cursor
.coladd
= ecol
- scol
+ 1;
3895 #if defined(FEAT_SMARTINDENT) || defined(FEAT_CINDENT) || defined(PROTO)
3897 * Return TRUE if lines starting with '#' should be left aligned.
3903 # ifdef FEAT_SMARTINDENT
3904 # ifdef FEAT_CINDENT
3905 (curbuf
->b_p_si
&& !curbuf
->b_p_cin
) ||
3910 # ifdef FEAT_CINDENT
3911 (curbuf
->b_p_cin
&& in_cinkeys('#', ' ', TRUE
))
3917 /* Return the character name of the register with the given number */
3919 get_register_name(num
)
3926 else if (num
== DELETION_REGISTER
)
3928 #ifdef FEAT_CLIPBOARD
3929 else if (num
== STAR_REGISTER
)
3931 else if (num
== PLUS_REGISTER
)
3939 /* EBCDIC is really braindead ... */
3940 i
= 'a' + (num
- 10);
3947 return num
+ 'a' - 10;
3953 * ":dis" and ":registers": Display the contents of the yank registers.
3965 char_u
*arg
= eap
->arg
;
3972 if (arg
!= NULL
&& *arg
== NUL
)
3974 attr
= hl_attr(HLF_8
);
3976 /* Highlight title */
3977 MSG_PUTS_TITLE(_("\n--- Registers ---"));
3978 for (i
= -1; i
< NUM_REGISTERS
&& !got_int
; ++i
)
3980 name
= get_register_name(i
);
3981 if (arg
!= NULL
&& vim_strchr(arg
, name
) == NULL
)
3982 continue; /* did not ask for this register */
3984 #ifdef FEAT_CLIPBOARD
3985 /* Adjust register name for "unnamed" in 'clipboard'.
3986 * When it's a clipboard register, fill it with the current contents
3987 * of the clipboard. */
3988 adjust_clip_reg(&name
);
3989 (void)may_get_selection(name
);
3994 if (y_previous
!= NULL
)
4003 if (name
== MB_TOLOWER(redir_reg
)
4004 || (redir_reg
== '"' && yb
== y_previous
))
4005 continue; /* do not list register being written to, the
4006 * pointer can be freed */
4009 if (yb
->y_array
!= NULL
)
4016 n
= (int)Columns
- 6;
4017 for (j
= 0; j
< yb
->y_size
&& n
> 1; ++j
)
4021 MSG_PUTS_ATTR("^J", attr
);
4024 for (p
= yb
->y_array
[j
]; *p
&& (n
-= ptr2cells(p
)) >= 0; ++p
)
4027 clen
= (*mb_ptr2len
)(p
);
4029 msg_outtrans_len(p
, clen
);
4035 if (n
> 1 && yb
->y_type
== MLINE
)
4036 MSG_PUTS_ATTR("^J", attr
);
4037 out_flush(); /* show one line at a time */
4043 * display last inserted text
4045 if ((p
= get_last_insert()) != NULL
4046 && (arg
== NULL
|| vim_strchr(arg
, '.') != NULL
) && !got_int
)
4053 * display last command line
4055 if (last_cmdline
!= NULL
&& (arg
== NULL
|| vim_strchr(arg
, ':') != NULL
)
4059 dis_msg(last_cmdline
, FALSE
);
4063 * display current file name
4065 if (curbuf
->b_fname
!= NULL
4066 && (arg
== NULL
|| vim_strchr(arg
, '%') != NULL
) && !got_int
)
4069 dis_msg(curbuf
->b_fname
, FALSE
);
4073 * display alternate file name
4075 if ((arg
== NULL
|| vim_strchr(arg
, '%') != NULL
) && !got_int
)
4080 if (buflist_name_nr(0, &fname
, &dummy
) != FAIL
)
4083 dis_msg(fname
, FALSE
);
4088 * display last search pattern
4090 if (last_search_pat() != NULL
4091 && (arg
== NULL
|| vim_strchr(arg
, '/') != NULL
) && !got_int
)
4094 dis_msg(last_search_pat(), FALSE
);
4099 * display last used expression
4101 if (expr_line
!= NULL
&& (arg
== NULL
|| vim_strchr(arg
, '=') != NULL
)
4105 dis_msg(expr_line
, FALSE
);
4111 * display a string for do_dis()
4112 * truncate at end of screen line
4115 dis_msg(p
, skip_esc
)
4117 int skip_esc
; /* if TRUE, ignore trailing ESC */
4124 n
= (int)Columns
- 6;
4126 && !(*p
== ESC
&& skip_esc
&& *(p
+ 1) == NUL
)
4127 && (n
-= ptr2cells(p
)) >= 0)
4130 if (has_mbyte
&& (l
= (*mb_ptr2len
)(p
)) > 1)
4132 msg_outtrans_len(p
, l
);
4137 msg_outtrans_len(p
++, 1);
4143 * join 'count' lines (minimal 2), including u_save()
4146 do_do_join(count
, insert_space
)
4150 colnr_T col
= MAXCOL
;
4152 if (u_save((linenr_T
)(curwin
->w_cursor
.lnum
- 1),
4153 (linenr_T
)(curwin
->w_cursor
.lnum
+ count
)) == FAIL
)
4159 if (got_int
|| do_join(insert_space
) == FAIL
)
4164 if (col
== MAXCOL
&& vim_strchr(p_cpo
, CPO_JOINCOL
) != NULL
)
4165 col
= curwin
->w_cursor
.col
;
4168 /* Vi compatible: use the column of the first join */
4169 if (col
!= MAXCOL
&& vim_strchr(p_cpo
, CPO_JOINCOL
) != NULL
)
4170 curwin
->w_cursor
.col
= col
;
4174 * Need to update the screen if the line where the cursor is became too
4175 * long to fit on the screen.
4177 update_topline_redraw();
4182 * Join two lines at the cursor position.
4183 * "redraw" is TRUE when the screen should be updated.
4184 * Caller must have setup for undo.
4186 * return FAIL for failure, OK otherwise
4189 do_join(insert_space
)
4193 char_u
*next
, *next_start
;
4195 int endcurr1
, endcurr2
;
4196 int currsize
; /* size of the current line */
4197 int nextsize
; /* size of the next line */
4198 int spaces
; /* number of spaces to insert */
4201 if (curwin
->w_cursor
.lnum
== curbuf
->b_ml
.ml_line_count
)
4202 return FAIL
; /* can't join on last line */
4204 curr
= ml_get_curline();
4205 currsize
= (int)STRLEN(curr
);
4206 endcurr1
= endcurr2
= NUL
;
4207 if (insert_space
&& currsize
> 0)
4212 next
= curr
+ currsize
;
4213 mb_ptr_back(curr
, next
);
4214 endcurr1
= (*mb_ptr2char
)(next
);
4217 mb_ptr_back(curr
, next
);
4218 endcurr2
= (*mb_ptr2char
)(next
);
4224 endcurr1
= *(curr
+ currsize
- 1);
4226 endcurr2
= *(curr
+ currsize
- 2);
4230 next
= next_start
= ml_get((linenr_T
)(curwin
->w_cursor
.lnum
+ 1));
4234 next
= skipwhite(next
);
4235 if (*next
!= ')' && currsize
!= 0 && endcurr1
!= TAB
4237 && (!has_format_option(FO_MBYTE_JOIN
)
4238 || (mb_ptr2char(next
) < 0x100 && endcurr1
< 0x100))
4239 && (!has_format_option(FO_MBYTE_JOIN2
)
4240 || mb_ptr2char(next
) < 0x100 || endcurr1
< 0x100)
4244 /* don't add a space if the line is ending in a space */
4245 if (endcurr1
== ' ')
4246 endcurr1
= endcurr2
;
4249 /* extra space when 'joinspaces' set and line ends in '.' */
4252 || (vim_strchr(p_cpo
, CPO_JOINSP
) == NULL
4253 && (endcurr1
== '?' || endcurr1
== '!'))))
4257 nextsize
= (int)STRLEN(next
);
4259 newp
= alloc_check((unsigned)(currsize
+ nextsize
+ spaces
+ 1));
4264 * Insert the next line first, because we already have that pointer.
4265 * Curr has to be obtained again, because getting next will have
4268 mch_memmove(newp
+ currsize
+ spaces
, next
, (size_t)(nextsize
+ 1));
4270 curr
= ml_get_curline();
4271 mch_memmove(newp
, curr
, (size_t)currsize
);
4273 copy_spaces(newp
+ currsize
, (size_t)spaces
);
4275 ml_replace(curwin
->w_cursor
.lnum
, newp
, FALSE
);
4277 /* Only report the change in the first line here, del_lines() will report
4278 * the deleted line. */
4279 changed_lines(curwin
->w_cursor
.lnum
, currsize
,
4280 curwin
->w_cursor
.lnum
+ 1, 0L);
4283 * Delete the following line. To do this we move the cursor there
4284 * briefly, and then move it back. After del_lines() the cursor may
4285 * have moved up (last line deleted), so the current lnum is kept in t.
4287 * Move marks from the deleted line to the joined line, adjusting the
4288 * column. This is not Vi compatible, but Vi deletes the marks, thus that
4289 * should not really be a problem.
4291 t
= curwin
->w_cursor
.lnum
;
4292 mark_col_adjust(t
+ 1, (colnr_T
)0, (linenr_T
)-1,
4293 (long)(currsize
+ spaces
- (next
- next_start
)));
4294 ++curwin
->w_cursor
.lnum
;
4295 del_lines(1L, FALSE
);
4296 curwin
->w_cursor
.lnum
= t
;
4299 * go to first character of the joined line
4301 curwin
->w_cursor
.col
= currsize
;
4303 #ifdef FEAT_VIRTUALEDIT
4304 curwin
->w_cursor
.coladd
= 0;
4306 curwin
->w_set_curswant
= TRUE
;
4311 #ifdef FEAT_COMMENTS
4313 * Return TRUE if the two comment leaders given are the same. "lnum" is
4314 * the first line. White-space is ignored. Note that the whole of
4315 * 'leader1' must match 'leader2_len' characters from 'leader2' -- webb
4318 same_leader(lnum
, leader1_len
, leader1_flags
, leader2_len
, leader2_flags
)
4321 char_u
*leader1_flags
;
4323 char_u
*leader2_flags
;
4325 int idx1
= 0, idx2
= 0;
4330 if (leader1_len
== 0)
4331 return (leader2_len
== 0);
4334 * If first leader has 'f' flag, the lines can be joined only if the
4335 * second line does not have a leader.
4336 * If first leader has 'e' flag, the lines can never be joined.
4337 * If fist leader has 's' flag, the lines can only be joined if there is
4338 * some text after it and the second line has the 'm' flag.
4340 if (leader1_flags
!= NULL
)
4342 for (p
= leader1_flags
; *p
&& *p
!= ':'; ++p
)
4344 if (*p
== COM_FIRST
)
4345 return (leader2_len
== 0);
4348 if (*p
== COM_START
)
4350 if (*(ml_get(lnum
) + leader1_len
) == NUL
)
4352 if (leader2_flags
== NULL
|| leader2_len
== 0)
4354 for (p
= leader2_flags
; *p
&& *p
!= ':'; ++p
)
4355 if (*p
== COM_MIDDLE
)
4363 * Get current line and next line, compare the leaders.
4364 * The first line has to be saved, only one line can be locked at a time.
4366 line1
= vim_strsave(ml_get(lnum
));
4369 for (idx1
= 0; vim_iswhite(line1
[idx1
]); ++idx1
)
4371 line2
= ml_get(lnum
+ 1);
4372 for (idx2
= 0; idx2
< leader2_len
; ++idx2
)
4374 if (!vim_iswhite(line2
[idx2
]))
4376 if (line1
[idx1
++] != line2
[idx2
])
4380 while (vim_iswhite(line1
[idx1
]))
4385 return (idx2
== leader2_len
&& idx1
== leader1_len
);
4390 * implementation of the format operator 'gq'
4393 op_format(oap
, keep_cursor
)
4395 int keep_cursor
; /* keep cursor on same text char */
4397 long old_line_count
= curbuf
->b_ml
.ml_line_count
;
4399 /* Place the cursor where the "gq" or "gw" command was given, so that "u"
4400 * can put it back there. */
4401 curwin
->w_cursor
= oap
->cursor_start
;
4403 if (u_save((linenr_T
)(oap
->start
.lnum
- 1),
4404 (linenr_T
)(oap
->end
.lnum
+ 1)) == FAIL
)
4406 curwin
->w_cursor
= oap
->start
;
4410 /* When there is no change: need to remove the Visual selection */
4411 redraw_curbuf_later(INVERTED
);
4414 /* Set '[ mark at the start of the formatted area */
4415 curbuf
->b_op_start
= oap
->start
;
4417 /* For "gw" remember the cursor position and put it back below (adjusted
4418 * for joined and split lines). */
4420 saved_cursor
= oap
->cursor_start
;
4422 format_lines(oap
->line_count
, keep_cursor
);
4425 * Leave the cursor at the first non-blank of the last formatted line.
4426 * If the cursor was moved one line back (e.g. with "Q}") go to the next
4427 * line, so "." will do the next lines.
4429 if (oap
->end_adjusted
&& curwin
->w_cursor
.lnum
< curbuf
->b_ml
.ml_line_count
)
4430 ++curwin
->w_cursor
.lnum
;
4431 beginline(BL_WHITE
| BL_FIX
);
4432 old_line_count
= curbuf
->b_ml
.ml_line_count
- old_line_count
;
4433 msgmore(old_line_count
);
4435 /* put '] mark on the end of the formatted area */
4436 curbuf
->b_op_end
= curwin
->w_cursor
;
4440 curwin
->w_cursor
= saved_cursor
;
4441 saved_cursor
.lnum
= 0;
4451 if (wp
->w_old_cursor_lnum
!= 0)
4453 /* When lines have been inserted or deleted, adjust the end of
4454 * the Visual area to be redrawn. */
4455 if (wp
->w_old_cursor_lnum
> wp
->w_old_visual_lnum
)
4456 wp
->w_old_cursor_lnum
+= old_line_count
;
4458 wp
->w_old_visual_lnum
+= old_line_count
;
4465 #if defined(FEAT_EVAL) || defined(PROTO)
4467 * Implementation of the format operator 'gq' for when using 'formatexpr'.
4475 /* When there is no change: need to remove the Visual selection */
4476 redraw_curbuf_later(INVERTED
);
4479 (void)fex_format(oap
->start
.lnum
, oap
->line_count
, NUL
);
4483 fex_format(lnum
, count
, c
)
4486 int c
; /* character to be inserted */
4488 int use_sandbox
= was_set_insecurely((char_u
*)"formatexpr",
4493 * Set v:lnum to the first line number and v:count to the number of lines.
4494 * Set v:char to the character to be inserted (can be NUL).
4496 set_vim_var_nr(VV_LNUM
, lnum
);
4497 set_vim_var_nr(VV_COUNT
, count
);
4498 set_vim_var_char(c
);
4501 * Evaluate the function.
4505 r
= eval_to_number(curbuf
->b_p_fex
);
4509 set_vim_var_string(VV_CHAR
, NULL
, -1);
4516 * Format "line_count" lines, starting at the cursor position.
4517 * When "line_count" is negative, format until the end of the paragraph.
4518 * Lines after the cursor line are saved for undo, caller must have saved the
4522 format_lines(line_count
, avoid_fex
)
4523 linenr_T line_count
;
4524 int avoid_fex
; /* don't use 'formatexpr' */
4527 int is_not_par
; /* current line not part of parag. */
4528 int next_is_not_par
; /* next line not part of paragraph */
4529 int is_end_par
; /* at end of paragraph */
4530 int prev_is_end_par
= FALSE
;/* prev. line not part of parag. */
4531 int next_is_start_par
= FALSE
;
4532 #ifdef FEAT_COMMENTS
4533 int leader_len
= 0; /* leader len of current line */
4534 int next_leader_len
; /* leader len of next line */
4535 char_u
*leader_flags
= NULL
; /* flags for leader of current line */
4536 char_u
*next_leader_flags
; /* flags for leader of next line */
4537 int do_comments
; /* format comments */
4540 int second_indent
= -1;
4541 int do_second_indent
;
4542 int do_number_indent
;
4544 int first_par_line
= TRUE
;
4547 int need_set_indent
= TRUE
; /* set indent of next paragraph */
4548 int force_format
= FALSE
;
4549 int old_State
= State
;
4551 /* length of a line to force formatting: 3 * 'tw' */
4552 max_len
= comp_textwidth(TRUE
) * 3;
4554 /* check for 'q', '2' and '1' in 'formatoptions' */
4555 #ifdef FEAT_COMMENTS
4556 do_comments
= has_format_option(FO_Q_COMS
);
4558 do_second_indent
= has_format_option(FO_Q_SECOND
);
4559 do_number_indent
= has_format_option(FO_Q_NUMBER
);
4560 do_trail_white
= has_format_option(FO_WHITE_PAR
);
4563 * Get info about the previous and current line.
4565 if (curwin
->w_cursor
.lnum
> 1)
4566 is_not_par
= fmt_check_par(curwin
->w_cursor
.lnum
- 1
4567 #ifdef FEAT_COMMENTS
4568 , &leader_len
, &leader_flags
, do_comments
4573 next_is_not_par
= fmt_check_par(curwin
->w_cursor
.lnum
4574 #ifdef FEAT_COMMENTS
4575 , &next_leader_len
, &next_leader_flags
, do_comments
4578 is_end_par
= (is_not_par
|| next_is_not_par
);
4579 if (!is_end_par
&& do_trail_white
)
4580 is_end_par
= !ends_in_white(curwin
->w_cursor
.lnum
- 1);
4582 curwin
->w_cursor
.lnum
--;
4583 for (count
= line_count
; count
!= 0 && !got_int
; --count
)
4586 * Advance to next paragraph.
4590 curwin
->w_cursor
.lnum
++;
4591 prev_is_end_par
= is_end_par
;
4592 is_not_par
= next_is_not_par
;
4593 #ifdef FEAT_COMMENTS
4594 leader_len
= next_leader_len
;
4595 leader_flags
= next_leader_flags
;
4600 * The last line to be formatted.
4602 if (count
== 1 || curwin
->w_cursor
.lnum
== curbuf
->b_ml
.ml_line_count
)
4604 next_is_not_par
= TRUE
;
4605 #ifdef FEAT_COMMENTS
4606 next_leader_len
= 0;
4607 next_leader_flags
= NULL
;
4612 next_is_not_par
= fmt_check_par(curwin
->w_cursor
.lnum
+ 1
4613 #ifdef FEAT_COMMENTS
4614 , &next_leader_len
, &next_leader_flags
, do_comments
4617 if (do_number_indent
)
4619 (get_number_indent(curwin
->w_cursor
.lnum
+ 1) > 0);
4622 is_end_par
= (is_not_par
|| next_is_not_par
|| next_is_start_par
);
4623 if (!is_end_par
&& do_trail_white
)
4624 is_end_par
= !ends_in_white(curwin
->w_cursor
.lnum
);
4627 * Skip lines that are not in a paragraph.
4637 * For the first line of a paragraph, check indent of second line.
4638 * Don't do this for comments and empty lines.
4641 && (do_second_indent
|| do_number_indent
)
4643 && curwin
->w_cursor
.lnum
< curbuf
->b_ml
.ml_line_count
4644 #ifdef FEAT_COMMENTS
4646 && next_leader_len
== 0
4650 if (do_second_indent
4651 && !lineempty(curwin
->w_cursor
.lnum
+ 1))
4652 second_indent
= get_indent_lnum(curwin
->w_cursor
.lnum
+ 1);
4653 else if (do_number_indent
)
4654 second_indent
= get_number_indent(curwin
->w_cursor
.lnum
);
4658 * When the comment leader changes, it's the end of the paragraph.
4660 if (curwin
->w_cursor
.lnum
>= curbuf
->b_ml
.ml_line_count
4661 #ifdef FEAT_COMMENTS
4662 || !same_leader(curwin
->w_cursor
.lnum
,
4663 leader_len
, leader_flags
,
4664 next_leader_len
, next_leader_flags
)
4670 * If we have got to the end of a paragraph, or the line is
4671 * getting long, format it.
4673 if (is_end_par
|| force_format
)
4675 if (need_set_indent
)
4676 /* replace indent in first line with minimal number of
4677 * tabs and spaces, according to current options */
4678 (void)set_indent(get_indent(), SIN_CHANGED
);
4680 /* put cursor on last non-space */
4681 State
= NORMAL
; /* don't go past end-of-line */
4682 coladvance((colnr_T
)MAXCOL
);
4683 while (curwin
->w_cursor
.col
&& vim_isspace(gchar_cursor()))
4686 /* do the formatting, without 'showmode' */
4687 State
= INSERT
; /* for open_line() */
4690 insertchar(NUL
, INSCHAR_FORMAT
4691 #ifdef FEAT_COMMENTS
4692 + (do_comments
? INSCHAR_DO_COM
: 0)
4694 + (avoid_fex
? INSCHAR_NO_FEX
: 0), second_indent
);
4698 /* at end of par.: need to set indent of next par. */
4699 need_set_indent
= is_end_par
;
4702 /* When called with a negative line count, break at the
4703 * end of the paragraph. */
4706 first_par_line
= TRUE
;
4708 force_format
= FALSE
;
4712 * When still in same paragraph, join the lines together. But
4713 * first delete the comment leader from the second line.
4718 curwin
->w_cursor
.lnum
++;
4719 curwin
->w_cursor
.col
= 0;
4720 if (line_count
< 0 && u_save_cursor() == FAIL
)
4722 #ifdef FEAT_COMMENTS
4723 (void)del_bytes((long)next_leader_len
, FALSE
, FALSE
);
4724 if (next_leader_len
> 0)
4725 mark_col_adjust(curwin
->w_cursor
.lnum
, (colnr_T
)0, 0L,
4726 (long)-next_leader_len
);
4728 curwin
->w_cursor
.lnum
--;
4729 if (do_join(TRUE
) == FAIL
)
4734 first_par_line
= FALSE
;
4735 /* If the line is getting long, format it next time */
4736 if (STRLEN(ml_get_curline()) > (size_t)max_len
)
4737 force_format
= TRUE
;
4739 force_format
= FALSE
;
4747 * Return TRUE if line "lnum" ends in a white character.
4753 char_u
*s
= ml_get(lnum
);
4758 /* Don't use STRLEN() inside vim_iswhite(), SAS/C complains: "macro
4759 * invocation may call function multiple times". */
4761 return vim_iswhite(s
[l
]);
4765 * Blank lines, and lines containing only the comment leader, are left
4766 * untouched by the formatting. The function returns TRUE in this
4767 * case. It also returns TRUE when a line starts with the end of a comment
4768 * ('e' in comment flags), so that this line is skipped, and not joined to the
4769 * previous line. A new paragraph starts after a blank line, or when the
4770 * comment leader changes -- webb.
4772 #ifdef FEAT_COMMENTS
4774 fmt_check_par(lnum
, leader_len
, leader_flags
, do_comments
)
4777 char_u
**leader_flags
;
4780 char_u
*flags
= NULL
; /* init for GCC */
4785 *leader_len
= get_leader_len(ptr
, leader_flags
, FALSE
);
4789 if (*leader_len
> 0)
4792 * Search for 'e' flag in comment leader flags.
4794 flags
= *leader_flags
;
4795 while (*flags
&& *flags
!= ':' && *flags
!= COM_END
)
4799 return (*skipwhite(ptr
+ *leader_len
) == NUL
4800 || (*leader_len
> 0 && *flags
== COM_END
)
4801 || startPS(lnum
, NUL
, FALSE
));
4808 return (*skipwhite(ml_get(lnum
)) == NUL
|| startPS(lnum
, NUL
, FALSE
));
4813 * Return TRUE when a paragraph starts in line "lnum". Return FALSE when the
4814 * previous line is in the same paragraph. Used for auto-formatting.
4817 paragraph_start(lnum
)
4821 #ifdef FEAT_COMMENTS
4822 int leader_len
= 0; /* leader len of current line */
4823 char_u
*leader_flags
= NULL
; /* flags for leader of current line */
4824 int next_leader_len
; /* leader len of next line */
4825 char_u
*next_leader_flags
; /* flags for leader of next line */
4826 int do_comments
; /* format comments */
4830 return TRUE
; /* start of the file */
4832 p
= ml_get(lnum
- 1);
4834 return TRUE
; /* after empty line */
4836 #ifdef FEAT_COMMENTS
4837 do_comments
= has_format_option(FO_Q_COMS
);
4839 if (fmt_check_par(lnum
- 1
4840 #ifdef FEAT_COMMENTS
4841 , &leader_len
, &leader_flags
, do_comments
4844 return TRUE
; /* after non-paragraph line */
4846 if (fmt_check_par(lnum
4847 #ifdef FEAT_COMMENTS
4848 , &next_leader_len
, &next_leader_flags
, do_comments
4851 return TRUE
; /* "lnum" is not a paragraph line */
4853 if (has_format_option(FO_WHITE_PAR
) && !ends_in_white(lnum
- 1))
4854 return TRUE
; /* missing trailing space in previous line. */
4856 if (has_format_option(FO_Q_NUMBER
) && (get_number_indent(lnum
) > 0))
4857 return TRUE
; /* numbered item starts in "lnum". */
4859 #ifdef FEAT_COMMENTS
4860 if (!same_leader(lnum
- 1, leader_len
, leader_flags
,
4861 next_leader_len
, next_leader_flags
))
4862 return TRUE
; /* change of comment leader. */
4870 * prepare a few things for block mode yank/delete/tilde
4873 * - textlen includes the first/last char to be (partly) deleted
4874 * - start/endspaces is the number of columns that are taken by the
4875 * first/last deleted char minus the number of columns that have to be
4877 * for yank and tilde:
4878 * - textlen includes the first/last char to be wholly yanked
4879 * - start/endspaces is the number of columns of the first/last yanked char
4880 * that are to be yanked.
4883 block_prep(oap
, bdp
, lnum
, is_del
)
4885 struct block_def
*bdp
;
4893 char_u
*prev_pstart
;
4896 bdp
->startspaces
= 0;
4899 bdp
->start_vcol
= 0;
4901 #ifdef FEAT_VISUALEXTRA
4902 bdp
->is_short
= FALSE
;
4903 bdp
->is_oneChar
= FALSE
;
4904 bdp
->pre_whitesp
= 0;
4905 bdp
->pre_whitesp_c
= 0;
4906 bdp
->end_char_vcols
= 0;
4908 bdp
->start_char_vcols
= 0;
4910 line
= ml_get(lnum
);
4913 while (bdp
->start_vcol
< oap
->start_vcol
&& *pstart
)
4915 /* Count a tab for what it's worth (if list mode not on) */
4916 incr
= lbr_chartabsize(pstart
, (colnr_T
)bdp
->start_vcol
);
4917 bdp
->start_vcol
+= incr
;
4918 #ifdef FEAT_VISUALEXTRA
4919 if (vim_iswhite(*pstart
))
4921 bdp
->pre_whitesp
+= incr
;
4922 bdp
->pre_whitesp_c
++;
4926 bdp
->pre_whitesp
= 0;
4927 bdp
->pre_whitesp_c
= 0;
4930 prev_pstart
= pstart
;
4933 bdp
->start_char_vcols
= incr
;
4934 if (bdp
->start_vcol
< oap
->start_vcol
) /* line too short */
4936 bdp
->end_vcol
= bdp
->start_vcol
;
4937 #ifdef FEAT_VISUALEXTRA
4938 bdp
->is_short
= TRUE
;
4940 if (!is_del
|| oap
->op_type
== OP_APPEND
)
4941 bdp
->endspaces
= oap
->end_vcol
- oap
->start_vcol
+ 1;
4945 /* notice: this converts partly selected Multibyte characters to
4947 bdp
->startspaces
= bdp
->start_vcol
- oap
->start_vcol
;
4948 if (is_del
&& bdp
->startspaces
)
4949 bdp
->startspaces
= bdp
->start_char_vcols
- bdp
->startspaces
;
4951 bdp
->end_vcol
= bdp
->start_vcol
;
4952 if (bdp
->end_vcol
> oap
->end_vcol
) /* it's all in one character */
4954 #ifdef FEAT_VISUALEXTRA
4955 bdp
->is_oneChar
= TRUE
;
4957 if (oap
->op_type
== OP_INSERT
)
4958 bdp
->endspaces
= bdp
->start_char_vcols
- bdp
->startspaces
;
4959 else if (oap
->op_type
== OP_APPEND
)
4961 bdp
->startspaces
+= oap
->end_vcol
- oap
->start_vcol
+ 1;
4962 bdp
->endspaces
= bdp
->start_char_vcols
- bdp
->startspaces
;
4966 bdp
->startspaces
= oap
->end_vcol
- oap
->start_vcol
+ 1;
4967 if (is_del
&& oap
->op_type
!= OP_LSHIFT
)
4969 /* just putting the sum of those two into
4970 * bdp->startspaces doesn't work for Visual replace,
4971 * so we have to split the tab in two */
4972 bdp
->startspaces
= bdp
->start_char_vcols
4973 - (bdp
->start_vcol
- oap
->start_vcol
);
4974 bdp
->endspaces
= bdp
->end_vcol
- oap
->end_vcol
- 1;
4981 while (bdp
->end_vcol
<= oap
->end_vcol
&& *pend
!= NUL
)
4983 /* Count a tab for what it's worth (if list mode not on) */
4985 incr
= lbr_chartabsize_adv(&pend
, (colnr_T
)bdp
->end_vcol
);
4986 bdp
->end_vcol
+= incr
;
4988 if (bdp
->end_vcol
<= oap
->end_vcol
4990 || oap
->op_type
== OP_APPEND
4991 || oap
->op_type
== OP_REPLACE
)) /* line too short */
4993 #ifdef FEAT_VISUALEXTRA
4994 bdp
->is_short
= TRUE
;
4996 /* Alternative: include spaces to fill up the block.
4997 * Disadvantage: can lead to trailing spaces when the line is
4998 * short where the text is put */
4999 /* if (!is_del || oap->op_type == OP_APPEND) */
5000 if (oap
->op_type
== OP_APPEND
|| virtual_op
)
5001 bdp
->endspaces
= oap
->end_vcol
- bdp
->end_vcol
5004 bdp
->endspaces
= 0; /* replace doesn't add characters */
5006 else if (bdp
->end_vcol
> oap
->end_vcol
)
5008 bdp
->endspaces
= bdp
->end_vcol
- oap
->end_vcol
- 1;
5009 if (!is_del
&& bdp
->endspaces
)
5011 bdp
->endspaces
= incr
- bdp
->endspaces
;
5017 #ifdef FEAT_VISUALEXTRA
5018 bdp
->end_char_vcols
= incr
;
5020 if (is_del
&& bdp
->startspaces
)
5021 pstart
= prev_pstart
;
5022 bdp
->textlen
= (int)(pend
- pstart
);
5024 bdp
->textcol
= (colnr_T
) (pstart
- line
);
5025 bdp
->textstart
= pstart
;
5027 #endif /* FEAT_VISUAL */
5029 #ifdef FEAT_RIGHTLEFT
5030 static void reverse_line
__ARGS((char_u
*s
));
5039 if ((i
= (int)STRLEN(s
) - 1) <= 0)
5042 curwin
->w_cursor
.col
= i
- curwin
->w_cursor
.col
;
5043 for (j
= 0; j
< i
; j
++, i
--)
5045 c
= s
[i
]; s
[i
] = s
[j
]; s
[j
] = c
;
5049 # define RLADDSUBFIX(ptr) if (curwin->w_p_rl) reverse_line(ptr);
5051 # define RLADDSUBFIX(ptr)
5055 * add or subtract 'Prenum1' from a number in a line
5056 * 'command' is CTRL-A for add, CTRL-X for subtract
5058 * return FAIL for failure, OK otherwise
5061 do_addsub(command
, Prenum1
)
5067 char_u buf2
[NUMBUFLEN
];
5068 int hex
; /* 'X' or 'x': hex; '0': octal */
5069 static int hexupper
= FALSE
; /* 0xABC */
5074 int length
= 0; /* character length of the number */
5083 dohex
= (vim_strchr(curbuf
->b_p_nf
, 'x') != NULL
); /* "heX" */
5084 dooct
= (vim_strchr(curbuf
->b_p_nf
, 'o') != NULL
); /* "Octal" */
5085 doalp
= (vim_strchr(curbuf
->b_p_nf
, 'p') != NULL
); /* "alPha" */
5087 ptr
= ml_get_curline();
5091 * First check if we are on a hexadecimal number, after the "0x".
5093 col
= curwin
->w_cursor
.col
;
5095 while (col
> 0 && vim_isxdigit(ptr
[col
]))
5101 && ptr
[col
- 1] == '0'
5102 && vim_isxdigit(ptr
[col
+ 1]))
5105 * Found hexadecimal number, move to its start.
5112 * Search forward and then backward to find the start of number.
5114 col
= curwin
->w_cursor
.col
;
5116 while (ptr
[col
] != NUL
5117 && !vim_isdigit(ptr
[col
])
5118 && !(doalp
&& ASCII_ISALPHA(ptr
[col
])))
5122 && vim_isdigit(ptr
[col
- 1])
5123 && !(doalp
&& ASCII_ISALPHA(ptr
[col
])))
5128 * If a number was found, and saving for undo works, replace the number.
5130 firstdigit
= ptr
[col
];
5132 if ((!VIM_ISDIGIT(firstdigit
) && !(doalp
&& ASCII_ISALPHA(firstdigit
)))
5133 || u_save_cursor() != OK
)
5139 /* get ptr again, because u_save() may have changed it */
5140 ptr
= ml_get_curline();
5143 if (doalp
&& ASCII_ISALPHA(firstdigit
))
5145 /* decrement or increment alphabetic character */
5146 if (command
== Ctrl_X
)
5148 if (CharOrd(firstdigit
) < Prenum1
)
5150 if (isupper(firstdigit
))
5157 firstdigit
= EBCDIC_CHAR_ADD(firstdigit
, -Prenum1
);
5159 firstdigit
-= Prenum1
;
5164 if (26 - CharOrd(firstdigit
) - 1 < Prenum1
)
5166 if (isupper(firstdigit
))
5173 firstdigit
= EBCDIC_CHAR_ADD(firstdigit
, Prenum1
);
5175 firstdigit
+= Prenum1
;
5178 curwin
->w_cursor
.col
= col
;
5179 (void)del_char(FALSE
);
5180 ins_char(firstdigit
);
5185 if (col
> 0 && ptr
[col
- 1] == '-') /* negative number */
5191 /* get the number value (unsigned) */
5192 vim_str2nr(ptr
+ col
, &hex
, &length
, dooct
, dohex
, NULL
, &n
);
5194 /* ignore leading '-' for hex and octal numbers */
5195 if (hex
&& negative
)
5202 /* add or subtract */
5204 if (command
== Ctrl_X
)
5211 n
-= (unsigned long)Prenum1
;
5213 n
+= (unsigned long)Prenum1
;
5215 /* handle wraparound for decimal numbers */
5222 n
= 1 + (n
^ (unsigned long)-1);
5230 n
= (n
^ (unsigned long)-1);
5239 * Delete the old number.
5241 curwin
->w_cursor
.col
= col
;
5245 * Don't include the '-' in the length, only the length of the part
5246 * after it is kept the same.
5252 if (c
< 0x100 && isalpha(c
))
5259 /* del_char() will mark line needing displaying */
5260 (void)del_char(FALSE
);
5265 * Prepare the leading characters in buf1[].
5266 * When there are many leading zeros it could be very long. Allocate
5269 buf1
= alloc((unsigned)length
+ NUMBUFLEN
);
5282 if (hex
== 'x' || hex
== 'X')
5289 * Put the number characters in buf2[].
5292 sprintf((char *)buf2
, "%lu", n
);
5293 else if (hex
== '0')
5294 sprintf((char *)buf2
, "%lo", n
);
5295 else if (hex
&& hexupper
)
5296 sprintf((char *)buf2
, "%lX", n
);
5298 sprintf((char *)buf2
, "%lx", n
);
5299 length
-= (int)STRLEN(buf2
);
5302 * Adjust number of zeros to the new number of digits, so the
5303 * total length of the number remains the same.
5304 * Don't do this when
5305 * the result may look like an octal number.
5307 if (firstdigit
== '0' && !(dooct
&& hex
== 0))
5308 while (length
-- > 0)
5312 ins_str(buf1
); /* insert the new number */
5315 --curwin
->w_cursor
.col
;
5316 curwin
->w_set_curswant
= TRUE
;
5317 #ifdef FEAT_RIGHTLEFT
5318 ptr
= ml_get_buf(curbuf
, curwin
->w_cursor
.lnum
, TRUE
);
5326 read_viminfo_register(virp
, force
)
5335 int set_prev
= FALSE
;
5337 char_u
**array
= NULL
;
5339 /* We only get here (hopefully) if line[0] == '"' */
5340 str
= virp
->vir_line
+ 1;
5342 /* If the line starts with "" this is the y_previous register. */
5349 if (!ASCII_ISALNUM(*str
) && *str
!= '-')
5351 if (viminfo_error("E577: ", _("Illegal register name"), virp
->vir_line
))
5352 return TRUE
; /* too many errors, pretend end-of-file */
5355 get_yank_register(*str
++, FALSE
);
5356 if (!force
&& y_current
->y_array
!= NULL
)
5361 /* "x@: register x used for @@ */
5362 if (force
|| execreg_lastc
== NUL
)
5363 execreg_lastc
= str
[-1];
5367 limit
= 100; /* Optimized for registers containing <= 100 lines */
5371 y_previous
= y_current
;
5372 vim_free(y_current
->y_array
);
5373 array
= y_current
->y_array
=
5374 (char_u
**)alloc((unsigned)(limit
* sizeof(char_u
*)));
5375 str
= skipwhite(skiptowhite(str
));
5376 if (STRNCMP(str
, "CHAR", 4) == 0)
5377 y_current
->y_type
= MCHAR
;
5379 else if (STRNCMP(str
, "BLOCK", 5) == 0)
5380 y_current
->y_type
= MBLOCK
;
5383 y_current
->y_type
= MLINE
;
5384 /* get the block width; if it's missing we get a zero, which is OK */
5385 str
= skipwhite(skiptowhite(str
));
5387 y_current
->y_width
= getdigits(&str
);
5389 (void)getdigits(&str
);
5393 while (!(eof
= viminfo_readline(virp
))
5394 && (virp
->vir_line
[0] == TAB
|| virp
->vir_line
[0] == '<'))
5400 y_current
->y_array
= (char_u
**)
5401 alloc((unsigned)(limit
* 2 * sizeof(char_u
*)));
5402 for (i
= 0; i
< limit
; i
++)
5403 y_current
->y_array
[i
] = array
[i
];
5406 array
= y_current
->y_array
;
5408 str
= viminfo_readstring(virp
, 1, TRUE
);
5410 array
[size
++] = str
;
5420 y_current
->y_array
= NULL
;
5422 else if (size
< limit
)
5424 y_current
->y_array
=
5425 (char_u
**)alloc((unsigned)(size
* sizeof(char_u
*)));
5426 for (i
= 0; i
< size
; i
++)
5427 y_current
->y_array
[i
] = array
[i
];
5430 y_current
->y_size
= size
;
5436 write_viminfo_registers(fp
)
5447 fprintf(fp
, _("\n# Registers:\n"));
5449 /* Get '<' value, use old '"' value if '<' is not found. */
5450 max_num_lines
= get_viminfo_parameter('<');
5451 if (max_num_lines
< 0)
5452 max_num_lines
= get_viminfo_parameter('"');
5453 if (max_num_lines
== 0)
5455 max_kbyte
= get_viminfo_parameter('s');
5459 for (i
= 0; i
< NUM_REGISTERS
; i
++)
5461 if (y_regs
[i
].y_array
== NULL
)
5463 #ifdef FEAT_CLIPBOARD
5464 /* Skip '*'/'+' register, we don't want them back next time */
5465 if (i
== STAR_REGISTER
|| i
== PLUS_REGISTER
)
5469 /* Neither do we want the '~' register */
5470 if (i
== TILDE_REGISTER
)
5473 /* Skip empty registers. */
5474 num_lines
= y_regs
[i
].y_size
;
5476 || (num_lines
== 1 && y_regs
[i
].y_type
== MCHAR
5477 && STRLEN(y_regs
[i
].y_array
[0]) == 0))
5482 /* Skip register if there is more text than the maximum size. */
5484 for (j
= 0; j
< num_lines
; j
++)
5485 len
+= (long)STRLEN(y_regs
[i
].y_array
[j
]) + 1L;
5486 if (len
> (long)max_kbyte
* 1024L)
5490 switch (y_regs
[i
].y_type
)
5493 type
= (char_u
*)"LINE";
5496 type
= (char_u
*)"CHAR";
5500 type
= (char_u
*)"BLOCK";
5504 sprintf((char *)IObuff
, _("E574: Unknown register type %d"),
5507 type
= (char_u
*)"LINE";
5510 if (y_previous
== &y_regs
[i
])
5512 c
= get_register_name(i
);
5513 fprintf(fp
, "\"%c", c
);
5514 if (c
== execreg_lastc
)
5516 fprintf(fp
, "\t%s\t%d\n", type
,
5518 (int)y_regs
[i
].y_width
5524 /* If max_num_lines < 0, then we save ALL the lines in the register */
5525 if (max_num_lines
> 0 && num_lines
> max_num_lines
)
5526 num_lines
= max_num_lines
;
5527 for (j
= 0; j
< num_lines
; j
++)
5530 viminfo_writestring(fp
, y_regs
[i
].y_array
[j
]);
5534 #endif /* FEAT_VIMINFO */
5536 #if defined(FEAT_CLIPBOARD) || defined(PROTO)
5538 * SELECTION / PRIMARY ('*')
5540 * Text selection stuff that uses the GUI selection register '*'. When using a
5541 * GUI this may be text from another window, otherwise it is the last text we
5542 * had highlighted with VIsual mode. With mouse support, clicking the middle
5543 * button performs the paste, otherwise you will need to do <"*p>. "
5544 * If not under X, it is synonymous with the clipboard register '+'.
5548 * Text selection stuff that uses the GUI clipboard register '+'.
5549 * Under X, this matches the standard cut/paste buffer CLIPBOARD selection.
5550 * It will be used for unnamed cut/pasting is 'clipboard' contains "unnamed",
5551 * otherwise you will need to do <"+p>. "
5552 * If not under X, it is synonymous with the selection register '*'.
5556 * Routine to export any final X selection we had to the environment
5557 * so that the text is still available after vim has exited. X selections
5558 * only exist while the owning application exists, so we write to the
5559 * permanent (while X runs) store CUT_BUFFER0.
5560 * Dump the CLIPBOARD selection if we own it (it's logically the more
5561 * 'permanent' of the two), otherwise the PRIMARY one.
5562 * For now, use a hard-coded sanity limit of 1Mb of data.
5564 #if defined(FEAT_X11) && defined(FEAT_CLIPBOARD)
5566 x11_export_final_selection()
5571 int motion_type
= -1;
5578 # ifdef FEAT_XCLIPBOARD
5584 /* Get selection to export */
5585 if (clip_plus
.owned
)
5586 motion_type
= clip_convert_selection(&str
, &len
, &clip_plus
);
5587 else if (clip_star
.owned
)
5588 motion_type
= clip_convert_selection(&str
, &len
, &clip_star
);
5591 if (dpy
!= NULL
&& str
!= NULL
&& motion_type
>= 0
5592 && len
< 1024*1024 && len
> 0)
5595 /* The CUT_BUFFER0 is supposed to always contain latin1. Convert from
5596 * 'enc' when it is a multi-byte encoding. When 'enc' is an 8-bit
5597 * encoding conversion usually doesn't work, so keep the text as-is.
5603 vc
.vc_type
= CONV_NONE
;
5604 if (convert_setup(&vc
, p_enc
, (char_u
*)"latin1") == OK
)
5609 conv_str
= string_convert(&vc
, str
, &intlen
);
5611 if (conv_str
!= NULL
)
5616 convert_setup(&vc
, NULL
, NULL
);
5620 XStoreBuffer(dpy
, (char *)str
, (int)len
, 0);
5629 clip_free_selection(cbd
)
5632 struct yankreg
*y_ptr
= y_current
;
5634 if (cbd
== &clip_plus
)
5635 y_current
= &y_regs
[PLUS_REGISTER
];
5637 y_current
= &y_regs
[STAR_REGISTER
];
5639 y_current
->y_size
= 0;
5644 * Get the selected text and put it in the gui selection register '*' or '+'.
5647 clip_get_selection(cbd
)
5650 struct yankreg
*old_y_previous
, *old_y_current
;
5654 int old_visual_mode
;
5656 colnr_T old_curswant
;
5657 int old_set_curswant
;
5658 pos_T old_op_start
, old_op_end
;
5664 if ((cbd
== &clip_plus
&& y_regs
[PLUS_REGISTER
].y_array
!= NULL
)
5665 || (cbd
== &clip_star
&& y_regs
[STAR_REGISTER
].y_array
!= NULL
))
5668 /* Get the text between clip_star.start & clip_star.end */
5669 old_y_previous
= y_previous
;
5670 old_y_current
= y_current
;
5671 old_cursor
= curwin
->w_cursor
;
5672 old_curswant
= curwin
->w_curswant
;
5673 old_set_curswant
= curwin
->w_set_curswant
;
5674 old_op_start
= curbuf
->b_op_start
;
5675 old_op_end
= curbuf
->b_op_end
;
5677 old_visual
= VIsual
;
5678 old_visual_mode
= VIsual_mode
;
5681 oa
.regname
= (cbd
== &clip_plus
? '+' : '*');
5682 oa
.op_type
= OP_YANK
;
5683 vim_memset(&ca
, 0, sizeof(ca
));
5687 ca
.retval
= CA_NO_ADJ_OP_END
;
5688 do_pending_operator(&ca
, 0, TRUE
);
5689 y_previous
= old_y_previous
;
5690 y_current
= old_y_current
;
5691 curwin
->w_cursor
= old_cursor
;
5692 changed_cline_bef_curs(); /* need to update w_virtcol et al */
5693 curwin
->w_curswant
= old_curswant
;
5694 curwin
->w_set_curswant
= old_set_curswant
;
5695 curbuf
->b_op_start
= old_op_start
;
5696 curbuf
->b_op_end
= old_op_end
;
5698 VIsual
= old_visual
;
5699 VIsual_mode
= old_visual_mode
;
5704 clip_free_selection(cbd
);
5706 /* Try to get selected text from another window */
5707 clip_gen_request_selection(cbd
);
5711 /* Convert from the GUI selection string into the '*'/'+' register */
5713 clip_yank_selection(type
, str
, len
, cbd
)
5719 struct yankreg
*y_ptr
;
5721 if (cbd
== &clip_plus
)
5722 y_ptr
= &y_regs
[PLUS_REGISTER
];
5724 y_ptr
= &y_regs
[STAR_REGISTER
];
5726 clip_free_selection(cbd
);
5728 str_to_reg(y_ptr
, type
, str
, len
, 0L);
5732 * Convert the '*'/'+' register into a GUI selection string returned in *str
5734 * Returns the motion type, or -1 for failure.
5737 clip_convert_selection(str
, len
, cbd
)
5746 struct yankreg
*y_ptr
;
5748 if (cbd
== &clip_plus
)
5749 y_ptr
= &y_regs
[PLUS_REGISTER
];
5751 y_ptr
= &y_regs
[STAR_REGISTER
];
5761 if (y_ptr
->y_array
== NULL
)
5764 for (i
= 0; i
< y_ptr
->y_size
; i
++)
5765 *len
+= (long_u
)STRLEN(y_ptr
->y_array
[i
]) + eolsize
;
5768 * Don't want newline character at end of last line if we're in MCHAR mode.
5770 if (y_ptr
->y_type
== MCHAR
&& *len
>= eolsize
)
5773 p
= *str
= lalloc(*len
+ 1, TRUE
); /* add one to avoid zero */
5777 for (i
= 0, j
= 0; i
< (int)*len
; i
++, j
++)
5779 if (y_ptr
->y_array
[lnum
][j
] == '\n')
5781 else if (y_ptr
->y_array
[lnum
][j
] == NUL
)
5795 p
[i
] = y_ptr
->y_array
[lnum
][j
];
5797 return y_ptr
->y_type
;
5801 # if defined(FEAT_VISUAL) || defined(FEAT_EVAL)
5803 * If we have written to a clipboard register, send the text to the clipboard.
5808 if (y_current
== &(y_regs
[STAR_REGISTER
]) && clip_star
.available
)
5810 clip_own_selection(&clip_star
);
5811 clip_gen_set_selection(&clip_star
);
5813 else if (y_current
== &(y_regs
[PLUS_REGISTER
]) && clip_plus
.available
)
5815 clip_own_selection(&clip_plus
);
5816 clip_gen_set_selection(&clip_plus
);
5821 #endif /* FEAT_CLIPBOARD || PROTO */
5824 #if defined(FEAT_DND) || defined(PROTO)
5826 * Replace the contents of the '~' register with str.
5829 dnd_yank_drag_data(str
, len
)
5833 struct yankreg
*curr
;
5836 y_current
= &y_regs
[TILDE_REGISTER
];
5838 str_to_reg(y_current
, MCHAR
, str
, len
, 0L);
5844 #if defined(FEAT_EVAL) || defined(PROTO)
5846 * Return the type of a register.
5847 * Used for getregtype()
5848 * Returns MAUTO for error.
5851 get_reg_type(regname
, reglen
)
5857 case '%': /* file name */
5858 case '#': /* alternate file name */
5859 case '=': /* expression */
5860 case ':': /* last command line */
5861 case '/': /* last search-pattern */
5862 case '.': /* last inserted text */
5863 #ifdef FEAT_SEARCHPATH
5864 case Ctrl_F
: /* Filename under cursor */
5865 case Ctrl_P
: /* Path under cursor, expand via "path" */
5867 case Ctrl_W
: /* word under cursor */
5868 case Ctrl_A
: /* WORD (mnemonic All) under cursor */
5869 case '_': /* black hole: always empty */
5873 #ifdef FEAT_CLIPBOARD
5874 regname
= may_get_selection(regname
);
5877 /* Should we check for a valid name? */
5878 get_yank_register(regname
, FALSE
);
5880 if (y_current
->y_array
!= NULL
)
5883 if (reglen
!= NULL
&& y_current
->y_type
== MBLOCK
)
5884 *reglen
= y_current
->y_width
;
5886 return y_current
->y_type
;
5892 * Return the contents of a register as a single allocated string.
5893 * Used for "@r" in expressions and for getreg().
5894 * Returns NULL for error.
5897 get_reg_contents(regname
, allowexpr
, expr_src
)
5899 int allowexpr
; /* allow "=" register */
5900 int expr_src
; /* get expression for "=" register */
5907 /* Don't allow using an expression register inside an expression */
5913 return get_expr_line_src();
5914 return get_expr_line();
5919 if (regname
== '@') /* "@@" is used for unnamed register */
5922 /* check for valid regname */
5923 if (regname
!= NUL
&& !valid_yank_reg(regname
, FALSE
))
5926 #ifdef FEAT_CLIPBOARD
5927 regname
= may_get_selection(regname
);
5930 if (get_spec_reg(regname
, &retval
, &allocated
, FALSE
))
5935 retval
= vim_strsave(retval
);
5939 get_yank_register(regname
, FALSE
);
5940 if (y_current
->y_array
== NULL
)
5944 * Compute length of resulting string.
5947 for (i
= 0; i
< y_current
->y_size
; ++i
)
5949 len
+= (long)STRLEN(y_current
->y_array
[i
]);
5951 * Insert a newline between lines and after last line if
5954 if (y_current
->y_type
== MLINE
|| i
< y_current
->y_size
- 1)
5958 retval
= lalloc(len
+ 1, TRUE
);
5961 * Copy the lines of the yank register into the string.
5966 for (i
= 0; i
< y_current
->y_size
; ++i
)
5968 STRCPY(retval
+ len
, y_current
->y_array
[i
]);
5969 len
+= (long)STRLEN(retval
+ len
);
5972 * Insert a NL between lines and after the last line if y_type is
5975 if (y_current
->y_type
== MLINE
|| i
< y_current
->y_size
- 1)
5976 retval
[len
++] = '\n';
5985 * Store string "str" in register "name".
5986 * "maxlen" is the maximum number of bytes to use, -1 for all bytes.
5987 * If "must_append" is TRUE, always append to the register. Otherwise append
5988 * if "name" is an uppercase letter.
5989 * Note: "maxlen" and "must_append" don't work for the "/" register.
5990 * Careful: 'str' is modified, you may have to use a copy!
5991 * If "str" ends in '\n' or '\r', use linewise, otherwise use characterwise.
5994 write_reg_contents(name
, str
, maxlen
, must_append
)
6000 write_reg_contents_ex(name
, str
, maxlen
, must_append
, MAUTO
, 0L);
6004 write_reg_contents_ex(name
, str
, maxlen
, must_append
, yank_type
, block_len
)
6012 struct yankreg
*old_y_previous
, *old_y_current
;
6018 len
= (long)STRLEN(str
);
6020 /* Special case: '/' search pattern */
6023 set_last_search_pat(str
, RE_SEARCH
, TRUE
, TRUE
);
6032 p
= vim_strnsave(str
, (int)len
);
6037 s
= concat_str(get_expr_line_src(), p
);
6047 if (!valid_yank_reg(name
, TRUE
)) /* check for valid reg name */
6053 if (name
== '_') /* black hole: nothing to do */
6056 /* Don't want to change the current (unnamed) register */
6057 old_y_previous
= y_previous
;
6058 old_y_current
= y_current
;
6060 get_yank_register(name
, TRUE
);
6061 if (!y_append
&& !must_append
)
6064 /* Just in case - make sure we don't use MBLOCK */
6065 if (yank_type
== MBLOCK
)
6068 if (yank_type
== MAUTO
)
6069 yank_type
= ((len
> 0 && (str
[len
- 1] == '\n' || str
[len
- 1] == '\r'))
6071 str_to_reg(y_current
, yank_type
, str
, len
, block_len
);
6073 # ifdef FEAT_CLIPBOARD
6074 /* Send text of clipboard register to the clipboard. */
6075 may_set_selection();
6078 /* ':let @" = "val"' should change the meaning of the "" register */
6080 y_previous
= old_y_previous
;
6081 y_current
= old_y_current
;
6083 #endif /* FEAT_EVAL */
6085 #if defined(FEAT_CLIPBOARD) || defined(FEAT_EVAL)
6087 * Put a string into a register. When the register is not empty, the string
6091 str_to_reg(y_ptr
, type
, str
, len
, blocklen
)
6092 struct yankreg
*y_ptr
; /* pointer to yank register */
6093 int type
; /* MCHAR, MLINE or MBLOCK */
6094 char_u
*str
; /* string to put in register */
6095 long len
; /* length of string */
6096 long blocklen
; /* width of Visual block */
6102 int newlines
; /* number of lines added */
6103 int extraline
= 0; /* extra line at the end */
6104 int append
= FALSE
; /* append to last line in register */
6111 if (y_ptr
->y_array
== NULL
) /* NULL means empty register */
6115 * Count the number of lines within the string
6118 for (i
= 0; i
< len
; i
++)
6121 if (type
== MCHAR
|| len
== 0 || str
[len
- 1] != '\n')
6124 ++newlines
; /* count extra newline at the end */
6126 if (y_ptr
->y_size
> 0 && y_ptr
->y_type
== MCHAR
)
6129 --newlines
; /* uncount newline when appending first line */
6133 * Allocate an array to hold the pointers to the new register lines.
6134 * If the register was not empty, move the existing lines to the new array.
6136 pp
= (char_u
**)lalloc_clear((y_ptr
->y_size
+ newlines
)
6137 * sizeof(char_u
*), TRUE
);
6138 if (pp
== NULL
) /* out of memory */
6140 for (lnum
= 0; lnum
< y_ptr
->y_size
; ++lnum
)
6141 pp
[lnum
] = y_ptr
->y_array
[lnum
];
6142 vim_free(y_ptr
->y_array
);
6143 y_ptr
->y_array
= pp
;
6149 * Find the end of each line and save it into the array.
6151 for (start
= 0; start
< len
+ extraline
; start
+= i
+ 1)
6153 for (i
= start
; i
< len
; ++i
) /* find the end of the line */
6156 i
-= start
; /* i is now length of line */
6164 extra
= (int)STRLEN(y_ptr
->y_array
[lnum
]);
6168 s
= alloc((unsigned)(i
+ extra
+ 1));
6172 mch_memmove(s
, y_ptr
->y_array
[lnum
], (size_t)extra
);
6174 vim_free(y_ptr
->y_array
[lnum
]);
6176 mch_memmove(s
+ extra
, str
+ start
, (size_t)i
);
6179 y_ptr
->y_array
[lnum
++] = s
;
6180 while (--extra
>= 0)
6183 *s
= '\n'; /* replace NUL with newline */
6186 append
= FALSE
; /* only first line is appended */
6188 y_ptr
->y_type
= type
;
6189 y_ptr
->y_size
= lnum
;
6192 y_ptr
->y_width
= (blocklen
< 0 ? maxlen
- 1 : blocklen
);
6197 #endif /* FEAT_CLIPBOARD || FEAT_EVAL || PROTO */
6203 vim_memset(oap
, 0, sizeof(oparg_T
));
6206 static long line_count_info
__ARGS((char_u
*line
, long *wc
, long *cc
, long limit
, int eol_size
));
6209 * Count the number of bytes, characters and "words" in a line.
6211 * "Words" are counted by looking for boundaries between non-space and
6212 * space characters. (it seems to produce results that match 'wc'.)
6214 * Return value is byte count; word count for the line is added to "*wc".
6215 * Char count is added to "*cc".
6217 * The function will only examine the first "limit" characters in the
6218 * line, stopping if it encounters an end-of-line (NUL byte). In that
6219 * case, eol_size will be added to the character count to account for
6220 * the size of the EOL character.
6223 line_count_info(line
, wc
, cc
, limit
, eol_size
)
6235 for (i
= 0; line
[i
] && i
< limit
; )
6239 if (vim_isspace(line
[i
]))
6245 else if (!vim_isspace(line
[i
]))
6249 i
+= (*mb_ptr2len
)(line
+ i
);
6259 /* Add eol_size if the end of line was reached before hitting limit. */
6260 if (line
[i
] == NUL
&& i
< limit
)
6270 * Give some info about the position of the cursor (for "g CTRL-G").
6271 * In Visual mode, give some info about the selected region. (In this case,
6272 * the *_count_cursor variables store running totals for the selection.)
6281 long byte_count
= 0;
6282 long byte_count_cursor
= 0;
6283 long char_count
= 0;
6284 long char_count_cursor
= 0;
6285 long word_count
= 0;
6286 long word_count_cursor
= 0;
6288 long last_check
= 100000L;
6290 long line_count_selected
= 0;
6291 pos_T min_pos
, max_pos
;
6293 struct block_def bd
;
6297 * Compute the length of the file in characters.
6299 if (curbuf
->b_ml
.ml_flags
& ML_EMPTY
)
6301 MSG(_(no_lines_msg
));
6305 if (get_fileformat(curbuf
) == EOL_DOS
)
6313 if (lt(VIsual
, curwin
->w_cursor
))
6316 max_pos
= curwin
->w_cursor
;
6320 min_pos
= curwin
->w_cursor
;
6323 if (*p_sel
== 'e' && max_pos
.col
> 0)
6326 if (VIsual_mode
== Ctrl_V
)
6328 #ifdef FEAT_LINEBREAK
6329 char_u
* saved_sbr
= p_sbr
;
6331 /* Make 'sbr' empty for a moment to get the correct size. */
6332 p_sbr
= empty_option
;
6334 oparg
.is_VIsual
= 1;
6335 oparg
.block_mode
= TRUE
;
6336 oparg
.op_type
= OP_NOP
;
6337 getvcols(curwin
, &min_pos
, &max_pos
,
6338 &oparg
.start_vcol
, &oparg
.end_vcol
);
6339 #ifdef FEAT_LINEBREAK
6342 if (curwin
->w_curswant
== MAXCOL
)
6343 oparg
.end_vcol
= MAXCOL
;
6344 /* Swap the start, end vcol if needed */
6345 if (oparg
.end_vcol
< oparg
.start_vcol
)
6347 oparg
.end_vcol
+= oparg
.start_vcol
;
6348 oparg
.start_vcol
= oparg
.end_vcol
- oparg
.start_vcol
;
6349 oparg
.end_vcol
-= oparg
.start_vcol
;
6352 line_count_selected
= max_pos
.lnum
- min_pos
.lnum
+ 1;
6356 for (lnum
= 1; lnum
<= curbuf
->b_ml
.ml_line_count
; ++lnum
)
6358 /* Check for a CTRL-C every 100000 characters. */
6359 if (byte_count
> last_check
)
6364 last_check
= byte_count
+ 100000L;
6368 /* Do extra processing for VIsual mode. */
6370 && lnum
>= min_pos
.lnum
&& lnum
<= max_pos
.lnum
)
6375 switch (VIsual_mode
)
6378 # ifdef FEAT_VIRTUALEDIT
6379 virtual_op
= virtual_active();
6381 block_prep(&oparg
, &bd
, lnum
, 0);
6382 # ifdef FEAT_VIRTUALEDIT
6386 len
= (long)bd
.textlen
;
6394 colnr_T start_col
= (lnum
== min_pos
.lnum
)
6396 colnr_T end_col
= (lnum
== max_pos
.lnum
)
6397 ? max_pos
.col
- start_col
+ 1 : MAXCOL
;
6399 s
= ml_get(lnum
) + start_col
;
6406 byte_count_cursor
+= line_count_info(s
, &word_count_cursor
,
6407 &char_count_cursor
, len
, eol_size
);
6408 if (lnum
== curbuf
->b_ml
.ml_line_count
6411 && (long)STRLEN(s
) < len
)
6412 byte_count_cursor
-= eol_size
;
6418 /* In non-visual mode, check for the line the cursor is on */
6419 if (lnum
== curwin
->w_cursor
.lnum
)
6421 word_count_cursor
+= word_count
;
6422 char_count_cursor
+= char_count
;
6423 byte_count_cursor
= byte_count
+
6424 line_count_info(ml_get(lnum
),
6425 &word_count_cursor
, &char_count_cursor
,
6426 (long)(curwin
->w_cursor
.col
+ 1), eol_size
);
6429 /* Add to the running totals */
6430 byte_count
+= line_count_info(ml_get(lnum
), &word_count
,
6431 &char_count
, (long)MAXCOL
, eol_size
);
6434 /* Correction for when last line doesn't have an EOL. */
6435 if (!curbuf
->b_p_eol
&& curbuf
->b_p_bin
)
6436 byte_count
-= eol_size
;
6441 if (VIsual_mode
== Ctrl_V
&& curwin
->w_curswant
< MAXCOL
)
6443 getvcols(curwin
, &min_pos
, &max_pos
, &min_pos
.col
,
6445 vim_snprintf((char *)buf1
, sizeof(buf1
), _("%ld Cols; "),
6446 (long)(oparg
.end_vcol
- oparg
.start_vcol
+ 1));
6451 if (char_count_cursor
== byte_count_cursor
6452 && char_count
== byte_count
)
6453 vim_snprintf((char *)IObuff
, IOSIZE
,
6454 _("Selected %s%ld of %ld Lines; %ld of %ld Words; %ld of %ld Bytes"),
6455 buf1
, line_count_selected
,
6456 (long)curbuf
->b_ml
.ml_line_count
,
6457 word_count_cursor
, word_count
,
6458 byte_count_cursor
, byte_count
);
6460 vim_snprintf((char *)IObuff
, IOSIZE
,
6461 _("Selected %s%ld of %ld Lines; %ld of %ld Words; %ld of %ld Chars; %ld of %ld Bytes"),
6462 buf1
, line_count_selected
,
6463 (long)curbuf
->b_ml
.ml_line_count
,
6464 word_count_cursor
, word_count
,
6465 char_count_cursor
, char_count
,
6466 byte_count_cursor
, byte_count
);
6471 p
= ml_get_curline();
6473 col_print(buf1
, sizeof(buf1
), (int)curwin
->w_cursor
.col
+ 1,
6474 (int)curwin
->w_virtcol
+ 1);
6475 col_print(buf2
, sizeof(buf2
), (int)STRLEN(p
), linetabsize(p
));
6477 if (char_count_cursor
== byte_count_cursor
6478 && char_count
== byte_count
)
6479 vim_snprintf((char *)IObuff
, IOSIZE
,
6480 _("Col %s of %s; Line %ld of %ld; Word %ld of %ld; Byte %ld of %ld"),
6481 (char *)buf1
, (char *)buf2
,
6482 (long)curwin
->w_cursor
.lnum
,
6483 (long)curbuf
->b_ml
.ml_line_count
,
6484 word_count_cursor
, word_count
,
6485 byte_count_cursor
, byte_count
);
6487 vim_snprintf((char *)IObuff
, IOSIZE
,
6488 _("Col %s of %s; Line %ld of %ld; Word %ld of %ld; Char %ld of %ld; Byte %ld of %ld"),
6489 (char *)buf1
, (char *)buf2
,
6490 (long)curwin
->w_cursor
.lnum
,
6491 (long)curbuf
->b_ml
.ml_line_count
,
6492 word_count_cursor
, word_count
,
6493 char_count_cursor
, char_count
,
6494 byte_count_cursor
, byte_count
);
6498 byte_count
= bomb_size();
6500 sprintf((char *)IObuff
+ STRLEN(IObuff
), _("(+%ld for BOM)"),
6503 /* Don't shorten this message, the user asked for it. */
6505 p_shm
= (char_u
*)"";