Permalink
Find file
Fetching contributors…
Cannot retrieve contributors at this time
487 lines (486 sloc) 23.2 KB
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns="http://alicebot.org/2001/AIML-1.0.1" xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:sch="http://www.ascc.net/xml/schematron"
targetNamespace="http://alicebot.org/2001/AIML-1.0.1" elementFormDefault="qualified"
attributeFormDefault="unqualified" version="1.0" xml:lang="EN">
<xs:element name="aiml">
<xs:annotation>
<xs:documentation>An AIML object is represented by an aiml element in an XML document.</xs:documentation>
<xs:appinfo>
<sch:title>Schematron validation</sch:title>
<sch:ns prefix="aiml" uri="http://alicebot.org/2001/AIML-1.0.1"/>
</xs:appinfo>
</xs:annotation>
<xs:complexType>
<xs:choice minOccurs="1" maxOccurs="unbounded">
<xs:element name="topic">
<xs:complexType>
<xs:annotation>
<xs:documentation>A topic is an optional top-level element that contains
category elements. A topic element has a required name attribute
that must contain a simple pattern expression. A topic element may
contain one or more category elements.</xs:documentation>
</xs:annotation>
<xs:sequence maxOccurs="unbounded">
<xs:element name="category" type="Category"/>
</xs:sequence>
<xs:attribute name="name" type="SimplePatternExpression" use="required"/>
</xs:complexType>
</xs:element>
<xs:element name="category" type="Category"/>
</xs:choice>
<xs:attribute name="version" use="required">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="1.0"/>
<xs:enumeration value="1.0.1"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
<xs:complexType name="Category">
<xs:annotation>
<xs:documentation>A category is a top-level (or second-level, if contained within a
topic) element that contains exactly one pattern and exactly one template. A
category does not have any attributes. All category elements that do not occur as
children of an explicit topic element must be assumed by the AIML interpreter to
occur as children of an "implied" topic whose name attribute has the value * (single
asterisk wildcard).</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element name="pattern" type="MixedPatternExpression">
<xs:annotation>
<xs:documentation>A pattern is an element whose content is a mixed pattern
expression. Exactly one pattern must appear in each category. The pattern
must always be the first child element of the category. A pattern does not
have any attributes. The contents of the pattern are appended to the full
match path that is constructed by the AIML interpreter at load
time.</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="that" type="MixedPatternExpression" minOccurs="0">
<xs:annotation>
<xs:documentation>The pattern-side that element is a special type of pattern
element used for context matching. The pattern-side that is optional in a
category, but if it occurs it must occur no more than once, and must
immediately follow the pattern and immediately precede the template. A
pattern-side that element contains a simple pattern expression. The contents
of the pattern-side that are appended to the full match path that is
constructed by the AIML interpreter at load time. If a category does not
contain a pattern-side that, the AIML interpreter must assume an "implied"
pattern-side that containing the pattern expression * (single asterisk
wildcard).</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="template" type="MixedTemplateContentContainer">
<xs:annotation>
<xs:documentation>The majority of AIML content is within the template. The
template may contain zero or more AIML template elements mixed with
character data.</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:complexType name="MixedPatternExpression" mixed="true">
<xs:annotation>
<xs:documentation>A mixed pattern expression is composed from one or more mixed pattern
expression constituents, separated by XML spaces (&amp;#x20).</xs:documentation>
</xs:annotation>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="bot" type="BotPredicate"/>
</xs:choice>
</xs:complexType>
<xs:complexType name="MixedTemplateContentContainer" mixed="true">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:group ref="atomicElements"/>
<xs:group ref="textFormattingElements"/>
<xs:group ref="conditionalElements"/>
<xs:group ref="captureElements"/>
<xs:group ref="symbolicReductionElements"/>
<xs:group ref="transformationalElements"/>
<xs:group ref="covertElements"/>
<xs:group ref="externalProcessorElements"/>
<xs:any namespace="##other" processContents="lax"/>
</xs:choice>
</xs:complexType>
<xs:group name="atomicElements">
<xs:annotation>
<xs:documentation>An atomic template element in AIML indicates to an AIML interpreter
that it must return a value according to the functional meaning of the element.
Atomic elements do not have any content.</xs:documentation>
</xs:annotation>
<xs:choice>
<xs:element name="star" type="IndexedElement">
<xs:annotation>
<xs:documentation>The star element indicates that an AIML interpreter should
substitute the value "captured" by a particular wildcard from the
pattern-specified portion of the match path when returning the template. The
star element has an optional integer index attribute that indicates which
wildcard to use. The minimum acceptable value for the index is "1" (the
first wildcard), and the maximum acceptable value is equal to the number of
wildcards in the pattern. </xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="that" type="OneOrTwoDIndexedElement">
<xs:annotation>
<xs:documentation>The pattern-side that element is a special type of pattern
element used for context matching. The pattern-side that is optional in a
category, but if it occurs it must occur no more than once, and must
immediately follow the pattern and immediately precede the template. A
pattern-side that element contains a simple pattern expression. The contents
of the pattern-side that are appended to the full match path that is
constructed by the AIML interpreter at load time. If a category does not
contain a pattern-side that, the AIML interpreter must assume an "implied"
pattern-side that containing the pattern expression * (single asterisk
wildcard). </xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="input" type="OneOrTwoDIndexedElement">
<xs:annotation>
<xs:documentation>The input element tells the AIML interpreter that it should
substitute the contents of a previous user input. The template-side input
has an optional index attribute that may contain either a single integer or
a comma-separated pair of integers. The minimum value for either of the
integers in the index is "1". The index tells the AIML interpreter which
previous user input should be returned (first dimension), and optionally
which "sentence" of the previous user input. The AIML interpreter should
raise an error if either of the specified index dimensions is invalid at
run-time. An unspecified index is the equivalent of "1,1". An unspecified
second dimension of the index is the equivalent of specifying a "1" for the
second dimension.</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="thatstar" type="IndexedElement">
<xs:annotation>
<xs:documentation>The thatstar element tells the AIML interpreter that it should
substitute the contents of a wildcard from a pattern-side that element. The
thatstar element has an optional integer index attribute that indicates
which wildcard to use; the minimum acceptable value for the index is "1"
(the first wildcard). An AIML interpreter should raise an error if the index
attribute of a star specifies a wildcard that does not exist in the that
element's pattern content. Not specifying the index is the same as
specifying an index of "1".</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="topicstar" type="IndexedElement">
<xs:annotation>
<xs:documentation> The topicstar element tells the AIML interpreter that it
should substitute the contents of a wildcard from the current topic (if the
topic contains any wildcards). The topicstar element has an optional integer
index attribute that indicates which wildcard to use; the minimum acceptable
value for the index is "1" (the first wildcard). Not specifying the index is
the same as specifying an index of "1".</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="get">
<xs:annotation>
<xs:documentation> The get element tells the AIML interpreter that it should
substitute the contents of a predicate, if that predicate has a value
defined. If the predicate has no value defined, the AIML interpreter should
substitute the empty string "". The AIML interpreter implementation may
optionally provide a mechanism that allows the AIML author to designate
default values for certain predicates.</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:attribute name="name" type="PredicateName"/>
</xs:complexType>
</xs:element>
<xs:element name="bot" type="BotPredicate"/>
<xs:group ref="shortcutElements"/>
<xs:group ref="systemDefinedPredicates"/>
</xs:choice>
</xs:group>
<xs:complexType name="BotPredicate">
<xs:annotation>
<xs:documentation> An element called bot, which may be considered a restricted
version of get, is used to tell the AIML interpreter that it should
substitute the contents of a "bot predicate". The value of a bot predicate
is set at load-time, and cannot be changed at run-time. The AIML interpreter
may decide how to set the values of bot predicate at load-time. If the bot
predicate has no value defined, the AIML interpreter should substitute an
empty string.</xs:documentation>
</xs:annotation>
<xs:attribute name="name" type="PredicateName" use="required"/>
</xs:complexType>
<xs:group name="shortcutElements">
<xs:annotation>
<xs:documentation>Several atomic AIML elements are "short-cuts" for combinations of
other AIML elements.</xs:documentation>
</xs:annotation>
<xs:choice>
<xs:element name="sr">
<xs:annotation>
<xs:documentation>The sr element is a shortcut for:
&lt;srai&gt;&lt;star/&gt;&lt;/srai&gt; The atomic sr
does not have any content. </xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:group>
<xs:group name="systemDefinedPredicates">
<xs:annotation>
<xs:documentation>Several atomic AIML elements require the AIML interpreter to
substitute a value that is determined from the system, independently of the AIML
content.</xs:documentation>
</xs:annotation>
<xs:choice>
<xs:element name="date">
<xs:annotation>
<xs:documentation> The date element tells the AIML interpreter that it should
substitute the system local date and time. No formatting constraints on the
output are specified.</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="id">
<xs:annotation>
<xs:documentation>The id element tells the AIML interpreter that it should
substitute the user ID. The determination of the user ID is not specified,
since it will vary by application. A suggested default return value is
"localhost".</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="size">
<xs:annotation>
<xs:documentation>The size element tells the AIML interpreter that it should
substitute the number of categories currently loaded.</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="version">
<xs:annotation>
<xs:documentation>The version element tells the AIML interpreter that it should
substitute the version number of the AIML interpreter.</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:group>
<xs:group name="textFormattingElements">
<xs:annotation>
<xs:documentation>Text-formatting elements instruct an AIML interpreter to perform
locale-specific post-processing of the textual results of the processing of their
contents.</xs:documentation>
</xs:annotation>
<xs:choice>
<xs:element name="uppercase" type="MixedTemplateContentContainer"/>
<xs:element name="lowercase" type="MixedTemplateContentContainer"/>
<xs:element name="formal" type="MixedTemplateContentContainer"/>
<xs:element name="sentence" type="MixedTemplateContentContainer"/>
</xs:choice>
</xs:group>
<xs:group name="conditionalElements">
<xs:choice>
<xs:element name="condition">
<xs:annotation>
<xs:documentation>The condition element instructs the AIML interpreter to return
specified contents depending upon the results of matching a predicate
against a pattern. NOTE: The definition in this Schema is currently far too
permissive. AIML conditions have several forms and constraints that can't be
expressed using W3C Schema alone. For this reason, AIML objects that
validate using this Schema alone may not actually be valid AIML.</xs:documentation>
<xs:appinfo>
<sch:pattern name="valid condition type">
<sch:rule context="aiml:condition">
<sch:assert
test="(@name and @value and not(aiml:li)) or (@name and not(@value) and aiml:li[@value and not(@name)] and not(aiml:li[@name]) and count(aiml:li[not(@value) and not(@name)]) &lt;= 1) or (not(@name) and not(@value) and aiml:li[@name and @value] and not(aiml:li[(@name and not(@value)) or (@value and not(@name))]) and count(aiml:li[not(@value) and not(@name)]) &lt;= 1)"
> A condition must be a block condition, a single-predicate
condition, or a multi-predicate condition. </sch:assert>
</sch:rule>
</sch:pattern>
</xs:appinfo>
</xs:annotation>
<xs:complexType mixed="true">
<xs:sequence minOccurs="0" maxOccurs="unbounded">
<xs:any namespace="##any" processContents="lax"/>
</xs:sequence>
<xs:attribute name="name" type="PredicateName"/>
<xs:attribute name="value" type="SimplePatternExpression"/>
</xs:complexType>
</xs:element>
<xs:element name="random">
<xs:annotation>
<xs:documentation>The random element instructs the AIML interpreter to return
exactly one of its contained li elements randomly.</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:sequence>
<xs:element name="li" type="MixedTemplateContentContainer"
maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:group>
<xs:group name="captureElements">
<xs:annotation>
<xs:documentation>AIML defines two content-capturing elements, which tell the AIML
interpreter to capture their processed contents and perform some storage operation
with them.</xs:documentation>
</xs:annotation>
<xs:choice>
<xs:element name="set">
<xs:annotation>
<xs:documentation>The set element instructs the AIML interpreter to set the
value of a predicate to the result of processing the contents of the set
element. The set element has a required attribute name, which must be a
valid AIML predicate name. If the predicate has not yet been defined, the
AIML interpreter should define it in memory.</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:complexContent>
<xs:extension base="MixedTemplateContentContainer">
<xs:attribute name="name" type="PredicateName"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
<xs:element name="gossip" type="MixedTemplateContentContainer">
<xs:annotation>
<xs:documentation> The gossip element instructs the AIML interpreter to capture
the result of processing the contents of the gossip elements and to store
these contents in a manner left up to the implementation. Most common uses
of gossip have been to store captured contents in a separate
file.</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:group>
<xs:group name="symbolicReductionElements">
<xs:choice>
<xs:element name="srai" type="MixedTemplateContentContainer">
<xs:annotation>
<xs:documentation> The srai element instructs the AIML interpreter to pass the
result of processing the contents of the srai element to the AIML matching
loop, as if the input had been produced by the user (this includes stepping
through the entire input normalization process).</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:group>
<xs:group name="transformationalElements">
<xs:choice>
<xs:element name="person" type="MixedTemplateContentContainer">
<xs:annotation>
<xs:documentation>The person element instructs the AIML interpreter to: 1.
replace words with first-person aspect in the result of processing the
contents of the person element with words with the
grammatically-corresponding third-person aspect; and 2. replace words with
third-person aspect in the result of processing the contents of the person
element with words with the grammatically-corresponding first-person aspect.
The definition of "grammatically-corresponding" is left up to the
implementation.</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="person2" type="MixedTemplateContentContainer">
<xs:annotation>
<xs:documentation>The person2 element instructs the AIML interpreter to: 1.
replace words with first-person aspect in the result of processing the
contents of the person2 element with words with the
grammatically-corresponding second-person aspect; and 2. replace words with
second-person aspect in the result of processing the contents of the person2
element with words with the grammatically-corresponding first-person aspect.
The definition of "grammatically-corresponding" is left up to the
implementation.</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="gender" type="MixedTemplateContentContainer">
<xs:annotation>
<xs:documentation>The gender element instructs the AIML interpreter to: 1.
replace male-gendered words in the result of processing the contents of the
gender element with the grammatically-corresponding female-gendered words;
and 2. replace female-gendered words in the result of processing the
contents of the gender element with the grammatically-corresponding
male-gendered words. The definition of "grammatically-corresponding" is left
up to the implementation. Historically, implementations of gender have
exclusively dealt with pronouns, likely due to the fact that most AIML has
been written in English. However, the decision about whether to transform
gender of other words is left up to the implementation.</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:group>
<xs:group name="covertElements">
<xs:annotation>
<xs:documentation>AIML defines two "covert" elements that instruct the AIML interpreter
to perform some processing on their contents, but to not return any
value.</xs:documentation>
</xs:annotation>
<xs:choice>
<xs:element name="think" type="MixedTemplateContentContainer">
<xs:annotation>
<xs:documentation>The think element instructs the AIML interpreter to perform
all usual processing of its contents, but to not return any value,
regardless of whether the contents produce output.</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="learn">
<xs:simpleType>
<xs:annotation>
<xs:documentation>The learn element instructs the AIML interpreter to
retrieve a resource specified by a URI, and to process its AIML object
contents.</xs:documentation>
</xs:annotation>
<xs:restriction base="xs:anyURI"/>
</xs:simpleType>
</xs:element>
</xs:choice>
</xs:group>
<xs:group name="externalProcessorElements">
<xs:annotation>
<xs:documentation>AIML defines two external processor elements, which instruct the AIML
interpreter to pass the contents of the elements to an external processor. External
processor elements may return a value, but are not required to do so. Contents of
external processor elements may consist of character data as well as AIML template
elements. If AIML template elements in the contents of an external processor element
are not enclosed as CDATA, then the AIML interpreter is required to substitute the
results of processing those elements before passing the contents to the external
processor. AIML does not require that any contents of an external processor element
are enclosed as CDATA. An AIML interpreter should assume that any unrecognized
content is character data, and simply pass it to the appropriate external processor
as-is, following any processing of AIML template elements not enclosed as CDATA. If
an external processor is not available to process the contents of an external
processor element, the AIML interpreter may return an error, but this is not
required.</xs:documentation>
</xs:annotation>
<xs:choice>
<xs:element name="system" type="MixedTemplateContentContainer">
<xs:annotation>
<xs:documentation>The system element instructs the AIML interpreter to pass its
content (with any appropriate preprocessing) to the system command
interpreter of the local machine on which the AIML interpreter is
running.</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="javascript" type="MixedTemplateContentContainer">
<xs:annotation>
<xs:documentation>The javascript element instructs the AIML interpreter to pass
its content (with any appropriate preprocessing, as noted above) to a
server-side JavaScript interpreter on the local machine on which the AIML
interpreter is running. The javascript element does not have any attributes.
AIML does not require that an AIML interpreter include a server-side
JavaScript interpreter, and does not require any particular behavior from
the server-side JavaScript interpreter if it exists. The javascript element
may return a value.</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:group>
<xs:complexType name="OneOrTwoDIndexedElement">
<xs:attribute name="index">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:minLength value="1"/>
<xs:pattern value="\d+|\d+,\d+"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
<xs:complexType name="IndexedElement">
<xs:attribute name="index" type="xs:integer"/>
</xs:complexType>
<xs:simpleType name="PredicateName">
<xs:restriction base="xs:string">
<xs:pattern value="\c+"/>
</xs:restriction>
</xs:simpleType>
</xs:schema>