xemacs-beta: src/specifier.c comparison

comparison src/specifier.c @ 185:3d6bfa290dbd r20-3b19

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	2d532a89d707
children	c5d627a313b1

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 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;
 };
-typedef struct specifier_type_entry_dynarr_type
+typedef struct
 {
-Dynarr_declare (struct specifier_type_entry);
+Dynarr_declare (specifier_type_entry);
 } specifier_type_entry_dynarr;
 specifier_type_entry_dynarr *the_specifier_type_entry_dynarr;
 Lisp_Object Vspecifier_type_list;
 /* #### The purpose of this is to check for inheritance loops
 in specifiers that can inherit from other specifiers, but it's
 not yet implemented.
 #### Look into this for 19.14. */
-lisp_dynarr current_specifiers;
+Lisp_Object_dynarr current_specifiers;
 static void recompute_cached_specifier_everywhere (Lisp_Object specifier);
 /************************************************************************/
 }
 static Lisp_Object
 make_specifier (struct specifier_methods *spec_meths)
 {
-struct Lisp_Specifier *sp;
 Lisp_Object specifier = Qnil;
 struct gcpro gcpro1;
+struct Lisp_Specifier *sp = (struct Lisp_Specifier *)
-sp = alloc_lcrecord (sizeof (struct Lisp_Specifier) +
+alloc_lcrecord (sizeof (struct Lisp_Specifier) +
-		       spec_meths->extra_data_size - 1, lrecord_specifier);
+		    spec_meths->extra_data_size - 1, lrecord_specifier);
 sp->methods = spec_meths;
 sp->global_specs = Qnil;
 sp->device_specs = Qnil;
 sp->frame_specs = Qnil;
 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
-any tags defined by `define-specifier-tag'.) It is called a \"tag set\"
+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
 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
 if (len == 0 || len == 1)
 /* most common case */
 return tag_set;
-tags = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
+tags = alloca_array (Lisp_Object, len);
 i = 0;
 LIST_LOOP (rest, tag_set)
 tags[i++] = XCAR (rest);
 }
 enum spec_add_meth
 decode_how_to_add_specification (Lisp_Object how_to_add)
 {
-enum spec_add_meth add_meth = 0;
 if (NILP (how_to_add) || EQ (Qremove_tag_set_prepend, how_to_add))
-add_meth = SPEC_REMOVE_TAG_SET_PREPEND;
+return SPEC_REMOVE_TAG_SET_PREPEND;
-else if (EQ (Qremove_tag_set_append, how_to_add))
+if (EQ (Qremove_tag_set_append, how_to_add))
-add_meth = SPEC_REMOVE_TAG_SET_APPEND;
+return SPEC_REMOVE_TAG_SET_APPEND;
-else if (EQ (Qappend, how_to_add))
+if (EQ (Qappend, how_to_add))
-add_meth = SPEC_APPEND;
+return SPEC_APPEND;
-else if (EQ (Qprepend, how_to_add))
+if (EQ (Qprepend, how_to_add))
-add_meth = SPEC_PREPEND;
+return SPEC_PREPEND;
-else if (EQ (Qremove_locale, how_to_add))
+if (EQ (Qremove_locale, how_to_add))
-add_meth = SPEC_REMOVE_LOCALE;
+return SPEC_REMOVE_LOCALE;
-else if (EQ (Qremove_locale_type, how_to_add))
+if (EQ (Qremove_locale_type, how_to_add))
-add_meth = SPEC_REMOVE_LOCALE_TYPE;
+return SPEC_REMOVE_LOCALE_TYPE;
-else if (EQ (Qremove_all, how_to_add))
+if (EQ (Qremove_all, how_to_add))
-add_meth = SPEC_REMOVE_ALL;
+return SPEC_REMOVE_ALL;
-else
 signal_simple_error ("Invalid `how-to-add' flag", how_to_add);
-return add_meth;
+return SPEC_PREPEND;		/* not reached */
 }
 /* This gets hit so much that the function call overhead had a
 measurable impact (according to Quantify).  #### We should figure
 out the frequency with which this is called with the various types
 and reorder the check accordingly. */
