[bpt/emacs.git] / src / cmds.c

/* Simple built-in editing commands.
   Copyright (C) 1985, 1992 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 2, or (at your option)
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */


#include "config.h"
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
#include "syntax.h"

Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;

int overwrite_binary_mode;
\f
DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "p",
  "Move point right ARG characters (left if ARG negative).\n\
On reaching end of buffer, stop and signal error.")
  (n)
     Lisp_Object 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);
    }
  return Qnil;
}

DEFUN ("backward-char", Fbackward_char, Sbackward_char, 0, 1, "p",
  "Move point left ARG characters (right if ARG negative).\n\
On attempt to pass beginning or end of buffer, stop and signal error.")
  (n)
     Lisp_Object n;
{
  if (NILP (n))
    XFASTINT (n) = 1;
  else
    CHECK_NUMBER (n, 0);

  XSETINT (n, - XINT (n));
  return Fforward_char (n);
}

DEFUN ("forward-line", Fforward_line, Sforward_line, 0, 1, "p",
  "Move ARG lines forward (backward if ARG is negative).\n\
Precisely, if point is on line I, move to the start of line I + ARG.\n\
If there isn't room, go as far as possible (no error).\n\
Returns the count of lines left to move.  If moving forward,\n\
that is ARG - number of lines moved; if backward, ARG + number moved.\n\
With positive ARG, a non-empty line at the end counts as one line\n\
  successfully moved (for the return value).")
  (n)
     Lisp_Object n;
{
  int pos2 = point;
  int pos;
  int count, shortage, negp;

  if (NILP (n))
    count = 1;
  else
    {
      CHECK_NUMBER (n, 0);
      count = XINT (n);
    }

  negp = count <= 0;
  pos = scan_buffer ('\n', pos2, count - negp, &shortage);
  if (shortage > 0
      && (negp
	  || (ZV > BEGV
	      && pos != pos2
	      && FETCH_CHAR (pos - 1) != '\n')))
    shortage--;
  SET_PT (pos);
  return make_number (negp ? - shortage : shortage);
}

DEFUN ("beginning-of-line", Fbeginning_of_line, Sbeginning_of_line,
  0, 1, "p",
  "Move point to beginning of current line.\n\
With argument ARG not nil or 1, move forward ARG - 1 lines first.\n\
If scan reaches end of buffer, stop there without error.")
  (n)
     Lisp_Object n;
{
  if (NILP (n))
    XFASTINT (n) = 1;
  else
    CHECK_NUMBER (n, 0);

  Fforward_line (make_number (XINT (n) - 1));
  return Qnil;
}

DEFUN ("end-of-line", Fend_of_line, Send_of_line,
  0, 1, "p",
  "Move point to end of current line.\n\
With argument ARG not nil or 1, move forward ARG - 1 lines first.\n\
If scan reaches end of buffer, stop there without error.")
  (n)
     Lisp_Object n;
{
  register int pos;
  register int stop;

  if (NILP (n))
    XFASTINT (n) = 1;
  else
    CHECK_NUMBER (n, 0);

  if (XINT (n) != 1)
    Fforward_line (make_number (XINT (n) - 1));

  pos = point;
  stop = ZV;
  while (pos < stop && FETCH_CHAR (pos) != '\n') pos++;
  SET_PT (pos);

  return Qnil;
}

DEFUN ("delete-char", Fdelete_char, Sdelete_char, 1, 2, "p\nP",
  "Delete the following ARG characters (previous, with negative arg).\n\
Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\
Interactively, ARG is the prefix arg, and KILLFLAG is set if\n\
ARG was explicitly specified.")
  (n, killflag)
     Lisp_Object n, killflag;
{
  CHECK_NUMBER (n, 0);

  if (NILP (killflag))
    {
      if (XINT (n) < 0)
	{
	  if (point + XINT (n) < BEGV)
	    Fsignal (Qbeginning_of_buffer, Qnil);
	  else
	    del_range (point + XINT (n), point);
	}
      else
	{
	  if (point + XINT (n) > ZV)
	    Fsignal (Qend_of_buffer, Qnil);
	  else
	    del_range (point, point + XINT (n));
	}
    }
  else
    {
      call1 (Qkill_forward_chars, n);
    }
  return Qnil;
}

