readline/text.c

   1 /* text.c -- text handling commands for readline. */
   2
   3 /* Copyright (C) 1987-2010 Free Software Foundation, Inc.
   4
   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.
   7
   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.
  12
  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.
  17
  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/>.
  20 */
  21
  22 #define READLINE_LIBRARY
  23
  24 #if defined (HAVE_CONFIG_H)
  25 #  include <config.h>
  26 #endif
  27
  28 #if defined (HAVE_UNISTD_H)
  29 #  include <unistd.h>
  30 #endif /* HAVE_UNISTD_H */
  31
  32 #if defined (HAVE_STDLIB_H)
  33 #  include <stdlib.h>
  34 #else
  35 #  include "ansi_stdlib.h"
  36 #endif /* HAVE_STDLIB_H */
  37
  38 #if defined (HAVE_LOCALE_H)
  39 #  include <locale.h>
  40 #endif
  41
  42 #include <stdio.h>
  43
  44 /* System-specific feature definitions and include files. */
  45 #include "rldefs.h"
  46 #include "rlmbutil.h"
  47
  48 #if defined (__EMX__)
  49 #  define INCL_DOSPROCESS
  50 #  include <os2.h>
  51 #endif /* __EMX__ */
  52
  53 /* Some standard library routines. */
  54 #include "readline.h"
  55 #include "history.h"
  56
  57 #include "rlprivate.h"
  58 #include "rlshell.h"
  59 #include "xmalloc.h"
  60
  61 /* Forward declarations. */
  62 static int rl_change_case PARAMS((int, int));
  63 static int _rl_char_search PARAMS((int, int, int));
  64
  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 *));
  68 #endif
  69
  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
  73
  74 /* **************************************************************** */
  75 /*                                                                  */
  76 /*                      Insert and Delete                           */
  77 /*                                                                  */
  78 /* **************************************************************** */
  79
  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. */
  83 int
  84 rl_insert_text (string)
  85      const char *string;
  86 {
  87   register int i, l;
  88
  89   l = (string && *string) ? strlen (string) : 0;
  90   if (l == 0)
  91     return 0;
  92
  93   if (rl_end + l >= rl_line_buffer_len)
  94     rl_extend_line_buffer (rl_end + l);
  95
  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);
  99
 100   /* Remember how to undo this if we aren't undoing something. */
 101   if (_rl_doing_an_undo == 0)
 102     {
 103       /* If possible and desirable, concatenate the undos. */
 104       if ((l == 1) &&
 105           rl_undo_list &&
 106           (rl_undo_list->what == UNDO_INSERT) &&
 107           (rl_undo_list->end == rl_point) &&
 108           (rl_undo_list->end - rl_undo_list->start < 20))
 109         rl_undo_list->end++;
 110       else
 111         rl_add_undo (UNDO_INSERT, rl_point, rl_point + l, (char *)NULL);
 112     }
 113   rl_point += l;
 114   rl_end += l;
 115   rl_line_buffer[rl_end] = '\0';
 116   return l;
 117 }
 118
 119 /* Delete the string between FROM and TO.  FROM is inclusive, TO is not.
 120    Returns the number of characters deleted. */
 121 int
 122 rl_delete_text (from, to)
 123      int from, to;
 124 {
 125   register char *text;
 126   register int diff, i;
 127
 128   /* Fix it if the caller is confused. */
 129   if (from > to)
 130     SWAP (from, to);
 131
 132   /* fix boundaries */
 133   if (to > rl_end)
 134     {
 135       to = rl_end;
 136       if (from > to)
 137         from = to;
 138     }
 139   if (from < 0)
 140     from = 0;
 141
 142   text = rl_copy_text (from, to);
 143
 144   /* Some versions of strncpy() can't handle overlapping arguments. */
 145   diff = to - from;
 146   for (i = from; i < rl_end - diff; i++)
 147     rl_line_buffer[i] = rl_line_buffer[i + diff];
 148
 149   /* Remember how to undo this delete. */
 150   if (_rl_doing_an_undo == 0)
 151     rl_add_undo (UNDO_DELETE, from, to, text);
 152   else
 153     xfree (text);
 154
 155   rl_end -= diff;
 156   rl_line_buffer[rl_end] = '\0';
 157   return (diff);
 158 }
 159
 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
 162    boundaries also. */
 163
 164 #define _RL_FIX_POINT(x) \
 165         do { \
 166         if (x > rl_end) \
 167           x = rl_end; \
 168         else if (x < 0) \
 169           x = 0; \
 170         } while (0)
 171
 172 void
 173 _rl_fix_point (fix_mark_too)
 174      int fix_mark_too;
 175 {
 176   _RL_FIX_POINT (rl_point);
 177   if (fix_mark_too)
 178     _RL_FIX_POINT (rl_mark);
 179 }
 180 #undef _RL_FIX_POINT
 181
 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); */
 185 int
 186 _rl_replace_text (text, start, end)
 187      const char *text;
 188      int start, end;
 189 {
 190   int n;
 191
 192   n = 0;
 193   rl_begin_undo_group ();
 194   if (start <= end)
 195     rl_delete_text (start, end + 1);
 196   rl_point = start;
 197   if (*text)
 198     n = rl_insert_text (text);
 199   rl_end_undo_group ();
 200
 201   return n;
 202 }
 203
 204 /* Replace the current line buffer contents with TEXT.  If CLEAR_UNDO is
 205    non-zero, we free the current undo list. */
 206 void
 207 rl_replace_line (text, clear_undo)
 208      const char *text;
 209      int clear_undo;
 210 {
 211   int len;
 212
 213   len = strlen (text);
 214   if (len >= rl_line_buffer_len)
 215     rl_extend_line_buffer (len);
 216   strcpy (rl_line_buffer, text);
 217   rl_end = len;
 218
 219   if (clear_undo)
 220     rl_free_undo_list ();
 221
 222   _rl_fix_point (1);
 223 }
 224
 225 /* **************************************************************** */
 226 /*                                                                  */
 227 /*                      Readline character functions                */
 228 /*                                                                  */
 229 /* **************************************************************** */
 230
 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. */
 233
 234 /* Note that:
 235
 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.
 238
 239    rl_point is the place in the string where the cursor is.  Sometimes
 240    this is the same as rl_end.
 241
 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.
 245 */
 246
 247 /* **************************************************************** */
 248 /*                                                                  */
 249 /*                      Movement Commands                           */
 250 /*                                                                  */
 251 /* **************************************************************** */
 252
 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. */
 257
 258 /* Move forward COUNT bytes. */
 259 int
 260 rl_forward_byte (count, key)
 261      int count, key;
 262 {
 263   if (count < 0)
 264     return (rl_backward_byte (-count, key));
 265
 266   if (count > 0)
 267     {
 268       int end, lend;
 269
 270       end = rl_point + count;
 271 #if defined (VI_MODE)
 272       lend = rl_end > 0 ? rl_end - (VI_COMMAND_MODE()) : rl_end;
 273 #else
 274       lend = rl_end;
 275 #endif
 276
 277       if (end > lend)
 278         {
 279           rl_point = lend;
 280           rl_ding ();
 281         }
 282       else
 283         rl_point = end;
 284     }
 285
 286   if (rl_end < 0)
 287     rl_end = 0;
 288
 289   return 0;
 290 }
 291
 292 int
 293 _rl_forward_char_internal (count)
 294      int count;
 295 {
 296   int point;
 297
 298 #if defined (HANDLE_MULTIBYTE)
 299   point = _rl_find_next_mbchar (rl_line_buffer, rl_point, count, MB_FIND_NONZERO);
 300
 301 #if defined (VI_MODE)
 302   if (point >= rl_end && VI_COMMAND_MODE())
 303     point = _rl_find_prev_mbchar (rl_line_buffer, rl_end, MB_FIND_NONZERO);
 304 #endif
 305
 306     if (rl_end < 0)
 307         rl_end = 0;
 308 #else
 309   point = rl_point + count;
 310   if (point > rl_end)
 311     point = rl_end;
 312 #endif
 313
 314   return (point);
 315 }
 316
 317 #if defined (HANDLE_MULTIBYTE)
 318 /* Move forward COUNT characters. */
 319 int
 320 rl_forward_char (count, key)
 321      int count, key;
 322 {
 323   int point;
 324
 325   if (MB_CUR_MAX == 1 || rl_byte_oriented)
 326     return (rl_forward_byte (count, key));
 327
 328   if (count < 0)
 329     return (rl_backward_char (-count, key));
 330
 331   if (count > 0)
 332     {
 333       if (rl_point == rl_end && EMACS_MODE())
 334         {
 335           rl_ding ();
 336           return 0;
 337         }
 338
 339       point = _rl_forward_char_internal (count);
 340
 341       if (rl_point == point)
 342         rl_ding ();
 343
 344       rl_point = point;
 345     }
 346
 347   return 0;
 348 }
 349 #else /* !HANDLE_MULTIBYTE */
 350 int
 351 rl_forward_char (count, key)
 352      int count, key;
 353 {
 354   return (rl_forward_byte (count, key));
 355 }
 356 #endif /* !HANDLE_MULTIBYTE */
 357
 358 /* Backwards compatibility. */
 359 int
 360 rl_forward (count, key)
 361      int count, key;
 362 {
 363   return (rl_forward_char (count, key));
 364 }
 365
 366 /* Move backward COUNT bytes. */
 367 int
 368 rl_backward_byte (count, key)
 369      int count, key;
 370 {
 371   if (count < 0)
 372     return (rl_forward_byte (-count, key));
 373
 374   if (count > 0)
 375     {
 376       if (rl_point < count)
 377         {
 378           rl_point = 0;
 379           rl_ding ();
 380         }
 381       else
 382         rl_point -= count;
 383     }
 384
 385   if (rl_point < 0)
 386     rl_point = 0;
 387
 388   return 0;
 389 }
 390
 391 #if defined (HANDLE_MULTIBYTE)
 392 /* Move backward COUNT characters. */
 393 int
 394 rl_backward_char (count, key)
 395      int count, key;
 396 {
 397   int point;
 398
 399   if (MB_CUR_MAX == 1 || rl_byte_oriented)
 400     return (rl_backward_byte (count, key));
 401
 402   if (count < 0)
 403     return (rl_forward_char (-count, key));
 404
 405   if (count > 0)
 406     {
 407       point = rl_point;
 408
 409       while (count > 0 && point > 0)
 410         {
 411           point = _rl_find_prev_mbchar (rl_line_buffer, point, MB_FIND_NONZERO);
 412           count--;
 413         }
 414       if (count > 0)
 415         {
 416           rl_point = 0;
 417           rl_ding ();
 418         }
 419       else
 420         rl_point = point;
 421     }
 422
 423   return 0;
 424 }
 425 #else
 426 int
 427 rl_backward_char (count, key)
 428      int count, key;
 429 {
 430   return (rl_backward_byte (count, key));
 431 }
 432 #endif
 433
 434 /* Backwards compatibility. */
 435 int
 436 rl_backward (count, key)
 437      int count, key;
 438 {
 439   return (rl_backward_char (count, key));
 440 }
 441
 442 /* Move to the beginning of the line. */
 443 int
 444 rl_beg_of_line (count, key)
 445      int count, key;
 446 {
 447   rl_point = 0;
 448   return 0;
 449 }
 450
 451 /* Move to the end of the line. */
 452 int
 453 rl_end_of_line (count, key)
 454      int count, key;
 455 {
 456   rl_point = rl_end;
 457   return 0;
 458 }
 459
 460 /* Move forward a word.  We do what Emacs does.  Handles multibyte chars. */
 461 int
 462 rl_forward_word (count, key)
 463      int count, key;
 464 {
 465   int c;
 466
 467   if (count < 0)
 468     return (rl_backward_word (-count, key));
 469
 470   while (count)
 471     {
 472       if (rl_point == rl_end)
 473         return 0;
 474
 475       /* If we are not in a word, move forward until we are in one.
 476          Then, move forward until we hit a non-alphabetic character. */
 477       c = _rl_char_value (rl_line_buffer, rl_point);
 478
 479       if (_rl_walphabetic (c) == 0)
 480         {
 481           rl_point = MB_NEXTCHAR (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
 482           while (rl_point < rl_end)
 483             {
 484               c = _rl_char_value (rl_line_buffer, rl_point);
 485               if (_rl_walphabetic (c))
 486                 break;
 487               rl_point = MB_NEXTCHAR (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
 488             }
 489         }
 490
 491       if (rl_point == rl_end)
 492         return 0;
 493
 494       rl_point = MB_NEXTCHAR (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
 495       while (rl_point < rl_end)
 496         {
 497           c = _rl_char_value (rl_line_buffer, rl_point);
 498           if (_rl_walphabetic (c) == 0)
 499             break;
 500           rl_point = MB_NEXTCHAR (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
 501         }
 502
 503       --count;
 504     }
 505
 506   return 0;
 507 }
 508
 509 /* Move backward a word.  We do what Emacs does.  Handles multibyte chars. */
 510 int
 511 rl_backward_word (count, key)
 512      int count, key;
 513 {
 514   int c, p;
 515
 516   if (count < 0)
 517     return (rl_forward_word (-count, key));
 518
 519   while (count)
 520     {
 521       if (rl_point == 0)
 522         return 0;
 523
 524       /* Like rl_forward_word (), except that we look at the characters
 525          just before point. */
 526
 527       p = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_NONZERO);
 528       c = _rl_char_value (rl_line_buffer, p);
 529
 530       if (_rl_walphabetic (c) == 0)
 531         {
 532           rl_point = p;
 533           while (rl_point > 0)
 534             {
 535               p = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_NONZERO);
 536               c = _rl_char_value (rl_line_buffer, p);
 537               if (_rl_walphabetic (c))
 538                 break;
 539               rl_point = p;
 540             }
 541         }
 542
 543       while (rl_point)
 544         {
 545           p = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_NONZERO);
 546           c = _rl_char_value (rl_line_buffer, p);
 547           if (_rl_walphabetic (c) == 0)
 548             break;
 549           else
 550             rl_point = p;
 551         }
 552
 553       --count;
 554     }
 555
 556   return 0;
 557 }
 558
 559 /* Clear the current line.  Numeric argument to C-l does this. */
 560 int
 561 rl_refresh_line (ignore1, ignore2)
 562      int ignore1, ignore2;
 563 {
 564   int curr_line;
 565
 566   curr_line = _rl_current_display_line ();
 567
 568   _rl_move_vert (curr_line);
 569   _rl_move_cursor_relative (0, rl_line_buffer);   /* XXX is this right */
 570
 571   _rl_clear_to_eol (0);         /* arg of 0 means to not use spaces */
 572
 573   rl_forced_update_display ();
 574   rl_display_fixed = 1;
 575
 576   return 0;
 577 }
 578
 579 /* C-l typed to a line without quoting clears the screen, and then reprints
 580    the prompt and the current input line.  Given a numeric arg, redraw only
 581    the current line. */
 582 int
 583 rl_clear_screen (count, key)
 584      int count, key;
 585 {
 586   if (rl_explicit_arg)
 587     {
 588       rl_refresh_line (count, key);
 589       return 0;
 590     }
 591
 592   _rl_clear_screen ();          /* calls termcap function to clear screen */
 593   rl_forced_update_display ();
 594   rl_display_fixed = 1;
 595
 596   return 0;
 597 }
 598
 599 int
 600 rl_skip_csi_sequence (count, key)
 601      int count, key;
 602 {
 603   int ch;
 604
 605   RL_SETSTATE (RL_STATE_MOREINPUT);
 606   do
 607     ch = rl_read_key ();
 608   while (ch >= 0x20 && ch < 0x40);
 609   RL_UNSETSTATE (RL_STATE_MOREINPUT);
 610
 611   return 0;
 612 }
 613
 614 int
 615 rl_arrow_keys (count, c)
 616      int count, c;
 617 {
 618   int ch;
 619
 620   RL_SETSTATE(RL_STATE_MOREINPUT);
 621   ch = rl_read_key ();
 622   RL_UNSETSTATE(RL_STATE_MOREINPUT);
 623
 624   switch (_rl_to_upper (ch))
 625     {
 626     case 'A':
 627       rl_get_previous_history (count, ch);
 628       break;
 629
 630     case 'B':
 631       rl_get_next_history (count, ch);
 632       break;
 633
 634     case 'C':
 635       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 636         rl_forward_char (count, ch);
 637       else
 638         rl_forward_byte (count, ch);
 639       break;
 640
 641     case 'D':
 642       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 643         rl_backward_char (count, ch);
 644       else
 645         rl_backward_byte (count, ch);
 646       break;
 647
 648     default:
 649       rl_ding ();
 650     }
 651
 652   return 0;
 653 }
 654
 655 /* **************************************************************** */
 656 /*                                                                  */
 657 /*                      Text commands                               */
 658 /*                                                                  */
 659 /* **************************************************************** */
 660
 661 #ifdef HANDLE_MULTIBYTE
 662 static char pending_bytes[MB_LEN_MAX];
 663 static int pending_bytes_length = 0;
 664 static mbstate_t ps = {0};
 665 #endif
 666
 667 /* Insert the character C at the current location, moving point forward.
 668    If C introduces a multibyte sequence, we read the whole sequence and
 669    then insert the multibyte char into the line buffer. */
 670 int
 671 _rl_insert_char (count, c)
 672      int count, c;
 673 {
 674   register int i;
 675   char *string;
 676 #ifdef HANDLE_MULTIBYTE
 677   int string_size;
 678   char incoming[MB_LEN_MAX + 1];
 679   int incoming_length = 0;
 680   mbstate_t ps_back;
 681   static int stored_count = 0;
 682 #endif
 683
 684   if (count <= 0)
 685     return 0;
 686
 687 #if defined (HANDLE_MULTIBYTE)
 688   if (MB_CUR_MAX == 1 || rl_byte_oriented)
 689     {
 690       incoming[0] = c;
 691       incoming[1] = '\0';
 692       incoming_length = 1;
 693     }
 694   else
 695     {
 696       wchar_t wc;
 697       size_t ret;
 698
 699       if (stored_count <= 0)
 700         stored_count = count;
 701       else
 702         count = stored_count;
 703
 704       ps_back = ps;
 705       pending_bytes[pending_bytes_length++] = c;
 706       ret = mbrtowc (&wc, pending_bytes, pending_bytes_length, &ps);
 707
 708       if (ret == (size_t)-2)
 709         {
 710           /* Bytes too short to compose character, try to wait for next byte.
 711              Restore the state of the byte sequence, because in this case the
 712              effect of mbstate is undefined. */
 713           ps = ps_back;
 714           return 1;
 715         }
 716       else if (ret == (size_t)-1)
 717         {
 718           /* Invalid byte sequence for the current locale.  Treat first byte
 719              as a single character. */
 720           incoming[0] = pending_bytes[0];
 721           incoming[1] = '\0';
 722           incoming_length = 1;
 723           pending_bytes_length--;
 724           memmove (pending_bytes, pending_bytes + 1, pending_bytes_length);
 725           /* Clear the state of the byte sequence, because in this case the
 726              effect of mbstate is undefined. */
 727           memset (&ps, 0, sizeof (mbstate_t));
 728         }
 729       else if (ret == (size_t)0)
 730         {
 731           incoming[0] = '\0';
 732           incoming_length = 0;
 733           pending_bytes_length--;
 734           /* Clear the state of the byte sequence, because in this case the
 735              effect of mbstate is undefined. */
 736           memset (&ps, 0, sizeof (mbstate_t));
 737         }
 738       else
 739         {
 740           /* We successfully read a single multibyte character. */
 741           memcpy (incoming, pending_bytes, pending_bytes_length);
 742           incoming[pending_bytes_length] = '\0';
 743           incoming_length = pending_bytes_length;
 744           pending_bytes_length = 0;
 745         }
 746     }
 747 #endif /* HANDLE_MULTIBYTE */
 748
 749   /* If we can optimize, then do it.  But don't let people crash
 750      readline because of extra large arguments. */
 751   if (count > 1 && count <= TEXT_COUNT_MAX)
 752     {
 753 #if defined (HANDLE_MULTIBYTE)
 754       string_size = count * incoming_length;
 755       string = (char *)xmalloc (1 + string_size);
 756
 757       i = 0;
 758       while (i < string_size)
 759         {
 760           strncpy (string + i, incoming, incoming_length);
 761           i += incoming_length;
 762         }
 763       incoming_length = 0;
 764       stored_count = 0;
 765 #else /* !HANDLE_MULTIBYTE */
 766       string = (char *)xmalloc (1 + count);
 767
 768       for (i = 0; i < count; i++)
 769         string[i] = c;
 770 #endif /* !HANDLE_MULTIBYTE */
 771
 772       string[i] = '\0';
 773       rl_insert_text (string);
 774       xfree (string);
 775
 776       return 0;
 777     }
 778
 779   if (count > TEXT_COUNT_MAX)
 780     {
 781       int decreaser;
 782 #if defined (HANDLE_MULTIBYTE)
 783       string_size = incoming_length * TEXT_COUNT_MAX;
 784       string = (char *)xmalloc (1 + string_size);
 785
 786       i = 0;
 787       while (i < string_size)
 788         {
 789           strncpy (string + i, incoming, incoming_length);
 790           i += incoming_length;
 791         }
 792
 793       while (count)
 794         {
 795           decreaser = (count > TEXT_COUNT_MAX) ? TEXT_COUNT_MAX : count;
 796           string[decreaser*incoming_length] = '\0';
 797           rl_insert_text (string);
 798           count -= decreaser;
 799         }
 800
 801       xfree (string);
 802       incoming_length = 0;
 803       stored_count = 0;
 804 #else /* !HANDLE_MULTIBYTE */
 805       char str[TEXT_COUNT_MAX+1];
 806
 807       for (i = 0; i < TEXT_COUNT_MAX; i++)
 808         str[i] = c;
 809
 810       while (count)
 811         {
 812           decreaser = (count > TEXT_COUNT_MAX ? TEXT_COUNT_MAX : count);
 813           str[decreaser] = '\0';
 814           rl_insert_text (str);
 815           count -= decreaser;
 816         }
 817 #endif /* !HANDLE_MULTIBYTE */
 818
 819       return 0;
 820     }
 821
 822   if (MB_CUR_MAX == 1 || rl_byte_oriented)
 823     {
 824       /* We are inserting a single character.
 825          If there is pending input, then make a string of all of the
 826          pending characters that are bound to rl_insert, and insert
 827          them all.  Don't do this if we're current reading input from
 828          a macro. */
 829       if ((RL_ISSTATE (RL_STATE_MACROINPUT) == 0) && _rl_any_typein ())
 830         _rl_insert_typein (c);
 831       else
 832         {
 833           /* Inserting a single character. */
 834           char str[2];
 835
 836           str[1] = '\0';
 837           str[0] = c;
 838           rl_insert_text (str);
 839         }
 840     }
 841 #if defined (HANDLE_MULTIBYTE)
 842   else
 843     {
 844       rl_insert_text (incoming);
 845       stored_count = 0;
 846     }
 847 #endif
 848
 849   return 0;
 850 }
 851
 852 /* Overwrite the character at point (or next COUNT characters) with C.
 853    If C introduces a multibyte character sequence, read the entire sequence
 854    before starting the overwrite loop. */
 855 int
 856 _rl_overwrite_char (count, c)
 857      int count, c;
 858 {
 859   int i;
 860 #if defined (HANDLE_MULTIBYTE)
 861   char mbkey[MB_LEN_MAX];
 862   int k;
 863
 864   /* Read an entire multibyte character sequence to insert COUNT times. */
 865   if (count > 0 && MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 866     k = _rl_read_mbstring (c, mbkey, MB_LEN_MAX);
 867 #endif
 868
 869   rl_begin_undo_group ();
 870
 871   for (i = 0; i < count; i++)
 872     {
 873 #if defined (HANDLE_MULTIBYTE)
 874       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 875         rl_insert_text (mbkey);
 876       else
 877 #endif
 878         _rl_insert_char (1, c);
 879
 880       if (rl_point < rl_end)
 881         rl_delete (1, c);
 882     }
 883
 884   rl_end_undo_group ();
 885
 886   return 0;
 887 }
 888
 889 int
 890 rl_insert (count, c)
 891      int count, c;
 892 {
 893   return (rl_insert_mode == RL_IM_INSERT ? _rl_insert_char (count, c)
 894                                          : _rl_overwrite_char (count, c));
 895 }
 896
 897 /* Insert the next typed character verbatim. */
 898 static int
 899 _rl_insert_next (count)
 900      int count;
 901 {
 902   int c;
 903
 904   RL_SETSTATE(RL_STATE_MOREINPUT);
 905   c = rl_read_key ();
 906   RL_UNSETSTATE(RL_STATE_MOREINPUT);
 907
 908   if (c < 0)
 909     return -1;
 910
 911 #if defined (HANDLE_SIGNALS)
 912   if (RL_ISSTATE (RL_STATE_CALLBACK) == 0)
 913     _rl_restore_tty_signals ();
 914 #endif
 915
 916   return (_rl_insert_char (count, c));
 917 }
 918
 919 #if defined (READLINE_CALLBACKS)
 920 static int
 921 _rl_insert_next_callback (data)
 922      _rl_callback_generic_arg *data;
 923 {
 924   int count;
 925
 926   count = data->count;
 927
 928   /* Deregister function, let rl_callback_read_char deallocate data */
 929   _rl_callback_func = 0;
 930   _rl_want_redisplay = 1;
 931
 932   return _rl_insert_next (count);
 933 }
 934 #endif
 935
 936 int
 937 rl_quoted_insert (count, key)
 938      int count, key;
 939 {
 940   /* Let's see...should the callback interface futz with signal handling? */
 941 #if defined (HANDLE_SIGNALS)
 942   if (RL_ISSTATE (RL_STATE_CALLBACK) == 0)
 943     _rl_disable_tty_signals ();
 944 #endif
 945
 946 #if defined (READLINE_CALLBACKS)
 947   if (RL_ISSTATE (RL_STATE_CALLBACK))
 948     {
 949       _rl_callback_data = _rl_callback_data_alloc (count);
 950       _rl_callback_func = _rl_insert_next_callback;
 951       return (0);
 952     }
 953 #endif
 954
 955   return _rl_insert_next (count);
 956 }
 957
 958 /* Insert a tab character. */
 959 int
 960 rl_tab_insert (count, key)
 961      int count, key;
 962 {
 963   return (_rl_insert_char (count, '\t'));
 964 }
 965
 966 /* What to do when a NEWLINE is pressed.  We accept the whole line.
 967    KEY is the key that invoked this command.  I guess it could have
 968    meaning in the future. */
 969 int
 970 rl_newline (count, key)
 971      int count, key;
 972 {
 973   rl_done = 1;
 974
 975   if (_rl_history_preserve_point)
 976     _rl_history_saved_point = (rl_point == rl_end) ? -1 : rl_point;
 977
 978   RL_SETSTATE(RL_STATE_DONE);
 979
 980 #if defined (VI_MODE)
 981   if (rl_editing_mode == vi_mode)
 982     {
 983       _rl_vi_done_inserting ();
 984       if (_rl_vi_textmod_command (_rl_vi_last_command) == 0)    /* XXX */
 985         _rl_vi_reset_last ();
 986     }
 987 #endif /* VI_MODE */
 988
 989   /* If we've been asked to erase empty lines, suppress the final update,
 990      since _rl_update_final calls rl_crlf(). */
 991   if (rl_erase_empty_line && rl_point == 0 && rl_end == 0)
 992     return 0;
 993
 994   if (_rl_echoing_p)
 995     _rl_update_final ();
 996   return 0;
 997 }
 998
 999 /* What to do for some uppercase characters, like meta characters,
1000    and some characters appearing in emacs_ctlx_keymap.  This function
1001    is just a stub, you bind keys to it and the code in _rl_dispatch ()
1002    is special cased. */
1003 int
1004 rl_do_lowercase_version (ignore1, ignore2)
1005      int ignore1, ignore2;
1006 {
1007   return 0;
1008 }
1009
1010 /* This is different from what vi does, so the code's not shared.  Emacs
1011    rubout in overwrite mode has one oddity:  it replaces a control
1012    character that's displayed as two characters (^X) with two spaces. */
1013 int
1014 _rl_overwrite_rubout (count, key)
1015      int count, key;
1016 {
1017   int opoint;
1018   int i, l;
1019
1020   if (rl_point == 0)
1021     {
1022       rl_ding ();
1023       return 1;
1024     }
1025
1026   opoint = rl_point;
1027
1028   /* L == number of spaces to insert */
1029   for (i = l = 0; i < count; i++)
1030     {
1031       rl_backward_char (1, key);
1032       l += rl_character_len (rl_line_buffer[rl_point], rl_point);       /* not exactly right */
1033     }
1034
1035   rl_begin_undo_group ();
1036
1037   if (count > 1 || rl_explicit_arg)
1038     rl_kill_text (opoint, rl_point);
1039   else
1040     rl_delete_text (opoint, rl_point);
1041
1042   /* Emacs puts point at the beginning of the sequence of spaces. */
1043   if (rl_point < rl_end)
1044     {
1045       opoint = rl_point;
1046       _rl_insert_char (l, ' ');
1047       rl_point = opoint;
1048     }
1049
1050   rl_end_undo_group ();
1051
1052   return 0;
1053 }
1054
1055 /* Rubout the character behind point. */
1056 int
1057 rl_rubout (count, key)
1058      int count, key;
1059 {
1060   if (count < 0)
1061     return (rl_delete (-count, key));
1062
1063   if (!rl_point)
1064     {
1065       rl_ding ();
1066       return -1;
1067     }
1068
1069   if (rl_insert_mode == RL_IM_OVERWRITE)
1070     return (_rl_overwrite_rubout (count, key));
1071
1072   return (_rl_rubout_char (count, key));
1073 }
1074
1075 int
1076 _rl_rubout_char (count, key)
1077      int count, key;
1078 {
1079   int orig_point;
1080   unsigned char c;
1081
1082   /* Duplicated code because this is called from other parts of the library. */
1083   if (count < 0)
1084     return (rl_delete (-count, key));
1085
1086   if (rl_point == 0)
1087     {
1088       rl_ding ();
1089       return -1;
1090     }
1091
1092   orig_point = rl_point;
1093   if (count > 1 || rl_explicit_arg)
1094     {
1095       rl_backward_char (count, key);
1096       rl_kill_text (orig_point, rl_point);
1097     }
1098   else if (MB_CUR_MAX == 1 || rl_byte_oriented)
1099     {
1100       c = rl_line_buffer[--rl_point];
1101       rl_delete_text (rl_point, orig_point);
1102       /* The erase-at-end-of-line hack is of questionable merit now. */
1103       if (rl_point == rl_end && ISPRINT (c) && _rl_last_c_pos)
1104         {
1105           int l;
1106           l = rl_character_len (c, rl_point);
1107           _rl_erase_at_end_of_line (l);
1108         }
1109     }
1110   else
1111     {
1112       rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_NONZERO);
1113       rl_delete_text (rl_point, orig_point);
1114     }
1115
1116   return 0;
1117 }
1118
1119 /* Delete the character under the cursor.  Given a numeric argument,
1120    kill that many characters instead. */
1121 int
1122 rl_delete (count, key)
1123      int count, key;
1124 {
1125   int xpoint;
1126
1127   if (count < 0)
1128     return (_rl_rubout_char (-count, key));
1129
1130   if (rl_point == rl_end)
1131     {
1132       rl_ding ();
1133       return -1;
1134     }
1135
1136   if (count > 1 || rl_explicit_arg)
1137     {
1138       xpoint = rl_point;
1139       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1140         rl_forward_char (count, key);
1141       else
1142         rl_forward_byte (count, key);
1143
1144       rl_kill_text (xpoint, rl_point);
1145       rl_point = xpoint;
1146     }
1147   else
1148     {
1149       xpoint = MB_NEXTCHAR (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
1150       rl_delete_text (rl_point, xpoint);
1151     }
1152   return 0;
1153 }
1154
1155 /* Delete the character under the cursor, unless the insertion
1156    point is at the end of the line, in which case the character
1157    behind the cursor is deleted.  COUNT is obeyed and may be used
1158    to delete forward or backward that many characters. */
1159 int
1160 rl_rubout_or_delete (count, key)
1161      int count, key;
1162 {
1163   if (rl_end != 0 && rl_point == rl_end)
1164     return (_rl_rubout_char (count, key));
1165   else
1166     return (rl_delete (count, key));
1167 }
1168
1169 /* Delete all spaces and tabs around point. */
1170 int
1171 rl_delete_horizontal_space (count, ignore)
1172      int count, ignore;
1173 {
1174   int start;
1175
1176   while (rl_point && whitespace (rl_line_buffer[rl_point - 1]))
1177     rl_point--;
1178
1179   start = rl_point;
1180
1181   while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
1182     rl_point++;
1183
1184   if (start != rl_point)
1185     {
1186       rl_delete_text (start, rl_point);
1187       rl_point = start;
1188     }
1189
1190   if (rl_point < 0)
1191     rl_point = 0;
1192
1193   return 0;
1194 }
1195
1196 /* Like the tcsh editing function delete-char-or-list.  The eof character
1197    is caught before this is invoked, so this really does the same thing as
1198    delete-char-or-list-or-eof, as long as it's bound to the eof character. */
1199 int
1200 rl_delete_or_show_completions (count, key)
1201      int count, key;
1202 {
1203   if (rl_end != 0 && rl_point == rl_end)
1204     return (rl_possible_completions (count, key));
1205   else
1206     return (rl_delete (count, key));
1207 }
1208
1209 #ifndef RL_COMMENT_BEGIN_DEFAULT
1210 #define RL_COMMENT_BEGIN_DEFAULT "#"
1211 #endif
1212
1213 /* Turn the current line into a comment in shell history.
1214    A K*rn shell style function. */
1215 int
1216 rl_insert_comment (count, key)
1217      int count, key;
1218 {
1219   char *rl_comment_text;
1220   int rl_comment_len;
1221
1222   rl_beg_of_line (1, key);
1223   rl_comment_text = _rl_comment_begin ? _rl_comment_begin : RL_COMMENT_BEGIN_DEFAULT;
1224
1225   if (rl_explicit_arg == 0)
1226     rl_insert_text (rl_comment_text);
1227   else
1228     {
1229       rl_comment_len = strlen (rl_comment_text);
1230       if (STREQN (rl_comment_text, rl_line_buffer, rl_comment_len))
1231         rl_delete_text (rl_point, rl_point + rl_comment_len);
1232       else
1233         rl_insert_text (rl_comment_text);
1234     }
1235
1236   (*rl_redisplay_function) ();
1237   rl_newline (1, '\n');
1238
1239   return (0);
1240 }
1241
1242 /* **************************************************************** */
1243 /*                                                                  */
1244 /*                      Changing Case                               */
1245 /*                                                                  */
1246 /* **************************************************************** */
1247
1248 /* The three kinds of things that we know how to do. */
1249 #define UpCase 1
1250 #define DownCase 2
1251 #define CapCase 3
1252
1253 /* Uppercase the word at point. */
1254 int
1255 rl_upcase_word (count, key)
1256      int count, key;
1257 {
1258   return (rl_change_case (count, UpCase));
1259 }
1260
1261 /* Lowercase the word at point. */
1262 int
1263 rl_downcase_word (count, key)
1264      int count, key;
1265 {
1266   return (rl_change_case (count, DownCase));
1267 }
1268
1269 /* Upcase the first letter, downcase the rest. */
1270 int
1271 rl_capitalize_word (count, key)
1272      int count, key;
1273 {
1274  return (rl_change_case (count, CapCase));
1275 }
1276
1277 /* The meaty function.
1278    Change the case of COUNT words, performing OP on them.
1279    OP is one of UpCase, DownCase, or CapCase.
1280    If a negative argument is given, leave point where it started,
1281    otherwise, leave it where it moves to. */
1282 static int
1283 rl_change_case (count, op)
1284      int count, op;
1285 {
1286   int start, next, end;
1287   int inword, c, nc, nop;
1288 #if defined (HANDLE_MULTIBYTE)
1289   wchar_t wc, nwc;
1290   char mb[MB_LEN_MAX+1];
1291   int mlen;
1292   size_t m;
1293   mbstate_t mps;
1294 #endif
1295
1296   start = rl_point;
1297   rl_forward_word (count, 0);
1298   end = rl_point;
1299
1300   if (op != UpCase && op != DownCase && op != CapCase)
1301     {
1302       rl_ding ();
1303       return -1;
1304     }
1305
1306   if (count < 0)
1307     SWAP (start, end);
1308
1309 #if defined (HANDLE_MULTIBYTE)
1310   memset (&mps, 0, sizeof (mbstate_t));
1311 #endif
1312
1313   /* We are going to modify some text, so let's prepare to undo it. */
1314   rl_modifying (start, end);
1315
1316   inword = 0;
1317   while (start < end)
1318     {
1319       c = _rl_char_value (rl_line_buffer, start);
1320       /*  This assumes that the upper and lower case versions are the same width. */
1321       next = MB_NEXTCHAR (rl_line_buffer, start, 1, MB_FIND_NONZERO);
1322
1323       if (_rl_walphabetic (c) == 0)
1324         {
1325           inword = 0;
1326           start = next;
1327           continue;
1328         }
1329
1330       if (op == CapCase)
1331         {
1332           nop = inword ? DownCase : UpCase;
1333           inword = 1;
1334         }
1335       else
1336         nop = op;
1337       if (MB_CUR_MAX == 1 || rl_byte_oriented || isascii (c))
1338         {
1339           nc = (nop == UpCase) ? _rl_to_upper (c) : _rl_to_lower (c);
1340           rl_line_buffer[start] = nc;
1341         }
1342 #if defined (HANDLE_MULTIBYTE)
1343       else
1344         {
1345           m = mbrtowc (&wc, rl_line_buffer + start, end - start, &mps);
1346           if (MB_INVALIDCH (m))
1347             wc = (wchar_t)rl_line_buffer[start];
1348           else if (MB_NULLWCH (m))
1349             wc = L'\0';
1350           nwc = (nop == UpCase) ? _rl_to_wupper (wc) : _rl_to_wlower (wc);
1351           if  (nwc != wc)       /*  just skip unchanged characters */
1352             {
1353               mlen = wcrtomb (mb, nwc, &mps);
1354               if (mlen > 0)
1355                 mb[mlen] = '\0';
1356               /* Assume the same width */
1357               strncpy (rl_line_buffer + start, mb, mlen);
1358             }
1359         }
1360 #endif
1361
1362       start = next;
1363     }
1364
1365   rl_point = end;
1366   return 0;
1367 }
1368
1369 /* **************************************************************** */
1370 /*                                                                  */
1371 /*                      Transposition                               */
1372 /*                                                                  */
1373 /* **************************************************************** */
1374
1375 /* Transpose the words at point.  If point is at the end of the line,
1376    transpose the two words before point. */
1377 int
1378 rl_transpose_words (count, key)
1379      int count, key;
1380 {
1381   char *word1, *word2;
1382   int w1_beg, w1_end, w2_beg, w2_end;
1383   int orig_point = rl_point;
1384
1385   if (!count)
1386     return 0;
1387
1388   /* Find the two words. */
1389   rl_forward_word (count, key);
1390   w2_end = rl_point;
1391   rl_backward_word (1, key);
1392   w2_beg = rl_point;
1393   rl_backward_word (count, key);
1394   w1_beg = rl_point;
1395   rl_forward_word (1, key);
1396   w1_end = rl_point;
1397
1398   /* Do some check to make sure that there really are two words. */
1399   if ((w1_beg == w2_beg) || (w2_beg < w1_end))
1400     {
1401       rl_ding ();
1402       rl_point = orig_point;
1403       return -1;
1404     }
1405
1406   /* Get the text of the words. */
1407   word1 = rl_copy_text (w1_beg, w1_end);
1408   word2 = rl_copy_text (w2_beg, w2_end);
1409
1410   /* We are about to do many insertions and deletions.  Remember them
1411      as one operation. */
1412   rl_begin_undo_group ();
1413
1414   /* Do the stuff at word2 first, so that we don't have to worry
1415      about word1 moving. */
1416   rl_point = w2_beg;
1417   rl_delete_text (w2_beg, w2_end);
1418   rl_insert_text (word1);
1419
1420   rl_point = w1_beg;
1421   rl_delete_text (w1_beg, w1_end);
1422   rl_insert_text (word2);
1423
1424   /* This is exactly correct since the text before this point has not
1425      changed in length. */
1426   rl_point = w2_end;
1427
1428   /* I think that does it. */
1429   rl_end_undo_group ();
1430   xfree (word1);
1431   xfree (word2);
1432
1433   return 0;
1434 }
1435
1436 /* Transpose the characters at point.  If point is at the end of the line,
1437    then transpose the characters before point. */
1438 int
1439 rl_transpose_chars (count, key)
1440      int count, key;
1441 {
1442 #if defined (HANDLE_MULTIBYTE)
1443   char *dummy;
1444   int i;
1445 #else
1446   char dummy[2];
1447 #endif
1448   int char_length, prev_point;
1449
1450   if (count == 0)
1451     return 0;
1452
1453   if (!rl_point || rl_end < 2)
1454     {
1455       rl_ding ();
1456       return -1;
1457     }
1458
1459   rl_begin_undo_group ();
1460
1461   if (rl_point == rl_end)
1462     {
1463       rl_point = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_NONZERO);
1464       count = 1;
1465     }
1466
1467   prev_point = rl_point;
1468   rl_point = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_NONZERO);
1469
1470 #if defined (HANDLE_MULTIBYTE)
1471   char_length = prev_point - rl_point;
1472   dummy = (char *)xmalloc (char_length + 1);
1473   for (i = 0; i < char_length; i++)
1474     dummy[i] = rl_line_buffer[rl_point + i];
1475   dummy[i] = '\0';
1476 #else
1477   dummy[0] = rl_line_buffer[rl_point];
1478   dummy[char_length = 1] = '\0';
1479 #endif
1480
1481   rl_delete_text (rl_point, rl_point + char_length);
1482
1483   rl_point = _rl_find_next_mbchar (rl_line_buffer, rl_point, count, MB_FIND_NONZERO);
1484
1485   _rl_fix_point (0);
1486   rl_insert_text (dummy);
1487   rl_end_undo_group ();
1488
1489 #if defined (HANDLE_MULTIBYTE)
1490   xfree (dummy);
1491 #endif
1492
1493   return 0;
1494 }
1495
1496 /* **************************************************************** */
1497 /*                                                                  */
1498 /*                      Character Searching                         */
1499 /*                                                                  */
1500 /* **************************************************************** */
1501
1502 int
1503 #if defined (HANDLE_MULTIBYTE)
1504 _rl_char_search_internal (count, dir, smbchar, len)
1505      int count, dir;
1506      char *smbchar;
1507      int len;
1508 #else
1509 _rl_char_search_internal (count, dir, schar)
1510      int count, dir, schar;
1511 #endif
1512 {
1513   int pos, inc;
1514 #if defined (HANDLE_MULTIBYTE)
1515   int prepos;
1516 #endif
1517
1518   if (dir == 0)
1519     return -1;
1520
1521   pos = rl_point;
1522   inc = (dir < 0) ? -1 : 1;
1523   while (count)
1524     {
1525       if ((dir < 0 && pos <= 0) || (dir > 0 && pos >= rl_end))
1526         {
1527           rl_ding ();
1528           return -1;
1529         }
1530
1531 #if defined (HANDLE_MULTIBYTE)
1532       pos = (inc > 0) ? _rl_find_next_mbchar (rl_line_buffer, pos, 1, MB_FIND_ANY)
1533                       : _rl_find_prev_mbchar (rl_line_buffer, pos, MB_FIND_ANY);
1534 #else
1535       pos += inc;
1536 #endif
1537       do
1538         {
1539 #if defined (HANDLE_MULTIBYTE)
1540           if (_rl_is_mbchar_matched (rl_line_buffer, pos, rl_end, smbchar, len))
1541 #else
1542           if (rl_line_buffer[pos] == schar)
1543 #endif
1544             {
1545               count--;
1546               if (dir < 0)
1547                 rl_point = (dir == BTO) ? _rl_find_next_mbchar (rl_line_buffer, pos, 1, MB_FIND_ANY)
1548                                         : pos;
1549               else
1550                 rl_point = (dir == FTO) ? _rl_find_prev_mbchar (rl_line_buffer, pos, MB_FIND_ANY)
1551                                         : pos;
1552               break;
1553             }
1554 #if defined (HANDLE_MULTIBYTE)
1555           prepos = pos;
1556 #endif
1557         }
1558 #if defined (HANDLE_MULTIBYTE)
1559       while ((dir < 0) ? (pos = _rl_find_prev_mbchar (rl_line_buffer, pos, MB_FIND_ANY)) != prepos
1560                        : (pos = _rl_find_next_mbchar (rl_line_buffer, pos, 1, MB_FIND_ANY)) != prepos);
1561 #else
1562       while ((dir < 0) ? pos-- : ++pos < rl_end);
1563 #endif
1564     }
1565   return (0);
1566 }
1567
1568 /* Search COUNT times for a character read from the current input stream.
1569    FDIR is the direction to search if COUNT is non-negative; otherwise
1570    the search goes in BDIR.  So much is dependent on HANDLE_MULTIBYTE
1571    that there are two separate versions of this function. */
1572 #if defined (HANDLE_MULTIBYTE)
1573 static int
1574 _rl_char_search (count, fdir, bdir)
1575      int count, fdir, bdir;
1576 {
1577   char mbchar[MB_LEN_MAX];
1578   int mb_len;
1579
1580   mb_len = _rl_read_mbchar (mbchar, MB_LEN_MAX);
1581
1582   if (mb_len <= 0)
1583     return -1;
1584
1585   if (count < 0)
1586     return (_rl_char_search_internal (-count, bdir, mbchar, mb_len));
1587   else
1588     return (_rl_char_search_internal (count, fdir, mbchar, mb_len));
1589 }
1590 #else /* !HANDLE_MULTIBYTE */
1591 static int
1592 _rl_char_search (count, fdir, bdir)
1593      int count, fdir, bdir;
1594 {
1595   int c;
1596
1597   RL_SETSTATE(RL_STATE_MOREINPUT);
1598   c = rl_read_key ();
1599   RL_UNSETSTATE(RL_STATE_MOREINPUT);
1600
1601   if (c < 0)
1602     return -1;
1603
1604   if (count < 0)
1605     return (_rl_char_search_internal (-count, bdir, c));
1606   else
1607     return (_rl_char_search_internal (count, fdir, c));
1608 }
1609 #endif /* !HANDLE_MULTIBYTE */
1610
1611 #if defined (READLINE_CALLBACKS)
1612 static int
1613 _rl_char_search_callback (data)
1614      _rl_callback_generic_arg *data;
1615 {
1616   _rl_callback_func = 0;
1617   _rl_want_redisplay = 1;
1618
1619   return (_rl_char_search (data->count, data->i1, data->i2));
1620 }
1621 #endif
1622
1623 int
1624 rl_char_search (count, key)
1625      int count, key;
1626 {
1627 #if defined (READLINE_CALLBACKS)
1628   if (RL_ISSTATE (RL_STATE_CALLBACK))
1629     {
1630       _rl_callback_data = _rl_callback_data_alloc (count);
1631       _rl_callback_data->i1 = FFIND;
1632       _rl_callback_data->i2 = BFIND;
1633       _rl_callback_func = _rl_char_search_callback;
1634       return (0);
1635     }
1636 #endif
1637
1638   return (_rl_char_search (count, FFIND, BFIND));
1639 }
1640
1641 int
1642 rl_backward_char_search (count, key)
1643      int count, key;
1644 {
1645 #if defined (READLINE_CALLBACKS)
1646   if (RL_ISSTATE (RL_STATE_CALLBACK))
1647     {
1648       _rl_callback_data = _rl_callback_data_alloc (count);
1649       _rl_callback_data->i1 = BFIND;
1650       _rl_callback_data->i2 = FFIND;
1651       _rl_callback_func = _rl_char_search_callback;
1652       return (0);
1653     }
1654 #endif
1655
1656   return (_rl_char_search (count, BFIND, FFIND));
1657 }
1658
1659 /* **************************************************************** */
1660 /*                                                                  */
1661 /*                 The Mark and the Region.                         */
1662 /*                                                                  */
1663 /* **************************************************************** */
1664
1665 /* Set the mark at POSITION. */
1666 int
1667 _rl_set_mark_at_pos (position)
1668      int position;
1669 {
1670   if (position > rl_end)
1671     return -1;
1672
1673   rl_mark = position;
1674   return 0;
1675 }
1676
1677 /* A bindable command to set the mark. */
1678 int
1679 rl_set_mark (count, key)
1680      int count, key;
1681 {
1682   return (_rl_set_mark_at_pos (rl_explicit_arg ? count : rl_point));
1683 }
1684
1685 /* Exchange the position of mark and point. */
1686 int
1687 rl_exchange_point_and_mark (count, key)
1688      int count, key;
1689 {
1690   if (rl_mark > rl_end)
1691     rl_mark = -1;
1692
1693   if (rl_mark == -1)
1694     {
1695       rl_ding ();
1696       return -1;
1697     }
1698   else
1699     SWAP (rl_point, rl_mark);
1700
1701   return 0;
1702 }