1 /* Call a Lisp function interactively.
2 Copyright (C) 1985-1986, 1993-1995, 1997, 2000-2017 Free Software
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or (at
10 your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
24 #include "ptr-bounds.h"
25 #include "character.h"
30 static Lisp_Object preserved_fns
;
32 /* Marker used within call-interactively to refer to point. */
33 static Lisp_Object point_marker
;
35 /* String for the prompt text used in Fcall_interactively. */
36 static Lisp_Object callint_message
;
39 DEFUN ("interactive", Finteractive
, Sinteractive
, 0, UNEVALLED
, 0,
40 doc
: /* Specify a way of parsing arguments for interactive use of a function.
42 (defun foo (arg buf) "Doc string" (interactive "P\\nbbuffer: ") .... )
43 to make ARG be the raw prefix argument, and set BUF to an existing buffer,
44 when `foo' is called as a command.
46 The "call" to `interactive' is actually a declaration rather than a
47 function; it tells `call-interactively' how to read arguments to pass
48 to the function. When actually called, `interactive' just returns
51 Usually the argument of `interactive' is a string containing a code
52 letter followed optionally by a prompt. (Some code letters do not
53 use I/O to get the argument and do not use prompts.) To pass several
54 arguments to the command, concatenate the individual strings,
55 separating them by newline characters.
57 Prompts are passed to `format', and may use % escapes to print the
58 arguments that have already been read.
59 If the argument is not a string, it is evaluated to get a list of
60 arguments to pass to the command.
61 Just `(interactive)' means pass no arguments to the command when
62 calling interactively.
64 Code letters available are:
65 a -- Function name: symbol with a function definition.
66 b -- Name of existing buffer.
67 B -- Name of buffer, possibly nonexistent.
68 c -- Character (no input method is used).
69 C -- Command name: symbol with interactive function definition.
70 d -- Value of point as number. Does not do I/O.
72 e -- Parameterized event (i.e., one that's a list) that invoked this command.
73 If used more than once, the Nth `e' returns the Nth parameterized event.
74 This skips events that are integers or symbols.
75 f -- Existing file name.
76 F -- Possibly nonexistent file name.
77 G -- Possibly nonexistent file name, defaulting to just directory name.
78 i -- Ignored, i.e. always nil. Does not do I/O.
79 k -- Key sequence (downcase the last event if needed to get a definition).
80 K -- Key sequence to be redefined (do not downcase the last event).
81 m -- Value of mark as number. Does not do I/O.
82 M -- Any string. Inherits the current input method.
83 n -- Number read using minibuffer.
84 N -- Numeric prefix arg, or if none, do like code `n'.
85 p -- Prefix arg converted to number. Does not do I/O.
86 P -- Prefix arg in raw form. Does not do I/O.
87 r -- Region: point and mark as 2 numeric args, smallest first. Does no I/O.
88 s -- Any string. Does not inherit the current input method.
90 U -- Mouse up event discarded by a previous k or K argument.
91 v -- Variable name: symbol that is `custom-variable-p'.
92 x -- Lisp expression read but not evaluated.
93 X -- Lisp expression read and evaluated.
95 Z -- Coding system, nil if no prefix arg.
97 In addition, if the string begins with `*', an error is signaled if
98 the buffer is read-only.
99 If `@' appears at the beginning of the string, and if the key sequence
100 used to invoke the command includes any mouse events, then the window
101 associated with the first of those events is selected before the
103 If the string begins with `^' and `shift-select-mode' is non-nil,
104 Emacs first calls the function `handle-shift-selection'.
105 You may use `@', `*', and `^' together. They are processed in the
106 order that they appear, before reading any arguments.
107 usage: (interactive &optional ARG-DESCRIPTOR) */
114 /* Quotify EXP: if EXP is constant, return it.
115 If EXP is not constant, return (quote EXP). */
117 quotify_arg (register Lisp_Object exp
)
121 && !NILP (exp
) && !EQ (exp
, Qt
)))
122 return list2 (Qquote
, exp
);
127 /* Modify EXP by quotifying each element (except the first). */
129 quotify_args (Lisp_Object exp
)
131 register Lisp_Object tail
;
133 for (tail
= exp
; CONSP (tail
); tail
= next
)
136 XSETCAR (tail
, quotify_arg (XCAR (tail
)));
141 static const char *callint_argfuns
[]
142 = {"", "point", "mark", "region-beginning", "region-end"};
145 check_mark (bool for_region
)
148 tem
= Fmarker_buffer (BVAR (current_buffer
, mark
));
149 if (NILP (tem
) || (XBUFFER (tem
) != current_buffer
))
150 error (for_region
? "The mark is not set now, so there is no region"
151 : "The mark is not set now");
152 if (!NILP (Vtransient_mark_mode
) && NILP (Vmark_even_if_inactive
)
153 && NILP (BVAR (current_buffer
, mark_active
)))
154 xsignal0 (Qmark_inactive
);
157 /* If the list of args INPUT was produced with an explicit call to
158 `list', look for elements that were computed with
159 (region-beginning) or (region-end), and put those expressions into
160 VALUES instead of the present values.
162 This function doesn't return a value because it modifies elements
163 of VALUES to do its job. */
166 fix_command (Lisp_Object input
, Lisp_Object values
)
168 /* FIXME: Instead of this ugly hack, we should provide a way for an
169 interactive spec to return an expression/function that will re-build the
170 args without user intervention. */
176 /* Skip through certain special forms. */
177 while (EQ (car
, Qlet
) || EQ (car
, Qletx
)
178 || EQ (car
, Qsave_excursion
)
181 while (CONSP (XCDR (input
)))
182 input
= XCDR (input
);
183 input
= XCAR (input
);
190 Lisp_Object intail
, valtail
;
191 for (intail
= Fcdr (input
), valtail
= values
;
193 intail
= Fcdr (intail
), valtail
= XCDR (valtail
))
199 Lisp_Object presflag
, carelt
;
201 /* If it is (if X Y), look at Y. */
203 && EQ (Fnthcdr (make_number (3), elt
), Qnil
))
204 elt
= Fnth (make_number (2), elt
);
205 /* If it is (when ... Y), look at Y. */
206 else if (EQ (carelt
, Qwhen
))
208 while (CONSP (XCDR (elt
)))
213 /* If the function call we're looking at
214 is a special preserved one, copy the
215 whole expression for this argument. */
218 presflag
= Fmemq (Fcar (elt
), preserved_fns
);
219 if (!NILP (presflag
))
220 Fsetcar (valtail
, Fcar (intail
));
228 /* Helper function to call `read-file-name' from C. */
231 read_file_name (Lisp_Object default_filename
, Lisp_Object mustmatch
,
232 Lisp_Object initial
, Lisp_Object predicate
)
234 return CALLN (Ffuncall
, intern ("read-file-name"),
235 callint_message
, Qnil
, default_filename
,
236 mustmatch
, initial
, predicate
);
239 /* BEWARE: Calling this directly from C would defeat the purpose! */
240 DEFUN ("funcall-interactively", Ffuncall_interactively
, Sfuncall_interactively
,
241 1, MANY
, 0, doc
: /* Like `funcall' but marks the call as interactive.
242 I.e. arrange that within the called function `called-interactively-p' will
244 usage: (funcall-interactively FUNCTION &rest ARGUMENTS) */)
245 (ptrdiff_t nargs
, Lisp_Object
*args
)
247 ptrdiff_t speccount
= SPECPDL_INDEX ();
248 temporarily_switch_to_single_kboard (NULL
);
250 /* Nothing special to do here, all the work is inside
251 `called-interactively-p'. Which will look for us as a marker in the
253 return unbind_to (speccount
, Ffuncall (nargs
, args
));
256 DEFUN ("call-interactively", Fcall_interactively
, Scall_interactively
, 1, 3, 0,
257 doc
: /* Call FUNCTION, providing args according to its interactive calling specs.
258 Return the value FUNCTION returns.
259 The function contains a specification of how to do the argument reading.
260 In the case of user-defined functions, this is specified by placing a call
261 to the function `interactive' at the top level of the function body.
264 Optional second arg RECORD-FLAG non-nil
265 means unconditionally put this command in the command-history.
266 Otherwise, this is done only if an arg is read using the minibuffer.
268 Optional third arg KEYS, if given, specifies the sequence of events to
269 supply, as a vector, if the command inquires which events were used to
270 invoke it. If KEYS is omitted or nil, the return value of
271 `this-command-keys-vector' is used. */)
272 (Lisp_Object function
, Lisp_Object record_flag
, Lisp_Object keys
)
274 /* `args' will contain the array of arguments to pass to the function.
275 `visargs' will contain the same list but in a nicer form, so that if we
276 pass it to Fformat_message it will be understandable to a human. */
277 Lisp_Object
*args
, *visargs
;
279 Lisp_Object filter_specs
;
281 Lisp_Object up_event
;
284 ptrdiff_t speccount
= SPECPDL_INDEX ();
286 /* The index of the next element of this_command_keys to examine for
287 the 'e' interactive code. */
288 ptrdiff_t next_event
;
290 Lisp_Object prefix_arg
;
294 /* If varies[i] > 0, the i'th argument shouldn't just have its value
295 in this call quoted in the command history. It should be
296 recorded as a call to the function named callint_argfuns[varies[i]]. */
301 bool arg_from_tty
= 0;
303 bool record_then_fail
= 0;
305 Lisp_Object save_this_command
, save_last_command
;
306 Lisp_Object save_this_original_command
, save_real_this_command
;
308 save_this_command
= Vthis_command
;
309 save_this_original_command
= Vthis_original_command
;
310 save_real_this_command
= Vreal_this_command
;
311 save_last_command
= KVAR (current_kboard
, Vlast_command
);
314 keys
= this_command_keys
, key_count
= this_command_key_count
;
318 key_count
= ASIZE (keys
);
321 /* Save this now, since use of minibuffer will clobber it. */
322 prefix_arg
= Vcurrent_prefix_arg
;
324 if (SYMBOLP (function
))
325 enable
= Fget (function
, Qenable_recursive_minibuffers
);
331 /* The idea of FILTER_SPECS is to provide a way to
332 specify how to represent the arguments in command history.
333 The feature is not fully implemented. */
336 /* If k or K discard an up-event, save it here so it can be retrieved with
340 /* Set SPECS to the interactive form, or barf if not interactive. */
343 form
= Finteractive_form (function
);
345 specs
= filter_specs
= Fcar (XCDR (form
));
347 wrong_type_argument (Qcommandp
, function
);
350 /* If SPECS is not a string, invent one. */
351 if (! STRINGP (specs
))
354 Lisp_Object funval
= Findirect_function (function
, Qt
);
355 uintmax_t events
= num_input_events
;
357 /* Compute the arg values using the user's expression. */
358 specs
= Feval (specs
,
359 CONSP (funval
) && EQ (Qclosure
, XCAR (funval
))
360 ? CAR_SAFE (XCDR (funval
)) : Qnil
);
361 if (events
!= num_input_events
|| !NILP (record_flag
))
363 /* We should record this command on the command history. */
365 Lisp_Object this_cmd
;
366 /* Make a copy of the list of values, for the command history,
367 and turn them into things we can eval. */
368 values
= quotify_args (Fcopy_sequence (specs
));
369 fix_command (input
, values
);
370 this_cmd
= Fcons (function
, values
);
371 if (history_delete_duplicates
)
372 Vcommand_history
= Fdelete (this_cmd
, Vcommand_history
);
373 Vcommand_history
= Fcons (this_cmd
, Vcommand_history
);
375 /* Don't keep command history around forever. */
376 if (INTEGERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
378 teml
= Fnthcdr (Vhistory_length
, Vcommand_history
);
380 XSETCDR (teml
, Qnil
);
384 Vthis_command
= save_this_command
;
385 Vthis_original_command
= save_this_original_command
;
386 Vreal_this_command
= save_real_this_command
;
387 kset_last_command (current_kboard
, save_last_command
);
390 = unbind_to (speccount
, CALLN (Fapply
, Qfuncall_interactively
,
396 /* SPECS is set to a string; use it as an interactive prompt.
397 Copy it so that STRING will be valid even if a GC relocates SPECS. */
398 SAFE_ALLOCA_STRING (string
, specs
);
400 /* Here if function specifies a string to control parsing the defaults. */
402 /* Set next_event to point to the first event with parameters. */
403 for (next_event
= 0; next_event
< key_count
; next_event
++)
404 if (EVENT_HAS_PARAMETERS (AREF (keys
, next_event
)))
407 /* Handle special starting chars `*' and `@'. Also `-'. */
408 /* Note that `+' is reserved for user extensions. */
412 error ("`+' is not used in `interactive' for ordinary commands");
413 else if (*string
== '*')
416 if (!NILP (BVAR (current_buffer
, read_only
)))
418 if (!NILP (record_flag
))
423 if (! (*p
== 'r' || *p
== 'p' || *p
== 'P'
425 Fbarf_if_buffer_read_only (Qnil
);
428 record_then_fail
= 1;
431 Fbarf_if_buffer_read_only (Qnil
);
434 /* Ignore this for semi-compatibility with Lucid. */
435 else if (*string
== '-')
437 else if (*string
== '@')
439 Lisp_Object event
, w
;
441 event
= (next_event
< key_count
442 ? AREF (keys
, next_event
)
444 if (EVENT_HAS_PARAMETERS (event
)
445 && (w
= XCDR (event
), CONSP (w
))
446 && (w
= XCAR (w
), CONSP (w
))
447 && (w
= XCAR (w
), WINDOWP (w
)))
449 if (MINI_WINDOW_P (XWINDOW (w
))
450 && ! (minibuf_level
> 0 && EQ (w
, minibuf_window
)))
451 error ("Attempt to select inactive minibuffer window");
453 /* If the current buffer wants to clean up, let it. */
454 run_hook (Qmouse_leave_buffer_hook
);
456 Fselect_window (w
, Qnil
);
460 else if (*string
== '^')
462 call0 (Qhandle_shift_selection
);
468 /* Count the number of arguments, which is two (the function itself and
469 `funcall-interactively') plus the number of arguments the interactive spec
470 would have us give to the function. */
472 for (nargs
= 2; *tem
; )
474 /* 'r' specifications ("point and mark as 2 numeric args")
475 produce *two* arguments. */
480 tem
= strchr (tem
, '\n');
487 if (MOST_POSITIVE_FIXNUM
< min (PTRDIFF_MAX
, SIZE_MAX
) / word_size
488 && MOST_POSITIVE_FIXNUM
< nargs
)
489 memory_full (SIZE_MAX
);
491 /* Allocate them all at one go. This wastes a bit of memory, but
492 it's OK to trade space for speed. */
493 SAFE_NALLOCA (args
, 3, nargs
);
494 visargs
= args
+ nargs
;
495 varies
= (signed char *) (visargs
+ nargs
);
497 memclear (args
, nargs
* (2 * word_size
+ 1));
498 args
= ptr_bounds_clip (args
, nargs
* sizeof *args
);
499 visargs
= ptr_bounds_clip (visargs
, nargs
* sizeof *visargs
);
500 varies
= ptr_bounds_clip (varies
, nargs
* sizeof *varies
);
503 specbind (Qenable_recursive_minibuffers
, Qt
);
506 for (i
= 2; *tem
; i
++)
508 visargs
[1] = make_string (tem
+ 1, strcspn (tem
+ 1, "\n"));
509 callint_message
= Fformat_message (i
- 1, visargs
+ 1);
513 case 'a': /* Symbol defined as a function. */
514 visargs
[i
] = Fcompleting_read (callint_message
,
515 Vobarray
, Qfboundp
, Qt
,
516 Qnil
, Qnil
, Qnil
, Qnil
);
517 /* Passing args[i] directly stimulates compiler bug. */
519 args
[i
] = Fintern (teml
, Qnil
);
522 case 'b': /* Name of existing buffer. */
523 args
[i
] = Fcurrent_buffer ();
524 if (EQ (selected_window
, minibuf_window
))
525 args
[i
] = Fother_buffer (args
[i
], Qnil
, Qnil
);
526 args
[i
] = Fread_buffer (callint_message
, args
[i
], Qt
, Qnil
);
529 case 'B': /* Name of buffer, possibly nonexistent. */
530 args
[i
] = Fread_buffer (callint_message
,
531 Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
),
535 case 'c': /* Character. */
536 /* Prompt in `minibuffer-prompt' face. */
537 Fput_text_property (make_number (0),
538 make_number (SCHARS (callint_message
)),
539 Qface
, Qminibuffer_prompt
, callint_message
);
540 args
[i
] = Fread_char (callint_message
, Qnil
, Qnil
);
542 /* Passing args[i] directly stimulates compiler bug. */
545 if (! CHARACTERP (teml
)) error ("Non-character input-event");
546 visargs
[i
] = Fchar_to_string (teml
);
549 case 'C': /* Command: symbol with interactive function. */
550 visargs
[i
] = Fcompleting_read (callint_message
,
552 Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
553 /* Passing args[i] directly stimulates compiler bug. */
555 args
[i
] = Fintern (teml
, Qnil
);
558 case 'd': /* Value of point. Does not do I/O. */
559 set_marker_both (point_marker
, Qnil
, PT
, PT_BYTE
);
560 args
[i
] = point_marker
;
561 /* visargs[i] = Qnil; */
565 case 'D': /* Directory name. */
566 args
[i
] = read_file_name (BVAR (current_buffer
, directory
), Qlambda
, Qnil
,
570 case 'f': /* Existing file name. */
571 args
[i
] = read_file_name (Qnil
, Qlambda
, Qnil
, Qnil
);
574 case 'F': /* Possibly nonexistent file name. */
575 args
[i
] = read_file_name (Qnil
, Qnil
, Qnil
, Qnil
);
578 case 'G': /* Possibly nonexistent file name,
579 default to directory alone. */
580 args
[i
] = read_file_name (Qnil
, Qnil
, empty_unibyte_string
, Qnil
);
583 case 'i': /* Ignore an argument -- Does not do I/O. */
587 case 'k': /* Key sequence. */
589 ptrdiff_t speccount1
= SPECPDL_INDEX ();
590 specbind (Qcursor_in_echo_area
, Qt
);
591 /* Prompt in `minibuffer-prompt' face. */
592 Fput_text_property (make_number (0),
593 make_number (SCHARS (callint_message
)),
594 Qface
, Qminibuffer_prompt
, callint_message
);
595 args
[i
] = Fread_key_sequence (callint_message
,
596 Qnil
, Qnil
, Qnil
, Qnil
);
597 unbind_to (speccount1
, Qnil
);
599 visargs
[i
] = Fkey_description (teml
, Qnil
);
601 /* If the key sequence ends with a down-event,
602 discard the following up-event. */
603 teml
= Faref (args
[i
], make_number (XINT (Flength (args
[i
])) - 1));
610 teml
= Fget (teml
, Qevent_symbol_elements
);
611 /* Ignore first element, which is the base key. */
612 tem2
= Fmemq (Qdown
, Fcdr (teml
));
614 up_event
= Fread_event (Qnil
, Qnil
, Qnil
);
619 case 'K': /* Key sequence to be defined. */
621 ptrdiff_t speccount1
= SPECPDL_INDEX ();
622 specbind (Qcursor_in_echo_area
, Qt
);
623 /* Prompt in `minibuffer-prompt' face. */
624 Fput_text_property (make_number (0),
625 make_number (SCHARS (callint_message
)),
626 Qface
, Qminibuffer_prompt
, callint_message
);
627 args
[i
] = Fread_key_sequence_vector (callint_message
,
628 Qnil
, Qt
, Qnil
, Qnil
);
630 visargs
[i
] = Fkey_description (teml
, Qnil
);
631 unbind_to (speccount1
, Qnil
);
633 /* If the key sequence ends with a down-event,
634 discard the following up-event. */
635 teml
= Faref (args
[i
], make_number (XINT (Flength (args
[i
])) - 1));
642 teml
= Fget (teml
, Qevent_symbol_elements
);
643 /* Ignore first element, which is the base key. */
644 tem2
= Fmemq (Qdown
, Fcdr (teml
));
646 up_event
= Fread_event (Qnil
, Qnil
, Qnil
);
651 case 'U': /* Up event from last k or K. */
652 if (!NILP (up_event
))
654 args
[i
] = Fmake_vector (make_number (1), up_event
);
657 visargs
[i
] = Fkey_description (teml
, Qnil
);
661 case 'e': /* The invoking event. */
662 if (next_event
>= key_count
)
663 error ("%s must be bound to an event with parameters",
665 ? SSDATA (SYMBOL_NAME (function
))
667 args
[i
] = AREF (keys
, next_event
);
671 /* Find the next parameterized event. */
672 while (next_event
< key_count
673 && !(EVENT_HAS_PARAMETERS (AREF (keys
, next_event
))))
678 case 'm': /* Value of mark. Does not do I/O. */
680 /* visargs[i] = Qnil; */
681 args
[i
] = BVAR (current_buffer
, mark
);
685 case 'M': /* String read via minibuffer with
686 inheriting the current input method. */
687 args
[i
] = Fread_string (callint_message
,
688 Qnil
, Qnil
, Qnil
, Qt
);
691 case 'N': /* Prefix arg as number, else number from minibuffer. */
692 if (!NILP (prefix_arg
))
693 goto have_prefix_arg
;
695 case 'n': /* Read number from minibuffer. */
696 args
[i
] = call1 (Qread_number
, callint_message
);
697 /* Passing args[i] directly stimulates compiler bug. */
699 visargs
[i
] = Fnumber_to_string (teml
);
702 case 'P': /* Prefix arg in raw form. Does no I/O. */
703 args
[i
] = prefix_arg
;
704 /* visargs[i] = Qnil; */
708 case 'p': /* Prefix arg converted to number. No I/O. */
710 args
[i
] = Fprefix_numeric_value (prefix_arg
);
711 /* visargs[i] = Qnil; */
715 case 'r': /* Region, point and mark as 2 args. */
717 set_marker_both (point_marker
, Qnil
, PT
, PT_BYTE
);
718 /* visargs[i+1] = Qnil; */
719 mark
= marker_position (BVAR (current_buffer
, mark
));
720 /* visargs[i] = Qnil; */
721 args
[i
] = PT
< mark
? point_marker
: BVAR (current_buffer
, mark
);
723 args
[++i
] = PT
> mark
? point_marker
: BVAR (current_buffer
, mark
);
727 case 's': /* String read via minibuffer without
728 inheriting the current input method. */
729 args
[i
] = Fread_string (callint_message
,
730 Qnil
, Qnil
, Qnil
, Qnil
);
733 case 'S': /* Any symbol. */
734 visargs
[i
] = Fread_string (callint_message
,
735 Qnil
, Qnil
, Qnil
, Qnil
);
736 /* Passing args[i] directly stimulates compiler bug. */
738 args
[i
] = Fintern (teml
, Qnil
);
741 case 'v': /* Variable name: symbol that is
742 custom-variable-p. */
743 args
[i
] = Fread_variable (callint_message
, Qnil
);
744 visargs
[i
] = last_minibuf_string
;
747 case 'x': /* Lisp expression read but not evaluated. */
748 args
[i
] = call1 (intern ("read-minibuffer"), callint_message
);
749 visargs
[i
] = last_minibuf_string
;
752 case 'X': /* Lisp expression read and evaluated. */
753 args
[i
] = call1 (intern ("eval-minibuffer"), callint_message
);
754 visargs
[i
] = last_minibuf_string
;
757 case 'Z': /* Coding-system symbol, or ignore the
758 argument if no prefix. */
759 if (NILP (prefix_arg
))
761 /* args[i] = Qnil; */
767 = Fread_non_nil_coding_system (callint_message
);
768 visargs
[i
] = last_minibuf_string
;
772 case 'z': /* Coding-system symbol or nil. */
773 args
[i
] = Fread_coding_system (callint_message
, Qnil
);
774 visargs
[i
] = last_minibuf_string
;
777 /* We have a case for `+' so we get an error
778 if anyone tries to define one here. */
781 error ("Invalid control letter `%c' (#o%03o, #x%04x) in interactive calling string",
782 STRING_CHAR ((unsigned char *) tem
),
783 (unsigned) STRING_CHAR ((unsigned char *) tem
),
784 (unsigned) STRING_CHAR ((unsigned char *) tem
));
790 if (NILP (visargs
[i
]) && STRINGP (args
[i
]))
791 visargs
[i
] = args
[i
];
793 tem
= strchr (tem
, '\n');
797 unbind_to (speccount
, Qnil
);
801 args
[0] = Qfuncall_interactively
;
804 if (arg_from_tty
|| !NILP (record_flag
))
806 /* We don't need `visargs' any more, so let's recycle it since we need
807 an array of just the same size. */
808 visargs
[1] = function
;
809 for (i
= 2; i
< nargs
; i
++)
812 visargs
[i
] = list1 (intern (callint_argfuns
[varies
[i
]]));
814 visargs
[i
] = quotify_arg (args
[i
]);
816 Vcommand_history
= Fcons (Flist (nargs
- 1, visargs
+ 1),
818 /* Don't keep command history around forever. */
819 if (INTEGERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
821 teml
= Fnthcdr (Vhistory_length
, Vcommand_history
);
823 XSETCDR (teml
, Qnil
);
827 /* If we used a marker to hold point, mark, or an end of the region,
828 temporarily, convert it to an integer now. */
829 for (i
= 2; i
< nargs
; i
++)
830 if (varies
[i
] >= 1 && varies
[i
] <= 4)
831 XSETINT (args
[i
], marker_position (args
[i
]));
833 if (record_then_fail
)
834 Fbarf_if_buffer_read_only (Qnil
);
836 Vthis_command
= save_this_command
;
837 Vthis_original_command
= save_this_original_command
;
838 Vreal_this_command
= save_real_this_command
;
839 kset_last_command (current_kboard
, save_last_command
);
843 specbind (Qcommand_debug_status
, Qnil
);
845 val
= Ffuncall (nargs
, args
);
846 val
= unbind_to (speccount
, val
);
852 DEFUN ("prefix-numeric-value", Fprefix_numeric_value
, Sprefix_numeric_value
,
854 doc
: /* Return numeric meaning of raw prefix argument RAW.
855 A raw prefix argument is what you get from `(interactive "P")'.
856 Its numeric meaning is what you would get from `(interactive "p")'. */)
862 XSETFASTINT (val
, 1);
863 else if (EQ (raw
, Qminus
))
865 else if (CONSP (raw
) && INTEGERP (XCAR (raw
)))
866 XSETINT (val
, XINT (XCAR (raw
)));
867 else if (INTEGERP (raw
))
870 XSETFASTINT (val
, 1);
876 syms_of_callint (void)
878 point_marker
= Fmake_marker ();
879 staticpro (&point_marker
);
881 callint_message
= Qnil
;
882 staticpro (&callint_message
);
884 preserved_fns
= listn (CONSTYPE_PURE
, 4,
885 intern_c_string ("region-beginning"),
886 intern_c_string ("region-end"),
887 intern_c_string ("point"),
888 intern_c_string ("mark"));
890 DEFSYM (Qlist
, "list");
891 DEFSYM (Qlet
, "let");
893 DEFSYM (Qwhen
, "when");
894 DEFSYM (Qletx
, "let*");
895 DEFSYM (Qsave_excursion
, "save-excursion");
896 DEFSYM (Qprogn
, "progn");
897 DEFSYM (Qminus
, "-");
899 DEFSYM (Qhandle_shift_selection
, "handle-shift-selection");
900 DEFSYM (Qread_number
, "read-number");
901 DEFSYM (Qfuncall_interactively
, "funcall-interactively");
902 DEFSYM (Qcommand_debug_status
, "command-debug-status");
903 DEFSYM (Qenable_recursive_minibuffers
, "enable-recursive-minibuffers");
904 DEFSYM (Qmouse_leave_buffer_hook
, "mouse-leave-buffer-hook");
906 DEFVAR_KBOARD ("prefix-arg", Vprefix_arg
,
907 doc
: /* The value of the prefix argument for the next editing command.
908 It may be a number, or the symbol `-' for just a minus sign as arg,
909 or a list whose car is a number for just one or more C-u's
910 or nil if no argument has been specified.
912 You cannot examine this variable to find the argument for this command
913 since it has been set to nil by the time you can look.
914 Instead, you should use the variable `current-prefix-arg', although
915 normally commands can get this prefix argument with (interactive "P"). */);
917 DEFVAR_KBOARD ("last-prefix-arg", Vlast_prefix_arg
,
918 doc
: /* The value of the prefix argument for the previous editing command.
919 See `prefix-arg' for the meaning of the value. */);
921 DEFVAR_LISP ("current-prefix-arg", Vcurrent_prefix_arg
,
922 doc
: /* The value of the prefix argument for this editing command.
923 It may be a number, or the symbol `-' for just a minus sign as arg,
924 or a list whose car is a number for just one or more C-u's
925 or nil if no argument has been specified.
926 This is what `(interactive \"P\")' returns. */);
927 Vcurrent_prefix_arg
= Qnil
;
929 DEFVAR_LISP ("command-history", Vcommand_history
,
930 doc
: /* List of recent commands that read arguments from terminal.
931 Each command is represented as a form to evaluate.
933 Maximum length of the history list is determined by the value
934 of `history-length', which see. */);
935 Vcommand_history
= Qnil
;
937 DEFVAR_LISP ("command-debug-status", Vcommand_debug_status
,
938 doc
: /* Debugging status of current interactive command.
939 Bound each time `call-interactively' is called;
940 may be set by the debugger as a reminder for itself. */);
941 Vcommand_debug_status
= Qnil
;
943 DEFVAR_LISP ("mark-even-if-inactive", Vmark_even_if_inactive
,
944 doc
: /* Non-nil means you can use the mark even when inactive.
945 This option makes a difference in Transient Mark mode.
946 When the option is non-nil, deactivation of the mark
947 turns off region highlighting, but commands that use the mark
948 behave as if the mark were still active. */);
949 Vmark_even_if_inactive
= Qt
;
951 DEFVAR_LISP ("mouse-leave-buffer-hook", Vmouse_leave_buffer_hook
,
952 doc
: /* Hook to run when about to switch windows with a mouse command.
953 Its purpose is to give temporary modes such as Isearch mode
954 a way to turn themselves off when a mouse command switches windows. */);
955 Vmouse_leave_buffer_hook
= Qnil
;
957 defsubr (&Sinteractive
);
958 defsubr (&Scall_interactively
);
959 defsubr (&Sfuncall_interactively
);
960 defsubr (&Sprefix_numeric_value
);