xemacs-beta: src/symbols.c comparison

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

Import from CVS: tag r20-3b13

author	cvs
date	Mon, 13 Aug 2007 09:49:09 +0200
parents	85ec50267440
children	e121b013d1f0

comparison

equal deleted inserted replaced

-:a38aed19690b
+:8eaf7971accc
 ((markobj) (sym->value));
 ((markobj) (sym->function));
 XSETSTRING (pname, sym->name);
 ((markobj) (pname));
 if (!symbol_next (sym))
-return (sym->plist);
+return sym->plist;
 else
 {
 ((markobj) (sym->plist));
 /* Mark the rest of the symbols in the obarray hash-chain */
 sym = symbol_next (sym);
 XSETSYMBOL (obj, sym);
-return (obj);
+return obj;
 }
 }
 #endif /* LRECORD_SYMBOL */
 static int oblookup_last_bucket_number;
 static Lisp_Object
 check_obarray (Lisp_Object obarray)
 {
-while (!VECTORP (obarray) || vector_length (XVECTOR (obarray)) == 0)
+while (!VECTORP (obarray) || XVECTOR_LENGTH (obarray) == 0)
 {
 /* If Vobarray is now invalid, force it to be valid.  */
 if (EQ (Vobarray, obarray)) Vobarray = initial_obarray;
 obarray = wrong_type_argument (Qvectorp, obarray);
 intern (CONST char *str)
 {
 Lisp_Object tem;
 Bytecount len = strlen (str);
 Lisp_Object obarray = Vobarray;
-if (!VECTORP (obarray) || vector_length (XVECTOR (obarray)) == 0)
+if (!VECTORP (obarray) || XVECTOR_LENGTH (obarray) == 0)
 obarray = check_obarray (obarray);
 tem = oblookup (obarray, (CONST Bufbyte *) str, len);
 if (SYMBOLP (tem))
 return tem;
 return Fintern (((purify_flag)
 		   ? make_pure_pname ((CONST Bufbyte *) str, len, 0)
 		   : make_string ((CONST Bufbyte *) str, len)),
 sym = oblookup (obarray, XSTRING_DATA (str), len);
 if (!INTP (sym))
 /* Found it */
 return sym;
-ptr = &vector_data (XVECTOR (obarray))[XINT (sym)];
+ptr = &XVECTOR_DATA (obarray)[XINT (sym)];
 if (purify_flag && ! purified (str))
 str = make_pure_pname (XSTRING_DATA (str), len, 0);
 sym = Fmake_symbol (str);
 if (SYMBOLP (name) && !EQ (name, tem))
 return Qnil;
 hash = oblookup_last_bucket_number;
-if (EQ (XVECTOR (obarray)->contents[hash], tem))
+if (EQ (XVECTOR_DATA (obarray)[hash], tem))
 {
 if (XSYMBOL (tem)->next)
-	XSETSYMBOL (XVECTOR (obarray)->contents[hash], XSYMBOL (tem)->next);
+	XSETSYMBOL (XVECTOR_DATA (obarray)[hash], XSYMBOL (tem)->next);
 else
-	XVECTOR (obarray)->contents[hash] = Qzero;
+	XVECTOR_DATA (obarray)[hash] = Qzero;
 }
 else
 {
 Lisp_Object tail, following;
-for (tail = XVECTOR (obarray)->contents[hash];
+for (tail = XVECTOR_DATA (obarray)[hash];
 	   XSYMBOL (tail)->next;
 	   tail = following)
 	{
 	  XSETSYMBOL (following, XSYMBOL (tail)->next);
 	  if (EQ (following, tem))
 int hash, obsize;
 struct Lisp_Symbol *tail;
 Lisp_Object bucket;
 if (!VECTORP (obarray) ||
-(obsize = vector_length (XVECTOR (obarray))) == 0)
+(obsize = XVECTOR_LENGTH (obarray)) == 0)
 {
 obarray = check_obarray (obarray);
-obsize = vector_length (XVECTOR (obarray));
+obsize = XVECTOR_LENGTH (obarray);
 }
 #if 0 /* FSFmacs */
 /* #### Huh? */
 /* This is sometimes needed in the middle of GC.  */
 obsize &= ~ARRAY_MARK_FLAG;
 #endif
 /* Combining next two lines breaks VMS C 2.3.	 */
 hash = hash_string (ptr, size);
 hash %= obsize;
-bucket = vector_data (XVECTOR (obarray))[hash];
+bucket = XVECTOR_DATA (obarray)[hash];
 oblookup_last_bucket_number = hash;
 if (ZEROP (bucket))
 ;
 else if (!SYMBOLP (bucket))
 error ("Bad data in guts of obarray"); /* Like CADR error message */
 {
 	if (string_length (tail->name) == size &&
 	    !memcmp (string_data (tail->name), ptr, size))
 	  {
 	    XSETSYMBOL (bucket, tail);
-	    return (bucket);
+	    return bucket;
 	  }
 	tail = symbol_next (tail);
 	if (!tail)
 	  break;
 }
-return (make_int (hash));
+return make_int (hash);
 }
 #if 0 /* Emacs 19.34 */
 int
 hash_string (CONST Bufbyte *ptr, Bytecount len)
 Bytecount count = len;
 while (count-- > 0)
 {
 hash = (hash << 4) + *p++;
-if (g = (hash & 0xf0000000)) {
+if ((g = (hash & 0xf0000000))) {
 	hash = hash ^ (g >> 24);
 	hash = hash ^ g;
 }
 }
 return hash & 07777777777;
 map_obarray (Lisp_Object obarray,
 	     void (*fn) (Lisp_Object sym, Lisp_Object arg),
 	     Lisp_Object arg)
 {
 REGISTER int i;
-REGISTER Lisp_Object tail;
+Lisp_Object tail;
 CHECK_VECTOR (obarray);
-for (i = vector_length (XVECTOR (obarray)) - 1; i >= 0; i--)
+for (i = XVECTOR_LENGTH (obarray) - 1; i >= 0; i--)
 {
-tail = vector_data (XVECTOR (obarray))[i];
+tail = XVECTOR_DATA (obarray)[i];
 if (SYMBOLP (tail))
 	while (1)
 	  {
 	    struct Lisp_Symbol *next;
 	    (*fn) (tail, arg);
 accumulation = Fcons (string, Fcons (pred, Qnil));
 GCPRO1 (accumulation);
 map_obarray (Vobarray, apropos_accum, accumulation);
 accumulation = Fsort (Fcdr (Fcdr (accumulation)), Qstring_lessp);
 UNGCPRO;
-return (accumulation);
+return accumulation;
 }
 /* Extract and set components of symbols */
 static void set_up_buffer_local_cache (Lisp_Object sym,
 				       struct symbol_value_buffer_local *bfwd,
 				       struct buffer *buf,
 				       Lisp_Object new_alist_el,
 				       int set_it_p);
 T if SYMBOL's value is not void.
 */
 (sym))
 {
 CHECK_SYMBOL (sym);
-return (UNBOUNDP (find_symbol_value (sym)) ? Qnil : Qt);
+return UNBOUNDP (find_symbol_value (sym)) ? Qnil : Qt;
 }
 DEFUN ("globally-boundp", Fglobally_boundp, 1, 1, 0, /*
 T if SYMBOL has a global (non-bound) value.
 This is for the byte-compiler; you really shouldn't be using this.
 */
 (sym))
 {
 CHECK_SYMBOL (sym);
-return (UNBOUNDP (top_level_value (sym)) ? Qnil : Qt);
+return UNBOUNDP (top_level_value (sym)) ? Qnil : Qt;
 }
 DEFUN ("fboundp", Ffboundp, 1, 1, 0, /*
 T if SYMBOL's function definition is not void.
 */
 (sym))
 {
 CHECK_SYMBOL (sym);
-return ((UNBOUNDP (XSYMBOL (sym)->function)) ? Qnil : Qt);
+return (UNBOUNDP (XSYMBOL (sym)->function)) ? Qnil : Qt;
 }
 /* Return non-zero if SYM's value or function (the current contents of
 which should be passed in as VAL) is constant, i.e. unsettable. */
 	 but I don't want to consider that right now. */
 (SYMBOL_VALUE_MAGIC_P (val) &&
 XSYMBOL_VALUE_MAGIC_TYPE (val) ==
 SYMVAL_SELECTED_CONSOLE_FORWARD)
 )
 signal_error (Qerror,
 		  list2 (build_string ("Symbol may not be buffer-local"),
 			 sym));
 }
 DEFUN ("makunbound", Fmakunbound, 1, 1, 0, /*
 However, calling `make-local-variable' or
 `make-variable-buffer-local' on one of these variables
 is currently disallowed because that would entail having
 both console-local and buffer-local variables, which is
 trickier to implement.
 SYMVAL_CONST_SELECTED_CONSOLE_FORWARD:
 (declare with DEFVAR_CONST_CONSOLE_LOCAL)
 Same as SYMVAL_SELECTED_CONSOLE_FORWARD except that the
 value cannot be set.
 			       this_one_is_unmarkable,
 			       print_symbol_value_magic, 0, 0, 0,
 			       struct symbol_value_forward);
 DEFINE_LRECORD_IMPLEMENTATION ("symbol-value-buffer-local",
 			       symbol_value_buffer_local,
 			       mark_symbol_value_buffer_local,
 			       print_symbol_value_magic,
 			       0, 0, 0,
 			       struct symbol_value_buffer_local);
 DEFINE_LRECORD_IMPLEMENTATION ("symbol-value-lisp-magic",
 			       symbol_value_lisp_magic,
 			       mark_symbol_value_lisp_magic,
 			       print_symbol_value_magic,
 			       0, 0, 0,
 			       struct symbol_value_lisp_magic);
 DEFINE_LRECORD_IMPLEMENTATION ("symbol-value-varalias",
 			       symbol_value_varalias,
 			       mark_symbol_value_varalias,
 			       print_symbol_value_magic,
 			       0, 0, 0,
 			       struct symbol_value_varalias);
 static Lisp_Object
 mark_symbol_value_buffer_local (Lisp_Object obj,
 bfwd = XSYMBOL_VALUE_BUFFER_LOCAL (obj);
 ((markobj) (bfwd->default_value));
 ((markobj) (bfwd->current_value));
 ((markobj) (bfwd->current_buffer));
-return (bfwd->current_alist_element);
+return bfwd->current_alist_element;
 }
 static Lisp_Object
 mark_symbol_value_lisp_magic (Lisp_Object obj,
 			      void (*markobj) (Lisp_Object))
 for (i = 0; i < MAGIC_HANDLER_MAX; i++)
 {
 ((markobj) (bfwd->handler[i]));
 ((markobj) (bfwd->harg[i]));
 }
-return (bfwd->shadowed);
+return bfwd->shadowed;
 }
 static Lisp_Object
 mark_symbol_value_varalias (Lisp_Object obj,
 			    void (*markobj) (Lisp_Object))
 assert (XSYMBOL_VALUE_MAGIC_TYPE (obj) == SYMVAL_VARALIAS);
 bfwd = XSYMBOL_VALUE_VARALIAS (obj);
 ((markobj) (bfwd->shadowed));
-return (bfwd->aliasee);
+return bfwd->aliasee;
 }
 /* Should never, ever be called. (except by an external debugger) */
 void
 print_symbol_value_magic (Lisp_Object obj,
 			  Lisp_Object printcharfun, int escapeflag)
 {
 char buf[200];
-sprintf (buf, "#<INTERNAL EMACS BUG (symfwd %d) 0x%x>",
+sprintf (buf, "#<INTERNAL EMACS BUG (symfwd %d) 0x%p>",
-	   (EMACS_INT) XSYMBOL_VALUE_MAGIC_TYPE (obj),
+	   XSYMBOL_VALUE_MAGIC_TYPE (obj), (void *) XPNTR (obj));
-	   (EMACS_INT) XPNTR (obj));
 write_c_string (buf, printcharfun);
 }
 /* Getting and setting values of symbols */
 		      struct console *console)
 {
 CONST struct symbol_value_forward *fwd;
 if (!SYMBOL_VALUE_MAGIC_P (valcontents))
-return (valcontents);
+return valcontents;
 fwd = XSYMBOL_VALUE_FORWARD (valcontents);
 switch (fwd->magic.type)
 {
 case SYMVAL_FIXNUM_FORWARD:
 case SYMVAL_CONST_FIXNUM_FORWARD:
-return (make_int (*((int *)symbol_value_forward_forward (fwd))));
+return make_int (*((int *)symbol_value_forward_forward (fwd)));
 case SYMVAL_BOOLEAN_FORWARD:
 case SYMVAL_CONST_BOOLEAN_FORWARD:
-{
+return *((int *)symbol_value_forward_forward (fwd)) ? Qt : Qnil;
-	if (*((int *)symbol_value_forward_forward (fwd)))
-	  return (Qt);
-	else
-	  return (Qnil);
-}
 case SYMVAL_OBJECT_FORWARD:
 case SYMVAL_CONST_OBJECT_FORWARD:
 case SYMVAL_CONST_SPECIFIER_FORWARD:
-return (*((Lisp_Object *)symbol_value_forward_forward (fwd)));
+return *((Lisp_Object *)symbol_value_forward_forward (fwd));
 case SYMVAL_DEFAULT_BUFFER_FORWARD:
 return (*((Lisp_Object *)((char *) XBUFFER (Vbuffer_defaults)
 				+ ((char *)symbol_value_forward_forward (fwd)
 				   - (char *)&buffer_local_flags))));
 return (*((Lisp_Object *)((char *)console
 				+ ((char *)symbol_value_forward_forward (fwd)
 				   - (char *)&console_local_flags))));
 case SYMVAL_UNBOUND_MARKER:
-return (valcontents);
+return valcontents;
 default:
 abort ();
 }
 return Qnil;	/* suppress compiler warning */
 */
 /* At this point, the value cell may not contain a symbol-value-varalias
 or symbol-value-buffer-local, and if there's a handler, we should
 have already called it. */
 Lisp_Object valcontents = fetch_value_maybe_past_magic (sym, Qt);
 CONST struct symbol_value_forward *fwd
 = XSYMBOL_VALUE_FORWARD (valcontents);
 int offset = ((char *) symbol_value_forward_forward (fwd)
 		- (char *) &buffer_local_flags);
 int mask = XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd)));
 int (*magicfun) (Lisp_Object simm, Lisp_Object *val, Lisp_Object in_object,
 		   int flags) = symbol_value_forward_magicfun (fwd);
 *((Lisp_Object *) (offset + (char *) XBUFFER (Vbuffer_defaults)))
 = value;
 if (mask > 0)		/* Not always per-buffer */
 {
 Lisp_Object tail;
 /* Set value in each buffer which hasn't shadowed the default */
 LIST_LOOP (tail, Vbuffer_alist)
 	{
 	  struct buffer *b = XBUFFER (XCDR (XCAR (tail)));
 	  if (!(b->local_var_flags & mask))
 	    {
 	      if (magicfun)
 		(magicfun) (sym, &value, make_buffer (b), 0);
 	      *((Lisp_Object *) (offset + (char *) b)) = value;
 	    }
 	}
 }
 }
 */
 /* At this point, the value cell may not contain a symbol-value-varalias
 or symbol-value-buffer-local, and if there's a handler, we should
 have already called it. */
 Lisp_Object valcontents = fetch_value_maybe_past_magic (sym, Qt);
 CONST struct symbol_value_forward *fwd
 = XSYMBOL_VALUE_FORWARD (valcontents);
 int offset = ((char *) symbol_value_forward_forward (fwd)
 		- (char *) &console_local_flags);
 int mask = XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd)));
 int (*magicfun) (Lisp_Object simm, Lisp_Object *val, Lisp_Object in_object,
 		   int flags) = symbol_value_forward_magicfun (fwd);
 *((Lisp_Object *) (offset + (char *) XCONSOLE (Vconsole_defaults)))
 = value;
 if (mask > 0)		/* Not always per-console */
 {
 Lisp_Object tail;
 /* Set value in each console which hasn't shadowed the default */
 LIST_LOOP (tail, Vconsole_list)
 	{
 	  Lisp_Object dev = XCAR (tail);
 	  struct console *d = XCONSOLE (dev);
 	  if (!(d->local_var_flags & mask))
 	    {
 	      if (magicfun)
 		(magicfun) (sym, &value, dev, 0);
 	      *((Lisp_Object *) (offset + (char *) d)) = value;
 	    }
 	}
 }
 }
 	    if (magicfun)
 	      (magicfun) (sym, &newval, Qnil, 0);
 	    *((Lisp_Object *) symbol_value_forward_forward (fwd)) = newval;
 	    return;
 	  }
 	case SYMVAL_DEFAULT_BUFFER_FORWARD:
 	  {
 	    set_default_buffer_slot_variable (sym, newval);
 	    return;
 	  }
 	  {
 	    if (magicfun)
 	      (magicfun) (sym, &newval, make_buffer (current_buffer), 0);
 	    *((Lisp_Object *) ((char *) current_buffer
 			       + ((char *) symbol_value_forward_forward (fwd)
 				  - (char *) &buffer_local_flags)))
 	      = newval;
 	    return;
 	  }
 	case SYMVAL_DEFAULT_CONSOLE_FORWARD:
 	  {
 	    if (magicfun)
 	      (magicfun) (sym, &newval, Vselected_console, 0);
 	    *((Lisp_Object *) ((char *) XCONSOLE (Vselected_console)
 			       + ((char *) symbol_value_forward_forward (fwd)
 				  - (char *) &console_local_flags)))
 	      = newval;
 	    return;
 	  }
 	default:
 			    struct symbol_value_buffer_local *bfwd)
 {
 if (!NILP (bfwd->current_buffer) &&
 XBUFFER (bfwd->current_buffer) == buffer)
 /* This is just an optimization of the below. */
-return (bfwd->current_alist_element);
+return bfwd->current_alist_element;
 else
-return (assq_no_quit (symbol, buffer->local_var_alist));
+return assq_no_quit (symbol, buffer->local_var_alist);
 }
 /* [Remember that the slot that mirrors CURRENT-VALUE in the
 symbol-value-buffer-local of a per-buffer variable -- i.e. the
 slot in CURRENT-BUFFER's local_var_alist, or the DEFAULT-VALUE
 (Otherwise, you can just retrieve the value without changing the
 cache, at the expense of slower retrieval.)
 */
 static void
 set_up_buffer_local_cache (Lisp_Object sym,
 			   struct symbol_value_buffer_local *bfwd,
 			   struct buffer *buf,
 			   Lisp_Object new_alist_el,
 			   int set_it_p)
 {
 Lisp_Object prev = Qnil;
 Lisp_Object alist;
 /* Any which are supposed to be permanent,
 make local again, with the same values they had.  */
 for (alist = buf->local_var_alist; !NILP (alist); alist = XCDR (alist))
 {
 Lisp_Object sym = XCAR (XCAR (alist));
 struct symbol_value_buffer_local *bfwd;
 /* Variables with a symbol-value-varalias should not be here
 retry:
 valcontents = XSYMBOL (sym)->value;
 retry_2:
 if (!SYMBOL_VALUE_MAGIC_P (valcontents))
-return (valcontents);
+return valcontents;
 switch (XSYMBOL_VALUE_MAGIC_TYPE (valcontents))
 {
 case SYMVAL_LISP_MAGIC:
 /* #### kludge */
 	    else
 	      valcontents = XCDR (symcons);
 	  }
 	break;
 }
 default:
 break;
 }
-return (do_symval_forwarding (valcontents, buf, con));
+return do_symval_forwarding (valcontents, buf, con);
 }
 /* Find the value of a symbol in BUFFER, returning Qunbound if it's not
 bound.  Note that it must not be possible to QUIT within this
 {
 /* WARNING: This function can be called when current_buffer is 0
 and Vselected_console is Qnil, early in initialization. */
 struct console *dev;
 Lisp_Object sym = find_it_p ? XCAR (symbol_cons) : symbol_cons;
 CHECK_SYMBOL (sym);
 if (CONSOLEP (Vselected_console))
 dev = XCONSOLE (Vselected_console);
 else
 {
 	      return newval;
 	    valcontents = XSYMBOL_VALUE_LISP_MAGIC (valcontents)->shadowed;
 	    /* semi-change-o */
 	    goto retry_2;
 	  }
 	case SYMVAL_VARALIAS:
 	  sym = follow_varalias_pointers (sym,
 					  UNBOUNDP (newval)
 					  ? Qmakunbound : Qset);
 	  /* presto change-o! */
 	case SYMVAL_BOOLEAN_FORWARD:
 	case SYMVAL_OBJECT_FORWARD:
 	case SYMVAL_DEFAULT_BUFFER_FORWARD:
 	case SYMVAL_DEFAULT_CONSOLE_FORWARD:
 	  if (UNBOUNDP (newval))
 	    signal_error (Qerror,
 			  list2 (build_string ("Cannot makunbound"), sym));
 	  break;
 	case SYMVAL_UNBOUND_MARKER:
 	  break;
 	       store the current CURRENT-VALUE value into
 	       CURRENT-ALIST- ELEMENT, then find the appropriate alist
 	       element for the buffer now current and set up
 	       CURRENT-ALIST-ELEMENT.  Then we set CURRENT-VALUE out
 	       of that element, and store into CURRENT-BUFFER.
 	       If we are setting the variable and the current buffer does
 	       not have an alist entry for this variable, an alist entry is
 	       created.
 	       Note that CURRENT-VALUE can be a forwarding pointer.
 	       Each time it is examined or set, forwarding must be
 	       done. */
 	    struct symbol_value_buffer_local *bfwd
 	      = XSYMBOL_VALUE_BUFFER_LOCAL (valcontents);
 		/* If the current buffer is not the buffer whose binding is
 		   currently cached, or if it's a SYMVAL_BUFFER_LOCAL and
 		   we're looking at the default value, the cache is invalid; we
 		   need to write it out, and find the new CURRENT-ALIST-ELEMENT
 		   */
 		/* Write out the cached value for the old buffer; copy it
 		   back to its alist element.  This works if the current
 		   buffer only sees the default value, too.  */
 		write_out_buffer_local_cache (sym, bfwd);
 	  abort ();
 	}
 }
 store_symval_forwarding (sym, valcontents, newval);
