xemacs-beta: src/specifier.c comparison

comparison src/specifier.c @ 442:abe6d1db359e r21-2-36

Import from CVS: tag r21-2-36

author	cvs
date	Mon, 13 Aug 2007 11:35:02 +0200
parents	8de8e3f6228a
children	576fb035e263

comparison

equal deleted inserted replaced

-:72a7cfa4a488
+:abe6d1db359e
 #include "window.h"
 #include "chartab.h"
 #include "rangetab.h"
 Lisp_Object Qspecifierp;
-Lisp_Object Qprepend, Qappend, Qremove_tag_set_prepend, Qremove_tag_set_append;
+Lisp_Object Qremove_tag_set_prepend, Qremove_tag_set_append;
-Lisp_Object Qremove_locale, Qremove_locale_type, Qremove_all;
+Lisp_Object Qremove_locale, Qremove_locale_type;
-Lisp_Object Qfallback;
-/* Qinteger, Qboolean, Qgeneric defined in general.c. */
-Lisp_Object Qnatnum;
 Lisp_Object Qconsole_type, Qdevice_class;
+Lisp_Object Qspecifier_syntax_error;
+Lisp_Object Qspecifier_argument_error;
+Lisp_Object Qspecifier_change_error;
 static Lisp_Object Vuser_defined_tags;
 typedef struct specifier_type_entry specifier_type_entry;
 struct specifier_type_entry
 static specifier_type_entry_dynarr *the_specifier_type_entry_dynarr;
 static const struct lrecord_description ste_description_1[] = {
 { XD_LISP_OBJECT, offsetof (specifier_type_entry, symbol) },
-{ XD_STRUCT_PTR,  offsetof (specifier_type_entry, meths), 1, &specifier_methods_description },
+{ XD_STRUCT_PTR,  offsetof (specifier_type_entry, meths), 1,
+&specifier_methods_description },
 { XD_END }
 };
 static const struct struct_description ste_description = {
 sizeof (specifier_type_entry),
 		internal_hash (s->frame_specs,  depth + 1),
 		internal_hash (s->buffer_specs, depth + 1));
 }
 static size_t
-sizeof_specifier (CONST void *header)
+sizeof_specifier (const void *header)
 {
 if (GHOST_SPECIFIER_P ((Lisp_Specifier *) header))
 return offsetof (Lisp_Specifier, data);
 else
 {
-CONST Lisp_Specifier *p = (CONST Lisp_Specifier *) header;
+const Lisp_Specifier *p = (const Lisp_Specifier *) header;
 return offsetof (Lisp_Specifier, data) + p->methods->extra_data_size;
 }
 }
 static const struct lrecord_description specifier_methods_description_1[] = {
 sizeof (struct specifier_caching),
 specifier_caching_description_1
 };
 static const struct lrecord_description specifier_description[] = {
-{ XD_STRUCT_PTR,  offsetof (Lisp_Specifier, methods), 1, &specifier_methods_description },
+{ XD_STRUCT_PTR,  offsetof (Lisp_Specifier, methods), 1,
+&specifier_methods_description },
 { XD_LO_LINK,     offsetof (Lisp_Specifier, next_specifier) },
 { XD_LISP_OBJECT, offsetof (Lisp_Specifier, global_specs) },
 { XD_LISP_OBJECT, offsetof (Lisp_Specifier, device_specs) },
 { XD_LISP_OBJECT, offsetof (Lisp_Specifier, frame_specs) },
 { XD_LISP_OBJECT, offsetof (Lisp_Specifier, window_specs) },
 { XD_LISP_OBJECT, offsetof (Lisp_Specifier, buffer_specs) },
-{ XD_STRUCT_PTR,  offsetof (Lisp_Specifier, caching), 1, &specifier_caching_description },
+{ XD_STRUCT_PTR,  offsetof (Lisp_Specifier, caching), 1,
+&specifier_caching_description },
 { XD_LISP_OBJECT, offsetof (Lisp_Specifier, magic_parent) },
 { XD_LISP_OBJECT, offsetof (Lisp_Specifier, fallback) },
 { XD_SPECIFIER_END }
 };
 {
 if (EQ (type, Dynarr_at (the_specifier_type_entry_dynarr, i).symbol))
 	return Dynarr_at (the_specifier_type_entry_dynarr, i).meths;
 }
