1 /* text.c -- text handling commands for readline. */
3 /* Copyright (C) 1987-2009 Free Software Foundation, Inc.
5 This file is part of the GNU Readline Library (Readline), a library
6 for reading lines of text with interactive input and history editing.
8 Readline is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 Readline is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with Readline. If not, see <http://www.gnu.org/licenses/>.
22 #define READLINE_LIBRARY
24 #if defined (HAVE_CONFIG_H)
28 #if defined (HAVE_UNISTD_H)
30 #endif /* HAVE_UNISTD_H */
32 #if defined (HAVE_STDLIB_H)
35 # include "ansi_stdlib.h"
36 #endif /* HAVE_STDLIB_H */
38 #if defined (HAVE_LOCALE_H)
44 /* System-specific feature definitions and include files. */
49 # define INCL_DOSPROCESS
53 /* Some standard library routines. */
57 #include "rlprivate.h"
61 /* Forward declarations. */
62 static int rl_change_case PARAMS((int, int));
63 static int _rl_char_search PARAMS((int, int, int));
65 #if defined (READLINE_CALLBACKS)
66 static int _rl_insert_next_callback PARAMS((_rl_callback_generic_arg *));
67 static int _rl_char_search_callback PARAMS((_rl_callback_generic_arg *));
70 /* The largest chunk of text that can be inserted in one call to
71 rl_insert_text. Text blocks larger than this are divided. */
72 #define TEXT_COUNT_MAX 1024
74 /* **************************************************************** */
76 /* Insert and Delete */
78 /* **************************************************************** */
80 /* Insert a string of text into the line at point. This is the only
81 way that you should do insertion. _rl_insert_char () calls this
82 function. Returns the number of characters inserted. */
84 rl_insert_text (string)
89 l = (string && *string) ? strlen (string) : 0;
93 if (rl_end + l >= rl_line_buffer_len)
94 rl_extend_line_buffer (rl_end + l);
96 for (i = rl_end; i >= rl_point; i--)
97 rl_line_buffer[i + l] = rl_line_buffer[i];
98 strncpy (rl_line_buffer + rl_point, string, l);
100 /* Remember how to undo this if we aren't undoing something. */
101 if (_rl_doing_an_undo == 0)
103 /* If possible and desirable, concatenate the undos. */
106 (rl_undo_list->what == UNDO_INSERT) &&
107 (rl_undo_list->end == rl_point) &&
108 (rl_undo_list->end - rl_undo_list->start < 20))
111 rl_add_undo (UNDO_INSERT, rl_point, rl_point + l, (char *)NULL);
115 rl_line_buffer[rl_end] = '\0';
119 /* Delete the string between FROM and TO. FROM is inclusive, TO is not.
120 Returns the number of characters deleted. */
122 rl_delete_text (from, to)
126 register int diff, i;
128 /* Fix it if the caller is confused. */
142 text = rl_copy_text (from, to);
144 /* Some versions of strncpy() can't handle overlapping arguments. */
146 for (i = from; i < rl_end - diff; i++)
147 rl_line_buffer[i] = rl_line_buffer[i + diff];
149 /* Remember how to undo this delete. */
150 if (_rl_doing_an_undo == 0)
151 rl_add_undo (UNDO_DELETE, from, to, text);
156 rl_line_buffer[rl_end] = '\0';
160 /* Fix up point so that it is within the line boundaries after killing
161 text. If FIX_MARK_TOO is non-zero, the mark is forced within line
164 #define _RL_FIX_POINT(x) \
173 _rl_fix_point (fix_mark_too)
176 _RL_FIX_POINT (rl_point);
178 _RL_FIX_POINT (rl_mark);
182 /* Replace the contents of the line buffer between START and END with
183 TEXT. The operation is undoable. To replace the entire line in an
184 undoable mode, use _rl_replace_text(text, 0, rl_end); */
186 _rl_replace_text (text, start, end)
193 rl_begin_undo_group ();
195 rl_delete_text (start, end + 1);
198 n = rl_insert_text (text);
199 rl_end_undo_group ();
204 /* Replace the current line buffer contents with TEXT. If CLEAR_UNDO is
205 non-zero, we free the current undo list. */
207 rl_replace_line (text, clear_undo)
214 if (len >= rl_line_buffer_len)
215 rl_extend_line_buffer (len);
216 strcpy (rl_line_buffer, text);
220 rl_free_undo_list ();
225 /* **************************************************************** */
227 /* Readline character functions */
229 /* **************************************************************** */
231 /* This is not a gap editor, just a stupid line input routine. No hair
232 is involved in writing any of the functions, and none should be. */
236 rl_end is the place in the string that we would place '\0';
237 i.e., it is always safe to place '\0' there.
239 rl_point is the place in the string where the cursor is. Sometimes
240 this is the same as rl_end.
242 Any command that is called interactively receives two arguments.
243 The first is a count: the numeric arg pased to this command.
244 The second is the key which invoked this command.
247 /* **************************************************************** */
249 /* Movement Commands */
251 /* **************************************************************** */
253 /* Note that if you `optimize' the display for these functions, you cannot
254 use said functions in other functions which do not do optimizing display.
255 I.e., you will have to update the data base for rl_redisplay, and you
256 might as well let rl_redisplay do that job. */
258 /* Move forward COUNT bytes. */
260 rl_forward_byte (count, key)
264 return (rl_backward_byte (-count, key));
268 int end = rl_point + count;
269 #if defined (VI_MODE)
270 int lend = rl_end > 0 ? rl_end - (VI_COMMAND_MODE()) : rl_end;
290 #if defined (HANDLE_MULTIBYTE)
291 /* Move forward COUNT characters. */
293 rl_forward_char (count, key)
298 if (MB_CUR_MAX == 1 || rl_byte_oriented)
299 return (rl_forward_byte (count, key));
302 return (rl_backward_char (-count, key));
306 if (rl_point == rl_end && EMACS_MODE())
312 point = _rl_find_next_mbchar (rl_line_buffer, rl_point, count, MB_FIND_NONZERO);
314 #if defined (VI_MODE)
315 if (point >= rl_end && VI_COMMAND_MODE())
316 point = _rl_find_prev_mbchar (rl_line_buffer, rl_end, MB_FIND_NONZERO);
319 if (rl_point == point)
330 #else /* !HANDLE_MULTIBYTE */
332 rl_forward_char (count, key)
335 return (rl_forward_byte (count, key));
337 #endif /* !HANDLE_MULTIBYTE */
339 /* Backwards compatibility. */
341 rl_forward (count, key)
344 return (rl_forward_char (count, key));
347 /* Move backward COUNT bytes. */
349 rl_backward_byte (count, key)
353 return (rl_forward_byte (-count, key));
357 if (rl_point < count)
372 #if defined (HANDLE_MULTIBYTE)
373 /* Move backward COUNT characters. */
375 rl_backward_char (count, key)
380 if (MB_CUR_MAX == 1 || rl_byte_oriented)
381 return (rl_backward_byte (count, key));
384 return (rl_forward_char (-count, key));
390 while (count > 0 && point > 0)
392 point = _rl_find_prev_mbchar (rl_line_buffer, point, MB_FIND_NONZERO);
408 rl_backward_char (count, key)
411 return (rl_backward_byte (count, key));
415 /* Backwards compatibility. */
417 rl_backward (count, key)
420 return (rl_backward_char (count, key));
423 /* Move to the beginning of the line. */
425 rl_beg_of_line (count, key)
432 /* Move to the end of the line. */
434 rl_end_of_line (count, key)
441 /* Move forward a word. We do what Emacs does. Handles multibyte chars. */
443 rl_forward_word (count, key)
449 return (rl_backward_word (-count, key));
453 if (rl_point == rl_end)
456 /* If we are not in a word, move forward until we are in one.
457 Then, move forward until we hit a non-alphabetic character. */
458 c = _rl_char_value (rl_line_buffer, rl_point);
460 if (_rl_walphabetic (c) == 0)
462 rl_point = MB_NEXTCHAR (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
463 while (rl_point < rl_end)
465 c = _rl_char_value (rl_line_buffer, rl_point);
466 if (_rl_walphabetic (c))
468 rl_point = MB_NEXTCHAR (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
472 if (rl_point == rl_end)
475 rl_point = MB_NEXTCHAR (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
476 while (rl_point < rl_end)
478 c = _rl_char_value (rl_line_buffer, rl_point);
479 if (_rl_walphabetic (c) == 0)
481 rl_point = MB_NEXTCHAR (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
490 /* Move backward a word. We do what Emacs does. Handles multibyte chars. */
492 rl_backward_word (count, key)
498 return (rl_forward_word (-count, key));
505 /* Like rl_forward_word (), except that we look at the characters
506 just before point. */
508 p = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_NONZERO);
509 c = _rl_char_value (rl_line_buffer, p);
511 if (_rl_walphabetic (c) == 0)
516 p = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_NONZERO);
517 c = _rl_char_value (rl_line_buffer, p);
518 if (_rl_walphabetic (c))
526 p = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_NONZERO);
527 c = _rl_char_value (rl_line_buffer, p);
528 if (_rl_walphabetic (c) == 0)
540 /* Clear the current line. Numeric argument to C-l does this. */
542 rl_refresh_line (ignore1, ignore2)
543 int ignore1, ignore2;
547 curr_line = _rl_current_display_line ();
549 _rl_move_vert (curr_line);
550 _rl_move_cursor_relative (0, rl_line_buffer); /* XXX is this right */
552 _rl_clear_to_eol (0); /* arg of 0 means to not use spaces */
554 rl_forced_update_display ();
555 rl_display_fixed = 1;
560 /* C-l typed to a line without quoting clears the screen, and then reprints
561 the prompt and the current input line. Given a numeric arg, redraw only
564 rl_clear_screen (count, key)
569 rl_refresh_line (count, key);
573 _rl_clear_screen (); /* calls termcap function to clear screen */
574 rl_forced_update_display ();
575 rl_display_fixed = 1;
581 rl_skip_csi_sequence (count, key)
586 RL_SETSTATE (RL_STATE_MOREINPUT);
589 while (ch >= 0x20 && ch < 0x40);
590 RL_UNSETSTATE (RL_STATE_MOREINPUT);
596 rl_arrow_keys (count, c)
601 RL_SETSTATE(RL_STATE_MOREINPUT);
603 RL_UNSETSTATE(RL_STATE_MOREINPUT);
605 switch (_rl_to_upper (ch))
608 rl_get_previous_history (count, ch);
612 rl_get_next_history (count, ch);
616 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
617 rl_forward_char (count, ch);
619 rl_forward_byte (count, ch);
623 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
624 rl_backward_char (count, ch);
626 rl_backward_byte (count, ch);
636 /* **************************************************************** */
640 /* **************************************************************** */
642 #ifdef HANDLE_MULTIBYTE
643 static char pending_bytes[MB_LEN_MAX];
644 static int pending_bytes_length = 0;
645 static mbstate_t ps = {0};
648 /* Insert the character C at the current location, moving point forward.
649 If C introduces a multibyte sequence, we read the whole sequence and
650 then insert the multibyte char into the line buffer. */
652 _rl_insert_char (count, c)
657 #ifdef HANDLE_MULTIBYTE
659 char incoming[MB_LEN_MAX + 1];
660 int incoming_length = 0;
662 static int stored_count = 0;
668 #if defined (HANDLE_MULTIBYTE)
669 if (MB_CUR_MAX == 1 || rl_byte_oriented)
680 if (stored_count <= 0)
681 stored_count = count;
683 count = stored_count;
686 pending_bytes[pending_bytes_length++] = c;
687 ret = mbrtowc (&wc, pending_bytes, pending_bytes_length, &ps);
689 if (ret == (size_t)-2)
691 /* Bytes too short to compose character, try to wait for next byte.
692 Restore the state of the byte sequence, because in this case the
693 effect of mbstate is undefined. */
697 else if (ret == (size_t)-1)
699 /* Invalid byte sequence for the current locale. Treat first byte
700 as a single character. */
701 incoming[0] = pending_bytes[0];
704 pending_bytes_length--;
705 memmove (pending_bytes, pending_bytes + 1, pending_bytes_length);
706 /* Clear the state of the byte sequence, because in this case the
707 effect of mbstate is undefined. */
708 memset (&ps, 0, sizeof (mbstate_t));
710 else if (ret == (size_t)0)
714 pending_bytes_length--;
715 /* Clear the state of the byte sequence, because in this case the
716 effect of mbstate is undefined. */
717 memset (&ps, 0, sizeof (mbstate_t));
721 /* We successfully read a single multibyte character. */
722 memcpy (incoming, pending_bytes, pending_bytes_length);
723 incoming[pending_bytes_length] = '\0';
724 incoming_length = pending_bytes_length;
725 pending_bytes_length = 0;
728 #endif /* HANDLE_MULTIBYTE */
730 /* If we can optimize, then do it. But don't let people crash
731 readline because of extra large arguments. */
732 if (count > 1 && count <= TEXT_COUNT_MAX)
734 #if defined (HANDLE_MULTIBYTE)
735 string_size = count * incoming_length;
736 string = (char *)xmalloc (1 + string_size);
739 while (i < string_size)
741 strncpy (string + i, incoming, incoming_length);
742 i += incoming_length;
746 #else /* !HANDLE_MULTIBYTE */
747 string = (char *)xmalloc (1 + count);
749 for (i = 0; i < count; i++)
751 #endif /* !HANDLE_MULTIBYTE */
754 rl_insert_text (string);
760 if (count > TEXT_COUNT_MAX)
763 #if defined (HANDLE_MULTIBYTE)
764 string_size = incoming_length * TEXT_COUNT_MAX;
765 string = (char *)xmalloc (1 + string_size);
768 while (i < string_size)
770 strncpy (string + i, incoming, incoming_length);
771 i += incoming_length;
776 decreaser = (count > TEXT_COUNT_MAX) ? TEXT_COUNT_MAX : count;
777 string[decreaser*incoming_length] = '\0';
778 rl_insert_text (string);
785 #else /* !HANDLE_MULTIBYTE */
786 char str[TEXT_COUNT_MAX+1];
788 for (i = 0; i < TEXT_COUNT_MAX; i++)
793 decreaser = (count > TEXT_COUNT_MAX ? TEXT_COUNT_MAX : count);
794 str[decreaser] = '\0';
795 rl_insert_text (str);
798 #endif /* !HANDLE_MULTIBYTE */
803 if (MB_CUR_MAX == 1 || rl_byte_oriented)
805 /* We are inserting a single character.
806 If there is pending input, then make a string of all of the
807 pending characters that are bound to rl_insert, and insert
809 if (_rl_any_typein ())
810 _rl_insert_typein (c);
813 /* Inserting a single character. */
818 rl_insert_text (str);
821 #if defined (HANDLE_MULTIBYTE)
824 rl_insert_text (incoming);
832 /* Overwrite the character at point (or next COUNT characters) with C.
833 If C introduces a multibyte character sequence, read the entire sequence
834 before starting the overwrite loop. */
836 _rl_overwrite_char (count, c)
840 #if defined (HANDLE_MULTIBYTE)
841 char mbkey[MB_LEN_MAX];
844 /* Read an entire multibyte character sequence to insert COUNT times. */
845 if (count > 0 && MB_CUR_MAX > 1 && rl_byte_oriented == 0)
846 k = _rl_read_mbstring (c, mbkey, MB_LEN_MAX);
849 rl_begin_undo_group ();
851 for (i = 0; i < count; i++)
853 #if defined (HANDLE_MULTIBYTE)
854 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
855 rl_insert_text (mbkey);
858 _rl_insert_char (1, c);
860 if (rl_point < rl_end)
864 rl_end_undo_group ();
873 return (rl_insert_mode == RL_IM_INSERT ? _rl_insert_char (count, c)
874 : _rl_overwrite_char (count, c));
877 /* Insert the next typed character verbatim. */
879 _rl_insert_next (count)
884 RL_SETSTATE(RL_STATE_MOREINPUT);
886 RL_UNSETSTATE(RL_STATE_MOREINPUT);
891 #if defined (HANDLE_SIGNALS)
892 if (RL_ISSTATE (RL_STATE_CALLBACK) == 0)
893 _rl_restore_tty_signals ();
896 return (_rl_insert_char (count, c));
899 #if defined (READLINE_CALLBACKS)
901 _rl_insert_next_callback (data)
902 _rl_callback_generic_arg *data;
908 /* Deregister function, let rl_callback_read_char deallocate data */
909 _rl_callback_func = 0;
910 _rl_want_redisplay = 1;
912 return _rl_insert_next (count);
917 rl_quoted_insert (count, key)
920 /* Let's see...should the callback interface futz with signal handling? */
921 #if defined (HANDLE_SIGNALS)
922 if (RL_ISSTATE (RL_STATE_CALLBACK) == 0)
923 _rl_disable_tty_signals ();
926 #if defined (READLINE_CALLBACKS)
927 if (RL_ISSTATE (RL_STATE_CALLBACK))
929 _rl_callback_data = _rl_callback_data_alloc (count);
930 _rl_callback_func = _rl_insert_next_callback;
935 return _rl_insert_next (count);
938 /* Insert a tab character. */
940 rl_tab_insert (count, key)
943 return (_rl_insert_char (count, '\t'));
946 /* What to do when a NEWLINE is pressed. We accept the whole line.
947 KEY is the key that invoked this command. I guess it could have
948 meaning in the future. */
950 rl_newline (count, key)
955 if (_rl_history_preserve_point)
956 _rl_history_saved_point = (rl_point == rl_end) ? -1 : rl_point;
958 RL_SETSTATE(RL_STATE_DONE);
960 #if defined (VI_MODE)
961 if (rl_editing_mode == vi_mode)
963 _rl_vi_done_inserting ();
964 if (_rl_vi_textmod_command (_rl_vi_last_command) == 0) /* XXX */
965 _rl_vi_reset_last ();
969 /* If we've been asked to erase empty lines, suppress the final update,
970 since _rl_update_final calls rl_crlf(). */
971 if (rl_erase_empty_line && rl_point == 0 && rl_end == 0)
979 /* What to do for some uppercase characters, like meta characters,
980 and some characters appearing in emacs_ctlx_keymap. This function
981 is just a stub, you bind keys to it and the code in _rl_dispatch ()
984 rl_do_lowercase_version (ignore1, ignore2)
985 int ignore1, ignore2;
990 /* This is different from what vi does, so the code's not shared. Emacs
991 rubout in overwrite mode has one oddity: it replaces a control
992 character that's displayed as two characters (^X) with two spaces. */
994 _rl_overwrite_rubout (count, key)
1008 /* L == number of spaces to insert */
1009 for (i = l = 0; i < count; i++)
1011 rl_backward_char (1, key);
1012 l += rl_character_len (rl_line_buffer[rl_point], rl_point); /* not exactly right */
1015 rl_begin_undo_group ();
1017 if (count > 1 || rl_explicit_arg)
1018 rl_kill_text (opoint, rl_point);
1020 rl_delete_text (opoint, rl_point);
1022 /* Emacs puts point at the beginning of the sequence of spaces. */
1023 if (rl_point < rl_end)
1026 _rl_insert_char (l, ' ');
1030 rl_end_undo_group ();
1035 /* Rubout the character behind point. */
1037 rl_rubout (count, key)
1041 return (rl_delete (-count, key));
1049 if (rl_insert_mode == RL_IM_OVERWRITE)
1050 return (_rl_overwrite_rubout (count, key));
1052 return (_rl_rubout_char (count, key));
1056 _rl_rubout_char (count, key)
1062 /* Duplicated code because this is called from other parts of the library. */
1064 return (rl_delete (-count, key));
1072 orig_point = rl_point;
1073 if (count > 1 || rl_explicit_arg)
1075 rl_backward_char (count, key);
1076 rl_kill_text (orig_point, rl_point);
1078 else if (MB_CUR_MAX == 1 || rl_byte_oriented)
1080 c = rl_line_buffer[--rl_point];
1081 rl_delete_text (rl_point, orig_point);
1082 /* The erase-at-end-of-line hack is of questionable merit now. */
1083 if (rl_point == rl_end && ISPRINT (c) && _rl_last_c_pos)
1086 l = rl_character_len (c, rl_point);
1087 _rl_erase_at_end_of_line (l);
1092 rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_NONZERO);
1093 rl_delete_text (rl_point, orig_point);
1099 /* Delete the character under the cursor. Given a numeric argument,
1100 kill that many characters instead. */
1102 rl_delete (count, key)
1108 return (_rl_rubout_char (-count, key));
1110 if (rl_point == rl_end)
1116 if (count > 1 || rl_explicit_arg)
1119 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1120 rl_forward_char (count, key);
1122 rl_forward_byte (count, key);
1124 rl_kill_text (xpoint, rl_point);
1129 xpoint = MB_NEXTCHAR (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
1130 rl_delete_text (rl_point, xpoint);
1135 /* Delete the character under the cursor, unless the insertion
1136 point is at the end of the line, in which case the character
1137 behind the cursor is deleted. COUNT is obeyed and may be used
1138 to delete forward or backward that many characters. */
1140 rl_rubout_or_delete (count, key)
1143 if (rl_end != 0 && rl_point == rl_end)
1144 return (_rl_rubout_char (count, key));
1146 return (rl_delete (count, key));
1149 /* Delete all spaces and tabs around point. */
1151 rl_delete_horizontal_space (count, ignore)
1156 while (rl_point && whitespace (rl_line_buffer[rl_point - 1]))
1161 while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
1164 if (start != rl_point)
1166 rl_delete_text (start, rl_point);
1176 /* Like the tcsh editing function delete-char-or-list. The eof character
1177 is caught before this is invoked, so this really does the same thing as
1178 delete-char-or-list-or-eof, as long as it's bound to the eof character. */
1180 rl_delete_or_show_completions (count, key)
1183 if (rl_end != 0 && rl_point == rl_end)
1184 return (rl_possible_completions (count, key));
1186 return (rl_delete (count, key));
1189 #ifndef RL_COMMENT_BEGIN_DEFAULT
1190 #define RL_COMMENT_BEGIN_DEFAULT "#"
1193 /* Turn the current line into a comment in shell history.
1194 A K*rn shell style function. */
1196 rl_insert_comment (count, key)
1199 char *rl_comment_text;
1202 rl_beg_of_line (1, key);
1203 rl_comment_text = _rl_comment_begin ? _rl_comment_begin : RL_COMMENT_BEGIN_DEFAULT;
1205 if (rl_explicit_arg == 0)
1206 rl_insert_text (rl_comment_text);
1209 rl_comment_len = strlen (rl_comment_text);
1210 if (STREQN (rl_comment_text, rl_line_buffer, rl_comment_len))
1211 rl_delete_text (rl_point, rl_point + rl_comment_len);
1213 rl_insert_text (rl_comment_text);
1216 (*rl_redisplay_function) ();
1217 rl_newline (1, '\n');
1222 /* **************************************************************** */
1226 /* **************************************************************** */
1228 /* The three kinds of things that we know how to do. */
1233 /* Uppercase the word at point. */
1235 rl_upcase_word (count, key)
1238 return (rl_change_case (count, UpCase));
1241 /* Lowercase the word at point. */
1243 rl_downcase_word (count, key)
1246 return (rl_change_case (count, DownCase));
1249 /* Upcase the first letter, downcase the rest. */
1251 rl_capitalize_word (count, key)
1254 return (rl_change_case (count, CapCase));
1257 /* The meaty function.
1258 Change the case of COUNT words, performing OP on them.
1259 OP is one of UpCase, DownCase, or CapCase.
1260 If a negative argument is given, leave point where it started,
1261 otherwise, leave it where it moves to. */
1263 rl_change_case (count, op)
1266 int start, next, end;
1267 int inword, c, nc, nop;
1268 #if defined (HANDLE_MULTIBYTE)
1270 char mb[MB_LEN_MAX+1];
1277 rl_forward_word (count, 0);
1280 if (op != UpCase && op != DownCase && op != CapCase)
1289 #if defined (HANDLE_MULTIBYTE)
1290 memset (&mps, 0, sizeof (mbstate_t));
1293 /* We are going to modify some text, so let's prepare to undo it. */
1294 rl_modifying (start, end);
1299 c = _rl_char_value (rl_line_buffer, start);
1300 /* This assumes that the upper and lower case versions are the same width. */
1301 next = MB_NEXTCHAR (rl_line_buffer, start, 1, MB_FIND_NONZERO);
1303 if (_rl_walphabetic (c) == 0)
1312 nop = inword ? DownCase : UpCase;
1317 if (MB_CUR_MAX == 1 || rl_byte_oriented || isascii (c))
1319 nc = (nop == UpCase) ? _rl_to_upper (c) : _rl_to_lower (c);
1320 rl_line_buffer[start] = nc;
1322 #if defined (HANDLE_MULTIBYTE)
1325 m = mbrtowc (&wc, rl_line_buffer + start, end - start, &mps);
1326 if (MB_INVALIDCH (m))
1327 wc = (wchar_t)rl_line_buffer[start];
1328 else if (MB_NULLWCH (m))
1330 nwc = (nop == UpCase) ? _rl_to_wupper (wc) : _rl_to_wlower (wc);
1331 if (nwc != wc) /* just skip unchanged characters */
1333 mlen = wcrtomb (mb, nwc, &mps);
1336 /* Assume the same width */
1337 strncpy (rl_line_buffer + start, mb, mlen);
1349 /* **************************************************************** */
1353 /* **************************************************************** */
1355 /* Transpose the words at point. If point is at the end of the line,
1356 transpose the two words before point. */
1358 rl_transpose_words (count, key)
1361 char *word1, *word2;
1362 int w1_beg, w1_end, w2_beg, w2_end;
1363 int orig_point = rl_point;
1368 /* Find the two words. */
1369 rl_forward_word (count, key);
1371 rl_backward_word (1, key);
1373 rl_backward_word (count, key);
1375 rl_forward_word (1, key);
1378 /* Do some check to make sure that there really are two words. */
1379 if ((w1_beg == w2_beg) || (w2_beg < w1_end))
1382 rl_point = orig_point;
1386 /* Get the text of the words. */
1387 word1 = rl_copy_text (w1_beg, w1_end);
1388 word2 = rl_copy_text (w2_beg, w2_end);
1390 /* We are about to do many insertions and deletions. Remember them
1391 as one operation. */
1392 rl_begin_undo_group ();
1394 /* Do the stuff at word2 first, so that we don't have to worry
1395 about word1 moving. */
1397 rl_delete_text (w2_beg, w2_end);
1398 rl_insert_text (word1);
1401 rl_delete_text (w1_beg, w1_end);
1402 rl_insert_text (word2);
1404 /* This is exactly correct since the text before this point has not
1405 changed in length. */
1408 /* I think that does it. */
1409 rl_end_undo_group ();
1416 /* Transpose the characters at point. If point is at the end of the line,
1417 then transpose the characters before point. */
1419 rl_transpose_chars (count, key)
1422 #if defined (HANDLE_MULTIBYTE)
1428 int char_length, prev_point;
1433 if (!rl_point || rl_end < 2)
1439 rl_begin_undo_group ();
1441 if (rl_point == rl_end)
1443 rl_point = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_NONZERO);
1447 prev_point = rl_point;
1448 rl_point = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_NONZERO);
1450 #if defined (HANDLE_MULTIBYTE)
1451 char_length = prev_point - rl_point;
1452 dummy = (char *)xmalloc (char_length + 1);
1453 for (i = 0; i < char_length; i++)
1454 dummy[i] = rl_line_buffer[rl_point + i];
1457 dummy[0] = rl_line_buffer[rl_point];
1458 dummy[char_length = 1] = '\0';
1461 rl_delete_text (rl_point, rl_point + char_length);
1463 rl_point = _rl_find_next_mbchar (rl_line_buffer, rl_point, count, MB_FIND_NONZERO);
1466 rl_insert_text (dummy);
1467 rl_end_undo_group ();
1469 #if defined (HANDLE_MULTIBYTE)
1476 /* **************************************************************** */
1478 /* Character Searching */
1480 /* **************************************************************** */
1483 #if defined (HANDLE_MULTIBYTE)
1484 _rl_char_search_internal (count, dir, smbchar, len)
1489 _rl_char_search_internal (count, dir, schar)
1490 int count, dir, schar;
1494 #if defined (HANDLE_MULTIBYTE)
1499 inc = (dir < 0) ? -1 : 1;
1502 if ((dir < 0 && pos <= 0) || (dir > 0 && pos >= rl_end))
1508 #if defined (HANDLE_MULTIBYTE)
1509 pos = (inc > 0) ? _rl_find_next_mbchar (rl_line_buffer, pos, 1, MB_FIND_ANY)
1510 : _rl_find_prev_mbchar (rl_line_buffer, pos, MB_FIND_ANY);
1516 #if defined (HANDLE_MULTIBYTE)
1517 if (_rl_is_mbchar_matched (rl_line_buffer, pos, rl_end, smbchar, len))
1519 if (rl_line_buffer[pos] == schar)
1524 rl_point = (dir == BTO) ? _rl_find_next_mbchar (rl_line_buffer, pos, 1, MB_FIND_ANY)
1527 rl_point = (dir == FTO) ? _rl_find_prev_mbchar (rl_line_buffer, pos, MB_FIND_ANY)
1531 #if defined (HANDLE_MULTIBYTE)
1535 #if defined (HANDLE_MULTIBYTE)
1536 while ((dir < 0) ? (pos = _rl_find_prev_mbchar (rl_line_buffer, pos, MB_FIND_ANY)) != prepos
1537 : (pos = _rl_find_next_mbchar (rl_line_buffer, pos, 1, MB_FIND_ANY)) != prepos);
1539 while ((dir < 0) ? pos-- : ++pos < rl_end);
1545 /* Search COUNT times for a character read from the current input stream.
1546 FDIR is the direction to search if COUNT is non-negative; otherwise
1547 the search goes in BDIR. So much is dependent on HANDLE_MULTIBYTE
1548 that there are two separate versions of this function. */
1549 #if defined (HANDLE_MULTIBYTE)
1551 _rl_char_search (count, fdir, bdir)
1552 int count, fdir, bdir;
1554 char mbchar[MB_LEN_MAX];
1557 mb_len = _rl_read_mbchar (mbchar, MB_LEN_MAX);
1563 return (_rl_char_search_internal (-count, bdir, mbchar, mb_len));
1565 return (_rl_char_search_internal (count, fdir, mbchar, mb_len));
1567 #else /* !HANDLE_MULTIBYTE */
1569 _rl_char_search (count, fdir, bdir)
1570 int count, fdir, bdir;
1574 RL_SETSTATE(RL_STATE_MOREINPUT);
1576 RL_UNSETSTATE(RL_STATE_MOREINPUT);
1582 return (_rl_char_search_internal (-count, bdir, c));
1584 return (_rl_char_search_internal (count, fdir, c));
1586 #endif /* !HANDLE_MULTIBYTE */
1588 #if defined (READLINE_CALLBACKS)
1590 _rl_char_search_callback (data)
1591 _rl_callback_generic_arg *data;
1593 _rl_callback_func = 0;
1594 _rl_want_redisplay = 1;
1596 return (_rl_char_search (data->count, data->i1, data->i2));
1601 rl_char_search (count, key)
1604 #if defined (READLINE_CALLBACKS)
1605 if (RL_ISSTATE (RL_STATE_CALLBACK))
1607 _rl_callback_data = _rl_callback_data_alloc (count);
1608 _rl_callback_data->i1 = FFIND;
1609 _rl_callback_data->i2 = BFIND;
1610 _rl_callback_func = _rl_char_search_callback;
1615 return (_rl_char_search (count, FFIND, BFIND));
1619 rl_backward_char_search (count, key)
1622 #if defined (READLINE_CALLBACKS)
1623 if (RL_ISSTATE (RL_STATE_CALLBACK))
1625 _rl_callback_data = _rl_callback_data_alloc (count);
1626 _rl_callback_data->i1 = BFIND;
1627 _rl_callback_data->i2 = FFIND;
1628 _rl_callback_func = _rl_char_search_callback;
1633 return (_rl_char_search (count, BFIND, FFIND));
1636 /* **************************************************************** */
1638 /* The Mark and the Region. */
1640 /* **************************************************************** */
1642 /* Set the mark at POSITION. */
1644 _rl_set_mark_at_pos (position)
1647 if (position > rl_end)
1654 /* A bindable command to set the mark. */
1656 rl_set_mark (count, key)
1659 return (_rl_set_mark_at_pos (rl_explicit_arg ? count : rl_point));
1662 /* Exchange the position of mark and point. */
1664 rl_exchange_point_and_mark (count, key)
1667 if (rl_mark > rl_end)
1676 SWAP (rl_point, rl_mark);