xemacs-beta: src/specifier.c comparison

comparison src/specifier.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	56c54cf7c5b6

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 if (decode_specifier_type (type, ERROR_ME_NOT))
 return 1;
 return 0;
 }
-DEFUN ("valid-specifier-type-p", Fvalid_specifier_type_p,
+DEFUN ("valid-specifier-type-p", Fvalid_specifier_type_p, 1, 1, 0, /*
-Svalid_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)
+(specifier_type))
-Lisp_Object specifier_type;
 {
 if (valid_specifier_type_p (specifier_type))
 return Qt;
 else
 return Qnil;
 }
-DEFUN ("specifier-type-list", Fspecifier_type_list, Sspecifier_type_list,
+DEFUN ("specifier-type-list", Fspecifier_type_list, 0, 0, 0, /*
-0, 0, 0 /*
 Return a list of valid specifier types.
-*/ )
+*/
-()
+())
 {
 return Fcopy_sequence (Vspecifier_type_list);
 }
 void
 MAYBE_SPECMETH (XSPECIFIER (specifier), create, (specifier));
 UNGCPRO;
 return specifier;
 }
-DEFUN ("make-specifier", Fmake_specifier, Smake_specifier, 1, 1, 0 /*
+DEFUN ("make-specifier", Fmake_specifier, 1, 1, 0, /*
 Create a new 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.
 For more information on particular types of specifiers, see the functions
 `generic-specifier-p', `integer-specifier-p', `boolean-specifier-p',
 `color-specifier-p', `font-specifier-p', `image-specifier-p',
 `face-boolean-specifier-p', and `toolbar-specifier-p'.
-*/ )
+*/
-(type)
+(type))
-Lisp_Object type;
 {
 /* This function can GC */
 struct specifier_methods *meths = decode_specifier_type (type,
 							   ERROR_ME);
 return make_specifier (meths);
 }
-DEFUN ("specifierp", Fspecifierp, Sspecifierp, 1, 1, 0 /*
+DEFUN ("specifierp", Fspecifierp, 1, 1, 0, /*
 Return non-nil 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)
+(object))
-Lisp_Object object;
 {
 if (!SPECIFIERP (object))
 return Qnil;
 return Qt;
 }
-DEFUN ("specifier-type", Fspecifier_type, Sspecifier_type, 1, 1, 0 /*
+DEFUN ("specifier-type", Fspecifier_type, 1, 1, 0, /*
 Return the type of SPECIFIER.
-*/ )
+*/
-(specifier)
+(specifier))
-Lisp_Object specifier;
 {
 CHECK_SPECIFIER (specifier);
 return intern (XSPECIFIER (specifier)->methods->name);
 }
 /************************************************************************/
 /*                       Locales and domains                            */
 /************************************************************************/