-maybe_signal_simple_error ("Invalid specifier type", type,
+maybe_signal_type_error (Qspecifier_argument_error, "Invalid specifier type",
-			     Qspecifier, errb);
+			   type, Qspecifier, errb);
 return 0;
 }
 static int
 DEFUN ("make-specifier", Fmake_specifier, 1, 1, 0, /*
 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.
+and can further be restricted to a particular console-type or
-Specifiers are used, for example, for the various built-in properties of a
+device-class.  Specifiers are used, for example, for the various
-face; this allows a face to have different values in different frames,
+built-in properties of a face; this allows a face to have different
-buffers, etc.  For more information, see `specifier-instance',
+values in different frames, buffers, etc.
+When speaking of the value of a specifier, it is important to
+distinguish between the *setting* of a specifier, called an
+\"instantiator\", and the *actual value*, called an \"instance\".  You
+put various possible instantiators (i.e. settings) into a specifier
+and associate them with particular locales (buffer, window, frame,
+device, global), and then the instance (i.e. actual value) is
+retrieved in a specific domain (window, frame, device) by looking
+through the possible instantiators (i.e. settings).  This process is
+called \"instantiation\".
+To put settings into a specifier, use `set-specifier', or the
+lower-level functions `add-spec-to-specifier' and
+`add-spec-list-to-specifier'.  You can also temporarily bind a setting
+to a specifier using `let-specifier'.  To retrieve settings, use
+`specifier-specs', or its lower-level counterpart
+`specifier-spec-list'.  To determine the actual value, use
+`specifier-instance'.
+For more information, see `set-specifier', `specifier-instance',
 `specifier-specs', and `add-spec-to-specifier'; or, for a detailed
-description of specifiers, including how they are instantiated over a
+description of specifiers, including how exactly the instantiation
-particular domain (i.e. how their value in that domain is determined),
+process works, see the chapter on specifiers in the XEmacs Lisp
-see the chapter on specifiers in the XEmacs Lisp Reference Manual.
+Reference Manual.
 TYPE specifies the particular type of specifier, and should be one of
-the symbols 'generic, 'integer, 'boolean, 'color, 'font, 'image,
+the symbols 'generic, 'integer, 'natnum, 'boolean, 'color, 'font,
-'face-boolean, or 'toolbar.
+'image, 'face-boolean, 'display-table, 'gutter, 'gutter-size,
+'gutter-visible or 'toolbar.
-For more information on particular types of specifiers, see the functions
-`generic-specifier-p', `integer-specifier-p', `boolean-specifier-p',
+For more information on particular types of specifiers, see the
-`color-specifier-p', `font-specifier-p', `image-specifier-p',
+functions `make-generic-specifier', `make-integer-specifier',
-`face-boolean-specifier-p', and `toolbar-specifier-p'.
+`make-natnum-specifier', `make-boolean-specifier',
+`make-color-specifier', `make-font-specifier', `make-image-specifier',
+`make-face-boolean-specifier', `make-gutter-size-specifier',
+`make-gutter-visible-specifier', `default-toolbar', `default-gutter',
+and `current-display-table'.
 */
 (type))
 {
 /* This function can GC */
-struct specifier_methods *meths = decode_specifier_type (type,
+struct specifier_methods *meths = decode_specifier_type (type, ERROR_ME);
-							   ERROR_ME);
 return make_specifier (meths);
 }
 DEFUN ("specifierp", Fspecifierp, 1, 1, 0, /*
 }
 DEFUN ("valid-specifier-domain-p", Fvalid_specifier_domain_p, 1, 1, 0, /*
 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 windows, frames, and devices.
+value in that domain).  Valid domains are image instances, windows, frames,
-\(nil is not valid.)
+and devices. \(nil is not valid.) image instances are pseudo-domains since
+instantiation will actually occur in the window the image instance itself is
+instantiated in.
 */
 (domain))
 {
 /* This cannot GC. */
 return ((DEVICEP (domain) && DEVICE_LIVE_P (XDEVICE (domain))) ||
 	  (FRAMEP  (domain) && FRAME_LIVE_P  (XFRAME  (domain))) ||
-	  (WINDOWP (domain) && WINDOW_LIVE_P (XWINDOW (domain))))
+	  (WINDOWP (domain) && WINDOW_LIVE_P (XWINDOW (domain))) ||
+	  /* #### get image instances out of domains! */
+	  IMAGE_INSTANCEP (domain))
 ? Qt : Qnil;
 }
