Coverity fix CI:203 REVERSE_INULL

[sxemacs] / src / callint.c

/* Call a Lisp function interactively.
   Copyright (C) 1985, 1986, 1992, 1993, 1994 Free Software Foundation, Inc.
   Copyright (C) 1995, 1996 Ben Wing.

This file is part of SXEmacs

SXEmacs 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 3 of the License, or
(at your option) any later version.

SXEmacs 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 this program.  If not, see <http://www.gnu.org/licenses/>. */


/* Synched up with: FSF 19.30, Mule 2.0. */

/* Authorship:

   FSF: long ago.
   Mly or JWZ: various changes.
 */

#include <config.h>
#include "lisp.h"

#include "buffer.h"
#include "bytecode.h"
#include "commands.h"
#define INCLUDE_EVENTS_H_PRIVATE_SPHERE
#include "events/events.h"
#include "ui/insdel.h"
#include "ui/window.h"

extern Charcount num_input_chars;

Lisp_Object Vcurrent_prefix_arg;
Lisp_Object Qcall_interactively;
Lisp_Object Vcommand_history;

Lisp_Object Vcommand_debug_status, Qcommand_debug_status;
Lisp_Object Qenable_recursive_minibuffers;

#if 0                           /* FSFmacs */
/* Non-nil means treat the mark as active
   even if mark_active is 0.  */
Lisp_Object Vmark_even_if_inactive;
#endif

#if 0                           /* ill-conceived */
/* FSF calls Qmouse_leave_buffer_hook at all sorts of random places,
   including a bunch of places in their mouse.el.  If this is
   implemented, it has to be done cleanly. */
Lisp_Object Vmouse_leave_buffer_hook, Qmouse_leave_buffer_hook;
#endif

Lisp_Object QletX, Qsave_excursion;

Lisp_Object Qread_from_minibuffer;
Lisp_Object Qread_file_name;
Lisp_Object Qread_directory_name;
Lisp_Object Qcompleting_read;
Lisp_Object Qread_buffer;
Lisp_Object Qread_function;
Lisp_Object Qread_variable;
Lisp_Object Qread_expression;
Lisp_Object Qread_command;
Lisp_Object Qread_number;
Lisp_Object Qread_string;
Lisp_Object Qevents_to_keys;

#if defined(MULE) || defined(FILE_CODING)
Lisp_Object Qread_coding_system;
Lisp_Object Qread_non_nil_coding_system;
#endif

/* ARGSUSED */
DEFUN("interactive", Finteractive, 0, UNEVALLED, 0,     /*
Specify a way of parsing arguments for interactive use of a function.
For example, write
(defun foo (arg) "Doc string" (interactive "p") ...use arg...)
to make ARG be the prefix argument when `foo' is called as a command.
The "call" to `interactive' is actually a declaration rather than a function;
it tells `call-interactively' how to read arguments
to pass to the function.
When actually called, `interactive' just returns nil.

The argument of `interactive' is usually a string containing a code letter
followed by a prompt.  (Some code letters do not use I/O to get
the argument and do not need prompts.)  To prompt for multiple arguments,
give a code letter, its prompt, a newline, and another code letter, etc.
Prompts are passed to format, and may use % escapes to print the
arguments that have already been read.
If the argument is not a string, it is evaluated to get a list of
arguments to pass to the function.
Just `(interactive)' means pass no args when calling interactively.

Code letters available are:
a -- Function name: symbol with a function definition.
b -- Name of existing buffer.
B -- Name of buffer, possibly nonexistent.
c -- Character.
C -- Command name: symbol with interactive function definition.
d -- Value of point as number.  Does not do I/O.
D -- Directory name.
e -- Last mouse-button or misc-user event that invoked this command.
If used more than once, the Nth `e' returns the Nth such event.
Does not do I/O.
f -- Existing file name.
F -- Possibly nonexistent file name.
i -- Always nil, ignore.  Use to skip arguments when interactive.
k -- Key sequence (a vector of events).
K -- Key sequence to be redefined (do not automatically down-case).
m -- Value of mark as number.  Does not do I/O.
n -- Number read using minibuffer.
N -- Prefix arg converted to number, or if none, do like code `n'.
p -- Prefix arg converted to number.  Does not do I/O.
P -- Prefix arg in raw form.  Does not do I/O.
r -- Region: point and mark as 2 numeric args, smallest first.  Does no I/O.
s -- Any string.
S -- Any symbol.
v -- Variable name: symbol that is user-variable-p.
x -- Lisp expression read but not evaluated.
X -- Lisp expression read and evaluated.
z -- Coding system. (Always nil if no Mule support.)
Z -- Coding system, nil if no prefix arg. (Always nil if no Mule support.)
In addition, if the string begins with `*'
then an error is signaled if the buffer is read-only.
This happens before reading any arguments.
If the string begins with `@', then the window the mouse is over is selected
before anything else is done.
If the string begins with `_', then this command will not cause the region
to be deactivated when it completes; that is, `zmacs-region-stays' will be
set to t when the command exits successfully.
You may use any of `@', `*' and `_' at the beginning of the string;
they are processed in the order that they appear.
*/
      (args))
{
        return Qnil;
}

/* Originally, this was just a function -- but `custom' used a
   garden-variety version, so why not make it a subr?  */
/* #### Move it to another file! */
DEFUN("quote-maybe", Fquote_maybe, 1, 1, 0,     /*
Quote EXPR if it is not self quoting.
*/
      (expr))
{
        return ((NILP(expr)
                 || EQ(expr, Qt)
                 || INTP(expr)
                 || FLOATP(expr)
                 || CHARP(expr)
                 || STRINGP(expr)
                 || VECTORP(expr)
                 || KEYWORDP(expr)
                 || BIT_VECTORP(expr)
                 || (CONSP(expr) && EQ(XCAR(expr), Qlambda)))
                ? expr : list2(Qquote, expr));
}

/* Modify EXPR by quotifying each element (except the first).  */
static Lisp_Object quotify_args(Lisp_Object expr)
{
        Lisp_Object tail;
        Lisp_Cons *ptr;
        for (tail = expr; CONSP(tail); tail = ptr->cdr) {
                ptr = XCONS(tail);
                ptr->car = Fquote_maybe(ptr->car);
        }
        return expr;
}

static Bufpos check_mark(void)
{
        Lisp_Object tem;

        if (zmacs_regions && !zmacs_region_active_p)
                error("The region is not active now");

        tem = Fmarker_buffer(current_buffer->mark);
        if (NILP(tem) || (XBUFFER(tem) != current_buffer))
                error("The mark is not set now");

        return marker_position(current_buffer->mark);
}

static Lisp_Object
callint_prompt(const Bufbyte * prompt_start, Bytecount prompt_length,
               const Lisp_Object *args, int nargs)
{
        Lisp_Object s = make_string(prompt_start, prompt_length);
        struct gcpro gcpro1;

        /* Fformat no longer smashes its arg vector, so no need to copy it. */

        if (!strchr((char*)XSTRING_DATA(s), '%')) {
                return s;
        }
        GCPRO1(s);
        RETURN_UNGCPRO(emacs_doprnt_string_lisp(0, s, 0, nargs, args));
}

/* `lambda' for RECORD-FLAG is an XEmacs addition. */

DEFUN("call-interactively", Fcall_interactively, 1, 3, 0,       /*
Call FUNCTION, reading args according to its interactive calling specs.