-DEFUN ("valid-specifier-locale-p", Fvalid_specifier_locale_p,
+DEFUN ("valid-specifier-locale-p", Fvalid_specifier_locale_p, 1, 1, 0, /*
-Svalid_specifier_locale_p, 1, 1, 0 /*
 Return non-nil if LOCALE is a valid specifier locale.
 Valid locales are a device, a frame, a window, a buffer, and 'global.
 (nil is not valid.)
-*/ )
+*/
-(locale)
+(locale))
-Lisp_Object locale;
 {
 /* This cannot GC. */
 if ((DEVICEP (locale) && DEVICE_LIVE_P (XDEVICE (locale))) ||
 (FRAMEP  (locale) && FRAME_LIVE_P  (XFRAME  (locale))) ||
 (BUFFERP (locale) && BUFFER_LIVE_P (XBUFFER (locale))) ||
 return Qt;
 else
 return Qnil;
 }
-DEFUN ("valid-specifier-domain-p",
+DEFUN ("valid-specifier-domain-p", Fvalid_specifier_domain_p, 1, 1, 0, /*
-Fvalid_specifier_domain_p,
-Svalid_specifier_domain_p, 1, 1, 0 /*
 Return non-nil 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.
 (nil is not valid.)
-*/ )
+*/
-(domain)
+(domain))
-Lisp_Object domain;
 {
 /* This cannot GC. */
 if ((DEVICEP (domain) && DEVICE_LIVE_P (XDEVICE (domain))) ||
 (FRAMEP  (domain) && FRAME_LIVE_P  (XFRAME  (domain))) ||
 (WINDOWP (domain) && WINDOW_LIVE_P (XWINDOW (domain))))
 return Qt;
 else
 return Qnil;
 }
-DEFUN ("valid-specifier-locale-type-p",
+DEFUN ("valid-specifier-locale-type-p", Fvalid_specifier_locale_type_p, 1, 1, 0, /*
-Fvalid_specifier_locale_type_p,
-Svalid_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.)
-*/ )
+*/
-(locale_type)
+(locale_type))
-Lisp_Object locale_type;
 {
 /* This cannot GC. */
 if (EQ (locale_type, Qglobal) ||
 EQ (locale_type, Qdevice) ||
 EQ (locale_type, Qframe)  ||
 !NILP (Fvalid_specifier_locale_type_p (locale)))
 return;
 signal_simple_error ("Invalid specifier locale or locale type", locale);
 }
-DEFUN ("specifier-locale-type-from-locale",
+DEFUN ("specifier-locale-type-from-locale", Fspecifier_locale_type_from_locale, 1, 1, 0, /*
-Fspecifier_locale_type_from_locale,
-Sspecifier_locale_type_from_locale, 1, 1, 0 /*
 Given a specifier LOCALE, return its type.
-*/ )
+*/
-(locale)
+(locale))
-Lisp_Object locale;
 {
 /* This cannot GC. */
 if (NILP (Fvalid_specifier_locale_p (locale)))
 signal_simple_error ("Invalid specifier locale", locale);
 if (DEVICEP (locale))
 /************************************************************************/
 /*                                 Tags                                 */
 /************************************************************************/
-DEFUN ("valid-specifier-tag-p", Fvalid_specifier_tag_p,
+DEFUN ("valid-specifier-tag-p", Fvalid_specifier_tag_p, 1, 1, 0, /*
-Svalid_specifier_tag_p,
-1, 1, 0 /*
 Return non-nil if TAG is a valid specifier tag.
 See also `valid-specifier-tag-set-p'.
-*/ )
+*/
-(tag)
+(tag))
-Lisp_Object tag;
 {
 if (valid_console_type_p (tag) ||
 valid_device_class_p (tag) ||
 !NILP (assq_no_quit (tag, Vuser_defined_tags)))
 return Qt;
 return Qnil;
 }
-DEFUN ("valid-specifier-tag-set-p", Fvalid_specifier_tag_set_p,
+DEFUN ("valid-specifier-tag-set-p", Fvalid_specifier_tag_set_p, 1, 1, 0, /*
-Svalid_specifier_tag_set_p,
-1, 1, 0 /*
 Return non-nil if TAG-SET is a valid specifier tag set.
 A specifier tag set is an entity that is attached to an instantiator
 and can be used to restrict the scope of that instantiator to a
 particular device class or device type and/or to mark instantiators
 considered if the device of the domain being instanced over matches
 all tags in the tag set attached to that instantiator.
 Most of the time, a tag set is not specified, and the instantiator
 gets a null tag set, which matches all devices.
-*/ )
+*/
-(tag_set)
+(tag_set))
-Lisp_Object tag_set;
 {
 Lisp_Object rest;
 for (rest = tag_set; !NILP (rest); rest = XCDR (rest))
 {
 }
 return Flist (j, tags);
 }
-DEFUN ("canonicalize-tag-set", Fcanonicalize_tag_set,
+DEFUN ("canonicalize-tag-set", Fcanonicalize_tag_set, 1, 1, 0, /*
-Scanonicalize_tag_set, 1, 1, 0 /*
 Canonicalize the given tag set.
 Two canonicalized tag sets can be compared with `equal' to see if they
 represent the same tag set. (Specifically, canonicalizing involves
 sorting by symbol name and removing duplicates.)
-*/ )
+*/
-(tag_set)
+(tag_set))
-Lisp_Object tag_set;
 {
 if (NILP (Fvalid_specifier_tag_set_p (tag_set)))
 signal_simple_error ("Invalid tag set", tag_set);
 return canonicalize_tag_set (tag_set);
 }
 }
 return 1;
 }
-DEFUN ("device-matches-specifier-tag-set-p",
+DEFUN ("device-matches-specifier-tag-set-p", Fdevice_matches_specifier_tag_set_p, 2, 2, 0, /*
-Fdevice_matches_specifier_tag_set_p,
-Sdevice_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)
+(device, tag_set))
-Lisp_Object device, tag_set;
 {
 CHECK_LIVE_DEVICE (device);
 if (NILP (Fvalid_specifier_tag_set_p (tag_set)))
 signal_simple_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, Sdefine_specifier_tag,
+DEFUN ("define-specifier-tag", Fdefine_specifier_tag, 1, 2, 0, /*
-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
 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.
-*/ )
+*/
-(tag, predicate)
+(tag, predicate))
-Lisp_Object tag, predicate;
 {
 Lisp_Object assoc, devcons, concons;
 int recompute = 0;
 CHECK_SYMBOL (tag);
 else
 	XCDR (XCAR (rest2)) = !NILP (call1 (predicate, device)) ? Qt : Qnil;
 }
 }
