/* Simple built-in editing commands.
- Copyright (C) 1985 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1993 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include "config.h"
+#include <config.h>
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;
+/* A possible value for a buffer's overwrite-mode variable. */
+Lisp_Object Qoverwrite_mode_binary;
+
\f
DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "p",
"Move point right ARG characters (left if ARG negative).\n\
(n)
Lisp_Object n;
{
- if (NULL (n))
+ if (NILP (n))
XFASTINT (n) = 1;
else
CHECK_NUMBER (n, 0);
- SET_PT (point + XINT (n));
- if (point < BEGV)
- {
- SET_PT (BEGV);
- Fsignal (Qbeginning_of_buffer, Qnil);
- }
- if (point > ZV)
- {
- SET_PT (ZV);
- Fsignal (Qend_of_buffer, Qnil);
- }
+ /* This used to just set point to point + XINT (n), and then check
+ to see if it was within boundaries. But now that SET_PT can
+ potentially do a lot of stuff (calling entering and exiting
+ hooks, etcetera), that's not a good approach. So we validate the
+ proposed position, then set point. */
+ {
+ int new_point = point + XINT (n);
+
+ if (new_point < BEGV)
+ {
+ SET_PT (BEGV);
+ Fsignal (Qbeginning_of_buffer, Qnil);
+ }
+ if (new_point > ZV)
+ {
+ SET_PT (ZV);
+ Fsignal (Qend_of_buffer, Qnil);
+ }
+
+ SET_PT (new_point);
+ }
+
return Qnil;
}
(n)
Lisp_Object n;
{
- if (NULL (n))
+ if (NILP (n))
XFASTINT (n) = 1;
else
CHECK_NUMBER (n, 0);
int pos;
int count, shortage, negp;
- if (NULL (n))
+ if (NILP (n))
count = 1;
else
{
}
negp = count <= 0;
- pos = scan_buffer ('\n', pos2, count - negp, &shortage);
+ pos = scan_buffer ('\n', pos2, count - negp, &shortage, 1);
if (shortage > 0
&& (negp
- || (ZV >= BEGV
+ || (ZV > BEGV
+ && pos != pos2
&& FETCH_CHAR (pos - 1) != '\n')))
shortage--;
SET_PT (pos);
(n)
Lisp_Object n;
{
- if (NULL (n))
+ if (NILP (n))
XFASTINT (n) = 1;
else
CHECK_NUMBER (n, 0);
register int pos;
register int stop;
- if (NULL (n))
+ if (NILP (n))
XFASTINT (n) = 1;
else
CHECK_NUMBER (n, 0);
{
CHECK_NUMBER (n, 0);
- if (NULL (killflag))
+ if (NILP (killflag))
{
if (XINT (n) < 0)
{
arg = Fprefix_numeric_value (arg1);
- if (!NULL (current_buffer->read_only))
- Fsignal (Qbuffer_read_only, Qnil);
+ if (!NILP (current_buffer->read_only))
+ Fbarf_if_buffer_read_only ();
+
+ /* Inserting a newline at the end of a line produces better
+ redisplay in try_window_id than inserting at the beginning of a
+ line, and the textual result is the same. So, if we're at
+ beginning of line, pretend to be at the end of the previous line.
- /* Inserting a newline at the end of a line
- produces better redisplay in try_window_id
- than inserting at the ebginning fo a line,
- And the textual result is the same.
- So if at beginning, pretend to be at the end.
- Must avoid internal_self_insert in that case since point is wrong.
- Luckily internal_self_insert's special features all do nothing in that case. */
+ We can't use internal_self_insert in that case since it won't do
+ the insertion correctly. Luckily, internal_self_insert's special
+ features all do nothing in that case. */
flag = point > BEGV && FETCH_CHAR (point - 1) == '\n';
+#ifdef USE_TEXT_PROPERTIES
+ /* We cannot use this optimization if properties change
+ in the vicinity.
+ ??? We need to check for change hook properties, etc. */
+ if (flag)
+ if (! (point - 1 > BEGV && ! property_change_between_p (point - 2, point)))
+ flag = 0;
+#endif
+
if (flag)
SET_PT (point - 1);
if (flag)
insert (&c1, 1);
else
- internal_self_insert ('\n', !NULL (arg1));
+ internal_self_insert ('\n', !NILP (arg1));
XFASTINT (arg)--; /* Ok since old and new vals both nonneg */
}
return Qnil;
}
+/* Insert character C1. If NOAUTOFILL is nonzero, don't do autofill
+ even if it is enabled.
+
+ If this insertion is suitable for direct output (completely simple),
+ return 0. A value of 1 indicates this *might* not have been simple. */
+
internal_self_insert (c1, noautofill)
char c1;
int noautofill;
Lisp_Object tem;
register enum syntaxcode synt;
register int c = c1;
+ Lisp_Object overwrite = current_buffer->overwrite_mode;
- if (!NULL (Vbefore_change_function) || !NULL (Vafter_change_function))
+ if (!NILP (Vbefore_change_function) || !NILP (Vafter_change_function))
hairy = 1;
- if (!NULL (current_buffer->overwrite_mode)
+ if (!NILP (overwrite)
&& point < ZV
- && c != '\n' && FETCH_CHAR (point) != '\n'
- && (FETCH_CHAR (point) != '\t'
+ && (EQ (overwrite, Qoverwrite_mode_binary)
+ || (c != '\n' && FETCH_CHAR (point) != '\n'))
+ && (EQ (overwrite, Qoverwrite_mode_binary)
+ || FETCH_CHAR (point) != '\t'
|| XINT (current_buffer->tab_width) <= 0
+ || XFASTINT (current_buffer->tab_width) > 20
|| !((current_column () + 1) % XFASTINT (current_buffer->tab_width))))
{
del_range (point, point + 1);
hairy = 1;
}
- if (!NULL (current_buffer->abbrev_mode)
+ if (!NILP (current_buffer->abbrev_mode)
&& SYNTAX (c) != Sword
- && NULL (current_buffer->read_only)
+ && NILP (current_buffer->read_only)
&& point > BEGV && SYNTAX (FETCH_CHAR (point - 1)) == Sword)
{
- tem = Fexpand_abbrev ();
- if (!NULL (tem))
+ int modiff = MODIFF;
+ Fexpand_abbrev ();
+ /* We can't trust the value of Fexpand_abbrev,
+ but if Fexpand_abbrev changed the buffer,
+ assume it expanded something. */
+ if (MODIFF != modiff)
hairy = 1;
}
if ((c == ' ' || c == '\n')
&& !noautofill
- && !NULL (current_buffer->auto_fill_function)
+ && !NILP (current_buffer->auto_fill_function)
&& current_column () > XFASTINT (current_buffer->fill_column))
{
if (c1 != '\n')
insert (&c1, 1);
synt = SYNTAX (c);
if ((synt == Sclose || synt == Smath)
- && !NULL (Vblink_paren_function) && INTERACTIVE)
+ && !NILP (Vblink_paren_function) && INTERACTIVE)
{
call0 (Vblink_paren_function);
hairy = 1;
Qkill_forward_chars = intern ("kill-forward-chars");
staticpro (&Qkill_forward_chars);
+ Qoverwrite_mode_binary = intern ("overwrite-mode-binary");
+ staticpro (&Qoverwrite_mode_binary);
+
DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function,
"Function called, if non-nil, whenever a close parenthesis is inserted.\n\
More precisely, a char with closeparen syntax is self-inserted.");
initial_define_key (global_map, Ctl('I'), "self-insert-command");
for (n = 040; n < 0177; n++)
initial_define_key (global_map, n, "self-insert-command");
+#ifdef MSDOS
+ for (n = 0200; n < 0240; n++)
+ initial_define_key (global_map, n, "self-insert-command");
+#endif
+ for (n = 0240; n < 0400; n++)
+ initial_define_key (global_map, n, "self-insert-command");
initial_define_key (global_map, Ctl ('A'), "beginning-of-line");
initial_define_key (global_map, Ctl ('B'), "backward-char");
HCoop / bpt / emacs.git / blobdiff