editfns.c

/* Lisp functions pertaining to editing.
   Copyright (C) 1985,86,87,89,93,94,95,96,97,98, 1999, 2000
	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, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */


#include <config.h>
#include <sys/types.h>

#ifdef VMS
#include "vms-pwd.h"
#else
#include <pwd.h>
#endif

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include "lisp.h"
#include "intervals.h"
#include "buffer.h"
#include "charset.h"
#include "coding.h"
#include "window.h"

#include "systime.h"

#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))

#ifndef NULL
#define NULL 0
#endif

#ifndef USE_CRT_DLL
extern char **environ;
#endif

extern Lisp_Object make_time P_ ((time_t));
extern size_t emacs_strftimeu P_ ((char *, size_t, const char *,
				   const struct tm *, int));
static int tm_diff P_ ((struct tm *, struct tm *));
static void find_field P_ ((Lisp_Object, Lisp_Object, int *, int *));
static void update_buffer_properties P_ ((int, int));
static Lisp_Object region_limit P_ ((int));
static int lisp_time_argument P_ ((Lisp_Object, time_t *, int *));
static size_t emacs_memftimeu P_ ((char *, size_t, const char *,
				   size_t, const struct tm *, int));
static void general_insert_function P_ ((void (*) (unsigned char *, int),
					 void (*) (Lisp_Object, int, int, int,
						   int, int),
					 int, int, Lisp_Object *));
static Lisp_Object subst_char_in_region_unwind P_ ((Lisp_Object));
static Lisp_Object subst_char_in_region_unwind_1 P_ ((Lisp_Object));
static void transpose_markers P_ ((int, int, int, int, int, int, int, int));

#ifdef HAVE_INDEX
extern char *index P_ ((const char *, int));
#endif

Lisp_Object Vbuffer_access_fontify_functions;
Lisp_Object Qbuffer_access_fontify_functions;
Lisp_Object Vbuffer_access_fontified_property;

Lisp_Object Fuser_full_name P_ ((Lisp_Object));

/* Non-nil means don't stop at field boundary in text motion commands.  */

Lisp_Object Vinhibit_field_text_motion;

/* Some static data, and a function to initialize it for each run */

Lisp_Object Vsystem_name;
Lisp_Object Vuser_real_login_name;	/* login name of current user ID */
Lisp_Object Vuser_full_name;		/* full name of current user */
Lisp_Object Vuser_login_name;		/* user name from LOGNAME or USER */

/* Symbol for the text property used to mark fields.  */

Lisp_Object Qfield;

/* A special value for Qfield properties.  */

Lisp_Object Qboundary;


void
init_editfns ()
{
  char *user_name;
  register unsigned char *p;
  struct passwd *pw;	/* password entry for the current user */
  Lisp_Object tem;

  /* Set up system_name even when dumping.  */
  init_system_name ();

#ifndef CANNOT_DUMP
  /* Don't bother with this on initial start when just dumping out */
  if (!initialized)
    return;
#endif /* not CANNOT_DUMP */

  pw = (struct passwd *) getpwuid (getuid ());
#ifdef MSDOS
  /* We let the real user name default to "root" because that's quite
     accurate on MSDOG and because it lets Emacs find the init file.
     (The DVX libraries override the Djgpp libraries here.)  */
  Vuser_real_login_name = build_string (pw ? pw->pw_name : "root");
#else
  Vuser_real_login_name = build_string (pw ? pw->pw_name : "unknown");
#endif

  /* Get the effective user name, by consulting environment variables,
     or the effective uid if those are unset.  */
  user_name = (char *) getenv ("LOGNAME");
  if (!user_name)
#ifdef WINDOWSNT
    user_name = (char *) getenv ("USERNAME");	/* it's USERNAME on NT */
#else  /* WINDOWSNT */
    user_name = (char *) getenv ("USER");
#endif /* WINDOWSNT */
  if (!user_name)
    {
      pw = (struct passwd *) getpwuid (geteuid ());
      user_name = (char *) (pw ? pw->pw_name : "unknown");
    }
  Vuser_login_name = build_string (user_name);

  /* If the user name claimed in the environment vars differs from
     the real uid, use the claimed name to find the full name.  */
  tem = Fstring_equal (Vuser_login_name, Vuser_real_login_name);
  Vuser_full_name = Fuser_full_name (NILP (tem)? make_number (geteuid())
				     : Vuser_login_name);

  p = (unsigned char *) getenv ("NAME");
  if (p)
    Vuser_full_name = build_string (p);
  else if (NILP (Vuser_full_name))
    Vuser_full_name = build_string ("unknown");
}