DEFUN ("delete-backward-char", Fdelete_backward_char, Sdelete_backward_char,
  1, 2, "p\nP",
  "Delete the previous ARG characters (following, with negative ARG).\n\
Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\
Interactively, ARG is the prefix arg, and KILLFLAG is set if\n\
ARG was explicitly specified.")
  (n, killflag)
     Lisp_Object n, killflag;
{
  CHECK_NUMBER (n, 0);
  return Fdelete_char (make_number (-XINT (n)), killflag);
}

DEFUN ("self-insert-command", Fself_insert_command, Sself_insert_command, 1, 1, "p",
  "Insert the character you type.\n\
Whichever character you type to run this command is inserted.")
  (arg)
     Lisp_Object arg;
{
  CHECK_NUMBER (arg, 0);

  /* Barf if the key that invoked this was not a character.  */
  if (XTYPE (last_command_char) != Lisp_Int)
    bitch_at_user ();
  else
    while (XINT (arg) > 0)
      {
	XFASTINT (arg)--;	/* Ok since old and new vals both nonneg */
	internal_self_insert (XINT (last_command_char), XFASTINT (arg) != 0);
      }

  return Qnil;
}

DEFUN ("newline", Fnewline, Snewline, 0, 1, "P",
  "Insert a newline.  With arg, insert that many newlines.\n\
In Auto Fill mode, if no numeric arg, break the preceding line if it's long.")
  (arg1)
     Lisp_Object arg1;
{
  int flag;
  Lisp_Object arg;
  char c1 = '\n';

  arg = Fprefix_numeric_value (arg1);

  if (!NILP (current_buffer->read_only))
    Fsignal (Qbuffer_read_only, Qnil);

  /* 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.  */

  flag = point > BEGV && FETCH_CHAR (point - 1) == '\n';
  if (flag)
    SET_PT (point - 1);

  while (XINT (arg) > 0)
    {
      if (flag)
	insert (&c1, 1);
      else
	internal_self_insert ('\n', !NILP (arg1));
      XFASTINT (arg)--;		/* Ok since old and new vals both nonneg */
    }

  if (flag)
    SET_PT (point + 1);

  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;
{
  extern Lisp_Object Fexpand_abbrev ();
  int hairy = 0;
  Lisp_Object tem;
  register enum syntaxcode synt;
  register int c = c1;

  if (!NILP (Vbefore_change_function) || !NILP (Vafter_change_function))
    hairy = 1;

  if (!NILP (current_buffer->overwrite_mode)
      && point < ZV
      && (overwrite_binary_mode || (c != '\n' && FETCH_CHAR (point) != '\n'))
      && (overwrite_binary_mode
	  || FETCH_CHAR (point) != '\t'
	  || XINT (current_buffer->tab_width) <= 0
	  || !((current_column () + 1) % XFASTINT (current_buffer->tab_width))))
    {
      del_range (point, point + 1);
      hairy = 1;
    }
  if (!NILP (current_buffer->abbrev_mode)
      && SYNTAX (c) != Sword
      && NILP (current_buffer->read_only)
      && point > BEGV && SYNTAX (FETCH_CHAR (point - 1)) == Sword)
    {
      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
      && !NILP (current_buffer->auto_fill_function)
      && current_column () > XFASTINT (current_buffer->fill_column))
    {
      if (c1 != '\n')
	insert (&c1, 1);
      call0 (current_buffer->auto_fill_function);
      if (c1 == '\n')
	insert (&c1, 1);
      hairy = 1;
    }
  else
    insert (&c1, 1);
  synt = SYNTAX (c);
  if ((synt == Sclose || synt == Smath)
      && !NILP (Vblink_paren_function) && INTERACTIVE)
    {
      call0 (Vblink_paren_function);
      hairy = 1;
    }
  return hairy;
}
\f
/* module initialization */

syms_of_cmds ()
{
  Qkill_backward_chars = intern ("kill-backward-chars");
  staticpro (&Qkill_backward_chars);

  Qkill_forward_chars = intern ("kill-forward-chars");
  staticpro (&Qkill_forward_chars);

  DEFVAR_BOOL ("overwrite-binary-mode", &overwrite_binary_mode,
    "*Non-nil means overwrite mode treats tab and newline normally.\n\
Ordinarily, overwriting preserves a tab until its whole width is overwritten\n\
and never replaces a newline.");
  overwrite_tabs_mode = 1;

  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.");
  Vblink_paren_function = Qnil;

  defsubr (&Sforward_char);
  defsubr (&Sbackward_char);
  defsubr (&Sforward_line);
  defsubr (&Sbeginning_of_line);
  defsubr (&Send_of_line);

  defsubr (&Sdelete_char);
  defsubr (&Sdelete_backward_char);

  defsubr (&Sself_insert_command);
  defsubr (&Snewline);
}

keys_of_cmds ()
{
  int n;

  initial_define_key (global_map, Ctl('M'), "newline");
  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");

  initial_define_key (global_map, Ctl ('A'), "beginning-of-line");
  initial_define_key (global_map, Ctl ('B'), "backward-char");
  initial_define_key (global_map, Ctl ('D'), "delete-char");
  initial_define_key (global_map, Ctl ('E'), "end-of-line");
  initial_define_key (global_map, Ctl ('F'), "forward-char");
  initial_define_key (global_map, 0177, "delete-backward-char");
}
Commit	Line	Data
cd645247	1	/* Simple built-in editing commands.
502ddf23	2	Copyright (C) 1985, 1992 Free Software Foundation, Inc.
cd645247 JB	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
502ddf23	8	the Free Software Foundation; either version 2, or (at your option)
cd645247 JB	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, 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20
	21	#include "config.h"
	22	#include "lisp.h"
	23	#include "commands.h"
	24	#include "buffer.h"
	25	#include "syntax.h"
	26
	27	Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;
	28
e686c647	29	int overwrite_binary_mode;
cd645247 JB	30	\f
	31	DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "p",
	32	"Move point right ARG characters (left if ARG negative).\n\
	33	On reaching end of buffer, stop and signal error.")
	34	(n)
	35	Lisp_Object n;
	36	{
265a9e55	37	if (NILP (n))
cd645247 JB	38	XFASTINT (n) = 1;
	39	else
	40	CHECK_NUMBER (n, 0);
	41
	42	SET_PT (point + XINT (n));
	43	if (point < BEGV)
	44	{
	45	SET_PT (BEGV);
	46	Fsignal (Qbeginning_of_buffer, Qnil);
	47	}
	48	if (point > ZV)
	49	{
	50	SET_PT (ZV);
	51	Fsignal (Qend_of_buffer, Qnil);
	52	}
	53	return Qnil;
	54	}
	55
	56	DEFUN ("backward-char", Fbackward_char, Sbackward_char, 0, 1, "p",
	57	"Move point left ARG characters (right if ARG negative).\n\
	58	On attempt to pass beginning or end of buffer, stop and signal error.")
	59	(n)
	60	Lisp_Object n;
	61	{
265a9e55	62	if (NILP (n))
cd645247 JB	63	XFASTINT (n) = 1;
	64	else
	65	CHECK_NUMBER (n, 0);
	66
	67	XSETINT (n, - XINT (n));
	68	return Fforward_char (n);
	69	}
	70
	71	DEFUN ("forward-line", Fforward_line, Sforward_line, 0, 1, "p",
	72	"Move ARG lines forward (backward if ARG is negative).\n\
	73	Precisely, if point is on line I, move to the start of line I + ARG.\n\
	74	If there isn't room, go as far as possible (no error).\n\
	75	Returns the count of lines left to move. If moving forward,\n\
	76	that is ARG - number of lines moved; if backward, ARG + number moved.\n\
	77	With positive ARG, a non-empty line at the end counts as one line\n\
	78	successfully moved (for the return value).")
	79	(n)
	80	Lisp_Object n;
	81	{
	82	int pos2 = point;
	83	int pos;
	84	int count, shortage, negp;
	85
265a9e55	86	if (NILP (n))
cd645247 JB	87	count = 1;
	88	else
	89	{
	90	CHECK_NUMBER (n, 0);
	91	count = XINT (n);
	92	}
	93
	94	negp = count <= 0;
	95	pos = scan_buffer ('\n', pos2, count - negp, &shortage);
	96	if (shortage > 0
	97	&& (negp
502ddf23 JB	98	\|\| (ZV > BEGV
502ddf23 JB	99	&& pos != pos2
cd645247 JB	100	&& FETCH_CHAR (pos - 1) != '\n')))
	101	shortage--;
	102	SET_PT (pos);
	103	return make_number (negp ? - shortage : shortage);
	104	}
	105
	106	DEFUN ("beginning-of-line", Fbeginning_of_line, Sbeginning_of_line,
	107	0, 1, "p",
	108	"Move point to beginning of current line.\n\
	109	With argument ARG not nil or 1, move forward ARG - 1 lines first.\n\
	110	If scan reaches end of buffer, stop there without error.")
	111	(n)
	112	Lisp_Object n;
	113	{
265a9e55	114	if (NILP (n))
cd645247 JB	115	XFASTINT (n) = 1;
	116	else
	117	CHECK_NUMBER (n, 0);
	118
	119	Fforward_line (make_number (XINT (n) - 1));
	120	return Qnil;
	121	}
	122
	123	DEFUN ("end-of-line", Fend_of_line, Send_of_line,
	124	0, 1, "p",
	125	"Move point to end of current line.\n\
	126	With argument ARG not nil or 1, move forward ARG - 1 lines first.\n\
	127	If scan reaches end of buffer, stop there without error.")
	128	(n)
	129	Lisp_Object n;
	130	{
	131	register int pos;
	132	register int stop;
	133
265a9e55	134	if (NILP (n))
cd645247 JB	135	XFASTINT (n) = 1;
	136	else
	137	CHECK_NUMBER (n, 0);
	138
	139	if (XINT (n) != 1)
	140	Fforward_line (make_number (XINT (n) - 1));
	141
	142	pos = point;
	143	stop = ZV;
	144	while (pos < stop && FETCH_CHAR (pos) != '\n') pos++;
	145	SET_PT (pos);
	146
	147	return Qnil;
	148	}
	149
	150	DEFUN ("delete-char", Fdelete_char, Sdelete_char, 1, 2, "p\nP",
	151	"Delete the following ARG characters (previous, with negative arg).\n\
	152	Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\
	153	Interactively, ARG is the prefix arg, and KILLFLAG is set if\n\
	154	ARG was explicitly specified.")
	155	(n, killflag)
	156	Lisp_Object n, killflag;
	157	{
	158	CHECK_NUMBER (n, 0);
	159
265a9e55	160	if (NILP (killflag))
cd645247 JB	161	{
	162	if (XINT (n) < 0)
	163	{
	164	if (point + XINT (n) < BEGV)
	165	Fsignal (Qbeginning_of_buffer, Qnil);
	166	else
	167	del_range (point + XINT (n), point);
	168	}
	169	else
	170	{
	171	if (point + XINT (n) > ZV)
	172	Fsignal (Qend_of_buffer, Qnil);
	173	else
	174	del_range (point, point + XINT (n));
	175	}
	176	}
	177	else
	178	{
	179	call1 (Qkill_forward_chars, n);
	180	}
	181	return Qnil;
	182	}
	183
	184	DEFUN ("delete-backward-char", Fdelete_backward_char, Sdelete_backward_char,
	185	1, 2, "p\nP",
	186	"Delete the previous ARG characters (following, with negative ARG).\n\
	187	Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\
	188	Interactively, ARG is the prefix arg, and KILLFLAG is set if\n\
	189	ARG was explicitly specified.")
	190	(n, killflag)
	191	Lisp_Object n, killflag;
	192	{
	193	CHECK_NUMBER (n, 0);
	194	return Fdelete_char (make_number (-XINT (n)), killflag);
	195	}
	196
	197	DEFUN ("self-insert-command", Fself_insert_command, Sself_insert_command, 1, 1, "p",
	198	"Insert the character you type.\n\
	199	Whichever character you type to run this command is inserted.")
	200	(arg)
	201	Lisp_Object arg;
	202	{
	203	CHECK_NUMBER (arg, 0);
	204
	205	/* Barf if the key that invoked this was not a character. */
	206	if (XTYPE (last_command_char) != Lisp_Int)
	207	bitch_at_user ();
	208	else
	209	while (XINT (arg) > 0)
	210	{
	211	XFASTINT (arg)--; /* Ok since old and new vals both nonneg */
	212	internal_self_insert (XINT (last_command_char), XFASTINT (arg) != 0);
	213	}
	214
	215	return Qnil;
	216	}
	217
	218	DEFUN ("newline", Fnewline, Snewline, 0, 1, "P",
	219	"Insert a newline. With arg, insert that many newlines.\n\
	220	In Auto Fill mode, if no numeric arg, break the preceding line if it's long.")
	221	(arg1)
	222	Lisp_Object arg1;
	223	{
	224	int flag;
225	Lisp_Object arg;
226	char c1 = '\n';
227
228	arg = Fprefix_numeric_value (arg1);
229
265a9e55	230	if (!NILP (current_buffer->read_only))
cd645247 JB	231	Fsignal (Qbuffer_read_only, Qnil);
	232
	233	/* Inserting a newline at the end of a line
	234	produces better redisplay in try_window_id
	235	than inserting at the ebginning fo a line,
	236	And the textual result is the same.
	237	So if at beginning, pretend to be at the end.
	238	Must avoid internal_self_insert in that case since point is wrong.
	239	Luckily internal_self_insert's special features all do nothing in that case. */
	240
	241	flag = point > BEGV && FETCH_CHAR (point - 1) == '\n';
	242	if (flag)
	243	SET_PT (point - 1);
	244
	245	while (XINT (arg) > 0)
	246	{
	247	if (flag)
	248	insert (&c1, 1);
	249	else
265a9e55	250	internal_self_insert ('\n', !NILP (arg1));
cd645247 JB	251	XFASTINT (arg)--; /* Ok since old and new vals both nonneg */
	252	}
	253
	254	if (flag)
	255	SET_PT (point + 1);
	256
	257	return Qnil;
	258	}
	259
