emacs: src/eval.c comparison

comparison src/eval.c @ 9148:e7ab930bb7eb

(Fprogn, Finteractive_p, Fuser_variable_p, FletX, Flet, Fmacroexpand, Fcommandp, Fautoload, Feval, Fapply, Ffuncall, funcall_lambda, specbind): Use type test macros.

author	Karl Heuer <kwzh@gnu.org>
date	Tue, 27 Sep 1994 04:03:15 +0000
parents	e641b60610a1
children	ac852c183fa1

comparison

equal deleted inserted replaced

-:ee9adbda1ad1
+:e7ab930bb7eb
 /* In Mocklisp code, symbols at the front of the progn arglist
 are to be bound to zero. */
 if (!EQ (Vmocklisp_arguments, Qt))
 {
 val = make_number (0);
-while (!NILP (args) && (tem = Fcar (args), XTYPE (tem) == Lisp_Symbol))
+while (!NILP (args) && (tem = Fcar (args), SYMBOLP (tem)))
 	{
 	  QUIT;
 	  specbind (tem, val), args = Fcdr (args);
 	}
 }
 btp = backtrace_list;
 /* If this isn't a byte-compiled function, there may be a frame at
 the top for Finteractive_p itself.  If so, skip it.  */
 fun = Findirect_function (*btp->function);