DEFUN ("char-to-string", Fchar_to_string, Schar_to_string, 1, 1, 0,
  "Convert arg CHAR to a string containing that character.")
  (character)
     Lisp_Object character;
{
  int len;
  unsigned char str[MAX_MULTIBYTE_LENGTH];

  CHECK_NUMBER (character, 0);

  len = CHAR_STRING (XFASTINT (character), str);
  return make_string_from_bytes (str, 1, len);
}

DEFUN ("string-to-char", Fstring_to_char, Sstring_to_char, 1, 1, 0,
  "Convert arg STRING to a character, the first character of that string.\n\
A multibyte character is handled correctly.")
  (string)
     register Lisp_Object string;
{
  register Lisp_Object val;
  register struct Lisp_String *p;
  CHECK_STRING (string, 0);
  p = XSTRING (string);
  if (p->size)
    {
      if (STRING_MULTIBYTE (string))
	XSETFASTINT (val, STRING_CHAR (p->data, STRING_BYTES (p)));
      else
	XSETFASTINT (val, p->data[0]);
    }
  else
    XSETFASTINT (val, 0);
  return val;
}

static Lisp_Object
buildmark (charpos, bytepos)
     int charpos, bytepos;
{
  register Lisp_Object mark;
  mark = Fmake_marker ();
  set_marker_both (mark, Qnil, charpos, bytepos);
  return mark;
}

DEFUN ("point", Fpoint, Spoint, 0, 0, 0,
  "Return value of point, as an integer.\n\
Beginning of buffer is position (point-min)")
  ()
{
  Lisp_Object temp;
  XSETFASTINT (temp, PT);
  return temp;
}

DEFUN ("point-marker", Fpoint_marker, Spoint_marker, 0, 0, 0,
   "Return value of point, as a marker object.")
  ()
{
  return buildmark (PT, PT_BYTE);
}

int
clip_to_bounds (lower, num, upper)
     int lower, num, upper;
{
  if (num < lower)
    return lower;
  else if (num > upper)
    return upper;
  else
    return num;
}

DEFUN ("goto-char", Fgoto_char, Sgoto_char, 1, 1, "NGoto char: ",
  "Set point to POSITION, a number or marker.\n\
Beginning of buffer is position (point-min), end is (point-max).\n\
If the position is in the middle of a multibyte form,\n\
the actual point is set at the head of the multibyte form\n\
except in the case that `enable-multibyte-characters' is nil.")
  (position)
     register Lisp_Object position;
{
  int pos;

  if (MARKERP (position)
      && current_buffer == XMARKER (position)->buffer)
    {
      pos = marker_position (position);
      if (pos < BEGV)
	SET_PT_BOTH (BEGV, BEGV_BYTE);
      else if (pos > ZV)
	SET_PT_BOTH (ZV, ZV_BYTE);
      else
	SET_PT_BOTH (pos, marker_byte_position (position));

      return position;
    }

  CHECK_NUMBER_COERCE_MARKER (position, 0);

  pos = clip_to_bounds (BEGV, XINT (position), ZV);
  SET_PT (pos);
  return position;
}


/* Return the start or end position of the region.
   BEGINNINGP non-zero means return the start.
   If there is no region active, signal an error. */

static Lisp_Object
region_limit (beginningp)
     int beginningp;
{
  extern Lisp_Object Vmark_even_if_inactive; /* Defined in callint.c. */
  Lisp_Object m;
  
  if (!NILP (Vtransient_mark_mode)
      && NILP (Vmark_even_if_inactive)
      && NILP (current_buffer->mark_active))
    Fsignal (Qmark_inactive, Qnil);
  
  m = Fmarker_position (current_buffer->mark);
  if (NILP (m))
    error ("There is no region now");
  
  if ((PT < XFASTINT (m)) == beginningp)
    m = make_number (PT);
  return m;
}

DEFUN ("region-beginning", Fregion_beginning, Sregion_beginning, 0, 0, 0,
  "Return position of beginning of region, as an integer.")
  ()
{
  return region_limit (1);
}

DEFUN ("region-end", Fregion_end, Sregion_end, 0, 0, 0,
  "Return position of end of region, as an integer.")
  ()
{
  return region_limit (0);
}

DEFUN ("mark-marker", Fmark_marker, Smark_marker, 0, 0, 0,
  "Return this buffer's mark, as a marker object.\n\
Watch out!  Moving this marker changes the mark position.\n\
If you set the marker not to point anywhere, the buffer will have no mark.")
  ()
{
  return current_buffer->mark;
}


