emacs: src/lread.c comparison

comparison src/lread.c @ 9149:fe6b30db719d

(readchar, readchar, unreadchar, read_filtered_event, Fread, read0, read1, read_list, check_obarray, intern, Fintern, Fintern_soft, oblookup, init_lread): Use type test macros.

author	Karl Heuer <kwzh@gnu.org>
date	Tue, 27 Sep 1994 04:10:43 +0000
parents	93f3d6f5753c
children	5c66d8b65a7c

comparison

equal deleted inserted replaced

-:e7ab930bb7eb
+:fe6b30db719d
 {
 Lisp_Object tem;
 register struct buffer *inbuffer;
 register int c, mpos;
-if (XTYPE (readcharfun) == Lisp_Buffer)
+if (BUFFERP (readcharfun))
 {
 inbuffer = XBUFFER (readcharfun);
 if (BUF_PT (inbuffer) >= BUF_ZV (inbuffer))
 	return -1;
 c = *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer, BUF_PT (inbuffer));
 SET_BUF_PT (inbuffer, BUF_PT (inbuffer) + 1);
 return c;
 }
-if (XTYPE (readcharfun) == Lisp_Marker)
+if (MARKERP (readcharfun))
 {
 inbuffer = XMARKER (readcharfun)->buffer;
 mpos = marker_position (readcharfun);
 	}
 #endif
 return c;
 }
