src/callint.c

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