/* Return nonzero if POS1 and POS2 have the same value
   for the text property PROP.  */

static int
char_property_eq (prop, pos1, pos2)
     Lisp_Object prop;
     Lisp_Object pos1, pos2;
{
  Lisp_Object pval1, pval2;

  pval1 = Fget_char_property (pos1, prop, Qnil);
  pval2 = Fget_char_property (pos2, prop, Qnil);

  return EQ (pval1, pval2);
}

/* Return the direction from which the text-property PROP would be
   inherited by any new text inserted at POS: 1 if it would be
   inherited from the char after POS, -1 if it would be inherited from
   the char before POS, and 0 if from neither.  */

static int
text_property_stickiness (prop, pos)
     Lisp_Object prop;
     Lisp_Object pos;
{
  Lisp_Object front_sticky;

  if (XINT (pos) > BEGV)
    /* Consider previous character.  */
    {
      Lisp_Object prev_pos, rear_non_sticky;

      prev_pos = make_number (XINT (pos) - 1);
      rear_non_sticky = Fget_text_property (prev_pos, Qrear_nonsticky, Qnil);

      if (EQ (rear_non_sticky, Qnil)
	  || (CONSP (rear_non_sticky)
	      && NILP (Fmemq (prop, rear_non_sticky))))
	/* PROP is not rear-non-sticky, and since this takes precedence over
	   any front-stickiness, PROP is inherited from before.  */
	return -1;
    }

  /* Consider following character.  */
  front_sticky = Fget_text_property (pos, Qfront_sticky, Qnil);

  if (EQ (front_sticky, Qt)
      || (CONSP (front_sticky)
	  && !NILP (Fmemq (prop, front_sticky))))
    /* PROP is inherited from after.  */
    return 1;

  /* PROP is not inherited from either side.  */
  return 0;
}


/* Find the field surrounding POS in *BEG and *END.  If POS is nil,
   the value of point is used instead.  If BEG or END null,
   means don't store the beginning or end of the field.

   If MERGE_AT_BOUNDARY is nonzero, then if POS is at the very first
   position of a field, then the beginning of the previous field is
   returned instead of the beginning of POS's field (since the end of a
   field is actually also the beginning of the next input field, this
   behavior is sometimes useful).  Additionally in the MERGE_AT_BOUNDARY
   true case, if two fields are separated by a field with the special
   value `boundary', and POS lies within it, then the two separated
   fields are considered to be adjacent, and POS between them, when
   finding the beginning and ending of the "merged" field.

   Either BEG or END may be 0, in which case the corresponding value
   is not stored.  */