4c6e656f RS	260	/* Insert character C1. If NOAUTOFILL is nonzero, don't do autofill
	261	even if it is enabled.
	262
	263	If this insertion is suitable for direct output (completely simple),
	264	return 0. A value of 1 indicates this might not have been simple. */
	265
cd645247 JB	266	internal_self_insert (c1, noautofill)
	267	char c1;
	268	int noautofill;
	269	{
	270	extern Lisp_Object Fexpand_abbrev ();
	271	int hairy = 0;
	272	Lisp_Object tem;
	273	register enum syntaxcode synt;
	274	register int c = c1;
	275
265a9e55	276	if (!NILP (Vbefore_change_function) \|\| !NILP (Vafter_change_function))
cd645247 JB	277	hairy = 1;
cd645247 JB	278
265a9e55	279	if (!NILP (current_buffer->overwrite_mode)
cd645247	280	&& point < ZV
e686c647 RS	281	&& (overwrite_binary_mode \|\| (c != '\n' && FETCH_CHAR (point) != '\n'))
	282	&& (overwrite_binary_mode
	283	\|\| FETCH_CHAR (point) != '\t'
cd645247 JB	284	\|\| XINT (current_buffer->tab_width) <= 0
	285	\|\| !((current_column () + 1) % XFASTINT (current_buffer->tab_width))))
	286	{
	287	del_range (point, point + 1);
	288	hairy = 1;
	289	}
265a9e55	290	if (!NILP (current_buffer->abbrev_mode)
cd645247	291	&& SYNTAX (c) != Sword
265a9e55	292	&& NILP (current_buffer->read_only)
cd645247 JB	293	&& point > BEGV && SYNTAX (FETCH_CHAR (point - 1)) == Sword)
cd645247 JB	294	{
ee8caabb	295	int modiff = MODIFF;
4c6e656f RS	296	Fexpand_abbrev ();
4c6e656f RS	297	/* We can't trust the value of Fexpand_abbrev,
ee8caabb RS	298	but if Fexpand_abbrev changed the buffer,
	299	assume it expanded something. */
	300	if (MODIFF != modiff)
cd645247 JB	301	hairy = 1;
	302	}
	303	if ((c == ' ' \|\| c == '\n')
	304	&& !noautofill
265a9e55	305	&& !NILP (current_buffer->auto_fill_function)
cd645247 JB	306	&& current_column () > XFASTINT (current_buffer->fill_column))
	307	{
	308	if (c1 != '\n')
	309	insert (&c1, 1);
	310	call0 (current_buffer->auto_fill_function);
	311	if (c1 == '\n')
	312	insert (&c1, 1);
	313	hairy = 1;
	314	}
	315	else
	316	insert (&c1, 1);
	317	synt = SYNTAX (c);
	318	if ((synt == Sclose \|\| synt == Smath)
265a9e55	319	&& !NILP (Vblink_paren_function) && INTERACTIVE)
cd645247 JB	320	{
	321	call0 (Vblink_paren_function);
	322	hairy = 1;
	323	}
	324	return hairy;
	325	}
	326	\f
	327	/* module initialization */
	328
	329	syms_of_cmds ()
	330	{
	331	Qkill_backward_chars = intern ("kill-backward-chars");
	332	staticpro (&Qkill_backward_chars);
	333
	334	Qkill_forward_chars = intern ("kill-forward-chars");
	335	staticpro (&Qkill_forward_chars);
	336
e686c647 RS	337	DEFVAR_BOOL ("overwrite-binary-mode", &overwrite_binary_mode,
	338	"*Non-nil means overwrite mode treats tab and newline normally.\n\
	339	Ordinarily, overwriting preserves a tab until its whole width is overwritten\n\
	340	and never replaces a newline.");
	341	overwrite_tabs_mode = 1;
	342
cd645247 JB	343	DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function,
	344	"Function called, if non-nil, whenever a close parenthesis is inserted.\n\
	345	More precisely, a char with closeparen syntax is self-inserted.");
	346	Vblink_paren_function = Qnil;
	347
	348	defsubr (&Sforward_char);
	349	defsubr (&Sbackward_char);
	350	defsubr (&Sforward_line);
	351	defsubr (&Sbeginning_of_line);
	352	defsubr (&Send_of_line);
	353
	354	defsubr (&Sdelete_char);
	355	defsubr (&Sdelete_backward_char);
	356
	357	defsubr (&Sself_insert_command);
	358	defsubr (&Snewline);
	359	}
	360
	361	keys_of_cmds ()
	362	{
	363	int n;
	364
	365	initial_define_key (global_map, Ctl('M'), "newline");
	366	initial_define_key (global_map, Ctl('I'), "self-insert-command");
	367	for (n = 040; n < 0177; n++)
	368	initial_define_key (global_map, n, "self-insert-command");
	369
	370	initial_define_key (global_map, Ctl ('A'), "beginning-of-line");
	371	initial_define_key (global_map, Ctl ('B'), "backward-char");
	372	initial_define_key (global_map, Ctl ('D'), "delete-char");
	373	initial_define_key (global_map, Ctl ('E'), "end-of-line");
	374	initial_define_key (global_map, Ctl ('F'), "forward-char");
	375	initial_define_key (global_map, 0177, "delete-backward-char");
	376	}