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 Lisp_Compiled_Function *f = XCOMPILED_FUNCTION (fun);
298 if (! f->flags.interactivep)
300 specs = compiled_function_interactive (f);
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 = compiled_function_domain (XCOMPILED_FUNCTION (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 = Ffuncall (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 struct gcpro ngcpro1;
720 Lisp_Object key_prompt = PROMPT ();
723 tem = Fread_key_sequence (key_prompt, Qnil, Qnil);
726 visargs[argnum] = Fkey_description (tem);
727 /* The following makes `describe-key' not work with
728 extent-local keymaps and such; and anyway, it's
729 contrary to the documentation. */
730 /* args[argnum] = call1 (Qevents_to_keys, tem); */
735 case 'K': /* Key sequence (vector of events),
736 no automatic downcasing */
738 struct gcpro ngcpro1;
740 Lisp_Object key_prompt = PROMPT ();
743 tem = Fread_key_sequence (key_prompt, Qnil, Qt);
746 visargs[argnum] = Fkey_description (tem);
747 /* The following makes `describe-key' not work with
748 extent-local keymaps and such; and anyway, it's
749 contrary to the documentation. */
750 /* args[argnum] = call1 (Qevents_to_keys, tem); */
756 case 'm': /* Value of mark. Does not do I/O. */
758 args[argnum] = current_buffer->mark;
759 varies[argnum] = Qmark;
762 case 'n': /* Read number from minibuffer. */
765 args[argnum] = call2 (Qread_number, PROMPT (), Qnil);
766 /* numbers are too boring to go on command history */
767 /* arg_from_tty = 1; */
770 case 'N': /* Prefix arg, else number from minibuffer */
777 case 'P': /* Prefix arg in raw form. Does no I/O. */
779 args[argnum] = prefix;
782 case 'p': /* Prefix arg converted to number. No I/O. */
786 Lisp_Object tem = Fprefix_numeric_value (prefix);
791 case 'r': /* Region, point and mark as 2 args. */
793 Bufpos tem = check_mark ();
794 args[argnum] = (BUF_PT (current_buffer) < tem
795 ? Fcopy_marker (current_buffer->point_marker, Qt)
796 : current_buffer->mark);
797 varies[argnum] = Qregion_beginning;
798 args[++argnum] = (BUF_PT (current_buffer) > tem
799 ? Fcopy_marker (current_buffer->point_marker,
801 : current_buffer->mark);
802 varies[argnum] = Qregion_end;
805 case 's': /* String read via minibuffer. */
807 args[argnum] = call1 (Qread_string, PROMPT ());
811 case 'S': /* Any symbol. */
813 #if 0 /* Historical crock */
814 Lisp_Object tem = intern ("minibuffer-local-ns-map");
815 tem = find_symbol_value (tem);
816 if (UNBOUNDP (tem)) tem = Qnil;
817 tem = call3 (Qread_from_minibuffer, PROMPT (), Qnil,
819 args[argnum] = Fintern (tem, Qnil);
821 visargs[argnum] = Qnil;
824 Lisp_Object tem = call5 (Qcompleting_read,
829 /* nil, or prev attempt */
831 visargs[argnum] = tem;
832 /* I could use condition-case with this loser, but why bother?
833 * tem = Fread (tem); check-symbol-p;
835 tem = Fintern (tem, Qnil);
837 if (string_length (XSYMBOL (tem)->name) > 0)
838 /* Don't accept the empty-named symbol. If the loser
839 really wants this s/he can call completing-read
847 case 'v': /* Variable name: user-variable-p symbol */
849 Lisp_Object tem = call1 (Qread_variable, PROMPT ());
854 case 'x': /* Lisp expression read but not evaluated */
856 args[argnum] = call1 (Qread_expression, PROMPT ());
857 /* visargs[argnum] = Fprin1_to_string (args[argnum], Qnil); */
861 case 'X': /* Lisp expression read and evaluated */
863 Lisp_Object tem = call1 (Qread_expression, PROMPT ());
864 /* visargs[argnum] = Fprin1_to_string (tem, Qnil); */
865 args[argnum] = Feval (tem);
869 case 'Z': /* Coding-system symbol or nil if no prefix */
871 #if defined(MULE) || defined(FILE_CODING)
879 call1 (Qread_non_nil_coding_system, PROMPT ());
887 case 'z': /* Coding-system symbol */
889 #if defined(MULE) || defined(FILE_CODING)
890 args[argnum] = call1 (Qread_coding_system, PROMPT ());
898 /* We have a case for `+' so we get an error
899 if anyone tries to define one here. */
903 error ("Invalid `interactive' control letter \"%c\" (#o%03o).",
904 prompt_data[prompt_index],
905 prompt_data[prompt_index]);
909 if (NILP (visargs[argnum]))
910 visargs[argnum] = args[argnum];
915 prompt_data = (CONST char *) XSTRING_DATA (specs);
916 prompt_index += prompt_length + 1 + 1; /* +1 to skip spec, +1 for \n */
918 unbind_to (speccount, Qnil);
922 if (EQ (record_flag, Qlambda))
924 RETURN_UNGCPRO (Flist (argcount, args));
927 if (arg_from_tty || !NILP (record_flag))
929 /* Reuse visargs as a temporary for constructing the command history */
930 for (argnum = 0; argnum < argcount; argnum++)
932 if (!NILP (varies[argnum]))
933 visargs[argnum] = list1 (varies[argnum]);
935 visargs[argnum] = Fquote_maybe (args[argnum]);
937 Vcommand_history = Fcons (Fcons (args[-1], Flist (argcount, visargs)),
941 /* If we used a marker to hold point, mark, or an end of the region,
942 temporarily, convert it to an integer now. */
943 for (argnum = 0; argnum < argcount; argnum++)
944 if (!NILP (varies[argnum]))
945 XSETINT (args[argnum], marker_position (args[argnum]));
947 single_console_state ();
948 specbind (Qcommand_debug_status, Qnil);
949 fun = Ffuncall (argcount + 1, args - 1);
951 if (set_zmacs_region_stays)
952 zmacs_region_stays = 1;
953 return unbind_to (speccount, fun);
957 DEFUN ("prefix-numeric-value", Fprefix_numeric_value, 1, 1, 0, /*
958 Return numeric meaning of raw prefix argument ARG.
959 A raw prefix argument is what you get from `(interactive "P")'.
960 Its numeric meaning is what you would get from `(interactive "p")'.
966 if (EQ (raw, Qminus))
967 return make_int (-1);
970 if (CONSP (raw) && INTP (XCAR (raw)))
977 syms_of_callint (void)
979 defsymbol (&Qcall_interactively, "call-interactively");
980 defsymbol (&Qread_from_minibuffer, "read-from-minibuffer");
981 defsymbol (&Qcompleting_read, "completing-read");
982 defsymbol (&Qread_file_name, "read-file-name");
983 defsymbol (&Qread_directory_name, "read-directory-name");
984 defsymbol (&Qread_string, "read-string");
985 defsymbol (&Qread_buffer, "read-buffer");
986 defsymbol (&Qread_variable, "read-variable");
987 defsymbol (&Qread_function, "read-function");
988 defsymbol (&Qread_command, "read-command");
989 defsymbol (&Qread_number, "read-number");
990 defsymbol (&Qread_expression, "read-expression");
991 #if defined(MULE) || defined(FILE_CODING)
992 defsymbol (&Qread_coding_system, "read-coding-system");
993 defsymbol (&Qread_non_nil_coding_system, "read-non-nil-coding-system");
995 defsymbol (&Qevents_to_keys, "events-to-keys");
996 defsymbol (&Qcommand_debug_status, "command-debug-status");
997 defsymbol (&Qenable_recursive_minibuffers, "enable-recursive-minibuffers");
998 defsymbol (&Quser_variable_p, "user-variable-p");
999 defsymbol (&Qcurrent_prefix_arg, "current-prefix-arg");
1001 defsymbol (&Qlet, "let");
1002 defsymbol (&QletX, "let*");
1003 defsymbol (&Qsave_excursion, "save-excursion");
1004 #if 0 /* ill-conceived */
1005 defsymbol (&Qmouse_leave_buffer_hook, "mouse-leave-buffer-hook");
1008 DEFSUBR (Finteractive);
1009 DEFSUBR (Fquote_maybe);
1010 DEFSUBR (Fcall_interactively);
1011 DEFSUBR (Fprefix_numeric_value);
1015 vars_of_callint (void)
1017 DEFVAR_LISP ("current-prefix-arg", &Vcurrent_prefix_arg /*
1018 The value of the prefix argument for this editing command.
1019 It may be a number, or the symbol `-' for just a minus sign as arg,
1020 or a list whose car is a number for just one or more C-U's
1021 or nil if no argument has been specified.
1022 This is what `(interactive "P")' returns.
1024 Vcurrent_prefix_arg = Qnil;
1026 DEFVAR_LISP ("command-history", &Vcommand_history /*
1027 List of recent commands that read arguments from terminal.
1028 Each command is represented as a form to evaluate.
1030 Vcommand_history = Qnil;
1032 DEFVAR_LISP ("command-debug-status", &Vcommand_debug_status /*
1033 Debugging status of current interactive command.
1034 Bound each time `call-interactively' is called;
1035 may be set by the debugger as a reminder for itself.
1037 Vcommand_debug_status = Qnil;
1040 xxDEFVAR_LISP ("mark-even-if-inactive", &Vmark_even_if_inactive /*
1041 *Non-nil means you can use the mark even when inactive.
1042 This option makes a difference in Transient Mark mode.
1043 When the option is non-nil, deactivation of the mark
1044 turns off region highlighting, but commands that use the mark
1045 behave as if the mark were still active.
1047 Vmark_even_if_inactive = Qnil;
1050 #if 0 /* Doesn't work and is totally ill-conceived anyway. */
1051 xxDEFVAR_LISP ("mouse-leave-buffer-hook", &Vmouse_leave_buffer_hook /*
1052 Hook to run when about to switch windows with a mouse command.
1053 Its purpose is to give temporary modes such as Isearch mode
1054 a way to turn themselves off when a mouse command switches windows.
1056 Vmouse_leave_buffer_hook = Qnil;