static void
find_field (pos, merge_at_boundary, beg, end)
     Lisp_Object pos;
     Lisp_Object merge_at_boundary;
     int *beg, *end;
{
  /* Fields right before and after the point.  */
  Lisp_Object before_field, after_field;
  /* If the fields came from overlays, the associated overlays.
     Qnil means they came from text-properties.  */
  Lisp_Object before_overlay = Qnil, after_overlay = Qnil;
  /* 1 if POS counts as the start of a field.  */
  int at_field_start = 0;
  /* 1 if POS counts as the end of a field.  */
  int at_field_end = 0;

  if (NILP (pos))
    XSETFASTINT (pos, PT);
  else
    CHECK_NUMBER_COERCE_MARKER (pos, 0);

  after_field
    = get_char_property_and_overlay (pos, Qfield, Qnil, &after_overlay);
  before_field
    = (XFASTINT (pos) > BEGV
       ? get_char_property_and_overlay (make_number (XINT (pos) - 1),
					Qfield, Qnil,
					&before_overlay)
       : Qnil);

  /* See if we need to handle the case where MERGE_AT_BOUNDARY is nil
     and POS is at beginning of a field, which can also be interpreted
     as the end of the previous field.  Note that the case where if
     MERGE_AT_BOUNDARY is non-nil (see function comment) is actually the
     more natural one; then we avoid treating the beginning of a field
     specially.  */
  if (NILP (merge_at_boundary) && !EQ (after_field, before_field))
    /* We are at a boundary, see which direction is inclusive.  We
       decide by seeing which field the `field' property sticks to.  */
    {
      /* -1 means insertions go into before_field, 1 means they go
	 into after_field, 0 means neither.  */
      int stickiness;
      /* Whether the before/after_field come from overlays.  */
      int bop = !NILP (before_overlay);
      int aop = !NILP (after_overlay);

      if (bop && XMARKER (OVERLAY_END (before_overlay))->insertion_type == 1)
	/* before_field is from an overlay, which expands upon
	   end-insertions.  Note that it's possible for after_overlay to
	   also eat insertions here, but then they will overlap, and
	   there's not much we can do.  */
	stickiness = -1;
      else if (aop
	       && XMARKER (OVERLAY_START (after_overlay))->insertion_type == 0)
	/* after_field is from an overlay, which expand to contain
	   start-insertions.  */
	stickiness = 1;
      else if (bop && aop)
	/* Both fields come from overlays, but neither will contain any
	   insertion here.  */
	stickiness = 0;
      else if (bop)
	/* before_field is an overlay that won't eat any insertion, but
	   after_field is from a text-property.  Assume that the
	   text-property continues underneath the overlay, and so will
	   be inherited by any insertion, regardless of any stickiness
	   settings.  */
	stickiness = 1;
      else if (aop)
	/* Similarly, when after_field is the overlay.  */
	stickiness = -1;
      else
	/* Both fields come from text-properties.  Look for explicit
	   stickiness properties.  */
	stickiness = text_property_stickiness (Qfield, pos);

      if (stickiness > 0)
	at_field_start = 1;
      else if (stickiness < 0)
	at_field_end = 1;
      else
	/* STICKINESS == 0 means that any inserted text will get a
	   `field' char-property of nil, so check to see if that
	   matches either of the adjacent characters (this being a
	   kind of "stickiness by default").  */
	{
	  if (NILP (before_field))
	    at_field_end = 1; /* Sticks to the left.  */
	  else if (NILP (after_field))
	    at_field_start = 1; /* Sticks to the right.  */
	}
    }

  /* Note about special `boundary' fields:

     Consider the case where the point (`.') is between the fields `x' and `y':

	xxxx.yyyy

     In this situation, if merge_at_boundary is true, we consider the
     `x' and `y' fields as forming one big merged field, and so the end
     of the field is the end of `y'.

     However, if `x' and `y' are separated by a special `boundary' field
     (a field with a `field' char-property of 'boundary), then we ignore
     this special field when merging adjacent fields.  Here's the same
     situation, but with a `boundary' field between the `x' and `y' fields:

	xxx.BBBByyyy

     Here, if point is at the end of `x', the beginning of `y', or
     anywhere in-between (within the `boundary' field), we merge all
     three fields and consider the beginning as being the beginning of
     the `x' field, and the end as being the end of the `y' field.  */

  if (beg)
    {
      if (at_field_start)
	/* POS is at the edge of a field, and we should consider it as
	   the beginning of the following field.  */
	*beg = XFASTINT (pos);
      else
	/* Find the previous field boundary.  */
	{
	  if (!NILP (merge_at_boundary) && EQ (before_field, Qboundary))
	    /* Skip a `boundary' field.  */
	    pos = Fprevious_single_char_property_change (pos, Qfield, Qnil,Qnil);

	  pos = Fprevious_single_char_property_change (pos, Qfield, Qnil, Qnil);
	  *beg = NILP (pos) ? BEGV : XFASTINT (pos);
	}
    }

  if (end)
    {
      if (at_field_end)
	/* POS is at the edge of a field, and we should consider it as
	   the end of the previous field.  */
	*end = XFASTINT (pos);
      else
	/* Find the next field boundary.  */
	{
	  if (!NILP (merge_at_boundary) && EQ (after_field, Qboundary))
	    /* Skip a `boundary' field.  */
	    pos = Fnext_single_char_property_change (pos, Qfield, Qnil, Qnil);

	  pos = Fnext_single_char_property_change (pos, Qfield, Qnil, Qnil);
	  *end = NILP (pos) ? ZV : XFASTINT (pos);
	}
    }
}


DEFUN ("delete-field", Fdelete_field, Sdelete_field, 0, 1, 0,
  "Delete the field surrounding POS.\n\
A field is a region of text with the same `field' property.\n\
If POS is nil, the value of point is used for POS.")
  (pos)
     Lisp_Object pos;
{
  int beg, end;
  find_field (pos, Qnil, &beg, &end);
  if (beg != end)
    del_range (beg, end);
  return Qnil;
}

DEFUN ("field-string", Ffield_string, Sfield_string, 0, 1, 0,
  "Return the contents of the field surrounding POS as a string.\n\
A field is a region of text with the same `field' property.\n\
If POS is nil, the value of point is used for POS.")
  (pos)
     Lisp_Object pos;
{
  int beg, end;
  find_field (pos, Qnil, &beg, &end);
  return make_buffer_string (beg, end, 1);
}

