(Fmake_chartable, Fmake_boolvector): New functions.
[bpt/emacs.git] / src / callint.c
1 /* Call a Lisp function interactively.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995 Free Software Foundation, Inc.
3
4 This file is part of GNU Emacs.
5
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20
21 #include <config.h>
22 #include "lisp.h"
23 #include "buffer.h"
24 #include "commands.h"
25 #include "keyboard.h"
26 #include "window.h"
27 #include "mocklisp.h"
28
29 extern char *index ();
30
31 Lisp_Object Vcurrent_prefix_arg, Qminus, Qplus;
32 Lisp_Object Qcall_interactively;
33 Lisp_Object Vcommand_history;
34
35 Lisp_Object Vcommand_debug_status, Qcommand_debug_status;
36 Lisp_Object Qenable_recursive_minibuffers;
37
38 /* Non-nil means treat the mark as active
39 even if mark_active is 0. */
40 Lisp_Object Vmark_even_if_inactive;
41
42 Lisp_Object Vmouse_leave_buffer_hook, Qmouse_leave_buffer_hook;
43
44 Lisp_Object Qlist;
45 static Lisp_Object preserved_fns;
46
47 /* Marker used within call-interactively to refer to point. */
48 static Lisp_Object point_marker;
49
50
51 /* This comment supplies the doc string for interactive,
52 for make-docfile to see. We cannot put this in the real DEFUN
53 due to limits in the Unix cpp.
54
55 DEFUN ("interactive", Ffoo, Sfoo, 0, 0, 0,
56 "Specify a way of parsing arguments for interactive use of a function.\n\
57 For example, write\n\
58 (defun foo (arg) \"Doc string\" (interactive \"p\") ...use arg...)\n\
59 to make ARG be the prefix argument when `foo' is called as a command.\n\
60 The \"call\" to `interactive' is actually a declaration rather than a function;\n\
61 it tells `call-interactively' how to read arguments\n\
62 to pass to the function.\n\
63 When actually called, `interactive' just returns nil.\n\
64 \n\
65 The argument of `interactive' is usually a string containing a code letter\n\
66 followed by a prompt. (Some code letters do not use I/O to get\n\
67 the argument and do not need prompts.) To prompt for multiple arguments,\n\
68 give a code letter, its prompt, a newline, and another code letter, etc.\n\
69 Prompts are passed to format, and may use % escapes to print the\n\
70 arguments that have already been read.\n\
71 If the argument is not a string, it is evaluated to get a list of\n\
72 arguments to pass to the function.\n\
73 Just `(interactive)' means pass no args when calling interactively.\n\
74 \nCode letters available are:\n\
75 a -- Function name: symbol with a function definition.\n\
76 b -- Name of existing buffer.\n\
77 B -- Name of buffer, possibly nonexistent.\n\
78 c -- Character.\n\
79 C -- Command name: symbol with interactive function definition.\n\
80 d -- Value of point as number. Does not do I/O.\n\
81 D -- Directory name.\n\
82 e -- Parametrized event (i.e., one that's a list) that invoked this command.\n\
83 If used more than once, the Nth `e' returns the Nth parameterized event.\n\
84 This skips events that are integers or symbols.\n\
85 f -- Existing file name.\n\
86 F -- Possibly nonexistent file name.\n\
87 k -- Key sequence (downcase the last event if needed to get a definition).\n\
88 K -- Key sequence to be redefined (do not downcase the last event).\n\
89 m -- Value of mark as number. Does not do I/O.\n\
90 n -- Number read using minibuffer.\n\
91 N -- Raw prefix arg, or if none, do like code `n'.\n\
92 p -- Prefix arg converted to number. Does not do I/O.\n\
93 P -- Prefix arg in raw form. Does not do I/O.\n\
94 r -- Region: point and mark as 2 numeric args, smallest first. Does no I/O.\n\
95 s -- Any string.\n\
96 S -- Any symbol.\n\
97 v -- Variable name: symbol that is user-variable-p.\n\
98 x -- Lisp expression read but not evaluated.\n\
99 X -- Lisp expression read and evaluated.\n\
100 In addition, if the string begins with `*'\n\
101 then an error is signaled if the buffer is read-only.\n\
102 This happens before reading any arguments.\n\
103 If the string begins with `@', then Emacs searches the key sequence\n\
104 which invoked the command for its first mouse click (or any other\n\
105 event which specifies a window), and selects that window before\n\
106 reading any arguments. You may use both `@' and `*'; they are\n\
107 processed in the order that they appear." */
108
109 /* ARGSUSED */
110 DEFUN ("interactive", Finteractive, Sinteractive, 0, UNEVALLED, 0,
111 0 /* See immediately above */)
112 (args)
113 Lisp_Object args;
114 {
115 return Qnil;
116 }
117
118 /* Quotify EXP: if EXP is constant, return it.
119 If EXP is not constant, return (quote EXP). */
120 Lisp_Object
121 quotify_arg (exp)
122 register Lisp_Object exp;
123 {
124 if (!INTEGERP (exp) && !STRINGP (exp)
125 && !NILP (exp) && !EQ (exp, Qt))
126 return Fcons (Qquote, Fcons (exp, Qnil));
127
128 return exp;
129 }
130
131 /* Modify EXP by quotifying each element (except the first). */
132 Lisp_Object
133 quotify_args (exp)
134 Lisp_Object exp;
135 {
136 register Lisp_Object tail;
137 register struct Lisp_Cons *ptr;
138 for (tail = exp; CONSP (tail); tail = ptr->cdr)
139 {
140 ptr = XCONS (tail);
141 ptr->car = quotify_arg (ptr->car);
142 }
143 return exp;
144 }
145
146 char *callint_argfuns[]
147 = {"", "point", "mark", "region-beginning", "region-end"};
148
149 static void
150 check_mark ()
151 {
152 Lisp_Object tem;
153 tem = Fmarker_buffer (current_buffer->mark);
154 if (NILP (tem) || (XBUFFER (tem) != current_buffer))
155 error ("The mark is not set now");
156 if (!NILP (Vtransient_mark_mode) && NILP (Vmark_even_if_inactive)
157 && NILP (current_buffer->mark_active))
158 Fsignal (Qmark_inactive, Qnil);
159 }
160
161
162 DEFUN ("call-interactively", Fcall_interactively, Scall_interactively, 1, 2, 0,
163 "Call FUNCTION, reading args according to its interactive calling specs.\n\
164 Return the value FUNCTION returns.\n\
165 The function contains a specification of how to do the argument reading.\n\
166 In the case of user-defined functions, this is specified by placing a call\n\
167 to the function `interactive' at the top level of the function body.\n\
168 See `interactive'.\n\
169 \n\
170 Optional second arg RECORD-FLAG non-nil\n\
171 means unconditionally put this command in the command-history.\n\
172 Otherwise, this is done only if an arg is read using the minibuffer.")
173 (function, record)
174 Lisp_Object function, record;
175 {
176 Lisp_Object *args, *visargs;
177 unsigned char **argstrings;
178 Lisp_Object fun;
179 Lisp_Object funcar;
180 Lisp_Object specs;
181 Lisp_Object teml;
182 Lisp_Object enable;
183 int speccount = specpdl_ptr - specpdl;
184
185 /* The index of the next element of this_command_keys to examine for
186 the 'e' interactive code. */
187 int next_event;
188
189 Lisp_Object prefix_arg;
190 unsigned char *string;
191 unsigned char *tem;
192
193 /* If varies[i] > 0, the i'th argument shouldn't just have its value
194 in this call quoted in the command history. It should be
195 recorded as a call to the function named callint_argfuns[varies[i]]. */
196 int *varies;
197
198 register int i, j;
199 int count, foo;
200 char prompt[100];
201 char prompt1[100];
202 char *tem1;
203 int arg_from_tty = 0;
204 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
205
206 /* Save this now, since use of minibuffer will clobber it. */
207 prefix_arg = Vcurrent_prefix_arg;
208
209 retry:
210
211 if (SYMBOLP (function))
212 enable = Fget (function, Qenable_recursive_minibuffers);
213
214 fun = indirect_function (function);
215
216 specs = Qnil;
217 string = 0;
218
219 /* Decode the kind of function. Either handle it and return,
220 or go to `lose' if not interactive, or go to `retry'
221 to specify a different function, or set either STRING or SPECS. */
222
223 if (SUBRP (fun))
224 {
225 string = (unsigned char *) XSUBR (fun)->prompt;
226 if (!string)
227 {
228 lose:
229 function = wrong_type_argument (Qcommandp, function);
230 goto retry;
231 }
232 if ((EMACS_INT) string == 1)
233 /* Let SPECS (which is nil) be used as the args. */
234 string = 0;
235 }
236 else if (COMPILEDP (fun))
237 {
238 if ((XVECTOR (fun)->size & PSEUDOVECTOR_SIZE_MASK) <= COMPILED_INTERACTIVE)
239 goto lose;
240 specs = XVECTOR (fun)->contents[COMPILED_INTERACTIVE];
241 }
242 else if (!CONSP (fun))
243 goto lose;
244 else if (funcar = Fcar (fun), EQ (funcar, Qautoload))
245 {
246 GCPRO2 (function, prefix_arg);
247 do_autoload (fun, function);
248 UNGCPRO;
249 goto retry;
250 }
251 else if (EQ (funcar, Qlambda))
252 {
253 specs = Fassq (Qinteractive, Fcdr (Fcdr (fun)));
254 if (NILP (specs))
255 goto lose;
256 specs = Fcar (Fcdr (specs));
257 }
258 else if (EQ (funcar, Qmocklisp))
259 {
260 single_kboard_state ();
261 return ml_apply (fun, Qinteractive);
262 }
263 else
264 goto lose;
265
266 /* If either specs or string is set to a string, use it. */
267 if (STRINGP (specs))
268 {
269 /* Make a copy of string so that if a GC relocates specs,
270 `string' will still be valid. */
271 string = (unsigned char *) alloca (XSTRING (specs)->size + 1);
272 bcopy (XSTRING (specs)->data, string, XSTRING (specs)->size + 1);
273 }
274 else if (string == 0)
275 {
276 Lisp_Object input;
277 i = num_input_chars;
278 input = specs;
279 /* Compute the arg values using the user's expression. */
280 specs = Feval (specs);
281 if (i != num_input_chars || !NILP (record))
282 {
283 /* We should record this command on the command history. */
284 Lisp_Object values, car;
285 /* Make a copy of the list of values, for the command history,
286 and turn them into things we can eval. */
287 values = quotify_args (Fcopy_sequence (specs));
288 /* If the list of args was produced with an explicit call to `list',
289 look for elements that were computed with (region-beginning)
290 or (region-end), and put those expressions into VALUES
291 instead of the present values. */
292 car = Fcar (input);
293 if (EQ (car, Qlist))
294 {
295 Lisp_Object intail, valtail;
296 for (intail = Fcdr (input), valtail = values;
297 CONSP (valtail);
298 intail = Fcdr (intail), valtail = Fcdr (valtail))
299 {
300 Lisp_Object elt;
301 elt = Fcar (intail);
302 if (CONSP (elt))
303 {
304 Lisp_Object presflag;
305 presflag = Fmemq (Fcar (elt), preserved_fns);
306 if (!NILP (presflag))
307 Fsetcar (valtail, Fcar (intail));
308 }
309 }
310 }
311 Vcommand_history
312 = Fcons (Fcons (function, values), Vcommand_history);
313 }
314 single_kboard_state ();
315 return apply1 (function, specs);
316 }
317
318 /* Here if function specifies a string to control parsing the defaults */
319
320 /* Set next_event to point to the first event with parameters. */
321 for (next_event = 0; next_event < this_command_key_count; next_event++)
322 if (EVENT_HAS_PARAMETERS
323 (XVECTOR (this_command_keys)->contents[next_event]))
324 break;
325
326 /* Handle special starting chars `*' and `@'. Also `-'. */
327 /* Note that `+' is reserved for user extensions. */
328 while (1)
329 {
330 if (*string == '+')
331 error ("`+' is not used in `interactive' for ordinary commands");
332 else if (*string == '*')
333 {
334 string++;
335 if (!NILP (current_buffer->read_only))
336 Fbarf_if_buffer_read_only ();
337 }
338 /* Ignore this for semi-compatibility with Lucid. */
339 else if (*string == '-')
340 string++;
341 else if (*string == '@')
342 {
343 Lisp_Object event;
344
345 event = XVECTOR (this_command_keys)->contents[next_event];
346 if (EVENT_HAS_PARAMETERS (event)
347 && (event = XCONS (event)->cdr, CONSP (event))
348 && (event = XCONS (event)->car, CONSP (event))
349 && (event = XCONS (event)->car, WINDOWP (event)))
350 {
351 if (MINI_WINDOW_P (XWINDOW (event))
352 && ! (minibuf_level > 0 && EQ (event, minibuf_window)))
353 error ("Attempt to select inactive minibuffer window");
354
355 /* If the current buffer wants to clean up, let it. */
356 if (!NILP (Vmouse_leave_buffer_hook))
357 call1 (Vrun_hooks, Qmouse_leave_buffer_hook);
358
359 Fselect_window (event);
360 }
361 string++;
362 }
363 else break;
364 }
365
366 /* Count the number of arguments the interactive spec would have
367 us give to the function. */
368 tem = string;
369 for (j = 0; *tem; j++)
370 {
371 /* 'r' specifications ("point and mark as 2 numeric args")
372 produce *two* arguments. */
373 if (*tem == 'r') j++;
374 tem = (unsigned char *) index (tem, '\n');
375 if (tem)
376 tem++;
377 else
378 tem = (unsigned char *) "";
379 }
380 count = j;
381
382 args = (Lisp_Object *) alloca ((count + 1) * sizeof (Lisp_Object));
383 visargs = (Lisp_Object *) alloca ((count + 1) * sizeof (Lisp_Object));
384 argstrings = (unsigned char **) alloca ((count + 1) * sizeof (char *));
385 varies = (int *) alloca ((count + 1) * sizeof (int));
386
387 for (i = 0; i < (count + 1); i++)
388 {
389 args[i] = Qnil;
390 visargs[i] = Qnil;
391 varies[i] = 0;
392 }
393
394 GCPRO4 (prefix_arg, function, *args, *visargs);
395 gcpro3.nvars = (count + 1);
396 gcpro4.nvars = (count + 1);
397
398 if (!NILP (enable))
399 specbind (Qenable_recursive_minibuffers, Qt);
400
401 tem = string;
402 for (i = 1; *tem; i++)
403 {
404 strncpy (prompt1, tem + 1, sizeof prompt1 - 1);
405 prompt1[sizeof prompt1 - 1] = 0;
406 tem1 = index (prompt1, '\n');
407 if (tem1) *tem1 = 0;
408 /* Fill argstrings with a vector of C strings
409 corresponding to the Lisp strings in visargs. */
410 for (j = 1; j < i; j++)
411 argstrings[j]
412 = EQ (visargs[j], Qnil)
413 ? (unsigned char *) ""
414 : XSTRING (visargs[j])->data;
415
416 doprnt (prompt, sizeof prompt, prompt1, (char *)0,
417 j - 1, argstrings + 1);
418
419 switch (*tem)
420 {
421 case 'a': /* Symbol defined as a function */
422 visargs[i] = Fcompleting_read (build_string (prompt),
423 Vobarray, Qfboundp, Qt, Qnil, Qnil);
424 /* Passing args[i] directly stimulates compiler bug */
425 teml = visargs[i];
426 args[i] = Fintern (teml, Qnil);
427 break;
428
429 case 'b': /* Name of existing buffer */
430 args[i] = Fcurrent_buffer ();
431 if (EQ (selected_window, minibuf_window))
432 args[i] = Fother_buffer (args[i], Qnil);
433 args[i] = Fread_buffer (build_string (prompt), args[i], Qt);
434 break;
435
436 case 'B': /* Name of buffer, possibly nonexistent */
437 args[i] = Fread_buffer (build_string (prompt),
438 Fother_buffer (Fcurrent_buffer (), Qnil),
439 Qnil);
440 break;
441
442 case 'c': /* Character */
443 message1 (prompt);
444 args[i] = Fread_char ();
445 /* Passing args[i] directly stimulates compiler bug */
446 teml = args[i];
447 visargs[i] = Fchar_to_string (teml);
448 break;
449
450 case 'C': /* Command: symbol with interactive function */
451 visargs[i] = Fcompleting_read (build_string (prompt),
452 Vobarray, Qcommandp, Qt, Qnil, Qnil);
453 /* Passing args[i] directly stimulates compiler bug */
454 teml = visargs[i];
455 args[i] = Fintern (teml, Qnil);
456 break;
457
458 case 'd': /* Value of point. Does not do I/O. */
459 Fset_marker (point_marker, make_number (PT), Qnil);
460 args[i] = point_marker;
461 /* visargs[i] = Qnil; */
462 varies[i] = 1;
463 break;
464
465 case 'D': /* Directory name. */
466 args[i] = Fread_file_name (build_string (prompt), Qnil,
467 current_buffer->directory, Qlambda, Qnil);
468 break;
469
470 case 'f': /* Existing file name. */
471 args[i] = Fread_file_name (build_string (prompt),
472 Qnil, Qnil, Qlambda, Qnil);
473 break;
474
475 case 'F': /* Possibly nonexistent file name. */
476 args[i] = Fread_file_name (build_string (prompt),
477 Qnil, Qnil, Qnil, Qnil);
478 break;
479
480 case 'k': /* Key sequence. */
481 args[i] = Fread_key_sequence (build_string (prompt), Qnil, Qnil, Qnil);
482 teml = args[i];
483 visargs[i] = Fkey_description (teml);
484 break;
485
486 case 'K': /* Key sequence to be defined. */
487 args[i] = Fread_key_sequence (build_string (prompt), Qnil, Qt, Qnil);
488 teml = args[i];
489 visargs[i] = Fkey_description (teml);
490 break;
491
492 case 'e': /* The invoking event. */
493 if (next_event >= this_command_key_count)
494 error ("%s must be bound to an event with parameters",
495 (SYMBOLP (function)
496 ? (char *) XSYMBOL (function)->name->data
497 : "command"));
498 args[i] = XVECTOR (this_command_keys)->contents[next_event++];
499 varies[i] = -1;
500
501 /* Find the next parameterized event. */
502 while (next_event < this_command_key_count
503 && ! (EVENT_HAS_PARAMETERS
504 (XVECTOR (this_command_keys)->contents[next_event])))
505 next_event++;
506
507 break;
508
509 case 'm': /* Value of mark. Does not do I/O. */
510 check_mark ();
511 /* visargs[i] = Qnil; */
512 args[i] = current_buffer->mark;
513 varies[i] = 2;
514 break;
515
516 case 'N': /* Prefix arg, else number from minibuffer */
517 if (!NILP (prefix_arg))
518 goto have_prefix_arg;
519 case 'n': /* Read number from minibuffer. */
520 do
521 args[i] = Fread_minibuffer (build_string (prompt), Qnil);
522 while (! NUMBERP (args[i]));
523 visargs[i] = last_minibuf_string;
524 break;
525
526 case 'P': /* Prefix arg in raw form. Does no I/O. */
527 have_prefix_arg:
528 args[i] = prefix_arg;
529 /* visargs[i] = Qnil; */
530 varies[i] = -1;
531 break;
532
533 case 'p': /* Prefix arg converted to number. No I/O. */
534 args[i] = Fprefix_numeric_value (prefix_arg);
535 /* visargs[i] = Qnil; */
536 varies[i] = -1;
537 break;
538
539 case 'r': /* Region, point and mark as 2 args. */
540 check_mark ();
541 Fset_marker (point_marker, make_number (PT), Qnil);
542 /* visargs[i+1] = Qnil; */
543 foo = marker_position (current_buffer->mark);
544 /* visargs[i] = Qnil; */
545 args[i] = point < foo ? point_marker : current_buffer->mark;
546 varies[i] = 3;
547 args[++i] = point > foo ? point_marker : current_buffer->mark;
548 varies[i] = 4;
549 break;
550
551 case 's': /* String read via minibuffer. */
552 args[i] = Fread_string (build_string (prompt), Qnil, Qnil);
553 break;
554
555 case 'S': /* Any symbol. */
556 visargs[i] = Fread_string (build_string (prompt), Qnil, Qnil);
557 /* Passing args[i] directly stimulates compiler bug */
558 teml = visargs[i];
559 args[i] = Fintern (teml, Qnil);
560 break;
561
562 case 'v': /* Variable name: symbol that is
563 user-variable-p. */
564 args[i] = Fread_variable (build_string (prompt));
565 visargs[i] = last_minibuf_string;
566 break;
567
568 case 'x': /* Lisp expression read but not evaluated */
569 args[i] = Fread_minibuffer (build_string (prompt), Qnil);
570 visargs[i] = last_minibuf_string;
571 break;
572
573 case 'X': /* Lisp expression read and evaluated */
574 args[i] = Feval_minibuffer (build_string (prompt), Qnil);
575 visargs[i] = last_minibuf_string;
576 break;
577
578 /* We have a case for `+' so we get an error
579 if anyone tries to define one here. */
580 case '+':
581 default:
582 error ("Invalid control letter `%c' (%03o) in interactive calling string",
583 *tem, *tem);
584 }
585
586 if (varies[i] == 0)
587 arg_from_tty = 1;
588
589 if (NILP (visargs[i]) && STRINGP (args[i]))
590 visargs[i] = args[i];
591
592 tem = (unsigned char *) index (tem, '\n');
593 if (tem) tem++;
594 else tem = (unsigned char *) "";
595 }
596 unbind_to (speccount, Qnil);
597
598 QUIT;
599
600 args[0] = function;
601
602 if (arg_from_tty || !NILP (record))
603 {
604 visargs[0] = function;
605 for (i = 1; i < count + 1; i++)
606 {
607 if (varies[i] > 0)
608 visargs[i] = Fcons (intern (callint_argfuns[varies[i]]), Qnil);
609 else
610 visargs[i] = quotify_arg (args[i]);
611 }
612 Vcommand_history = Fcons (Flist (count + 1, visargs),
613 Vcommand_history);
614 }
615
616 /* If we used a marker to hold point, mark, or an end of the region,
617 temporarily, convert it to an integer now. */
618 for (i = 1; i <= count; i++)
619 if (varies[i] >= 1 && varies[i] <= 4)
620 XSETINT (args[i], marker_position (args[i]));
621
622 single_kboard_state ();
623
624 {
625 Lisp_Object val;
626 specbind (Qcommand_debug_status, Qnil);
627
628 val = Ffuncall (count + 1, args);
629 UNGCPRO;
630 return unbind_to (speccount, val);
631 }
632 }
633
634 DEFUN ("prefix-numeric-value", Fprefix_numeric_value, Sprefix_numeric_value,
635 1, 1, 0,
636 "Return numeric meaning of raw prefix argument ARG.\n\
637 A raw prefix argument is what you get from `(interactive \"P\")'.\n\
638 Its numeric meaning is what you would get from `(interactive \"p\")'.")
639 (raw)
640 Lisp_Object raw;
641 {
642 Lisp_Object val;
643
644 if (NILP (raw))
645 XSETFASTINT (val, 1);
646 else if (EQ (raw, Qminus))
647 XSETINT (val, -1);
648 else if (CONSP (raw) && INTEGERP (XCONS (raw)->car))
649 XSETINT (val, XINT (XCONS (raw)->car));
650 else if (INTEGERP (raw))
651 val = raw;
652 else
653 XSETFASTINT (val, 1);
654
655 return val;
656 }
657
658 syms_of_callint ()
659 {
660 point_marker = Fmake_marker ();
661 staticpro (&point_marker);
662
663 preserved_fns = Fcons (intern ("region-beginning"),
664 Fcons (intern ("region-end"),
665 Fcons (intern ("point"),
666 Fcons (intern ("mark"), Qnil))));
667 staticpro (&preserved_fns);
668
669 Qlist = intern ("list");
670 staticpro (&Qlist);
671
672 Qminus = intern ("-");
673 staticpro (&Qminus);
674
675 Qplus = intern ("+");
676 staticpro (&Qplus);
677
678 Qcall_interactively = intern ("call-interactively");
679 staticpro (&Qcall_interactively);
680
681 Qcommand_debug_status = intern ("command-debug-status");
682 staticpro (&Qcommand_debug_status);
683
684 Qenable_recursive_minibuffers = intern ("enable-recursive-minibuffers");
685 staticpro (&Qenable_recursive_minibuffers);
686
687 Qmouse_leave_buffer_hook = intern ("mouse-leave-buffer-hook");
688 staticpro (&Qmouse_leave_buffer_hook);
689
690 DEFVAR_KBOARD ("prefix-arg", Vprefix_arg,
691 "The value of the prefix argument for the next editing command.\n\
692 It may be a number, or the symbol `-' for just a minus sign as arg,\n\
693 or a list whose car is a number for just one or more C-U's\n\
694 or nil if no argument has been specified.\n\
695 \n\
696 You cannot examine this variable to find the argument for this command\n\
697 since it has been set to nil by the time you can look.\n\
698 Instead, you should use the variable `current-prefix-arg', although\n\
699 normally commands can get this prefix argument with (interactive \"P\").");
700
701 DEFVAR_LISP ("current-prefix-arg", &Vcurrent_prefix_arg,
702 "The value of the prefix argument for this editing command.\n\
703 It may be a number, or the symbol `-' for just a minus sign as arg,\n\
704 or a list whose car is a number for just one or more C-U's\n\
705 or nil if no argument has been specified.\n\
706 This is what `(interactive \"P\")' returns.");
707 Vcurrent_prefix_arg = Qnil;
708
709 DEFVAR_LISP ("command-history", &Vcommand_history,
710 "List of recent commands that read arguments from terminal.\n\
711 Each command is represented as a form to evaluate.");
712 Vcommand_history = Qnil;
713
714 DEFVAR_LISP ("command-debug-status", &Vcommand_debug_status,
715 "Debugging status of current interactive command.\n\
716 Bound each time `call-interactively' is called;\n\
717 may be set by the debugger as a reminder for itself.");
718 Vcommand_debug_status = Qnil;
719
720 DEFVAR_LISP ("mark-even-if-inactive", &Vmark_even_if_inactive,
721 "*Non-nil means you can use the mark even when inactive.\n\
722 This option makes a difference in Transient Mark mode.\n\
723 When the option is non-nil, deactivation of the mark\n\
724 turns off region highlighting, but commands that use the mark\n\
725 behave as if the mark were still active.");
726 Vmark_even_if_inactive = Qnil;
727
728 DEFVAR_LISP ("mouse-leave-buffer-hook", &Vmouse_leave_buffer_hook,
729 "Hook to run when about to switch windows with a mouse command.\n\
730 Its purpose is to give temporary modes such as Isearch mode\n\
731 a way to turn themselves off when a mouse command switches windows.");
732 Vmouse_leave_buffer_hook = Qnil;
733
734 defsubr (&Sinteractive);
735 defsubr (&Scall_interactively);
736 defsubr (&Sprefix_numeric_value);
737 }