home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / e20313sr.zip / emacs / 20.3.1 / src / cmds.c < prev    next >
C/C++ Source or Header  |  1999-07-31  |  17KB  |  581 lines
  1. /* Simple built-in editing commands.
  2.    Copyright (C) 1985, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU Emacs.
  5.  
  6. GNU Emacs is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. GNU Emacs is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU Emacs; see the file COPYING.  If not, write to
  18. the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19. Boston, MA 02111-1307, USA.  */
  20.  
  21. /* Modified for emx by Jeremy Bowen, May 1999 based on patches
  22.    to v19.33 by Eberhard Mattes */
  23.  
  24. #include <config.h>
  25. #include "lisp.h"
  26. #include "commands.h"
  27. #include "buffer.h"
  28. #include "charset.h"
  29. #include "syntax.h"
  30. #include "window.h"
  31. #include "keyboard.h"
  32. #include "dispextern.h"
  33.  
  34. Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;
  35.  
  36. /* A possible value for a buffer's overwrite-mode variable.  */
  37. Lisp_Object Qoverwrite_mode_binary;
  38.  
  39. /* Non-nil means put this face on the next self-inserting character.  */
  40. Lisp_Object Vself_insert_face;
  41.  
  42. /* This is the command that set up Vself_insert_face.  */
  43. Lisp_Object Vself_insert_face_command;
  44.  
  45. extern Lisp_Object Qface;
  46.  
  47. DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
  48.   "Return buffer position N characters after (before if N negative) point.")
  49.   (n)
  50.      Lisp_Object n;
  51. {
  52.   CHECK_NUMBER (n, 0);
  53.  
  54.   return make_number (PT + XINT (n));
  55. }
  56.  
  57. DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "p",
  58.   "Move point right N characters (left if N is negative).\n\
  59. On reaching end of buffer, stop and signal error.")
  60.   (n)
  61.      Lisp_Object n;
  62. {
  63.   if (NILP (n))
  64.     XSETFASTINT (n, 1);
  65.   else
  66.     CHECK_NUMBER (n, 0);
  67.  
  68.   /* This used to just set point to point + XINT (n), and then check
  69.      to see if it was within boundaries.  But now that SET_PT can
  70.      potentially do a lot of stuff (calling entering and exiting
  71.      hooks, etcetera), that's not a good approach.  So we validate the
  72.      proposed position, then set point.  */
  73.   {
  74.     int new_point = PT + XINT (n);
  75.  
  76.     if (new_point < BEGV)
  77.       {
  78.     SET_PT (BEGV);
  79.     Fsignal (Qbeginning_of_buffer, Qnil);
  80.       }
  81.     if (new_point > ZV)
  82.       {
  83.     SET_PT (ZV);
  84.     Fsignal (Qend_of_buffer, Qnil);
  85.       }
  86.  
  87.     SET_PT (new_point);
  88.   }
  89.  
  90.   return Qnil;
  91. }
  92.  
  93. DEFUN ("backward-char", Fbackward_char, Sbackward_char, 0, 1, "p",
  94.   "Move point left N characters (right if N is negative).\n\
  95. On attempt to pass beginning or end of buffer, stop and signal error.")
  96.   (n)
  97.      Lisp_Object n;
  98. {
  99.   if (NILP (n))
  100.     XSETFASTINT (n, 1);
  101.   else
  102.     CHECK_NUMBER (n, 0);
  103.  
  104.   XSETINT (n, - XINT (n));
  105.   return Fforward_char (n);
  106. }
  107.  
  108. DEFUN ("forward-line", Fforward_line, Sforward_line, 0, 1, "p",
  109.   "Move N lines forward (backward if N is negative).\n\
  110. Precisely, if point is on line I, move to the start of line I + N.\n\
  111. If there isn't room, go as far as possible (no error).\n\
  112. Returns the count of lines left to move.  If moving forward,\n\
  113. that is N - number of lines moved; if backward, N + number moved.\n\
  114. With positive N, a non-empty line at the end counts as one line\n\
  115.   successfully moved (for the return value).")
  116.   (n)
  117.      Lisp_Object n;
  118. {
  119.   int opoint = PT, opoint_byte = PT_BYTE;
  120.   int pos, pos_byte;
  121.   int count, shortage;
  122.   int temp;
  123.  
  124.   if (NILP (n))
  125.     count = 1;
  126.   else
  127.     {
  128.       CHECK_NUMBER (n, 0);
  129.       count = XINT (n);
  130.     }
  131.  
  132.   if (count <= 0)
  133.     shortage = scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, count - 1, 1);
  134.   else
  135.     shortage = scan_newline (PT, PT_BYTE, ZV, ZV_BYTE, count, 1);
  136.  
  137.   /* Since scan_newline does TEMP_SET_PT_BOTH,
  138.      and we want to set PT "for real",
  139.      go back to the old point and then come back here.  */
  140.   pos = PT;
  141.   pos_byte = PT_BYTE;
  142.   TEMP_SET_PT_BOTH (opoint, opoint_byte);
  143.   SET_PT_BOTH (pos, pos_byte);
  144.  
  145.   if (shortage > 0
  146.       && (count <= 0
  147.       || (ZV > BEGV
  148.           && PT != opoint
  149.           && (FETCH_BYTE (PT_BYTE - 1) != '\n'))))
  150.     shortage--;
  151.  
  152.   return make_number (count <= 0 ? - shortage : shortage);
  153. }
  154.  
  155. DEFUN ("beginning-of-line", Fbeginning_of_line, Sbeginning_of_line,
  156.   0, 1, "p",
  157.   "Move point to beginning of current line.\n\
  158. With argument N not nil or 1, move forward N - 1 lines first.\n\
  159. If scan reaches end of buffer, stop there without error.")
  160.   (n)
  161.      Lisp_Object n;
  162. {
  163.   if (NILP (n))
  164.     XSETFASTINT (n, 1);
  165.   else
  166.     CHECK_NUMBER (n, 0);
  167.  
  168.   SET_PT (XINT (Fline_beginning_position (n)));
  169.   return Qnil;
  170. }
  171.  
  172. DEFUN ("end-of-line", Fend_of_line, Send_of_line,
  173.   0, 1, "p",
  174.   "Move point to end of current line.\n\
  175. With argument N not nil or 1, move forward N - 1 lines first.\n\
  176. If scan reaches end of buffer, stop there without error.")
  177.   (n)
  178.      Lisp_Object n;
  179. {
  180.   register int pos;
  181.   register int stop;
  182.  
  183.   if (NILP (n))
  184.     XSETFASTINT (n, 1);
  185.   else
  186.     CHECK_NUMBER (n, 0);
  187.  
  188.   SET_PT (XINT (Fline_end_position (n)));
  189.  
  190.   return Qnil;
  191. }
  192.  
  193. DEFUN ("delete-char", Fdelete_char, Sdelete_char, 1, 2, "p\nP",
  194.   "Delete the following N characters (previous if N is negative).\n\
  195. Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\
  196. Interactively, N is the prefix arg, and KILLFLAG is set if\n\
  197. N was explicitly specified.")
  198.   (n, killflag)
  199.      Lisp_Object n, killflag;
  200. {
  201.   int pos;
  202.  
  203.   CHECK_NUMBER (n, 0);
  204.  
  205.   pos = PT + XINT (n);
  206.   if (NILP (killflag))
  207.     {
  208.       if (XINT (n) < 0)
  209.     {
  210.       if (pos < BEGV)
  211.         Fsignal (Qbeginning_of_buffer, Qnil);
  212.       else
  213.         del_range (pos, PT);
  214.     }
  215.       else
  216.     {
  217.       if (pos > ZV)
  218.         Fsignal (Qend_of_buffer, Qnil);
  219.       else
  220.         del_range (PT, pos);
  221.     }
  222.     }
  223.   else
  224.     {
  225.       call1 (Qkill_forward_chars, n);
  226.     }
  227.   return Qnil;
  228. }
  229.  
  230. DEFUN ("delete-backward-char", Fdelete_backward_char, Sdelete_backward_char,
  231.   1, 2, "p\nP",
  232.   "Delete the previous N characters (following if N is negative).\n\
  233. Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\
  234. Interactively, N is the prefix arg, and KILLFLAG is set if\n\
  235. N was explicitly specified.")
  236.   (n, killflag)
  237.      Lisp_Object n, killflag;
  238. {
  239.   Lisp_Object value;
  240.   int deleted_special = 0;
  241.   int pos, pos_byte, i;
  242.  
  243.   CHECK_NUMBER (n, 0);
  244.  
  245.   /* See if we are about to delete a tab or newline backwards.  */
  246.   pos = PT;
  247.   pos_byte = PT_BYTE;
  248.   for (i = 0; i < XINT (n) && pos_byte > BEGV_BYTE; i++)
  249.     {
  250.       int c;
  251.  
  252.       DEC_BOTH (pos, pos_byte);
  253.       c = FETCH_BYTE (pos_byte);
  254.       if (c == '\t' || c == '\n')
  255.     {
  256.       deleted_special = 1;
  257.       break;
  258.     }
  259.     }
  260.  
  261.   /* In overwrite mode, back over columns while clearing them out,
  262.      unless at end of line.  */
  263.   if (XINT (n) > 0
  264.       && ! NILP (current_buffer->overwrite_mode)
  265.       && ! deleted_special
  266.       && ! (PT == ZV || FETCH_BYTE (PT_BYTE) == '\n'))
  267.     {
  268.       int column = current_column ();
  269.  
  270.       value = Fdelete_char (make_number (-XINT (n)), killflag);
  271.       i = column - current_column ();
  272.       Finsert_char (make_number (' '), make_number (i), Qnil);
  273.       /* Whitespace chars are ASCII chars, so we can simply subtract.  */
  274.       SET_PT_BOTH (PT - i, PT_BYTE - i);
  275.     }
  276.   else
  277.     value = Fdelete_char (make_number (-XINT (n)), killflag);
  278.  
  279.   return value;
  280. }
  281.  
  282. DEFUN ("self-insert-command", Fself_insert_command, Sself_insert_command, 1, 1, "p",
  283.   "Insert the character you type.\n\
  284. Whichever character you type to run this command is inserted.")
  285.   (n)
  286.      Lisp_Object n;
  287. {
  288.   int character = XINT (last_command_char);
  289.  
  290.   CHECK_NUMBER (n, 0);
  291.  
  292.   /* Barf if the key that invoked this was not a character.  */
  293.   if (!INTEGERP (last_command_char))
  294.     bitch_at_user ();
  295.   else if (XINT (n) >= 2 && NILP (current_buffer->overwrite_mode))
  296.     {
  297.       int modified_char = character;
  298.       /* Add the offset to the character, for Finsert_char.
  299.      We pass internal_self_insert the unmodified character
  300.      because it itself does this offsetting.  */
  301.       if (! NILP (current_buffer->enable_multibyte_characters))
  302.     modified_char = unibyte_char_to_multibyte (modified_char);
  303.  
  304.       XSETFASTINT (n, XFASTINT (n) - 2);
  305.       /* The first one might want to expand an abbrev.  */
  306.       internal_self_insert (character, 1);
  307.       /* The bulk of the copies of this char can be inserted simply.
  308.      We don't have to handle a user-specified face specially
  309.      because it will get inherited from the first char inserted.  */
  310.       Finsert_char (make_number (modified_char), n, Qt);
  311.       /* The last one might want to auto-fill.  */
  312.       internal_self_insert (character, 0);
  313.     }
  314.   else
  315.     while (XINT (n) > 0)
  316.       {
  317.     /* Ok since old and new vals both nonneg */
  318.     XSETFASTINT (n, XFASTINT (n) - 1);
  319.     internal_self_insert (character, XFASTINT (n) != 0);
  320.       }
  321.  
  322.   return Qnil;
  323. }
  324.  
  325. /* Insert character C.  If NOAUTOFILL is nonzero, don't do autofill
  326.    even if it is enabled.
  327.  
  328.    If this insertion is suitable for direct output (completely simple),
  329.    return 0.  A value of 1 indicates this *might* not have been simple.
  330.    A value of 2 means this did things that call for an undo boundary.  */
  331.  
  332. int
  333. internal_self_insert (c, noautofill)
  334.      int c;
  335.      int noautofill;
  336. {
  337.   extern Lisp_Object Fexpand_abbrev ();
  338.   int hairy = 0;
  339.   Lisp_Object tem;
  340.   register enum syntaxcode synt;
  341.   Lisp_Object overwrite, string;
  342.   /* Length of multi-byte form of C.  */
  343.   int len;
  344.   /* Working buffer and pointer for multi-byte form of C.  */
  345.   unsigned char workbuf[4], *str;
  346.   int chars_to_delete = 0;
  347.   int spaces_to_insert = 0;
  348.  
  349.   overwrite = current_buffer->overwrite_mode;
  350.   if (!NILP (Vbefore_change_function) || !NILP (Vafter_change_function)
  351.       || !NILP (Vbefore_change_functions) || !NILP (Vafter_change_functions))
  352.     hairy = 1;
  353.  
  354.   /* At first, get multi-byte form of C in STR.  */
  355.   if (!NILP (current_buffer->enable_multibyte_characters))
  356.     {
  357.       c = unibyte_char_to_multibyte (c);
  358.       len = CHAR_STRING (c, workbuf, str);
  359.     }
  360.   else
  361.     {
  362.       workbuf[0] = (SINGLE_BYTE_CHAR_P (c)
  363.             ? c
  364.             : multibyte_char_to_unibyte (c, Qnil));
  365.       str = workbuf;
  366.       len = 1;
  367.     }
  368.   if (!NILP (overwrite)
  369.       && PT < ZV)
  370.     {
  371.       /* In overwrite-mode, we substitute a character at point (C2,
  372.      hereafter) by C.  For that, we delete C2 in advance.  But,
  373.      just substituting C2 by C may move a remaining text in the
  374.      line to the right or to the left, which is not preferable.
  375.      So we insert more spaces or delete more characters in the
  376.      following cases: if C is narrower than C2, after deleting C2,
  377.      we fill columns with spaces, if C is wider than C2, we delete
  378.      C2 and several characters following C2.  */
  379.  
  380.       /* This is the character after point.  */
  381.       int c2 = FETCH_CHAR (PT_BYTE);
  382.  
  383.       /* Column the cursor should be placed at after this insertion.
  384.          The correct value should be calculated only when necessary.  */
  385.       int target_clm = 0;
  386.  
  387.       /* Overwriting in binary-mode always replaces C2 by C.
  388.      Overwriting in textual-mode doesn't always do that.
  389.      It inserts newlines in the usual way,
  390.      and inserts any character at end of line
  391.      or before a tab if it doesn't use the whole width of the tab.  */
  392.       if (EQ (overwrite, Qoverwrite_mode_binary)
  393.       || (c != '\n'
  394.           && c2 != '\n'
  395.           && ! (c2 == '\t'
  396.             && XINT (current_buffer->tab_width) > 0
  397.             && XFASTINT (current_buffer->tab_width) < 20
  398.             && (target_clm = (current_column () 
  399.                       + XINT (Fchar_width (make_number (c2)))),
  400.             target_clm % XFASTINT (current_buffer->tab_width)))))
  401.     {
  402.       int pos = PT;
  403.       int pos_byte = PT_BYTE;
  404.  
  405.       if (target_clm == 0)
  406.         chars_to_delete = 1;
  407.       else
  408.         {
  409.           /* The actual cursor position after the trial of moving
  410.          to column TARGET_CLM.  It is greater than TARGET_CLM
  411.          if the TARGET_CLM is middle of multi-column
  412.          character.  In that case, the new point is set after
  413.          that character.  */
  414.           int actual_clm
  415.         = XFASTINT (Fmove_to_column (make_number (target_clm), Qnil));
  416.  
  417.           chars_to_delete = PT - pos;
  418.  
  419.           if (actual_clm > target_clm)
  420.         {
  421.           /* We will delete too many columns.  Let's fill columns
  422.              by spaces so that the remaining text won't move.  */
  423.           spaces_to_insert = actual_clm - target_clm;
  424.         }
  425.         }
  426.       SET_PT_BOTH (pos, pos_byte);
  427.       hairy = 2;
  428.     }
  429.       hairy = 2;
  430.     }
  431.   if (!NILP (current_buffer->abbrev_mode)
  432.       && SYNTAX (c) != Sword
  433.       && NILP (current_buffer->read_only)
  434.       && PT > BEGV && SYNTAX (XFASTINT (Fprevious_char ())) == Sword)
  435.     {
  436.       int modiff = MODIFF;
  437.       Lisp_Object sym;
  438.  
  439.       sym = Fexpand_abbrev ();
  440.  
  441.       /* If we expanded an abbrev which has only a hook,
  442.      and the hook has a non-nil `no-self-insert' property,
  443.      return right away--don't really self-insert.  */
  444.       if (! NILP (sym) && ! NILP (XSYMBOL (sym)->function)
  445.       && SYMBOLP (XSYMBOL (sym)->function))
  446.     {
  447.       Lisp_Object prop;
  448.       prop = Fget (XSYMBOL (sym)->function, intern ("no-self-insert"));
  449.       if (! NILP (prop))
  450.         return 1;
  451.     }
  452.  
  453.       if (MODIFF != modiff)
  454.     hairy = 2;
  455.     }
  456.  
  457.   if (chars_to_delete)
  458.     {
  459.       string = make_string_from_bytes (str, 1, len);
  460.       if (spaces_to_insert)
  461.     {
  462.       tem = Fmake_string (make_number (spaces_to_insert),
  463.                   make_number (' '));
  464.       string = concat2 (tem, string);
  465.     }
  466.  
  467.       replace_range (PT, PT + chars_to_delete, string, 1, 1, 1);
  468.       Fforward_char (make_number (1 + spaces_to_insert));
  469.     }
  470.   else
  471.     insert_and_inherit (str, len);
  472.  
  473.   if ((c == ' ' || c == '\n')
  474.       && !noautofill
  475.       && !NILP (current_buffer->auto_fill_function))
  476.     {
  477.       Lisp_Object tem;
  478.  
  479.       if (c == '\n')
  480.     /* After inserting a newline, move to previous line and fill
  481.        that.  Must have the newline in place already so filling and
  482.        justification, if any, know where the end is going to be.  */
  483.     SET_PT_BOTH (PT - 1, PT_BYTE - 1);
  484.       tem = call0 (current_buffer->auto_fill_function);
  485.       if (c == '\n')
  486.     SET_PT_BOTH (PT + 1, PT_BYTE + 1);
  487.       if (!NILP (tem))
  488.     hairy = 2;
  489.     }
  490.  
  491. #ifdef HAVE_FACES
  492.   /* If previous command specified a face to use, use it.  */
  493.   if (!NILP (Vself_insert_face)
  494.       && EQ (current_kboard->Vlast_command, Vself_insert_face_command))
  495.     {
  496.       Fput_text_property (make_number (PT - 1), make_number (PT),
  497.               Qface, Vself_insert_face, Qnil);
  498.       Vself_insert_face = Qnil;
  499.     }
  500. #endif
  501.  
  502.   synt = SYNTAX (c);
  503.   if ((synt == Sclose || synt == Smath)
  504.       && !NILP (Vblink_paren_function) && INTERACTIVE
  505.       && !noautofill)
  506.     {
  507.       call0 (Vblink_paren_function);
  508.       hairy = 2;
  509.     }
  510.   return hairy;
  511. }
  512.  
  513. /* module initialization */
  514.  
  515. void
  516. syms_of_cmds ()
  517. {
  518.   Qkill_backward_chars = intern ("kill-backward-chars");
  519.   staticpro (&Qkill_backward_chars);
  520.  
  521.   Qkill_forward_chars = intern ("kill-forward-chars");
  522.   staticpro (&Qkill_forward_chars);
  523.  
  524.   Qoverwrite_mode_binary = intern ("overwrite-mode-binary");
  525.   staticpro (&Qoverwrite_mode_binary);
  526.  
  527.   DEFVAR_LISP ("self-insert-face", &Vself_insert_face,
  528.     "If non-nil, set the face of the next self-inserting character to this.\n\
  529. See also `self-insert-face-command'.");
  530.   Vself_insert_face = Qnil;
  531.  
  532.   DEFVAR_LISP ("self-insert-face-command", &Vself_insert_face_command,
  533.     "This is the command that set up `self-insert-face'.\n\
  534. If `last-command' does not equal this value, we ignore `self-insert-face'.");
  535.   Vself_insert_face_command = Qnil;
  536.  
  537.   DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function,
  538.     "Function called, if non-nil, whenever a close parenthesis is inserted.\n\
  539. More precisely, a char with closeparen syntax is self-inserted.");
  540.   Vblink_paren_function = Qnil;
  541.  
  542.   defsubr (&Sforward_point);
  543.   defsubr (&Sforward_char);
  544.   defsubr (&Sbackward_char);
  545.   defsubr (&Sforward_line);
  546.   defsubr (&Sbeginning_of_line);
  547.   defsubr (&Send_of_line);
  548.  
  549.   defsubr (&Sdelete_char);
  550.   defsubr (&Sdelete_backward_char);
  551.  
  552.   defsubr (&Sself_insert_command);
  553. }
  554.  
  555. void
  556. keys_of_cmds ()
  557. {
  558.   int n;
  559.  
  560.   initial_define_key (global_map, Ctl ('I'), "self-insert-command");
  561.   for (n = 040; n < 0177; n++)
  562.     initial_define_key (global_map, n, "self-insert-command");
  563. #ifdef MSDOS
  564.   for (n = 0200; n < 0240; n++)
  565.     initial_define_key (global_map, n, "self-insert-command");
  566. #endif
  567. #ifdef EMX
  568.   for (n = 0200; n < 0240; n++)
  569.     initial_define_key (global_map, n, "self-insert-command");
  570. #endif /* EMX */
  571.   for (n = 0240; n < 0400; n++)
  572.     initial_define_key (global_map, n, "self-insert-command");
  573.  
  574.   initial_define_key (global_map, Ctl ('A'), "beginning-of-line");
  575.   initial_define_key (global_map, Ctl ('B'), "backward-char");
  576.   initial_define_key (global_map, Ctl ('D'), "delete-char");
  577.   initial_define_key (global_map, Ctl ('E'), "end-of-line");
  578.   initial_define_key (global_map, Ctl ('F'), "forward-char");
  579.   initial_define_key (global_map, 0177, "delete-backward-char");
  580. }
  581.