-if (XTYPE (readcharfun) == Lisp_String)
+if (STRINGP (readcharfun))
 {
 register int c;
 /* This used to be return of a conditional expression,
 	 but that truncated -1 to a char on VMS.  */
 if (read_from_string_index < read_from_string_limit)
 {
 if (c == -1)
 /* Don't back up the pointer if we're unreading the end-of-input mark,
 since readchar didn't advance it when we read it.  */
 ;
-else if (XTYPE (readcharfun) == Lisp_Buffer)
+else if (BUFFERP (readcharfun))
 {
 if (XBUFFER (readcharfun) == current_buffer)
 	SET_PT (point - 1);
 else
 	SET_BUF_PT (XBUFFER (readcharfun), BUF_PT (XBUFFER (readcharfun)) - 1);
 }
-else if (XTYPE (readcharfun) == Lisp_Marker)
+else if (MARKERP (readcharfun))
 XMARKER (readcharfun)->bufpos--;
-else if (XTYPE (readcharfun) == Lisp_String)
+else if (STRINGP (readcharfun))
 read_from_string_index--;
 else if (EQ (readcharfun, Qget_file_char))
 ungetc (c, instream);
 else
 call1 (readcharfun, make_number (c));
 /* Read until we get an acceptable event.  */
 retry:
 val = read_char (0, 0, 0, Qnil, 0);
-if (XTYPE (val) == Lisp_Buffer)
+if (BUFFERP (val))
 goto retry;
 /* switch-frame events are put off until after the next ASCII
 character.  This is better than signalling an error just because
 the last characters were typed to a separate minibuffer frame,
 }
 if (ascii_required)
 {
 /* Convert certain symbols to their ASCII equivalents.  */
-if (XTYPE (val) == Lisp_Symbol)
+if (SYMBOLP (val))
 	{
 	  Lisp_Object tem, tem1, tem2;
 	  tem = Fget (val, Qevent_symbol_element_mask);
 	  if (!NILP (tem))
 	    {
 		XFASTINT (val) = XINT (tem1) | XINT (Fcar (Fcdr (tem)));
 	    }
 	}
 /* If we don't have a character now, deal with it appropriately.  */
-if (XTYPE (val) != Lisp_Int)
+if (!INTEGERP (val))
 	{
 	  if (error_nonascii)
 	    {
 	      Vunread_command_events = Fcons (val, Qnil);
 	      error ("Non-character input-event");
 #ifndef standalone
 if (EQ (readcharfun, Qread_char))
 return Fread_minibuffer (build_string ("Lisp expression: "), Qnil);
 #endif
-if (XTYPE (readcharfun) == Lisp_String)
+if (STRINGP (readcharfun))
 return Fcar (Fread_from_string (readcharfun, Qnil, Qnil));
 return read0 (readcharfun);
 }
 {
 register Lisp_Object val;
 char c;
 val = read1 (readcharfun);
-if (XTYPE (val) == Lisp_Internal)
+if (INTERNALP (val))
 {
 c = XINT (val);
 return Fsignal (Qinvalid_read_syntax, Fcons (make_string (&c, 1), Qnil));
 }
 	  Lisp_Object tmp;
 	  struct gcpro gcpro1;
 	  /* Read the string itself.  */
 	  tmp = read1 (readcharfun);
-	  if (XTYPE (tmp) != Lisp_String)
+	  if (!STRINGP (tmp))
 	    Fsignal (Qinvalid_read_syntax, Fcons (make_string ("#", 1), Qnil));
 	  GCPRO1 (tmp);
 	  /* Read the intervals and their properties.  */
 	  while (1)
 	    {
 	      Lisp_Object beg, end, plist;
 	      beg = read1 (readcharfun);
-	      if (XTYPE (beg) == Lisp_Internal)
+	      if (INTERNALP (beg))
 		{
 		  if (XINT (beg) == ')')
 		    break;
 		  Fsignal (Qinvalid_read_syntax, Fcons (make_string ("invalid string property list", 28), Qnil));
 		}
 	      end = read1 (readcharfun);
-	      if (XTYPE (end) == Lisp_Internal)
+	      if (INTERNALP (end))
 		Fsignal (Qinvalid_read_syntax,
 			 Fcons (make_string ("invalid string property list", 28), Qnil));
 	      plist = read1 (readcharfun);
-	      if (XTYPE (plist) == Lisp_Internal)
+	      if (INTERNALP (plist))
 		Fsignal (Qinvalid_read_syntax,
 			 Fcons (make_string ("invalid string property list", 28), Qnil));
 	      Fset_text_properties (beg, end, plist, tmp);
 	    }
 	  UNGCPRO;
 while (1)
 {
 GCPRO2 (val, tail);
 elt = read1 (readcharfun);
 UNGCPRO;
-if (XTYPE (elt) == Lisp_Internal)
+if (INTERNALP (elt))
 	{
 	  if (flag > 0)
 	    {
 	      if (XINT (elt) == ']')
 		return val;
 		XCONS (tail)->cdr = read0 (readcharfun);
 	      else
 		val = read0 (readcharfun);
 	      elt = read1 (readcharfun);
 	      UNGCPRO;
-	      if (XTYPE (elt) == Lisp_Internal && XINT (elt) == ')')
+	      if (INTERNALP (elt) && XINT (elt) == ')')
 		return val;
 	      return Fsignal (Qinvalid_read_syntax, Fcons (make_string (". in wrong context", 18), Qnil));
 	    }
 	  return Fsignal (Qinvalid_read_syntax, Fcons (make_string ("] in a list", 11), Qnil));
 	}
 Lisp_Object
 check_obarray (obarray)
 Lisp_Object obarray;
 {
-while (XTYPE (obarray) != Lisp_Vector || XVECTOR (obarray)->size == 0)
+while (!VECTORP (obarray) || XVECTOR (obarray)->size == 0)
 {
 /* If Vobarray is now invalid, force it to be valid.  */
 if (EQ (Vobarray, obarray)) Vobarray = initial_obarray;
 obarray = wrong_type_argument (Qvectorp, obarray);
 Lisp_Object tem;
 int len = strlen (str);
 Lisp_Object obarray;
 obarray = Vobarray;
-if (XTYPE (obarray) != Lisp_Vector || XVECTOR (obarray)->size == 0)
+if (!VECTORP (obarray) || XVECTOR (obarray)->size == 0)
 obarray = check_obarray (obarray);
 tem = oblookup (obarray, str, len);
-if (XTYPE (tem) == Lisp_Symbol)
+if (SYMBOLP (tem))
 return tem;
 return Fintern ((!NILP (Vpurify_flag)
 		   ? make_pure_string (str, len)
 		   : make_string (str, len)),
 		  obarray);
 obarray = check_obarray (obarray);
 CHECK_STRING (str, 0);
 tem = oblookup (obarray, XSTRING (str)->data, XSTRING (str)->size);
-if (XTYPE (tem) != Lisp_Int)
+if (!INTEGERP (tem))
 return tem;
 if (!NILP (Vpurify_flag))
 str = Fpurecopy (str);
 sym = Fmake_symbol (str);
 ptr = &XVECTOR (obarray)->contents[XINT (tem)];
-if (XTYPE (*ptr) == Lisp_Symbol)
+if (SYMBOLP (*ptr))
 XSYMBOL (sym)->next = XSYMBOL (*ptr);
 else
 XSYMBOL (sym)->next = 0;
 *ptr = sym;
 return sym;
 obarray = check_obarray (obarray);
 CHECK_STRING (str, 0);
 tem = oblookup (obarray, XSTRING (str)->data, XSTRING (str)->size);
-if (XTYPE (tem) != Lisp_Int)
+if (!INTEGERP (tem))
 return tem;
 return Qnil;
 }
 Lisp_Object
 int hash;
 int obsize;
 register Lisp_Object tail;
 Lisp_Object bucket, tem;
-if (XTYPE (obarray) != Lisp_Vector
+if (!VECTORP (obarray)
 || (obsize = XVECTOR (obarray)->size) == 0)
 {
 obarray = check_obarray (obarray);
 obsize = XVECTOR (obarray)->size;
 }
 hash = hash_string (ptr, size);
 hash %= obsize;
 bucket = XVECTOR (obarray)->contents[hash];
 if (XFASTINT (bucket) == 0)
 ;
-else if (XTYPE (bucket) != Lisp_Symbol)
+else if (!SYMBOLP (bucket))
 error ("Bad data in guts of obarray"); /* Like CADR error message */
 else for (tail = bucket; ; XSET (tail, Lisp_Symbol, XSYMBOL (tail)->next))
 {
 	if (XSYMBOL (tail)->name->size == size &&
 	    !bcmp (XSYMBOL (tail)->name->data, ptr, size))
 	 !NILP (path_tail);
 	 path_tail = XCONS (path_tail)->cdr)
 {
 	Lisp_Object dirfile;
 	dirfile = Fcar (path_tail);
-	if (XTYPE (dirfile) == Lisp_String)
+	if (STRINGP (dirfile))
 	  {
 	    dirfile = Fdirectory_file_name (dirfile);
 	    if (access (XSTRING (dirfile)->data, 0) < 0)
 	      fprintf (stderr,
 		       "Warning: Lisp directory `%s' does not exist.\n",

Mercurial > emacs

comparison src/lread.c @ 9149:fe6b30db719d