xemacs-beta: src/data.c comparison

comparison src/data.c @ 16:0293115a14e9 r19-15b91

Import from CVS: tag r19-15b91

author	cvs
date	Mon, 13 Aug 2007 08:49:20 +0200
parents	376386a54a3c
children	859a2309aef8

comparison

equal deleted inserted replaced

-:ad457d5f7d04
+:0293115a14e9
 	 if (INTP (value) && EQ (predicate, Qstringp))
 	   return Fnumber_to_string (value);
 	 if (CHARP (value) && EQ (predicate, Qstringp))
 	   return Fchar_to_string (value);
 	}
-#endif
+#endif /* MOCKLISP_SUPPORT */
 value = Fsignal (Qwrong_type_argument, list2 (predicate, value));
 tem = call1 (predicate, value);
 }
 while (NILP (tem));
 return value;
 /* characters do not need to sign extend so there's no need for special
 futzing like with ints. */
 Lisp_Object
 make_char (Emchar num)
 {
-return make_int (num);
+Lisp_Object val;
+val = make_int (num);
+return val;
 }
 /* Data type predicates */
 DEFUN ("eq", Feq, Seq, 2, 2, 0 /*
 T if the two args are the same Lisp object.
 */ )
 (obj1, obj2)
 Lisp_Object obj1, obj2;
 {
-if (EQ (obj1, obj2))
+return EQ (obj1, obj2) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("null", Fnull, Snull, 1, 1, 0 /*
 T if OBJECT is nil.
 */ )
 (object)
 Lisp_Object object;
 {
-if (NILP (object))
+return NILP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("consp", Fconsp, Sconsp, 1, 1, 0 /*
 T if OBJECT is a cons cell.
 */ )
 (object)
 Lisp_Object object;
 {
-if (CONSP (object))
+return CONSP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("atom", Fatom, Satom, 1, 1, 0 /*
 T if OBJECT is not a cons cell.  This includes nil.
 */ )
 (object)
 Lisp_Object object;
 {
-if (CONSP (object))
+return CONSP (object) ? Qnil : Qt;
-return Qnil;
-return Qt;
 }
 DEFUN ("listp", Flistp, Slistp, 1, 1, 0 /*
 T if OBJECT is a list.  This includes nil.
 */ )
 (object)
 Lisp_Object object;
 {
-if (CONSP (object) || NILP (object))
+return (CONSP (object) || NILP (object)) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("nlistp", Fnlistp, Snlistp, 1, 1, 0 /*
 T if OBJECT is not a list.  Lists include nil.
 */ )
 (object)
 Lisp_Object object;
 {
-if (CONSP (object) || NILP (object))
+return (CONSP (object) || NILP (object)) ? Qnil : Qt;
-return Qnil;
-return Qt;
 }
 DEFUN ("symbolp", Fsymbolp, Ssymbolp, 1, 1, 0 /*
 T if OBJECT is a symbol.
 */ )
 (object)
 Lisp_Object object;
 {
-if (SYMBOLP (object))
+return SYMBOLP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("keywordp", Fkeywordp, Skeywordp, 1, 1, 0 /*
 T if OBJECT is a keyword.
 */ )
 (object)
 Lisp_Object object;
 {
-if (KEYWORDP (object))
+return KEYWORDP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("vectorp", Fvectorp, Svectorp, 1, 1, 0 /*
 T if OBJECT is a vector.
 */ )
 (object)
 Lisp_Object object;
 {
-if (VECTORP (object))
+return VECTORP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("bit-vector-p", Fbit_vector_p, Sbit_vector_p, 1, 1, 0 /*
 T if OBJECT is a bit vector.
 */ )
 (object)
 Lisp_Object object;
 {
-if (BIT_VECTORP (object))
+return BIT_VECTORP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("stringp", Fstringp, Sstringp, 1, 1, 0 /*
 T if OBJECT is a string.
 */ )
 (object)
 Lisp_Object object;
 {
-if (STRINGP (object))
+return STRINGP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("arrayp", Farrayp, Sarrayp, 1, 1, 0 /*
 T if OBJECT is an array (string, vector, or bit vector).
 */ )
 (object)
 Lisp_Object object;
 {
-if (VECTORP (object) || STRINGP (object) || BIT_VECTORP (object))
+return (VECTORP     (object) ||
-return Qt;
+	  STRINGP     (object) ||
-return Qnil;
+	  BIT_VECTORP (object))
+? Qt : Qnil;
 }
 DEFUN ("sequencep", Fsequencep, Ssequencep, 1, 1, 0 /*
 T if OBJECT is a sequence (list or array).
 */ )
 (object)
 Lisp_Object object;
 {
-if (CONSP (object) || NILP (object)
+return (CONSP       (object) ||
-|| VECTORP (object) || STRINGP (object) || BIT_VECTORP (object))
+	  NILP        (object) ||
-return Qt;
+	  VECTORP     (object) ||
-return Qnil;
+	  STRINGP     (object) ||
+	  BIT_VECTORP (object))
+? Qt : Qnil;
 }
 DEFUN ("markerp", Fmarkerp, Smarkerp, 1, 1, 0 /*
 T if OBJECT is a marker (editor pointer).
 */ )
 (object)
 Lisp_Object object;
 {
-if (MARKERP (object))
+return MARKERP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("subrp", Fsubrp, Ssubrp, 1, 1, 0 /*
 T if OBJECT is a built-in function.
 */ )
 (object)
 Lisp_Object object;
 {
-if (SUBRP (object))
+return SUBRP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("subr-min-args", Fsubr_min_args, Ssubr_min_args, 1, 1, 0 /*
 Return minimum number of args built-in function SUBR may be called with.
 */ )
 return make_int (XSUBR (subr)->min_args);
 }
 DEFUN ("subr-max-args", Fsubr_max_args, Ssubr_max_args, 1, 1, 0 /*
 Return maximum number of args built-in function SUBR may be called with,
-or nil if it takes an arbitrary number of arguments (or is a special form).
+or nil if it takes an arbitrary number of arguments or is a special form.
 */ )
 (subr)
 Lisp_Object subr;
 {
 int nargs;
 t if OBJECT is a byte-compiled function object.
 */ )
 (object)
 Lisp_Object object;
 {
-if (COMPILED_FUNCTIONP (object))
+return COMPILED_FUNCTIONP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("characterp", Fcharacterp, Scharacterp, 1, 1, 0 /*
 t if OBJECT is a character.
 modded with 256 to get the actual character to use.
 */ )
 (object)
 Lisp_Object object;
 {
-if (CHARP (object))
+return CHARP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("char-or-string-p", Fchar_or_string_p, Schar_or_string_p, 1, 1, 0 /*
 t if OBJECT is a character or a string.
 */ )
 (object)
 Lisp_Object object;
 {
-if (CHAR_OR_CHAR_INTP (object) || STRINGP (object))
+return CHAR_OR_CHAR_INTP (object) || STRINGP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("integerp", Fintegerp, Sintegerp, 1, 1, 0 /*
 t if OBJECT is an integer.
 */ )
 (object)
 Lisp_Object object;
 {
-if (INTP (object))
+return INTP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("integer-or-marker-p", Finteger_or_marker_p, Sinteger_or_marker_p,
 1, 1, 0 /*
 t if OBJECT is an integer or a marker (editor pointer).
 */ )
 (object)
 Lisp_Object object;
 {
-if (INTP (object) || MARKERP (object))
+return INTP (object) || MARKERP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("natnump", Fnatnump, Snatnump, 1, 1, 0 /*
 t if OBJECT is a nonnegative integer.
 */ )
 (object)
 Lisp_Object object;
 {
-if (NATNUMP (object))
+return NATNUMP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("bitp", Fbitp, Sbitp, 1, 1, 0 /*
 t if OBJECT is a bit (0 or 1).
 */ )
 (object)
 Lisp_Object object;
 {
-if (BITP (object))
+return BITP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("numberp", Fnumberp, Snumberp, 1, 1, 0 /*
 t if OBJECT is a number (floating point or integer).
 */ )
 (object)
 Lisp_Object object;
 {
-if (INT_OR_FLOATP (object))
+return INT_OR_FLOATP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("number-or-marker-p", Fnumber_or_marker_p, Snumber_or_marker_p, 1, 1, 0 /*
 t if OBJECT is a number or a marker.
 */ )
 (object)
 Lisp_Object object;
 {
-if (INT_OR_FLOATP (object)
+return INT_OR_FLOATP (object) || MARKERP (object) ? Qt : Qnil;
-|| MARKERP (object))
-return Qt;
-return Qnil;
 }
 #ifdef LISP_FLOAT_TYPE
 DEFUN ("floatp", Ffloatp, Sfloatp, 1, 1, 0 /*
 t if OBJECT is a floating point number.
 */ )
 (object)
 Lisp_Object object;
 {
-if (FLOATP (object))
+return FLOATP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 #endif /* LISP_FLOAT_TYPE */
 DEFUN ("type-of", Ftype_of, Stype_of, 1, 1, 0 /*
 Return a symbol representing the type of OBJECT.
 */ )
 (object)
 Lisp_Object object;
 {
-if (CONSP (object))
+if (CONSP    (object)) return Qcons;
-return Qcons;
+if (SYMBOLP  (object)) return Qsymbol;
-if (SYMBOLP (object))
+if (KEYWORDP (object)) return Qkeyword;
-return Qsymbol;
+if (INTP     (object)) return Qinteger;
-if (KEYWORDP (object))
+if (STRINGP  (object)) return Qstring;
-return Qkeyword;
+if (VECTORP  (object)) return Qvector;
-if (INTP (object))
-return Qinteger;
-if (STRINGP (object))
-return Qstring;
-if (VECTORP (object))
-return Qvector;
 assert (LRECORDP (object));
 return intern (XRECORD_LHEADER (object)->implementation->name);
 }
 Return the car of OBJECT if it is a cons cell, or else nil.
 */ )
 (object)
 Lisp_Object object;
 {
-if (CONSP (object))
+return CONSP (object) ? XCAR (object) : Qnil;
-return XCAR (object);
-else
-return Qnil;
 }
 DEFUN ("cdr", Fcdr, Scdr, 1, 1, 0 /*
 Return the cdr of LIST.  If arg is nil, return nil.
 Error if arg is not nil and not a cons cell.  See also `cdr-safe'.
 Return the cdr of OBJECT if it is a cons cell, or else  nil.
 */ )
 (object)
 Lisp_Object object;
 {
-if (CONSP (object))
+return CONSP (object) ? XCDR (object) : Qnil;
-return XCDR (object);
-else
-return Qnil;
 }
 DEFUN ("setcar", Fsetcar, Ssetcar, 2, 2, 0 /*
 Set the car of CONSCELL to be NEWCAR.  Returns NEWCAR.
 */ )
 error if the chain ends up unbound.  */
 Lisp_Object
 indirect_function (Lisp_Object object, int errorp)
 {
 Lisp_Object tortoise = object;
-Lisp_Object hare = object;
+Lisp_Object hare     = object;
 for (;;)
 {
 if (!SYMBOLP (hare) || UNBOUNDP (hare))
 	break;
 /**********************************************************************/
 enum comparison { equal, notequal, less, grtr, less_or_equal, grtr_or_equal };
 static Lisp_Object
-arithcompare (Lisp_Object num1, Lisp_Object num2,
+arithcompare (Lisp_Object num1, Lisp_Object num2, enum comparison comparison)
-enum comparison comparison)
+{
-{
-int floatp = 0;
 CHECK_INT_OR_FLOAT_COERCE_CHAR_OR_MARKER (num1);
 CHECK_INT_OR_FLOAT_COERCE_CHAR_OR_MARKER (num2);
 #ifdef LISP_FLOAT_TYPE
 if (FLOATP (num1) || FLOATP (num2))
 {
-double f1, f2;
+double f1 = (FLOATP (num1)) ? float_data (XFLOAT (num1)) : XINT (num1);
+double f2 = (FLOATP (num2)) ? float_data (XFLOAT (num2)) : XINT (num2);
-floatp = 1;
-f1 = (FLOATP (num1)) ? float_data (XFLOAT (num1)) : XINT (num1);
-f2 = (FLOATP (num2)) ? float_data (XFLOAT (num2)) : XINT (num2);
 switch (comparison)
-{
+	{
-case equal:
+	case equal:         return f1 == f2 ? Qt : Qnil;
-if (f1 == f2)
+	case notequal:      return f1 != f2 ? Qt : Qnil;
-return Qt;
+	case less:          return f1 <  f2 ? Qt : Qnil;
-return Qnil;
+	case less_or_equal: return f1 <= f2 ? Qt : Qnil;
+	case grtr:          return f1 >  f2 ? Qt : Qnil;
-case notequal:
+	case grtr_or_equal: return f1 >= f2 ? Qt : Qnil;
-if (f1 != f2)
+	}
-return Qt;
-return Qnil;
-case less:
-if (f1 < f2)
-return Qt;
-return Qnil;
-case less_or_equal:
-if (f1 <= f2)
-return Qt;
-return Qnil;
-case grtr:
-if (f1 > f2)
-return Qt;
-return Qnil;
-case grtr_or_equal:
-if (f1 >= f2)
-return Qt;
-return Qnil;
-}
 }
 #endif /* LISP_FLOAT_TYPE */
-else
-{
+switch (comparison)
-switch (comparison)
+{
-{
+case equal:         return XINT (num1) == XINT (num2) ? Qt : Qnil;
-case equal:
+case notequal:      return XINT (num1) != XINT (num2) ? Qt : Qnil;
-if (XINT (num1) == XINT (num2))
+case less:          return XINT (num1) <  XINT (num2) ? Qt : Qnil;
-return Qt;
+case less_or_equal: return XINT (num1) <= XINT (num2) ? Qt : Qnil;
-return Qnil;
+case grtr:          return XINT (num1) >  XINT (num2) ? Qt : Qnil;
+case grtr_or_equal: return XINT (num1) >= XINT (num2) ? Qt : Qnil;
-case notequal:
+}
-if (XINT (num1) != XINT (num2))
-return Qt;
-return Qnil;
-case less:
-if (XINT (num1) < XINT (num2))
-return Qt;
-return Qnil;
-case less_or_equal:
-if (XINT (num1) <= XINT (num2))
-return Qt;
-return Qnil;
-case grtr:
-if (XINT (num1) > XINT (num2))
-return Qt;
-return Qnil;
-case grtr_or_equal:
-if (XINT (num1) >= XINT (num2))
-return Qt;
-return Qnil;
-}
-}
 abort ();
 return Qnil;	/* suppress compiler warning */
 }
 DEFUN ("=", Feqlsign, Seqlsign, 2, 2, 0 /*
 {
 return arithcompare (num1, num2, equal);
 }
 DEFUN ("<", Flss, Slss, 2, 2, 0 /*
-T if first arg is less than second arg.  Both must be numbers or markers.
+T if first arg is less than second arg.
+Both must be numbers or markers.
 */ )
 (num1, num2)
 Lisp_Object num1, num2;
 {
 return arithcompare (num1, num2, less);
 }
 DEFUN (">", Fgtr, Sgtr, 2, 2, 0 /*
-T if first arg is greater than second arg.  Both must be numbers or markers.
+T if first arg is greater than second arg.
+Both must be numbers or markers.
 */ )
 (num1, num2)
 Lisp_Object num1, num2;
 {
 return arithcompare (num1, num2, grtr);
 {
 return arithcompare (num1, num2, grtr_or_equal);
 }
 DEFUN ("/=", Fneq, Sneq, 2, 2, 0 /*
-T if first arg is not equal to second arg.  Both must be numbers or markers.
+T if first arg is not equal to second arg.
+Both must be numbers or markers.
 */ )
 (num1, num2)
 Lisp_Object num1, num2;
 {
 return arithcompare (num1, num2, notequal);
 {
 CHECK_INT_OR_FLOAT (number);
 #ifdef LISP_FLOAT_TYPE
 if (FLOATP (number))
-{
+return (float_data (XFLOAT (number)) == 0.0) ? Qt : Qnil;
-if (float_data (XFLOAT (number)) == 0.0)
-	return Qt;
-return Qnil;
-}
 #endif /* LISP_FLOAT_TYPE */
-if (XINT (number) == 0)
+return (XINT (number) == 0) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 /* Convert between a 32-bit value and a cons of two 16-bit values.
 This is used to pass 32-bit integers to and from the user.
 Use time_to_lisp() and lisp_to_time() for time values.
 {
 Lisp_Object value;
 char *p;
 CHECK_STRING (string);
-p = (char *) string_data (XSTRING (string));
+p = (char *) XSTRING_DATA (string);
 /* Skip any whitespace at the front of the number.  Some versions of
 atoi do this anyway, so we might as well make Emacs lisp consistent.  */
 while (*p == ' ' || *p == '\t')
 p++;
 enum arithop
 { Aadd, Asub, Amult, Adiv, Alogand, Alogior, Alogxor, Amax, Amin };
 #ifdef LISP_FLOAT_TYPE
-static Lisp_Object float_arith_driver (double accum, int argnum,
-enum arithop code,
-int nargs, Lisp_Object *args);
-#endif
-static Lisp_Object
-arith_driver (enum arithop code, int nargs, Lisp_Object *args)
-{
-Lisp_Object val;
-REGISTER int argnum;
-REGISTER EMACS_INT accum = 0;
-REGISTER EMACS_INT next;
-switch (code)
-{
-case Alogior:
-case Alogxor:
-case Aadd:
-case Asub:
-accum = 0; break;
-case Amult:
-accum = 1; break;
-case Alogand:
-accum = -1; break;
-case Adiv:
-case Amax:
-case Amin:
-accum = 0;
-break;
-default:
-abort ();
-}
-for (argnum = 0; argnum < nargs; argnum++)
-{
-val = args[argnum];    /* using args[argnum] as argument to CHECK_INT_OR_FLOAT_... */
-CHECK_INT_OR_FLOAT_COERCE_CHAR_OR_MARKER (val);
-#ifdef LISP_FLOAT_TYPE
-if (FLOATP (val)) /* time to do serious math */
-	return (float_arith_driver ((double) accum, argnum, code,
-				    nargs, args));
-#endif /* LISP_FLOAT_TYPE */
-args[argnum] = val;    /* runs into a compiler bug. */
-next = XINT (args[argnum]);
-switch (code)
-	{
-	case Aadd: accum += next; break;
-	case Asub:
-	  if (!argnum && nargs != 1)
-	    next = - next;
-	  accum -= next;
-	  break;
-	case Amult: accum *= next; break;
-	case Adiv:
-	  if (!argnum) accum = next;
-	  else
-	    {
-	      if (next == 0)
-		Fsignal (Qarith_error, Qnil);
-	      accum /= next;
-	    }
-	  break;
-	case Alogand: accum &= next; break;
-	case Alogior: accum |= next; break;
-	case Alogxor: accum ^= next; break;
-	case Amax: if (!argnum || next > accum) accum = next; break;
-	case Amin: if (!argnum || next < accum) accum = next; break;
-	}
-}
-XSETINT (val, accum);
-return val;
-}
-#ifdef LISP_FLOAT_TYPE
 static Lisp_Object
 float_arith_driver (double accum, int argnum, enum arithop code, int nargs,
 		    Lisp_Object *args)
 {
 REGISTER Lisp_Object val;
 double next;
 for (; argnum < nargs; argnum++)
 {
-val = args[argnum];    /* using args[argnum] as argument to CHECK_INT_OR_FLOAT_... */
+/* using args[argnum] as argument to CHECK_INT_OR_FLOAT_... */
+val = args[argnum];
 CHECK_INT_OR_FLOAT_COERCE_CHAR_OR_MARKER (val);
 if (FLOATP (val))
 	{
 	  next = float_data (XFLOAT (val));
 return make_float (accum);
 }
 #endif /* LISP_FLOAT_TYPE */
+static Lisp_Object
+arith_driver (enum arithop code, int nargs, Lisp_Object *args)
+{
+Lisp_Object val;
+REGISTER int argnum;
+REGISTER EMACS_INT accum = 0;
+REGISTER EMACS_INT next;
+switch (code)
+{
+case Alogior:
+case Alogxor:
+case Aadd:
+case Asub:
+accum = 0; break;
+case Amult:
+accum = 1; break;
+case Alogand:
+accum = -1; break;
+case Adiv:
+case Amax:
+case Amin:
+accum = 0; break;
+default:
+abort ();
+}
+for (argnum = 0; argnum < nargs; argnum++)
+{
+/* using args[argnum] as argument to CHECK_INT_OR_FLOAT_... */
+val = args[argnum];
+CHECK_INT_OR_FLOAT_COERCE_CHAR_OR_MARKER (val);
+#ifdef LISP_FLOAT_TYPE
+if (FLOATP (val)) /* time to do serious math */
+	return (float_arith_driver ((double) accum, argnum, code,
+				    nargs, args));
+#endif /* LISP_FLOAT_TYPE */
+args[argnum] = val;    /* runs into a compiler bug. */
+next = XINT (args[argnum]);
+switch (code)
+	{
+	case Aadd: accum += next; break;
+	case Asub:
+	  if (!argnum && nargs != 1)
+	    next = - next;
+	  accum -= next;
+	  break;
+	case Amult: accum *= next; break;
+	case Adiv:
+	  if (!argnum) accum = next;
+	  else
+	    {
+	      if (next == 0)
+		Fsignal (Qarith_error, Qnil);
+	      accum /= next;
+	    }
+	  break;
+	case Alogand: accum &= next; break;
+	case Alogior: accum |= next; break;
+	case Alogxor: accum ^= next; break;
+	case Amax: if (!argnum || next > accum) accum = next; break;
+	case Amin: if (!argnum || next < accum) accum = next; break;
+	}
+}
+XSETINT (val, accum);
+return val;
+}
 DEFUN ("+", Fplus, Splus, 0, MANY, 0 /*
-Return sum of any number of arguments, which are numbers or markers.
+Return sum of any number of arguments.
+The arguments should all be numbers or markers.
 */ )
 (nargs, args)
 int nargs;
 Lisp_Object *args;
 {
 {
 return arith_driver (Asub, nargs, args);
 }
 DEFUN ("*", Ftimes, Stimes, 0, MANY, 0 /*
-Return product of any number of arguments, which are numbers or markers.
+Return product of any number of arguments.
+The arguments should all be numbers or markers.
 */ )
 (nargs, args)
 int nargs;
 Lisp_Object *args;
 {
 return (make_int (i1));
 }
 DEFUN ("max", Fmax, Smax, 1, MANY, 0 /*
-Return largest of all the arguments (which must be numbers or markers).
+Return largest of all the arguments.
+All arguments must be numbers or markers.
 The value is always a number; markers are converted to numbers.
 */ )
 (nargs, args)
 int nargs;
 Lisp_Object *args;
 {
 return arith_driver (Amax, nargs, args);
 }
 DEFUN ("min", Fmin, Smin, 1, MANY, 0 /*
-Return smallest of all the arguments (which must be numbers or markers).
+Return smallest of all the arguments.
+All arguments must be numbers or markers.
 The value is always a number; markers are converted to numbers.
 */ )
 (nargs, args)
 int nargs;
 Lisp_Object *args;
 Lisp_Object value, count;
 {
 CHECK_INT_COERCE_CHAR (value);
 CHECK_INT (count);
-if (XINT (count) > 0)
+return make_int (XINT (count) > 0 ?
-return (make_int (XINT (value) << XINT (count)));
+		 XINT (value) << XINT (count) :
-else
+		 XINT (value) >> -XINT (count));
-return (make_int (XINT (value) >> -XINT (count)));
 }
 DEFUN ("lsh", Flsh, Slsh, 2, 2, 0 /*
 Return VALUE with its bits shifted left by COUNT.
 If COUNT is negative, shifting is actually to the right.
 weak_list_equal (Lisp_Object o1, Lisp_Object o2, int depth)
 {
 struct weak_list *w1 = XWEAK_LIST (o1);
 struct weak_list *w2 = XWEAK_LIST (o2);
-if (w1->type != w2->type ||
+return (w1->type != w2->type &&
-!internal_equal (w1->list, w2->list, depth + 1))
+internal_equal (w1->list, w2->list, depth + 1));
-return 0;
-else
-return 1;
 }
 static unsigned long
 weak_list_hash (Lisp_Object obj, int depth)
 {
 static enum weak_list_type
 decode_weak_list_type (Lisp_Object symbol)
 {
 CHECK_SYMBOL (symbol);
-if (EQ (symbol, Qsimple))
+if (EQ (symbol, Qsimple))	 return WEAK_LIST_SIMPLE;
-return WEAK_LIST_SIMPLE;
+if (EQ (symbol, Qassoc))	 return WEAK_LIST_ASSOC;
-if (EQ (symbol, Qassoc))
+if (EQ (symbol, Qkey_assoc))	 return WEAK_LIST_KEY_ASSOC;
-return WEAK_LIST_ASSOC;
+if (EQ (symbol, Qvalue_assoc)) return WEAK_LIST_VALUE_ASSOC;
-if (EQ (symbol, Qkey_assoc))
-return WEAK_LIST_KEY_ASSOC;
-if (EQ (symbol, Qvalue_assoc))
-return WEAK_LIST_VALUE_ASSOC;
 signal_simple_error ("Invalid weak list type", symbol);
 return WEAK_LIST_SIMPLE; /* not reached */
 }
 static Lisp_Object
 encode_weak_list_type (enum weak_list_type type)
 {
 switch (type)
 {
-case WEAK_LIST_SIMPLE:
+case WEAK_LIST_SIMPLE:      return Qsimple;
-return Qsimple;
+case WEAK_LIST_ASSOC:       return Qassoc;
-case WEAK_LIST_ASSOC:
+case WEAK_LIST_KEY_ASSOC:   return Qkey_assoc;
-return Qassoc;
+case WEAK_LIST_VALUE_ASSOC: return Qvalue_assoc;
-case WEAK_LIST_KEY_ASSOC:
-return Qkey_assoc;
-case WEAK_LIST_VALUE_ASSOC:
-return Qvalue_assoc;
 default:
 abort ();
 }
-return Qnil;
+return Qnil; /* not reached */
 }
 DEFUN ("weak-list-p", Fweak_list_p, Sweak_list_p, 1, 1, 0 /*
 Return non-nil if OBJECT is a weak list.
 */ )

Mercurial > hg > xemacs-beta

comparison src/data.c @ 16:0293115a14e9 r19-15b91