-if (XTYPE (fun) == Lisp_Subr
+if (SUBRP (fun)
 && (struct Lisp_Subr *) XPNTR (fun) == &Sinteractive_p)
 btp = btp->next;
 /* If we're running an Emacs 18-style byte-compiled function, there
 may be a frame for Fbytecode.  Now, given the strictest
 /* btp now points at the frame of the innermost function that isn't
 a special form, ignoring frames for Finteractive_p and/or
 Fbytecode at the top.  If this frame is for a built-in function
 (such as load or eval-region) return nil.  */
 fun = Findirect_function (*btp->function);
-if (XTYPE (fun) == Lisp_Subr)
+if (SUBRP (fun))
 return Qnil;
 /* btp points to the frame of a Lisp function that called interactive-p.
 Return t if that function was called interactively.  */
 if (btp && btp->next && EQ (*btp->next->function, Qcall_interactively))
 return Qt;
 Lisp_Object variable;
 {
 Lisp_Object documentation;
 documentation = Fget (variable, Qvariable_documentation);
-if (XTYPE (documentation) == Lisp_Int && XINT (documentation) < 0)
+if (INTEGERP (documentation) && XINT (documentation) < 0)
 return Qt;
-if ((XTYPE (documentation) == Lisp_String) &&
+if ((STRINGP (documentation)) &&
 ((unsigned char) XSTRING (documentation)->data[0] == '*'))
 return Qt;
 return Qnil;
 }
 varlist = Fcar (args);
 while (!NILP (varlist))
 {
 QUIT;
 elt = Fcar (varlist);
-if (XTYPE (elt) == Lisp_Symbol)
+if (SYMBOLP (elt))
 	specbind (elt, Qnil);
 else if (! NILP (Fcdr (Fcdr (elt))))
 	Fsignal (Qerror,
 		 Fcons (build_string ("`let' bindings can have only one value-form"),
 			elt));
 for (argnum = 0; !NILP (varlist); varlist = Fcdr (varlist))
 {
 QUIT;
 elt = Fcar (varlist);
-if (XTYPE (elt) == Lisp_Symbol)
+if (SYMBOLP (elt))
 	temps [argnum++] = Qnil;
 else if (! NILP (Fcdr (Fcdr (elt))))
 	Fsignal (Qerror,
 		 Fcons (build_string ("`let' bindings can have only one value-form"),
 			elt));
 varlist = Fcar (args);
 for (argnum = 0; !NILP (varlist); varlist = Fcdr (varlist))
 {
 elt = Fcar (varlist);
 tem = temps[argnum++];
-if (XTYPE (elt) == Lisp_Symbol)
+if (SYMBOLP (elt))
 	specbind (elt, tem);
 else
 	specbind (Fcar (elt), tem);
 }
 while (1)
 {
 /* Come back here each time we expand a macro call,
 	 in case it expands into another macro call.  */
-if (XTYPE (form) != Lisp_Cons)
+if (!CONSP (form))
 	break;
 /* Set SYM, give DEF and TEM right values in case SYM is not a symbol. */
 def = sym = XCONS (form)->car;
 tem = Qnil;
 /* Trace symbols aliases to other symbols
 	 until we get a symbol that is not an alias.  */
-while (XTYPE (def) == Lisp_Symbol)
+while (SYMBOLP (def))
 	{
 	  QUIT;
 	  sym = def;
 	  tem = Fassq (sym, env);
 	  if (NILP (tem))
 	 and if TEM is nil then DEF is SYM's function definition.  */
 if (NILP (tem))
 	{
 	  /* SYM is not mentioned in ENV.
 	     Look at its function definition.  */
-	  if (EQ (def, Qunbound)
+	  if (EQ (def, Qunbound) || !CONSP (def))
-	      || XTYPE (def) != Lisp_Cons)
 	    /* Not defined or definition not suitable */
 	    break;
 	  if (EQ (XCONS (def)->car, Qautoload))
 	    {
 	      /* Autoloading function: will it be a macro when loaded?  */
 if (EQ (fun, Qunbound))
 return Qnil;
 /* Emacs primitives are interactive if their DEFUN specifies an
 interactive spec.  */
-if (XTYPE (fun) == Lisp_Subr)
+if (SUBRP (fun))
 {
 if (XSUBR (fun)->prompt)
 	return Qt;
 else
 	return Qnil;
 }
 /* Bytecode objects are interactive if they are long enough to
 have an element whose index is COMPILED_INTERACTIVE, which is
 where the interactive spec is stored.  */
-else if (XTYPE (fun) == Lisp_Compiled)
+else if (COMPILEDP (fun))
 return (XVECTOR (fun)->size > COMPILED_INTERACTIVE
 	    ? Qt : Qnil);
 /* Strings and vectors are keyboard macros.  */
-if (XTYPE (fun) == Lisp_String
+if (STRINGP (fun) || VECTORP (fun))
-|| XTYPE (fun) == Lisp_Vector)
 return Qt;
 /* Lists may represent commands.  */
 if (!CONSP (fun))
 return Qnil;
 funcar = Fcar (fun);
-if (XTYPE (funcar) != Lisp_Symbol)
+if (!SYMBOLP (funcar))
 return Fsignal (Qinvalid_function, Fcons (fun, Qnil));
 if (EQ (funcar, Qlambda))
 return Fassq (Qinteractive, Fcdr (Fcdr (fun)));
 if (EQ (funcar, Qmocklisp))
 return Qt;  /* All mocklisp functions can be called interactively */
 CHECK_SYMBOL (function, 0);
 CHECK_STRING (file, 1);
 /* If function is defined and not as an autoload, don't override */
 if (!EQ (XSYMBOL (function)->function, Qunbound)
-&& !(XTYPE (XSYMBOL (function)->function) == Lisp_Cons
+&& !(CONSP (XSYMBOL (function)->function)
 	   && EQ (XCONS (XSYMBOL (function)->function)->car, Qautoload)))
 return Qnil;
 #ifdef NO_ARG_ARRAY
 args[0] = file;
 Lisp_Object fun, val, original_fun, original_args;
 Lisp_Object funcar;
 struct backtrace backtrace;
 struct gcpro gcpro1, gcpro2, gcpro3;
-if (XTYPE (form) == Lisp_Symbol)
+if (SYMBOLP (form))
 {
 if (EQ (Vmocklisp_arguments, Qt))
 return Fsymbol_value (form);
 val = Fsymbol_value (form);
 if (NILP (val))
 /* At this point, only original_fun and original_args
 have values that will be used below */
 retry:
 fun = Findirect_function (original_fun);
-if (XTYPE (fun) == Lisp_Subr)
+if (SUBRP (fun))
 {
 Lisp_Object numargs;
 Lisp_Object argvals[7];
 Lisp_Object args_left;
 register int i, maxargs;
 	     subr to use a different argument protocol, or add more
 	     cases to this switch.  */
 	  abort ();
 	}
 }
-if (XTYPE (fun) == Lisp_Compiled)
+if (COMPILEDP (fun))
 val = apply_lambda (fun, original_args, 1);
 else
 {
 if (!CONSP (fun))
 	return Fsignal (Qinvalid_function, Fcons (fun, Qnil));
 funcar = Fcar (fun);
-if (XTYPE (funcar) != Lisp_Symbol)
+if (!SYMBOLP (funcar))
 	return Fsignal (Qinvalid_function, Fcons (fun, Qnil));
 if (EQ (funcar, Qautoload))
 	{
 	  do_autoload (fun, original_fun);
 	  goto retry;
 /* Let funcall get the error */
 fun = args[0];
 goto funcall;
 }
-if (XTYPE (fun) == Lisp_Subr)
+if (SUBRP (fun))
 {
 if (numargs < XSUBR (fun)->min_args
 	  || (XSUBR (fun)->max_args >= 0 && XSUBR (fun)->max_args < numargs))
 	goto funcall;		/* Let funcall get the error */
 else if (XSUBR (fun)->max_args > numargs)
 fun = args[0];
 fun = Findirect_function (fun);
-if (XTYPE (fun) == Lisp_Subr)
+if (SUBRP (fun))
 {
 if (numargs < XSUBR (fun)->min_args
 	  || (XSUBR (fun)->max_args >= 0 && XSUBR (fun)->max_args < numargs))
 	{
 	  XFASTINT (lisp_numargs) = numargs;
 	     or UNEVALLED, we need to extend this function to support it.
 	     Until this is done, there is no way to call the function.  */
 	  abort ();
 	}
 }
-if (XTYPE (fun) == Lisp_Compiled)
+if (COMPILEDP (fun))
 val = funcall_lambda (fun, numargs, args + 1);
 else
 {
 if (!CONSP (fun))
 	return Fsignal (Qinvalid_function, Fcons (fun, Qnil));
 funcar = Fcar (fun);
-if (XTYPE (funcar) != Lisp_Symbol)
+if (!SYMBOLP (funcar))
 	return Fsignal (Qinvalid_function, Fcons (fun, Qnil));
 if (EQ (funcar, Qlambda))
 	val = funcall_lambda (fun, numargs, args + 1);
 else if (EQ (funcar, Qmocklisp))
 	val = ml_apply (fun, Flist (numargs, args + 1));
 specbind (Qmocklisp_arguments, Qt);   /* t means NOT mocklisp! */
 XFASTINT (numargs) = nargs;
-if (XTYPE (fun) == Lisp_Cons)
+if (CONSP (fun))
 syms_left = Fcar (Fcdr (fun));
-else if (XTYPE (fun) == Lisp_Compiled)
+else if (COMPILEDP (fun))
 syms_left = XVECTOR (fun)->contents[COMPILED_ARGLIST];
 else abort ();
 i = 0;
 for (; !NILP (syms_left); syms_left = Fcdr (syms_left))
 {
 QUIT;
 next = Fcar (syms_left);
-while (XTYPE (next) != Lisp_Symbol)
+while (!SYMBOLP (next))
 	next = Fsignal (Qinvalid_function, Fcons (fun, Qnil));
 if (EQ (next, Qand_rest))
 	rest = 1;
 else if (EQ (next, Qand_optional))
 	optional = 1;
 }
 if (i < nargs)
 return Fsignal (Qwrong_number_of_arguments, Fcons (fun, Fcons (numargs, Qnil)));
-if (XTYPE (fun) == Lisp_Cons)
+if (CONSP (fun))
 val = Fprogn (Fcdr (Fcdr (fun)));
 else
 val = Fbyte_code (XVECTOR (fun)->contents[COMPILED_BYTECODE],
 		      XVECTOR (fun)->contents[COMPILED_CONSTANTS],
 		      XVECTOR (fun)->contents[COMPILED_STACK_DEPTH]);
 grow_specpdl ();
 specpdl_ptr->symbol = symbol;
 specpdl_ptr->func = 0;
 specpdl_ptr->old_value = ovalue = find_symbol_value (symbol);
 specpdl_ptr++;
-if (XTYPE (ovalue) == Lisp_Buffer_Objfwd)
+if (BUFFER_OBJFWDP (ovalue))
 store_symval_forwarding (symbol, ovalue, value);
 else
 Fset (symbol, value);
 }

Mercurial > emacs

comparison src/eval.c @ 9148:e7ab930bb7eb