Home
You are not currently signed in.

RFC4912

  1. RFC 4912
Network Working Group                                            S. Legg
Request for Comments: 4912                                       eB2Bcom
Category: Experimental                                         July 2007


                   Abstract Syntax Notation X (ASN.X)

Status of This Memo

   This memo defines an Experimental Protocol for the Internet
   community.  It does not specify an Internet standard of any kind.
   Discussion and suggestions for improvement are requested.
   Distribution of this memo is unlimited.

Copyright Notice

   Copyright (C) The IETF Trust (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,
   specifications written in ASN.X are much easier to parse and manage
   than original ASN.1 specifications.  ASN.X, together with the Robust
   XML Encoding Rules (RXER), constitutes a schema language for XML
   documents that offers, through other ASN.1 encoding rules,
   alternative compact binary encodings for XML instance documents.






















Legg                          Experimental                      [Page 1]
RFC 4912               Abstract Syntax Notation X              July 2007


Table of Contents

   1. Introduction ....................................................4
   2. Conventions .....................................................5
   3. General Considerations ..........................................6
      3.1. Annotations ................................................7
   4. ModuleDefinition Translation ....................................8
   5. Translation of Assignments .....................................11
      5.1. Referencing Named Constructs ..............................11
      5.2. Importing Namespaces ......................................12
      5.3. TypeAssignment Translation ................................14
      5.4. ValueAssignment and XMLValueAssignment Translation ........14
      5.5. ValueSetTypeAssignment Translation ........................15
      5.6. ObjectClassAssignment Translation .........................15
      5.7. ObjectAssignment Translation ..............................16
      5.8. ObjectSetAssignment Translation ...........................16
      5.9. ParameterizedAssignment Translation .......................17
   6. Translation of Types ...........................................17
      6.1. Identifier Replacement ....................................17
      6.2. DefinedType Translation ...................................18
      6.3. Translation of Built-in Types .............................20
      6.4. BitStringType Translation .................................21
      6.5. IntegerType Translation ...................................22
      6.6. EnumeratedType Translation ................................24
      6.7. PrefixedType Translation ..................................25
           6.7.1. Short Form TaggedType Translation ..................28
           6.7.2. Long Form TaggedType Translation ...................29
      6.8. SelectionType Translation .................................30
      6.9. InstanceOfType Translation ................................31
      6.10. ObjectClassFieldType Translation .........................31
      6.11. TypeFromObject and ValueSetFromObjects Translation .......32
      6.12. Translation of Combining Types ...........................32
           6.12.1. NamedType Translation .............................32
           6.12.2. SequenceType Translation ..........................36
           6.12.3. SetType Translation ...............................38
           6.12.4. ChoiceType Translation ............................39
           6.12.5. Translation of UNION Types ........................40
           6.12.6. SequenceOfType Translation ........................41
           6.12.7. Translation of LIST Types .........................42
           6.12.8. SetOfType Translation .............................42
           6.12.9. Effect of Insertion Encoding Instructions .........43
      6.13. Translation of Constrained Types .........................43
           6.13.1. Constraint Translation ............................46
           6.13.2. UserDefinedConstraint Translation .................46
           6.13.3. TableConstraint Translation .......................47
           6.13.4. ContentsConstraint Translation ....................49
           6.13.5. ExceptionSpec Translation .........................50




Legg                          Experimental                      [Page 2]
RFC 4912               Abstract Syntax Notation X              July 2007


   7. Translation of Values ..........................................51
      7.1. Translation of Literal Values .............................53
      7.2. Translation of Notational Values ..........................54
           7.2.1. DefinedValue Translation ...........................56
           7.2.2. BuiltinValue Translation ...........................57
           7.2.3. ValueFromObject Translation ........................60
           7.2.4. ObjectClassFieldValue Translation ..................60
   8. Translation of Value Sets ......................................61
      8.1. ElementSetSpecs Translation ...............................62
      8.2. ElementSetSpec Translation ................................62
      8.3. SubtypeElements Translation ...............................63
           8.3.1. ValueRange Translation .............................64
           8.3.2. InnerTypeConstraints Translation ...................65
   9. Translation of Object Classes ..................................66
      9.1. DefinedObjectClass Translation ............................66
      9.2. ObjectClassDefn Translation ...............................68
           9.2.1. TypeFieldSpec Translation ..........................68
           9.2.2. FixedTypeValueFieldSpec Translation ................69
           9.2.3. FixedTypeValueSetFieldSpec Translation .............70
           9.2.4. VariableTypeValueFieldSpec Translation .............71
           9.2.5. VariableTypeValueSetFieldSpec Translation ..........73
           9.2.6. FieldName Translation ..............................74
           9.2.7. ObjectFieldSpec Translation ........................75
           9.2.8. ObjectSetFieldSpec Translation .....................76
   10. Translation of Objects ........................................77
      10.1. DefinedObject Translation ................................77
      10.2. ObjectDefn Translation ...................................78
      10.3. ObjectFromObject Translation .............................80
   11. Translation of Object Sets ....................................80
      11.1. DefinedObjectSet Translation .............................81
      11.2. ObjectSetElements Translation ............................82
           11.2.1. ObjectSetFromObjects Translation ..................83
   12. Translation of Information From Objects .......................83
   13. Translation of Parameterized Definitions ......................83
   14. EncodingControlSections Translation ...........................93
   15. Security Considerations .......................................94
   16. Acknowledgements ..............................................94
   17. References ....................................................95
      17.1. Normative References .....................................95
      17.2. Informative References ...................................97
   Appendix A. ASN.1 for ASN.X .......................................95
   Appendix B. ASN.X for ASN.X ......................................115









Legg                          Experimental                      [Page 3]
RFC 4912               Abstract Syntax Notation X              July 2007


1.  Introduction

   A full parser for the Abstract Syntax Notation One (ASN.1) language
   [X.680][X.680-1][X.681][X.682][X.683] 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 notation.  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).  An ASN.X module is a
   well-formed and valid XML document conforming to XML namespaces
   [XMLNS10][XMLNS11].  ASN.X completely avoids the inherent ambiguities
   of the ASN.1 language; therefore, specifications written in ASN.X 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.

   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] documents, RELAX NG [RNG]
   documents, 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 module being written
   directly without a pre-existing ASN.1 module; however, such an ASN.X
   module is considered valid if and only if there exists, in principle,
   an ASN.1 module that when translated would yield the ASN.X module.

   The format for ASN.X has also been designed so that the content of an
   ASN.X module 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 module using an RXER
   decoder and then re-encode the abstract value (for storage or



Legg                          Experimental                      [Page 4]
RFC 4912               Abstract Syntax Notation X              July 2007


   transmission) using any of the other encoding rules for ASN.1.  Thus,
   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
   module makes use of definitions from the XML Information Set
   (Infoset) [INFOSET].  In particular, information item property names
   follow the Infoset convention of being shown in square brackets,
   e.g., [local name].  Literal values of Infoset properties are
   enclosed in double quotes; however, the double quotes are not part of
   the property values.  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.




Legg                          Experimental                      [Page 5]
RFC 4912               Abstract Syntax Notation X              July 2007


3.  General Considerations

   ASN.X is defined in terms of rules for translating an ASN.1 module
   into a synthetic Infoset.  This synthetic Infoset is then serialized
   into a well-formed and valid XML document (the ASN.X module) in the
   same manner that the synthetic Infoset for a non-canonical RXER
   encoding is serialized into an XML document (see Section 6.12 of the
   specification for RXER [RXER]).

      Aside: The serialization permits CDATA sections, character
      references, and parsed entity references.  However, note that an
      ASN.X module 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
   module, 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 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".




