void
display_malloc_warning (void)
{
- call3 (Qdisplay_warning,
+ calln (Qdisplay_warning,
Qalloc,
build_string (pending_malloc_warning),
QCemergency);
= Ffind_file_name_handler (BVAR (current_buffer, directory),
Qmemory_info);
if (!NILP (handler))
- return call1 (handler, Qmemory_info);
+ return calln (handler, Qmemory_info);
#if defined HAVE_LINUX_SYSINFO
struct sysinfo si;
{
Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
- call2 (Qface_set_after_frame_default, frame, Qnil);
+ calln (Qface_set_after_frame_default, frame, Qnil);
if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
{
{
if (!NILP (tip_timer))
{
- call1 (Qcancel_timer, tip_timer);
+ calln (Qcancel_timer, tip_timer);
tip_timer = Qnil;
}
tip_f = XFRAME (tip_frame);
if (!NILP (tip_timer))
{
- call1 (Qcancel_timer, tip_timer);
+ calln (Qcancel_timer, tip_timer);
tip_timer = Qnil;
}
}
else
tip_last_parms
- = call2 (Qassq_delete_all, parm, tip_last_parms);
+ = calln (Qassq_delete_all, parm, tip_last_parms);
}
else
tip_last_parms
- = call2 (Qassq_delete_all, parm, tip_last_parms);
+ = calln (Qassq_delete_all, parm, tip_last_parms);
}
/* Now check if every parameter in what is left of
start_timer:
/* Let the tip disappear after timeout seconds. */
- tip_timer = call3 (Qrun_at_time, timeout, Qnil,
- Qx_hide_tip);
+ tip_timer = calln (Qrun_at_time, timeout, Qnil, Qx_hide_tip);
return unbind_to (count, Qnil);
#endif
file = ENCODE_FILE (Fexpand_file_name (file, Qnil));
- if (!NILP (call1 (Qfile_remote_p, file)))
+ if (!NILP (calln (Qfile_remote_p, file)))
signal_error ("Cannot relinquish access to remote file", file);
vp = android_name_file (SSDATA (file));
handler = Ffind_file_name_handler (filename, Qget_file_buffer);
if (!NILP (handler))
{
- Lisp_Object handled_buf = call2 (handler, Qget_file_buffer,
+ Lisp_Object handled_buf = calln (handler, Qget_file_buffer,
filename);
return BUFFERP (handled_buf) ? handled_buf : Qnil;
}
{
eassert (buf);
if (! (NILP (Vrun_hooks) || buf->inhibit_buffer_hooks))
- call1 (Vrun_hooks, Qbuffer_list_update_hook);
+ calln (Vrun_hooks, Qbuffer_list_update_hook);
}
DEFUN ("get-buffer-create", Fget_buffer_create, Sget_buffer_create, 1, 2, 0,
run_buffer_list_update_hook (current_buffer);
- call2 (Quniquify__rename_buffer_advice,
- requestedname, unique);
+ calln (Quniquify__rename_buffer_advice, requestedname, unique);
/* Refetch since that last call may have done GC. */
return BVAR (current_buffer, name);
if (candidate_buffer (buf, buffer)
/* If the frame has a buffer_predicate, disregard buffers that
don't fit the predicate. */
- && (NILP (pred) || !NILP (call1 (pred, buf))))
+ && (NILP (pred) || !NILP (calln (pred, buf))))
{
if (!NILP (visible_ok)
|| NILP (Fget_buffer_window (buf, Qvisible)))
if (candidate_buffer (buf, buffer)
/* If the frame has a buffer_predicate, disregard buffers that
don't fit the predicate. */
- && (NILP (pred) || !NILP (call1 (pred, buf))))
+ && (NILP (pred) || !NILP (calln (pred, buf))))
{
if (!NILP (visible_ok)
|| NILP (Fget_buffer_window (buf, Qvisible)))
{
/* Ask whether to kill the buffer, and exit if the user says
"no". */
- if (NILP (call1 (Qkill_buffer__possibly_save, buffer)))
+ if (NILP (calln (Qkill_buffer__possibly_save, buffer)))
return unbind_to (count, Qnil);
/* Recheck modified. */
modified = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b);
while (CONSP (list))
{
if (NILP (arg3))
- call4 (XCAR (list), overlay, after ? Qt : Qnil, arg1, arg2);
+ calln (XCAR (list), overlay, after ? Qt : Qnil, arg1, arg2);
else
- call5 (XCAR (list), overlay, after ? Qt : Qnil, arg1, arg2, arg3);
+ calln (XCAR (list), overlay, after ? Qt : Qnil, arg1, arg2, arg3);
list = XCDR (list);
}
}
Lisp_Object up_event = Qnil;
/* Set SPECS to the interactive form, or barf if not interactive. */
- Lisp_Object form = call1 (Qinteractive_form, function);
+ Lisp_Object form = calln (Qinteractive_form, function);
if (! CONSP (form))
wrong_type_argument (Qcommandp, function);
Lisp_Object specs = Fcar (XCDR (form));
and turn them into things we can eval. */
Lisp_Object values = quotify_args (Fcopy_sequence (specs));
fix_command (function, values);
- call4 (Qadd_to_history, Qcommand_history,
+ calln (Qadd_to_history, Qcommand_history,
Fcons (function, values), Qnil, Qt);
}
goto have_prefix_arg;
FALLTHROUGH;
case 'n': /* Read number from minibuffer. */
- args[i] = call1 (Qread_number, callint_message);
+ args[i] = calln (Qread_number, callint_message);
visargs[i] = Fnumber_to_string (args[i]);
break;
break;
case 'x': /* Lisp expression read but not evaluated. */
- args[i] = call1 (Qread_minibuffer, callint_message);
+ args[i] = calln (Qread_minibuffer, callint_message);
visargs[i] = last_minibuf_string;
break;
case 'X': /* Lisp expression read and evaluated. */
- args[i] = call1 (Qeval_minibuffer, callint_message);
+ args[i] = calln (Qeval_minibuffer, callint_message);
visargs[i] = last_minibuf_string;
break;
visargs[i] = (varies[i] > 0
? list1 (intern (callint_argfuns[varies[i]]))
: quotify_arg (args[i]));
- call4 (Qadd_to_history, Qcommand_history,
+ calln (Qadd_to_history, Qcommand_history,
Flist (nargs - 1, visargs + 1), Qnil, Qt);
}
/* If the caller required, let the buffer inherit the
coding-system used to decode the process output. */
if (inherit_process_coding_system)
- call1 (Qafter_insert_file_set_buffer_file_coding_system,
+ calln (Qafter_insert_file_set_buffer_file_coding_system,
make_fixnum (total_read));
}
{
if (!NILP (region_noncontiguous_p))
{
- Lisp_Object bounds = call1 (Vregion_extract_function, Qbounds);
+ Lisp_Object bounds = calln (Vregion_extract_function, Qbounds);
FOR_EACH_TAIL (bounds)
{
CHECK_CONS (XCAR (bounds));
if (c_function)
(*c_function) (arg, range);
else
- call2 (function, range, arg);
+ calln (function, range, arg);
XSETCAR (range, Qnil);
}
if (c == stop)
if (c_function)
(*c_function) (arg, range);
else
- call2 (function, range, arg);
+ calln (function, range, arg);
}
break;
}
if (NILP (function))
(*c_function) (arg, range);
else
- call2 (function, range, arg);
+ calln (function, range, arg);
}
else if (CHARSET_METHOD (charset) == CHARSET_METHOD_MAP)
{
if (optimizable
&& (NILP (test) ? NILP (Fequal (this, elt)) /* defaults to `equal'. */
: EQ (test, Qeq) ? !EQ (this, elt) /* Optimize `eq' case. */
- : NILP (call2 (test, this, elt))))
+ : NILP (calln (test, this, elt))))
optimizable = 0;
}
{
if (decoder)
val = decoder (top, val);
- call2 (function, XCAR (range), val);
+ calln (function, XCAR (range), val);
}
}
else
{
if (decoder)
val = decoder (top, val);
- call2 (function, range, val);
+ calln (function, range, val);
}
}
}
{
if (decoder)
val = decoder (table, val);
- call2 (function, XCAR (range), val);
+ calln (function, XCAR (range), val);
}
}
else
{
if (decoder)
val = decoder (table, val);
- call2 (function, range, val);
+ calln (function, range, val);
}
}
}
if (c_function)
(*c_function) (arg, range);
else
- call2 (function, range, arg);
+ calln (function, range, arg);
}
XSETCAR (range, Qnil);
}
if (c_function)
(*c_function) (arg, range);
else
- call2 (function, range, arg);
+ calln (function, range, arg);
XSETCAR (range, Qnil);
}
}
if (c_function)
(*c_function) (arg, range);
else
- call2 (function, range, arg);
+ calln (function, range, arg);
}
XSETCAR (range, Qnil);
}
if (c_function)
(*c_function) (arg, range);
else
- call2 (function, range, arg);
+ calln (function, range, arg);
}
}
}
else
{
- call1 (Qkill_forward_chars, n);
+ calln (Qkill_forward_chars, n);
}
return Qnil;
}
Fcons (undo_list, Fcurrent_buffer ()));
bset_undo_list (current_buffer, Qt);
TEMP_SET_PT_BOTH (coding->dst_pos, coding->dst_pos_byte);
- val = call1 (CODING_ATTR_POST_READ (attrs),
+ val = calln (CODING_ATTR_POST_READ (attrs),
make_fixnum (coding->produced_char));
CHECK_FIXNAT (val);
coding->produced_char += Z - prev_Z;
return Fcons (val, val);
if (! NILP (Ffboundp (val)))
{
- /* We use call1 rather than safe_call1
+ /* We use calln rather than safe_calln
so as to get bug reports about functions called here
which don't handle the current interface. */
- val = call1 (val, Flist (nargs, args));
+ val = calln (val, Flist (nargs, args));
if (CONSP (val))
return val;
if (SYMBOLP (val) && ! NILP (Fcoding_system_p (val)))
&& !composition_valid_p (start, end, prop))
to = end;
if (!NILP (Ffboundp (func)))
- call2 (func, make_fixnum (from), make_fixnum (to));
+ calln (func, make_fixnum (from), make_fixnum (to));
}
/* Make invalid compositions adjacent to or inside FROM and TO valid.
{ /* Handle automatic advice activation. */
Lisp_Object hook = Fget (symbol, Qdefalias_fset_function);
if (!NILP (hook))
- call2 (hook, symbol, definition);
+ calln (hook, symbol, definition);
else
Ffset (symbol, definition);
}
if (genfun
/* Avoid burping during bootstrap. */
&& !NILP (Fsymbol_function (Qoclosure_interactive_form)))
- return call1 (Qoclosure_interactive_form, fun);
+ return calln (Qoclosure_interactive_form, fun);
else
return Qnil;
}
}
else if (FUNCTIONP (predicate))
{
- if (NILP (call1 (predicate, newval)))
+ if (NILP (calln (predicate, newval)))
wrong_type_argument (predicate, newval);
}
}
bus or an unknown name, we regard it as broadcast message
due to backward compatibility. */
if (dbus_bus_name_has_owner (connection, SSDATA (service), NULL))
- uname = call2 (Qdbus_get_name_owner, bus, service);
+ uname = calln (Qdbus_get_name_owner, bus, service);
else
uname = Qnil;
call the corresponding file name handler. */
Lisp_Object handler = Ffind_file_name_handler (directory, Qdirectory_files);
if (!NILP (handler))
- return call6 (handler, Qdirectory_files, directory,
+ return calln (handler, Qdirectory_files, directory,
full, match, nosort, count);
return directory_files_internal (directory, full, match, nosort,
Lisp_Object handler
= Ffind_file_name_handler (directory, Qdirectory_files_and_attributes);
if (!NILP (handler))
- return call7 (handler, Qdirectory_files_and_attributes,
+ return calln (handler, Qdirectory_files_and_attributes,
directory, full, match, nosort, id_format, count);
return directory_files_internal (directory, full, match, nosort,
call the corresponding file name handler. */
handler = Ffind_file_name_handler (directory, Qfile_name_completion);
if (!NILP (handler))
- return call4 (handler, Qfile_name_completion, file, directory, predicate);
+ return calln (handler, Qfile_name_completion, file, directory, predicate);
/* If the file name has special constructs in it,
call the corresponding file name handler. */
handler = Ffind_file_name_handler (file, Qfile_name_completion);
if (!NILP (handler))
- return call4 (handler, Qfile_name_completion, file, directory, predicate);
+ return calln (handler, Qfile_name_completion, file, directory, predicate);
return file_name_completion (file, directory, 0, predicate);
}
call the corresponding file name handler. */
handler = Ffind_file_name_handler (directory, Qfile_name_all_completions);
if (!NILP (handler))
- return call3 (handler, Qfile_name_all_completions, file, directory);
+ return calln (handler, Qfile_name_all_completions, file, directory);
/* If the file name has special constructs in it,
call the corresponding file name handler. */
handler = Ffind_file_name_handler (file, Qfile_name_all_completions);
if (!NILP (handler))
- return call3 (handler, Qfile_name_all_completions, file, directory);
+ return calln (handler, Qfile_name_all_completions, file, directory);
return file_name_completion (file, directory, 1, Qnil);
}
name = Ffile_name_as_directory (name);
/* Test the predicate, if any. */
- if (!NILP (predicate) && NILP (call1 (predicate, name)))
+ if (!NILP (predicate) && NILP (calln (predicate, name)))
continue;
/* Reject entries where the encoded strings match, but the
compatibility with old file name handlers which do not
implement the new arg. --Stef */
if (NILP (id_format))
- return call2 (handler, Qfile_attributes, filename);
+ return calln (handler, Qfile_attributes, filename);
else
- return call3 (handler, Qfile_attributes, filename, id_format);
+ return calln (handler, Qfile_attributes, filename, id_format);
}
encoded = ENCODE_FILE (filename);
xsignal1 (Qvoid_function, function);
if (CONSP (fun) && EQ (XCAR (fun), Qmacro))
fun = XCDR (fun);
- doc = call1 (Qfunction_documentation, fun);
+ doc = calln (Qfunction_documentation, fun);
/* If DOC is 0, it's typically because of a dumped file missing
from the DOC file (bug in src/Makefile.in). */
}
if (NILP (raw))
- doc = call1 (Qsubstitute_command_keys, doc);
+ doc = calln (Qsubstitute_command_keys, doc);
return doc;
}
tem = Feval (tem, Qnil);
if (NILP (raw) && STRINGP (tem))
- tem = call1 (Qsubstitute_command_keys, tem);
+ tem = calln (Qsubstitute_command_keys, tem);
return tem;
}
\f
if (NILP (Vpurify_flag))
{
if (!NILP (Ffboundp (Qfile_truename)))
- dir = call1 (Qfile_truename, dir);
+ dir = calln (Qfile_truename, dir);
}
dir = Fexpand_file_name (build_string ("../.."), dir);
}
if (noninteractive)
safe_run_hooks (Qkill_emacs_hook);
else
- call1 (Qrun_hook_query_error_with_timeout, Qkill_emacs_hook);
+ calln (Qrun_hook_query_error_with_timeout, Qkill_emacs_hook);
}
#ifdef HAVE_X_WINDOWS
return Fmake_interpreted_closure
(args, cdr, Vinternal_interpreter_environment, docstring, iform);
else
- return call5 (Vinternal_make_interpreted_closure_function,
+ return calln (Vinternal_make_interpreted_closure_function,
args, cdr, Vinternal_interpreter_environment,
docstring, iform);
}
" to `%s'");
formatted = CALLN (Fformat_message, message,
new_alias, base_variable);
- call2 (Qdisplay_warning,
+ calln (Qdisplay_warning,
list3 (Qdefvaralias, Qlosing_value, new_alias),
formatted);
}
/* FIXME: 'handler-bind' makes `signal-hook-function' obsolete? */
/* FIXME: Here we still "split" the error object
into its error-symbol and its error-data? */
- call2 (Vsignal_hook_function, error_symbol, data);
+ calln (Vsignal_hook_function, error_symbol, data);
unbind_to (count, Qnil);
}
max_ensure_room (20);
push_handler (make_fixnum (skip + h->bytecode_dest),
SKIP_CONDITIONS);
- call1 (h->val, error);
+ calln (h->val, error);
unbind_to (count, Qnil);
pop_handler ();
}
a type-specific interactive-form. */
if (genfun)
{
- Lisp_Object iform = call1 (Qinteractive_form, fun);
+ Lisp_Object iform = calln (Qinteractive_form, fun);
return NILP (iform) ? Qnil : Qt;
}
else
flags = list2 (QCdebug_on_exit, Qt);
if (backtrace_nargs (pdl) == UNEVALLED)
- return call4 (function, Qnil, backtrace_function (pdl), *backtrace_args (pdl), flags);
+ return calln (function, Qnil, backtrace_function (pdl), *backtrace_args (pdl), flags);
else
{
Lisp_Object tem = Flist (backtrace_nargs (pdl), backtrace_args (pdl));
- return call4 (function, Qt, backtrace_function (pdl), tem, flags);
+ return calln (function, Qt, backtrace_function (pdl), tem, flags);
}
}
handler = Ffind_file_name_handler (filename, Qfile_name_directory);
if (!NILP (handler))
{
- Lisp_Object handled_name = call2 (handler, Qfile_name_directory,
+ Lisp_Object handled_name = calln (handler, Qfile_name_directory,
filename);
return STRINGP (handled_name) ? handled_name : Qnil;
}
handler = Ffind_file_name_handler (filename, Qfile_name_nondirectory);
if (!NILP (handler))
{
- Lisp_Object handled_name = call2 (handler, Qfile_name_nondirectory,
+ Lisp_Object handled_name = calln (handler, Qfile_name_nondirectory,
filename);
if (STRINGP (handled_name))
return handled_name;
handler = Ffind_file_name_handler (filename, Qunhandled_file_name_directory);
if (!NILP (handler))
{
- Lisp_Object handled_name = call2 (handler, Qunhandled_file_name_directory,
+ Lisp_Object handled_name = calln (handler, Qunhandled_file_name_directory,
filename);
return STRINGP (handled_name) ? handled_name : Qnil;
}
handler = Ffind_file_name_handler (file, Qfile_name_as_directory);
if (!NILP (handler))
{
- Lisp_Object handled_name = call2 (handler, Qfile_name_as_directory,
+ Lisp_Object handled_name = calln (handler, Qfile_name_as_directory,
file);
if (STRINGP (handled_name))
return handled_name;
handler = Ffind_file_name_handler (directory, Qdirectory_file_name);
if (!NILP (handler))
{
- Lisp_Object handled_name = call2 (handler, Qdirectory_file_name,
+ Lisp_Object handled_name = calln (handler, Qdirectory_file_name,
directory);
if (STRINGP (handled_name))
return handled_name;
handler = Ffind_file_name_handler (name, Qexpand_file_name);
if (!NILP (handler))
{
- handled_name = call3 (handler, Qexpand_file_name,
+ handled_name = calln (handler, Qexpand_file_name,
name, default_directory);
if (STRINGP (handled_name))
return handled_name;
handler = Ffind_file_name_handler (default_directory, Qexpand_file_name);
if (!NILP (handler))
{
- handled_name = call3 (handler, Qexpand_file_name,
+ handled_name = calln (handler, Qexpand_file_name,
name, default_directory);
if (STRINGP (handled_name))
return handled_name;
Qexpand_file_name);
if (!NILP (handler))
{
- handled_name = call3 (handler, Qexpand_file_name,
+ handled_name = calln (handler, Qexpand_file_name,
name, default_directory);
if (STRINGP (handled_name))
return handled_name;
handler = Ffind_file_name_handler (result, Qexpand_file_name);
if (!NILP (handler))
{
- handled_name = call3 (handler, Qexpand_file_name,
+ handled_name = calln (handler, Qexpand_file_name,
result, default_directory);
if (! STRINGP (handled_name))
error ("Invalid handler in `file-name-handler-alist'");
handler = Ffind_file_name_handler (filename, Qsubstitute_in_file_name);
if (!NILP (handler))
{
- Lisp_Object handled_name = call2 (handler, Qsubstitute_in_file_name,
+ Lisp_Object handled_name = calln (handler, Qsubstitute_in_file_name,
filename);
if (STRINGP (handled_name))
return handled_name;
Lisp_Object name
= (!substituted ? filename
: make_specified_string (nm, -1, endp - nm, multibyte));
- Lisp_Object tmp = call1 (Qsubstitute_env_in_file_name, name);
+ Lisp_Object tmp = calln (Qsubstitute_env_in_file_name, name);
CHECK_STRING (tmp);
if (!EQ (tmp, name))
substituted = true;
AUTO_STRING (format, "File %s already exists; %s anyway? ");
tem = CALLN (Fformat, format, absname, build_string (querystring));
if (quick)
- tem = call1 (Qy_or_n_p, tem);
+ tem = calln (Qy_or_n_p, tem);
else
tem = do_yes_or_no_p (tem);
if (NILP (tem))
if (NILP (handler))
handler = Ffind_file_name_handler (newname, Qcopy_file);
if (!NILP (handler))
- return call7 (handler, Qcopy_file, file, newname,
+ return calln (handler, Qcopy_file, file, newname,
ok_if_already_exists, keep_time, preserve_uid_gid,
preserve_permissions);
call the corresponding file name handler. */
handler = Ffind_file_name_handler (filename, Qfile_name_case_insensitive_p);
if (!NILP (handler))
- return call2 (handler, Qfile_name_case_insensitive_p, filename);
+ return calln (handler, Qfile_name_case_insensitive_p, filename);
/* If the file doesn't exist or there is trouble checking its
filesystem, move up the filesystem tree until we reach an
if (NILP (handler))
handler = Ffind_file_name_handler (newname, Qrename_file);
if (!NILP (handler))
- return call4 (handler, Qrename_file,
+ return calln (handler, Qrename_file,
file, newname, ok_if_already_exists);
encoded_file = ENCODE_FILE (file);
dirp = S_ISDIR (file_st.st_mode) != 0;
}
if (dirp)
- call4 (Qcopy_directory, file, newname, Qt, Qnil);
+ calln (Qcopy_directory, file, newname, Qt, Qnil);
else if (S_ISREG (file_st.st_mode))
Fcopy_file (file, newname, ok_if_already_exists, Qt, Qt, Qt);
else if (S_ISLNK (file_st.st_mode))
specpdl_ref count = SPECPDL_INDEX ();
specbind (Qdelete_by_moving_to_trash, Qnil);
if (dirp)
- call2 (Qdelete_directory, file, Qt);
+ calln (Qdelete_directory, file, Qt);
else
- call2 (Qdelete_file, file, Qnil);
+ calln (Qdelete_file, file, Qnil);
return unbind_to (count, Qnil);
}
call the corresponding file name handler. */
handler = Ffind_file_name_handler (file, Qadd_name_to_file);
if (!NILP (handler))
- return call4 (handler, Qadd_name_to_file, file,
+ return calln (handler, Qadd_name_to_file, file,
newname, ok_if_already_exists);
/* If the new name has special constructs in it,
call the corresponding file name handler. */
handler = Ffind_file_name_handler (newname, Qadd_name_to_file);
if (!NILP (handler))
- return call4 (handler, Qadd_name_to_file, file,
+ return calln (handler, Qadd_name_to_file, file,
newname, ok_if_already_exists);
encoded_file = ENCODE_FILE (file);
call the corresponding file name handler. */
handler = Ffind_file_name_handler (linkname, Qmake_symbolic_link);
if (!NILP (handler))
- return call4 (handler, Qmake_symbolic_link, target,
+ return calln (handler, Qmake_symbolic_link, target,
linkname, ok_if_already_exists);
encoded_target = ENCODE_FILE (target);
Lisp_Object handler = Ffind_file_name_handler (file, operation);
if (!NILP (handler))
{
- Lisp_Object ok = call2 (handler, operation, file);
+ Lisp_Object ok = calln (handler, operation, file);
/* This errno value is bogus. Any caller that depends on errno
should be rethought anyway, to avoid a race between testing a
handled file's accessibility and using the file. */
call the corresponding file name handler. */
handler = Ffind_file_name_handler (absname, Qfile_writable_p);
if (!NILP (handler))
- return call2 (handler, Qfile_writable_p, absname);
+ return calln (handler, Qfile_writable_p, absname);
encoded = ENCODE_FILE (absname);
if (file_access_p (SSDATA (encoded), W_OK))
call the corresponding file name handler. */
handler = Ffind_file_name_handler (absname, Qaccess_file);
if (!NILP (handler))
- return call3 (handler, Qaccess_file, absname, string);
+ return calln (handler, Qaccess_file, absname, string);
encoded_filename = ENCODE_FILE (absname);
call the corresponding file name handler. */
handler = Ffind_file_name_handler (filename, Qfile_symlink_p);
if (!NILP (handler))
- return call2 (handler, Qfile_symlink_p, filename);
+ return calln (handler, Qfile_symlink_p, filename);
return emacs_readlinkat (AT_FDCWD, SSDATA (ENCODE_FILE (filename)));
}
call the corresponding file name handler. */
Lisp_Object handler = Ffind_file_name_handler (absname, Qfile_directory_p);
if (!NILP (handler))
- return call2 (handler, Qfile_directory_p, absname);
+ return calln (handler, Qfile_directory_p, absname);
return file_directory_p (ENCODE_FILE (absname)) ? Qt : Qnil;
}
handler = Ffind_file_name_handler (absname, Qfile_accessible_directory_p);
if (!NILP (handler))
{
- Lisp_Object r = call2 (handler, Qfile_accessible_directory_p, absname);
+ Lisp_Object r = calln (handler, Qfile_accessible_directory_p, absname);
/* Set errno in case the handler failed. EACCES might be a lie
(e.g., the directory might not exist, or be a regular file),
call the corresponding file name handler. */
Lisp_Object handler = Ffind_file_name_handler (absname, Qfile_regular_p);
if (!NILP (handler))
- return call2 (handler, Qfile_regular_p, absname);
+ return calln (handler, Qfile_regular_p, absname);
#ifdef WINDOWSNT
/* Tell stat to use expensive method to get accurate info. */
Lisp_Object handler = Ffind_file_name_handler (absname,
Qfile_selinux_context);
if (!NILP (handler))
- return call2 (handler, Qfile_selinux_context, absname);
+ return calln (handler, Qfile_selinux_context, absname);
#ifdef HAVE_LIBSELINUX
file = SSDATA (ENCODE_FILE (absname));
call the corresponding file name handler. */
handler = Ffind_file_name_handler (absname, Qset_file_selinux_context);
if (!NILP (handler))
- return call3 (handler, Qset_file_selinux_context, absname, context);
+ return calln (handler, Qset_file_selinux_context, absname, context);
#if HAVE_LIBSELINUX
encoded_absname = ENCODE_FILE (absname);
call the corresponding file name handler. */
Lisp_Object handler = Ffind_file_name_handler (absname, Qfile_acl);
if (!NILP (handler))
- return call2 (handler, Qfile_acl, absname);
+ return calln (handler, Qfile_acl, absname);
# ifdef HAVE_ACL_SET_FILE
# ifndef HAVE_ACL_TYPE_EXTENDED
call the corresponding file name handler. */
handler = Ffind_file_name_handler (absname, Qset_file_acl);
if (!NILP (handler))
- return call3 (handler, Qset_file_acl, absname, acl_string);
+ return calln (handler, Qset_file_acl, absname, acl_string);
# ifdef HAVE_ACL_SET_FILE
if (STRINGP (acl_string))
call the corresponding file name handler. */
Lisp_Object handler = Ffind_file_name_handler (absname, Qfile_modes);
if (!NILP (handler))
- return call3 (handler, Qfile_modes, absname, flag);
+ return calln (handler, Qfile_modes, absname, flag);
char *fname = SSDATA (ENCODE_FILE (absname));
if (emacs_fstatat (AT_FDCWD, fname, &st, nofollow) != 0)
call the corresponding file name handler. */
Lisp_Object handler = Ffind_file_name_handler (absname, Qset_file_modes);
if (!NILP (handler))
- return call4 (handler, Qset_file_modes, absname, mode, flag);
+ return calln (handler, Qset_file_modes, absname, mode, flag);
encoded = ENCODE_FILE (absname);
char *fname = SSDATA (encoded);
absname = Fexpand_file_name (filename, BVAR (current_buffer, directory)),
handler = Ffind_file_name_handler (absname, Qset_file_times);
if (!NILP (handler))
- return call4 (handler, Qset_file_times, absname, timestamp, flag);
+ return calln (handler, Qset_file_times, absname, timestamp, flag);
Lisp_Object encoded_absname = ENCODE_FILE (absname);
check_vfs_filename (encoded_absname, "Trying to set access times of"
if (NILP (handler))
handler = Ffind_file_name_handler (absname2, Qfile_newer_than_file_p);
if (!NILP (handler))
- return call3 (handler, Qfile_newer_than_file_p, absname1, absname2);
+ return calln (handler, Qfile_newer_than_file_p, absname1, absname2);
encoded = ENCODE_FILE (absname1);
{
Lisp_Object pt_marker = Fpoint_marker ();
Lisp_Object windows
- = call3 (Qget_buffer_window_list, Fcurrent_buffer (), Qnil, Qt);
+ = calln (Qget_buffer_window_list, Fcurrent_buffer (), Qnil, Qt);
Lisp_Object window_markers = windows;
/* Window markers (and point) are handled specially: rather than move to
just before or just after the modified text, we try to keep the
handler = Ffind_file_name_handler (filename, Qinsert_file_contents);
if (!NILP (handler))
{
- val = call6 (handler, Qinsert_file_contents, filename,
+ val = calln (handler, Qinsert_file_contents, filename,
visit, beg, end, replace);
if (CONSP (val) && CONSP (XCDR (val))
&& RANGED_FIXNUMP (0, XCAR (XCDR (val)), ZV - PT))
insert_1_both ((char *) read_buf, nread, nread, 0, 0, 0);
TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
- coding_system = call2 (Vset_auto_coding_function,
+ coding_system = calln (Vset_auto_coding_function,
filename, make_fixnum (nread));
set_buffer_internal (prev);
if (inserted > 0 && ! NILP (Vset_auto_coding_function))
{
- coding_system = call2 (Vset_auto_coding_function,
+ coding_system = calln (Vset_auto_coding_function,
filename, make_fixnum (inserted));
}
if (! NILP (Ffboundp (Qafter_insert_file_set_coding)))
{
- insval = call2 (Qafter_insert_file_set_coding, make_fixnum (inserted),
+ insval = calln (Qafter_insert_file_set_coding, make_fixnum (inserted),
visit);
if (! NILP (insval))
{
if (NILP (replace))
{
- insval = call3 (Qformat_decode,
+ insval = calln (Qformat_decode,
Qnil, make_fixnum (inserted), visit);
if (! RANGED_FIXNUMP (0, insval, ZV - PT))
wrong_type_argument (Qinserted_chars, insval);
modiff_count ochars_modiff = CHARS_MODIFF;
TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
- insval = call3 (Qformat_decode,
+ insval = calln (Qformat_decode,
Qnil, make_fixnum (oinserted), visit);
if (! RANGED_FIXNUMP (0, insval, ZV - PT))
wrong_type_argument (Qinserted_chars, insval);
{
if (NILP (replace))
{
- insval = call1 (XCAR (p), make_fixnum (inserted));
+ insval = calln (XCAR (p), make_fixnum (inserted));
if (!NILP (insval))
{
if (! RANGED_FIXNUMP (0, insval, ZV - PT))
modiff_count ochars_modiff = CHARS_MODIFF;
TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
- insval = call1 (XCAR (p), make_fixnum (oinserted));
+ insval = calln (XCAR (p), make_fixnum (oinserted));
if (!NILP (insval))
{
if (! RANGED_FIXNUMP (0, insval, ZV - PT))
if (coding_system_require_warning
&& !NILP (Ffboundp (Vselect_safe_coding_system_function)))
/* Confirm that VAL can surely encode the current region. */
- val = call5 (Vselect_safe_coding_system_function,
+ val = calln (Vselect_safe_coding_system_function,
start, end, list2 (Qt, val),
Qnil, filename);
}
&& !NILP (Ffboundp (Vselect_safe_coding_system_function)))
{
/* Confirm that VAL can surely encode the current region. */
- val = call5 (Vselect_safe_coding_system_function,
+ val = calln (Vselect_safe_coding_system_function,
start, end, val, Qnil, filename);
/* As the function specified by select-safe-coding-system-function
is out of our control, make sure we are not fed by bogus
if (!NILP (handler))
{
Lisp_Object val;
- val = call8 (handler, Qwrite_region, start, end,
+ val = calln (handler, Qwrite_region, start, end,
filename, append, visit, lockname, mustbenew);
if (visiting)
goto loop_over_p;
}
Vwrite_region_annotations_so_far = annotations;
- res = call2 (XCAR (p), start, end);
+ res = calln (XCAR (p), start, end);
/* If the function makes a different buffer current,
assume that means this buffer contains altered text to be output.
Reset START and END from the buffer bounds
/* Value is either a list of annotations or nil if the function
has written annotations to a temporary buffer, which is now
current. */
- res = call5 (Qformat_annotate_function, XCAR (p), start, end,
+ res = calln (Qformat_annotate_function, XCAR (p), start, end,
original_buffer, make_fixnum (i++));
if (current_buffer != given_buffer)
{
handler = Ffind_file_name_handler (BVAR (b, filename),
Qverify_visited_file_modtime);
if (!NILP (handler))
- return call2 (handler, Qverify_visited_file_modtime, buf);
+ return calln (handler, Qverify_visited_file_modtime, buf);
filename = ENCODE_FILE (BVAR (b, filename));
mtime = (emacs_fstatat (AT_FDCWD, SSDATA (filename), &st, 0) == 0
handler = Ffind_file_name_handler (filename, Qset_visited_file_modtime);
if (!NILP (handler))
/* The handler can find the file name the same way we did. */
- return call2 (handler, Qset_visited_file_modtime, Qnil);
+ return calln (handler, Qset_visited_file_modtime, Qnil);
encoded = ENCODE_FILE (filename);
AUTO_STRING (format, "Auto-saving %s: %s");
Lisp_Object msg = CALLN (Fformat, format, BVAR (current_buffer, name),
Ferror_message_string (error_val));
- call3 (Qdisplay_warning,
- Qauto_save, msg, QCerror);
+ calln (Qdisplay_warning, Qauto_save, msg, QCerror);
return Qnil;
}
Lisp_Object result;
auto_saving_dir_umask = 077;
- result = call2 (Qmake_directory, dir, Qt);
+ result = calln (Qmake_directory, dir, Qt);
auto_saving_dir_umask = 0;
return result;
}
Lisp_Object handler = Ffind_file_name_handler (filename, Qfile_system_info);
if (!NILP (handler))
{
- Lisp_Object result = call2 (handler, Qfile_system_info, filename);
+ Lisp_Object result = calln (handler, Qfile_system_info, filename);
if (CONSP (result) || NILP (result))
return result;
error ("Invalid handler in `file-name-handler-alist'");
return Qnil;
#endif /* defined HAVE_ANDROID && !defined ANDROID_STUBIFY */
- lock_file_name = call1 (Qmake_lock_file_name, fn);
+ lock_file_name = calln (Qmake_lock_file_name, fn);
return !NILP (lock_file_name) ? ENCODE_FILE (lock_file_name) : Qnil;
}
&& NILP (Fverify_visited_file_modtime (subject_buf))
&& !NILP (Ffile_exists_p (fn))
&& !(!NILP (lfname) && current_lock_owner (NULL, lfname) == I_OWN_IT))
- call1 (intern ("userlock--ask-user-about-supersession-threat"), fn);
+ calln (intern ("userlock--ask-user-about-supersession-threat"), fn);
/* Don't do locking if the user has opted out. */
if (!NILP (lfname))
memmove (dot + replacementlen, dot + 1, pidlen);
strcpy (dot + replacementlen + pidlen, ")");
memcpy (dot, replacement, replacementlen);
- attack = call2 (intern ("ask-user-about-lock"), fn,
+ attack = calln (intern ("ask-user-about-lock"), fn,
build_string (lock_info.user));
/* Take the lock if the user said so. */
if (!NILP (attack))
static Lisp_Object
unlock_file_handle_error (Lisp_Object err)
{
- call1 (intern ("userlock--handle-unlock-error"), err);
+ calln (intern ("userlock--handle-unlock-error"), err);
return Qnil;
}
Lisp_Object handler;
handler = Ffind_file_name_handler (file, Qlock_file);
if (!NILP (handler))
- return call2 (handler, Qlock_file, file);
+ return calln (handler, Qlock_file, file);
lock_file (file);
#endif /* MSDOS */
handler = Ffind_file_name_handler (file, Qunlock_file);
if (!NILP (handler))
{
- call2 (handler, Qunlock_file, file);
+ calln (handler, Qunlock_file, file);
return Qnil;
}
handler = Ffind_file_name_handler (filename, Qfile_locked_p);
if (!NILP (handler))
{
- return call2 (handler, Qfile_locked_p, filename);
+ return calln (handler, Qfile_locked_p, filename);
}
Lisp_Object lfname = make_lock_file_name (filename);
if ((NILP (testfn)
? (EQ (XCAR (car), key) || !NILP (Fequal
(XCAR (car), key)))
- : !NILP (call2 (testfn, XCAR (car), key))))
+ : !NILP (calln (testfn, XCAR (car), key))))
return car;
}
CHECK_LIST_END (tail, alist);
}
Lisp_Object tem;
- if (!NILP (call2 (pred, Fcar (l1), Fcar (l2))))
+ if (!NILP (calln (pred, Fcar (l1), Fcar (l2))))
{
tem = l1;
l1 = Fcdr (l1);
{
if (! CONSP (XCDR (tail)))
break;
- if (!NILP (call2 (predicate, XCAR (tail), prop)))
+ if (!NILP (calln (predicate, XCAR (tail), prop)))
return XCAR (XCDR (tail));
tail = XCDR (tail);
}
if (! CONSP (XCDR (tail)))
break;
- if (!NILP (call2 (predicate, XCAR (tail), prop)))
+ if (!NILP (calln (predicate, XCAR (tail), prop)))
{
Fsetcar (XCDR (tail), val);
return plist;
Lisp_Object tail = plist;
FOR_EACH_TAIL (tail)
{
- if (!NILP (call2 (predicate, XCAR (tail), prop)))
+ if (!NILP (calln (predicate, XCAR (tail), prop)))
return tail;
tail = XCDR (tail);
if (! CONSP (tail))
{
if (! CONSP (tail))
return i;
- Lisp_Object dummy = call1 (fn, XCAR (tail));
+ Lisp_Object dummy = calln (fn, XCAR (tail));
if (vals)
vals[i] = dummy;
tail = XCDR (tail);
{
for (ptrdiff_t i = 0; i < leni; i++)
{
- Lisp_Object dummy = call1 (fn, AREF (seq, i));
+ Lisp_Object dummy = calln (fn, AREF (seq, i));
if (vals)
vals[i] = dummy;
}
{
ptrdiff_t i_before = i;
int c = fetch_string_char_advance (seq, &i, &i_byte);
- Lisp_Object dummy = call1 (fn, make_fixnum (c));
+ Lisp_Object dummy = calln (fn, make_fixnum (c));
if (vals)
vals[i_before] = dummy;
}
eassert (BOOL_VECTOR_P (seq));
for (EMACS_INT i = 0; i < leni; i++)
{
- Lisp_Object dummy = call1 (fn, bool_vector_ref (seq, i));
+ Lisp_Object dummy = calln (fn, bool_vector_ref (seq, i));
if (vals)
vals[i] = dummy;
}
Lisp_Object
do_yes_or_no_p (Lisp_Object prompt)
{
- return call1 (Qyes_or_no_p, prompt);
+ return calln (Qyes_or_no_p, prompt);
}
DEFUN ("yes-or-no-p", Fyes_or_no_p, Syes_or_no_p, 1, 1, 0,
}
if (use_short_answers)
- return call1 (Qy_or_n_p, prompt);
+ return calln (Qy_or_n_p, prompt);
ptrdiff_t promptlen = SCHARS (prompt);
bool prompt_ends_in_nonspace
we shouldn't crash as a result (although the effects are
unpredictable). */
DOHASH_SAFE (h, i)
- call2 (function, HASH_KEY (h, i), HASH_VALUE (h, i));
+ calln (function, HASH_KEY (h, i), HASH_VALUE (h, i));
return Qnil;
}
if (!force_raw_text
&& !NILP (Ffboundp (Vselect_safe_coding_system_function)))
/* Confirm that VAL can surely encode the current region. */
- coding_system = call4 (Vselect_safe_coding_system_function,
+ coding_system = calln (Vselect_safe_coding_system_function,
make_fixnum (b), make_fixnum (e),
coding_system, Qnil);
: FRAME_COLUMN_WIDTH (f)));
}
else
- retval = XFIXNUM (call4 (Qframe_windows_min_size, frame, horizontal,
+ retval = XFIXNUM (calln (Qframe_windows_min_size, frame, horizontal,
ignore, pixelwise));
/* Don't allow too small height of text-mode frames, or else cm.c
#endif
}
else if (new_text_cols != old_text_cols)
- call2 (Qwindow__pixel_to_total, frame, Qt);
+ calln (Qwindow__pixel_to_total, frame, Qt);
if (new_inner_height != old_inner_height
/* When the top margin has changed we have to recalculate the top
FrameRows (FRAME_TTY (f)) = new_text_lines + FRAME_TOP_MARGIN (f);
}
else if (new_text_lines != old_text_lines)
- call2 (Qwindow__pixel_to_total, frame, Qnil);
+ calln (Qwindow__pixel_to_total, frame, Qnil);
/* Assign new sizes. */
FRAME_COLS (f) = new_text_cols;
Lisp_Object initial_frame;
/* If there's no minibuffer frame to use, create one. */
- initial_frame = call1 (Qmake_initial_minibuffer_frame,
+ initial_frame = calln (Qmake_initial_minibuffer_frame,
display);
kset_default_minibuffer_frame (kb, initial_frame);
}
non-active minibuffer. */
&& NILP (Fminibufferp (XWINDOW (f->minibuffer_window)->contents, Qt)))
{
- Lisp_Object w = call1 (Qget_mru_window, frame);
+ Lisp_Object w = calln (Qget_mru_window, frame);
if (WINDOW_LIVE_P (w)) /* W can be nil in minibuffer-only frames. */
Fset_frame_selected_window (frame, w, Qnil);
}
lispy_dummy = Qnil;
retval = Fcons (lispy_dummy, Fcons (x, y));
if (call_mouse_position_function && !NILP (Vmouse_position_function))
- retval = call1 (Vmouse_position_function, retval);
+ retval = calln (Vmouse_position_function, retval);
return retval;
}
retval = Fcons (lispy_dummy, Fcons (x, y));
if (!NILP (Vmouse_position_function))
- retval = call1 (Vmouse_position_function, retval);
+ retval = calln (Vmouse_position_function, retval);
return retval;
}
Lisp_Object frame;
XSETFRAME (frame, f);
- monitor_attributes = call1 (Qframe_monitor_attributes, frame);
+ monitor_attributes = calln (Qframe_monitor_attributes, frame);
if (NILP (monitor_attributes))
{
/* No monitor attributes available. */
Lisp_Object frame, outer_edges;
XSETFRAME (frame, f);
- outer_edges = call2 (Qframe_edges, frame, Qouter_edges);
+ outer_edges = calln (Qframe_edges, frame, Qouter_edges);
if (!NILP (outer_edges))
{
#ifdef HAVE_NS
if (strchr (SSDATA (string), ' ') != NULL)
- return call1 (Qns_parse_geometry, string);
+ return calln (Qns_parse_geometry, string);
#endif
int geometry = XParseGeometry (SSDATA (string),
&x, &y, &width, &height);
/* Now call this to apply the existing value(s) of the `default'
face. */
- call2 (Qface_set_after_frame_default, frame, params);
+ calln (Qface_set_after_frame_default, frame, params);
/* Restore the value of the `font-parameter' parameter, as
`face-set-after-frame-default' will have changed it through its
Lisp_Object rtl_image = PROP (TOOL_BAR_ITEM_IMAGES);
if (!NILP (file = file_for_image (rtl_image)))
{
- file = call1 (Qfile_name_sans_extension,
+ file = calln (Qfile_name_sans_extension,
Ffile_name_nondirectory (file));
if (! NILP (Fequal (file, rtl_name)))
{
specified_file = file_for_image (image);
if (!NILP (specified_file) && !NILP (Ffboundp (Qx_gtk_map_stock)))
- stock = call1 (Qx_gtk_map_stock, specified_file);
+ stock = calln (Qx_gtk_map_stock, specified_file);
if (CONSP (stock))
{
{
Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
- call2 (Qface_set_after_frame_default, frame, Qnil);
+ calln (Qface_set_after_frame_default, frame, Qnil);
if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
{
if (!NILP (tip_timer))
{
- call1 (Qcancel_timer, tip_timer);
+ calln (Qcancel_timer, tip_timer);
tip_timer = Qnil;
}
tip_f = XFRAME (tip_frame);
if (!NILP (tip_timer))
{
- call1 (Qcancel_timer, tip_timer);
+ calln (Qcancel_timer, tip_timer);
tip_timer = Qnil;
}
}
else
tip_last_parms =
- call2 (Qassq_delete_all, parm, tip_last_parms);
+ calln (Qassq_delete_all, parm, tip_last_parms);
}
else
tip_last_parms =
- call2 (Qassq_delete_all, parm, tip_last_parms);
+ calln (Qassq_delete_all, parm, tip_last_parms);
}
/* Now check if every parameter in what is left of
start_timer:
/* Let the tip disappear after timeout seconds. */
- tip_timer = call3 (Qrun_at_time, timeout, Qnil, Qx_hide_tip);
+ tip_timer = calln (Qrun_at_time, timeout, Qnil, Qx_hide_tip);
return unbind_to (count, Qnil);
}
popup_activated_p += 1;
}
else
- return call2 (Qpopup_menu, call0 (Qmouse_menu_bar_map),
+ return calln (Qpopup_menu, calln (Qmouse_menu_bar_map),
last_nonmenu_event);
return Qnil;
if (NILP (loader))
loader = Qgs_load_image;
- img->lisp_data = call6 (loader, frame, img->spec,
+ img->lisp_data = calln (loader, frame, img->spec,
make_fixnum (img->width),
make_fixnum (img->height),
window_and_pixmap_id,
: (!NILP (Vselect_active_regions)
&& !NILP (Vtransient_mark_mode))))
Vsaved_region_selection
- = call1 (Vregion_extract_function, Qnil);
+ = calln (Vregion_extract_function, Qnil);
signal_before_change (start, end, preserve_ptr);
Fset (Qdeactivate_mark, Qt);
enter_after = Qnil;
if (! EQ (leave_before, enter_before) && !NILP (leave_before))
- call2 (leave_before, make_fixnum (old_position),
+ calln (leave_before, make_fixnum (old_position),
make_fixnum (charpos));
if (! EQ (leave_after, enter_after) && !NILP (leave_after))
- call2 (leave_after, make_fixnum (old_position),
+ calln (leave_after, make_fixnum (old_position),
make_fixnum (charpos));
if (! EQ (enter_before, leave_before) && !NILP (enter_before))
- call2 (enter_before, make_fixnum (old_position),
+ calln (enter_before, make_fixnum (old_position),
make_fixnum (charpos));
if (! EQ (enter_after, leave_after) && !NILP (enter_after))
- call2 (enter_after, make_fixnum (old_position),
+ calln (enter_after, make_fixnum (old_position),
make_fixnum (charpos));
}
}
/* Use user's specified output function if any. */
if (!NILP (Vcommand_error_function))
- call3 (Vcommand_error_function, data,
+ calln (Vcommand_error_function, data,
context ? build_string (context) : empty_unibyte_string,
Vsignaling_function);
update_redisplay_ticks (0, NULL);
display_working_on_window_p = false;
- call1 (Qcommand_execute, Vthis_command);
+ calln (Qcommand_execute, Vthis_command);
display_working_on_window_p = false;
#ifdef HAVE_WINDOW_SYSTEM
Vselection_inhibit_update_commands)))
{
Lisp_Object txt
- = call1 (Vregion_extract_function, Qnil);
+ = calln (Vregion_extract_function, Qnil);
if (XFIXNUM (Flength (txt)) > 0)
/* Don't set empty selections. */
- call2 (Qgui_set_selection, QPRIMARY, txt);
+ calln (Qgui_set_selection, QPRIMARY, txt);
CALLN (Frun_hook_with_args, Qpost_select_region_hook, txt);
}
help)))
return help;
- return call1 (Qsubstitute_command_keys, help);
+ return calln (Qsubstitute_command_keys, help);
}
/* Display the help-echo property of the character after the mouse pointer.
restore the mouse_moved flag. */
struct frame *f = some_mouse_moved ();
- help = call1 (Qmouse_fixup_help_message, help);
+ help = calln (Qmouse_fixup_help_message, help);
if (f)
f->mouse_moved = true;
}
if (STRINGP (help) || NILP (help))
{
if (!NILP (Vshow_help_function))
- call1 (Vshow_help_function, help_echo_substitute_command_keys (help));
+ calln (Vshow_help_function, help_echo_substitute_command_keys (help));
help_echo_showing_p = STRINGP (help);
}
}
struct buffer *prev_buffer = current_buffer;
last_input_event = c;
- call4 (Qcommand_execute, tem, Qnil, Fvector (1, &last_input_event), Qt);
+ calln (Qcommand_execute, tem, Qnil, Fvector (1, &last_input_event), Qt);
if (CONSP (c) && !NILP (Fmemq (XCAR (c), Vwhile_no_input_ignore_events))
&& !end_time)
}
/* Call the input method. */
- tem = call1 (Vinput_method_function, c);
+ tem = calln (Vinput_method_function, c);
tem = unbind_to (count, tem);
specbind (Qinhibit_quit, Qt);
- call1 (Qtimer_event_handler, chosen_timer);
+ calln (Qtimer_event_handler, chosen_timer);
Vdeactivate_mark = old_deactivate_mark;
timers_run++;
unbind_to (count, Qnil);
being generated. */
{
Lisp_Object edges
- = call4 (Qwindow_edges, Fcar (start_pos), Qt, Qnil, Qt);
+ = calln (Qwindow_edges, Fcar (start_pos), Qt, Qnil, Qt);
int new_x = XFIXNUM (Fcar (frame_relative_event_pos));
int new_y = XFIXNUM (Fcdr (frame_relative_event_pos));
/* The previous code preferred :key-sequence to :keys, so we
preserve this behavior. */
if (STRINGP (keyeq) && !CONSP (keyhint))
- keyeq = concat2 (space_space, call1 (Qsubstitute_command_keys, keyeq));
+ keyeq = concat2 (space_space, calln (Qsubstitute_command_keys, keyeq));
else
{
Lisp_Object prefix = keyeq;
remapped. */
count = SPECPDL_INDEX ();
specbind (Qcurrent_key_remap_sequence, remap);
- next = unbind_to (count, call1 (next, prompt));
+ next = unbind_to (count, calln (next, prompt));
/* If the function returned something invalid,
barf--don't ignore it. */
static void
map_keymap_call (Lisp_Object key, Lisp_Object val, Lisp_Object fun, void *dummy)
{
- call2 (fun, key, val);
+ calln (fun, key, val);
}
/* Same as map_keymap_internal, but traverses parent keymaps as well.
(Lisp_Object function, Lisp_Object keymap, Lisp_Object sort_first)
{
if (! NILP (sort_first))
- return call2 (Qmap_keymap_sorted, function, keymap);
+ return calln (Qmap_keymap_sorted, function, keymap);
map_keymap (keymap, map_keymap_call, function, NULL, 1);
return Qnil;
This happens when menu items define as bindings strings that
should be inserted into the buffer, not commands. See
bug#64927, for example. */
- if (NILP (call1 (Qkey_valid_p, AREF (key, 0))))
+ if (NILP (calln (Qkey_valid_p, AREF (key, 0))))
return key;
- key = call1 (Qkey_parse, AREF (key, 0));
+ key = calln (Qkey_parse, AREF (key, 0));
*length = CHECK_VECTOR_OR_STRING (key);
if (*length == 0)
xsignal2 (Qerror, build_string ("Invalid `key-parse' syntax: %S"), key);
describe_vector_princ (Lisp_Object elt, Lisp_Object fun)
{
Findent_to (make_fixnum (16), make_fixnum (1));
- call1 (fun, elt);
+ calln (fun, elt);
Fterpri (Qnil, Qnil);
}
static void
describe_vector_basic (Lisp_Object elt, Lisp_Object fun)
{
- call1 (fun, elt);
+ calln (fun, elt);
}
DEFUN ("describe-vector", Fdescribe_vector, Sdescribe_vector, 1, 2, 0,
The calling convention:
if (!NILP (Vrun_hooks))
- call1 (Vrun_hooks, Qmy_funny_hook);
+ calln (Vrun_hooks, Qmy_funny_hook);
should no longer be used. */
extern void run_hook (Lisp_Object);
unread_char = c;
}
else
- call1 (readcharfun, make_fixnum (c));
+ calln (readcharfun, make_fixnum (c));
}
static int
handler = Ffind_file_name_handler (file, Qload);
if (!NILP (handler))
return
- call6 (handler, Qload, file, noerror, nomessage, nosuffix, must_suffix);
+ calln (handler, Qload, file, noerror, nomessage, nosuffix, must_suffix);
/* The presence of this call is the result of a historical accident:
it used to be in every file-operation and when it got removed
else
handler = Ffind_file_name_handler (found, Qload);
if (! NILP (handler))
- return call5 (handler, Qload, found, noerror, nomessage, Qt);
+ return calln (handler, Qload, found, noerror, nomessage, Qt);
#ifdef DOS_NT
/* Tramp has to deal with semi-broken packages that prepend
drive letters to remote files. For that reason, Tramp
lread_close (fd);
clear_unwind_protect (fd_index);
}
- val = call4 (Vload_source_file_function, found, hist_file_name,
+ val = calln (Vload_source_file_function, found, hist_file_name,
NILP (noerror) ? Qnil : Qt,
(NILP (nomessage) || force_load_messages) ? Qnil : Qt);
return unbind_to (count, val);
/* Run any eval-after-load forms for this file. */
if (!NILP (Ffboundp (Qdo_after_load_evaluation)))
- call1 (Qdo_after_load_evaluation, hist_file_name) ;
+ calln (Qdo_after_load_evaluation, hist_file_name);
for (int i = 0; i < ARRAYELTS (saved_strings); i++)
{
exists = !NILP (Ffile_readable_p (string));
else
{
- Lisp_Object tmp = call1 (predicate, string);
+ Lisp_Object tmp = calln (predicate, string);
if (NILP (tmp))
exists = false;
else if (EQ (tmp, Qdir_ok)
form in the progn as a top-level form. This way, if one form in
the progn defines a macro, that macro is in effect when we expand
the remaining forms. See similar code in bytecomp.el. */
- val = call2 (macroexpand, val, Qnil);
+ val = calln (macroexpand, val, Qnil);
if (EQ (CAR_SAFE (val), Qprogn))
{
Lisp_Object subforms = XCDR (val);
val = readevalloop_eager_expand_eval (XCAR (subforms), macroexpand);
}
else
- val = eval_sub (call2 (macroexpand, val, Qt));
+ val = eval_sub (calln (macroexpand, val, Qt));
return val;
}
{
if (!NILP (readfun))
{
- val = call1 (readfun, readcharfun);
+ val = calln (readfun, readcharfun);
/* If READCHARFUN has set point to ZV, we should
stop reading, even if the form read sets point
}
}
else if (! NILP (Vload_read_function))
- val = call1 (Vload_read_function, readcharfun);
+ val = calln (Vload_read_function, readcharfun);
else
val = read_internal_start (readcharfun, Qnil, Qnil, false);
}
minibuffer without a stream, as in (read). But is this feature
ever used, and if so, why? IOW, will anything break if this
feature is removed !? */
- return call1 (Qread_minibuffer,
- build_string ("Lisp expression: "));
+ return calln (Qread_minibuffer, build_string ("Lisp expression: "));
return read_internal_start (stream, Qnil, Qnil, false);
}
stream = Qread_char;
if (EQ (stream, Qread_char))
/* FIXME: ?! When is this used !? */
- return call1 (Qread_minibuffer,
- build_string ("Lisp expression: "));
+ return calln (Qread_minibuffer, build_string ("Lisp expression: "));
return read_internal_start (stream, Qnil, Qnil, true);
}
Lisp_Object code
= (name[0] == 'U' && name[1] == '+'
? string_to_number (name + 1, 16, &len)
- : call2 (Qchar_from_name, make_unibyte_string (name, name_len), Qt));
+ : calln (Qchar_from_name, make_unibyte_string (name, name_len), Qt));
if (! RANGED_FIXNUMP (0, code, MAX_UNICODE_CHAR)
|| len != name_len - 1
static void
mapatoms_1 (Lisp_Object sym, Lisp_Object function)
{
- call1 (function, sym);
+ calln (function, sym);
}
DEFUN ("mapatoms", Fmapatoms, Smapatoms, 1, 2, 0,
return;
}
- call1 (Qrecord_window_buffer, dest_window);
- call1 (Qrecord_window_buffer, source_window);
+ calln (Qrecord_window_buffer, dest_window);
+ calln (Qrecord_window_buffer, source_window);
acc = merge_c (dw->prev_buffers, sw->prev_buffers, minibuffer_ent_greater);
to abort any extra non-minibuffer recursive edits. Thus,
the number of recursive edits we have to abort equals the
number of minibuffers we have to abort. */
- call1 (Qminibuffer_quit_recursive_edit, array[1]);
+ calln (Qminibuffer_quit_recursive_edit, array[1]);
}
}
else
}
MB_frame = XWINDOW (XFRAME (selected_frame)->minibuffer_window)->frame;
- call1 (Qrecord_window_buffer, minibuf_window);
+ calln (Qrecord_window_buffer, minibuf_window);
record_unwind_protect_void (minibuffer_unwind);
/* Turn on an input method stored in INPUT_METHOD if any. */
if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method)))
- call1 (Qactivate_input_method, input_method);
+ calln (Qactivate_input_method, input_method);
run_hook (Qminibuffer_setup_hook);
done after the previous buffer has been made current again, in
case the history variable is buffer-local. */
if (! (NILP (Vhistory_add_new_input) || NILP (histstring)))
- call2 (Qadd_to_history, histvar, histstring);
+ calln (Qadd_to_history, histvar, histstring);
/* The appropriate frame will get selected
in set-window-configuration. */
&& !EQ (XWINDOW (XFRAME (calling_frame)->minibuffer_window)
->frame,
calling_frame))))
- call2 (Qselect_frame_set_input_focus, calling_frame, Qnil);
+ calln (Qselect_frame_set_input_focus, calling_frame, Qnil);
/* If Lisp form desired instead of string, parse it. */
if (expflag)
result = (NILP (predicate)
/* Partial backward compatibility for older read_buffer_functions
which don't expect a `predicate' argument. */
- ? call3 (Vread_buffer_function, prompt, def, require_match)
- : call4 (Vread_buffer_function, prompt, def, require_match,
+ ? calln (Vread_buffer_function, prompt, def, require_match)
+ : calln (Vread_buffer_function, prompt, def, require_match,
predicate));
return unbind_to (count, result);
}
CHECK_STRING (string);
if (type == function_table)
- return call3 (collection, string, predicate, Qnil);
+ return calln (collection, string, predicate, Qnil);
bestmatch = bucket = Qnil;
zero = make_fixnum (0);
else
{
if (type == hash_table)
- tem = call2 (predicate, elt,
+ tem = calln (predicate, elt,
HASH_VALUE (XHASH_TABLE (collection),
idx - 1));
else
- tem = call1 (predicate, elt);
+ tem = calln (predicate, elt);
}
if (NILP (tem)) continue;
}
CHECK_STRING (string);
if (type == 0)
- return call3 (collection, string, predicate, Qt);
+ return calln (collection, string, predicate, Qt);
allmatches = bucket = Qnil;
zero = make_fixnum (0);
else
{
if (type == 3)
- tem = call2 (predicate, elt,
+ tem = calln (predicate, elt,
HASH_VALUE (XHASH_TABLE (collection),
idx - 1));
else
- tem = call1 (predicate, elt);
+ tem = calln (predicate, elt);
}
if (NILP (tem)) continue;
}
found_matching_key: ;
}
else
- return call3 (collection, string, predicate, Qlambda);
+ return calln (collection, string, predicate, Qlambda);
/* Finally, check the predicate. */
if (!NILP (predicate))
{
return HASH_TABLE_P (collection)
- ? call2 (predicate, tem, arg)
- : call1 (predicate, tem);
+ ? calln (predicate, tem, arg)
+ : calln (predicate, tem);
}
else
return Qt;
handler = Ffind_file_name_handler (filename, operation);
if (!NILP (handler))
- return call2 (handler, operation, filename);
+ return calln (handler, operation, filename);
else
{
NSFileManager *fm = [NSFileManager defaultManager];
{
Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
- call2 (Qface_set_after_frame_default, frame, Qnil);
+ calln (Qface_set_after_frame_default, frame, Qnil);
if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
{
{
if (!NILP (tip_timer))
{
- call1 (Qcancel_timer, tip_timer);
+ calln (Qcancel_timer, tip_timer);
tip_timer = Qnil;
}
tip_f = XFRAME (tip_frame);
if (!NILP (tip_timer))
{
- call1 (Qcancel_timer, tip_timer);
+ calln (Qcancel_timer, tip_timer);
tip_timer = Qnil;
}
}
else
tip_last_parms
- = call2 (Qassq_delete_all, parm, tip_last_parms);
+ = calln (Qassq_delete_all, parm, tip_last_parms);
}
else
tip_last_parms
- = call2 (Qassq_delete_all, parm, tip_last_parms);
+ = calln (Qassq_delete_all, parm, tip_last_parms);
}
/* Now check if every parameter in what is left of
start_timer:
/* Let the tip disappear after timeout seconds. */
- tip_timer = call3 (Qrun_at_time, timeout, Qnil,
- Qx_hide_tip);
+ tip_timer = calln (Qrun_at_time, timeout, Qnil, Qx_hide_tip);
}
return unbind_to (count, Qnil);
{
/* FIXME: Use run-hook-with-args! */
for (rest = Vns_sent_selection_hooks; CONSP (rest); rest = Fcdr (rest))
- call3 (Fcar (rest), selection, target_symbol, successful_p);
+ calln (Fcar (rest), selection, target_symbol, successful_p);
}
return value;
{
Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
- call2 (Qface_set_after_frame_default, frame, Qnil);
+ calln (Qface_set_after_frame_default, frame, Qnil);
if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
{
{
if (!NILP (tip_timer))
{
- call1 (Qcancel_timer, tip_timer);
+ calln (Qcancel_timer, tip_timer);
tip_timer = Qnil;
}
tip_f = XFRAME (tip_frame);
if (!NILP (tip_timer))
{
- call1 (Qcancel_timer, tip_timer);
+ calln (Qcancel_timer, tip_timer);
tip_timer = Qnil;
}
}
else
tip_last_parms =
- call2 (Qassq_delete_all, parm, tip_last_parms);
+ calln (Qassq_delete_all, parm, tip_last_parms);
}
else
tip_last_parms =
- call2 (Qassq_delete_all, parm, tip_last_parms);
+ calln (Qassq_delete_all, parm, tip_last_parms);
}
/* Now check if every parameter in what is left of
start_timer:
/* Let the tip disappear after timeout seconds. */
- tip_timer = call3 (Qrun_at_time, timeout, Qnil, Qx_hide_tip);
+ tip_timer = calln (Qrun_at_time, timeout, Qnil, Qx_hide_tip);
return unbind_to (count, Qnil);
}
}
if (!NILP (handler_fn))
- value = call3 (handler_fn, selection_symbol,
- (local_request
- ? Qnil
- : target_type),
+ value = calln (handler_fn, selection_symbol,
+ (local_request ? Qnil : target_type),
tem);
else
value = Qnil;
printchar (unsigned int ch, Lisp_Object fun)
{
if (!NILP (fun) && !EQ (fun, Qt))
- call1 (fun, make_fixnum (ch));
+ calln (fun, make_fixnum (ch));
else
{
unsigned char str[MAX_MULTIBYTE_LENGTH];
Lisp_Object result = Qt;
if (!NILP (Ffboundp (Qnsm_verify_connection)))
- result = call3 (Qnsm_verify_connection,
+ result = calln (Qnsm_verify_connection,
proc,
plist_get (contact, QChost),
plist_get (contact, QCservice));
{
int code = errno;
if (!would_block (code) && !NILP (ps->log))
- call3 (ps->log, server, Qnil,
+ calln (ps->log, server, Qnil,
concat3 (build_string ("accept failed with code"),
Fnumber_to_string (make_fixnum (code)),
build_string ("\n")));
if (!NILP (ps->log))
{
AUTO_STRING (accept_from, "accept from ");
- call3 (ps->log, server, proc, concat3 (accept_from, host_string, nl));
+ calln (ps->log, server, proc, concat3 (accept_from, host_string, nl));
}
AUTO_STRING (open_from, "open from ");
= Ffind_file_name_handler (BVAR (current_buffer, directory),
Qlist_system_processes);
if (!NILP (handler))
- return call1 (handler, Qlist_system_processes);
+ return calln (handler, Qlist_system_processes);
return list_system_processes ();
}
= Ffind_file_name_handler (BVAR (current_buffer, directory),
Qprocess_attributes);
if (!NILP (handler))
- return call2 (handler, Qprocess_attributes, pid);
+ return calln (handler, Qprocess_attributes, pid);
return system_process_attributes (pid);
}
static bool
order_pred_lisp (merge_state *ms, Lisp_Object a, Lisp_Object b)
{
- return !NILP (call2 (ms->predicate, a, b));
+ return !NILP (calln (ms->predicate, a, b));
}
static bool
(any call to keyfunc might trigger a GC). */
if (!NILP (keyfunc))
for (ptrdiff_t i = 0; i < length; i++)
- keys[i] = call1 (keyfunc, seq[i]);
+ keys[i] = calln (keyfunc, seq[i]);
/* FIXME: This is where we would check the keys for interesting
properties for more optimized comparison (such as all being fixnums
return find_start_value;
modiff_count modiffs = CHARS_MODIFF;
- Lisp_Object ppss = call1 (Qsyntax_ppss, make_fixnum (pos));
+ Lisp_Object ppss = calln (Qsyntax_ppss, make_fixnum (pos));
if (modiffs != CHARS_MODIFF)
error ("syntax-ppss modified the buffer!");
TEMP_SET_PT_BOTH (opoint, opoint_byte);
{
AUTO_STRING (prefixdoc,
",\n\t is a prefix character for `backward-prefix-chars'");
- insert1 (call1 (Qsubstitute_command_keys, prefixdoc));
+ insert1 (calln (Qsubstitute_command_keys, prefixdoc));
}
return syntax;
func = CHAR_TABLE_REF (Vfind_word_boundary_function_table, ch0);
if (! NILP (Ffboundp (func)))
{
- pos = call2 (func, make_fixnum (from - 1), make_fixnum (end));
+ pos = calln (func, make_fixnum (from - 1), make_fixnum (end));
if (FIXNUMP (pos) && from < XFIXNUM (pos) && XFIXNUM (pos) <= ZV)
{
from = XFIXNUM (pos);
func = CHAR_TABLE_REF (Vfind_word_boundary_function_table, ch1);
if (! NILP (Ffboundp (func)))
{
- pos = call2 (func, make_fixnum (from), make_fixnum (beg));
+ pos = calln (func, make_fixnum (from), make_fixnum (beg));
if (FIXNUMP (pos) && BEGV <= XFIXNUM (pos) && XFIXNUM (pos) < from)
{
from = XFIXNUM (pos);
&& !NILP (BVAR (current_buffer, mark_active)))
call0 (Qdeactivate_mark);
else
- call1 (Qpush_mark, make_fixnum (mark));
+ calln (Qpush_mark, make_fixnum (mark));
/* Update the ephemeral last point. */
w = XWINDOW (selected_window);
{
while (!NILP (list))
{
- call2 (Fcar (list), start, end);
+ calln (Fcar (list), start, end);
list = Fcdr (list);
}
}
Lisp_Object tem;
/* Normally the function this calls is undo-outer-limit-truncate. */
- tem = call1 (Vundo_outer_limit_function, make_int (size_so_far));
+ tem = calln (Vundo_outer_limit_function, make_int (size_so_far));
if (! NILP (tem))
{
/* The function is responsible for making
Lisp_Object fg = Fframe_parameter (frame, Qforeground_color);
Lisp_Object colors = Qnil;
- call2 (Qface_set_after_frame_default, frame, Qnil);
+ calln (Qface_set_after_frame_default, frame, Qnil);
if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
colors = Fcons (Fcons (Qbackground_color, bg), colors);
{
if (!NILP (tip_timer))
{
- call1 (Qcancel_timer, tip_timer);
+ calln (Qcancel_timer, tip_timer);
tip_timer = Qnil;
}
Lisp_Object timer = tip_timer;
tip_timer = Qnil;
- call1 (Qcancel_timer, timer);
+ calln (Qcancel_timer, timer);
}
block_input ();
}
else
tip_last_parms =
- call2 (Qassq_delete_all, parm, tip_last_parms);
+ calln (Qassq_delete_all, parm, tip_last_parms);
}
else
tip_last_parms =
- call2 (Qassq_delete_all, parm, tip_last_parms);
+ calln (Qassq_delete_all, parm, tip_last_parms);
}
/* Now check if there's a parameter left in tip_last_parms with a
start_timer:
/* Let the tip disappear after timeout seconds. */
- tip_timer = call3 (Qrun_at_time, timeout, Qnil,
- Qx_hide_tip);
+ tip_timer = calln (Qrun_at_time, timeout, Qnil, Qx_hide_tip);
return unbind_to (count, Qnil);
}
handler = Ffind_file_name_handler (filename, operation);
if (!NILP (handler))
- return call2 (handler, operation, filename);
+ return calln (handler, operation, filename);
else
{
const char * path;
Lisp_Object handler = Ffind_file_name_handler (encoded, Qfile_system_info);
if (!NILP (handler))
{
- value = call2 (handler, Qfile_system_info, encoded);
+ value = calln (handler, Qfile_system_info, encoded);
if (CONSP (value) || NILP (value))
return value;
error ("Invalid handler in `file-name-handler-alist'");
static void
delete_deletable_window (Lisp_Object window)
{
- if (!NILP (call1 (Qwindow_deletable_p, window)))
- call1 (Qdelete_window, window);
+ if (!NILP (calln (Qwindow_deletable_p, window)))
+ calln (Qdelete_window, window);
}
\f
/***********************************************************************
Lisp_Object horizontal, Lisp_Object ignore,
Lisp_Object pixelwise)
{
- return call5 (Qwindow__resize_root_window, window, delta,
+ return calln (Qwindow__resize_root_window, window, delta,
horizontal, ignore, pixelwise);
}
static Lisp_Object
window_pixel_to_total (Lisp_Object frame, Lisp_Object horizontal)
{
- return call2 (Qwindow__pixel_to_total, frame, horizontal);
+ return calln (Qwindow__pixel_to_total, frame, horizontal);
}
/* When kill-buffer is called early during loadup, this function is
undefined. */
if (!NILP (Ffboundp (Qreplace_buffer_in_windows)))
- call1 (Qreplace_buffer_in_windows, buffer);
+ calln (Qreplace_buffer_in_windows, buffer);
}
/** If BUFFER is shown in any window, safely replace it with some other
dedication. */
wset_dedicated (w, Qnil);
- call1 (Qrecord_window_buffer, window);
+ calln (Qrecord_window_buffer, window);
}
unshow_buffer (w);
static Lisp_Object
display_buffer (Lisp_Object buffer, Lisp_Object not_this_window_p, Lisp_Object override_frame)
{
- return call3 (Qdisplay_buffer, buffer, not_this_window_p, override_frame);
+ return calln (Qdisplay_buffer, buffer, not_this_window_p, override_frame);
}
DEFUN ("force-window-update", Fforce_window_update, Sforce_window_update,
set_buffer_internal (old);
if (!NILP (Vtemp_buffer_show_function))
- call1 (Vtemp_buffer_show_function, buf);
+ calln (Vtemp_buffer_show_function, buf);
else if (WINDOW_LIVE_P (window = display_buffer (buf, Qnil, Qnil)))
{
if (!EQ (XWINDOW (window)->frame, selected_frame))
struct window *r = XWINDOW (root);
Lisp_Object grow;
- grow = call3 (Qwindow__resize_root_window_vertically,
+ grow = calln (Qwindow__resize_root_window_vertically,
root, make_fixnum (- delta), Qt);
if (FIXNUMP (grow)
struct window *r = XWINDOW (root);
Lisp_Object grow;
- grow = call3 (Qwindow__resize_root_window_vertically,
+ grow = calln (Qwindow__resize_root_window_vertically,
root, make_fixnum (delta), Qt);
if (FIXNUMP (grow) && window_resize_check (r, false))
&& (NILP (Fminibufferp (p->buffer, Qnil))))
/* If a window we restore gets another buffer, record the
window's old buffer. */
- call1 (Qrecord_window_buffer, window);
+ calln (Qrecord_window_buffer, window);
}
/* Disallow set_window_size_hook, temporarily. */
XSETFRAME (frame, f);
- color_desc = call2 (Qtty_color_desc, color, frame);
+ color_desc = calln (Qtty_color_desc, color, frame);
if (CONSP (color_desc) && CONSP (XCDR (color_desc)))
{
Lisp_Object rgb;
&& !NILP (Ffboundp (Qtty_color_standard_values)))
{
/* Look up STD_COLOR separately. */
- rgb = call1 (Qtty_color_standard_values, color);
+ rgb = calln (Qtty_color_standard_values, color);
if (! parse_rgb_list (rgb, std_color))
return false;
}
Lisp_Object coldesc;
XSETFRAME (frame, f);
- coldesc = call2 (Qtty_color_by_index, make_fixnum (idx), frame);
+ coldesc = calln (Qtty_color_by_index, make_fixnum (idx), frame);
if (!NILP (coldesc))
return XCAR (coldesc);
mode, so that we have to load new defface specs.
Call frame-set-background-mode to do that. */
XSETFRAME (frame, f);
- call1 (Qframe_set_background_mode, frame);
+ calln (Qframe_set_background_mode, frame);
face = Qdefault;
lface = lface_from_face_name (f, face, true);
if (NILP (metric))
return make_fixnum (color_distance (&cdef1, &cdef2));
else
- return call2 (metric,
+ return calln (metric,
list3i (cdef1.red, cdef1.green, cdef1.blue),
list3i (cdef2.red, cdef2.green, cdef2.blue));
}
if (STRINGP (color)
&& SCHARS (color)
&& CONSP (Vtty_defined_color_alist)
- && (def = assoc_no_quit (color, call1 (Qtty_color_alist, frame)),
+ && (def = assoc_no_quit (color, calln (Qtty_color_alist, frame)),
CONSP (def)))
{
/* Associations in tty-defined-color-alist are of the form
{
Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
- call2 (Qface_set_after_frame_default, frame, Qnil);
+ calln (Qface_set_after_frame_default, frame, Qnil);
if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
{
{
if (!NILP (tip_timer))
{
- call1 (Qcancel_timer, tip_timer);
+ calln (Qcancel_timer, tip_timer);
tip_timer = Qnil;
}
tip_f = XFRAME (tip_frame);
if (!NILP (tip_timer))
{
- call1 (Qcancel_timer, tip_timer);
+ calln (Qcancel_timer, tip_timer);
tip_timer = Qnil;
}
}
else
tip_last_parms =
- call2 (Qassq_delete_all, parm, tip_last_parms);
+ calln (Qassq_delete_all, parm, tip_last_parms);
}
else
tip_last_parms =
- call2 (Qassq_delete_all, parm, tip_last_parms);
+ calln (Qassq_delete_all, parm, tip_last_parms);
}
/* Now check if every parameter in what is left of
start_timer:
/* Let the tip disappear after timeout seconds. */
- tip_timer = call3 (Qrun_at_time, timeout, Qnil,
- Qx_hide_tip);
+ tip_timer = calln (Qrun_at_time, timeout, Qnil, Qx_hide_tip);
return unbind_to (count, Qnil);
}
#endif
/* TODO: Get the monitor workarea directly without calculating other
items in x-display-monitor-attributes-list. */
- workarea = call3 (Qframe_monitor_workarea,
+ workarea = calln (Qframe_monitor_workarea,
Qnil,
make_fixnum (data->x),
make_fixnum (data->y));
}
if (!NILP (handler_fn))
- value = call3 (handler_fn, selection_symbol,
+ value = calln (handler_fn, selection_symbol,
((local_request
&& NILP (Vx_treat_local_requests_remotely))
? Qnil
ref = SPECPDL_INDEX ();
record_unwind_protect_ptr (x_dnd_cleanup_drag_and_drop, f);
- call2 (Vx_dnd_movement_function, frame_object,
+ calln (Vx_dnd_movement_function, frame_object,
Fposn_at_x_y (x, y, frame_object, Qnil));
x_dnd_unwind_flag = false;
unbind_to (ref, Qnil);
ref = SPECPDL_INDEX ();
record_unwind_protect_ptr (x_dnd_cleanup_drag_and_drop, f);
- call4 (Vx_dnd_wheel_function,
+ calln (Vx_dnd_wheel_function,
Fposn_at_x_y (x, y, frame_object, Qnil),
make_fixnum (x_dnd_wheel_button),
make_uint (x_dnd_wheel_state),
record_unwind_protect_ptr (x_dnd_cleanup_drag_and_drop, f);
if (!NILP (Vx_dnd_unsupported_drop_function))
- val = call8 (Vx_dnd_unsupported_drop_function,
+ val = calln (Vx_dnd_unsupported_drop_function,
XCAR (XCDR (x_dnd_unsupported_drop_data)),
Fnth (make_fixnum (3), x_dnd_unsupported_drop_data),
Fnth (make_fixnum (4), x_dnd_unsupported_drop_data),
projects / emacs.git / commitdiff