-DEFUN ("device-matching-specifier-tag-list",
+DEFUN ("device-matching-specifier-tag-list", Fdevice_matching_specifier_tag_list, 0, 1, 0, /*
-Fdevice_matching_specifier_tag_list,
-Sdevice_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)
+(device))
-Lisp_Object device;
 {
 struct device *d = decode_device (device);
 Lisp_Object rest, list = Qnil;
 struct gcpro gcpro1;
 list = Fcons (DEVICE_TYPE (d), list);
 RETURN_UNGCPRO (list);
 }
-DEFUN ("specifier-tag-list", Fspecifier_tag_list, Sspecifier_tag_list,
+DEFUN ("specifier-tag-list", Fspecifier_tag_list, 0, 0, 0, /*
-0, 0, 0 /*
 Return a list of all currently-defined specifier tags.
 This includes the built-in ones (the device types and classes).
-*/ )
+*/
-()
+())
 {
 Lisp_Object list = Qnil, rest;
 struct gcpro gcpro1;
 GCPRO1 (list);
 list = nconc2 (Fcopy_sequence (Vconsole_type_list), list);
 RETURN_UNGCPRO (list);
 }
-DEFUN ("specifier-tag-predicate", Fspecifier_tag_predicate,
+DEFUN ("specifier-tag-predicate", Fspecifier_tag_predicate, 1, 1, 0, /*
-Sspecifier_tag_predicate,
-1, 1, 0 /*
 Return the predicate for the given specifier tag.
-*/ )
+*/
-(tag)
+(tag))
-Lisp_Object tag;
 {
 /* The return value of this function must be GCPRO'd. */
 CHECK_SYMBOL (tag);
 if (NILP (Fvalid_specifier_tag_p (tag)))
 return retval;
 }
 return Qt;
 }
-DEFUN ("check-valid-instantiator", Fcheck_valid_instantiator,
+DEFUN ("check-valid-instantiator", Fcheck_valid_instantiator, 2, 2, 0, /*
-Scheck_valid_instantiator,
-2, 2, 0 /*
 Signal an error if INSTANTIATOR is invalid for SPECIFIER-TYPE.
-*/ )
+*/
-(instantiator, specifier_type)
+(instantiator, specifier_type))
-Lisp_Object instantiator, specifier_type;
 {
 struct specifier_methods *meths = decode_specifier_type (specifier_type,
 							   ERROR_ME);
 return check_valid_instantiator (instantiator, meths, ERROR_ME);
 }
-DEFUN ("valid-instantiator-p", Fvalid_instantiator_p, Svalid_instantiator_p,
+DEFUN ("valid-instantiator-p", Fvalid_instantiator_p, 2, 2, 0, /*
-2, 2, 0 /*
 Return non-nil if INSTANTIATOR is valid for SPECIFIER-TYPE.
-*/ )
+*/
-(instantiator, specifier_type)
+(instantiator, specifier_type))
-Lisp_Object instantiator, specifier_type;
 {
 struct specifier_methods *meths = decode_specifier_type (specifier_type,
 							   ERROR_ME);
 return check_valid_instantiator (instantiator, meths, ERROR_ME_NOT);
 }
 return Qt;
 }
-DEFUN ("check-valid-inst-list", Fcheck_valid_inst_list, Scheck_valid_inst_list,
+DEFUN ("check-valid-inst-list", Fcheck_valid_inst_list, 2, 2, 0, /*
-2, 2, 0 /*
 Signal an error if INST-LIST is invalid for specifier type TYPE.
-*/ )
+*/
-(inst_list, type)
+(inst_list, type))
-Lisp_Object inst_list, type;
 {
 struct specifier_methods *meths = decode_specifier_type (type, ERROR_ME);
 return check_valid_inst_list (inst_list, meths, ERROR_ME);
 }
