INTERNET-DRAFT S. Legg
draft-legg-xed-asd-06.txt eB2Bcom
Intended Category: Standards Track October 20, 2006
Abstract Syntax Notation X (ASN.X)
Copyright (C) The Internet Society (2006).
Status of This Memo
By submitting this Internet-draft, each author represents that any
applicable patent or other IPR claims of which he or she is aware
have been or will be disclosed, and any of which he or she becomes
aware will be disclosed, in accordance with Section 6 of BCP 79.
Internet-Drafts are working documents of the Internet Engineering
Task Force (IETF), its areas, and its working groups. Note that
other groups may also distribute working documents as
Internet-Drafts.
Internet-Drafts are draft documents valid for a maximum of six months
and may be updated, replaced, or obsoleted by other documents at any
time. It is inappropriate to use Internet-Drafts as reference
material or to cite them other than as "work in progress".
The list of current Internet-Drafts can be accessed at
http://www.ietf.org/1id-abstracts.html
The list of Internet-Draft Shadow Directories can be accessed at
http://www.ietf.org/shadow.html
Technical discussion of this document should take place on the XED
developers mailing list <xeddev@eb2bcom.com>. Please send editorial
comments directly to the editor <steven.legg@eb2bcom.com>. Further
information is available on the XED website: www.xmled.info.
This Internet-Draft expires on 20 April 2007.
Abstract
Abstract Syntax Notation X (ASN.X) is a semantically equivalent
Extensible Markup Language (XML) representation for Abstract Syntax
Notation One (ASN.1) specifications. ASN.X completely avoids the
numerous ambiguities inherent in the ASN.1 language, therefore ASN.X
documents are much easier to parse and manage than original ASN.1
specifications. ASN.X, together with the Robust XML Encoding Rules
Legg Expires 20 April 2007 [Page 1]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
(RXER), constitutes a schema language for XML documents that offers,
through other ASN.1 encoding rules, alternative compact binary
encodings for XML instance documents.
Table of Contents
1. Introduction ....................................................3
2. Conventions .....................................................5
3. General Considerations ..........................................5
3.1. Annotations ................................................7
4. ModuleDefinition Translation ....................................8
5. Translation of Assignments .....................................10
5.1. Referencing Named Constructs ..............................11
5.2. Importing Namespaces ......................................12
5.3. TypeAssignment Translation ................................13
5.4. ValueAssignment and XMLValueAssignment Translation ........14
5.5. ValueSetTypeAssignment Translation ........................14
5.6. ObjectClassAssignment Translation .........................15
5.7. ObjectAssignment Translation ..............................15
5.8. ObjectSetAssignment Translation ...........................16
5.9. Parameterized Definitions .................................16
6. Translation of Types ...........................................16
6.1. Identifier Replacement ....................................25
6.2. DefinedType Translation ...................................26
6.3. Translation of Predefined Types ...........................29
6.4. BitStringType Translation .................................30
6.5. IntegerType Translation ...................................31
6.6. EnumeratedType Translation ................................33
6.7. PrefixedType Translation ..................................34
6.7.1. Short Form TaggedType Translation ..................37
6.7.2. Long Form TaggedType Translation ...................38
6.8. SelectionType Translation ................................39
6.9. InstanceOfType Translation ................................40
6.10. ObjectClassFieldType Translation .........................40
6.11. TypeFromObject and ValueSetFromObjects Translation .......40
6.12. Translation of Combining Types ...........................41
6.12.1. NamedType Translation .............................41
6.12.2. SequenceType Translation ..........................45
6.12.3. SetType Translation ...............................47
6.12.4. ChoiceType Translation ............................47
6.12.5. Translation of UNION Types ........................48
6.12.6. SequenceOfType Translation ........................49
6.12.7. Translation of LIST Types .........................50
6.12.8. SetOfType Translation .............................50
6.12.9. Insertion Encoding Instructions ...................51
6.13. Translation of Constrained Types .........................51
6.13.1. Constraint Translation ............................54
6.13.2. UserDefinedConstraint Translation .................54
Legg Expires 20 April 2007 [Page 2]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
6.13.3. TableConstraint Translation .......................55
6.13.4. ContentsConstraint Translation ....................57
6.13.5. ExceptionSpec Translation .........................58
7. Translation of Values ..........................................59
7.1. Translation of Literal Values .............................60
7.2. Translation of Notational Values ..........................62
7.2.1. DefinedValue Translation ...........................63
7.2.2. BuiltinValue Translation ...........................64
7.2.3. ValueFromObject Translation ........................67
7.2.4. ObjectClassFieldValue Translation ..................67
8. Translation of Value Sets ......................................68
8.1. ElementSetSpecs Translation ...............................69
8.2. ElementSetSpec Translation ................................69
8.3. SubtypeElements Translation ...............................70
8.3.1. ValueRange Translation .............................71
8.3.2. InnerTypeConstraints Translation ...................72
9. Translation of Object Classes ..................................73
9.1. DefinedObjectClass Translation ............................73
9.2. ObjectClassDefn Translation ...............................74
9.2.1. TypeFieldSpec Translation ..........................75
9.2.2. FixedTypeValueFieldSpec Translation ................76
9.2.3. FixedTypeValueSetFieldSpec Translation .............77
9.2.4. VariableTypeValueFieldSpec Translation .............78
9.2.5. VariableTypeValueSetFieldSpec Translation ..........79
9.2.6. FieldName Translation ..............................81
9.2.7. ObjectFieldSpec Translation ........................81
9.2.8. ObjectSetFieldSpec Translation .....................82
10. Translation of Objects ........................................84
10.1. DefinedObject Translation ................................84
10.2. ObjectDefn Translation ...................................85
10.3. ObjectFromObject Translation .............................86
11. Translation of Object Sets ....................................86
11.1. DefinedObjectSet Translation .............................87
11.2. ObjectSetElements Translation ............................88
11.2.1. ObjectSetFromObjects Translation .................89
12. Translation of Information From Objects .......................89
13. EncodingControlSections Translation ...........................90
14. Security Considerations .......................................90
15. Acknowledgements ..............................................91
16. IANA Considerations ...........................................91
17. References ....................................................91
17.1. Normative References .....................................91
17.2. Informative References ...................................93
Appendix A. ASN.1 for ASN.X .......................................93
Appendix B. ASN.X for ASN.X ......................................113
1. Introduction
Legg Expires 20 April 2007 [Page 3]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
A full parser for the Abstract Syntax Notation One (ASN.1) language
[X.680] is difficult to implement due to numerous ambiguities in the
notation. For example, certain notations for a Value are
syntactically indistinguishable from notation for a ValueSet, Object,
ObjectSet, DummyReference or SimpleTableConstraint. An
ObjectClassAssignment, ObjectAssignment or ObjectSetAssignment
resembles respectively a TypeAssignment, ValueAssignment or
ValueSetTypeAssignment. A FixedTypeValueFieldSpec or
FixedTypeValueSetFieldSpec resembles respectively an ObjectFieldSpec
or ObjectSetFieldSpec, and an ObjectClassFieldType resembles
InformationFromObjects. In general such ambiguities can only be
resolved once the entire specification has been parsed. There are
other notations that are not mutually ambiguous but still require
several lexical tokens to be scanned before they can be distinguished
from each other. The difficulty of parsing ASN.1 is an impediment to
its wider adoption.
This document defines a semantically equivalent Extensible Markup
Language (XML) [XML10][XML11] representation for ASN.1 specifications
called Abstract Syntax Notation X (ASN.X). ASN.X completely avoids
the inherent ambiguities of the ASN.1 language, therefore ASN.X
documents are much easier to parse and manage than original ASN.1
specifications. For example, any conformant XML processor forms the
basis of an ASN.1 toolkit.
An ASN.X document is a well-formed and valid XML document conforming
to XML namespaces [XMLNS10][XMLNS11]. ASN.X, together with the
Robust XML Encoding Rules (RXER) [RXER], constitutes a schema
language for XML documents that offers, through other ASN.1 encoding
rules, alternative compact binary encodings for XML instance
documents conforming to an ASN.X specification. ASN.X definitions
can also incorporate type, element and attribute definitions from
XML Schema [XSD1], RELAX NG [RNG] or Document Type Definitions (DTDs)
[XML10][XML11].
ASN.X is defined in terms of rules for translating from an ASN.1
specification. This does not preclude an ASN.X document being
written directly without a pre-existing ASN.1 specification, however
such an ASN.X document is considered valid if and only if there
exists, in principle, an ASN.1 specification that when translated
would yield the ASN.X document.
The format for ASN.X has also been designed so that the content of an
ASN.X document conforms to the RXER encoding of an abstract value of
an ASN.1 type, the ModuleDefinition type, presented in Appendix A.
This means that it is possible to decode an ASN.X document using an
RXER decoder and then re-encode the abstract value (for storage or
transmission) using any of the other encoding rules for ASN.1. Thus
Legg Expires 20 April 2007 [Page 4]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
the "X" in ASN.X can be regarded as standing for either XML or RXER,
or more generally, for any set of ASN.1 encoding rules.
The ASN.X translation of the ASN.1 module in Appendix A is presented
in Appendix B.
2. Conventions
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED" and "MAY" in this document are
to be interpreted as described in, BCP 14, RFC 2119 [BCP14]. The key
word "OPTIONAL" is exclusively used with its ASN.1 meaning.
Throughout this document "type" shall be taken to mean an ASN.1 type,
and "value" shall be taken to mean an ASN.1 abstract value.
A reference to an ASN.1 production [X.680] (e.g., Type, NamedType) is
a reference to the text in an ASN.1 specification corresponding to
that production.
The description of the translation of an ASN.1 module into an ASN.X
document makes use of definitions from the XML Information Set
(Infoset) [ISET]. In particular, information item property names
follow the Infoset convention of being shown in square brackets,
e.g., [local name]. In the sections that follow, "information item"
will be abbreviated to "item", e.g., "element information item" is
abbreviated to "element item". Element items will be referred to by
their [local name] in angle brackets, e.g., "the <type> element item"
means the element item with the [local name] "type". Attribute items
will be referred to by their [local name], e.g., "the type attribute
item" means the attribute item with the [local name] "type".
This document uses the namespace prefix "asnx:" to stand for the
namespace name "urn:ietf:params:xml:ns:asnx", though in practice any
valid namespace prefix is permitted in ASN.X.
Encoding instructions [X.680-1] referenced by name in this
specification are encoding instructions for RXER [RXEREI]. The
associated provisions do not apply to encoding instructions for other
encoding rules that happen to have the same name.
Code points for characters [UNICODE] are expressed using the Unicode
convention U+n, where n is four to six hexadecimal digits, e.g., the
space character is U+0020.
3. General Considerations
ASN.X is defined in terms of rules for translating an ASN.1 module
Legg Expires 20 April 2007 [Page 5]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
into a synthetic Infoset. This synthetic Infoset is then serialized
into a well-formed and valid XML document (the ASN.X document) in the
same manner that the synthetic Infoset for a non-canonical RXER
encoding is serialized into an XML document (see Section 5.11 of the
specification for RXER [RXER]).
Aside: The serialization permits CDATA sections, character
references and parsed entity references. However, note that an
ASN.X document may be transferred as data in a protocol and that
some protocols disallow entity references.
Apart from the [document element] of the document item for an ASN.X
document, the translation of some ASN.1 construct belongs to the
[children] or [attributes] of an enclosing element item.
Where the translation of the construct is an element item, it is
appended to the [children] of the enclosing element item. Elements
MUST be appended to the [children] of the enclosing element item in
the order described. Translators MAY add white space character items
(i.e., U+0020, U+0009, U+000D and U+000A) to the [children] of any
element item (to improve the layout) except element items with the
[local name] "literalValue", "fieldName" or "restrictBy".
Aside: White space character items in the [children] of
<fieldName> and <restrictBy> element items is explicitly covered
under their respective descriptions.
Where the translation of the construct is an attribute item it is
added to the [attributes] of the enclosing element item. The order
of attribute items is not significant. Translators MAY add leading
and trailing white space characters to the [normalized value] of any
attribute item except an attribute item with the [local name]
"literalValue".
Aside: An attribute or element item with the [local name]
"literalValue" holds an RXER Infoset translation of an abstract
value, and white space characters may be significant in that
abstract value. In most cases RXER itself permits optional
leading and trailing white space characters in the Infoset
translation.
Translators MAY add comment and processing instruction (PI) items to
the [children] of any element item except an element item with the
[local name] "literalValue".
Aside: In most cases RXER itself permits comment and PI items in
the [children] of the element items with the [local name]
"literalValue".
Legg Expires 20 April 2007 [Page 6]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
Aside: Note that an ASN.X document may be transferred as data in a
protocol and that some protocols disallow processing instructions.
The [in-scope namespaces] and [namespace attributes] for
<literalValue> and <restrictBy> element items are determined
according to Section 5.9 of the specification for RXER [RXER]. The
[in-scope namespaces] and [namespace attributes] for other element
items in the translation are determined according to Section 5.3.2.1
of the specification for RXER.
The [namespace name] of any element item or attribute item generated
by the translation from an ASN.1 specification has no value unless
specified otherwise.
In those cases where the [namespace name] of an element item has a
value, the [prefix] of the element item is determined according to
Section 5.3.2.2 of the specification for RXER. In those cases where
the [namespace name] of an attribute item has a value, the [prefix]
of the attribute item is determined according to Section 5.3.3.1 of
the specification for RXER.
Aside: Non-canonical RXER allows all valid namespace prefixes and
all valid placements for their corresponding namespace declaration
attributes.
Whenever an element item is added to the [children] of an enclosing
element item the enclosing element item becomes the [parent] of the
element item.
Whenever an attribute item is added to the [attributes] of an element
item the element item becomes the [owner element] of the attribute
item. For each attribute item, the [specified] property is set to
true, the [attribute type] has no value and the value of the
[references] property is set to unknown.
3.1. Annotations
In a number of places, as indicated in subsequent sections, the
translator is permitted to add an element item with the [local name]
"annotation". The corresponding ASN.1 type for the <annotation>
element item is the Markup type [RXER], and the [children] and
[attributes] of the <annotation> element item are at the discretion
of the translator.
Typical uses of the <annotation> element item would be to hold
comments from the ASN.1 specification that are normative in nature,
e.g., a comment in a user defined constraint, or to hold directives
for an ASN.1 compiler.
Legg Expires 20 April 2007 [Page 7]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
Free text or XML comments in an <annotation> element will be
preserved in a Canonical RXER (CRXER) encoding, while XML comments
outside <annotation> elements will not be.
Vendors using the <annotation> element items to hold ASN.1 compiler
directives (as attributes or child elements of the <annotation>
element) are encouraged to use element or attribute names that are
qualified with a namespace name specific to the vendor.
4. ModuleDefinition Translation
The translation of a ModuleDefinition [X.680] (an ASN.1 module) is a
document item. The [document element] of the document item is an
element item with the [local name] "module" and the [namespace name]
"urn:ietf:params:xml:ns:asnx".
An attribute item with the [local name] "format" and
[normalized value] "1.0" MAY be added to the [attributes] of the
[document element].
An ASN.1 module has a schema identity URI if it contains a
SCHEMA-IDENTITY encoding instruction, in which case the schema
identity URI is the character string specified by the AnyURIValue of
the SCHEMA-IDENTITY encoding instruction.
If the ASN.1 module being translated has a schema identity URI, then
an attribute item with the [local name] "schemaIdentity" SHALL be
added to the [attributes] of the [document element] (i.e., the
<asnx:module> element item). The [normalized value] of this
attribute item is the schema identity URI of the module.
An ASN.1 module has a target namespace if it contains a
TARGET-NAMESPACE encoding instruction, in which case the target
namespace is the character string specified by the AnyURIValue of the
TARGET-NAMESPACE encoding instruction.
If the ASN.1 module being translated has a target namespace, then an
attribute item with the [local name] "targetNamespace" SHALL be added
to the [attributes] of the [document element]. The
[normalized value] of this attribute item is the target namespace of
the module.
If the ASN.1 module contains a TARGET-NAMESPACE encoding instruction
that specifies a Prefix, then an attribute item with the [local name]
"targetPrefix" SHALL be added to the [attributes] of the
[document element]. The [normalized value] of this attribute item is
the character string specified by the NCName value of the Prefix.
Legg Expires 20 April 2007 [Page 8]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
In examples in the remainder of this document the namespace prefix
"tns:" is used to stand for the target namespace of the module being
translated.
An attribute item with the [local name] "name" SHALL be added to the
[attributes] of the [document element]. The [normalized value] of
this attribute item is the modulereference in the ModuleIdentifier in
the ModuleDefinition.
If the DefinitiveIdentifier in the ModuleIdentifier in the
ModuleDefinition is not empty, then an attribute item with the
[local name] "identifier" SHALL be added to the [attributes] of the
[document element]. The [normalized value] of this attribute item is
the RXER character data translation [RXER] of the
DefinitiveIdentifier.
If the TagDefault in the ModuleDefinition is empty, then an attribute
item with the [local name] "tagDefault" and [normalized value]
"explicit" SHALL be added to the [attributes] of the
[document element].
If the TagDefault in the ModuleDefinition is not empty and the first
keyword in the TagDefault is not "AUTOMATIC", then an attribute item
with the [local name] "tagDefault" SHALL be added to the [attributes]
of the [document element]. The [normalized value] of this attribute
item is the first keyword in the TagDefault with all letters
downcased, i.e., "explicit" or "implicit".
If the TagDefault in the ModuleDefinition is not empty and the first
keyword in the TagDefault is "AUTOMATIC", then an attribute item with
the [local name] "tagDefault" and [normalized value] "automatic" MAY
be added to the [attributes] of the [document element].
If the ExtensionDefault in the ModuleDefinition is not empty, then an
attribute item with the [local name] "extensibilityImplied" and
[normalized value] "true" or "1" SHALL be added to the [attributes]
of the [document element].
If the ExtensionDefault in the ModuleDefinition is empty, then an
attribute item with the [local name] "extensibilityImplied" and
[normalized value] "false" or "0" MAY be added to the [attributes] of
the [document element].
An element item with the [local name] "annotation" MAY be added to
the [children] of the [document element].
The translation of each Assignment in the AssignmentList in the
ModuleBody in the ModuleDefinition of the module being translated
Legg Expires 20 April 2007 [Page 9]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
SHALL be appended to the [children] of the [document element].
If the EncodingControlSections in the ModuleDefinition contains an
EncodingControlSection for RXER, then the translation of each
NamedType in a TopLevelComponent [RXEREI] in a TopLevelComponents in
the EncodingInstructionAssignmentList SHALL be added to the
[children] of the [document element]. The relative order of the
top-level components SHOULD be preserved in the translation, however
the translations of the top-level components MAY be interspersed with
the translations of the assignments in the AssignmentList.
The translation of the EncodingControlSections in the
ModuleDefinition of the module being translated SHALL be appended to
the [children] of the [document element].
Example
MyModule DEFINITIONS
IMPLICIT TAGS
EXTENSIBILITY IMPLIED ::=
BEGIN
MyType ::= INTEGER
ENCODING-CONTROL RXER
SCHEMA-IDENTITY "http://example.com/id/MyModule"
TARGET-NAMESPACE "http://example.com/ns/MyModule"
COMPONENT myElement INTEGER
END
<asnx:module xmlns:asnx="urn:ietf:params:xml:ns:asnx"
name="MyModule"
schemaIdentity="http://example.com/id/MyModule"
targetNamespace="http://example.com/ns/MyModule"
tagDefault="implicit"
extensibilityImplied="true">
<namedType name="MyType" type="asnx:INTEGER"/>
<element name="myElement" type="asnx:INTEGER"/>
</asnx:module>
5. Translation of Assignments
Legg Expires 20 April 2007 [Page 10]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
5.1. Referencing Named Constructs
An Assignment in ASN.1 associates a reference name with a Type,
Value, ValueSet, ObjectClass, Object or ObjectSet. In ASN.X, the
translation of the Assignment is regarded as associating a qualified
name [XMLNS10][XMLNS11] with the Type, Value, ValueSet, ObjectClass,
Object or ObjectSet. ASN.X uses these qualified names in place of
the references in an ASN.1 specification.
In every case, the local part of the qualified name is the
typereference, valuereference, objectclassreference, objectreference
or objectsetreference in the Assignment (i.e., the [normalized value]
of the name attribute item in the translation of the Assignment,
ignoring white space characters). If the ASN.1 module in which the
Assignment is defined has a target namespace, then this SHALL be the
namespace name of the qualified name. The namespace prefix is
determined according to Section 5.6.11.1 of the specification for
RXER.
If the ASN.1 module in which the Assignment is defined does not have
a target namespace, then the namespace name of the qualified name is
absent (i.e., the name is unqualified).
If an ASN.1 specification contains two or more modules without target
namespaces, then there exists the possibility that reference names
defined in those modules are not distinct. The reference names are
not distinct if two or more type or value set assignments define the
same typereference or two or more value assignments define the same
valuereference or two or more object class assignments define the
same objectclassreference or two or more object assignments define
the same objectreference or two or more object set assignments define
the same objectsetreference or two or more top-level NamedType
instances [RXEREI] subject to an ATTRIBUTE encoding instruction have
the same effective name [RXEREI] or two or more top-level NamedType
instances not subject to an ATTRIBUTE encoding instruction have the
same effective name. If the reference names are not distinct, then
an unambiguous translation into ASN.X does not exist unless each of
the modules has a SCHEMA-IDENTITY encoding instruction.
Consequently, if two or more modules without target namespaces are
being translated into ASN.X and the reference names defined in those
modules are not distinct, then as a local action prior to the
translation, a SCHEMA-IDENTITY encoding instruction MUST be added to
each of the modules that defines one or more of the indistinct
reference names and that does not already have a SCHEMA-IDENTITY
encoding instruction. The character string (a URI) specified by the
AnyURIValue of each added SCHEMA-IDENTITY encoding instruction is
freely chosen by the translator, subject to the condition that these
character strings are distinct [RXEREI].
Legg Expires 20 April 2007 [Page 11]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
Aside: Although this means that different translators might
produce ASN.X documents that are syntactically different for any
given ASN.1 module, those documents will be semantically
equivalent to each other and to the original ASN.1 module.
TARGET-NAMESPACE and SCHEMA-IDENTITY encoding instructions are
RECOMMENDED for every ASN.1 module.
5.2. Importing Namespaces
An Assignment is referenced from an ASN.X document if its qualified
name appears in the [normalized value] of a an attribute item with
the [local name] "type", "value", "class", "object" or "objectSet".
These references are categorized as direct references. An Assignment
or top-level component is also referenced from an ASN.X document if
its qualified name appears in the [normalized value] of an attribute
item with the [local name] "ref". This reference is only categorized
as direct if the ref attribute is not the result of the translation
of a DefinedType subject to a TYPE-REF encoding instruction or a
NamedType subject to an ATTRIBUTE-REF or ELEMENT-REF encoding
instruction.
Aside: In the case of an indirect reference, an attribute with the
[local name] "embedded" and [normalized value] "true" or "1" will
also be present.
Definition (external module): An external module is any module other
than the module being translated and the AdditionalBasicDefinitions
module [RXER].
Aside: The AdditionalBasicDefinitions module is always assumed to
be imported, as are all the built-in types and object classes of
ASN.1.
An element item with the [local name] "import" SHALL be added to the
[children] of the [document element] for each external module
containing Assignments or top-level components that are directly
referenced from the ASN.X document. An <import> element item MAY be
added to the [children] of the [document element] for any other
external module.
An attribute item with the [local name] "name" SHOULD be added to the
[attributes] of the <import> element item. The [normalized value] of
this attribute item is the modulereference in the ModuleIdentifier in
the ModuleDefinition of the external module.
If the DefinitiveIdentifier in the ModuleIdentifier in the
ModuleDefinition of the external module is not empty, then an
Legg Expires 20 April 2007 [Page 12]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
attribute item with the [local name] "identifier" SHALL be added to
the [attributes] of the <import> element item. The
[normalized value] of this attribute item is the RXER character data
translation of the DefinitiveIdentifier.
If the external module has a schema identity URI, then an attribute
item with the [local name] "schemaIdentity" SHALL be added to the
[attributes] of the <import> element item. The [normalized value] of
this attribute item is the schema identity URI of the external
module.
If the external module has a target namespace, then an attribute item
with the [local name] "namespace" SHALL be added to the [attributes]
of the <import> element item. The [normalized value] of this
attribute item is the target namespace of the external module.
An attribute item with the [local name] "schemaLocation" MAY be added
to the [attributes] of the <import> element item. The
[normalized value] of this attribute item is a URI [URI] indicating
the physical location of the ASN.X translation of the external
module.
The <import> element items MUST follow an <annotation> element item
(if present) and MUST precede any other element items in the
[children] of the [document element].
Note that because of the way parameterized references are expanded in
ASN.X, the modules in the Imports of the ModuleDefinition may not
correspond exactly to the <import> element items.
5.3. TypeAssignment Translation
The translation of a TypeAssignment is an element item with the
[local name] "namedType". An attribute item with the [local name]
"name" SHALL be added to the [attributes] of the <namedType> element
item. The [normalized value] of this attribute item is the
typereference on the left hand side of the assignment.
An element item with the [local name] "annotation" MAY be added to
the [children] of the <namedType> element item. The translation of
the Type on the right hand side of the assignment SHALL be added to
the [children] or [attributes] of the <namedType> element item.
Example
MyType ::= INTEGER
<namedType name="MyType" type="asnx:INTEGER"/>
Legg Expires 20 April 2007 [Page 13]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
5.4. ValueAssignment and XMLValueAssignment Translation
The translation of a ValueAssignment is an element item with the
[local name] "namedValue". An attribute item with the [local name]
"name" SHALL be added to the [attributes] of the <namedValue> element
item. The [normalized value] of this attribute item is the
valuereference on the left hand side of the assignment.
An element item with the [local name] "annotation" MAY be added to
the [children] of the <namedValue> element item. The translation of
the Type on the left hand side of the assignment and the translation
of the Value on the right hand side of the assignment SHALL be added
to the [children] and/or [attributes] of the <namedValue> element
item.
Example
myValue INTEGER ::= 10
<namedValue name="myValue" type="asnx:INTEGER" literalValue="10"/>
An XMLValueAssignment is converted into the equivalent
ValueAssignment and then translated as a ValueAssignment. Note that
the ASN.X representation for a Value is unrelated to XMLTypedValue.
5.5. ValueSetTypeAssignment Translation
The translation of a ValueSetTypeAssignment is an element item with
the [local name] "namedValueSet". An attribute item with the
[local name] "name" SHALL be added to the [attributes] of the
<namedValueSet> element item. The [normalized value] of this
attribute item is the typereference on the left hand side of the
assignment.
An element item with the [local name] "annotation" MAY be added to
the [children] of the <namedValueSet> element item. The translation
of the Type on the left hand side of the assignment SHALL be added to
the [children] or [attributes] of the <namedValueSet> element item.
The translation of the ValueSet on the right hand side of the
assignment SHALL be added to the [children] of the <namedValueSet>
element item.
Example
MyValueSet INTEGER ::= { 10 }
<namedValueSet name="MyValueSet" type="asnx:INTEGER">
<valueSet>
Legg Expires 20 April 2007 [Page 14]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<literalValue>10</literalValue>
</valueSet>
</namedValueSet>
5.6. ObjectClassAssignment Translation
The translation of an ObjectClassAssignment is an element item with
the [local name] "namedClass". An attribute item with the
[local name] "name" SHALL be added to the [attributes] of the
<namedClass> element item. The [normalized value] of this attribute
item is the objectclassreference on the left hand side of the
assignment.
An element item with the [local name] "annotation" MAY be added to
the [children] of the <namedClass> element item. The translation of
the ObjectClass on the right hand side of the assignment SHALL be
added to the [children] or [attributes] of the <namedClass> element
item.
Example
MY-CLASS ::= TYPE-IDENTIFIER
<namedClass name="MY-CLASS" class="asnx:TYPE-IDENTIFIER"/>
5.7. ObjectAssignment Translation
The translation of an ObjectAssignment is an element item with the
[local name] "namedObject". An attribute item with the [local name]
"name" SHALL be added to the [attributes] of the <namedObject>
element item. The [normalized value] of this attribute item is the
objectreference on the left hand side of the assignment.
An element item with the [local name] "annotation" MAY be added to
the [children] of the <namedObject> element item. The translation of
the DefinedObjectClass on the left hand side of the assignment and
the translation of the Object on the right hand side of the
assignment SHALL be added to the [children] and/or [attributes] of
the <namedObject> element item.
Example
myObject TYPE-IDENTIFIER ::=
{ INTEGER IDENTIFIED BY { 2 5 13 14 } }
<namedObject name="myObject" class="asnx:TYPE-IDENTIFIER">
<object>
<field name="id" literalValue="2.5.13.14"/>
Legg Expires 20 April 2007 [Page 15]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<field name="Type" type="asnx:INTEGER"/>
</object>
</namedObject>
5.8. ObjectSetAssignment Translation
The translation of an ObjectSetAssignment is an element item with the
[local name] "namedObjectSet". An attribute item with the
[local name] "name" SHALL be added to the [attributes] of the
<namedObjectSet> element item. The [normalized value] of this
attribute item is the objectsetreference on the left hand side of the
assignment.
An element item with the [local name] "annotation" MAY be added to
the [children] of the <namedObjectSet> element item. The translation
of the DefinedObjectClass on the left hand side of the assignment and
the translation of the ObjectSet on the right hand side of the
assignment SHALL be added to the [children] and/or [attributes] of
the <namedObjectSet> element item.
Example
MyObjectSet TYPE-IDENTIFIER ::= { myObject }
<namedObjectSet name="MyObjectSet" class="asnx:TYPE-IDENTIFIER">
<objectSet>
<object ref="tns:myObject"/>
</objectSet>
</namedObjectSet>
5.9. Parameterized Definitions
The translation of an ASN.1 specification into ASN.X replaces any
DummyReference [X.683] or reference to a parameterized definition
[X.683] with the definition expanded in-line (except for a special
case involving recursive parameterized types). For example, a
ParameterizedObject is replaced by the Object on the right hand side
of the referenced ParameterizedObjectAssignment. Consequently there
is no direct translation for a ParameterizedAssignment, though its
definition may come into play in the translation of references to the
parameterized definition.
The definition that substitutes for a DummyReference or parameterized
reference (e.g., the Object that substitutes for a
ParameterizedObject) potentially comes from a different module from
the reference. Expanding a DummyReference or parameterized reference
in-line puts the substitute definition into the context of the module
containing the reference, which could therefore alter the
Legg Expires 20 April 2007 [Page 16]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
interpretation of the substitute definition.
A type definition is potentially dependent on the TagDefault and
ExtensionDefault of the module in which it appears, and may also be
affected by encoding instructions in an XML Encoding Rules (XER)
[X.693] encoding control section [X.693-1]. Other kinds of
definitions are not dependent on the module context, however type
definitions can be nested within the other kinds of definitions, so a
change of context can still be significant.
Aside: Type definitions are not dependent on their module's RXER
or Generic String Encoding Rules (GSER) [GSER] encoding control
section [RXEREI][GSEREI] (as they are currently defined), so the
presence of an encoding control section for RXER or GSER is not
significant in a change of context.
The remainder of this section describes how and when a change of
context is indicated in the ASN.X translation of a DummyReference or
parameterized reference.
In any instance of use, the module containing the DummyReference or
parameterized reference is the referencing module and the module
providing the substitute definition is the referenced module. The
referenced and referencing modules may be the same module.
In the case of a ParameterizedType, the substitute definition is the
Type on the right hand side of the referenced
ParameterizedTypeAssignment.
In the case of a ParameterizedValueSetType, the substitute definition
is the constrained type on the right hand side of the notional
ParameterizedTypeAssignment equivalent to the referenced
ParameterizedValueSetTypeAssignment (see Clause 15.8 of X.680
[X.680]).
In the case of a ParameterizedValue, the substitute definition is the
Value on the right hand side of the referenced
ParameterizedValueAssignment.
In the case of a ParameterizedObjectClass, the substitute definition
is the ObjectClass on the right hand side of the referenced
ParameterizedObjectClassAssignment.
In the case of a ParameterizedObject, the substitute definition is
the Object on the right hand side of the referenced
ParameterizedObjectAssignment.
In the case of a ParameterizedObjectSet, the substitute definition is
Legg Expires 20 April 2007 [Page 17]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
the ObjectSet on the right hand side of the referenced
ParameterizedObjectSetAssignment.
If the ActualParameter corresponding to a DummyReference is not a
ValueSet, then the substitute definition for that DummyReference is
the Type, Value, DefinedObjectClass, Object or ObjectSet in the
ActualParameter corresponding to the DummyReference.
If the ActualParameter corresponding to a DummyReference is a
ValueSet, then the substitute definition for that DummyReference is
the notional constrained type equivalent to the ValueSet; the
ElementSetSpecs of the ValueSet contributes to the constraint of the
constrained type and the governor of the Parameter corresponding to
the ActualParameter is used as the parent type that is constrained.
Definition (interchangeable): The contexts of the referencing and
referenced modules are interchangeable with respect to interpreting
the substitute definition if:
(a) the referenced module is the referencing module and does not
contain an XER encoding control section, or
(b) the referenced module and referencing module have the same
TagDefault (where an absent TagDefault is taken to be equivalent
to "EXPLICIT TAGS"), the referenced module and referencing module
have the same ExtensionDefault, and neither module has an XER
encoding control section.
Aside: A module with an XER encoding control section is not
considered to have a context interchangeable with another module,
including itself, because the typereference by which a substitute
type definition is identified may appear in a TargetList in the
XER encoding control section of the referenced module, and because
the in-line expansion of a substitute definition may cause its
text to come within the scope of a TargetList in the XER encoding
control section of the referencing module that would not apply
otherwise.
Definition (recursively contained): A ParameterizedType is
recursively contained if its translation will be nested within the
translation (i.e., in-line expansion) of another ParameterizedType to
which it is equivalent. A ParameterizedValueSetType is recursively
contained if its translation will be nested within the translation of
another ParameterizedValueSetType to which it is equivalent.
Aside: ASN.1 does not permit the other kinds of parameterized
reference to be recursive.
Legg Expires 20 April 2007 [Page 18]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The translation of a DummyReference, a ParameterizedType that is not
recursively contained, a ParameterizedValue, a
ParameterizedValueSetType that is not recursively contained, a
ParameterizedObjectClass, a ParameterizedObject or a
ParameterizedObjectSet is either:
(1) the translation of the substitute definition, or
(2) an element item with the [local name] "type" if the substitute
definition is a Type, "value" if the substitute definition is a
Value, "class" if the substitute definition is an ObjectClass or
DefinedObjectClass, "object" if the substitute definition is an
Object, or "objectSet" if the substitute definition is an
ObjectSet. A fully expanded reference (described shortly) SHALL
be added to the [children] of the element item.
The translation in case (2) is always allowed and provides
information to identify the referenced module and the referenced
definition.
The translation in case (1) MAY be used instead if and only if the
contexts of the referencing and referenced modules are
interchangeable, or the contexts of the referencing and referenced
modules are not interchangeable but the difference between them does
not affect how the substitute definition is interpreted.
Aside: There are many ways in which the substitute definition can
be unaffected by a difference between the contexts of the
referencing and referenced modules. One example would be where
the referencing and referenced modules differ only in their
TagDefault, but the substitute definition does not contain any
TaggedType notation.
Note that if the translation in case (1) is used, then the
referencing module is still the referencing module when considering a
nested in-line expansion. If the translation in case (2) is used,
then the referenced module becomes the referencing module when
considering a nested in-line expansion.
A fully expanded reference is an element item with the [local name]
"expanded". Except in the case of a DummyReference, the reference
name is indicated by an attribute item with the [local name] "name"
added to the [attributes] of the <expanded> element item.
In the case of a ParameterizedType or ParameterizedValueSetType, the
[normalized value] of this attribute item is the typereference of the
ParameterizedType or ParameterizedValueSetType.
Legg Expires 20 April 2007 [Page 19]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
In the case of a ParameterizedValue, the [normalized value] of this
attribute item is the valuereference of the ParameterizedValue.
In the case of a ParameterizedObjectClass, the [normalized value] of
this attribute item is the objectclassreference of the
ParameterizedObjectClass,
In the case of a ParameterizedObject, the [normalized value] of this
attribute item is the objectreference of the ParameterizedObject.
In the case of a ParameterizedObjectSet, the [normalized value] of
this attribute item is the objectsetreference of the
ParameterizedObjectSet.
The "name" attribute item MAY be omitted if:
(a) the conditions permitting the use of the translation in the
aforementioned case (1) are satisfied, or
(b) the reference is not a typereference, or
(c) the reference is a typereference that does not appear in any
TargetList in an XER encoding control section of the referenced
module.
The "name" attribute SHALL NOT appear in the translation of a
DummyReference.
The referenced module is indicated by an element item with the
[local name] "module" added to the [children] of the <expanded>
element item. The <module> element item MAY be omitted if the
conditions permitting the use of the translation in the
aforementioned case (1) are satisfied, or if the referencing module
is the referenced module. When the <module> element item is present:
(a) An attribute item with the [local name] "name" SHOULD be added to
the [attributes] of the <module> element item. The
[normalized value] of this attribute item is the modulereference
in the ModuleIdentifier in the ModuleDefinition of the referenced
module.
(b) If the DefinitiveIdentifier in the ModuleIdentifier in the
ModuleDefinition of the referenced module is not empty, then an
attribute item with the [local name] "identifier" SHALL be added
to the [attributes] of the <module> element item. The
[normalized value] of this attribute item is the RXER character
data translation of the DefinitiveIdentifier.
Legg Expires 20 April 2007 [Page 20]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
(c) If the referenced module has a schema identity URI, then an
attribute item with the [local name] "schemaIdentity" SHALL be
added to the [attributes] of the <module> element item. The
[normalized value] of this attribute item is the schema identity
URI of the referenced module.
At least one of the attribute items specified in cases (a), (b) and
(c) MUST appear in the [attributes] of the <module> element item.
The translation of the substitute definition SHALL be added to the
[children] or [attributes] of the <expanded> element item.
Example
Consider these module definitions:
Templates
DEFINITIONS
AUTOMATIC TAGS ::=
BEGIN
CollectionOfThings { Thing } ::= SEQUENCE OF thing Thing
END
ProtocolDefinitions
DEFINITIONS
AUTOMATIC TAGS ::=
BEGIN
IMPORTS
CollectionOfThings{}
FROM Templates
;
CollectionOfIntegers ::= CollectionOfThings { INTEGER }
END
The Type on the right hand side of the TypeAssignment for
CollectionOfIntegers is a ParameterizedType. Thing is a
DummyReference.
Without using the translation in case (1), the translations of
these modules are:
<asnx:module name="Templates"/>
Legg Expires 20 April 2007 [Page 21]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<asnx:module xmlns:asnx="urn:ietf:params:xml:ns:asnx"
name="ProtocolDefinitions">
<namedType name="CollectionOfIntegers">
<type>
<expanded name="CollectionOfThings">
<module name="Templates"/>
<type>
<sequenceOf>
<element name="thing">
<type>
<expanded>
<module name="ProtocolDefinitions"/>
<type ref="asnx:INTEGER"/>
</expanded>
</type>
</element>
</sequenceOf>
</type>
</expanded>
</type>
</namedType>
</asnx:module>
The translation of the Templates module is empty because the
module contains only a parameterized assignment.
Since the contexts of the Templates and ProtocolDefinitions
modules are interchangeable, a simpler translation of the
ProtocolDefinitions module is permitted:
<asnx:module xmlns:asnx="urn:ietf:params:xml:ns:asnx"
name="ProtocolDefinitions">
<namedType name="CollectionOfIntegers">
<type>
<sequenceOf>
<element name="thing" type="asnx:INTEGER"/>
</sequenceOf>
</type>
</namedType>
</asnx:module>
If a ParameterizedType or ParameterizedValueSetType is recursively
contained, then its translation is an element item with the
[local name] "type". An attribute item with the [local name]
Legg Expires 20 April 2007 [Page 22]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
"ancestor" SHALL be added to the [attributes] of the <type> element
item. The [normalized value] of this attribute item is the decimal
digit string representing the integer value of one plus the number of
intermediate enclosing <type> element items between the <type>
element items resulting from the translations of the two equivalent
instances of ParameterizedType or ParameterizedValueSetType. An
element item with the [local name] "annotation" MAY be added to the
[children] of the <type> element item.
A <type> element item with an ancestor attribute item is a reference
to an ancestor <type> element item. This form for a <type> element
item SHOULD NOT be used in original specifications written in ASN.X.
Aside: The form is only intended for the purpose of handling
recursive parameterized type definitions in an ASN.1 specification
being translated into ASN.X. Such definitions are
self-referencing but have no obvious name. It is also not easy to
construct a suitable name from the surrounding context because
recursive parameterized types can be embedded in other constructs,
such as information objects, that are themselves unnamed.
Example
Consider these type definitions, assumed to be defined in a module
that does not have an XER encoding control section:
Tree { ValueType } ::= SEQUENCE {
value [0] ValueType,
left-subtree [1] Tree { ValueType } OPTIONAL,
right-subtree [2] Tree { ValueType } OPTIONAL
}
NumberTree ::= [APPLICATION 13] Tree { INTEGER }
The assignment for "Tree" is not directly translated because it is
a ParameterizedAssignment. The translation for the "NumberTree"
assignment, up to but not yet including the Type in the
TaggedType, is as follows:
<namedType name="NumberTree">
<type>
<tagged tagClass="application" number="13"/>
</type>
</namedType>
The Type in the TaggedType is a ParameterizedType. Since the
ParameterizedType is not recursively contained the translation of
the ParameterizedType, using the translation in case (1) above, is
Legg Expires 20 April 2007 [Page 23]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
the translation of the Type on the right hand side of the
referenced ParameterizedTypeAssignment, namely this type:
SEQUENCE {
value [0] ValueType,
left-subtree [1] Tree { ValueType } OPTIONAL,
right-subtree [2] Tree { ValueType } OPTIONAL
}
ValueType is a DummyReference. The translation of the actual
parameter substitutes for the DummyReference. In this case the
actual parameter is the type INTEGER.
The translation for the SEQUENCE type, up to the first component,
is added to the <tagged> element:
<namedType name="NumberTree">
<type>
<tagged tagClass="application" number="13">
<type><!-- Tree { INTEGER } -->
<sequence>
<element name="value">
<type>
<tagged number="0">
<type ref="asnx:INTEGER"/><!-- ValueType -->
</tagged>
</type>
</element>
</sequence>
</type>
</tagged>
</type>
</namedType>
The Type in the TaggedType for the second component is a
ParameterizedType. Since this ParameterizedType is recursively
contained its translation is a <type> element with the ancestor
attribute. The value of the ancestor attribute is "2" because
there is one intermediate <type> element (for a TaggedType). Put
another way, the translations of the equivalent instances of
ParameterizedType are two <type> steps apart.
The translation of the third component of the SEQUENCE type
follows the same pattern as the second component. The completed
translation is as follows:
<namedType name="NumberTree">
<type>
Legg Expires 20 April 2007 [Page 24]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<tagged tagClass="application" number="13">
<type><!-- Tree { INTEGER } -->
<sequence>
<element name="value">
<type>
<tagged number="0">
<type ref="asnx:INTEGER"/><!-- ValueType -->
</tagged>
</type>
</element>
<optional>
<element name="left-subtree">
<type>
<tagged number="1">
<type ancestor="2"/><!-- Tree { ValueType } -->
</tagged>
</type>
</element>
</optional>
<optional>
<element name="right-subtree">
<type>
<tagged number="2">
<type ancestor="2"/><!-- Tree { ValueType } -->
</tagged>
</type>
</element>
</optional>
</sequence>
</type>
</tagged>
</type>
</namedType>
6. Translation of Types
The rules for translating the different varieties of Type are
detailed in this section.
Note that the notation of ASN.1 is ambiguous where a Type is both
prefixed [X.680-1] (e.g., tagged) and constrained. For example, the
notation "[0] INTEGER (0..10)" could be interpreted either as a
tagged ConstrainedType or a constrained TaggedType. For the purposes
of the translation into ASN.X the constraint is assumed to have
higher precedence than the prefix, so the above notation would be
taken to be a tagged ConstrainedType.
6.1. Identifier Replacement
Legg Expires 20 April 2007 [Page 25]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
Various RXER encoding instructions can be used to override an
identifier in an ASN.1 specification with an NCName [XMLNS10]. The
NCName is given pre-eminence in the ASN.X representation and the
identifier is not explicitly given if it is algorithmically related
to the NCName. The cases where an NCName overrides an identifier are
covered individually in other parts of this specification and make
use of the following definition.
Definition (reduction): The reduction of an NCName is the string of
characters resulting from the following operations performed in order
on the NCName:
(1) replace each "." (U+002E) and "_" (U+005F) character with a "-"
(U+002D) character,
(2) remove every character except latin letters (U+0041-U+005A,
U+0061-U+007A), decimal digits (U+0030-U+0039) and hyphens
(U+002D),
(3) remove leading and trailing hyphen characters,
(4) replace sequences of two or more hyphen characters with a single
hyphen, and
(5) convert the first character to lowercase if it is an uppercase
letter.
Aside: If the reduction of an NCName is not the same as the
identifier that the NCName replaces, then the identifier will be
explicitly given in the translation into ASN.X.
6.2. DefinedType Translation
If a Type is a DefinedType in a ReferencedType, then the translation
of the Type is the translation of the DefinedType.
If a DefinedType is not a ParameterizedType,
ParameterizedValueSetType or DummyReference and is not subject to a
TYPE-REF or REF-AS-TYPE encoding instruction, then the translation of
the DefinedType is either the attribute form translation of a type
reference, or the element form translation of a type reference.
The attribute form translation of a type reference is an attribute
item with the [local name] "type". The [normalized value] of this
attribute item is the qualified name referencing the type definition
(see Section 5.1). The attribute form translation SHALL NOT be used
if the qualified name is shared by two or more type definitions in
separate modules, i.e., is ambiguous.
Legg Expires 20 April 2007 [Page 26]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The element form translation of a type reference is an element item
with the [local name] "type". An attribute item with the
[local name] "ref" SHALL be added to the [attributes] of the <type>
element item. The [normalized value] of this attribute item is the
qualified name referencing the type definition. If this reference
name is not distinct with respect to the current module and the
modules referenced by its <import> element items (see Section 5.1),
then an attribute item with the [local name] "context" SHALL be added
to the [attributes] of the <type> element item, otherwise if the
module containing the referenced type definition has a schema
identity URI, then an attribute item with the [local name] "context"
MAY be added to the [attributes] of the <type> element item. The
[normalized value] of this attribute item is the schema identity URI
of the module containing the type definition referenced by the
DefinedType.
Aside: If a reference name is not distinct, then the module
containing the referenced definition must have a schema identity
URI (see Section 5.1).
An element item with the [local name] "annotation" MAY be added to
the [children] of the <type> element item.
An attribute item with the [local name] "embedded" and
[normalized value] "false" or "0" MAY be added to the [attributes] of
the <type> element item.
The translation of the DefinedType is the same whether the type
definition is referenced by a typereference or an
ExternalTypeReference.
If a DefinedType is subject to a TYPE-REF encoding instruction, then
the translation of the DefinedType is an element item with the
[local name] "type". An attribute item with the [local name] "ref"
SHALL be added to the [attributes] of the <type> element item. The
[normalized value] of this attribute item is the RXER character data
translation of the QNameValue from the TYPE-REF encoding instruction.
If the ContextParameter is present in the RefParameters in the
TYPE-REF encoding instruction, then an attribute item with the
[local name] "context" SHALL be added to the [attributes] of the
<type> element item. The [normalized value] of this attribute item
is the string value of the AnyURIValue in the ContextParameter. An
attribute item with the [local name] "embedded" and
[normalized value] "true" or "1" SHALL be added to the [attributes]
of the <type> element item.
Aside: The embedded attribute item indicates whether a type is
directly referenced as a DefinedType or indirectly referenced
Legg Expires 20 April 2007 [Page 27]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
through a TYPE-REF encoding instruction. An ASN.1 type can be
referenced either way. Type definitions in other schema languages
cannot be directly referenced.
An element item with the [local name] "annotation" MAY be added to
the [children] of the <type> element item.
If a DefinedType is subject to a REF-AS-TYPE encoding instruction,
then the translation of the DefinedType is an element item with the
[local name] "type". An attribute item with the [local name]
"elementType" SHALL be added to the [attributes] of the <type>
element item. The [normalized value] of this attribute item is the
RXER character data translation of the NameValue from the REF-AS-TYPE
encoding instruction. If the Namespace is present in the REF-AS-TYPE
encoding instruction, then an attribute item with the [local name]
"namespace" SHALL be added to the [attributes] of the <type> element
item. The [normalized value] of this attribute item is the string
value of the AnyURIValue in the Namespace. If the ContextParameter
is present in the RefParameters in the REF-AS-TYPE encoding
instruction, then an attribute item with the [local name] "context"
SHALL be added to the [attributes] of the <type> element item. The
[normalized value] of this attribute item is the string value of the
AnyURIValue in the ContextParameter. An element item with the
[local name] "annotation" MAY be added to the [children] of the
<type> element item.
Example
CHOICE {
one Foo,
two [RXER:TYPE-REF
{ namespace-name "http://www.example.com/PO1",
local-name "PurchaseOrderType" }
] Markup,
three [RXER:REF-AS-TYPE "product"
CONTEXT "http://www.example.com/inventory"
] Markup
}
<type xmlns:po="http://www.example.com/PO1">
<choice>
<element name="one" type="tns:Foo"/>
<element name="two" type="po:PurchaseOrderType"/>
<element name="three">
<type elementType="product"
context="http://www.example.com/inventory"/>
</element>
</choice>
Legg Expires 20 April 2007 [Page 28]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</type>
If a DefinedType is a DummyReference, ParameterizedType or
ParameterizedValueSetType, then the translation of the Type is the
translation of that DummyReference, ParameterizedType or
ParameterizedValueSetType (see Section 5.9).
6.3. Translation of Predefined Types
If a Type is a BuiltinType or ReferencedType comprising one of the
productions in Table 1, then the translation of the Type is either
the attribute form or element form translation of that type.
The attribute form translation of a Type comprising of one of the
productions in Table 1 is an attribute item with the [local name]
"type". The [normalized value] of this attribute item is a qualified
name with the namespace name "urn:ietf:params:xml:ns:asnx" and the
local part as indicated in Table 1.
Table 1: Reference Names for Predefined Types
+------------------------------------+-------------------+
| ASN.1 Production | local part |
+====================================+===================+
| BitStringType | |
| without a NamedBitList | BIT-STRING |
+------------------------------------+-------------------+
| BooleanType | BOOLEAN |
| EmbeddedPDVType | EMBEDDED-PDV |
| ExternalType | EXTERNAL |
+------------------------------------+-------------------+
| IntegerType | |
| without a NamedNumberList | INTEGER |
+------------------------------------+-------------------+
| NullType | NULL |
| ObjectIdentifierType | OBJECT-IDENTIFIER |
| OctetStringType | OCTET-STRING |
| RealType | REAL |
| RelativeOIDType | RELATIVE-OID |
+------------------------------------+-------------------+
| CharacterStringType | |
| RestrictedCharacterStringType | |
| BMPString | BMPString |
| GeneralString | GeneralString |
| GraphicString | GraphicString |
| IA5String | IA5String |
| ISO646String | ISO646String |
| NumericString | NumericString |
Legg Expires 20 April 2007 [Page 29]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
| PrintableString | PrintableString |
| TeletexString | TeletexString |
| T61String | T61String |
| UniversalString | UniversalString |
| UTF8String | UTF8String |
| VideotexString | VideotexString |
| VisibleString | VisibleString |
+------------------------------------+-------------------+
| UnrestrictedCharacterStringType | CHARACTER-STRING |
+------------------------------------+-------------------+
| UsefulType | |
| GeneralizedTime | GeneralizedTime |
| UTCTime | UTCTime |
| ObjectDescriptor | ObjectDescriptor |
+------------------------------------+-------------------+
The element form translation of a Type comprising one of the
productions in Table 1 is an element item with the [local name]
"type". An attribute item with the [local name] "ref" SHALL be added
to the [attributes] of the <type> element item. The
[normalized value] of this attribute item is a qualified name with
the namespace name "urn:ietf:params:xml:ns:asnx" and the local part
as indicated in Table 1. An element item with the [local name]
"annotation" MAY be added to the [children] of the <type> element
item.
Example
BOOLEAN
<type ref="asnx:BOOLEAN"/>
Usually the translator is free to choose either the attribute form or
element form translation for a Type, however in some contexts
attribute forms for a Type are explicitly disallowed.
6.4. BitStringType Translation
The translation of a BitStringType with a NamedBitList is an element
item with the [local name] "type". An element item with the
[local name] "annotation" MAY be added to the [children] of the
<type> element item. An element item with the [local name]
"namedBitList" SHALL be appended to the [children] of the <type>
element item. The translation of each NamedBit in the NamedBitList
SHALL be appended to the [children] of the <namedBitList> element
item.
The translation of a NamedBit is an element item with the
Legg Expires 20 April 2007 [Page 30]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
[local name] "namedBit". An attribute item with the [local name]
"name" SHALL be added to the [attributes] of the <namedBit> element
item. If the BitStringType is subject to a VALUES encoding
instruction, then the [normalized value] of this attribute item is
the replacement name [RXEREI] for the identifier of the NamedBit,
otherwise it is the identifier of the NamedBit. If the BitStringType
is subject to a VALUES encoding instruction and the reduction of the
replacement name (see Section 6.1) is not the same as the identifier,
then an attribute item with the [local name] "identifier" SHALL be
added to the [attributes] of the <namedBit> element item, otherwise
an attribute item with the [local name] "identifier" MAY be added to
the [attributes] of the <namedBit> element item. The
[normalized value] of this attribute item is the identifier of the
NamedBit. An attribute item with the [local name] "bit" SHALL be
added to the [attributes] of the <namedBit> element item. The
[normalized value] of this attribute item is the digit string
representation of the integer value of the number or DefinedValue of
the NamedBit.
Examples
BIT STRING { zero(0), one(1), two(2) }
<type>
<namedBitList>
<namedBit name="zero" bit="0"/>
<namedBit name="one" bit="1"/>
<namedBit name="two" bit="2"/>
</namedBitList>
</type>
[RXER:VALUES ALL CAPITALIZED, wednesday AS "Midweek"]
BIT STRING {
monday(0), tuesday(1), wednesday(2),
thursday(3), friday(4)
}
<type>
<namedBitList>
<namedBit name="Monday" bit="0"/>
<namedBit name="Tuesday" bit="1"/>
<namedBit name="Midweek" identifier="wednesday" bit="2"/>
<namedBit name="Thursday" bit="3"/>
<namedBit name="Friday" bit="4"/>
</namedBitList>
</type>
6.5. IntegerType Translation
Legg Expires 20 April 2007 [Page 31]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The translation of an IntegerType with a NamedNumberList is an
element item with the [local name] "type". An element item with the
[local name] "annotation" MAY be added to the [children] of the
<type> element item. An element item with the [local name]
"namedNumberList" SHALL be appended to the [children] of the <type>
element item. The translation of each NamedNumber in the
NamedNumberList SHALL be appended to the [children] of the
<namedNumberList> element item.
The translation of a NamedNumber is an element item with the
[local name] "namedNumber". An attribute item with the [local name]
"name" SHALL be added to the [attributes] of the <namedNumber>
element item. If the IntegerType is subject to a VALUES encoding
instruction, then the [normalized value] of this attribute item is
the replacement name [RXEREI] for the identifier of the NamedNumber,
otherwise it is the identifier of the NamedNumber. If the
IntegerType is subject to a VALUES encoding instruction and the
reduction of the replacement name (see Section 6.1) is not the same
as the identifier, then an attribute item with the [local name]
"identifier" SHALL be added to the [attributes] of the <namedNumber>
element item, otherwise an attribute item with the [local name]
"identifier" MAY be added to the [attributes] of the <namedNumber>
element item. The [normalized value] of this attribute item is the
identifier of the NamedNumber. An attribute item with the
[local name] "number" SHALL be added to the [attributes] of the
<namedNumber> element item. The [normalized value] of this attribute
item is the digit string representation of the integer value of the
SignedNumber or DefinedValue of the NamedNumber.
Examples
INTEGER { nothing(0), a-little(1), a-lot(100) }
<type>
<namedNumberList>
<namedNumber name="nothing" number="0"/>
<namedNumber name="a-little" number="1"/>
<namedNumber name="a-lot" number="100"/>
</namedNumberList>
</type>
[RXER:VALUES ALL CAPITALIZED, very-high AS "DANGEROUS"]
INTEGER { low(25), medium(50), high(75), very-high(100) }
<type>
<namedNumberList>
<namedNumber name="Low" number="25"/>
<namedNumber name="Medium" number="50"/>
Legg Expires 20 April 2007 [Page 32]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<namedNumber name="High" number="75"/>
<namedNumber name="DANGEROUS" identifier="very-high"
number="100"/>
</namedNumberList>
</type>
6.6. EnumeratedType Translation
The translation of an EnumeratedType is an element item with the
[local name] "type". An element item with the [local name]
"annotation" MAY be added to the [children] of the <type> element
item. An element item with the [local name] "enumerated" SHALL be
appended to the [children] of the <type> element item. The
translation of each EnumerationItem in the RootEnumeration SHALL be
appended to the [children] of the <enumerated> element item.
If the ellipsis ("...") is present, then an element item with the
[local name] "extension" SHALL be appended to the [children] of the
<enumerated> element item, and the translation of the ExceptionSpec
(possibly empty) SHALL be added to the [children] of the <extension>
element item. If an AdditionalEnumeration is present, then the
translation of each EnumerationItem in the AdditionalEnumeration
SHALL be appended to the [children] of the <extension> element item.
The translation of an EnumerationItem is an element item with the
[local name] "enumeration".
If the EnumerationItem is of the "identifier" form, then an attribute
item with the [local name] "name" SHALL be added to the [attributes]
of the <enumeration> element item. If the EnumeratedType is subject
to a VALUES encoding instruction, then the [normalized value] of this
attribute item is the replacement name [RXEREI] for the identifier,
otherwise it is the identifier. If the EnumeratedType is subject to
a VALUES encoding instruction and the reduction of the replacement
name (see Section 6.1) is not the same as the identifier, then an
attribute item with the [local name] "identifier" SHALL be added to
the [attributes] of the <enumeration> element item, otherwise an
attribute item with the [local name] "identifier" MAY be added to the
[attributes] of the <enumeration> element item. The
[normalized value] of this attribute item is the identifier.
If the EnumerationItem is of the "NamedNumber" form, then an
attribute item with the [local name] "name" SHALL be added to the
[attributes] of the <enumeration> element item. If the
EnumeratedType is subject to a VALUES encoding instruction, then the
[normalized value] of this attribute item is the replacement name
[RXEREI] for the identifier of the NamedNumber, otherwise it is the
identifier of the NamedNumber. If the EnumeratedType is subject to a
Legg Expires 20 April 2007 [Page 33]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
VALUES encoding instruction and the reduction of the replacement name
is not the same as the identifier, then an attribute item with the
[local name] "identifier" SHALL be added to the [attributes] of the
<enumeration> element item, otherwise an attribute item with the
[local name] "identifier" MAY be added to the [attributes] of the
<enumeration> element item. The [normalized value] of this attribute
item is the identifier of the NamedNumber. An attribute item with
the [local name] "number" SHALL be added to the [attributes] of the
<enumeration> element item. The [normalized value] of this attribute
item is the digit string representation of the integer value of the
SignedNumber or DefinedValue of the NamedNumber.
Example
ENUMERATED { red(0), green(1), ..., blue(2) }
<type>
<enumerated>
<enumeration name="red" number="0"/>
<enumeration name="green" number="1"/>
<extension>
<enumeration name="blue" number="2"/>
</extension>
</enumerated>
</type>
[RXER:VALUES ALL CAPITALIZED, red AS "Crimson"]
ENUMERATED { red, yellow, green, blue }
<type>
<enumerated>
<enumeration name="Crimson" identifier="red"/>
<enumeration name="Yellow"/>
<enumeration name="Green"/>
<enumeration name="Blue"/>
</enumerated>
</type>
6.7. PrefixedType Translation
The translation of a PrefixedType [X.680-1] that is a TaggedType is
either the short form translation (Section 6.7.1) or long form
translation (Section 6.7.2) of the TaggedType.
Aside: The short form translation is provided because TaggedType
notation is heavily used in existing ASN.1 specifications. The
long form translation has the same structure as the translation of
an EncodingPrefixedType and can be simplified where there is a
Legg Expires 20 April 2007 [Page 34]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
series of nested PrefixedType instances.
If a PrefixedType is an EncodingPrefixedType and the
EncodingReference is RXER, or the EncodingReference is empty and the
default encoding reference [X.680-1] for the module is RXER, then the
translation of the PrefixedType is the translation of the Type in the
EncodingPrefixedType.
Aside: This is not suggesting that RXER encoding instructions are
ignored. Encoding instructions for RXER are not explicitly
represented in ASN.X, but rather affect how an ASN.1 specification
is translated into an ASN.X document (since the content of an
ASN.X document is also the RXER encoding of an abstract value of
the ModuleDefinition ASN.1 type in Appendix A). The individual
effects of RXER encoding instructions on the translation are
addressed in other parts of this specification. Encoding
instructions for other encoding rules have explicit
representations in ASN.X.
If a PrefixedType is an EncodingPrefixedType and the
EncodingReference is not RXER, or the EncodingReference is empty and
the default encoding reference for the module is not RXER, then the
translation of the PrefixedType is an element item with the
[local name] "prefixed". The translation of the EncodingPrefix in
the EncodingPrefixedType SHALL be added to the [children] of the
<prefixed> element item.
If the EncodingReference of an EncodingPrefix is not empty, then the
translation of the EncodingPrefix is an element item with the
encodingreference of the EncodingReference as the [local name]. The
translation of the EncodingInstruction in the EncodingPrefix SHALL be
added to the [children] of this element item.
If the EncodingReference of an EncodingPrefix is empty, then the
translation of the EncodingPrefix is an element item with the default
encoding reference for the module as the [local name]. The
translation of the EncodingInstruction in the EncodingPrefix SHALL be
added to the [children] of this element item.
The EncodingInstruction notation is different for each set of
encoding instructions, and their translations into ASN.X are
specified in separate documents [GSEREIT][XEREIT]. At the time of
writing, only three sets of encoding instructions have been defined
(for RXER [RXEREI], GSER [GSEREI] and EXTENDED-XER [X.693-1]).
If the child <type> element item of a <prefixed> element item has no
attribute items and has a child <prefixed> element item, then that
child <type> element item MAY be replaced by the [children] and
Legg Expires 20 April 2007 [Page 35]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
[attributes] of the inner <prefixed> element item. Note that the
long form translation of a TaggedType is also eligible for this
rewriting step. This rewriting step MAY be applied to the result of
a previous rewriting step if the necessary condition still holds.
Example
These three definitions are equivalent.
[XER:ATTRIBUTE] [XER:USE-UNION] [GSER:CHOICE-OF-STRINGS] CHOICE {
one PrintableString,
two UTF8String
}
<type>
<prefixed>
<XER><attribute/></XER>
<type>
<prefixed>
<XER><useUnion/></XER>
<type>
<prefixed>
<GSER><choiceOfStrings/></GSER>
<type>
<choice>
<element name="one" type="asnx:PrintableString"/>
<element name="two" type="asnx:UTF8String"/>
</choice>
</type>
</prefixed>
</type>
</prefixed>
</type>
</prefixed>
</type>
<type>
<prefixed>
<XER><attribute/></XER>
<XER><useUnion/></XER>
<GSER><choiceOfStrings/></GSER>
<choice>
<element name="one" type="asnx:PrintableString"/>
<element name="two" type="asnx:UTF8String"/>
</choice>
</prefixed>
</type>
Legg Expires 20 April 2007 [Page 36]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
6.7.1. Short Form TaggedType Translation
The short form translation of a TaggedType is an element item with
the [local name] "type". An element item with the [local name]
"annotation" MAY be added to the [children] of the <type> element
item. An element item with the [local name] "tagged" SHALL be
appended to the [children] of the <type> element item.
If the Class of the Tag in the TaggedType is not empty, then an
attribute item with the [local name] "tagClass" SHALL be added to the
[attributes] of the <tagged> element item. The [normalized value] of
this attribute item is the Class of the Tag, with all letters
downcased, i.e., either "universal", "application" or "private".
If the Tag is immediately followed by the "IMPLICIT" keyword, then an
attribute item with the [local name] "tagging" and [normalized value]
"implicit" SHALL be added to the [attributes] of the <tagged> element
item.
If the Tag is immediately followed by the "EXPLICIT" keyword, then an
attribute item with the [local name] "tagging" and [normalized value]
"explicit" SHALL be added to the [attributes] of the <tagged> element
item.
If the Tag is not immediately followed by either the "IMPLICIT" or
"EXPLICIT" keyword and the Type in the TaggedType is a
DummyReference, then an attribute item with the [local name]
"tagging" and [normalized value] "explicit" SHALL be added to the
[attributes] of the <tagged> element item.
The translation of the Type in the TaggedType SHALL be added to the
[children] or [attributes] of the <tagged> element item.
Examples
[0] INTEGER
<type>
<tagged number="0" type="asnx:INTEGER"/>
</type>
[APPLICATION 10] IMPLICIT BOOLEAN
<type>
<tagged tagClass="application" number="10" tagging="implicit"
type="asnx:BOOLEAN"/>
</type>
Legg Expires 20 April 2007 [Page 37]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
6.7.2. Long Form TaggedType Translation
The long form translation of a TaggedType is an element item with the
[local name] "type". An element item with the [local name]
"annotation" MAY be added to the [children] of the <type> element
item. An element item with the [local name] "prefixed" SHALL be
appended to the [children] of the <type> element item. The
translation of the Tag in the TaggedType SHALL be added to the
[children] of the <prefixed> element item.
The translation of a Tag is an element item with the [local name]
"TAG".
If the Class of the Tag is not empty, then an attribute item with the
[local name] "tagClass" SHALL be added to the [attributes] of the
<TAG> element item. The [normalized value] of this attribute item is
the Class of the Tag, with all letters downcased, i.e., either
"universal", "application" or "private".
If the Tag is immediately followed by the "IMPLICIT" keyword, then an
attribute item with the [local name] "tagging" and [normalized value]
"implicit" SHALL be added to the [attributes] of the <TAG> element
item.
If the Tag is immediately followed by the "EXPLICIT" keyword, then an
attribute item with the [local name] "tagging" and [normalized value]
"explicit" SHALL be added to the [attributes] of the <TAG> element
item.
If the Tag is not immediately followed by either the "IMPLICIT" or
"EXPLICIT" keyword and the Type in the TaggedType is a
DummyReference, then an attribute item with the [local name]
"tagging" and [normalized value] "explicit" SHALL be added to the
[attributes] of the <TAG> element item.
The translation of the Type in the TaggedType SHALL be added to the
[children] or [attributes] of the <prefixed> element item.
Examples
[0] INTEGER
<type>
<prefixed type="asnx:INTEGER">
<TAG number="0"/>
</prefixed>
</type>
Legg Expires 20 April 2007 [Page 38]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
[APPLICATION 10] IMPLICIT BOOLEAN
<type>
<prefixed type="asnx:BOOLEAN">
<TAG tagClass="application" number="10" tagging="implicit"/>
</prefixed>
</type>
6.8. SelectionType Translation
The translation of a SelectionType is an element item with the
[local name] "type". An element item with the [local name]
"annotation" MAY be added to the [children] of the <type> element
item. An element item with the [local name] "selection" SHALL be
appended to the [children] of the <type> element item.
The identifier in a SelectionType identifies a NamedType in the
definition of the Type in the SelectionType. The translation of that
NamedType will be an element item with the [local name] either
"attribute", "element", "group" or "member". An attribute item with
the same [local name] as the translation of the NamedType SHALL be
added to the [attributes] of the <selection> element item. The
[normalized value] of this attribute item is the RXER character data
translation of the effective name of the NamedType.
The translation of the Type in the SelectionType SHALL be added to
the [children] or [attributes] of the <selection> element item.
Example
field1 < MyChoiceType
<type>
<selection element="field1" type="tns:MyChoiceType"/>
</type>
field2 < CHOICE {
field2 [RXER:ATTRIBUTE][RXER:NAME AS "field-two"] INTEGER
}
<type>
<selection attribute="field-two">
<type>
<choice>
<attribute name="field-two" identifier="field2"
type="asnx:INTEGER"/>
</choice>
</type>
Legg Expires 20 April 2007 [Page 39]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</selection>
</type>
6.9. InstanceOfType Translation
The translation of an InstanceOfType is an element item with the
[local name] "type". An element item with the [local name]
"annotation" MAY be added to the [children] of the <type> element
item. An element item with the [local name] "instanceOf" SHALL be
appended to the [children] of the <type> element item. The
translation of the DefinedObjectClass in the InstanceOfType SHALL be
added to the [children] or [attributes] of the <instanceOf> element
item.
Example
INSTANCE OF TYPE-IDENTIFIER
<type>
<instanceOf class="asnx:TYPE-IDENTIFIER"/>
</type>
6.10. ObjectClassFieldType Translation
The translation of an ObjectClassFieldType is an element item with
the [local name] "type". An element item with the [local name]
"annotation" MAY be added to the [children] of the <type> element
item. An element item with the [local name] "fromClass" SHALL be
appended to the [children] of the <type> element item. The
translation of the DefinedObjectClass in the ObjectClassFieldType and
the translation of the FieldName (see Section 9.2.6) in the
ObjectClassFieldType SHALL be added to the [children] and/or
[attributes] of the <fromClass> element item.
Example
OPERATION.&Linked.&ArgumentType
<type>
<fromClass class="tns:OPERATION"
fieldName="Linked/ArgumentType"/>
</type>
6.11. TypeFromObject and ValueSetFromObjects Translation
The translation of a TypeFromObject or ValueSetFromObjects is an
element item with the [local name] "type". An element item with the
[local name] "annotation" MAY be added to the [children] of the
Legg Expires 20 April 2007 [Page 40]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<type> element item. An element item with the [local name]
"fromObjects" SHALL be appended to the [children] of the <type>
element item.
The translation of the ReferencedObjects in the TypeFromObject or
ValueSetFromObjects SHALL be added to the [children] or [attributes]
of the <fromObjects> element item.
The translation of the FieldName in the TypeFromObject or
ValueSetFromObjects SHALL be added to the [children] or [attributes]
of the <fromObjects> element item.
Example
invertMatrix.&Errors.&errorCode
<type>
<fromObjects object="tns:invertMatrix"
fieldName="Errors/errorCode"/>
</type>
6.12. Translation of Combining Types
This section details the translation of the ASN.1 combining types:
SET, SEQUENCE, CHOICE, SET OF and SEQUENCE OF. The combining type
definitions all make use of the NamedType notation.
6.12.1. NamedType Translation
A NamedType is translated in one of three ways depending on the
context. These are the normal translation, the member translation
and the item translation. These translations are not
interchangeable. One of the three will be explicitly invoked as part
of the translation of an enclosing combining type.
If a NamedType is subject to an ATTRIBUTE or ATTRIBUTE-REF encoding
instruction or subject to a COMPONENT-REF encoding instruction that
references a top-level NamedType that is subject to an ATTRIBUTE
encoding instruction, then the normal translation of the NamedType is
an element item with the [local name] "attribute", otherwise if the
NamedType is subject to a GROUP encoding instruction, then the normal
translation of the NamedType is an element item with the [local name]
"group", otherwise if the NamedType is subject to a SIMPLE-CONTENT
encoding instruction, then the normal translation of the NamedType is
an element item with the [local name] "simpleContent", otherwise the
normal translation of the NamedType is an element item with the
[local name] "element" or "component" (translator's choice).
Legg Expires 20 April 2007 [Page 41]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
Aside: The local names "element" and "component" are synonymous.
The "component" alternative is offered for specifying applications
that don't use RXER (except for the ASN.X specification itself, of
course), where referring to parts of an encoding as elements would
seem incongruous.
The member translation of a NamedType is an element item with the
[local name] "member".
The item translation of a NamedType is an element item with the
[local name] "item".
An element item with the [local name] "annotation" MAY be added to
the [children] of the <attribute>, <group>, <element>, <component>,
<member> or <item> element item.
Aside: A Namedtype for which the member or item translation is
invoked will never be subject to an ATTRIBUTE, ATTRIBUTE-REF,
COMPONENT-REF, GROUP or SIMPLE-CONTENT encoding instruction.
These encoding instructions are also mutually exclusive [RXEREI].
If a NamedType is subject to a TYPE-AS-VERSION encoding instruction,
then an attribute item with the [local name] "typeAsVersion" and
[normalized value] "true" or "1" SHALL be added to the <element> or
<component> element item. For the normal translation, if a NamedType
is not subject to an ATTRIBUTE, ATTRIBUTE-REF, COMPONENT-REF GROUP,
SIMPLE-CONTENT or TYPE-AS-VERSION encoding instruction, then an
attribute item with the [local name] "typeAsVersion" and
[normalized value] "false" or "0" MAY be added to the <element> or
<component> element item.
For the normal, member and item translations, if a NamedType is not
subject to an ATTRIBUTE-REF, COMPONENT-REF, ELEMENT-REF or
REF-AS-ELEMENT encoding instruction, then an attribute item with the
[local name] "name" SHALL be added to the [attributes] of the
<attribute>, <group>, <element>, <component>, <member> or <item>
element item. The [normalized value] of this attribute item is the
value of the local-name component of the effective name [RXEREI] of
the NamedType.
Aside: If there are no NAME, ATTRIBUTE-REF, COMPONENT_REF,
ELEMENT-REF or REF-AS-ELEMENT encoding instructions, then the
value of the local-name component of the effective name of a
NamedType is its identifier.
If the reduction of the local-name component (an NCName) of the
effective name of the NamedType is not the same as the identifier of
the NamedType, then an attribute item with the [local name]
Legg Expires 20 April 2007 [Page 42]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
"identifier" SHALL be added to the [attributes] of the <attribute>,
<group>, <element>, <component>, <member> or <item> element item.
otherwise an attribute item with the [local name] "identifier" MAY be
added to the [attributes] of the aforementioned element item. The
[normalized value] of this attribute item is the identifier of the
NamedType.
If a NamedType is subject to a COMPONENT-REF encoding instruction,
then an attribute item with the [local name] "ref" SHALL be added to
the [attributes] of the <attribute>, <element> or <component> element
item. The [normalized value] of this attribute item is the RXER
character data translation of the effective name of the top-level
NamedType referenced by the encoding instruction. If the effective
name is not distinct with respect to the current module and the
modules referenced by its <import> element items (see Section 5.1),
then an attribute item with the [local name] "context" SHALL be added
to the [attributes] of the <attribute>, <element> or <component>
element item, otherwise if the module containing the referenced
top-level NamedType has a schema identity URI, then an attribute item
with the [local name] "context" MAY be added to the [attributes] of
the <attribute>, <element> or <component> element item. The
[normalized value] of this attribute item is the schema identity URI
of the module containing the referenced top-level NamedType.
Aside: If an effective name is not distinct, then the module
containing the referenced top-level NamedType must have a schema
identity URI (see Section 5.1).
If a NamedType is subject to a COMPONENT-REF encoding instruction,
then an attribute item with the [local name] "embedded" and
[normalized value] "false" or "0" MAY be added to the [attributes] of
the <attribute>, <element> or <component> element item.
If a NamedType is subject to an ATTRIBUTE-REF or ELEMENT-REF encoding
instruction, then an attribute item with the [local name] "ref" SHALL
be added to the [attributes] of the <attribute>, <element> or
<component> element item. The [normalized value] of this attribute
item is the RXER character data translation of the QNameValue from
the encoding instruction. An attribute item with the [local name]
"embedded" and [normalized value] "true" or "1" MUST be added to the
[attributes] of the <attribute>, <element> or <component> element
item.
If a NamedType is subject to a REF-AS-ELEMENT encoding instruction,
then an attribute item with the [local name] "elementType" SHALL be
added to the [attributes] of the <element> or <component> element
item. The [normalized value] of this attribute item is the RXER
character data translation of the NameValue from the REF-AS-ELEMENT
Legg Expires 20 April 2007 [Page 43]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
encoding instruction. If the Namespace is present in the
REF-AS-ELEMENT encoding instruction, then an attribute item with the
[local name] "namespace" SHALL be added to the [attributes] of the
<element> or <component> element item. The [normalized value] of
this attribute item is the string value of the AnyURIValue in the
Namespace.
If the ContextParameter is present in the RefParameters in the
ATTRIBUTE-REF, ELEMENT-REF or REF-AS-ELEMENT encoding instruction,
then an attribute item with the [local name] "context" SHALL be added
to the [attributes] of the <attribute>, <element> or <component>
element item. The [normalized value] of this attribute item is the
string value of the AnyURIValue in the ContextParameter.
If a NamedType is subject to an ATTRIBUTE encoding instruction and a
VERSION-INDICATOR encoding instruction, then an attribute item with
the [local name] "versionIndicator" and [normalized value] "true" or
"1" SHALL be added to the <attribute> element item. If a NamedType
is subject to an ATTRIBUTE encoding instruction and not subject to a
VERSION-INDICATOR encoding instruction, then an attribute item with
the [local name] "versionIndicator" and [normalized value] "false" or
"0" MAY be added to the <attribute> element item.
If a NamedType is not subject to an ATTRIBUTE-REF, COMPONENT-REF,
ELEMENT-REF or REF-AS-ELEMENT encoding instruction, then the
translation of the Type in the NamedType SHALL be added to the
[children] or [attributes] of the <attribute>, <group>, <element>,
<component>, <member> or <item> element item. If the enclosing
combining type is a SEQUENCE, SET or CHOICE type and the Type in the
NamedType is a DummyReference and the TagDefault for the module
containing the NamedType is "AUTOMATIC TAGS", then an attribute form
translation of the Type in the NamedType SHALL NOT be used, and an
attribute item with the [local name] "explicit" and
[normalized value] "true" or "1" SHALL be added to the [attributes]
of the <type> element item resulting from the translation of the Type
in the NamedType. Where the automatic tagging transformation applies
[X.680], this attribute item indicates that explicit tagging applies
to the Type in the NamedType instead of the usual implicit tagging.
If a NamedType is subject to an ATTRIBUTE-REF, COMPONENT-REF,
ELEMENT-REF or REF-AS-ELEMENT encoding instruction, then the
translation of each EncodingPrefix (Section 6.7) and Tag
(Section 6.7.2) textually within the NamedType SHALL be added in
order to the [children] of the <attribute>, <element> or <component>
element item.
Example
Legg Expires 20 April 2007 [Page 44]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
CHOICE {
one INTEGER,
two [RXER:ATTRIBUTE] BOOLEAN,
three [RXER:ATTRIBUTE-REF
{ namespace-name "http://www.example.com/schema",
local-name "foo" }]
UTF8String,
bar [RXER:ELEMENT-REF
{ namespace-name "http://www.example.com/schema",
local-name "bar" }]
Markup,
five [0] [RXER:REF-AS-ELEMENT "product"
CONTEXT "http://www.example.com/inventory"]
Markup,
six [RXER:GROUP] MySequence
}
<type>
<choice xmlns:ex="http://www.example.com/schema">
<element name="one" type="asnx:INTEGER"/>
<attribute name="two" type="asnx:BOOLEAN"/>
<attribute ref="ex:foo" identifier="three" embedded="true"/>
<element ref="ex:bar" embedded="true"/>
<element elementType="product"
context="http://www.example.com/inventory"
identifier="five">
<TAG number="0"/>
</element>
<group name="six" type="tns:MySequence"/>
</choice>
</type>
6.12.2. SequenceType Translation
The translation of a SequenceType is an element item with the
[local name] "type". An element item with the [local name]
"annotation" MAY be added to the [children] of the <type> element
item. An element item with the [local name] "sequence" SHALL be
appended to the [children] of the <type> element item. The
translation of each ComponentType in the ComponentTypeList of the
initial RootComponentTypeList, if present, SHALL be appended to the
[children] of the <sequence> element item.
If the ExtensionAndException is present, then an element item with
the [local name] "extension" SHALL be appended to the [children] of
the <sequence> element item, and the translation of the ExceptionSpec
(possibly empty) SHALL be added to the [children] of the <extension>
element item.
Legg Expires 20 April 2007 [Page 45]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The translation of each ExtensionAdditionGroup or ComponentType
nested in the ExtensionAdditions (if any) SHALL be appended to the
[children] of the <extension> element item.
If the ExtensionEndMarker is present, then the translation of each
ComponentType in the final RootComponentTypeList SHALL be appended to
the [children] of the <sequence> element item.
The translation of an ExtensionAdditionGroup is an element item with
the [local name] "extensionGroup". If the VersionNumber is present,
then an attribute item with the [local name] "version" SHALL be added
to the [attributes] of the <extensionGroup> element item. The
[normalized value] of this attribute item is the number of the
VersionNumber. The translation of each ComponentType in the
ExtensionAdditionGroup SHALL be appended to the [children] of the
<extensionGroup> element item.
The translation of a ComponentType of the "NamedType" form is the
normal translation of the NamedType.
The translation of a ComponentType of the "NamedType OPTIONAL" form
is an element item with the [local name] "optional". The normal
translation of the NamedType SHALL be added to the [children] of the
<optional> element item.
The translation of a ComponentType of the "NamedType DEFAULT Value"
form is an element item with the [local name] "optional". The normal
translation of the NamedType SHALL be added to the [children] of the
<optional> element item. An element item with the [local name]
"default" SHALL be appended to the [children] of the <optional>
element item. The translation of the Value SHALL be added to the
[children] or [attributes] of the <default> element item.
The translation of a ComponentType of the "COMPONENTS OF Type" form
is an element item with the [local name] "componentsOf". The
translation of the Type SHALL be added to the [children] or
[attributes] of the <componentsOf> element item.
Example
SEQUENCE {
one INTEGER,
two [RXER:ATTRIBUTE] BOOLEAN OPTIONAL,
...,
[[ 2:
four NULL
]],
COMPONENTS OF MySequence,
Legg Expires 20 April 2007 [Page 46]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
...,
three PrintableString DEFAULT "third"
}
<type>
<sequence>
<element name="one" type="asnx:INTEGER"/>
<optional>
<attribute name="two" type="asnx:BOOLEAN"/>
</optional>
<extension>
<extensionGroup version="2">
<element name="four" type="asnx:NULL"/>
</extensionGroup>
<componentsOf type="tns:MySequence"/>
</extension>
<optional>
<element name="three" type="asnx:PrintableString"/>
<default literalValue="third"/>
</optional>
</sequence>
</type>
6.12.3. SetType Translation
The translation of a SetType follows the same procedure as a
SequenceType except that SetType replaces SequenceType, "SET"
replaces "SEQUENCE", and the [local name] "set" is used instead of
"sequence".
6.12.4. ChoiceType Translation
The translation of a ChoiceType that is not subject to a UNION
encoding instruction is an element item with the [local name] "type".
An element item with the [local name] "annotation" MAY be added to
the [children] of the <type> element item. An element item with the
[local name] "choice" SHALL be appended to the [children] of the
<type> element item. The normal translation of each NamedType in the
AlternativeTypeList in the RootAlternativeTypeList SHALL be appended
to the [children] of the <choice> element item.
If the ExtensionAndException is present, then an element item with
the [local name] "extension" is appended to the [children] of the
<choice> element item, and the translation of the ExceptionSpec
(possibly empty) is added to the [children] of the <extension>
element item.
The translation of each ExtensionAdditionAlternativesGroup or
Legg Expires 20 April 2007 [Page 47]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
NamedType in the ExtensionAdditionAlternatives (if any) SHALL be
appended to the [children] of the <extension> element item. The
normal translation of the NamedType is used.
The translation of an ExtensionAdditionAlternativesGroup is an
element item with the [local name] "extensionGroup". If the
VersionNumber is present, then an attribute item with the
[local name] "version" SHALL be added to the [attributes] of the
<extensionGroup> element item. The [normalized value] of this
attribute item is the number of the VersionNumber. The normal
translation of each NamedType in the
ExtensionAdditionAlternativesGroup SHALL be appended to the
[children] of the <extensionGroup> element item.
Example
CHOICE {
one INTEGER,
two [RXER:NAME AS "Two"] BOOLEAN,
...,
[[ 2:
three NULL
]],
four PrintableString,
...
}
<type>
<choice>
<element name="one" type="asnx:INTEGER"/>
<element name="Two" type="asnx:BOOLEAN"/>
<extension>
<extensionGroup version="2">
<element name="three" type="asnx:NULL"/>
</extensionGroup>
<element name="four" type="asnx:PrintableString"/>
</extension>
</choice>
</type>
6.12.5. Translation of UNION Types
The translation of a ChoiceType that is subject to a UNION encoding
instruction follows the same procedure as a ChoiceType that is not
subject to a UNION encoding instruction except that the [local name]
"union" is used instead of "choice", and the member translation of
each NamedType is used instead of the normal translation.
Legg Expires 20 April 2007 [Page 48]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
In addition, if the UNION encoding instruction has a PrecedenceList,
then an attribute item with the [local name] "precedence" SHALL be
added to the [attributes] of the <union> element item. The
[normalized value] of this attribute item is the white space
separated list of the RXER character data translations of the
effective names [RXEREI] of the NamedType instances corresponding to
the identifiers in the PrecedenceList.
Example
[RXER:UNION PRECEDENCE utf8 visible] CHOICE {
printable PrintableString,
teletex TeletexString,
visible [RXER:NAME AS "ascii"] VisibleString,
...,
utf8 UTF8String
}
<type>
<union precedence="utf8 ascii">
<member name="printable" type="asnx:PrintableString"/>
<member name="teletex" type="asnx:TeletexString"/>
<member name="ascii" identifier="visible"
type="asnx:VisibleString"/>
<extension>
<member name="utf8" type="asnx:UTF8String"/>
</extension>
</union>
</type>
6.12.6. SequenceOfType Translation
The translation of a SequenceOfType that is not subject to a LIST
encoding instruction is an element item with the [local name] "type".
An element item with the [local name] "annotation" MAY be added to
the [children] of the <type> element item. An element item with the
[local name] "sequenceOf" SHALL be appended to the [children] of the
<type> element item.
If the SequenceOfType is of the "SEQUENCE OF NamedType" form, then
the normal translation of the NamedType SHALL be added to the
[children] of the <sequenceOf> element item.
If the SequenceOfType is of the "SEQUENCE OF Type" form, then an
element item with the [local name] "element" or "component"
(translator's choice) SHALL be added to the [children] of the <type>
element item. An attribute item with the [local name] "name" and
[normalized value] "item" SHALL be added to the [attributes] of the
Legg Expires 20 April 2007 [Page 49]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<element> or <component> element item. An attribute item with the
[local name] "identifier" and empty [normalized value] SHALL be added
to the [attributes] of the <element> or <component> element item.
The translation of the Type SHALL be added to the [children] or
[attributes] of the <element> or <component> element item.
Examples
SEQUENCE OF INTEGER
<type>
<sequenceOf>
<element name="item" identifier="" type="asnx:INTEGER"/>
</sequenceOf>
</type>
SEQUENCE OF counter INTEGER
<type>
<sequenceOf>
<element name="counter" type="asnx:INTEGER"/>
</sequenceOf>
</type>
6.12.7. Translation of LIST Types
The translation of a SequenceOfType that is subject to a LIST
encoding instruction is an element item with the [local name] "type".
An element item with the [local name] "annotation" MAY be added to
the [children] of the <type> element item. An element item with the
[local name] "list" SHALL be appended to the [children] of the <type>
element item. The item translation of the NamedType SHALL be added
to the [children] of the <list> element item.
Aside: SequenceOfType is necessarily of the
"SEQUENCE OF NamedType" form for a LIST encoding instruction.
Example
[RXER:LIST] SEQUENCE OF number INTEGER
<type>
<list>
<item name="number" type="asnx:INTEGER"/>
</list>
</type>
6.12.8. SetOfType Translation
Legg Expires 20 April 2007 [Page 50]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The translation of a SetOfType follows the same procedure as a
SequenceOfType except that SetOfType replaces SequenceOfType, "SET"
replaces "SEQUENCE", and the [local name] "setOf" is used instead of
"sequenceOf".
6.12.9. Insertion Encoding Instructions
If a Type is subject to a NO-INSERTIONS, HOLLOW-INSERTIONS,
SINGULAR-INSERTIONS, UNIFORM-INSERTIONS or MULTIFORM-INSERTIONS
encoding instruction, then an attribute item with the [local name]
"insertions" SHALL be added to the [attributes] of the <choice>,
<sequence> or <set> element item in the [children] of the <type>
element item resulting from the translation of the Type. The
[normalized value] of this attribute item is "none" in the case of a
NO-INSERTIONS encoding instruction, "hollow" in the case of a
HOLLOW-INSERTIONS encoding instruction, "singular" in the case of a
SINGULAR-INSERTIONS encoding instruction, "uniform" in the case of a
UNIFORM-INSERTIONS encoding instruction, and "multiform" in the case
of a MULTIFORM-INSERTIONS encoding instruction.
Example
[NO-INSERTIONS] CHOICE {
one [RXER:GROUP] [RXER:SINGULAR-INSERTIONS] CHOICE {
two INTEGER,
...
},
...
}
<type>
<choice insertions="none">
<group name="one">
<type>
<choice insertions="singular">
<element name="two" type="asnx:INTEGER"/>
<extension/>
</choice>
</type>
</group>
<extension/>
</choice>
</type>
6.13. Translation of Constrained Types
If a ConstrainedType is of the "Type Constraint" form, then the
translation of the ConstrainedType is an element item with the
Legg Expires 20 April 2007 [Page 51]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
[local name] "type". An element item with the [local name]
"annotation" MAY be added to the [children] of the <type> element
item. An element item with the [local name] "constrained" SHALL be
appended to the [children] of the <type> element item. The
translation of the Type SHALL be added to the [children] or
[attributes] of the <constrained> element item. The translation of
the Constraint SHALL be added to the [children] of the <constrained>
element item.
The translation of a ContainedType that is a TypeWithConstraint is
the translation of the TypeWithConstraint.
Definition (simple endpoint): A LowerEndpoint or UpperEndpoint is a
simple endpoint if it is closed and its value is "MIN", "MAX" or a
SignedNumber in an IntegerValue in a BuiltinValue in the Value of the
endpoint.
Definition (simple range SizeContraint): A SizeConstraint is a simple
range if the Constraint in the SizeConstraint contains only a
ValueRange (i.e., a ValueRange in a SubtypeElements in an Elements in
a single IntersectionElements in a single Intersections in a Unions
in an ElementSetSpec in a lone RootElementSetSpec in an
ElementSetSpecs in a SubtypeConstraint in a lone ConstraintSpec in
the Constraint) and both endpoints are simple.
Definition (simple range Contraint): A Constraint is a simple range
if contains only a SizeConstraint that is a simple range (i.e., a
simple range SizeConstraint in a SubtypeElements in an Elements in a
single IntersectionElements in a single Intersections in a Unions in
an ElementSetSpec in a lone RootElementSetSpec in an ElementSetSpecs
in a SubtypeConstraint in a lone ConstraintSpec in the Constraint).
If the Constraint or SizeConstraint in a TypeWithConstraint is a
simple range, then the compact translation of the TypeWithConstraint
MAY be used, otherwise the full translation of the TypeWithConstraint
is used.
The compact translation of a TypeWithConstraint is the translation of
the parent type. If the value of the lower endpoint is not "MIN" or
"0", then an attribute item with the [local name] "minSize" SHALL be
added to the [attributes] of the <sequenceOf>, <setOf> or <list>
element item from the translation of the parent type. The
[normalized value] of this attribute item is the value of the lower
endpoint. If the value of the lower endpoint is "MIN" or "0", then
an attribute item with the [local name] "minSize" and
[normalized value] "0" MAY be added to the [attributes] of the
<sequenceOf>, <setOf> or <list> element item. If the value of the
upper endpoint is not "MAX", then an attribute item with the
Legg Expires 20 April 2007 [Page 52]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
[local name] "maxSize" SHALL be added to the [attributes] of the
<sequenceOf>, <setOf> or <list> element item. The [normalized value]
of this attribute item is the value of the upper endpoint.
The full translation of a TypeWithConstraint is an element item with
the [local name] "type". An element item with the [local name]
"annotation" MAY be added to the [children] of the <type> element
item. An element item with the [local name] "constrained" SHALL be
appended to the [children] of the <type> element item. The
translation of the parent type SHALL be added to the [children] or
[attributes] of the <constrained> element item. The translation of
the Constraint or SizeConstraint SHALL be added to the [children] of
the <constrained> element item.
Examples
SEQUENCE (SIZE(1..MAX)) OF number INTEGER
<type>
<sequenceOf minSize="1">
<element name="number" type="asnx:INTEGER"/>
</sequenceOf>
</type>
SEQUENCE SIZE(0..10) OF number INTEGER
<type>
<sequenceOf maxSize="10">
<element name="number" type="asnx:INTEGER"/>
</sequenceOf>
</type>
SEQUENCE SIZE(1..limit) OF number INTEGER
<type>
<constrained>
<type>
<sequenceOf>
<element name="number" type="asnx:INTEGER"/>
</sequenceOf>
</type>
<size>
<range>
<minInclusive literalValue="1"/>
<maxInclusive value="tns:limit"/>
</range>
</size>
</constrained>
Legg Expires 20 April 2007 [Page 53]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</type>
6.13.1. Constraint Translation
The translation of a Constraint is the translation of the
ConstraintSpec followed by the translation of the ExceptionSpec
(possibly empty).
The translation of a ConstraintSpec is the translation of the
contained SubtypeConstraint or GeneralConstraint.
The translation of a SubtypeConstraint is the translation of the
contained ElementSetSpecs.
The translation of a GeneralConstraint is the translation of the
contained UserDefinedConstraint, TableConstraint or
ContentsConstraint.
6.13.2. UserDefinedConstraint Translation
The translation of a UserDefinedConstraint is an element item with
the [local name] "constrainedBy". An element item with the
[local name] "annotation" MAY be added to the [children] of the
<constrainedBy> element item. The translation of each
UserDefinedConstraintParameter SHALL be appended to the [children] of
the <constrainedBy> element item.
The translation of a UserDefinedConstraintParameter of the
"Governor : Value" form is an element item with the [local name]
"valueParameter". The translation of the Type in the Governor and
the translation of the Value SHALL be added to the [children] and/or
[attributes] of the <valueParameter> element item.
The translation of a UserDefinedConstraintParameter of the
"Governor : ValueSet" form is an element item with the [local name]
"valueSetParameter". The translation of the Type in the Governor
SHALL be added to the [children] or [attributes] of the
<valueSetParameter> element item. The translation of the ValueSet
SHALL be added to the [children] of the <valueSetParameter> element
item.
The translation of a UserDefinedConstraintParameter of the
"Governor : Object" form is an element item with the [local name]
"objectParameter". The translation of the DefinedObjectClass in the
Governor and the translation of the Object SHALL be added to the
[children] and/or [attributes] of the <objectParameter> element item.
The translation of a UserDefinedConstraintParameter of the
Legg Expires 20 April 2007 [Page 54]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
"Governor : ObjectSet" form is an element item with the [local name]
"objectSetParameter". The translation of the DefinedObjectClass in
the Governor and the translation of the ObjectSet SHALL be added to
the [children] and/or [attributes] of the <objectSetParameter>
element item.
The translation of a UserDefinedConstraintParameter that is a Type is
an element item with the [local name] "typeParameter". The
translation of the Type SHALL be added to the [children] or
[attributes] of the <typeParameter> element item.
The translation of a UserDefinedConstraintParameter that is a
DefinedObjectClass is an element item with the [local name]
"classParameter". The translation of the DefinedObjectClass SHALL be
added to the [children] or [attributes] of the <classParameter>
element item.
Example
OCTET STRING
(CONSTRAINED BY {
-- contains the hash of the value -- MyType:myValue })
<type>
<constrained type="asnx:OCTET-STRING">
<constrainedBy>
<annotation> contains the hash of the value </annotation>
<valueParameter type="tns:MyType" value="tns:myValue"/>
</constrainedBy>
</constrained>
</type>
6.13.3. TableConstraint Translation
The translation of a TableConstraint that is a SimpleTableConstraint
is an element item with the [local name] "table". The translation of
the ObjectSet in the SimpleTableConstraint SHALL be added to the
[children] or [attributes] of the <table> element item.
The translation of a TableConstraint that is a
ComponentRelationConstraint is an element item with the [local name]
"table". The translation of the DefinedObjectSet in the
ComponentRelationConstraint SHALL be added to the [children] or
[attributes] of the <table> element item. The translation of each
AtNotation SHALL be appended to the [children] of the <table> element
item.
The translation of an AtNotation is an element item with the
Legg Expires 20 April 2007 [Page 55]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
[local name] "restrictBy". The [children] property of the
<restrictBy> element item is set to the sequence of character items
for the character string formed by the concatenation of zero, one or
more "../" strings, one for each Level in the AtNotation (including
the empty one), followed by a "/" (U+002F) separated list of the RXER
character data translations of the effective names [RXEREI] of the
NamedType instances identified by the ComponentIdList identifiers.
If a NamedType is subject to an ATTRIBUTE or ATTRIBUTE-REF encoding
instruction, or subject to a COMPONENT-REF encoding instruction that
references a top-level NamedType that is subject to an ATTRIBUTE
encoding instruction, then the translation of the effective name is
prefixed with the "@" (U+0040) character. Leading and/or trailing
white space character items MAY be added to the [children] of the
<restrictBy> element item. White space character items MAY be added
immediately before and/or after any character item for the "/"
character.
Examples
ERROR.&Type({Errors}{@severity,@...errorId})
<type>
<constrained>
<type>
<fromClass class="tns:ERROR" fieldName="Type"/>
</type>
<table objectset="tns:Errors">
<restrictBy>severity</restrictBy>
<restrictBy>../../../errorId</restrictBy>
</table>
</constrained>
</type>
SEQUENCE {
iD [RXER:NAME AS "ID"] [RXER:ATTRIBUTE]
TYPE-IDENTIFIER.&id({AllTypes}),
value TYPE-IDENTIFIER.&Type({AllTypes}{@iD})
}
<type>
<sequence>
<attribute name="ID">
<type>
<constrained>
<type>
<fromClass class="asnx:TYPE-IDENTIFIER" fieldName="id"/>
</type>
<table objectset="tns:AllTypes"/>
Legg Expires 20 April 2007 [Page 56]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</constrained>
</type>
</attribute>
<element name="value">
<type>
<constrained>
<type>
<fromClass class="asnx:TYPE-IDENTIFIER" fieldName="Type"/>
</type>
<table objectset="tns:AllTypes">
<restrictBy>@ID</restrictBy>
</table>
</constrained>
</type>
</element>
</sequence>
</type>
The <restrictBy> element item is required to be self-contained
[RXER].
Aside: An element item is self-contained if all namespace prefixes
used by the element item and its contents are declared within the
element item.
6.13.4. ContentsConstraint Translation
The translation of a ContentsConstraint is an element item with the
[local name] "contents".
If the ContentsConstraint is of the "CONTAINING Type" form, then an
element item with the [local name] "containing" SHALL be added to the
[children] of the <contents> element item. The translation of the
Type SHALL be added to the [children] or [attributes] of the
<containing> element item.
If the ContentsConstraint is of the "ENCODED BY Value" form, then an
element item with the [local name] "encodedBy" SHALL be added to the
[children] of the <contents> element item. The translation of the
Value SHALL be added to the [children] or [attributes] of the
<encodedBy> element item.
If the ContentsConstraint is of the
"CONTAINING Type ENCODED BY Value" form, then an element item with
the [local name] "containing" and an element item with the
[local name] "encodedBy" SHALL be added to the [children] of the
<contents> element item. The translation of the Type SHALL be added
to the [children] or [attributes] of the <containing> element item.
Legg Expires 20 April 2007 [Page 57]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The translation of the Value SHALL be added to the [children] or
[attributes] of the <encodedBy> element item.
Example
OCTET STRING
(CONTAINING MyType
ENCODED BY { joint-iso-itu-t asn1(1) basic-encoding(1) })
<type>
<constrained type="asnx:OCTET-STRING">
<contents>
<containing type="tns:MyType/>
<encodedBy literalValue="2.1.1"/>
</contents>
</constrained>
</type>
6.13.5. ExceptionSpec Translation
The translation of an empty ExceptionSpec is empty.
The translation of a non-empty ExceptionSpec is an element item with
the [local name] "exception".
If the ExceptionSpec is a SignedNumber, then the translation of a
notional INTEGER Type and the translation of a notional Value of the
INTEGER type with the IntegerValue of SignedNumber SHALL be added to
the [children] and/or [attributes] of the <exception> element item.
If the ExceptionSpec is a DefinedValue, then the translation of a
notional INTEGER Type and the translation of the DefinedValue SHALL
be added to the [children] and/or [attributes] of the <exception>
element item.
If the ExceptionSpec is of the "Type : Value" form, then the
translation of the Type and the translation of the Value SHALL be
added to the [children] and/or [attributes] of the <exception>
element item.
Examples
!10
<exception type="asnx:INTEGER" literalValue="10"/>
!myValue
Legg Expires 20 April 2007 [Page 58]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<exception type="asnx:INTEGER" value="tns:myValue"/>
!PrintableString:"failure"
<exception type="asnx:PrintableString" literalValue="failure"/>
7. Translation of Values
A Value in an ASN.1 specification is a mix of literal values (e.g.,
numbers and character strings) and notations for referencing defined
values. Likewise, the ASN.X translation of a Value is a mix of
markup for literal values and markup for referencing notations
(notational values). A Value is categorized by the following
definitions.
Definition (literal value): A Value is a literal value if and only if
it is not a notational value.
Definition (notational value): A Value is a notational value if and
only if:
(a) the Value is a BuiltinValue, and
(1) the BuiltinValue is a TaggedValue and the Value in the
TaggedValue is a notational value, or
(2) the BuiltinValue is a SequenceValue or SetValue and the
ComponentValueList of the SequenceValue or SetValue contains
a NamedValue where the translation of the corresponding
NamedType (from the governing type of the Value) is not an
<element> or <component> element item and the Value of the
NamedValue is a notational value, or
(3) the BuiltinValue is a ChoiceValue where the translation of
the NamedType corresponding to the identifier of the
ChoiceValue is not an <element> or <component> element item
and the Value of the ChoiceValue is a notational value, or
(4) the BuiltinValue is a SequenceOfValue with a NamedValueList
that contains a NamedValue where the translation of the
corresponding NamedType (from the governing type of the
Value) is not an <element> or <component> element item and
the Value of the NamedValue is a notational value, or
(b) the Value is a ReferencedValue, and
(1) the ReferencedValue is a ValueFromObject, or
Legg Expires 20 April 2007 [Page 59]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
(2) the ReferencedValue is a DefinedValue, and
(i) the DefinedValue is a valuereference (not a
DummyReference) or an ExternalValueReference, or
(ii) the DefinedValue is a DummyReference or
ParameterizedValue and the substitute definition for
the DummyReference or ParameterizedValue is a
notational value (see Section 5.9), or
(iii) the DefinedValue is a DummyReference or
ParameterizedValue where the translation of the
DummyReference or ParameterizedValue will use a fully
expanded reference (see Section 5.9), or
(c) the Value is an ObjectClassFieldValue, and
(1) the ObjectClassFieldValue is an OpenTypeFieldVal, or
(2) the ObjectClassFieldValue is a FixedTypeFieldVal, and
(i) the FixedTypeFieldVal is a BuiltinValue that satisfies
case (a), or
(ii) the FixedTypeFieldVal is a ReferencedValue that
satisfies case (b).
A literal value that is a BuiltinValue that is a SequenceValue,
SetValue, ChoiceValue, SequenceOfValue or SetOfValue MAY be
translated as a notational value.
Definition (directly nested): A notational value is directly nested
(within a literal value) if the innermost enclosing Value is a
literal value.
7.1. Translation of Literal Values
The translation of a literal value is either the attribute form
translation of a literal value, or the element form translation of a
literal value.
The attribute form translation of a literal value is an attribute
item with the [local name] "literalValue" whose [normalized value] is
the RXER character data translation [RXER] of the Value.
The attribute form translation of a literal value SHALL NOT be used
if:
Legg Expires 20 April 2007 [Page 60]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
(a) the RXER Infoset translation of the Value is not a character data
translation [RXER] or is a character data translation that
contains qualified names [XMLNS10], or
(b) attribute forms of Value have been explicitly disallowed, or
(c) the Value has a nested notational value.
The element form translation of a literal value is an element item
with the [local name] "literalValue" whose [children] and
[attributes] are the RXER Infoset translation of the Value, except
that a value of the EXTERNAL type (or a subtype thereof) is
translated according to the associated type defined in Clause 34.5 of
X.680 [X.680]. In addition, where the [children] and [attributes] of
an element item in the translation correspond to a directly nested
notational value, the translation specified in Section 7.2. MUST be
used for the [children] and [attributes] of that element item, and an
attribute item with the [local name] "literal", [namespace name]
"urn:ietf:params:xml:ns:asnx" and [normalized value] "false" or "0"
(e.g., asnx:literal="false") MUST be added to the [attributes] of
that element item.
Each outermost <literalValue> element item, and each nested element
item that corresponds to a top-level NamedType from a module with a
target namespace, is required to be self-contained [RXER].
Aside: An element item is self-contained if all namespace prefixes
used by the element item and its contents are declared within the
element item.
Aside: A <literalValue> element item nested within another
<literalValue> element item is not required to be self-contained.
An attribute item with the [local name] "literal", [namespace name]
"urn:ietf:params:xml:ns:asnx" and [normalized value] "true" or "1"
(e.g., asnx:literal="true") MAY be added to the [attributes] of the
<literalValue> element item and/or any nested element item whose
content and attributes correspond to a literal value.
Aside: The asnx:literal attribute operates as a switch that
indicates whether the content and other attributes of the element
containing the attribute are interpreted as ASN.X notation (a
notational value) or as an RXER encoding (a literal value).
From the perspective of an ASN.X document as the RXER encoding of an
abstract value of the ModuleDefinition type in Appendix A, the type
of the <literalValue> element is unconstrained Markup [RXER], not the
governing type of the Value. This means that the Infoset
Legg Expires 20 April 2007 [Page 61]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
representation of the <literalValue> element must be preserved in
re-encodings of the ASN.X document.
Similarly, the type of the literalValue attribute is a UTF8String,
not the governing type of the Value. This means that the exact
characters of the [normalized value] of the attribute must be
preserved in re-encodings of the ASN.X document.
7.2. Translation of Notational Values
The translation of a notational value is the translation of either a
BuiltinValue, a ReferencedValue or an ObjectClassFieldValue.
The translation of a ReferencedValue is the translation of either a
DefinedValue or a ValueFromObject.
The translation for each these cases is described as creating an
element item with the [local name] "value", which is appropriate for
a notational value that stands on its own. However, a notational
value may also be directly nested within a literal value, in which
case the [local name] will be determined according to RXER and the
governing ASN.1 type of the enclosing literal value.
Aside: In the latter case the element item will also have a
literal attribute item with the [normalized value] "false" or "0".
A notational value that is not directly nested within a literal value
MAY instead have the [local name] "literalValue" provided an
attribute item with the [local name] "literal", [namespace name]
"urn:ietf:params:xml:ns:asnx" and [normalized value] "false" or "0"
is added to the [attributes] of the <literalValue> element item.
Examples
zero INTEGER ::= 0
<namedValue name="zero" type="asnx:INTEGER" literalValue="0"/>
OR
<namedValue name="zero" type="asnx:INTEGER">
<literalValue>0</literalValue>
</namedValue>
nothing INTEGER ::= zero
<namedValue name="nothing" type="asnx:INTEGER" value="tns:zero"/>
Legg Expires 20 April 2007 [Page 62]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
OR
<namedValue name="nothing" type="asnx:INTEGER">
<value ref="tns:zero"/><!-- A notational value. -->
</namedValue>
OR
<namedValue name="nothing" type="asnx:INTEGER">
<literalValue xmlns:asnx="urn:ietf:params:xml:ns:asnx"
xmlns:tns="http://example.com/ns/MyModule"
asnx:literal="false"
ref="tns:zero"/><!-- A notational value. -->
</namedValue>
integerList SEQUENCE OF number INTEGER ::= { zero, 3, 7 }
<namedValue name="integerList">
<type>
<sequenceOf>
<element name="number" type="asnx:INTEGER"/>
</sequenceOf>
</type>
<literalValue xmlns:asnx="urn:ietf:params:xml:ns:asnx"
xmlns:tns="http://example.com/ns/MyModule">
<number asnx:literal="false"
ref="tns:zero"/><!-- A notational value. -->
<number>3</number><!-- A literal value. -->
<number>7</number><!-- A literal value. -->
</literalValue>
</namedValue>
7.2.1. DefinedValue Translation
If a DefinedValue is a valuereference (not a DummyReference) or an
ExternalValueReference, then the translation of the DefinedValue is
either the attribute form translation of a value reference, or the
element form translation of a value reference.
The attribute form translation of a value reference is an attribute
item with the [local name] "value". The [normalized value] of this
attribute item is the qualified name referencing the value definition
(see Section 5.1). The attribute form translation SHALL NOT be used
if the qualified name is shared by two or more value definitions in
separate modules, i.e., is ambiguous.
The element form translation of a value reference is an element item
with the [local name] "value". An attribute item with the
Legg Expires 20 April 2007 [Page 63]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
[local name] "ref" SHALL be added to the [attributes] of the <value>
element item. The [normalized value] of this attribute item is the
qualified name referencing the value definition (see Section 5.1).
If this reference name is not distinct with respect to the current
module and the modules referenced by its <import> element items (see
Section 5.1), then an attribute item with the [local name] "context"
SHALL be added to the [attributes] of the <value> element item,
otherwise if the module containing the referenced value definition
has a schema identity URI, then an attribute item with the
[local name] "context" MAY be added to the [attributes] of the
<value> element item. The [normalized value] of this attribute item
is the schema identity URI of the module containing the value
definition referenced by the DefinedValue.
Aside: If a reference name is not distinct, then the module
containing the referenced definition must have a schema identity
URI (see Section 5.1).
An element item with the [local name] "annotation" MAY be added to
the [children] of the <value> element item.
Usually the translator is free to choose either an attribute form or
element form translation for a DefinedValue, however in some contexts
attribute forms of Value are explicitly disallowed. In particular,
the attribute form translation SHALL NOT be used for a DefinedValue
that is directly nested in a literal value.
If a DefinedValue is a DummyReference or ParameterizedValue, then the
translation of the DefinedValue is the translation of that
DummyReference or ParameterizedValue (see Section 5.9).
7.2.2. BuiltinValue Translation
The translation of a BuiltinValue is the translation of either a
ChoiceValue, a SequenceValue, a SequenceOfValue, a SetValue or a
TaggedValue.
Aside: There are other possibilities for a BuiltinValue, but these
will all be literal values. This section applies to a
BuiltinValue that is a notational value.
The translation of a TaggedValue is the translation of the contained
Value (which is necessarily a notational value).
The translation of a ChoiceValue is an element item with the
[local name] "value". An element item with the [local name]
"annotation" MAY be added to the [children] of the <value> element
item. An element item with the same [local name] (i.e., "attribute",
Legg Expires 20 April 2007 [Page 64]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
"element", "group" or "member") as the translation of the NamedType
corresponding to the identifier in the ChoiceValue SHALL be appended
to the [children] of the <value> element item. An attribute item
with the [local name] "name" SHALL be added to the [attributes] of
the <attribute>, <element>, <component>, <group> or <member> element
item. The [normalized value] of this attribute item is the RXER
character data translation of the effective name of the NamedType.
The translation of the Value in the ChoiceValue SHALL be added to the
[children] or [attributes] of the <attribute>, <element>,
<component>, <group> or <member> element item.
The translation of a SequenceValue or SetValue is an element item
with the [local name] "value". An element item with the [local name]
"annotation" MAY be added to the [children] of the <value> element
item. The translation of each NamedValue in the ComponentValueList
of the SequenceValue or SetValue SHALL be appended to the [children]
of the <value> element item, in the order in which their
corresponding NamedType instances appear in the definition of the
governing type.
The translation of a SequenceOfValue is an element item with the
[local name] "value". An element item with the [local name]
"annotation" MAY be added to the [children] of the <value> element
item.
If the SequenceOfValue has a NamedValueList, then the translation of
each NamedValue in the NamedValueList SHALL be appended to the
[children] of the <value> element item.
If the SequenceOfValue has a ValueList, then an element item with the
[local name] "element" or "component" (translator's choice) SHALL be
appended to the [children] of the <value> element item for each Value
in the ValueList. An attribute item with the [local name] "name" and
[normalized value] "item" SHALL be added to the [attributes] of the
<element> or <component> element item. The translation of the Value
(from the ValueList) SHALL be added to the [children] or [attributes]
of the <element> or <component> element item.
The translation of a NamedValue is an element item with the same
[local name] as the translation of the corresponding NamedType, i.e.,
"attribute", "element", "group" or "item". An attribute item with
the [local name] "name" SHALL be added to the [attributes] of the
element item. The [normalized value] of this attribute item is the
RXER character data translation of the effective name of the
NamedType. The translation of the Value in the NamedValue SHALL be
added to the [children] or [attributes] of the element item.
Examples
Legg Expires 20 April 2007 [Page 65]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
-- This is the governing type.
MyType ::= SEQUENCE {
one [ATTRIBUTE] INTEGER,
two INTEGER,
three [ATTRIBUTE][LIST] SEQUENCE OF number INTEGER
}
<namedType name="MyType">
<type>
<sequence>
<attribute name="one" type="asnx:INTEGER"/>
<element name="two" type="asnx:INTEGER"/>
<attribute name="three">
<type>
<list>
<item name="number" type="asnx:INTEGER"/>
</list>
</type>
</attribute>
</sequence>
</type>
</namedType>
myValue1 MyType ::= {
one 456,
two 123,
three { number 123, number 456 }
}
-- All literal values.
<namedValue name="myValue1" type="tns:MyType">
<literalValue one="456" three="123 456">
<two>123</two>
</literalValue>
</namedValue>
myValue2 MyType ::= {
one 456,
two myObject.&number,
-- only the value for component "two" is a notational value
three { number 123, number 456 }
}
<namedValue name="myValue2" type="tns:MyType">
<literalValue xmlns:asnx="urn:ietf:params:xml:ns:asnx"
xmlns:tns="http://example.com/ns/MyModule"
one="456" three="123 456">
<two asnx:literal="false">
Legg Expires 20 April 2007 [Page 66]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<fromObjects object="tns:myObject" fieldName="number"/>
</two>
</literalValue>
</namedValue>
myValue3 MyType ::= {
one myObject.&number,
two 123,
three { number 123, number myObject.&number }
}
<namedValue name="myValue3" type="tns:MyType">
<value>
<attribute name="one">
<value>
<fromObjects object="tns:myObject" fieldName="number"/>
</value>
</attribute>
<element name="two" literalValue="123"/>
<attribute name="three">
<value>
<item name="number" literalValue="123"/>
<item name="number">
<value>
<fromObjects object="tns:myObject" fieldName="number"/>
</value>
</item>
</value>
</attribute>
</value>
</namedValue>
7.2.3. ValueFromObject Translation
The translation of a ValueFromObject is an element item with the
[local name] "value". An element item with the [local name]
"annotation" MAY be added to the [children] of the <value> element
item. An element item with the [local name] "fromObjects" SHALL be
appended to the [children] of the <value> element item.
The translation of the ReferencedObjects in the ValueFromObject and
the translation of the FieldName in the ValueFromObject SHALL be
added to the [children] and/or [attributes] of the <fromObjects>
element item.
7.2.4. ObjectClassFieldValue Translation
If an ObjectClassFieldValue is a BuiltinValue in a FixedTypeFieldVal,
Legg Expires 20 April 2007 [Page 67]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
then the translation of the ObjectClassFieldValue is the translation
of the BuiltinValue.
If an ObjectClassFieldValue is a ReferencedValue in a
FixedTypeFieldVal, then the translation of the ObjectClassFieldValue
is the translation of the ReferencedValue.
If an ObjectClassFieldValue is an OpenTypeFieldVal, then the
translation of the ObjectClassFieldValue is an element item with the
[local name] "value". An element item with the [local name]
"annotation" MAY be added to the [children] of the <value> element
item. An element item with the [local name] "openTypeValue" SHALL be
appended to the [children] of the <value> element item. The
translation of the Type in the OpenTypeFieldVal and the translation
of the Value in the OpenTypeFieldVal SHALL be added to the [children]
and/or [attributes] of the <openTypeValue> element item.
Example
myValue TYPE-IDENTIFIER.&Type ::= INTEGER:123
<namedValue name="myValue">
<type>
<fromClass class="asnx:TYPE-IDENTIFIER" fieldName="Type"/>
</type>
<value>
<openTypeValue type="asnx:INTEGER" literalValue="123"/>
</value>
</namedValue>
8. Translation of Value Sets
The translation of a ValueSet is an element item with the
[local name] "valueSet". An element item with the [local name]
"annotation" MAY be added to the [children] of the <valueSet> element
item. The translation of the ElementSetSpecs in the ValueSet SHALL
be appended to the [children] of the <valueSet> element item.
Example
{ 1 | 3..7, ..., 9..19 EXCEPT ( 11 | 12 ) }
<valueSet>
<union>
<literalValue>1</literalValue>
<range>
<minInclusive literalValue="3"/>
<maxInclusive literalValue="7"/>
Legg Expires 20 April 2007 [Page 68]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</range>
</union>
<extension>
<all>
<range>
<minInclusive literalValue="9"/>
<maxInclusive literalValue="19"/>
</range>
<except>
<union>
<literalValue>11</literalValue>
<literalValue>12</literalValue>
</union>
</except>
</all>
</extension>
</valueSet>
8.1. ElementSetSpecs Translation
The translation of an ElementSetSpecs where the ellipsis ("...") is
not present is the translation of the ElementSetSpec in the
RootElementSetSpec.
The translation of an ElementSetSpecs where the ellipsis ("...") is
present is the translation of the ElementSetSpec in the
RootElementSetSpec followed by an element item with the [local name]
"extension". If an AdditionalElementSetSpec is present, then the
translation of the ElementSetSpec in the AdditionalElementSetSpec
SHALL be added to the [children] of the <extension> element item.
8.2. ElementSetSpec Translation
If the ElementSetSpec is of the "ALL Exclusions" form, then the
translation of the ElementSetSpec is an element item with the
[local name] "all". An element item with the [local name] "except"
SHALL be added to the [children] of the <all> element item. The
translation of the Elements in the Exclusions SHALL be added to the
[children] of the <except> element item.
If the ElementSetSpec is of the "Unions" form, then the translation
of the ElementSetSpec is the translation of the Unions.
If the Unions has only one Intersections, then the translation of the
Unions is the translation of that Intersections, otherwise the
translation of the Unions is an element item with the [local name]
"union". The translation of each Intersections SHALL be appended to
the [children] of the <union> element item.
Legg Expires 20 April 2007 [Page 69]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
If the Intersections has only one IntersectionElements, then the
translation of the Intersections is the translation of that
IntersectionElements, otherwise the translation of the Intersections
is an element item with the [local name] "intersection". The
translation of each IntersectionElements SHALL be appended to the
[children] of the <intersection> element item.
If the IntersectionElements is of the "Elems Exclusions" form, then
the translation of the IntersectionElements is an element item with
the [local name] "all". The translation of the Elements in the Elems
and an element item with the [local name] "except" SHALL be added to
the [children] of the <all> element item. The translation of the
Elements in the Exclusions SHALL be added to the [children] of the
<except> element item.
If the IntersectionElements is of the "Elements" form, then the
translation of the IntersectionElements is the translation of the
Elements.
The translation of an Elements is the translation of the
SubtypeElements, ObjectSetElements or ElementSetSpec, as appropriate.
8.3. SubtypeElements Translation
If a SubtypeElements is a SingleValue, then the translation of the
SubtypeElements is the translation of the Value, except that an
attribute form of the Value translation SHALL NOT be used.
If a SubtypeElements is a ContainedSubtype, then the translation of
the SubtypeElements is an element item with the [local name]
"includes". The translation of the Type in the ContainedSubtype
SHALL be added to the [children] or [attributes] of the <includes>
element item.
If a SubtypeElements is a ValueRange, then the translation of the
SubtypeElements is the translation of the ValueRange.
If a SubtypeElements is a SizeConstraint, then the translation of the
SubtypeElements is an element item with the [local name] "size". The
translation of the Constraint in the SizeConstraint SHALL be added to
the [children] of the <size> element item.
If a SubtypeElements is a TypeConstraint, then the translation of the
SubtypeElements is an element item with the [local name]
"typeConstraint". The translation of the Type in the TypeConstraint
SHALL be added to the [children] or [attributes] of the
<typeConstraint> element item.
Legg Expires 20 April 2007 [Page 70]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
If a SubtypeElements is a PermittedAlphabet, then the translation of
the SubtypeElements is an element item with the [local name] "from".
The translation of the Constraint in the PermittedAlphabet SHALL be
added to the [children] of the <from> element item.
If a SubtypeElements is an InnerTypeConstraints, then the translation
of the SubtypeElements is the translation of the
InnerTypeConstraints.
If a SubtypeElements is a PatternConstraint, then the translation of
the SubtypeElements is an element item with the [local name]
"pattern". The translation of the Value in the PatternConstraint
SHALL be added to the [children] or [attributes] of the <pattern>
element item.
8.3.1. ValueRange Translation
The translation of a ValueRange is an element item with the
[local name] "range".
If the LowerEndpoint in the ValueRange is of the "LowerEndValue <"
form, then an element item with the [local name] "minExclusive" SHALL
be added to the [children] of the <range> element item. If the
LowerEndValue is not "MIN", then the translation of the Value in the
LowerEndValue SHALL be added to the [children] or [attributes] of the
<minExclusive> element item.
If the LowerEndpoint in the ValueRange is of the "LowerEndValue" form
and the LowerEndValue is not "MIN", then an element item with the
[local name] "minInclusive" SHALL be added to the [children] of the
<range> element item. The translation of the Value in the
LowerEndValue SHALL be added to the [children] or [attributes] of the
<minInclusive> element item.
If the LowerEndpoint in the ValueRange is of the "LowerEndValue" form
and the LowerEndValue is "MIN", then an element item with the
[local name] "minInclusive" MAY be added to the [children] of the
<range> element item.
If the UpperEndpoint in the ValueRange is of the "< UpperEndValue"
form, then an element item with the [local name] "maxExclusive" SHALL
be added to the [children] of the <range> element item. If the
UpperEndValue is not "MAX", then the translation of the Value in the
UpperEndValue SHALL be added to the [children] or [attributes] of the
<maxExclusive> element item.
If the UpperEndpoint in the ValueRange is of the "UpperEndValue" form
and the UpperEndValue is not "MAX", then an element item with the
Legg Expires 20 April 2007 [Page 71]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
[local name] "maxInclusive" SHALL be added to the [children] of the
<range> element item. The translation of the Value in the
UpperEndValue SHALL be added to the [children] or [attributes] of the
<maxInclusive> element item.
If the UpperEndpoint in the ValueRange is of the "UpperEndValue" form
and the UpperEndValue is "MAX", then an element item with the
[local name] "maxInclusive" MAY be added to the [children] of the
<range> element item.
Examples
1..10
<range>
<minInclusive literalValue="1"/>
<maxInclusive literalValue="10"/>
</range>
0..MAX
<range>
<minInclusive literalValue="0"/>
</range>
0<..<MAX
<range>
<minExclusive literalValue="0"/>
<maxExclusive/>
</range>
8.3.2. InnerTypeConstraints Translation
The translation of an InnerTypeConstraints of the
"WITH COMPONENT SingleTypeConstraint" form is an element item with
the [local name] "withComponent". The translation of the Constraint
in the SingleTypeConstraint SHALL be added to the [children] of the
<withComponent> element item.
The translation of an InnerTypeConstraints of the
"WITH COMPONENTS MultipleTypeConstraints" form is an element item
with the [local name] "withComponents".
If the MultipleTypeConstraints is a PartialSpecification, then an
attribute item with the [local name] "partial" and the
[normalized value] "true" or "1" SHALL be added to the [attributes]
of the <withComponents> element item. If the MultipleTypeConstraints
Legg Expires 20 April 2007 [Page 72]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
is a FullSpecification, then an attribute item with the [local name]
"partial" and the [normalized value] "false" or "0" MAY be added to
the [attributes] of the <withComponents> element item.
The translation of each NamedConstraint in the
MultipleTypeConstraints SHALL be appended to the [children] of the
<withComponents> element item.
The translation of a NamedConstraint is an element item with the same
[local name] (i.e., "component", "attribute", "element", "group" or
"member") as the translation of the NamedType corresponding to the
identifier of the NamedConstraint. An attribute item with the
[local name] "name" SHALL be added to the [attributes] of the
<attribute>, <element>, <component>, <group> or <member> element
item, as the case may be. The [normalized value] of this attribute
item is the RXER character data translation of the effective name of
the NamedType corresponding to the identifier of the NamedConstraint.
If the PresenceConstraint of the ComponentConstraint of the
NamedConstraint is not empty, then an attribute item with the
[local name] "use" SHALL be added to the [attributes] of the
<attribute>, <element>, <component>, <group> or <member> element
item, as the case may be. The [normalized value] of this attribute
item is the text of the PresenceConstraint with all letters
downcased, i.e., either "present", "absent" or "optional".
If the ValueConstraint in the ComponentConstraint of the
NamedConstraint is not empty, then the translation of the Constraint
in the ValueConstraint SHALL be added to the [children] of the
<attribute>, <element>, <component>, <group> or <member> element
item, as the case may be.
9. Translation of Object Classes
The translation of an ObjectClass is the translation of either a
DefinedObjectClass, an ObjectClassDefn or a ParameterizedObjectClass.
The translation of a ParameterizedObjectClass is described in
Section 5.9.
9.1. DefinedObjectClass Translation
If a DefinedObjectClass is an objectclassreference (not a
DummyReference), an ExternalObjectClassReference or a
UsefulObjectClassReference, then the translation of the
DefinedObjectClass is either the attribute form translation of an
object class reference, or the element form translation of an object
class reference.
Legg Expires 20 April 2007 [Page 73]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The attribute form translation of an object class reference is an
attribute item with the [local name] "class". The [normalized value]
of this attribute item is the qualified name referencing the object
class definition (see Section 5.1). In the case of a
UsefulObjectClassReference, the namespace name is
"urn:ietf:params:xml:ns:asnx" and the local part is either
"TYPE-IDENTIFIER" or "ABSTRACT-SYNTAX", as appropriate. The
attribute form translation SHALL NOT be used if the qualified name is
shared by two or more object class definitions in separate modules,
i.e., is ambiguous. Otherwise, the translator is free to choose
either the attribute form or element form translation for an object
class reference.
The element form translation of an object class reference is an
element item with the [local name] "class". An attribute item with
the [local name] "ref" SHALL be added to the [attributes] of the
<class> element item. The [normalized value] of this attribute item
is the qualified name referencing the object class definition. In
the case of a UsefulObjectClassReference the namespace name is
"urn:ietf:params:xml:ns:asnx" and the local part is either
"TYPE-IDENTIFIER" or "ABSTRACT-SYNTAX", as the case may be. If the
reference name is not distinct with respect to the current module and
the modules referenced by its <import> element items (see
Section 5.1), then an attribute item with the [local name] "context"
SHALL be added to the [attributes] of the <class> element item,
otherwise if the module containing the referenced object class
definition has a schema identity URI, then an attribute item with the
[local name] "context" MAY be added to the [attributes] of the
<class> element item. The [normalized value] of this attribute item
is the schema identity URI of the module containing the referenced
object class definition.
Aside: If a reference name is not distinct, then the module
containing the referenced definition must have a schema identity
URI (see Section 5.1).
An element item with the [local name] "annotation" MAY be added to
the [children] of the <class> element item.
The translation of the DefinedObjectClass is the same whether the
object class definition is referenced by an objectclassreference or
an ExternalObjectClassReference.
If a DefinedObjectClass is a DummyReference, then the translation of
the DefinedObjectClass is the translation of the DummyReference (see
Section 5.9).
9.2. ObjectClassDefn Translation
Legg Expires 20 April 2007 [Page 74]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The translation of an ObjectClassDefn is an element item with the
[local name] "class". An element item with the [local name]
"annotation" MAY be added to the [children] of the <class> element
item. The translation of each FieldSpec in the ObjectClassDefn SHALL
be appended to the [children] of the <class> element item.
The translation of a FieldSpec is the translation of either a
TypeFieldSpec, a FixedTypeValueFieldSpec, a
VariableTypeValueFieldSpec, a FixedTypeValueSetFieldSpec, a
VariableTypeValueSetFieldSpec, an ObjectFieldSpec or an
ObjectSetFieldSpec.
9.2.1. TypeFieldSpec Translation
The translation of a TypeFieldSpec where the TypeOptionalitySpec is
absent is an element item with the [local name] "typeField".
The translation of a TypeFieldSpec with a TypeOptionalitySpec of
"OPTIONAL" is an element item with the [local name] "optional". An
element item with the [local name] "typeField" SHALL be added to the
[children] of the <optional> element item.
The translation of a TypeFieldSpec with a TypeOptionalitySpec of
"DEFAULT" is an element item with the [local name] "optional". An
element item with the [local name] "typeField" SHALL be added to the
[children] of the <optional> element item. An element item with the
[local name] "default" SHALL be appended to the [children] of the
<optional> element item. The translation of the Type in the
TypeOptionalitySpec SHALL be added to the [children] or [attributes]
of the <default> element item.
An attribute item with the [local name] "name" SHALL be added to the
[attributes] of the <typeField> element item. The [normalized value]
of this attribute item is the typefieldreference of the
TypeFieldSpec, without the ampersand ("&", U+0026). An element item
with the [local name] "annotation" MAY be added to the [children] of
the <typeField> element item.
Example
CLASS {
&One,
&Two OPTIONAL,
&Three DEFAULT OBJECT IDENTIFIER
}
<class>
<typeField name="One"/>
Legg Expires 20 April 2007 [Page 75]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<optional>
<typeField name="Two"/>
</optional>
<optional>
<typeField name="Three"/>
<default type="asnx:OBJECT-IDENTIFIER"/>
</optional>
</class>
9.2.2. FixedTypeValueFieldSpec Translation
The translation of a FixedTypeValueFieldSpec where the
ValueOptionalitySpec is absent is an element item with the
[local name] "valueField".
The translation of a FixedTypeValueFieldSpec with a
ValueOptionalitySpec of "OPTIONAL" is an element item with the
[local name] "optional". An element item with the [local name]
"valueField" SHALL be added to the [children] of the <optional>
element item.
The translation of a FixedTypeValueFieldSpec with a
ValueOptionalitySpec of "DEFAULT" is an element item with the
[local name] "optional". An element item with the [local name]
"valueField" SHALL be added to the [children] of the <optional>
element item. An element item with the [local name] "default" SHALL
be appended to the [children] of the <optional> element item. The
translation of the Value in the ValueOptionalitySpec SHALL be added
to the [children] or [attributes] of the <default> element item.
An attribute item with the [local name] "name" SHALL be added to the
[attributes] of the <valueField> element item. The
[normalized value] of this attribute item is the valuefieldreference
of the FixedTypeValueFieldSpec, without the ampersand ("&", U+0026).
If the "UNIQUE" keyword is present, then an attribute item with the
[local name] "unique" and [normalized value] "true" or "1" SHALL be
added to the [attributes] of the <valueField> element item, otherwise
an attribute item with the [local name] "unique" and
[normalized value] "false" or "0" MAY be added to the [attributes] of
the <valueField> element item. An element item with the [local name]
"annotation" MAY be added to the [children] of the <valueField>
element item. The translation of the Type in the
FixedTypeValueFieldSpec SHALL be added to the [children] or
[attributes] of the <valueField> element item.
Example
CLASS {
Legg Expires 20 April 2007 [Page 76]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
&one OBJECT IDENTIFIER UNIQUE,
&two BOOLEAN OPTIONAL,
&three INTEGER DEFAULT 0
}
<class>
<valueField name="one" unique="true"
type="asnx:OBJECT-IDENTIFIER"/>
<optional>
<valueField name="two" type="asnx:BOOLEAN"/>
</optional>
<optional>
<valueField name="three" type="asnx:INTEGER"/>
<default literalValue="0"/>
</optional>
</class>
9.2.3. FixedTypeValueSetFieldSpec Translation
The translation of a FixedTypeValueSetFieldSpec where the
ValueSetOptionalitySpec is absent is an element item with the
[local name] "valueSetField".
The translation of a FixedTypeValueSetFieldSpec with a
ValueSetOptionalitySpec of "OPTIONAL" is an element item with the
[local name] "optional". An element item with the [local name]
"valueSetField" SHALL be added to the [children] of the <optional>
element item.
The translation of a FixedTypeValueSetFieldSpec with a
ValueSetOptionalitySpec of "DEFAULT" is an element item with the
[local name] "optional". An element item with the [local name]
"valueSetField" SHALL be added to the [children] of the <optional>
element item. An element item with the [local name] "default" SHALL
be appended to the [children] of the <optional> element item. The
translation of the ValueSet in the ValueSetOptionalitySpec SHALL be
added to the [children] of the <default> element item.
An attribute item with the [local name] "name" SHALL be added to the
[attributes] of the <valueSetField> element item. The
[normalized value] of this attribute item is the
valuesetfieldreference of the FixedTypeValueSetFieldSpec, without the
ampersand ("&", U+0026). An element item with the [local name]
"annotation" MAY be added to the [children] of the <valueSetField>
element item. The translation of the Type in the
FixedTypeValueSetFieldSpec SHALL be added to the [children] or
[attributes] of the <valueSetField> element item.
Legg Expires 20 April 2007 [Page 77]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
Example
CLASS {
&One UTF8String,
&Two BOOLEAN OPTIONAL,
&Three INTEGER DEFAULT { 1 | 2 }
}
<class>
<valueSetField name="One" type="asnx:UTF8String"/>
<optional>
<valueSetField name="Two" type="asnx:BOOLEAN"/>
</optional>
<optional>
<valueSetField name="Three" type="asnx:INTEGER"/>
<default>
<valueSet>
<union>
<literalValue>1</literalValue>
<literalValue>2</literalValue>
</union>
</valueSet>
</default>
</optional>
</class>
9.2.4. VariableTypeValueFieldSpec Translation
The translation of a VariableTypeValueFieldSpec where the
ValueOptionalitySpec is absent is an element item with the
[local name] "valueField".
The translation of a VariableTypeValueFieldSpec with a
ValueOptionalitySpec of "OPTIONAL" is an element item with the
[local name] "optional". An element item with the [local name]
"valueField" SHALL be added to the [children] of the <optional>
element item.
The translation of a VariableTypeValueFieldSpec with a
ValueOptionalitySpec of "DEFAULT" is an element item with the
[local name] "optional". An element item with the [local name]
"valueField" SHALL be added to the [children] of the <optional>
element item. An element item with the [local name] "default" SHALL
be appended to the [children] of the <optional> element item. The
translation of the Value in the ValueOptionalitySpec SHALL be added
to the [children] or [attributes] of the <default> element item.
An attribute item with the [local name] "name" SHALL be added to the
Legg Expires 20 April 2007 [Page 78]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
[attributes] of the <valueField> element item. The
[normalized value] of this attribute item is the valuefieldreference
of the VariableTypeValueFieldSpec, without the ampersand ("&",
U+0026). An element item with the [local name] "annotation" MAY be
added to the [children] of the <valueField> element item. An element
item with the [local name] "typeFromField" SHALL be appended to the
[children] of the <valueField> element item. The translation of the
FieldName in the VariableTypeValueFieldSpec SHALL be added to the
[children] or [attributes] of the <typeFromField> element item.
Example
CLASS {
&Syntax DEFAULT INTEGER,
&one &Syntax,
&two &Syntax OPTIONAL,
&three &Syntax DEFAULT 0
}
<class>
<optional>
<typeField name="Syntax"/>
<default type="asnx:INTEGER"/>
</optional>
<valueField name="one">
<typeFromField fieldName="Syntax"/>
</valueField>
<optional>
<valueField name="two">
<typeFromField fieldName="Syntax"/>
</valueField>
</optional>
<optional>
<valueField name="three">
<typeFromField fieldName="Syntax"/>
</valueField>
<default literalValue="0"/>
</optional>
</class>
9.2.5. VariableTypeValueSetFieldSpec Translation
The translation of a VariableTypeValueSetFieldSpec where the
ValueSetOptionalitySpec is absent is an element item with the
[local name] "valueSetField".
The translation of a VariableTypeValueSetFieldSpec with a
ValueSetOptionalitySpec of "OPTIONAL" is an element item with the
Legg Expires 20 April 2007 [Page 79]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
[local name] "optional". An element item with the [local name]
"valueSetField" SHALL be added to the [children] of the <optional>
element item.
The translation of a VariableTypeValueSetFieldSpec with a
ValueSetOptionalitySpec of "DEFAULT" is an element item with the
[local name] "optional". An element item with the [local name]
"valueSetField" SHALL be added to the [children] of the <optional>
element item. An element item with the [local name] "default" SHALL
be appended to the [children] of the <optional> element item. The
translation of the ValueSet in the ValueSetOptionalitySpec SHALL be
added to the [children] of the <default> element item.
An attribute item with the [local name] "name" SHALL be added to the
[attributes] of the <valueSetField> element item. The
[normalized value] of this attribute item is the
valuesetfieldreference of the VariableTypeValueSetFieldSpec, without
the ampersand ("&", U+0026). An element item with the [local name]
"annotation" MAY be added to the [children] of the <valueSetField>
element item. An element item with the [local name] "typeFromField"
SHALL be appended to the [children] of the <valueSetField> element
item. The translation of the FieldName in the
VariableTypeValueSetFieldSpec SHALL be added to the [children] or
[attributes] of the <typeFromField> element item.
Example
CLASS {
&Syntax DEFAULT INTEGER,
&One &Syntax,
&Two &Syntax OPTIONAL,
&Three &Syntax DEFAULT { 1 | 2 }
}
<class>
<optional>
<typeField name="Syntax"/>
<default type="asnx:INTEGER"/>
</optional>
<valueSetField name="One">
<typeFromField fieldName="Syntax"/>
</valueSetField>
<optional>
<valueSetField name="Two">
<typeFromField fieldName="Syntax"/>
</valueSetField>
</optional>
<optional>
Legg Expires 20 April 2007 [Page 80]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<valueSetField name="Three">
<typeFromField fieldName="Syntax"/>
</valueSetField>
<default>
<valueSet>
<union>
<literalValue>1</literalValue>
<literalValue>2</literalValue>
</union>
</valueSet>
</default>
</optional>
</class>
9.2.6. FieldName Translation
The translation of a FieldName is either, at the translator's option,
an attribute item with the [local name] "fieldName" added to the
[attributes] of the enclosing element item, or an element item with
the [local name] "fieldName" appended to the [children] of the
enclosing element item.
The [normalized value] of the fieldName attribute item is a "/"
(U+002F) separated list of the primitive field names without the
ampersand characters ("&", U+0026). Leading and/or trailing white
space characters MAY be added to the [normalized value] of the
attribute item. White space characters MAY be added immediately
before and/or after any "/" character in the [normalized value].
The [children] property of the <fieldName> element item is set to the
sequence of character items for a "/" (U+002F) separated list of the
primitive field names without the ampersand characters ("&", U+0026).
Leading and/or trailing white space character items MAY be added to
the [children] of the <fieldName> element item. White space
character items MAY be added immediately before and/or after any
character item for the "/" character.
Example
&Linked.&ArgumentType
<fieldName>Linked/ArgumentType</fieldName>
9.2.7. ObjectFieldSpec Translation
The translation of an ObjectFieldSpec where the ObjectOptionalitySpec
is absent is an element item with the [local name] "objectField".
Legg Expires 20 April 2007 [Page 81]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The translation of a ObjectFieldSpec with a ObjectOptionalitySpec of
"OPTIONAL" is an element item with the [local name] "optional". An
element item with the [local name] "objectField" SHALL be added to
the [children] of the <optional> element item.
The translation of a ObjectFieldSpec with a ObjectOptionalitySpec of
"DEFAULT" is an element item with the [local name] "optional". An
element item with the [local name] "objectField" SHALL be added to
the [children] of the <optional> element item. An element item with
the [local name] "default" SHALL be appended to the [children] of the
<optional> element item. The translation of the Object in the
ObjectOptionalitySpec SHALL be added to the [children] or
[attributes] of the <default> element item.
An attribute item with the [local name] "name" SHALL be added to the
[attributes] of the <objectField> element item. The
[normalized value] of this attribute item is the objectfieldreference
of the ObjectFieldSpec, without the ampersand ("&", U+0026). An
element item with the [local name] "annotation" MAY be added to the
[children] of the <objectField> element item. The translation of the
DefinedObjectClass in the ObjectFieldSpec SHALL be added to the
[children] or [attributes] of the <objectField> element item.
Example
CLASS {
&one TYPE-IDENTIFIER,
&two ABSTRACT-SYNTAX OPTIONAL,
&three TYPE-IDENTIFIER DEFAULT myObject
}
<class>
<objectField name="one" class="asnx:TYPE-IDENTIFIER"/>
<optional>
<objectField name="two" class="asnx:ABSTRACT-SYNTAX"/>
</optional>
<optional>
<objectField name="three" class="asnx:TYPE-IDENTIFIER"/>
<default object="tns:myObject"/>
</optional>
</class>
9.2.8. ObjectSetFieldSpec Translation
The translation of an ObjectSetFieldSpec where the
ObjectSetOptionalitySpec is absent is an element item with the
[local name] "objectSetField".
Legg Expires 20 April 2007 [Page 82]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The translation of a ObjectSetFieldSpec with a
ObjectSetOptionalitySpec of "OPTIONAL" is an element item with the
[local name] "optional". An element item with the [local name]
"objectSetField" SHALL be added to the [children] of the <optional>
element item.
The translation of a ObjectSetFieldSpec with a
ObjectSetOptionalitySpec of "DEFAULT" is an element item with the
[local name] "optional". An element item with the [local name]
"objectSetField" SHALL be added to the [children] of the <optional>
element item. An element item with the [local name] "default" SHALL
be appended to the [children] of the <optional> element item. The
translation of the ObjectSet in the ObjectSetOptionalitySpec SHALL be
added to the [children] or [attributes] of the <default> element
item.
An attribute item with the [local name] "name" SHALL be added to the
[attributes] of the <objectSetField> element item. The
[normalized value] of this attribute item is the
objectsetfieldreference of the ObjectSetFieldSpec, without the
ampersand ("&", U+0026). An element item with the [local name]
"annotation" MAY be added to the [children] of the <objectSetField>
element item. The translation of the DefinedObjectClass in the
ObjectSetFieldSpec SHALL be added to the [children] or [attributes]
of the <objectSetField> element item.
Example
CLASS {
&One TYPE-IDENTIFIER,
&Two ABSTRACT-SYNTAX OPTIONAL,
&Three TYPE-IDENTIFIER DEFAULT { myObject }
}
<class>
<objectSetField name="One" class="asnx:TYPE-IDENTIFIER"/>
<optional>
<objectSetField name="Two" class="asnx:ABSTRACT-SYNTAX"/>
</optional>
<optional>
<objectSetField name="Three" class="asnx:TYPE-IDENTIFIER"/>
<default>
<objectSet>
<object ref="tns:myObject"/>
</objectSet>
</default>
</optional>
</class>
Legg Expires 20 April 2007 [Page 83]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
10. Translation of Objects
The translation of an Object is the translation of either a
DefinedObject, an ObjectDefn, an ObjectFromObject or a
ParameterizedObject.
The translation of a ParameterizedObject is described in Section 5.9.
10.1. DefinedObject Translation
If a DefinedObject is an objectreference (not a DummyReference) or an
ExternalObjectReference, then the translation of the DefinedObject is
either the attribute form translation of an object reference, or the
element form translation of an object reference.
The attribute form translation of an object reference is an attribute
item with the [local name] "object". The [normalized value] of this
attribute item is the qualified name referencing the object
definition (see Section 5.1). The attribute form translation SHALL
NOT be used if the qualified name is shared by two or more object
definitions in separate modules, i.e., is ambiguous.
The element form translation of an object reference is an element
item with the [local name] "object". An attribute item with the
[local name] "ref" SHALL be added to the [attributes] of the <object>
element item. The [normalized value] of this attribute item is the
qualified name referencing the object definition. If this reference
name is not distinct with respect to the current module and the
modules referenced by its <import> element items (see Section 5.1),
then an attribute item with the [local name] "context" SHALL be added
to the [attributes] of the <object> element item, otherwise if the
module containing the referenced object definition has a schema
identity URI, then an attribute item with the [local name] "context"
MAY be added to the [attributes] of the <object> element item. The
[normalized value] of this attribute item is the schema identity URI
of the module containing the referenced object definition.
Aside: If a reference name is not distinct, then the module
containing the referenced definition must have a schema identity
URI (see Section 5.1).
An element item with the [local name] "annotation" MAY be added to
the [children] of the <object> element item.
The translation of the DefinedObject is the same whether the object
definition is referenced by an objectreference or an
ExternalObjectReference.
Legg Expires 20 April 2007 [Page 84]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
Usually the translator is free to choose either the attribute form or
element form translation for an object reference, however in some
contexts the attribute form is explicitly disallowed.
If a DefinedObject is a DummyReference, then the translation of the
DefinedObject is the translation of the DummyReference (see
Section 5.9).
10.2. ObjectDefn Translation
An ObjectDefn in the DefinedSyntax form is first converted to the
equivalent DefaultSyntax and then translated.
The translation of an ObjectDefn is an element item with the
[local name] "object". An element item with the [local name]
"annotation" MAY be added to the [children] of the <object> element
item. The translation of each FieldSetting in the DefaultSyntax of
the ObjectClassDefn SHALL be appended to the [children] of the
<object> element item.
The translation of a FieldSetting is an element item with the
[local name] "field". An attribute item with the [local name] "name"
SHALL be added to the [attributes] of the <field> element item. The
[normalized value] of this attribute item is the PrimitiveFieldName
without the ampersand ("&", U+0026). The translation of the Type,
Value, ValueSet, Object or ObjectSet in the Setting of the
FieldSetting SHALL be added to the [children] of the <field> element
item.
Example
-- This is the governing object class.
ONE-OF-EVERYTHING ::= CLASS {
&One,
&two INTEGER,
&Three INTEGER,
&four TYPE-IDENTIFIER,
&Five TYPE-IDENTIFIER
}
<namedClass name="ONE-OF-EVERYTHING">
<class>
<typeField name="One"/>
<valueField name="two" type="asnx:INTEGER"/>
<valueSetField name="Three" type="asnx:INTEGER"/>
<objectField name="four" class="asnx:TYPE-IDENTIFIER"/>
<objectSetField name="Five" class="asnx:TYPE-IDENTIFIER"/>
</class>
Legg Expires 20 April 2007 [Page 85]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</namedClass>
mixedBag ONE-OF-EVERYTHING ::= {
&One BOOLEAN,
&two 99,
&Three { 1 | 2 },
&four myObject,
&Five { myObject }
}
<namedObject name="mixedBag" class="tns:ONE-OF-EVERYTHING">
<object>
<field name="One" type="asnx:BOOLEAN"/>
<field name="two" literalValue="99"/>
<field name="Three">
<valueSet>
<union>
<literalValue>1</literalValue>
<literalValue>2</literalValue>
</union>
</valueSet>
</field>
<field name="four" object="tns:myObject"/>
<field name="Five">
<objectSet>
<object ref="tns:myObject"/>
</objectSet>
</field>
</object>
</namedObject>
10.3. ObjectFromObject Translation
The translation of an ObjectFromObject is an element item with the
[local name] "object". An element item with the [local name]
"annotation" MAY be added to the [children] of the <object> element
item. An element item with the [local name] "fromObjects" SHALL be
appended to the [children] of the <object> element item.
The translation of the ReferencedObjects in the ObjectFromObject and
the translation of the FieldName in the ObjectFromObject SHALL be
added to the [children] and/or [attributes] of the <fromObjects>
element item.
11. Translation of Object Sets
If an ObjectSet matches the form "{ DefinedObjectSet }" (i.e., a
DefinedObjectSet in an ObjectSetElements in an Elements in a single
Legg Expires 20 April 2007 [Page 86]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
IntersectionElements in a single Intersections in a Unions in an
ElementSetSpec in a lone RootElementSetSpec in the ObjectSetSpec),
then the translator MAY use the translation of the DefinedObjectSet
as the translation of the ObjectSet, otherwise the translation of an
ObjectSet is an element item with the [local name] "objectSet". An
element item with the [local name] "annotation" MAY be added to the
[children] of the <objectSet> element item. The translation of the
ObjectSetSpec in the ObjectSet SHALL be appended to the [children] of
the <objectSet> element item.
Aside: An ObjectSet that is directly a DefinedObjectSet is a
notational capability that does not exist in ASN.1 but is allowed
in ASN.X to avoid excessive nesting of <objectSet> element items
in the expansion of parameterized definitions.
If an ObjectSetSpec contains only a RootElementSetSpec, then the
translation of the ObjectSetSpec is the translation of the
ElementSetSpec in the RootElementSetSpec.
If an ObjectSetSpec contains a RootElementSetSpec and the ellipsis
("..."), then the translation of the ObjectSetSpec is the translation
of the ElementSetSpec in the RootElementSetSpec followed by an
element item with the [local name] "extension". If an
AdditionalElementSetSpec is present, then the translation of the
ElementSetSpec in the AdditionalElementSetSpec SHALL be added to the
[children] of the <extension> element item.
If an ObjectSetSpec does not contain a RootElementSetSpec, then the
translation of the ObjectSetSpec is an element item with the
[local name] "extension". If an AdditionalElementSetSpec is present,
then the translation of the ElementSetSpec in the
AdditionalElementSetSpec SHALL be added to the [children] of the
<extension> element item.
Contained within the ElementSetSpec will be one or more
ObjectSetElements.
11.1. DefinedObjectSet Translation
If a DefinedObjectSet is an objectsetreference (not a DummyReference)
or an ExternalObjectSetReference, then the translation of the
DefinedObjectSet is either the attribute form translation of an
object set reference, or the element form translation of an object
set reference.
The attribute form translation of an object set reference is an
attribute item with the [local name] "objectSet". The
[normalized value] of this attribute item is the qualified name
Legg Expires 20 April 2007 [Page 87]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
referencing the object set definition (see Section 5.1). The
attribute form translation SHALL NOT be used if the qualified name is
shared by two or more object set definitions in separate modules,
i.e., is ambiguous.
The element form translation of an object set reference is an element
item with the [local name] "objectSet". An attribute item with the
[local name] "ref" SHALL be added to the [attributes] of the
<objectSet> element item. The [normalized value] of this attribute
item is the qualified name referencing the object set definition. If
this reference name is not distinct with respect to the current
module and the modules referenced by its <import> element items (see
Section 5.1), then an attribute item with the [local name] "context"
SHALL be added to the [attributes] of the <objectSet> element item,
otherwise if the module containing the referenced object set
definition has a schema identity URI, then an attribute item with the
[local name] "context" MAY be added to the [attributes] of the
<objectSet> element item. The [normalized value] of this attribute
item is the schema identity URI of the module containing the
referenced object set definition.
Aside: If a reference name is not distinct, then the module
containing the referenced definition must have a schema identity
URI (see Section 5.1).
An element item with the [local name] "annotation" MAY be added to
the [children] of the <objectSet> element item.
The translation of the DefinedObjectSet is the same whether the
object definition is referenced by an objectsetreference or an
ExternalObjectSetReference.
Usually the translator is free to choose either the attribute form or
element form translation for an object set reference, however in some
contexts the attribute form is explicitly disallowed.
If a DefinedObjectSet is a DummyReference, then the translation of
the DefinedObjectSet is the translation of the DummyReference (see
Section 5.9).
11.2. ObjectSetElements Translation
If an ObjectSetElements is an Object, then the translation of the
ObjectSetElements is the translation of the Object, except that the
attribute form of the DefinedObject translation SHALL NOT be used.
If an ObjectSetElements is a DefinedObjectSet, then the translation
of the ObjectSetElements is the translation of the DefinedObjectSet,
Legg Expires 20 April 2007 [Page 88]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
except that the attribute form of the DefinedObjectSet translation
SHALL NOT be used.
If an ObjectSetElements is an ObjectSetFromObjects, then the
translation of the ObjectSetElements is the translation of the
ObjectSetFromObjects.
If an ObjectSetElements is a ParameterizedObjectSet, then the
translation of the ObjectSetElements is the translation of the
ParameterizedObjectSet (see Section 5.9).
Aside: The in-line expansion of a ParameterizedObjectSet results
in an ObjectSet. An ObjectSetElements that is an ObjectSet is a
notational capability that does not exist in ASN.1 but is allowed
in ASN.X to avoid the need to manufacture a reference name for the
expanded parameterized definition.
11.2.1. ObjectSetFromObjects Translation
The translation of an ObjectSetFromObjects is an element item with
the [local name] "objectSet". An element item with the [local name]
"annotation" MAY be added to the [children] of the <objectSet>
element item. An element item with the [local name] "fromObjects"
SHALL be appended to the [children] of the <objectSet> element item.
The translation of the ReferencedObjects in the ObjectSetFromObjects
and the translation of the FieldName in the ObjectSetFromObjects
SHALL be added to the [children] and/or [attributes] of the
<fromObjects> element item.
12. Translation of Information From Objects
If a ReferencedObjects is a DefinedObject (not a DummyReference),
then the translation of the ReferencedObjects is the translation of
the DefinedObject.
If a ReferencedObjects is a DefinedObjectSet (not a DummyReference),
then the translation of the ReferencedObjects is the translation of
the DefinedObjectSet.
If a ReferencedObjects is a DummyReference, ParameterizedObject or
ParameterizedObjectSet, then the translation of the ReferencedObjects
is the translation of that DummyReference, ParameterizedObject or
ParameterizedObjectSet (see Section 5.9).
Aside: The in-line expansion of a ParameterizedObject or
ParameterizedObjectSet results in an Object or ObjectSet. A
ReferencedObjects that is an Object or ObjectSet is a notational
Legg Expires 20 April 2007 [Page 89]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
capability that does not exist in ASN.1 but is allowed in ASN.X to
avoid the need to manufacture a reference name for an expanded
parameterized definition.
13. EncodingControlSections Translation
If an EncodingControlSections contains at least one
EncodingControlSection with an encodingreference that is not RXER,
then the translation of the EncodingControlSections is an element
item with the [local name] "encodingControls". The translation of
each EncodingControlSection with an encodingreference that is not
RXER SHALL be appended to the [children] of the <encodingControls>
element item.
Aside: This is not suggesting that RXER encoding control sections
are ignored. Encoding control sections for RXER are not
explicitly represented in ASN.X, but rather affect how an ASN.1
specification is translated into an ASN.X document. The effect of
an RXER encoding control section on the translation is addressed
in other parts of this specification.
Encoding control sections for other encoding rules will have
explicit representations in ASN.X.
If the encodingreference in an EncodingControlSection is GSER, then
the translation of the EncodingControlSection is an element item with
the [local name] "GSER". The translation of the
EncodingInstructionAssignmentList SHALL be added to the [children] or
[attributes] of the <GSER> element item.
The EncodingInstructionAssignmentList notation is different for each
set of encoding instructions. The translation into ASN.X of an
EncodingInstructionAssignmentList for GSER is specified in a separate
document [GSEREIT].
Aside: The translation of an EncodingInstructionAssignmentList for
GSER, as it is currently defined, is always empty.
If the encodingreference in an EncodingControlSection is XER, then
the translation of the EncodingControlSection is an element item with
the [local name] "XER". The translation of the
EncodingInstructionAssignmentList SHALL be added to the [children] or
[attributes] of the <XER> element item. The translation into ASN.X
of an EncodingInstructionAssignmentList for XER is specified in a
separate document [XEREIT].
14. Security Considerations
Legg Expires 20 April 2007 [Page 90]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The ASN.X translation of an ASN.1 specification is semantically
equivalent to the original ASN.1 specification. The security
considerations that apply to an application built from the original
ASN.1 specification apply equally to an application built from the
ASN.X translation.
Syntax-based canonicalization for XML documents (e.g., Canonical XML
[CXML]) depends on the Infoset of an XML document being preserved.
However, the Infoset representation of an ASN.X document (an abstract
value of the ModuleDefinition ASN.1 type) potentially changes if it
is decoded and re-encoded, disrupting the Canonical XML
representation. To avoid this problem, ASN.X documents must be
normalized prior to the application of syntax-based canonicalization.
The normalization rules can be found in Section 5.12 of the
specification for RXER [RXER].
15. Acknowledgements
The technology described in this document is the product of a
research project begun jointly by Adacel Technologies Limited and
Deakin University, and subsequently refined and completed by eB2Bcom.
16. IANA Considerations
This document has no actions for IANA.
17. References
17.1. Normative References
[BCP14] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119, March 1997.
[URI] Berners-Lee, T., Fielding, R. and L. Masinter, "Uniform
Resource Identifiers (URI): Generic Syntax", STD 66, RFC
3986, January 2005.
[GSER] Legg, S., "Generic String Encoding Rules (GSER) for ASN.1
Types", RFC 3641, October 2003.
[GSEREI] Legg, S., "Encoding Instructions for the Generic String
Encoding Rules (GSER)", draft-legg-ldap-gser-ei-xx.txt, a
work in progress, August 2006.
[RXER] Legg, S. and D. Prager, "Robust XML Encoding Rules (RXER)
for Abstract Syntax Notation One (ASN.1)",
draft-legg-xed-rxer-xx.txt, a work in progress, October
2006.
Legg Expires 20 April 2007 [Page 91]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
[RXEREI] Legg, S., "Encoding Instructions for the Robust XML
Encoding Rules (RXER)", draft-legg-xed-rxer-ei-xx.txt, a
work in progress, October 2006.
[GSEREIT] Legg, S., "Abstract Syntax Notation X (ASN.X)
Representation of Encoding Instructions for the Generic
String Encoding Rules (GSER)",
draft-legg-xed-asd-gserei-xx.txt, a work in progress,
October 2006.
[XEREIT] Legg, S., "Abstract Syntax Notation X (ASN.X)
Representation of Encoding Instructions for the XML
Encoding Rules (XER)", draft-legg-xed-asd-xerei-xx.txt, a
work in progress, October 2006.
[X.680] ITU-T Recommendation X.680 (07/02) | ISO/IEC 8824-1,
Information technology - Abstract Syntax Notation One
(ASN.1): Specification of basic notation.
[X.680-1] ITU-T Recommendation X.680 (2002) Amendment 1 (10/03) |
ISO/IEC 8824-1:2002/Amd 1:2004, Support for EXTENDED-XER.
[X.681] ITU-T Recommendation X.681 (07/02) | ISO/IEC 8824-2,
Information technology - Abstract Syntax Notation One
(ASN.1): Information object specification.
[X.682] ITU-T Recommendation X.682 (07/02) | ISO/IEC 8824-3,
Information technology - Abstract Syntax Notation One
(ASN.1): Constraint specification.
[X.683] ITU-T Recommendation X.683 (07/02) | ISO/IEC 8824-4,
Information technology - Abstract Syntax Notation One
(ASN.1): Parameterization of ASN.1 specifications.
[X.693] ITU-T Recommendation X.693 (12/01) | ISO/IEC 8825-4:2002,
Information technology - ASN.1 encoding rules: XML
encoding rules (XER)
[X.693-1] Amendment 1: (to ITU-T Rec. X.693 | ISO/IEC 8825-4) XER
encoding instructions and EXTENDED-XER
[XML10] Bray, T., Paoli, J., Sperberg-McQueen, C., Maler, E. and
F. Yergeau, "Extensible Markup Language (XML) 1.0 (Fourth
Edition)", W3C Recommendation,
http://www.w3.org/TR/2006/REC-xml-20060816, August 2006.
[XML11] Bray, T., Paoli, J., Sperberg-McQueen, C., Maler, E.,
Yergeau, F., and J. Cowan, "Extensible Markup Language
Legg Expires 20 April 2007 [Page 92]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
(XML) 1.1 (Second Edition)", W3C Recommendation,
http://www.w3.org/TR/2006/REC-xml11-20060816, August 2006.
[XMLNS10] Bray, T., Hollander, D., Layman, A., and R. Tobin,
"Namespaces in XML 1.0 (Second Edition)", W3C
Recommendation,
http://www.w3.org/TR/2006/REC-xml-names-20060816, August
2006.
[XMLNS11] Bray, T., Hollander, D., Layman, A. and R. Tobin,
"Namespaces in XML 1.1 (Second Edition)", W3C
Recommendation,
http://www.w3.org/TR/2004/REC-xml-names11-20040204, August
2006.
[ISET] Cowan, J. and R. Tobin, "XML Information Set (Second
Edition)", W3C Recommendation,
http://www.w3.org/TR/2004/REC-xml-infoset-20040204,
February 2004.
[UNICODE] The Unicode Consortium, "The Unicode Standard, Version
4.0", Boston, MA, Addison-Wesley Developers Press, 2003.
ISBN 0-321-18578-1.
17.2. Informative References
[CXML] Boyer, J., "Canonical XML Version 1.0", W3C
Recommendation,
http://www.w3.org/TR/2001/REC-xml-c14n-20010315, March
2001.
[XSD1] Thompson, H., Beech, D., Maloney, M. and N. Mendelsohn,
"XML Schema Part 1: Structures Second Edition", W3C
Recommendation,
http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/,
October 2004.
[RNG] Clark, J. and M. Makoto, "RELAX NG Tutorial", OASIS
Committee Specification, http://www.oasis-
open.org/committees/relax-ng/tutorial-20011203.html,
December 2001.
Appendix A. ASN.1 for ASN.X
This appendix is normative.
AbstractSyntaxNotation-X
{ iso(1) identified-organization(3) dod(6)
Legg Expires 20 April 2007 [Page 93]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
internet(1) private(4) enterprise(1)
xmled(21472) asnx(1) module(0) notation(1) }
-- Copyright (C) The Internet Society (2006). This version of
-- this ASN.1 module is part of RFC XXXX; see the RFC itself
-- for full legal notices.
DEFINITIONS
RXER INSTRUCTIONS
AUTOMATIC TAGS
EXTENSIBILITY IMPLIED ::= BEGIN
IMPORTS
Markup,
AnyURI,
NCName,
Name,
QName
FROM AdditionalBasicDefinitions
{ iso(1) identified-organization(3) dod(6)
internet(1) private(4) enterprise(1)
xmled(21472) asnx(1) module(0) basic(0) }
GSER-EncodingInstruction,
GSER-EncodingInstructionAssignmentList
FROM GSER-EncodingInstructionNotation
{ iso(1) identified-organization(3) dod(6)
internet(1) private(4) enterprise(1)
xmled(21472) asnx(1) module(0) gser-ei-notation(2) }
XER-EncodingInstruction,
XER-EncodingInstructionAssignmentList
FROM XER-EncodingInstructionNotation
{ iso(1) identified-organization(3) dod(6)
internet(1) private(4) enterprise(1)
xmled(21472) asnx(1) module(0) xer-ei-notation(3) }
;
ModuleDefinition ::= [HOLLOW-INSERTIONS] SEQUENCE {
annotation Annotation OPTIONAL,
format [ATTRIBUTE] [VERSION-INDICATOR]
UTF8String ("1.0", ...) DEFAULT "1.0",
name [ATTRIBUTE] ModuleReference,
identifier [ATTRIBUTE] DefinitiveIdentifier OPTIONAL,
schemaIdentity [ATTRIBUTE] AnyURI OPTIONAL,
targetNamespace [ATTRIBUTE] AnyURI OPTIONAL,
targetPrefix [ATTRIBUTE] NCName OPTIONAL,
tagDefault [ATTRIBUTE] TagDefault DEFAULT automatic,
extensibilityImplied [ATTRIBUTE] BOOLEAN DEFAULT FALSE,
export SEQUENCE { } OPTIONAL,
Legg Expires 20 April 2007 [Page 94]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
-- export is not used in this version
imports [GROUP] ImportList OPTIONAL,
assignments [GROUP] AssignmentList OPTIONAL,
encodingControls EncodingControlSections OPTIONAL
}
ModuleReference ::= TypeReference
DefinitiveIdentifier ::= OBJECT IDENTIFIER
TagDefault ::= ENUMERATED { explicit, implicit, automatic }
Annotation ::= Markup
ImportList ::= SEQUENCE SIZE (1..MAX) OF import Import
Import ::= SEQUENCE {
name [ATTRIBUTE] ModuleReference OPTIONAL,
identifier [ATTRIBUTE] DefinitiveIdentifier OPTIONAL,
schemaIdentity [ATTRIBUTE] AnyURI OPTIONAL,
namespace [ATTRIBUTE] AnyURI OPTIONAL,
schemaLocation [ATTRIBUTE] AnyURI OPTIONAL
}
AssignmentList ::= SEQUENCE SIZE (1..MAX) OF
assignment [GROUP] Assignment
Assignment ::= [NO-INSERTIONS] CHOICE {
namedType TypeAssignment,
namedValue ValueAssignment,
namedValueSet ValueSetTypeAssignment,
namedClass ObjectClassAssignment,
namedObject ObjectAssignment,
namedObjectSet ObjectSetAssignment,
component [GROUP] TopLevelNamedType
}
TypeAssignment ::= SEQUENCE {
annotation Annotation OPTIONAL,
name [ATTRIBUTE] TypeReference,
type [GROUP] Type
}
TypeReference ::= UTF8String (PATTERN "[A-Z]\w*(-\w+)*")
-- \w is equivalent to [a-zA-Z0-9]
ValueAssignment ::= SEQUENCE {
annotation Annotation OPTIONAL,
Legg Expires 20 April 2007 [Page 95]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
name [ATTRIBUTE] ValueReference,
type [GROUP] Type,
value [GROUP] Value
}
ValueReference ::= Identifier
Identifier ::= UTF8String (PATTERN "[a-z]\w(-\w+)*")
ValueSetTypeAssignment ::= SEQUENCE {
annotation Annotation OPTIONAL,
name [ATTRIBUTE] TypeReference,
type [GROUP] Type,
valueSet [GROUP] ValueSet
}
ObjectClassAssignment ::= SEQUENCE {
annotation Annotation OPTIONAL,
name [ATTRIBUTE] ObjectClassReference,
objectClass [GROUP] ObjectClass
}
ObjectClassReference ::= UTF8String
(PATTERN "[A-Z][A-Z0-9]*(-[A-Z0-9]+)*")
ObjectAssignment ::= SEQUENCE {
annotation Annotation OPTIONAL,
name [ATTRIBUTE] ObjectReference,
objectClass [GROUP] DefinedObjectClass,
object [GROUP] Object
}
ObjectReference ::= ValueReference
ObjectSetAssignment ::= SEQUENCE {
annotation Annotation OPTIONAL,
name [ATTRIBUTE] ObjectSetReference,
objectClass [GROUP] DefinedObjectClass,
objectSet [GROUP] ObjectSet
}
ObjectSetReference ::= TypeReference
TopLevelNamedType ::= NamedType
(WITH COMPONENTS { ...,
component (WITH COMPONENTS { ...,
definition (WITH COMPONENTS { ..., reference ABSENT })
}),
Legg Expires 20 April 2007 [Page 96]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
element (WITH COMPONENTS { ...,
definition (WITH COMPONENTS { ..., reference ABSENT })
}),
attribute (WITH COMPONENTS { ...,
definition (WITH COMPONENTS { ..., reference ABSENT })
}),
group ABSENT,
member ABSENT,
item ABSENT })
NamedType ::= [SINGULAR-INSERTIONS] CHOICE {
component Element,
element Element,
attribute Attribute,
group InvisibleNamedType,
member InvisibleNamedType,
item InvisibleNamedType
}
Attribute ::= GenericNamedType
(WITH COMPONENTS { ...,
definition (WITH COMPONENTS { ...,
local (WITH COMPONENTS { ...,
typeAsVersion ABSENT }) }) })
Element ::= GenericNamedType
(WITH COMPONENTS { ...,
definition (WITH COMPONENTS { ...,
local (WITH COMPONENTS { ...,
versionIndicator ABSENT }) }) })
InvisibleNamedType ::= GenericNamedType
(WITH COMPONENTS { ...,
definition (WITH COMPONENTS { ...,
reference ABSENT,
local (WITH COMPONENTS { ...,
typeAsVersion ABSENT,
versionIndicator ABSENT }) }) })
GenericNamedType ::= [HOLLOW-INSERTIONS] SEQUENCE {
annotation Annotation OPTIONAL,
identifier [ATTRIBUTE] IdentifierOrEmpty OPTIONAL,
definition [GROUP] CHOICE {
reference [GROUP] DefinedComponent,
local [GROUP] LocalComponent
}
}
Legg Expires 20 April 2007 [Page 97]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
IdentifierOrEmpty ::= UTF8String (INCLUDES Identifier | "")
DefinedComponent ::= [HOLLOW-INSERTIONS] SEQUENCE {
name [GROUP] [NO-INSERTIONS] CHOICE {
ref [ATTRIBUTE] QName,
elementType [ATTRIBUTE] Name
},
namespace [ATTRIBUTE] AnyURI OPTIONAL,
context [ATTRIBUTE] AnyURI OPTIONAL,
embedded [ATTRIBUTE] BOOLEAN OPTIONAL,
prefixes [GROUP] EncodingPrefixes OPTIONAL
}
(WITH COMPONENTS { ...,
name (WITH COMPONENTS { ref PRESENT }),
namespace ABSENT } |
WITH COMPONENTS { ...,
name (WITH COMPONENTS { elementType PRESENT }),
embedded ABSENT })
LocalComponent ::= SEQUENCE {
name [ATTRIBUTE] NCName,
typeAsVersion [ATTRIBUTE] BOOLEAN OPTIONAL,
versionIndicator [ATTRIBUTE] BOOLEAN OPTIONAL,
type [GROUP] Type
}
Type ::= [NO-INSERTIONS] CHOICE {
typeRef [NAME AS "type"] [ATTRIBUTE] QName,
type ElementFormType
}
ElementFormType ::= [HOLLOW-INSERTIONS] SEQUENCE {
annotation Annotation OPTIONAL,
explicit [ATTRIBUTE] BOOLEAN DEFAULT FALSE,
definition [GROUP] CHOICE {
reference [GROUP] DefinedType,
expanded ExpandedType,
ancestor [ATTRIBUTE] INTEGER (1..MAX),
namedBitList NamedBitList,
namedNumberList NamedNumberList,
enumerated EnumeratedType,
tagged TaggedType,
prefixed EncodingPrefixedType,
selection SelectionType,
instanceOf InstanceOfType,
fromClass ObjectClassFieldType,
fromObjects InformationFromObjects,
sequence SequenceType,
Legg Expires 20 April 2007 [Page 98]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
set SetType,
choice ChoiceType,
union UnionType,
sequenceOf SequenceOfType,
setOf SetOfType,
list ListType,
constrained ConstrainedType
}
}
DefinedType ::= SEQUENCE {
name [GROUP] [NO-INSERTIONS] CHOICE {
ref [ATTRIBUTE] QName,
elementType [ATTRIBUTE] Name
},
namespace [ATTRIBUTE] AnyURI OPTIONAL,
context [ATTRIBUTE] AnyURI OPTIONAL,
embedded [ATTRIBUTE] BOOLEAN OPTIONAL
}
(WITH COMPONENTS { ...,
name (WITH COMPONENTS { ref PRESENT }),
namespace ABSENT } |
WITH COMPONENTS { ...,
name (WITH COMPONENTS { elementType PRESENT }),
embedded ABSENT })
ExpandedType ::= SEQUENCE {
name [ATTRIBUTE] NCName OPTIONAL,
module ReferencedModule OPTIONAL,
type [GROUP] Type
}
ReferencedModule ::= SEQUENCE {
name [ATTRIBUTE] ModuleReference OPTIONAL,
identifier [ATTRIBUTE] DefinitiveIdentifier OPTIONAL,
schemaIdentity [ATTRIBUTE] AnyURI OPTIONAL
}
NamedBitList ::= SEQUENCE SIZE (1..MAX) OF namedBit NamedBit
NamedBit ::= SEQUENCE {
name [ATTRIBUTE] NCName,
identifier [ATTRIBUTE] Identifier OPTIONAL,
bit [ATTRIBUTE] INTEGER (0..MAX)
}
NamedNumberList ::= SEQUENCE SIZE (1..MAX) OF
namedNumber NamedNumber
Legg Expires 20 April 2007 [Page 99]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
NamedNumber ::= SEQUENCE {
name [ATTRIBUTE] NCName,
identifier [ATTRIBUTE] Identifier OPTIONAL,
number [ATTRIBUTE] INTEGER
}
EnumeratedType ::= SEQUENCE {
root [GROUP] Enumeration,
extension SEQUENCE {
exception ExceptionSpec OPTIONAL,
additions [GROUP] Enumeration OPTIONAL
} OPTIONAL
}
Enumeration ::= SEQUENCE SIZE (1..MAX) OF
enumeration EnumerationItem
EnumerationItem ::= SEQUENCE {
name [ATTRIBUTE] NCName,
identifier [ATTRIBUTE] Identifier OPTIONAL,
number [ATTRIBUTE] INTEGER OPTIONAL
}
Tag ::= SEQUENCE {
tagClass [ATTRIBUTE] TagClass OPTIONAL,
number [ATTRIBUTE] INTEGER (0..MAX),
tagging [ATTRIBUTE] Tagging OPTIONAL
}
TaggedType ::= SEQUENCE {
COMPONENTS OF Tag,
type [GROUP] Type
}
TagClass ::= ENUMERATED { universal, application, private }
Tagging ::= ENUMERATED { explicit, implicit }
EncodingPrefixedType ::= [HOLLOW-INSERTIONS] SEQUENCE {
prefixes [GROUP] EncodingPrefixes,
type [GROUP] Type
}
EncodingPrefixes ::= SEQUENCE SIZE (1..MAX) OF
prefix [GROUP] EncodingPrefix
EncodingPrefix ::= [SINGULAR-INSERTIONS] CHOICE {
tag [NAME AS "TAG"] Tag,
Legg Expires 20 April 2007 [Page 100]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
gser [NAME AS "GSER"] GSER-EncodingInstruction,
xer [NAME AS "XER"] XER-EncodingInstruction
-- plus encoding instructions
-- for other encoding rules in the future
}
SelectionType ::= SEQUENCE {
alternative [GROUP] [SINGULAR-INSERTIONS] CHOICE {
component [ATTRIBUTE] QName,
element [ATTRIBUTE] QName,
attribute [ATTRIBUTE] QName,
group [ATTRIBUTE] QName,
member [ATTRIBUTE] QName
},
type [GROUP] Type
}
InstanceOfType ::= DefinedObjectClass
ObjectClassFieldType ::= SEQUENCE {
objectClass [GROUP] DefinedObjectClass,
fieldName [GROUP] FieldName
}
FieldName ::= [SINGULAR-INSERTIONS] CHOICE {
fieldNameAtt [NAME AS "fieldName"]
[ATTRIBUTE] PrimitiveFieldNames,
fieldName PrimitiveFieldNames
}
PrimitiveFieldNames ::= UTF8String
InformationFromObjects ::= [HOLLOW-INSERTIONS] SEQUENCE {
referencedObjects [GROUP] ReferencedObjects,
fieldName [GROUP] FieldName
}
ReferencedObjects ::= [SINGULAR-INSERTIONS] CHOICE {
object [GROUP] Object,
objectSet [GROUP] ObjectSet
}
Insertions ::=
ENUMERATED { none, hollow, singular, uniform, multiform }
SequenceType ::= [HOLLOW-INSERTIONS] SEQUENCE {
insertions [ATTRIBUTE] Insertions OPTIONAL,
root [GROUP] ComponentTypeList OPTIONAL,
Legg Expires 20 April 2007 [Page 101]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
extensionAndFinal [GROUP] [HOLLOW-INSERTIONS] SEQUENCE {
extension [HOLLOW-INSERTIONS] SEQUENCE {
exception ExceptionSpec OPTIONAL,
additions [GROUP] ExtensionAdditions OPTIONAL
},
root [GROUP] ComponentTypeList OPTIONAL
} OPTIONAL
}
ComponentTypeList ::= SEQUENCE SIZE (1..MAX) OF
componentType [GROUP] ComponentType
ComponentType ::= [NO-INSERTIONS] CHOICE {
component [GROUP] SequenceNamedType,
optional SEQUENCE {
component [GROUP] SequenceNamedType,
default Value OPTIONAL
},
componentsOf Type
}
SequenceNamedType ::= NamedType
(WITH COMPONENTS { ..., member ABSENT, item ABSENT })
ExtensionAdditions ::= SEQUENCE SIZE (1..MAX) OF
addition [GROUP] ExtensionAddition
ExtensionAddition ::= [NO-INSERTIONS] CHOICE {
extensionGroup ExtensionAdditionGroup,
componentType [GROUP] ComponentType
}
ExtensionAdditionGroup ::= [HOLLOW-INSERTIONS] SEQUENCE {
version [ATTRIBUTE] VersionNumber OPTIONAL,
componentTypes [GROUP] ComponentTypeList
}
VersionNumber ::= INTEGER (2..MAX)
SetType ::= SequenceType
ChoiceOrUnionType ::= [HOLLOW-INSERTIONS] SEQUENCE {
insertions [ATTRIBUTE] Insertions OPTIONAL,
precedence [ATTRIBUTE] PrecedenceList OPTIONAL,
root [GROUP] AlternativeTypeList,
extension [HOLLOW-INSERTIONS] SEQUENCE {
exception ExceptionSpec OPTIONAL,
additions [GROUP] ExtensionAdditionAlternatives OPTIONAL
Legg Expires 20 April 2007 [Page 102]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
} OPTIONAL
}
PrecedenceList ::= [LIST] SEQUENCE SIZE (1..MAX) OF member QName
AlternativeTypeList ::= SEQUENCE SIZE (1..MAX) OF
component [GROUP] ChoiceOrUnionNamedType
ChoiceOrUnionNamedType ::= NamedType
(WITH COMPONENTS { ..., item ABSENT })
ExtensionAdditionAlternatives ::= SEQUENCE SIZE (1..MAX) OF
addition [GROUP] ExtensionAdditionAlternative
ExtensionAdditionAlternative ::= [NO-INSERTIONS] CHOICE {
extensionGroup ExtensionAdditionAlternativesGroup,
component [GROUP] ChoiceOrUnionNamedType
}
ExtensionAdditionAlternativesGroup ::= [HOLLOW-INSERTIONS] SEQUENCE {
version [ATTRIBUTE] VersionNumber OPTIONAL,
alternatives [GROUP] AlternativeTypeList
}
ChoiceType ::= ChoiceOrUnionType
(WITH COMPONENTS { ...,
precedence ABSENT,
root (WITH COMPONENT (INCLUDES ChoiceNamedType)),
extension (WITH COMPONENTS { ...,
additions (WITH COMPONENT (WITH COMPONENTS { ...,
extensionGroup (WITH COMPONENTS { ...,
alternatives (WITH COMPONENT
(INCLUDES ChoiceNamedType)) }),
component (INCLUDES ChoiceNamedType) })) }) })
ChoiceNamedType ::= ChoiceOrUnionNamedType
(WITH COMPONENTS { ..., member ABSENT })
UnionType ::= ChoiceOrUnionType
(WITH COMPONENTS { ...,
insertions ABSENT,
root (WITH COMPONENT (INCLUDES UnionNamedType)),
extension (WITH COMPONENTS { ...,
additions (WITH COMPONENT (WITH COMPONENTS { ...,
extensionGroup (WITH COMPONENTS { ...,
alternatives (WITH COMPONENT
(INCLUDES UnionNamedType)) }),
component (INCLUDES UnionNamedType) })) }) })
Legg Expires 20 April 2007 [Page 103]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
UnionNamedType ::= ChoiceOrUnionNamedType
(WITH COMPONENTS { ...,
component ABSENT,
element ABSENT,
attribute ABSENT,
group ABSENT })
SequenceOfOrListType ::= SEQUENCE {
minSize [ATTRIBUTE] INTEGER (0..MAX) OPTIONAL,
maxSize [ATTRIBUTE] INTEGER (0..MAX) OPTIONAL,
component [GROUP] NamedType
(WITH COMPONENTS { ...,
attribute ABSENT, member ABSENT })
}
SequenceOfType ::= SequenceOfOrListType
(WITH COMPONENTS { ...,
component (WITH COMPONENTS { ..., item ABSENT }) })
SetOfType ::= SequenceOfType
ListType ::= SequenceOfOrListType
(WITH COMPONENTS { ...,
component (WITH COMPONENTS { ...,
component ABSENT,
element ABSENT,
group ABSENT }) })
ConstrainedType ::= [HOLLOW-INSERTIONS] SEQUENCE {
type [GROUP] Type,
constraint [GROUP] Constraint
}
Constraint ::= SEQUENCE {
constraintSpec [GROUP] [NO-INSERTIONS] CHOICE {
subtype [GROUP] ElementSetSpecs,
constrainedBy UserDefinedConstraint,
table TableConstraint,
contents ContentsConstraint
},
exception ExceptionSpec OPTIONAL
}
UserDefinedConstraint ::= [HOLLOW-INSERTIONS] SEQUENCE {
annotation Annotation OPTIONAL,
parameters [GROUP] ConstraintParameters OPTIONAL
}
Legg Expires 20 April 2007 [Page 104]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
ConstraintParameters ::= SEQUENCE SIZE (1..MAX) OF
parameter [GROUP] UserDefinedConstraintParameter
UserDefinedConstraintParameter ::= [SINGULAR-INSERTIONS] CHOICE {
valueParameter SEQUENCE {
type [GROUP] Type,
value [GROUP] Value
},
valueSetParameter SEQUENCE {
type [GROUP] Type,
valueSet [GROUP] ValueSet
},
objectParameter SEQUENCE {
objectClass [GROUP] DefinedObjectClass,
object [GROUP] Object
},
objectSetParameter SEQUENCE {
objectClass [GROUP] DefinedObjectClass,
objectSet [GROUP] ObjectSet
},
typeParameter SEQUENCE {
type [GROUP] Type
},
classParameter SEQUENCE {
objectClass [GROUP] DefinedObjectClass
}
}
TableConstraint ::= SEQUENCE {
objectSet [GROUP] ObjectSet,
componentRelation [GROUP] AtNotations OPTIONAL
}
AtNotations ::= SEQUENCE SIZE (1..MAX) OF
restrictBy AtNotation
AtNotation ::= Markup
ContentsConstraint ::= SEQUENCE {
containing Type OPTIONAL,
encodedBy Value OPTIONAL
} ((WITH COMPONENTS { ..., containing PRESENT }) |
(WITH COMPONENTS { ..., encodedBy PRESENT }))
ExceptionSpec ::= SEQUENCE {
type [GROUP] Type,
value [GROUP] Value
}
Legg Expires 20 April 2007 [Page 105]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
Value ::= [NO-INSERTIONS] CHOICE {
literalValueAtt [NAME AS "literalValue"] [ATTRIBUTE] UTF8String,
literalValue ElementFormLiteralValue,
valueRef [NAME AS "value"] [ATTRIBUTE] QName,
value ElementFormNotationalValue
}
ElementFormLiteralValue ::= Markup
-- If asnx:literal="false" then the governing type of
-- ElementFormLiteralValue is ElementFormNotationalValue.
ElementFormNotationalValue ::= [HOLLOW-INSERTIONS] SEQUENCE {
annotation Annotation OPTIONAL,
definition [GROUP] [NO-INSERTIONS] CHOICE {
reference [GROUP] Reference,
expanded ExpandedValue,
fromObjects InformationFromObjects,
openTypeValue SEQUENCE {
type [GROUP] Type,
value [GROUP] Value
},
components [GROUP] ComponentValueList
}
}
Reference ::= SEQUENCE {
ref [ATTRIBUTE] QName,
context [ATTRIBUTE] AnyURI OPTIONAL
}
ExpandedValue ::= SEQUENCE {
name [ATTRIBUTE] NCName OPTIONAL,
module ReferencedModule OPTIONAL,
value [GROUP] Value
}
ComponentValueList ::= SEQUENCE SIZE (1..MAX) OF
component [GROUP] NamedValue
NamedValue ::= [SINGULAR-INSERTIONS] CHOICE {
component GenericNamedValue,
element GenericNamedValue,
attribute GenericNamedValue,
group GenericNamedValue,
member GenericNamedValue,
item GenericNamedValue
}
Legg Expires 20 April 2007 [Page 106]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
GenericNamedValue ::= SEQUENCE {
name [ATTRIBUTE] QName,
value [GROUP] Value
}
ValueSet ::= [NO-INSERTIONS] CHOICE {
valueSetRef [NAME AS "valueSet"] [ATTRIBUTE] QName,
-- valueSetRef is not used in this version
valueSet ElementFormValueSet
}
ElementFormValueSet ::= [HOLLOW-INSERTIONS] SEQUENCE {
annotation Annotation OPTIONAL,
definition [GROUP] [NO-INSERTIONS] CHOICE {
elementSetSpecs [GROUP] ElementSetSpecs
}
}
ElementSetSpecs ::= [HOLLOW-INSERTIONS] SEQUENCE {
root [GROUP] ValueElementSetSpec,
extension [HOLLOW-INSERTIONS] SEQUENCE {
additions [GROUP] ValueElementSetSpec OPTIONAL
} OPTIONAL
}
ValueElementSetSpec ::= ElementSetSpec
(WITH COMPONENTS { ...,
object ABSENT,
objectSet ABSENT,
union (WITH COMPONENT (INCLUDES ValueElementSetSpec)),
intersection (WITH COMPONENT (INCLUDES ValueElementSetSpec)),
all (WITH COMPONENTS { ...,
elements (INCLUDES ValueElementSetSpec),
except (INCLUDES ValueElementSetSpec) }) })
ElementSetSpec ::= [SINGULAR-INSERTIONS] CHOICE {
literalValue ElementFormLiteralValue,
value ElementFormNotationalValue,
includes Type,
range ValueRange,
size Constraint,
typeConstraint Type,
from Constraint,
withComponent Constraint,
withComponents MultipleTypeConstraints,
pattern Value,
object ElementFormObject,
objectSet ElementFormObjectSet,
Legg Expires 20 April 2007 [Page 107]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
union ElementSetSpecList,
intersection ElementSetSpecList,
all SEQUENCE {
elements [GROUP] ElementSetSpec OPTIONAL,
except ElementSetSpec
}
}
ElementSetSpecList ::= SEQUENCE SIZE (2..MAX) OF
elements [GROUP] ElementSetSpec
ValueRange ::= SEQUENCE {
minimum [GROUP] [NO-INSERTIONS] CHOICE {
minInclusive EndValue,
minExclusive EndValue
} DEFAULT minInclusive:{},
maximum [GROUP] [NO-INSERTIONS] CHOICE {
maxInclusive EndValue,
maxExclusive EndValue
} DEFAULT maxInclusive:{}
}
EndValue ::= [HOLLOW-INSERTIONS] SEQUENCE {
value [GROUP] Value OPTIONAL
}
MultipleTypeConstraints ::= [HOLLOW-INSERTIONS] SEQUENCE {
partial [ATTRIBUTE] BOOLEAN DEFAULT FALSE,
typeConstraints [GROUP] TypeConstraints
}
TypeConstraints ::= SEQUENCE SIZE (1..MAX) OF
namedConstraint [GROUP] NamedConstraint
NamedConstraint ::= [SINGULAR-INSERTIONS] CHOICE {
component GenericNamedConstraint,
element GenericNamedConstraint,
attribute GenericNamedConstraint,
group GenericNamedConstraint,
member GenericNamedConstraint,
item GenericNamedConstraint
}
GenericNamedConstraint ::= [HOLLOW-INSERTIONS] SEQUENCE {
name [ATTRIBUTE] QName,
use [ATTRIBUTE] PresenceConstraint OPTIONAL,
constraint [GROUP] Constraint OPTIONAL
}
Legg Expires 20 April 2007 [Page 108]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
PresenceConstraint ::= ENUMERATED { present, absent, optional }
ObjectClass ::= [SINGULAR-INSERTIONS] CHOICE {
classRef [NAME AS "class"] [ATTRIBUTE] QName,
class ElementFormObjectClass
}
DefinedObjectClass ::= ObjectClass
(WITH COMPONENTS { ...,
class (WITH COMPONENTS { ...,
definition (WITH COMPONENTS { ...,
objectClassDefn ABSENT }) }) })
ElementFormObjectClass ::= [HOLLOW-INSERTIONS] SEQUENCE {
annotation Annotation OPTIONAL,
definition [GROUP] [NO-INSERTIONS] CHOICE {
reference [GROUP] Reference,
expanded ExpandedObjectClass,
objectClassDefn [GROUP] ObjectClassDefn
}
}
ExpandedObjectClass ::= SEQUENCE {
name [ATTRIBUTE] NCName OPTIONAL,
module ReferencedModule OPTIONAL,
objectClass [GROUP] ObjectClass
}
ObjectClassDefn ::= SEQUENCE SIZE (1..MAX) OF
fieldSpec [GROUP] FieldSpec
FieldSpec ::= [SINGULAR-INSERTIONS] CHOICE {
typeField TypeField,
valueField ValueField,
valueSetField ValueSetField,
objectField ObjectField,
objectSetField ObjectSetField,
optional OptionalField
}
OptionalField ::= SEQUENCE {
field [GROUP] [SINGULAR-INSERTIONS] CHOICE {
typeField TypeField,
valueField ValueField,
valueSetField ValueSetField,
objectField ObjectField,
objectSetField ObjectSetField
},
Legg Expires 20 April 2007 [Page 109]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
default Setting OPTIONAL
} (WITH COMPONENTS { ...,
field (WITH COMPONENTS { typeField PRESENT }),
default (WITH COMPONENTS { ...,
value ABSENT,
valueSet ABSENT,
object ABSENT,
objectSet ABSENT }) } |
WITH COMPONENTS { ...,
field (WITH COMPONENTS { valueField PRESENT }),
default (WITH COMPONENTS { ...,
type ABSENT,
valueSet ABSENT,
object ABSENT,
objectSet ABSENT }) } |
WITH COMPONENTS { ...,
field (WITH COMPONENTS { valueSetField PRESENT }),
default (WITH COMPONENTS { ...,
type ABSENT,
value ABSENT,
object ABSENT,
objectSet ABSENT }) } |
WITH COMPONENTS { ...,
field (WITH COMPONENTS { objectField PRESENT }),
default (WITH COMPONENTS { ...,
type ABSENT,
value ABSENT,
valueSet ABSENT,
objectSet ABSENT }) } |
WITH COMPONENTS { ...,
field (WITH COMPONENTS { objectSetField PRESENT }),
default (WITH COMPONENTS { ...,
type ABSENT,
value ABSENT,
valueSet ABSENT,
object ABSENT }) })
TypeField ::= SEQUENCE {
annotation Annotation OPTIONAL,
name [ATTRIBUTE] TypeFieldReference
}
TypeFieldReference ::= TypeReference
ValueField ::= SEQUENCE {
annotation Annotation OPTIONAL,
name [ATTRIBUTE] ValueFieldReference,
unique [ATTRIBUTE] BOOLEAN OPTIONAL,
Legg Expires 20 April 2007 [Page 110]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
governor [GROUP] [SINGULAR-INSERTIONS] CHOICE {
type [GROUP] Type,
typeFromField FieldName
}
} ((WITH COMPONENTS { ..., unique ABSENT }) |
(WITH COMPONENTS { ...,
governor (WITH COMPONENTS { ..., typeFromField ABSENT }) }))
ValueFieldReference ::= ValueReference
ValueSetField ::= SEQUENCE {
annotation Annotation OPTIONAL,
name [ATTRIBUTE] ValueSetFieldReference,
governor [GROUP] [SINGULAR-INSERTIONS] CHOICE {
type [GROUP] Type,
typeFromField FieldName
}
}
ValueSetFieldReference ::= TypeReference
ObjectField ::= SEQUENCE {
annotation Annotation OPTIONAL,
name [ATTRIBUTE] ObjectFieldReference,
objectClass [GROUP] DefinedObjectClass
}
ObjectFieldReference ::= ObjectReference
ObjectSetField ::= SEQUENCE {
annotation Annotation OPTIONAL,
name [ATTRIBUTE] ObjectSetFieldReference,
objectClass [GROUP] DefinedObjectClass
}
ObjectSetFieldReference ::= ObjectSetReference
Object ::= [NO-INSERTIONS] CHOICE {
objectRef [NAME AS "object"] [ATTRIBUTE] QName,
object ElementFormObject
}
ElementFormObject ::= [HOLLOW-INSERTIONS] SEQUENCE {
annotation Annotation OPTIONAL,
definition [GROUP] [SINGULAR-INSERTIONS] CHOICE {
reference [GROUP] Reference,
expanded ExpandedObject,
fromObjects InformationFromObjects,
Legg Expires 20 April 2007 [Page 111]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
fields [GROUP] ObjectDefn
}
}
ExpandedObject ::= SEQUENCE {
name [ATTRIBUTE] NCName OPTIONAL,
module ReferencedModule OPTIONAL,
object [GROUP] Object
}
ObjectDefn ::= SEQUENCE OF field FieldSetting
FieldSetting ::= [HOLLOW-INSERTIONS] SEQUENCE {
name [ATTRIBUTE] NCName,
setting [GROUP] Setting
}
Setting ::= CHOICE {
type [GROUP] Type,
value [GROUP] Value,
valueSet [GROUP] ValueSet,
object [GROUP] Object,
objectSet [GROUP] ObjectSet
}
ObjectSet ::= [NO-INSERTIONS] CHOICE {
objectSetRef [NAME AS "objectSet"] [ATTRIBUTE] QName,
objectSet ElementFormObjectSet
}
ElementFormObjectSet ::= [HOLLOW-INSERTIONS] SEQUENCE {
annotation Annotation OPTIONAL,
definition [GROUP] [NO-INSERTIONS] CHOICE {
reference [GROUP] Reference,
expanded ExpandedObjectSet,
objectSetSpec [GROUP] ObjectSetSpec,
fromObjects InformationFromObjects
}
}
ExpandedObjectSet ::= SEQUENCE {
name [ATTRIBUTE] NCName OPTIONAL,
module ReferencedModule OPTIONAL,
objectSet [GROUP] ObjectSet
}
ObjectSetSpec ::= [HOLLOW-INSERTIONS] SEQUENCE {
root [GROUP] ObjectElementSetSpec OPTIONAL,
Legg Expires 20 April 2007 [Page 112]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
extension [HOLLOW-INSERTIONS] SEQUENCE {
additions [GROUP] ObjectElementSetSpec OPTIONAL
} OPTIONAL
} ((WITH COMPONENTS { ..., root PRESENT }) |
(WITH COMPONENTS { ..., extension PRESENT }))
ObjectElementSetSpec ::= ElementSetSpec
(WITH COMPONENTS { ...,
literalValue ABSENT,
value ABSENT,
includes ABSENT,
range ABSENT,
size ABSENT,
typeConstraint ABSENT,
from ABSENT,
withComponent ABSENT,
withComponents ABSENT,
pattern ABSENT,
union (WITH COMPONENT (INCLUDES ObjectElementSetSpec)),
intersection (WITH COMPONENT (INCLUDES ObjectElementSetSpec)),
all (WITH COMPONENTS { ...,
elements (INCLUDES ObjectElementSetSpec),
except (INCLUDES ObjectElementSetSpec) }) })
EncodingControlSections ::= SEQUENCE SIZE (1..MAX) OF
section [GROUP] EncodingControlSection
EncodingControlSection ::= [SINGULAR-INSERTIONS] CHOICE {
gser [NAME AS "GSER"] GSER-EncodingInstructionAssignmentList,
xer [NAME AS "XER"] XER-EncodingInstructionAssignmentList
-- plus encoding control sections
-- for other encoding rules in the future
}
ENCODING-CONTROL RXER
SCHEMA-IDENTITY "urn:oid:1.3.6.1.4.1.21472.1.0.1"
TARGET-NAMESPACE "urn:ietf:params:xml:ns:asnx" PREFIX "asnx"
COMPONENT module ModuleDefinition
COMPONENT literal [ATTRIBUTE] BOOLEAN
END
Appendix B. ASN.X for ASN.X
This appendix is non-normative.
Legg Expires 20 April 2007 [Page 113]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<?xml version="1.0"?>
<asnx:module xmlns:asnx="urn:ietf:params:xml:ns:asnx"
name="AbstractSyntaxNotation-X"
identifier="1.3.6.1.4.1.21472.1.0.1"
schemaIdentity="urn:oid:1.3.6.1.4.1.21472.1.0.1"
targetNamespace="urn:ietf:params:xml:ns:asnx"
targetPrefix="asnx"
extensibilityImplied="true">
<annotation>
Copyright (C) The Internet Society (2006). This version of
this ASN.X module is part of RFC XXXX; see the RFC itself
for full legal notices.
</annotation>
<import name="GSER-EncodingInstructionNotation"
identifier="1.3.6.1.4.1.21472.1.0.2"
schemaIdentity="urn:oid:1.3.6.1.4.1.21472.1.0.2"
namespace="urn:ietf:params:xml:ns:asnx"/>
<import name="XER-EncodingInstructionNotation"
identifier="1.3.6.1.4.1.21472.1.0.3"
schemaIdentity="urn:oid:1.3.6.1.4.1.21472.1.0.3"
namespace="urn:ietf:params:xml:ns:asnx"/>
<namedType name="ModuleDefinition">
<type>
<sequence insertions="hollow">
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<optional>
<attribute name="format" versionIndicator="true">
<type>
<constrained type="asnx:UTF8String">
<literalValue>1.0</literalValue>
<extension/>
</constrained>
</type>
</attribute>
<default literalValue="1.0"/>
</optional>
<attribute name="name" type="asnx:ModuleReference"/>
<optional>
<attribute name="identifier" type="asnx:DefinitiveIdentifier"/>
</optional>
<optional>
<attribute name="schemaIdentity" type="asnx:AnyURI"/>
Legg Expires 20 April 2007 [Page 114]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</optional>
<optional>
<attribute name="targetNamespace" type="asnx:AnyURI"/>
</optional>
<optional>
<attribute name="targetPrefix" type="asnx:NCName"/>
</optional>
<optional>
<attribute name="tagDefault" type="asnx:TagDefault"/>
<default literalValue="automatic"/>
</optional>
<optional>
<attribute name="extensibilityImplied" type="asnx:BOOLEAN"/>
<default literalValue="false"/>
</optional>
<optional>
<element name="export">
<annotation> export is not used in this version </annotation>
<type>
<sequence/>
</type>
</element>
</optional>
<optional>
<group name="imports" type="asnx:ImportList"/>
</optional>
<optional>
<group name="assignments" type="asnx:AssignmentList"/>
</optional>
<optional>
<element name="encodingControls"
type="asnx:EncodingControlSections"/>
</optional>
</sequence>
</type>
</namedType>
<namedType name="ModuleReference" type="asnx:TypeReference"/>
<namedType name="DefinitiveIdentifier"
type="asnx:OBJECT-IDENTIFIER"/>
<namedType name="TagDefault">
<type>
<enumerated>
<enumeration name="explicit"/>
<enumeration name="implicit"/>
<enumeration name="automatic"/>
Legg Expires 20 April 2007 [Page 115]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</enumerated>
</type>
</namedType>
<namedType name="Annotation" type="asnx:Markup"/>
<namedType name="ImportList">
<type>
<sequenceOf minSize="1">
<element name="import" type="asnx:Import"/>
</sequenceOf>
</type>
</namedType>
<namedType name="Import">
<type>
<sequence>
<optional>
<attribute name="name" type="asnx:ModuleReference"/>
</optional>
<optional>
<attribute name="identifier" type="asnx:DefinitiveIdentifier"/>
</optional>
<optional>
<attribute name="schemaIdentity" type="asnx:AnyURI"/>
</optional>
<optional>
<attribute name="namespace" type="asnx:AnyURI"/>
</optional>
<optional>
<attribute name="schemaLocation" type="asnx:AnyURI"/>
</optional>
</sequence>
</type>
</namedType>
<namedType name="AssignmentList">
<type>
<sequenceOf minSize="1">
<group name="assignment" type="asnx:Assignment"/>
</sequenceOf>
</type>
</namedType>
<namedType name="Assignment">
<type>
<choice insertions="none">
<element name="namedType" type="asnx:TypeAssignment"/>
Legg Expires 20 April 2007 [Page 116]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<element name="namedValue" type="asnx:ValueAssignment"/>
<element name="namedValueSet"
type="asnx:ValueSetTypeAssignment"/>
<element name="namedClass" type="asnx:ObjectClassAssignment"/>
<element name="namedObject" type="asnx:ObjectAssignment"/>
<element name="namedObjectSet" type="asnx:ObjectSetAssignment"/>
<group name="component" type="asnx:TopLevelNamedType"/>
</choice>
</type>
</namedType>
<namedType name="TypeAssignment">
<type>
<sequence>
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<attribute name="name" type="asnx:TypeReference"/>
<group name="type" type="asnx:Type"/>
</sequence>
</type>
</namedType>
<namedType name="TypeReference">
<type>
<constrained type="asnx:UTF8String">
<pattern literalValue="[A-Z]\w*(-\w+)*"/>
<!-- \w is equivalent to [a-zA-Z0-9] -->
</constrained>
</type>
</namedType>
<namedType name="ValueAssignment">
<type>
<sequence>
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<attribute name="name" type="asnx:ValueReference"/>
<group name="type" type="asnx:Type"/>
<group name="value" type="asnx:Value"/>
</sequence>
</type>
</namedType>
<namedType name="ValueReference" type="asnx:Identifier"/>
<namedType name="Identifier">
Legg Expires 20 April 2007 [Page 117]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<type>
<constrained type="asnx:UTF8String">
<pattern literalValue="[a-z]\w(-\w+)*"/>
</constrained>
</type>
</namedType>
<namedType name="ValueSetTypeAssignment">
<type>
<sequence>
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<attribute name="name" type="asnx:TypeReference"/>
<group name="type" type="asnx:Type"/>
<group name="valueSet" type="asnx:ValueSet"/>
</sequence>
</type>
</namedType>
<namedType name="ObjectClassAssignment">
<type>
<sequence>
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<attribute name="name" type="asnx:ObjectClassReference"/>
<group name="objectClass" type="asnx:ObjectClass"/>
</sequence>
</type>
</namedType>
<namedType name="ObjectClassReference">
<type>
<constrained type="asnx:UTF8String">
<pattern literalValue="[A-Z][A-Z0-9]*(-[A-Z0-9]+)*"/>
</constrained>
</type>
</namedType>
<namedType name="ObjectAssignment">
<type>
<sequence>
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<attribute name="name" type="asnx:ObjectReference"/>
<group name="objectClass" type="asnx:DefinedObjectClass"/>
Legg Expires 20 April 2007 [Page 118]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<group name="object" type="asnx:Object"/>
</sequence>
</type>
</namedType>
<namedType name="ObjectReference" type="asnx:ValueReference"/>
<namedType name="ObjectSetAssignment">
<type>
<sequence>
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<attribute name="name" type="asnx:ObjectSetReference"/>
<group name="objectClass" type="asnx:DefinedObjectClass"/>
<group name="objectSet" type="asnx:ObjectSet"/>
</sequence>
</type>
</namedType>
<namedType name="ObjectSetReference" type="asnx:TypeReference"/>
<namedType name="TopLevelNamedType">
<type>
<constrained type="asnx:NamedType">
<withComponents partial="true">
<element name="component">
<withComponents partial="true">
<group name="definition">
<withComponents partial="true">
<group name="reference" use="absent"/>
</withComponents>
</group>
</withComponents>
</element>
<element name="element">
<withComponents partial="true">
<group name="definition">
<withComponents partial="true">
<group name="reference" use="absent"/>
</withComponents>
</group>
</withComponents>
</element>
<element name="attribute">
<withComponents partial="true">
<group name="definition">
<withComponents partial="true">
Legg Expires 20 April 2007 [Page 119]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<group name="reference" use="absent"/>
</withComponents>
</group>
</withComponents>
</element>
<element name="group" use="absent"/>
<element name="member" use="absent"/>
<element name="item" use="absent"/>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="NamedType">
<type>
<choice insertions="singular">
<element name="component" type="asnx:Element"/>
<element name="element" type="asnx:Element"/>
<element name="attribute" type="asnx:Attribute"/>
<element name="group" type="asnx:InvisibleNamedType"/>
<element name="member" type="asnx:InvisibleNamedType"/>
<element name="item" type="asnx:InvisibleNamedType"/>
</choice>
</type>
</namedType>
<namedType name="Attribute">
<type>
<constrained type="asnx:GenericNamedType">
<withComponents partial="true">
<group name="definition">
<withComponents partial="true">
<group name="local">
<withComponents partial="true">
<attribute name="typeAsVersion" use="absent"/>
</withComponents>
</group>
</withComponents>
</group>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="Element">
<type>
<constrained type="asnx:GenericNamedType">
<withComponents partial="true">
Legg Expires 20 April 2007 [Page 120]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<group name="definition">
<withComponents partial="true">
<group name="local">
<withComponents partial="true">
<attribute name="versionIndicator" use="absent"/>
</withComponents>
</group>
</withComponents>
</group>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="InvisibleNamedType">
<type>
<constrained type="asnx:GenericNamedType">
<withComponents partial="true">
<group name="definition">
<withComponents partial="true">
<group name="reference" use="absent"/>
<group name="local">
<withComponents partial="true">
<attribute name="typeAsVersion" use="absent"/>
<attribute name="versionIndicator" use="absent"/>
</withComponents>
</group>
</withComponents>
</group>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="GenericNamedType">
<type>
<sequence insertions="hollow">
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<optional>
<attribute name="identifier" type="asnx:IdentifierOrEmpty"/>
</optional>
<group name="definition">
<type>
<choice>
<group name="reference" type="asnx:DefinedComponent"/>
<group name="local" type="asnx:LocalComponent"/>
Legg Expires 20 April 2007 [Page 121]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</choice>
</type>
</group>
</sequence>
</type>
</namedType>
<namedType name="IdentifierOrEmpty">
<type>
<constrained type="asnx:UTF8String">
<union>
<includes type="asnx:Identifier"/>
<literalValue></literalValue>
</union>
</constrained>
</type>
</namedType>
<namedType name="DefinedComponent">
<type>
<constrained>
<type>
<sequence insertions="hollow">
<group name="name">
<type>
<choice insertions="none">
<attribute name="ref" type="asnx:QName"/>
<attribute name="elementType" type="asnx:Name"/>
</choice>
</type>
</group>
<optional>
<attribute name="namespace" type="asnx:AnyURI"/>
</optional>
<optional>
<attribute name="context" type="asnx:AnyURI"/>
</optional>
<optional>
<attribute name="embedded" type="asnx:BOOLEAN"/>
</optional>
<optional>
<group name="prefixes" type="asnx:EncodingPrefixes"/>
</optional>
</sequence>
</type>
<union>
<withComponents partial="true">
<group name="name">
Legg Expires 20 April 2007 [Page 122]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<withComponents>
<attribute name="ref" use="present"/>
</withComponents>
</group>
<attribute name="namespace" use="absent"/>
</withComponents>
<withComponents partial="true">
<group name="name">
<withComponents>
<attribute name="elementType" use="present"/>
</withComponents>
</group>
<attribute name="embedded" use="absent"/>
</withComponents>
</union>
</constrained>
</type>
</namedType>
<namedType name="LocalComponent">
<type>
<sequence>
<attribute name="name" type="asnx:NCName"/>
<optional>
<attribute name="typeAsVersion" type="asnx:BOOLEAN"/>
</optional>
<optional>
<attribute name="versionIndicator" type="asnx:BOOLEAN"/>
</optional>
<group name="type" type="asnx:Type"/>
</sequence>
</type>
</namedType>
<namedType name="Type">
<type>
<choice insertions="none">
<attribute name="type" identifier="typeRef" type="asnx:QName"/>
<element name="type" type="asnx:ElementFormType"/>
</choice>
</type>
</namedType>
<namedType name="ElementFormType">
<type>
<sequence insertions="hollow">
<optional>
<element name="annotation" type="asnx:Annotation"/>
Legg Expires 20 April 2007 [Page 123]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</optional>
<optional>
<attribute name="explicit" type="asnx:BOOLEAN"/>
<default literalValue="false"/>
</optional>
<group name="definition">
<type>
<choice>
<group name="reference" type="asnx:DefinedType"/>
<element name="expanded" type="asnx:ExpandedType"/>
<attribute name="ancestor">
<type>
<constrained type="asnx:INTEGER">
<range>
<minInclusive literalValue="1"/>
</range>
</constrained>
</type>
</attribute>
<element name="namedBitList" type="asnx:NamedBitList"/>
<element name="namedNumberList" type="asnx:NamedNumberList"/>
<element name="enumerated" type="asnx:EnumeratedType"/>
<element name="tagged" type="asnx:TaggedType"/>
<element name="prefixed" type="asnx:EncodingPrefixedType"/>
<element name="selection" type="asnx:SelectionType"/>
<element name="instanceOf" type="asnx:InstanceOfType"/>
<element name="fromClass" type="asnx:ObjectClassFieldType"/>
<element name="fromObjects"
type="asnx:InformationFromObjects"/>
<element name="sequence" type="asnx:SequenceType"/>
<element name="set" type="asnx:SetType"/>
<element name="choice" type="asnx:ChoiceType"/>
<element name="union" type="asnx:UnionType"/>
<element name="sequenceOf" type="asnx:SequenceOfType"/>
<element name="setOf" type="asnx:SetOfType"/>
<element name="list" type="asnx:ListType"/>
<element name="constrained" type="asnx:ConstrainedType"/>
</choice>
</type>
</group>
</sequence>
</type>
</namedType>
<namedType name="DefinedType">
<type>
<constrained>
<type>
Legg Expires 20 April 2007 [Page 124]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<sequence>
<group name="name">
<type>
<choice insertions="none">
<attribute name="ref" type="asnx:QName"/>
<attribute name="elementType" type="asnx:Name"/>
</choice>
</type>
</group>
<optional>
<attribute name="namespace" type="asnx:AnyURI"/>
</optional>
<optional>
<attribute name="context" type="asnx:AnyURI"/>
</optional>
<optional>
<attribute name="embedded" type="asnx:BOOLEAN"/>
</optional>
</sequence>
</type>
<union>
<withComponents partial="true">
<group name="name">
<withComponents>
<attribute name="ref" use="present"/>
</withComponents>
</group>
<attribute name="namespace" use="absent"/>
</withComponents>
<withComponents partial="true">
<group name="name">
<withComponents>
<attribute name="elementType" use="present"/>
</withComponents>
</group>
<attribute name="embedded" use="absent"/>
</withComponents>
</union>
</constrained>
</type>
</namedType>
<namedType name="ExpandedType">
<type>
<sequence>
<optional>
<attribute name="name" type="asnx:NCName"/>
</optional>
Legg Expires 20 April 2007 [Page 125]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<optional>
<element name="module" type="asnx:ReferencedModule"/>
</optional>
<group name="type" type="asnx:Type"/>
</sequence>
</type>
</namedType>
<namedType name="ReferencedModule">
<type>
<sequence>
<optional>
<attribute name="name" type="asnx:ModuleReference"/>
</optional>
<optional>
<attribute name="identifier" type="asnx:DefinitiveIdentifier"/>
</optional>
<optional>
<attribute name="schemaIdentity" type="asnx:AnyURI"/>
</optional>
</sequence>
</type>
</namedType>
<namedType name="NamedBitList">
<type>
<sequenceOf minSize="1">
<element name="namedBit" type="asnx:NamedBit"/>
</sequenceOf>
</type>
</namedType>
<namedType name="NamedBit">
<type>
<sequence>
<attribute name="name" type="asnx:NCName"/>
<optional>
<attribute name="identifier" type="asnx:Identifier"/>
</optional>
<attribute name="bit">
<type>
<constrained type="asnx:INTEGER">
<range>
<minInclusive literalValue="0"/>
</range>
</constrained>
</type>
</attribute>
Legg Expires 20 April 2007 [Page 126]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</sequence>
</type>
</namedType>
<namedType name="NamedNumberList">
<type>
<sequenceOf minSize="1">
<element name="namedNumber" type="asnx:NamedNumber"/>
</sequenceOf>
</type>
</namedType>
<namedType name="NamedNumber">
<type>
<sequence>
<attribute name="name" type="asnx:NCName"/>
<optional>
<attribute name="identifier" type="asnx:Identifier"/>
</optional>
<attribute name="number" type="asnx:INTEGER"/>
</sequence>
</type>
</namedType>
<namedType name="EnumeratedType">
<type>
<sequence>
<group name="root" type="asnx:Enumeration"/>
<optional>
<element name="extension">
<type>
<sequence>
<optional>
<element name="exception" type="asnx:ExceptionSpec"/>
</optional>
<optional>
<group name="additions" type="asnx:Enumeration"/>
</optional>
</sequence>
</type>
</element>
</optional>
</sequence>
</type>
</namedType>
<namedType name="Enumeration">
<type>
Legg Expires 20 April 2007 [Page 127]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<sequenceOf minSize="1">
<element name="enumeration" type="asnx:EnumerationItem"/>
</sequenceOf>
</type>
</namedType>
<namedType name="EnumerationItem">
<type>
<sequence>
<attribute name="name" type="asnx:NCName"/>
<optional>
<attribute name="identifier" type="asnx:Identifier"/>
</optional>
<optional>
<attribute name="number" type="asnx:INTEGER"/>
</optional>
</sequence>
</type>
</namedType>
<namedType name="Tag">
<type>
<sequence>
<optional>
<attribute name="tagClass" type="asnx:TagClass"/>
</optional>
<attribute name="number">
<type>
<constrained type="asnx:INTEGER">
<range>
<minInclusive literalValue="0"/>
</range>
</constrained>
</type>
</attribute>
<optional>
<attribute name="tagging" type="asnx:Tagging"/>
</optional>
</sequence>
</type>
</namedType>
<namedType name="TaggedType">
<type>
<sequence>
<componentsOf type="asnx:Tag"/>
<group name="type" type="asnx:Type"/>
</sequence>
Legg Expires 20 April 2007 [Page 128]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</type>
</namedType>
<namedType name="TagClass">
<type>
<enumerated>
<enumeration name="universal"/>
<enumeration name="application"/>
<enumeration name="private"/>
</enumerated>
</type>
</namedType>
<namedType name="Tagging">
<type>
<enumerated>
<enumeration name="explicit"/>
<enumeration name="implicit"/>
</enumerated>
</type>
</namedType>
<namedType name="EncodingPrefixedType">
<type>
<sequence insertions="hollow">
<group name="prefixes" type="asnx:EncodingPrefixes"/>
<group name="type" type="asnx:Type"/>
</sequence>
</type>
</namedType>
<namedType name="EncodingPrefixes">
<type>
<sequenceOf minSize="1">
<group name="prefix" type="asnx:EncodingPrefix"/>
</sequenceOf>
</type>
</namedType>
<namedType name="EncodingPrefix">
<type>
<choice insertions="singular">
<element name="TAG" identifier="tag" type="asnx:Tag"/>
<element name="GSER" identifier="gser"
type="asnx:GSER-EncodingInstruction"/>
<element name="XER" identifier="xer"
type="asnx:XER-EncodingInstruction"/>
<!-- plus encoding instructions
Legg Expires 20 April 2007 [Page 129]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
for other encoding rules in the future -->
</choice>
</type>
</namedType>
<namedType name="SelectionType">
<type>
<sequence>
<group name="alternative">
<type>
<choice insertions="singular">
<attribute name="component" type="asnx:QName"/>
<attribute name="element" type="asnx:QName"/>
<attribute name="attribute" type="asnx:QName"/>
<attribute name="group" type="asnx:QName"/>
<attribute name="member" type="asnx:QName"/>
</choice>
</type>
</group>
<group name="type" type="asnx:Type"/>
</sequence>
</type>
</namedType>
<namedType name="InstanceOfType" type="asnx:DefinedObjectClass"/>
<namedType name="ObjectClassFieldType">
<type>
<sequence>
<group name="objectClass" type="asnx:DefinedObjectClass"/>
<group name="fieldName" type="asnx:FieldName"/>
</sequence>
</type>
</namedType>
<namedType name="FieldName">
<type>
<choice insertions="singular">
<attribute name="fieldName" identifier="fieldNameAtt"
type="asnx:PrimitiveFieldNames"/>
<element name="fieldName" type="asnx:PrimitiveFieldNames"/>
</choice>
</type>
</namedType>
<namedType name="PrimitiveFieldNames" type="asnx:UTF8String"/>
<namedType name="InformationFromObjects">
Legg Expires 20 April 2007 [Page 130]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<type>
<sequence insertions="hollow">
<group name="referencedObjects" type="asnx:ReferencedObjects"/>
<group name="fieldName" type="asnx:FieldName"/>
</sequence>
</type>
</namedType>
<namedType name="ReferencedObjects">
<type>
<choice insertions="singular">
<group name="object" type="asnx:Object"/>
<group name="objectSet" type="asnx:ObjectSet"/>
</choice>
</type>
</namedType>
<namedType name="Insertions">
<type>
<enumerated>
<enumeration name="none"/>
<enumeration name="hollow"/>
<enumeration name="singular"/>
<enumeration name="uniform"/>
<enumeration name="multiform"/>
</enumerated>
</type>
</namedType>
<namedType name="SequenceType">
<type>
<sequence insertions="hollow">
<optional>
<attribute name="insertions" type="asnx:Insertions"/>
</optional>
<optional>
<group name="root" type="asnx:ComponentTypeList"/>
</optional>
<optional>
<group name="extensionAndFinal">
<type>
<sequence insertions="hollow">
<element name="extension">
<type>
<sequence insertions="hollow">
<optional>
<element name="exception" type="asnx:ExceptionSpec"/>
</optional>
Legg Expires 20 April 2007 [Page 131]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<optional>
<group name="additions" type="asnx:ExtensionAdditions"/>
</optional>
</sequence>
</type>
</element>
<optional>
<group name="root" type="asnx:ComponentTypeList"/>
</optional>
</sequence>
</type>
</group>
</optional>
</sequence>
</type>
</namedType>
<namedType name="ComponentTypeList">
<type>
<sequenceOf minSize="1">
<group name="componentType" type="asnx:ComponentType"/>
</sequenceOf>
</type>
</namedType>
<namedType name="ComponentType">
<type>
<choice insertions="none">
<group name="component" type="asnx:SequenceNamedType"/>
<element name="optional">
<type>
<sequence>
<group name="component" type="asnx:SequenceNamedType"/>
<optional>
<element name="default" type="asnx:Value"/>
</optional>
</sequence>
</type>
</element>
<element name="componentsOf" type="asnx:Type"/>
</choice>
</type>
</namedType>
<namedType name="SequenceNamedType">
<type>
<constrained type="asnx:NamedType">
<withComponents partial="true">
Legg Expires 20 April 2007 [Page 132]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<element name="member" use="absent"/>
<element name="item" use="absent"/>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="ExtensionAdditions">
<type>
<sequenceOf minSize="1">
<group name="addition" type="asnx:ExtensionAddition"/>
</sequenceOf>
</type>
</namedType>
<namedType name="ExtensionAddition">
<type>
<choice insertions="none">
<element name="extensionGroup"
type="asnx:ExtensionAdditionGroup"/>
<group name="componentType" type="asnx:ComponentType"/>
</choice>
</type>
</namedType>
<namedType name="ExtensionAdditionGroup">
<type>
<sequence insertions="hollow">
<optional>
<attribute name="version" type="asnx:VersionNumber"/>
</optional>
<group name="componentTypes" type="asnx:ComponentTypeList"/>
</sequence>
</type>
</namedType>
<namedType name="VersionNumber">
<type>
<constrained type="asnx:INTEGER">
<range>
<minInclusive literalValue="2"/>
</range>
</constrained>
</type>
</namedType>
<namedType name="SetType" type="asnx:SequenceType"/>
Legg Expires 20 April 2007 [Page 133]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<namedType name="ChoiceOrUnionType">
<type>
<sequence insertions="hollow">
<optional>
<attribute name="insertions" type="asnx:Insertions"/>
</optional>
<optional>
<attribute name="precedence" type="asnx:PrecedenceList"/>
</optional>
<group name="root" type="asnx:AlternativeTypeList"/>
<optional>
<element name="extension">
<type>
<sequence insertions="hollow">
<optional>
<element name="exception" type="asnx:ExceptionSpec"/>
</optional>
<optional>
<group name="additions"
type="asnx:ExtensionAdditionAlternatives"/>
</optional>
</sequence>
</type>
</element>
</optional>
</sequence>
</type>
</namedType>
<namedType name="PrecedenceList">
<type>
<list minSize="1">
<item name="member" type="asnx:QName"/>
</list>
</type>
</namedType>
<namedType name="AlternativeTypeList">
<type>
<sequenceOf minSize="1">
<group name="component" type="asnx:ChoiceOrUnionNamedType"/>
</sequenceOf>
</type>
</namedType>
<namedType name="ChoiceOrUnionNamedType">
<type>
<constrained type="asnx:NamedType">
Legg Expires 20 April 2007 [Page 134]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<withComponents partial="true">
<element name="item" use="absent"/>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="ExtensionAdditionAlternatives">
<type>
<sequenceOf minSize="1">
<group name="addition" type="asnx:ExtensionAdditionAlternative"/>
</sequenceOf>
</type>
</namedType>
<namedType name="ExtensionAdditionAlternative">
<type>
<choice insertions="none">
<element name="extensionGroup"
type="asnx:ExtensionAdditionAlternativesGroup"/>
<group name="component" type="asnx:ChoiceOrUnionNamedType"/>
</choice>
</type>
</namedType>
<namedType name="ExtensionAdditionAlternativesGroup">
<type>
<sequence insertions="hollow">
<optional>
<attribute name="version" type="asnx:VersionNumber"/>
</optional>
<group name="alternatives" type="asnx:AlternativeTypeList"/>
</sequence>
</type>
</namedType>
<namedType name="ChoiceType">
<type>
<constrained type="asnx:ChoiceOrUnionType">
<withComponents partial="true">
<attribute name="precedence" use="absent"/>
<group name="root">
<withComponent>
<includes type="asnx:ChoiceNamedType"/>
</withComponent>
</group>
<element name="extension">
<withComponents partial="true">
Legg Expires 20 April 2007 [Page 135]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<group name="additions">
<withComponent>
<withComponents partial="true">
<element name="extensionGroup">
<withComponents partial="true">
<group name="alternatives">
<withComponent>
<includes type="asnx:ChoiceNamedType"/>
</withComponent>
</group>
</withComponents>
</element>
<group name="component">
<includes type="asnx:ChoiceNamedType"/>
</group>
</withComponents>
</withComponent>
</group>
</withComponents>
</element>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="ChoiceNamedType">
<type>
<constrained type="asnx:ChoiceOrUnionNamedType">
<withComponents partial="true">
<element name="member" use="absent"/>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="UnionType">
<type>
<constrained type="asnx:ChoiceOrUnionType">
<withComponents partial="true">
<attribute name="insertions" use="absent"/>
<group name="root">
<withComponent>
<includes type="asnx:UnionNamedType"/>
</withComponent>
</group>
<element name="extension">
<withComponents partial="true">
<group name="additions">
Legg Expires 20 April 2007 [Page 136]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<withComponent>
<withComponents partial="true">
<element name="extensionGroup">
<withComponents partial="true">
<group name="alternatives">
<withComponent>
<includes type="asnx:UnionNamedType"/>
</withComponent>
</group>
</withComponents>
</element>
<group name="component">
<includes type="asnx:UnionNamedType"/>
</group>
</withComponents>
</withComponent>
</group>
</withComponents>
</element>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="UnionNamedType">
<type>
<constrained type="asnx:ChoiceOrUnionNamedType">
<withComponents partial="true">
<element name="component" use="absent"/>
<element name="element" use="absent"/>
<element name="attribute" use="absent"/>
<element name="group" use="absent"/>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="SequenceOfOrListType">
<type>
<sequence>
<optional>
<attribute name="minSize">
<type>
<constrained type="asnx:INTEGER">
<range>
<minInclusive literalValue="0"/>
</range>
</constrained>
Legg Expires 20 April 2007 [Page 137]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</type>
</attribute>
</optional>
<optional>
<attribute name="maxSize">
<type>
<constrained type="asnx:INTEGER">
<range>
<minInclusive literalValue="0"/>
</range>
</constrained>
</type>
</attribute>
</optional>
<group name="component">
<type>
<constrained type="asnx:NamedType">
<withComponents partial="true">
<element name="attribute" use="absent"/>
<element name="member" use="absent"/>
</withComponents>
</constrained>
</type>
</group>
</sequence>
</type>
</namedType>
<namedType name="SequenceOfType">
<type>
<constrained type="asnx:SequenceOfOrListType">
<withComponents partial="true">
<group name="component">
<withComponents partial="true">
<element name="item" use="absent"/>
</withComponents>
</group>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="SetOfType" type="asnx:SequenceOfType"/>
<namedType name="ListType">
<type>
<constrained type="asnx:SequenceOfOrListType">
<withComponents partial="true">
Legg Expires 20 April 2007 [Page 138]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<group name="component">
<withComponents partial="true">
<element name="component" use="absent"/>
<element name="element" use="absent"/>
<element name="group" use="absent"/>
</withComponents>
</group>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="ConstrainedType">
<type>
<sequence insertions="hollow">
<group name="type" type="asnx:Type"/>
<group name="constraint" type="asnx:Constraint"/>
</sequence>
</type>
</namedType>
<namedType name="Constraint">
<type>
<sequence>
<group name="constraintSpec">
<type>
<choice insertions="none">
<group name="subtype" type="asnx:ElementSetSpecs"/>
<element name="constrainedBy"
type="asnx:UserDefinedConstraint"/>
<element name="table" type="asnx:TableConstraint"/>
<element name="contents" type="asnx:ContentsConstraint"/>
</choice>
</type>
</group>
<optional>
<element name="exception" type="asnx:ExceptionSpec"/>
</optional>
</sequence>
</type>
</namedType>
<namedType name="UserDefinedConstraint">
<type>
<sequence insertions="hollow">
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
Legg Expires 20 April 2007 [Page 139]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<optional>
<group name="parameters" type="asnx:ConstraintParameters"/>
</optional>
</sequence>
</type>
</namedType>
<namedType name="ConstraintParameters">
<type>
<sequenceOf minSize="1">
<group name="parameter"
type="asnx:UserDefinedConstraintParameter"/>
</sequenceOf>
</type>
</namedType>
<namedType name="UserDefinedConstraintParameter">
<type>
<choice insertions="singular">
<element name="valueParameter">
<type>
<sequence>
<group name="type" type="asnx:Type"/>
<group name="value" type="asnx:Value"/>
</sequence>
</type>
</element>
<element name="valueSetParameter">
<type>
<sequence>
<group name="type" type="asnx:Type"/>
<group name="valueSet" type="asnx:ValueSet"/>
</sequence>
</type>
</element>
<element name="objectParameter">
<type>
<sequence>
<group name="objectClass" type="asnx:DefinedObjectClass"/>
<group name="object" type="asnx:Object"/>
</sequence>
</type>
</element>
<element name="objectSetParameter">
<type>
<sequence>
<group name="objectClass" type="asnx:DefinedObjectClass"/>
<group name="objectSet" type="asnx:ObjectSet"/>
Legg Expires 20 April 2007 [Page 140]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</sequence>
</type>
</element>
<element name="typeParameter">
<type>
<sequence>
<group name="type" type="asnx:Type"/>
</sequence>
</type>
</element>
<element name="classParameter">
<type>
<sequence>
<group name="objectClass" type="asnx:DefinedObjectClass"/>
</sequence>
</type>
</element>
</choice>
</type>
</namedType>
<namedType name="TableConstraint">
<type>
<sequence>
<group name="objectSet" type="asnx:ObjectSet"/>
<optional>
<group name="componentRelation" type="asnx:AtNotations"/>
</optional>
</sequence>
</type>
</namedType>
<namedType name="AtNotations">
<type>
<sequenceOf minSize="1">
<element name="restrictBy" type="asnx:AtNotation"/>
</sequenceOf>
</type>
</namedType>
<namedType name="AtNotation" type="asnx:Markup"/>
<namedType name="ContentsConstraint">
<type>
<constrained>
<type>
<sequence>
<optional>
Legg Expires 20 April 2007 [Page 141]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<element name="containing" type="asnx:Type"/>
</optional>
<optional>
<element name="encodedBy" type="asnx:Value"/>
</optional>
</sequence>
</type>
<union>
<withComponents partial="true">
<element name="containing" use="present"/>
</withComponents>
<withComponents partial="true">
<element name="encodedBy" use="present"/>
</withComponents>
</union>
</constrained>
</type>
</namedType>
<namedType name="ExceptionSpec">
<type>
<sequence>
<group name="type" type="asnx:Type"/>
<group name="value" type="asnx:Value"/>
</sequence>
</type>
</namedType>
<namedType name="Value">
<type>
<choice insertions="none">
<attribute name="literalValue" identifier="literalValueAtt"
type="asnx:UTF8String"/>
<element name="literalValue"
type="asnx:ElementFormLiteralValue"/>
<attribute name="value" identifier="valueRef" type="asnx:QName"/>
<element name="value" type="asnx:ElementFormNotationalValue"/>
</choice>
</type>
</namedType>
<namedType name="ElementFormLiteralValue" type="asnx:Markup">
<annotation>
If asnx:literal="false" then the governing type of
ElementFormLiteralValue is ElementFormNotationalValue.
</annotation>
</namedType>
Legg Expires 20 April 2007 [Page 142]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<namedType name="ElementFormNotationalValue">
<type>
<sequence insertions="hollow">
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<group name="definition">
<type>
<choice insertions="none">
<group name="reference" type="asnx:Reference"/>
<element name="expanded" type="asnx:ExpandedValue"/>
<element name="fromObjects"
type="asnx:InformationFromObjects"/>
<element name="openTypeValue">
<type>
<sequence>
<group name="type" type="asnx:Type"/>
<group name="value" type="asnx:Value"/>
</sequence>
</type>
</element>
<group name="components" type="asnx:ComponentValueList"/>
</choice>
</type>
</group>
</sequence>
</type>
</namedType>
<namedType name="Reference">
<type>
<sequence>
<attribute name="ref" type="asnx:QName"/>
<optional>
<attribute name="context" type="asnx:AnyURI"/>
</optional>
</sequence>
</type>
</namedType>
<namedType name="ExpandedValue">
<type>
<sequence>
<optional>
<attribute name="name" type="asnx:NCName"/>
</optional>
<optional>
<element name="module" type="asnx:ReferencedModule"/>
Legg Expires 20 April 2007 [Page 143]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</optional>
<group name="value" type="asnx:Value"/>
</sequence>
</type>
</namedType>
<namedType name="ComponentValueList">
<type>
<sequenceOf minSize="1">
<group name="component" type="asnx:NamedValue"/>
</sequenceOf>
</type>
</namedType>
<namedType name="NamedValue">
<type>
<choice insertions="singular">
<element name="component" type="asnx:GenericNamedValue"/>
<element name="element" type="asnx:GenericNamedValue"/>
<element name="attribute" type="asnx:GenericNamedValue"/>
<element name="group" type="asnx:GenericNamedValue"/>
<element name="member" type="asnx:GenericNamedValue"/>
<element name="item" type="asnx:GenericNamedValue"/>
</choice>
</type>
</namedType>
<namedType name="GenericNamedValue">
<type>
<sequence>
<attribute name="name" type="asnx:QName"/>
<group name="value" type="asnx:Value"/>
</sequence>
</type>
</namedType>
<namedType name="ValueSet">
<type>
<choice insertions="none">
<attribute name="valueSet" identifier="valueSetRef"
type="asnx:QName">
<annotation>
valueSet attribute is not used in this version
</annotation>
</attribute>
<element name="valueSet" type="asnx:ElementFormValueSet"/>
</choice>
</type>
Legg Expires 20 April 2007 [Page 144]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</namedType>
<namedType name="ElementFormValueSet">
<type>
<sequence insertions="hollow">
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<group name="definition">
<type>
<choice insertions="none">
<group name="elementSetSpecs" type="asnx:ElementSetSpecs"/>
</choice>
</type>
</group>
</sequence>
</type>
</namedType>
<namedType name="ElementSetSpecs">
<type>
<sequence insertions="hollow">
<group name="root" type="asnx:ValueElementSetSpec"/>
<optional>
<element name="extension">
<type>
<sequence insertions="hollow">
<optional>
<group name="additions" type="asnx:ValueElementSetSpec"/>
</optional>
</sequence>
</type>
</element>
</optional>
</sequence>
</type>
</namedType>
<namedType name="ValueElementSetSpec">
<type>
<constrained type="asnx:ElementSetSpec">
<withComponents partial="true">
<element name="object" use="absent"/>
<element name="objectSet" use="absent"/>
<element name="union">
<withComponent>
<includes type="asnx:ValueElementSetSpec"/>
</withComponent>
Legg Expires 20 April 2007 [Page 145]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</element>
<element name="intersection">
<withComponent>
<includes type="asnx:ValueElementSetSpec"/>
</withComponent>
</element>
<element name="all">
<withComponents partial="true">
<group name="elements">
<includes type="asnx:ValueElementSetSpec"/>
</group>
<element name="except">
<includes type="asnx:ValueElementSetSpec"/>
</element>
</withComponents>
</element>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="ElementSetSpec">
<type>
<choice insertions="singular">
<element name="literalValue"
type="asnx:ElementFormLiteralValue"/>
<element name="value" type="asnx:ElementFormNotationalValue"/>
<element name="includes" type="asnx:Type"/>
<element name="range" type="asnx:ValueRange"/>
<element name="size" type="asnx:Constraint"/>
<element name="typeConstraint" type="asnx:Type"/>
<element name="from" type="asnx:Constraint"/>
<element name="withComponent" type="asnx:Constraint"/>
<element name="withComponents"
type="asnx:MultipleTypeConstraints"/>
<element name="pattern" type="asnx:Value"/>
<element name="object" type="asnx:ElementFormObject"/>
<element name="objectSet" type="asnx:ElementFormObjectSet"/>
<element name="union" type="asnx:ElementSetSpecList"/>
<element name="intersection" type="asnx:ElementSetSpecList"/>
<element name="all">
<type>
<sequence>
<optional>
<group name="elements" type="asnx:ElementSetSpec"/>
</optional>
<element name="except" type="asnx:ElementSetSpec"/>
</sequence>
Legg Expires 20 April 2007 [Page 146]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</type>
</element>
</choice>
</type>
</namedType>
<namedType name="ElementSetSpecList">
<type>
<sequenceOf minSize="2">
<group name="elements" type="asnx:ElementSetSpec"/>
</sequenceOf>
</type>
</namedType>
<namedType name="ValueRange">
<type>
<sequence>
<optional>
<group name="minimum">
<type>
<choice insertions="none">
<element name="minInclusive" type="asnx:EndValue"/>
<element name="minExclusive" type="asnx:EndValue"/>
</choice>
</type>
</group>
<default>
<literalValue>
<minInclusive/>
</literalValue>
</default>
</optional>
<optional>
<group name="maximum">
<type>
<choice insertions="none">
<element name="maxInclusive" type="asnx:EndValue"/>
<element name="maxExclusive" type="asnx:EndValue"/>
</choice>
</type>
</group>
<default>
<literalValue>
<maxInclusive/>
</literalValue>
</default>
</optional>
</sequence>
Legg Expires 20 April 2007 [Page 147]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</type>
</namedType>
<namedType name="EndValue">
<type>
<sequence insertions="hollow">
<optional>
<group name="value" type="asnx:Value"/>
</optional>
</sequence>
</type>
</namedType>
<namedType name="MultipleTypeConstraints">
<type>
<sequence insertions="hollow">
<optional>
<attribute name="partial" type="asnx:BOOLEAN"/>
<default literalValue="false"/>
</optional>
<group name="typeConstraints" type="asnx:TypeConstraints"/>
</sequence>
</type>
</namedType>
<namedType name="TypeConstraints">
<type>
<sequenceOf minSize="1">
<group name="namedConstraint" type="asnx:NamedConstraint"/>
</sequenceOf>
</type>
</namedType>
<namedType name="NamedConstraint">
<type>
<choice insertions="singular">
<element name="component" type="asnx:GenericNamedConstraint"/>
<element name="element" type="asnx:GenericNamedConstraint"/>
<element name="attribute" type="asnx:GenericNamedConstraint"/>
<element name="group" type="asnx:GenericNamedConstraint"/>
<element name="member" type="asnx:GenericNamedConstraint"/>
<element name="item" type="asnx:GenericNamedConstraint"/>
</choice>
</type>
</namedType>
<namedType name="GenericNamedConstraint">
<type>
Legg Expires 20 April 2007 [Page 148]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<sequence insertions="hollow">
<attribute name="name" type="asnx:QName"/>
<optional>
<attribute name="use" type="asnx:PresenceConstraint"/>
</optional>
<optional>
<group name="constraint" type="asnx:Constraint"/>
</optional>
</sequence>
</type>
</namedType>
<namedType name="PresenceConstraint">
<type>
<enumerated>
<enumeration name="present"/>
<enumeration name="absent"/>
<enumeration name="optional"/>
</enumerated>
</type>
</namedType>
<namedType name="ObjectClass">
<type>
<choice insertions="singular">
<attribute name="class" identifier="classRef" type="asnx:QName"/>
<element name="class" type="asnx:ElementFormObjectClass"/>
</choice>
</type>
</namedType>
<namedType name="DefinedObjectClass">
<type>
<constrained type="asnx:ObjectClass">
<withComponents partial="true">
<element name="class">
<withComponents partial="true">
<group name="definition">
<withComponents partial="true">
<group name="objectClassDefn" use="absent"/>
</withComponents>
</group>
</withComponents>
</element>
</withComponents>
</constrained>
</type>
</namedType>
Legg Expires 20 April 2007 [Page 149]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<namedType name="ElementFormObjectClass">
<type>
<sequence insertions="hollow">
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<group name="definition">
<type>
<choice insertions="none">
<group name="reference" type="asnx:Reference"/>
<element name="expanded" type="asnx:ExpandedObjectClass"/>
<group name="objectClassDefn" type="asnx:ObjectClassDefn"/>
</choice>
</type>
</group>
</sequence>
</type>
</namedType>
<namedType name="ExpandedObjectClass">
<type>
<sequence>
<optional>
<attribute name="name" type="asnx:NCName"/>
</optional>
<optional>
<element name="module" type="asnx:ReferencedModule"/>
</optional>
<group name="objectClass" type="asnx:ObjectClass"/>
</sequence>
</type>
</namedType>
<namedType name="ObjectClassDefn">
<type>
<sequenceOf minSize="1">
<group name="fieldSpec" type="asnx:FieldSpec"/>
</sequenceOf>
</type>
</namedType>
<namedType name="FieldSpec">
<type>
<choice insertions="singular">
<element name="typeField" type="asnx:TypeField"/>
<element name="valueField" type="asnx:ValueField"/>
<element name="valueSetField" type="asnx:ValueSetField"/>
<element name="objectField" type="asnx:ObjectField"/>
Legg Expires 20 April 2007 [Page 150]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<element name="objectSetField" type="asnx:ObjectSetField"/>
<element name="optional" type="asnx:OptionalField"/>
</choice>
</type>
</namedType>
<namedType name="OptionalField">
<type>
<constrained>
<type>
<sequence>
<group name="field">
<type>
<choice insertions="singular">
<element name="typeField" type="asnx:TypeField"/>
<element name="valueField" type="asnx:ValueField"/>
<element name="valueSetField" type="asnx:ValueSetField"/>
<element name="objectField" type="asnx:ObjectField"/>
<element name="objectSetField" type="asnx:ObjectSetField"/>
</choice>
</type>
</group>
<optional>
<element name="default" type="asnx:Setting"/>
</optional>
</sequence>
</type>
<union>
<withComponents partial="true">
<group name="field">
<withComponents>
<element name="typeField" use="present"/>
</withComponents>
</group>
<element name="default">
<withComponents partial="true">
<group name="value" use="absent"/>
<group name="valueSet" use="absent"/>
<group name="object" use="absent"/>
<group name="objectSet" use="absent"/>
</withComponents>
</element>
</withComponents>
<withComponents partial="true">
<group name="field">
<withComponents>
<element name="valueField" use="present"/>
</withComponents>
Legg Expires 20 April 2007 [Page 151]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</group>
<element name="default">
<withComponents partial="true">
<group name="type" use="absent"/>
<group name="valueSet" use="absent"/>
<group name="object" use="absent"/>
<group name="objectSet" use="absent"/>
</withComponents>
</element>
</withComponents>
<withComponents partial="true">
<group name="field">
<withComponents>
<element name="valueSetField" use="present"/>
</withComponents>
</group>
<element name="default">
<withComponents partial="true">
<group name="type" use="absent"/>
<group name="value" use="absent"/>
<group name="object" use="absent"/>
<group name="objectSet" use="absent"/>
</withComponents>
</element>
</withComponents>
<withComponents partial="true">
<group name="field">
<withComponents>
<element name="objectField" use="present"/>
</withComponents>
</group>
<element name="default">
<withComponents partial="true">
<group name="type" use="absent"/>
<group name="value" use="absent"/>
<group name="valueSet" use="absent"/>
<group name="objectSet" use="absent"/>
</withComponents>
</element>
</withComponents>
<withComponents partial="true">
<group name="field">
<withComponents>
<element name="objectSetField" use="present"/>
</withComponents>
</group>
<element name="default">
<withComponents partial="true">
Legg Expires 20 April 2007 [Page 152]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<group name="type" use="absent"/>
<group name="value" use="absent"/>
<group name="valueSet" use="absent"/>
<group name="object" use="absent"/>
</withComponents>
</element>
</withComponents>
</union>
</constrained>
</type>
</namedType>
<namedType name="TypeField">
<type>
<sequence>
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<attribute name="name" type="asnx:TypeFieldReference"/>
</sequence>
</type>
</namedType>
<namedType name="TypeFieldReference" type="asnx:TypeReference"/>
<namedType name="ValueField">
<type>
<constrained>
<type>
<sequence>
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<attribute name="name" type="asnx:ValueFieldReference"/>
<optional>
<attribute name="unique" type="asnx:BOOLEAN"/>
</optional>
<group name="governor">
<type>
<choice insertions="singular">
<group name="type" type="asnx:Type"/>
<element name="typeFromField" type="asnx:FieldName"/>
</choice>
</type>
</group>
</sequence>
</type>
<union>
Legg Expires 20 April 2007 [Page 153]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<withComponents partial="true">
<attribute name="unique" use="absent"/>
</withComponents>
<withComponents partial="true">
<group name="governor">
<withComponents partial="true">
<element name="typeFromField" use="absent"/>
</withComponents>
</group>
</withComponents>
</union>
</constrained>
</type>
</namedType>
<namedType name="ValueFieldReference" type="asnx:ValueReference"/>
<namedType name="ValueSetField">
<type>
<sequence>
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<attribute name="name" type="asnx:ValueSetFieldReference"/>
<group name="governor">
<type>
<choice insertions="singular">
<group name="type" type="asnx:Type"/>
<element name="typeFromField" type="asnx:FieldName"/>
</choice>
</type>
</group>
</sequence>
</type>
</namedType>
<namedType name="ValueSetFieldReference" type="asnx:TypeReference"/>
<namedType name="ObjectField">
<type>
<sequence>
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<attribute name="name" type="asnx:ObjectFieldReference"/>
<group name="objectClass" type="asnx:DefinedObjectClass"/>
</sequence>
</type>
Legg Expires 20 April 2007 [Page 154]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</namedType>
<namedType name="ObjectFieldReference" type="asnx:ObjectReference"/>
<namedType name="ObjectSetField">
<type>
<sequence>
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<attribute name="name" type="asnx:ObjectSetFieldReference"/>
<group name="objectClass" type="asnx:DefinedObjectClass"/>
</sequence>
</type>
</namedType>
<namedType name="ObjectSetFieldReference"
type="asnx:ObjectSetReference"/>
<namedType name="Object">
<type>
<choice insertions="none">
<attribute name="object" identifier="objectRef"
type="asnx:QName"/>
<element name="object" type="asnx:ElementFormObject"/>
</choice>
</type>
</namedType>
<namedType name="ElementFormObject">
<type>
<sequence insertions="hollow">
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<group name="definition">
<type>
<choice insertions="singular">
<group name="reference" type="asnx:Reference"/>
<element name="expanded" type="asnx:ExpandedObject"/>
<element name="fromObjects"
type="asnx:InformationFromObjects"/>
<group name="fields" type="asnx:ObjectDefn"/>
</choice>
</type>
</group>
</sequence>
</type>
Legg Expires 20 April 2007 [Page 155]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
</namedType>
<namedType name="ExpandedObject">
<type>
<sequence>
<optional>
<attribute name="name" type="asnx:NCName"/>
</optional>
<optional>
<element name="module" type="asnx:ReferencedModule"/>
</optional>
<group name="object" type="asnx:Object"/>
</sequence>
</type>
</namedType>
<namedType name="ObjectDefn">
<type>
<sequenceOf>
<element name="field" type="asnx:FieldSetting"/>
</sequenceOf>
</type>
</namedType>
<namedType name="FieldSetting">
<type>
<sequence insertions="hollow">
<attribute name="name" type="asnx:NCName"/>
<group name="setting" type="asnx:Setting"/>
</sequence>
</type>
</namedType>
<namedType name="Setting">
<type>
<choice>
<group name="type" type="asnx:Type"/>
<group name="value" type="asnx:Value"/>
<group name="valueSet" type="asnx:ValueSet"/>
<group name="object" type="asnx:Object"/>
<group name="objectSet" type="asnx:ObjectSet"/>
</choice>
</type>
</namedType>
<namedType name="ObjectSet">
<type>
<choice insertions="none">
Legg Expires 20 April 2007 [Page 156]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<attribute name="objectSet" identifier="objectSetRef"
type="asnx:QName"/>
<element name="objectSet" type="asnx:ElementFormObjectSet"/>
</choice>
</type>
</namedType>
<namedType name="ElementFormObjectSet">
<type>
<sequence insertions="hollow">
<optional>
<element name="annotation" type="asnx:Annotation"/>
</optional>
<group name="definition">
<type>
<choice insertions="none">
<group name="reference" type="asnx:Reference"/>
<element name="expanded" type="asnx:ExpandedObjectSet"/>
<group name="objectSetSpec" type="asnx:ObjectSetSpec"/>
<element name="fromObjects"
type="asnx:InformationFromObjects"/>
</choice>
</type>
</group>
</sequence>
</type>
</namedType>
<namedType name="ExpandedObjectSet">
<type>
<sequence>
<optional>
<attribute name="name" type="asnx:NCName"/>
</optional>
<optional>
<element name="module" type="asnx:ReferencedModule"/>
</optional>
<group name="objectSet" type="asnx:ObjectSet"/>
</sequence>
</type>
</namedType>
<namedType name="ObjectSetSpec">
<type>
<constrained>
<type>
<sequence insertions="hollow">
<optional>
Legg Expires 20 April 2007 [Page 157]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<group name="root" type="asnx:ObjectElementSetSpec"/>
</optional>
<optional>
<element name="extension">
<type>
<sequence insertions="hollow">
<optional>
<group name="additions" type="asnx:ObjectElementSetSpec"/>
</optional>
</sequence>
</type>
</element>
</optional>
</sequence>
</type>
<union>
<withComponents partial="true">
<group name="root" use="present"/>
</withComponents>
<withComponents partial="true">
<element name="extension" use="present"/>
</withComponents>
</union>
</constrained>
</type>
</namedType>
<namedType name="ObjectElementSetSpec">
<type>
<constrained type="asnx:ElementSetSpec">
<withComponents partial="true">
<element name="literalValue" use="absent"/>
<element name="value" use="absent"/>
<element name="includes" use="absent"/>
<element name="range" use="absent"/>
<element name="size" use="absent"/>
<element name="typeConstraint" use="absent"/>
<element name="from" use="absent"/>
<element name="withComponent" use="absent"/>
<element name="withComponents" use="absent"/>
<element name="pattern" use="absent"/>
<element name="union">
<withComponent>
<includes type="asnx:ObjectElementSetSpec"/>
</withComponent>
</element>
<element name="intersection">
<withComponent>
Legg Expires 20 April 2007 [Page 158]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
<includes type="asnx:ObjectElementSetSpec"/>
</withComponent>
</element>
<element name="all">
<withComponents partial="true">
<group name="elements">
<includes type="asnx:ObjectElementSetSpec"/>
</group>
<element name="except">
<includes type="asnx:ObjectElementSetSpec"/>
</element>
</withComponents>
</element>
</withComponents>
</constrained>
</type>
</namedType>
<namedType name="EncodingControlSections">
<type>
<sequenceOf minSize="1">
<group name="section" type="asnx:EncodingControlSection"/>
</sequenceOf>
</type>
</namedType>
<namedType name="EncodingControlSection">
<type>
<choice insertions="singular">
<element name="GSER" identifier="gser"
type="asnx:GSER-EncodingInstructionAssignmentList"/>
<element name="XER" identifier="xer"
type="asnx:XER-EncodingInstructionAssignmentList"/>
<!-- plus encoding control sections
for other encoding rules in the future -->
</choice>
</type>
</namedType>
<element name="module" type="asnx:ModuleDefinition"/>
<attribute name="literal" type="asnx:BOOLEAN"/>
</asnx:module>
Author's Address
Dr. Steven Legg
Legg Expires 20 April 2007 [Page 159]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
eB2Bcom
Suite 3, Woodhouse Corporate Centre
935 Station Street
Box Hill North, Victoria 3129
AUSTRALIA
Phone: +61 3 9896 7830
Fax: +61 3 9896 7801
EMail: steven.legg@eb2bcom.com
Full Copyright Statement
Copyright (C) The Internet Society (2006).
This document is subject to the rights, licenses and restrictions
contained in BCP 78, and except as set forth therein, the authors
retain all their rights.
This document and the information contained herein are provided on an
"AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS
OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY AND THE INTERNET
ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE
INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED
WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
Intellectual Property
The IETF takes no position regarding the validity or scope of any
Intellectual Property Rights or other rights that might be claimed to
pertain to the implementation or use of the technology described in
this document or the extent to which any license under such rights
might or might not be available; nor does it represent that it has
made any independent effort to identify any such rights. Information
on the procedures with respect to rights in RFC documents can be
found in BCP 78 and BCP 79.
Copies of IPR disclosures made to the IETF Secretariat and any
assurances of licenses to be made available, or the result of an
attempt made to obtain a general license or permission for the use of
such proprietary rights by implementers or users of this
specification can be obtained from the IETF on-line IPR repository at
http://www.ietf.org/ipr.
The IETF invites any interested party to bring to its attention any
copyrights, patents or patent applications, or other proprietary
rights that may cover technology that may be required to implement
this standard. Please address the information to the IETF at
Legg Expires 20 April 2007 [Page 160]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
ietf-ipr@ietf.org.
Note to the RFC Editor: the remainder of this document is to be removed
before final publication.
Changes in Draft 01
The Directory XML Encoding Rules (DXER) have been renamed to the
Robust XML Encoding Rules (RXER).
The ASN.1 Schema representation of a value of the EXTERNAL type has
been changed from the usual RXER encoding, the encoding according to
the associated type in X.690, to the encoding according to the
associated type in X.680. However the RXER encoding of EXTERNAL is
unchanged.
The translation of extensions to SEQUENCE, SET and CHOICE types has
been simplified. The second extension marker no longer generates a
second <extension> element item.
The translation of UserDefinedConstraintParameter has been revised so
that the corresponding ASN.1 type in the ASN.1 for ASN.1 Schema
(ASN.1 for ASN.X) is more straightforward.
The assumedName attribute item on the <element> child of a
<sequenceOf> or <setOf> element item has been replaced by a pair of
attribute items - name and identifier. The identifier attribute item
is intended to hold the identifier appearing in the original ASN.1
specification when that identifier is not the same as the value of
the name attribute item, i.e. because there is no identifier, or the
identifier is modified by a NAME encoding instruction.
The ASN.1 for ASN.1 Schema (ASN.1 for ASN.X), and the ASN.1 Schema
for ASN.1 Schema (ASN.X for ASN.X), have been provided.
Changes in Draft 02
The changes introduced in Draft 02 have been superseded by the
changes in Draft 03.
Changes in Draft 03
The effect of RXER encoding instructions on the translation of an
ASN.1 specification into ASN.1 Schema (ASN.X) has been included.
The ASN.1 for ASN.1 Schema (ASN.1 for ASN.X) has been changed to use
RXER encoding instructions instead of XER encoding instructions.
Legg Expires 20 April 2007 [Page 161]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
The ASN.1 for ASN.1 Schema (ASN.1 for ASN.X), and the ASN.1 Schema
for ASN.1 Schema (ASN.X for ASN.X), have been changed to a more
natural representation using attributes nested in content models.
A translation for PrefixedType has been included.
The "renames" (a verb) attribute item has been renamed to
"identifier" (a noun).
The OBJECT IDENTIFIER for the ASN1-Schema (AbstractSyntaxNotation-X)
module has been replaced.
The translation of AtNotation has been changed from the value of a
component attribute item of a <restrictBy> element item to simple
content of the <restrictBy> element item.
A solution for translating recursive parameterized definitions has
been added.
Changes in Draft 04
ASN.1 Schema has been renamed to Abstract Syntax Notation X (ASN.X)
and the <asnx:schema> element has been renamed to <asnx:module>.
The "literal" attribute item has been renamed to "literalValue". The
<value> element item has been renamed to <literalValue>. A new
<value> element item has been added to represent notational (meta)
values.
The asnx:meta attribute item has been replaced by the asnx:literal
attribute item. The boolean value of the attribute has been
inverted.
<literalValue> and <restrictBy> element items are required to be
self-contained.
An "embedded" attribute item has been added to type references to
distinguish between a DefinedType or a TYPE-REF encoding instruction
referencing an ASN.1 type.
References to the CanonicalizationParameter in the RefParameters for
reference encoding instructions have been removed (this notation has
been removed from the encoding instructions).
The GeneralReference and Reference ASN.1 types in the ASN.1 for ASN.X
are now separate definitions. GeneralReference has been renamed to
TypeOrElementReference.
Legg Expires 20 April 2007 [Page 162]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
Changes in Draft 05
The CONTENT encoding instruction has been renamed to GROUP and a
component subject to a GROUP encoding instruction is now an element
item with the [local name] "group" instead of "content".
Section 6.7.3. has been added to describe the effects of the
NO-INSERTIONS, HOLLOW-INSERTIONS, SINGULAR-INSERTIONS,
UNIFORM-INSERTIONS and MULTIFORM-INSERTIONS encoding instructions on
the translation of an ASN.1 specification into ASN.X. Insertion
encoding instructions have been added to the ASN.1 for ASN.X to
remove extension ambiguity.
A "versionIndicator" attribute item has been added to the <attribute>
element item to account for the VersionIndicator parameter of the
ATTRIBUTE encoding instruction. A version indicator attribute has
been added to the ModuleDefinition type.
The values of the tagDefault, tagClass, tagging and use attributes
have been downcased.
A free-form <annotation> element has been added to the nameable
constructs in ASN.X to support uses outside the scope of this
document.
The ASN.1 for ASN.X has been revised to correct errors and omissions
(particularly GenericNamedType and ElementSetSpec) and to simplify
the non-RXER encodings of ASN.X documents. These changes have no
effect on the RXER encoding of ASN.X documents except that the
<encodingControl-GSER> and <encodingControl-XER> elements have been
renamed to <GSER> and <XER>, respectively, and now appear as child
elements of an <encodingControls> element.
Changes in Draft 06
The method of in-line substitution of parameterized references has
been revised such that an explicit change of module context can be
indicated in the translation of the parameterized reference. As a
consequence, the tagDefault and extensibilityImplied attributes of
the <type> element item have been removed.
The AnyType ASN.1 type has been renamed to Markup.
Translations for the COMPONENT-REF and SIMPLE-CONTENT encoding
instructions have been added.
The sense of the embedded attribute has been inverted for components
subject to an ELEMENT-REF encoding instruction that references a
Legg Expires 20 April 2007 [Page 163]
INTERNET-DRAFT Abstract Syntax Notation X October 20, 2006
top-level NamedType. The embedded attribute is now required in the
translation of an ELEMENT-REF or ATTRIBUTE-REF encoding instruction.
A translation for the Prefix of a TARGET-NAMESPACE encoding
instruction has been added.
The insertions attribute has been moved from the <type> element item
to its child <sequence>, <set> or <choice> element item.
An alternative translation of a TaggedType as a prefixed type has
been added. Encoding prefixes in components subject to an
ATTRIBUTE-REF, COMPONENT-REF, ELEMENT-REF or REF-AS-ELEMENT encoding
instruction now have a translation.
The URL for the ASN.1 namespace has been replaced. A permanent URN
will be requested from IANA.
Legg Expires 20 April 2007 [Page 164]