Legg                          Experimental                      [Page 6]
RFC 4912               Abstract Syntax Notation X              July 2007


      Aside: In most cases, RXER itself permits comment and PI items in
      the [children] of the element items with the [local name]
      "literalValue".

      Aside: Note that an ASN.X module 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 6.10 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 6.2.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 6.2.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 6.2.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 [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                          Experimental                      [Page 7]
RFC 4912               Abstract Syntax Notation X              July 2007


   Free text or XML comments in an <annotation> element will be
   preserved in a Canonical RXER (CRXER) encoding [RXER] (because the
   corresponding ASN.1 type for the <annotation> element item is the
   Markup type [RXER]), while XML comments outside <annotation> elements
   will not be preserved.

   Vendors using the <annotation> element items to hold ASN.1 compiler
   directives (as attributes or child elements of the <annotation>
   element) SHOULD 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 an
   element item with the [local name] "module" and the [namespace name]
   "urn:ietf:params:xml:ns:asnx" (i.e., an <asnx:module> element item).
   The element item is typically the [document element] of a document
   item.

   An attribute item with the [local name] "format" and
   [normalized value] "1.0" MAY be added to the [attributes] of the
   <asnx:module> element item.

   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 <asnx:module> element item.  The
   [normalized value] of this attribute item is the schema identity URI
   of the module.

   If the target namespace [RXEREI] for the ASN.1 module is not absent,
   then an attribute item with the [local name] "targetNamespace" SHALL
   be added to the [attributes] of the <asnx:module> element item.  The
   [normalized value] of this attribute item is the target namespace of
   the module.

      Aside: An ASN.1 module has a target namespace if it contains a
      TARGET-NAMESPACE encoding instruction.

   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





Legg                          Experimental                      [Page 8]
RFC 4912               Abstract Syntax Notation X              July 2007


   <asnx:module> element item.  The [normalized value] of this attribute
   item is the character string specified by the NCNameValue in the
   Prefix.

   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 <asnx:module> element item.  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
   <asnx:module> element item.  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 <asnx:module>
   element item.

   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 <asnx:module> element item.  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 <asnx:module> element item.

   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 <asnx:module> element item.

   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 <asnx:module> element item.





Legg                          Experimental                      [Page 9]
RFC 4912               Abstract Syntax Notation X              July 2007


   An element item with the [local name] "annotation" MAY be added to
   the [children] of the <asnx:module> element item.

   The translation of each Assignment in the AssignmentList in the
   ModuleBody in the ModuleDefinition of the module being translated
   SHALL be appended to the [children] of the <asnx:module> element
   item.

   If the EncodingControlSections instance in the ModuleDefinition
   contains an EncodingControlSection for RXER, then the translation of
   each NamedType in a TopLevelComponent [RXEREI] nested in the
   EncodingInstructionAssignmentList SHALL be added to the [children] of
   the <asnx:module> element item.  The relative order of the top-level
   components [RXEREI] 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 instance in the
   ModuleDefinition of the module being translated SHALL be appended to
   the [children] of the <asnx:module> element item.

   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"/>




Legg                          Experimental                     [Page 10]
RFC 4912               Abstract Syntax Notation X              July 2007


       <element name="myElement" type="asnx:INTEGER"/>

      </asnx:module>

5.  Translation of Assignments

5.1.  Referencing Named Constructs

   An Assignment in ASN.1 associates a reference name with a Type,
   Value, ValueSet, ObjectClass, Object, or ObjectSet.  For ASN.X, an
   Assignment is also regarded as associating an expanded name
   [XMLNS10][XMLNS11] with the Type, Value, ValueSet, ObjectClass,
   Object, or ObjectSet.  ASN.X uses these expanded names, rendered as
   qualified names [XMLNS10][XMLNS11], in place of the references in an
   ASN.1 specification.

   In every case, the local name of the expanded 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 target namespace of the
   ASN.1 module in which the Assignment is defined is not absent, then
   the namespace name of the expanded name is that target namespace;
   otherwise, the namespace name of the expanded name has no value.
   When the expanded name is rendered as a qualified name, the namespace
   prefix is determined according to Section 6.7.11.1 of the
   specification for RXER [RXER].

   If an ASN.1 specification contains two or more modules where the
   target namespace is absent, then there exists the possibility that
   the expanded names defined by the ASN.X translations of those modules
   are not distinct.  The expanded names are not distinct if:

   (1) two or more type or value set assignments define the same
       typereference, or

   (2) two or more value assignments define the same valuereference, or

   (3) two or more object class assignments define the same
       objectclassreference, or

   (4) two or more object assignments define the same objectreference,
       or

   (5) two or more object set assignments define the same
       objectsetreference, or





Legg                          Experimental                     [Page 11]
RFC 4912               Abstract Syntax Notation X              July 2007


   (6) two or more top-level element components [RXEREI] have the same
       local name, or

   (7) two or more top-level attribute components [RXEREI] have the same
       local name.

   If the expanded 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 where the target namespace is absent are being translated
   into ASN.X and the reference names defined in those modules will not
   be 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 expanded 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].

      Aside: Although this means that different translators might
      produce ASN.X modules that are syntactically different for any
      given ASN.1 module, those ASN.X modules 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 module if its associated
   expanded name appears as a qualified name in the [normalized value]
   of 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 module if its expanded name appears as a qualified name
   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 item
      with the [local name] "embedded" and [normalized value] "true" or
      "1" will also be present.






Legg                          Experimental                     [Page 12]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 <asnx:module> element item for each external module
   containing Assignments or top-level components that are directly
   referenced from the ASN.X module.  An <import> element item MAY be
   added to the [children] of the <asnx:module> element item 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
   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 target namespace of the external module is not absent, 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 <asnx:module> element item.



Legg                          Experimental                     [Page 13]
RFC 4912               Abstract Syntax Notation X              July 2007


   Note that because of the way parameterized references are expanded in
   ASN.X (see Section 13), the modules in the Imports in the ModuleBody
   in 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"/>

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 SHALL be added to
   the [children] or [attributes] of the <namedValue> element item.  The
   translation of the Value on the right-hand side of the assignment
   SHALL be added to the [children] or [attributes] of the <namedValue>
   element item.

   Example

      myValue INTEGER ::= 10

      <namedValue name="myValue" type="asnx:INTEGER" literalValue="10"/>






Legg                          Experimental                     [Page 14]
RFC 4912               Abstract Syntax Notation X              July 2007


   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>
        <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.






Legg                          Experimental                     [Page 15]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 SHALL
   be added to the [children] or [attributes] of the <namedObject>
   element item.  The translation of the Object on the right-hand side
   of the assignment SHALL be added to the [children] or [attributes] of
   the <namedObject> element item.

   Example

      myObject TYPE-IDENTIFIER ::=
          { NULL IDENTIFIED BY { 1 3 14 3 2 26 } }

      <namedObject name="myObject" class="asnx:TYPE-IDENTIFIER">
       <object>
        <field name="id" literalValue="1.3.14.3.2.26"/>
        <field name="Type" type="asnx:NULL"/>
       </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
   SHALL be added to the [children] or [attributes] of the
   <namedObjectSet> element item.  The translation of the ObjectSet on



Legg                          Experimental                     [Page 16]
RFC 4912               Abstract Syntax Notation X              July 2007


   the right-hand side of the assignment SHALL be added to the
   [children] 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.  ParameterizedAssignment Translation

   The translation of an ASN.1 specification into ASN.X replaces any
   reference to a parameterized definition [X.683] with the definition
   expanded in-line.  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 (see
   Section 13).

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 as either 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

   Various RXER encoding instructions can be used to override an
   identifier in an ASN.1 specification with an NCName [XMLNS10].  The
   NCName is given preeminence 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:



Legg                          Experimental                     [Page 17]
RFC 4912               Abstract Syntax Notation X              July 2007


   (1) replace each full stop ('.', U+002E) and low line ('_', U+005F)
       character with a hyphen character ('-', U+002D),

   (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 a qualified name for the expanded name of the
   referenced type definition (see Section 5.1).  The attribute form
   translation SHALL NOT be used if this expanded name is not distinct
   with respect to the current module and the modules referenced by its
   <import> element items (see Section 5.1).

   The element form translation of a type reference 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 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 for the
   expanded name of the referenced type definition.  If this expanded
   name is not distinct with respect to the current module and the
   modules referenced by its <import> element items, then an attribute
   item with the [local name] "context" SHALL be added to the



Legg                          Experimental                     [Page 18]
RFC 4912               Abstract Syntax Notation X              July 2007


   [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 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 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] "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 in the TYPE-REF encoding instruction.
   If a 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
      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.

   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 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] "elementType" SHALL be
   added to the [attributes] of the <type> element item.  The



Legg                          Experimental                     [Page 19]
RFC 4912               Abstract Syntax Notation X              July 2007


   [normalized value] of this attribute item is the RXER character data
   translation of the NameValue in the REF-AS-TYPE encoding instruction.
   If a 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.

   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>
       <choice>
        <element name="one" type="tns:Foo"/>
        <element name="two" xmlns:po="http://www.example.com/PO1">
         <type ref="po:PurchaseOrderType" embedded="true"/>
        </element>
        <element name="three">
         <type elementType="product"
               context="http://www.example.com/inventory"/>
        </element>
       </choice>
      </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 13).

6.3.  Translation of Built-in Types

   If a Type is a BuiltinType or ReferencedType that is one of the
   productions in Table 1 in Section 5 of the specification for RXER
   [RXER], then the translation of the Type is either the attribute form
   or element form translation of that type.