-DEFUN ("valid-inst-list-p", Fvalid_inst_list_p, Svalid_inst_list_p,
+DEFUN ("valid-inst-list-p", Fvalid_inst_list_p, 2, 2, 0, /*
-2, 2, 0 /*
 Return non-nil if INST-LIST is valid for specifier type TYPE.
-*/ )
+*/
-(inst_list, type)
+(inst_list, type))
-Lisp_Object inst_list, type;
 {
 struct specifier_methods *meths = decode_specifier_type (type, ERROR_ME);
 return check_valid_inst_list (inst_list, meths, ERROR_ME_NOT);
 }
 }
 return Qt;
 }
-DEFUN ("check-valid-spec-list", Fcheck_valid_spec_list, Scheck_valid_spec_list,
+DEFUN ("check-valid-spec-list", Fcheck_valid_spec_list, 2, 2, 0, /*
-2, 2, 0 /*
 Signal an error if SPEC-LIST is invalid for specifier type TYPE.
-*/ )
+*/
-(spec_list, type)
+(spec_list, type))
-Lisp_Object spec_list, type;
 {
 struct specifier_methods *meths = decode_specifier_type (type, ERROR_ME);
 return check_valid_spec_list (spec_list, meths, ERROR_ME);
 }
-DEFUN ("valid-spec-list-p", Fvalid_spec_list_p, Svalid_spec_list_p,
+DEFUN ("valid-spec-list-p", Fvalid_spec_list_p, 2, 2, 0, /*
-2, 2, 0 /*
 Return non-nil if SPEC-LIST is valid for specifier type TYPE.
-*/ )
+*/
-(spec_list, type)
+(spec_list, type))
-Lisp_Object spec_list, type;
 {
 struct specifier_methods *meths = decode_specifier_type (type, ERROR_ME);
 return check_valid_spec_list (spec_list, meths, ERROR_ME_NOT);
 }
 UNGCPRO;
 return retval;
 }
-DEFUN ("add-spec-to-specifier", Fadd_spec_to_specifier, Sadd_spec_to_specifier,
+DEFUN ("add-spec-to-specifier", Fadd_spec_to_specifier, 2, 5, 0, /*
-2, 5, 0 /*
 Add a specification to SPECIFIER.
 The specification maps from LOCALE (which should be a buffer, window,
 frame, device, or 'global, and defaults to 'global) to INSTANTIATOR,
 whose allowed values depend on the type of the specifier.  Optional
 argument TAG-SET limits the instantiator to apply only to the specified
 'remove-all		Remove all specifications from the specifier
 			before adding the new spec.
 You can retrieve the specifications for a particular locale or locale type
 with the function `specifier-spec-list' or `specifier-specs'.
-*/ )
+*/
-(specifier, instantiator, locale, tag_set, how_to_add)
+(specifier, instantiator, locale, tag_set, how_to_add))
-Lisp_Object specifier, instantiator, locale, tag_set, how_to_add;
 {
 enum spec_add_meth add_meth;
 Lisp_Object inst_list;
 struct gcpro gcpro1;
 specifier_add_spec (specifier, locale, inst_list, add_meth);
 recompute_cached_specifier_everywhere (specifier);
 RETURN_UNGCPRO (Qnil);
 }