DEFUN ("field-string-no-properties", Ffield_string_no_properties, Sfield_string_no_properties, 0, 1, 0,
  "Return the contents of the field around POS, without text-properties.\n\
A field is a region of text with the same `field' property.\n\
If POS is nil, the value of point is used for POS.")
  (pos)
     Lisp_Object pos;
{
  int beg, end;
  find_field (pos, Qnil, &beg, &end);
  return make_buffer_string (beg, end, 0);
}

DEFUN ("field-beginning", Ffield_beginning, Sfield_beginning, 0, 2, 0,
  "Return the beginning of the field surrounding POS.\n\
A field is a region of text with the same `field' property.\n\
If POS is nil, the value of point is used for POS.\n\
If ESCAPE-FROM-EDGE is non-nil and POS is at the beginning of its\n\
field, then the beginning of the *previous* field is returned.")
  (pos, escape_from_edge)
     Lisp_Object pos, escape_from_edge;
{
  int beg;
  find_field (pos, escape_from_edge, &beg, 0);
  return make_number (beg);
}

DEFUN ("field-end", Ffield_end, Sfield_end, 0, 2, 0,
  "Return the end of the field surrounding POS.\n\
A field is a region of text with the same `field' property.\n\
If POS is nil, the value of point is used for POS.\n\
If ESCAPE-FROM-EDGE is non-nil and POS is at the end of its field,\n\
then the end of the *following* field is returned.")
  (pos, escape_from_edge)
     Lisp_Object pos, escape_from_edge;
{
  int end;
  find_field (pos, escape_from_edge, 0, &end);
  return make_number (end);
}

DEFUN ("constrain-to-field", Fconstrain_to_field, Sconstrain_to_field, 2, 5, 0,
  "Return the position closest to NEW-POS that is in the same field as OLD-POS.\n\
\n\
A field is a region of text with the same `field' property.\n\
If NEW-POS is nil, then the current point is used instead, and set to the\n\
constrained position if that is is different.\n\
\n\
If OLD-POS is at the boundary of two fields, then the allowable\n\
positions for NEW-POS depends on the value of the optional argument\n\
ESCAPE-FROM-EDGE: If ESCAPE-FROM-EDGE is nil, then NEW-POS is\n\
constrained to the field that has the same `field' char-property\n\
as any new characters inserted at OLD-POS, whereas if ESCAPE-FROM-EDGE\n\
is non-nil, NEW-POS is constrained to the union of the two adjacent\n\
fields.  Additionally, if two fields are separated by another field with\n\
the special value `boundary', then any point within this special field is\n\
also considered to be `on the boundary'.\n\
\n\
If the optional argument ONLY-IN-LINE is non-nil and constraining\n\
NEW-POS would move it to a different line, NEW-POS is returned\n\
unconstrained.  This useful for commands that move by line, like\n\
\\[next-line] or \\[beginning-of-line], which should generally respect field boundaries\n\
only in the case where they can still move to the right line.\n\
\n\
If the optional argument INHIBIT-CAPTURE-PROPERTY is non-nil, and OLD-POS has\n\
a non-nil property of that name, then any field boundaries are ignored.\n\
\n\
Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.")
  (new_pos, old_pos, escape_from_edge, only_in_line, inhibit_capture_property)
     Lisp_Object new_pos, old_pos;
     Lisp_Object escape_from_edge, only_in_line, inhibit_capture_property;
{
  /* If non-zero, then the original point, before re-positioning.  */
  int orig_point = 0;

  if (NILP (new_pos))
    /* Use the current point, and afterwards, set it.  */
    {
      orig_point = PT;
      XSETFASTINT (new_pos, PT);
    }

  if (NILP (Vinhibit_field_text_motion)
      && !EQ (new_pos, old_pos)
      && (!NILP (Fget_char_property (new_pos, Qfield, Qnil))
	  || !NILP (Fget_char_property (old_pos, Qfield, Qnil)))
      && (NILP (inhibit_capture_property)
	  || NILP (Fget_char_property(old_pos, inhibit_capture_property, Qnil))))
    /* NEW_POS is not within the same field as OLD_POS; try to
       move NEW_POS so that it is.  */
    {
      int fwd, shortage;
      Lisp_Object field_bound;

      CHECK_NUMBER_COERCE_MARKER (new_pos, 0);
      CHECK_NUMBER_COERCE_MARKER (old_pos, 0);

      fwd = (XFASTINT (new_pos) > XFASTINT (old_pos));

      if (fwd)
	field_bound = Ffield_end (old_pos, escape_from_edge);
      else
	field_bound = Ffield_beginning (old_pos, escape_from_edge);

      if (/* See if ESCAPE_FROM_EDGE caused FIELD_BOUND to jump to the
             other side of NEW_POS, which would mean that NEW_POS is
             already acceptable, and it's not necessary to constrain it
             to FIELD_BOUND.  */
	  ((XFASTINT (field_bound) < XFASTINT (new_pos)) ? fwd : !fwd)
	  /* NEW_POS should be constrained, but only if either
	     ONLY_IN_LINE is nil (in which case any constraint is OK),
	     or NEW_POS and FIELD_BOUND are on the same line (in which
	     case the constraint is OK even if ONLY_IN_LINE is non-nil). */
	  && (NILP (only_in_line)
	      /* This is the ONLY_IN_LINE case, check that NEW_POS and
		 FIELD_BOUND are on the same line by seeing whether
		 there's an intervening newline or not.  */
	      || (scan_buffer ('\n',
			       XFASTINT (new_pos), XFASTINT (field_bound),
			       fwd ? -1 : 1, &shortage, 1),
		  shortage != 0)))
	/* Constrain NEW_POS to FIELD_BOUND.  */
	new_pos = field_bound;

      if (orig_point && XFASTINT (new_pos) != orig_point)
	/* The NEW_POS argument was originally nil, so automatically set PT. */
	SET_PT (XFASTINT (new_pos));
    }

  return new_pos;
}