-DEFUN ("valid-specifier-locale-type-p", Fvalid_specifier_locale_type_p, 1, 1, 0, /*
+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
 type, 'global is considered an individual locale.)
 */
 /* This cannot GC. */
 if (EQ (locale, Qall) ||
 !NILP (Fvalid_specifier_locale_p (locale)) ||
 !NILP (Fvalid_specifier_locale_type_p (locale)))
 return;
-signal_simple_error ("Invalid specifier locale or locale type", locale);
+signal_type_error (Qspecifier_argument_error,
+		     "Invalid specifier locale or locale type", locale);
 }
 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);
+signal_type_error (Qspecifier_argument_error, "Invalid specifier locale",
+		       locale);
 if (DEVICEP (locale)) return Qdevice;
 if (FRAMEP  (locale)) return Qframe;
 if (WINDOWP (locale)) return Qwindow;
 if (BUFFERP (locale)) return Qbuffer;
 assert (EQ (locale, Qglobal));
 if (NILP (locale))
 return Qglobal;
 else if (!NILP (Fvalid_specifier_locale_p (locale)))
 return locale;
 else
-signal_simple_error ("Invalid specifier locale", locale);
+signal_type_error (Qspecifier_argument_error, "Invalid specifier locale",
+		       locale);
 return Qnil;
 }
 static enum spec_locale_type
 if (EQ (locale_type, Qdevice)) return LOCALE_DEVICE;
 if (EQ (locale_type, Qframe))  return LOCALE_FRAME;
 if (EQ (locale_type, Qwindow)) return LOCALE_WINDOW;
 if (EQ (locale_type, Qbuffer)) return LOCALE_BUFFER;
-signal_simple_error ("Invalid specifier locale type", locale_type);
+signal_type_error (Qspecifier_argument_error, "Invalid specifier locale type",
+		     locale_type);
 return LOCALE_GLOBAL; /* not reached */
 }
 Lisp_Object
 decode_locale_list (Lisp_Object locale)
 {
 return list1 (Qall);
 }
 else if (CONSP (locale))
 {
-Lisp_Object elt;
 EXTERNAL_LIST_LOOP_2 (elt, locale)
 	check_valid_locale_or_locale_type (elt);
 return locale;
 }
 else
 static void
 check_valid_domain (Lisp_Object domain)
 {
 if (NILP (Fvalid_specifier_domain_p (domain)))
-signal_simple_error ("Invalid specifier domain", domain);
+signal_type_error (Qspecifier_argument_error, "Invalid specifier domain",
-}
+		       domain);
+}
-static Lisp_Object
+Lisp_Object
 decode_domain (Lisp_Object domain)
 {
 if (NILP (domain))
 return Fselected_window (Qnil);
 check_valid_domain (domain);
 {
 /* The return value of this function must be GCPRO'd. */
 if (!NILP (Fvalid_specifier_tag_p (tag_set)))
 return list1 (tag_set);
 if (NILP (Fvalid_specifier_tag_set_p (tag_set)))
-signal_simple_error ("Invalid specifier tag-set", tag_set);
+signal_type_error (Qspecifier_argument_error, "Invalid specifier tag-set",
+		       tag_set);
 return tag_set;
 }
 static Lisp_Object
 canonicalize_tag_set (Lisp_Object tag_set)
 sorting by symbol name and removing duplicates.)
 */
 (tag_set))
 {
 if (NILP (Fvalid_specifier_tag_set_p (tag_set)))
-signal_simple_error ("Invalid tag set", tag_set);
+signal_type_error (Qspecifier_argument_error, "Invalid tag set", tag_set);
 return canonicalize_tag_set (tag_set);
 }
 static int
 device_matches_specifier_tag_set_p (Lisp_Object device, Lisp_Object tag_set)
 }
 return 1;
 }