Legg                          Experimental                     [Page 20]
RFC 4912               Abstract Syntax Notation X              July 2007


   The attribute form translation of a Type that is a BuiltinType or
   ReferencedType that is 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 for the expanded name of
   the built-in type (see Section 5 of the specification for RXER
   [RXER]).

   The element form translation of a Type that is a BuiltinType or
   ReferencedType that is one of the productions in Table 1 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 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 for the
   expanded name of the built-in type.

   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
   [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 in the NamedBit;
   otherwise, it is the identifier in 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>



Legg                          Experimental                     [Page 21]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 in 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 in 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

   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.




Legg                          Experimental                     [Page 22]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 in the NamedNumber;
   otherwise, it is the identifier in 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 in 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 in 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"/>
        <namedNumber name="High" number="75"/>
        <namedNumber name="DANGEROUS" identifier="very-high"
                     number="100"/>
       </namedNumberList>
      </type>







Legg                          Experimental                     [Page 23]
RFC 4912               Abstract Syntax Notation X              July 2007


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 nested in the RootEnumeration in
   the Enumerations instance in the EnumeratedType SHALL be appended to
   the [children] of the <enumerated> element item.

   If an ellipsis ("...") is present in the Enumerations instance, 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 in the Enumerations instance, then
   the translation of each EnumerationItem nested 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 in the NamedNumber; otherwise, it is the
   identifier in the NamedNumber.  If the EnumeratedType is subject to a
   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



Legg                          Experimental                     [Page 24]
RFC 4912               Abstract Syntax Notation X              July 2007


   <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 in 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 in the NamedNumber.

   Examples

      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
      series of nested PrefixedType instances.





Legg                          Experimental                     [Page 25]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 module is
      translated into an ASN.X module (since the content of an ASN.X
      module 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 in 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
   [attributes] of the inner <prefixed> element item.  Note that the
   long form translation of a TaggedType is also eligible for this



Legg                          Experimental                     [Page 26]
RFC 4912               Abstract Syntax Notation X              July 2007


   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>
        <type>
         <choice>
          <element name="one" type="asnx:PrintableString"/>
          <element name="two" type="asnx:UTF8String"/>
         </choice>
        </type>
       </prefixed>
      </type>




Legg                          Experimental                     [Page 27]
RFC 4912               Abstract Syntax Notation X              July 2007


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 in 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".

   An attribute item with the [local name] "number" SHALL be added to
   the [attributes] of the <tagged> element item.  The
   [normalized value] of this attribute item is the digit string
   representation of the integer value of the number or DefinedValue in
   the ClassNumber in the Tag.

   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.

   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                          Experimental                     [Page 28]
RFC 4912               Abstract Syntax Notation X              July 2007


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".

   An attribute item with the [local name] "number" SHALL be added to
   the [attributes] of the <TAG> element item.  The [normalized value]
   of this attribute item is the digit string representation of the
   integer value of the number or DefinedValue in the ClassNumber in the
   Tag.

   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.

   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                          Experimental                     [Page 29]
RFC 4912               Abstract Syntax Notation X              July 2007


      [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", "component", "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 a
   qualified name for the expanded name of the NamedType [RXEREI].

   The translation of the Type in the SelectionType SHALL be added to
   the [children] or [attributes] of the <selection> element item.

   Examples

      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                          Experimental                     [Page 30]
RFC 4912               Abstract Syntax Notation X              July 2007


       </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
   SHALL be added to the [children] or [attributes] of the <fromClass>
   element item.  The translation of the FieldName (see Section 9.2.6)
   in the ObjectClassFieldType SHALL be added to the [children] or
   [attributes] of the <fromClass> element item.

   Example

      OPERATION.&Linked.&ArgumentType

      <type>
       <fromClass class="tns:OPERATION"
                  fieldName="Linked/ArgumentType"/>
      </type>








Legg                          Experimental                     [Page 31]
RFC 4912               Abstract Syntax Notation X              July 2007


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
   <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 instance 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.

   The normal translation of a NamedType is an element item with the
   [local name] determined as follows:

   (1) if the 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 [local name] is
       "attribute",



Legg                          Experimental                     [Page 32]
RFC 4912               Abstract Syntax Notation X              July 2007


   (2) else if the NamedType is subject to a GROUP encoding instruction,
       then the [local name] is "group",

   (3) else if the NamedType is subject to a SIMPLE-CONTENT encoding
       instruction, then the [local name] is "simpleContent",

   (4) otherwise, the [local name] is "element" or "component"
       (translator's choice).

      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".

      Aside: A Namedtype for which the member or item translation is
      invoked will never be subject to an ATTRIBUTE, ATTRIBUTE-REF,
      COMPONENT-REF, GROUP, SIMPLE-CONTENT, or TYPE-AS-VERSION encoding
      instruction.  These encoding instructions are also mutually
      exclusive [RXEREI].

   An element item with the [local name] "annotation" MAY be added to
   the [children] of the <attribute>, <element>, <component>, <group>,
   <item>, <member>, or <simpleContent> element item.

   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>, <element>, <component>, <group>, <item>, <member>, or





Legg                          Experimental                     [Page 33]
RFC 4912               Abstract Syntax Notation X              July 2007


   <simpleContent> element item.  The [normalized value] of this
   attribute item is the local name of the expanded name of the
   NamedType [RXEREI].

      Aside: If there are no NAME, ATTRIBUTE-REF, COMPONENT_REF,
      ELEMENT-REF or REF-AS-ELEMENT encoding instructions, then the
      local name of the expanded name of a NamedType is the same as the
      identifier in the NamedType.

   If the reduction of the local name (an NCName) of the expanded name
   of a NamedType is not the same as the identifier in the NamedType,
   then an attribute item with the [local name] "identifier" SHALL be
   added to the [attributes] of the <attribute>, <element>, <component>,
   <group>, <item>, <member>, or <simpleContent> 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 in the
   NamedType.

      Aside: The identifier attribute is not contingent on there being a
      name attribute.  That is, an element item can have an identifier
      attribute item without having a name attribute item.

   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 a
   qualified name for the expanded name of the top-level NamedType
   referenced by the encoding instruction.  If the expanded 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 expanded 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.



Legg                          Experimental                     [Page 34]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 in the
   encoding instruction.  An attribute item with the [local name]
   "embedded" and [normalized value] "true" or "1" SHALL 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 in the REF-AS-ELEMENT
   encoding instruction.  If a 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 a 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 both 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>, <element>,
   <component>, <group>, <item>, <member>, or <simpleContent> element
   item.






Legg                          Experimental                     [Page 35]
RFC 4912               Abstract Syntax Notation X              July 2007


   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

      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



Legg                          Experimental                     [Page 36]
RFC 4912               Abstract Syntax Notation X              July 2007


   translation of each ComponentType nested in the ComponentTypeList in
   the initial RootComponentTypeList, if present, SHALL be appended to
   the [children] of the <sequence> element item.

   If an ExtensionAndException is present, then an element item with the
   [local name] "extension" SHALL be appended to the [children] of the
   <sequence> element item.  If an ExceptionSpec is present in the
   ExtensionAndException, then the translation of the ExceptionSpec
   (possibly empty) SHALL be added to the [children] of the <extension>
   element item.

   If an ExtensionAdditions instance is present, then 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 an ExtensionEndMarker is present, then the translation of each
   ComponentType nested in the ComponentTypeList 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 in the
   ExtensionAdditionGroup is not empty, 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 in the VersionNumber.  The translation
   of each ComponentType nested 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.






Legg                          Experimental                     [Page 37]
RFC 4912               Abstract Syntax Notation X              July 2007


   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,
          ...,
          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 the
   translation of a SequenceType except that SetType replaces
   SequenceType, "SET" replaces "SEQUENCE", and the [local name] "set"
   is used instead of "sequence".







Legg                          Experimental                     [Page 38]
RFC 4912               Abstract Syntax Notation X              July 2007


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 nested
   in the AlternativeTypeList in the RootAlternativeTypeList in the
   AlternativeTypeLists SHALL be appended to the [children] of the
   <choice> element item.

   If an ExtensionAndException is present in the AlternativeTypeLists,
   then an element item with the [local name] "extension" SHALL be
   appended to the [children] of the <choice> element item.  If an
   ExceptionSpec is present in the ExtensionAndException, then the
   translation of the ExceptionSpec (possibly empty) is added to the
   [children] of the <extension> element item.

   If an ExtensionAdditionAlternatives instance is present in the
   AlternativeTypeLists, then the translation of each
   ExtensionAdditionAlternativesGroup or NamedType (if any) nested in
   the ExtensionAdditionAlternatives SHALL be appended in order 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 in the ExtensionAdditionAlternativesGroup is not empty,
   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 in the
   VersionNumber.  The normal translation of each NamedType nested in
   the AlternativeTypeList in the ExtensionAdditionAlternativesGroup
   SHALL be appended to the [children] of the <extensionGroup> element
   item.















Legg                          Experimental                     [Page 39]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 the translation of 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.

   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 qualified names for the expanded names of the
   NamedType instances [RXEREI] corresponding to the identifiers in the
   PrecedenceList.  A white space separator is one or more of the white
   space characters.








Legg                          Experimental                     [Page 40]
RFC 4912               Abstract Syntax Notation X              July 2007


   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
   <sequenceOf> element item.  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.  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.





Legg                          Experimental                     [Page 41]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 in the
   SequenceOfType SHALL be added to the [children] of the <list> element
   item.

      Aside: A 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

   The translation of a SetOfType follows the same procedure as the
   translation of a SequenceOfType except that SetOfType replaces
   SequenceOfType, "SET" replaces "SEQUENCE", and the [local name]
   "setOf" is used instead of "sequenceOf".



Legg                          Experimental                     [Page 42]
RFC 4912               Abstract Syntax Notation X              July 2007


6.12.9.  Effect of 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
   [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



Legg                          Experimental                     [Page 43]
RFC 4912               Abstract Syntax Notation X              July 2007


   [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 SizeConstraint): A SizeConstraint is a
   simple range if the Constraint in the SizeConstraint contains only a
   ValueRange (i.e., a ValueRange in a SubtypeElements instance in an
   Elements instance in a lone IntersectionElements instance in a lone
   Intersections instance in a Unions instance in an ElementSetSpec in a
   RootElementSetSpec in an ElementSetSpecs instance without an
   AdditionalElementSetSpec in a SubtypeConstraint in a ConstraintSpec
   in the Constraint) and both endpoints are simple.

   Definition (simple range Constraint): 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 instance in an
   Elements instance in a lone IntersectionElements instance in a lone
   Intersections instance in a Unions instance in an ElementSetSpec in a
   RootElementSetSpec in an ElementSetSpecs instance without an
   AdditionalElementSetSpec in a SubtypeConstraint in a 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 initially the
   translation of its notional 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 resulting 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 [local name] "maxSize" SHALL be added to the
   [attributes] of the <sequenceOf>, <setOf>, or <list> element item.



Legg                          Experimental                     [Page 44]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 notional parent type of the TypeWithConstraint
   SHALL be added to the [children] or [attributes] of the <constrained>
   element item.  The translation of the Constraint or SizeConstraint in
   the TypeWithConstraint 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>





Legg                          Experimental                     [Page 45]
RFC 4912               Abstract Syntax Notation X              July 2007


        </size>
       </constrained>
      </type>

6.13.1.  Constraint Translation

   The translation of a Constraint is the translation of the
   ConstraintSpec in the Constraint followed by the translation of the
   ExceptionSpec (possibly empty) in the Constraint.

   The translation of a ConstraintSpec is the translation of the
   SubtypeConstraint or GeneralConstraint in the ConstraintSpec.

   The translation of a SubtypeConstraint is the translation of the
   ElementSetSpecs in the SubtypeConstraint.

   The translation of a GeneralConstraint [X.682] is the translation of
   the UserDefinedConstraint, TableConstraint, or ContentsConstraint in
   the GeneralConstraint.

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 in the UserDefinedConstraint 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 SHALL
   be added to the [children] or [attributes] of the <valueParameter>
   element item.  The translation of the Value SHALL be added to the
   [children] 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 SHALL be added to the [children] or [attributes] of the



Legg                          Experimental                     [Page 46]
RFC 4912               Abstract Syntax Notation X              July 2007


   <objectParameter> element item.  The translation of the Object SHALL
   be added to the [children] or [attributes] of the <objectParameter>
   element item.

   The translation of a UserDefinedConstraintParameter of the
   "Governor : ObjectSet" form is an element item with the [local name]
   "objectSetParameter".  The translation of the DefinedObjectClass in
   the Governor SHALL be added to the [children] or [attributes] of the
   <objectSetParameter> element item.  The translation of the ObjectSet
   SHALL be added to the [children] 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



Legg                          Experimental                     [Page 47]
RFC 4912               Abstract Syntax Notation X              July 2007


   ComponentRelationConstraint SHALL be added to the [children] or
   [attributes] of the <table> element item.  The translation of each
   AtNotation in the ComponentRelationConstraint SHALL be appended to
   the [children] of the <table> element item.

   The translation of an AtNotation is an element item with the
   [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 solidus ('/', U+002F) separated list of
   qualified names for the expanded names of the NamedType instances
   [RXEREI] identified by the identifiers in the ComponentIdList in the
   AtNotation.  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 qualified name
   for the expanded name is prefixed with the commercial at character
   ('@', U+0040).  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 solidus character ('/', U+002F).

   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-att  [RXER:NAME AS "ID"] [RXER:ATTRIBUTE]
                      TYPE-IDENTIFIER.&id({AllTypes}),
          value   TYPE-IDENTIFIER.&Type({AllTypes}{@id-att})
      }

      <type>
       <sequence>
        <attribute name="ID" identifier="id-att">



Legg                          Experimental                     [Page 48]
RFC 4912               Abstract Syntax Notation X              July 2007


         <type>
          <constrained>
           <type>
            <fromClass class="asnx:TYPE-IDENTIFIER" fieldName="id"/>
           </type>
           <table objectset="tns:AllTypes"/>
          </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.




Legg                          Experimental                     [Page 49]
RFC 4912               Abstract Syntax Notation X              July 2007


   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.
   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 ExceptionIdentification in a non-empty ExceptionSpec is a
   SignedNumber, then the translation of a notional INTEGER Type SHALL
   be added to the [children] or [attributes] of the <exception> element
   item, and the translation of a notional Value of the INTEGER type
   with the SignedNumber as its IntegerValue SHALL be added to the
   [children] or [attributes] of the <exception> element item.

   If the ExceptionIdentification in a non-empty ExceptionSpec is a
   DefinedValue, then the translation of a notional INTEGER Type SHALL
   be added to the [children] or [attributes] of the <exception> element
   item, and the translation of the DefinedValue SHALL be added to the
   [children] or [attributes] of the <exception> element item.








Legg                          Experimental                     [Page 50]
RFC 4912               Abstract Syntax Notation X              July 2007


   If the ExceptionIdentification in a non-empty ExceptionSpec is of the
   "Type : Value" form, then the translation of the Type SHALL be added
   to the [children] or [attributes] of the <exception> element item,
   and the translation of the Value SHALL be added to the [children] or
   [attributes] of the <exception> element item.

   Examples

      !10

      <exception type="asnx:INTEGER" literalValue="10"/>

      !myValue

      <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:

   (1) the Value is a BuiltinValue, and

       (a) the BuiltinValue is a TaggedValue and the Value in the
           TaggedValue is a notational value, or

       (b) the BuiltinValue is a SequenceValue or SetValue with a
           ComponentValueList that contains a NamedValue where the Value
           in the NamedValue is a notational value and the translation
           of the corresponding NamedType (from the governing type of
           the outer Value) is not an <element> or <component> element
           item, or





Legg                          Experimental                     [Page 51]
RFC 4912               Abstract Syntax Notation X              July 2007


       (c) the BuiltinValue is a ChoiceValue where the Value of the
           ChoiceValue is a notational value and the translation of the
           NamedType corresponding to the identifier in the ChoiceValue
           is not an <element> or <component> element item, or

       (d) the BuiltinValue is a SequenceOfValue or SetOfValue with a
           NamedValueList that contains a NamedValue where the Value of
           the NamedValue is a notational value and the translation of
           the corresponding NamedType (from the governing type of the
           outer Value) is not an <element> or <component> element item,
           or

   (2) the Value is a ReferencedValue, and

       (a) the ReferencedValue is a ValueFromObject, or

       (b) 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 (see
                 Section 13) is a notational value, 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 13), or

   (3) the Value is an ObjectClassFieldValue, and

       (a) the ObjectClassFieldValue is an OpenTypeFieldVal, or

       (b) the ObjectClassFieldValue is a FixedTypeFieldVal, and

           (i)  the FixedTypeFieldVal is a BuiltinValue that satisfies
                case (1), or

           (ii) the FixedTypeFieldVal is a ReferencedValue that
                satisfies case (2).

   A literal value that is a BuiltinValue that is a SequenceValue,
   SetValue, ChoiceValue, SequenceOfValue, or SetOfValue MAY be
   translated as a notational value.





Legg                          Experimental                     [Page 52]
RFC 4912               Abstract Syntax Notation X              July 2007


   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".  The [normalized value] of
   this attribute item is the RXER character data translation [RXER] of
   the literal value.

   The attribute form translation of a literal value SHALL NOT be used
   if:

   (1) the RXER Infoset translation of the literal value is not a
       character data translation [RXER] or is a character data
       translation that contains qualified names [XMLNS10][XMLNS11], or

   (2) attribute form translations of Value have been explicitly
       disallowed in the context where the literal value appears, or

   (3) the literal value has a nested notational value.

   The element form translation of a literal value is an element item
   with the [local name] "literalValue".  The [children] and
   [attributes] of the <literalValue> element item are set to the RXER
   Infoset translation of the literal 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"
   (i.e., asnx:literal="false") MUST be added to the [attributes] of
   that element item.

   Each outermost <literalValue> 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.



Legg                          Experimental                     [Page 53]
RFC 4912               Abstract Syntax Notation X              July 2007


      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"
   (i.e., asnx:literal="true") MAY be added to the [attributes] of the
   <literalValue> element item and/or any nested element item with
   content and attributes that 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).

   Example

      zero INTEGER ::= 0

      <namedValue name="zero" type="asnx:INTEGER" literalValue="0"/>

          OR

      <namedValue name="zero" type="asnx:INTEGER">
       <literalValue>0</literalValue>
      </namedValue>

   From the perspective of an ASN.X module as the RXER encoding of an
   ASN.1 value (an abstract value of the ModuleDefinition type in
   Appendix A), the type of the <literalValue> element is the
   unconstrained Markup type [RXER], not the governing type of the Value
   according to the ASN.1 specification.  This means that the Infoset
   representation of the <literalValue> element must be preserved in
   re-encodings of the ASN.X module.

   Similarly, the type of the literalValue attribute is a UTF8String,
   not the governing type of the Value according to the ASN.1
   specification.  This means that the exact characters of the
   [normalized value] of the attribute must be preserved in re-encodings
   of the ASN.X module.

7.2.  Translation of Notational Values

   The translation of a notational value is the translation of the
   BuiltinValue, ReferencedValue, or ObjectClassFieldValue in the
   notational value.

   The translation of a ReferencedValue is the translation of the
   DefinedValue or ValueFromObject in the ReferencedValue.



Legg                          Experimental                     [Page 54]
RFC 4912               Abstract Syntax Notation X              July 2007


   The translation for each of 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

      nothing INTEGER ::= zero

      <namedValue name="nothing" type="asnx:INTEGER" value="tns:zero"/>

          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"



Legg                          Experimental                     [Page 55]
RFC 4912               Abstract Syntax Notation X              July 2007


                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 a qualified name for the expanded name of the
   referenced value definition (see Section 5.1).  The attribute form
   translation SHALL NOT be used if this expanded name is not distinct
   with respect to the current module and the modules referenced by its
   <import> element items (see Section 5.1).

   The element form translation of a value reference 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 attribute item with the [local name] "ref" SHALL be added
   to the [attributes] of the <value> element item.  The
   [normalized value] of this attribute item is a qualified name for the
   expanded name of the referenced value definition.  If this expanded
   name is not distinct with respect to the current module and the
   modules referenced by its <import> element items, 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).

   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





Legg                          Experimental                     [Page 56]
RFC 4912               Abstract Syntax Notation X              July 2007


   particular, the attribute form translation SHALL NOT be used for a
   DefinedValue in a ReferencedValue in a Value 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 13).

7.2.2.  BuiltinValue Translation

   The translation of a BuiltinValue is the translation of the
   ChoiceValue, SequenceValue, SetValue, SequenceOfValue, SetOfValue, or
   TaggedValue in the BuiltinValue.

      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 Value in
   the TaggedValue (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",
   "element", "component", "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 a qualified name for the expanded 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.  If the SequenceValue or SetValue has a ComponentValueList,
   then the translation of each NamedValue nested in the
   ComponentValueList 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.







Legg                          Experimental                     [Page 57]
RFC 4912               Abstract Syntax Notation X              July 2007


   The translation of a SequenceOfValue or SetOfValue 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 or SetOfValue has a NamedValueList, then the
   translation of each NamedValue nested in the NamedValueList SHALL be
   appended to the [children] of the <value> element item.

   If the SequenceOfValue or SetOfValue has a ValueList, then an element
   item with the same [local name] (i.e., "element" or "component") as
   the element item in the [children] of the <sequenceOf> or <setOf>
   element item in the translation of the governing type SHALL be
   appended to the [children] of the <value> element item for each Value
   nested 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", "component", "group", "item", or
   "simpleContent".  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 a qualified name for the
   expanded 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

      -- 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>



Legg                          Experimental                     [Page 58]
RFC 4912               Abstract Syntax Notation X              July 2007


            <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">
         <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>



Legg                          Experimental                     [Page 59]
RFC 4912               Abstract Syntax Notation X              July 2007


          <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 instance in the
   ValueFromObject SHALL be added to the [children] or [attributes] of
   the <fromObjects> element item.

   The translation of the FieldName in the ValueFromObject SHALL be
   added to the [children] or [attributes] of the <fromObjects> element
   item.

7.2.4.  ObjectClassFieldValue Translation

   If an ObjectClassFieldValue is a BuiltinValue in a FixedTypeFieldVal,
   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



Legg                          Experimental                     [Page 60]
RFC 4912               Abstract Syntax Notation X              July 2007


   appended to the [children] of the <value> element item.  The
   translation of the Type in the OpenTypeFieldVal SHALL be added to the
   [children] or [attributes] of the <openTypeValue> element item.  The
   translation of the Value in the OpenTypeFieldVal SHALL be added to
   the [children] 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 instance 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"/>
        </range>
       </union>
       <extension>
        <all>
         <range>
          <minInclusive literalValue="9"/>
          <maxInclusive literalValue="19"/>
         </range>
         <except>
          <union>



Legg                          Experimental                     [Page 61]
RFC 4912               Abstract Syntax Notation X              July 2007


           <literalValue>11</literalValue>
           <literalValue>12</literalValue>
          </union>
         </except>
        </all>
       </extension>
      </valueSet>

8.1.  ElementSetSpecs Translation

   The translation of an ElementSetSpecs instance where the ellipsis
   ("...") is not present is the translation of the ElementSetSpec in
   the RootElementSetSpec.

   The translation of an ElementSetSpecs instance 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 in the
   ElementSetSpecs, 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 an 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 instance in the Exclusions SHALL be added
   to the [children] of the <except> element item.

   If an ElementSetSpec is a Unions instance, then the translation of
   the ElementSetSpec is the translation of the Unions instance.

   If a Unions instance has only one nested Intersections instance, then
   the translation of the Unions instance is the translation of that
   Intersections instance; otherwise, the translation of the Unions
   instance is an element item with the [local name] "union".  In the
   latter case, the translation of each nested Intersections instance
   SHALL be appended to the [children] of the <union> element item.

   If an Intersections instance has only one nested IntersectionElements
   instance, then the translation of the Intersections instance is the
   translation of that IntersectionElements instance; otherwise, the
   translation of the Intersections instance is an element item with the
   [local name] "intersection".  In the latter case, the translation of
   each nested IntersectionElements instance SHALL be appended to the
   [children] of the <intersection> element item.



Legg                          Experimental                     [Page 62]
RFC 4912               Abstract Syntax Notation X              July 2007


   If an IntersectionElements instance is of the "Elems Exclusions"
   form, then the translation of the IntersectionElements instance is an
   element item with the [local name] "all".  The translation of the
   Elements instance in the Elems SHALL be added to the [children] of
   the <all> element item.  An element item with the [local name]
   "except" SHALL be appended to the [children] of the <all> element
   item.  The translation of the Elements instance in the Exclusions
   SHALL be added to the [children] of the <except> element item.

   If an IntersectionElements instance is an Elements instance, then the
   translation of the IntersectionElements instance is the translation
   of the Elements instance.

   The translation of an Elements instance is the translation of the
   SubtypeElements, ObjectSetElements, or ElementSetSpec in the Elements
   instance.

8.3.  SubtypeElements Translation

   If a SubtypeElements instance is a SingleValue, then the translation
   of the SubtypeElements instance is the translation of the Value in
   the SingleValue, except that an attribute form of the Value
   translation SHALL NOT be used.

   If a SubtypeElements instance is a ContainedSubtype, then the
   translation of the SubtypeElements instance 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 instance is a ValueRange, then the translation
   of the SubtypeElements instance is the translation of the ValueRange.

   If a SubtypeElements instance is a SizeConstraint, then the
   translation of the SubtypeElements instance 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 instance is a TypeConstraint, then the
   translation of the SubtypeElements instance 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                          Experimental                     [Page 63]
RFC 4912               Abstract Syntax Notation X              July 2007


   If a SubtypeElements instance is a PermittedAlphabet, then the
   translation of the SubtypeElements instance 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 instance is an InnerTypeConstraints instance,
   then the translation of the SubtypeElements instance is the
   translation of the InnerTypeConstraints instance.

   If a SubtypeElements instance is a PatternConstraint, then the
   translation of the SubtypeElements instance 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 a Value, then the translation of the Value 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 a Value, 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 a Value, then the translation of the Value SHALL be
   added to the [children] or [attributes] of the <maxExclusive> element
   item.





Legg                          Experimental                     [Page 64]
RFC 4912               Abstract Syntax Notation X              July 2007


   If the UpperEndpoint in the ValueRange is of the "UpperEndValue" form
   and the UpperEndValue is a Value, then an element item with the
   [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 instance that has a
   SingleTypeConstraint 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 instance that has a
   MultipleTypeConstraints instance is an element item with the
   [local name] "withComponents".  If the MultipleTypeConstraints
   instance 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.



Legg                          Experimental                     [Page 65]
RFC 4912               Abstract Syntax Notation X              July 2007


   If the MultipleTypeConstraints instance 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 nested in the TypeConstraints instance in the
   FullSpecification or PartialSpecification 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., "attribute", "element", "component", "group",
   "member", or "simpleContent") as the translation of the NamedType
   corresponding to the identifier in the NamedConstraint.  An attribute
   item with the [local name] "name" SHALL be added to the [attributes]
   of the <attribute>, <element>, <component>, <group>, <member>, or
   <simpleContent> element item.  The [normalized value] of this
   attribute item is a qualified name for the expanded name of the
   NamedType corresponding to the identifier in the NamedConstraint.

   If the PresenceConstraint in the ComponentConstraint in 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>, <member>, or
   <simpleContent> element item.  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 in 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>, <member>, or
   <simpleContent> element item.

9.  Translation of Object Classes

   The translation of an ObjectClass is the translation of the
   DefinedObjectClass, ObjectClassDefn, or ParameterizedObjectClass in
   the ObjectClass.

   The translation of a ParameterizedObjectClass is described in
   Section 13.

9.1.  DefinedObjectClass Translation

   If a DefinedObjectClass is an objectclassreference (not a
   DummyReference), an ExternalObjectClassReference, or a
   UsefulObjectClassReference, then the translation of the





Legg                          Experimental                     [Page 66]
RFC 4912               Abstract Syntax Notation X              July 2007


   DefinedObjectClass is either the attribute form translation of an
   object class reference, or the element form translation of an object
   class reference.

   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 a qualified name for the expanded name of
   the referenced object class definition (see Section 5.1).  In the
   case of a UsefulObjectClassReference, the namespace name of the
   expanded name is "urn:ietf:params:xml:ns:asnx", and the local name is
   either "TYPE-IDENTIFIER" or "ABSTRACT-SYNTAX", as the case may be.
   The attribute form translation SHALL NOT be used if the expanded name
   is not distinct with respect to the current module and the modules
   referenced by its <import> element items (see Section 5.1).
   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 element item with the
   [local name] "annotation" MAY be added to the [children] of the
   <class> element item.  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 a qualified name for the
   expanded name of the referenced object class definition.  In the case
   of a UsefulObjectClassReference, the namespace name of the expanded
   name is "urn:ietf:params:xml:ns:asnx" and the local name is either
   "TYPE-IDENTIFIER" or "ABSTRACT-SYNTAX", as the case may be.  If the
   expanded name is not distinct with respect to the current module and
   the modules referenced by its <import> element items, 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).

   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 13).



