{
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 ("The mark is not set now, so there is no region");
-
+
if ((PT < XFASTINT (m)) == beginningp)
m = make_number (PT);
return m;
}
\f
+/* 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
+overlays_around (pos, vec, len)
+ int pos;
+ Lisp_Object *vec;
+ int len;
+{
+ Lisp_Object tail, overlay, start, end;
+ int startpos, endpos;
+ int idx = 0;
+
+ for (tail = current_buffer->overlays_before;
+ GC_CONSP (tail);
+ tail = XCDR (tail))
+ {
+ overlay = XCAR (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++;
+ }
+ }
+
+ for (tail = current_buffer->overlays_after;
+ GC_CONSP (tail);
+ tail = XCDR (tail))
+ {
+ overlay = XCAR (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;
+}
+
+/* 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;
+{
+ struct window *w = 0;
+
+ CHECK_NUMBER_COERCE_MARKER (position);
+
+ if (NILP (object))
+ XSETBUFFER (object, current_buffer);
+
+ if (WINDOWP (object))
+ {
+ w = XWINDOW (object);
+ object = w->buffer;
+ }
+ if (BUFFERP (object))
+ {
+ int posn = XINT (position);
+ int noverlays;
+ Lisp_Object *overlay_vec, tem;
+ struct buffer *obuf = current_buffer;
+
+ set_buffer_temp (XBUFFER (object));
+
+ /* 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 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);
+
+ set_buffer_temp (obuf);
+
+ /* 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;
+ }
+ }
+ }
+
+ }
+
+ { /* Now check the text-properties. */
+ int stickiness = text_property_stickiness (prop, position);
+ if (stickiness > 0)
+ return Fget_text_property (position, prop, Qnil);
+ else if (stickiness < 0 && XINT (position) > BEGV)
+ return Fget_text_property (make_number (XINT (position) - 1),
+ prop, Qnil);
+ else
+ return Qnil;
+ }
+}
+
/* 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.
{
/* 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. */
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. */
- {
- /* -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)
+ if (NILP (merge_at_boundary))
+ {
+ 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,
- beg_limit);
-
- pos = Fprevious_single_char_property_change (pos, Qfield, Qnil,
+ p = Fprevious_single_char_property_change (p, Qfield, Qnil,
beg_limit);
- *beg = NILP (pos) ? BEGV : XFASTINT (pos);
+
+ p = Fprevious_single_char_property_change (p, Qfield, Qnil,
+ beg_limit);
+ *beg = NILP (p) ? BEGV : XFASTINT (p);
}
}
/* 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
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)
clip_to_bounds (beg->charpos, pt, end->charpos),
clip_to_bounds (beg->bytepos, BUF_PT_BYTE (buf),
end->bytepos));
-
+
buf->clip_changed = 1; /* Remember that the narrowing changed. */
}
}
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 * sizeof (int)));
int longest_format;
Lisp_Object val;
struct info
This is not always right; sometimes the result needs to be multibyte
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++)
+ for (n = 0; n < nargs; n++) {
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]);
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
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;
-
+ /* NOTE the handling of specifiers here differs in some ways
+ from the libc model. There are bugs in this code that lead
+ to incorrect formatting when flags recognized by C but
+ neither parsed nor rejected here are used. Further
+ revisions will be made soon. */
+
+ /* incorrect list of flags to skip; will be fixed */
while (index ("-*# 0", *format))
++format;
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)
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. */
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 remeber 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 = SBYTES (args[n]);
}
}
else if (FLOATP (args[n]) && *format != 's')
/* 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
{
format++;
/* Process a numeric arg and skip it. */
+ /* NOTE atoi is the wrong thing to use here; will be fixed */
minlen = atoi (format);
if (minlen < 0)
minlen = - minlen, negative = 1;
+ /* NOTE the parsing here is not consistent with the first
+ pass, and neither attempt is what we want to do. Will be
+ fixed. */
while ((*format >= '0' && *format <= '9')
|| *format == '-' || *format == ' ' || *format == '.')
format++;
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 (SREF (args[n], 0)))
maybe_combine_byte = 1;
- nbytes = copy_text (SDATA (args[n]), p,
- SBYTES (args[n]),
- STRING_MULTIBYTE (args[n]), multibyte);
- p += nbytes;
- nchars += SCHARS (args[n]);
- end = nchars;
+
+ p += copy_text (SDATA (args[n]), p,
+ nbytes,
+ STRING_MULTIBYTE (args[n]), multibyte);
if (negative)
while (padding-- > 0)
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];
+ int numargs;
+ 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,