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