Legg                          Experimental                     [Page 67]
RFC 4912               Abstract Syntax Notation X              July 2007


9.2.  ObjectClassDefn Translation

   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 the
   TypeFieldSpec, FixedTypeValueFieldSpec, VariableTypeValueFieldSpec,
   FixedTypeValueSetFieldSpec, VariableTypeValueSetFieldSpec,
   ObjectFieldSpec, or ObjectSetFieldSpec in the FieldSpec.

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 the
   "OPTIONAL" form 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 the
   "DEFAULT Type" form 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 in the
   TypeFieldSpec, without the ampersand character ('&', 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
      }





Legg                          Experimental                     [Page 68]
RFC 4912               Abstract Syntax Notation X              July 2007


      <class>
       <typeField name="One"/>
       <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 the "OPTIONAL" form 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 the "DEFAULT Value" form 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
   in the FixedTypeValueFieldSpec, without the ampersand character ('&',
   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.




Legg                          Experimental                     [Page 69]
RFC 4912               Abstract Syntax Notation X              July 2007


   Example

      CLASS {
          &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 the "OPTIONAL" form 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 the "DEFAULT ValueSet" form 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 in the FixedTypeValueSetFieldSpec, without the
   ampersand character ('&', U+0026).  An element item with the
   [local name] "annotation" MAY be added to the [children] of the



Legg                          Experimental                     [Page 70]
RFC 4912               Abstract Syntax Notation X              July 2007


   <valueSetField> element item.  The translation of the Type in the
   FixedTypeValueSetFieldSpec SHALL be added to the [children] or
   [attributes] of the <valueSetField> element item.

   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 the "OPTIONAL" form 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 the "DEFAULT Value" form 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>



Legg                          Experimental                     [Page 71]
RFC 4912               Abstract Syntax Notation X              July 2007


   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
   in the VariableTypeValueFieldSpec, without the ampersand character
   ('&', 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>







Legg                          Experimental                     [Page 72]
RFC 4912               Abstract Syntax Notation X              July 2007


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 the "OPTIONAL" form 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 VariableTypeValueSetFieldSpec with a
   ValueSetOptionalitySpec of the "DEFAULT ValueSet" form 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 in the VariableTypeValueSetFieldSpec, without
   the ampersand character ('&', 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>



Legg                          Experimental                     [Page 73]
RFC 4912               Abstract Syntax Notation X              July 2007


       <valueSetField name="One">
        <typeFromField fieldName="Syntax"/>
       </valueSetField>
       <optional>
        <valueSetField name="Two">
         <typeFromField fieldName="Syntax"/>
        </valueSetField>
       </optional>
       <optional>
        <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 solidus
   ('/', U+002F) separated list of the PrimitiveFieldName instances in
   the FieldName, 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 solidus character ('/',
   U+002F) in the [normalized value].

   The [children] property of the <fieldName> element item is set to the
   sequence of character items for a solidus ('/', U+002F) separated
   list of the PrimitiveFieldName instances in the FieldName, 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 solidus
   character ('/', U+002F).




Legg                          Experimental                     [Page 74]
RFC 4912               Abstract Syntax Notation X              July 2007


   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".

   The translation of an ObjectFieldSpec with an ObjectOptionalitySpec
   of the "OPTIONAL" form 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 an ObjectFieldSpec with an ObjectOptionalitySpec
   of the "DEFAULT Object" form 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
   in the ObjectFieldSpec, without the ampersand character ('&',
   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
      }









Legg                          Experimental                     [Page 75]
RFC 4912               Abstract Syntax Notation X              July 2007


      <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".

   The translation of an ObjectSetFieldSpec with an
   ObjectSetOptionalitySpec of the "OPTIONAL" form 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 an ObjectSetFieldSpec with an
   ObjectSetOptionalitySpec of the "DEFAULT ObjectSet" form 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 in the ObjectSetFieldSpec, without the
   ampersand character ('&', 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.









Legg                          Experimental                     [Page 76]
RFC 4912               Abstract Syntax Notation X              July 2007


   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>

10.  Translation of Objects

   The translation of an Object is the translation of the DefinedObject,
   ObjectDefn, ObjectFromObject, or ParameterizedObject in the Object.

   The translation of a ParameterizedObject is described in Section 13.

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 a qualified name for the expanded name of the
   referenced object definition (see Section 5.1).  The attribute form
   translation SHALL NOT be used if this expanded name is not distinct
   with respect to the current module and the modules referenced by its
   <import> element items (see Section 5.1).

   The element form translation of an object reference 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



Legg                          Experimental                     [Page 77]
RFC 4912               Abstract Syntax Notation X              July 2007


   <object> element item.  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 a qualified name for the
   expanded name of the referenced object definition.  If this expanded
   name is not distinct with respect to the current module and the
   modules referenced by its <import> element items, 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).

   The translation of the DefinedObject is the same whether the object
   definition is referenced by an objectreference or an
   ExternalObjectReference.

   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 13).

10.2.  ObjectDefn Translation

   An ObjectDefn that is a DefinedSyntax 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 in
   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
   in the FieldSetting, without the ampersand character ('&', U+0026).
   The translation of the Type, Value, ValueSet, Object, or ObjectSet in



Legg                          Experimental                     [Page 78]
RFC 4912               Abstract Syntax Notation X              July 2007


   the Setting in the FieldSetting SHALL be added to the [children] or
   [attributes] 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>
      </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"/>



Legg                          Experimental                     [Page 79]
RFC 4912               Abstract Syntax Notation X              July 2007


         </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 instance in the
   ObjectFromObject SHALL be added to the [children] or [attributes] of
   the <fromObjects> element item.

   The translation of the FieldName in the ObjectFromObject SHALL be
   added to the [children] 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 instance in an Elements
   instance in a lone IntersectionElements instance in a lone
   Intersections instance in a Unions instance in an ElementSetSpec in a
   RootElementSetSpec in an ObjectSetSpec without an
   AdditionalElementSetSpec), 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.






Legg                          Experimental                     [Page 80]
RFC 4912               Abstract Syntax Notation X              July 2007


   If an ObjectSetSpec contains a RootElementSetSpec and an 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.

   Nested within the ElementSetSpec will be one or more
   ObjectSetElements instances.

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 a qualified name for the
   expanded name of the referenced object set definition (see
   Section 5.1).  The attribute form translation SHALL NOT be used if
   this expanded name is not distinct with respect to the current module
   and the modules referenced by its <import> element items (see
   Section 5.1).

   The element form translation of an object set reference 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 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 a qualified
   name for the expanded name of the referenced object set definition.
   If this expanded name is not distinct with respect to the current
   module and the modules referenced by its <import> element items, 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"



Legg                          Experimental                     [Page 81]
RFC 4912               Abstract Syntax Notation X              July 2007


   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).

   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 13).

11.2.  ObjectSetElements Translation

   If an ObjectSetElements instance is an Object, then the translation
   of the ObjectSetElements instance is the translation of the Object,
   except that the attribute form of the DefinedObject translation SHALL
   NOT be used if the Object is a DefinedObject.

   If an ObjectSetElements instance is a DefinedObjectSet, then the
   translation of the ObjectSetElements instance is the translation of
   the DefinedObjectSet, except that the attribute form of the
   DefinedObjectSet translation SHALL NOT be used.

   If an ObjectSetElements instance is an ObjectSetFromObjects, then the
   translation of the ObjectSetElements instance is the translation of
   the ObjectSetFromObjects.

   If an ObjectSetElements instance is a ParameterizedObjectSet, then
   the translation of the ObjectSetElements instance is the translation
   of the ParameterizedObjectSet (see Section 13).

      Aside: The in-line expansion of a ParameterizedObjectSet results
      in an ObjectSet.  An ObjectSetElements instance 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.






Legg                          Experimental                     [Page 82]
RFC 4912               Abstract Syntax Notation X              July 2007


11.2.1.  ObjectSetFromObjects Translation

   The translation of an ObjectSetFromObjects instance 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 instance in the
   ObjectSetFromObjects SHALL be added to the [children] or [attributes]
   of the <fromObjects> element item.

   The translation of the FieldName in the ObjectSetFromObjects SHALL be
   added to the [children] or [attributes] of the <fromObjects> element
   item.

