/* Call a Lisp function interactively.
- Copyright (C) 1985, 1986, 1993, 1994, 1995, 1997, 2000, 2001, 2002,
- 2003, 2004, 2005, 2006, 2007, 2008
+ Copyright (C) 1985-1986, 1993-1995, 1997, 2000-2011
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
+#include <setjmp.h>
#include "lisp.h"
#include "buffer.h"
#include "window.h"
#include "keymap.h"
-#ifdef HAVE_INDEX
-extern char *index P_ ((const char *, int));
-#endif
-
-extern Lisp_Object Qcursor_in_echo_area;
-extern Lisp_Object Qfile_directory_p;
-extern Lisp_Object Qonly;
-
-Lisp_Object Vcurrent_prefix_arg, Qminus, Qplus;
+Lisp_Object Qminus, Qplus;
Lisp_Object Qcall_interactively;
-Lisp_Object Vcommand_history;
-
-extern Lisp_Object Vhistory_length;
-extern Lisp_Object Vthis_original_command, real_this_command;
-
-Lisp_Object Vcommand_debug_status, Qcommand_debug_status;
+Lisp_Object Qcommand_debug_status;
Lisp_Object Qenable_recursive_minibuffers;
-/* Non-nil means treat the mark as active
- even if mark_active is 0. */
-Lisp_Object Vmark_even_if_inactive;
-
-Lisp_Object Vshift_select_mode, Qhandle_shift_selection;
+Lisp_Object Qhandle_shift_selection;
-Lisp_Object Vmouse_leave_buffer_hook, Qmouse_leave_buffer_hook;
+Lisp_Object Qmouse_leave_buffer_hook;
Lisp_Object Qlist, Qlet, Qletx, Qsave_excursion, Qprogn, Qif, Qwhen;
static Lisp_Object preserved_fns;
DEFUN ("interactive", Finteractive, Sinteractive, 0, UNEVALLED, 0,
doc: /* Specify a way of parsing arguments for interactive use of a function.
For example, write
- (defun foo (arg) "Doc string" (interactive "p") ...use arg...)
-to make ARG be the prefix argument when `foo' is called as a command.
+ (defun foo (arg buf) "Doc string" (interactive "P\\nbbuffer: ") .... )
+ to make ARG be the raw prefix argument, and set BUF to an existing buffer,
+ when `foo' is called as a command.
The "call" to `interactive' is actually a declaration rather than a function;
it tells `call-interactively' how to read arguments
to pass to the function.
When actually called, `interactive' just returns nil.
-The argument of `interactive' is usually a string containing a code letter
- followed by a prompt. (Some code letters do not use I/O to get
- the argument and do not need prompts.) To prompt for multiple arguments,
- give a code letter, its prompt, a newline, and another code letter, etc.
- Prompts are passed to format, and may use % escapes to print the
+Usually the argument of `interactive' is a string containing a code letter
+ followed optionally by a prompt. (Some code letters do not use I/O to get
+ the argument and do not use prompts.) To get several arguments, concatenate
+ the individual strings, separating them by newline characters.
+Prompts are passed to format, and may use % escapes to print the
arguments that have already been read.
If the argument is not a string, it is evaluated to get a list of
arguments to pass to the function.
invoked the command for its first mouse click (or any other event
which specifies a window).
If the string begins with `^' and `shift-select-mode' is non-nil,
- Emacs first calls the function `handle-shift-select'.
+ Emacs first calls the function `handle-shift-selection'.
You may use `@', `*', and `^' together. They are processed in the
order that they appear, before reading any arguments.
-usage: (interactive ARGS) */)
- (args)
- Lisp_Object args;
+usage: (interactive &optional ARGS) */)
+ (Lisp_Object args)
{
return Qnil;
}
/* Quotify EXP: if EXP is constant, return it.
If EXP is not constant, return (quote EXP). */
Lisp_Object
-quotify_arg (exp)
- register Lisp_Object exp;
+quotify_arg (register Lisp_Object exp)
{
if (!INTEGERP (exp) && !STRINGP (exp)
&& !NILP (exp) && !EQ (exp, Qt))
/* Modify EXP by quotifying each element (except the first). */
Lisp_Object
-quotify_args (exp)
- Lisp_Object exp;
+quotify_args (Lisp_Object exp)
{
register Lisp_Object tail;
Lisp_Object next;
return exp;
}
-char *callint_argfuns[]
+static const char *callint_argfuns[]
= {"", "point", "mark", "region-beginning", "region-end"};
static void
-check_mark (for_region)
- int for_region;
+check_mark (int for_region)
{
Lisp_Object tem;
tem = Fmarker_buffer (current_buffer->mark);
of VALUES to do its job. */
static void
-fix_command (input, values)
- Lisp_Object input, values;
+fix_command (Lisp_Object input, Lisp_Object values)
{
if (CONSP (input))
{
supply, as a vector, if the command inquires which events were used to
invoke it. If KEYS is omitted or nil, the return value of
`this-command-keys-vector' is used. */)
- (function, record_flag, keys)
- Lisp_Object function, record_flag, keys;
+ (Lisp_Object function, Lisp_Object record_flag, Lisp_Object keys)
{
Lisp_Object *args, *visargs;
Lisp_Object specs;
/* Make a copy of string so that if a GC relocates specs,
`string' will still be valid. */
string = (unsigned char *) alloca (SBYTES (specs) + 1);
- bcopy (SDATA (specs), string,
- SBYTES (specs) + 1);
+ memcpy (string, SDATA (specs), SBYTES (specs) + 1);
}
else
{
{
/* We should record this command on the command history. */
Lisp_Object values;
+ Lisp_Object this_cmd;
/* Make a copy of the list of values, for the command history,
and turn them into things we can eval. */
values = quotify_args (Fcopy_sequence (specs));
fix_command (input, values);
- Vcommand_history
- = Fcons (Fcons (function, values), Vcommand_history);
+ this_cmd = Fcons (function, values);
+ if (history_delete_duplicates)
+ Vcommand_history = Fdelete (this_cmd, Vcommand_history);
+ Vcommand_history = Fcons (this_cmd, Vcommand_history);
/* Don't keep command history around forever. */
if (INTEGERP (Vhistory_length) && XINT (Vhistory_length) > 0)
}
else if (*string == '^')
{
- if (! NILP (Vshift_select_mode))
- call1 (Qhandle_shift_selection, Qnil);
- /* Even if shift-select-mode is off, temporarily active
- regions could be set using the mouse, and should be
- deactivated. */
- else if (CONSP (Vtransient_mark_mode)
- && EQ (XCAR (Vtransient_mark_mode), Qonly))
- call1 (Qhandle_shift_selection, Qt);
+ call0 (Qhandle_shift_selection);
string++;
}
else break;
j += 2;
else
j++;
- tem = (unsigned char *) index (tem, '\n');
+ tem = (unsigned char *) strchr (tem, '\n');
if (tem)
++tem;
else
{
strncpy (prompt1, tem + 1, sizeof prompt1 - 1);
prompt1[sizeof prompt1 - 1] = 0;
- tem1 = (char *) index (prompt1, '\n');
+ tem1 = strchr (prompt1, '\n');
if (tem1) *tem1 = 0;
visargs[0] = build_string (prompt1);
- if (index (prompt1, '%'))
+ if (strchr (prompt1, '%'))
callint_message = Fformat (i, visargs);
else
callint_message = visargs[0];
break;
case 'c': /* Character */
+ /* Prompt in `minibuffer-prompt' face. */
+ Fput_text_property (make_number (0),
+ make_number (SCHARS (callint_message)),
+ Qface, Qminibuffer_prompt, callint_message);
args[i] = Fread_char (callint_message, Qnil, Qnil);
message1_nolog ((char *) 0);
/* Passing args[i] directly stimulates compiler bug */
{
int speccount1 = SPECPDL_INDEX ();
specbind (Qcursor_in_echo_area, Qt);
+ /* Prompt in `minibuffer-prompt' face. */
+ Fput_text_property (make_number (0),
+ make_number (SCHARS (callint_message)),
+ Qface, Qminibuffer_prompt, callint_message);
args[i] = Fread_key_sequence (callint_message,
Qnil, Qnil, Qnil, Qnil);
unbind_to (speccount1, Qnil);
{
int speccount1 = SPECPDL_INDEX ();
specbind (Qcursor_in_echo_area, Qt);
+ /* Prompt in `minibuffer-prompt' face. */
+ Fput_text_property (make_number (0),
+ make_number (SCHARS (callint_message)),
+ Qface, Qminibuffer_prompt, callint_message);
args[i] = Fread_key_sequence (callint_message,
Qnil, Qt, Qnil, Qnil);
teml = args[i];
if (next_event >= key_count)
error ("%s must be bound to an event with parameters",
(SYMBOLP (function)
- ? (char *) SDATA (SYMBOL_NAME (function))
+ ? SSDATA (SYMBOL_NAME (function))
: "command"));
args[i] = AREF (keys, next_event);
next_event++;
if (NILP (visargs[i]) && STRINGP (args[i]))
visargs[i] = args[i];
- tem = (unsigned char *) index (tem, '\n');
+ tem = (unsigned char *) strchr (tem, '\n');
if (tem) tem++;
else tem = (unsigned char *) "";
}
doc: /* Return numeric meaning of raw prefix argument RAW.
A raw prefix argument is what you get from `(interactive "P")'.
Its numeric meaning is what you would get from `(interactive "p")'. */)
- (raw)
- Lisp_Object raw;
+ (Lisp_Object raw)
{
Lisp_Object val;
}
void
-syms_of_callint ()
+syms_of_callint (void)
{
point_marker = Fmake_marker ();
staticpro (&point_marker);
callint_message = Qnil;
staticpro (&callint_message);
- preserved_fns = Fcons (intern ("region-beginning"),
- Fcons (intern ("region-end"),
- Fcons (intern ("point"),
- Fcons (intern ("mark"), Qnil))));
- staticpro (&preserved_fns);
+ preserved_fns = pure_cons (intern_c_string ("region-beginning"),
+ pure_cons (intern_c_string ("region-end"),
+ pure_cons (intern_c_string ("point"),
+ pure_cons (intern_c_string ("mark"), Qnil))));
- Qlist = intern ("list");
+ Qlist = intern_c_string ("list");
staticpro (&Qlist);
- Qlet = intern ("let");
+ Qlet = intern_c_string ("let");
staticpro (&Qlet);
- Qif = intern ("if");
+ Qif = intern_c_string ("if");
staticpro (&Qif);
- Qwhen = intern ("when");
+ Qwhen = intern_c_string ("when");
staticpro (&Qwhen);
- Qletx = intern ("let*");
+ Qletx = intern_c_string ("let*");
staticpro (&Qletx);
- Qsave_excursion = intern ("save-excursion");
+ Qsave_excursion = intern_c_string ("save-excursion");
staticpro (&Qsave_excursion);
- Qprogn = intern ("progn");
+ Qprogn = intern_c_string ("progn");
staticpro (&Qprogn);
- Qminus = intern ("-");
+ Qminus = intern_c_string ("-");
staticpro (&Qminus);
- Qplus = intern ("+");
+ Qplus = intern_c_string ("+");
staticpro (&Qplus);
- Qhandle_shift_selection = intern ("handle-shift-selection");
+ Qhandle_shift_selection = intern_c_string ("handle-shift-selection");
staticpro (&Qhandle_shift_selection);
- Qcall_interactively = intern ("call-interactively");
+ Qcall_interactively = intern_c_string ("call-interactively");
staticpro (&Qcall_interactively);
- Qcommand_debug_status = intern ("command-debug-status");
+ Qcommand_debug_status = intern_c_string ("command-debug-status");
staticpro (&Qcommand_debug_status);
- Qenable_recursive_minibuffers = intern ("enable-recursive-minibuffers");
+ Qenable_recursive_minibuffers = intern_c_string ("enable-recursive-minibuffers");
staticpro (&Qenable_recursive_minibuffers);
- Qmouse_leave_buffer_hook = intern ("mouse-leave-buffer-hook");
+ Qmouse_leave_buffer_hook = intern_c_string ("mouse-leave-buffer-hook");
staticpro (&Qmouse_leave_buffer_hook);
DEFVAR_KBOARD ("prefix-arg", Vprefix_arg,
doc: /* The value of the prefix argument for the previous editing command.
See `prefix-arg' for the meaning of the value. */);
- DEFVAR_LISP ("current-prefix-arg", &Vcurrent_prefix_arg,
+ DEFVAR_LISP ("current-prefix-arg", Vcurrent_prefix_arg,
doc: /* The value of the prefix argument for this editing command.
It may be a number, or the symbol `-' for just a minus sign as arg,
or a list whose car is a number for just one or more C-u's
This is what `(interactive \"P\")' returns. */);
Vcurrent_prefix_arg = Qnil;
- DEFVAR_LISP ("command-history", &Vcommand_history,
+ DEFVAR_LISP ("command-history", Vcommand_history,
doc: /* List of recent commands that read arguments from terminal.
Each command is represented as a form to evaluate.
of `history-length', which see. */);
Vcommand_history = Qnil;
- DEFVAR_LISP ("command-debug-status", &Vcommand_debug_status,
+ DEFVAR_LISP ("command-debug-status", Vcommand_debug_status,
doc: /* Debugging status of current interactive command.
Bound each time `call-interactively' is called;
may be set by the debugger as a reminder for itself. */);
Vcommand_debug_status = Qnil;
- DEFVAR_LISP ("mark-even-if-inactive", &Vmark_even_if_inactive,
+ DEFVAR_LISP ("mark-even-if-inactive", Vmark_even_if_inactive,
doc: /* *Non-nil means you can use the mark even when inactive.
This option makes a difference in Transient Mark mode.
When the option is non-nil, deactivation of the mark
behave as if the mark were still active. */);
Vmark_even_if_inactive = Qt;
- DEFVAR_LISP ("shift-select-mode", &Vshift_select_mode,
- doc: /* When non-nil, shifted motion keys activate the mark momentarily.
-
-While the mark is activated in this way, any shift-translated point
-motion key extends the region, and if Transient Mark mode was off, it
-is temporarily turned on. Furthermore, the mark will be deactivated
-by any subsequent point motion key that was not shift-translated, or
-by any action that normally deactivates the mark in Transient Mark
-mode.
-
-See `this-command-keys-shift-translated' for the meaning of
-shift-translation. */);
- Vshift_select_mode = Qt;
-
- DEFVAR_LISP ("mouse-leave-buffer-hook", &Vmouse_leave_buffer_hook,
+ DEFVAR_LISP ("mouse-leave-buffer-hook", Vmouse_leave_buffer_hook,
doc: /* Hook to run when about to switch windows with a mouse command.
Its purpose is to give temporary modes such as Isearch mode
a way to turn themselves off when a mouse command switches windows. */);
defsubr (&Scall_interactively);
defsubr (&Sprefix_numeric_value);
}
-
-/* arch-tag: a3a7cad7-bcac-42ce-916e-1bd2546ebf37
- (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff