xemacs-beta: src/alloc.c comparison

comparison src/alloc.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
 #endif
 int
 purified (Lisp_Object obj)
 {
-if (!POINTER_TYPE_P (XGCTYPE (obj)))
+return !POINTER_TYPE_P (XGCTYPE (obj)) ? 0 : PURIFIED (XPNTR (obj));
-return (0);
-return (PURIFIED (XPNTR (obj)));
 }
 int
 purespace_usage (void)
 {
 check_purespace (EMACS_INT size)
 {
 if (pure_lossage)
 {
 pure_lossage += size;
-return (0);
+return 0;
 }
 else if (pureptr + size > get_PURESIZE())
 {
 /* This can cause recursive bad behavior, we'll yell at the end */
 /* when we're done. */
 /* message ("\nERROR:  Pure Lisp storage exhausted!\n"); */
 pure_lossage = size;
-return (0);
+return 0;
 }
 else
-return (1);
+return 1;
 }
 #ifndef PURESTAT
 int len = strlen (str) + 1;   /* for stupid terminating 0 */
 val = xmalloc (len);
 if (val == 0) return 0;
 memcpy (val, str, len);
-return (val);
+return val;
 }
 #ifdef NEED_STRDUP
 char *
 strdup (CONST char *s)
 if ((char *) XCONS (val) != lim)
 {
 xfree (p);
 memory_full ();
 }
-return (p);
+return p;
 }
 #define MARKED_RECORD_HEADER_P(lheader) \
 (((lheader)->implementation->finalizer) == this_marks_a_marked_record)
 lcheader->uid = (int) &lcheader;
 #endif
 lcheader->free = 0;
 all_lcrecords = lcheader;
 INCREMENT_CONS_COUNTER (size, implementation->name);
-return (lcheader);
+return lcheader;
 }
 #if 0 /* Presently unused */
 /* Very, very poor man's EGC?
 * This may be slow and thrash pages all over the place.
 Lisp_Object
 list1 (Lisp_Object obj0)
 {
 /* This cannot GC. */
-return (Fcons (obj0, Qnil));
+return Fcons (obj0, Qnil);
 }
 Lisp_Object
 list2 (Lisp_Object obj0, Lisp_Object obj1)
 {
 ALLOCATE_FIXED_TYPE (float, struct Lisp_Float, f);
 f->lheader.implementation = lrecord_float;
 float_next (f) = ((struct Lisp_Float *) -1);
 float_data (f) = float_value;
 XSETFLOAT (val, f);
-return (val);
+return val;
 }
 #endif /* LISP_FLOAT_TYPE */
 INCREMENT_CONS_COUNTER (sizem, "vector");
 p->size = sizei;
 vector_next (p) = all_vectors;
 XSETVECTOR (all_vectors, p);
-return (p);
+return p;
 }
 Lisp_Object
 make_vector (EMACS_INT length, Lisp_Object init)
 {
 {
 if (travesty[i] != travesty[0])
 goto fill;
 }
 memset (vector_data (p), travesty[0], length * sizeof (Lisp_Object));
-return (vector);
+return vector;
 }
 fill:
 #endif
 for (elt = 0; elt < length; elt++)
 vector_data(p)[elt] = init;
-return (vector);
+return vector;
 }
 DEFUN ("make-vector", Fmake_vector, 2, 2, 0, /*
 Return a newly created vector of length LENGTH, with each element being INIT.
 See also the function `vector'.
 (length, init))
 {
 if (!INTP (length) || XINT (length) < 0)
 length = wrong_type_argument (Qnatnump, length);
-return (make_vector (XINT (length), init));
+return make_vector (XINT (length), init);
 }
 DEFUN ("vector", Fvector, 0, MANY, 0, /*
 Return a newly created vector with specified arguments as elements.
 Any number of arguments, even zero arguments, are allowed.
 XSETVECTOR (vector, p);
 for (elt = 0; elt < nargs; elt++)
 vector_data(p)[elt] = args[elt];
-return (vector);
+return vector;
 }
 Lisp_Object
 vector1 (Lisp_Object obj0)
 {
 bit_vector_next (p) = all_bit_vectors;
 /* make sure the extra bits in the last long are 0; the calling
 functions might not set them. */
 p->bits[BIT_VECTOR_LONG_STORAGE (sizei) - 1] = 0;
 XSETBIT_VECTOR (all_bit_vectors, p);
-return (p);
+return p;
 }
 Lisp_Object
 make_bit_vector (EMACS_INT length, Lisp_Object init)
 {
 	 last integer are 0, so that equal/hash is easy. */
 if (bits_in_last)
 	p->bits[num_longs - 1] &= (1 << bits_in_last) - 1;
 }