-return (newval);
+return newval;
 }
 /* Access or set a buffer-local symbol's default value.	 */
 retry:
 valcontents = XSYMBOL (sym)->value;
 retry_2:
 if (!SYMBOL_VALUE_MAGIC_P (valcontents))
-return (valcontents);
+return valcontents;
 switch (XSYMBOL_VALUE_MAGIC_TYPE (valcontents))
 {
 case SYMVAL_LISP_MAGIC:
 /* #### kludge */
 valcontents = XSYMBOL_VALUE_LISP_MAGIC (valcontents)->shadowed;
 }
 case SYMVAL_BUFFER_LOCAL:
 case SYMVAL_SOME_BUFFER_LOCAL:
 {
 	struct symbol_value_buffer_local *bfwd =
 	  XSYMBOL_VALUE_BUFFER_LOCAL (valcontents);
 	/* Handle user-created local variables.	 */
 	/* If var is set up for a buffer that lacks a local value for it,
 	   the current value is nominally the default value.
 	   But the current value slot may be more up to date, since
 	   ordinary setq stores just that slot.	 So use that.  */
 	if (NILP (bfwd->current_alist_element))
-	  return (do_symval_forwarding (bfwd->current_value, current_buffer,
+	  return do_symval_forwarding (bfwd->current_value, current_buffer,
-					XCONSOLE (Vselected_console)));
+				       XCONSOLE (Vselected_console));
 	else
-	  return (bfwd->default_value);
+	  return bfwd->default_value;
 }
 default:
 /* For other variables, get the current value.	*/
