* ediff.texi (Session Commands): Fix typo.
[emacs.git] / src / callint.c
blob3641fbc5b779057f86fd991554763d602e465710
1 /* Call a Lisp function interactively.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1997, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
22 #include <config.h>
24 #include "lisp.h"
25 #include "buffer.h"
26 #include "commands.h"
27 #include "keyboard.h"
28 #include "window.h"
29 #include "keymap.h"
31 #ifdef HAVE_INDEX
32 extern char *index P_ ((const char *, int));
33 #endif
35 extern Lisp_Object Qcursor_in_echo_area;
36 extern Lisp_Object Qfile_directory_p;
37 extern Lisp_Object Qonly;
39 Lisp_Object Vcurrent_prefix_arg, Qminus, Qplus;
40 Lisp_Object Qcall_interactively;
41 Lisp_Object Vcommand_history;
43 extern Lisp_Object Vhistory_length;
44 extern Lisp_Object Vthis_original_command, real_this_command;
46 Lisp_Object Vcommand_debug_status, Qcommand_debug_status;
47 Lisp_Object Qenable_recursive_minibuffers;
48 extern Lisp_Object Qface, Qminibuffer_prompt;
50 /* Non-nil means treat the mark as active
51 even if mark_active is 0. */
52 Lisp_Object Vmark_even_if_inactive;
54 Lisp_Object Qhandle_shift_selection;
56 Lisp_Object Vmouse_leave_buffer_hook, Qmouse_leave_buffer_hook;
58 Lisp_Object Qlist, Qlet, Qletx, Qsave_excursion, Qprogn, Qif, Qwhen;
59 static Lisp_Object preserved_fns;
61 /* Marker used within call-interactively to refer to point. */
62 static Lisp_Object point_marker;
64 /* String for the prompt text used in Fcall_interactively. */
65 static Lisp_Object callint_message;
67 /* ARGSUSED */
68 DEFUN ("interactive", Finteractive, Sinteractive, 0, UNEVALLED, 0,
69 doc: /* Specify a way of parsing arguments for interactive use of a function.
70 For example, write
71 (defun foo (arg buf) "Doc string" (interactive "P\\nbbuffer: ") .... )
72 to make ARG be the raw prefix argument, and set BUF to an existing buffer,
73 when `foo' is called as a command.
74 The "call" to `interactive' is actually a declaration rather than a function;
75 it tells `call-interactively' how to read arguments
76 to pass to the function.
77 When actually called, `interactive' just returns nil.
79 Usually the argument of `interactive' is a string containing a code letter
80 followed optionally by a prompt. (Some code letters do not use I/O to get
81 the argument and do not use prompts.) To get several arguments, concatenate
82 the individual strings, separating them by newline characters.
83 Prompts are passed to format, and may use % escapes to print the
84 arguments that have already been read.
85 If the argument is not a string, it is evaluated to get a list of
86 arguments to pass to the function.
87 Just `(interactive)' means pass no args when calling interactively.
89 Code letters available are:
90 a -- Function name: symbol with a function definition.
91 b -- Name of existing buffer.
92 B -- Name of buffer, possibly nonexistent.
93 c -- Character (no input method is used).
94 C -- Command name: symbol with interactive function definition.
95 d -- Value of point as number. Does not do I/O.
96 D -- Directory name.
97 e -- Parametrized event (i.e., one that's a list) that invoked this command.
98 If used more than once, the Nth `e' returns the Nth parameterized event.
99 This skips events that are integers or symbols.
100 f -- Existing file name.
101 F -- Possibly nonexistent file name.
102 G -- Possibly nonexistent file name, defaulting to just directory name.
103 i -- Ignored, i.e. always nil. Does not do I/O.
104 k -- Key sequence (downcase the last event if needed to get a definition).
105 K -- Key sequence to be redefined (do not downcase the last event).
106 m -- Value of mark as number. Does not do I/O.
107 M -- Any string. Inherits the current input method.
108 n -- Number read using minibuffer.
109 N -- Numeric prefix arg, or if none, do like code `n'.
110 p -- Prefix arg converted to number. Does not do I/O.
111 P -- Prefix arg in raw form. Does not do I/O.
112 r -- Region: point and mark as 2 numeric args, smallest first. Does no I/O.
113 s -- Any string. Does not inherit the current input method.
114 S -- Any symbol.
115 U -- Mouse up event discarded by a previous k or K argument.
116 v -- Variable name: symbol that is user-variable-p.
117 x -- Lisp expression read but not evaluated.
118 X -- Lisp expression read and evaluated.
119 z -- Coding system.
120 Z -- Coding system, nil if no prefix arg.
122 In addition, if the string begins with `*', an error is signaled if
123 the buffer is read-only.
124 If the string begins with `@', Emacs searches the key sequence which
125 invoked the command for its first mouse click (or any other event
126 which specifies a window).
127 If the string begins with `^' and `shift-select-mode' is non-nil,
128 Emacs first calls the function `handle-shift-select'.
129 You may use `@', `*', and `^' together. They are processed in the
130 order that they appear, before reading any arguments.
131 usage: (interactive &optional ARGS) */)
132 (args)
133 Lisp_Object args;
135 return Qnil;
138 /* Quotify EXP: if EXP is constant, return it.
139 If EXP is not constant, return (quote EXP). */
140 Lisp_Object
141 quotify_arg (exp)
142 register Lisp_Object exp;
144 if (!INTEGERP (exp) && !STRINGP (exp)
145 && !NILP (exp) && !EQ (exp, Qt))
146 return Fcons (Qquote, Fcons (exp, Qnil));
148 return exp;
151 /* Modify EXP by quotifying each element (except the first). */
152 Lisp_Object
153 quotify_args (exp)
154 Lisp_Object exp;
156 register Lisp_Object tail;
157 Lisp_Object next;
158 for (tail = exp; CONSP (tail); tail = next)
160 next = XCDR (tail);
161 XSETCAR (tail, quotify_arg (XCAR (tail)));
163 return exp;
166 char *callint_argfuns[]
167 = {"", "point", "mark", "region-beginning", "region-end"};
169 static void
170 check_mark (for_region)
171 int for_region;
173 Lisp_Object tem;
174 tem = Fmarker_buffer (current_buffer->mark);
175 if (NILP (tem) || (XBUFFER (tem) != current_buffer))
176 error (for_region ? "The mark is not set now, so there is no region"
177 : "The mark is not set now");
178 if (!NILP (Vtransient_mark_mode) && NILP (Vmark_even_if_inactive)
179 && NILP (current_buffer->mark_active))
180 xsignal0 (Qmark_inactive);
183 /* If the list of args INPUT was produced with an explicit call to
184 `list', look for elements that were computed with
185 (region-beginning) or (region-end), and put those expressions into
186 VALUES instead of the present values.
188 This function doesn't return a value because it modifies elements
189 of VALUES to do its job. */
191 static void
192 fix_command (input, values)
193 Lisp_Object input, values;
195 if (CONSP (input))
197 Lisp_Object car;
199 car = XCAR (input);
200 /* Skip through certain special forms. */
201 while (EQ (car, Qlet) || EQ (car, Qletx)
202 || EQ (car, Qsave_excursion)
203 || EQ (car, Qprogn))
205 while (CONSP (XCDR (input)))
206 input = XCDR (input);
207 input = XCAR (input);
208 if (!CONSP (input))
209 break;
210 car = XCAR (input);
212 if (EQ (car, Qlist))
214 Lisp_Object intail, valtail;
215 for (intail = Fcdr (input), valtail = values;
216 CONSP (valtail);
217 intail = Fcdr (intail), valtail = XCDR (valtail))
219 Lisp_Object elt;
220 elt = Fcar (intail);
221 if (CONSP (elt))
223 Lisp_Object presflag, carelt;
224 carelt = Fcar (elt);
225 /* If it is (if X Y), look at Y. */
226 if (EQ (carelt, Qif)
227 && EQ (Fnthcdr (make_number (3), elt), Qnil))
228 elt = Fnth (make_number (2), elt);
229 /* If it is (when ... Y), look at Y. */
230 else if (EQ (carelt, Qwhen))
232 while (CONSP (XCDR (elt)))
233 elt = XCDR (elt);
234 elt = Fcar (elt);
237 /* If the function call we're looking at
238 is a special preserved one, copy the
239 whole expression for this argument. */
240 if (CONSP (elt))
242 presflag = Fmemq (Fcar (elt), preserved_fns);
243 if (!NILP (presflag))
244 Fsetcar (valtail, Fcar (intail));
252 DEFUN ("call-interactively", Fcall_interactively, Scall_interactively, 1, 3, 0,
253 doc: /* Call FUNCTION, reading args according to its interactive calling specs.
254 Return the value FUNCTION returns.
255 The function contains a specification of how to do the argument reading.
256 In the case of user-defined functions, this is specified by placing a call
257 to the function `interactive' at the top level of the function body.
258 See `interactive'.
260 Optional second arg RECORD-FLAG non-nil
261 means unconditionally put this command in the command-history.
262 Otherwise, this is done only if an arg is read using the minibuffer.
264 Optional third arg KEYS, if given, specifies the sequence of events to
265 supply, as a vector, if the command inquires which events were used to
266 invoke it. If KEYS is omitted or nil, the return value of
267 `this-command-keys-vector' is used. */)
268 (function, record_flag, keys)
269 Lisp_Object function, record_flag, keys;
271 Lisp_Object *args, *visargs;
272 Lisp_Object specs;
273 Lisp_Object filter_specs;
274 Lisp_Object teml;
275 Lisp_Object up_event;
276 Lisp_Object enable;
277 int speccount = SPECPDL_INDEX ();
279 /* The index of the next element of this_command_keys to examine for
280 the 'e' interactive code. */
281 int next_event;
283 Lisp_Object prefix_arg;
284 unsigned char *string;
285 unsigned char *tem;
287 /* If varies[i] > 0, the i'th argument shouldn't just have its value
288 in this call quoted in the command history. It should be
289 recorded as a call to the function named callint_argfuns[varies[i]]. */
290 int *varies;
292 register int i, j;
293 int count, foo;
294 char prompt1[100];
295 char *tem1;
296 int arg_from_tty = 0;
297 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
298 int key_count;
299 int record_then_fail = 0;
301 Lisp_Object save_this_command, save_last_command;
302 Lisp_Object save_this_original_command, save_real_this_command;
304 save_this_command = Vthis_command;
305 save_this_original_command = Vthis_original_command;
306 save_real_this_command = real_this_command;
307 save_last_command = current_kboard->Vlast_command;
309 if (NILP (keys))
310 keys = this_command_keys, key_count = this_command_key_count;
311 else
313 CHECK_VECTOR (keys);
314 key_count = XVECTOR (keys)->size;
317 /* Save this now, since use of minibuffer will clobber it. */
318 prefix_arg = Vcurrent_prefix_arg;
320 if (SYMBOLP (function))
321 enable = Fget (function, Qenable_recursive_minibuffers);
322 else
323 enable = Qnil;
325 specs = Qnil;
326 string = 0;
327 /* The idea of FILTER_SPECS is to provide away to
328 specify how to represent the arguments in command history.
329 The feature is not fully implemented. */
330 filter_specs = Qnil;
332 /* If k or K discard an up-event, save it here so it can be retrieved with U */
333 up_event = Qnil;
335 /* Set SPECS to the interactive form, or barf if not interactive. */
337 Lisp_Object form;
338 GCPRO2 (function, prefix_arg);
339 form = Finteractive_form (function);
340 UNGCPRO;
341 if (CONSP (form))
342 specs = filter_specs = Fcar (XCDR (form));
343 else
344 wrong_type_argument (Qcommandp, function);
347 /* If SPECS is set to a string, use it as an interactive prompt. */
348 if (STRINGP (specs))
350 /* Make a copy of string so that if a GC relocates specs,
351 `string' will still be valid. */
352 string = (unsigned char *) alloca (SBYTES (specs) + 1);
353 bcopy (SDATA (specs), string,
354 SBYTES (specs) + 1);
356 else
358 Lisp_Object input;
359 i = num_input_events;
360 input = specs;
361 /* Compute the arg values using the user's expression. */
362 GCPRO2 (input, filter_specs);
363 specs = Feval (specs);
364 UNGCPRO;
365 if (i != num_input_events || !NILP (record_flag))
367 /* We should record this command on the command history. */
368 Lisp_Object values;
369 /* Make a copy of the list of values, for the command history,
370 and turn them into things we can eval. */
371 values = quotify_args (Fcopy_sequence (specs));
372 fix_command (input, values);
373 Vcommand_history
374 = Fcons (Fcons (function, values), Vcommand_history);
376 /* Don't keep command history around forever. */
377 if (INTEGERP (Vhistory_length) && XINT (Vhistory_length) > 0)
379 teml = Fnthcdr (Vhistory_length, Vcommand_history);
380 if (CONSP (teml))
381 XSETCDR (teml, Qnil);
385 Vthis_command = save_this_command;
386 Vthis_original_command = save_this_original_command;
387 real_this_command= save_real_this_command;
388 current_kboard->Vlast_command = save_last_command;
390 temporarily_switch_to_single_kboard (NULL);
391 return unbind_to (speccount, apply1 (function, specs));
394 /* Here if function specifies a string to control parsing the defaults */
396 /* Set next_event to point to the first event with parameters. */
397 for (next_event = 0; next_event < key_count; next_event++)
398 if (EVENT_HAS_PARAMETERS (AREF (keys, next_event)))
399 break;
401 /* Handle special starting chars `*' and `@'. Also `-'. */
402 /* Note that `+' is reserved for user extensions. */
403 while (1)
405 if (*string == '+')
406 error ("`+' is not used in `interactive' for ordinary commands");
407 else if (*string == '*')
409 string++;
410 if (!NILP (current_buffer->read_only))
412 if (!NILP (record_flag))
414 unsigned char *p = string;
415 while (*p)
417 if (! (*p == 'r' || *p == 'p' || *p == 'P'
418 || *p == '\n'))
419 Fbarf_if_buffer_read_only ();
420 p++;
422 record_then_fail = 1;
424 else
425 Fbarf_if_buffer_read_only ();
428 /* Ignore this for semi-compatibility with Lucid. */
429 else if (*string == '-')
430 string++;
431 else if (*string == '@')
433 Lisp_Object event, tem;
435 event = (next_event < key_count
436 ? AREF (keys, next_event)
437 : Qnil);
438 if (EVENT_HAS_PARAMETERS (event)
439 && (tem = XCDR (event), CONSP (tem))
440 && (tem = XCAR (tem), CONSP (tem))
441 && (tem = XCAR (tem), WINDOWP (tem)))
443 if (MINI_WINDOW_P (XWINDOW (tem))
444 && ! (minibuf_level > 0 && EQ (tem, minibuf_window)))
445 error ("Attempt to select inactive minibuffer window");
447 /* If the current buffer wants to clean up, let it. */
448 if (!NILP (Vmouse_leave_buffer_hook))
449 call1 (Vrun_hooks, Qmouse_leave_buffer_hook);
451 Fselect_window (tem, Qnil);
453 string++;
455 else if (*string == '^')
457 call0 (Qhandle_shift_selection);
458 string++;
460 else break;
463 /* Count the number of arguments the interactive spec would have
464 us give to the function. */
465 tem = string;
466 for (j = 0; *tem;)
468 /* 'r' specifications ("point and mark as 2 numeric args")
469 produce *two* arguments. */
470 if (*tem == 'r')
471 j += 2;
472 else
473 j++;
474 tem = (unsigned char *) index (tem, '\n');
475 if (tem)
476 ++tem;
477 else
478 break;
480 count = j;
482 args = (Lisp_Object *) alloca ((count + 1) * sizeof (Lisp_Object));
483 visargs = (Lisp_Object *) alloca ((count + 1) * sizeof (Lisp_Object));
484 varies = (int *) alloca ((count + 1) * sizeof (int));
486 for (i = 0; i < (count + 1); i++)
488 args[i] = Qnil;
489 visargs[i] = Qnil;
490 varies[i] = 0;
493 GCPRO5 (prefix_arg, function, *args, *visargs, up_event);
494 gcpro3.nvars = (count + 1);
495 gcpro4.nvars = (count + 1);
497 if (!NILP (enable))
498 specbind (Qenable_recursive_minibuffers, Qt);
500 tem = string;
501 for (i = 1; *tem; i++)
503 strncpy (prompt1, tem + 1, sizeof prompt1 - 1);
504 prompt1[sizeof prompt1 - 1] = 0;
505 tem1 = (char *) index (prompt1, '\n');
506 if (tem1) *tem1 = 0;
508 visargs[0] = build_string (prompt1);
509 if (index (prompt1, '%'))
510 callint_message = Fformat (i, visargs);
511 else
512 callint_message = visargs[0];
514 switch (*tem)
516 case 'a': /* Symbol defined as a function */
517 visargs[i] = Fcompleting_read (callint_message,
518 Vobarray, Qfboundp, Qt,
519 Qnil, Qnil, Qnil, Qnil);
520 /* Passing args[i] directly stimulates compiler bug */
521 teml = visargs[i];
522 args[i] = Fintern (teml, Qnil);
523 break;
525 case 'b': /* Name of existing buffer */
526 args[i] = Fcurrent_buffer ();
527 if (EQ (selected_window, minibuf_window))
528 args[i] = Fother_buffer (args[i], Qnil, Qnil);
529 args[i] = Fread_buffer (callint_message, args[i], Qt);
530 break;
532 case 'B': /* Name of buffer, possibly nonexistent */
533 args[i] = Fread_buffer (callint_message,
534 Fother_buffer (Fcurrent_buffer (), Qnil, Qnil),
535 Qnil);
536 break;
538 case 'c': /* Character */
539 /* Prompt in `minibuffer-prompt' face. */
540 Fput_text_property (make_number (0),
541 make_number (SCHARS (callint_message)),
542 Qface, Qminibuffer_prompt, callint_message);
543 args[i] = Fread_char (callint_message, Qnil, Qnil);
544 message1_nolog ((char *) 0);
545 /* Passing args[i] directly stimulates compiler bug */
546 teml = args[i];
547 visargs[i] = Fchar_to_string (teml);
548 break;
550 case 'C': /* Command: symbol with interactive function */
551 visargs[i] = Fcompleting_read (callint_message,
552 Vobarray, Qcommandp,
553 Qt, Qnil, Qnil, Qnil, Qnil);
554 /* Passing args[i] directly stimulates compiler bug */
555 teml = visargs[i];
556 args[i] = Fintern (teml, Qnil);
557 break;
559 case 'd': /* Value of point. Does not do I/O. */
560 set_marker_both (point_marker, Qnil, PT, PT_BYTE);
561 args[i] = point_marker;
562 /* visargs[i] = Qnil; */
563 varies[i] = 1;
564 break;
566 case 'D': /* Directory name. */
567 args[i] = Fread_file_name (callint_message, Qnil,
568 current_buffer->directory, Qlambda, Qnil,
569 Qfile_directory_p);
570 break;
572 case 'f': /* Existing file name. */
573 args[i] = Fread_file_name (callint_message,
574 Qnil, Qnil, Qlambda, Qnil, Qnil);
575 break;
577 case 'F': /* Possibly nonexistent file name. */
578 args[i] = Fread_file_name (callint_message,
579 Qnil, Qnil, Qnil, Qnil, Qnil);
580 break;
582 case 'G': /* Possibly nonexistent file name,
583 default to directory alone. */
584 args[i] = Fread_file_name (callint_message,
585 Qnil, Qnil, Qnil, empty_unibyte_string, Qnil);
586 break;
588 case 'i': /* Ignore an argument -- Does not do I/O */
589 varies[i] = -1;
590 break;
592 case 'k': /* Key sequence. */
594 int speccount1 = SPECPDL_INDEX ();
595 specbind (Qcursor_in_echo_area, Qt);
596 /* Prompt in `minibuffer-prompt' face. */
597 Fput_text_property (make_number (0),
598 make_number (SCHARS (callint_message)),
599 Qface, Qminibuffer_prompt, callint_message);
600 args[i] = Fread_key_sequence (callint_message,
601 Qnil, Qnil, Qnil, Qnil);
602 unbind_to (speccount1, Qnil);
603 teml = args[i];
604 visargs[i] = Fkey_description (teml, Qnil);
606 /* If the key sequence ends with a down-event,
607 discard the following up-event. */
608 teml = Faref (args[i], make_number (XINT (Flength (args[i])) - 1));
609 if (CONSP (teml))
610 teml = XCAR (teml);
611 if (SYMBOLP (teml))
613 Lisp_Object tem2;
615 teml = Fget (teml, intern ("event-symbol-elements"));
616 /* Ignore first element, which is the base key. */
617 tem2 = Fmemq (intern ("down"), Fcdr (teml));
618 if (! NILP (tem2))
619 up_event = Fread_event (Qnil, Qnil, Qnil);
622 break;
624 case 'K': /* Key sequence to be defined. */
626 int speccount1 = SPECPDL_INDEX ();
627 specbind (Qcursor_in_echo_area, Qt);
628 /* Prompt in `minibuffer-prompt' face. */
629 Fput_text_property (make_number (0),
630 make_number (SCHARS (callint_message)),
631 Qface, Qminibuffer_prompt, callint_message);
632 args[i] = Fread_key_sequence (callint_message,
633 Qnil, Qt, Qnil, Qnil);
634 teml = args[i];
635 visargs[i] = Fkey_description (teml, Qnil);
636 unbind_to (speccount1, Qnil);
638 /* If the key sequence ends with a down-event,
639 discard the following up-event. */
640 teml = Faref (args[i], make_number (XINT (Flength (args[i])) - 1));
641 if (CONSP (teml))
642 teml = XCAR (teml);
643 if (SYMBOLP (teml))
645 Lisp_Object tem2;
647 teml = Fget (teml, intern ("event-symbol-elements"));
648 /* Ignore first element, which is the base key. */
649 tem2 = Fmemq (intern ("down"), Fcdr (teml));
650 if (! NILP (tem2))
651 up_event = Fread_event (Qnil, Qnil, Qnil);
654 break;
656 case 'U': /* Up event from last k or K */
657 if (!NILP (up_event))
659 args[i] = Fmake_vector (make_number (1), up_event);
660 up_event = Qnil;
661 teml = args[i];
662 visargs[i] = Fkey_description (teml, Qnil);
664 break;
666 case 'e': /* The invoking event. */
667 if (next_event >= key_count)
668 error ("%s must be bound to an event with parameters",
669 (SYMBOLP (function)
670 ? (char *) SDATA (SYMBOL_NAME (function))
671 : "command"));
672 args[i] = AREF (keys, next_event);
673 next_event++;
674 varies[i] = -1;
676 /* Find the next parameterized event. */
677 while (next_event < key_count
678 && !(EVENT_HAS_PARAMETERS (AREF (keys, next_event))))
679 next_event++;
681 break;
683 case 'm': /* Value of mark. Does not do I/O. */
684 check_mark (0);
685 /* visargs[i] = Qnil; */
686 args[i] = current_buffer->mark;
687 varies[i] = 2;
688 break;
690 case 'M': /* String read via minibuffer with
691 inheriting the current input method. */
692 args[i] = Fread_string (callint_message,
693 Qnil, Qnil, Qnil, Qt);
694 break;
696 case 'N': /* Prefix arg as number, else number from minibuffer */
697 if (!NILP (prefix_arg))
698 goto have_prefix_arg;
699 case 'n': /* Read number from minibuffer. */
701 int first = 1;
704 Lisp_Object tem;
705 if (! first)
707 message ("Please enter a number.");
708 sit_for (make_number (1), 0, 0);
710 first = 0;
712 tem = Fread_from_minibuffer (callint_message,
713 Qnil, Qnil, Qnil, Qnil, Qnil,
714 Qnil);
715 if (! STRINGP (tem) || SCHARS (tem) == 0)
716 args[i] = Qnil;
717 else
718 args[i] = Fread (tem);
720 while (! NUMBERP (args[i]));
722 visargs[i] = args[i];
723 break;
725 case 'P': /* Prefix arg in raw form. Does no I/O. */
726 args[i] = prefix_arg;
727 /* visargs[i] = Qnil; */
728 varies[i] = -1;
729 break;
731 case 'p': /* Prefix arg converted to number. No I/O. */
732 have_prefix_arg:
733 args[i] = Fprefix_numeric_value (prefix_arg);
734 /* visargs[i] = Qnil; */
735 varies[i] = -1;
736 break;
738 case 'r': /* Region, point and mark as 2 args. */
739 check_mark (1);
740 set_marker_both (point_marker, Qnil, PT, PT_BYTE);
741 /* visargs[i+1] = Qnil; */
742 foo = marker_position (current_buffer->mark);
743 /* visargs[i] = Qnil; */
744 args[i] = PT < foo ? point_marker : current_buffer->mark;
745 varies[i] = 3;
746 args[++i] = PT > foo ? point_marker : current_buffer->mark;
747 varies[i] = 4;
748 break;
750 case 's': /* String read via minibuffer without
751 inheriting the current input method. */
752 args[i] = Fread_string (callint_message,
753 Qnil, Qnil, Qnil, Qnil);
754 break;
756 case 'S': /* Any symbol. */
757 visargs[i] = Fread_string (callint_message,
758 Qnil, Qnil, Qnil, Qnil);
759 /* Passing args[i] directly stimulates compiler bug */
760 teml = visargs[i];
761 args[i] = Fintern (teml, Qnil);
762 break;
764 case 'v': /* Variable name: symbol that is
765 user-variable-p. */
766 args[i] = Fread_variable (callint_message, Qnil);
767 visargs[i] = last_minibuf_string;
768 break;
770 case 'x': /* Lisp expression read but not evaluated */
771 args[i] = Fread_minibuffer (callint_message, Qnil);
772 visargs[i] = last_minibuf_string;
773 break;
775 case 'X': /* Lisp expression read and evaluated */
776 args[i] = Feval_minibuffer (callint_message, Qnil);
777 visargs[i] = last_minibuf_string;
778 break;
780 case 'Z': /* Coding-system symbol, or ignore the
781 argument if no prefix */
782 if (NILP (prefix_arg))
784 args[i] = Qnil;
785 varies[i] = -1;
787 else
789 args[i]
790 = Fread_non_nil_coding_system (callint_message);
791 visargs[i] = last_minibuf_string;
793 break;
795 case 'z': /* Coding-system symbol or nil */
796 args[i] = Fread_coding_system (callint_message, Qnil);
797 visargs[i] = last_minibuf_string;
798 break;
800 /* We have a case for `+' so we get an error
801 if anyone tries to define one here. */
802 case '+':
803 default:
804 error ("Invalid control letter `%c' (%03o) in interactive calling string",
805 *tem, *tem);
808 if (varies[i] == 0)
809 arg_from_tty = 1;
811 if (NILP (visargs[i]) && STRINGP (args[i]))
812 visargs[i] = args[i];
814 tem = (unsigned char *) index (tem, '\n');
815 if (tem) tem++;
816 else tem = (unsigned char *) "";
818 unbind_to (speccount, Qnil);
820 QUIT;
822 args[0] = function;
824 if (arg_from_tty || !NILP (record_flag))
826 visargs[0] = function;
827 for (i = 1; i < count + 1; i++)
829 if (varies[i] > 0)
830 visargs[i] = Fcons (intern (callint_argfuns[varies[i]]), Qnil);
831 else
832 visargs[i] = quotify_arg (args[i]);
834 Vcommand_history = Fcons (Flist (count + 1, visargs),
835 Vcommand_history);
836 /* Don't keep command history around forever. */
837 if (INTEGERP (Vhistory_length) && XINT (Vhistory_length) > 0)
839 teml = Fnthcdr (Vhistory_length, Vcommand_history);
840 if (CONSP (teml))
841 XSETCDR (teml, Qnil);
845 /* If we used a marker to hold point, mark, or an end of the region,
846 temporarily, convert it to an integer now. */
847 for (i = 1; i <= count; i++)
848 if (varies[i] >= 1 && varies[i] <= 4)
849 XSETINT (args[i], marker_position (args[i]));
851 if (record_then_fail)
852 Fbarf_if_buffer_read_only ();
854 Vthis_command = save_this_command;
855 Vthis_original_command = save_this_original_command;
856 real_this_command= save_real_this_command;
857 current_kboard->Vlast_command = save_last_command;
860 Lisp_Object val;
861 specbind (Qcommand_debug_status, Qnil);
863 temporarily_switch_to_single_kboard (NULL);
864 val = Ffuncall (count + 1, args);
865 UNGCPRO;
866 return unbind_to (speccount, val);
870 DEFUN ("prefix-numeric-value", Fprefix_numeric_value, Sprefix_numeric_value,
871 1, 1, 0,
872 doc: /* Return numeric meaning of raw prefix argument RAW.
873 A raw prefix argument is what you get from `(interactive "P")'.
874 Its numeric meaning is what you would get from `(interactive "p")'. */)
875 (raw)
876 Lisp_Object raw;
878 Lisp_Object val;
880 if (NILP (raw))
881 XSETFASTINT (val, 1);
882 else if (EQ (raw, Qminus))
883 XSETINT (val, -1);
884 else if (CONSP (raw) && INTEGERP (XCAR (raw)))
885 XSETINT (val, XINT (XCAR (raw)));
886 else if (INTEGERP (raw))
887 val = raw;
888 else
889 XSETFASTINT (val, 1);
891 return val;
894 void
895 syms_of_callint ()
897 point_marker = Fmake_marker ();
898 staticpro (&point_marker);
900 callint_message = Qnil;
901 staticpro (&callint_message);
903 preserved_fns = Fcons (intern ("region-beginning"),
904 Fcons (intern ("region-end"),
905 Fcons (intern ("point"),
906 Fcons (intern ("mark"), Qnil))));
907 staticpro (&preserved_fns);
909 Qlist = intern ("list");
910 staticpro (&Qlist);
911 Qlet = intern ("let");
912 staticpro (&Qlet);
913 Qif = intern ("if");
914 staticpro (&Qif);
915 Qwhen = intern ("when");
916 staticpro (&Qwhen);
917 Qletx = intern ("let*");
918 staticpro (&Qletx);
919 Qsave_excursion = intern ("save-excursion");
920 staticpro (&Qsave_excursion);
921 Qprogn = intern ("progn");
922 staticpro (&Qprogn);
924 Qminus = intern ("-");
925 staticpro (&Qminus);
927 Qplus = intern ("+");
928 staticpro (&Qplus);
930 Qhandle_shift_selection = intern ("handle-shift-selection");
931 staticpro (&Qhandle_shift_selection);
933 Qcall_interactively = intern ("call-interactively");
934 staticpro (&Qcall_interactively);
936 Qcommand_debug_status = intern ("command-debug-status");
937 staticpro (&Qcommand_debug_status);
939 Qenable_recursive_minibuffers = intern ("enable-recursive-minibuffers");
940 staticpro (&Qenable_recursive_minibuffers);
942 Qmouse_leave_buffer_hook = intern ("mouse-leave-buffer-hook");
943 staticpro (&Qmouse_leave_buffer_hook);
945 DEFVAR_KBOARD ("prefix-arg", Vprefix_arg,
946 doc: /* The value of the prefix argument for the next editing command.
947 It may be a number, or the symbol `-' for just a minus sign as arg,
948 or a list whose car is a number for just one or more C-u's
949 or nil if no argument has been specified.
951 You cannot examine this variable to find the argument for this command
952 since it has been set to nil by the time you can look.
953 Instead, you should use the variable `current-prefix-arg', although
954 normally commands can get this prefix argument with (interactive "P"). */);
956 DEFVAR_KBOARD ("last-prefix-arg", Vlast_prefix_arg,
957 doc: /* The value of the prefix argument for the previous editing command.
958 See `prefix-arg' for the meaning of the value. */);
960 DEFVAR_LISP ("current-prefix-arg", &Vcurrent_prefix_arg,
961 doc: /* The value of the prefix argument for this editing command.
962 It may be a number, or the symbol `-' for just a minus sign as arg,
963 or a list whose car is a number for just one or more C-u's
964 or nil if no argument has been specified.
965 This is what `(interactive \"P\")' returns. */);
966 Vcurrent_prefix_arg = Qnil;
968 DEFVAR_LISP ("command-history", &Vcommand_history,
969 doc: /* List of recent commands that read arguments from terminal.
970 Each command is represented as a form to evaluate.
972 Maximum length of the history list is determined by the value
973 of `history-length', which see. */);
974 Vcommand_history = Qnil;
976 DEFVAR_LISP ("command-debug-status", &Vcommand_debug_status,
977 doc: /* Debugging status of current interactive command.
978 Bound each time `call-interactively' is called;
979 may be set by the debugger as a reminder for itself. */);
980 Vcommand_debug_status = Qnil;
982 DEFVAR_LISP ("mark-even-if-inactive", &Vmark_even_if_inactive,
983 doc: /* *Non-nil means you can use the mark even when inactive.
984 This option makes a difference in Transient Mark mode.
985 When the option is non-nil, deactivation of the mark
986 turns off region highlighting, but commands that use the mark
987 behave as if the mark were still active. */);
988 Vmark_even_if_inactive = Qt;
990 DEFVAR_LISP ("mouse-leave-buffer-hook", &Vmouse_leave_buffer_hook,
991 doc: /* Hook to run when about to switch windows with a mouse command.
992 Its purpose is to give temporary modes such as Isearch mode
993 a way to turn themselves off when a mouse command switches windows. */);
994 Vmouse_leave_buffer_hook = Qnil;
996 defsubr (&Sinteractive);
997 defsubr (&Scall_interactively);
998 defsubr (&Sprefix_numeric_value);
1001 /* arch-tag: a3a7cad7-bcac-42ce-916e-1bd2546ebf37
1002 (do not change this comment) */