xemacs-beta: src/specifier.c comparison

comparison src/specifier.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	3d6bfa290dbd
children	6330739388db

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 Lisp_Object Qconsole_type, Qdevice_class;
 Lisp_Object Vuser_defined_tags;
-MAC_DEFINE (struct Lisp_Specifier *, MTspecmeth_or_given)
-MAC_DEFINE (struct Lisp_Specifier *, MTspecifier_data)
 typedef struct specifier_type_entry specifier_type_entry;
 struct specifier_type_entry
 {
 Lisp_Object symbol;
 struct specifier_methods *meths;
 #### Look into this for 19.14. */
 Lisp_Object_dynarr current_specifiers;
 static void recompute_cached_specifier_everywhere (Lisp_Object specifier);
+EXFUN (Fspecifier_specs, 4);
+EXFUN (Fremove_specifier, 4);
 /************************************************************************/
 /*                       Specifier object methods                       */
 /************************************************************************/
-static Lisp_Object mark_specifier (Lisp_Object, void (*) (Lisp_Object));
-static void print_specifier (Lisp_Object, Lisp_Object, int);
-static int specifier_equal (Lisp_Object, Lisp_Object, int depth);
-static unsigned long specifier_hash (Lisp_Object obj, int depth);
-static unsigned int sizeof_specifier (CONST void *header);
-static void finalize_specifier (void *header, int for_disksave);
-DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION ("specifier", specifier,
-					mark_specifier, print_specifier,
-					finalize_specifier,
-					specifier_equal, specifier_hash,
-					sizeof_specifier,
-					struct Lisp_Specifier);
 /* Remove dead objects from the specified assoc list. */
 static Lisp_Object
 cleanup_assoc_list (Lisp_Object list)
 /* This function can be called from within redisplay.
 internal_equal can trigger a quit.  That leads to Bad Things. */
 Vinhibit_quit = Qt;
 depth++;
-if (s1->methods != s2->methods ||
+retval =
-!internal_equal (s1->global_specs, s2->global_specs, depth) ||
+(s1->methods == s2->methods &&
-!internal_equal (s1->device_specs, s2->device_specs, depth) ||
+internal_equal (s1->global_specs, s2->global_specs, depth) &&
-!internal_equal (s1->frame_specs, s2->frame_specs, depth) ||
+internal_equal (s1->device_specs, s2->device_specs, depth) &&
-!internal_equal (s1->window_specs, s2->window_specs, depth) ||
+internal_equal (s1->frame_specs,  s2->frame_specs,  depth) &&
-!internal_equal (s1->buffer_specs, s2->buffer_specs, depth) ||
+internal_equal (s1->window_specs, s2->window_specs, depth) &&
-!SPECMETH_OR_GIVEN (s1, equal, (o1, o2, depth - 1), 1))
+internal_equal (s1->buffer_specs, s2->buffer_specs, depth));
-retval = 0;
-else
+if (retval && HAS_SPECMETH_P (s1, equal))
-retval = 1;
+retval = SPECMETH (s1, equal, (o1, o2, depth - 1));
 Vinhibit_quit = old_inhibit_quit;
 return retval;
 }
 struct Lisp_Specifier *s = XSPECIFIER (obj);
 /* specifier hashing is a bit problematic because there are so
 many places where data can be stored.  We pick what are perhaps
 the most likely places where interesting stuff will be. */
-return HASH5 (SPECMETH_OR_GIVEN (s, hash, (obj, depth), 0),
+return HASH5 ((HAS_SPECMETH_P (s, hash) ?
+		 SPECMETH (s, hash, (obj, depth)) : 0),
 		(unsigned long) s->methods,
 		internal_hash (s->global_specs, depth + 1),
-		internal_hash (s->frame_specs, depth + 1),
+		internal_hash (s->frame_specs,  depth + 1),
 		internal_hash (s->buffer_specs, depth + 1));
 }