-return (do_symval_forwarding (valcontents, current_buffer,
+return do_symval_forwarding (valcontents, current_buffer,
-				    XCONSOLE (Vselected_console)));
+				   XCONSOLE (Vselected_console));
 }
 RETURN_NOT_REACHED(Qnil)	/* suppress compiler warning */
 }
 DEFUN ("default-boundp", Fdefault_boundp, 1, 1, 0, /*
 Return T if SYMBOL has a non-void default value.
 This is the value that is seen in buffers that do not have their own values
 for this variable.
 */
 (sym))
 {
-Lisp_Object value;
+return UNBOUNDP (default_value (sym)) ? Qnil : Qt;
-value = default_value (sym);
-return (UNBOUNDP (value) ? Qnil : Qt);
 }
 DEFUN ("default-value", Fdefault_value, 1, 1, 0, /*
 Return SYMBOL's default value.
 This is the value that is seen in buffers that do not have their own values
 for this variable.  The default value is meaningful for variables with
 local bindings in certain buffers.
 */
 (sym))
 {
-Lisp_Object value;
+Lisp_Object value = default_value (sym);
-value = default_value (sym);
+return UNBOUNDP (value) ? Fsignal (Qvoid_variable, list1 (sym)) : value;
-if (UNBOUNDP (value))
-return Fsignal (Qvoid_variable, list1 (sym));
-return value;
 }
 DEFUN ("set-default", Fset_default, 2, 2, 0, /*
 Set SYMBOL's default value to VAL.  SYMBOL and VAL are evaluated.
 The default value is seen in buffers that do not have their own values
 RETURN_IF_NOT_UNBOUND (maybe_call_magic_handler (sym, Qset_default, 1,
 						       value));
 valcontents = XSYMBOL_VALUE_LISP_MAGIC (valcontents)->shadowed;
 /* semi-change-o */
 goto retry_2;
 case SYMVAL_VARALIAS:
 sym = follow_varalias_pointers (sym, Qset_default);
 /* presto change-o! */
 goto retry;
 case SYMVAL_CURRENT_BUFFER_FORWARD:
 set_default_buffer_slot_variable (sym, value);
-return (value);
+return value;
 case SYMVAL_SELECTED_CONSOLE_FORWARD:
 set_default_console_slot_variable (sym, value);
-return (value);
+return value;
 case SYMVAL_BUFFER_LOCAL:
 case SYMVAL_SOME_BUFFER_LOCAL:
 {
 	/* Store new value into the DEFAULT-VALUE slot */
 	bfwd->default_value = value;
 	/* If current-buffer doesn't shadow default_value,
 	 *  we must set the CURRENT-VALUE slot too */
 	if (NILP (bfwd->current_alist_element))
 	  store_symval_forwarding (sym, bfwd->current_value, value);
-	return (value);
+	return value;
 }
 default:
 return Fset (sym, value);
 }
 	  break;
 	case SYMVAL_CURRENT_BUFFER_FORWARD:
 	case SYMVAL_BUFFER_LOCAL:
 	  /* Already per-each-buffer */
