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