-DEFUN ("add-spec-list-to-specifier", Fadd_spec_list_to_specifier,
+DEFUN ("add-spec-list-to-specifier", Fadd_spec_list_to_specifier, 2, 3, 0, /*
-Sadd_spec_list_to_specifier, 2, 3, 0 /*
 Add a spec-list (a list of specifications) to SPECIFIER.
 The format of a spec-list is
 ((LOCALE (TAG-SET . INSTANTIATOR) ...) ...)
 the existing ones, and has the same semantics as for
 `add-spec-to-specifier'.
 In many circumstances, the higher-level function `set-specifier' is
 more convenient and should be used instead.
-*/ )
+*/
-(specifier, spec_list, how_to_add)
+(specifier, spec_list, how_to_add))
-Lisp_Object specifier, spec_list, how_to_add;
 {
 enum spec_add_meth add_meth;
 Lisp_Object rest;
 CHECK_SPECIFIER (specifier);
 the actual objects.  This may cause a slight loss of potential
 functionality but if we were to allow it then a user could manage to
 violate our assertion that the specs contained in the actual
 specifier lists are all valid. */
-DEFUN ("specifier-spec-list", Fspecifier_spec_list, Sspecifier_spec_list,
+DEFUN ("specifier-spec-list", Fspecifier_spec_list, 1, 4, 0, /*
-1, 4, 0 /*
 Return the spec-list of specifications for SPECIFIER in LOCALE.
 If LOCALE is a particular locale (a buffer, window, frame, device,
 or 'global), a spec-list consisting of the specification for that
 locale will be returned.
 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
 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)
+(specifier, locale, tag_set, exact_p))
-Lisp_Object specifier, locale, tag_set, exact_p;
 {
 struct specifier_spec_list_closure cl;
 struct gcpro gcpro1, gcpro2;
 CHECK_SPECIFIER (specifier);
 UNGCPRO;
 return cl.head;
 }
-DEFUN ("specifier-specs", Fspecifier_specs, Sspecifier_specs,
+DEFUN ("specifier-specs", Fspecifier_specs, 1, 4, 0, /*
-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
 will be returned.  Otherwise, this function is identical to
 instead of the inst-pair.
 3. If there is only one instantiator, its value is nil, and its tag is
 'any, a one-element list containing nil will be returned rather
 than just nil, to distinguish this case from there being no
 instantiators at all.
-*/ )
+*/
-(specifier, locale, tag_set, exact_p)
+(specifier, locale, tag_set, exact_p))
-Lisp_Object specifier, locale, tag_set, exact_p;
 {
 if (!NILP (Fvalid_specifier_locale_p (locale)) ||
 (CONSP (locale) && !NILP (Fvalid_specifier_locale_p (XCAR (locale))) &&
 NILP (XCDR (locale))))
 {
 else
 specifier_remove_spec (specifier, locale, locale_type, tag_set, exact_p);
 return 0;
 }
-DEFUN ("remove-specifier", Fremove_specifier,
+DEFUN ("remove-specifier", Fremove_specifier, 1, 4, 0, /*
-Sremove_specifier, 1, 4, 0 /*
 Remove specification(s) for SPECIFIER.
 If LOCALE is a particular locale (a buffer, window, frame, device,
 or 'global), the specification for that locale will be removed.
 subset of (or possibly equal to) the instantiator's tag set are removed.
 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 removed.
-*/ )
+*/
-(specifier, locale, tag_set, exact_p)
+(specifier, locale, tag_set, exact_p))
-Lisp_Object specifier, locale, tag_set, exact_p;
 {
 CHECK_SPECIFIER (specifier);
 map_specifier (specifier, locale, remove_specifier_mapfun, tag_set,
 		 exact_p, 0);
 recompute_cached_specifier_everywhere (specifier);
 			 cl->add_meth_is_nil ? SPEC_REMOVE_LOCALE :
 			 cl->add_meth);
 return 0;
 }
-DEFUN ("copy-specifier", Fcopy_specifier, Scopy_specifier,
+DEFUN ("copy-specifier", Fcopy_specifier, 1, 6, 0, /*
-1, 6, 0 /*
 Copy SPECIFIER to DEST, or create a new one if DEST is nil.
 If DEST is nil or omitted, a new specifier will be created and the
 specifications copied into it.  Otherwise, the specifications will be
 copied into the existing specifier in DEST.
 Optional argument HOW-TO-ADD specifies what to do with existing
 specifications in DEST.  If nil, then whichever locales or locale types
 are copied will first be completely erased in DEST.  Otherwise, it is
 the same as in `add-spec-to-specifier'.
-*/ )
+*/
-(specifier, dest, locale, tag_set, exact_p, how_to_add)
+(specifier, dest, locale, tag_set, exact_p, how_to_add))
-Lisp_Object specifier, dest, locale, tag_set, exact_p, how_to_add;
 {
 struct gcpro gcpro1;
 struct copy_specifier_closure cl;
 CHECK_SPECIFIER (specifier);
 	 intern (meths->name), Qspecifier, errb);
 return Qnil;
 }
 }
-DEFUN ("check-valid-specifier-matchspec", Fcheck_valid_specifier_matchspec,
+DEFUN ("check-valid-specifier-matchspec", Fcheck_valid_specifier_matchspec, 2, 2, 0, /*
-Scheck_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)
+(matchspec, specifier_type))
-Lisp_Object matchspec, specifier_type;
 {
 struct specifier_methods *meths = decode_specifier_type (specifier_type,
 							   ERROR_ME);
 return check_valid_specifier_matchspec (matchspec, meths, ERROR_ME);
 }
-DEFUN ("valid-specifier-matchspec-p", Fvalid_specifier_matchspec_p,
+DEFUN ("valid-specifier-matchspec-p", Fvalid_specifier_matchspec_p, 2, 2, 0, /*
-Svalid_specifier_matchspec_p,
-2, 2, 0 /*
 Return non-nil if MATCHSPEC is valid for SPECIFIER-TYPE.
 See `specifier-matching-instance' for a description of matchspecs.
-*/ )
+*/
-(matchspec, specifier_type)
+(matchspec, specifier_type))
-Lisp_Object matchspec, specifier_type;
 {
 struct specifier_methods *meths = decode_specifier_type (specifier_type,
 							   ERROR_ME);
 return check_valid_specifier_matchspec (matchspec, meths, ERROR_ME_NOT);
 /* call the after-change method */
 MAYBE_SPECMETH (sp, after_change, (specifier, Qfallback));
 recompute_cached_specifier_everywhere (specifier);
 }