-return (bit_vector);
+return bit_vector;
 }
 Lisp_Object
 make_bit_vector_from_byte_vector (unsigned char *bytevec, EMACS_INT length)
 {
 (length, init))
 {
 if (!INTP (length) || XINT (length) < 0)
 length = wrong_type_argument (Qnatnump, length);
-return (make_bit_vector (XINT (length), init));
+return make_bit_vector (XINT (length), init);
 }
 DEFUN ("bit-vector", Fbit_vector, 0, MANY, 0, /*
 Return a newly created bit vector with specified arguments as elements.
 Any number of arguments, even zero arguments, are allowed.
 XSETBIT_VECTOR (bit_vector, p);
 for (elt = 0; elt < nargs; elt++)
 set_bit_vector_bit (p, elt, !ZEROP (args[elt]));
-return (bit_vector);
+return bit_vector;
 }
 /**********************************************************************/
 /*                   Compiled-function allocation                     */
 b->doc_and_interactive = Qnil;
 #ifdef COMPILED_FUNCTION_ANNOTATION_HACK
 b->annotated = Qnil;
 #endif
 XSETCOMPILED_FUNCTION (new, b);
-return (new);
+return new;
 }
 DEFUN ("make-byte-code", Fmake_byte_code, 4, MANY, 0, /*
 Create a compiled-function object.
 Usage: (arglist instructions constants stack-size
 b->doc_and_interactive = Vfile_domain;
 #endif
 else
 b->doc_and_interactive = doc_string;
-return (val);
+return val;
 }
 }
 /**********************************************************************/
 extent_face (e) = Qnil;
 e->flags.end_open = 1;  /* default is for endpoints to behave like markers */
 e->flags.detachable = 1;
-return (e);
+return e;
 }
 /**********************************************************************/
 /*                         Event allocation                           */
 #define BIG_STRING_FULLSIZE_P(fullsize) ((fullsize) >= STRING_CHARS_BLOCK_SIZE)
 #define BIG_STRING_SIZE_P(size) (BIG_STRING_FULLSIZE_P (STRING_FULLSIZE(size)))
 #define CHARS_TO_STRING_CHAR(x) \
 ((struct string_chars *) \
-(((char *) (x)) - (slot_offset (struct string_chars, chars))))
+(((char *) (x)) - (slot_offset (struct string_chars, chars[0]))))
 struct string_chars
 {
 struct Lisp_String *string;
 s->plist = Qnil;
 set_string_byte (s, length, 0);
 XSETSTRING (val, s);
-return (val);
+return val;
 }
 #ifdef VERIFY_STRING_CHARS_INTEGRITY
 static void verify_string_chars_integrity (void);
 #endif
 	for (i = 0; i < XINT (length); i++)
 	  for (j = 0; j < len; j++)
 	    ptr[k++] = str[j];
 }
 }
-return (val);
+return val;
 }
 /* Take some raw memory, which MUST already be in internal format,
 and package it up it into a Lisp string. */
 Lisp_Object
 bytecount_to_charcount (contents, length); /* Just for the assertions */
 #endif
 val = make_uninit_string (length);
 memcpy (XSTRING_DATA (val), contents, length);
-return (val);
+return val;
 }
 /* Take some raw memory, encoded in some external data format,
 and convert it into a Lisp string. */
 Lisp_Object
 if (SYMBOLP (tem))
 	{
 	  s = XSYMBOL (tem)->name;
 	  if (!PURIFIED (s)) abort ();
 	  XSETSTRING (new, s);
-	  return (new);
+	  return new;
 	}
 }
 if (!check_purespace (size))