-	  return (variable);
+	  return variable;
 	case SYMVAL_SOME_BUFFER_LOCAL:
 	  /* Transmogrify */
 	  XSYMBOL_VALUE_BUFFER_LOCAL (valcontents)->magic.type =
 	    SYMVAL_BUFFER_LOCAL;
-	  return (variable);
+	  return variable;
 	default:
 	  abort ();
 	}
 }
 {
 struct symbol_value_buffer_local *bfwd
 = alloc_lcrecord (sizeof (struct symbol_value_buffer_local),
 			lrecord_symbol_value_buffer_local);
 Lisp_Object foo = Qnil;
 	case SYMVAL_CURRENT_BUFFER_FORWARD:
 	  {
 	    /* Make sure the symbol has a local value in this particular
 	       buffer, by setting it to the same value it already has.	*/
 	    Fset (variable, find_symbol_value (variable));
-	    return (variable);
+	    return variable;
 	  }
 	case SYMVAL_SOME_BUFFER_LOCAL:
 	  {
 	    if (!NILP (buffer_local_alist_element (current_buffer,
 XSETBUFFER (bfwd->current_buffer, current_buffer);
 bfwd->current_alist_element = Fcons (variable, Qnil);
 current_buffer->local_var_alist =
 	Fcons (bfwd->current_alist_element, current_buffer->local_var_alist);
 store_symval_forwarding (variable, bfwd->current_value, Qnil);
-return (variable);
+return variable;
 }
 current_buffer->local_var_alist
 = Fcons (Fcons (variable, bfwd->default_value),
 	     current_buffer->local_var_alist);
 	default:
 	  abort ();
 	}
 }
-return (variable);
+return variable;
 }
 DEFUN ("kill-local-variable", Fkill_local_variable, 1, 1, "vKill Local Variable: ", /*
 Make VARIABLE no longer have a separate value in the current buffer.
 From now on the default value will apply in this buffer.
 retry:
 valcontents = XSYMBOL (variable)->value;
 retry_2:
 if (!SYMBOL_VALUE_MAGIC_P (valcontents))
-return (variable);
+return variable;
 switch (XSYMBOL_VALUE_MAGIC_TYPE (valcontents))
 {
 case SYMVAL_LISP_MAGIC:
 if (!UNBOUNDP (maybe_call_magic_handler
 case SYMVAL_CURRENT_BUFFER_FORWARD:
 {
 	CONST struct symbol_value_forward *fwd
 	  = XSYMBOL_VALUE_FORWARD (valcontents);
 	int offset = ((char *) symbol_value_forward_forward (fwd)
 			       - (char *) &buffer_local_flags);
 	int mask =
 	  XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd)));
 	if (mask > 0)
 	      (magicfun) (variable, &oldval, make_buffer (current_buffer), 0);
 	    *(Lisp_Object *) (offset + (char *) current_buffer)
 	      = oldval;
 	    current_buffer->local_var_flags &= ~mask;
 	  }
-	return (variable);
+	return variable;
 }
 case SYMVAL_BUFFER_LOCAL:
 case SYMVAL_SOME_BUFFER_LOCAL:
 {
 	   value of the C variable.  set_up_buffer_local_cache()
 	   will do this.  It doesn't hurt to do it always,
 	   so just go ahead and do that. */
 	set_up_buffer_local_cache (variable, bfwd, current_buffer, Qnil, 1);
 }
-return (variable);
+return variable;
 default:
-return (variable);
+return variable;
 }
 RETURN_NOT_REACHED(Qnil)	/* suppress compiler warning */
 }
 retry:
 valcontents = XSYMBOL (variable)->value;
 retry_2:
 if (!SYMBOL_VALUE_MAGIC_P (valcontents))