-DEFUN ("specifier-fallback", Fspecifier_fallback, Sspecifier_fallback,
+DEFUN ("specifier-fallback", Fspecifier_fallback, 1, 1, 0, /*
-1, 1, 0 /*
 Return the fallback value for SPECIFIER.
 Fallback values are provided by the C code for certain built-in
 specifiers to make sure that instancing won't fail even if all
 specs are removed from the specifier, or to implement simple
 inheritance behavior (e.g. this method is used to ensure that
 \(results in inheritance), or nil for no fallback.
 When you instance a specifier, you can explicitly request that the
 fallback not be consulted. (The C code does this, for example, when
 merging faces.) See `specifier-instance'.
-*/ )
+*/
-(specifier)
+(specifier))
-Lisp_Object specifier;
 {
 CHECK_SPECIFIER (specifier);
 return Fcopy_tree (XSPECIFIER (specifier)->fallback, Qt);
 }
 {
 return specifier_instance (specifier, matchspec, domain, errb,
 			     1, no_fallback, depth);
 }
-DEFUN ("specifier-instance", Fspecifier_instance, Sspecifier_instance,
+DEFUN ("specifier-instance", Fspecifier_instance, 1, 4, 0, /*
-1, 4, 0 /*
 Instantiate SPECIFIER (return its value) in DOMAIN.
 If no instance can be generated for this domain, return DEFAULT.
 DOMAIN should be a window, frame, or device.  Other values that are legal
 as a locale (e.g. a buffer) are not valid as a domain because they do not
 for a font specifier (as returned by the `face-font' function), the returned
 value will be a font-instance object.  For glyphs, the returned value
 will be a string, pixmap, or subwindow.
 See also `specifier-matching-instance'.
-*/ )
+*/
-(specifier, domain, defalt, no_fallback)
+(specifier, domain, defalt, no_fallback))
-Lisp_Object specifier, domain, defalt, no_fallback;
 {
 Lisp_Object instance;
 CHECK_SPECIFIER (specifier);
 domain = decode_domain (domain);
 if (UNBOUNDP (instance))
 return defalt;
 return instance;
 }
-DEFUN ("specifier-matching-instance", Fspecifier_matching_instance,
+DEFUN ("specifier-matching-instance", Fspecifier_matching_instance, 2, 5, 0, /*
-Sspecifier_matching_instance, 2, 5, 0 /*
 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.
 -- For font specifiers, MATCHSPEC should be a charset, and the specification
 (a font string) must have a registry that matches the charset's registry.
 (This only makes sense with Mule support.) This makes it easy to choose a
 font that can display a particular character. (This is what redisplay
 does, in fact.)
-*/ )
+*/
-(specifier, matchspec, domain, defalt, no_fallback)
+(specifier, matchspec, domain, defalt, no_fallback))
-Lisp_Object specifier, matchspec, domain, defalt, no_fallback;
 {
 Lisp_Object instance;
 CHECK_SPECIFIER (specifier);
 check_valid_specifier_matchspec (matchspec, XSPECIFIER (specifier)->methods,
 if (UNBOUNDP (instance))
 return defalt;
 return instance;
 }
-DEFUN ("specifier-instance-from-inst-list", Fspecifier_instance_from_inst_list,
+DEFUN ("specifier-instance-from-inst-list",
-Sspecifier_instance_from_inst_list, 3, 4, 0 /*
+Fspecifier_instance_from_inst_list, 3, 4, 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.  If
 the instantiation fails, DEFAULT is returned.  In most circumstances,
 you should not use this function; use `specifier-instance' instead.
-*/ )
+*/
-(specifier, domain, inst_list, defalt)
+(specifier, domain, inst_list, defalt))
-Lisp_Object specifier, domain, inst_list, defalt;
 {
 Lisp_Object val = Qunbound;
 struct Lisp_Specifier *sp = XSPECIFIER (specifier);
 struct gcpro gcpro1;
 Lisp_Object built_up_list = Qnil;
 return defalt;
 return val;
 }
 DEFUN ("specifier-matching-instance-from-inst-list",
-Fspecifier_matching_instance_from_inst_list,
+Fspecifier_matching_instance_from_inst_list, 4, 5, 0, /*
-Sspecifier_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.
 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
 works.
-*/ )
+*/
-(specifier, matchspec, domain, inst_list, defalt)
+(specifier, matchspec, domain, inst_list, defalt))
-Lisp_Object specifier, matchspec, domain, inst_list, defalt;
 {
 Lisp_Object val = Qunbound;
 struct Lisp_Specifier *sp = XSPECIFIER (specifier);
 struct gcpro gcpro1;
 Lisp_Object built_up_list = Qnil;
 	recompute_one_cached_specifier_in_frame (specifier,
 						 XFRAME (XCAR (frmcons)));
 }
 }
