From ec28a64dd1b7db32ef2a3c643681c47862c43b65 Mon Sep 17 00:00:00 2001 From: "Michael I. Bushnell" Date: Sun, 25 Aug 1991 01:14:32 +0000 Subject: [PATCH] Initial revision --- src/callint.c | 569 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 569 insertions(+) create mode 100644 src/callint.c diff --git a/src/callint.c b/src/callint.c new file mode 100644 index 0000000000..f85ff113bc --- /dev/null +++ b/src/callint.c @@ -0,0 +1,569 @@ +/* Call a Lisp function interactively. + Copyright (C) 1985, 1986 Free Software Foundation, Inc. + +This file is part of GNU Emacs. + +GNU Emacs is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GNU Emacs is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Emacs; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + + +#include "config.h" +#include "lisp.h" +#include "buffer.h" +#include "commands.h" +#include "window.h" +#include "mocklisp.h" + +extern char *index (); + +Lisp_Object Vprefix_arg, Vcurrent_prefix_arg, Qminus; +Lisp_Object Qcall_interactively; +Lisp_Object Vcommand_history; + +Lisp_Object Vcommand_debug_status, Qcommand_debug_status; + +/* This comment supplies the doc string for interactive, + for make-docfile to see. We cannot put this in the real DEFUN + due to limits in the Unix cpp. + +DEFUN ("interactive", Ffoo, Sfoo, 0, 0, 0, + "Specify a way of parsing arguments for interactive use of a function.\n\ +For example, write\n\ + (defun foo (arg) \"Doc string\" (interactive \"p\") ...use arg...)\n\ +to make ARG be the prefix argument when `foo' is called as a command.\n\ +The \"call\" to `interactive' is actually a declaration rather than a function;\n\ + it tells `call-interactively' how to read arguments\n\ + to pass to the function.\n\ +When actually called, `interactive' just returns nil.\n\ +\n\ +The argument of `interactive' is usually a string containing a code letter\n\ + followed by a prompt. (Some code letters do not use I/O to get\n\ + the argument and do not need prompts.) To prompt for multiple arguments,\n\ + give a code letter, its prompt, a newline, and another code letter, etc.\n\ + Prompts are passed to format, and may use % escapes to print the\n\ + arguments that have already been read.\n\ +If the argument is not a string, it is evaluated to get a list of\n\ + arguments to pass to the function.\n\ +Just `(interactive)' means pass no args when calling interactively.\n\ +\nCode letters available are:\n\ +a -- Function name: symbol with a function definition.\n\ +b -- Name of existing buffer.\n\ +B -- Name of buffer, possibly nonexistent.\n\ +c -- Character.\n\ +C -- Command name: symbol with interactive function definition.\n\ +d -- Value of point as number. Does not do I/O.\n\ +D -- Directory name.\n\ +e -- Last mouse event.\n\ +f -- Existing file name.\n\ +F -- Possibly nonexistent file name.\n\ +k -- Key sequence (string).\n\ +m -- Value of mark as number. Does not do I/O.\n\ +n -- Number read using minibuffer.\n\ +N -- Prefix arg converted to number, or if none, do like code `n'.\n\ +p -- Prefix arg converted to number. Does not do I/O.\n\ +P -- Prefix arg in raw form. Does not do I/O.\n\ +r -- Region: point and mark as 2 numeric args, smallest first. Does no I/O.\n\ +s -- Any string.\n\ +S -- Any symbol.\n\ +v -- Variable name: symbol that is user-variable-p.\n\ +x -- Lisp expression read but not evaluated.\n\ +X -- Lisp expression read and evaluated.\n\ +In addition, if the string begins with `*'\n\ + then an error is signaled if the buffer is read-only.\n\ + This happens before reading any arguments.\n\ +If the string begins with `@', then the window the mouse is over is selected\n\ + before anything else is done. You may use both `@' and `*';\n\ +they are processed in the order that they appear." +*/ + +/* ARGSUSED */ +DEFUN ("interactive", Finteractive, Sinteractive, 0, UNEVALLED, 0, + 0 /* See immediately above */) + (args) + Lisp_Object args; +{ + return Qnil; +} + +/* Quotify EXP: if EXP is constant, return it. + If EXP is not constant, return (quote EXP). */ +Lisp_Object +quotify_arg (exp) + register Lisp_Object exp; +{ + if (XTYPE (exp) != Lisp_Int && XTYPE (exp) != Lisp_String + && !NULL (exp) && !EQ (exp, Qt)) + return Fcons (Qquote, Fcons (exp, Qnil)); + + return exp; +} + +/* Modify EXP by quotifying each element (except the first). */ +Lisp_Object +quotify_args (exp) + Lisp_Object exp; +{ + register Lisp_Object tail; + register struct Lisp_Cons *ptr; + for (tail = exp; CONSP (tail); tail = ptr->cdr) + { + ptr = XCONS (tail); + ptr->car = quotify_arg (ptr->car); + } + return exp; +} + +char *callint_argfuns[] + = {"", "point", "mark", "region-beginning", "region-end"}; + +static void +check_mark () +{ + Lisp_Object tem = Fmarker_buffer (current_buffer->mark); + if (NULL (tem) || (XBUFFER (tem) != current_buffer)) + error ("The mark is not set now"); +} + + +DEFUN ("call-interactively", Fcall_interactively, Scall_interactively, 1, 2, 0, + "Call FUNCTION, reading args according to its interactive calling specs.\n\ +The function contains a specification of how to do the argument reading.\n\ +In the case of user-defined functions, this is specified by placing a call\n\ +to the function `interactive' at the top level of the function body.\n\ +See `interactive'.\n\ +\n\ +Optional second arg RECORD-FLAG non-nil\n\ +means unconditionally put this command in the command-history.\n\ +Otherwise, this is done only if an arg is read using the minibuffer.") + (function, record) + Lisp_Object function, record; +{ + Lisp_Object *args, *visargs; + unsigned char **argstrings; + Lisp_Object fun; + Lisp_Object funcar; + Lisp_Object specs; + Lisp_Object teml; + + Lisp_Object prefix_arg; + unsigned char *string; + unsigned char *tem; + int *varies; + register int i, j; + int count, foo; + char prompt[100]; + char prompt1[100]; + char *tem1; + int arg_from_tty = 0; + struct gcpro gcpro1, gcpro2, gcpro3, gcpro4; + + /* Save this now, since use ofminibuffer will clobber it. */ + prefix_arg = Vcurrent_prefix_arg; + +retry: + + fun = function; + while (XTYPE (fun) == Lisp_Symbol && !EQ (fun, Qunbound)) fun = XSYMBOL (fun)->function; + + specs = Qnil; + string = 0; + + /* Decode the kind of function. Either handle it and return, + or go to `lose' if not interactive, or go to `retry' + to specify a different function, or set either STRING or SPECS. */ + + if (XTYPE (fun) == Lisp_Subr) + { + string = (unsigned char *) XSUBR (fun)->prompt; + if (!string) + { + lose: + function = wrong_type_argument (Qcommandp, function, 0); + goto retry; + } + if ((int) string == 1) + /* Let SPECS (which is nil) be used as the args. */ + string = 0; + } + else if (XTYPE (fun) == Lisp_Compiled) + { + if (XVECTOR (fun)->size <= COMPILED_INTERACTIVE) + goto lose; + specs = XVECTOR (fun)->contents[COMPILED_INTERACTIVE]; + } + else if (!CONSP (fun)) + goto lose; + else if (funcar = Fcar (fun), EQ (funcar, Qautoload)) + { + GCPRO2 (function, prefix_arg); + do_autoload (fun, function); + UNGCPRO; + goto retry; + } + else if (EQ (funcar, Qlambda)) + { + specs = Fassq (Qinteractive, Fcdr (Fcdr (fun))); + if (NULL (specs)) + goto lose; + specs = Fcar (Fcdr (specs)); + } + else if (EQ (funcar, Qmocklisp)) + return ml_apply (fun, Qinteractive); + else + goto lose; + + if (XTYPE (specs) == Lisp_String) + string = XSTRING (specs)->data; + else if (string == 0) + { + i = num_input_chars; + specs = Feval (specs); + if (i != num_input_chars || !NULL (record)) + Vcommand_history + = Fcons (Fcons (function, quotify_args (Fcopy_sequence (specs))), + Vcommand_history); + return apply1 (function, specs); + } + + /* Here if function specifies a string to control parsing the defaults */ + + /* Handle special starting chars `*' and `@'. */ + while (1) + { + if (*string == '*') + { + string++; + if (!NULL (current_buffer->read_only)) + Fbarf_if_buffer_read_only (); + } + else if (*string == '@') + { + string++; + if (!NULL (Vmouse_window)) + Fselect_window (Vmouse_window); + } + else break; + } + + /* Count the number of arguments the interactive spec would have + us give to the function. */ + tem = string; + for (j = 0; *tem; j++) + { + /* 'r' specifications ("point and mark as 2 numeric args") + produce *two* arguments. */ + if (*tem == 'r') j++; + tem = (unsigned char *) index (tem, '\n'); + if (tem) + tem++; + else + tem = (unsigned char *) ""; + } + count = j; + + args = (Lisp_Object *) alloca ((count + 1) * sizeof (Lisp_Object)); + visargs = (Lisp_Object *) alloca ((count + 1) * sizeof (Lisp_Object)); + argstrings = (unsigned char **) alloca ((count + 1) * sizeof (char *)); + varies = (int *) alloca ((count + 1) * sizeof (int)); + + for (i = 0; i < (count + 1); i++) + { + args[i] = Qnil; + visargs[i] = Qnil; + varies[i] = 0; + } + + GCPRO4 (prefix_arg, function, *args, *visargs); + gcpro3.nvars = (count + 1); + gcpro4.nvars = (count + 1); + + tem = string; + for (i = 1; *tem; i++) + { + strncpy (prompt1, tem + 1, sizeof prompt1 - 1); + prompt1[sizeof prompt1 - 1] = 0; + tem1 = index (prompt1, '\n'); + if (tem1) *tem1 = 0; + /* Fill argstrings with a vector of C strings + corresponding to the Lisp strings in visargs. */ + for (j = 1; j < i; j++) + argstrings[j] + = EQ (visargs[j], Qnil) + ? (unsigned char *) "" + : XSTRING (visargs[j])->data; + + doprnt (prompt, sizeof prompt, prompt1, 0, j - 1, argstrings + 1); + + switch (*tem) + { + case 'a': /* Symbol defined as a function */ + visargs[i] = Fcompleting_read (build_string (prompt), + Vobarray, Qfboundp, Qt, Qnil, Qnil); + /* Passing args[i] directly stimulates compiler bug */ + teml = visargs[i]; + args[i] = Fintern (teml, Qnil); + break; + + case 'b': /* Name of existing buffer */ + args[i] = Fcurrent_buffer (); + if (EQ (selected_window, minibuf_window)) + args[i] = Fother_buffer (args[i]); + args[i] = Fread_buffer (build_string (prompt), args[i], Qt); + break; + + case 'B': /* Name of buffer, possibly nonexistent */ + args[i] = Fread_buffer (build_string (prompt), + Fother_buffer (Fcurrent_buffer ()), Qnil); + break; + + case 'c': /* Character */ + message1 (prompt); + args[i] = Fread_char (); + /* Passing args[i] directly stimulates compiler bug */ + teml = args[i]; + visargs[i] = Fchar_to_string (teml); + break; + + case 'C': /* Command: symbol with interactive function */ + visargs[i] = Fcompleting_read (build_string (prompt), + Vobarray, Qcommandp, Qt, Qnil, Qnil); + /* Passing args[i] directly stimulates compiler bug */ + teml = visargs[i]; + args[i] = Fintern (teml, Qnil); + break; + + case 'd': /* Value of point. Does not do I/O. */ + XFASTINT (args[i]) = point; + /* visargs[i] = Qnil; */ + varies[i] = 1; + break; + + case 'e': + varies[i] = 1; + args[i] = Vmouse_event; + break; + + case 'D': /* Directory name. */ + args[i] = Fread_file_name (build_string (prompt), Qnil, + current_buffer->directory, Qlambda, Qnil); + break; + + case 'f': /* Existing file name. */ + args[i] = Fread_file_name (build_string (prompt), + Qnil, Qnil, Qlambda, Qnil); + break; + + case 'F': /* Possibly nonexistent file name. */ + args[i] = Fread_file_name (build_string (prompt), + Qnil, Qnil, Qnil, Qnil); + break; + + case 'k': /* Key sequence (string) */ + args[i] = Fread_key_sequence (build_string (prompt)); + teml = args[i]; + visargs[i] = Fkey_description (teml); + break; + + case 'm': /* Value of mark. Does not do I/O. */ + check_mark (); + /* visargs[i] = Qnil; */ + XFASTINT (args[i]) = marker_position (current_buffer->mark); + varies[i] = 2; + break; + + case 'N': /* Prefix arg, else number from minibuffer */ + if (!NULL (prefix_arg)) + goto have_prefix_arg; + case 'n': /* Read number from minibuffer. */ + do + args[i] = Fread_minibuffer (build_string (prompt), Qnil); +#ifdef LISP_FLOAT_TYPE + while (XTYPE (args[i]) != Lisp_Int + && XTYPE (args[i]) != Lisp_Float); +#else + while (XTYPE (args[i]) != Lisp_Int); +#endif + visargs[i] = last_minibuf_string; + break; + + case 'P': /* Prefix arg in raw form. Does no I/O. */ + have_prefix_arg: + args[i] = prefix_arg; + /* visargs[i] = Qnil; */ + varies[i] = -1; + break; + + case 'p': /* Prefix arg converted to number. No I/O. */ + args[i] = Fprefix_numeric_value (prefix_arg); + /* visargs[i] = Qnil; */ + varies[i] = -1; + break; + + case 'r': /* Region, point and mark as 2 args. */ + check_mark (); + /* visargs[i+1] = Qnil; */ + foo = marker_position (current_buffer->mark); + /* visargs[i] = Qnil; */ + XFASTINT (args[i]) = point < foo ? point : foo; + varies[i] = 3; + XFASTINT (args[++i]) = point > foo ? point : foo; + varies[i] = 4; + break; + + case 's': /* String read via minibuffer. */ + args[i] = Fread_string (build_string (prompt), Qnil); + break; + + case 'S': /* Any symbol. */ + visargs[i] = read_minibuf (Vminibuffer_local_ns_map, + Qnil, + build_string (prompt), + 0); + /* Passing args[i] directly stimulates compiler bug */ + teml = visargs[i]; + args[i] = Fintern (teml, Qnil); + break; + + case 'v': /* Variable name: symbol that is + user-variable-p. */ + args[i] = Fread_variable (build_string (prompt)); + visargs[i] = last_minibuf_string; + break; + + case 'x': /* Lisp expression read but not evaluated */ + args[i] = Fread_minibuffer (build_string (prompt), Qnil); + visargs[i] = last_minibuf_string; + break; + + case 'X': /* Lisp expression read and evaluated */ + args[i] = Feval_minibuffer (build_string (prompt), Qnil); + visargs[i] = last_minibuf_string; + break; + + default: + error ("Invalid control letter \"%c\" (%03o) in interactive calling string", + *tem, *tem); + } + + if (varies[i] == 0) + arg_from_tty = 1; + + if (NULL (visargs[i]) && XTYPE (args[i]) == Lisp_String) + visargs[i] = args[i]; + + tem = (unsigned char *) index (tem, '\n'); + if (tem) tem++; + else tem = (unsigned char *) ""; + } + + QUIT; + + args[0] = function; + + if (arg_from_tty || !NULL (record)) + { + visargs[0] = function; + for (i = 1; i < count + 1; i++ if (varies[i] > 0) + visargs[i] = Fcons (intern (callint_argfuns[varies[i]]), Qnil); + else + visargs[i] = quotify_arg (args[i]); + Vcommand_history = Fcons (Flist (count + 1, visargs), + Vcommand_history); + } + + { + Lisp_Object val; + int speccount = specpdl_ptr - specpdl; + specbind (Qcommand_debug_status, Qnil); + + val = Ffuncall (count + 1, args); + UNGCPRO; + return unbind_to (speccount, val); + } +} + +DEFUN ("prefix-numeric-value", Fprefix_numeric_value, Sprefix_numeric_value, + 1, 1, 0, + "Return numeric meaning of raw prefix argument ARG.\n\ +A raw prefix argument is what you get from `(interactive \"P\")'.\n\ +Its numeric meaning is what you would get from `(interactive \"p\")'.") + (raw) + Lisp_Object raw; +{ + Lisp_Object val; + + /* Tag val as an integer, so the rest of the assignments + may use XSETINT. */ + XFASTINT (val) = 0; + + if (NULL (raw)) + XFASTINT (val) = 1; + else if (XTYPE (raw) == Lisp_Symbol) + XSETINT (val, -1); + else if (CONSP (raw)) + XSETINT (val, XINT (XCONS (raw)->car)); + else if (XTYPE (raw) == Lisp_Int) + val = raw; + else + XFASTINT (val) = 1; + + return val; +} + +syms_of_callint () +{ + Qminus = intern ("-"); + staticpro (&Qminus); + + Qcall_interactively = intern ("call-interactively"); + staticpro (&Qcall_interactively); + + Qcommand_debug_status = intern ("command-debug-status"); + staticpro (&Qcommand_debug_status); + + DEFVAR_LISP ("prefix-arg", &Vprefix_arg, + "The value of the prefix argument for the next editing command.\n\ +It may be a number, or the symbol `-' for just a minus sign as arg,\n\ +or a list whose car is a number for just one or more C-U's\n\ +or nil if no argument has been specified.\n\ +\n\ +You cannot examine this variable to find the argument for this command\n\ +since it has been set to nil by the time you can look.\n\ +Instead, you should use the variable `current-prefix-arg', although\n\ +normally commands can get this prefix argument with (interactive \"P\")."); + Vprefix_arg = Qnil; + + DEFVAR_LISP ("current-prefix-arg", &Vcurrent_prefix_arg, + "The value of the prefix argument for this editing command.\n\ +It may be a number, or the symbol `-' for just a minus sign as arg,\n\ +or a list whose car is a number for just one or more C-U's\n\ +or nil if no argument has been specified.\n\ +This is what `(interactive \"P\")' returns."); + Vcurrent_prefix_arg = Qnil; + + DEFVAR_LISP ("command-history", &Vcommand_history, + "List of recent commands that read arguments from terminal.\n\ +Each command is represented as a form to evaluate."); + Vcommand_history = Qnil; + + DEFVAR_LISP ("command-debug-status", &Vcommand_debug_status, + "Debugging status of current interactive command.\n\ +Bound each time `call-interactively' is called;\n\ +may be set by the debugger as a reminder for itself."); + Vcommand_debug_status = Qnil; + + defsubr (&Sinteractive); + defsubr (&Scall_interactively); + defsubr (&Sprefix_numeric_value); +} -- 2.20.1