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 XEmacs.
7 XEmacs is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 XEmacs is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with XEmacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Synched up with: FSF 19.30, Mule 2.0. */
27 Mly or JWZ: various changes.
40 extern int 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 Lisp_Object Vmouse_leave_buffer_hook, Qmouse_leave_buffer_hook;
59 Lisp_Object Qlet, QletX, Qsave_excursion;
61 Lisp_Object Qcurrent_prefix_arg;
63 Lisp_Object Quser_variable_p;
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.
164 || BIT_VECTORP (expr)
165 || (CONSP (expr) && EQ (XCAR (expr), Qlambda)))
166 ? expr : list2 (Qquote, expr));
169 /* Modify EXPR by quotifying each element (except the first). */
171 quotify_args (Lisp_Object expr)
173 REGISTER Lisp_Object tail;
174 REGISTER struct Lisp_Cons *ptr;
175 for (tail = expr; CONSP (tail); tail = ptr->cdr)
178 ptr->car = Fquote_maybe (ptr->car);
188 if (zmacs_regions && !zmacs_region_active_p)
189 error ("The region is not active now");
191 tem = Fmarker_buffer (current_buffer->mark);
192 if (NILP (tem) || (XBUFFER (tem) != current_buffer))
193 error ("The mark is not set now");
195 return marker_position (current_buffer->mark);
199 callint_prompt (CONST Bufbyte *prompt_start, Bytecount prompt_length,
200 CONST Lisp_Object *args, int nargs)
202 Lisp_Object s = make_string (prompt_start, prompt_length);
205 /* Fformat no longer smashes its arg vector, so no need to copy it. */
207 if (!strchr ((char *) XSTRING_DATA (s), '%'))
210 RETURN_UNGCPRO (emacs_doprnt_string_lisp (0, s, 0, nargs, args));
213 /* `lambda' for RECORD-FLAG is an XEmacs addition. */
215 DEFUN ("call-interactively", Fcall_interactively, 1, 3, 0, /*
216 Call FUNCTION, reading args according to its interactive calling specs.
217 Return the value FUNCTION returns.
218 The function contains a specification of how to do the argument reading.
219 In the case of user-defined functions, this is specified by placing a call
220 to the function `interactive' at the top level of the function body.
223 If optional second arg RECORD-FLAG is the symbol `lambda', the interactive
224 calling arguments for FUNCTION are read and returned as a list,
225 but the function is not called on them.
227 If RECORD-FLAG is `t' then unconditionally put this command in the
228 command-history. Otherwise, this is done only if an arg is read using
231 The argument KEYS specifies the value to use instead of (this-command-keys)
232 when reading the arguments.
234 (function, record_flag, keys))
236 /* This function can GC */
237 int speccount = specpdl_depth ();
241 Lisp_Object specs = Qnil;
242 #ifdef IT_SEEMS_THAT_MLY_DOESNT_LIKE_THIS
245 /* If SPECS is a string, we reset prompt_data to string_data
246 * (XSTRING (specs)) every time a GC might have occurred */
247 CONST char *prompt_data = 0;
248 int prompt_index = 0;
250 int set_zmacs_region_stays = 0;
251 int mouse_event_count = 0;
258 len = XVECTOR_LENGTH (keys);
259 for (i = 0; i < len; i++)
260 CHECK_LIVE_EVENT (XVECTOR_DATA (keys)[i]);
263 /* Save this now, since use of minibuffer will clobber it. */
264 prefix = Vcurrent_prefix_arg;
268 #ifdef IT_SEEMS_THAT_MLY_DOESNT_LIKE_THIS
269 /* Marginal kludge. Use an evaluated interactive spec instead of this! */
270 if (SYMBOLP (function))
271 enable = Fget (function, Qenable_recursive_minibuffers, Qnil);
274 fun = indirect_function (function, 1);
276 /* Decode the kind of function. Either handle it and return,
277 or go to `lose' if not interactive, or go to `retry'
278 to specify a different function, or set either PROMPT_DATA or SPECS. */
282 prompt_data = XSUBR (fun)->prompt;
286 function = wrong_type_argument (Qcommandp, function);
289 #if 0 /* FSFmacs */ /* Huh? Where is this used? */
290 if ((EMACS_INT) prompt_data == 1)
291 /* Let SPECS (which is nil) be used as the args. */
295 else if (COMPILED_FUNCTIONP (fun))
297 struct Lisp_Compiled_Function *b = XCOMPILED_FUNCTION (fun);
298 if (!(b->flags.interactivep))
300 specs = compiled_function_interactive (b);
302 else if (!CONSP (fun))
306 Lisp_Object funcar = Fcar (fun);
308 if (EQ (funcar, Qautoload))
310 struct gcpro gcpro1, gcpro2;
311 GCPRO2 (function, prefix);
312 do_autoload (fun, function);
316 else if (EQ (funcar, Qlambda))
318 specs = Fassq (Qinteractive, Fcdr (Fcdr (fun)));
321 specs = Fcar (Fcdr (specs));
327 /* FSFmacs makes an alloca() copy of prompt_data here.
328 We're more intelligent about this and just reset prompt_data
330 /* If either specs or prompt_data is set to a string, use it. */
331 if (!STRINGP (specs) && prompt_data == 0)
333 struct gcpro gcpro1, gcpro2, gcpro3;
334 int i = num_input_chars;
335 Lisp_Object input = specs;
337 GCPRO3 (function, specs, input);
338 /* Compute the arg values using the user's expression. */
339 specs = Feval (specs);
340 if (EQ (record_flag, Qlambda)) /* XEmacs addition */
345 if (!NILP (record_flag) || i != num_input_chars)
347 /* We should record this command on the command history. */
348 /* #### The following is too specific; should have general
349 mechanism for doing this. */
350 Lisp_Object values, car;
351 /* Make a copy of the list of values, for the command history,
352 and turn them into things we can eval. */
353 values = quotify_args (Fcopy_sequence (specs));
354 /* If the list of args was produced with an explicit call to `list',
355 look for elements that were computed with (region-beginning)
356 or (region-end), and put those expressions into VALUES
357 instead of the present values. */
361 /* Skip through certain special forms. */
362 while (EQ (car, Qlet) || EQ (car, QletX)
363 || EQ (car, Qsave_excursion))
365 while (CONSP (XCDR (input)))
366 input = XCDR (input);
367 input = XCAR (input);
374 Lisp_Object intail, valtail;
375 for (intail = Fcdr (input), valtail = values;
377 intail = Fcdr (intail), valtail = Fcdr (valtail))
383 Lisp_Object eltcar = Fcar (elt);
384 if (EQ (eltcar, Qpoint) ||
385 EQ (eltcar, Qmark) ||
386 EQ (eltcar, Qregion_beginning) ||
387 EQ (eltcar, Qregion_end))
388 Fsetcar (valtail, Fcar (intail));
394 = Fcons (Fcons (function, values), Vcommand_history);
396 single_console_state ();
397 RETURN_UNGCPRO (apply1 (fun, specs));
400 /* Here if function specifies a string to control parsing the defaults */
403 /* Translate interactive prompt. */
406 Lisp_Object domain = Qnil;
407 if (COMPILED_FUNCTIONP (fun))
408 domain = Fcompiled_function_domain (fun);
410 specs = Fgettext (specs);
412 specs = Fdgettext (domain, specs);
414 else if (prompt_data)
415 /* We do not have to worry about domains in this case because
416 prompt_data is non-nil only for built-in functions, which
417 always use the default domain. */
418 prompt_data = gettext (prompt_data);
421 /* Handle special starting chars `*' and `@' and `_'. */
422 /* Note that `+' is reserved for user extensions. */
425 struct gcpro gcpro1, gcpro2;
426 GCPRO2 (function, specs);
431 prompt_data = (CONST char *) XSTRING_DATA (specs);
433 if (prompt_data[prompt_index] == '+')
434 error ("`+' is not used in `interactive' for ordinary commands");
435 else if (prompt_data[prompt_index] == '*')
438 if (!NILP (current_buffer->read_only))
439 barf_if_buffer_read_only (current_buffer, -1, -1);
441 else if (prompt_data[prompt_index] == '@')
447 event = extract_vector_nth_mouse_event (keys, 0);
450 event = extract_this_command_keys_nth_mouse_event (0);
452 /* Doesn't work; see below */
453 event = Vcurrent_mouse_event;
457 Lisp_Object window = Fevent_window (event);
460 if (MINI_WINDOW_P (XWINDOW (window))
461 && ! (minibuf_level > 0 && EQ (window,
463 error ("Attempt to select inactive minibuffer window");
465 #if 0 /* unclean! see event-stream.c */
466 /* If the current buffer wants to clean up, let it. */
467 if (!NILP (Vmouse_leave_buffer_hook))
468 run_hook (Qmouse_leave_buffer_hook);
471 Fselect_window (window, Qnil);
475 else if (prompt_data[prompt_index] == '_')
478 set_zmacs_region_stays = 1;
488 /* Count the number of arguments the interactive spec would have
489 us give to the function. */
493 for (tem = prompt_data + prompt_index; *tem; )
495 /* 'r' specifications ("point and mark as 2 numeric args")
496 produce *two* arguments. */
501 tem = (CONST char *) strchr (tem + 1, '\n');
508 #ifdef IT_SEEMS_THAT_MLY_DOESNT_LIKE_THIS
510 specbind (Qenable_recursive_minibuffers, Qt);
515 /* Interactive function or no arguments; just call it */
516 if (EQ (record_flag, Qlambda))
518 if (!NILP (record_flag))
520 Vcommand_history = Fcons (list1 (function), Vcommand_history);
522 specbind (Qcommand_debug_status, Qnil);
523 /* XEmacs: was fun = call0 (fun), but that's backtraced wrong */
528 fun = funcall_recording_as (function, 1, &fun);
531 if (set_zmacs_region_stays)
532 zmacs_region_stays = 1;
533 return unbind_to (speccount, fun);
536 /* Read interactive arguments */
538 /* args[-1] is the function to call */
539 /* args[n] is the n'th argument to the function */
540 int alloca_size = (1 /* function to call */
541 + argcount /* actual arguments */
542 + argcount /* visargs */
543 + argcount /* varies */
545 Lisp_Object *args = alloca_array (Lisp_Object, alloca_size) + 1;
546 /* visargs is an array of either Qnil or user-friendlier versions (often
547 * strings) of previous arguments, to use in prompts for successive
548 * arguments. ("Often strings" because emacs didn't used to have
549 * format %S and prin1-to-string.) */
550 Lisp_Object *visargs = args + argcount;
551 /* If varies[i] is non-null, the i'th argument shouldn't just have
552 its value in this call quoted in the command history. It should be
553 recorded as a call to the function named varies[i]]. */
554 Lisp_Object *varies = visargs + argcount;
555 int arg_from_tty = 0;
557 struct gcpro gcpro1, gcpro2;
560 for (argnum = 0; argnum < alloca_size - 1; argnum++)
563 /* Must GC-protect args[-1] (ie function) because Ffuncall doesn't */
564 /* `function' itself isn't GC-protected -- use args[-1] from here
565 (actually, doesn't matter since Emacs GC doesn't relocate, sigh) */
566 GCPRO2 (prefix, args[-1]);
567 gcpro2.nvars = alloca_size;
569 for (argnum = 0; ; argnum++)
571 CONST char *prompt_start = prompt_data + prompt_index + 1;
572 CONST char *prompt_limit = (CONST char *) strchr (prompt_start, '\n');
574 prompt_length = ((prompt_limit)
575 ? (prompt_limit - prompt_start)
576 : strlen (prompt_start));
577 if (prompt_limit && prompt_limit[1] == 0)
579 prompt_limit = 0; /* "sfoo:\n" -- strip tailing return */
582 /* This uses `visargs' instead of `args' so that global-set-key
583 prompts with "Set key C-x C-f to command: "instead of printing
584 event objects in there.
586 #define PROMPT() callint_prompt ((CONST Bufbyte *) prompt_start, prompt_length, visargs, argnum)
587 switch (prompt_data[prompt_index])
589 case 'a': /* Symbol defined as a function */
591 Lisp_Object tem = call1 (Qread_function, PROMPT ());
596 case 'b': /* Name of existing buffer */
598 Lisp_Object def = Fcurrent_buffer ();
599 if (EQ (Fselected_window (Qnil), minibuf_window))
600 def = Fother_buffer (def, Qnil, Qnil);
601 /* read-buffer returns a buffer name, not a buffer! */
602 args[argnum] = call3 (Qread_buffer, PROMPT (), def,
607 case 'B': /* Name of buffer, possibly nonexistent */
609 /* read-buffer returns a buffer name, not a buffer! */
610 args[argnum] = call2 (Qread_buffer, PROMPT (),
611 Fother_buffer (Fcurrent_buffer (), Qnil,
616 case 'c': /* Character */
619 int shadowing_speccount = specpdl_depth ();
621 specbind (Qcursor_in_echo_area, Qt);
622 message ("%s", XSTRING_DATA (PROMPT ()));
623 tem = (call0 (Qread_char));
625 /* visargs[argnum] = Fsingle_key_description (tem); */
626 /* FSF has visargs[argnum] = Fchar_to_string (tem); */
628 unbind_to (shadowing_speccount, Qnil);
630 /* #### `C-x / a' should not leave the prompt in the minibuffer.
631 This isn't the right fix, because (message ...) (read-char)
632 shouldn't leave the message there either... */
638 case 'C': /* Command: symbol with interactive function */
640 Lisp_Object tem = call1 (Qread_command, PROMPT ());
645 case 'd': /* Value of point. Does not do I/O. */
647 args[argnum] = Fcopy_marker (current_buffer->point_marker, Qt);
648 varies[argnum] = Qpoint;
656 event = extract_vector_nth_mouse_event (keys,
660 /* This doesn't quite work because this-command-keys
661 behaves in utterly counterintuitive ways. Sometimes
662 it retrieves an event back in the future, e.g. when
663 one command invokes another command and both are
664 invoked with the mouse. */
665 event = (extract_this_command_keys_nth_mouse_event
666 (mouse_event_count));
668 event = Vcurrent_mouse_event;
672 error ("%s must be bound to a mouse or misc-user event",
674 ? (char *) string_data (XSYMBOL (function)->name)
676 args[argnum] = event;
680 case 'D': /* Directory name. */
682 args[argnum] = call4 (Qread_directory_name, PROMPT (),
684 current_buffer->directory, /* default */
690 case 'f': /* Existing file name. */
692 Lisp_Object tem = call4 (Qread_file_name, PROMPT (),
695 Qzero /* must-match */
701 case 'F': /* Possibly nonexistent file name. */
703 args[argnum] = call4 (Qread_file_name, PROMPT (),
706 Qnil /* must-match */
711 case 'i': /* Ignore: always nil. Use to skip arguments. */
716 case 'k': /* Key sequence (vector of events) */
718 Lisp_Object tem = Fread_key_sequence (PROMPT (), Qnil, Qnil);
719 visargs[argnum] = Fkey_description (tem);
720 /* The following makes `describe-key' not work with
721 extent-local keymaps and such; and anyway, it's
722 contrary to the documentation. */
723 /* args[argnum] = call1 (Qevents_to_keys, tem); */
728 case 'K': /* Key sequence (vector of events),
729 no automatic downcasing */
731 Lisp_Object tem = Fread_key_sequence (PROMPT (), Qnil, Qt);
732 visargs[argnum] = Fkey_description (tem);
733 /* The following makes `describe-key' not work with
734 extent-local keymaps and such; and anyway, it's
735 contrary to the documentation. */
736 /* args[argnum] = call1 (Qevents_to_keys, tem); */
742 case 'm': /* Value of mark. Does not do I/O. */
744 args[argnum] = current_buffer->mark;
745 varies[argnum] = Qmark;
748 case 'n': /* Read number from minibuffer. */
751 args[argnum] = call2 (Qread_number, PROMPT (), Qnil);
752 /* numbers are too boring to go on command history */
753 /* arg_from_tty = 1; */
756 case 'N': /* Prefix arg, else number from minibuffer */
763 case 'P': /* Prefix arg in raw form. Does no I/O. */
765 args[argnum] = prefix;
768 case 'p': /* Prefix arg converted to number. No I/O. */
772 Lisp_Object tem = Fprefix_numeric_value (prefix);
777 case 'r': /* Region, point and mark as 2 args. */
779 Bufpos tem = check_mark ();
780 args[argnum] = (BUF_PT (current_buffer) < tem
781 ? Fcopy_marker (current_buffer->point_marker, Qt)
782 : current_buffer->mark);
783 varies[argnum] = Qregion_beginning;
784 args[++argnum] = (BUF_PT (current_buffer) > tem
785 ? Fcopy_marker (current_buffer->point_marker,
787 : current_buffer->mark);
788 varies[argnum] = Qregion_end;
791 case 's': /* String read via minibuffer. */
793 args[argnum] = call1 (Qread_string, PROMPT ());
797 case 'S': /* Any symbol. */
799 #if 0 /* Historical crock */
800 Lisp_Object tem = intern ("minibuffer-local-ns-map");
801 tem = find_symbol_value (tem);
802 if (UNBOUNDP (tem)) tem = Qnil;
803 tem = call3 (Qread_from_minibuffer, PROMPT (), Qnil,
805 args[argnum] = Fintern (tem, Qnil);
807 visargs[argnum] = Qnil;
810 Lisp_Object tem = call5 (Qcompleting_read,
815 /* nil, or prev attempt */
817 visargs[argnum] = tem;
818 /* I could use condition-case with this loser, but why bother?
819 * tem = Fread (tem); check-symbol-p;
821 tem = Fintern (tem, Qnil);
823 if (string_length (XSYMBOL (tem)->name) > 0)
824 /* Don't accept the empty-named symbol. If the loser
825 really wants this s/he can call completing-read
833 case 'v': /* Variable name: user-variable-p symbol */
835 Lisp_Object tem = call1 (Qread_variable, PROMPT ());
840 case 'x': /* Lisp expression read but not evaluated */
842 args[argnum] = call1 (Qread_expression, PROMPT ());
843 /* visargs[argnum] = Fprin1_to_string (args[argnum], Qnil); */
847 case 'X': /* Lisp expression read and evaluated */
849 Lisp_Object tem = call1 (Qread_expression, PROMPT ());
850 /* visargs[argnum] = Fprin1_to_string (tem, Qnil); */
851 args[argnum] = Feval (tem);
855 case 'Z': /* Coding-system symbol or nil if no prefix */
857 #if defined(MULE) || defined(FILE_CODING)
865 call1 (Qread_non_nil_coding_system, PROMPT ());
873 case 'z': /* Coding-system symbol */
875 #if defined(MULE) || defined(FILE_CODING)
876 args[argnum] = call1 (Qread_coding_system, PROMPT ());
884 /* We have a case for `+' so we get an error
885 if anyone tries to define one here. */
889 error ("Invalid `interactive' control letter \"%c\" (#o%03o).",
890 prompt_data[prompt_index],
891 prompt_data[prompt_index]);
895 if (NILP (visargs[argnum]))
896 visargs[argnum] = args[argnum];
901 prompt_data = (CONST char *) XSTRING_DATA (specs);
902 prompt_index += prompt_length + 1 + 1; /* +1 to skip spec, +1 for \n */
904 unbind_to (speccount, Qnil);
908 if (EQ (record_flag, Qlambda))
910 RETURN_UNGCPRO (Flist (argcount, args));
913 if (arg_from_tty || !NILP (record_flag))
915 /* Reuse visargs as a temporary for constructing the command history */
916 for (argnum = 0; argnum < argcount; argnum++)
918 if (!NILP (varies[argnum]))
919 visargs[argnum] = list1 (varies[argnum]);
921 visargs[argnum] = Fquote_maybe (args[argnum]);
923 Vcommand_history = Fcons (Fcons (args[-1], Flist (argcount, visargs)),
927 /* If we used a marker to hold point, mark, or an end of the region,
928 temporarily, convert it to an integer now. */
929 for (argnum = 0; argnum < argcount; argnum++)
930 if (!NILP (varies[argnum]))
931 XSETINT (args[argnum], marker_position (args[argnum]));
933 single_console_state ();
934 specbind (Qcommand_debug_status, Qnil);
935 fun = Ffuncall (argcount + 1, args - 1);
937 if (set_zmacs_region_stays)
938 zmacs_region_stays = 1;
939 return unbind_to (speccount, fun);
943 DEFUN ("prefix-numeric-value", Fprefix_numeric_value, 1, 1, 0, /*
944 Return numeric meaning of raw prefix argument ARG.
945 A raw prefix argument is what you get from `(interactive "P")'.
946 Its numeric meaning is what you would get from `(interactive "p")'.
952 if (EQ (raw, Qminus))
953 return make_int (-1);
956 if (CONSP (raw) && INTP (XCAR (raw)))
963 syms_of_callint (void)
965 defsymbol (&Qcall_interactively, "call-interactively");
966 defsymbol (&Qread_from_minibuffer, "read-from-minibuffer");
967 defsymbol (&Qcompleting_read, "completing-read");
968 defsymbol (&Qread_file_name, "read-file-name");
969 defsymbol (&Qread_directory_name, "read-directory-name");
970 defsymbol (&Qread_string, "read-string");
971 defsymbol (&Qread_buffer, "read-buffer");
972 defsymbol (&Qread_variable, "read-variable");
973 defsymbol (&Qread_function, "read-function");
974 defsymbol (&Qread_command, "read-command");
975 defsymbol (&Qread_number, "read-number");
976 defsymbol (&Qread_expression, "read-expression");
977 #if defined(MULE) || defined(FILE_CODING)
978 defsymbol (&Qread_coding_system, "read-coding-system");
979 defsymbol (&Qread_non_nil_coding_system, "read-non-nil-coding-system");
981 defsymbol (&Qevents_to_keys, "events-to-keys");
982 defsymbol (&Qcommand_debug_status, "command-debug-status");
983 defsymbol (&Qenable_recursive_minibuffers, "enable-recursive-minibuffers");
984 defsymbol (&Quser_variable_p, "user-variable-p");
985 defsymbol (&Qcurrent_prefix_arg, "current-prefix-arg");
987 defsymbol (&Qlet, "let");
988 defsymbol (&QletX, "let*");
989 defsymbol (&Qsave_excursion, "save-excursion");
990 #if 0 /* ill-conceived */
991 defsymbol (&Qmouse_leave_buffer_hook, "mouse-leave-buffer-hook");
994 DEFSUBR (Finteractive);
995 DEFSUBR (Fquote_maybe);
996 DEFSUBR (Fcall_interactively);
997 DEFSUBR (Fprefix_numeric_value);
1001 vars_of_callint (void)
1003 DEFVAR_LISP ("current-prefix-arg", &Vcurrent_prefix_arg /*
1004 The value of the prefix argument for this editing command.
1005 It may be a number, or the symbol `-' for just a minus sign as arg,
1006 or a list whose car is a number for just one or more C-U's
1007 or nil if no argument has been specified.
1008 This is what `(interactive "P")' returns.
1010 Vcurrent_prefix_arg = Qnil;
1012 DEFVAR_LISP ("command-history", &Vcommand_history /*
1013 List of recent commands that read arguments from terminal.
1014 Each command is represented as a form to evaluate.
1016 Vcommand_history = Qnil;
1018 DEFVAR_LISP ("command-debug-status", &Vcommand_debug_status /*
1019 Debugging status of current interactive command.
1020 Bound each time `call-interactively' is called;
1021 may be set by the debugger as a reminder for itself.
1023 Vcommand_debug_status = Qnil;
1026 xxDEFVAR_LISP ("mark-even-if-inactive", &Vmark_even_if_inactive /*
1027 *Non-nil means you can use the mark even when inactive.
1028 This option makes a difference in Transient Mark mode.
1029 When the option is non-nil, deactivation of the mark
1030 turns off region highlighting, but commands that use the mark
1031 behave as if the mark were still active.
1033 Vmark_even_if_inactive = Qnil;
1036 #if 0 /* Doesn't work and is totally ill-conceived anyway. */
1037 xxDEFVAR_LISP ("mouse-leave-buffer-hook", &Vmouse_leave_buffer_hook /*
1038 Hook to run when about to switch windows with a mouse command.
1039 Its purpose is to give temporary modes such as Isearch mode
1040 a way to turn themselves off when a mouse command switches windows.
1042 Vmouse_leave_buffer_hook = Qnil;