12.  Translation of Information From Objects

   If a ReferencedObjects instance is a DefinedObject (not a
   DummyReference), then the translation of the ReferencedObjects
   instance is the translation of the DefinedObject.

   If a ReferencedObjects instance is a DefinedObjectSet (not a
   DummyReference), then the translation of the ReferencedObjects
   instance is the translation of the DefinedObjectSet.

   If a ReferencedObjects instance is a DummyReference,
   ParameterizedObject, or ParameterizedObjectSet, then the translation
   of the ReferencedObjects instance is the translation of that
   DummyReference, ParameterizedObject, or ParameterizedObjectSet (see
   Section 13).

      Aside: The in-line expansion of a ParameterizedObject or
      ParameterizedObjectSet results in an Object or ObjectSet,
      respectively.  A ReferencedObjects instance that is an Object or
      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 an expanded parameterized definition.

13.  Translation of 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.



Legg                          Experimental                     [Page 83]
RFC 4912               Abstract Syntax Notation X              July 2007


   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
   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.



Legg                          Experimental                     [Page 84]
RFC 4912               Abstract Syntax Notation X              July 2007


   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
   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.

   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:

   (1) the referenced module is the referencing module and does not
       contain an XER encoding control section, or

   (2) 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





Legg                          Experimental                     [Page 85]
RFC 4912               Abstract Syntax Notation X              July 2007


   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.

   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:

   (a) the translation of the substitute definition, or

   (b) 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 (b) is always allowed and provides
   information to identify the referenced module and the referenced
   definition.

   The translation in case (a) 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 (a) is used, then the
   referencing module is still the referencing module when considering a
   nested in-line expansion.  If the translation in case (b) is used,
   then the referenced module becomes the referencing module when
   considering a nested in-line expansion.






Legg                          Experimental                     [Page 86]
RFC 4912               Abstract Syntax Notation X              July 2007


   If case (a) is used for the translation of a DummyReference where the
   substitute definition is a Type, then an attribute form translation
   of the substitute definition 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 substitute definition.  Where
   the automatic tagging transformation applies [X.680], this attribute
   item indicates that explicit tagging applies to the type instead of
   the usual implicit tagging.

   If case (b) is used for the translation of a DummyReference where the
   substitute definition is a Type, then 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 generated by
   case (b).

   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.

   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:

   (1) the conditions permitting the use of the translation in case (a)
       are satisfied, or

   (2) the reference is not a typereference, or