-static unsigned int
+static size_t
 sizeof_specifier (CONST void *header)
 {
 CONST struct Lisp_Specifier *p = (CONST struct Lisp_Specifier *) header;
 return sizeof (*p) + p->methods->extra_data_size - 1;
 }
+DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION ("specifier", specifier,
+					mark_specifier, print_specifier,
+					finalize_specifier,
+					specifier_equal, specifier_hash,
+					sizeof_specifier,
+					struct Lisp_Specifier);
 /************************************************************************/
 /*                       Creating specifiers                            */
 /************************************************************************/
 }
 static int
 valid_specifier_type_p (Lisp_Object type)
 {
-if (decode_specifier_type (type, ERROR_ME_NOT))
+return decode_specifier_type (type, ERROR_ME_NOT) != 0;
-return 1;
-return 0;
 }
 DEFUN ("valid-specifier-type-p", Fvalid_specifier_type_p, 1, 1, 0, /*
 Given a SPECIFIER-TYPE, return non-nil if it is valid.
 Valid types are 'generic, 'integer, boolean, 'color, 'font, 'image,
 'face-boolean, and 'toolbar.
 */
 (specifier_type))
 {
-if (valid_specifier_type_p (specifier_type))
+return valid_specifier_type_p (specifier_type) ? Qt : Qnil;
-return Qt;
-else
-return Qnil;
 }
 DEFUN ("specifier-type-list", Fspecifier_type_list, 0, 0, 0, /*
 Return a list of valid specifier types.
 */
 }
 static Lisp_Object
 make_specifier (struct specifier_methods *spec_meths)
 {
-Lisp_Object specifier = Qnil;
+Lisp_Object specifier;
 struct gcpro gcpro1;
 struct Lisp_Specifier *sp = (struct Lisp_Specifier *)
 alloc_lcrecord (sizeof (struct Lisp_Specifier) +
 		    spec_meths->extra_data_size - 1, lrecord_specifier);
 UNGCPRO;
 return specifier;
 }
 DEFUN ("make-specifier", Fmake_specifier, 1, 1, 0, /*
-Create a new specifier.
+Return a new specifier object of type TYPE.
 A specifier is an object that can be used to keep track of a property
 whose value can be per-buffer, per-window, per-frame, or per-device,
 and can further be restricted to a particular console-type or device-class.
 Specifiers are used, for example, for the various built-in properties of a
 return make_specifier (meths);
 }
 DEFUN ("specifierp", Fspecifierp, 1, 1, 0, /*
-Return non-nil if OBJECT is a specifier.
+Return t if OBJECT is a specifier.
 A specifier is an object that can be used to keep track of a property
 whose value can be per-buffer, per-window, per-frame, or per-device,
 and can further be restricted to a particular console-type or device-class.
 See `make-specifier'.
 */
 (object))
 {
-if (!SPECIFIERP (object))
+return SPECIFIERP (object) ? Qt : Qnil;
-return Qnil;
-return Qt;
 }
 DEFUN ("specifier-type", Fspecifier_type, 1, 1, 0, /*
 Return the type of SPECIFIER.
 */
 /************************************************************************/
 /*                       Locales and domains                            */
 /************************************************************************/
 DEFUN ("valid-specifier-locale-p", Fvalid_specifier_locale_p, 1, 1, 0, /*
-Return non-nil if LOCALE is a valid specifier locale.
+Return t if LOCALE is a valid specifier locale.
-Valid locales are a device, a frame, a window, a buffer, and 'global.
+Valid locales are devices, frames, windows, buffers, and 'global.
-(nil is not valid.)
+\(nil is not valid.)
 */
 (locale))
 {
 /* This cannot GC. */
-if ((DEVICEP (locale) && DEVICE_LIVE_P (XDEVICE (locale))) ||
+return ((DEVICEP (locale) && DEVICE_LIVE_P (XDEVICE (locale))) ||
-(FRAMEP  (locale) && FRAME_LIVE_P  (XFRAME  (locale))) ||
+	  (FRAMEP  (locale) && FRAME_LIVE_P  (XFRAME  (locale))) ||
-(BUFFERP (locale) && BUFFER_LIVE_P (XBUFFER (locale))) ||
+	  (BUFFERP (locale) && BUFFER_LIVE_P (XBUFFER (locale))) ||
-/* dead windows are allowed because they may become live
+	  /* dead windows are allowed because they may become live
-	 windows again when a window configuration is restored */
+	     windows again when a window configuration is restored */
-WINDOWP (locale) ||
+	  WINDOWP (locale) ||
-EQ (locale, Qglobal))
+	  EQ (locale, Qglobal))
-return Qt;
+? Qt : Qnil;
-else
-return Qnil;
 }
 DEFUN ("valid-specifier-domain-p", Fvalid_specifier_domain_p, 1, 1, 0, /*
-Return non-nil if DOMAIN is a valid specifier domain.
+Return t if DOMAIN is a valid specifier domain.
 A domain is used to instance a specifier (i.e. determine the specifier's
-value in that domain).  Valid domains are a window, frame, or device.
+value in that domain).  Valid domains are windows, frames, and devices.
-(nil is not valid.)
+\(nil is not valid.)
 */
 (domain))
 {
 /* This cannot GC. */
-if ((DEVICEP (domain) && DEVICE_LIVE_P (XDEVICE (domain))) ||
+return ((DEVICEP (domain) && DEVICE_LIVE_P (XDEVICE (domain))) ||
-(FRAMEP  (domain) && FRAME_LIVE_P  (XFRAME  (domain))) ||
+	  (FRAMEP  (domain) && FRAME_LIVE_P  (XFRAME  (domain))) ||
-(WINDOWP (domain) && WINDOW_LIVE_P (XWINDOW (domain))))
+	  (WINDOWP (domain) && WINDOW_LIVE_P (XWINDOW (domain))))
-return Qt;
+? Qt : Qnil;
-else
-return Qnil;
 }
 DEFUN ("valid-specifier-locale-type-p", Fvalid_specifier_locale_type_p, 1, 1, 0, /*
 Given a specifier LOCALE-TYPE, return non-nil if it is valid.
 Valid locale types are 'global, 'device, 'frame, 'window, and 'buffer.
-(Note, however, that in functions that accept either a locale or a locale
+\(Note, however, that in functions that accept either a locale or a locale
 type, 'global is considered an individual locale.)
 */
 (locale_type))
 {
 /* This cannot GC. */
-if (EQ (locale_type, Qglobal) ||
+return (EQ (locale_type, Qglobal) ||
-EQ (locale_type, Qdevice) ||
+	  EQ (locale_type, Qdevice) ||
-EQ (locale_type, Qframe)  ||
+	  EQ (locale_type, Qframe)  ||
-EQ (locale_type, Qwindow) ||
+	  EQ (locale_type, Qwindow) ||
-EQ (locale_type, Qbuffer))
+	  EQ (locale_type, Qbuffer)) ? Qt : Qnil;
-return Qt;
-else
-return Qnil;
 }
 static void
 check_valid_locale_or_locale_type (Lisp_Object locale)
 {
 !NILP (Fvalid_specifier_locale_type_p (locale)))
 return;
 signal_simple_error ("Invalid specifier locale or locale type", locale);
 }