DEFUN ("line-beginning-position", Fline_beginning_position, Sline_beginning_position,
  0, 1, 0,
  "Return the character position of the first character on the current line.\n\
With argument N not nil or 1, move forward N - 1 lines first.\n\
If scan reaches end of buffer, return that position.\n\
The scan does not cross a field boundary unless it would move\n\
beyond there to a different line.  Field boundaries are not noticed if\n\
`inhibit-field-text-motion' is non-nil. .And if N is nil or 1,\n\
and scan starts at a field boundary, the scan stops as soon as it starts.\n\
\n\
This function does not move point.")
  (n)
     Lisp_Object n;
{
  int orig, orig_byte, end;

  if (NILP (n))
    XSETFASTINT (n, 1);
  else
    CHECK_NUMBER (n, 0);

  orig = PT;
  orig_byte = PT_BYTE;
  Fforward_line (make_number (XINT (n) - 1));
  end = PT;

  SET_PT_BOTH (orig, orig_byte);

  /* Return END constrained to the current input field.  */
  return Fconstrain_to_field (make_number (end), make_number (orig),
			      XINT (n) != 1 ? Qt : Qnil,
			      Qt, Qnil);
}

DEFUN ("line-end-position", Fline_end_position, Sline_end_position,
  0, 1, 0,
  "Return the character position of the last character on the current line.\n\
With argument N not nil or 1, move forward N - 1 lines first.\n\
If scan reaches end of buffer, return that position.\n\
This function does not move point.")
  (n)
     Lisp_Object n;
{
  int end_pos;
  int orig = PT;

  if (NILP (n))
    XSETFASTINT (n, 1);
  else
    CHECK_NUMBER (n, 0);

  end_pos = find_before_next_newline (orig, 0, XINT (n) - (XINT (n) <= 0));

  /* Return END_POS constrained to the current input field.  */
  return Fconstrain_to_field (make_number (end_pos), make_number (orig),
			      Qnil, Qt, Qnil);
}

Lisp_Object
save_excursion_save ()
{
  int visible = (XBUFFER (XWINDOW (selected_window)->buffer)
		 == current_buffer);

  return Fcons (Fpoint_marker (),
		Fcons (Fcopy_marker (current_buffer->mark, Qnil),
		       Fcons (visible ? Qt : Qnil,
			      Fcons (current_buffer->mark_active,
				     selected_window))));
}