Legg                          Experimental                     [Page 87]
RFC 4912               Abstract Syntax Notation X              July 2007


   (3) 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 case (a) are
   satisfied, or if the referencing module is the referenced module.
   When the <module> element item is present:

   (1) 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.

   (2) 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.

   (3) 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.

   The [attributes] of the <module> element item MUST contain at least
   one of the attribute items specified in cases (1), (2), and (3).

   The translation of the substitute definition SHALL be added to the
   [children] or [attributes] of the <expanded> element item.













Legg                          Experimental                     [Page 88]
RFC 4912               Abstract Syntax Notation X              July 2007


   Example

      Consider these module definitions:

         Templates
         DEFINITIONS
         AUTOMATIC TAGS ::=
         BEGIN

         CollectionOfThings { Thing } ::= SEQUENCE OF thing Thing
             -- the Thing on the right-hand side of the assignment is
             -- a DummyReference

         END

         ProtocolDefinitions
         DEFINITIONS
         AUTOMATIC TAGS ::=
         BEGIN

         IMPORTS
             CollectionOfThings{}
                 FROM Templates
             ;

         CollectionOfIntegers ::= CollectionOfThings { INTEGER }
             -- the right-hand side of the assignment is
             -- a ParameterizedType

         END

      Without using the translation in case (a), the translations of
      these modules are:

         <asnx:module name="Templates"/>

         <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>



Legg                          Experimental                     [Page 89]
RFC 4912               Abstract Syntax Notation X              July 2007


                  <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 ref="asnx:INTEGER" explicit="true"/>
             </element>
            </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]
   "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.





Legg                          Experimental                     [Page 90]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 (a) above) is
      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
         }




Legg                          Experimental                     [Page 91]
RFC 4912               Abstract Syntax Notation X              July 2007


      ValueType is a DummyReference.  The translation of the actual
      parameter substitutes for the DummyReference.  In this case, the
      actual parameter is the INTEGER type.

      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"
                       explicit="true"/><!-- 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>
           <tagged tagClass="application" number="13">
            <type><!-- Tree { INTEGER } -->
             <sequence>
              <element name="value">
               <type>
                <tagged number="0">
                 <type ref="asnx:INTEGER"
                       explicit="true"/><!-- ValueType -->



Legg                          Experimental                     [Page 92]
RFC 4912               Abstract Syntax Notation X              July 2007


                </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>

14.  EncodingControlSections Translation

   If an EncodingControlSections instance contains at least one
   EncodingControlSection with an encodingreference that is not RXER,
   then the translation of the EncodingControlSections instance 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
      module is translated into an ASN.X module.  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.





Legg                          Experimental                     [Page 93]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 in the EncodingControlSection SHALL
   be added to the [children] 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 in the EncodingControlSection SHALL
   be added to the [children] of the <XER> element item.  The
   translation into ASN.X of an EncodingInstructionAssignmentList for
   XER is specified in a separate document [XEREIT].

15.  Security Considerations

   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 module potentially
   changes if it is decoded and re-encoded (though its ASN.1 value is
   preserved), disrupting the Canonical XML representation.  To avoid
   this problem, ASN.X modules MUST be normalized prior to the
   application of syntax-based canonicalization.  The normalization
   rules can be found in Section 6.13 of the specification for RXER
   [RXER].

16.  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.






Legg                          Experimental                     [Page 94]
RFC 4912               Abstract Syntax Notation X              July 2007


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)", RFC 4792, January 2007.

   [RXER]     Legg, S. and D. Prager, "Robust XML Encoding Rules (RXER)
              for Abstract Syntax Notation One (ASN.1)",
               RFC 4910, July 2007.

   [RXEREI]   Legg, S., "Encoding Instructions for the Robust XML
              Encoding Rules (RXER)",
               RFC 4911, July 2007.

   [GSEREIT]  Legg, S., "Abstract Syntax Notation X (ASN.X)
              Representation of Encoding Instructions for the Generic
              String Encoding Rules (GSER)",
               RFC 4913, July 2007.

   [XEREIT]   Legg, S., "Abstract Syntax Notation X (ASN.X)
              Representation of Encoding Instructions for the XML
              Encoding Rules (XER)",
               RFC 4914, July 2007.

   [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.






Legg                          Experimental                     [Page 95]
RFC 4912               Abstract Syntax Notation X              July 2007


   [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
              (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/2006/REC-xml-names11-20060816, August
              2006.

   [INFOSET]  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.






Legg                          Experimental                     [Page 96]
RFC 4912               Abstract Syntax Notation X              July 2007


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.



































Legg                          Experimental                     [Page 97]
RFC 4912               Abstract Syntax Notation X              July 2007


Appendix A.  ASN.1 for ASN.X

   This appendix is normative.

   AbstractSyntaxNotation-X
       { iso(1) identified-organization(3) dod(6)
         internet(1) private(4) enterprise(1)
         xmled(21472) asnx(1) module(0) notation(1) }

   -- Copyright (C) The IETF Trust (2007).  This version of
   -- this ASN.1 module is part of RFC 4912; see the RFC itself
   -- for full legal notices.
   --
   -- Regarding this ASN.1 module or any portion of it, the author
   -- makes no guarantees and is not responsible for any damage
   -- resulting from its use.  The author grants irrevocable permission
   -- to anyone to use, modify, and distribute it in any way that does
   -- not diminish the rights of anyone else to use, modify, and
   -- distribute it, provided that redistributed derivative works do
   -- not contain misleading author or version information.
   -- Derivative works need not be licensed under similar terms.

   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)



Legg                          Experimental                     [Page 98]
RFC 4912               Abstract Syntax Notation X              July 2007


                 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,
           -- 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,



Legg                          Experimental                     [Page 99]
RFC 4912               Abstract Syntax Notation X              July 2007


       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,
       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



Legg                          Experimental                    [Page 100]
RFC 4912               Abstract Syntax Notation X              July 2007


   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 })
           }),
           element   (WITH COMPONENTS { ...,
               definition (WITH COMPONENTS { ..., reference ABSENT })
           }),
           attribute (WITH COMPONENTS { ...,
               definition (WITH COMPONENTS { ..., reference ABSENT })
           }),
           group         ABSENT,
           member        ABSENT,
           item          ABSENT,
           simpleContent ABSENT })

   NamedType ::= [SINGULAR-INSERTIONS] CHOICE {
       component      Element,
       element        Element,
       attribute      Attribute,
       group          InvisibleNamedType,
       member         InvisibleNamedType,
       item           InvisibleNamedType,
       simpleContent  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 }) }) })





Legg                          Experimental                    [Page 101]
RFC 4912               Abstract Syntax Notation X              July 2007


   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
       }
   }

   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
   }




Legg                          Experimental                    [Page 102]
RFC 4912               Abstract Syntax Notation X              July 2007


   ElementFormType ::= [HOLLOW-INSERTIONS] SEQUENCE {
       annotation  Annotation OPTIONAL,
       explicit    [ATTRIBUTE] BOOLEAN OPTIONAL,
       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,
           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
       },
       context    [ATTRIBUTE] AnyURI OPTIONAL,
       embedded   [ATTRIBUTE] BOOLEAN OPTIONAL
   }
   (WITH COMPONENTS { ...,
        name (WITH COMPONENTS { ref PRESENT }) } |
    WITH COMPONENTS { ...,
        name (WITH COMPONENTS { elementType PRESENT }),
        embedded ABSENT })

   ExpandedType ::= SEQUENCE {
       name    [ATTRIBUTE] NCName OPTIONAL,
       module  ReferencedModule OPTIONAL,
       type    [GROUP] Type
   }

   ReferencedModule ::= SEQUENCE {



Legg                          Experimental                    [Page 103]
RFC 4912               Abstract Syntax Notation X              July 2007


       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

   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



Legg                          Experimental                    [Page 104]
RFC 4912               Abstract Syntax Notation X              July 2007


   }

   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,
       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




Legg                          Experimental                    [Page 105]
RFC 4912               Abstract Syntax Notation X              July 2007


   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,
       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
   }




Legg                          Experimental                    [Page 106]
RFC 4912               Abstract Syntax Notation X              July 2007


   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
       } 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, simpleContent 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



Legg                          Experimental                    [Page 107]
RFC 4912               Abstract Syntax Notation X              July 2007


                           (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) })) }) })

   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,
                          simpleContent 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 {



Legg                          Experimental                    [Page 108]
RFC 4912               Abstract Syntax Notation X              July 2007


       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
   }

   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 {



Legg                          Experimental                    [Page 109]
RFC 4912               Abstract Syntax Notation X              July 2007


       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
   }

   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



Legg                          Experimental                    [Page 110]
RFC 4912               Abstract Syntax Notation X              July 2007


   }

   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,
       simpleContent  GenericNamedValue
   }

   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 { ...,



Legg                          Experimental                    [Page 111]
RFC 4912               Abstract Syntax Notation X              July 2007


       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,
       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 {



Legg                          Experimental                    [Page 112]
RFC 4912               Abstract Syntax Notation X              July 2007


       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,
       simpleContent  GenericNamedConstraint
   }

   GenericNamedConstraint ::= [HOLLOW-INSERTIONS] SEQUENCE {
       name        [ATTRIBUTE] QName,
       use         [ATTRIBUTE] PresenceConstraint OPTIONAL,
       constraint  [GROUP] Constraint OPTIONAL
   }

   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,



Legg                          Experimental                    [Page 113]
RFC 4912               Abstract Syntax Notation X              July 2007


       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
       },
       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 { ...,



Legg                          Experimental                    [Page 114]
RFC 4912               Abstract Syntax Notation X              July 2007


             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,
       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



Legg                          Experimental                    [Page 115]
RFC 4912               Abstract Syntax Notation X              July 2007


   }

   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,
           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
   }




