/* Lisp functions pertaining to editing.
-Copyright (C) 1985-1987, 1989, 1993-2013 Free Software Foundation, Inc.
+Copyright (C) 1985-1987, 1989, 1993-2014 Free Software Foundation, Inc.
This file is part of GNU Emacs.
extern Lisp_Object w32_get_internal_run_time (void);
#endif
-static Lisp_Object format_time_string (char const *, ptrdiff_t, EMACS_TIME,
+static Lisp_Object format_time_string (char const *, ptrdiff_t, struct timespec,
bool, struct tm *);
static int tm_diff (struct tm *, struct tm *);
static void update_buffer_properties (ptrdiff_t, ptrdiff_t);
The return value is POSITION. */)
(register Lisp_Object position)
{
- ptrdiff_t 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);
-
- pos = clip_to_bounds (BEGV, XINT (position), ZV);
- SET_PT (pos);
+ if (MARKERP (position))
+ set_point_from_marker (position);
+ else if (INTEGERP (position))
+ SET_PT (clip_to_bounds (BEGV, XINT (position), ZV));
+ else
+ wrong_type_argument (Qinteger_or_marker_p, position);
return position;
}
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 (Lisp_Object position, register Lisp_Object prop, Lisp_Object object)
+DEFUN ("get-pos-property", Fget_pos_property, Sget_pos_property, 2, 3, 0,
+ doc: /* Return the value of POSITION's property PROP, in OBJECT.
+Almost identical to `get-char-property' except for the following difference:
+Whereas `get-char-property' returns the property of the char at (i.e. right
+after) POSITION, this pays attention to properties's stickiness and overlays's
+advancement settings, in order to find the property of POSITION itself,
+i.e. the property that a char would inherit if it were inserted
+at POSITION. */)
+ (Lisp_Object position, register Lisp_Object prop, Lisp_Object object)
{
CHECK_NUMBER_COERCE_MARKER (position);
specially. */
if (NILP (merge_at_boundary))
{
- Lisp_Object field = get_pos_property (pos, Qfield, Qnil);
+ Lisp_Object field = Fget_pos_property (pos, Qfield, Qnil);
if (!EQ (field, after_field))
at_field_end = 1;
if (!EQ (field, before_field))
If the optional argument ONLY-IN-LINE is non-nil and constraining
NEW-POS would move it to a different line, NEW-POS is returned
-unconstrained. This useful for commands that move by line, like
+unconstrained. This is useful for commands that move by line, like
\\[next-line] or \\[beginning-of-line], which should generally respect field boundaries
only in the case where they can still move to the right line.
&& (!NILP (Fget_char_property (new_pos, Qfield, Qnil))
|| !NILP (Fget_char_property (old_pos, Qfield, Qnil))
/* To recognize field boundaries, we must also look at the
- previous positions; we could use `get_pos_property'
+ previous positions; we could use `Fget_pos_property'
instead, but in itself that would fail inside non-sticky
fields (like comint prompts). */
|| (XFASTINT (new_pos) > BEGV
/* Field boundaries are again a problem; but now we must
decide the case exactly, so we need to call
`get_pos_property' as well. */
- || (NILP (get_pos_property (old_pos, inhibit_capture_property, Qnil))
+ || (NILP (Fget_pos_property (old_pos, inhibit_capture_property, Qnil))
&& (XFASTINT (old_pos) <= BEGV
- || NILP (Fget_char_property (old_pos, inhibit_capture_property, Qnil))
- || NILP (Fget_char_property (prev_old, inhibit_capture_property, Qnil))))))
+ || NILP (Fget_char_property
+ (old_pos, inhibit_capture_property, Qnil))
+ || NILP (Fget_char_property
+ (prev_old, inhibit_capture_property, Qnil))))))
/* It is possible that NEW_POS is not within the same field as
OLD_POS; try to move NEW_POS so that it is. */
{
/* 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). */
+ 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
(Lisp_Object n)
{
ptrdiff_t orig, orig_byte, end;
- ptrdiff_t count = SPECPDL_INDEX ();
+ dynwind_begin ();
specbind (Qinhibit_point_motion_hooks, Qt);
if (NILP (n))
SET_PT_BOTH (orig, orig_byte);
- unbind_to (count, Qnil);
+ dynwind_end ();
/* Return END constrained to the current input field. */
return Fconstrain_to_field (make_number (end), make_number (orig),
Lisp_Object
save_excursion_save (void)
{
- return make_save_value
- (SAVE_TYPE_OBJ_OBJ_OBJ_OBJ,
- Fpoint_marker (),
+ return make_save_obj_obj_obj_obj
+ (Fpoint_marker (),
/* Do not copy the mark if it points to nowhere. */
(XMARKER (BVAR (current_buffer, mark))->buffer
? Fcopy_marker (BVAR (current_buffer, mark), Qnil)
(Lisp_Object args)
{
register Lisp_Object val;
- ptrdiff_t count = SPECPDL_INDEX ();
+ dynwind_begin ();
record_unwind_protect (save_excursion_restore, save_excursion_save ());
val = Fprogn (args);
- return unbind_to (count, val);
+ dynwind_end ();
+ return val;
}
DEFUN ("save-current-buffer", Fsave_current_buffer, Ssave_current_buffer, 0, UNEVALLED, 0,
usage: (save-current-buffer &rest BODY) */)
(Lisp_Object args)
{
- ptrdiff_t count = SPECPDL_INDEX ();
+ dynwind_begin ();
record_unwind_current_buffer ();
- return unbind_to (count, Fprogn (args));
+ Lisp_Object tem0 = Fprogn (args);
+ dynwind_end ();
+ return tem0;
}
\f
DEFUN ("buffer-size", Fbuffer_size, Sbuffer_size, 0, 1, 0,
picosecond counts. */)
(void)
{
- return make_lisp_time (current_emacs_time ());
+ return make_lisp_time (current_timespec ());
}
DEFUN ("get-internal-run-time", Fget_internal_run_time, Sget_internal_run_time,
usecs -= 1000000;
secs++;
}
- return make_lisp_time (make_emacs_time (secs, usecs * 1000));
+ return make_lisp_time (make_timespec (secs, usecs * 1000));
#else /* ! HAVE_GETRUSAGE */
#ifdef WINDOWSNT
return w32_get_internal_run_time ();
UNKNOWN_MODTIME_NSECS; in that case, the Lisp list contains a
correspondingly negative picosecond count. */
Lisp_Object
-make_lisp_time (EMACS_TIME t)
+make_lisp_time (struct timespec t)
{
- int ns = EMACS_NSECS (t);
- return make_time_tail (EMACS_SECS (t), list2i (ns / 1000, ns % 1000 * 1000));
+ int ns = t.tv_nsec;
+ return make_time_tail (t.tv_sec, list2i (ns / 1000, ns % 1000 * 1000));
}
/* Decode a Lisp list SPECIFIED_TIME that represents a time.
list, generate the corresponding time value.
If RESULT is not null, store into *RESULT the converted time;
- this can fail if the converted time does not fit into EMACS_TIME.
+ this can fail if the converted time does not fit into struct timespec.
If *DRESULT is not null, store into *DRESULT the number of
seconds since the start of the POSIX Epoch.
bool
decode_time_components (Lisp_Object high, Lisp_Object low, Lisp_Object usec,
Lisp_Object psec,
- EMACS_TIME *result, double *dresult)
+ struct timespec *result, double *dresult)
{
EMACS_INT hi, lo, us, ps;
if (! (INTEGERP (high) && INTEGERP (low)
/* Return the greatest representable time that is not greater
than the requested time. */
time_t sec = hi;
- *result = make_emacs_time ((sec << 16) + lo, us * 1000 + ps / 1000);
+ *result = make_timespec ((sec << 16) + lo, us * 1000 + ps / 1000);
}
else
{
/* Decode a Lisp list SPECIFIED_TIME that represents a time.
If SPECIFIED_TIME is nil, use the current time.
- Round the time down to the nearest EMACS_TIME value.
+ Round the time down to the nearest struct timespec value.
Return seconds since the Epoch.
Signal an error if unsuccessful. */
-EMACS_TIME
+struct timespec
lisp_time_argument (Lisp_Object specified_time)
{
- EMACS_TIME t;
+ struct timespec t;
if (NILP (specified_time))
- t = current_emacs_time ();
+ t = current_timespec ();
else
{
Lisp_Object high, low, usec, psec;
else
{
Lisp_Object high, low, usec, psec;
- EMACS_TIME t;
+ struct timespec t;
if (! (disassemble_lisp_time (specified_time, &high, &low, &usec, &psec)
&& decode_time_components (high, low, make_number (0),
make_number (0), &t, 0)))
error ("Invalid time specification");
- return EMACS_SECS (t);
+ return t.tv_sec;
}
}
double t;
if (NILP (specified_time))
{
- EMACS_TIME now = current_emacs_time ();
- t = EMACS_SECS (now) + EMACS_NSECS (now) / 1e9;
+ struct timespec now = current_timespec ();
+ t = now.tv_sec + now.tv_nsec / 1e9;
}
else
{
%G is the year corresponding to the ISO week, %g within the century.
%m is the numeric month.
%b and %h are the locale's abbreviated month name, %B the full name.
+ (%h is not supported on MS-Windows.)
%d is the day of the month, zero-padded, %e is blank-padded.
%u is the numeric day of week from 1 (Monday) to 7, %w from 0 (Sunday) to 6.
%a is the locale's abbreviated name of the day of week, %A the full name.
%c is the locale's date and time format.
%x is the locale's "preferred" date format.
%D is like "%m/%d/%y".
+%F is the ISO 8601 date format (like "%Y-%m-%d").
%R is like "%H:%M", %T is like "%H:%M:%S", %r is like "%I:%M:%S %p".
%X is the locale's "preferred" time format.
%EX is a locale's alternative version of %X;
%OX is like %X, but uses the locale's number symbols.
-For example, to produce full ISO 8601 format, use "%Y-%m-%dT%T%z".
+For example, to produce full ISO 8601 format, use "%FT%T%z".
usage: (format-time-string FORMAT-STRING &optional TIME UNIVERSAL) */)
(Lisp_Object format_string, Lisp_Object timeval, Lisp_Object universal)
{
- EMACS_TIME t = lisp_time_argument (timeval);
+ struct timespec t = lisp_time_argument (timeval);
struct tm tm;
CHECK_STRING (format_string);
static Lisp_Object
format_time_string (char const *format, ptrdiff_t formatlen,
- EMACS_TIME t, bool ut, struct tm *tmp)
+ struct timespec t, bool ut, struct tm *tmp)
{
char buffer[4000];
char *buf = buffer;
ptrdiff_t size = sizeof buffer;
size_t len;
Lisp_Object bufstring;
- int ns = EMACS_NSECS (t);
+ int ns = t.tv_nsec;
struct tm *tm;
USE_SAFE_ALLOCA;
while (1)
{
- time_t *taddr = emacs_secs_addr (&t);
+ time_t *taddr = &t.tv_sec;
block_input ();
synchronize_system_time_locale ();
the data it can't find. */)
(Lisp_Object specified_time)
{
- EMACS_TIME value;
+ struct timespec value;
int offset;
struct tm *t;
struct tm localtm;
Lisp_Object zone_offset, zone_name;
zone_offset = Qnil;
- value = make_emacs_time (lisp_seconds_argument (specified_time), 0);
+ value = make_timespec (lisp_seconds_argument (specified_time), 0);
zone_name = format_time_string ("%Z", sizeof "%Z" - 1, value, 0, &localtm);
block_input ();
- t = gmtime (emacs_secs_addr (&value));
+ t = gmtime (&value.tv_sec);
if (t)
offset = tm_diff (&localtm, t);
unblock_input ();
len = CHAR_STRING (c, str);
else
{
- str[0] = ASCII_CHAR_P (c) ? c : multibyte_char_to_unibyte (c);
+ str[0] = CHAR_TO_BYTE8 (c);
len = 1;
}
(*insert_func) ((char *) str, len);
If the current buffer is unibyte, multibyte strings are converted
to unibyte for insertion.
+If an overlay begins at the insertion point, the inserted text falls
+outside the overlay; if a nonempty overlay ends at the insertion
+point, the inserted text falls inside that overlay.
+
usage: (insert-before-markers &rest ARGS) */)
(ptrdiff_t nargs, Lisp_Object *args)
{
ptrdiff_t changed = 0;
unsigned char fromstr[MAX_MULTIBYTE_LENGTH], tostr[MAX_MULTIBYTE_LENGTH];
unsigned char *p;
- ptrdiff_t count = SPECPDL_INDEX ();
+ dynwind_begin ();
#define COMBINING_NO 0
#define COMBINING_BEFORE 1
#define COMBINING_AFTER 2
len = CHAR_STRING (fromc, fromstr);
if (CHAR_STRING (toc, tostr) != len)
error ("Characters in `subst-char-in-region' have different byte-lengths");
- if (!ASCII_BYTE_P (*tostr))
+ if (!ASCII_CHAR_P (*tostr))
{
/* If *TOSTR is in the range 0x80..0x9F and TOCHAR is not a
complete multibyte character, it may be combined with the
else if (!changed)
{
changed = -1;
- modify_region_1 (pos, XINT (end), false);
+ modify_text (pos, XINT (end));
if (! NILP (noundo))
{
: ((pos_byte_next < Z_BYTE
&& ! CHAR_HEAD_P (FETCH_BYTE (pos_byte_next)))
|| (pos_byte > BEG_BYTE
- && ! ASCII_BYTE_P (FETCH_BYTE (pos_byte - 1))))))
+ && ! ASCII_CHAR_P (FETCH_BYTE (pos_byte - 1))))))
{
Lisp_Object tem, string;
update_compositions (changed, last_changed, CHECK_ALL);
}
- unbind_to (count, Qnil);
+ dynwind_end ();
return Qnil;
}
pos = XINT (start);
pos_byte = CHAR_TO_BYTE (pos);
end_pos = XINT (end);
- modify_region_1 (pos, end_pos, false);
+ modify_text (pos, end_pos);
cnt = 0;
for (; pos < end_pos; )
else
{
nc = tt[oc];
- if (! ASCII_BYTE_P (nc) && multibyte)
+ if (! ASCII_CHAR_P (nc) && multibyte)
{
str_len = BYTE8_STRING (nc, buf);
str = buf;
buf->clip_changed = 1; /* Remember that the narrowing changed. */
}
- /* These aren't needed anymore, so don't wait for GC. */
- free_marker (XCAR (data));
- free_marker (XCDR (data));
- free_cons (XCONS (data));
}
else
/* A buffer, which means that there was no old restriction. */
(Lisp_Object body)
{
register Lisp_Object val;
- ptrdiff_t count = SPECPDL_INDEX ();
+ dynwind_begin ();
record_unwind_protect (save_restriction_restore, save_restriction_save ());
val = Fprogn (body);
- return unbind_to (count, val);
+ dynwind_end ();
+ return val;
}
\f
DEFUN ("message", Fmessage, Smessage, 1, MANY, 0,
is non-nil. (In keyboard macros, that's all it does.)
Return the message.
+In batch mode, the message is printed to the standard error stream,
+followed by a newline.
+
The first argument is a format control string, and the rest are data
to be formatted under control of the string. See `format' for details.
else
{
Lisp_Object val = Fformat (nargs, args);
-#ifdef HAVE_MENUS
- /* The MS-DOS frames support popup menus even though they are
- not FRAME_WINDOW_P. */
- if (FRAME_WINDOW_P (XFRAME (selected_frame))
- || FRAME_MSDOS_P (XFRAME (selected_frame)))
- {
- Lisp_Object pane, menu;
- struct gcpro gcpro1;
- pane = list1 (Fcons (build_string ("OK"), Qt));
- GCPRO1 (pane);
- menu = Fcons (val, pane);
- Fx_popup_dialog (Qt, menu, Qt);
- UNGCPRO;
- return val;
- }
-#endif /* HAVE_MENUS */
- message3 (val);
+ Lisp_Object pane, menu;
+ struct gcpro gcpro1;
+
+ pane = list1 (Fcons (build_string ("OK"), Qt));
+ GCPRO1 (pane);
+ menu = Fcons (val, pane);
+ Fx_popup_dialog (Qt, menu, Qt);
+ UNGCPRO;
return val;
}
}
usage: (message-or-box FORMAT-STRING &rest ARGS) */)
(ptrdiff_t nargs, Lisp_Object *args)
{
-#ifdef HAVE_MENUS
if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
&& use_dialog_box)
return Fmessage_box (nargs, args);
-#endif
return Fmessage (nargs, args);
}
Fadd_text_properties (make_number (0),
make_number (SCHARS (string)),
properties, string);
- RETURN_UNGCPRO (string);
+ return string;
}
DEFUN ("format", Fformat, Sformat, 1, MANY, 0,
usage: (format STRING &rest OBJECTS) */)
(ptrdiff_t nargs, Lisp_Object *args)
{
- ptrdiff_t n; /* The number of the next arg to substitute */
+ ptrdiff_t n; /* The number of the next arg to substitute. */
char initial_buffer[4000];
char *buf = initial_buffer;
ptrdiff_t bufsize = sizeof initial_buffer;
ptrdiff_t max_bufsize = STRING_BYTES_BOUND + 1;
char *p;
- ptrdiff_t buf_save_value_index IF_LINT (= 0);
char *format, *end, *format_start;
ptrdiff_t formatlen, nchars;
/* True if the format is multibyte. */
struct info
{
ptrdiff_t start, end;
- unsigned converted_to_string : 1;
- unsigned intervals : 1;
+ bool_bf converted_to_string : 1;
+ bool_bf intervals : 1;
} *info = 0;
/* It should not be necessary to GCPRO ARGS, because
if (p > buf
&& multibyte
- && !ASCII_BYTE_P (*((unsigned char *) p - 1))
+ && !ASCII_CHAR_P (*((unsigned char *) p - 1))
&& STRING_MULTIBYTE (args[n])
&& !CHAR_HEAD_P (SREF (args[n], 0)))
maybe_combine_byte = 1;
{
/* Copy a whole multibyte character. */
if (p > buf
- && !ASCII_BYTE_P (*((unsigned char *) p - 1))
+ && !ASCII_CHAR_P (*((unsigned char *) p - 1))
&& !CHAR_HEAD_P (*format))
maybe_combine_byte = 1;
else
{
unsigned char uc = *format++;
- if (! multibyte || ASCII_BYTE_P (uc))
+ if (! multibyte || ASCII_CHAR_P (uc))
convbytes = 1;
else
{
if (buf == initial_buffer)
{
- buf = xmalloc (bufsize);
- sa_must_free = 1;
- buf_save_value_index = SPECPDL_INDEX ();
- record_unwind_protect_ptr (xfree, buf);
+ buf = xmalloc_atomic (bufsize);
memcpy (buf, initial_buffer, used);
}
else
{
buf = xrealloc (buf, bufsize);
- set_unwind_protect_ptr (buf_save_value_index, buf);
}
p = buf + used;
return Qnil;
i1 = XFASTINT (c1);
- if (NILP (BVAR (current_buffer, enable_multibyte_characters))
- && ! ASCII_CHAR_P (i1))
- {
- MAKE_CHAR_MULTIBYTE (i1);
- }
i2 = XFASTINT (c2);
- if (NILP (BVAR (current_buffer, enable_multibyte_characters))
- && ! ASCII_CHAR_P (i2))
+
+ /* FIXME: It is possible to compare multibyte characters even when
+ the current buffer is unibyte. Unfortunately this is ambiguous
+ for characters between 128 and 255, as they could be either
+ eight-bit raw bytes or Latin-1 characters. Assume the former for
+ now. See Bug#17011, and also see casefiddle.c's casify_object,
+ which has a similar problem. */
+ if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
{
- MAKE_CHAR_MULTIBYTE (i2);
+ if (SINGLE_BYTE_CHAR_P (i1))
+ i1 = UNIBYTE_TO_CHAR (i1);
+ if (SINGLE_BYTE_CHAR_P (i2))
+ i2 = UNIBYTE_TO_CHAR (i2);
}
+
return (downcase (i1) == downcase (i2) ? Qt : Qnil);
}
\f
if (end1 == start2) /* adjacent regions */
{
- modify_region_1 (start1, end2, false);
+ modify_text (start1, end2);
record_change (start1, len1 + len2);
tmp_interval1 = copy_intervals (cur_intv, start1, len1);
{
USE_SAFE_ALLOCA;
- modify_region_1 (start1, end1, false);
- modify_region_1 (start2, end2, false);
+ modify_text (start1, end1);
+ modify_text (start2, end2);
record_change (start1, len1);
record_change (start2, len2);
tmp_interval1 = copy_intervals (cur_intv, start1, len1);
{
USE_SAFE_ALLOCA;
- modify_region_1 (start1, end2, false);
+ modify_text (start1, end2);
record_change (start1, (end2 - start1));
tmp_interval1 = copy_intervals (cur_intv, start1, len1);
tmp_interval_mid = copy_intervals (cur_intv, end1, len_mid);
USE_SAFE_ALLOCA;
record_change (start1, (end2 - start1));
- modify_region_1 (start1, end2, false);
+ modify_text (start1, end2);
tmp_interval1 = copy_intervals (cur_intv, start1, len1);
tmp_interval_mid = copy_intervals (cur_intv, end1, len_mid);
void
syms_of_editfns (void)
{
+#include "editfns.x"
+
DEFSYM (Qbuffer_access_fontify_functions, "buffer-access-fontify-functions");
DEFVAR_LISP ("inhibit-field-text-motion", Vinhibit_field_text_motion,
DEFVAR_LISP ("operating-system-release", Voperating_system_release,
doc: /* The release of the operating system Emacs is running on. */);
- defsubr (&Spropertize);
- defsubr (&Schar_equal);
- defsubr (&Sgoto_char);
- defsubr (&Sstring_to_char);
- defsubr (&Schar_to_string);
- defsubr (&Sbyte_to_string);
- defsubr (&Sbuffer_substring);
- defsubr (&Sbuffer_substring_no_properties);
- defsubr (&Sbuffer_string);
-
- defsubr (&Spoint_marker);
- defsubr (&Smark_marker);
- defsubr (&Spoint);
- defsubr (&Sregion_beginning);
- defsubr (&Sregion_end);
-
DEFSYM (Qfield, "field");
DEFSYM (Qboundary, "boundary");
- defsubr (&Sfield_beginning);
- defsubr (&Sfield_end);
- defsubr (&Sfield_string);
- defsubr (&Sfield_string_no_properties);
- defsubr (&Sdelete_field);
- defsubr (&Sconstrain_to_field);
-
- defsubr (&Sline_beginning_position);
- defsubr (&Sline_end_position);
-
- defsubr (&Ssave_excursion);
- defsubr (&Ssave_current_buffer);
-
- defsubr (&Sbuffer_size);
- defsubr (&Spoint_max);
- defsubr (&Spoint_min);
- defsubr (&Spoint_min_marker);
- defsubr (&Spoint_max_marker);
- defsubr (&Sgap_position);
- defsubr (&Sgap_size);
- defsubr (&Sposition_bytes);
- defsubr (&Sbyte_to_position);
-
- defsubr (&Sbobp);
- defsubr (&Seobp);
- defsubr (&Sbolp);
- defsubr (&Seolp);
- defsubr (&Sfollowing_char);
- defsubr (&Sprevious_char);
- defsubr (&Schar_after);
- defsubr (&Schar_before);
- defsubr (&Sinsert);
- defsubr (&Sinsert_before_markers);
- defsubr (&Sinsert_and_inherit);
- defsubr (&Sinsert_and_inherit_before_markers);
- defsubr (&Sinsert_char);
- defsubr (&Sinsert_byte);
-
- defsubr (&Suser_login_name);
- defsubr (&Suser_real_login_name);
- defsubr (&Suser_uid);
- defsubr (&Suser_real_uid);
- defsubr (&Sgroup_gid);
- defsubr (&Sgroup_real_gid);
- defsubr (&Suser_full_name);
- defsubr (&Semacs_pid);
- defsubr (&Scurrent_time);
- defsubr (&Sget_internal_run_time);
- defsubr (&Sformat_time_string);
- defsubr (&Sfloat_time);
- defsubr (&Sdecode_time);
- defsubr (&Sencode_time);
- defsubr (&Scurrent_time_string);
- defsubr (&Scurrent_time_zone);
- defsubr (&Sset_time_zone_rule);
- defsubr (&Ssystem_name);
- defsubr (&Smessage);
- defsubr (&Smessage_box);
- defsubr (&Smessage_or_box);
- defsubr (&Scurrent_message);
- defsubr (&Sformat);
-
- defsubr (&Sinsert_buffer_substring);
- defsubr (&Scompare_buffer_substrings);
- defsubr (&Ssubst_char_in_region);
- defsubr (&Stranslate_region_internal);
- defsubr (&Sdelete_region);
- defsubr (&Sdelete_and_extract_region);
- defsubr (&Swiden);
- defsubr (&Snarrow_to_region);
- defsubr (&Ssave_restriction);
- defsubr (&Stranspose_regions);
}
HCoop / bpt / emacs.git / blobdiff