-DEFUN ("specifier-locale-type-from-locale", Fspecifier_locale_type_from_locale, 1, 1, 0, /*
+DEFUN ("specifier-locale-type-from-locale",
+Fspecifier_locale_type_from_locale, 1, 1, 0, /*
 Given a specifier LOCALE, return its type.
 */
 (locale))
 {
 /* This cannot GC. */
 if (NILP (Fvalid_specifier_locale_p (locale)))
 signal_simple_error ("Invalid specifier locale", locale);
-if (DEVICEP (locale))
+if (DEVICEP (locale)) return Qdevice;
-return Qdevice;
+if (FRAMEP  (locale)) return Qframe;
-if (FRAMEP (locale))
+if (WINDOWP (locale)) return Qwindow;
-return Qframe;
+if (BUFFERP (locale)) return Qbuffer;
-if (WINDOWP (locale))
-return Qwindow;
-if (BUFFERP (locale))
-return Qbuffer;
 assert (EQ (locale, Qglobal));
 return Qglobal;
 }
-Lisp_Object
+static Lisp_Object
 decode_locale (Lisp_Object locale)
 {
 /* This cannot GC. */
 if (NILP (locale))
 return Qglobal;
 {
 if (NILP (Fvalid_specifier_domain_p (domain)))
 signal_simple_error ("Invalid specifier domain", domain);
 }
-Lisp_Object
+static Lisp_Object
 decode_domain (Lisp_Object domain)
 {
 if (NILP (domain))
 return Fselected_window (Qnil);
 check_valid_domain (domain);
 Return non-nil if TAG is a valid specifier tag.
 See also `valid-specifier-tag-set-p'.
 */
 (tag))
 {
-if (valid_console_type_p (tag) ||
+return (valid_console_type_p (tag) ||
-valid_device_class_p (tag) ||
+	  valid_device_class_p (tag) ||
-!NILP (assq_no_quit (tag, Vuser_defined_tags)))
+	  !NILP (assq_no_quit (tag, Vuser_defined_tags))) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("valid-specifier-tag-set-p", Fvalid_specifier_tag_set_p, 1, 1, 0, /*
 Return non-nil if TAG-SET is a valid specifier tag set.
 particular device class or device type and/or to mark instantiators
 added by a particular package so that they can be later removed.
 A specifier tag set consists of a list of zero of more specifier tags,
 each of which is a symbol that is recognized by XEmacs as a tag.
-(The valid device types and device classes are always tags, as are
+\(The valid device types and device classes are always tags, as are
 any tags defined by `define-specifier-tag'.) It is called a "tag set"
-(as opposed to a list) because the order of the tags or the number of
+\(as opposed to a list) because the order of the tags or the number of
 times a particular tag occurs does not matter.
 Each tag has a predicate associated with it, which specifies whether
 that tag applies to a particular device.  The tags which are device types
 and classes match devices of that type or class.  User-defined tags can
 }
 DEFUN ("define-specifier-tag", Fdefine_specifier_tag, 1, 2, 0, /*
 Define a new specifier tag.
 If PREDICATE is specified, it should be a function of one argument
-(a device) that specifies whether the tag matches that particular
+\(a device) that specifies whether the tag matches that particular
 device.  If PREDICATE is omitted, the tag matches all devices.
 You can redefine an existing user-defined specifier tag.  However,
 you cannot redefine the built-in specifier tags (the device types
 and classes) or the symbols nil, t, 'all, or 'global.
 void
 setup_device_initial_specifier_tags (struct device *d)
 {
 Lisp_Object rest, rest2;
-Lisp_Object device = Qnil;
+Lisp_Object device;
 XSETDEVICE (device, d);
 DEVICE_USER_DEFINED_TAGS (d) = Fcopy_alist (Vuser_defined_tags);
 else
 	XCDR (XCAR (rest2)) = !NILP (call1 (predicate, device)) ? Qt : Qnil;
 }
 }
-DEFUN ("device-matching-specifier-tag-list", Fdevice_matching_specifier_tag_list, 0, 1, 0, /*
+DEFUN ("device-matching-specifier-tag-list",
+Fdevice_matching_specifier_tag_list, 0, 1, 0, /*
 Return a list of all specifier tags matching DEVICE.
 DEVICE defaults to the selected device if omitted.
 */
 (device))
 {
 	list = Fcons (XCAR (XCAR (rest)), list);
 }
 list = Fnreverse (list);
 list = Fcons (DEVICE_CLASS (d), list);
-list = Fcons (DEVICE_TYPE (d), list);
+list = Fcons (DEVICE_TYPE  (d), list);
 RETURN_UNGCPRO (list);
 }
 DEFUN ("specifier-tag-list", Fspecifier_tag_list, 0, 0, 0, /*
 {
 Lisp_Object rest;
 LIST_LOOP (rest, inst_list)
 {
-if (!CONSP (rest) || !CONSP (XCAR (rest)))
+Lisp_Object inst_pair, tag_set;
+if (!CONSP (rest))
 	{
 	  maybe_signal_simple_error ("Invalid instantiator list", inst_list,
 				     Qspecifier, errb);
 	  return Qnil;
 	}
-if (NILP (Fvalid_specifier_tag_set_p (XCAR (XCAR (rest)))))
+if (!CONSP (inst_pair = XCAR (rest)))
 	{
-	  maybe_signal_simple_error ("Invalid specifier tag",
+	  maybe_signal_simple_error ("Invalid instantiator pair", inst_pair,
-				     XCAR (XCAR (rest)), Qspecifier, errb);
+				     Qspecifier, errb);
 	  return Qnil;
 	}
+if (NILP (Fvalid_specifier_tag_set_p (tag_set = XCAR (inst_pair))))
-if (NILP (check_valid_instantiator (XCDR (XCAR (rest)), meths,
+	{
-					  errb)))
+	  maybe_signal_simple_error ("Invalid specifier tag", tag_set,
+				     Qspecifier, errb);
+	  return Qnil;
+	}
+if (NILP (check_valid_instantiator (XCDR (inst_pair), meths, errb)))
 	return Qnil;
 }
 return Qt;
 }
 {
 Lisp_Object rest;
 LIST_LOOP (rest, spec_list)
 {
-if (!CONSP (rest) || !CONSP (XCAR (rest)))
+Lisp_Object spec, locale;
+if (!CONSP (rest) || !CONSP (spec = XCAR (rest)))
 	{
 	  maybe_signal_simple_error ("Invalid specification list", spec_list,
 				     Qspecifier, errb);
 	  return Qnil;
 	}
-if (NILP (Fvalid_specifier_locale_p (XCAR (XCAR (rest)))))
+if (NILP (Fvalid_specifier_locale_p (locale = XCAR (spec))))
 	{
-	  maybe_signal_simple_error ("Invalid specifier locale",
+	  maybe_signal_simple_error ("Invalid specifier locale", locale,
-				     XCAR (XCAR (rest)),
 				     Qspecifier, errb);
 	  return Qnil;
 	}
-if (NILP (check_valid_inst_list (XCDR (XCAR (rest)), meths, errb)))
+if (NILP (check_valid_inst_list (XCDR (spec), meths, errb)))
 	return Qnil;
 }
 return Qt;
 }
 static enum spec_add_meth
 handle_multiple_add_insts (Lisp_Object *inst_list,
 			   Lisp_Object new_list,
 			   enum spec_add_meth add_meth)
 {
-if (add_meth == SPEC_REMOVE_TAG_SET_PREPEND ||
+switch (add_meth)
-add_meth == SPEC_REMOVE_TAG_SET_APPEND)
+{
-{
+case SPEC_REMOVE_TAG_SET_APPEND:
-Lisp_Object rest;
+add_meth = SPEC_APPEND;
+goto remove_tag_set;
-LIST_LOOP (rest, new_list)
+case SPEC_REMOVE_TAG_SET_PREPEND:
-	{
+add_meth = SPEC_PREPEND;
-	  Lisp_Object canontag = canonicalize_tag_set (XCAR (XCAR (rest)));
+remove_tag_set:
-	  struct gcpro gcpro1;
+{
+	Lisp_Object rest;
-	  GCPRO1 (canontag);
-	  /* pull out all elements from the existing list with the
+	LIST_LOOP (rest, new_list)
-	     same tag as any tags in NEW_LIST. */
+	  {
-	  *inst_list = remassoc_no_quit (canontag, *inst_list);
+	    Lisp_Object canontag = canonicalize_tag_set (XCAR (XCAR (rest)));
-	  UNGCPRO;
+	    struct gcpro gcpro1;
-	}
-if (add_meth == SPEC_REMOVE_TAG_SET_PREPEND)
+	    GCPRO1 (canontag);
-	return SPEC_PREPEND;
+	    /* pull out all elements from the existing list with the
-else
+	       same tag as any tags in NEW_LIST. */
-	return SPEC_APPEND;
+	    *inst_list = remassoc_no_quit (canontag, *inst_list);
-}
+	    UNGCPRO;
-else if (add_meth == SPEC_REMOVE_LOCALE)
+	  }
-{
+}
+return add_meth;
+case SPEC_REMOVE_LOCALE:
 *inst_list = Qnil;
 return SPEC_PREPEND;
