emacs: src/fns.c comparison

comparison src/fns.c @ 485:8c615e453683

*** empty log message ***

author	Jim Blandy <jimb@redhat.com>
date	Mon, 13 Jan 1992 21:48:08 +0000
parents	4c9349866dac
children	540b047ece4d

comparison

equal deleted inserted replaced

-:3165b2697c78
+:8c615e453683
 /* Note on some machines this defines `vector' as a typedef,
 so make sure we don't use that name in this file.  */
 #undef vector
 #define vector *****
-#ifdef NULL
-#undef NULL
-#endif
 #include "lisp.h"
 #include "commands.h"
 #ifdef MULTI_SCREEN
 #include "screen.h"
 if (XTYPE (obj) == Lisp_Vector || XTYPE (obj) == Lisp_String
 || XTYPE (obj) == Lisp_Compiled)
 return Farray_length (obj);
 else if (CONSP (obj))
 {
-for (i = 0, tail = obj; !NULL(tail); i++)
+for (i = 0, tail = obj; !NILP(tail); i++)
 	{
 	  QUIT;
 	  tail = Fcdr (tail);
 	}
 XFASTINT (val) = i;
 return val;
 }
-else if (NULL(obj))
+else if (NILP(obj))
 {
 XFASTINT (val) = 0;
 return val;
 }
 else
 The elements of a list or vector are not copied; they are shared\n\
 with the original.")
 (arg)
 Lisp_Object arg;
 {
-if (NULL (arg)) return arg;
+if (NILP (arg)) return arg;
 if (!CONSP (arg) && XTYPE (arg) != Lisp_Vector && XTYPE (arg) != Lisp_String)
 arg = wrong_type_argument (Qsequencep, arg);
 return concat (1, &arg, CONSP (arg) ? Lisp_Cons : XTYPE (arg), 0);
 }
 last_tail = Qnil;
 for (argnum = 0; argnum < nargs; argnum++)
 {
 this = args[argnum];
-if (!(CONSP (this) || NULL (this)
+if (!(CONSP (this) || NILP (this)
 	    || XTYPE (this) == Lisp_Vector || XTYPE (this) == Lisp_String
 	    || XTYPE (this) == Lisp_Compiled))
 	{
 	  if (XTYPE (this) == Lisp_Int)
 args[argnum] = Fint_to_string (this);
 while (1)
 	{
 	  register Lisp_Object elt;
 	  /* Fetch next element of `this' arg into `elt', or break if `this' is exhausted. */
-	  if (NULL (this)) break;
+	  if (NILP (this)) break;
 	  if (CONSP (this))
 	    elt = Fcar (this), this = Fcdr (this);
 	  else
 	    {
 	      if (thisindex >= thisleni) break;
 #endif
 	      }
 	    }
 	}
 }
-if (!NULL (prev))
+if (!NILP (prev))
 XCONS (prev)->cdr = last_tail;
 return val;
 }
 Lisp_Object alist;
 {
 register Lisp_Object tem;
 CHECK_LIST (alist, 0);
-if (NULL (alist))
+if (NILP (alist))
 return alist;
 alist = concat (1, &alist, Lisp_Cons, 0);
 for (tem = alist; CONSP (tem); tem = XCONS (tem)->cdr)
 {
 register Lisp_Object car;
 Lisp_Object string;
 register Lisp_Object from, to;
 {
 CHECK_STRING (string, 0);
 CHECK_NUMBER (from, 1);
-if (NULL (to))
+if (NILP (to))
 to = Flength (string);
 else
 CHECK_NUMBER (to, 2);
 if (XINT (from) < 0)
 register Lisp_Object list;
 {
 register int i, num;
 CHECK_NUMBER (n, 0);
 num = XINT (n);
-for (i = 0; i < num && !NULL (list); i++)
+for (i = 0; i < num && !NILP (list); i++)
 {
 QUIT;
 list = Fcdr (list);
 }
 return list;
 register Lisp_Object seq, n;
 {
 CHECK_NUMBER (n, 0);
 while (1)
 {
-if (XTYPE (seq) == Lisp_Cons || NULL (seq))
+if (XTYPE (seq) == Lisp_Cons || NILP (seq))
 	return Fcar (Fnthcdr (n, seq));
 else if (XTYPE (seq) == Lisp_String
 	       || XTYPE (seq) == Lisp_Vector)
 	return Faref (seq, n);
 else
 (elt, list)
 register Lisp_Object elt;
 Lisp_Object list;
 {
 register Lisp_Object tail;
-for (tail = list; !NULL (tail); tail = Fcdr (tail))
+for (tail = list; !NILP (tail); tail = Fcdr (tail))
 {
 register Lisp_Object tem;
 tem = Fcar (tail);
-if (! NULL (Fequal (elt, tem)))
+if (! NILP (Fequal (elt, tem)))
 	return tail;
 QUIT;
 }
 return Qnil;
 }
 (elt, list)
 register Lisp_Object elt;
 Lisp_Object list;
 {
 register Lisp_Object tail;
-for (tail = list; !NULL (tail); tail = Fcdr (tail))
+for (tail = list; !NILP (tail); tail = Fcdr (tail))
 {
 register Lisp_Object tem;
 tem = Fcar (tail);
 if (EQ (elt, tem)) return tail;
 QUIT;
 (key, list)
 register Lisp_Object key;
 Lisp_Object list;
 {
 register Lisp_Object tail;
-for (tail = list; !NULL (tail); tail = Fcdr (tail))
+for (tail = list; !NILP (tail); tail = Fcdr (tail))
 {
 register Lisp_Object elt, tem;
 elt = Fcar (tail);
 if (!CONSP (elt)) continue;
 tem = Fcar (elt);
 (key, list)
 register Lisp_Object key;
 Lisp_Object list;
 {
 register Lisp_Object tail;
-for (tail = list; !NULL (tail); tail = Fcdr (tail))
+for (tail = list; !NILP (tail); tail = Fcdr (tail))
 {
 register Lisp_Object elt, tem;
 elt = Fcar (tail);
 if (!CONSP (elt)) continue;
 tem = Fequal (Fcar (elt), key);
-if (!NULL (tem)) return elt;
+if (!NILP (tem)) return elt;
 QUIT;
 }
 return Qnil;
 }
 (key, list)
 register Lisp_Object key;
 Lisp_Object list;
 {
 register Lisp_Object tail;
-for (tail = list; !NULL (tail); tail = Fcdr (tail))
+for (tail = list; !NILP (tail); tail = Fcdr (tail))
 {
 register Lisp_Object elt, tem;
 elt = Fcar (tail);
 if (!CONSP (elt)) continue;
 tem = Fcdr (elt);
 register Lisp_Object tail, prev;
 register Lisp_Object tem;
 tail = list;
 prev = Qnil;
-while (!NULL (tail))
+while (!NILP (tail))
 {
 tem = Fcar (tail);
 if (EQ (elt, tem))
 	{
-	  if (NULL (prev))
+	  if (NILP (prev))
 	    list = Fcdr (tail);
 	  else
 	    Fsetcdr (prev, Fcdr (tail));
 	}
 else
 register Lisp_Object tail, prev;
 register Lisp_Object tem;
 tail = list;
 prev = Qnil;
-while (!NULL (tail))
+while (!NILP (tail))
 {
 tem = Fcar (tail);
 if (Fequal (elt, tem))
 	{
-	  if (NULL (prev))
+	  if (NILP (prev))
 	    list = Fcdr (tail);
 	  else
 	    Fsetcdr (prev, Fcdr (tail));
 	}
 else
 (list)
 Lisp_Object list;
 {
 register Lisp_Object prev, tail, next;
-if (NULL (list)) return list;
+if (NILP (list)) return list;
 prev = Qnil;
 tail = list;
-while (!NULL (tail))
+while (!NILP (tail))
 {
 QUIT;
 next = Fcdr (tail);
 Fsetcdr (tail, prev);
 prev = tail;
 back into the org_ vars.  */
 GCPRO4 (org_l1, org_l2, pred, value);
 while (1)
 {
-if (NULL (l1))
+if (NILP (l1))
 	{
 	  UNGCPRO;
-	  if (NULL (tail))
+	  if (NILP (tail))
 	    return l2;
 	  Fsetcdr (tail, l2);
 	  return value;
 	}
-if (NULL (l2))
+if (NILP (l2))
 	{
 	  UNGCPRO;
-	  if (NULL (tail))
+	  if (NILP (tail))
 	    return l1;
 	  Fsetcdr (tail, l1);
 	  return value;
 	}
 tem = call2 (pred, Fcar (l2), Fcar (l1));
-if (NULL (tem))
+if (NILP (tem))
 	{
 	  tem = l1;
 	  l1 = Fcdr (l1);
 	  org_l1 = l1;
 	}
 	{
 	  tem = l2;
 	  l2 = Fcdr (l2);
 	  org_l2 = l2;
 	}
-if (NULL (tail))
+if (NILP (tail))
 	value = tem;
 else
 	Fsetcdr (tail, tem);
 tail = tem;
 }
 (sym, prop)
 Lisp_Object sym;
 register Lisp_Object prop;
 {
 register Lisp_Object tail;
-for (tail = Fsymbol_plist (sym); !NULL (tail); tail = Fcdr (Fcdr (tail)))
+for (tail = Fsymbol_plist (sym); !NILP (tail); tail = Fcdr (Fcdr (tail)))
 {
 register Lisp_Object tem;
 tem = Fcar (tail);
 if (EQ (prop, tem))
 	return Fcar (Fcdr (tail));
 Lisp_Object val;
 {
 register Lisp_Object tail, prev;
 Lisp_Object newcell;
 prev = Qnil;
-for (tail = Fsymbol_plist (sym); !NULL (tail); tail = Fcdr (Fcdr (tail)))
+for (tail = Fsymbol_plist (sym); !NILP (tail); tail = Fcdr (Fcdr (tail)))
 {
 register Lisp_Object tem;
 tem = Fcar (tail);
 if (EQ (prop, tem))
 	return Fsetcar (Fcdr (tail), val);
 prev = tail;
 }
 newcell = Fcons (prop, Fcons (val, Qnil));
-if (NULL (prev))
+if (NILP (prev))
 Fsetplist (sym, newcell);
 else
 Fsetcdr (Fcdr (prev), newcell);
 return val;
 }
 if (XINT (o1) == XINT (o2)) return Qt;
 if (XTYPE (o1) == Lisp_Cons)
 {
 Lisp_Object v1;
 v1 = Fequal (Fcar (o1), Fcar (o2), depth + 1);
-if (NULL (v1))
+if (NILP (v1))
 	return v1;
 o1 = Fcdr (o1), o2 = Fcdr (o2);
 goto do_cdr;
 }
 if (XTYPE (o1) == Lisp_Marker)
 	{
 	  Lisp_Object v, v1, v2;
 	  v1 = XVECTOR (o1)->contents [index];
 	  v2 = XVECTOR (o2)->contents [index];
 	  v = Fequal (v1, v2, depth + 1);
-	  if (NULL (v)) return v;
+	  if (NILP (v)) return v;
 	}
 return Qt;
 }
 if (XTYPE (o1) == Lisp_String)
 {
 val = Qnil;
 for (argnum = 0; argnum < nargs; argnum++)
 {
 tem = args[argnum];
-if (NULL (tem)) continue;
+if (NILP (tem)) continue;
-if (NULL (val))
+if (NILP (val))
 	val = tem;
 if (argnum + 1 == nargs) break;
 if (!CONSP (tem))
 	  QUIT;
 	}
 tem = args[argnum + 1];
 Fsetcdr (tail, tem);
-if (NULL (tem))
+if (NILP (tem))
 	args[argnum + 1] = tail;
 }
 return val;
 }
 Lisp_Object feature;
 {
 register Lisp_Object tem;
 CHECK_SYMBOL (feature, 0);
 tem = Fmemq (feature, Vfeatures);
-return (NULL (tem)) ? Qnil : Qt;
+return (NILP (tem)) ? Qnil : Qt;
 }
 DEFUN ("provide", Fprovide, Sprovide, 1, 1, 0,
 "Announce that FEATURE is a feature of the current Emacs.")
 (feature)
 Lisp_Object feature;
 {
 register Lisp_Object tem;
 CHECK_SYMBOL (feature, 0);
-if (!NULL (Vautoload_queue))
+if (!NILP (Vautoload_queue))
 Vautoload_queue = Fcons (Fcons (Vfeatures, Qnil), Vautoload_queue);
 tem = Fmemq (feature, Vfeatures);
-if (NULL (tem))
+if (NILP (tem))
 Vfeatures = Fcons (feature, Vfeatures);
 return feature;
 }
 DEFUN ("require", Frequire, Srequire, 1, 2, 0,
 Lisp_Object feature, file_name;
 {
 register Lisp_Object tem;
 CHECK_SYMBOL (feature, 0);
 tem = Fmemq (feature, Vfeatures);
-if (NULL (tem))
+if (NILP (tem))
 {
 int count = specpdl_ptr - specpdl;
 /* Value saved here is to be restored into Vautoload_queue */
 record_unwind_protect (un_autoload, Vautoload_queue);
 Vautoload_queue = Qt;
-Fload (NULL (file_name) ? Fsymbol_name (feature) : file_name,
+Fload (NILP (file_name) ? Fsymbol_name (feature) : file_name,
 	     Qnil, Qt, Qnil);
 tem = Fmemq (feature, Vfeatures);
-if (NULL (tem))
+if (NILP (tem))
 	error ("Required feature %s was not provided",
 	       XSYMBOL (feature)->name->data );
 /* Once loading finishes, don't undo it.  */
 Vautoload_queue = Qt;

Mercurial > emacs

comparison src/fns.c @ 485:8c615e453683