-return (make_string (data, length));
+return make_string (data, length);
 s = (struct Lisp_String *) (PUREBEG + pureptr);
 set_string_length (s, length);
 if (no_need_to_copy_data)
 {
 /* Do this after the official "completion" of the purecopying. */
 s->plist = Fpurecopy (plist);
 XSETSTRING (new, s);
-return (new);
+return new;
 }
 Lisp_Object
 make_pure_pname (CONST Bufbyte *data, Bytecount length,
 bump_purestat (&purestat_string_pname, pure_sizeof (name));
 /* We've made (at least) Qnil now, and Vobarray will soon be set up. */
 symbols_initialized = 1;
-return (name);
+return name;
 }
 Lisp_Object
 pure_cons (Lisp_Object car, Lisp_Object cdr)
 {
 Lisp_Object new;
 if (!check_purespace (sizeof (struct Lisp_Cons)))
-return (Fcons (Fpurecopy (car), Fpurecopy (cdr)));
+return Fcons (Fpurecopy (car), Fpurecopy (cdr));
 XSETCONS (new, PUREBEG + pureptr);
 pureptr += sizeof (struct Lisp_Cons);
 bump_purestat (&purestat_cons, sizeof (struct Lisp_Cons));
 XCAR (new) = Fpurecopy (car);
 XCDR (new) = Fpurecopy (cdr);
-return (new);
+return new;
 }
 Lisp_Object
 pure_list (int nargs, Lisp_Object *args)
 {
 p = (char *) (((unsigned EMACS_INT) p + alignment - 1) & - alignment);
 pureptr = p - (char *) PUREBEG;
 }
 if (!check_purespace (sizeof (struct Lisp_Float)))
-return (make_float (num));
+return make_float (num);
 f = (struct Lisp_Float *) (PUREBEG + pureptr);
 set_lheader_implementation (&(f->lheader), lrecord_float);
 pureptr += sizeof (struct Lisp_Float);
 bump_purestat (&purestat_float, sizeof (struct Lisp_Float));
 float_next (f) = ((struct Lisp_Float *) -1);
 float_data (f) = num;
 XSETFLOAT (val, f);
-return (val);
+return val;
 }
 #endif /* LISP_FLOAT_TYPE */
 Lisp_Object
 + (len - 1) * sizeof (Lisp_Object));
 init = Fpurecopy (init);
 if (!check_purespace (size))
-return (make_vector (len, init));
+return make_vector (len, init);
 XSETVECTOR (new, PUREBEG + pureptr);
 pureptr += size;
 bump_purestat (&purestat_vector_all, size);
-XVECTOR (new)->size = len;
+XVECTOR_LENGTH (new) = len;
 for (size = 0; size < len; size++)
-vector_data (XVECTOR (new))[size] = init;
+XVECTOR_DATA (new)[size] = init;
-return (new);
+return new;
 }
 #if 0
 /* Presently unused */
 void *
 if (pureptr + size > get_PURESIZE())
 pure_storage_exhausted ();
 set_lheader_implementation (header, implementation);
 header->next = 0;
-return (header);
+return header;
 }
 #endif
 */
 (obj))
 {
 int i;
 if (!purify_flag)
-return (obj);
+return obj;
 if (!POINTER_TYPE_P (XTYPE (obj))
 || PURIFIED (XPNTR (obj)))
-return (obj);
+return obj;
 switch (XTYPE (obj))
 {
 case Lisp_Cons:
 return pure_cons (XCAR (obj), XCDR (obj));
 case Lisp_Vector:
 {
 struct Lisp_Vector *o = XVECTOR (obj);
 Lisp_Object new = make_pure_vector (vector_length (o), Qnil);
 for (i = 0; i < vector_length (o); i++)
-	  vector_data (XVECTOR (new))[i] = Fpurecopy (o->contents[i]);
+	  XVECTOR_DATA (new)[i] = Fpurecopy (o->contents[i]);
-return (new);
+return new;
 }
 default:
 {
 if (COMPILED_FUNCTIONP (obj))
 n->bytecodes = Fpurecopy (o->bytecodes);
 n->constants = Fpurecopy (o->constants);
 n->arglist = Fpurecopy (o->arglist);
 n->doc_and_interactive = Fpurecopy (o->doc_and_interactive);
 	    n->maxdepth = o->maxdepth;
-return (new);
+return new;
 }
 #ifdef LISP_FLOAT_TYPE
 else if (FLOATP (obj))
 return make_pure_float (float_data (XFLOAT (obj)));
 #endif /* LISP_FLOAT_TYPE */
 	else if (!SYMBOLP (obj))
 signal_simple_error ("Can't purecopy %S", obj);
 }
 }
-return (obj);
+return obj;
 }
 static void
 int total = 0;
 /*tail_recurse: */
 if (!POINTER_TYPE_P (XTYPE (obj))
 || !PURIFIED (XPNTR (obj)))