Lisp_Object
save_excursion_restore (info)
     Lisp_Object info;
{
  Lisp_Object tem, tem1, omark, nmark;
  struct gcpro gcpro1, gcpro2, gcpro3;
  int visible_p;

  tem = Fmarker_buffer (XCAR (info));
  /* If buffer being returned to is now deleted, avoid error */
  /* Otherwise could get error here while unwinding to top level
     and crash */
  /* In that case, Fmarker_buffer returns nil now.  */
  if (NILP (tem))
    return Qnil;

  omark = nmark = Qnil;
  GCPRO3 (info, omark, nmark);

  Fset_buffer (tem);

  /* Point marker.  */
  tem = XCAR (info);
  Fgoto_char (tem);
  unchain_marker (tem);

  /* Mark marker.  */
  info = XCDR (info);
  tem = XCAR (info);
  omark = Fmarker_position (current_buffer->mark);
  Fset_marker (current_buffer->mark, tem, Fcurrent_buffer ());
  nmark = Fmarker_position (tem);
  unchain_marker (tem);

  /* visible */
  info = XCDR (info);
  visible_p = !NILP (XCAR (info));
  
#if 0 /* We used to make the current buffer visible in the selected window
	 if that was true previously.  That avoids some anomalies.
	 But it creates others, and it wasn't documented, and it is simpler
	 and cleaner never to alter the window/buffer connections.  */
  tem1 = Fcar (tem);
  if (!NILP (tem1)
      && current_buffer != XBUFFER (XWINDOW (selected_window)->buffer))
    Fswitch_to_buffer (Fcurrent_buffer (), Qnil);
#endif /* 0 */

  /* Mark active */
  info = XCDR (info);
  tem = XCAR (info);
  tem1 = current_buffer->mark_active;
  current_buffer->mark_active = tem;

  if (!NILP (Vrun_hooks))
    {
      /* If mark is active now, and either was not active
	 or was at a different place, run the activate hook.  */
      if (! NILP (current_buffer->mark_active))
	{
	  if (! EQ (omark, nmark))
	    call1 (Vrun_hooks, intern ("activate-mark-hook"));
	}
      /* If mark has ceased to be active, run deactivate hook.  */
      else if (! NILP (tem1))
	call1 (Vrun_hooks, intern ("deactivate-mark-hook"));
    }

  /* If buffer was visible in a window, and a different window was
     selected, and the old selected window is still live, restore
     point in that window.  */
  tem = XCDR (info);
  if (visible_p
      && !EQ (tem, selected_window)
      && !NILP (Fwindow_live_p (tem)))
    Fset_window_point (tem, make_number (PT));

  UNGCPRO;
  return Qnil;
}

DEFUN ("save-excursion", Fsave_excursion, Ssave_excursion, 0, UNEVALLED, 0,
  "Save point, mark, and current buffer; execute BODY; restore those things.\n\
Executes BODY just like `progn'.\n\
The values of point, mark and the current buffer are restored\n\
even in case of abnormal exit (throw or error).\n\
The state of activation of the mark is also restored.\n\
\n\
This construct does not save `deactivate-mark', and therefore\n\
functions that change the buffer will still cause deactivation\n\
of the mark at the end of the command.  To prevent that, bind\n\
`deactivate-mark' with `let'.")
  (args)
     Lisp_Object args;
{
  register Lisp_Object val;
  int count = specpdl_ptr - specpdl;

  record_unwind_protect (save_excursion_restore, save_excursion_save ());

  val = Fprogn (args);
  return unbind_to (count, val);
}

DEFUN ("save-current-buffer", Fsave_current_buffer, Ssave_current_buffer, 0, UNEVALLED, 0,
  "Save the current buffer; execute BODY; restore the current buffer.\n\
Executes BODY just like `progn'.")
  (args)
     Lisp_Object args;
{
  Lisp_Object val;
  int count = specpdl_ptr - specpdl;

  record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());

  val = Fprogn (args);
  return unbind_to (count, val);
}

DEFUN ("buffer-size", Fbufsize, Sbufsize, 0, 1, 0,
  "Return the number of characters in the current buffer.\n\
If BUFFER, return the number of characters in that buffer instead.")
  (buffer)
     Lisp_Object buffer;
{
  if (NILP (buffer))
    return make_number (Z - BEG);
  else
    {
      CHECK_BUFFER (buffer, 1);
      return make_number (BUF_Z (XBUFFER (buffer))
			  - BUF_BEG (XBUFFER (buffer)));
    }
}

DEFUN ("point-min", Fpoint_min, Spoint_min, 0, 0, 0,
  "Return the minimum permissible value of point in the current buffer.\n\
This is 1, unless narrowing (a buffer restriction) is in effect.")
  ()
{
  Lisp_Object temp;
  XSETFASTINT (temp, BEGV);
  return temp;
}

DEFUN ("point-min-marker", Fpoint_min_marker, Spoint_min_marker, 0, 0, 0,
  "Return a marker to the minimum permissible value of point in this buffer.\n\
This is the beginning, unless narrowing (a buffer restriction) is in effect.")
  ()
{
  return buildmark (BEGV, BEGV_BYTE);
}

