void (*) (Lisp_Object, EMACS_INT,
EMACS_INT, EMACS_INT,
EMACS_INT, int),
- int, int, Lisp_Object *);
+ int, size_t, Lisp_Object *);
static Lisp_Object subst_char_in_region_unwind (Lisp_Object);
static Lisp_Object subst_char_in_region_unwind_1 (Lisp_Object);
static void transpose_markers (EMACS_INT, EMACS_INT, EMACS_INT, EMACS_INT,
EMACS_INT, EMACS_INT, EMACS_INT, EMACS_INT);
Lisp_Object Qbuffer_access_fontify_functions;
-Lisp_Object Fuser_full_name (Lisp_Object);
+INFUN (Fuser_full_name, 1);
/* Symbol for the text property used to mark fields. */
#endif
}
\f
-DEFUN ("char-to-string", Fchar_to_string, Schar_to_string, 1, 1, 0,
+DEFUE ("char-to-string", Fchar_to_string, Schar_to_string, 1, 1, 0,
doc: /* Convert arg CHAR to a string containing that character.
usage: (char-to-string CHAR) */)
(Lisp_Object character)
return mark;
}
-DEFUN ("point", Fpoint, Spoint, 0, 0, 0,
+DEFUE ("point", Fpoint, Spoint, 0, 0, 0,
doc: /* Return value of point, as an integer.
Beginning of buffer is position (point-min). */)
(void)
return temp;
}
-DEFUN ("point-marker", Fpoint_marker, Spoint_marker, 0, 0, 0,
+DEFUE ("point-marker", Fpoint_marker, Spoint_marker, 0, 0, 0,
doc: /* Return value of point, as a marker object. */)
(void)
{
return num;
}
-DEFUN ("goto-char", Fgoto_char, Sgoto_char, 1, 1, "NGoto char: ",
+DEFUE ("goto-char", Fgoto_char, Sgoto_char, 1, 1, "NGoto char: ",
doc: /* Set point to POSITION, a number or marker.
Beginning of buffer is position (point-min), end is (point-max).
return make_number (beg);
}
-DEFUN ("field-end", Ffield_end, Sfield_end, 0, 3, 0,
+DEFUE ("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.
return make_number (end);
}
-DEFUN ("constrain-to-field", Fconstrain_to_field, Sconstrain_to_field, 2, 5, 0,
+DEFUE ("constrain-to-field", Fconstrain_to_field, Sconstrain_to_field, 2, 5, 0,
doc: /* Return the position closest to NEW-POS that is in the same field as OLD-POS.
A field is a region of text with the same `field' property.
/* It is possible that NEW_POS is not within the same field as
OLD_POS; try to move NEW_POS so that it is. */
{
- int shortage;
+ EMACS_INT shortage;
Lisp_Object field_bound;
if (fwd)
}
\f
-DEFUN ("line-beginning-position",
+DEFUE ("line-beginning-position",
Fline_beginning_position, Sline_beginning_position, 0, 1, 0,
doc: /* Return the character position of the first character on the current line.
With argument N not nil or 1, move forward N - 1 lines first.
Qt, Qnil);
}
-DEFUN ("line-end-position", Fline_end_position, Sline_end_position, 0, 1, 0,
+DEFUE ("line-end-position", Fline_end_position, Sline_end_position, 0, 1, 0,
doc: /* Return the character position of the last character on the current line.
With argument N not nil or 1, move forward N - 1 lines first.
If scan reaches end of buffer, return that position.
tem1 = BVAR (current_buffer, mark_active);
BVAR (current_buffer, mark_active) = tem;
- if (!NILP (Vrun_hooks))
+ /* If mark is active now, and either was not active
+ or was at a different place, run the activate hook. */
+ if (! NILP (tem))
{
- /* If mark is active now, and either was not active
- or was at a different place, run the activate hook. */
- if (! NILP (BVAR (current_buffer, mark_active)))
- {
- if (! EQ (omark, nmark))
- call1 (Vrun_hooks, intern ("activate-mark-hook"));
- }
- /* If mark has ceased to be active, run deactivate hook. */
- else if (! NILP (tem1))
- call1 (Vrun_hooks, intern ("deactivate-mark-hook"));
+ if (! EQ (omark, nmark))
+ {
+ tem = intern ("activate-mark-hook");
+ Frun_hooks (1, &tem);
+ }
+ }
+ /* If mark has ceased to be active, run deactivate hook. */
+ else if (! NILP (tem1))
+ {
+ tem = intern ("deactivate-mark-hook");
+ Frun_hooks (1, &tem);
}
/* If buffer was visible in a window, and a different window was
return temp;
}
-DEFUN ("point-max-marker", Fpoint_max_marker, Spoint_max_marker, 0, 0, 0,
+DEFUE ("point-max-marker", Fpoint_max_marker, Spoint_max_marker, 0, 0, 0,
doc: /* Return a marker to the maximum permissible value of point in this buffer.
This is (1+ (buffer-size)), unless narrowing (a buffer restriction)
is in effect, in which case it is less. */)
return make_number (BYTE_TO_CHAR (XINT (bytepos)));
}
\f
-DEFUN ("following-char", Ffollowing_char, Sfollowing_char, 0, 0, 0,
+DEFUE ("following-char", Ffollowing_char, Sfollowing_char, 0, 0, 0,
doc: /* Return the character following point, as a number.
At the end of the buffer or accessible region, return 0. */)
(void)
return temp;
}
-DEFUN ("preceding-char", Fprevious_char, Sprevious_char, 0, 0, 0,
+DEFUE ("preceding-char", Fprevious_char, Sprevious_char, 0, 0, 0,
doc: /* Return the character preceding point, as a number.
At the beginning of the buffer or accessible region, return 0. */)
(void)
return temp;
}
-DEFUN ("bobp", Fbobp, Sbobp, 0, 0, 0,
+DEFUE ("bobp", Fbobp, Sbobp, 0, 0, 0,
doc: /* Return t if point is at the beginning of the buffer.
If the buffer is narrowed, this means the beginning of the narrowed part. */)
(void)
return Qnil;
}
-DEFUN ("eobp", Feobp, Seobp, 0, 0, 0,
+DEFUE ("eobp", Feobp, Seobp, 0, 0, 0,
doc: /* Return t if point is at the end of the buffer.
If the buffer is narrowed, this means the end of the narrowed part. */)
(void)
return Qnil;
}
-DEFUN ("bolp", Fbolp, Sbolp, 0, 0, 0,
+DEFUE ("bolp", Fbolp, Sbolp, 0, 0, 0,
doc: /* Return t if point is at the beginning of a line. */)
(void)
{
return Qnil;
}
-DEFUN ("eolp", Feolp, Seolp, 0, 0, 0,
+DEFUE ("eolp", Feolp, Seolp, 0, 0, 0,
doc: /* Return t if point is at the end of a line.
`End of a line' includes point being at the end of the buffer. */)
(void)
return Qnil;
}
-DEFUN ("char-after", Fchar_after, Schar_after, 0, 1, 0,
+DEFUE ("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 and defaults to point.
If POS is out of range, the value is nil. */)
return val;
}
\f
-DEFUN ("user-login-name", Fuser_login_name, Suser_login_name, 0, 1, 0,
+DEFUE ("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 variables LOGNAME or USER are set,
return full;
}
-DEFUN ("system-name", Fsystem_name, Ssystem_name, 0, 0, 0,
+DEFUE ("system-name", Fsystem_name, Ssystem_name, 0, 0, 0,
doc: /* Return the host name of the machine you are running on, as a string. */)
(void)
{
return t & ((1 << 16) - 1);
}
-DEFUN ("current-time", Fcurrent_time, Scurrent_time, 0, 0, 0,
+DEFUE ("current-time", Fcurrent_time, Scurrent_time, 0, 0, 0,
doc: /* Return the current time, as the number of seconds since 1970-01-01 00:00:00.
The time is returned as a list of three integers. The first has the
most significant 16 bits of the seconds, while the second has the
make_number (EMACS_USECS (t)));
}
-DEFUN ("get-internal-run-time", Fget_internal_run_time, Sget_internal_run_time,
+DEFUE ("get-internal-run-time", Fget_internal_run_time, Sget_internal_run_time,
0, 0, 0,
doc: /* Return the current run time used by Emacs.
The time is returned as a list of three integers. The first has the
year values as low as 1901 do work.
usage: (encode-time SECOND MINUTE HOUR DAY MONTH YEAR &optional ZONE) */)
- (int nargs, register Lisp_Object *args)
+ (size_t nargs, register Lisp_Object *args)
{
time_t value;
struct tm tm;
void (*insert_from_string_func)
(Lisp_Object, EMACS_INT, EMACS_INT,
EMACS_INT, EMACS_INT, int),
- int inherit, int nargs, Lisp_Object *args)
+ int inherit, size_t nargs, Lisp_Object *args)
{
- register int argnum;
+ register size_t argnum;
register Lisp_Object val;
for (argnum = 0; argnum < nargs; argnum++)
{
str[0] = (ASCII_CHAR_P (XINT (val))
? XINT (val)
- : multibyte_char_to_unibyte (XINT (val), Qnil));
+ : multibyte_char_to_unibyte (XINT (val)));
len = 1;
}
(*insert_func) ((char *) str, len);
not be used after calling insert or insert_from_string, so
we don't care if it gets trashed. */
-DEFUN ("insert", Finsert, Sinsert, 0, MANY, 0,
+DEFUE ("insert", Finsert, Sinsert, 0, MANY, 0,
doc: /* Insert the arguments, either strings or characters, at point.
Point and before-insertion markers move forward to end up
after the inserted text.
and insert the result.
usage: (insert &rest ARGS) */)
- (int nargs, register Lisp_Object *args)
+ (size_t nargs, register Lisp_Object *args)
{
general_insert_function (insert, insert_from_string, 0, nargs, args);
return Qnil;
to unibyte for insertion.
usage: (insert-and-inherit &rest ARGS) */)
- (int nargs, register Lisp_Object *args)
+ (size_t nargs, register Lisp_Object *args)
{
general_insert_function (insert_and_inherit, insert_from_string, 1,
nargs, args);
to unibyte for insertion.
usage: (insert-before-markers &rest ARGS) */)
- (int nargs, register Lisp_Object *args)
+ (size_t nargs, register Lisp_Object *args)
{
general_insert_function (insert_before_markers,
insert_from_string_before_markers, 0,
to unibyte for insertion.
usage: (insert-before-markers-and-inherit &rest ARGS) */)
- (int nargs, register Lisp_Object *args)
+ (size_t nargs, register Lisp_Object *args)
{
general_insert_function (insert_before_markers_and_inherit,
insert_from_string_before_markers, 1,
return Qnil;
}
\f
-DEFUN ("insert-char", Finsert_char, Sinsert_char, 2, 3, 0,
+DEFUE ("insert-char", Finsert_char, Sinsert_char, 2, 3, 0,
doc: /* Insert COUNT copies of CHARACTER.
Point, and before-insertion markers, are relocated as in the function `insert'.
The optional third arg INHERIT, if non-nil, says to inherit text properties
}
}
-DEFUN ("buffer-substring", Fbuffer_substring, Sbuffer_substring, 2, 2, 0,
+DEFUE ("buffer-substring", Fbuffer_substring, Sbuffer_substring, 2, 2, 0,
doc: /* Return the contents of part of the current buffer as a string.
The two arguments START and END are character positions;
they can be in either order.
return make_buffer_string (b, e, 0);
}
-DEFUN ("buffer-string", Fbuffer_string, Sbuffer_string, 0, 0, 0,
+DEFUE ("buffer-string", Fbuffer_string, Sbuffer_string, 0, 0, 0,
doc: /* Return the contents of the current buffer as a string.
If narrowing is in effect, this function returns only the visible part
of the buffer. */)
return make_number (cnt);
}
-DEFUN ("delete-region", Fdelete_region, Sdelete_region, 2, 2, "r",
+DEFUE ("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,
return del_range_1 (XINT (start), XINT (end), 1, 1);
}
\f
-DEFUN ("widen", Fwiden, Swiden, 0, 0, "",
+DEFUE ("widen", Fwiden, Swiden, 0, 0, "",
doc: /* Remove restrictions (narrowing) from current buffer.
This allows the buffer's full text to be seen and edited. */)
(void)
return Qnil;
}
-DEFUN ("narrow-to-region", Fnarrow_to_region, Snarrow_to_region, 2, 2, "r",
+DEFUE ("narrow-to-region", Fnarrow_to_region, Snarrow_to_region, 2, 2, "r",
doc: /* Restrict editing in this buffer to the current region.
The rest of the text becomes temporarily invisible and untouchable
but is not deleted; if you save the buffer in a file, the invisible
/* Allocated length of that buffer. */
static int message_length;
-DEFUN ("message", Fmessage, Smessage, 1, MANY, 0,
+DEFUE ("message", Fmessage, Smessage, 1, MANY, 0,
doc: /* Display a message at the bottom of the screen.
The message also goes into the `*Messages*' buffer.
\(In keyboard macros, that's all it does.)
also `current-message'.
usage: (message FORMAT-STRING &rest ARGS) */)
- (int nargs, Lisp_Object *args)
+ (size_t nargs, Lisp_Object *args)
{
if (NILP (args[0])
|| (STRINGP (args[0])
message; let the minibuffer contents show.
usage: (message-box FORMAT-STRING &rest ARGS) */)
- (int nargs, Lisp_Object *args)
+ (size_t nargs, Lisp_Object *args)
{
if (NILP (args[0]))
{
if (FRAME_WINDOW_P (XFRAME (selected_frame))
|| FRAME_MSDOS_P (XFRAME (selected_frame)))
{
- Lisp_Object pane, menu, obj;
+ Lisp_Object pane, menu;
struct gcpro gcpro1;
pane = Fcons (Fcons (build_string ("OK"), Qt), Qnil);
GCPRO1 (pane);
menu = Fcons (val, pane);
- obj = Fx_popup_dialog (Qt, menu, Qt);
+ Fx_popup_dialog (Qt, menu, Qt);
UNGCPRO;
return val;
}
message; let the minibuffer contents show.
usage: (message-or-box FORMAT-STRING &rest ARGS) */)
- (int nargs, Lisp_Object *args)
+ (size_t nargs, Lisp_Object *args)
{
#ifdef HAVE_MENUS
if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
return Fmessage (nargs, args);
}
-DEFUN ("current-message", Fcurrent_message, Scurrent_message, 0, 0, 0,
+DEFUE ("current-message", Fcurrent_message, Scurrent_message, 0, 0, 0,
doc: /* Return the string currently displayed in the echo area, or nil if none. */)
(void)
{
Remaining arguments form a sequence of PROPERTY VALUE pairs for text
properties to add to the result.
usage: (propertize STRING &rest PROPERTIES) */)
- (int nargs, Lisp_Object *args)
+ (size_t nargs, Lisp_Object *args)
{
Lisp_Object properties, string;
struct gcpro gcpro1, gcpro2;
- int i;
+ size_t i;
/* Number of args must be odd. */
- if ((nargs & 1) == 0 || nargs < 1)
+ if ((nargs & 1) == 0)
error ("Wrong number of arguments");
properties = string = Qnil;
? count_size_as_multibyte (SDATA (STRING), SBYTES (STRING)) \
: SBYTES (STRING))
-DEFUN ("format", Fformat, Sformat, 1, MANY, 0,
+DEFUE ("format", Fformat, Sformat, 1, MANY, 0,
doc: /* Format a string out of a format-string and arguments.
The first argument is a format control string.
The other arguments are substituted into it to make the result, a string.
specifier truncates the string to the given width.
usage: (format STRING &rest OBJECTS) */)
- (int nargs, register Lisp_Object *args)
+ (size_t nargs, register Lisp_Object *args)
{
- register int n; /* The number of the next arg to substitute */
- register EMACS_INT total; /* An estimate of the final length */
+ register size_t n; /* The number of the next arg to substitute */
+ register size_t total; /* An estimate of the final length */
char *buf, *p;
register char *format, *end, *format_start;
int nchars;
/* Allocate the info and discarded tables. */
{
- int nbytes = (nargs+1) * sizeof *info;
- int i;
+ size_t nbytes = (nargs+1) * sizeof *info;
+ size_t i;
if (!info)
info = (struct info *) alloca (nbytes);
memset (info, 0, nbytes);
- for (i = 0; i <= nargs; i++)
+ for (i = 0; i < nargs + 1; i++)
info[i].start = -1;
if (!discarded)
SAFE_ALLOCA (discarded, char *, SBYTES (args[0]));
if (*format == 'c')
{
if (! ASCII_CHAR_P (XINT (args[n]))
- /* Note: No one can remeber why we have to treat
+ /* 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. */
args[n] = Fchar_to_string (args[n]);
thissize = SBYTES (args[n]);
}
- else if (! ASCII_BYTE_P (XINT (args[n])) && multibyte)
- {
- args[n]
- = Fchar_to_string (Funibyte_char_to_multibyte (args[n]));
- thissize = SBYTES (args[n]);
- }
}
}
else if (FLOATP (args[n]) && *format != 's')
HCoop / bpt / emacs.git / blobdiff