-return (total);
+return total;
 /* symbol's sizes are accounted for separately */
 if (SYMBOLP (obj))
-return (total);
+return total;
 switch (XTYPE (obj))
 {
 case Lisp_String:
 {
 /* Others can't be purified */
 default:
 abort ();
 }
-return (total);
+return total;
 }
 #endif /* PURESTAT */
 abort ();
 type_index = ++last_lrecord_type_index_assigned;
 lrecord_implementations_table[type_index] = implementation;
 *(implementation->lrecord_type_index) = type_index;
 }
-return (type_index);
+return type_index;
 }
 /* stats on lcrecords in use - kinda kludgy */
 static struct
 case Lisp_Record:
 return MARKED_RECORD_HEADER_P (XRECORD_LHEADER (obj));
 case Lisp_String:
 return XMARKBIT (XSTRING (obj)->plist);
 case Lisp_Vector:
-return (vector_length (XVECTOR (obj)) < 0);
+return XVECTOR_LENGTH (obj) < 0;
 #ifndef LRECORD_SYMBOL
 case Lisp_Symbol:
 return XMARKBIT (XSYMBOL (obj)->plist);
 #endif
 default:
 gc_plist_hack (CONST char *name, int value, Lisp_Object tail)
 {
 /* C doesn't have local functions (or closures, or GC, or readable syntax,
 or portable numeric datatypes, or bit-vectors, or characters, or
 arrays, or exceptions, or ...) */
-return (cons3 (intern (name), make_int (value), tail));
+return cons3 (intern (name), make_int (value), tail);
 }
 #define HACK_O_MATIC(type, name, pl)					\
 {									\
 int s = 0;								\
 ret[2] = Fcons (make_int (gc_count_num_marker_in_use),
 make_int (gc_count_num_marker_freelist));
 ret[3] = make_int (gc_count_string_total_size);
 ret[4] = make_int (gc_count_vector_total_size);
 ret[5] = pl;
-return (Flist (6, ret));
+return Flist (6, ret);
 }
 #undef HACK_O_MATIC
 DEFUN ("consing-since-gc", Fconsing_since_gc, 0, 0, "", /*
 Return the number of bytes consed since the last garbage collection.
 If this value exceeds `gc-cons-threshold', a garbage collection happens.
 */
 ())
 {
-return (make_int (consing_since_gc));
+return make_int (consing_since_gc);
 }
 DEFUN ("memory-limit", Fmemory_limit, 0, 0, "", /*
 Return the address of the last byte Emacs has allocated, divided by 1024.
 This may be helpful in debugging Emacs's memory usage.
 The value is divided by 1024 to make sure it will fit in a lisp integer.
 */
 ())
 {
-return (make_int ((EMACS_INT) sbrk (0) / 1024));
+return make_int ((EMACS_INT) sbrk (0) / 1024);
 }
 int
 object_dead_p (Lisp_Object obj)
 {
-return ((BUFFERP (obj) && !BUFFER_LIVE_P (XBUFFER (obj))) ||
+return ((BUFFERP  (obj) && !BUFFER_LIVE_P  (XBUFFER  (obj))) ||
-	  (FRAMEP (obj) && !FRAME_LIVE_P (XFRAME (obj))) ||
+	  (FRAMEP   (obj) && !FRAME_LIVE_P   (XFRAME   (obj))) ||
-	  (WINDOWP (obj) && !WINDOW_LIVE_P (XWINDOW (obj))) ||
+	  (WINDOWP  (obj) && !WINDOW_LIVE_P  (XWINDOW  (obj))) ||
-	  (DEVICEP (obj) && !DEVICE_LIVE_P (XDEVICE (obj))) ||
+	  (DEVICEP  (obj) && !DEVICE_LIVE_P  (XDEVICE  (obj))) ||
 	  (CONSOLEP (obj) && !CONSOLE_LIVE_P (XCONSOLE (obj))) ||
-	  (EVENTP (obj) && !EVENT_LIVE_P (XEVENT (obj))) ||
+	  (EVENTP   (obj) && !EVENT_LIVE_P   (XEVENT   (obj))) ||
-	  (EXTENTP (obj) && !EXTENT_LIVE_P (XEXTENT (obj))));
+	  (EXTENTP  (obj) && !EXTENT_LIVE_P  (XEXTENT  (obj))));
 }
 #ifdef MEMORY_USAGE_STATS

Mercurial > hg > xemacs-beta

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