-DEFUN ("device-matches-specifier-tag-set-p", Fdevice_matches_specifier_tag_set_p, 2, 2, 0, /*
+DEFUN ("device-matches-specifier-tag-set-p",
+Fdevice_matches_specifier_tag_set_p, 2, 2, 0, /*
 Return non-nil if DEVICE matches specifier tag set TAG-SET.
 This means that DEVICE matches each tag in the tag set. (Every
 tag recognized by XEmacs has a predicate associated with it that
 specifies which devices match it.)
 */
 (device, tag_set))
 {
 CHECK_LIVE_DEVICE (device);
 if (NILP (Fvalid_specifier_tag_set_p (tag_set)))
-signal_simple_error ("Invalid tag set", tag_set);
+signal_type_error (Qspecifier_argument_error, "Invalid tag set", tag_set);
 return device_matches_specifier_tag_set_p (device, tag_set) ? Qt : Qnil;
 }
 DEFUN ("define-specifier-tag", Fdefine_specifier_tag, 1, 2, 0, /*
 int recompute = 0;
 CHECK_SYMBOL (tag);
 if (valid_device_class_p (tag) ||
 valid_console_type_p (tag))
-signal_simple_error ("Cannot redefine built-in specifier tags", tag);
+signal_type_error (Qspecifier_change_error,
+		       "Cannot redefine built-in specifier tags", tag);
 /* Try to prevent common instantiators and locales from being
 redefined, to reduce ambiguity */
 if (NILP (tag) || EQ (tag, Qt) || EQ (tag, Qall) || EQ (tag, Qglobal))
-signal_simple_error ("Cannot define nil, t, 'all, or 'global",
+signal_type_error (Qspecifier_change_error, "Cannot define nil, t, 'all, or 'global",
-			 tag);
+		       tag);
 assoc = assq_no_quit (tag, Vuser_defined_tags);
 if (NILP (assoc))
 {
 recompute = 1;
 Vuser_defined_tags = Fcons (Fcons (tag, predicate), Vuser_defined_tags);
 else
 	XCDR (XCAR (rest2)) = !NILP (call1 (predicate, device)) ? Qt : Qnil;
 }
 }