-#define SPECIFIER_GET_SPEC_LIST(specifier, type) \
+#define SPECIFIER_GET_SPEC_LIST(specifier, type)			\
-(type == LOCALE_GLOBAL				\
+(type == LOCALE_GLOBAL ? &(XSPECIFIER (specifier)->global_specs)   :	\
-? &(XSPECIFIER (specifier)->global_specs)	\
+type == LOCALE_DEVICE ? &(XSPECIFIER (specifier)->device_specs)   :	\
-: (type == LOCALE_DEVICE			\
+type == LOCALE_FRAME  ? &(XSPECIFIER (specifier)->frame_specs)    :	\
-? &(XSPECIFIER (specifier)->device_specs)	\
+type == LOCALE_WINDOW ? &(XWEAK_LIST_LIST				\
-: (type == LOCALE_FRAME			\
+			   (XSPECIFIER (specifier)->window_specs)) :	\
-? &(XSPECIFIER (specifier)->frame_specs)	\
+type == LOCALE_BUFFER ? &(XSPECIFIER (specifier)->buffer_specs)   :	\
-: (type == LOCALE_WINDOW			\
+0)
-	  ? &(XWEAK_LIST_LIST (XSPECIFIER (specifier)->window_specs)) \
-	  : (type == LOCALE_BUFFER		\
-	     ? &(XSPECIFIER (specifier)->buffer_specs) \
-	     : 0)))))
 static Lisp_Object *
 specifier_get_inst_list (Lisp_Object specifier, Lisp_Object locale,
 			 enum spec_locale_type type)
 {
 'append		Add to the end of the current list of
 			instantiators for LOCALE.
 'remove-tag-set-prepend (this is the default)
 			Remove any existing instantiators whose tag set is
 			the same as TAG-SET; then put the new instantiator
-			at the beginning of the current list. (\"Same tag
+			at the beginning of the current list. ("Same tag
-			set\" means that they contain the same elements.
+			set" means that they contain the same elements.
 			The order may be different.)
 'remove-tag-set-append
 			Remove any existing instantiators whose tag set is
 			the same as TAG-SET; then put the new instantiator
 			at the end of the current list.
 DEFUN ("specifier-specs", Fspecifier_specs, 1, 4, 0, /*
 Return the specification(s) for SPECIFIER in LOCALE.
 If LOCALE is a single locale or is a list of one element containing a
-single locale, then a \"short form\" of the instantiators for that locale
+single locale, then a "short form" of the instantiators for that locale
 will be returned.  Otherwise, this function is identical to
 `specifier-spec-list'.
-The \"short form\" is designed for readability and not for ease of use
+The "short form" is designed for readability and not for ease of use
 in Lisp programs, and is as follows:
 1. If there is only one instantiator, then an inst-pair (i.e. cons of
 tag and instantiator) will be returned; otherwise a list of
 inst-pairs will be returned.
 as a locale (e.g. a buffer) are not valid as a domain because they do not
 provide enough information to identify a particular device (see
 `valid-specifier-domain-p').  DOMAIN defaults to the selected window
 if omitted.
-\"Instantiating\" a specifier in a particular domain means determining
+"Instantiating" a specifier in a particular domain means determining
-the specifier's \"value\" in that domain.  This is accomplished by
+the specifier's "value" in that domain.  This is accomplished by
 searching through the specifications in the specifier that correspond
 to all locales that can be derived from the given domain, from specific
 to general.  In most cases, the domain is an Emacs window.  In that case
 specifications are searched for as follows:
 Return an instance for SPECIFIER in DOMAIN that matches MATCHSPEC.
 If no instance can be generated for this domain, return DEFAULT.
 This function is identical to `specifier-instance' except that a
 specification will only be considered if it matches MATCHSPEC.
-The definition of \"match\", and allowed values for MATCHSPEC, are
+The definition of "match", and allowed values for MATCHSPEC, are
 dependent on the particular type of specifier.  Here are some examples:
 -- For chartable (e.g. display table) specifiers, MATCHSPEC should be a
 character, and the specification (a chartable) must give a value for
 that character in order to be considered.  This allows you to specify,
 			Lisp_Object oldval))
 {
 struct Lisp_Specifier *sp = XSPECIFIER (specifier);
 if (!sp->caching)
-sp->caching = malloc_type_and_zero (struct specifier_caching);
+sp->caching = xnew_and_zero (struct specifier_caching);
 sp->caching->offset_into_struct_window = struct_window_offset;
 sp->caching->value_changed_in_window = value_changed_in_window;
 sp->caching->offset_into_struct_frame = struct_frame_offset;
 sp->caching->value_changed_in_frame = value_changed_in_frame;
 Vcached_specifiers = Fcons (specifier, Vcached_specifiers);
 }
 void
 specifier_type_create (void)
 {
-the_specifier_type_entry_dynarr = Dynarr_new (struct specifier_type_entry);
+the_specifier_type_entry_dynarr = Dynarr_new (specifier_type_entry);
 Vspecifier_type_list = Qnil;
 staticpro (&Vspecifier_type_list);
 INITIALIZE_SPECIFIER_TYPE (generic, "generic", "generic-specifier-p");

Mercurial > hg > xemacs-beta

comparison src/specifier.c @ 185:3d6bfa290dbd r20-3b19