-DEFUN ("set-specifier-dirty-flag", Fset_specifier_dirty_flag,
+DEFUN ("set-specifier-dirty-flag", Fset_specifier_dirty_flag, 1, 1, 0, /*
-Sset_specifier_dirty_flag, 1, 1, 0 /*
 Force recomputation of any caches associated with SPECIFIER.
 Note that this automatically happens whenever you change a specification
 in SPECIFIER; you do not have to call this function then.
 One example of where this function is useful is when you have a
 toolbar button whose `active-p' field is an expression to be
 evaluated.  Calling `set-specifier-dirty-flag' on the
 toolbar specifier will force the `active-p' fields to be
 recomputed.
-*/ )
+*/
-(specifier)
+(specifier))
-Lisp_Object specifier;
 {
 CHECK_SPECIFIER (specifier);
 recompute_cached_specifier_everywhere (specifier);
 return Qnil;
 }
 "instantiator is valid).  It can also return nil to indicate an invalid\n"
 "instantiator; in this case, a general error will be signalled."
 #endif /* 0 */
-DEFUN ("generic-specifier-p", Fgeneric_specifier_p,
+DEFUN ("generic-specifier-p", Fgeneric_specifier_p, 1, 1, 0, /*
-Sgeneric_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,
 and returns back the Lisp object unchanged when it is instantiated.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return (GENERIC_SPECIFIERP (object) ? Qt : Qnil);
 }
 integer_validate (Lisp_Object instantiator)
 {
 CHECK_INT (instantiator);
 }
-DEFUN ("integer-specifier-p", Finteger_specifier_p,
+DEFUN ("integer-specifier-p", Finteger_specifier_p, 1, 1, 0, /*
-Sinteger_specifier_p, 1, 1, 0 /*
 Return non-nil if OBJECT is an integer specifier.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return (INTEGER_SPECIFIERP (object) ? Qt : Qnil);
 }
 /************************************************************************/
 natnum_validate (Lisp_Object instantiator)
 {
 CHECK_NATNUM (instantiator);
 }
-DEFUN ("natnum-specifier-p", Fnatnum_specifier_p,
+DEFUN ("natnum-specifier-p", Fnatnum_specifier_p, 1, 1, 0, /*
-Snatnum_specifier_p, 1, 1, 0 /*
 Return non-nil if OBJECT is a natnum (non-negative-integer) specifier.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return (NATNUM_SPECIFIERP (object) ? Qt : Qnil);
 }
 /************************************************************************/
 {
 if (!EQ (instantiator, Qt) && !EQ (instantiator, Qnil))
 signal_simple_error ("Must be t or nil", instantiator);
 }
-DEFUN ("boolean-specifier-p", Fboolean_specifier_p,
+DEFUN ("boolean-specifier-p", Fboolean_specifier_p, 1, 1, 0, /*
-Sboolean_specifier_p, 1, 1, 0 /*
 Return non-nil if OBJECT is an boolean specifier.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return (BOOLEAN_SPECIFIERP (object) ? Qt : Qnil);
 }
 defsymbol (&Qdevice_class, "device-class");
 /* Qinteger, Qboolean, Qgeneric defined in general.c */
 defsymbol (&Qnatnum, "natnum");
-defsubr (&Svalid_specifier_type_p);
+DEFSUBR (Fvalid_specifier_type_p);
-defsubr (&Sspecifier_type_list);
+DEFSUBR (Fspecifier_type_list);
-defsubr (&Smake_specifier);
+DEFSUBR (Fmake_specifier);
-defsubr (&Sspecifierp);
+DEFSUBR (Fspecifierp);
-defsubr (&Sspecifier_type);
+DEFSUBR (Fspecifier_type);
-defsubr (&Svalid_specifier_locale_p);
+DEFSUBR (Fvalid_specifier_locale_p);
-defsubr (&Svalid_specifier_domain_p);
+DEFSUBR (Fvalid_specifier_domain_p);
-defsubr (&Svalid_specifier_locale_type_p);
+DEFSUBR (Fvalid_specifier_locale_type_p);
-defsubr (&Sspecifier_locale_type_from_locale);
+DEFSUBR (Fspecifier_locale_type_from_locale);
-defsubr (&Svalid_specifier_tag_p);
+DEFSUBR (Fvalid_specifier_tag_p);
-defsubr (&Svalid_specifier_tag_set_p);
+DEFSUBR (Fvalid_specifier_tag_set_p);
-defsubr (&Scanonicalize_tag_set);
+DEFSUBR (Fcanonicalize_tag_set);
-defsubr (&Sdevice_matches_specifier_tag_set_p);
+DEFSUBR (Fdevice_matches_specifier_tag_set_p);
-defsubr (&Sdefine_specifier_tag);
+DEFSUBR (Fdefine_specifier_tag);
-defsubr (&Sdevice_matching_specifier_tag_list);
+DEFSUBR (Fdevice_matching_specifier_tag_list);
-defsubr (&Sspecifier_tag_list);
+DEFSUBR (Fspecifier_tag_list);
-defsubr (&Sspecifier_tag_predicate);
+DEFSUBR (Fspecifier_tag_predicate);
-defsubr (&Scheck_valid_instantiator);
+DEFSUBR (Fcheck_valid_instantiator);
-defsubr (&Svalid_instantiator_p);
+DEFSUBR (Fvalid_instantiator_p);
-defsubr (&Scheck_valid_inst_list);
+DEFSUBR (Fcheck_valid_inst_list);
-defsubr (&Svalid_inst_list_p);
+DEFSUBR (Fvalid_inst_list_p);
-defsubr (&Scheck_valid_spec_list);
+DEFSUBR (Fcheck_valid_spec_list);
-defsubr (&Svalid_spec_list_p);
+DEFSUBR (Fvalid_spec_list_p);
-defsubr (&Sadd_spec_to_specifier);
+DEFSUBR (Fadd_spec_to_specifier);
-defsubr (&Sadd_spec_list_to_specifier);
+DEFSUBR (Fadd_spec_list_to_specifier);
-defsubr (&Sspecifier_spec_list);
+DEFSUBR (Fspecifier_spec_list);
-defsubr (&Sspecifier_specs);
+DEFSUBR (Fspecifier_specs);
-defsubr (&Sremove_specifier);
+DEFSUBR (Fremove_specifier);
-defsubr (&Scopy_specifier);
+DEFSUBR (Fcopy_specifier);
-defsubr (&Scheck_valid_specifier_matchspec);
+DEFSUBR (Fcheck_valid_specifier_matchspec);
-defsubr (&Svalid_specifier_matchspec_p);
+DEFSUBR (Fvalid_specifier_matchspec_p);
-defsubr (&Sspecifier_fallback);
+DEFSUBR (Fspecifier_fallback);
-defsubr (&Sspecifier_instance);
+DEFSUBR (Fspecifier_instance);
-defsubr (&Sspecifier_matching_instance);
+DEFSUBR (Fspecifier_matching_instance);
-defsubr (&Sspecifier_instance_from_inst_list);
+DEFSUBR (Fspecifier_instance_from_inst_list);
-defsubr (&Sspecifier_matching_instance_from_inst_list);
+DEFSUBR (Fspecifier_matching_instance_from_inst_list);
-defsubr (&Sset_specifier_dirty_flag);
+DEFSUBR (Fset_specifier_dirty_flag);
-defsubr (&Sgeneric_specifier_p);
+DEFSUBR (Fgeneric_specifier_p);
-defsubr (&Sinteger_specifier_p);
+DEFSUBR (Finteger_specifier_p);
-defsubr (&Snatnum_specifier_p);
+DEFSUBR (Fnatnum_specifier_p);
-defsubr (&Sboolean_specifier_p);
+DEFSUBR (Fboolean_specifier_p);
 /* Symbols pertaining to specifier creation.  Specifiers are created
 in the syms_of() functions. */
 /* locales are defined in general.c. */

Mercurial > hg > xemacs-beta

comparison src/specifier.c @ 20:859a2309aef8 r19-15b93