emacs: src/lread.c comparison

comparison src/lread.c @ 485:8c615e453683

*** empty log message ***

author	Jim Blandy <jimb@redhat.com>
date	Mon, 13 Jan 1992 21:48:08 +0000
parents	ffdbf3445088
children	63a8e7b3c547

comparison

equal deleted inserted replaced

-:3165b2697c78
+:8c615e453683
 return c;
 }
 tem = call0 (readcharfun);
-if (NULL (tem))
+if (NILP (tem))
 return -1;
 return XINT (tem);
 }
 /* Unread the character C in the way appropriate for the stream READCHARFUN.
 /* Avoid weird lossage with null string as arg,
 since it would try to load a directory as a Lisp file */
 if (XSTRING (str)->size > 0)
 {
-fd = openp (Vload_path, str, !NULL (nosuffix) ? "" : ".elc:.el:",
+fd = openp (Vload_path, str, !NILP (nosuffix) ? "" : ".elc:.el:",
 		  &found, 0);
 }
 if (fd < 0)
 {
-if (NULL (noerror))
+if (NILP (noerror))
 	while (1)
 	  Fsignal (Qfile_error, Fcons (build_string ("Cannot open load file"),
 				       Fcons (str, Qnil)));
 else
 	return Qnil;
 {
 close (fd);
 error ("Failure to create stdio stream for %s", XSTRING (str)->data);
 }
-if (NULL (nomessage))
+if (NILP (nomessage))
 message ("Loading %s...", XSTRING (str)->data);
 GCPRO1 (str);
 /* We may not be able to store STREAM itself as a Lisp_Object pointer
 since that is guaranteed to work only for data that has been malloc'd.
 readevalloop (Qget_file_char, stream, Feval, 0);
 unbind_to (count, Qnil);
 /* Run any load-hooks for this file.  */
 temp = Fassoc (str, Vafter_load_alist);
-if (!NULL (temp))
+if (!NILP (temp))
 Fprogn (Fcdr (temp));
 UNGCPRO;
-if (!noninteractive && NULL (nomessage))
+if (!noninteractive && NILP (nomessage))
 message ("Loading %s...done", XSTRING (str)->data);
 return Qt;
 }
 static Lisp_Object
 *storeptr = Qnil;
 if (complete_filename_p (str))
 absolute = 1;
-for (; !NULL (path); path = Fcdr (path))
+for (; !NILP (path); path = Fcdr (path))
 {
 char *nsuffix;
 filename = Fexpand_file_name (str, Fcar (path));
 if (!complete_filename_p (filename))
 	  continue;
 	}
 if (c < 0) break;
 if (c == ' ' || c == '\t' || c == '\n' || c == '\f') continue;
-if (!NULL (Vpurify_flag) && c == '(')
+if (!NILP (Vpurify_flag) && c == '(')
 	{
 	  record_unwind_protect (unreadpure, Qnil);
 	  val = read_list (-1, readcharfun);
 	  unbind_to (count + 1, Qnil);
 	}
 Lisp_Object printflag;
 {
 int count = specpdl_ptr - specpdl;
 Lisp_Object tem;
-if (NULL (printflag))
+if (NILP (printflag))
 tem = Qsymbolp;
 else
 tem = printflag;
 specbind (Qstandard_output, tem);
 record_unwind_protect (save_excursion_restore, save_excursion_save ());
 SET_PT (BEGV);
-readevalloop (Fcurrent_buffer (), 0, Feval, !NULL (printflag));
+readevalloop (Fcurrent_buffer (), 0, Feval, !NILP (printflag));
 return unbind_to (count, Qnil);
 }
 DEFUN ("eval-region", Feval_region, Seval_region, 2, 3, "r",
 "Execute the region as Lisp code.\n\
 Lisp_Object b, e, printflag;
 {
 int count = specpdl_ptr - specpdl;
 Lisp_Object tem;
-if (NULL (printflag))
+if (NILP (printflag))
 tem = Qsymbolp;
 else
 tem = printflag;
 specbind (Qstandard_output, tem);
-if (NULL (printflag))
+if (NILP (printflag))
 record_unwind_protect (save_excursion_restore, save_excursion_save ());
 record_unwind_protect (save_restriction_restore, save_restriction_save ());
 /* This both uses b and checks its type.  */
 Fgoto_char (b);
 Fnarrow_to_region (make_number (BEGV), e);
-readevalloop (Fcurrent_buffer (), 0, Feval, !NULL (printflag));
+readevalloop (Fcurrent_buffer (), 0, Feval, !NILP (printflag));
 return unbind_to (count, Qnil);
 }
 #endif /* standalone */
 (readcharfun)
 Lisp_Object readcharfun;
 {
 extern Lisp_Object Fread_minibuffer ();
-if (NULL (readcharfun))
+if (NILP (readcharfun))
 readcharfun = Vstandard_input;
 if (EQ (readcharfun, Qt))
 readcharfun = Qread_char;
 #ifndef standalone
 int startval, endval;
 Lisp_Object tem;
 CHECK_STRING (string,0);
-if (NULL (end))
+if (NILP (end))
 endval = XSTRING (string)->size;
 else
 { CHECK_NUMBER (end,2);
 endval = XINT (end);
 if (endval < 0 || endval > XSTRING (string)->size)
 	args_out_of_range (string, end);
 }
-if (NULL (start))
+if (NILP (start))
 startval = 0;
 else
 { CHECK_NUMBER (start,1);
 startval = XINT (start);
 if (startval < 0 || startval > endval)
 {
 register int c = READCHAR;
 switch (c)
 {
 case 'a':
-return '\a';
+return '\007';
 case 'b':
 return '\b';
 case 'e':
 return 033;
 case 'f':
 	if (c < 0) return Fsignal (Qend_of_file, Qnil);
 	/* If purifying, and string starts with \ newline,
 	   return zero instead.  This is for doc strings
 	   that we are really going to find in share-lib/DOC.nn.nn  */
-	if (!NULL (Vpurify_flag) && NULL (Vdoc_file_name) && cancel)
+	if (!NILP (Vpurify_flag) && NILP (Vdoc_file_name) && cancel)
 	  return make_number (0);
 	if (read_pure)
 	  return make_pure_string (read_buffer, p - read_buffer);
 	else
 	  if (XINT (elt) == ')')
 	    return val;
 	  if (XINT (elt) == '.')
 	    {
 	      GCPRO2 (val, tail);
-	      if (!NULL (tail))
+	      if (!NILP (tail))
 		XCONS (tail)->cdr = read0 (readcharfun);
 	      else
 		val = read0 (readcharfun);
 	      elt = read1 (readcharfun);
 	      UNGCPRO;
 	  return Fsignal (Qinvalid_read_syntax, Fcons (make_string ("] in a list", 11), Qnil));
 	}
 tem = (read_pure && flag <= 0
 	     ? pure_cons (elt, Qnil)
 	     : Fcons (elt, Qnil));
-if (!NULL (tail))
+if (!NILP (tail))
 	XCONS (tail)->cdr = tem;
 else
 	val = tem;
 tail = tem;
 if (defunflag < 0)
 if (XTYPE (obarray) != Lisp_Vector || XVECTOR (obarray)->size == 0)
 obarray = check_obarray (obarray);
 tem = oblookup (obarray, str, len);
 if (XTYPE (tem) == Lisp_Symbol)
 return tem;
-return Fintern ((!NULL (Vpurify_flag)
+return Fintern ((!NILP (Vpurify_flag)
 		   ? make_pure_string (str, len)
 		   : make_string (str, len)),
 		  obarray);
 }
 (str, obarray)
 Lisp_Object str, obarray;
 {
 register Lisp_Object tem, sym, *ptr;
-if (NULL (obarray)) obarray = Vobarray;
+if (NILP (obarray)) obarray = Vobarray;
 obarray = check_obarray (obarray);
 CHECK_STRING (str, 0);
 tem = oblookup (obarray, XSTRING (str)->data, XSTRING (str)->size);
 if (XTYPE (tem) != Lisp_Int)
 return tem;
-if (!NULL (Vpurify_flag))
+if (!NILP (Vpurify_flag))
 str = Fpurecopy (str);
 sym = Fmake_symbol (str);
 ptr = &XVECTOR (obarray)->contents[XINT (tem)];
 if (XTYPE (*ptr) == Lisp_Symbol)
 (str, obarray)
 Lisp_Object str, obarray;
 {
 register Lisp_Object tem;
-if (NULL (obarray)) obarray = Vobarray;
+if (NILP (obarray)) obarray = Vobarray;
 obarray = check_obarray (obarray);
 CHECK_STRING (str, 0);
 tem = oblookup (obarray, XSTRING (str)->data, XSTRING (str)->size);
 (function, obarray)
 Lisp_Object function, obarray;
 {
 Lisp_Object tem;
-if (NULL (obarray)) obarray = Vobarray;
+if (NILP (obarray)) obarray = Vobarray;
 obarray = check_obarray (obarray);
 map_obarray (obarray, mapatoms_1, function);
 return Qnil;
 }
 Vload_path = normal_path;
 }
 /* Warn if dirs in the *standard* path don't exist.  */
-for (; !NULL (normal_path); normal_path = XCONS (normal_path)->cdr)
+for (; !NILP (normal_path); normal_path = XCONS (normal_path)->cdr)
 {
 Lisp_Object dirfile;
 dirfile = Fcar (normal_path);
-if (!NULL (dirfile))
+if (!NILP (dirfile))
 	{
 	  dirfile = Fdirectory_file_name (dirfile);
 	  if (access (XSTRING (dirfile)->data, 0) < 0)
 	    printf ("Warning: lisp library (%s) does not exist.\n",
 		    XSTRING (Fcar (normal_path))->data);
 }
 if (egetenv ("EMACSLOADPATH"))
 Vload_path = decode_env_path ("EMACSLOADPATH", normal);
 #ifndef CANNOT_DUMP
-if (!NULL (Vpurify_flag))
+if (!NILP (Vpurify_flag))
 Vload_path = Fcons (build_string ("../lisp"), Vload_path);
 #endif
 Vvalues = Qnil;

Mercurial > emacs

comparison src/lread.c @ 485:8c615e453683