/* Lisp functions pertaining to editing.
- Copyright (C) 1985,86,87,89,93,94,95,96,97,98, 1999, 2000, 2001
+ Copyright (C) 1985,86,87,89,93,94,95,96,97,98,1999,2000,01,02,03,2004
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
-#include <ctype.h>
#include <sys/types.h>
#ifdef VMS
#include <unistd.h>
#endif
+/* Without this, sprintf on Mac OS Classic will produce wrong
+ result. */
+#ifdef MAC_OS8
+#include <stdio.h>
+#endif
+
+#include <ctype.h>
+
#include "lisp.h"
#include "intervals.h"
#include "buffer.h"
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 find_field P_ ((Lisp_Object, Lisp_Object, Lisp_Object, int *, Lisp_Object, 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 *));
+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),
+static void general_insert_function P_ ((void (*) (const unsigned char *, int),
void (*) (Lisp_Object, int, int, int,
int, int),
int, int, Lisp_Object *));
}
\f
DEFUN ("char-to-string", Fchar_to_string, Schar_to_string, 1, 1, 0,
- doc: /* Convert arg CHARACTER to a string containing that character. */)
+ doc: /* Convert arg CHAR to a string containing that character.
+usage: (char-to-string CHAR) */)
(character)
Lisp_Object character;
{
int len;
unsigned char str[MAX_MULTIBYTE_LENGTH];
- CHECK_NUMBER (character, 0);
+ CHECK_NUMBER (character);
len = (SINGLE_BYTE_CHAR_P (XFASTINT (character))
? (*str = (unsigned char)(XFASTINT (character)), 1)
register Lisp_Object string;
{
register Lisp_Object val;
- register struct Lisp_String *p;
- CHECK_STRING (string, 0);
- p = XSTRING (string);
- if (p->size)
+ CHECK_STRING (string);
+ if (SCHARS (string))
{
if (STRING_MULTIBYTE (string))
- XSETFASTINT (val, STRING_CHAR (p->data, STRING_BYTES (p)));
+ XSETFASTINT (val, STRING_CHAR (SDATA (string), SBYTES (string)));
else
- XSETFASTINT (val, p->data[0]);
+ XSETFASTINT (val, SREF (string, 0));
}
else
XSETFASTINT (val, 0);
return position;
}
- CHECK_NUMBER_COERCE_MARKER (position, 0);
+ CHECK_NUMBER_COERCE_MARKER (position);
pos = clip_to_bounds (BEGV, XINT (position), ZV);
SET_PT (pos);
{
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)
+ error ("The mark is not set now, so there is no region");
+
+ if ((PT < XFASTINT (m)) == (beginningp != 0))
m = make_number (PT);
return m;
}
}
\f
-#if 0 /* Not used. */
-
-/* Return nonzero if POS1 and POS2 have the same value
- for the text property PROP. */
+/* Find all the overlays in the current buffer that touch position POS.
+ Return the number found, and store them in a vector in VEC
+ of length LEN. */
static int
-char_property_eq (prop, pos1, pos2)
- Lisp_Object prop;
- Lisp_Object pos1, pos2;
+overlays_around (pos, vec, len)
+ int pos;
+ Lisp_Object *vec;
+ int len;
{
- Lisp_Object pval1, pval2;
+ Lisp_Object overlay, start, end;
+ struct Lisp_Overlay *tail;
+ int startpos, endpos;
+ int idx = 0;
- pval1 = Fget_char_property (pos1, prop, Qnil);
- pval2 = Fget_char_property (pos2, prop, Qnil);
+ for (tail = current_buffer->overlays_before; tail; tail = tail->next)
+ {
+ XSETMISC (overlay, tail);
+
+ end = OVERLAY_END (overlay);
+ endpos = OVERLAY_POSITION (end);
+ if (endpos < pos)
+ break;
+ start = OVERLAY_START (overlay);
+ startpos = OVERLAY_POSITION (start);
+ if (startpos <= pos)
+ {
+ if (idx < len)
+ vec[idx] = overlay;
+ /* Keep counting overlays even if we can't return them all. */
+ idx++;
+ }
+ }
- return EQ (pval1, pval2);
+ for (tail = current_buffer->overlays_after; tail; tail = tail->next)
+ {
+ XSETMISC (overlay, tail);
+
+ start = OVERLAY_START (overlay);
+ startpos = OVERLAY_POSITION (start);
+ if (pos < startpos)
+ break;
+ end = OVERLAY_END (overlay);
+ endpos = OVERLAY_POSITION (end);
+ if (pos <= endpos)
+ {
+ if (idx < len)
+ vec[idx] = overlay;
+ idx++;
+ }
+ }
+
+ return idx;
}
-#endif /* 0 */
+/* Return the value of property PROP, in OBJECT at POSITION.
+ It's the value of PROP that a char inserted at POSITION would get.
+ OBJECT is optional and defaults to the current buffer.
+ If OBJECT is a buffer, then overlay properties are considered as well as
+ text properties.
+ If OBJECT is a window, then that window's buffer is used, but
+ window-specific overlays are considered only if they are associated
+ with OBJECT. */
+Lisp_Object
+get_pos_property (position, prop, object)
+ Lisp_Object position, object;
+ register Lisp_Object prop;
+{
+ CHECK_NUMBER_COERCE_MARKER (position);
+
+ if (NILP (object))
+ XSETBUFFER (object, current_buffer);
+ else if (WINDOWP (object))
+ object = XWINDOW (object)->buffer;
+
+ if (!BUFFERP (object))
+ /* pos-property only makes sense in buffers right now, since strings
+ have no overlays and no notion of insertion for which stickiness
+ could be obeyed. */
+ return Fget_text_property (position, prop, object);
+ else
+ {
+ int posn = XINT (position);
+ int noverlays;
+ Lisp_Object *overlay_vec, tem;
+ struct buffer *obuf = current_buffer;
-/* 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. */
+ set_buffer_temp (XBUFFER (object));
-static int
-text_property_stickiness (prop, pos)
- Lisp_Object prop;
- Lisp_Object pos;
-{
- Lisp_Object prev_pos, front_sticky;
- int is_rear_sticky = 1, is_front_sticky = 0; /* defaults */
+ /* First try with room for 40 overlays. */
+ noverlays = 40;
+ overlay_vec = (Lisp_Object *) alloca (noverlays * sizeof (Lisp_Object));
+ noverlays = overlays_around (posn, overlay_vec, noverlays);
- if (XINT (pos) > BEGV)
- /* Consider previous character. */
- {
- Lisp_Object rear_non_sticky;
+ /* If there are more than 40,
+ make enough space for all, and try again. */
+ if (noverlays > 40)
+ {
+ overlay_vec = (Lisp_Object *) alloca (noverlays * sizeof (Lisp_Object));
+ noverlays = overlays_around (posn, overlay_vec, noverlays);
+ }
+ noverlays = sort_overlays (overlay_vec, noverlays, NULL);
- prev_pos = make_number (XINT (pos) - 1);
- rear_non_sticky = Fget_text_property (prev_pos, Qrear_nonsticky, Qnil);
+ set_buffer_temp (obuf);
- if (CONSP (rear_non_sticky)
- ? Fmemq (prop, rear_non_sticky)
- : !NILP (rear_non_sticky))
- /* PROP is rear-non-sticky. */
- is_rear_sticky = 0;
- }
+ /* Now check the overlays in order of decreasing priority. */
+ while (--noverlays >= 0)
+ {
+ Lisp_Object ol = overlay_vec[noverlays];
+ tem = Foverlay_get (ol, prop);
+ if (!NILP (tem))
+ {
+ /* Check the overlay is indeed active at point. */
+ Lisp_Object start = OVERLAY_START (ol), finish = OVERLAY_END (ol);
+ if ((OVERLAY_POSITION (start) == posn
+ && XMARKER (start)->insertion_type == 1)
+ || (OVERLAY_POSITION (finish) == posn
+ && XMARKER (finish)->insertion_type == 0))
+ ; /* The overlay will not cover a char inserted at point. */
+ else
+ {
+ return tem;
+ }
+ }
+ }
- /* 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. */
- is_front_sticky = 1;
-
- /* Simple cases, where the properties are consistent. */
- if (is_rear_sticky && !is_front_sticky)
- return -1;
- else if (!is_rear_sticky && is_front_sticky)
- return 1;
- else if (!is_rear_sticky && !is_front_sticky)
- return 0;
-
- /* The stickiness properties are inconsistent, so we have to
- disambiguate. Basically, rear-sticky wins, _except_ if the
- property that would be inherited has a value of nil, in which case
- front-sticky wins. */
- if (XINT (pos) == BEGV || NILP (Fget_text_property (prev_pos, prop, Qnil)))
- return 1;
- else
- return -1;
+ { /* Now check the text-properties. */
+ int stickiness = text_property_stickiness (prop, position, object);
+ if (stickiness > 0)
+ return Fget_text_property (position, prop, object);
+ else if (stickiness < 0
+ && XINT (position) > BUF_BEGV (XBUFFER (object)))
+ return Fget_text_property (make_number (XINT (position) - 1),
+ prop, object);
+ else
+ return Qnil;
+ }
+ }
}
-\f
/* 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.
+ BEG_LIMIT and END_LIMIT serve to limit the ranged of the returned
+ results; they do not effect boundary behavior.
+
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
is not stored. */
static void
-find_field (pos, merge_at_boundary, beg, end)
+find_field (pos, merge_at_boundary, beg_limit, beg, end_limit, end)
Lisp_Object pos;
Lisp_Object merge_at_boundary;
+ Lisp_Object beg_limit, end_limit;
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. */
if (NILP (pos))
XSETFASTINT (pos, PT);
else
- CHECK_NUMBER_COERCE_MARKER (pos, 0);
+ CHECK_NUMBER_COERCE_MARKER (pos);
after_field
- = get_char_property_and_overlay (pos, Qfield, Qnil, &after_overlay);
+ = get_char_property_and_overlay (pos, Qfield, Qnil, NULL);
before_field
= (XFASTINT (pos) > BEGV
? get_char_property_and_overlay (make_number (XINT (pos) - 1),
- Qfield, Qnil,
- &before_overlay)
+ Qfield, Qnil, NULL)
: Qnil);
/* See if we need to handle the case where MERGE_AT_BOUNDARY is nil
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. */
+ if (NILP (merge_at_boundary))
{
- /* -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)
+ Lisp_Object field = get_pos_property (pos, Qfield, Qnil);
+ if (!EQ (field, after_field))
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. */
- }
+ if (!EQ (field, before_field))
+ at_field_start = 1;
+ if (NILP (field) && at_field_start && at_field_end)
+ /* If an inserted char would have a nil field while the surrounding
+ text is non-nil, we're probably not looking at a
+ zero-length field, but instead at a non-nil field that's
+ not intended for editing (such as comint's prompts). */
+ at_field_end = at_field_start = 0;
}
/* Note about special `boundary' fields:
else
/* Find the previous field boundary. */
{
+ Lisp_Object p = pos;
if (!NILP (merge_at_boundary) && EQ (before_field, Qboundary))
/* Skip a `boundary' field. */
- pos = Fprevious_single_char_property_change (pos, Qfield, Qnil,Qnil);
+ p = Fprevious_single_char_property_change (p, Qfield, Qnil,
+ beg_limit);
- pos = Fprevious_single_char_property_change (pos, Qfield, Qnil, Qnil);
- *beg = NILP (pos) ? BEGV : XFASTINT (pos);
+ p = Fprevious_single_char_property_change (p, Qfield, Qnil,
+ beg_limit);
+ *beg = NILP (p) ? BEGV : XFASTINT (p);
}
}
{
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,
+ end_limit);
- pos = Fnext_single_char_property_change (pos, Qfield, Qnil, Qnil);
+ pos = Fnext_single_char_property_change (pos, Qfield, Qnil,
+ end_limit);
*end = NILP (pos) ? ZV : XFASTINT (pos);
}
}
Lisp_Object pos;
{
int beg, end;
- find_field (pos, Qnil, &beg, &end);
+ find_field (pos, Qnil, Qnil, &beg, Qnil, &end);
if (beg != end)
del_range (beg, end);
return Qnil;
Lisp_Object pos;
{
int beg, end;
- find_field (pos, Qnil, &beg, &end);
+ find_field (pos, Qnil, Qnil, &beg, Qnil, &end);
return make_buffer_string (beg, end, 1);
}
Lisp_Object pos;
{
int beg, end;
- find_field (pos, Qnil, &beg, &end);
+ find_field (pos, Qnil, Qnil, &beg, Qnil, &end);
return make_buffer_string (beg, end, 0);
}
-DEFUN ("field-beginning", Ffield_beginning, Sfield_beginning, 0, 2, 0,
+DEFUN ("field-beginning", Ffield_beginning, Sfield_beginning, 0, 3, 0,
doc: /* Return the beginning of the field surrounding POS.
A field is a region of text with the same `field' property.
If POS is nil, the value of point is used for POS.
If ESCAPE-FROM-EDGE is non-nil and POS is at the beginning of its
-field, then the beginning of the *previous* field is returned. */)
- (pos, escape_from_edge)
- Lisp_Object pos, escape_from_edge;
+field, then the beginning of the *previous* field is returned.
+If LIMIT is non-nil, it is a buffer position; if the beginning of the field
+is before LIMIT, then LIMIT will be returned instead. */)
+ (pos, escape_from_edge, limit)
+ Lisp_Object pos, escape_from_edge, limit;
{
int beg;
- find_field (pos, escape_from_edge, &beg, 0);
+ find_field (pos, escape_from_edge, limit, &beg, Qnil, 0);
return make_number (beg);
}
-DEFUN ("field-end", Ffield_end, Sfield_end, 0, 2, 0,
+DEFUN ("field-end", Ffield_end, Sfield_end, 0, 3, 0,
doc: /* Return the end of the field surrounding POS.
A field is a region of text with the same `field' property.
If POS is nil, the value of point is used for POS.
If ESCAPE-FROM-EDGE is non-nil and POS is at the end of its field,
-then the end of the *following* field is returned. */)
- (pos, escape_from_edge)
- Lisp_Object pos, escape_from_edge;
+then the end of the *following* field is returned.
+If LIMIT is non-nil, it is a buffer position; if the end of the field
+is after LIMIT, then LIMIT will be returned instead. */)
+ (pos, escape_from_edge, limit)
+ Lisp_Object pos, escape_from_edge, limit;
{
int end;
- find_field (pos, escape_from_edge, 0, &end);
+ find_field (pos, escape_from_edge, Qnil, 0, limit, &end);
return make_number (end);
}
int fwd, shortage;
Lisp_Object field_bound;
- CHECK_NUMBER_COERCE_MARKER (new_pos, 0);
- CHECK_NUMBER_COERCE_MARKER (old_pos, 0);
+ CHECK_NUMBER_COERCE_MARKER (new_pos);
+ CHECK_NUMBER_COERCE_MARKER (old_pos);
fwd = (XFASTINT (new_pos) > XFASTINT (old_pos));
if (fwd)
- field_bound = Ffield_end (old_pos, escape_from_edge);
+ field_bound = Ffield_end (old_pos, escape_from_edge, new_pos);
else
- field_bound = Ffield_beginning (old_pos, escape_from_edge);
+ field_bound = Ffield_beginning (old_pos, escape_from_edge, new_pos);
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
if (NILP (n))
XSETFASTINT (n, 1);
else
- CHECK_NUMBER (n, 0);
+ CHECK_NUMBER (n);
orig = PT;
orig_byte = PT_BYTE;
if (NILP (n))
XSETFASTINT (n, 1);
else
- CHECK_NUMBER (n, 0);
+ CHECK_NUMBER (n);
end_pos = find_before_next_newline (orig, 0, XINT (n) - (XINT (n) <= 0));
/* Point marker. */
tem = XCAR (info);
Fgoto_char (tem);
- unchain_marker (tem);
+ unchain_marker (XMARKER (tem));
/* Mark marker. */
info = XCDR (info);
omark = Fmarker_position (current_buffer->mark);
Fset_marker (current_buffer->mark, tem, Fcurrent_buffer ());
nmark = Fmarker_position (tem);
- unchain_marker (tem);
+ unchain_marker (XMARKER (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
This construct does not save `deactivate-mark', and therefore
functions that change the buffer will still cause deactivation
of the mark at the end of the command. To prevent that, bind
-`deactivate-mark' with `let'. */)
+`deactivate-mark' with `let'.
+
+usage: (save-excursion &rest BODY) */)
(args)
Lisp_Object args;
{
register Lisp_Object val;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
record_unwind_protect (save_excursion_restore, save_excursion_save ());
DEFUN ("save-current-buffer", Fsave_current_buffer, Ssave_current_buffer, 0, UNEVALLED, 0,
doc: /* Save the current buffer; execute BODY; restore the current buffer.
-Executes BODY just like `progn'. */)
+Executes BODY just like `progn'.
+usage: (save-current-buffer &rest BODY) */)
(args)
Lisp_Object args;
{
Lisp_Object val;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
return make_number (Z - BEG);
else
{
- CHECK_BUFFER (buffer, 1);
+ CHECK_BUFFER (buffer);
return make_number (BUF_Z (XBUFFER (buffer))
- BUF_BEG (XBUFFER (buffer)));
}
(position)
Lisp_Object position;
{
- CHECK_NUMBER_COERCE_MARKER (position, 1);
+ CHECK_NUMBER_COERCE_MARKER (position);
if (XINT (position) < BEG || XINT (position) > Z)
return Qnil;
return make_number (CHAR_TO_BYTE (XINT (position)));
(bytepos)
Lisp_Object bytepos;
{
- CHECK_NUMBER (bytepos, 1);
+ CHECK_NUMBER (bytepos);
if (XINT (bytepos) < BEG_BYTE || XINT (bytepos) > Z_BYTE)
return Qnil;
return make_number (BYTE_TO_CHAR (XINT (bytepos)));
DEFUN ("char-after", Fchar_after, Schar_after, 0, 1, 0,
doc: /* Return character in current buffer at position POS.
-POS is an integer or a marker.
+POS is an integer or a marker and defaults to point.
If POS is out of range, the value is nil. */)
(pos)
Lisp_Object pos;
}
else
{
- CHECK_NUMBER_COERCE_MARKER (pos, 0);
+ CHECK_NUMBER_COERCE_MARKER (pos);
if (XINT (pos) < BEGV || XINT (pos) >= ZV)
return Qnil;
DEFUN ("char-before", Fchar_before, Schar_before, 0, 1, 0,
doc: /* Return character in current buffer preceding position POS.
-POS is an integer or a marker.
+POS is an integer or a marker and defaults to point.
If POS is out of range, the value is nil. */)
(pos)
Lisp_Object pos;
}
else
{
- CHECK_NUMBER_COERCE_MARKER (pos, 0);
+ CHECK_NUMBER_COERCE_MARKER (pos);
if (XINT (pos) <= BEGV || XINT (pos) > ZV)
return Qnil;
DEFUN ("user-login-name", Fuser_login_name, Suser_login_name, 0, 1, 0,
doc: /* Return the name under which the user logged in, as a string.
This is based on the effective uid, not the real uid.
-Also, if the environment variable LOGNAME or USER is set,
+Also, if the environment variables LOGNAME or USER are set,
that determines the value of this function.
If optional argument UID is an integer, return the login name of the user
if (NILP (uid))
return Vuser_login_name;
- CHECK_NUMBER (uid, 0);
+ CHECK_NUMBER (uid);
pw = (struct passwd *) getpwuid (XINT (uid));
return (pw ? build_string (pw->pw_name) : Qnil);
}
DEFUN ("user-real-login-name", Fuser_real_login_name, Suser_real_login_name,
- 0, 0, 0,
+ 0, 0, 0,
doc: /* Return the name of the user's real uid, as a string.
This ignores the environment variables LOGNAME and USER, so it differs from
`user-login-name' when running under `su'. */)
else if (NUMBERP (uid))
pw = (struct passwd *) getpwuid ((uid_t) XFLOATINT (uid));
else if (STRINGP (uid))
- pw = (struct passwd *) getpwnam (XSTRING (uid)->data);
+ pw = (struct passwd *) getpwnam (SDATA (uid));
else
error ("Invalid UID specification");
full = make_string (p, q ? q - p : strlen (p));
#ifdef AMPERSAND_FULL_NAME
- p = XSTRING (full)->data;
+ p = SDATA (full);
q = (unsigned char *) index (p, '&');
/* Substitute the login name for the &, upcasing the first character. */
if (q)
Lisp_Object login;
login = Fuser_login_name (make_number (pw->pw_uid));
- r = (unsigned char *) alloca (strlen (p) + XSTRING (login)->size + 1);
+ r = (unsigned char *) alloca (strlen (p) + SCHARS (login) + 1);
bcopy (p, r, q - p);
r[q - p] = 0;
- strcat (r, XSTRING (login)->data);
+ strcat (r, SDATA (login));
r[q - p] = UPCASE (r[q - p]);
strcat (r, q + 1);
full = build_string (r);
get_system_name ()
{
if (STRINGP (Vsystem_name))
- return (char *) XSTRING (Vsystem_name)->data;
+ return (char *) SDATA (Vsystem_name);
else
return "";
}
}
\f
-static int
+int
lisp_time_argument (specified_time, result, usec)
Lisp_Object specified_time;
time_t *result;
{
Lisp_Object high, low;
high = Fcar (specified_time);
- CHECK_NUMBER (high, 0);
+ CHECK_NUMBER (high);
low = Fcdr (specified_time);
if (CONSP (low))
{
*usec = 0;
else
{
- CHECK_NUMBER (usec_l, 0);
+ CHECK_NUMBER (usec_l);
*usec = XINT (usec_l);
}
}
}
else if (usec)
*usec = 0;
- CHECK_NUMBER (low, 0);
+ CHECK_NUMBER (low);
*result = (XINT (high) << 16) + (XINT (low) & 0xffff);
return *result >> 16 == XINT (high);
}
DEFUN ("float-time", Ffloat_time, Sfloat_time, 0, 1, 0,
doc: /* Return the current time, as a float number of seconds since the epoch.
-If an argument is given, it specifies a time to convert to float
+If SPECIFIED-TIME is given, it is the time to convert to float
instead of the current time. The argument should have the forms:
(HIGH . LOW) or (HIGH LOW USEC) or (HIGH LOW . USEC).
Thus, you can use times obtained from `current-time'
Certain flags and modifiers are available with some format controls.
The flags are `_', `-', `^' and `#'. For certain characters X,
%_X is like %X, but padded with blanks; %-X is like %X,
-ut without padding. %^X is like %X but with all textual
-characters up-cased; %#X is like %X but with letter-case of
+but without padding. %^X is like %X, but with all textual
+characters up-cased; %#X is like %X, but with letter-case of
all textual characters reversed.
%NX (where N stands for an integer) is like %X,
but takes up at least N (a number) positions.
struct tm *tm;
int ut = ! NILP (universal);
- CHECK_STRING (format_string, 1);
+ CHECK_STRING (format_string);
if (! lisp_time_argument (time, &value, NULL))
error ("Invalid time specification");
Vlocale_coding_system, 1);
/* This is probably enough. */
- size = STRING_BYTES (XSTRING (format_string)) * 6 + 50;
+ size = SBYTES (format_string) * 6 + 50;
tm = ut ? gmtime (&value) : localtime (&value);
if (! tm)
int result;
buf[0] = '\1';
- result = emacs_memftimeu (buf, size, XSTRING (format_string)->data,
- STRING_BYTES (XSTRING (format_string)),
+ result = emacs_memftimeu (buf, size, SDATA (format_string),
+ SBYTES (format_string),
tm, ut);
if ((result > 0 && result < size) || (result == 0 && buf[0] == '\0'))
return code_convert_string_norecord (make_string (buf, result),
/* If buffer was too small, make it bigger and try again. */
result = emacs_memftimeu (NULL, (size_t) -1,
- XSTRING (format_string)->data,
- STRING_BYTES (XSTRING (format_string)),
+ SDATA (format_string),
+ SBYTES (format_string),
tm, ut);
size = result + 1;
}
The intervening arguments are ignored.
This feature lets (apply 'encode-time (decode-time ...)) work.
-Out-of-range values for SEC, MINUTE, HOUR, DAY, or MONTH are allowed;
+Out-of-range values for SECOND, MINUTE, HOUR, DAY, or MONTH are allowed;
for example, a DAY of 0 means the day preceding the given month.
Year numbers less than 100 are treated just like other year numbers.
If you want them to stand for years in this century, you must do that yourself.
+Years before 1970 are not guaranteed to work. On some systems,
+year values as low as 1901 do work.
+
usage: (encode-time SECOND MINUTE HOUR DAY MONTH YEAR &optional ZONE) */)
(nargs, args)
int nargs;
struct tm tm;
Lisp_Object zone = (nargs > 6 ? args[nargs - 1] : Qnil);
- CHECK_NUMBER (args[0], 0); /* second */
- CHECK_NUMBER (args[1], 1); /* minute */
- CHECK_NUMBER (args[2], 2); /* hour */
- CHECK_NUMBER (args[3], 3); /* day */
- CHECK_NUMBER (args[4], 4); /* month */
- CHECK_NUMBER (args[5], 5); /* year */
+ CHECK_NUMBER (args[0]); /* second */
+ CHECK_NUMBER (args[1]); /* minute */
+ CHECK_NUMBER (args[2]); /* hour */
+ CHECK_NUMBER (args[3]); /* day */
+ CHECK_NUMBER (args[4]); /* month */
+ CHECK_NUMBER (args[5]); /* year */
tm.tm_sec = XINT (args[0]);
tm.tm_min = XINT (args[1]);
if (EQ (zone, Qt))
tzstring = "UTC0";
else if (STRINGP (zone))
- tzstring = (char *) XSTRING (zone)->data;
+ tzstring = (char *) SDATA (zone);
else if (INTEGERP (zone))
{
int abszone = abs (XINT (zone));
However, see also the functions `decode-time' and `format-time-string'
which provide a much more powerful and general facility.
-If an argument is given, it specifies a time to format
-instead of the current time. The argument should have the form:
+If SPECIFIED-TIME is given, it is a time to format instead
+of the current time. The argument should have the form:
(HIGH . LOW)
or the form:
(HIGH LOW . IGNORED).
OFFSET is an integer number of seconds ahead of UTC (east of Greenwich).
A negative value means west of Greenwich.
NAME is a string giving the name of the time zone.
-If an argument is given, it specifies when the time zone offset is determined
+If SPECIFIED-TIME is given, the time zone offset is determined from it
instead of using the current time. The argument should have the form:
(HIGH . LOW)
or the form:
tzstring = "UTC0";
else
{
- CHECK_STRING (tz, 0);
- tzstring = (char *) XSTRING (tz)->data;
+ CHECK_STRING (tz);
+ tzstring = (char *) SDATA (tz);
}
set_time_zone_rule (tzstring);
static void
general_insert_function (insert_func, insert_from_string_func,
inherit, nargs, args)
- void (*insert_func) P_ ((unsigned char *, int));
+ void (*insert_func) P_ ((const unsigned char *, int));
void (*insert_from_string_func) P_ ((Lisp_Object, int, int, int, int, int));
int inherit, nargs;
register Lisp_Object *args;
else if (STRINGP (val))
{
(*insert_from_string_func) (val, 0, 0,
- XSTRING (val)->size,
- STRING_BYTES (XSTRING (val)),
+ SCHARS (val),
+ SBYTES (val),
inherit);
}
else
Any other markers at the point of insertion remain before the text.
If the current buffer is multibyte, unibyte strings are converted
-to multibyte for insertion (see `unibyte-char-to-multibyte').
+to multibyte for insertion (see `string-make-multibyte').
If the current buffer is unibyte, multibyte strings are converted
-to unibyte for insertion.
+to unibyte for insertion (see `string-make-unibyte').
+
+When operating on binary data, it may be necessary to preserve the
+original bytes of a unibyte string when inserting it into a multibyte
+buffer; to accomplish this, apply `string-as-multibyte' to the string
+and insert the result.
usage: (insert &rest ARGS) */)
(nargs, args)
int len;
unsigned char str[MAX_MULTIBYTE_LENGTH];
- CHECK_NUMBER (character, 0);
- CHECK_NUMBER (count, 1);
+ CHECK_NUMBER (character);
+ CHECK_NUMBER (count);
if (!NILP (current_buffer->enable_multibyte_characters))
len = CHAR_STRING (XFASTINT (character), str);
result = make_uninit_multibyte_string (end - start, end_byte - start_byte);
else
result = make_uninit_string (end - start);
- bcopy (BYTE_POS_ADDR (start_byte), XSTRING (result)->data,
+ bcopy (BYTE_POS_ADDR (start_byte), SDATA (result),
end_byte - start_byte);
/* If desired, update and copy the text properties. */
}
DEFUN ("insert-buffer-substring", Finsert_buffer_substring, Sinsert_buffer_substring,
- 1, 3, 0,
- doc: /* Insert before point a substring of the contents of buffer BUFFER.
+ 1, 3, 0,
+ doc: /* Insert before point a substring of the contents of BUFFER.
BUFFER may be a buffer or a buffer name.
-Arguments START and END are character numbers specifying the substring.
-They default to the beginning and the end of BUFFER. */)
- (buf, start, end)
- Lisp_Object buf, start, end;
+Arguments START and END are character positions specifying the substring.
+They default to the values of (point-min) and (point-max) in BUFFER. */)
+ (buffer, start, end)
+ Lisp_Object buffer, start, end;
{
register int b, e, temp;
register struct buffer *bp, *obuf;
- Lisp_Object buffer;
+ Lisp_Object buf;
- buffer = Fget_buffer (buf);
- if (NILP (buffer))
- nsberror (buf);
- bp = XBUFFER (buffer);
+ buf = Fget_buffer (buffer);
+ if (NILP (buf))
+ nsberror (buffer);
+ bp = XBUFFER (buf);
if (NILP (bp->name))
error ("Selecting deleted buffer");
b = BUF_BEGV (bp);
else
{
- CHECK_NUMBER_COERCE_MARKER (start, 0);
+ CHECK_NUMBER_COERCE_MARKER (start);
b = XINT (start);
}
if (NILP (end))
e = BUF_ZV (bp);
else
{
- CHECK_NUMBER_COERCE_MARKER (end, 1);
+ CHECK_NUMBER_COERCE_MARKER (end);
e = XINT (end);
}
}
DEFUN ("compare-buffer-substrings", Fcompare_buffer_substrings, Scompare_buffer_substrings,
- 6, 6, 0,
+ 6, 6, 0,
doc: /* Compare two substrings of two buffers; return result as number.
the value is -N if first string is less after N-1 chars,
+N if first string is greater after N-1 chars, or 0 if strings match.
begp1 = BUF_BEGV (bp1);
else
{
- CHECK_NUMBER_COERCE_MARKER (start1, 1);
+ CHECK_NUMBER_COERCE_MARKER (start1);
begp1 = XINT (start1);
}
if (NILP (end1))
endp1 = BUF_ZV (bp1);
else
{
- CHECK_NUMBER_COERCE_MARKER (end1, 2);
+ CHECK_NUMBER_COERCE_MARKER (end1);
endp1 = XINT (end1);
}
begp2 = BUF_BEGV (bp2);
else
{
- CHECK_NUMBER_COERCE_MARKER (start2, 4);
+ CHECK_NUMBER_COERCE_MARKER (start2);
begp2 = XINT (start2);
}
if (NILP (end2))
endp2 = BUF_ZV (bp2);
else
{
- CHECK_NUMBER_COERCE_MARKER (end2, 5);
+ CHECK_NUMBER_COERCE_MARKER (end2);
endp2 = XINT (end2);
}
characters, not just the bytes. */
int c1, c2;
+ QUIT;
+
if (! NILP (bp1->enable_multibyte_characters))
{
c1 = BUF_FETCH_MULTIBYTE_CHAR (bp1, i1_byte);
}
DEFUN ("subst-char-in-region", Fsubst_char_in_region,
- Ssubst_char_in_region, 4, 5, 0,
+ Ssubst_char_in_region, 4, 5, 0,
doc: /* From START to END, replace FROMCHAR with TOCHAR each time it occurs.
If optional arg NOUNDO is non-nil, don't record this change for undo
and don't mark the buffer as really changed.
int changed = 0;
unsigned char fromstr[MAX_MULTIBYTE_LENGTH], tostr[MAX_MULTIBYTE_LENGTH];
unsigned char *p;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
#define COMBINING_NO 0
#define COMBINING_BEFORE 1
#define COMBINING_AFTER 2
int multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
validate_region (&start, &end);
- CHECK_NUMBER (fromchar, 2);
- CHECK_NUMBER (tochar, 3);
+ CHECK_NUMBER (fromchar);
+ CHECK_NUMBER (tochar);
if (multibyte_p)
{
doc: /* From START to END, translate characters according to TABLE.
TABLE is a string; the Nth character in it is the mapping
for the character with code N.
-This function does not alter multibyte characters.
It returns the number of characters changed. */)
(start, end, table)
Lisp_Object start;
Lisp_Object end;
register Lisp_Object table;
{
- register int pos_byte, stop; /* Limits of the region. */
register unsigned char *tt; /* Trans table. */
register int nc; /* New character. */
int cnt; /* Number of changes made. */
int size; /* Size of translate table. */
- int pos;
+ int pos, pos_byte;
int multibyte = !NILP (current_buffer->enable_multibyte_characters);
+ int string_multibyte;
validate_region (&start, &end);
- CHECK_STRING (table, 2);
+ CHECK_STRING (table);
- size = STRING_BYTES (XSTRING (table));
- tt = XSTRING (table)->data;
+ if (multibyte != (SCHARS (table) < SBYTES (table)))
+ table = (multibyte
+ ? string_make_multibyte (table)
+ : string_make_unibyte (table));
+ string_multibyte = SCHARS (table) < SBYTES (table);
+
+ size = SCHARS (table);
+ tt = SDATA (table);
- pos_byte = CHAR_TO_BYTE (XINT (start));
- stop = CHAR_TO_BYTE (XINT (end));
- modify_region (current_buffer, XINT (start), XINT (end));
pos = XINT (start);
+ pos_byte = CHAR_TO_BYTE (pos);
+ modify_region (current_buffer, pos, XINT (end));
cnt = 0;
- for (; pos_byte < stop; )
+ for (; pos < XINT (end); )
{
register unsigned char *p = BYTE_POS_ADDR (pos_byte);
- int len;
+ unsigned char *str;
+ int len, str_len;
int oc;
- int pos_byte_next;
if (multibyte)
- oc = STRING_CHAR_AND_LENGTH (p, stop - pos_byte, len);
+ oc = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, len);
else
oc = *p, len = 1;
- pos_byte_next = pos_byte + len;
- if (oc < size && len == 1)
+ if (oc < size)
{
- nc = tt[oc];
+ if (string_multibyte)
+ {
+ str = tt + string_char_to_byte (table, oc);
+ nc = STRING_CHAR_AND_LENGTH (str, MAX_MULTIBYTE_LENGTH, str_len);
+ }
+ else
+ {
+ str = tt + oc;
+ nc = tt[oc], str_len = 1;
+ }
if (nc != oc)
{
- /* Take care of the case where the new character
- combines with neighboring bytes. */
- if (!ASCII_BYTE_P (nc)
- && (CHAR_HEAD_P (nc)
- ? ! CHAR_HEAD_P (FETCH_BYTE (pos_byte + 1))
- : (pos_byte > BEG_BYTE
- && ! ASCII_BYTE_P (FETCH_BYTE (pos_byte - 1)))))
+ if (len != str_len)
{
Lisp_Object string;
- string = make_multibyte_string (tt + oc, 1, 1);
/* This is less efficient, because it moves the gap,
- but it handles combining correctly. */
- replace_range (pos, pos + 1, string,
- 1, 0, 1);
- pos_byte_next = CHAR_TO_BYTE (pos);
- if (pos_byte_next > pos_byte)
- /* Before combining happened. We should not
- increment POS. So, to cancel the later
- increment of POS, we decrease it now. */
- pos--;
- else
- INC_POS (pos_byte_next);
+ but it should multibyte characters correctly. */
+ string = make_multibyte_string (str, 1, str_len);
+ replace_range (pos, pos + 1, string, 1, 0, 1);
+ len = str_len;
}
else
{
record_change (pos, 1);
- *p = nc;
+ while (str_len-- > 0)
+ *p++ = *str++;
signal_after_change (pos, 1, 1);
update_compositions (pos, pos + 1, CHECK_BORDER);
}
++cnt;
}
}
- pos_byte = pos_byte_next;
+ pos_byte += len;
pos++;
}
DEFUN ("delete-region", Fdelete_region, Sdelete_region, 2, 2, "r",
doc: /* Delete the text between point and mark.
+
When called from a program, expects two arguments,
positions (integers or markers) specifying the stretch to be deleted. */)
(start, end)
(start, end)
register Lisp_Object start, end;
{
- CHECK_NUMBER_COERCE_MARKER (start, 0);
- CHECK_NUMBER_COERCE_MARKER (end, 1);
+ CHECK_NUMBER_COERCE_MARKER (start);
+ CHECK_NUMBER_COERCE_MARKER (end);
if (XINT (start) > XINT (end))
{
struct Lisp_Marker *end = XMARKER (XCDR (data));
struct buffer *buf = beg->buffer; /* END should have the same buffer. */
- if (beg->charpos != BUF_BEGV(buf) || end->charpos != BUF_ZV(buf))
+ if (buf /* Verify marker still points to a buffer. */
+ && (beg->charpos != BUF_BEGV (buf) || end->charpos != BUF_ZV (buf)))
/* The restriction has changed from the saved one, so restore
the saved restriction. */
{
/* The point is outside the new visible range, move it inside. */
SET_BUF_PT_BOTH (buf,
clip_to_bounds (beg->charpos, pt, end->charpos),
- clip_to_bounds (beg->bytepos, BUF_PT_BYTE(buf),
+ clip_to_bounds (beg->bytepos, BUF_PT_BYTE (buf),
end->bytepos));
-
+
buf->clip_changed = 1; /* Remember that the narrowing changed. */
}
}
{
struct buffer *buf = XBUFFER (data);
- if (BUF_BEGV(buf) != BUF_BEG(buf) || BUF_ZV(buf) != BUF_Z(buf))
+ if (buf /* Verify marker still points to a buffer. */
+ && (BUF_BEGV (buf) != BUF_BEG (buf) || BUF_ZV (buf) != BUF_Z (buf)))
/* The buffer has been narrowed, get rid of the narrowing. */
{
- SET_BUF_BEGV_BOTH (buf, BUF_BEG(buf), BUF_BEG_BYTE(buf));
- SET_BUF_ZV_BOTH (buf, BUF_Z(buf), BUF_Z_BYTE(buf));
+ SET_BUF_BEGV_BOTH (buf, BUF_BEG (buf), BUF_BEG_BYTE (buf));
+ SET_BUF_ZV_BOTH (buf, BUF_Z (buf), BUF_Z_BYTE (buf));
buf->clip_changed = 1; /* Remember that the narrowing changed. */
}
Note: if you are using both `save-excursion' and `save-restriction',
use `save-excursion' outermost:
- (save-excursion (save-restriction ...)) */)
+ (save-excursion (save-restriction ...))
+
+usage: (save-restriction &rest BODY) */)
(body)
Lisp_Object body;
{
register Lisp_Object val;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
record_unwind_protect (save_restriction_restore, save_restriction_save ());
val = Fprogn (body);
int nargs;
Lisp_Object *args;
{
- if (NILP (args[0]))
+ if (NILP (args[0])
+ || (STRINGP (args[0])
+ && SBYTES (args[0]) == 0))
{
message (0);
return Qnil;
{
register Lisp_Object val;
val = Fformat (nargs, args);
- message3 (val, STRING_BYTES (XSTRING (val)), STRING_MULTIBYTE (val));
+ message3 (val, SBYTES (val), STRING_MULTIBYTE (val));
return val;
}
}
message_text = (char *)xmalloc (80);
message_length = 80;
}
- if (STRING_BYTES (XSTRING (val)) > message_length)
+ if (SBYTES (val) > message_length)
{
- message_length = STRING_BYTES (XSTRING (val));
+ message_length = SBYTES (val);
message_text = (char *)xrealloc (message_text, message_length);
}
- bcopy (XSTRING (val)->data, message_text, STRING_BYTES (XSTRING (val)));
- message2 (message_text, STRING_BYTES (XSTRING (val)),
+ bcopy (SDATA (val), message_text, SBYTES (val));
+ message2 (message_text, SBYTES (val),
STRING_MULTIBYTE (val));
return val;
}
}
-DEFUN ("propertize", Fpropertize, Spropertize, 3, MANY, 0,
+DEFUN ("propertize", Fpropertize, Spropertize, 1, MANY, 0,
doc: /* Return a copy of STRING with text properties added.
First argument is the string to copy.
Remaining arguments form a sequence of PROPERTY VALUE pairs for text
int i;
/* Number of args must be odd. */
- if ((nargs & 1) == 0 || nargs < 3)
+ if ((nargs & 1) == 0 || nargs < 1)
error ("Wrong number of arguments");
properties = string = Qnil;
GCPRO2 (properties, string);
/* First argument must be a string. */
- CHECK_STRING (args[0], 0);
+ CHECK_STRING (args[0]);
string = Fcopy_sequence (args[0]);
for (i = 1; i < nargs; i += 2)
{
- CHECK_SYMBOL (args[i], i);
+ CHECK_SYMBOL (args[i]);
properties = Fcons (args[i], Fcons (args[i + 1], properties));
}
Fadd_text_properties (make_number (0),
- make_number (XSTRING (string)->size),
+ make_number (SCHARS (string)),
properties, string);
RETURN_UNGCPRO (string);
}
#define CONVERTED_BYTE_SIZE(MULTIBYTE, STRING) \
(((MULTIBYTE) && ! STRING_MULTIBYTE (STRING)) \
- ? count_size_as_multibyte (XSTRING (STRING)->data, \
- STRING_BYTES (XSTRING (STRING))) \
- : STRING_BYTES (XSTRING (STRING)))
+ ? count_size_as_multibyte (SDATA (STRING), SBYTES (STRING)) \
+ : SBYTES (STRING))
DEFUN ("format", Fformat, Sformat, 1, MANY, 0,
doc: /* Format a string out of a control-string and arguments.
The argument used for %d, %o, %x, %e, %f, %g or %c must be a number.
Use %% to put a single % into the output.
+The basic structure of a %-sequence is
+ % <flags> <width> <precision> character
+where flags is [- #0]+, width is [0-9]+, and precision is .[0-9]+
+
usage: (format STRING &rest OBJECTS) */)
(nargs, args)
int nargs;
register int n; /* The number of the next arg to substitute */
register int total; /* An estimate of the final length */
char *buf, *p;
- register unsigned char *format, *end;
+ register unsigned char *format, *end, *format_start;
int nchars;
/* Nonzero if the output should be a multibyte string,
which is true if any of the inputs is one. */
must consider such a situation or not. */
int maybe_combine_byte;
unsigned char *this_format;
+ /* Precision for each spec, or -1, a flag value meaning no precision
+ was given in that spec. Element 0, corresonding to the format
+ string itself, will not be used. Element NARGS, corresponding to
+ no argument, *will* be assigned to in the case that a `%' and `.'
+ occur after the final format specifier. */
+ int *precision = (int *) (alloca((nargs + 1) * sizeof (int)));
int longest_format;
Lisp_Object val;
+ int arg_intervals = 0;
+ USE_SAFE_ALLOCA;
+
+ /* discarded[I] is 1 if byte I of the format
+ string was not copied into the output.
+ It is 2 if byte I was not the first byte of its character. */
+ char *discarded;
+
+ /* Each element records, for one argument,
+ the start and end bytepos in the output string,
+ and whether the argument is a string with intervals.
+ info[0] is unused. Unused elements have -1 for start. */
struct info
{
- int start, end;
+ int start, end, intervals;
} *info = 0;
/* It should not be necessary to GCPRO ARGS, because
because of an object that we will pass through prin1,
and in that case, we won't know it here. */
for (n = 0; n < nargs; n++)
- if (STRINGP (args[n]) && STRING_MULTIBYTE (args[n]))
- multibyte = 1;
+ {
+ if (STRINGP (args[n]) && STRING_MULTIBYTE (args[n]))
+ multibyte = 1;
+ /* Piggyback on this loop to initialize precision[N]. */
+ precision[n] = -1;
+ }
+
+ CHECK_STRING (args[0]);
+ /* We may have to change "%S" to "%s". */
+ args[0] = Fcopy_sequence (args[0]);
- CHECK_STRING (args[0], 0);
+ /* GC should never happen here, so abort if it does. */
+ abort_on_gc++;
/* If we start out planning a unibyte result,
- and later find it has to be multibyte, we jump back to retry. */
+ then discover it has to be multibyte, we jump back to retry.
+ That can only happen from the first large while loop below. */
retry:
- format = XSTRING (args[0])->data;
- end = format + STRING_BYTES (XSTRING (args[0]));
+ format = SDATA (args[0]);
+ format_start = format;
+ end = format + SBYTES (args[0]);
longest_format = 0;
/* Make room in result for all the non-%-codes in the control string. */
- total = 5 + CONVERTED_BYTE_SIZE (multibyte, args[0]);
+ total = 5 + CONVERTED_BYTE_SIZE (multibyte, args[0]) + 1;
+
+ /* Allocate the info and discarded tables. */
+ {
+ int nbytes = nargs * sizeof *info;
+ int i;
+ info = (struct info *) alloca (nbytes);
+ bzero (info, nbytes);
+ for (i = 0; i < nargs; i++)
+ info[i].start = -1;
+ discarded = (char *) alloca (SBYTES (args[0]));
+ bzero (discarded, SBYTES (args[0]));
+ }
/* Add to TOTAL enough space to hold the converted arguments. */
if (*format++ == '%')
{
int thissize = 0;
+ int actual_width = 0;
unsigned char *this_format_start = format - 1;
- int field_width, precision;
+ int field_width = 0;
/* General format specifications look like
where
- flags ::= [#-* 0]+
+ flags ::= [- #0]+
field-width ::= [0-9]+
precision ::= '.' [0-9]*
the output should be padded with blanks, iff the output
string is shorter than field-width.
- if precision is specified, it specifies the number of
+ If precision is specified, it specifies the number of
digits to print after the '.' for floats, or the max.
number of chars to print from a string. */
- precision = field_width = 0;
-
- while (index ("-*# 0", *format))
+ while (index ("-0# ", *format))
++format;
if (*format >= '0' && *format <= '9')
field_width = 10 * field_width + *format - '0';
}
+ /* N is not incremented for another few lines below, so refer to
+ element N+1 (which might be precision[NARGS]). */
if (*format == '.')
{
++format;
- for (precision = 0; *format >= '0' && *format <= '9'; ++format)
- precision = 10 * precision + *format - '0';
+ for (precision[n+1] = 0; *format >= '0' && *format <= '9'; ++format)
+ precision[n+1] = 10 * precision[n+1] + *format - '0';
}
if (format - this_format_start + 1 > longest_format)
goto retry;
}
args[n] = tem;
+ /* If we restart the loop, we should not come here again
+ because args[n] is now a string and calling
+ Fprin1_to_string on it produces superflous double
+ quotes. So, change "%S" to "%s" now. */
+ *format = 's';
goto string;
}
else if (SYMBOLP (args[n]))
{
- /* Use a temp var to avoid problems when ENABLE_CHECKING
- is turned on. */
- struct Lisp_String *t = XSYMBOL (args[n])->name;
- XSETSTRING (args[n], t);
+ args[n] = SYMBOL_NAME (args[n]);
if (STRING_MULTIBYTE (args[n]) && ! multibyte)
{
multibyte = 1;
string:
if (*format != 's' && *format != 'S')
error ("Format specifier doesn't match argument type");
- thissize = CONVERTED_BYTE_SIZE (multibyte, args[n]);
+ /* In the case (PRECISION[N] > 0), THISSIZE may not need
+ to be as large as is calculated here. Easy check for
+ the case PRECISION = 0. */
+ thissize = precision[n] ? CONVERTED_BYTE_SIZE (multibyte, args[n]) : 0;
+ actual_width = lisp_string_width (args[n], -1, NULL, NULL);
}
/* Would get MPV otherwise, since Lisp_Int's `point' to low memory. */
else if (INTEGERP (args[n]) && *format != 's')
error ("Invalid format operation %%%c", *format);
thissize = 30;
- if (*format == 'c'
- && (! SINGLE_BYTE_CHAR_P (XINT (args[n]))
- || XINT (args[n]) == 0))
+ if (*format == 'c')
{
- if (! multibyte)
+ if (! SINGLE_BYTE_CHAR_P (XINT (args[n]))
+ /* Note: No one can remember why we have to treat
+ the character 0 as a multibyte character here.
+ But, until it causes a real problem, let's
+ don't change it. */
+ || XINT (args[n]) == 0)
+ {
+ if (! multibyte)
+ {
+ multibyte = 1;
+ goto retry;
+ }
+ args[n] = Fchar_to_string (args[n]);
+ thissize = SBYTES (args[n]);
+ }
+ else if (! ASCII_BYTE_P (XINT (args[n])) && multibyte)
{
- multibyte = 1;
- goto retry;
+ args[n]
+ = Fchar_to_string (Funibyte_char_to_multibyte (args[n]));
+ thissize = SBYTES (args[n]);
}
- args[n] = Fchar_to_string (args[n]);
- thissize = STRING_BYTES (XSTRING (args[n]));
}
}
else if (FLOATP (args[n]) && *format != 's')
{
if (! (*format == 'e' || *format == 'f' || *format == 'g'))
- args[n] = Ftruncate (args[n], Qnil);
+ {
+ if (*format != 'd' && *format != 'o' && *format != 'x'
+ && *format != 'i' && *format != 'X' && *format != 'c')
+ error ("Invalid format operation %%%c", *format);
+ args[n] = Ftruncate (args[n], Qnil);
+ }
/* Note that we're using sprintf to print floats,
so we have to take into account what that function
prints. */
- thissize = MAX_10_EXP + 100 + precision;
+ /* Filter out flag value of -1. */
+ thissize = (MAX_10_EXP + 100
+ + (precision[n] > 0 ? precision[n] : 0));
}
else
{
/* Anything but a string, convert to a string using princ. */
register Lisp_Object tem;
tem = Fprin1_to_string (args[n], Qt);
- if (STRING_MULTIBYTE (tem) & ! multibyte)
+ if (STRING_MULTIBYTE (tem) && ! multibyte)
{
multibyte = 1;
goto retry;
goto string;
}
- thissize = max (field_width, thissize);
+ thissize += max (0, field_width - actual_width);
total += thissize + 4;
}
+ abort_on_gc--;
+
/* Now we can no longer jump to retry.
TOTAL and LONGEST_FORMAT are known for certain. */
/* Allocate the space for the result.
Note that TOTAL is an overestimate. */
- if (total < 1000)
- buf = (char *) alloca (total + 1);
- else
- buf = (char *) xmalloc (total + 1);
+ SAFE_ALLOCA (buf, char *, total);
p = buf;
nchars = 0;
n = 0;
/* Scan the format and store result in BUF. */
- format = XSTRING (args[0])->data;
+ format = SDATA (args[0]);
+ format_start = format;
+ end = format + SBYTES (args[0]);
maybe_combine_byte = 0;
while (format != end)
{
int negative = 0;
unsigned char *this_format_start = format;
+ discarded[format - format_start] = 1;
format++;
- /* Process a numeric arg and skip it. */
+ while (index("-0# ", *format))
+ {
+ if (*format == '-')
+ {
+ negative = 1;
+ }
+ discarded[format - format_start] = 1;
+ ++format;
+ }
+
minlen = atoi (format);
- if (minlen < 0)
- minlen = - minlen, negative = 1;
- while ((*format >= '0' && *format <= '9')
- || *format == '-' || *format == ' ' || *format == '.')
- format++;
+ while ((*format >= '0' && *format <= '9') || *format == '.')
+ {
+ discarded[format - format_start] = 1;
+ format++;
+ }
if (*format++ == '%')
{
++n;
+ discarded[format - format_start - 1] = 1;
+ info[n].start = nchars;
+
if (STRINGP (args[n]))
{
- int padding, nbytes, start, end;
- int width = lisp_string_width (args[n], -1, NULL, NULL);
+ /* handle case (precision[n] >= 0) */
+
+ int width, padding;
+ int nbytes, start, end;
+ int nchars_string;
+
+ /* lisp_string_width ignores a precision of 0, but GNU
+ libc functions print 0 characters when the precision
+ is 0. Imitate libc behavior here. Changing
+ lisp_string_width is the right thing, and will be
+ done, but meanwhile we work with it. */
+
+ if (precision[n] == 0)
+ width = nchars_string = nbytes = 0;
+ else if (precision[n] > 0)
+ width = lisp_string_width (args[n], precision[n], &nchars_string, &nbytes);
+ else
+ { /* no precision spec given for this argument */
+ width = lisp_string_width (args[n], -1, NULL, NULL);
+ nbytes = SBYTES (args[n]);
+ nchars_string = SCHARS (args[n]);
+ }
/* If spec requires it, pad on right with spaces. */
padding = minlen - width;
}
start = nchars;
-
+ nchars += nchars_string;
+ end = nchars;
+
if (p > buf
&& multibyte
&& !ASCII_BYTE_P (*((unsigned char *) p - 1))
&& STRING_MULTIBYTE (args[n])
- && !CHAR_HEAD_P (XSTRING (args[n])->data[0]))
+ && !CHAR_HEAD_P (SREF (args[n], 0)))
maybe_combine_byte = 1;
- nbytes = copy_text (XSTRING (args[n])->data, p,
- STRING_BYTES (XSTRING (args[n])),
- STRING_MULTIBYTE (args[n]), multibyte);
- p += nbytes;
- nchars += XSTRING (args[n])->size;
- end = nchars;
+
+ p += copy_text (SDATA (args[n]), p,
+ nbytes,
+ STRING_MULTIBYTE (args[n]), multibyte);
if (negative)
while (padding-- > 0)
/* If this argument has text properties, record where
in the result string it appears. */
- if (XSTRING (args[n])->intervals)
- {
- if (!info)
- {
- int nbytes = nargs * sizeof *info;
- info = (struct info *) alloca (nbytes);
- bzero (info, nbytes);
- }
-
- info[n].start = start;
- info[n].end = end;
- }
+ if (STRING_INTERVALS (args[n]))
+ info[n].intervals = arg_intervals = 1;
}
else if (INTEGERP (args[n]) || FLOATP (args[n]))
{
maybe_combine_byte = 1;
this_nchars = strlen (p);
if (multibyte)
- p += str_to_multibyte (p, buf + total - p, this_nchars);
+ p += str_to_multibyte (p, buf + total - 1 - p, this_nchars);
else
p += this_nchars;
nchars += this_nchars;
}
+
+ info[n].end = nchars;
}
else if (STRING_MULTIBYTE (args[0]))
{
&& !CHAR_HEAD_P (*format))
maybe_combine_byte = 1;
*p++ = *format++;
- while (! CHAR_HEAD_P (*format)) *p++ = *format++;
+ while (! CHAR_HEAD_P (*format))
+ {
+ discarded[format - format_start] = 2;
+ *p++ = *format++;
+ }
nchars++;
}
else if (multibyte)
*p++ = *format++, nchars++;
}
- if (p > buf + total + 1)
+ if (p > buf + total)
abort ();
if (maybe_combine_byte)
val = make_specified_string (buf, nchars, p - buf, multibyte);
/* If we allocated BUF with malloc, free it too. */
- if (total >= 1000)
- xfree (buf);
+ SAFE_FREE (total);
/* If the format string has text properties, or any of the string
arguments has text properties, set up text properties of the
result string. */
- if (XSTRING (args[0])->intervals || info)
+ if (STRING_INTERVALS (args[0]) || arg_intervals)
{
Lisp_Object len, new_len, props;
struct gcpro gcpro1;
/* Add text properties from the format string. */
- len = make_number (XSTRING (args[0])->size);
+ len = make_number (SCHARS (args[0]));
props = text_property_list (args[0], make_number (0), len, Qnil);
GCPRO1 (props);
if (CONSP (props))
{
- new_len = make_number (XSTRING (val)->size);
- extend_property_ranges (props, len, new_len);
+ int bytepos = 0, position = 0, translated = 0, argn = 1;
+ Lisp_Object list;
+
+ /* Adjust the bounds of each text property
+ to the proper start and end in the output string. */
+ /* We take advantage of the fact that the positions in PROPS
+ are in increasing order, so that we can do (effectively)
+ one scan through the position space of the format string.
+
+ BYTEPOS is the byte position in the format string,
+ POSITION is the untranslated char position in it,
+ TRANSLATED is the translated char position in BUF,
+ and ARGN is the number of the next arg we will come to. */
+ for (list = props; CONSP (list); list = XCDR (list))
+ {
+ Lisp_Object item;
+ int pos;
+
+ item = XCAR (list);
+
+ /* First adjust the property start position. */
+ pos = XINT (XCAR (item));
+
+ /* Advance BYTEPOS, POSITION, TRANSLATED and ARGN
+ up to this position. */
+ for (; position < pos; bytepos++)
+ {
+ if (! discarded[bytepos])
+ position++, translated++;
+ else if (discarded[bytepos] == 1)
+ {
+ position++;
+ if (translated == info[argn].start)
+ {
+ translated += info[argn].end - info[argn].start;
+ argn++;
+ }
+ }
+ }
+
+ XSETCAR (item, make_number (translated));
+
+ /* Likewise adjust the property end position. */
+ pos = XINT (XCAR (XCDR (item)));
+
+ for (; bytepos < pos; bytepos++)
+ {
+ if (! discarded[bytepos])
+ position++, translated++;
+ else if (discarded[bytepos] == 1)
+ {
+ position++;
+ if (translated == info[argn].start)
+ {
+ translated += info[argn].end - info[argn].start;
+ argn++;
+ }
+ }
+ }
+
+ XSETCAR (XCDR (item), make_number (translated));
+ }
+
add_text_properties_from_list (val, props, make_number (0));
}
/* Add text properties from arguments. */
- if (info)
+ if (arg_intervals)
for (n = 1; n < nargs; ++n)
- if (info[n].end)
+ if (info[n].intervals)
{
- len = make_number (XSTRING (args[n])->size);
+ len = make_number (SCHARS (args[n]));
new_len = make_number (info[n].end - info[n].start);
props = text_property_list (args[n], make_number (0), len, Qnil);
extend_property_ranges (props, len, new_len);
return val;
}
-
-/* VARARGS 1 */
Lisp_Object
-#ifdef NO_ARG_ARRAY
-format1 (string1, arg0, arg1, arg2, arg3, arg4)
- EMACS_INT arg0, arg1, arg2, arg3, arg4;
-#else
-format1 (string1)
-#endif
+format2 (string1, arg0, arg1)
char *string1;
+ Lisp_Object arg0, arg1;
{
- char buf[100];
-#ifdef NO_ARG_ARRAY
- EMACS_INT args[5];
- args[0] = arg0;
- args[1] = arg1;
- args[2] = arg2;
- args[3] = arg3;
- args[4] = arg4;
- doprnt (buf, sizeof buf, string1, (char *)0, 5, (char **) args);
-#else
- doprnt (buf, sizeof buf, string1, (char *)0, 5, &string1 + 1);
-#endif
- return build_string (buf);
+ Lisp_Object args[3];
+ args[0] = build_string (string1);
+ args[1] = arg0;
+ args[2] = arg1;
+ return Fformat (3, args);
}
\f
DEFUN ("char-equal", Fchar_equal, Schar_equal, 2, 2, 0,
register Lisp_Object c1, c2;
{
int i1, i2;
- CHECK_NUMBER (c1, 0);
- CHECK_NUMBER (c2, 1);
+ CHECK_NUMBER (c1);
+ CHECK_NUMBER (c2);
if (XINT (c1) == XINT (c2))
return Qt;
register int start1_byte, end1_byte, start2_byte, end2_byte;
{
register int amt1, amt1_byte, amt2, amt2_byte, diff, diff_byte, mpos;
- register Lisp_Object marker;
+ register struct Lisp_Marker *marker;
/* Update point as if it were a marker. */
if (PT < start1)
amt1_byte = (end2_byte - start2_byte) + (start2_byte - end1_byte);
amt2_byte = (end1_byte - start1_byte) + (start2_byte - end1_byte);
- for (marker = BUF_MARKERS (current_buffer); !NILP (marker);
- marker = XMARKER (marker)->chain)
+ for (marker = BUF_MARKERS (current_buffer); marker; marker = marker->next)
{
- mpos = marker_byte_position (marker);
+ mpos = marker->bytepos;
if (mpos >= start1_byte && mpos < end2_byte)
{
if (mpos < end1_byte)
mpos += diff_byte;
else
mpos -= amt2_byte;
- XMARKER (marker)->bytepos = mpos;
+ marker->bytepos = mpos;
}
- mpos = XMARKER (marker)->charpos;
+ mpos = marker->charpos;
if (mpos >= start1 && mpos < end2)
{
if (mpos < end1)
else
mpos -= amt2;
}
- XMARKER (marker)->charpos = mpos;
+ marker->charpos = mpos;
}
}
DEFUN ("transpose-regions", Ftranspose_regions, Stranspose_regions, 4, 5, 0,
- doc: /* Transpose region START1 to END1 with START2 to END2.
+ doc: /* Transpose region STARTR1 to ENDR1 with STARTR2 to ENDR2.
The regions may not be overlapping, because the size of the buffer is
never changed in a transposition.
-Optional fifth arg LEAVE_MARKERS, if non-nil, means don't update
+Optional fifth arg LEAVE-MARKERS, if non-nil, means don't update
any markers that happen to be located in the regions.
Transposing beyond buffer boundaries is an error. */)
/* First region smaller than second. */
if (len1_byte < len2_byte)
{
- /* We use alloca only if it is small,
- because we want to avoid stack overflow. */
- if (len2_byte > 20000)
- temp = (unsigned char *) xmalloc (len2_byte);
- else
- temp = (unsigned char *) alloca (len2_byte);
+ USE_SAFE_ALLOCA;
+
+ SAFE_ALLOCA (temp, unsigned char *, len2_byte);
/* Don't precompute these addresses. We have to compute them
at the last minute, because the relocating allocator might
bcopy (start2_addr, temp, len2_byte);
bcopy (start1_addr, start1_addr + len2_byte, len1_byte);
bcopy (temp, start1_addr, len2_byte);
- if (len2_byte > 20000)
- xfree (temp);
+ SAFE_FREE (len2_byte);
}
else
/* First region not smaller than second. */
{
- if (len1_byte > 20000)
- temp = (unsigned char *) xmalloc (len1_byte);
- else
- temp = (unsigned char *) alloca (len1_byte);
+ USE_SAFE_ALLOCA;
+
+ SAFE_ALLOCA (temp, unsigned char *, len1_byte);
start1_addr = BYTE_POS_ADDR (start1_byte);
start2_addr = BYTE_POS_ADDR (start2_byte);
bcopy (start1_addr, temp, len1_byte);
bcopy (start2_addr, start1_addr, len2_byte);
bcopy (temp, start1_addr + len2_byte, len1_byte);
- if (len1_byte > 20000)
- xfree (temp);
+ SAFE_FREE (len1_byte);
}
graft_intervals_into_buffer (tmp_interval1, start1 + len2,
len1, current_buffer, 0);
if (len1_byte == len2_byte)
/* Regions are same size, though, how nice. */
{
+ USE_SAFE_ALLOCA;
+
modify_region (current_buffer, start1, end1);
modify_region (current_buffer, start2, end2);
record_change (start1, len1);
Fset_text_properties (make_number (start2), make_number (end2),
Qnil, Qnil);
- if (len1_byte > 20000)
- temp = (unsigned char *) xmalloc (len1_byte);
- else
- temp = (unsigned char *) alloca (len1_byte);
+ SAFE_ALLOCA (temp, unsigned char *, len1_byte);
start1_addr = BYTE_POS_ADDR (start1_byte);
start2_addr = BYTE_POS_ADDR (start2_byte);
bcopy (start1_addr, temp, len1_byte);
bcopy (start2_addr, start1_addr, len2_byte);
bcopy (temp, start2_addr, len1_byte);
- if (len1_byte > 20000)
- xfree (temp);
+ SAFE_FREE (len1_byte);
+
graft_intervals_into_buffer (tmp_interval1, start2,
len1, current_buffer, 0);
graft_intervals_into_buffer (tmp_interval2, start1,
else if (len1_byte < len2_byte) /* Second region larger than first */
/* Non-adjacent & unequal size, area between must also be shifted. */
{
+ USE_SAFE_ALLOCA;
+
modify_region (current_buffer, start1, end2);
record_change (start1, (end2 - start1));
tmp_interval1 = copy_intervals (cur_intv, start1, len1);
Qnil, Qnil);
/* holds region 2 */
- if (len2_byte > 20000)
- temp = (unsigned char *) xmalloc (len2_byte);
- else
- temp = (unsigned char *) alloca (len2_byte);
+ SAFE_ALLOCA (temp, unsigned char *, len2_byte);
start1_addr = BYTE_POS_ADDR (start1_byte);
start2_addr = BYTE_POS_ADDR (start2_byte);
bcopy (start2_addr, temp, len2_byte);
bcopy (start1_addr, start1_addr + len_mid + len2_byte, len1_byte);
safe_bcopy (start1_addr + len1_byte, start1_addr + len2_byte, len_mid);
bcopy (temp, start1_addr, len2_byte);
- if (len2_byte > 20000)
- xfree (temp);
+ SAFE_FREE (len2_byte);
+
graft_intervals_into_buffer (tmp_interval1, end2 - len1,
len1, current_buffer, 0);
graft_intervals_into_buffer (tmp_interval_mid, start1 + len2,
else
/* Second region smaller than first. */
{
+ USE_SAFE_ALLOCA;
+
record_change (start1, (end2 - start1));
modify_region (current_buffer, start1, end2);
Qnil, Qnil);
/* holds region 1 */
- if (len1_byte > 20000)
- temp = (unsigned char *) xmalloc (len1_byte);
- else
- temp = (unsigned char *) alloca (len1_byte);
+ SAFE_ALLOCA (temp, unsigned char *, len1_byte);
start1_addr = BYTE_POS_ADDR (start1_byte);
start2_addr = BYTE_POS_ADDR (start2_byte);
bcopy (start1_addr, temp, len1_byte);
bcopy (start2_addr, start1_addr, len2_byte);
bcopy (start1_addr + len1_byte, start1_addr + len2_byte, len_mid);
bcopy (temp, start1_addr + len2_byte + len_mid, len1_byte);
- if (len1_byte > 20000)
- xfree (temp);
+ SAFE_FREE (len1_byte);
+
graft_intervals_into_buffer (tmp_interval1, end2 - len1,
len1, current_buffer, 0);
graft_intervals_into_buffer (tmp_interval_mid, start1 + len2,
transpose_markers (start1, end1, start2, end2,
start1_byte, start1_byte + len1_byte,
start2_byte, start2_byte + len2_byte);
- fix_overlays_in_range (start1, end2);
+ fix_start_end_in_overlays (start1, end2);
}
return Qnil;
staticpro (&Qbuffer_access_fontify_functions);
DEFVAR_LISP ("inhibit-field-text-motion", &Vinhibit_field_text_motion,
- doc: /* Non-nil means.text motion commands don't notice fields. */);
+ doc: /* Non-nil means text motion commands don't notice fields. */);
Vinhibit_field_text_motion = Qnil;
DEFVAR_LISP ("buffer-access-fontify-functions",
defsubr (&Ssave_restriction);
defsubr (&Stranspose_regions);
}
+
+/* arch-tag: fc3827d8-6f60-4067-b11e-c3218031b018
+ (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff