407
|
1 /* Call a Lisp function interactively.
|
617
|
2 Copyright (C) 1985, 1986, 1992 Free Software Foundation, Inc.
|
407
|
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 1, 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"
|
516
|
25 #include "keyboard.h"
|
407
|
26 #include "window.h"
|
|
27 #include "mocklisp.h"
|
|
28
|
|
29 extern char *index ();
|
|
30
|
|
31 Lisp_Object Vprefix_arg, Vcurrent_prefix_arg, Qminus;
|
|
32 Lisp_Object Qcall_interactively;
|
|
33 Lisp_Object Vcommand_history;
|
|
34
|
|
35 Lisp_Object Vcommand_debug_status, Qcommand_debug_status;
|
|
36
|
|
37 /* This comment supplies the doc string for interactive,
|
|
38 for make-docfile to see. We cannot put this in the real DEFUN
|
|
39 due to limits in the Unix cpp.
|
|
40
|
|
41 DEFUN ("interactive", Ffoo, Sfoo, 0, 0, 0,
|
|
42 "Specify a way of parsing arguments for interactive use of a function.\n\
|
|
43 For example, write\n\
|
|
44 (defun foo (arg) \"Doc string\" (interactive \"p\") ...use arg...)\n\
|
|
45 to make ARG be the prefix argument when `foo' is called as a command.\n\
|
|
46 The \"call\" to `interactive' is actually a declaration rather than a function;\n\
|
|
47 it tells `call-interactively' how to read arguments\n\
|
|
48 to pass to the function.\n\
|
|
49 When actually called, `interactive' just returns nil.\n\
|
|
50 \n\
|
|
51 The argument of `interactive' is usually a string containing a code letter\n\
|
|
52 followed by a prompt. (Some code letters do not use I/O to get\n\
|
|
53 the argument and do not need prompts.) To prompt for multiple arguments,\n\
|
|
54 give a code letter, its prompt, a newline, and another code letter, etc.\n\
|
|
55 Prompts are passed to format, and may use % escapes to print the\n\
|
|
56 arguments that have already been read.\n\
|
|
57 If the argument is not a string, it is evaluated to get a list of\n\
|
|
58 arguments to pass to the function.\n\
|
|
59 Just `(interactive)' means pass no args when calling interactively.\n\
|
|
60 \nCode letters available are:\n\
|
|
61 a -- Function name: symbol with a function definition.\n\
|
|
62 b -- Name of existing buffer.\n\
|
|
63 B -- Name of buffer, possibly nonexistent.\n\
|
|
64 c -- Character.\n\
|
|
65 C -- Command name: symbol with interactive function definition.\n\
|
|
66 d -- Value of point as number. Does not do I/O.\n\
|
|
67 D -- Directory name.\n\
|
|
68 f -- Existing file name.\n\
|
|
69 F -- Possibly nonexistent file name.\n\
|
|
70 k -- Key sequence (string).\n\
|
438
|
71 K -- Mouse click that invoked this command - last-command-char.\n\
|
407
|
72 m -- Value of mark as number. Does not do I/O.\n\
|
|
73 n -- Number read using minibuffer.\n\
|
|
74 N -- Prefix arg converted to number, or if none, do like code `n'.\n\
|
|
75 p -- Prefix arg converted to number. Does not do I/O.\n\
|
|
76 P -- Prefix arg in raw form. Does not do I/O.\n\
|
|
77 r -- Region: point and mark as 2 numeric args, smallest first. Does no I/O.\n\
|
|
78 s -- Any string.\n\
|
|
79 S -- Any symbol.\n\
|
|
80 v -- Variable name: symbol that is user-variable-p.\n\
|
|
81 x -- Lisp expression read but not evaluated.\n\
|
|
82 X -- Lisp expression read and evaluated.\n\
|
|
83 In addition, if the string begins with `*'\n\
|
|
84 then an error is signaled if the buffer is read-only.\n\
|
|
85 This happens before reading any arguments.\n\
|
|
86 If the string begins with `@', then the window the mouse is over is selected\n\
|
|
87 before anything else is done. You may use both `@' and `*';\n\
|
|
88 they are processed in the order that they appear."
|
|
89 */
|
|
90
|
|
91 /* ARGSUSED */
|
|
92 DEFUN ("interactive", Finteractive, Sinteractive, 0, UNEVALLED, 0,
|
|
93 0 /* See immediately above */)
|
|
94 (args)
|
|
95 Lisp_Object args;
|
|
96 {
|
|
97 return Qnil;
|
|
98 }
|
|
99
|
|
100 /* Quotify EXP: if EXP is constant, return it.
|
|
101 If EXP is not constant, return (quote EXP). */
|
|
102 Lisp_Object
|
|
103 quotify_arg (exp)
|
|
104 register Lisp_Object exp;
|
|
105 {
|
|
106 if (XTYPE (exp) != Lisp_Int && XTYPE (exp) != Lisp_String
|
485
|
107 && !NILP (exp) && !EQ (exp, Qt))
|
407
|
108 return Fcons (Qquote, Fcons (exp, Qnil));
|
|
109
|
|
110 return exp;
|
|
111 }
|
|
112
|
|
113 /* Modify EXP by quotifying each element (except the first). */
|
|
114 Lisp_Object
|
|
115 quotify_args (exp)
|
|
116 Lisp_Object exp;
|
|
117 {
|
|
118 register Lisp_Object tail;
|
|
119 register struct Lisp_Cons *ptr;
|
|
120 for (tail = exp; CONSP (tail); tail = ptr->cdr)
|
|
121 {
|
|
122 ptr = XCONS (tail);
|
|
123 ptr->car = quotify_arg (ptr->car);
|
|
124 }
|
|
125 return exp;
|
|
126 }
|
|
127
|
|
128 char *callint_argfuns[]
|
|
129 = {"", "point", "mark", "region-beginning", "region-end"};
|
|
130
|
|
131 static void
|
|
132 check_mark ()
|
|
133 {
|
|
134 Lisp_Object tem = Fmarker_buffer (current_buffer->mark);
|
485
|
135 if (NILP (tem) || (XBUFFER (tem) != current_buffer))
|
407
|
136 error ("The mark is not set now");
|
|
137 }
|
|
138
|
|
139
|
|
140 DEFUN ("call-interactively", Fcall_interactively, Scall_interactively, 1, 2, 0,
|
|
141 "Call FUNCTION, reading args according to its interactive calling specs.\n\
|
|
142 The function contains a specification of how to do the argument reading.\n\
|
|
143 In the case of user-defined functions, this is specified by placing a call\n\
|
|
144 to the function `interactive' at the top level of the function body.\n\
|
|
145 See `interactive'.\n\
|
|
146 \n\
|
|
147 Optional second arg RECORD-FLAG non-nil\n\
|
|
148 means unconditionally put this command in the command-history.\n\
|
|
149 Otherwise, this is done only if an arg is read using the minibuffer.")
|
|
150 (function, record)
|
|
151 Lisp_Object function, record;
|
|
152 {
|
|
153 Lisp_Object *args, *visargs;
|
|
154 unsigned char **argstrings;
|
|
155 Lisp_Object fun;
|
|
156 Lisp_Object funcar;
|
|
157 Lisp_Object specs;
|
|
158 Lisp_Object teml;
|
|
159
|
|
160 Lisp_Object prefix_arg;
|
|
161 unsigned char *string;
|
|
162 unsigned char *tem;
|
438
|
163
|
|
164 /* If varies[i] > 0, the i'th argument shouldn't just have its value
|
|
165 in this call quoted in the command history. It should be
|
|
166 recorded as a call to the function named callint_argfuns[varies[i]]. */
|
407
|
167 int *varies;
|
438
|
168
|
407
|
169 register int i, j;
|
|
170 int count, foo;
|
|
171 char prompt[100];
|
|
172 char prompt1[100];
|
|
173 char *tem1;
|
|
174 int arg_from_tty = 0;
|
|
175 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
|
|
176
|
|
177 /* Save this now, since use ofminibuffer will clobber it. */
|
|
178 prefix_arg = Vcurrent_prefix_arg;
|
|
179
|
617
|
180 retry:
|
407
|
181
|
438
|
182 for (fun = function;
|
|
183 XTYPE (fun) == Lisp_Symbol && !EQ (fun, Qunbound);
|
|
184 fun = XSYMBOL (fun)->function)
|
617
|
185 {
|
|
186 QUIT;
|
|
187 }
|
407
|
188
|
|
189 specs = Qnil;
|
|
190 string = 0;
|
|
191
|
|
192 /* Decode the kind of function. Either handle it and return,
|
|
193 or go to `lose' if not interactive, or go to `retry'
|
|
194 to specify a different function, or set either STRING or SPECS. */
|
|
195
|
|
196 if (XTYPE (fun) == Lisp_Subr)
|
|
197 {
|
|
198 string = (unsigned char *) XSUBR (fun)->prompt;
|
|
199 if (!string)
|
|
200 {
|
|
201 lose:
|
|
202 function = wrong_type_argument (Qcommandp, function, 0);
|
|
203 goto retry;
|
|
204 }
|
|
205 if ((int) string == 1)
|
|
206 /* Let SPECS (which is nil) be used as the args. */
|
|
207 string = 0;
|
|
208 }
|
|
209 else if (XTYPE (fun) == Lisp_Compiled)
|
|
210 {
|
|
211 if (XVECTOR (fun)->size <= COMPILED_INTERACTIVE)
|
|
212 goto lose;
|
|
213 specs = XVECTOR (fun)->contents[COMPILED_INTERACTIVE];
|
|
214 }
|
|
215 else if (!CONSP (fun))
|
|
216 goto lose;
|
|
217 else if (funcar = Fcar (fun), EQ (funcar, Qautoload))
|
|
218 {
|
|
219 GCPRO2 (function, prefix_arg);
|
|
220 do_autoload (fun, function);
|
|
221 UNGCPRO;
|
|
222 goto retry;
|
|
223 }
|
|
224 else if (EQ (funcar, Qlambda))
|
|
225 {
|
|
226 specs = Fassq (Qinteractive, Fcdr (Fcdr (fun)));
|
485
|
227 if (NILP (specs))
|
407
|
228 goto lose;
|
|
229 specs = Fcar (Fcdr (specs));
|
|
230 }
|
|
231 else if (EQ (funcar, Qmocklisp))
|
|
232 return ml_apply (fun, Qinteractive);
|
|
233 else
|
|
234 goto lose;
|
|
235
|
617
|
236 /* If either specs or string is set to a string, use it. */
|
407
|
237 if (XTYPE (specs) == Lisp_String)
|
617
|
238 {
|
|
239 /* Make a copy of string so that if a GC relocates specs,
|
|
240 `string' will still be valid. */
|
|
241 string = (char *) alloca (XSTRING (specs)->size + 1);
|
|
242 bcopy (XSTRING (specs)->data, string, XSTRING (specs)->size + 1);
|
|
243 }
|
407
|
244 else if (string == 0)
|
|
245 {
|
|
246 i = num_input_chars;
|
|
247 specs = Feval (specs);
|
485
|
248 if (i != num_input_chars || !NILP (record))
|
407
|
249 Vcommand_history
|
|
250 = Fcons (Fcons (function, quotify_args (Fcopy_sequence (specs))),
|
|
251 Vcommand_history);
|
|
252 return apply1 (function, specs);
|
|
253 }
|
|
254
|
|
255 /* Here if function specifies a string to control parsing the defaults */
|
|
256
|
|
257 /* Handle special starting chars `*' and `@'. */
|
|
258 while (1)
|
|
259 {
|
|
260 if (*string == '*')
|
|
261 {
|
|
262 string++;
|
485
|
263 if (!NILP (current_buffer->read_only))
|
407
|
264 Fbarf_if_buffer_read_only ();
|
|
265 }
|
|
266 else if (*string == '@')
|
|
267 {
|
|
268 string++;
|
485
|
269 if (!NILP (Vmouse_window))
|
407
|
270 Fselect_window (Vmouse_window);
|
|
271 }
|
|
272 else break;
|
|
273 }
|
|
274
|
|
275 /* Count the number of arguments the interactive spec would have
|
|
276 us give to the function. */
|
|
277 tem = string;
|
|
278 for (j = 0; *tem; j++)
|
|
279 {
|
|
280 /* 'r' specifications ("point and mark as 2 numeric args")
|
|
281 produce *two* arguments. */
|
|
282 if (*tem == 'r') j++;
|
|
283 tem = (unsigned char *) index (tem, '\n');
|
|
284 if (tem)
|
|
285 tem++;
|
|
286 else
|
|
287 tem = (unsigned char *) "";
|
|
288 }
|
|
289 count = j;
|
|
290
|
|
291 args = (Lisp_Object *) alloca ((count + 1) * sizeof (Lisp_Object));
|
|
292 visargs = (Lisp_Object *) alloca ((count + 1) * sizeof (Lisp_Object));
|
|
293 argstrings = (unsigned char **) alloca ((count + 1) * sizeof (char *));
|
|
294 varies = (int *) alloca ((count + 1) * sizeof (int));
|
|
295
|
|
296 for (i = 0; i < (count + 1); i++)
|
|
297 {
|
|
298 args[i] = Qnil;
|
|
299 visargs[i] = Qnil;
|
|
300 varies[i] = 0;
|
|
301 }
|
|
302
|
|
303 GCPRO4 (prefix_arg, function, *args, *visargs);
|
|
304 gcpro3.nvars = (count + 1);
|
|
305 gcpro4.nvars = (count + 1);
|
|
306
|
|
307 tem = string;
|
617
|
308 for (i = 1; *tem; i++)
|
407
|
309 {
|
|
310 strncpy (prompt1, tem + 1, sizeof prompt1 - 1);
|
|
311 prompt1[sizeof prompt1 - 1] = 0;
|
|
312 tem1 = index (prompt1, '\n');
|
|
313 if (tem1) *tem1 = 0;
|
|
314 /* Fill argstrings with a vector of C strings
|
|
315 corresponding to the Lisp strings in visargs. */
|
|
316 for (j = 1; j < i; j++)
|
|
317 argstrings[j]
|
|
318 = EQ (visargs[j], Qnil)
|
|
319 ? (unsigned char *) ""
|
617
|
320 : XSTRING (visargs[j])->data;
|
407
|
321
|
|
322 doprnt (prompt, sizeof prompt, prompt1, 0, j - 1, argstrings + 1);
|
|
323
|
|
324 switch (*tem)
|
|
325 {
|
|
326 case 'a': /* Symbol defined as a function */
|
|
327 visargs[i] = Fcompleting_read (build_string (prompt),
|
|
328 Vobarray, Qfboundp, Qt, Qnil, Qnil);
|
|
329 /* Passing args[i] directly stimulates compiler bug */
|
|
330 teml = visargs[i];
|
|
331 args[i] = Fintern (teml, Qnil);
|
|
332 break;
|
|
333
|
|
334 case 'b': /* Name of existing buffer */
|
|
335 args[i] = Fcurrent_buffer ();
|
|
336 if (EQ (selected_window, minibuf_window))
|
|
337 args[i] = Fother_buffer (args[i]);
|
|
338 args[i] = Fread_buffer (build_string (prompt), args[i], Qt);
|
|
339 break;
|
|
340
|
|
341 case 'B': /* Name of buffer, possibly nonexistent */
|
|
342 args[i] = Fread_buffer (build_string (prompt),
|
|
343 Fother_buffer (Fcurrent_buffer ()), Qnil);
|
|
344 break;
|
|
345
|
|
346 case 'c': /* Character */
|
|
347 message1 (prompt);
|
|
348 args[i] = Fread_char ();
|
|
349 /* Passing args[i] directly stimulates compiler bug */
|
|
350 teml = args[i];
|
|
351 visargs[i] = Fchar_to_string (teml);
|
|
352 break;
|
|
353
|
|
354 case 'C': /* Command: symbol with interactive function */
|
|
355 visargs[i] = Fcompleting_read (build_string (prompt),
|
|
356 Vobarray, Qcommandp, Qt, Qnil, Qnil);
|
|
357 /* Passing args[i] directly stimulates compiler bug */
|
|
358 teml = visargs[i];
|
|
359 args[i] = Fintern (teml, Qnil);
|
|
360 break;
|
|
361
|
|
362 case 'd': /* Value of point. Does not do I/O. */
|
|
363 XFASTINT (args[i]) = point;
|
|
364 /* visargs[i] = Qnil; */
|
|
365 varies[i] = 1;
|
|
366 break;
|
|
367
|
|
368 case 'D': /* Directory name. */
|
|
369 args[i] = Fread_file_name (build_string (prompt), Qnil,
|
|
370 current_buffer->directory, Qlambda, Qnil);
|
|
371 break;
|
|
372
|
|
373 case 'f': /* Existing file name. */
|
|
374 args[i] = Fread_file_name (build_string (prompt),
|
|
375 Qnil, Qnil, Qlambda, Qnil);
|
|
376 break;
|
|
377
|
|
378 case 'F': /* Possibly nonexistent file name. */
|
|
379 args[i] = Fread_file_name (build_string (prompt),
|
|
380 Qnil, Qnil, Qnil, Qnil);
|
|
381 break;
|
|
382
|
|
383 case 'k': /* Key sequence (string) */
|
438
|
384 args[i] = Fread_key_sequence (build_string (prompt), Qnil);
|
407
|
385 teml = args[i];
|
|
386 visargs[i] = Fkey_description (teml);
|
|
387 break;
|
|
388
|
438
|
389 case 'K': /* Mouse click. */
|
|
390 args[i] = last_command_char;
|
485
|
391 if (NILP (Fmouse_click_p (args[i])))
|
438
|
392 error ("%s must be bound to a mouse click.",
|
|
393 (XTYPE (function) == Lisp_Symbol
|
|
394 ? (char *) XSYMBOL (function)->name->data
|
|
395 : "Command"));
|
|
396 break;
|
|
397
|
407
|
398 case 'm': /* Value of mark. Does not do I/O. */
|
|
399 check_mark ();
|
|
400 /* visargs[i] = Qnil; */
|
|
401 XFASTINT (args[i]) = marker_position (current_buffer->mark);
|
|
402 varies[i] = 2;
|
|
403 break;
|
|
404
|
|
405 case 'N': /* Prefix arg, else number from minibuffer */
|
485
|
406 if (!NILP (prefix_arg))
|
407
|
407 goto have_prefix_arg;
|
|
408 case 'n': /* Read number from minibuffer. */
|
|
409 do
|
|
410 args[i] = Fread_minibuffer (build_string (prompt), Qnil);
|
621
|
411 while (! NUMBERP (args[i]));
|
407
|
412 visargs[i] = last_minibuf_string;
|
|
413 break;
|
|
414
|
|
415 case 'P': /* Prefix arg in raw form. Does no I/O. */
|
|
416 have_prefix_arg:
|
|
417 args[i] = prefix_arg;
|
|
418 /* visargs[i] = Qnil; */
|
|
419 varies[i] = -1;
|
|
420 break;
|
|
421
|
|
422 case 'p': /* Prefix arg converted to number. No I/O. */
|
|
423 args[i] = Fprefix_numeric_value (prefix_arg);
|
|
424 /* visargs[i] = Qnil; */
|
|
425 varies[i] = -1;
|
|
426 break;
|
|
427
|
|
428 case 'r': /* Region, point and mark as 2 args. */
|
|
429 check_mark ();
|
|
430 /* visargs[i+1] = Qnil; */
|
|
431 foo = marker_position (current_buffer->mark);
|
|
432 /* visargs[i] = Qnil; */
|
|
433 XFASTINT (args[i]) = point < foo ? point : foo;
|
|
434 varies[i] = 3;
|
|
435 XFASTINT (args[++i]) = point > foo ? point : foo;
|
|
436 varies[i] = 4;
|
|
437 break;
|
|
438
|
|
439 case 's': /* String read via minibuffer. */
|
|
440 args[i] = Fread_string (build_string (prompt), Qnil);
|
|
441 break;
|
|
442
|
|
443 case 'S': /* Any symbol. */
|
|
444 visargs[i] = read_minibuf (Vminibuffer_local_ns_map,
|
|
445 Qnil,
|
|
446 build_string (prompt),
|
|
447 0);
|
|
448 /* Passing args[i] directly stimulates compiler bug */
|
|
449 teml = visargs[i];
|
|
450 args[i] = Fintern (teml, Qnil);
|
|
451 break;
|
|
452
|
|
453 case 'v': /* Variable name: symbol that is
|
|
454 user-variable-p. */
|
|
455 args[i] = Fread_variable (build_string (prompt));
|
|
456 visargs[i] = last_minibuf_string;
|
|
457 break;
|
|
458
|
|
459 case 'x': /* Lisp expression read but not evaluated */
|
|
460 args[i] = Fread_minibuffer (build_string (prompt), Qnil);
|
|
461 visargs[i] = last_minibuf_string;
|
|
462 break;
|
|
463
|
|
464 case 'X': /* Lisp expression read and evaluated */
|
|
465 args[i] = Feval_minibuffer (build_string (prompt), Qnil);
|
|
466 visargs[i] = last_minibuf_string;
|
|
467 break;
|
|
468
|
|
469 default:
|
|
470 error ("Invalid control letter \"%c\" (%03o) in interactive calling string",
|
|
471 *tem, *tem);
|
|
472 }
|
|
473
|
|
474 if (varies[i] == 0)
|
|
475 arg_from_tty = 1;
|
|
476
|
485
|
477 if (NILP (visargs[i]) && XTYPE (args[i]) == Lisp_String)
|
407
|
478 visargs[i] = args[i];
|
|
479
|
|
480 tem = (unsigned char *) index (tem, '\n');
|
|
481 if (tem) tem++;
|
|
482 else tem = (unsigned char *) "";
|
|
483 }
|
|
484
|
|
485 QUIT;
|
|
486
|
|
487 args[0] = function;
|
|
488
|
485
|
489 if (arg_from_tty || !NILP (record))
|
407
|
490 {
|
|
491 visargs[0] = function;
|
438
|
492 for (i = 1; i < count + 1; i++)
|
|
493 if (varies[i] > 0)
|
407
|
494 visargs[i] = Fcons (intern (callint_argfuns[varies[i]]), Qnil);
|
|
495 else
|
|
496 visargs[i] = quotify_arg (args[i]);
|
|
497 Vcommand_history = Fcons (Flist (count + 1, visargs),
|
|
498 Vcommand_history);
|
|
499 }
|
|
500
|
|
501 {
|
|
502 Lisp_Object val;
|
|
503 int speccount = specpdl_ptr - specpdl;
|
|
504 specbind (Qcommand_debug_status, Qnil);
|
|
505
|
|
506 val = Ffuncall (count + 1, args);
|
|
507 UNGCPRO;
|
|
508 return unbind_to (speccount, val);
|
|
509 }
|
|
510 }
|
|
511
|
|
512 DEFUN ("prefix-numeric-value", Fprefix_numeric_value, Sprefix_numeric_value,
|
|
513 1, 1, 0,
|
|
514 "Return numeric meaning of raw prefix argument ARG.\n\
|
|
515 A raw prefix argument is what you get from `(interactive \"P\")'.\n\
|
|
516 Its numeric meaning is what you would get from `(interactive \"p\")'.")
|
|
517 (raw)
|
|
518 Lisp_Object raw;
|
|
519 {
|
|
520 Lisp_Object val;
|
|
521
|
|
522 /* Tag val as an integer, so the rest of the assignments
|
|
523 may use XSETINT. */
|
|
524 XFASTINT (val) = 0;
|
|
525
|
485
|
526 if (NILP (raw))
|
407
|
527 XFASTINT (val) = 1;
|
|
528 else if (XTYPE (raw) == Lisp_Symbol)
|
|
529 XSETINT (val, -1);
|
|
530 else if (CONSP (raw))
|
|
531 XSETINT (val, XINT (XCONS (raw)->car));
|
|
532 else if (XTYPE (raw) == Lisp_Int)
|
|
533 val = raw;
|
|
534 else
|
|
535 XFASTINT (val) = 1;
|
|
536
|
|
537 return val;
|
|
538 }
|
|
539
|
|
540 syms_of_callint ()
|
|
541 {
|
|
542 Qminus = intern ("-");
|
|
543 staticpro (&Qminus);
|
|
544
|
|
545 Qcall_interactively = intern ("call-interactively");
|
|
546 staticpro (&Qcall_interactively);
|
|
547
|
|
548 Qcommand_debug_status = intern ("command-debug-status");
|
|
549 staticpro (&Qcommand_debug_status);
|
|
550
|
|
551 DEFVAR_LISP ("prefix-arg", &Vprefix_arg,
|
|
552 "The value of the prefix argument for the next editing command.\n\
|
|
553 It may be a number, or the symbol `-' for just a minus sign as arg,\n\
|
|
554 or a list whose car is a number for just one or more C-U's\n\
|
|
555 or nil if no argument has been specified.\n\
|
|
556 \n\
|
|
557 You cannot examine this variable to find the argument for this command\n\
|
|
558 since it has been set to nil by the time you can look.\n\
|
|
559 Instead, you should use the variable `current-prefix-arg', although\n\
|
|
560 normally commands can get this prefix argument with (interactive \"P\").");
|
|
561 Vprefix_arg = Qnil;
|
|
562
|
|
563 DEFVAR_LISP ("current-prefix-arg", &Vcurrent_prefix_arg,
|
|
564 "The value of the prefix argument for this editing command.\n\
|
|
565 It may be a number, or the symbol `-' for just a minus sign as arg,\n\
|
|
566 or a list whose car is a number for just one or more C-U's\n\
|
|
567 or nil if no argument has been specified.\n\
|
|
568 This is what `(interactive \"P\")' returns.");
|
|
569 Vcurrent_prefix_arg = Qnil;
|
|
570
|
|
571 DEFVAR_LISP ("command-history", &Vcommand_history,
|
|
572 "List of recent commands that read arguments from terminal.\n\
|
|
573 Each command is represented as a form to evaluate.");
|
|
574 Vcommand_history = Qnil;
|
|
575
|
|
576 DEFVAR_LISP ("command-debug-status", &Vcommand_debug_status,
|
|
577 "Debugging status of current interactive command.\n\
|
|
578 Bound each time `call-interactively' is called;\n\
|
|
579 may be set by the debugger as a reminder for itself.");
|
|
580 Vcommand_debug_status = Qnil;
|
|
581
|
|
582 defsubr (&Sinteractive);
|
|
583 defsubr (&Scall_interactively);
|
|
584 defsubr (&Sprefix_numeric_value);
|
|
585 }
|