-DEFUN ("device-matching-specifier-tag-list", Fdevice_matching_specifier_tag_list,
+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))
 {
 /* The return value of this function must be GCPRO'd. */
 CHECK_SYMBOL (tag);
 if (NILP (Fvalid_specifier_tag_p (tag)))
-signal_simple_error ("Invalid specifier tag", tag);
+signal_type_error (Qspecifier_argument_error, "Invalid specifier tag",
+		       tag);
 /* Make up some predicates for the built-in types */
 if (valid_console_type_p (tag))
 return list3 (Qlambda, list1 (Qdevice),
 {
 Lisp_Object inst_pair, tag_set;
 if (!CONSP (rest))
 	{
-	  maybe_signal_simple_error ("Invalid instantiator list", inst_list,
+	  maybe_signal_type_error (Qspecifier_syntax_error,
+				   "Invalid instantiator list", inst_list,
 				     Qspecifier, errb);
 	  return Qnil;
 	}
 if (!CONSP (inst_pair = XCAR (rest)))
 	{
-	  maybe_signal_simple_error ("Invalid instantiator pair", inst_pair,
+	  maybe_signal_type_error (Qspecifier_syntax_error,
+				   "Invalid instantiator pair", inst_pair,
 				     Qspecifier, errb);
 	  return Qnil;
 	}
 if (NILP (Fvalid_specifier_tag_set_p (tag_set = XCAR (inst_pair))))
 	{
-	  maybe_signal_simple_error ("Invalid specifier tag", tag_set,
+	  maybe_signal_type_error (Qspecifier_syntax_error,
+				   "Invalid specifier tag", tag_set,
 				     Qspecifier, errb);
 	  return Qnil;
 	}
 if (NILP (check_valid_instantiator (XCDR (inst_pair), meths, errb)))
 LIST_LOOP (rest, spec_list)
 {
 Lisp_Object spec, locale;
 if (!CONSP (rest) || !CONSP (spec = XCAR (rest)))
 	{
-	  maybe_signal_simple_error ("Invalid specification list", spec_list,
+	  maybe_signal_type_error (Qspecifier_syntax_error,
+				   "Invalid specification list", spec_list,
 				     Qspecifier, errb);
 	  return Qnil;
 	}
 if (NILP (Fvalid_specifier_locale_p (locale = XCAR (spec))))
 	{
-	  maybe_signal_simple_error ("Invalid specifier locale", locale,
+	  maybe_signal_type_error (Qspecifier_syntax_error,
+				   "Invalid specifier locale", locale,
 				     Qspecifier, errb);
 	  return Qnil;
 	}
 if (NILP (check_valid_inst_list (XCDR (spec), meths, errb)))
 if (EQ (Qremove_locale_type, how_to_add))
 return SPEC_REMOVE_LOCALE_TYPE;
 if (EQ (Qremove_all, how_to_add))
 return SPEC_REMOVE_ALL;
-signal_simple_error ("Invalid `how-to-add' flag", how_to_add);
+signal_type_error (Qspecifier_argument_error, "Invalid `how-to-add' flag",
+		     how_to_add);
 return SPEC_PREPEND;		/* not reached */
 }
 /* Given a specifier object SPEC, return bodily specifier if SPEC is a
 static void
 check_modifiable_specifier (Lisp_Object spec)
 {
 if (NILP (Vunlock_ghost_specifiers)
 && GHOST_SPECIFIER_P (XSPECIFIER (spec)))
-signal_simple_error ("Attempt to modify read-only specifier",
+signal_type_error (Qspecifier_change_error,
+		       "Attempt to modify read-only specifier",
 			 list1 (spec));
 }
 /* Helper function which unwind protects the value of
 Vunlock_ghost_specifiers, then sets it to non-nil value */
 if (add_meth == SPEC_PREPEND)
 tem = nconc2 (list_to_build_up, *orig_inst_list);
 else if (add_meth == SPEC_APPEND)
 tem = nconc2 (*orig_inst_list, list_to_build_up);
 else
-abort ();
+{
+abort ();
+tem = Qnil;
+}
 *orig_inst_list = tem;
 UNGCPRO;
 	 intern (meths->name), Qspecifier, errb);
 return Qnil;
 }
 }
-DEFUN ("check-valid-specifier-matchspec", Fcheck_valid_specifier_matchspec, 2, 2, 0, /*
+DEFUN ("check-valid-specifier-matchspec", Fcheck_valid_specifier_matchspec, 2,
+2, 0, /*
 Signal an error if MATCHSPEC is invalid for SPECIFIER-TYPE.
 See `specifier-matching-instance' for a description of matchspecs.
 */
 (matchspec, specifier_type))
 {
 struct gcpro gcpro1, gcpro2;
 GCPRO2 (specifier, inst_list);
 sp = XSPECIFIER (specifier);
-device = DFW_DEVICE (domain);
+device = DOMAIN_DEVICE (domain);
 if (no_quit)
 /* The instantiate method is allowed to call eval.  Since it
 is quite common for this function to get called from somewhere in
 redisplay we need to make sure that quits are ignored.  Otherwise
 sp = XSPECIFIER (specifier);
 /* Attempt to determine buffer, window, frame, and device from the
 domain. */
-if (WINDOWP (domain))
+/* #### get image instances out of domains! */
+if (IMAGE_INSTANCEP (domain))
+window = DOMAIN_WINDOW (domain);
+else if (WINDOWP (domain))
 window = domain;
 else if (FRAMEP (domain))
 frame = domain;
 else if (DEVICEP (domain))
 device = domain;
 else
-/* #### dmoore - dammit, this should just signal an error or something
+/* dmoore writes: [dammit, this should just signal an error or something
-shouldn't it?
+shouldn't it?]
-#### No. Errors are handled in Lisp primitives implementation.
+No. Errors are handled in Lisp primitives implementation.
 Invalid domain is a design error here - kkm. */
 abort ();
 if (NILP (buffer) && !NILP (window))
 buffer = XWINDOW (window)->buffer;
 					     0, Qzero);
 UNGCPRO;
 return UNBOUNDP (val) ? default_ : val;
 }
-DEFUN ("specifier-matching-instance-from-inst-list", Fspecifier_matching_instance_from_inst_list,
+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),
 matching the specifications against MATCHSPEC.
 better be able to deal.  If not, set a default so this
 never happens or correct it in the value_changed_in_window
 method. */
 location = (Lisp_Object *)
 ((char *) w + XSPECIFIER (specifier)->caching->offset_into_struct_window);
+/* #### What's the point of this check, other than to optimize image
+instance instantiation? Unless you specify a caching instantiate
+method the instantiation that specifier_instance will do will
+always create a new copy. Thus EQ will always fail. Unfortunately
+calling equal is no good either as this doesn't take into account
+things attached to the specifier - for instance strings on
+extents. --andyp */
 if (!EQ (newval, *location))
 {
 Lisp_Object oldval = *location;
 *location = newval;
 (XSPECIFIER (specifier)->caching->value_changed_in_window)
 is supposed to require only that the specifier type is passed,
 while with this approach the actual specifier is needed.)
 What really needs to be done is to write a function
 `make-specifier-type' that creates new specifier types.
-#### I'll look into this for 19.14.
-*/
+#### [I'll look into this for 19.14.]  Well, sometime. (Currently
+May 2000, 21.2 is in development.  19.14 was released in June 1996.) */
 "A generic specifier is a generalized kind of specifier with user-defined\n"
 "semantics.  The instantiator can be any kind of Lisp object, and the\n"
 "instance computed from it is likewise any kind of Lisp object.  The\n"
 "SPECIFIER-DATA should be an alist of methods governing how the specifier\n"
 #endif /* 0 */
 DEFUN ("generic-specifier-p", Fgeneric_specifier_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a generic specifier.
-A generic specifier allows any kind of Lisp object as an instantiator,
+See `make-generic-specifier' for a description of possible generic
-and returns back the Lisp object unchanged when it is instantiated.
+instantiators.
 */
 (object))
 {
 return GENERIC_SPECIFIERP (object) ? Qt : Qnil;
 }
 CHECK_INT (instantiator);
 }
 DEFUN ("integer-specifier-p", Finteger_specifier_p, 1, 1, 0, /*
 Return non-nil if OBJECT is an integer specifier.
+See `make-integer-specifier' for a description of possible integer
+instantiators.
 */
 (object))
 {
 return INTEGER_SPECIFIERP (object) ? Qt : Qnil;
 }
 CHECK_NATNUM (instantiator);
 }
 DEFUN ("natnum-specifier-p", Fnatnum_specifier_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a natnum (non-negative-integer) specifier.
+See `make-natnum-specifier' for a description of possible natnum
+instantiators.
 */
 (object))
 {
 return NATNUM_SPECIFIERP (object) ? Qt : Qnil;
 }
 static void
 boolean_validate (Lisp_Object instantiator)
 {
 if (!EQ (instantiator, Qt) && !EQ (instantiator, Qnil))
-signal_simple_error ("Must be t or nil", instantiator);
+signal_type_error (Qspecifier_argument_error, "Must be t or nil",
+		       instantiator);
 }
 DEFUN ("boolean-specifier-p", Fboolean_specifier_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a boolean specifier.
+See `make-boolean-specifier' for a description of possible boolean
+instantiators.
 */
 (object))
 {
 return BOOLEAN_SPECIFIERP (object) ? Qt : Qnil;
 }
 /*                        Display table specifier type                  */
 /************************************************************************/
 DEFINE_SPECIFIER_TYPE (display_table);
-#define VALID_SINGLE_DISPTABLE_INSTANTIATOR_P(instantiator)			\
+#define VALID_SINGLE_DISPTABLE_INSTANTIATOR_P(instantiator)		   \
-(VECTORP (instantiator)							\
+(VECTORP (instantiator)						   \
-|| (CHAR_TABLEP (instantiator)						\
+|| (CHAR_TABLEP (instantiator)					   \
-&& (XCHAR_TABLE_TYPE (instantiator) == CHAR_TABLE_TYPE_CHAR		\
+&& (XCHAR_TABLE_TYPE (instantiator) == CHAR_TABLE_TYPE_CHAR	   \
-	   || XCHAR_TABLE_TYPE (instantiator) == CHAR_TABLE_TYPE_GENERIC))	\
+	   || XCHAR_TABLE_TYPE (instantiator) == CHAR_TABLE_TYPE_GENERIC)) \
 || RANGE_TABLEP (instantiator))
 static void
 display_table_validate (Lisp_Object instantiator)
 {
 else
 {
 if (!VALID_SINGLE_DISPTABLE_INSTANTIATOR_P (instantiator))
 	{
 	lose:
-	  dead_wrong_type_argument (display_table_specifier_methods->predicate_symbol,
+	  dead_wrong_type_argument
+	    (display_table_specifier_methods->predicate_symbol,
 				    instantiator);
 	}
 }
 }
 DEFUN ("display-table-specifier-p", Fdisplay_table_specifier_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a display-table specifier.
+See `current-display-table' for a description of possible display-table
+instantiators.
 */
 (object))
 {
 return DISPLAYTABLE_SPECIFIERP (object) ? Qt : Qnil;
 }
 /************************************************************************/
 void
 syms_of_specifier (void)
 {
-defsymbol (&Qspecifierp, "specifierp");
+INIT_LRECORD_IMPLEMENTATION (specifier);
-defsymbol (&Qconsole_type, "console-type");
+DEFSYMBOL (Qspecifierp);
-defsymbol (&Qdevice_class, "device-class");
+DEFSYMBOL (Qconsole_type);
-/* Qinteger, Qboolean, Qgeneric defined in general.c */
+DEFSYMBOL (Qdevice_class);
-defsymbol (&Qnatnum, "natnum");
+/* specifier types defined in general.c. */
 DEFSUBR (Fvalid_specifier_type_p);
 DEFSUBR (Fspecifier_type_list);
 DEFSUBR (Fmake_specifier);
 DEFSUBR (Fspecifierp);
 /* Symbols pertaining to specifier creation.  Specifiers are created
 in the syms_of() functions. */
 /* locales are defined in general.c. */
-defsymbol (&Qprepend, "prepend");
+/* some how-to-add flags in general.c. */
-defsymbol (&Qappend, "append");
+DEFSYMBOL (Qremove_tag_set_prepend);
-defsymbol (&Qremove_tag_set_prepend, "remove-tag-set-prepend");
+DEFSYMBOL (Qremove_tag_set_append);
-defsymbol (&Qremove_tag_set_append, "remove-tag-set-append");
+DEFSYMBOL (Qremove_locale);
-defsymbol (&Qremove_locale, "remove-locale");
+DEFSYMBOL (Qremove_locale_type);
-defsymbol (&Qremove_locale_type, "remove-locale-type");
-defsymbol (&Qremove_all, "remove-all");
+DEFERROR_STANDARD (Qspecifier_syntax_error, Qsyntax_error);
+DEFERROR_STANDARD (Qspecifier_argument_error, Qinvalid_argument);
-defsymbol (&Qfallback, "fallback");
+DEFERROR_STANDARD (Qspecifier_change_error, Qinvalid_change);
 }
 void
 specifier_type_create (void)
 {
 INITIALIZE_SPECIFIER_TYPE (boolean, "boolean", "boolean-specifier-p");
 SPECIFIER_HAS_METHOD (boolean, validate);
-INITIALIZE_SPECIFIER_TYPE (display_table, "display-table", "display-table-p");
+INITIALIZE_SPECIFIER_TYPE (display_table, "display-table",
+			     "display-table-p");
 SPECIFIER_HAS_METHOD (display_table, validate);
 }
 void

Mercurial > hg > xemacs-beta

comparison src/specifier.c @ 442:abe6d1db359e r21-2-36