-}
+case SPEC_APPEND:
-if (add_meth == SPEC_APPEND)
+return add_meth;
-return add_meth;
+default:
+return SPEC_PREPEND;
-return SPEC_PREPEND;
+}
 }
 /* Given a LOCALE and INST_LIST that is going to be added to SPECIFIER,
 copy, canonicalize, and call the going_to_add methods as necessary
 to produce a new list that is the one that really will be added
 build_up_processed_list (Lisp_Object specifier, Lisp_Object locale,
 			 Lisp_Object inst_list)
 {
 /* The return value of this function must be GCPRO'd. */
 Lisp_Object rest, list_to_build_up = Qnil;
+struct Lisp_Specifier *sp = XSPECIFIER (specifier);
 struct gcpro gcpro1;
 GCPRO1 (list_to_build_up);
 LIST_LOOP (rest, inst_list)
 {
 Lisp_Object sub_inst_list = Qnil;
 struct gcpro ngcpro1, ngcpro2;
 NGCPRO2 (instantiator, sub_inst_list);
 /* call the will-add method; it may GC */
-sub_inst_list = SPECMETH_OR_GIVEN (XSPECIFIER (specifier), going_to_add,
+sub_inst_list = HAS_SPECMETH_P (sp, going_to_add) ?
-					 (specifier, locale, tag_set,
+	SPECMETH (sp, going_to_add,
-					  instantiator), Qt);
+		  (specifier, locale, tag_set, instantiator)) :
+	Qt;
 if (EQ (sub_inst_list, Qt))
 	/* no change here. */
 	sub_inst_list = list1 (Fcons (canonicalize_tag_set (tag_set),
 				      instantiator));
 else
 static void
 specifier_add_spec (Lisp_Object specifier, Lisp_Object locale,
 		    Lisp_Object inst_list, enum spec_add_meth add_meth)
 {
 struct Lisp_Specifier *sp = XSPECIFIER (specifier);
-enum spec_locale_type type;
+enum spec_locale_type type = locale_type_from_locale (locale);
-Lisp_Object *orig_inst_list;
+Lisp_Object *orig_inst_list, tem;
 Lisp_Object list_to_build_up = Qnil;
 struct gcpro gcpro1;
-type = locale_type_from_locale (locale);
 GCPRO1 (list_to_build_up);
 list_to_build_up = build_up_processed_list (specifier, locale, inst_list);
 /* Now handle REMOVE_LOCALE_TYPE and REMOVE_ALL.  These are the
 add-meth types that affect locales other than this one. */
 specifier_remove_locale_type (specifier, type, Qnil, 0);
 else if (add_meth == SPEC_REMOVE_ALL)
 {
 specifier_remove_locale_type (specifier, LOCALE_BUFFER, Qnil, 0);
 specifier_remove_locale_type (specifier, LOCALE_WINDOW, Qnil, 0);
-specifier_remove_locale_type (specifier, LOCALE_FRAME, Qnil, 0);
+specifier_remove_locale_type (specifier, LOCALE_FRAME,  Qnil, 0);
 specifier_remove_locale_type (specifier, LOCALE_DEVICE, Qnil, 0);
 specifier_remove_spec (specifier, Qglobal, LOCALE_GLOBAL, Qnil, 0);
 }
 orig_inst_list = specifier_get_inst_list (specifier, locale, type);
 orig_inst_list = specifier_new_spec (specifier, locale, type);
 add_meth = handle_multiple_add_insts (orig_inst_list, list_to_build_up,
 					add_meth);
 if (add_meth == SPEC_PREPEND)
-{
+tem = nconc2 (list_to_build_up, *orig_inst_list);
-*orig_inst_list = nconc2 (list_to_build_up, *orig_inst_list);
-}
 else if (add_meth == SPEC_APPEND)
-{
+tem = nconc2 (*orig_inst_list, list_to_build_up);
-*orig_inst_list = nconc2 (*orig_inst_list, list_to_build_up);
-}
 else
 abort ();
+*orig_inst_list = tem;
 UNGCPRO;
 /* call the after-change method */
 MAYBE_SPECMETH (sp, after_change, (specifier, locale));
 add_meth = decode_how_to_add_specification (how_to_add);
 LIST_LOOP (rest, spec_list)
 {
 /* Placating the GCC god. */
-Lisp_Object crock1 = specifier;
+Lisp_Object specification = XCAR (rest);
-Lisp_Object crock2 = XCAR (XCAR (rest));
+Lisp_Object locale    = XCAR (specification);
-Lisp_Object crock3 = XCDR (XCAR (rest));
+Lisp_Object inst_list = XCDR (specification);
-specifier_add_spec (crock1, crock2, crock3, add_meth);
+specifier_add_spec (specifier, locale, inst_list, add_meth);
 }
 recompute_cached_specifier_everywhere (specifier);
 return Qnil;
 }
 result is as if `specifier-spec-list' were called on each element of the
 list and the results concatenated together.
 Only instantiators where TAG-SET (a list of zero or more tags) is a
 subset of (or possibly equal to) the instantiator's tag set are returned.
-(The default value of nil is a subset of all tag sets, so in this case
+\(The default value of nil is a subset of all tag sets, so in this case
 no instantiators will be screened out.) If EXACT-P is non-nil, however,
 TAG-SET must be equal to an instantiator's tag set for the instantiator
 to be returned.
 */
 (specifier, locale, tag_set, exact_p))
 	  if (HAS_SPECMETH_P (sp, instantiate))
 	    val = call_with_suspended_errors
 	      ((lisp_fn_t) RAW_SPECMETH (sp, instantiate),
 	       Qunbound, Qspecifier, errb, 5, specifier,
-	       matchspec, domain, XCDR (tagged_inst), depth);
+	       matchspec, domain, val, depth);
 	  if (!UNBOUNDP (val))
 	    {
 	      unbind_to (count, Qnil);
 	      UNGCPRO;
 DEFUN ("specifier-matching-instance-from-inst-list",
 Fspecifier_matching_instance_from_inst_list, 4, 5, 0, /*
 Attempt to convert a particular inst-list into an instance.
 This attempts to instantiate INST-LIST in the given DOMAIN
-(as if INST-LIST existed in a specification in SPECIFIER),
+\(as if INST-LIST existed in a specification in SPECIFIER),
 matching the specifications against MATCHSPEC.
 This function is analogous to `specifier-instance-from-inst-list'
 but allows for specification-matching as in `specifier-matching-instance'.
 See that function for a description of exactly how the matching process
 static void
 recompute_one_cached_specifier_in_window (Lisp_Object specifier,
 					  struct window *w)
 {
-Lisp_Object window = Qnil;
+Lisp_Object window;
 Lisp_Object newval, *location;
 XSETWINDOW (window, w);
 newval = specifier_instance (specifier, Qunbound, window, ERROR_ME_WARN,
 static void
 recompute_one_cached_specifier_in_frame (Lisp_Object specifier,
 					 struct frame *f)
 {
-Lisp_Object frame = Qnil;
+Lisp_Object frame;
 Lisp_Object newval, *location;
 XSETFRAME (frame, f);
 newval = specifier_instance (specifier, Qunbound, frame, ERROR_ME_WARN,

Mercurial > hg > xemacs-beta

comparison src/specifier.c @ 272:c5d627a313b1 r21-0b34