1 /* Call a Lisp function interactively.
2 Copyright (C) 1985, 1986, 1992, 1993, 1994 Free Software Foundation, Inc.
3 Copyright (C) 1995, 1996 Ben Wing.
5 This file is part of SXEmacs
7 SXEmacs 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
10 (at your option) any later version.
12 SXEmacs 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 this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* Synched up with: FSF 19.30, Mule 2.0. */
26 Mly or JWZ: various changes.
35 #define INCLUDE_EVENTS_H_PRIVATE_SPHERE
36 #include "events/events.h"
37 #include "ui/insdel.h"
38 #include "ui/window.h"
40 extern Charcount num_input_chars;
42 Lisp_Object Vcurrent_prefix_arg;
43 Lisp_Object Qcall_interactively;
44 Lisp_Object Vcommand_history;
46 Lisp_Object Vcommand_debug_status, Qcommand_debug_status;
47 Lisp_Object Qenable_recursive_minibuffers;
50 /* Non-nil means treat the mark as active
51 even if mark_active is 0. */
52 Lisp_Object Vmark_even_if_inactive;
55 #if 0 /* ill-conceived */
56 /* FSF calls Qmouse_leave_buffer_hook at all sorts of random places,
57 including a bunch of places in their mouse.el. If this is
58 implemented, it has to be done cleanly. */
59 Lisp_Object Vmouse_leave_buffer_hook, Qmouse_leave_buffer_hook;
62 Lisp_Object QletX, Qsave_excursion;
64 Lisp_Object Qread_from_minibuffer;
65 Lisp_Object Qread_file_name;
66 Lisp_Object Qread_directory_name;
67 Lisp_Object Qcompleting_read;
68 Lisp_Object Qread_buffer;
69 Lisp_Object Qread_function;
70 Lisp_Object Qread_variable;
71 Lisp_Object Qread_expression;
72 Lisp_Object Qread_command;
73 Lisp_Object Qread_number;
74 Lisp_Object Qread_string;
75 Lisp_Object Qevents_to_keys;
77 #if defined(MULE) || defined(FILE_CODING)
78 Lisp_Object Qread_coding_system;
79 Lisp_Object Qread_non_nil_coding_system;
83 DEFUN("interactive", Finteractive, 0, UNEVALLED, 0, /*
84 Specify a way of parsing arguments for interactive use of a function.
86 (defun foo (arg) "Doc string" (interactive "p") ...use arg...)
87 to make ARG be the prefix argument when `foo' is called as a command.
88 The "call" to `interactive' is actually a declaration rather than a function;
89 it tells `call-interactively' how to read arguments
90 to pass to the function.
91 When actually called, `interactive' just returns nil.
93 The argument of `interactive' is usually a string containing a code letter
94 followed by a prompt. (Some code letters do not use I/O to get
95 the argument and do not need prompts.) To prompt for multiple arguments,
96 give a code letter, its prompt, a newline, and another code letter, etc.
97 Prompts are passed to format, and may use % escapes to print the
98 arguments that have already been read.
99 If the argument is not a string, it is evaluated to get a list of
100 arguments to pass to the function.
101 Just `(interactive)' means pass no args when calling interactively.
103 Code letters available are:
104 a -- Function name: symbol with a function definition.
105 b -- Name of existing buffer.
106 B -- Name of buffer, possibly nonexistent.
108 C -- Command name: symbol with interactive function definition.
109 d -- Value of point as number. Does not do I/O.
111 e -- Last mouse-button or misc-user event that invoked this command.
112 If used more than once, the Nth `e' returns the Nth such event.
114 f -- Existing file name.
115 F -- Possibly nonexistent file name.
116 i -- Always nil, ignore. Use to skip arguments when interactive.
117 k -- Key sequence (a vector of events).
118 K -- Key sequence to be redefined (do not automatically down-case).
119 m -- Value of mark as number. Does not do I/O.
120 n -- Number read using minibuffer.
121 N -- Prefix arg converted to number, or if none, do like code `n'.
122 p -- Prefix arg converted to number. Does not do I/O.
123 P -- Prefix arg in raw form. Does not do I/O.
124 r -- Region: point and mark as 2 numeric args, smallest first. Does no I/O.
127 v -- Variable name: symbol that is user-variable-p.
128 x -- Lisp expression read but not evaluated.
129 X -- Lisp expression read and evaluated.
130 z -- Coding system. (Always nil if no Mule support.)
131 Z -- Coding system, nil if no prefix arg. (Always nil if no Mule support.)
132 In addition, if the string begins with `*'
133 then an error is signaled if the buffer is read-only.
134 This happens before reading any arguments.
135 If the string begins with `@', then the window the mouse is over is selected
136 before anything else is done.
137 If the string begins with `_', then this command will not cause the region
138 to be deactivated when it completes; that is, `zmacs-region-stays' will be
139 set to t when the command exits successfully.
140 You may use any of `@', `*' and `_' at the beginning of the string;
141 they are processed in the order that they appear.
148 /* Originally, this was just a function -- but `custom' used a
149 garden-variety version, so why not make it a subr? */
150 /* #### Move it to another file! */
151 DEFUN("quote-maybe", Fquote_maybe, 1, 1, 0, /*
152 Quote EXPR if it is not self quoting.
165 || (CONSP(expr) && EQ(XCAR(expr), Qlambda)))
166 ? expr : list2(Qquote, expr));
169 /* Modify EXPR by quotifying each element (except the first). */
170 static Lisp_Object quotify_args(Lisp_Object expr)
174 for (tail = expr; CONSP(tail); tail = ptr->cdr) {
176 ptr->car = Fquote_maybe(ptr->car);
181 static Bufpos check_mark(void)
185 if (zmacs_regions && !zmacs_region_active_p)
186 error("The region is not active now");
188 tem = Fmarker_buffer(current_buffer->mark);
189 if (NILP(tem) || (XBUFFER(tem) != current_buffer))
190 error("The mark is not set now");
192 return marker_position(current_buffer->mark);
196 callint_prompt(const Bufbyte * prompt_start, Bytecount prompt_length,
197 const Lisp_Object *args, int nargs)
199 Lisp_Object s = make_string(prompt_start, prompt_length);
202 /* Fformat no longer smashes its arg vector, so no need to copy it. */
204 if (!strchr((char*)XSTRING_DATA(s), '%')) {
208 RETURN_UNGCPRO(emacs_doprnt_string_lisp(0, s, 0, nargs, args));
211 /* `lambda' for RECORD-FLAG is an XEmacs addition. */
213 DEFUN("call-interactively", Fcall_interactively, 1, 3, 0, /*
214 Call FUNCTION, reading args according to its interactive calling specs.
215 Return the value FUNCTION returns.
216 The function contains a specification of how to do the argument reading.
217 In the case of user-defined functions, this is specified by placing a call
218 to the function `interactive' at the top level of the function body.
221 If optional second arg RECORD-FLAG is the symbol `lambda', the interactive
222 calling arguments for FUNCTION are read and returned as a list,
223 but the function is not called on them.
225 If RECORD-FLAG is `t' then unconditionally put this command in the
226 command-history. Otherwise, this is done only if an arg is read using
229 The argument KEYS specifies the value to use instead of (this-command-keys)
230 when reading the arguments.
232 (function, record_flag, keys))
234 /* This function can GC */
235 int speccount = specpdl_depth();
239 Lisp_Object specs = Qnil;
240 #ifdef IT_SEEMS_THAT_MLY_DOESNT_LIKE_THIS
243 /* If SPECS is a string, we reset prompt_data to string_data
244 * (XSTRING (specs)) every time a GC might have occurred */
245 const char *prompt_data = 0;
246 int prompt_index = 0;
248 int set_zmacs_region_stays = 0;
249 int mouse_event_count = 0;
255 len = XVECTOR_LENGTH(keys);
256 for (i = 0; i < len; i++)
257 CHECK_LIVE_EVENT(XVECTOR_DATA(keys)[i]);
260 /* Save this now, since use of minibuffer will clobber it. */
261 prefix = Vcurrent_prefix_arg;
265 #ifdef IT_SEEMS_THAT_MLY_DOESNT_LIKE_THIS
266 /* Marginal kludge. Use an evaluated interactive spec instead of this! */
267 if (SYMBOLP(function))
268 enable = Fget(function, Qenable_recursive_minibuffers, Qnil);
271 fun = indirect_function(function, 1);
273 /* Decode the kind of function. Either handle it and return,
274 or go to `lose' if not interactive, or go to `retry'
275 to specify a different function, or set either PROMPT_DATA or SPECS. */
278 prompt_data = XSUBR(fun)->prompt;
281 function = wrong_type_argument(Qcommandp, function);
284 #if 0 /* FSFmacs */ /* Huh? Where is this used? */
285 if ((EMACS_INT) prompt_data == 1)
286 /* Let SPECS (which is nil) be used as the args. */
289 } else if (COMPILED_FUNCTIONP(fun)) {
290 Lisp_Compiled_Function *f = XCOMPILED_FUNCTION(fun);
291 if (!f->flags.interactivep)
293 specs = compiled_function_interactive(f);
294 } else if (!CONSP(fun))
297 Lisp_Object funcar = Fcar(fun);
299 if (EQ(funcar, Qautoload)) {
302 /* do_autoload GCPROs both arguments */
303 do_autoload(fun, function);
306 } else if (EQ(funcar, Qlambda)) {
307 specs = Fassq(Qinteractive, Fcdr(Fcdr(fun)));
310 specs = Fcar(Fcdr(specs));
315 /* FSFmacs makes an alloca() copy of prompt_data here.
316 We're more intelligent about this and just reset prompt_data
318 /* If either specs or prompt_data is set to a string, use it. */
319 if (!STRINGP(specs) && prompt_data == 0) {
320 struct gcpro gcpro1, gcpro2, gcpro3;
321 int i = num_input_chars;
322 Lisp_Object input = specs;
324 GCPRO3(function, specs, input);
325 /* Compute the arg values using the user's expression. */
326 specs = Feval(specs);
327 if (EQ(record_flag, Qlambda)) { /* XEmacs addition */
331 if (!NILP(record_flag) || i != num_input_chars) {
332 /* We should record this command on the command history. */
333 /* #### The following is too specific; should have general
334 mechanism for doing this. */
335 Lisp_Object values, car;
336 /* Make a copy of the list of values, for the command history,
337 and turn them into things we can eval. */
338 values = quotify_args(Fcopy_sequence(specs));
339 /* If the list of args was produced with an explicit call to `list',
340 look for elements that were computed with (region-beginning)
341 or (region-end), and put those expressions into VALUES
342 instead of the present values. */
345 /* Skip through certain special forms. */
346 while (EQ(car, Qlet) || EQ(car, QletX)
347 || EQ(car, Qsave_excursion)) {
348 while (CONSP(XCDR(input)))
355 if (EQ(car, Qlist)) {
356 Lisp_Object intail, valtail;
357 for (intail = Fcdr(input), valtail =
358 values; CONSP(valtail);
359 intail = Fcdr(intail), valtail =
366 if (EQ(eltcar, Qpoint)
380 = Fcons(Fcons(function, values), Vcommand_history);
382 single_console_state();
383 RETURN_UNGCPRO(apply1(fun, specs));
386 /* Here if function specifies a string to control parsing the defaults */
389 /* Translate interactive prompt. */
390 if (STRINGP(specs)) {
391 Lisp_Object domain = Qnil;
392 if (COMPILED_FUNCTIONP(fun))
394 compiled_function_domain(XCOMPILED_FUNCTION(fun));
396 specs = Fgettext(specs);
398 specs = Fdgettext(domain, specs);
399 } else if (prompt_data)
400 /* We do not have to worry about domains in this case because
401 prompt_data is non-nil only for built-in functions, which
402 always use the default domain. */
403 prompt_data = gettext(prompt_data);
406 /* Handle special starting chars `*' and `@' and `_'. */
407 /* Note that `+' is reserved for user extensions. */
410 struct gcpro gcpro1, gcpro2;
411 GCPRO2(function, specs);
415 prompt_data = (char *)XSTRING_DATA(specs);
417 if (prompt_data[prompt_index] == '+')
419 ("`+' is not used in `interactive' for ordinary commands");
420 else if (prompt_data[prompt_index] == '*') {
422 if (!NILP(current_buffer->read_only))
423 barf_if_buffer_read_only(current_buffer,
425 } else if (prompt_data[prompt_index] == '@') {
431 extract_vector_nth_mouse_event(keys,
436 extract_this_command_keys_nth_mouse_event
439 /* Doesn't work; see below */
440 event = Vcurrent_mouse_event;
444 Fevent_window(event);
448 && !(minibuf_level > 0
452 ("Attempt to select inactive minibuffer window");
454 #if 0 /* unclean! see event-stream.c */
455 /* If the current buffer wants to clean up, let it. */
457 (Vmouse_leave_buffer_hook))
459 (Qmouse_leave_buffer_hook);
462 Fselect_window(window, Qnil);
465 } else if (prompt_data[prompt_index] == '_') {
467 set_zmacs_region_stays = 1;
475 /* Count the number of arguments the interactive spec would have
476 us give to the function. */
480 for (tem = prompt_data + prompt_index; *tem;) {
481 /* 'r' specifications ("point and mark as 2 numeric args")
482 produce *two* arguments. */
487 tem = (const char *)strchr(tem + 1, '\n');
494 #ifdef IT_SEEMS_THAT_MLY_DOESNT_LIKE_THIS
496 specbind(Qenable_recursive_minibuffers, Qt);
500 /* Interactive function or no arguments; just call it */
501 if (EQ(record_flag, Qlambda))
503 if (!NILP(record_flag)) {
505 Fcons(list1(function), Vcommand_history);
507 specbind(Qcommand_debug_status, Qnil);
508 /* XEmacs: was fun = call0 (fun), but that's backtraced wrong */
513 fun = Ffuncall(1, &fun);
516 if (set_zmacs_region_stays)
517 zmacs_region_stays = 1;
518 return unbind_to(speccount, fun);
521 /* Read interactive arguments */
523 /* args[-1] is the function to call */
524 /* args[n] is the n'th argument to the function */
525 int alloca_size = (1 /* function to call */
526 + argcount /* actual arguments */
527 + argcount /* visargs */
528 + argcount /* varies */
530 Lisp_Object *fcall= alloca_array(Lisp_Object, alloca_size);
531 Lisp_Object *args = fcall+1;
532 /* visargs is an array of either Qnil or user-friendlier
534 * strings) of previous arguments, to use in prompts for
536 * arguments. ("Often strings" because emacs didn't used to
538 * format %S and prin1-to-string.) */
539 Lisp_Object *visargs = args + argcount;
540 /* If varies[i] is non-null, the i'th argument shouldn't just
541 have its value in this call quoted in the command history.
542 It should be recorded as a call to the function named
544 Lisp_Object *varies = visargs + argcount;
545 int arg_from_tty = 0;
547 struct gcpro gcpro1, gcpro2;
550 for (argnum = 0; argnum < alloca_size - 1; argnum++)
553 /* Must GC-protect args[-1] (ie function) because Ffuncall
555 /* `function' itself isn't GC-protected -- use args[-1] from
556 here (actually, doesn't matter since Emacs GC doesn't
558 GCPRO1n(prefix, &args[-1], alloca_size);
560 for (argnum = 0;; argnum++) {
561 const char *prompt_start =
562 prompt_data + prompt_index + 1;
564 (char *)strchr(prompt_start, '\n');
566 prompt_length = ((prompt_limit)
567 ? (prompt_limit - prompt_start)
568 : (int)strlen(prompt_start));
569 if (prompt_limit && prompt_limit[1] == 0) {
570 /* "sfoo:\n" -- strip tailing return */
574 /* This uses `visargs' instead of `args' so that
575 global-set-key prompts with "Set key C-x C-f to
576 command: "instead of printing event objects in there.
578 #define PROMPT() callint_prompt ((const Bufbyte *) prompt_start, \
579 prompt_length, visargs, argnum)
580 switch (prompt_data[prompt_index]) {
582 /* Symbol defined as a function */
583 Lisp_Object tem = call1(
584 Qread_function, PROMPT());
590 /* Name of existing buffer */
591 Lisp_Object def = Fcurrent_buffer();
592 if (EQ(Fselected_window(Qnil),
594 def = Fother_buffer(def, Qnil, Qnil);
595 /* read-buffer returns a buffer name, not a
597 args[argnum] = call3(
598 Qread_buffer, PROMPT(), def, Qt);
603 /* Name of buffer, possibly nonexistent */
604 /* read-buffer returns a buffer name, not a
606 args[argnum] = call2(Qread_buffer, PROMPT(),
616 int shadowing_speccount =
619 specbind(Qcursor_in_echo_area, Qt);
621 Lisp_Object tmp = PROMPT();
622 message("%s", XSTRING_DATA(tmp));
624 tem = (call0(Qread_char));
626 /* visargs[argnum] = Fsingle_key_description
628 /* FSF has visargs[argnum] = Fchar_to_string
631 unbind_to(shadowing_speccount, Qnil);
633 /* #### `C-x / a' should not leave the prompt in
635 This isn't the right fix, because (message
636 ...) (read-char) shouldn't leave the message
644 /* Command: symbol with interactive function */
646 call1(Qread_command, PROMPT());
652 /* Value of point. Does not do I/O. */
653 args[argnum] = Fcopy_marker(current_buffer->
655 varies[argnum] = Qpoint;
664 extract_vector_nth_mouse_event
665 (keys, mouse_event_count);
668 /* This doesn't quite work because this-command-keys
669 behaves in utterly counterintuitive ways. Sometimes
670 it retrieves an event back in the future, e.g. when
671 one command invokes another command and both are
672 invoked with the mouse. */
674 (extract_this_command_keys_nth_mouse_event
675 (mouse_event_count));
677 event = Vcurrent_mouse_event;
682 ("%s must be bound to a mouse or misc-user event",
689 args[argnum] = event;
693 case 'D': /* Directory name. */
695 args[argnum] = call4(Qread_directory_name, PROMPT(), Qnil, /* dir */
696 current_buffer->directory, /* default */
702 case 'f': /* Existing file name. */
705 call4(Qread_file_name, PROMPT(),
708 Qzero /* must-match */
714 case 'F': /* Possibly nonexistent file name. */
716 args[argnum] = call4(Qread_file_name, PROMPT(), Qnil, /* dir */
718 Qnil /* must-match */
723 case 'i': /* Ignore: always nil. Use to skip arguments. */
728 case 'k': /* Key sequence (vector of events) */
730 struct gcpro ngcpro1;
732 Lisp_Object key_prompt = PROMPT();
736 Fread_key_sequence(key_prompt, Qnil,
740 visargs[argnum] = Fkey_description(tem);
741 /* The following makes `describe-key' not work with
742 extent-local keymaps and such; and anyway, it's
743 contrary to the documentation. */
744 /* args[argnum] = call1 (Qevents_to_keys, tem); */
749 case 'K': /* Key sequence (vector of events),
750 no automatic downcasing */
752 struct gcpro ngcpro1;
754 Lisp_Object key_prompt = PROMPT();
758 Fread_key_sequence(key_prompt, Qnil,
762 visargs[argnum] = Fkey_description(tem);
763 /* The following makes `describe-key' not work with
764 extent-local keymaps and such; and anyway, it's
765 contrary to the documentation. */
766 /* args[argnum] = call1 (Qevents_to_keys, tem); */
772 case 'm': /* Value of mark. Does not do I/O. */
774 args[argnum] = current_buffer->mark;
775 varies[argnum] = Qmark;
778 case 'n': /* Read number from minibuffer. */
782 call2(Qread_number, PROMPT(), Qnil);
783 /* numbers are too boring to go on command history */
784 /* arg_from_tty = 1; */
787 case 'N': /* Prefix arg, else number from minibuffer */
794 case 'P': /* Prefix arg in raw form. Does no I/O. */
796 args[argnum] = prefix;
799 case 'p': /* Prefix arg converted to number. No I/O. */
804 Fprefix_numeric_value
810 case 'r': /* Region, point and mark as 2 args. */
812 Bufpos tem = check_mark();
814 (BUF_PT(current_buffer) <
815 tem ? Fcopy_marker(current_buffer->
818 : current_buffer->mark);
819 varies[argnum] = Qregion_beginning;
821 (BUF_PT(current_buffer) >
822 tem ? Fcopy_marker(current_buffer->
825 : current_buffer->mark);
826 varies[argnum] = Qregion_end;
829 case 's': /* String read via minibuffer. */
832 call1(Qread_string, PROMPT());
836 case 'S': /* Any symbol. */
838 visargs[argnum] = Qnil;
841 call5(Qcompleting_read,
846 /* nil, or prev attempt */
848 visargs[argnum] = tem;
849 /* I could use condition-case with this loser, but why bother?
850 * tem = Fread (tem); check-symbol-p;
852 tem = Fintern(tem, Qnil);
855 (XSYMBOL(tem)->name) > 0)
856 /* Don't accept the empty-named symbol. If the loser
857 really wants this s/he can call completing-read
864 case 'v': /* Variable name: user-variable-p symbol */
867 call1(Qread_variable, PROMPT());
872 case 'x': /* Lisp expression read but not evaluated */
875 call1(Qread_expression, PROMPT());
876 /* visargs[argnum] = Fprin1_to_string (args[argnum], Qnil); */
880 case 'X': /* Lisp expression read and evaluated */
883 call1(Qread_expression, PROMPT());
884 /* visargs[argnum] = Fprin1_to_string (tem, Qnil); */
885 args[argnum] = Feval(tem);
889 case 'Z': /* Coding-system symbol or nil if no prefix */
891 #if defined(MULE) || defined(FILE_CODING)
897 (Qread_non_nil_coding_system,
906 case 'z': /* Coding-system symbol */
908 #if defined(MULE) || defined(FILE_CODING)
910 call1(Qread_coding_system,
919 /* We have a case for `+' so we get an error
920 if anyone tries to define one here. */
925 ("Invalid `interactive' control letter \"%c\" (#o%03o).",
926 prompt_data[prompt_index],
927 prompt_data[prompt_index]);
931 if (NILP(visargs[argnum]))
932 visargs[argnum] = args[argnum];
936 if (STRINGP(specs)) {
937 prompt_data = (char *)XSTRING_DATA(specs);
939 /* +1 to skip spec, +1 for \n */
940 prompt_index += prompt_length + 1 + 1;
942 unbind_to(speccount, Qnil);
946 if (EQ(record_flag, Qlambda)) {
947 RETURN_UNGCPRO(Flist(argcount, args));
950 if (arg_from_tty || !NILP(record_flag)) {
951 /* Reuse visargs as a temporary for constructing the command history */
952 for (argnum = 0; argnum < argcount; argnum++) {
953 if (!NILP(varies[argnum]))
954 visargs[argnum] = list1(varies[argnum]);
957 Fquote_maybe(args[argnum]);
960 Fcons(Fcons(args[-1], Flist(argcount, visargs)),
964 /* If we used a marker to hold point, mark, or an end of the region,
965 temporarily, convert it to an integer now. */
966 for (argnum = 0; argnum < argcount; argnum++)
967 if (!NILP(varies[argnum]))
968 XSETINT(args[argnum],
969 marker_position(args[argnum]));
971 single_console_state();
972 specbind(Qcommand_debug_status, Qnil);
973 fun = Ffuncall(argcount + 1, args - 1);
975 if (set_zmacs_region_stays)
976 zmacs_region_stays = 1;
977 return unbind_to(speccount, fun);
981 DEFUN("prefix-numeric-value", Fprefix_numeric_value, 1, 1, 0, /*
982 Return numeric meaning of raw prefix argument RAW.
983 A raw prefix argument is what you get from `(interactive "P")'.
984 Its numeric meaning is what you would get from `(interactive "p")'.
994 if (CONSP(raw) && INTP(XCAR(raw)))
1000 void syms_of_callint(void)
1002 defsymbol(&Qcall_interactively, "call-interactively");
1003 defsymbol(&Qread_from_minibuffer, "read-from-minibuffer");
1004 defsymbol(&Qcompleting_read, "completing-read");
1005 defsymbol(&Qread_file_name, "read-file-name");
1006 defsymbol(&Qread_directory_name, "read-directory-name");
1007 defsymbol(&Qread_string, "read-string");
1008 defsymbol(&Qread_buffer, "read-buffer");
1009 defsymbol(&Qread_variable, "read-variable");
1010 defsymbol(&Qread_function, "read-function");
1011 defsymbol(&Qread_command, "read-command");
1012 defsymbol(&Qread_number, "read-number");
1013 defsymbol(&Qread_expression, "read-expression");
1014 #if defined(MULE) || defined(FILE_CODING)
1015 defsymbol(&Qread_coding_system, "read-coding-system");
1016 defsymbol(&Qread_non_nil_coding_system, "read-non-nil-coding-system");
1018 defsymbol(&Qevents_to_keys, "events-to-keys");
1019 defsymbol(&Qcommand_debug_status, "command-debug-status");
1020 defsymbol(&Qenable_recursive_minibuffers,
1021 "enable-recursive-minibuffers");
1023 defsymbol(&QletX, "let*");
1024 defsymbol(&Qsave_excursion, "save-excursion");
1025 #if 0 /* ill-conceived */
1026 defsymbol(&Qmouse_leave_buffer_hook, "mouse-leave-buffer-hook");
1029 DEFSUBR(Finteractive);
1030 DEFSUBR(Fquote_maybe);
1031 DEFSUBR(Fcall_interactively);
1032 DEFSUBR(Fprefix_numeric_value);
1035 void vars_of_callint(void)
1037 DEFVAR_LISP("current-prefix-arg", &Vcurrent_prefix_arg /*
1038 The value of the prefix argument for this editing command.
1039 It may be a number, or the symbol `-' for just a minus sign as arg,
1040 or a list whose car is a number for just one or more C-U's
1041 or nil if no argument has been specified.
1042 This is what `(interactive "P")' returns.
1044 Vcurrent_prefix_arg = Qnil;
1046 DEFVAR_LISP("command-history", &Vcommand_history /*
1047 List of recent commands that read arguments from terminal.
1048 Each command is represented as a form to evaluate.
1050 Vcommand_history = Qnil;
1052 DEFVAR_LISP("command-debug-status", &Vcommand_debug_status /*
1053 Debugging status of current interactive command.
1054 Bound each time `call-interactively' is called;
1055 may be set by the debugger as a reminder for itself.
1057 Vcommand_debug_status = Qnil;
1060 xxDEFVAR_LISP("mark-even-if-inactive", &Vmark_even_if_inactive /*
1061 *Non-nil means you can use the mark even when inactive.
1062 This option makes a difference in Transient Mark mode.
1063 When the option is non-nil, deactivation of the mark
1064 turns off region highlighting, but commands that use the mark
1065 behave as if the mark were still active.
1067 Vmark_even_if_inactive = Qnil;
1070 #if 0 /* Doesn't work and is totally ill-conceived anyway. */
1071 xxDEFVAR_LISP("mouse-leave-buffer-hook", &Vmouse_leave_buffer_hook /*
1072 Hook to run when about to switch windows with a mouse command.
1073 Its purpose is to give temporary modes such as Isearch mode
1074 a way to turn themselves off when a mouse command switches windows.
1076 Vmouse_leave_buffer_hook = Qnil;