Legg                          Experimental                    [Page 116]
RFC 4912               Abstract Syntax Notation X              July 2007


   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,
       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



Legg                          Experimental                    [Page 117]
RFC 4912               Abstract Syntax Notation X              July 2007


       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.

   <?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 IETF Trust (2007).  This version of
     this ASN.X module is part of RFC 4912; see the RFC itself
     for full legal notices.

     Regarding this ASN.X module or any portion of it, the author
     makes no guarantees and is not responsible for any damage
     resulting from its use.  The author grants irrevocable permission
     to anyone to use, modify, and distribute it in any way that does
     not diminish the rights of anyone else to use, modify, and
     distribute it, provided that redistributed derivative works do
     not contain misleading author or version information.
     Derivative works need not be licensed under similar terms.
    </annotation>




Legg                          Experimental                    [Page 118]
RFC 4912               Abstract Syntax Notation X              July 2007


    <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"/>
       </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>



Legg                          Experimental                    [Page 119]
RFC 4912               Abstract Syntax Notation X              July 2007


       <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"/>
      </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">



Legg                          Experimental                    [Page 120]
RFC 4912               Abstract Syntax Notation X              July 2007


     <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"/>
       <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>



Legg                          Experimental                    [Page 121]
RFC 4912               Abstract Syntax Notation X              July 2007


        <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">
     <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"/>



Legg                          Experimental                    [Page 122]
RFC 4912               Abstract Syntax Notation X              July 2007


       <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"/>
       <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"/>



Legg                          Experimental                    [Page 123]
RFC 4912               Abstract Syntax Notation X              July 2007


       <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">
            <group name="reference" use="absent"/>
           </withComponents>
          </group>
         </withComponents>
        </element>
        <element name="group" use="absent"/>
        <element name="member" use="absent"/>
        <element name="item" use="absent"/>
        <element name="simpleContent" use="absent"/>
       </withComponents>
      </constrained>
     </type>
    </namedType>

    <namedType name="NamedType">



Legg                          Experimental                    [Page 124]
RFC 4912               Abstract Syntax Notation X              July 2007


     <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"/>
       <element name="simpleContent" 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">
        <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>



Legg                          Experimental                    [Page 125]
RFC 4912               Abstract Syntax Notation X              July 2007


    <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"/>
         </choice>
        </type>
       </group>
      </sequence>
     </type>
    </namedType>

    <namedType name="IdentifierOrEmpty">
     <type>
      <constrained type="asnx:UTF8String">
       <union>
        <includes type="asnx:Identifier"/>
        <literalValue></literalValue>
       </union>



Legg                          Experimental                    [Page 126]
RFC 4912               Abstract Syntax Notation X              July 2007


      </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">
          <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>



Legg                          Experimental                    [Page 127]
RFC 4912               Abstract Syntax Notation X              July 2007


       </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"/>
       </optional>
       <optional>
        <attribute name="explicit" type="asnx:BOOLEAN"/>
       </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"/>



Legg                          Experimental                    [Page 128]
RFC 4912               Abstract Syntax Notation X              July 2007


             </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>
        <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="context" type="asnx:AnyURI"/>
         </optional>
         <optional>
          <attribute name="embedded" type="asnx:BOOLEAN"/>
         </optional>



Legg                          Experimental                    [Page 129]
RFC 4912               Abstract Syntax Notation X              July 2007


        </sequence>
       </type>
       <union>
        <withComponents partial="true">
         <group name="name">
          <withComponents>
           <attribute name="ref" use="present"/>
          </withComponents>
         </group>
        </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>
       <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"/>



Legg                          Experimental                    [Page 130]
RFC 4912               Abstract Syntax Notation X              July 2007


       </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>
      </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>



Legg                          Experimental                    [Page 131]
RFC 4912               Abstract Syntax Notation X              July 2007


       <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>
      <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>



Legg                          Experimental                    [Page 132]
RFC 4912               Abstract Syntax Notation X              July 2007


    <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>
     </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>



Legg                          Experimental                    [Page 133]
RFC 4912               Abstract Syntax Notation X              July 2007


    </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
            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"/>



Legg                          Experimental                    [Page 134]
RFC 4912               Abstract Syntax Notation X              July 2007


      </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">
     <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>



Legg                          Experimental                    [Page 135]
RFC 4912               Abstract Syntax Notation X              July 2007


       <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>
              <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">



Legg                          Experimental                    [Page 136]
RFC 4912               Abstract Syntax Notation X              July 2007


       <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">
        <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"/>



Legg                          Experimental                    [Page 137]
RFC 4912               Abstract Syntax Notation X              July 2007


       <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"/>

    <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"/>



Legg                          Experimental                    [Page 138]
RFC 4912               Abstract Syntax Notation X              July 2007


           </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">
       <withComponents partial="true">
        <element name="item" use="absent"/>
        <element name="simpleContent" 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"



Legg                          Experimental                    [Page 139]
RFC 4912               Abstract Syntax Notation X              July 2007


                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">
          <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>



Legg                          Experimental                    [Page 140]
RFC 4912               Abstract Syntax Notation X              July 2007


        </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">
           <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>



Legg                          Experimental                    [Page 141]
RFC 4912               Abstract Syntax Notation X              July 2007


       </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>
         </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"/>



Legg                          Experimental                    [Page 142]
RFC 4912               Abstract Syntax Notation X              July 2007


           <element name="member" use="absent"/>
           <element name="simpleContent" 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">
        <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>



Legg                          Experimental                    [Page 143]
RFC 4912               Abstract Syntax Notation X              July 2007


     </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>
       <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>



Legg                          Experimental                    [Page 144]
RFC 4912               Abstract Syntax Notation X              July 2007


      <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"/>
         </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>



Legg                          Experimental                    [Page 145]
RFC 4912               Abstract Syntax Notation X              July 2007


     </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>
          <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>



Legg                          Experimental                    [Page 146]
RFC 4912               Abstract Syntax Notation X              July 2007


    <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>

    <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>



Legg                          Experimental                    [Page 147]
RFC 4912               Abstract Syntax Notation X              July 2007


           </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"/>
       </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"/>



Legg                          Experimental                    [Page 148]
RFC 4912               Abstract Syntax Notation X              July 2007


       <element name="attribute" type="asnx:GenericNamedValue"/>
       <element name="group" type="asnx:GenericNamedValue"/>
       <element name="member" type="asnx:GenericNamedValue"/>
       <element name="item" type="asnx:GenericNamedValue"/>
       <element name="simpleContent" 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>
    </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>



Legg                          Experimental                    [Page 149]
RFC 4912               Abstract Syntax Notation X              July 2007


    <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>
        </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>



Legg                          Experimental                    [Page 150]
RFC 4912               Abstract Syntax Notation X              July 2007


    </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>
        </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">



Legg                          Experimental                    [Page 151]
RFC 4912               Abstract Syntax Notation X              July 2007


         <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>
     </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"/>



Legg                          Experimental                    [Page 152]
RFC 4912               Abstract Syntax Notation X              July 2007


       </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"/>
       <element name="simpleContent"
                type="asnx:GenericNamedConstraint"/>
      </choice>
     </type>
    </namedType>

    <namedType name="GenericNamedConstraint">
     <type>
      <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"/>



Legg                          Experimental                    [Page 153]
RFC 4912               Abstract Syntax Notation X              July 2007


       <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>

    <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>



Legg                          Experimental                    [Page 154]
RFC 4912               Abstract Syntax Notation X              July 2007


     </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"/>
       <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"/>



Legg                          Experimental                    [Page 155]
RFC 4912               Abstract Syntax Notation X              July 2007


            <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>
         </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>



Legg                          Experimental                    [Page 156]
RFC 4912               Abstract Syntax Notation X              July 2007


         <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">
           <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>



Legg                          Experimental                    [Page 157]
RFC 4912               Abstract Syntax Notation X              July 2007


        <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>
        <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"/>



Legg                          Experimental                    [Page 158]
RFC 4912               Abstract Syntax Notation X              July 2007


    <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>
    </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"



Legg                          Experimental                    [Page 159]
RFC 4912               Abstract Syntax Notation X              July 2007


               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>
    </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">



Legg                          Experimental                    [Page 160]
RFC 4912               Abstract Syntax Notation X              July 2007


     <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">
       <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"/>



Legg                          Experimental                    [Page 161]
RFC 4912               Abstract Syntax Notation X              July 2007


          <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>
          <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">



Legg                          Experimental                    [Page 162]
RFC 4912               Abstract Syntax Notation X              July 2007


         <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>
          <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>



Legg                          Experimental                    [Page 163]
RFC 4912               Abstract Syntax Notation X              July 2007


    <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
   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












Legg                          Experimental                    [Page 164]
RFC 4912               Abstract Syntax Notation X              July 2007


Full Copyright Statement

   Copyright (C) The IETF Trust (2007).

   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, THE IETF TRUST 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
   ietf-ipr@ietf.org.

Acknowledgement

   Funding for the RFC Editor function is currently provided by the
   Internet Society.







Legg                          Experimental                    [Page 165]
  1. RFC 4912