DEFUN ("point-max", Fpoint_max, Spoint_max, 0, 0, 0,
  "Return the maximum permissible value of point in the current buffer.\n\
This is (1+ (buffer-size)), unless narrowing (a buffer restriction)\n\
is in effect, in which case it is less.")
  ()
{
  Lisp_Object temp;
  XSETFASTINT (temp, ZV);
  return temp;
}

DEFUN ("point-max-marker", Fpoint_max_marker, Spoint_max_marker, 0, 0, 0,
  "Return a marker to the maximum permissible value of point in this buffer.\n\
This is (1+ (buffer-size)), unless narrowing (a buffer restriction)\n\
is in effect, in which case it is less.")
  ()
{
  return buildmark (ZV, ZV_BYTE);
}

DEFUN ("gap-position", Fgap_position, Sgap_position, 0, 0, 0,
  "Return the position of the gap, in the current buffer.\n\
See also `gap-size'.")
  ()
{
  Lisp_Object temp;
  XSETFASTINT (temp, GPT);
  return temp;
}

DEFUN ("gap-size", Fgap_size, Sgap_size, 0, 0, 0,
  "Return the size of the current buffer's gap.\n\
See also `gap-position'.")
  ()
{
  Lisp_Object temp;
  XSETFASTINT (temp, GAP_SIZE);
  return temp;
}

DEFUN ("position-bytes", Fposition_bytes, Sposition_bytes, 1, 1, 0,
  "Return the byte position for character position POSITION.\n\
If POSITION is out of range, the value is nil.")
  (position)
     Lisp_Object position;
{
  CHECK_NUMBER_COERCE_MARKER (position, 1);
  if (XINT (position) < BEG || XINT (position) > Z)
    return Qnil;
  return make_number (CHAR_TO_BYTE (XINT (position)));
}

DEFUN ("byte-to-position", Fbyte_to_position, Sbyte_to_position, 1, 1, 0,
  "Return the character position for byte position BYTEPOS.\n\
If BYTEPOS is out of range, the value is nil.")
  (bytepos)
     Lisp_Object bytepos;
{
  CHECK_NUMBER (bytepos, 1);
  if (XINT (bytepos) < BEG_BYTE || XINT (bytepos) > Z_BYTE)
    return Qnil;
  return make_number (BYTE_TO_CHAR (XINT (bytepos)));
}

DEFUN ("following-char", Ffollowing_char, Sfollowing_char, 0, 0, 0,
  "Return the character following point, as a number.\n\
At the end of the buffer or accessible region, return 0.")
  ()
{
  Lisp_Object temp;
  if (PT >= ZV)
    XSETFASTINT (temp, 0);
  else
    XSETFASTINT (temp, FETCH_CHAR (PT_BYTE));
  return temp;
}

DEFUN ("preceding-char", Fprevious_char, Sprevious_char, 0, 0, 0,
  "Return the character preceding point, as a number.\n\
At the beginning of the buffer or accessible region, return 0.")
  ()
{
  Lisp_Object temp;
  if (PT <= BEGV)
    XSETFASTINT (temp, 0);
  else if (!NILP (current_buffer->enable_multibyte_characters))
    {
      int pos = PT_BYTE;
      DEC_POS (pos);
      XSETFASTINT (temp, FETCH_CHAR (pos));
    }
  else
    XSETFASTINT (temp, FETCH_BYTE (PT_BYTE - 1));
  return temp;
}

DEFUN ("bobp", Fbobp, Sbobp, 0, 0, 0,
  "Return t if point is at the beginning of the buffer.\n\
If the buffer is narrowed, this means the beginning of the narrowed part.")
  ()
{
  if (PT == BEGV)
    return Qt;
  return Qnil;
}

DEFUN ("eobp", Feobp, Seobp, 0, 0, 0,
  "Return t if point is at the end of the buffer.\n\
If the buffer is narrowed, this means the end of the narrowed part.")
  ()
{
  if (PT == ZV)
    return Qt;
  return Qnil;
}

DEFUN ("bolp", Fbolp, Sbolp, 0, 0, 0,
  "Return t if point is at the beginning of a line.")
  ()
{
  if (PT == BEGV || FETCH_BYTE (PT_BYTE - 1) == '\n')
    return Qt;
  return Qnil;
}

DEFUN ("eolp", Feolp, Seolp, 0, 0, 0,
  "Return t if point is at the end of a line.\n\
`End of a line' includes point being at the end of the buffer.")
  ()
{
  if (PT == ZV || FETCH_BYTE (PT_BYTE) == '\n')
    return Qt;
  return Qnil;
}

DEFUN ("char-after", Fchar_after, Schar_after, 0, 1, 0,
  "Return character in current buffer at position POS.\n\