xemacs-beta: src/data.c comparison

comparison src/data.c @ 173:8eaf7971accc r20-3b13

Import from CVS: tag r20-3b13

author	cvs
date	Mon, 13 Aug 2007 09:49:09 +0200
parents	929b76928fce
children	2d532a89d707

comparison

equal deleted inserted replaced

-:a38aed19690b
+:8eaf7971accc
 DEFUN ("listp", Flistp, 1, 1, 0, /*
 T if OBJECT is a list.  This includes nil.
 */
 (object))
 {
-return (CONSP (object) || NILP (object)) ? Qt : Qnil;
+return CONSP (object) || NILP (object) ? Qt : Qnil;
 }
 DEFUN ("nlistp", Fnlistp, 1, 1, 0, /*
 T if OBJECT is not a list.  Lists include nil.
 */
 (object))
 {
-return (CONSP (object) || NILP (object)) ? Qnil : Qt;
+return CONSP (object) || NILP (object) ? Qnil : Qt;
 }
 DEFUN ("symbolp", Fsymbolp, 1, 1, 0, /*
 T if OBJECT is a symbol.
 */
 if (KEYWORDP (object)) return Qkeyword;
 if (INTP     (object)) return Qinteger;
 if (CHARP    (object)) return Qcharacter;
 if (STRINGP  (object)) return Qstring;
 if (VECTORP  (object)) return Qvector;
 assert (LRECORDP (object));
 return intern (XRECORD_LHEADER (object)->implementation->name);
 }
 This is like Findirect_function, except that it doesn't signal an
 error if the chain ends up unbound.  */
 Lisp_Object
 indirect_function (Lisp_Object object, int errorp)
 {
 Lisp_Object tortoise = object;
 Lisp_Object hare     = object;
 for (;;)
 {
 if (!SYMBOLP (hare) || UNBOUNDP (hare))
 hare = XSYMBOL (hare)->function;
 tortoise = XSYMBOL (tortoise)->function;
 if (EQ (hare, tortoise))
-	return (Fsignal (Qcyclic_function_indirection, list1 (object)));
+	return Fsignal (Qcyclic_function_indirection, list1 (object));
 }
 if (UNBOUNDP (hare) && errorp)
 return Fsignal (Qvoid_function, list1 (object));
 return hare;
 lose:
 args_out_of_range (array, idx);
 }
 if (VECTORP (array))
 {
-if (idxval >= vector_length (XVECTOR (array))) goto lose;
+if (idxval >= XVECTOR_LENGTH (array)) goto lose;
-return vector_data (XVECTOR (array))[idxval];
+return XVECTOR_DATA (array)[idxval];
 }
 else if (BIT_VECTORP (array))
 {
 if (idxval >= bit_vector_length (XBIT_VECTOR (array))) goto lose;
 return make_int (bit_vector_bit (XBIT_VECTOR (array), idxval));
 }
 else if (STRINGP (array))
 {
 if (idxval >= string_char_length (XSTRING (array))) goto lose;
-return (make_char (string_char (XSTRING (array), idxval)));
+return make_char (string_char (XSTRING (array), idxval));
 }
 #ifdef LOSING_BYTECODE
 else if (COMPILED_FUNCTIONP (array))
 {
 /* Weird, gross compatibility kludge */
-return (Felt (array, idx));
+return Felt (array, idx);
 }
 #endif
 else
 {
 check_losing_bytecode ("aref", array);
 }
 CHECK_IMPURE (array);
 if (VECTORP (array))
 {
-if (idxval >= vector_length (XVECTOR (array))) goto lose;
+if (idxval >= XVECTOR_LENGTH (array)) goto lose;
-vector_data (XVECTOR (array))[idxval] = newval;
+XVECTOR_DATA (array)[idxval] = newval;
 }
 else if (BIT_VECTORP (array))
 {
 if (idxval >= bit_vector_length (XBIT_VECTOR (array))) goto lose;
 CHECK_BIT (newval);
 Lisp_Object
 compiled_function_interactive (struct Lisp_Compiled_Function *b)
 {
 assert (b->flags.interactivep);
 if (b->flags.documentationp && b->flags.domainp)
-return (XCAR (XCDR (b->doc_and_interactive)));
+return XCAR (XCDR (b->doc_and_interactive));
 else if (b->flags.documentationp)
-return (XCDR (b->doc_and_interactive));
+return XCDR (b->doc_and_interactive);
 else if (b->flags.domainp)
-return (XCAR (b->doc_and_interactive));
+return XCAR (b->doc_and_interactive);
 /* if all else fails... */
-return (b->doc_and_interactive);
+return b->doc_and_interactive;
 }
 /* Caller need not check flags.documentationp first */
 Lisp_Object
 compiled_function_documentation (struct Lisp_Compiled_Function *b)
 {
 if (! b->flags.documentationp)
 return Qnil;
 else if (b->flags.interactivep && b->flags.domainp)
-return (XCAR (b->doc_and_interactive));
+return XCAR (b->doc_and_interactive);
 else if (b->flags.interactivep)
-return (XCAR (b->doc_and_interactive));
+return XCAR (b->doc_and_interactive);
 else if (b->flags.domainp)
-return (XCAR (b->doc_and_interactive));
+return XCAR (b->doc_and_interactive);
 else
-return (b->doc_and_interactive);
+return b->doc_and_interactive;
 }
 /* Caller need not check flags.domainp first */
 Lisp_Object
 compiled_function_domain (struct Lisp_Compiled_Function *b)
 {
 if (! b->flags.domainp)
 return Qnil;
 else if (b->flags.documentationp && b->flags.interactivep)
-return (XCDR (XCDR (b->doc_and_interactive)));
+return XCDR (XCDR (b->doc_and_interactive));
 else if (b->flags.documentationp)
-return (XCDR (b->doc_and_interactive));
+return XCDR (b->doc_and_interactive);
 else if (b->flags.interactivep)
-return (XCDR (b->doc_and_interactive));
+return XCDR (b->doc_and_interactive);
 else
-return (b->doc_and_interactive);
+return b->doc_and_interactive;
 }
 #ifdef COMPILED_FUNCTION_ANNOTATION_HACK
 Lisp_Object
 Return the byte-opcode string of the compiled-function object.
 */
 (function))
 {
 CHECK_COMPILED_FUNCTION (function);
-return (XCOMPILED_FUNCTION (function)->bytecodes);
+return XCOMPILED_FUNCTION (function)->bytecodes;
 }
 DEFUN ("compiled-function-constants", Fcompiled_function_constants, 1, 1, 0, /*
 Return the constants vector of the compiled-function object.
 */
 (function))
 {
 CHECK_COMPILED_FUNCTION (function);
-return (XCOMPILED_FUNCTION (function)->constants);
+return XCOMPILED_FUNCTION (function)->constants;
 }
 DEFUN ("compiled-function-stack-depth", Fcompiled_function_stack_depth, 1, 1, 0, /*
 Return the max stack depth of the compiled-function object.
 */
 (function))
 {
 CHECK_COMPILED_FUNCTION (function);
-return (make_int (XCOMPILED_FUNCTION (function)->maxdepth));
+return make_int (XCOMPILED_FUNCTION (function)->maxdepth);
 }
 DEFUN ("compiled-function-arglist", Fcompiled_function_arglist, 1, 1, 0, /*
 Return the argument list of the compiled-function object.
 */
 (function))
 {
 CHECK_COMPILED_FUNCTION (function);
-return (XCOMPILED_FUNCTION (function)->arglist);
+return XCOMPILED_FUNCTION (function)->arglist;
 }
 DEFUN ("compiled-function-interactive", Fcompiled_function_interactive, 1, 1, 0, /*
 Return the interactive spec of the compiled-function object, or nil.
 If non-nil, the return value will be a list whose first element is
 a `load'.
 */
 (function))
 {
 CHECK_COMPILED_FUNCTION (function);
-return (compiled_function_annotation (XCOMPILED_FUNCTION (function)));
+return compiled_function_annotation (XCOMPILED_FUNCTION (function));
 }
 #endif /* COMPILED_FUNCTION_ANNOTATION_HACK */
 DEFUN ("compiled-function-domain", Fcompiled_function_domain, 1, 1, 0, /*
 (function))
 {
 CHECK_COMPILED_FUNCTION (function);
 if (!XCOMPILED_FUNCTION (function)->flags.domainp)
 return Qnil;
-return (compiled_function_domain (XCOMPILED_FUNCTION (function)));
+return compiled_function_domain (XCOMPILED_FUNCTION (function));
 }
 /**********************************************************************/
 /*                       Arithmetic functions                         */
 	case grtr:          return f1 >  f2 ? Qt : Qnil;
 	case grtr_or_equal: return f1 >= f2 ? Qt : Qnil;
 	}
 }
 #endif /* LISP_FLOAT_TYPE */
 switch (comparison)
 {
 case equal:         return XINT (num1) == XINT (num2) ? Qt : Qnil;
 case notequal:      return XINT (num1) != XINT (num2) ? Qt : Qnil;
 case less:          return XINT (num1) <  XINT (num2) ? Qt : Qnil;
 {
 CHECK_INT_OR_FLOAT (number);
 #ifdef LISP_FLOAT_TYPE
 if (FLOATP (number))
-return (float_data (XFLOAT (number)) == 0.0) ? Qt : Qnil;
+return float_data (XFLOAT (number)) == 0.0 ? Qt : Qnil;
 #endif /* LISP_FLOAT_TYPE */
-return (XINT (number) == 0) ? Qt : Qnil;
+return XINT (number) == 0 ? Qt : 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.
 if (FLOATP (num))
 {
 char pigbuf[350];	/* see comments in float_to_string */
 float_to_string (pigbuf, float_data (XFLOAT (num)));
 return build_string (pigbuf);
 }
 #endif /* LISP_FLOAT_TYPE */
-if (sizeof (int) == sizeof (EMACS_INT))
+sprintf (buffer, "%ld", (long) (XINT (num)));
-sprintf (buffer, "%d", XINT (num));
-else if (sizeof (long) == sizeof (EMACS_INT))
-sprintf (buffer, "%ld", (long) XINT (num));
-else
-abort ();
 return build_string (buffer);
 }
 static int
 digit_to_number (int character, int base)
 	{
 	  negative = -1;
 	  p++;
 	}
 else if (*p == '+')
 	p++;
 while (1)
 	{
 	  digit = digit_to_number (*p++, b);
 	  if (digit < 0)
 	    break;
 	  v = v * b + digit;
 	}
 return make_int (negative * v);
 }
 }
 enum arithop
 { Aadd, Asub, Amult, Adiv, Alogand, Alogior, Alogxor, Amax, Amin };
 #ifdef LISP_FLOAT_TYPE
 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++)
 {
 /* using args[argnum] as argument to CHECK_INT_OR_FLOAT_... */
 val = args[argnum];
 CHECK_INT_OR_FLOAT_COERCE_CHAR_OR_MARKER (val);
 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,
+	return float_arith_driver ((double) accum, argnum, code,
-				    nargs, args));
+				   nargs, args);
 #endif /* LISP_FLOAT_TYPE */
 args[argnum] = val;    /* runs into a compiler bug. */
 next = XINT (args[argnum]);
 switch (code)
 	{
 CHECK_INT_COERCE_CHAR_OR_MARKER (num2);
 if (ZEROP (num2))
 Fsignal (Qarith_error, Qnil);
-return (make_int (XINT (num1) % XINT (num2)));
+return make_int (XINT (num1) % XINT (num2));
 }
 /* Note, ANSI *requires* the presence of the fmod() library routine.
 If your system doesn't have it, complain to your vendor, because
 that is a bug. */
 double
 fmod (double f1, double f2)
 {
 if (f2 < 0.0)
 f2 = -f2;
-return (f1 - f2 * floor (f1/f2));
+return f1 - f2 * floor (f1/f2);
 }
 #endif /* ! HAVE_FMOD */
 DEFUN ("mod", Fmod, 2, 2, 0, /*
 f1 = ((FLOATP (x)) ? float_data (XFLOAT (x)) : XINT (x));
 f2 = ((FLOATP (y)) ? float_data (XFLOAT (y)) : XINT (y));
 if (f2 == 0)
 	Fsignal (Qarith_error, Qnil);
 f1 = fmod (f1, f2);
 /* If the "remainder" comes out with the wrong sign, fix it.  */
 if (f2 < 0 ? f1 > 0 : f1 < 0)
 	f1 += f2;
-return (make_float (f1));
+return make_float (f1);
 }
 #else /* not LISP_FLOAT_TYPE */
 CHECK_INT_OR_FLOAT_COERCE_CHAR_OR_MARKER (x);
 CHECK_INT_OR_FLOAT_COERCE_CHAR_OR_MARKER (y);
 #endif /* not LISP_FLOAT_TYPE */
 i1 = XINT (x);
 i2 = XINT (y);
 if (i2 == 0)
 Fsignal (Qarith_error, Qnil);
 i1 %= i2;
 /* If the "remainder" comes out with the wrong sign, fix it.  */
 if (i2 < 0 ? i1 > 0 : i1 < 0)
 i1 += i2;