-return (variable);
+return variable;
 switch (XSYMBOL_VALUE_MAGIC_TYPE (valcontents))
 {
 case SYMVAL_LISP_MAGIC:
 if (!UNBOUNDP (maybe_call_magic_handler
 case SYMVAL_SELECTED_CONSOLE_FORWARD:
 {
 	CONST struct symbol_value_forward *fwd
 	  = XSYMBOL_VALUE_FORWARD (valcontents);
 	int offset = ((char *) symbol_value_forward_forward (fwd)
 			       - (char *) &console_local_flags);
 	int mask =
 	  XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd)));
 	if (mask > 0)
 	      (magicfun) (variable, &oldval, Vselected_console, 0);
 	    *(Lisp_Object *) (offset + (char *) XCONSOLE (Vselected_console))
 	      = oldval;
 	    XCONSOLE (Vselected_console)->local_var_flags &= ~mask;
 	  }
-	return (variable);
+	return variable;
 }
 default:
-return (variable);
+return variable;
 }
 RETURN_NOT_REACHED(Qnil)	/* suppress compiler warning */
 }
 /* Used by specbind to determine what effects it might have.  Returns:
 	      = XSYMBOL_VALUE_FORWARD (valcontents);
 	    int mask = XINT (*((Lisp_Object *)
 			       symbol_value_forward_forward (fwd)));
 	    if ((mask <= 0) || (buffer && (buffer->local_var_flags & mask)))
 	      /* Already buffer-local */
-	      return (1);
+	      return 1;
 	    else
 	      /* Would be buffer-local after set */
