xsddoc/samples/ruleml/modules desc_module.xsd,1.1,1.2 equality_module.xsd,1.1,1.2 boole_module.xsd,1.1,1.2 toplevel_module.xsd,1.1,1.2 cterm_module.xsd,1.1,1.2 clause_module.xsd,1.1,1.2 role_module.xsd,1.1,1.2 atom_module.xsd,1.1,1.2 negation_module.xsd,1.1,1.2 term_module.xsd,1.2,1.3 ur_module.xsd,1.1,1.2
Kurt Riede <[email protected]> Thu, 30 Sep 2004 11:26:34 +0000
| Newsgroups | gmane.text.xml.xframe.xsddoc.devel |
|---|---|
| Message-ID | <[email protected]> |
Update of /cvsroot/xframe/xsddoc/samples/ruleml/modules
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv32681/samples/ruleml/modules
Modified Files:
desc_module.xsd equality_module.xsd boole_module.xsd
toplevel_module.xsd cterm_module.xsd clause_module.xsd
role_module.xsd atom_module.xsd negation_module.xsd
term_module.xsd ur_module.xsd
Log Message:
changed to ASCII
Index: clause_module.xsd
===================================================================
RCS file: /cvsroot/xframe/xsddoc/samples/ruleml/modules/clause_module.xsd,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** clause_module.xsd 30 Aug 2004 07:05:48 -0000 1.1
--- clause_module.xsd 30 Sep 2004 11:26:31 -0000 1.2
***************
*** 1,72 ****
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Clause RuleML elements module.
! This is the XML Schema clause elements module for RuleML.
! File: clause_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following clause RuleML elements:
! * _head
! * _body
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** _head ***
! content model: (atom)
!
! The head of a rule, also known as the "consequent" or "then" part of the rule.
!
! The '_head' role is usable within facts and implication rules. '_head' uses
! an atomic (or, in equalog, equational) formula.
! -->
! <xs:attributeGroup name="_head.attlist"/>
! <xs:group name="_head.content">
! <xs:choice>
! <xs:element ref="atom"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="_head.type">
! <xs:group ref="_head.content"/>
! <xs:attributeGroup ref="_head.attlist"/>
! </xs:complexType>
! <xs:element name="_head" type="_head.type"/>
!
! <!--
! *** _body ***
! content model: (atom | and | or)
!
! The body of a rule, also known as the "antecedent" or "if" part of the rule.
!
! The '_body' role is usable within query tests and implication rules. '_body'
! uses an atomic (or, in equalog, equational) formula, an 'and' or an 'or'.
! -->
! <xs:attributeGroup name="_body.attlist"/>
! <xs:group name="_body.content">
! <xs:choice>
! <xs:element ref="atom"/>
! <xs:element ref="and"/>
! <xs:element ref="or"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="_body.type">
! <xs:group ref="_body.content"/>
! <xs:attributeGroup ref="_body.attlist"/>
! </xs:complexType>
! <xs:element name="_body" type="_body.type"/>
!
</xs:schema>
\ No newline at end of file
--- 1,72 ----
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Clause RuleML elements module.
! This is the XML Schema clause elements module for RuleML.
! File: clause_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following clause RuleML elements:
! * _head
! * _body
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** _head ***
! content model: (atom)
!
! The head of a rule, also known as the "consequent" or "then" part of the rule.
!
! The '_head' role is usable within facts and implication rules. '_head' uses
! an atomic (or, in equalog, equational) formula.
! -->
! <xs:attributeGroup name="_head.attlist"/>
! <xs:group name="_head.content">
! <xs:choice>
! <xs:element ref="atom"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="_head.type">
! <xs:group ref="_head.content"/>
! <xs:attributeGroup ref="_head.attlist"/>
! </xs:complexType>
! <xs:element name="_head" type="_head.type"/>
!
! <!--
! *** _body ***
! content model: (atom | and | or)
!
! The body of a rule, also known as the "antecedent" or "if" part of the rule.
!
! The '_body' role is usable within query tests and implication rules. '_body'
! uses an atomic (or, in equalog, equational) formula, an 'and' or an 'or'.
! -->
! <xs:attributeGroup name="_body.attlist"/>
! <xs:group name="_body.content">
! <xs:choice>
! <xs:element ref="atom"/>
! <xs:element ref="and"/>
! <xs:element ref="or"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="_body.type">
! <xs:group ref="_body.content"/>
! <xs:attributeGroup ref="_body.attlist"/>
! </xs:complexType>
! <xs:element name="_body" type="_body.type"/>
!
</xs:schema>
\ No newline at end of file
Index: role_module.xsd
===================================================================
RCS file: /cvsroot/xframe/xsddoc/samples/ruleml/modules/role_module.xsd,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** role_module.xsd 30 Aug 2004 07:05:48 -0000 1.1
--- role_module.xsd 30 Sep 2004 11:26:31 -0000 1.2
***************
*** 1,91 ****
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Role RuleML elements module.
! This is the XML Schema role elements module for RuleML.
! File: role_module.xsd
! Version: 0.86
! Last Modification: 2004-06-23
!
! This module declares the following RuleML element:
! * _slot
! * @name
! * @card
! * @weight
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** _slot ***
! content model: ( ind | var )
!
! User-defined non-positional metaroles.
!
! '_slot' uses either an individual constant or a variable (or, in hornlog, a complex term),
! and must have a name given in the 'name' attribute. Optional attributes are 'card',
! specifying the role's cardinality, and 'weight', specifying the role's relative weight.
! -->
! <xs:attributeGroup name="_slot.attlist">
! <xs:attributeGroup ref="name.attrib"/>
! <xs:attributeGroup ref="card.attrib"/>
! <xs:attributeGroup ref="weight.attrib"/>
! </xs:attributeGroup>
! <xs:group name="_slot.content">
! <xs:choice>
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="_slot.type">
! <xs:group ref="_slot.content"/>
! <xs:attributeGroup ref="_slot.attlist"/>
! </xs:complexType>
! <xs:element name="_slot" type="_slot.type"/>
!
! <!--
! *** @name ***
!
! Specifies a user-defined name. It is required for metaroles.
! -->
! <xs:attributeGroup name="name.attrib">
! <xs:attribute name="name" type="xs:string" use="required"/>
! </xs:attributeGroup>
!
! <!--
! *** @card ***
!
! Optionally specifies the metarole's cardinality.
! -->
! <xs:attributeGroup name="card.attrib">
! <xs:attribute name="card" type="xs:nonNegativeInteger" use="optional"/>
! </xs:attributeGroup>
!
! <!--
! *** @card ***
!
! Optionally specifies the metarole's relative weight.
! -->
! <xs:attributeGroup name="weight.attrib">
! <xs:attribute name="weight" use="optional">
! <xs:simpleType>
! <xs:restriction base="xs:decimal">
! <xs:minInclusive value="0"/>
! <xs:maxInclusive value="1"/>
! </xs:restriction>
! </xs:simpleType>
! </xs:attribute>
! </xs:attributeGroup>
!
</xs:schema>
\ No newline at end of file
--- 1,91 ----
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Role RuleML elements module.
! This is the XML Schema role elements module for RuleML.
! File: role_module.xsd
! Version: 0.86
! Last Modification: 2004-06-23
!
! This module declares the following RuleML element:
! * _slot
! * @name
! * @card
! * @weight
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** _slot ***
! content model: ( ind | var )
!
! User-defined non-positional metaroles.
!
! '_slot' uses either an individual constant or a variable (or, in hornlog, a complex term),
! and must have a name given in the 'name' attribute. Optional attributes are 'card',
! specifying the role's cardinality, and 'weight', specifying the role's relative weight.
! -->
! <xs:attributeGroup name="_slot.attlist">
! <xs:attributeGroup ref="name.attrib"/>
! <xs:attributeGroup ref="card.attrib"/>
! <xs:attributeGroup ref="weight.attrib"/>
! </xs:attributeGroup>
! <xs:group name="_slot.content">
! <xs:choice>
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="_slot.type">
! <xs:group ref="_slot.content"/>
! <xs:attributeGroup ref="_slot.attlist"/>
! </xs:complexType>
! <xs:element name="_slot" type="_slot.type"/>
!
! <!--
! *** @name ***
!
! Specifies a user-defined name. It is required for metaroles.
! -->
! <xs:attributeGroup name="name.attrib">
! <xs:attribute name="name" type="xs:string" use="required"/>
! </xs:attributeGroup>
!
! <!--
! *** @card ***
!
! Optionally specifies the metarole's cardinality.
! -->
! <xs:attributeGroup name="card.attrib">
! <xs:attribute name="card" type="xs:nonNegativeInteger" use="optional"/>
! </xs:attributeGroup>
!
! <!--
! *** @card ***
!
! Optionally specifies the metarole's relative weight.
! -->
! <xs:attributeGroup name="weight.attrib">
! <xs:attribute name="weight" use="optional">
! <xs:simpleType>
! <xs:restriction base="xs:decimal">
! <xs:minInclusive value="0"/>
! <xs:maxInclusive value="1"/>
! </xs:restriction>
! </xs:simpleType>
! </xs:attribute>
! </xs:attributeGroup>
!
</xs:schema>
\ No newline at end of file
Index: atom_module.xsd
===================================================================
RCS file: /cvsroot/xframe/xsddoc/samples/ruleml/modules/atom_module.xsd,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** atom_module.xsd 30 Aug 2004 07:05:48 -0000 1.1
--- atom_module.xsd 30 Sep 2004 11:26:31 -0000 1.2
***************
*** 1,141 ****
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Atom RuleML elements module.
! This is the XML Schema atom elements module for RuleML.
! File: atom_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following RuleML elements:
! * atom
! * _opr
! * rel
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** atom ***
! content model:
! ( (_opr, (_slot)*, (ind | var)*, (_slot)*) | ((_slot)*, (ind | var)+, (_slot)*, _opr) )
!
! however, this is non-deterministic, so it is (equivalently) restructured as follows:
!
! (
! ( _opr,
! (_slot)*,
! ( (ind | var)+, (_slot)*)?
! )
! |
! (
! (
! ( (_slot)+,
! ( (ind | var)+, (_slot)* )?
! )
! |
! ((ind | var)+, (_slot)*)
! ),
! _opr
! )
! )
!
! A logical atom, i.e. an expression formed from a predicate applied to a collection of its
! (logical) arguments.
!
! An atomic formula is usable within '_head','_body', or 'and'. Atom elements use an '_opr' role
! followed by a sequence of zero or more arguments, or equivalently, with '_opr' at the end.
! The arguments may be individuals or variables (or, in hornlog, complex terms or plexs).
! Optional user-defined metaroles ('_slot') are also permitted before and/or after the individuals.
! -->
! <xs:group name="atom.extend">
! <xs:sequence>
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! </xs:choice>
! </xs:sequence>
! </xs:group>
! <xs:attributeGroup name="atom.attlist"/>
! <xs:group name="atom.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_opr"/>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! <xs:sequence minOccurs="0">
! <xs:group ref="atom.extend"/>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:sequence>
! <xs:sequence>
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_slot" minOccurs="1" maxOccurs="unbounded"/>
! <xs:sequence minOccurs="0">
! <xs:group ref="atom.extend"/>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:sequence>
! <xs:sequence>
! <xs:group ref="atom.extend"/>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:choice>
! <xs:element ref="_opr"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="atom.type">
! <xs:group ref="atom.content"/>
! <xs:attributeGroup ref="atom.attlist"/>
! </xs:complexType>
! <xs:element name="atom" type="atom.type"/>
!
! <!--
! *** _opr ***
! content model: (rel)
!
! A relational operator expression.
!
! '_opr' is usable within atoms. It uses a rel(ation) symbol.
! -->
! <xs:attributeGroup name="_opr.attlist"/>
! <xs:group name="_opr.content">
! <xs:sequence>
! <xs:element ref="rel"/>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="_opr.type">
! <xs:group ref="_opr.content"/>
! <xs:attributeGroup ref="_opr.attlist"/>
! </xs:complexType>
! <xs:element name="_opr" type="_opr.type"/>
!
! <!--
! *** rel ***
! content model: (#PCDATA)
!
! A relation, i.e. a logical predicate.
! -->
! <xs:attributeGroup name="rel.attlist"/>
! <xs:group name="rel.content">
! <xs:sequence/>
! </xs:group>
! <xs:complexType name="rel.type" mixed="true">
! <xs:group ref="rel.content"/>
! <xs:attributeGroup ref="rel.attlist"/>
! </xs:complexType>
! <xs:element name="rel" type="rel.type"/>
!
</xs:schema>
\ No newline at end of file
--- 1,141 ----
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Atom RuleML elements module.
! This is the XML Schema atom elements module for RuleML.
! File: atom_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following RuleML elements:
! * atom
! * _opr
! * rel
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** atom ***
! content model:
! ( (_opr, (_slot)*, (ind | var)*, (_slot)*) | ((_slot)*, (ind | var)+, (_slot)*, _opr) )
!
! however, this is non-deterministic, so it is (equivalently) restructured as follows:
!
! (
! ( _opr,
! (_slot)*,
! ( (ind | var)+, (_slot)*)?
! )
! |
! (
! (
! ( (_slot)+,
! ( (ind | var)+, (_slot)* )?
! )
! |
! ((ind | var)+, (_slot)*)
! ),
! _opr
! )
! )
!
! A logical atom, i.e. an expression formed from a predicate applied to a collection of its
! (logical) arguments.
!
! An atomic formula is usable within '_head','_body', or 'and'. Atom elements use an '_opr' role
! followed by a sequence of zero or more arguments, or equivalently, with '_opr' at the end.
! The arguments may be individuals or variables (or, in hornlog, complex terms or plexs).
! Optional user-defined metaroles ('_slot') are also permitted before and/or after the individuals.
! -->
! <xs:group name="atom.extend">
! <xs:sequence>
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! </xs:choice>
! </xs:sequence>
! </xs:group>
! <xs:attributeGroup name="atom.attlist"/>
! <xs:group name="atom.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_opr"/>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! <xs:sequence minOccurs="0">
! <xs:group ref="atom.extend"/>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:sequence>
! <xs:sequence>
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_slot" minOccurs="1" maxOccurs="unbounded"/>
! <xs:sequence minOccurs="0">
! <xs:group ref="atom.extend"/>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:sequence>
! <xs:sequence>
! <xs:group ref="atom.extend"/>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:choice>
! <xs:element ref="_opr"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="atom.type">
! <xs:group ref="atom.content"/>
! <xs:attributeGroup ref="atom.attlist"/>
! </xs:complexType>
! <xs:element name="atom" type="atom.type"/>
!
! <!--
! *** _opr ***
! content model: (rel)
!
! A relational operator expression.
!
! '_opr' is usable within atoms. It uses a rel(ation) symbol.
! -->
! <xs:attributeGroup name="_opr.attlist"/>
! <xs:group name="_opr.content">
! <xs:sequence>
! <xs:element ref="rel"/>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="_opr.type">
! <xs:group ref="_opr.content"/>
! <xs:attributeGroup ref="_opr.attlist"/>
! </xs:complexType>
! <xs:element name="_opr" type="_opr.type"/>
!
! <!--
! *** rel ***
! content model: (#PCDATA)
!
! A relation, i.e. a logical predicate.
! -->
! <xs:attributeGroup name="rel.attlist"/>
! <xs:group name="rel.content">
! <xs:sequence/>
! </xs:group>
! <xs:complexType name="rel.type" mixed="true">
! <xs:group ref="rel.content"/>
! <xs:attributeGroup ref="rel.attlist"/>
! </xs:complexType>
! <xs:element name="rel" type="rel.type"/>
!
</xs:schema>
\ No newline at end of file
Index: cterm_module.xsd
===================================================================
RCS file: /cvsroot/xframe/xsddoc/samples/ruleml/modules/cterm_module.xsd,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** cterm_module.xsd 30 Aug 2004 07:05:48 -0000 1.1
--- cterm_module.xsd 30 Sep 2004 11:26:31 -0000 1.2
***************
*** 1,192 ****
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Horn RuleML elements module.
! This is the XML Schema horn module for RuleML.
! File: horn_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following horn RuleML elements:
! * cterm
! * _opc
! * ctor
! * plex
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** cterm ***
! content model:
! (
! ( _opc, (_slot)*, (ind | var | cterm | plex)*, (_slot)* ) |
! ( (_slot)*, (ind | var | cterm | plex)+, (_slot)*, _opc )
! )
!
! however, this is non-deterministic, so it is (equivalently) restructured as follows:
!
! (
! ( _opc,
! (_slot)*,
! ( (ind | var | cterm | plex)+, (_slot)*)?
! )
! |
! (
! (
! ( (_slot)+,
! ( (ind | var | cterm | plex)+, (_slot)* )?
! )
! |
! ((ind | var | cterm | plex)+, (_slot)*)
! ),
! _opc
! )
! )
!
! A complex term, i.e. a logical term of the form "f(...)" where f is a constructor.
!
! Complex, compound, or constructor terms are usable within other cterms, plexs, and atoms.
! The cterm element uses '_opc' ("operator of constructors") role followed by a sequence
! of four kinds of arguments, surrounded by optional metaroles ('_slot'), or vice versa, much
! like atoms.
!
! Complex terms may have an optional 'type' attribute for term typing.
! -->
! <xs:attributeGroup name="cterm.attlist">
! <xs:attributeGroup ref="type.attrib"/>
! </xs:attributeGroup>
! <xs:group name="cterm.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_opc"/>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! <xs:sequence minOccurs="0">
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="plex"/>
! </xs:choice>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:sequence>
! <xs:sequence>
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_slot" minOccurs="1" maxOccurs="unbounded"/>
! <xs:sequence minOccurs="0">
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="plex"/>
! </xs:choice>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:sequence>
! <xs:sequence>
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="plex"/>
! </xs:choice>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:choice>
! <xs:element ref="_opc"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="cterm.type">
! <xs:group ref="cterm.content"/>
! <xs:attributeGroup ref="cterm.attlist"/>
! </xs:complexType>
! <xs:element name="cterm" type="cterm.type"/>
!
! <!--
! *** _opc ***
! content model: (ctor)
!
! A constructor operator expression (similar in spirit to _opr).
!
! '_opc' is usable within complex terms. It uses a c(onstruc)tor.
! -->
! <xs:attributeGroup name="_opc.attlist"/>
! <xs:group name="_opc.content">
! <xs:sequence>
! <xs:element ref="ctor"/>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="_opc.type">
! <xs:group ref="_opc.content"/>
! <xs:attributeGroup ref="_opc.attlist"/>
! </xs:complexType>
! <xs:element name="_opc" type="_opc.type"/>
!
! <!--
! *** ctor ***
! content model: (#PCDATA)
!
! A constructor, i.e. a logical function.
! -->
! <xs:attributeGroup name="ctor.attlist"/>
! <xs:group name="ctor.content">
! <xs:sequence/>
! </xs:group>
! <xs:complexType name="ctor.type" mixed="true">
! <xs:group ref="ctor.content"/>
! <xs:attributeGroup ref="ctor.attlist"/>
! </xs:complexType>
! <xs:element name="ctor" type="ctor.type"/>
!
! <!--
! *** plex ***
! content model: ( (_slot)*, (ind | var | cterm | plex)*, (_slot)* )
!
! however, this is non-deterministic, so it is (equivalently) restructured as follows:
! ( (_slot)*, ( (ind | var | cterm | plex)+, (_slot)* )? )
!
! An unordered collection of arguments.
!
! (com)plex elements are usable within complex terms, atoms and other 'plex' elements.
! (Previous to version 0.85, these were called tup(le)s - the addition of user-defined
! roles meant the term "tup" was no longer appropriate because it implies order.)
!
! The 'plex' element uses a sequence of four kinds of arguments surrounded by optional
! metaroles (_slot).
! -->
! <xs:attributeGroup name="plex.attlist"/>
! <xs:group name="plex.content">
! <xs:sequence>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! <xs:sequence minOccurs="0">
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="plex"/>
! </xs:choice>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="plex.type">
! <xs:group ref="plex.content"/>
! <xs:attributeGroup ref="plex.attlist"/>
! </xs:complexType>
! <xs:element name="plex" type="plex.type"/>
!
</xs:schema>
\ No newline at end of file
--- 1,192 ----
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Horn RuleML elements module.
! This is the XML Schema horn module for RuleML.
! File: horn_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following horn RuleML elements:
! * cterm
! * _opc
! * ctor
! * plex
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** cterm ***
! content model:
! (
! ( _opc, (_slot)*, (ind | var | cterm | plex)*, (_slot)* ) |
! ( (_slot)*, (ind | var | cterm | plex)+, (_slot)*, _opc )
! )
!
! however, this is non-deterministic, so it is (equivalently) restructured as follows:
!
! (
! ( _opc,
! (_slot)*,
! ( (ind | var | cterm | plex)+, (_slot)*)?
! )
! |
! (
! (
! ( (_slot)+,
! ( (ind | var | cterm | plex)+, (_slot)* )?
! )
! |
! ((ind | var | cterm | plex)+, (_slot)*)
! ),
! _opc
! )
! )
!
! A complex term, i.e. a logical term of the form "f(...)" where f is a constructor.
!
! Complex, compound, or constructor terms are usable within other cterms, plexs, and atoms.
! The cterm element uses '_opc' ("operator of constructors") role followed by a sequence
! of four kinds of arguments, surrounded by optional metaroles ('_slot'), or vice versa, much
! like atoms.
!
! Complex terms may have an optional 'type' attribute for term typing.
! -->
! <xs:attributeGroup name="cterm.attlist">
! <xs:attributeGroup ref="type.attrib"/>
! </xs:attributeGroup>
! <xs:group name="cterm.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_opc"/>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! <xs:sequence minOccurs="0">
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="plex"/>
! </xs:choice>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:sequence>
! <xs:sequence>
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_slot" minOccurs="1" maxOccurs="unbounded"/>
! <xs:sequence minOccurs="0">
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="plex"/>
! </xs:choice>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:sequence>
! <xs:sequence>
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="plex"/>
! </xs:choice>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:choice>
! <xs:element ref="_opc"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="cterm.type">
! <xs:group ref="cterm.content"/>
! <xs:attributeGroup ref="cterm.attlist"/>
! </xs:complexType>
! <xs:element name="cterm" type="cterm.type"/>
!
! <!--
! *** _opc ***
! content model: (ctor)
!
! A constructor operator expression (similar in spirit to _opr).
!
! '_opc' is usable within complex terms. It uses a c(onstruc)tor.
! -->
! <xs:attributeGroup name="_opc.attlist"/>
! <xs:group name="_opc.content">
! <xs:sequence>
! <xs:element ref="ctor"/>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="_opc.type">
! <xs:group ref="_opc.content"/>
! <xs:attributeGroup ref="_opc.attlist"/>
! </xs:complexType>
! <xs:element name="_opc" type="_opc.type"/>
!
! <!--
! *** ctor ***
! content model: (#PCDATA)
!
! A constructor, i.e. a logical function.
! -->
! <xs:attributeGroup name="ctor.attlist"/>
! <xs:group name="ctor.content">
! <xs:sequence/>
! </xs:group>
! <xs:complexType name="ctor.type" mixed="true">
! <xs:group ref="ctor.content"/>
! <xs:attributeGroup ref="ctor.attlist"/>
! </xs:complexType>
! <xs:element name="ctor" type="ctor.type"/>
!
! <!--
! *** plex ***
! content model: ( (_slot)*, (ind | var | cterm | plex)*, (_slot)* )
!
! however, this is non-deterministic, so it is (equivalently) restructured as follows:
! ( (_slot)*, ( (ind | var | cterm | plex)+, (_slot)* )? )
!
! An unordered collection of arguments.
!
! (com)plex elements are usable within complex terms, atoms and other 'plex' elements.
! (Previous to version 0.85, these were called tup(le)s - the addition of user-defined
! roles meant the term "tup" was no longer appropriate because it implies order.)
!
! The 'plex' element uses a sequence of four kinds of arguments surrounded by optional
! metaroles (_slot).
! -->
! <xs:attributeGroup name="plex.attlist"/>
! <xs:group name="plex.content">
! <xs:sequence>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! <xs:sequence minOccurs="0">
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="plex"/>
! </xs:choice>
! <xs:element ref="_slot" minOccurs="0" maxOccurs="unbounded"/>
! </xs:sequence>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="plex.type">
! <xs:group ref="plex.content"/>
! <xs:attributeGroup ref="plex.attlist"/>
! </xs:complexType>
! <xs:element name="plex" type="plex.type"/>
!
</xs:schema>
\ No newline at end of file
Index: negation_module.xsd
===================================================================
RCS file: /cvsroot/xframe/xsddoc/samples/ruleml/modules/negation_module.xsd,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** negation_module.xsd 30 Aug 2004 07:05:48 -0000 1.1
--- negation_module.xsd 30 Sep 2004 11:26:31 -0000 1.2
***************
*** 1,71 ****
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Negation RuleML elements module.
! This is the XML Schema negation module for RuleML.
! File: negation_module.xsd
! Version: 0.86
! Last Modification: 2004-06-23
!
! This module declares the following negation RuleML elements:
! * neg
! * naf
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** neg ***
! content model: (atom)
!
! Classical negation.
!
! The 'neg' element negates its atom (explicitly, i.e. classical or "strong" negation).
! It is usable within 'body', 'and' and 'or', as well as 'head' in the negdatalog
! sublanguage.
! -->
! <xs:attributeGroup name="neg.attlist"/>
! <xs:group name="neg.content">
! <xs:sequence>
! <xs:element ref="atom"/>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="neg.type">
! <xs:group ref="neg.content"/>
! <xs:attributeGroup ref="neg.attlist"/>
! </xs:complexType>
! <xs:element name="neg" type="neg.type"/>
!
! <!--
! *** naf ***
! content model: (atom)
!
! Negation as failure.
!
! The 'naf' element negates its atom (by default, i.e. negation as failure).
! It is usable within 'body', 'and' and 'or'.
! -->
! <xs:attributeGroup name="naf.attlist"/>
! <xs:group name="naf.content">
! <xs:choice>
! <xs:element ref="atom"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="naf.type">
! <xs:group ref="naf.content"/>
! <xs:attributeGroup ref="naf.attlist"/>
! </xs:complexType>
! <xs:element name="naf" type="naf.type"/>
!
</xs:schema>
\ No newline at end of file
--- 1,71 ----
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Negation RuleML elements module.
! This is the XML Schema negation module for RuleML.
! File: negation_module.xsd
! Version: 0.86
! Last Modification: 2004-06-23
!
! This module declares the following negation RuleML elements:
! * neg
! * naf
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** neg ***
! content model: (atom)
!
! Classical negation.
!
! The 'neg' element negates its atom (explicitly, i.e. classical or "strong" negation).
! It is usable within 'body', 'and' and 'or', as well as 'head' in the negdatalog
! sublanguage.
! -->
! <xs:attributeGroup name="neg.attlist"/>
! <xs:group name="neg.content">
! <xs:sequence>
! <xs:element ref="atom"/>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="neg.type">
! <xs:group ref="neg.content"/>
! <xs:attributeGroup ref="neg.attlist"/>
! </xs:complexType>
! <xs:element name="neg" type="neg.type"/>
!
! <!--
! *** naf ***
! content model: (atom)
!
! Negation as failure.
!
! The 'naf' element negates its atom (by default, i.e. negation as failure).
! It is usable within 'body', 'and' and 'or'.
! -->
! <xs:attributeGroup name="naf.attlist"/>
! <xs:group name="naf.content">
! <xs:choice>
! <xs:element ref="atom"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="naf.type">
! <xs:group ref="naf.content"/>
! <xs:attributeGroup ref="naf.attlist"/>
! </xs:complexType>
! <xs:element name="naf" type="naf.type"/>
!
</xs:schema>
\ No newline at end of file
Index: term_module.xsd
===================================================================
RCS file: /cvsroot/xframe/xsddoc/samples/ruleml/modules/term_module.xsd,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** term_module.xsd 15 Sep 2004 15:17:23 -0000 1.2
--- term_module.xsd 30 Sep 2004 11:26:31 -0000 1.3
***************
*** 1,82 ****
! <?xml version="1.0"?>
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Data RuleML elements module.
! This is the XML Schema data module for RuleML.
! File: data_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following data RuleML elements/attributes:
! * @type
! * ind
! * var
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** @type ***
!
! Optionally specifies the term's type.
! -->
! <xs:attributeGroup name="type.attrib">
! <xs:attribute name="type" type="xs:anyURI" use="optional"/>
! </xs:attributeGroup>
!
! <!--
! *** ind ***
! content model: (#PCDATA)
!
! An individual constant, as in predicate logic.
!
! The one kind of fixed argument, generalizing RDF literals and resources. It can be
! viewed logically as logical function whose arity is zero.
!
! Individuals may have an optional 'type' attribute for term typing.
! -->
! <xs:attributeGroup name="ind.attlist">
! <xs:attributeGroup ref="type.attrib"/>
! </xs:attributeGroup>
! <xs:group name="ind.content">
! <xs:sequence/>
! </xs:group>
! <xs:complexType name="ind.type" mixed="true">
! <xs:group ref="ind.content"/>
! <xs:attributeGroup ref="ind.attlist"/>
! </xs:complexType>
! <xs:element name="ind" type="ind.type"/>
!
! <!--
! *** var ***
! content model: (#PCDATA)
!
! A logical variable, as in logic programming.
!
! The one kind of variable argument.
!
! Variables may have an optional 'type' attribute for term typing.
! -->
! <xs:attributeGroup name="var.attlist">
! <xs:attributeGroup ref="type.attrib"/>
! </xs:attributeGroup>
! <xs:group name="var.content">
! <xs:sequence/>
! </xs:group>
! <xs:complexType name="var.type" mixed="true">
! <xs:group ref="var.content"/>
! <xs:attributeGroup ref="var.attlist"/>
! </xs:complexType>
! <xs:element name="var" type="var.type"/>
!
</xs:schema>
\ No newline at end of file
--- 1,82 ----
! <?xml version="1.0"?>
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Data RuleML elements module.
! This is the XML Schema data module for RuleML.
! File: data_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following data RuleML elements/attributes:
! * @type
! * ind
! * var
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** @type ***
!
! Optionally specifies the term's type.
! -->
! <xs:attributeGroup name="type.attrib">
! <xs:attribute name="type" type="xs:anyURI" use="optional"/>
! </xs:attributeGroup>
!
! <!--
! *** ind ***
! content model: (#PCDATA)
!
! An individual constant, as in predicate logic.
!
! The one kind of fixed argument, generalizing RDF literals and resources. It can be
! viewed logically as logical function whose arity is zero.
!
! Individuals may have an optional 'type' attribute for term typing.
! -->
! <xs:attributeGroup name="ind.attlist">
! <xs:attributeGroup ref="type.attrib"/>
! </xs:attributeGroup>
! <xs:group name="ind.content">
! <xs:sequence/>
! </xs:group>
! <xs:complexType name="ind.type" mixed="true">
! <xs:group ref="ind.content"/>
! <xs:attributeGroup ref="ind.attlist"/>
! </xs:complexType>
! <xs:element name="ind" type="ind.type"/>
!
! <!--
! *** var ***
! content model: (#PCDATA)
!
! A logical variable, as in logic programming.
!
! The one kind of variable argument.
!
! Variables may have an optional 'type' attribute for term typing.
! -->
! <xs:attributeGroup name="var.attlist">
! <xs:attributeGroup ref="type.attrib"/>
! </xs:attributeGroup>
! <xs:group name="var.content">
! <xs:sequence/>
! </xs:group>
! <xs:complexType name="var.type" mixed="true">
! <xs:group ref="var.content"/>
! <xs:attributeGroup ref="var.attlist"/>
! </xs:complexType>
! <xs:element name="var" type="var.type"/>
!
</xs:schema>
\ No newline at end of file
Index: desc_module.xsd
===================================================================
RCS file: /cvsroot/xframe/xsddoc/samples/ruleml/modules/desc_module.xsd,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** desc_module.xsd 30 Aug 2004 07:05:48 -0000 1.1
--- desc_module.xsd 30 Sep 2004 11:26:31 -0000 1.2
***************
*** 1,77 ****
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Description RuleML elements module.
! This is the XML Schema description elements module for RuleML.
! File: desc_module.xsd
! Version: 0.86
! Last Modification: 2004-06-23
!
! This module declares the following description RuleML elements:
! * _rbaselab
! * _rlab
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** _rbaselab ***
! content model: (ind)
!
! A rulebase label.
!
! Rulebases may have an optional label, '_rbaselab', allowing the naming of an entire
! individual rulebase in a fashion that is accessible within the knowledge representation.
! These labels use individual constants (or, in hornlog, complex terms).
!
! For example, this can help for representing prioritization between rulebases, or perhaps
! to enable forward inferencing of selected rulebase(s).
! -->
! <xs:attributeGroup name="_rbaselab.attlist"/>
! <xs:group name="_rbaselab.content">
! <xs:choice>
! <xs:element ref="ind"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="_rbaselab.type">
! <xs:group ref="_rbaselab.content"/>
! <xs:attributeGroup ref="_rbaselab.attlist"/>
! </xs:complexType>
! <xs:element name="_rbaselab" type="_rbaselab.type"/>
!
! <!--
! *** _rlab ***
! content model: (ind)
!
! A rule label.
!
! A rule (an imp, fact, or query) may have an optional label, '_rlab', creating accessibility
! within the knowledge representation. This can help for representing prioritization between
! rules, for example. These labels use individual constants (or, in hornlog, complex terms).
!
! NOTE: rule labels are not required to be unique within a rulebase.
! -->
! <xs:attributeGroup name="_rlab.attlist"/>
! <xs:group name="_rlab.content">
! <xs:choice>
! <xs:element ref="ind"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="_rlab.type">
! <xs:group ref="_rlab.content"/>
! <xs:attributeGroup ref="_rlab.attlist"/>
! </xs:complexType>
! <xs:element name="_rlab" type="_rlab.type"/>
!
</xs:schema>
\ No newline at end of file
--- 1,77 ----
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Description RuleML elements module.
! This is the XML Schema description elements module for RuleML.
! File: desc_module.xsd
! Version: 0.86
! Last Modification: 2004-06-23
!
! This module declares the following description RuleML elements:
! * _rbaselab
! * _rlab
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** _rbaselab ***
! content model: (ind)
!
! A rulebase label.
!
! Rulebases may have an optional label, '_rbaselab', allowing the naming of an entire
! individual rulebase in a fashion that is accessible within the knowledge representation.
! These labels use individual constants (or, in hornlog, complex terms).
!
! For example, this can help for representing prioritization between rulebases, or perhaps
! to enable forward inferencing of selected rulebase(s).
! -->
! <xs:attributeGroup name="_rbaselab.attlist"/>
! <xs:group name="_rbaselab.content">
! <xs:choice>
! <xs:element ref="ind"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="_rbaselab.type">
! <xs:group ref="_rbaselab.content"/>
! <xs:attributeGroup ref="_rbaselab.attlist"/>
! </xs:complexType>
! <xs:element name="_rbaselab" type="_rbaselab.type"/>
!
! <!--
! *** _rlab ***
! content model: (ind)
!
! A rule label.
!
! A rule (an imp, fact, or query) may have an optional label, '_rlab', creating accessibility
! within the knowledge representation. This can help for representing prioritization between
! rules, for example. These labels use individual constants (or, in hornlog, complex terms).
!
! NOTE: rule labels are not required to be unique within a rulebase.
! -->
! <xs:attributeGroup name="_rlab.attlist"/>
! <xs:group name="_rlab.content">
! <xs:choice>
! <xs:element ref="ind"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="_rlab.type">
! <xs:group ref="_rlab.content"/>
! <xs:attributeGroup ref="_rlab.attlist"/>
! </xs:complexType>
! <xs:element name="_rlab" type="_rlab.type"/>
!
</xs:schema>
\ No newline at end of file
Index: boole_module.xsd
===================================================================
RCS file: /cvsroot/xframe/xsddoc/samples/ruleml/modules/boole_module.xsd,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** boole_module.xsd 30 Aug 2004 07:05:48 -0000 1.1
--- boole_module.xsd 30 Sep 2004 11:26:31 -0000 1.2
***************
*** 1,73 ****
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Boolean RuleML elements module.
! This is the XML Schema boolean elements module for RuleML.
! File: boole_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following boolean RuleML elements:
! * and
! * or
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** and ***
! content model: ( (atom | or)* )
!
! A conjunctive body expression.
!
! An 'and' uses zero or more atomic (or, in equalog, equational) formulas or disjunctions.
! It is usable within '_body'. "<and>atom</and>" is equivalent to "atom", while "<and></and>"
! is equivalent to "true".
! -->
! <xs:attributeGroup name="and.attlist"/>
! <xs:group name="and.content">
! <!-- note the min and maxOccurs constraints on the reference to this content model -->
! <xs:choice>
! <xs:element ref="atom"/>
! <xs:element ref="or"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="and.type">
! <xs:group ref="and.content" minOccurs="0" maxOccurs="unbounded"/>
! <xs:attributeGroup ref="and.attlist"/>
! </xs:complexType>
! <xs:element name="and" type="and.type"/>
!
! <!--
! *** or ***
! content model: ( (atom | and)* )
!
! An 'or' uses zero or more atomic formulas or conjunctions. It is usable within '_body'.
! "<or>atom</or>" is equivalent to "atom".
! -->
! <xs:attributeGroup name="or.attlist"/>
! <xs:group name="or.content">
! <!-- note the min and maxOccurs constraints on the reference to this content model -->
! <xs:choice>
! <xs:element ref="atom"/>
! <xs:element ref="and"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="or.type">
! <xs:group ref="or.content" minOccurs="0" maxOccurs="unbounded"/>
! <xs:attributeGroup ref="or.attlist"/>
! </xs:complexType>
! <xs:element name="or" type="or.type"/>
!
</xs:schema>
\ No newline at end of file
--- 1,73 ----
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Boolean RuleML elements module.
! This is the XML Schema boolean elements module for RuleML.
! File: boole_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following boolean RuleML elements:
! * and
! * or
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** and ***
! content model: ( (atom | or)* )
!
! A conjunctive body expression.
!
! An 'and' uses zero or more atomic (or, in equalog, equational) formulas or disjunctions.
! It is usable within '_body'. "<and>atom</and>" is equivalent to "atom", while "<and></and>"
! is equivalent to "true".
! -->
! <xs:attributeGroup name="and.attlist"/>
! <xs:group name="and.content">
! <!-- note the min and maxOccurs constraints on the reference to this content model -->
! <xs:choice>
! <xs:element ref="atom"/>
! <xs:element ref="or"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="and.type">
! <xs:group ref="and.content" minOccurs="0" maxOccurs="unbounded"/>
! <xs:attributeGroup ref="and.attlist"/>
! </xs:complexType>
! <xs:element name="and" type="and.type"/>
!
! <!--
! *** or ***
! content model: ( (atom | and)* )
!
! An 'or' uses zero or more atomic formulas or conjunctions. It is usable within '_body'.
! "<or>atom</or>" is equivalent to "atom".
! -->
! <xs:attributeGroup name="or.attlist"/>
! <xs:group name="or.content">
! <!-- note the min and maxOccurs constraints on the reference to this content model -->
! <xs:choice>
! <xs:element ref="atom"/>
! <xs:element ref="and"/>
! </xs:choice>
! </xs:group>
! <xs:complexType name="or.type">
! <xs:group ref="or.content" minOccurs="0" maxOccurs="unbounded"/>
! <xs:attributeGroup ref="or.attlist"/>
! </xs:complexType>
! <xs:element name="or" type="or.type"/>
!
</xs:schema>
\ No newline at end of file
Index: toplevel_module.xsd
===================================================================
RCS file: /cvsroot/xframe/xsddoc/samples/ruleml/modules/toplevel_module.xsd,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** toplevel_module.xsd 30 Aug 2004 07:05:48 -0000 1.1
--- toplevel_module.xsd 30 Sep 2004 11:26:31 -0000 1.2
***************
*** 1,232 ****
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Core RuleML elements module.
! This is the XML Schema toplevel elements module for RuleML.
! File: toplevel_module.xsd
! Version: 0.86
! Last Modification: 2004-06-23
!
! This module declares the following toplevel RuleML elements/attributes:
! * rulebase
! * @direction
! * fact
! * imp
! * query
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** rulebase ***
! content model:
! (
! ( (_rbaselab, (fact | query | imp)* ) |
! ( (fact | query | imp)+, _rbaselab?) )?
! )
!
! A knowledge base of rules.
!
! The 'rulebase' root element uses 'fact' assertions, 'query' tests, and 'imp' rules as
! top-level elements. A rulebase may have an optional label, '_rbaselab', and/or a 'direction'
! attribute which indicates the intended direction of imp inferencing.
! -->
! <xs:attributeGroup name="rulebase.attlist">
! <xs:attributeGroup ref="direction.attrib"/>
! </xs:attributeGroup>
! <xs:group name="rulebase.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rbaselab"/>
! <xs:choice minOccurs="0" maxOccurs="unbounded">
! <xs:element ref="fact"/>
! <xs:element ref="query"/>
! <xs:element ref="imp"/>
! </xs:choice>
! </xs:sequence>
! <xs:sequence minOccurs="0">
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="fact"/>
! <xs:element ref="query"/>
! <xs:element ref="imp"/>
! </xs:choice>
! <xs:element ref="_rbaselab" minOccurs="0"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="rulebase.type">
! <xs:group ref="rulebase.content" minOccurs="0"/>
! <xs:attributeGroup ref="rulebase.attlist"/>
! </xs:complexType>
! <xs:element name="rulebase" type="rulebase.type"/>
!
! <!--
! *** @direction ***
!
! The direction attribute indicates the intended direction of implication rule
! inferencing in a rulebase. It has a neutral default value of "bidirectional".
! -->
! <xs:attributeGroup name="direction.attrib">
! <xs:attribute name="direction" use="optional" default="bidirectional">
! <xs:simpleType>
! <xs:restriction base="xs:NMTOKEN">
! <xs:enumeration value="forward"/>
! <xs:enumeration value="backward"/>
! <xs:enumeration value="bidirectional"/>
! </xs:restriction>
! </xs:simpleType>
! </xs:attribute>
! </xs:attributeGroup>
!
! <!--
! *** fact ***
! content model: ( (_rlab, _head) | (_head, _rlab?) )
!
! A fact within the rulebase.
!
! 'fact' assertions are usable as degenerate rules on the top-level, using just
! a conclusion role '_head'. They can be viewed logically as implication rules
! that have empty bodies.
! e.g. "<fact>_head</fact>" stands for "_head is implied by true", i.e., "_head is true".
!
! A fact may also have a label, '_rlab', useful for various purposes within the rulebase.
! -->
! <xs:attributeGroup name="fact.attlist"/>
! <xs:group name="fact.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rlab"/>
! <xs:element ref="_head"/>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_head"/>
! <xs:element ref="_rlab" minOccurs="0"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="fact.type">
! <xs:group ref="fact.content"/>
! <xs:attributeGroup ref="fact.attlist"/>
! </xs:complexType>
! <xs:element name="fact" type="fact.type"/>
!
! <!--
! *** imp ***
! content model: (
! (_rlab, ( (_head, _body) | (_body, _head) )) |
! (_head, ( (_rlab, _body) | (_body, _rlab?) )) |
! (_body, ( (_rlab, _head) | (_head, _rlab?) ))
! )
!
! An implication rule.
!
! 'imp' rules are usable as general implications on the top-level. They use
! a conclusion role '_head' followed by a premise role '_body', or, equivalently
! (since roles constitute unordered elements), a premise role '_body'
! followed by a conclusion role '_head'.
!
! e.g.
! "<imp>_head _body</imp>" stands for "_head is implied by _body",
! i.e., "_head is true is implied by _body is true" or, equivalently,
! "<imp>_body _head</imp>" stands for "_body implies _head",
! i.e., "_body is true implies _head is true".
!
! An imp may also have a label, '_rlab', useful for various purposes within the rulebase.
! -->
! <xs:attributeGroup name="imp.attlist"/>
! <xs:group name="imp.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rlab"/>
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_head"/>
! <xs:element ref="_body"/>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_body"/>
! <xs:element ref="_head"/>
! </xs:sequence>
! </xs:choice>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_head"/>
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rlab"/>
! <xs:element ref="_body"/>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_body"/>
! <xs:element ref="_rlab" minOccurs="0"/>
! </xs:sequence>
! </xs:choice>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_body"/>
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rlab"/>
! <xs:element ref="_head"/>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_head"/>
! <xs:element ref="_rlab" minOccurs="0"/>
! </xs:sequence>
! </xs:choice>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="imp.type">
! <xs:group ref="imp.content"/>
! <xs:attributeGroup ref="imp.attlist"/>
! </xs:complexType>
! <xs:element name="imp" type="imp.type"/>
!
! <!--
! *** query ***
! content model: ( (_rlab, _body) | (_body, _rlab?) )
!
! A query within the rulebase.
!
! 'query' elements are usable as degenerate rules on the rulebase top-level, using
! just a premise role '_body' in the same way that facts use '_head'.
!
! e.g.
! "<query>_body</query>" stands for "false is implied by _body",
! i.e., "_body cannot be proved", which is to be refuted by generating
! the bindings for free variables in _body.
!
! A query may also have a label, '_rlab', useful for various purposes within the rulebase.
! -->
! <xs:attributeGroup name="query.attlist"/>
! <xs:group name="query.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rlab"/>
! <xs:element ref="_body"/>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_body"/>
! <xs:element ref="_rlab" minOccurs="0"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="query.type" mixed="true">
! <xs:group ref="query.content"/>
! <xs:attributeGroup ref="query.attlist"/>
! </xs:complexType>
! <xs:element name="query" type="query.type"/>
!
! </xs:schema>
--- 1,232 ----
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Core RuleML elements module.
! This is the XML Schema toplevel elements module for RuleML.
! File: toplevel_module.xsd
! Version: 0.86
! Last Modification: 2004-06-23
!
! This module declares the following toplevel RuleML elements/attributes:
! * rulebase
! * @direction
! * fact
! * imp
! * query
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** rulebase ***
! content model:
! (
! ( (_rbaselab, (fact | query | imp)* ) |
! ( (fact | query | imp)+, _rbaselab?) )?
! )
!
! A knowledge base of rules.
!
! The 'rulebase' root element uses 'fact' assertions, 'query' tests, and 'imp' rules as
! top-level elements. A rulebase may have an optional label, '_rbaselab', and/or a 'direction'
! attribute which indicates the intended direction of imp inferencing.
! -->
! <xs:attributeGroup name="rulebase.attlist">
! <xs:attributeGroup ref="direction.attrib"/>
! </xs:attributeGroup>
! <xs:group name="rulebase.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rbaselab"/>
! <xs:choice minOccurs="0" maxOccurs="unbounded">
! <xs:element ref="fact"/>
! <xs:element ref="query"/>
! <xs:element ref="imp"/>
! </xs:choice>
! </xs:sequence>
! <xs:sequence minOccurs="0">
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="fact"/>
! <xs:element ref="query"/>
! <xs:element ref="imp"/>
! </xs:choice>
! <xs:element ref="_rbaselab" minOccurs="0"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="rulebase.type">
! <xs:group ref="rulebase.content" minOccurs="0"/>
! <xs:attributeGroup ref="rulebase.attlist"/>
! </xs:complexType>
! <xs:element name="rulebase" type="rulebase.type"/>
!
! <!--
! *** @direction ***
!
! The direction attribute indicates the intended direction of implication rule
! inferencing in a rulebase. It has a neutral default value of "bidirectional".
! -->
! <xs:attributeGroup name="direction.attrib">
! <xs:attribute name="direction" use="optional" default="bidirectional">
! <xs:simpleType>
! <xs:restriction base="xs:NMTOKEN">
! <xs:enumeration value="forward"/>
! <xs:enumeration value="backward"/>
! <xs:enumeration value="bidirectional"/>
! </xs:restriction>
! </xs:simpleType>
! </xs:attribute>
! </xs:attributeGroup>
!
! <!--
! *** fact ***
! content model: ( (_rlab, _head) | (_head, _rlab?) )
!
! A fact within the rulebase.
!
! 'fact' assertions are usable as degenerate rules on the top-level, using just
! a conclusion role '_head'. They can be viewed logically as implication rules
! that have empty bodies.
! e.g. "<fact>_head</fact>" stands for "_head is implied by true", i.e., "_head is true".
!
! A fact may also have a label, '_rlab', useful for various purposes within the rulebase.
! -->
! <xs:attributeGroup name="fact.attlist"/>
! <xs:group name="fact.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rlab"/>
! <xs:element ref="_head"/>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_head"/>
! <xs:element ref="_rlab" minOccurs="0"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="fact.type">
! <xs:group ref="fact.content"/>
! <xs:attributeGroup ref="fact.attlist"/>
! </xs:complexType>
! <xs:element name="fact" type="fact.type"/>
!
! <!--
! *** imp ***
! content model: (
! (_rlab, ( (_head, _body) | (_body, _head) )) |
! (_head, ( (_rlab, _body) | (_body, _rlab?) )) |
! (_body, ( (_rlab, _head) | (_head, _rlab?) ))
! )
!
! An implication rule.
!
! 'imp' rules are usable as general implications on the top-level. They use
! a conclusion role '_head' followed by a premise role '_body', or, equivalently
! (since roles constitute unordered elements), a premise role '_body'
! followed by a conclusion role '_head'.
!
! e.g.
! "<imp>_head _body</imp>" stands for "_head is implied by _body",
! i.e., "_head is true is implied by _body is true" or, equivalently,
! "<imp>_body _head</imp>" stands for "_body implies _head",
! i.e., "_body is true implies _head is true".
!
! An imp may also have a label, '_rlab', useful for various purposes within the rulebase.
! -->
! <xs:attributeGroup name="imp.attlist"/>
! <xs:group name="imp.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rlab"/>
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_head"/>
! <xs:element ref="_body"/>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_body"/>
! <xs:element ref="_head"/>
! </xs:sequence>
! </xs:choice>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_head"/>
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rlab"/>
! <xs:element ref="_body"/>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_body"/>
! <xs:element ref="_rlab" minOccurs="0"/>
! </xs:sequence>
! </xs:choice>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_body"/>
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rlab"/>
! <xs:element ref="_head"/>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_head"/>
! <xs:element ref="_rlab" minOccurs="0"/>
! </xs:sequence>
! </xs:choice>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="imp.type">
! <xs:group ref="imp.content"/>
! <xs:attributeGroup ref="imp.attlist"/>
! </xs:complexType>
! <xs:element name="imp" type="imp.type"/>
!
! <!--
! *** query ***
! content model: ( (_rlab, _body) | (_body, _rlab?) )
!
! A query within the rulebase.
!
! 'query' elements are usable as degenerate rules on the rulebase top-level, using
! just a premise role '_body' in the same way that facts use '_head'.
!
! e.g.
! "<query>_body</query>" stands for "false is implied by _body",
! i.e., "_body cannot be proved", which is to be refuted by generating
! the bindings for free variables in _body.
!
! A query may also have a label, '_rlab', useful for various purposes within the rulebase.
! -->
! <xs:attributeGroup name="query.attlist"/>
! <xs:group name="query.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_rlab"/>
! <xs:element ref="_body"/>
! </xs:sequence>
! <xs:sequence>
! <xs:element ref="_body"/>
! <xs:element ref="_rlab" minOccurs="0"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="query.type" mixed="true">
! <xs:group ref="query.content"/>
! <xs:attributeGroup ref="query.attlist"/>
! </xs:complexType>
! <xs:element name="query" type="query.type"/>
!
! </xs:schema>
Index: ur_module.xsd
===================================================================
RCS file: /cvsroot/xframe/xsddoc/samples/ruleml/modules/ur_module.xsd,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** ur_module.xsd 30 Aug 2004 07:05:48 -0000 1.1
--- ur_module.xsd 30 Sep 2004 11:26:31 -0000 1.2
***************
*** 1,46 ****
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! UR RuleML attribute module.
! This is the XML Schema ur module for RuleML.
! File: ur_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following RuleML attribute:
! * @ur
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** @ur ***
!
! Fixed arguments to relations etc. normally enclose non-empty PCDATA content between
! 'ind' tags, so individuals having empty content can be used like null values in databases.
!
! Fixed arguments to relations etc. can also have the character of objects (resources).
!
! Objects (resources) are inds using a URL/URI as their OID, as in SHOE or RDF (cf. URML).
! Named objects (resources) additionally enclose some non-empty PCDATA content between
! 'ind' tags. Now individuals with empty content are anonymous objects (resources).
!
! Like for XHTML anchors, the URI can be used under an optional 'href' attribute of inds.
! The 'href' attribute may be used in the following tags: ind, rel, fun and ctor.
! -->
! <xs:attributeGroup name="href.attrib">
! <xs:attribute name="href" type="xs:anyURI" use="optional"/>
! </xs:attributeGroup>
!
</xs:schema>
\ No newline at end of file
--- 1,46 ----
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! UR RuleML attribute module.
! This is the XML Schema ur module for RuleML.
! File: ur_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following RuleML attribute:
! * @ur
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** @ur ***
!
! Fixed arguments to relations etc. normally enclose non-empty PCDATA content between
! 'ind' tags, so individuals having empty content can be used like null values in databases.
!
! Fixed arguments to relations etc. can also have the character of objects (resources).
!
! Objects (resources) are inds using a URL/URI as their OID, as in SHOE or RDF (cf. URML).
! Named objects (resources) additionally enclose some non-empty PCDATA content between
! 'ind' tags. Now individuals with empty content are anonymous objects (resources).
!
! Like for XHTML anchors, the URI can be used under an optional 'href' attribute of inds.
! The 'href' attribute may be used in the following tags: ind, rel, fun and ctor.
! -->
! <xs:attributeGroup name="href.attrib">
! <xs:attribute name="href" type="xs:anyURI" use="optional"/>
! </xs:attributeGroup>
!
</xs:schema>
\ No newline at end of file
Index: equality_module.xsd
===================================================================
RCS file: /cvsroot/xframe/xsddoc/samples/ruleml/modules/equality_module.xsd,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** equality_module.xsd 30 Aug 2004 07:05:48 -0000 1.1
--- equality_module.xsd 30 Sep 2004 11:26:31 -0000 1.2
***************
*** 1,133 ****
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Equation RuleML elements module.
! This is the XML Schema equation module for RuleML.
! File: equation_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following equation RuleML elements:
! * eq
! * nano
! * _opf
! * fun
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** eq ***
! content model: ( (ind | var | cterm | nano), (ind | var | cterm | nano) )
!
! An equational formula.
!
! Equational formulas are usable within 'head', 'body', or 'and'. They use two expressions
! consisting of individuals, variables, complex terms or nanos.
! -->
! <xs:attributeGroup name="eq.attlist"/>
! <xs:group name="eq.content">
! <xs:sequence>
! <xs:choice>
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="nano"/>
! </xs:choice>
! <xs:choice>
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="nano"/>
! </xs:choice>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="eq.type">
! <xs:group ref="eq.content"/>
! <xs:attributeGroup ref="eq.attlist"/>
! </xs:complexType>
! <xs:element name="eq" type="eq.type"/>
!
! <!--
! *** nano ***
! content model: ( (_opf, (ind | var | cterm)*) | ((ind | var | cterm)+, _opf) )
!
! Nanos are usable within equational formulas. They use an '_opf' role followed
! by three flat (i.e. non-nano) kinds of arguments, or vice versa, much like
! atoms and cterms.
! -->
! <xs:attributeGroup name="nano.attlist"/>
! <xs:group name="nano.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_opf"/>
! <xs:choice minOccurs="0" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! </xs:choice>
! </xs:sequence>
! <xs:sequence>
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! </xs:choice>
! <xs:element ref="_opf"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="nano.type">
! <xs:group ref="nano.content"/>
! <xs:attributeGroup ref="nano.attlist"/>
! </xs:complexType>
! <xs:element name="nano" type="nano.type"/>
!
! <!--
! *** _opf ***
! content model: (fun)
!
! A function operator expression (similar in spirit to _opr and _opc).
!
! '_opf' is usable within nanos. It uses a fun(ction) symbol.
! -->
! <xs:attributeGroup name="_opf.attlist"/>
! <xs:group name="_opf.content">
! <xs:sequence>
! <xs:element ref="fun"/>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="_opf.type">
! <xs:group ref="_opf.content"/>
! <xs:attributeGroup ref="_opf.attlist"/>
! </xs:complexType>
! <xs:element name="_opf" type="_opf.type"/>
!
! <!--
! *** fun ***
! content model: (#PCDATA)
!
! A user-defined function name.
! -->
! <xs:attributeGroup name="fun.attlist"/>
! <xs:group name="fun.content">
! <xs:sequence/>
! </xs:group>
! <xs:complexType name="fun.type" mixed="true">
! <xs:group ref="fun.content"/>
! <xs:attributeGroup ref="fun.attlist"/>
! </xs:complexType>
! <xs:element name="fun" type="fun.type"/>
!
</xs:schema>
\ No newline at end of file
--- 1,133 ----
! <?xml version="1.0"?>
!
! <xs:schema
! targetNamespace="http://www.ruleml.org/0.86/xsd"
! xmlns="http://www.ruleml.org/0.86/xsd"
! xmlns:xs="http://www.w3.org/2001/XMLSchema"
! >
!
! <xs:annotation>
! <xs:documentation xml:lang="en">
! Equation RuleML elements module.
! This is the XML Schema equation module for RuleML.
! File: equation_module.xsd
! Version: 0.86
! Last Modification: 2004-06-24
!
! This module declares the following equation RuleML elements:
! * eq
! * nano
! * _opf
! * fun
!
! The approach is modelled after that used in "Modularization of XHTML in XML Schema"
! WD [http://www.w3.org/TR/xhtml-m12n-schema/], which will soon be integrated with
! "Modularization of XHTML" (REC-xhtml-modularization-20010410)
! [http://www.w3.org/TR/xhtml-modularization/].
! </xs:documentation>
! </xs:annotation>
!
! <!--
! *** eq ***
! content model: ( (ind | var | cterm | nano), (ind | var | cterm | nano) )
!
! An equational formula.
!
! Equational formulas are usable within 'head', 'body', or 'and'. They use two expressions
! consisting of individuals, variables, complex terms or nanos.
! -->
! <xs:attributeGroup name="eq.attlist"/>
! <xs:group name="eq.content">
! <xs:sequence>
! <xs:choice>
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="nano"/>
! </xs:choice>
! <xs:choice>
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! <xs:element ref="nano"/>
! </xs:choice>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="eq.type">
! <xs:group ref="eq.content"/>
! <xs:attributeGroup ref="eq.attlist"/>
! </xs:complexType>
! <xs:element name="eq" type="eq.type"/>
!
! <!--
! *** nano ***
! content model: ( (_opf, (ind | var | cterm)*) | ((ind | var | cterm)+, _opf) )
!
! Nanos are usable within equational formulas. They use an '_opf' role followed
! by three flat (i.e. non-nano) kinds of arguments, or vice versa, much like
! atoms and cterms.
! -->
! <xs:attributeGroup name="nano.attlist"/>
! <xs:group name="nano.content">
! <xs:choice>
! <xs:sequence>
! <xs:element ref="_opf"/>
! <xs:choice minOccurs="0" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! </xs:choice>
! </xs:sequence>
! <xs:sequence>
! <xs:choice minOccurs="1" maxOccurs="unbounded">
! <xs:element ref="ind"/>
! <xs:element ref="var"/>
! <xs:element ref="cterm"/>
! </xs:choice>
! <xs:element ref="_opf"/>
! </xs:sequence>
! </xs:choice>
! </xs:group>
! <xs:complexType name="nano.type">
! <xs:group ref="nano.content"/>
! <xs:attributeGroup ref="nano.attlist"/>
! </xs:complexType>
! <xs:element name="nano" type="nano.type"/>
!
! <!--
! *** _opf ***
! content model: (fun)
!
! A function operator expression (similar in spirit to _opr and _opc).
!
! '_opf' is usable within nanos. It uses a fun(ction) symbol.
! -->
! <xs:attributeGroup name="_opf.attlist"/>
! <xs:group name="_opf.content">
! <xs:sequence>
! <xs:element ref="fun"/>
! </xs:sequence>
! </xs:group>
! <xs:complexType name="_opf.type">
! <xs:group ref="_opf.content"/>
! <xs:attributeGroup ref="_opf.attlist"/>
! </xs:complexType>
! <xs:element name="_opf" type="_opf.type"/>
!
! <!--
! *** fun ***
! content model: (#PCDATA)
!
! A user-defined function name.
! -->
! <xs:attributeGroup name="fun.attlist"/>
! <xs:group name="fun.content">
! <xs:sequence/>
! </xs:group>
! <xs:complexType name="fun.type" mixed="true">
! <xs:group ref="fun.content"/>
! <xs:attributeGroup ref="fun.attlist"/>
! </xs:complexType>
! <xs:element name="fun" type="fun.type"/>
!
</xs:schema>
\ No newline at end of file
-------------------------------------------------------
This SF.net email is sponsored by: IT Product Guide on ITManagersJournal
Use IT products in your business? Tell us what you think of them. Give us
Your Opinions, Get Free ThinkGeek Gift Certificates! Click to find out more
http://productguide.itmanagersjournal.com/guidepromo.tmpl