-return (make_int (i1));
+return make_int (i1);
 }
 DEFUN ("max", Fmax, 1, MANY, 0, /*
 Return largest of all the arguments.
 {
 CHECK_INT_OR_FLOAT_COERCE_CHAR_OR_MARKER (number);
 #ifdef LISP_FLOAT_TYPE
 if (FLOATP (number))
-return (make_float (1.0 + float_data (XFLOAT (number))));
+return make_float (1.0 + float_data (XFLOAT (number)));
 #endif /* LISP_FLOAT_TYPE */
-return (make_int (XINT (number) + 1));
+return make_int (XINT (number) + 1);
 }
 DEFUN ("1-", Fsub1, 1, 1, 0, /*
 Return NUMBER minus one.  NUMBER may be a number or a marker.
 Markers and characters are converted to integers.
 {
 CHECK_INT_OR_FLOAT_COERCE_CHAR_OR_MARKER (number);
 #ifdef LISP_FLOAT_TYPE
 if (FLOATP (number))
-return (make_float (-1.0 + (float_data (XFLOAT (number)))));
+return make_float (-1.0 + (float_data (XFLOAT (number))));
 #endif /* LISP_FLOAT_TYPE */
-return (make_int (XINT (number) - 1));
+return make_int (XINT (number) - 1);
 }
 DEFUN ("lognot", Flognot, 1, 1, 0, /*
 Return the bitwise complement of NUMBER.  NUMBER must be an integer.
 */
 (number))
 {
 CHECK_INT (number);
-return (make_int (~XINT (number)));
+return make_int (~XINT (number));
 }
 /************************************************************************/
 /*                              weak lists                              */
 static void
 print_weak_list (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
 if (print_readably)
 error ("printing unreadable object #<weak-list>");
 write_c_string ("#<weak-list ", printcharfun);
 print_internal (encode_weak_list_type (XWEAK_LIST (obj)->type),
 		  printcharfun, 0);
 write_c_string (" ", printcharfun);
 print_internal (XWEAK_LIST (obj)->list, printcharfun, escapeflag);
 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);
-return (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));
 }
 static unsigned long
 weak_list_hash (Lisp_Object obj, int depth)
 {
 		     we must have already visited the spot, so we exit.
 		     (If we process with the tortoise, we can fail to
 		     process cases where a cons points to itself, or
 		     where cons A points to cons B, which points to
 		     cons A.) */
 		  rest2 = XCDR (rest2);
 		  if (go_tortoise)
 		    tortoise = XCDR (tortoise);
 		  go_tortoise = !go_tortoise;
 		  if (GC_EQ (rest2, tortoise))

Mercurial > hg > xemacs-beta

comparison src/data.c @ 173:8eaf7971accc r20-3b13