-	      return (-1);
+	      return -1;
 	  }
 	case SYMVAL_BUFFER_LOCAL:
 	case SYMVAL_SOME_BUFFER_LOCAL:
 	  {
 	    struct symbol_value_buffer_local *bfwd
 	      = XSYMBOL_VALUE_BUFFER_LOCAL (valcontents);
 	    if (buffer
 		&& !NILP (buffer_local_alist_element (buffer, symbol, bfwd)))
-	      return (1);
+	      return 1;
 	    else
-	      return ((bfwd->magic.type == SYMVAL_BUFFER_LOCAL)
+	      /* Automatically becomes local when set */
-		      ? -1	 /* Automatically becomes local when set */
+	      return bfwd->magic.type == SYMVAL_BUFFER_LOCAL ? -1 : 0;
-		      : 0);
 	  }
 	default:
-	  return (0);
+	  return 0;
 	}
 }
-return (0);
+return 0;
 }
 DEFUN ("symbol-value-in-buffer", Fsymbol_value_in_buffer, 2, 3, 0, /*
 Return the value of SYMBOL in BUFFER, or UNBOUND-VALUE if it is unbound.
 Lisp_Object value;
 CHECK_SYMBOL (symbol);
 CHECK_BUFFER (buffer);
 value = symbol_value_in_buffer (symbol, buffer);
 if (UNBOUNDP (value))
-return (unbound_value);
+return unbound_value;
 else
-return (value);
+return value;
 }
 DEFUN ("symbol-value-in-console", Fsymbol_value_in_console, 2, 3, 0, /*
 Return the value of SYMBOL in CONSOLE, or UNBOUND-VALUE if it is unbound.
 */
 Lisp_Object value;
 CHECK_SYMBOL (symbol);
 CHECK_CONSOLE (console);
 value = symbol_value_in_console (symbol, console);
 if (UNBOUNDP (value))
-return (unbound_value);
+return unbound_value;
 else
-return (value);
+return value;
 }
 DEFUN ("built-in-variable-type", Fbuilt_in_variable_type, 1, 1, 0, /*
 If SYM is a built-in variable, return info about this; else return nil.
 The returned info will be a symbol, one of
 	{
 	case SYMVAL_LISP_MAGIC:
 	  valcontents = XSYMBOL_VALUE_LISP_MAGIC (valcontents)->shadowed;
 	  /* semi-change-o */
 	  goto retry_2;
 	case SYMVAL_VARALIAS:
 	  sym = follow_varalias_pointers (sym, Qt);
 	  /* presto change-o! */
 	  goto retry;
 the variable has had `make-variable-buffer-local' applied to it.
 */
 (symbol, buffer, after_set))
 {
 int local_info;
 CHECK_SYMBOL (symbol);
 if (!NILP (buffer))
 {
 buffer = get_buffer (buffer, 1);
 local_info = symbol_value_buffer_local_info (symbol, XBUFFER (buffer));
 }
 else
 {
 local_info = symbol_value_buffer_local_info (symbol, 0);
 }
 if (NILP (after_set))
-return ((local_info > 0) ? Qt : Qnil);
+return local_info > 0 ? Qt : Qnil;
 else
-return ((local_info != 0) ? Qt : Qnil);
+return local_info != 0 ? Qt : Qnil;
 }
 /*
 I've gone ahead and partially implemented this because it's
 super-useful for dealing with the compatibility problems in supporting
 the old pointer-shape variables, and preventing people from `setq'ing
 the new variables.  Any other way of handling this problem is way
 ugly, likely to be slow, and generally not something I want to waste
 would_be_magic_handled() so it knows about this,
 or dire things could result.
 ************************************************************
 NOTE NOTE NOTE NOTE NOTE NOTE NOTE
 Real documentation is as follows.
 Set a magic handler for VARIABLE.
 This allows you to specify arbitrary behavior that results from
 accessing or setting a variable.  For example, retrieving the
 variable's value might actually retrieve the first element off of
 The meanings of the arguments are as follows:
 SYM is the symbol on which the function was called, and is always
 the first argument to the function.
 ARGS are the remaining arguments in the original call (i.e. all
 but the first).  In the case of `set-value' in particular,
 the first element of ARGS is the value to which the variable
 is being set.  In some cases, ARGS is sanitized from what was
 actually given.  For example, whenever `nil' is passed to an
 argument and it means `current-buffer', the current buffer is
 substituted instead.
 FUN is a symbol indicating which function is being called.
 For many of the functions, you can determine the corresponding
 function of a different class using
 `symbol-function-corresponding-function'.
 HARG is the argument that was given in the call
 to `set-symbol-value-handler' for SYM and HANDLER-TYPE.
 HANDLERS is a structure containing the remaining handlers
 for the variable; to call one of them, use
 `chain-to-symbol-value-handler'.
 NOTE: You may *not* modify the list in ARGS, and if you want to
 */
 static enum lisp_magic_handler
 decode_magic_handler_type (Lisp_Object symbol)
 {
-if (EQ (symbol, Qget_value))
+if (EQ (symbol, Qget_value))       return MAGIC_HANDLER_GET_VALUE;
-return MAGIC_HANDLER_GET_VALUE;
+if (EQ (symbol, Qset_value))       return MAGIC_HANDLER_SET_VALUE;
-if (EQ (symbol, Qset_value))
+if (EQ (symbol, Qbound_predicate)) return MAGIC_HANDLER_BOUND_PREDICATE;
-return MAGIC_HANDLER_SET_VALUE;
+if (EQ (symbol, Qmake_unbound))    return MAGIC_HANDLER_MAKE_UNBOUND;
-if (EQ (symbol, Qbound_predicate))
+if (EQ (symbol, Qlocal_predicate)) return MAGIC_HANDLER_LOCAL_PREDICATE;
-return MAGIC_HANDLER_BOUND_PREDICATE;
+if (EQ (symbol, Qmake_local))      return MAGIC_HANDLER_MAKE_LOCAL;
-if (EQ (symbol, Qmake_unbound))
-return MAGIC_HANDLER_MAKE_UNBOUND;
-if (EQ (symbol, Qlocal_predicate))
-return MAGIC_HANDLER_LOCAL_PREDICATE;
-if (EQ (symbol, Qmake_local))
-return MAGIC_HANDLER_MAKE_LOCAL;
 signal_simple_error ("Unrecognized symbol value handler type", symbol);
 abort ();
 return MAGIC_HANDLER_MAX;
 }
 static Lisp_Object
 follow_varalias_pointers (Lisp_Object object,
 			  Lisp_Object follow_past_lisp_magic)
 {
 Lisp_Object tortoise = object;
 Lisp_Object hare = object;
 /* quick out just in case */
 if (!SYMBOL_VALUE_MAGIC_P (XSYMBOL (object)->value))
 return object;
 value = fetch_value_maybe_past_magic (tortoise, follow_past_lisp_magic);
 tortoise = symbol_value_varalias_aliasee
 	(XSYMBOL_VALUE_VARALIAS (value));
 if (EQ (hare, tortoise))
-	return (Fsignal (Qcyclic_variable_indirection, list1 (object)));
+	return Fsignal (Qcyclic_variable_indirection, list1 (object));
 }
 return hare;
 }
 	    symbol_value_varalias_shadowed
 	      (XSYMBOL_VALUE_VARALIAS (valcontents));
 	}
 return Qnil;
 }
 CHECK_SYMBOL (alias);
 if (SYMBOL_VALUE_VARALIAS_P (valcontents))
 {
 /* transmogrify */
 XSYMBOL_VALUE_VARALIAS (valcontents)->aliasee = alias;
 bfwd = alloc_lcrecord (sizeof (struct symbol_value_varalias),
 			 lrecord_symbol_value_varalias);
 bfwd->magic.type = SYMVAL_VARALIAS;
 bfwd->aliasee = alias;
 bfwd->shadowed = valcontents;
 XSETSYMBOL_VALUE_MAGIC (valcontents, bfwd);
 XSYMBOL (variable)->value = valcontents;
 return Qnil;
 }
 /* Bootstrapping problem: Qnil isn't set when make_pure_pname is
 called the first time. */
 XSYMBOL (Qnil)->name->plist = Qnil;
 XSYMBOL (Qnil)->value = Qnil; /* Nihil ex nihil */
 XSYMBOL (Qnil)->plist = Qnil;
 #ifndef Qzero
 Qzero = make_int (0);	/* Only used if Lisp_Object is a union type */
 #endif
 Vobarray = make_vector (OBARRAY_SIZE, Qzero);
 initial_obarray = Vobarray;
 staticpro (&initial_obarray);
 /* Intern nil in the obarray */
 {
 /* These locals are to kludge around a pyramid compiler bug. */
 int hash;
 Lisp_Object *tem;
 hash = hash_string (string_data (XSYMBOL (Qnil)->name), 3);
 /* Separate statement here to avoid VAXC bug. */
 hash %= OBARRAY_SIZE;
-tem = &vector_data (XVECTOR (Vobarray))[hash];
+tem = &XVECTOR_DATA (Vobarray)[hash];
 *tem = Qnil;
 }
 {
 /* Required to get around a GCC syntax error on certain
 architectures */
 struct symbol_value_magic *tem = &guts_of_unbound_marker;
 XSETSYMBOL_VALUE_MAGIC (Qunbound, tem);
 }
 if ((CONST void *) XPNTR (Qunbound) !=
 (CONST void *)&guts_of_unbound_marker)
 {
 	 So heap-allocate it. */
 struct symbol_value_magic *urk = xmalloc (sizeof (*urk));
 memcpy (urk, &guts_of_unbound_marker, sizeof (*urk));
 XSETSYMBOL_VALUE_MAGIC (Qunbound, urk);
 }
 XSYMBOL (Qnil)->function = Qunbound;
 defsymbol (&Qt, "t");
 XSYMBOL (Qt)->value = Qt;	/* Veritas aetera */
 Vquit_flag = Qnil;
 }
 {
 /* Need to fix lisp.h and eval.c if SUBR_MAX_ARGS too small */
 assert (subr->max_args <= SUBR_MAX_ARGS);
 assert (subr->min_args <= subr->max_args);
 }
 assert (UNBOUNDP (XSYMBOL (sym)->function));
 #endif /* DEBUG_XEMACS */
 XSETSUBR (XSYMBOL (sym)->function, subr);
 }
 DEFSUBR (Fdontusethis_set_symbol_value_handler);
 }
 /* Create and initialize a variable whose value is forwarded to C data */
 void
 defvar_mumble (CONST char *namestring,
 	       CONST void *magic, int sizeof_magic)
 {
 Lisp_Object kludge;
 Lisp_Object sym = Fintern (make_pure_pname ((CONST Bufbyte *) namestring,
 					      strlen (namestring),

Mercurial > hg > xemacs-beta

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