"ГОСТ Р ИСО/МЭК 8825-3-2016. Национальный стандарт Российской Федерации. Информационная технология. Правила кодирования АСН.1. Часть 3. Спецификация нотации контроля кодирования (ECN)"
(утв. и введен в действие Приказом Росстандарта от 07.11.2016 N 1597-ст)

0 до 9	(ЦИФРА НУЛЬ ... ЦИФРА 9)
A до Z	(ЛАТИНСКИЕ ПРОПИСНЫЕ БУКВЫ ОТ A ДО Z)
a до z	(ЛАТИНСКИЕ СТРОЧНЫЕ БУКВЫ ОТ A ДО Z)
"	(КАВЫЧКИ)
#	(ЗНАК НОМЕРА)
&	(СОЮЗ "И")
'	(АПОСТРОФ)
(	(ЛЕВАЯ КРУГЛАЯ СКОБКА)
)	(ПРАВАЯ КРУГЛАЯ СКОБКА)
,	(ЗАПЯТАЯ)
.	(ТОЧКА)
-	(ДЕФИС, МИНУС)
:	(ДВОЕТОЧИЕ)
;	(ТОЧКА С ЗАПЯТОЙ)
<	(ЗНАК "МЕНЬШЕ, ЧЕМ")
=	(ЗНАК РАВЕНСТВА)
>	(ЗНАК "БОЛЬШЕ, ЧЕМ")
{	(ЛЕВАЯ ФИГУРНАЯ СКОБКА)
|	(ВЕРТИКАЛЬНАЯ ЧЕРТА)
}	(ПРАВАЯ ФИГУРНАЯ СКОБКА)

ALL AS BEGIN BER BITS BY CER COMPLETED DECODE DER DISTRIBUTION ENCODE ENCODING-CLASS ENCODE-DECODE ENCODING-DEFINITIONS END EXCEPT EXPORTS FALSE

FIELDS FROM GENERATES IF IMPORTS IN LINK-DEFINITIONS MAPPING MAX MIN MINUS-INFINITY NON-ECN-BEGIN NON-ECN-END NULL OPTIONAL-ENCODING OPTIONS ORDERED OUTER PER-BASIC-ALIGNED

PER-BASIC-UNALIGNED PER-CANONICAL-ALIGNED PER-CANONICAL-UNALIGNED PLUS-INFINITY REFERENCE REMAINDER RENAMES SIZE STRUCTURE STRUCTURED TO TRANSFORMS TRUE UNION USE USE-SET VALUES WITH

#ALTERNATIVES #BITS #BIT-STRING #BMPString #BOOL #BOOLEAN #CHARACTER-STRING #CHARS #CHOICE #CONCATENATION #CONDITIONAL-INT #CONDITIONAL-REPETITION #DATE #DATE-TIME #DURATION #EMBEDDED-PDV #ENCODINGS

#ENUMERATED #EXTERNAL #GeneralizedTime #GeneralString #GraphicString #IA5String #INT #INTEGER #NUL #NULL #NumericString #OBJECT-IDENTIFIER #ObjectDescriptor #OCTETS #OCTET-STRING #OPEN-TYPE #OPTIONAL #OUTER

#PAD #PrintableString #REAL #RELATIVE-OID #REPETITION #SEQUENCE #SEQUENCE-OF #SET #SET-OF #TAG #TeletexString #TIME-OF-DAY #TRANSFORM #UniversalString #UTCTime #UTF8String #VideotexString #VisibleString

ExternalEncodingClassReference ::= modulereference "." encodingclassreference | modulereference "." BuiltinEncodingClassReference ExternalEncodingObjectReference ::= modulereference "." encodingobjectreference ExternalEncodingObjectSetReference ::= modulereference "." encodingobjectsetreference

- классы кодирования "ParameterizedEncodingClassAssignment" (см. C.1); "ParameterizedEncodingClass" (см. C.3); - объекты кодирования "ParameterizedEncodingObjectAssignment" (см. C.1); "ParameterizedEncodingObject" (см. C.3); - наборы объектов кодирования "ParameterizedEncodingObjectSetAssignment" (см. C.1); "ParameterizedEncodingObjectSet" (см. C.3).

DefinedEncodingClass ::= encodingclassreference | ExternalEncodingClassReference | ParameterizedEncodingClass DefinedOrBuiltinEncodingClass ::= DefinedEncodingClass | BuiltinEncodingClassReference

DefinedEncodingObject ::= encodingobjectreference | ExternalEncodingObjectReference | ParameterizedEncodingObject

DefinedEncodingObjectSet ::= encodingobjectsetreference | ExternalEncodingObjectSetReference | ParameterizedEncodingObjectSet DefinedOrBuiltinEncodingObjectSet ::= DefinedEncodingObjectSet | BuiltinEncodingObjectSetReference

Нотация АСН.1	Класс кодирования	Простейший класс
BIT STRING	#BIT-STRING	#BITS
BOOLEAN	#BOOLEAN	#BOOL
CHARACTER STRING	#CHARACTER-STRING	Определен с помощью #SEQUENCE
CHOICE	#CHOICE	#ALTERNATIVES
EMBEDDED PDV	#EMBEDDED-PDV	Определен с помощью #SEQUENCE
ENUMERATED	#ENUMERATED	#INT
EXTERNAL	EXTERNAL#EXTERNAL	Определен с помощью #SEQUENCE
INTEGER	#INTEGER	#INT
NULL	#NULL	#NUL
OBJECT IDENTIFIER	#OBJECT-IDENTIFIER	#OBJECT-IDENTIFIER
OCTET STRING	#OCTET-STRING	#OCTETS
нотация открытого типа	#OPEN-TYPE	#OPEN-TYPE
OPTIONAL	#OPTIONAL	#OPTIONAL
REAL	#REAL	#REAL
RELATIVE-OID	#RELATIVE-OID	#OBJECT-IDENTIFIER
SEQUENCE	#SEQUENCE	#CONCATENATION
SEQUENCE OF	#SEQUENCE-OF	#REPETITION
SET	#SET	#CONCATENATION
SET OF	#SET-OF	#REPETITION
TIME	#TIME	#TIME
DATE	#DATE	#TIME
TIME-OF-DAY	#TIMEh-OF-DAY	#TIME
DATE-TIME	#DATE-TIME	#TIME
DURATION	#DURATION	#TIME
GeneralizedTime	#GeneralizedTime	#CHARS
UTCTime	#UTCTime	#CHARS
ObjectDescriptor	#ObjectDescriptor	#CHARS
BMPString	#BMPString	#CHARS
GeneralString	#GeneralString	#CHARS
GraphicString	#GraphicString	#CHARS
IA5String	#IA5String	#CHARS
NumericString	#NumericString	#CHARS
PrintableString	#PrintableString	#CHARS
TeletexString	#TeletexString	#CHARS
UniversalString	#UniversalString	#CHARS
UTF8String	#UTF8String	#CHARS
VideotexString	#VideotexString	#CHARS
VisibleString	#VisibleString	#CHARS
Текстуально изложенная нотация тега	#TAG	#TAG

ELMDefinition ::= ModuleIdentifier LINK-DEFINITIONS "::=" BEGIN ELMModuleBody END

ELMModuleBody ::= Imports ? EncodingApplicationList EncodingApplicationList ::= EncodingApplication EncodingApplicationList ?

EncodingApplication ::= ENCODE SimpleDefinedEncodingClass "," + CombinedEncodings

CombinedEncodings ::= WITH PrimaryEncodings CompletionClause ? CompletionClause ::= COMPLETED BY SecondaryEncodings PrimaryEncodings ::= EncodingObjectSet SecondaryEncodings ::= EncodingObjectSet

EDMDefinition ::= ModuleIdentifier ENCODING-DEFINITIONS "::=" BEGIN EDMModuleBody END

EDMModuleBody ::= Exports ? RenamesAndExports ? Imports ? EDMAssignmentList ? EDMAssignmentList ::= EDMAssignment EDMAssignmentList ? EDMAssignment ::= EncodingClassAssignment | EncodingObjectAssignment | EncodingObjectSetAssignment | ParameterizedAssignment

EncodingClassAssignment раздел 16; EncodingObjectAssignment раздел 17; EncodingObjectSetAssignment раздел 18; ParameterizedAssignment подраздел C.1.

RenamesAndExports ::= RENAMES ExplicitGenerationList ";" ExplicitGenerationList ::= ExplicitGeneration ExplicitGenerationList ? ExplicitGeneration ::= OptionalNameChanges FROM GlobalModuleReference OptionalNameChanges ::= NameChanges | GENERATES

NameChanges ::= NameChange NameChanges ? NameChange ::= OriginalClassName AS NewClassName IN NameChangeDomain OriginalClassName ::= SimpleDefinedEncodingClass| BuiltinEncodingClassReference NewClassName ::= encodingclassreference

NameChangeDomain ::= IncludedRegions Exception ? Exception ::= EXCEPT ExcludedRegions IncludedRegions ::= ALL | RegionList ExcludedRegions ::= RegionList RegionList ::= Region "," + Region ::= SimpleDefinedEncodingClass | ComponentReference ComponentReference ::= SimpleDefinedEncodingClass "." ComponentIdList ComponentIdList ::= identifier "." +

EncodingClassAssignment ::= encodingclassreference "::=" EncodingClass

EncodingClass ::= BuiltinEncodingClassReference | EncodingStructure

BuiltinEncodingClassReference ::= BitfieldClassReference | AlternativesClassReference | ConcatenationClassReference | RepetitionClassReference | OptionalityClassReference | TagClassReference | EncodingProcedureClassReference

BitfieldClassReference ::= #NUL | #BOOL | #INT | #BITS | #OCTETS | #CHARS | #PAD | #BIT-STRING | #BOOLEAN | #CHARACTER-STRING | #EMBEDDED-PDV | #ENUMERATED | #EXTERNAL | #INTEGER | #NULL | #OBJECT-IDENTIFIER | #OCTET-STRING | #OPEN-TYPE | #REAL | #RELATIVE-OID | #TIME | #DATE | #DATE-TIME | #TIME-OF-DAY | #DURATION | #GeneralizedTime | #UTCTime | #ObjectDescriptor | #BMPString | #GeneralString | #GraphicString | #IA5String | #NumericString | #PrintableString | #TeletexString | #UniversalString | #UTF8String | #VideotexString | #VisibleString

AlternativesClassReference ::= #ALTERNATIVES | #CHOICE

ConcatenationClassReference ::= #CONCATENATION | #SEQUENCE | #SET

RepetitionClassReference ::= #REPETITION | #SEQUENCE-OF | #SET-OF

OptionalityClassReference ::= #OPTIONAL

TagClassReference ::= #TAG

EncodingProcedureClassReference ::= #TRANSFORM | #CONDITIONAL-INT | #CONDITIONAL-REPETITION | #OUTER

Предопределенный класс	Образован из	Категория
#ALTERNATIVES	(простейший)	alternatives
#BITS	(простейший)	bitstring
#BIT-STRING	#BITS
#BOOL	(простейший)	boolean
#BOOLEAN	#BOOL
#CHARACTER-STRING	(определен с помощью #SEQUENCE)
#CHARS	(простейший)	characterstring
#CHOICE	#ALTERNATIVES
#CONCATENATION	(простейший)	concatenation
#CONDITIONAL-INT	(простейший)	encoding procedure
#CONDITIONAL-REPETITION	(простейший)	encoding procedure
#EMBEDDED-PDV	(определен с помощью #SEQUENCE)
#ENUMERATED	#INT
#EXTERNAL	(определен с помощью #SEQUENCE)
#INT	(простейший)	integer
#INTEGER	#INT
#NUL	(простейший)	null
#NULL	#NUL
#OBJECT-IDENTIFIER	(простейший)	objectidentifier
#OCTETS	(простейший)	octetstring
#OCTET-STRING	#OCTETS
#OPEN-TYPE	(простейший)	opentype
#OPTIONAL	(простейший)	optionality
#OUTER	(простейший)	encoding procedure
#PAD	(простейший)	pad
#REAL	(простейший)	real
#RELATIVE-OID	#OBJECT-IDENTIFIER
#REPETITION	(простейший)	repetition
#SEQUENCE	#CONCATENATION
#SEQUENCE-OF	#REPETITION
#SET		#CONCATENATION
#SET-OF	#REPETITION
#TAG	(простейший)	tag
#TIME	(простейший)	time
#DATE	#TIME
#TIME-OF-DAY	#TIME
#DATE-TIME	#TIME
#DURATION	#TIME
#TRANSFORM	(простейший)	encoding procedure
#GeneralizedTime	#CHARS
#UTCTime	#CHARS
#ObjectDescriptor	#CHARS
#BMPString	#CHARS
#GeneralString	#CHARS
#GraphicString	#CHARS
#IA5String	#CHARS
#NumericString	#CHARS
#PrintableString	#CHARS
#TeletexString	#CHARS
#UniversalString	#CHARS
#UTF8String	#CHARS
#VideotexString	#CHARS
#VisibleString	#CHARS

EncodingStructure ::= TaggedStructure | UntaggedStructure TaggedStructure ::= "[" TagClass TagValue ? "]" UntaggedStructure UntaggedStructure ::= DefinedEncodingClass | EncodingStructureField | EncodingStructureDefn TagClass ::= DefinedEncodingClass | TagClassReference TagValue ::= "("number")"

EncodingStructureField ::= #NUL | #BOOL
| #INT	Bounds?
| #BITS	Size?
| #OCTETS	Size?
| #CHARS	Size?
| #PAD
| #BIT-STRING	Size?
| #BOOLEAN | #CHARACTER-STRING | #EMBEDDED-PDV
| #ENUMERATED	Bounds?
| #EXTERNAL
| #INTEGER	Bounds?
| #NULL | #OBJECT-IDENTIFIER
| #OCTET-STRING	Size?
| #OPEN-TYPE | #REAL | #RELATIVE-OID | #TIME | #DATE | #TIME-OF-DAY | #DATE-TIME | #DURATION | #GeneralizedTime | #UTCTime
| #ObjectDescriptor	Size?
| #BMPString	Size?
| #GeneralString	Size?
| #GraphicString	Size?
| #IA5String	Size?
| #NumericString	Size?
| #PrintableString	Size?
| #TeletexString	Size?
| #UniversalString	Size?
| #UTF8String	Size?
| #VideotexString	Size?
| #VisibleString	Size?

#NUL	Значение НУЛЬ
#BOOL	Булевы значения
#INT	Целочисленные значения
#BITS	Значения цепочки битов
#OCTETS	Значения цепочки октетов
#CHARS	Значения цепочки знаков
#PAD	НЕТ
#OBJECT-IDENTIFIER	Значения идентификатора объекта
#OPEN-TYPE	Значения открытого типа
#REAL	Значения действительного числа
#TIME	Значения времени
#TAG	Номера тегов

Bounds ::= "(" EffectiveRange ")" EffectiveRange ::= MinMax | Fixed Size ::= "(" SIZE SizeEffectiveRange ")" SizeEffectiveRange ::= "(" EffectiveRange ")" MinMax ::= ValueOrMin ".." ValueOrMax ValueOrMin ::= SignedNumber | MIN ValueOrMax ::= SignedNumber | MAX Fixed ::= SignedNumber

EncodingStructureDefn ::= AlternativesStructure | RepetitionStructure | ConcatenationStructure

AlternativesStructure 16.3; RepetitionStructure 16.4; ConcatenationStructure 16.5.

AlternativesStructure ::= AlternativesClass "{" NamedFields "}" AlternativesClass ::= DefinedEncodingClass | AlternativesClassReference NamedFields ::= NamedField "," + NamedField ::= identifier EncodingStructure

RepetitionStructure ::= RepetitionClass "{" identifier ? EncodingStructure "}" Size? RepetitionClass ::= DefinedEncodingClass | RepetitionClassReference

ConcatenationStructure ::= ConcatenationClass "{" ConcatComponents "}" ConcatenationClass ::= DefinedEncodingClass | ConcatenationClassReference ConcatComponents ::= ConcatComponent "," * ConcatComponent ::= NamedField ConcatComponentPresence ? ConcatComponentPresence ::= OPTIONAL-ENCODING OptionalClass OptionalClass ::= DefinedEncodingClass | OptionalityClassReference

EncodingObjectAssignment ::= encodingobjectreference DefinedOrBuiltinEncodingClass "::=" EncodingObject

EncodingObject ::= DefinedEncodingObject | DefinedSyntax | EncodeWith | EncodeByValueMapping | EncodeStructure | DifferentialEncodeDecodeObject | EncodingOptionsEncodingObject | NonECNEncodingObject

DefinedSyntax	17.2 с разделами 20 - 25
EncodeWith	17.3
EncodeByValueMapping	17.4
EncodeStructure	17.5
DifferentialEncodeDecodeObject	17.6
EncodingOptionsEncodingObject	17.7
NonECNEncodingObject	17.8

категория "вырожденная" категория "булева" категория "целочисленная" категория "цепочка битов" категория "цепочка октетов" категория "цепочка знаков" категория "pad" категория "альтернативы" категория "повторение" категория "конкатенация" категория "факультативные возможности" класс #CONDITIONAL-INT класс #CONDITIONAL-REPETITION категория "тег" класс #TRANSFORM класс #OUTER

EncodeWith ::= "{" ENCODE CombinedEncodings "}"

EncodeByValueMapping ::= "{" USE DefinedOrBuiltinEncodingClass MAPPING ValueMapping WITH ValueMappingEncodingObjects "}" ValueMappingEncodingObjects ::= EncodingObject | DefinedOrBuiltinEncodingObjectSet

EncodeStructure ::= "{" ENCODE STRUCTURE "{" ComponentEncodingList StructureEncoding ? "}" CombinedEncodings ? "}" StructureEncoding ::= STRUCTURED WITH TagEncoding ? EncodingOrUseSet TagEncoding ::= "[" EncodingOrUseSet "]" EncodingOrUseSet ::= EncodingObject | USE-SET

ComponentEncodingList ::= ComponentEncoding "," * ComponentEncoding ::= NonOptionalComponentEncodingSpec | OptionalComponentEncodingSpec

NonOptionalComponentEncodingSpec ::= identifier ? TagAndElementEncoding OptionalComponentEncodingSpec ::= identifier TagAndElementEncoding OPTIONAL-ENCODING OptionalEncoding TagAndElementEncoding ::= TagEncoding ? EncodingOrUseSet OptionalEncoding ::= EncodingOrUseSet

DifferentialEncodeDecodeObject ::= "{" ENCODE-DECODE SpecForEncoding DECODE AS IF SpecForDecoders "}" SpecForEncoding ::= EncodingObject SpecForDecoders ::= EncodingObject

EncodingOptionsEncodingObject ::= "{" OPTIONS EncodingOptionsList WITH AlternativesEncodingObject "}" EncodingOptionsList ::= OrderedEncodingObjectList AlternativesEncodingObject ::= EncodingObject

NonECNEncodingObject::= NON-ECN-BEGIN AssignedIdentifier anystringexceptnonecnend NON-ECN-END

EncodingObjectSetAssignment ::= encodingobjectsetreference #ENCODINGS "::=" EncodingObjectSet CompletionClause ? EncodingObjectSet ::= DefinedOrBuiltinEncodingObjectSet | EncodingObjectSetSpec

EncodingObjectSetSpec ::= "{" EncodingObjects UnionMark * "}" EncodingObjects ::= DefinedEncodingObject | DefinedEncodingObjectSet UnionMark ::= "|" | UNION

BuiltinEncodingObjectSetReference ::= PER-BASIC-ALIGNED | PER-BASIC-UNALIGNED | PER-CANONICAL-ALIGNED | PER-CANONICAL-UNALIGNED | BER | CER | DER

Имя	Идентификатор
PER-BASIC-ALIGNED	{joint-iso-itu-t(2) asn1(1) packed-encoding(3) basic(0) aligned(0)}
PER-BASIC-UNALIGNED	{joint-iso-itu-t(2) asn1(1) packed-encoding(3) basic(0) unaligned(1)}
PER-CANONICAL-ALIGNED	{joint-iso-itu-t(2) asn1(1) packed-encoding(3) canonical(1) aligned(0)}
PER-CANONICAL-UNALIGNED	{joint-iso-itu-t(2) packed-encoding(3) canonical(1) unaligned(1)}
BER	{joint-iso-itu-t(2) asn1(1) basic-encoding(1)}
CER	{joint-iso-itu-t(2) asn1(1) ber-derived(2) canonical-encoding(0)}
DER	{joint-iso-itu-t(2) asn1(1) ber-derived(2) distinguished-encoding(1)}

ИС NORMPROD: примечание. В официальном тексте документа, видимо, допущена опечатка: имеется в виду перечисление d) 13.2.9 и 13.2.10.5, а не перечисление d) 13.2.10.5 и 13.2.9 соответственно.

ValueMapping ::= MappingByExplicitValues | MappingByMatchingFields | MappingByTransformEncodingObjects | MappingByAbstractValueOrdering | MappingByValueDistribution | MappingIntToBits

MappingByExplicitValues	19.2;
MappingByMatchingFields	19.3;
MappingByTransformEncodingObjects	19.4;
MappingByAbstractValueOrdering	19.5;
MappingByValueDistribution	19.6;
MappingIntToBits	19.7.

Категория управляющего класса кодирования	Нотация значения АСН.1
bitstring	"bstring" или "hstring" (ИСО/МЭК 8824-1, подразделы 12.10 и 12.12)
boolean	"BooleanValue" (ИСО/МЭК 8824-1, пункт 18.3)
characterstring	"RestrictedCharacterStringValue" (ИСО/МЭК 8824-1, пункт 41.8)
enteger	"SignedNumber" (ИСО/МЭК 8824-1, пункт 19.1)
null	"NullValue" (см. ИСО/МЭК 8824-1, пункт 24.3)
objectidentifier	"DefinitiveIdentifier" (см. A.1)
octetstring	"bstring" или "hstring" (см. ИСО/МЭК 8824-1, подразделы 12.10 и 12.12)
real	"RealValue" (см. ИСО/МЭК 8824-1, пункт 21.6)
time	"TimeValue" (см. ИСО/МЭК 8824-1, подпункт 38.3.2)

MappingByExplicitValues ::= VALUES "{" MappedValues "," + "}" MappedValues ::= MappedValue1 TO MappedValue2 MappedValue1 ::= Value MappedValue2 ::= Value

MappingByMatchingFields ::= FIELDS

MappingByTransformEncodingObjects ::= TRANSFORMS "{" OrderedTransformList "}" OrderedTransformList ::= Transform "," + Transform ::= EncodingObject

MappingByAbstractValueOrdering ::= ORDERED VALUES

MappingByValueDistribution ::= DISTRIBUTION "{" Distribution "," + "}" Distribution ::= SelectedValues TO identifier SelectedValues ::= SelectedValue | DistributionRange | REMAINDER DistributionRange ::= DistributionRangeValue1 ".." DistributionRangeValue2 SelectedValue ::= SignedNumber DistributionRangeValue1 ::= SignedNumber DistributionRangeValue2 ::= SignedNumber

MappingIntToBits ::= TO BITS "{" MappedIntToBits "," + "}" MappedIntToBits ::= SingleIntValMap | IntValRangeMap

SingleIntValMap ::= IntValue TO BitValue IntValue ::= SignedNumber BitValue ::= bstring | hstring

IntValRangeMap ::= IntRange TO BitRange IntRange ::= IntRangeValue1 ".." IntRangeValue2 BitRange ::= BitRangeValue1 ".." BitRangeValue2 IntRangeValue1 ::= SignedNumber IntRangeValue2 ::= SignedNumber BitRangeValue1 ::= bstring | hstring BitRangeValue2 ::= bstring | hstring

Unit ::= INTEGER {repetitions (0), bit (1), nibble (4), octet (8), word 16 (16), dword32 (32)} (0..256)

EncodingSpaceSize ::= INTEGER { encoder-option-with-determinant (-3), variable-with-determinant (-2), self-delimiting-values (-1), fixed-to-max (0)} (-3..MAX)

ИС NORMPROD: примечание. В официальном тексте документа, видимо, допущена опечатка: п. 23.13.2.5 отсутствует.

EncodingSpaceDetermination ::= ENUMERATED {field-to-be-set, field-to-be-used, container}

UnusedBitsDetermination ::= ENUMERATED {field-to-be-set, field-to-be-used, not-needed}

OptionalityDetermination ::= ENUMERATED {field-to-be-set, field-to-be-used, container, handle, pointer}

AlternativeDetermination ::= ENUMERATED {field-to-be-set, field-to-be-used, handle}

RepetitionSpaceDetermination ::= ENUMERATED {field-to-be-set, field-to-be-used, flag-to-be-set, flag-to-be-used, container, pattern, handle, not-needed}

Justification ::= CHOICE { left INTEGER (0..MAX), right INTEGER (0..MAX)}

Pattern ::= CHOICE {bits BIT STRING, octets OCTET STRING, char8 IA5String, char16 BMPString, char32 UniversalString, any-of-length INTEGER (1..MAX), different ENUMERATED {any} }

Non-Null-Pattern ::= Pattern (ALL EXCEPT (bits:"B | octets:"H | char8:'''' | char16:'''' | char32:''''))

RangeCondition ::= ENUMERATED { unbounded-or-no-lower-bound, semi-bounded-with-negatives, bounded-with-negatives, semi-bounded-without-negatives, bounded-without-negatives test-lower-bound, test-upper-bound, test-range}

Comparison ::= ENUMERATED {equal-to, not-equal-to, greater-than, less-than, greater-than-or-equal-to, less-than-or-equal-to}

SizeRangeCondition ::= ENUMERATED { no-ub-with-zero-lb, ub-with-zero-lb, no-ub-with-non-zero-lb, ub-with-non-zero-lb, fixed-size test-lower-bound, test-upper-bound, test-range}

ReversalSpecification ::= ENUMERATED {no-reversal, reverse-bits-in-units, reverse-half-units, reverse-bits-in-half-units}

ResultSize ::= INTEGER {variable(-1), fixed-to-max(0)} (-1..MAX)

HandleValue ::= CHOICE { bits BIT STRING, octets OCTET STRING, number INTEGER (0..MAX), tag ENUMERATED {any}, range SEQUENCE { low INTEGER(0..MAX), high INTEGER(0..MAX) }, ranges SET (SIZE(1..MAX)) OF SEQUENCE { low INTEGER(0..MAX), high INTEGER(0..MAX) }}

IntegerMapping ::= SET OF SEQUENCE { source SET OF INTEGER, result INTEGER} (CONSTRAINED BY {/* the intersection of the source components shall be empty */})

&#Replacement-structure		OPTIONAL,
&#Replacement-structure2		OPTIONAL,
&replacement-structure-encoding-object &#Replacement-structure			OPTIONAL,
&replacement-structure-encoding-object2 &#Replacement-structure2			OPTIONAL,
&#Head-end-structure	OPTIONAL,
&#Head-end-structure2	OPTIONAL

[REPLACE [STRUCTURE] [COMPONENT] [ALL COMPONENTS] [OPTIONALS] [NON-OPTIONALS] WITH &#Replacement-structure [ENCODED BY &replacement-structure-encoding-object [INSERT AT HEAD &#Head-end-structure]] [AND OPTIONALS WITH &#Replacement-structure2 [ENCODED BY &replacement-structure-encoding-object2 [INSERT AT HEAD &#Head-end-structure2]]] ]

&#Replacement-structure OPTIONAL, &replacement-structure-encoding-object &#Replacement-structure OPTIONAL,
&#Head-end-structure	OPTIONAL

[REPLACE [STRUCTURE] [COMPONENT] [ALL COMPONENTS] WITH &Replacement-structure [ENCODED BY &replacement-structure-encoding-object [INSERT AT HEAD &#Head-end-structure]]]

&#Replacement-structure OPTIONAL, &replacement-structure-encoding-object &#Replacement-structure OPTIONAL

[REPLACE [STRUCTURE] WITH &#Replacement-structure [ENCODED BY &replacement-structure-encoding-object]]

&encoding-space-pre-alignment-unit	Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding	Padding DEFAULT zero,
&encoding-space-pre-pattern	Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B

[ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]]

Unit ::= INTEGER {repetitions(0), bit(1), nibble(4), octet(8), word16(16), dword32(32)} (0..256) -- (см. 21.1) Padding ::= ENUMERATED {zero, one, pattern, encoder-option} -- (см. 21.9) Pattern ::= CHOICE
{bits	BIT STRING,
octets	OCTET STRING,
char8	IA5String,
char16	BMPString,
char32	UniversalString,
any-of-length	INTEGER (1..MAX),
different	ENUMERATED {any} }
Non-Null-Pattern ::= Pattern (ALL EXCEPT (bits:"B | octets:"H | char8:'''' | char16:'''' | char32:'''')) -- (см. 21.10)

&start-pointer	REFERENCE OPTIONAL,
&start-pointer-unit	Unit (ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms	#TRANSFORM ORDERED OPTIONAL

[START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS&Start-pointer-encoder-transforms]]

Unit ::= INTEGER {repetitions(0), bit(1), nibble(4), octet(8), word16(16), dword32(32)} (0..256) - (см. 21.1)

&encoding-space-size	EncodingSpaceSize DEFAULT self-delimiting-values,
&encoding-space-unit	Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-determination	EncodingSpaceDetermination DEFAULT field-to-be-set,
&encoding-space-reference	REFERENCE OPTIONAL,
&Encoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms	#TRANSFORM ORDERED OPTIONAL

ENCODING-SPACE [SIZE &encoding-space-size [MULTIPLE OF &encoding-space-unit]] [DETERMINED BY &encoding-space-determination] [USING &encoding-space-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]]

EncodingSpaceSize ::= INTEGER { encoder-option-with-determinant(-3), variable-with-determinant(-2), self-delimiting-values(-1), fixed-to-max(0)} (-3..MAX) -- (см. 21.2) Unit ::= INTEGER {repetitions(0), bit(1), nibble(4), octet(8), word16(16), dword32(32)} (0..256) -- (см. 21.1) EncodingSpaceDetermination ::= ENUMERATED {field-to-be-set, field-to-be-used, container} -- (см. 21.3)

&optionality-determination	OptionalityDetermination DEFAULT field-to-be-set,
&optionality-reference	REFERENCE OPTIONAL,
&Encoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&handle-id	PrintableString DEFAULT "default-handle"

PRESENCE [DETERMINED BY &optionality-determination [HANDLE &handle-id]] [USING &optionality-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]]

OptionalityDetermination ::= ENUMERATED {field-to-be-set, field-to-be-used, container, handle, pointer} -- (см. 21.5)

&alternative-determination	AlternativeDetermination DEFAULT field-to-be-set,
&alternative-reference	REFERENCE OPTIONAL,
&Encoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&handle-id	PrintableString DEFAULT "default-handle",
&alternative-ordering	ENUMERATED {textual, tag} DEFAULT textual

ALTERNATIVE [DETERMINED BY &alternative-determination [HANDLE &handle-id]] [USING &alternative-reference [ORDER &alternative-ordering] [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]]

AlternativeDetermination ::= ENUMERATED {field-to-be-set, field-to-be-used, handle} -- (см. 21.6)

&repetition-space-size	EncodingSpaceSize DEFAULT self-delimiting-values,
&repetition-space-unit Unit	DEFAULT bit,
&repetition-space-determination	RepetitionSpaceDetermination DEFAULT field-to-be-set,
&main-reference	REFERENCE OPTIONAL,
&Encoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&handle-id PrintableString	DEFAULT "default-handle",
&termination-pattern different:any)	Non-Null-Pattern (ALL EXCEPT DEFAULT bits '0'B

REPETITION-SPACE [SIZE &repetition-space-size [MULTIPLE OF &repetition-space-unit]] [DETERMINED BY &repetition-space-determination [HANDLE &handle-id]] [USING &main-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]] [PATTERN &termination-pattern]

EncodingSpaceSize ::= INTEGER {encoder-option-with-determinant(-3), variable-with-determinant(-2), self-delimiting-values(-1), fixed-to-max(0)} (-3..MAX) -- (см. 21.2) Unit ::= INTEGER { repetitions(0), bit(1), nibble(4), octet(8), word16(16), dword32(32)} (0..256) -- (см. 21.1) RepetitionSpaceDetermination ::= ENUMERATED { field-to-be-set, field-to-be-used, flag-to-be-set, flag-to-be-used, container, pattern, handle, not-needed} -- (см. 21.7) Non-Null-Pattern ::= Pattern (ALL EXCEPT (bits:"B | octets:"H | char8:'''' | char16:'''' | char32:'''')) -- (см. 21.10.2)

&value-justification	Justification DEFAULT right:0,
&value-pre-padding	Padding DEFAULT zero,
&value-pre-pattern	Non-Null-Pattern DEFAULT bits:'0'B,
&value-post-padding	Padding DEFAULT zero,
&value-post-pattern	Non-Null-Pattern DEFAULT bits:'0'B,
&unused-bits-determination	UnusedBitsDetermination DEFAULT field-to-be-set,
&unused-bits-reference	REFERENCE OPTIONAL,
&Unused-bits-encoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&Unused-bits-decoder-transforms	#TRANSFORM ORDERED OPTIONAL

[VALUE-PADDING [JUSTIFIED &value-justification] [PRE-PADDING &value-pre-padding [PATTERN &value-pre-pattern]] [POST-PADDING &value-post-padding [PATTERN &value-post-pattern]] [UNUSED BITS [DETERMINED BY &unused-bits-determination] [USING &unused-bits-reference [ENCODER-TRANSFORMS &Unused-bits-encoder-transforms] [DECODER-TRANSFORMS &Unused-bits-decoder-transforms]]]]

Justification ::= CHOICE
{ left	INTEGER (0..MAX),
right	INTEGER (0..MAX)} -- (см. 21.8)
Padding ::= ENUMERATED {zero, one, pattern, encoder-option} -- (см. 21.9) Pattern ::= CHOICE
{bits	BIT STRING,
octets	OCTET STRING,
char8	IA5String,
char16	BMPString,
char32	UniversalString,
any-of-length	INTEGER (1..MAX),
different	ENUMERATED {any} }
Non-Null-Pattern ::= Pattern (ALL EXCEPT (bits:"B | octets:"H | char8:'''' | char16:'''' | char32:'''')) -- (см. 21.10)
UnusedBitsDetermination ::= ENUMERATED {field-to-be-set, field-to-be-used, not-needed} -- (см. 21.4)

&exhibited-handle PrintableString	DEFAULT "default-handle",
&Handle-positions	INTEGER (0..MAX) OPTIONAL,
&handle-value-set	HandleValueSet DEFAULT tag:any

[EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value-set]]

HandleValue ::= CHOICE {
bits	BIT STRING,
octets	OCTET STRING,
number	INTEGER (0..MAX),
tag	ENUMERATED {any}}
range SEQUENCE { low INTEGER(0..MAX), high INTEGER(0..MAX) }, ranges SET (SIZE(1..MAX)) OF SEQUENCE { low INTEGER(0..MAX), high INTEGER(0..MAX) }} -- (см. 21.16)

&concatenation-order	ENUMERATED {textual, tag, random} DEFAULT textual,
&concatenation-alignment	ENUMERATED {none, aligned} DEFAULT aligned,
&concatenation-handle	PrintableString DEFAULT "default-handle"

[CONCATENATION [ORDER &concatenation-order] [ALIGNMENT &concatenation-alignment] [HANDLE &concatenation-handle]]

&Primary-encoding-object-set	#ENCODINGS OPTIONAL,
&Secondary-encoding-object-set	#ENCODINGS OPTIONAL,
&over-ride-encoded-by	BOOLEAN DEFAULT FALSE

[CONTENTS-ENCODING &Primary-encoding-object-set [COMPLETED BY &Secondary-encoding-object-set] [OVERRIDE &over-ride-encoded-by]]

&bit-revers ReversalSpecification DEFAULT no-reversal

[BIT-REVERSAL &bit-reversal]

ReversalSpecification ::= ENUMERATED {no-reversal, reverse-bits-in-units, reverse-half-units, reverse-bits-in-half-units} -- (см. 21.14)

#ALTERNATIVES ::= ENCODING-CLASS { -- Спецификация замены структуры или компонента (см. 22.1)
&#Replacement-structure		OPTIONAL,
&replacement-structure-encoding-object &#Replacement-structure OPTIONAL, -- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit	Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding	Padding DEFAULT zero,
&encoding-space-pre-pattern	Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer	REFERENCE OPTIONAL,
&start-pointer-unit Unit	(ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms	#TRANSFORM ORDERED OPTIONAL,
-- Определение альтернативы (см. 22.6)
&alternative-determination	AlternativeDetermination DEFAULT field-to-be-set,
&alternative-reference	REFERENCE OPTIONAL,
&Encoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&handle-id PrintableString
	DEFAULT "default-handle",
&alternative-ordering	ENUMERATED {textual, tag} DEFAULT textual,
-- Спецификация идентификационного описателя (см. 22.9)
&exhibited-handle	PrintableString DEFAULT "default-handle",
&Handle-positions	INTEGER (0..MAX) OPTIONAL,
&handle-value-set	HandleValueSet DEFAULT tag:any
} WITH SYNTAX { [REPLACE [STRUCTURE] WITH &#Replacement-structure [ENCODED BY &replacement-structure-encoding-object]] [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] ALTERNATIVE [DETERMINED BY &alternative-determination [HANDLE &handle-id]] [USING &alternative-reference [ORDER &alternative-ordering] [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] }

#BITS ::= ENCODING-CLASS { -- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit	Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding	Padding DEFAULT zero,
&encoding-space-pre-pattern	Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer	REFERENCE OPTIONAL,
&start-pointer-unit Unit	(ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms	#TRANSFORM ORDERED OPTIONAL,
-- кодирование значения битов
&value-reversal	BOOLEAN DEFAULT FALSE,
&Transforms	#TRANSFORM ORDERED OPTIONAL,
&Bits-repetition-encodings	#CONDITIONAL-REPETITION ORDERED OPTIONAL,
&bits-repetition-encoding	#CONDITIONAL-REPETITION OPTIONAL,
-- Спецификация идентификационного описателя (см. 22.9)
&exhibited-handle	PrintableString DEFAULT "default-handle",
&Handle-positions	INTEGER (0..MAX) OPTIONAL,
&handle-value-set	HandleValueSet DEFAULT tag:any,
-- Спецификация кодирования вложенного типа (см. 22.11)
&Primary-encoding-object-set	#ENCODINGS OPTIONAL,
&Secondary-encoding-object-set	#ENCODINGS OPTIONAL,
&over-ride-encoded-by	BOOLEAN DEFAULT FALSE
} WITH SYNTAX { [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] [VALUE-REVERSAL &value-reversal] [TRANSFORMS &Transforms] [REPETITION-ENCODINGS &Bits-repetition-encodings] [REPETITION-ENCODING &bits-repetition-encoding] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] [CONTENTS-ENCODING &Primary-encoding-object-set [COMPLETED BY &Secondary-encoding-object-set] [OVERRIDE &over-ride-encoded-by]] }

#BOOL ::= ENCODING-CLASS { -- Спецификация замены исключительно структуры (см. 22.1) &#Replacement-structure OPTIONAL, &replacement-structure-encoding-object &#Replacement-structure OPTIONAL, -- Спецификация предварительного выравнивания и заполнения (см. 22.2) &encoding-space-pre-alignment-unit Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding		Padding DEFAULT zero,
&encoding-space-pre-pattern		Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer		REFERENCE OPTIONAL,
&start-pointer-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Спецификация пространства кодирования (см. 22.4)
&encoding-space-size		EncodingSpaceSize DEFAULT self-delimiting-values,
&encoding-space-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-determination		EncodingSpaceDetermination DEFAULT field-to-be-set,
&encoding-space-reference		REFERENCE OPTIONAL,
&Encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Кодирование
&value-true-pattern		Pattern DEFAULT bits:'1'B,
&value-false-pattern		Pattern DEFAULT bits:'0'B,
-- Заполнение и выравнивание значения (см. 22.8)
&value-justification		Justification DEFAULT right:0,
&value-pre-padding		Padding DEFAULT zero,
&value-pre-pattern		Non-Null-Pattern DEFAULT bits:'0'B,
&value-post-padding		Padding DEFAULT zero,
&value-post-pattern		Non-Null-Pattern DEFAULT bits:'0'B,
&unused-bits-determination		UnusedBitsDetermination DEFAULT field-to-be-set,
&unused-bits-reference		REFERENCE OPTIONAL,
&Unused-bits-encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
&Unused-bits-decoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Спецификация идентификационного описателя (см. 22.9)
&exhibited-handle		PrintableString DEFAULT "default-handle"
&Handle-positions		INTEGER (0..MAX) OPTIONAL,
&handle-value-set		HandleValueSet DEFAULT tag:any,
-- Спецификация реверсии битов (см. 22.12)
&bit-reversal	ReversalSpecification DEFAULT no-reversal
} WITH SYNTAX { [REPLACE [STRUCTURE] WITH &#Replacement-structure [ENCODED BY &replacement-structure-encoding-object]] [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] ENCODING-SPACE [SIZE &encoding-space-size [MULTIPLE OF &encoding-space-unit]] [DETERMINED BY &encoding-space-determination] [USING &encoding-space-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]] [TRUE-PATTERN &value-true-pattern] [FALSE-PATTERN &value-false-pattern] [VALUE-PADDING [JUSTIFIED &value-justification] [PRE-PADDING &value-pre-padding [PATTERN &value-pre-pattern]] [POST-PADDING &value-post-padding [PATTERN &value-post-pattern]] [UNUSED BITS [DETERMINED BY &unused-bits-determination] [USING &unused-bits-reference [ENCODER-TRANSFORMS &Unused-bits-encoder-transforms] [DECODER-TRANSFORMS &Unused-bits-decoder-transforms]]]] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] [BIT-REVERSAL &bit-reversal] }

#CHARS ::= ENCODING-CLASS { -- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit	Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding	Padding DEFAULT zero,
&encoding-space-pre-pattern	Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer	REFERENCE OPTIONAL,
&start-pointer-unit	Unit (ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms	#TRANSFORM ORDERED OPTIONAL,
-- Кодирование значений знаков
&value-reversal	BOOLEAN DEFAULT FALSE,
&Transforms	#TRANSFORM ORDERED OPTIONAL,
&Chars-repetition-encodings	#CONDITIONAL-REPETITION ORDERED OPTIONAL,
&chars-repetition-encoding	#CONDITIONAL-REPETITION OPTIONAL,
-- Спецификация идентификационного описателя (см. 22.9)
&exhibited-handle	PrintableString DEFAULT "default-handle",
&Handle-positions	INTEGER (0..MAX) OPTIONAL,
&handle-value-set	HandleValueSet DEFAULT tag:any
} WITH SYNTAX { [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] [VALUE-REVERSAL &value-reversal] [TRANSFORMS &Transforms] [REPETITION-ENCODINGS &Chars-repetition-encodings] [REPETITION-ENCODING &chars-repetition-encoding] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] }

#CONCATENATION ::= ENCODING-CLASS { -- Спецификация полной замены (см. 22.1) &#Replacement-structure OPTIONAL, &#Replacement-structure2 OPTIONAL,
&replacement-structure-encoding-object &#Replacement-structure				OPTIONAL,
&replacement-structure-encoding-object2 &#Replacement-structure2				OPTIONAL,
&#Head-end-structure			OPTIONAL,
&#Head-end-structure2			OPTIONAL,
-- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit			Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding			Padding DEFAULT zero,
&encoding-space-pre-pattern			Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer			REFERENCE OPTIONAL,
&start-pointer-unit			Unit (ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms			#TRANSFORM ORDERED OPTIONAL,
-- Спецификация пространства кодирования (см. 22.4)
&encoding-space-size			EncodingSpaceSize DEFAULT self-delimiting-values,
&encoding-space-unit			Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-determination			EncodingSpaceDetermination DEFAULT field-to-be-set,
&encoding-space-reference			REFERENCE OPTIONAL,
&Encoder-transforms			#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms			#TRANSFORM ORDERED OPTIONAL,
-- Спецификация конкатенации (см. 22.10)
&concatenation-order		ENUMERATED {textual, tag, random} DEFAULT textual,
&concatenation-alignment		ENUMERATED {none, aligned} DEFAULT aligned,
&concatenation-handle		PrintableString DEFAULT "default-handle",
-- Заполнение и выравнивание значения (см. 22.8)
&value-justification			Justification DEFAULT right:0,
--&value-pre-padding			Padding DEFAULT zero,
&value-pre-pattern			Non-Null-Pattern DEFAULT bits:'0'B,
&value-post-padding			Padding DEFAULT zero,
&value-post-pattern			Non-Null-Pattern DEFAULT bits:'0'B,
&unused-bits-determination			UnusedBitsDetermination DEFAULT field-to-be-set,
&unused-bits-reference			REFERENCE OPTIONAL,
&Unused-bits-encoder-transforms			#TRANSFORM ORDERED OPTIONAL,
&Unused-bits-decoder-transforms			#TRANSFORM ORDERED OPTIONAL,
-- Спецификация идентификационного описателя (см. 22.9)
&exhibited-handle	PrintableString DEFAULT "default-handle",
&Handle-positions	INTEGER (0..MAX) OPTIONAL,
&handle-value-set	HandleValueSet DEFAULT tag:any,
-- Спецификация реверсии битов (см. 22.12)
&bit-reversal	ReversalSpecification DEFAULT no-reversal
} WITH SYNTAX { [REPLACE [STRUCTURE] [COMPONENT] [ALL COMPONENTS] [OPTIONALS] [NON-OPTIONALS] WITH &#Replacement-structure [ENCODED BY &replacement-structure-encoding-object [INSERT AT HEAD &#Head-end-structure]] [AND OPTIONALS WITH &#Replacement-structure2 [ENCODED BY &replacement-structure-encoding-object2 [INSERT AT HEAD &#Head-end-structure2]]] ] [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] ENCODING-SPACE [SIZE &encoding-space-size [MULTIPLE OF &encoding-space-unit]] [DETERMINED BY &encoding-space-determination] [USING &encoding-space-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]] [CONCATENATION [ORDER &concatenation-order] [ALIGNMENT &concatenation-alignment] [HANDLE &concatenation-handle]]
[VALUE-PADDING [JUSTIFIED &value-justification] [PRE-PADDING &value-pre-padding [PATTERN &value-pre-pattern]] [POST-PADDING &value-post-padding [PATTERN &value-post-pattern]] [UNUSED BITS [DETERMINED BY &unused-bits-determination] [USING &unused-bits-reference [ENCODER-TRANSFORMS &Unused-bits-encoder-transforms] [DECODER-TRANSFORMS &Unused-bits-decoder-transforms]]]] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] [BIT-REVERSAL &bit-reversal] }

#INT ::= ENCODING-CLASS { -- Codage d'entier
&Integer-encodings	#CONDITIONAL-INT ORDERED OPTIONAL,
&integer-encoding	#CONDITIONAL-INT OPTIONAL
} WITH SYNTAX { [ENCODINGS &Integer-encodings] [ENCODING &integer-encoding] }

#CONDITIONAL-INT ::= ENCODING-CLASS {
-- Условие (см. 21.11)
&range-condition RangeCondition		OPTIONAL,
&comparison		Comparison OPTIONAL,
&comparator		INTEGER OPTIONAL,
&Range-conditions		RangeCondition ORDERED OPTIONAL,
&Comparisons		Comparison ORDERED OPTIONAL,
&Comparators		INTEGER ORDERED OPTIONAL,
-- Спецификация замены исключительно структуры (см. 22.1)
&#Replacement-structure OPTIONAL, &replacement-structure-encoding-object &#Replacement-structure OPTIONAL,
-- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit				Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding				Padding DEFAULT zero,
&encoding-space-pre-pattern				Non-Null-Pattern (ALLEXCEPTdifferent:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer				REFERENCE OPTIONAL,
&start-pointer-unit				Unit (ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms				#TRANSFORM ORDERED OPTIONAL,
-- Спецификация пространства кодирования (см. 22.4)
&encoding-space-size				EncodingSpaceSize DEFAULT self-delimiting-values,
&encoding-space-unit				Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-determination				EncodingSpaceDetermination DEFAULT field-to-be-set,
&encoding-space-reference				REFERENCE OPTIONAL,
&Encoder-transforms				#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms				#TRANSFORM ORDERED OPTIONAL,
-- Кодирование значения
&Transform			#TRANSFORM ORDERED OPTIONAL,
&encoding			ENUMERATED {positive-int, twos-complement, reverse-positive-int, reverse-twos-complement}
				DEFAULT twos-complement,
-- Заполнение и выравнивание значения (см. 22.8)
&value-justification				Justification DEFAULT right:0,
&value-pre-padding				Padding DEFAULT zero,
&value-pre-pattern				Non-Null-Pattern DEFAULT bits:'0'B,
&value-post-padding				Padding DEFAULT zero,
&value-post-pattern				Non-Null-Pattern DEFAULT bits:'0'B,
&unused-bits-determination				UnusedBitsDetermination DEFAULT field-to-be-set,
&unused-bits-reference				REFERENCE OPTIONAL,
&Unused-bits-encoder-transforms				#TRANSFORM ORDERED OPTIONAL,
&Unused-bits-decoder-transforms				#TRANSFORM ORDERED OPTIONAL,
-- Спецификация идентификационного описателя (см. 22.9)
&exhibited-handle				PrintableString DEFAULT "default-handle",
&Handle-positions				INTEGER (0..MAX) OPTIONAL,
&handle-value-set				HandleValueSet DEFAULT tag:any,
-- Спецификация реверсии битов (см. 22.12)
&bit-reversal	ReversalSpecification DEFAULT no-reversal
} WITH SYNTAX { [IF &range-condition [&comparison &comparator]] [IF-ALL &Range-conditions [&Comparisons &Comparators]] [ELSE] [REPLACE [STRUCTURE] WITH &#Replacement-structure [ENCODED BY &replacement-structure-encoding-object]] [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] ENCODING-SPACE [SIZE &encoding-space-size [MULTIPLE OF &encoding-space-unit]] [DETERMINED BY &encoding-space-determination] [USING &encoding-space-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]] [TRANSFORMS &Transforms] [ENCODING &encoding] [VALUE-PADDING [JUSTIFIED &value-justification] [PRE-PADDING &value-pre-padding [PATTERN &value-pre-pattern]] [POST-PADDING &value-post-padding [PATTERN &value-post-pattern]] [UNUSED BITS [DETERMINED BY &unused-bits-determination] [USING &unused-bits-reference [ENCODER-TRANSFORMS &Unused-bits-encoder-transforms] [DECODER-TRANSFORMS&Unused-bits-decoder-transforms]]]] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] [BIT-REVERSAL &bit-reversal] }

Пример IF-ALL {test-lower-bound, test-range, bounded-with-negatives } {greater-than , less-than-or-equal-to }
{-10	, 20	}

"ENCODING"	Минимальное значение	Максимальное значение
"positive-int"	0	2n - 1
"reverse-positive-int"	0	2n - 1
"twos-complement"	-2n - 1	-2n - 1 - 1
"reverse-twos-complement"	-2n - 1	-2n - 1 - 1

#NUL ::= ENCODING-CLASS { -- Спецификация замены исключительно структуры (см. 22.1) &#Replacement-structure OPTIONAL, &replacement-structure-encoding-object &#Replacement-structure OPTIONAL, -- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding		Padding DEFAULT zero,
&encoding-space-pre-pattern		Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer		REFERENCE OPTIONAL,
&start-pointer-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Спецификация пространства кодирования (см. 22.4)
&encoding-space-size		EncodingSpaceSize DEFAULT self-delimiting-values,
&encoding-space-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-determination		EncodingSpaceDetermination DEFAULT field-to-be-set,
&encoding-space-reference		REFERENCE OPTIONAL,
&Encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Структура значения
&value-pattern	Pattern (ALL EXCEPT different:any) DEFAULT bits:"B,
-- Заполнение и выравнивание значения (см. 22.8)
&value-justification		Justification DEFAULT right:0,
&value-pre-padding		Padding DEFAULT zero,
&value-pre-pattern		Non-Null-Pattern DEFAULT bits:'0'B,
&value-post-padding		Padding DEFAULT zero,
&value-post-pattern		Non-Null-Pattern DEFAULT bits:'0'B,
&unused-bits-determination		UnusedBitsDetermination DEFAULT field-to-be-set,
&unused-bits-reference		REFERENCE OPTIONAL,
&Unused-bits-encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
&Unused-bits-decoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Спецификация идентификационного описателя (см. 22.9)
&exhibited-handle		PrintableString DEFAULT "default-handle",
&Handle-positions		INTEGER (0..MAX) OPTIONAL,
&handle-value-set		HandleValueSet DEFAULT tag:any,
-- Спецификация реверсии битов (см. 22.12)
&bit-reversal	ReversalSpecification DEFAULT no-reversal
} WITH SYNTAX { [REPLACE [STRUCTURE] WITH &#Replacement-structure [ENCODED BY &replacement-structure-encoding-object]] [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] ENCODING-SPACE [SIZE &encoding-space-size [MULTIPLE OF &encoding-space-unit]] [DETERMINED BY &encoding-space-determination] [USING &encoding-space-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]] [NULL-PATTERN &value-pattern] [VALUE-PADDING [JUSTIFIED &value-justification] [PRE-PADDING &value-pre-padding [PATTERN &value-pre-pattern]] [POST-PADDING &value-post-padding [PATTERN &value-post-pattern]] [UNUSED BITS [DETERMINED BY &unused-bits-determination] [USING &unused-bits-reference [ENCODER-TRANSFORMS &Unused-bits-encoder-transforms] [DECODER-TRANSFORMS &Unused-bits-decoder-transforms]]]] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] [BIT-REVERSAL &bit-reversal] }

#OCTETS ::= ENCODING-CLASS { -- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding		Padding DEFAULT zero,
&encoding-space-pre-pattern		Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer	REFERENCE OPTIONAL,
&start-pointer-unit	Unit (ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms	#TRANSFORM ORDERED OPTIONAL,
-- Кодирование значений октетов
&value-reversal	BOOLEAN DEFAULT FALSE,
&Transforms	#TRANSFORM ORDERED OPTIONAL,
&Octets-repetition-encodings	#CONDITIONAL-REPETITION ORDERED OPTIONAL,
&octets-repetition-encoding	#CONDITIONAL-REPETITION OPTIONAL,
-- Спецификация идентификационного описателя (см. 22.9)
&exhibited-handle	PrintableString DEFAULT "default-handle",
&Handle-positions	INTEGER (0..MAX) OPTIONAL,
&handle-value-set	HandleValueSet DEFAULT tag:any,
-- Спецификация кодирования вложенного типа (см. 22.11)
&Primary-encoding-object-set	#ENCODINGS OPTIONAL,
&Secondary-encoding-object-set	#ENCODINGS OPTIONAL,
&over-ride-encoded-by	BOOLEAN DEFAULT FALSE
} WITH SYNTAX { [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] [VALUE-REVERSAL &value-reversal] [TRANSFORMS &Transforms] [REPETITION-ENCODINGS &Octets-repetition-encodings] [REPETITION-ENCODING &octets-repetition-encoding] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] [CONTENTS-ENCODING &Primary-encoding-object-set [COMPLETED BY &Secondary-encoding-object-set] [OVERRIDE &over-ride-encoded-by]] }

#OPEN-TYPE ::= ENCODING-CLASS { -- Спецификация замены исключительно структуры (см. 22.1)
&#Replacement-structure				OPTIONAL,
&replacement-structure-encoding-object &#Replacement-structure				OPTIONAL,
-- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit			Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding			Padding DEFAULT zero,
&encoding-space-pre-pattern			Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer		REFERENCE OPTIONAL,
&start-pointer-unit Unit		(ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Спецификация пространства кодирования (см. 22.4)
&encoding-space-size		EncodingSpaceSize DEFAULT self-delimiting-values,
&encoding-space-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-determination		EncodingSpaceDetermination DEFAULT field-to-be-set,
&encoding-space-reference		REFERENCE OPTIONAL,
&Encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Кодирование открытого типа
&Known-structure-encodings			#ENCODINGS OPTIONAL,
&Unknown-structure			OPTIONAL,
&Unknown-structure-encodings			#ENCODINGS OPTIONAL,
-- Заполнение и выравнивание значения (см. 22.8)
&value-justification		Justification DEFAULT right:0,
&value-pre-padding		Padding DEFAULT zero,
&value-pre-pattern		Non-Null-Pattern DEFAULT bits:'0'B,
&value-post-padding		Padding DEFAULT zero,
&value-post-pattern		Non-Null-Pattern DEFAULT bits:'0'B,
&unused-bits-determination		UnusedBitsDetermination DEFAULT field-to-be-set,
&unused-bits-reference		REFERENCE OPTIONAL,
&Unused-bits-encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
&Unused-bits-decoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Спецификация реверсии битов (см. 22.12)
&bit-reversal	ReversalSpecification DEFAULT no-reversal
} WITH SYNTAX { [REPLACE [STRUCTURE] WITH &#Replacement-structure [ENCODED BY &replacement-structure-encoding-object]] [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] ENCODING-SPACE [SIZE &encoding-space-size [MULTIPLE OF &encoding-space-unit]] [DETERMINED BY &encoding-space-determination] [USING &encoding-space-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]] [ENCODED WITH &Known-structure-encodings] [UNKNOWN IS &Unknown-structure [ENCODED WITH &Unknown-structure-encodings]] [VALUE-PADDING [JUSTIFIED &value-justification] [PRE-PADDING &value-pre-padding [PATTERN &value-pre-pattern]] [POST-PADDING &value-post-padding [PATTERN &value-post-pattern]] [UNUSED BITS [DETERMINED BY &unused-bits-determination] [USING &unused-bits-reference [ENCODER-TRANSFORMS &Unused-bits-encoder-transforms] [DECODER-TRANSFORMS &Unused-bits-decoder-transforms]]]] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] [BIT-REVERSAL &bit-reversal] }

#OPTIONAL ::= ENCODING-CLASS { -- Спецификация замены исключительно структуры (см. 22.1) &#Replacement-structure OPTIONAL, &replacement-structure-encoding-object &#Replacement-structure OPTIONAL, -- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding		Padding DEFAULT zero,
&encoding-space-pre-pattern		Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer		REFERENCE OPTIONAL,
&start-pointer-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Определение факультативных возможностей (см. 22.5)
&optionality-determination	OptionalityDetermination DEFAULT field-to-be-set,
&optionality-reference	REFERENCE OPTIONAL,
&Encoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms	#TRANSFORM ORDERED OPTIONAL,
&handle-id	PrintableString DEFAULT "default-handle"
} WITH SYNTAX { [REPLACE [STRUCTURE] WITH &#Replacement-structure [ENCODED BY &replacement-structure-encoding-object]] [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] PRESENCE [DETERMINED BY &optionality-determination [HANDLE &handle-id]] [USING &optionality-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]] }

#PAD ::= ENCODING-CLASS { -- Спецификация замены исключительно структуры (см. 22.1) &#Replacement-structure OPTIONAL, &replacement-structure-encoding-object &#Replacement-structure OPTIONAL, -- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding		Padding DEFAULT zero,
&encoding-space-pre-pattern		Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer		REFERENCE OPTIONAL,
&start-pointer-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Спецификация пространства кодирования (см. 22.4)
&encoding-space-size		EncodingSpaceSize DEFAULT self-delimiting-values,
&encoding-space-unit		Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-determination		EncodingSpaceDetermination DEFAULT field-to-be-set,
&encoding-space-reference		REFERENCE OPTIONAL,
&Encoder-transforms		#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms		#TRANSFORM ORDERED OPTIONAL,
-- Кодирование значения
&pad-pattern Pattern	(ALL EXCEPT different:any) DEFAULT bits:"B,
-- Спецификация идентификационного описателя (см. 22.9)
&exhibited-handle &Handle-positions &handle-value-set	PrintableString DEFAULT "default-handle", INTEGER (0..MAX) OPTIONAL, HandleValueSet DEFAULT tag:any,
-- Спецификация реверсии битов (см. 22.12)
&bit-reversal	ReversalSpecification DEFAULT no-reversal
} WITH SYNTAX { [REPLACE [STRUCTURE] WITH &#Replacement-structure [ENCODED BY &replacement-structure-encoding-object]] [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] ENCODING-SPACE [SIZE &encoding-space-size [MULTIPLE OF &encoding-space-unit]] [DETERMINED BY &encoding-space-determination] [USING &encoding-space-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]] [PAD-PATTERN &pad-pattern] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] [BIT-REVERSAL &bit-reversal] }

#REPETITION ::= ENCODING-CLASS { -- Кодирование повторения
&Repetition-encodings	#CONDITIONAL-REPETITION ORDERED OPTIONAL,
&repetition-encoding	#CONDITIONAL-REPETITION OPTIONAL
} WITH SYNTAX { [REPETITION-ENCODINGS &Repetition-encodings] [REPETITION-ENCODING &repetition-encoding] }

#CONDITIONAL-REPETITION ::= ENCODING-CLASS {
-- Условие (см. 21.12)
&size-range-condition			SizeRangeCondition OPTIONAL,
&comparison			Comparison OPTIONAL,
&comparator			INTEGER OPTIONAL,
&Size-range-conditions			SizeRangeCondition ORDERED OPTIONAL,
&Comparisons			Comparison ORDERED OPTIONAL,
&Comparators			INTEGER ORDERED OPTIONAL,
-- Спецификация замены структуры или компонента (см. 22.1)
&#Replacement-structure OPTIONAL, &replacement-structure-encoding-object&#Replacement-structure OPTIONAL,
&#Head-end-structure			OPTIONAL,
-- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit			Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding			Padding DEFAULT zero,
&encoding-space-pre-pattern			Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer			REFERENCE OPTIONAL,
&start-pointer-unit			Unit (ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms			#TRANSFORM ORDERED OPTIONAL,
-- Спецификация пространства повторения (см. 22.7)
&repetition-space-size			EncodingSpaceSize DEFAULT self-delimiting-values,
&repetition-space-unit			Unit DEFAULT bit,
&repetition-space-determination			RepetitionSpaceDetermination DEFAULT field-to-be-set,
&main-reference			REFERENCE OPTIONAL,
&Encoder-transforms			#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms			#TRANSFORM ORDERED OPTIONAL,
&handle-id			PrintableString DEFAULT "default-handle",
&termination-pattern			Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits '0'B,
-- Выравнивание повторения
&repetition-alignment		ENUMERATED {none, aligned} DEFAULT none,
-- Заполнение и выравнивание значения (см. 22.8)
&value-justification			Justification DEFAULT right:0,
&value-pre-padding			Padding DEFAULT zero,
&value-pre-pattern			Non-Null-Pattern DEFAULT bits:'0'B,
&value-post-padding			Padding DEFAULT zero,
&value-post-pattern			Non-Null-Pattern DEFAULT bits:'0'B,
&unused-bits-determination			UnusedBitsDetermination DEFAULT field-to-be-set,
&unused-bits-reference			REFERENCE OPTIONAL,
&Unused-bits-encoder-transforms			#TRANSFORM ORDERED OPTIONAL,
&Unused-bits-decoder-transforms			#TRANSFORM ORDERED OPTIONAL,
-- Спецификация идентификационного описателя (см. 22.9)
&exhibited-handle PrintableString			DEFAULT "default-handle",
&Handle-positions			INTEGER (0..MAX) OPTIONAL,
&handle-value-set			HandleValueSet DEFAULT tag:any,
-- Спецификация реверсии битов (см. 22.12)
&bit-reversal	ReversalSpecification DEFAULT no-reversal
} WITH SYNTAX { [IF &size-range-condition [&comparison &comparator]] [IF-ALL &Size-range-conditions [&Comparisons &Comparators]] [ELSE] [REPLACE [STRUCTURE] [COMPONENT] [ALL COMPONENTS] WITH &Replacement-structure [ENCODED BY &replacement-structure-encoding-object [INSERT AT HEAD &#Head-end-structure]]] [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] REPETITION-SPACE [SIZE &repetition-space-size [MULTIPLE OF &repetition-space-unit]] [DETERMINED BY &repetition-space-determination [HANDLE &handle-id]] [USING &main-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]] [PATTERN &termination-pattern] [ALIGNMENT &repetition-alignment] [VALUE-PADDING [JUSTIFIED &value-justification] [PRE-PADDING &value-pre-padding [PATTERN &value-pre-pattern]] [POST-PADDING &value-post-padding [PATTERN &value-post-pattern]] [UNUSED BITS
[DETERMINED BY &unused-bits-determination] [USING &unused-bits-reference [ENCODER-TRANSFORMS &Unused-bits-encoder-transforms] [DECODER-TRANSFORMS &Unused-bits-decoder-transforms]]]] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] [BIT-REVERSAL &bit-reversal] }

#TAG ::= ENCODING-CLASS { -- Спецификация замены исключительно структуры (см. 22.1) &#Replacement-structure OPTIONAL, &replacement-structure-encoding-object &#Replacement-structure OPTIONAL, -- Спецификация предварительного выравнивания и заполнения (см. 22.2)
&encoding-space-pre-alignment-unit			Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-pre-padding			Padding DEFAULT zero,
&encoding-space-pre-pattern			Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация начального указателя (см. 22.3)
&start-pointer			REFERENCE OPTIONAL,
&start-pointer-unit			Unit (ALL EXCEPT repetitions) DEFAULT bit,
&Start-pointer-encoder-transforms			#TRANSFORM ORDERED OPTIONAL,
-- Спецификация пространства кодирования (см. 22.4)
&encoding-space-size			EncodingSpaceSize DEFAULT self-delimiting-values,
&encoding-space-unit			Unit (ALL EXCEPT repetitions) DEFAULT bit,
&encoding-space-determination			EncodingSpaceDetermination DEFAULT field-to-be-set,
&encoding-space-reference			REFERENCE OPTIONAL,
&Encoder-transforms			#TRANSFORM ORDERED OPTIONAL,
&Decoder-transforms			#TRANSFORM ORDERED OPTIONAL,
-- Заполнение и выравнивание значения (см. 22.8)
&value-justification		Justification DEFAULT right:0,
&value-pre-padding		Padding DEFAULT zero,
&value-pre-pattern		Non-Null-Pattern DEFAULT bits:'0'B,
&value-post-padding		Padding DEFAULT zero,
&value-post-pattern		Non-Null-Pattern DEFAULT bits:'0'B,
&unused-bits-determination				UnusedBitsDetermination DEFAULT field-to-be-set,
&unused-bits-reference				REFERENCE OPTIONAL,
&Unused-bits-encoder-transforms				#TRANSFORM ORDERED OPTIONAL,
&Unused-bits-decoder-transforms				#TRANSFORM ORDERED OPTIONAL,
-- Спецификация идентификационного описателя (см. 22.9)
&exhibited-handle		PrintableString DEFAULT "default-handle",
&Handle-positions		INTEGER (0..MAX) OPTIONAL,
&handle-value-set		HandleValueSet DEFAULT tag:any,
-- Спецификация реверсии битов (см. 22.12)
&bit-reversal	ReversalSpecification DEFAULT no-reversal
} WITH SYNTAX { [REPLACE [STRUCTURE] WITH &#Replacement-structure [ENCODED BY &replacement-structure-encoding-object]] [ALIGNED TO [NEXT] [ANY] &encoding-space-pre-alignment-unit [PADDING &encoding-space-pre-padding [PATTERN &encoding-space-pre-pattern]]] [START-POINTER &start-pointer [MULTIPLE OF &start-pointer-unit] [ENCODER-TRANSFORMS &Start-pointer-encoder-transforms]] ENCODING-SPACE [SIZE &encoding-space-size [MULTIPLE OF &encoding-space-unit]] [DETERMINED BY &encoding-space-determination] [USING &encoding-space-reference [ENCODER-TRANSFORMS &Encoder-transforms] [DECODER-TRANSFORMS &Decoder-transforms]] [VALUE-PADDING [JUSTIFIED &value-justification] [PRE-PADDING &value-pre-padding [PATTERN &value-pre-pattern]] [POST-PADDING &value-post-padding [PATTERN &value-post-pattern]] [UNUSED BITS [DETERMINED BY &unused-bits-determination] [USING &unused-bits-reference [ENCODER-TRANSFORMS &Unused-bits-encoder-transforms] [DECODER-TRANSFORMS &Unused-bits-decoder-transforms]]]] [EXHIBITS HANDLE &exhibited-handle AT &Handle-positions [AS &handle-value]] [BIT-REVERSAL &bit-reversal] }

#TRANSFORM ::= ENCODING-CLASS { -- int-to-int (см. 24.3)
&int-to-int	CHOICE
	{increment			INTEGER (1..MAX),
	decrement			INTEGER (1..MAX),
	multiply			INTEGER (2..MAX),
	divide			INTEGER (2..MAX),
	negate			ENUMERATED{value},
	modulo			INTEGER (2..MAX),
	subtract			ENUMERATED{lower-bound}
	} OPTIONAL,
-- bool-to-bool (см. 24.4)
&bool-to-bool	CHOICE
	{logical			ENUMERATED{not}}
	DEFAULT logical:not,
-- bool-to-int (см. 24.5)
&bool-to-int			ENUMERATED {true-zero, true-one} DEFAULT true-one,
-- int-to-bool (см. 24.6)
&int-to-bool			ENUMERATED {zero-true, zero-false} DEFAULT zero-false,
&Int-to-bool-true-is			INTEGER OPTIONAL,
&Int-to-bool-false-is			INTEGER OPTIONAL,
-- int-to-chars (см. 24.7)
&int-to-chars-size		ResultSize DEFAULT variable,
&int-to-chars-plus		BOOLEAN DEFAULT FALSE,
&int-to-chars-pad		ENUMERATED
{spaces, zeros}		DEFAULT zeros,
-- int-to-bits (см. 24.8)
&int-to-bits-encoded-as		ENUMERATED {positive-int, twos-complement} DEFAULT twos-complement,
&int-to-bits-unit		Unit (1..MAX) DEFAULT bit,
&int-to-bits-size		ResultSize DEFAULT variable,
-- bits-to-int (см. 24.9)
&bits-to-int-decoded-assuming			ENUMERATED positive-int, twos-complement} DEFAULT twos-complement,
-- char-to-bits (см. 24.10)
&char-to-bits-encoded-as		ENUMERATED {iso10646, compact, mapped}
DEFAULT compact,
&Char-to-bits-chars		UniversalString (SIZE(1)) ORDERED OPTIONAL,
&Char-to-bits-values		BIT STRING ORDERED OPTIONAL,
&char-to-bits-unit		Unit (1..MAX) DEFAULT bit,
&char-to-bits-size		ResultSize DEFAULT variable,
-- bits-to-char (см. 24.11)
&bits-to-char-decoded-assuming			ENUMERATED {iso10646, mapped} DEFAULT iso10646,
&Bits-to-char-values			BIT STRING ORDERED OPTIONAL,
&Bits-to-char-chars			UniversalString (SIZE(1)) ORDERED OPTIONAL,
-- bit-to-bits (см. 24.12)
&bit-to-bits-one	Non-Null-Pattern DEFAULT bits:'1'B,
&bit-to-bits-zero	Non-Null-Pattern DEFAULT bits:'0'B,
-- bits-to-bits (см. 24.13)
&Source-values	BIT STRING ORDERED,
&Result-values	BIT STRING ORDERED,
-- chars-to-composite-char (см. 24.14) -- Признаки кодирования для этого преобразования отсутствуют. -- bits-to-composite-bits (см. 24.15)
&bits-to-composite-bits-unit			Unit (1..MAX) DEFAULT bit
-- octets-to-composite-bits (см. 24.16) -- Признаки кодирования для этого преобразования отсутствуют. -- composite-char-to-chars (см. 24.17) -- Признаки кодирования для этого преобразования отсутствуют. -- composite-bits-to-bits (см. 24.18) -- Признаки кодирования для этого преобразования отсутствуют. -- composite-bits-to-octets (см. 24.19) -- Признаки кодирования для этого преобразования отсутствуют. } WITH SYNTAX { -- Может использоваться только один из следующих классов. [INT-TO-INT &int-to-int] [BOOL-TO-BOOL [AS &bool-to-bool]] [BOOL-TO-INT AS &bool-to-int] [INT-TO-BOOL [AS &int-to-bool] [TRUE-IS &Int-to-bool-true-is] [FALSE-IS &Int-to-bool-false-is]] [INT-TO-CHARS [SIZE &int-to-chars-size] [PLUS-SIGN &int-to-chars-plus] [PADDING &int-to-chars-pad]] [INT-TO-BITS [AS &int-to-bits-encoded-as] [SIZE &int-to-bits-size] [MULTIPLE OF &int-to-bits-unit]] [BITS-TO-INT [AS &bits-to-int-decoded-assuming]] [CHAR-TO-BITS [AS &char-to-bits-encoded-as] [CHAR-LIST &Char-to-bits-chars] [BITS-LIST &Char-to-bits-values] [SIZE &char-to-bits-size] [MULTIPLE OF &char-to-bits-unit]]
[BITS-TO-CHAR [AS &bits-to-char-decoded-assuming] [BITS-LIST &Bits-to-char-values] [CHAR-LIST &Bits-to-char-chars]] [BIT-TO-BITS [ZERO-PATTERN &bit-to-bits-zero] [ONE-PATTERN &bit-to-bits-one]] [BITS-TO-BITS SOURCE-LIST &Source-values RESULT-LIST &Result-values] [CHARS-TO-COMPOSITE-CHAR] [BITS-TO-COMPOSITE-BITS [UNIT &bits-to-composite-bits-unit]] [OCTETS-TO-COMPOSITE-BITS] [COMPOSITE-CHAR-TO-CHARS] [COMPOSITE-BITS-TO-BITS] [COMPOSITE-BITS-TO-OCTETS] }

&int-to-int	CHOICE
increment		INTEGER (1..MAX),
decrement		INTEGER (1..MAX),
multiply		INTEGER (2..MAX),
divide		INTEGER (2..MAX),
negate		ENUMERATED{value},
modulo		INTEGER (2..MAX),
subtract		ENUMERATED{lower-bound}
mapping } OPTIONAL		IntegerMapping

[INT-TO-INT &int-to-int]

IntegerMapping ::= SET OF SEQUENCE { source SET OF INTEGER, result INTEGER} (CONSTRAINED BY {/* пересечение исходных компонентов должно быть пустым (см. 21.17) */})

Преобразователь	Условие
increment:n	Всегда обратим
decrement:n	Всегда обратим
multiply:n	Всегда обратим
divide:n	Значение кратно n
negate:value	Всегда обратим
modulo:n	Никогда не обратим
subtract:lower-bound	Всегда обратим
mapping:integerMapping	Исходные наборы значений, каждый из которых содержит только одно значение, и результирующие значения различны

&bool-to-bool	CHOICE
	{logical	ENUMERATED{not}}
	DEFAULT logical:not

[BOOL-TO-BOOL [AS &bool-to-bool]]

&bool-to-int

ENUMERATED {true-zero, true-one} DEFAULT true-one

&int-to-bool	ENUMERATED {zero-true, zero-false} DEFAULT zero-false,
&Int-to-bool-true-is	INTEGER OPTIONAL,
&Int-to-bool-false-is	INTEGER OPTIONAL

[INT-TO-BOOL [AS &int-to-bool] [TRUE-IS &Int-to-bool-true-is] [FALSE-IS &Int-to-bool-false-is]]

&int-to-chars-size	ResultSize DEFAULT variable,
&int-to-chars-plus	BOOLEAN DEFAULT FALSE,
&int-to-chars-pad	ENUMERATED {spaces, zeros} DEFAULT zeros

[INT-TO-CHARS [SIZE &int-to-chars-size] [PLUS-SIGN &int-to-chars-plus] [PADDING &int-to-chars-pad]]

&int-to-bits-encoded-as	ENUMERATED {positive-int, twos-complement} DEFAULT twos-complement,
&int-to-bits-unit	Unit (1..MAX) DEFAULT bit,
&int-to-bits-size	ResultSize DEFAULT variable

[INT-TO-BITS [AS &int-to-bits-encoded-as] [SIZE &int-to-bits-size] [MULTIPLE OF &int-to-bits-unit]]

Unit ::= INTEGER {repetitions(0), bit(1), nibble(4), octet(8), word16(16), dword32(32)} (0..256) - (см. 21.1) ResultSize ::= INTEGER {variable(-1), fixed-to-max(0)} (-1..MAX) -- (см. 21.15)

&bits-to-int-decoded-assuming

ENUMERATED {positive-int, twos-complement} DEFAULT twos-complement

[BITS-TO-INT [AS &bits-to-int-decoded-assuming]]

&char-to-bits-encoded-as	ENUMERATED {iso10646, compact, mapped} DEFAULT compact,
&Char-to-bits-chars	UniversalString (SIZE(1)) ORDERED OPTIONAL,
&Char-to-bits-values	BIT STRING ORDERED OPTIONAL,
&char-to-bits-unit	Unit (1..MAX) DEFAULT bit,
&char-to-bits-size	ResultSize DEFAULT variable

[CHAR-TO-BITS [AS &char-to-bits-encoded-as] [CHAR-LIST &Char-to-bits-chars] [BITS-LIST &Char-to-bits-values] [SIZE &char-to-bits-size] [MULTIPLE OF &char-to-bits-unit]]

Unit ::= INTEGER {repetitions(0), bit(1), nibble(4), octet(8), word16(16), dword32(32)} (0..256) -- (см. 21.1) ResultSize ::= INTEGER {variable(-1), fixed-to-max(0)} (-1..MAX) -- (см. 21.15)

INT-TO-BITS -- (см. 24.8) AS positive-int SIZE <size> MULTIPLE OF <multiple-of>,

INT-TO-BITS -- (см. 24.8) AS positive-int SIZE <size> MULTIPLE OF <multiple-of>,

&bits-to-char-decoded-assuming	ENUMERATED {iso10646, mapped} DEFAULT iso10646,
&Bits-to-char-values	BIT STRING ORDERED OPTIONAL,
&Bits-to-char-chars	UniversalString (SIZE(1)) ORDERED OPTIONAL

[BITS-TO-CHAR [AS &bits-to-char-decoded-assuming] [BITS-LIST &Bits-to-char-values] [CHAR-LIST &Bits-to-char-chars]]

&bit-to-bits-one Non-Null-Pattern	DEFAULT bits:'1'B,
&bit-to-bits-zero Non-Null-Pattern	DEFAULT bits:'0'B

[BIT-TO-BITS [ZERO-PATTERN &bit-to-bits-zero] [ONE-PATTERN &bit-to-bits-one]]

Non-Null-Pattern ::= Pattern (ALL EXCEPT (bits:"B | octets:"H | char8:"" | char16:"" | char32:"")) -- (см. 21.10.2)

&Source-values	BIT STRING ORDERED,
&Result-values	BIT STRING ORDERED

[BITS-TO-BITS SOURCE-LIST &Source-values RESULT-LIST &Result-values]

[CHARS-TO-COMPOSITE-CHAR]

&bits-to-composite-bits-unit

Unit (1..MAX) DEFAULT bit

[BITS-TO-COMPOSITE-BITS [UNIT &bits-to-composite-bits-unit]]

Unit ::= INTEGER {repetitions(0), bit(1), nibble(4), octet(8), word16(16), dword32(32)} (0..256) -- (см. 21.1)

[OCTETS-TO-COMPOSITE-BITS]

[COMPOSITE-CHAR-TO-CHARS]

[COMPOSITE-BITS-TO-BITS]

[COMPOSITE-BITS-TO-OCTETS]

#OUTER ::= ENCODING-CLASS {
-- Точка выравнивания
&alignment-point	ENUMERATED {unchanged, reset } DEFAULT reset,
-- Заполнение
&post-padding-unit	Unit (1..MAX) DEFAULT octet,
&post-padding	Padding DEFAULT zero,
&post-padding-pattern	Non-Null-Pattern (ALL EXCEPT different:any) DEFAULT bits:'0'B,
-- Спецификация реверсии битов (см. 22.12)
&bit-reversal	ReversalSpecification DEFAULT no-reversal,
-- Действие в отношении добавленных битов
&added-bits	ENUMERATED {hard-error, signal-application, silently-ignore, next-value} DEFAULT hard-error
} WITH SYNTAX { [ALIGNMENT &alignment-point] [PADDING [MULTIPLE OF &post-padding-unit] [POST-PADDING &post-padding [PATTERN &post-padding-pattern]]] [BIT-REVERSAL &bit-reversal] [ADDED BITS DECODING &added-bits] }

Unit ::= INTEGER {repetitions(0), bit(1), nibble(4), octet(8), word16(16), dword32(32)} (0..256) -- (см. 21.1) Padding ::= ENUMERATED {zero, one, pattern, encoder-option} -- (см. 21.9) Non-Null-Pattern ::= Pattern (ALL EXCEPT (bits:"B | octets:"H | char8:"" | char16:"" | char32:"")) -- (см. 21.10.2)

ИС NORMPROD: примечание. В официальном тексте документа, видимо, допущена опечатка: имеются в виду п.п. 25.1.5 - 25.1.7, а не 21.1.5 - 21.1.7 соответственно.

AssignedIdentifier ::= DefinitiveIdentifier | empty Symbol ::= Reference | BuiltinEncodingClassReference | ParameterizedReference Reference ::= encodingclassreference | ExternalEncodingClassReference | encodingobjectreference | encodingobjectsetreference,

DefinitiveIdentifier ::= "{" DefinitiveObjldComponentList "}" | empty

Type ::= BuiltinType | ReferencedType | ConstrainedType | REFERENCE

CharsDefn ::= cstring | Quadruple | Tuple | AbsoluteCharReference AbsoluteCharReference ::= ModuleIdentifier "." Valuereference

FieldSpec ::= FixedTypeValueFieldSpec | FixedTypeValueSetFieldSpec | FixedTypeOrderedValueListFieldSpec | FixedClassEncodingObjectFieldSpec | VariableClassEncodingObjectFieldSpec | FixedClassEncodingObjectSetFieldSpec | FixedClassOrderedEncodingObjectListFieldSpec | EncodingClassFieldSpec

FixedTypeOrderedValueListFieldSpec ::= orderedvaluelistfieldreference DefinedType ORDERED FixedTypeOrderedValueListOptionalitySpec ? FixedTypeOrderedValueListOptionalitySpec ::= OPTIONAL | DEFAULT OrderedValueList

FixedClassOrderedEncodingObjectListFieldSpec ::= orderedencodingobjectlistfieldreference DefinedOrBuiltinEncodingClass ORDERED OrderedEncodingObjectListOptionalitySpec? OrderedEncodingObjectListOptionalitySpec ::= OPTIONAL | DEFAULT OrderedEncodingOb-jectList

VariableClassEncodingObjectFieldSpec ::= objectfieldreference encodingclassfieldreference EncodingObjectOptionalitySpec?

FixedClassEncodingObjectSetFieldSpec ::= objectsetfieldreference DefinedOrBuiltinEncodingClass EncodingObjectSetOptionalitySpec? EncodingObjectSetOptionalitySpec ::= OPTIONAL | DEFAULT EncodingObjectSet

FixedClassOrderedEncodingObjectListFieldSpec ::= orderedencodingobjectlistieldreference DefinedOrBuiltinEncodingClass ORDERED OrderedEncodingObjectListOptionalitySpec? OrderedEncodingObjectListOptionalitySpec ::= OPTIONAL | DEFAULTOrderedEncodingObjectList

EncodingClassFieldSpec ::= encodingclassfieldreference EncodingClassOptionalitySpec? EncodingClassOptionalitySpec ::= OPTIONAL | DEFAULT DefinedOrBuiltinEncodingClass

OrderedValueList ::= "{" Value "," + "}"

OrderedEncodingObjectList ::= "{" EncodingObject "," + "}"

PrimitiveFieldName ::= valuefieldreference | valuesetfieldreference | orderedvaluelistfieldreference

BEGIN BER CER DER ENCODE ENCODE-DECODE END FALSE

MINUS-INFINITY NON-ECN-BEGIN NULL OPTIONS OUTER PER-BASIC-ALIGNED PER-BASIC-UNALIGNED PER-CANONICAL-UNALIGNED

PER-CANONICAL-UNALIGNED PLUS-INFINITY TRUE UNION USE USE-SET

Setting ::= Value | ValueSet | OrderedValueList | EncodingObject | EncodingObjectSet | OrderedEncodingObjectList | DefinedOrBuiltinEncodingClass | OUTER

EncodingClassFieldType ::= DefinedOrBuiltinEncodingClass "." FieldName,

ParameterizedAssignment ::= ParameterizedEncodingObjectAssignment | ParameterizedEncodingClassAssignment | ParameterizedEncodingObjectSetAssignment

Governor ::= EncodingClassFieldType | REFERENCE | DefinedOrBuiltinEncodingClass | #ENCODINGS | Type

ParameterizedEncodingClassAssignment ::= encodingclassreference ParameterList "::=" EncodingClass ParameterizedEncodingObjectAssignment ::= encodingobjectreference ParameterList DefinedOrBuiltinEncodingClass "::=" EncodingObject ParameterizedEncodingObjectSetAssignment ::= encodingobjectsetreference ParameterList #ENCODINGS "::=" EncodingObjectSet

new-component-encoding {< #Any-class >} #New-component {< #Any-class >}::= {-- определение объекта кодирования --}

ParameterizedReference ::= Reference | Reference "{<" ">}"

ParameterizedEncodingObject ::= SimpleDefinedEncodingObject ActualParameterList SimpleDefinedEncodingObject ::= ExternalEncodingObjectReference | encodingobjectreference ParameterizedEncodingObjectSet ::= SimpleDefinedEncodingObjectSet ActualParameterList SimpleDefinedEncodingObjectSet ::= ExternalEncodingObjectSetReference | encodingobjectsetreference ParameterizedEncodingClass ::= SimpleDefinedEncodingClass ActualParameterList SimpleDefinedEncodingClass ::= ExternalEncodingClassReference | encodingclassreference

ActualParameterList ::= "{<" Actual Parameter "," + ">}" ActualParameter ::= Value | ValueSet | OrderedValueList | DefinedOrBuiltinEncodingClass | EncodingObject | EncodingObjectSet | OrderedEncodingObjectList | identifier | STRUCTURE | OUTER

Married ::= BOOLEAN

booleanEncoding #BOOLEAN ::= { ENCODING-SPACE SIZE 1 MULTIPLE OF bit TRUE-PATTERN bits:'1'B FALSE-PATTERN bits:'0'B} marriedEncoding-1 #Married ::= booleanEncoding

marriedEncoding-2 #Married ::= { ENCODING-SPACE SIZE 1}

marriedEncoding-3 #Married ::= { ENCODE WITH PER-BASIC-UNALIGNED}

evenPositiveIntegerEncoding #EvenPositiveInteger ::= { USE #NonNegativeInt MAPPING TRANSFORMS {{INT-TO-INT divide:2}} WITH PER-BASIC-UNALIGNED} #NonNegativeInt ::= #INT (0..MAX) evenNegativeIntegerEncoding #EvenNegativeInteger ::= { USE #NonPositiveInt MAPPING TRANSFORMS {{INT-TO-INT divide:2 -- Примечание: -1/2 = 0 - см. раздел 24.3.7 -- }} WITH PER-BASIC-UNALIGNED} #NonPositiveInt ::= #INT(MIN..0)

Altitude ::= INTEGER (0..65535)

integerRightAlignedEncoding #Altitude ::= { ENCODING { ALIGNED TO NEXT octet ENCODING-SPACE SIZE 16}}

IntegerWithHole ::= INTEGER (-256..-1 | 32..1056)

integerWithHoleEncoding #IntegerWithHole ::= { USE #IntFrom0To1280 MAPPING ORDERED VALUES WITH PER-BASIC-UNALIGNED} #IntFrom0To1280 ::= #INT (0..1280)

PositiveInteger ::= INTEGER (1..MAX) NegativeInteger ::= INTEGER (MIN..-1)

positiveIntegerEncoding #PositiveInteger ::= integerEncoding negativeIntegerEncoding #NegativeInteger ::= integerEncoding

integerEncoding #INT ::= {ENCODINGS { { IF unbounded-or-no-lower-bound ENCODING-SPACE SIZE variable-with-determinant DETERMINED BY container USING OUTER ENCODING twos-complement}, { IF bounded-with-negatives ENCODING-SPACE SIZE fixed-to-max ENCODING twos-complement}, { IF semi-bounded-with-negatives ENCODING-SPACE SIZE variable-with-determinant DETERMINED BY container USING OUTER ENCODING twos-complement}, { IF semi-bounded-without-negatives ENCODING-SPACE SIZE variable-with-determinant DETERMINED BY container USING OUTER ENCODING positive-int}, { IF bounded-without-negatives ENCODING-SPACE SIZE fixed-to-max ENCODING positive-int}}}

PositiveIntegerBCD ::= INTEGER(0..MAX)

positiveIntegerBCDEncoding #PositiveIntegerBCD ::= { USE #CHARS MAPPING TRANSFORMS{{ INT-TO-CHARS -- Мы превращаем в знаки (например, целое число 42 становится цепочкой знаков "42") -- и кодируем знаки с объектом кодирования "numeric-chars-to-bcdEncoding" SIZE variable PLUS-SIGN FALSE}} WITH numeric-chars-to-bcdEncoding } numeric-chars-to-bcdEncoding #CHARS ::= { ALIGNED TO NEXT nibble TRANSFORMS {{ CHAR-TO-BITS -- Мы превращаем каждый знак в цепочку битов (например, знак "4" становится -- '0100'B, а "2" становится '0010'B) AS mapped CHAR-LIST { "0","1","2","3", "4","5","6","7", "8","9"} BITS-LIST { '0000'B, '0001'B, '0010'B, '0011'B, '0100'B, '0101'B, '0110'B, '0111'B, '1000'B, '1001'B }}} REPETITION-ENCODING { REPETITION-SPACE -- Мы определяем конкатенацию цепочек битов для знаков и добавляем признак конца -- (например, '0100'B + '0010'B становится '0100 0010 1111'B) SIZE variable-with-determinant DETERMINED BY pattern PATTERN bits:'1111'B}}

faxEncoding #Fax ::= { ALIGNED TO NEXT octet REPETITION-ENCODING { REPETITION-SPACE SIZE variable-with-determinant DETERMINED BY pattern PATTERN bits:'00000000'B}}

BinaryFile ::= OCTET STRING

binaryFileEncoding #BinaryFile ::= { ALIGNED TO NEXT octet PADDING one REPETITION-ENCODING { REPETITION-SPACE SIZE variable-with-determinant DETERMINED BY container USING OUTER}}

passwordEncoding #Password ::= { ALIGNED TO NEXT octet TRANSFORMS {{CHAR-TO-BITS AS compact SIZE fixed-to-max MULTIPLE OF bit }} REPETITION-ENCODING { REPETITION-SPACE SIZE variable-with-determinant DETERMINED BY container USING OUTER}}

CharacterStringToBit ::= IA5String ("FIRST" | "SECOND" | "THIRD")

characterStringToBitEncoding #CharacterStringToBit ::= { USE #IntFrom0To2 MAPPING VALUES { "FIRST" TO 0, "SECOND" TO 1, "THIRD" TO 2} WITH integerEncoding} #IntFrom0To2 ::= #INT (0..2),

Sequence1	::= SEQUENCE {
a	BOOLEAN,
b	INTEGER OPTIONAL,
c	BinaryFile
	-- "BinaryFile" определен в D.1.8.1 --}

sequence1Encoding #Sequence1 ::= { ENCODE STRUCTURE { b USE-SET OPTIONAL-ENCODING parameterizedPresenceEncoding {< a >}, c binaryFileEncoding -- "binaryFileEncoding" определен в D.1.8.2 -- } WITH PER-BASIC-UNALIGNED} parameterizedPresenceEncoding {< REFERENCE:reference >} #OPTIONAL ::= { PRESENCE DETERMINED BY field-to-be-used USING reference}

Choice ::= CHOICE { boolean [1] BOOLEAN, integer [3] INTEGER, string [5] IA5String}

choiceEncoding #Choice ::= { ENCODE STRUCTURE { boolean [tagEncoding] USE-SET, integer [tagEncoding] USE-SET, string [tagEncoding] USE-SET STRUCTURED WITH { ALTERNATIVE DETERMINED BY handle HANDLE "Tag"}} WITH PER-BASIC-UNALIGNED} tagEncoding #TAG ::= { ENCODING-SPACE SIZE 3 MULTIPLE OF bit EXHIBITS HANDLE "Tag" AT {0 | 1 | 2}}

MyEncodings #ENCODINGS ::= { tagEncoding } COMPLETED BY PER-BASIC-UNALIGNED choiceEncoding #Choice ::= { ENCODE STRUCTURE { STRUCTURED WITH { ALTERNATIVE DETERMINED BY handle HANDLE "Tag"}} WITH MyEncodings}

Sequence2 ::= SEQUENCE { a BOOLEAN, b BIT STRING (CONTAINING Sequence3) } Sequence3 ::= SEQUENCE { a INTEGER(0..10), b BOOLEAN }

sequence2Encoding #Sequence2 ::= { ENCODE STRUCTURE { b { REPETITION-ENCODING { REPETITION-SPACE SIZE 8 MULTIPLE OF bit} CONTENTS-ENCODING {containerEncoding} COMPLETED BY PER-BASIC-UNALIGNED}} WITH PER-BASIC-UNALIGNED} sequence3Encoding #Sequence3 ::= { ENCODE STRUCTURE { STRUCTURED WITH sequence3StructureEncoding } WITH PER-BASIC-UNALIGNED } sequence3StructureEncoding #CONCATENATION ::= { ENCODING-SPACE MULTIPLE OF octet VALUE-PADDING JUSTIFIED left:0 POST-PADDING zero UNUSED BITS DETERMINED BY not-needed }

Example1Encodings #ENCODINGS ::= { marriedEncoding-1 | integerRightAlignedEncoding | evenPositiveIntegerEncoding | evenNegativeIntegerEncoding | integerRightAlignedEncoding | integerWithHoleEncoding | positiveIntegerEncoding | negativeIntegerEncoding | positiveIntegerBCDEncoding | faxEncoding | binaryFileEncoding | passwordEncoding | characterStringToBitEncoding | sequence1Encoding | choiceEncoding-1 | sequence2Encoding | sequence3Encoding}

Example1-ASN1-Module {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module1(2)} DEFINITIONS AUTOMATIC TAGS : := BEGIN MyPDU ::= CHOICE {
married Message	Married,
altitudeMessage	Altitude
-- и т. д.
} Married ::= BOOLEAN Altitude ::= INTEGER (0..65535) -- и т. д. END

Example1-EDM {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) edm-module1(3)} ENCODING-DEFINITIONS ::= BEGIN EXPORTS Example1Encodings; IMPORTS #Married, #Altitude, #EvenPositiveInteger, #EvenNegativeInteger, #IntegerRightAligned, #IntegerWithHole, #PositiveInteger, #NegativeInteger, #PositiveIntegerBCD, #Fax, #BinaryFile, #Password, #CharacterStringToBit, #Sequence1, #Choice, #Sequence2 FROM Example1-ASN1-Module { joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module1(2) }; Example1Encodings #ENCODINGS ::= { marriedEncoding-1 | -- и т. д. sequence2Encoding} -- и т. д. END

Example1-ELM {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) elm-module1(1)} LINK-DEFINITIONS ::= BEGIN IMPORTS Example1Encodings FROM Example-EDM {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) edm-module1(3)} #MyPDU FROM Examplel-ASN1-Module {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module1(2)}; ENCODE #MyPDU WITH Example1Encodings COMPLETED BY PER-BASIC-UNALIGNED END

NormallySmallValues ::= INTEGER (0..1000) - Обычно значения находятся в диапазоне 0 - 63, но иногда используется полный диапазон значений.

normallySmallValuesEncoding-1 #NormallySmallValues ::= { USE #NormallySmallValuesStruct-1 MAPPING DISTRIBUTION { 0..63 TO small, REMAINDER TO large } WITH PER-BASIC-UNALIGNED}

#NormallySmallValuesStruct ::= #CHOICE { small #INT (0..63), large #INT (64..1000)}

normallySmallValuesEncoding-2 #NormallySmallValues ::= { USE #NormallySmallValuesStruct2 MAPPING ORDERED VALUES WITH NormallySmallValuesTag-encoding-plus-PER} normallySmallValuesTag-encoding #TAG ::= { ENCODING-SPACE SIZE 1} NormallySmallValuesTag-encoding-plus-PER #ENCODINGS ::= {normallySmallValuesTag-encoding} COMPLETED BY PER-BASIC-UNALIGNED

#NormallySmallValuesStruct2 ::= #CHOICE { small [#TAG(0)] #INT (0..63), large [#TAG(1)] #INT (0..MAX) }

sparseEvenlyDistributedValueSetEncoding SparseEvenlyDistributedValueSet ::= { USE #IntFrom0To7 MAPPING ORDERED VALUES WITH PER-BASIC-UNALIGNED} #IntFrom0To7 ::= #INT (0..7)

sparseEvenlyDistributedValueSetEncoding-2 #SparseEvenlyDistributedValueSet ::= { USE #IntFrom0To7 MAPPING TRANSFORMS {{INT-TO-INT divide: 2}, {INT-TO-INT decrement:1}} WITH PER-BASIC-UNALIGNED}

SparseUnevenlyDistributedValueSet ::= INTEGER (0|3|5|6|11|8) -- В беспорядке - для иллюстрации того, что порядок следования не важен в таком ограничении.

sparseUnevenlyDistributedValueSetEncoding #SparseUnevenlyDistributedValueSet ::= { USE #IntFrom0To5 MAPPING ORDERED VALUES WITH PER-BASIC-UNALIGNED} #IntFrom0To5 ::= #INT (0..5)

ConditionalPresenceOnValue ::= SEQUENCE { a INTEGER (0..4), b INTEGER (1..10), c BOOLEAN OPTIONAL -- Условие: "c" присутствует, если "a" равно 0, а в остальных случаях "c" отсутствует --, d BOOLEAN OPTIONAL -- Условие: "d" отсутствует, если "a" равно 1, а в остальных случаях "d" присутствует -- } -- Учтем подразумеваемые в комментариях ограничения присутствия. -- Учтем также, что целочисленное поле "a" переносит прикладную семантику -- и имеет значения, отличающиеся от нуля и единицы. Если "a" имеет значение 0, -- то "c" и "d" оба присутствуют. Если "a" имеет значение 1, то "c" и "d" оба отсутствуют. -- Если "a" имеет значение 3 или 4, то "c" отсутствует, а "d" присутствует. Эти условия -- являются очень жесткими для формального выражения при использовании только АСН.1.

conditionalPresenceOnValueEncoding #ConditionalPresenceOnValue ::= { ENCODE STRUCTURE { c USE-SET OPTIONAL-ENCODING is-c-present{< a >}, d USE-SET OPTIONAL-ENCODING is-d-present{< a >}} WITH PER-BASIC-UNALIGNED} is-c-present {< REFERENCE : a >} #OPTIONAL ::= { PRESENCE DETERMINED BY field-to-be-used USING a DECODER-TRANSFORMS {{INT-TO-BOOL TRUE-IS {0}}}} is-d-present {< REFERENCE : a >} #OPTIONAL ::= { PRESENCE DETERMINED BY field-to-be-used USING a DECODER-TRANSFORMS {{INT-TO-BOOL TRUE-IS {0 | 2 | 3 | 4}}}}

ConditionalPresenceOnExternalCondition ::= SEQUENCE { a BOOLEAN OPTIONAL -- Условие: "a" присутствует, если сохраняется внешнее условие "C", -- в противном случае "a" отсутствует -- } -- Отметим, что ограничение присутствия может добавляться только в комментарии.

conditionalPresenceOnExternalConditionEncoding #ConditionalPresenceOnExternalCondition ::= { ENCODE STRUCTURE { a USE-SET OPTIONAL-ENCODING is-a-present} WITH PER-BASIC-UNALIGNED} is-a-present #OPTIONAL ::= NON-ECN-BEGIN {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) user-notation(7)} extern C; extern channel; /* a присутствует только, если канал эквивалентен некоторому значению "C" */ int is_a_present() { if(channel == C) return 1; else return 0; } NON-ECN-END

EnclosingStructureForList ::= SEQUENCE { list VariableLengthList} VariableLengthList ::= SEQUENCE (SIZE (0..1023) ) OF INTEGER (1..2) -- Обычно этот список содержит только небольшое число элементов (0 - 31), но мог бы содержать много.

ИС NORMPROD: примечание. Нумерация пунктов дана в соответствии с официальным текстом документа.

enclosingStructureForListEncoding #EnclosingStructureForList ::= { USE #EnclosingStructureForListStruct MAPPING FIELDS WITH { ENCODE STRUCTURE { aux-length list-lengthEncoding, list { ENCODE STRUCTURE { STRUCTURED WITH { REPETITION-ENCODING { REPETITION-SPACE DETERMINED BY field-to-be-set USING aux-length}}} WITH PER-BASIC-UNALIGNED }} WITH PER-BASIC-UNALIGNED}} -- Первое отображение: использование структуры кодирования с явным детерминантом длины. list-lengthEncoding #AuxVariableListLength ::= { USE #AuxVariableListLengthStruct -- См. D.2.8.4. MAPPING ORDERED VALUES WITH PER-BASIC-UNALIGNED} -- Второе отображение: длина списка кодируется в виде выбора между короткой формой "normally" и -- длинной формой "sometimes".

#EnclosingStructureForListStruct ::= #CONCATENATION { aux-length #AuxVariableListLength, list #VariableLengthList} #AuxVariableListLength ::= #INT (0..1023) #AuxVariableListLengthStruct ::= #ALTERNATIVES { normally #INT (0..31), sometimes #INT (32..1023)}

EqualLengthLists ::= SEQUENCE { list1 List1, list2 List2} (CONSTRAINED BY { -- "list1" и "list2" всегда имеют одно и то же число элементов. -- }) List1 ::= SEQUENCE (SIZE (0..1023)) OF BOOLEAN List2 ::= SEQUENCE (SIZE (0..1023)) OF INTEGER (1..2)

equalLengthListsEncoding #EqualLengthLists ::= { USE #EqualLengthListsStruct MAPPING FIELDS WITH { ENCODE STRUCTURE { list1 list1Encoding{< aux-length >}, list2 list2Encoding{< aux-length >}} WITH PER-BASIC-UNALIGNED}}

list1Encoding {< REFERENCE : length >} #List1 ::= { ENCODE STRUCTURE { USE-SET STRUCTURED WITH list-with-determinantEncoding {< length >}} WITH PER-BASIC-UNALIGNED} list2Encoding {< REFERENCE : length >} #List2 ::= { ENCODE STRUCTURE { USE-SET STRUCTURED WITH list-with-determinantEncoding {< length >}} WITH PER-BASIC-UNALIGNED} list-with-determinantEncoding {< REFERENCE : length-determinant >} #REPETITION ::= { REPETITION-ENCODING { REPETITION-SPACE SIZE variable-with-determinant MULTIPLE OF repetitions DETERMINED BY field-to-be-set USING length-determinant}}

#EqualLengthListsStruct ::= #CONCATENATION { aux-length #AuxListLength, list1 #List1, list2 #List2} #AuxListLength ::= #INT (0..1023)

EnclosingStructureForChoice ::= SEQUENCE { choice UnevenChoiceProbability } UnevenChoiceProbability ::= CHOICE { frequent1 INTEGER (1..2), frequent2 BOOLEAN, common1 INTEGER (1..2), common2 BOOLEAN, common3 BOOLEAN, rare1 BOOLEAN, rare2 INTEGER (1..2), rare3 INTEGER (1..2)}

#EnclosingStructureForChoiceStruct ::= #CONCATENATION { aux-selector #AuxSelector, choice #UnevenChoiceProbability } -- Явный вспомогательный детерминант альтернативы для "выборочного типа". #AuxSelector ::= #INT (0..7)

enclosingStructureForChoiceEncoding #EnclosingStructureForChoice ::= { USE #EnclosingStructureForChoiceStruct MAPPING FIELDS WITH { ENCODE STRUCTURE { aux-selector auxSelectorEncoding, choice { ENCODE STRUCTURE { STRUCTURED WITH { ALTERNATIVE DETERMINED BY field-to-be-set USING aux-selector}} WITH PER-BASIC-UNALIGNED }} WITH PER-BASIC-UNALIGNED} } -- Первое отображение: вводит явный вспомогательный -- детерминант альтернативы. -- Этот объект кодирования указывает, что вспомогательный детерминант используется в качестве -- детерминанта альтернативы. auxSelectorEncoding #AuxSelector ::= { USE #BITS -- ECN Хаффман -- ДИАПАЗОН (0 - 7) -- (0 - 1) занимают 60% -- (2 - 4) занимают 30% -- (5 - 7) занимают 10% -- Определение конца (End Definition) -- Отображения, которые вырабатывает "ECN Public -- Domain Software for Huffman encodings, version 1" -- (см. E.8). MAPPING TO BITS { 0 .. 1 TO '10'B .. '11'B, 2 .. 4 TO '001'B .. '011'B, 5 TO '0001'B, 6 .. 7 TO '00000'B .. '00001'B} WITH PER-BASIC-UNALIGNED } -- Второе отображение: Отображает индексы детерминанта в цепочки битов.

Version1Message ::= SEQUENCE { ie-1 BOOLEAN, ie-2 INTEGER (0..20)}

#Version1DecodingStructure ::= #CONCATENATION { ie-1 #BOOL, ie-2 #INT (0..20), future-additions #PAD}

version1MessageEncoding #Version1Message ::= { ENCODE-DECODE {ENCODE WITH PER-BASIC-UNALIGNED } DECODE AS IF decodingSpecification} decodingSpecification #Version1Message ::= { USE #Version1DecodingStructure MAPPING FIELDS WITH { ENCODE STRUCTURE { future-additions additionsEncoding{< OUTER >} } WITH PER-BASIC-UNALIGNED}} additionsEncoding {< REFERENCE:determinant >} #PAD ::= { ENCODING-SPACE SIZE encoder-option-with-determinant DETERMINED BY container USING determinant}

Example2Encodings #ENCODINGS ::= {
normallySmallValuesEncoding-1	|
sparseEvenlyDistributedValueSetEncoding	|
sparseUnevenlyDistributedValueSetEncoding	|
conditionalPresenceOnValueEncoding	|
conditionalPresenceOnExternalConditionEncoding	|
enclosingStructureForListEncoding	|
equalLenghListsEncoding	|
enclosingStructureForChoiceEncoding version1MessageEncoding }	|

Example2-ASN1-Module {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module2(5)} DEFINITIONS AUTOMATIC TAGS ::= BEGIN ExampleMessages ::= CHOICE { firstExample NormallySmallValues, secondExample SparseEvenlyDistributedValueSet -- и т.д. } NormallySmallValues ::= INTEGER (0..1024) SparseEvenlyDistributedValueSet ::= INTEGER (2 | 4 | 6 | 8 | 10 | 12 | 14 | 16) -- и т.д. END

Example2-EDM {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) edm-module2(6)} ENCODING-DEFINITIONS ::= BEGIN EXPORTS Example2Encodings; IMPORTS #NormallySmallValues, #SparseEvenlyDistributedValue, #SparseUnevenlyDistributedValueSet, #ConditionalPresenceOnValueSet, #ConditionalPresenceOnExternalCondition, #EnclosingStructureForList,#EqualLengthLists, EnclosingStructureForChoice, #Version1Message FROM Example2-ASN1-Module {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module2(5)}; Example2Encodings #ENCODINGS ::= { normallySmallValuesEncoding | -- и т.д. extensibleMessageEncoding} -- и т.д. END

Example2-ELM {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) elm-module2(4)} LINK-DEFINITIONS ::= BEGIN IMPORTS Example2Encodings FROM Example2-EDM {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) edm-module2(6)} #ExampleMessages FROM Example2-ASN1-Module {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module2(5)}; ENCODE #ExampleMessages WITH Example2Encodings COMPLETED BY PER-BASIC-UNALIGNED END

Sequence1 ::= SEQUENCE { component1 INTEGER OPTIONAL, component2 INTEGER OPTIONAL, component3 VisibleString }

sequence1-encoding #SEQUENCE ::= { REPLACE OPTIONALS WITH #Integer-with-pointer-concat ENCODED BY integer-with-pointer-concat-encoding INSERT AT HEAD #Pointer ENCODING-SPACE SIZE variable-with-determinant DETERMINED BY container USING OUTER } #Pointer ::= #INTEGER #Integer-with-pointer-concat {< #Element >} ::= #CONCATENATION { element #Element OPTIONAL-ENCODING #Integer-optionality } #Integer-optionality ::= #OPTIONAL integer-optionality-encoding{< REFERENCE: start-pointer>} #Integer-optionality ::= { ALIGNED TO ANY octet START-POINTER start-pointer PRESENCE DETERMINED BY pointer} integer-with-pointer-concat-encoding {< #Element, REFERENCE:pointer, #ENCOINGS:EncodingObjectSet >} #Integer-with-pointer-concat{< #Element >} ::= { ENCODE STRUCTURE { element USE-SET OPTIONAL-ENCODING integer-optionality-encoding{< pointer >}} WITH EncodingObjectSet} concat #CONCATENATION ::= { ENCODING-SPACE }

Sequence2 ::= SEQUENCE { component1 BOOLEAN OPTIONAL, component2 INTEGER, component3 VisibleString OPTIONAL }

#Sequence2 ::= #SEQUENCE { component1 #BOOL OPTIONAL-ENCODING #Sequence2-optional, component2 #INTEGER, component3 #VisibleString OPTIONAL-ENCODING #Sequence2-optional}, где: #Sequence2-optional ::= #OPTIONAL

sequence2-optional-encoding #Sequence2-optional ::= { REPLACE STRUCTURE WITH #Optional-with-determinant ENCODED BY optional-with-determinant-encoding}

#Optional-with-determinant{< #Element >} ::= #CONCATENATION { determinant #BOOLEAN, component #Element OPTIONAL-ENCODING #Presence-determinant}, где: #Presence-determinant ::= #OPTIONAL

optional-with-determinant-encoding {< #Element, #ENCODINGS: Sequence2-combined-encoding-object-set >} #Optional-with-determinant {< #Element >} ::={ ENCODE STRUCTURE { determinant determinant-encoding, component USE-SET OPTIONAL-ENCODING if-component-present-encoding{< determinant >} } WITH Sequence2-combined-encoding-object-set }

if-component-present-encoding {<REFERENCE:presence-bit>} #Presence-determinant ::= { PRESENCE DETERMINED BY field-to-be-set USING presence-bit} determinant-encoding #BOOLEAN ::= { ENCODING-SPACE SIZE 1 MULTIPLE OF bit TRUE-PATTERN bits'0'B FALSE-PATTERN bits:'1'B}

Octet3 ::= OCTET STRING (CONTAINING Sequence3) Sequence3 ::=SEQUENCE { component1 [0] BIT STRING (SIZE(0..2047)) OPTIONAL, component2 [1] OCTET STRING (SIZE(0..2047)) OPTIONAL, component3 [2] VisibleString (SIZE(0..2047)) OPTIONAL }

#Octets3 ::= #OCTET-STRING octets3-encoding #Octets3 ::= { REPETITION-ENCODING { REPLACE STRUCTURE WITH #Octets-with-length ENCODED BY octets-with-length-encoding}} #Octets-with-length{< #Element >} ::= #CONCATENATION { length #INT(0..2047), octets #Element} octets-with-length-encoding{< #Element >} #Octets-with-length{< #Element >} ::= { ENCODE STRUCTURE { octets octets-encoding{< length >}} WITH PER-BASIC-UNALIGNED} octets-encoding{< REFERENCE:length >} #OCTETS ::= { REPETITION-ENCODING { REPETITION-SPACE SIZE variable-with-determinant DETERMINED BY field-to-be-set USING length} }

sequence3-encoding #Sequence3 ::= { ENCODE STRUCTURE { STRUCTURED WITH sequence3Structure-encoding } WITH Sequence3-encodings COMPLETED BY PER-BASIC-UNALIGNED } Sequence3-encodings #ENCODINGS ::= { sequence3-optional-encoding | tag-4-bits-encoding } #Sequence3-optional ::= #OPTIONAL sequence3-optional-encoding #Sequence3-optional ::= { PRESENCE DETERMINED BY container USING OUTER} #TAG-4-bits ::= #TAG tag-4-bits-encoding #TAG-4-bits ::= { ENCODING-SPACE SIZE 4}

outer-encoding #OUTER ::= { ADDED BITS DECODING silently-ignore }

SequenceOfIntegers ::= SEQUENCE(SIZE(0..63)) OF INTEGER(0..1023)

#SequenceOf ::= #REPETITION sequenceOf-encoding #SequenceOf ::= { REPETITION-ENCODING { REPLACE STRUCTURE WITH #SequenceOf-with-count ENCODED BY sequenceOf-with-count-encoding}} #SequenceOf-with-count{< #Element >} ::= #CONCATENATION { count #INT(0..63), elements #Element } sequenceOf-with-count-encoding{< #Element >} #SequenceOf-with-count{< #Element >} ::= { ENCODE STRUCTURE { elements { ENCODE STRUCTURE { STRUCTURED WITH elements-encoding{< count >}} WITH PER-BASIC-UNALIGNED}} WITH PER-BASIC-UNALIGNED} elements-encoding{< REFERENCE:count >} #REPETITION ::= { REPETITION-ENCODING { REPETITION-SPACE SIZE variable-with-determinant MULTIPLE OF repetitions DETERMINED BY field-to-be-set USING count}}

Example3Encodings-1	#ENCODINGS ::= {
sequence1-encoding		|
Example3Encodings-2	#ENCODINGS ::= {
concat		|
sequence2-optional-encoding		|
octets3-encoding		|
sequenceOf-encoding		|
sequence3-encoding outer-encoding }		|

Example3-ASN1-Module {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module3(9)}
DEFINITIONS AUTOMATIC TAGS ::= BEGIN
Sequence1 ::=	SEQUENCE {
component1	BOOLEAN	OPTIONAL,
component2	INTEGER	OPTIONAL,
component3	VisibleString	OPTIONAL }
-- и т.д. END

Example3-EDM {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) edm-module3(10)} ENCODING-DEFINITIONS ::= BEGIN EXPORTS Example3Encodings; RENAMES #OPTIONAL AS #Sequence2-optional IN #Sequence2 #OCTET-STRING AS #Octets3 IN ALL #OPTIONAL AS #Sequence3-optional IN #Sequence3 #TAG AS #TAG-4-bits IN #Sequence3 FROM Example3-ASN1-Module {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module3(9)}; Example3Encodings-1 #ENCODINGS ::= { sequence1-encoding } Example3Encodings-2 #ENCODINGS ::= { concat | -- и т.д. sequenceOf-encoding } -- и т.д. END

Example3-ELM {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) elm-module3(8)} LINK-DEFINITIONS ::= BEGIN IMPORTS Example3Encodings, #Sequence1, #Sequence2, #Octet3, #Sequence3, #SequenceOfIntegers FROM Example3-EDM { joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) edm-module3(10) }; ENCODE #Sequence1, WITH Example3Encodings-1 COMPLETED BY PER-BASIC-UNALIGNED ENCODE #Sequence2, #Octet3, #Sequence3, #SequenceOfIntegers WITH Example3Encodings-2 COMPLETED BY PER-BASIC-UNALIGNED END

8	7	6	5	4	3	2	1
Индикатор расширения	Резерв		Профиль протокола

ProfileIndication ::= SEQUENCE OF SEQUENCE {
more-bit	BOOLEAN,
reserved	BIT STRING (SIZE (2)),
protocol-Profile-ID	INTEGER (0..31) }

#ProfileIndication ::= #SEQUENCE-OF { #SEQUENCE {
more-bit	#BOOLEAN,
reserved	#BIT-STRING (SIZE (2)),
protocol-Profile-ID	#INTEGER (0..31) } }

more-bit-encoding {< REFERENCE:more-bit >} #SEQUENCE-OF ::= { REPETITION-ENCODING { REPETITION-SPACE SIZE variable-with-determinant DETERMINED BY flag-to-be-set USING more-bit ENCODER-TRANSFORMS { { BOOL-TO-BOOL AS logical:not } } } }

profileIndicationEncoding #ProfileIndication ::= { ENCODE STRUCTURE { STRUCTURED WITH more-bit-encoding {< more-bit >} } WITH PER-BASIC-UNALIGNED }

ProfileIndication2 ::= SEQUENCE OF protocol-Profile-ID INTEGER (0..31)

#ProfileIndication2 ::= #SEQUENCE-OF { protocol-Profile-ID INTEGER (0..31) }

#ProfileIndicationStruct ::= #SEQUENCE-OF { #SEQUENCE {
more-bit-field	#BOOLEAN,
reserved	#PAD,
protocol-Profile-ID	#INTEGER (0..31) } }

pad-encoding #PAD ::= { ENCODING-SPACE SIZE 2 PATTERN bits:'00'B }

	8	7	6	5	4	3	2	1
Октет 1	Идентификатор сообщения
Октет 2	A			b-flag	c-len			Резерв
Октет 3	b1		b2	Резерв	b3		Резерв
...
Октет Y	c1				c2
Октет Y + 1	c3						Резерв
...
Октет Z	d1	d2			d3			Резерв

	8	7	6	5	4	3	2	1
Октет 1	Идентификатор сообщения
Октет 2...	Что-либо - 1

	8	7	6	5	4	3	2	1
Октет 1	Идентификатор сообщения
Октет 2...	Что-либо - 2

Legacy Protocol-ASN 1-Module {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module4(11)} DEFINITIONS AUTOMATIC TAGS ::= BEGIN LegacyProtocolMessages ::= SEQUENCE { message-id ENUMERATED {message1, message2, message3}, messages CHOICE { message1 Message1, message2 Message2, message3 Message3}} -- CHOICE ограничен значением message-id. Message1 ::= SEQUENCE { a A, b-flag BOOLEAN, c-len INTEGER (0..max-c-len), b B OPTIONAL, -- определяется значением "b-flag" c C, -- определяется значением "c-len" d D OPTIONAL} -- определяется концом PDU A ::= INTEGER (0..7) -- Значения 5 - 7 зарезервированы для будущего -- использования. Системы версии 1 -- должны рассматривать 5 - 7 как 4. B ::= SEQUENCE { b1 ENUMERATED {e0, e1, e2, e3 }, b2 BOOLEAN, b3 INTEGER (0..3) } C ::= SEQUENCE (SIZE (0..max-c-len)) OF C-elem C-elem ::= SEQUENCE { c1 BIT STRING (SIZE (4)), c2 INTEGER (0..1024) } D ::= SEQUENCE (SIZE (0..max-d-len)) OF D-elem D-elem ::= SEQUENCE { d1 BOOLEAN, d2 ENUMERATED { f0, f1, f2, f3, f4, f5, f6, f7 }, d3 INTEGER (0..7) } max-c-len INTEGER ::= 7 max-d-len INTEGER ::= 20 Message2 ::= SEQUENCE { -- quelque chose 1 --} Message3 ::= SEQUENCE { -- quelque chose 2 --} END

legacyProtocolMessagesEncoding #LegacyProtocolMessages ::= { ENCODE STRUCTURE { message-id { ENCODING { ENCODING-SPACE SIZE 8}}, messages { ENCODE STRUCTURE { STRUCTURED WITH { ALTERNATIVE DETERMINED BY field-to-be-used USING message-id}} WITH PER-BASIC-UNALIGNED}} WITH PER-BASIC-UNALIGNED}

message1Encoding #Message1 ::= { ENCODE STRUCTURE { b b-encoding OPTIONAL-ENCODING { PRESENCE DETERMINED BY field-to-be-used USING b-flag}, c octet-aligned-seq-of-with-ext-determinant{< c-len >}, d octet-aligned-seq-of-until-end-of-container OPTIONAL-ENCODING USE-SET} WITH PER-BASIC-UNALIGNED}

b-encoding #B ::= { ENCODE STRUCTURE { -- Компоненты b3 { ALIGNED TO NEXT nibble ENCODING { ENCODING-SPACE SIZE 2 MULTIPLE OF bit }} -- Структура STRUCTURED WITH { ALIGNED TO NEXT octet ENCODING-SPACE SIZE self-delimiting-values MULTIPLE OF bit }} -- Остаток WITH PER-BASIC-UNALIGNED}

octet-aligned-seq-of-with-ext-determinant{< REFERENCE : len >} #REPETITION ::= { REPETITION-ENCODING { ALIGNED TO NEXT octet REPETITION-SPACE SIZE variable-with-determinant DETERMINED BY field-to-be-used USING len}}

octet-aligned-seq-of-with-ext-determinant{< REFERENCE : len >} #REPETITION ::= { REPETITION-ENCODING { ALIGNED TO NEXT octet REPETITION-SPACE SIZE variable-with-determinant DETERMINED BY field-to-be-used USING len}}

LegacyProtocol-EDM-Module {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) edm-module4(13)} ENCODING-DEFINITIONS ::= BEGIN EXPORTS LegacyProtocolEncodings; IMPORTS #LegacyProtocolMessages FROM LegacyProtocol-ASN1-Module { joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module4(11) }; LegacyProtocolEncodings #ENCODINGS ::= { legacyProtocolMessagesEncoding | message1Encoding } -- и т.д. END

LegacyProtocol-ELM-Module { joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) elm-module4(12) } LINK-DEFINITIONS ::= BEGIN IMPORTS LegacyProtocolEncodings FROM LegacyProtocol-EDM-Module { joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) edm-module4(13) } #LegacyProtocol Messages FROM LegacyProtocol-ASN1-Module { joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module4(11) }; ENCODE #LegacyProtocolMessages WITH LegacyProtocolEncodings COMPLETED BY PER-BASIC-UNALIGNED END

ECN Huffman

my-int-encoding1 #My-Special-1 ::= { USE #BITS -- ECN Хаффман -- ДИАПАЗОН (-1 - 10) -- -1 занимает 20% -- 0 занимает 15% -- 1 занимает 25% -- (3 - 6) занимают 10% -- Оставшиеся занимают 2% -- Определение конца -- Отображения, созданные "ECN Public Domain -- Software for Huffman encodings, version 1" MAPPING TO BITS { -1 TO '11'B, 0 .. 1 TO '01'B .. '10'B, 2 TO '0000001'B, 3 .. 5 TO '0001'B .. '0011'B, 6 TO '00001'B, 7 .. 8 TO '0000010'B .. '0000011'B, 9 .. 10 TO '00000000'B .. '00000001'B } WITH my-self-delim-bits-encoding }

my-int-encoding2 #My-Special-2 ::= { USE #BITS -- ECN Хаффман -- ДИАПАЗОН (-10 - 10) -- -10 занимает 20% -- 1 занимает 25% -- 5 занимает 15% -- (7 - 10) занимают 10% -- Определение конца -- Отображения, созданные "ECN Public Domain -- Software for Huffman encodings, version 1" MAPPING TO BITS { -10 TO '11'B, 1 TO '10'B, 5 TO '01'B, 7 .. 10 TO '0000'B .. '0011'B } WITH my-self-delim-bits-encoding }

my-int-encoding3 #My-Special-3 ::= { USE #BITS -- ECN Хаффман -- ДИАПАЗОН (0 - 1000) -- (0 - 63) занимают 100% -- Оставшиеся занимают 0% -- Определение конца -- Отображения, созданные "ECN Public Domain -- Software for Huffman encodings, version 1" MAPPING TO BITS { 0 .. 62 TO '000001'B .. '111111'B, 63 TO '0000001'B, 64 .. 150 TO '0000000110101001'B .. '0000000111111111'B, 151 .. 1000 TO '00000000000000000'B .. '00000001101010001'B } WITH my-self-delim-bits-encoding }

anystringexceptnonecend encodingobjectreference encodingobjectsetreference encodingclassreference "::=" ".." "{" "}" "(" ")" "," "." "|" ALL AS BEGIN BER BITS BY CER COMPLETED DECODE DER DISTRIBUTION ENCODE ENCODE-DECODE ENCODING-CLASS ENCODING-DEFINITIONS END EXCEPT EXPORTS FALSE FIELDS FROM GENERATES

IF IMPORTS IN LINK-DEFINITIONS MAPPING MAX MIN MINUS-INFINITY NON-ECN-BEGIN NON-ECN-END NULL OPTIONAL-ENCODING OPTIONS ORDERED OUTER PER-BASIC-ALIGNED PER-BASIC-UNALIGNED PER-CANONICAL-ALIGNED PER-CANONICAL-UNALIGNED PLUS-INFINITY REFERENCE REMAINDER RENAMES SIZE STRUCTURE STRUCTURED TO TRANSFORMS TRUE UNION USE USE-SET VALUES WITH

REFERENCE

bstring cstring hstring identifier modulereference number realnumber typereference "-" NULL PLUS-INFINITY

";" ":" ALL EXCEPT EXPORTS FALSE FROM IMPORTS MINUS-INFINITY TRUE

"{<" ">}"

ELMDefinition ::= ModuleIdentifier LINK-DEFINITIONS "::=" BEGIN ELMModuleBody END ELMModuleBody ::= Imports ? EncodingApplicationList EncodingApplicationList ::= EncodingApplication EncodingApplicationList ? EncodingApplication ::= ENCODE SimpleDefinedEncodingClass "," + CombinedEncodings CombinedEncodings ::= WITH PrimaryEncodings CompletionClause ? CompletionClause ::= COMPLETED BY SecondaryEncodings PrimaryEncodings ::= EncodingObjectSet SecondaryEncodings ::= EncodingObjectSet EDMDefinition ::= ModuleIdentifier ENCODING-DEFINITIONS "::=" BEGIN EDMModuleBody END EDMModuleBody ::= Exports ? RenamesAndExports ? Imports ?

EDMAssignmentList ? EDMAssignmentList ::= EDMAssignment EDMAssignmentList ? EDMAssignment ::= EncodingClassAssignment | EncodingObjectAssignment | EncodingObjectSetAssignment | ParameterizedAssignment RenamesAndExports ::= RENAMES ExplicitGenerationList ";" ExplicitGenerationList ::= ExplicitGeneration ExplicitGenerationList ? ExplicitGeneration ::= OptionalNameChanges FROM Global ModuleReference OptionalNameChanges ::= NameChanges | GENERATES NameChanges ::= NameChange NameChanges ? NameChange ::= OriginalClassName AS NewClassName IN NameChangeDomain OriginalClassName ::= SimpleDefinedEncodingClass | BuiltinEncodingClassReference NewClassName ::= encodingclassreference NameChangeDomain ::= IncludedRegions Exception ? Exception ::= EXCEPT ExcludedRegions IncludedRegions ::=

ALL | RegionList ExcludedRegions ::= RegionList RegionList ::= Region "," + Region ::= SimpleDefinedEncodingClass | ComponentReference ComponentReference ::= SimpleDefinedEncodingClass "." ComponentIdList ComponentIdList ::= identifier "." + EncodingClassAssignment ::= encodingclassreference "::=" EncodingClass EncodingClass ::= BuiltinEncodingClassReference | EncodingStructure EncodingObjectAssignment ::= encodingobjectreference DefinedOrBuiltinEncodingClass "::=" EncodingObject EncodingObjectSetAssignment ::= encodingobjectsetreference #ENCODINGS "::=" EncodingObjectSet CompletionClause ? EncodingObjectSet ::= DefinedOrBuiltinEncodingObjectSet | EncodingObjectSetSpec EncodingStructure ::=

TaggedStructure | UntaggedStructure TaggedStructure ::= "[" TagClass TagValue ? "]" UntaggedStructure UntaggedStructure ::= Defined EncodingClass | EncodingStructureField | EncodingStructureDefn TagClass ::= DefinedEncodingClass | TagClassReference TagValue ::= "(" number")" EncodingStructureDefn ::= AlternativesStructure | RepetitionStructure | ConcatenationStructure AlternativesStructure ::= AlternativesClass "{" NamedFields "}" AlternativesClass ::= DefinedEncodingClass | AlternativesClassReference NamedFields ::= NamedField "," + NamedField ::= identifier EncodingStructure RepetitionStructure ::=

RepetitionClass "{" identifier ? EncodingStructure "}" Size? RepetitionClass ::= DefinedEncodingClass | RepetitionClassReference ConcatenationStructure ::= ConcatenationClass "{" ConcatComponents "}" ConcatenationClass ::= DefinedEncodingClass | ConcatenationClassReference ConcatComponents ::= ConcatComponent "," * ConcatComponent ::= NamedField ConcatComponentPresence ? ConcatComponentPresence ::= OPTIONAL-ENCODING OptionalClass OptionalClass ::= DefinedEncodingClass | OptionalityClassReference DefinedEncodingClass ::= encodingclassreference | ExternalEncodingClassReference | ParameterizedEncodingClass DefinedOrBuiltinEncodingClass ::= DefinedEncodingClass | BuiltinEncodingClassReference

DefinedEncodingObject ::= encodingobjectreference | ExternalEncodingObjectReference | ParameterizedEncodingObject DefinedEncodingObjectSet ::= encodingobjectsetreference | ExternalEncodingObjectSetReference | ParameterizedEncodingObjectSet DefinedOrBuiltinEncodingObjectSet ::= DefinedEncodingObjectSet | BuiltinEncodingObjectSetReference BuiltinEncodingObjectSetReference ::= PER-BASIC-ALIGNED | PER-BASIC-UNALIGNED | PER-CANONICAL-ALIGNED | PER-CANONICAL-UNALIGNED | BER | CER | DER ExternalEncodingClassReference ::= modulereference "." encodingclassreference | modulereference "." BuiltinEncodingClassReference ExternalEncodingObjectReference ::= modulereference "." encodingobjectreference ExternalEncodingObjectSetReference ::= modulereference "." encodingobjectsetreference EncodingObjectSetSpec ::= "{" EncodingObjects UnionMark * "}" EncodingObjects ::= DefinedEncodingObject | DefinedEncodingObjectSet UnionMark ::=

"|" | UNION EncodingObject ::= DefinedEncodingObject | DefinedSyntax | EncodeWith | EncodeByValueMapping | EncodeStructure | DifferentialEncodeDecodeObject | EncodingOptionsEncodingObject | NonECNEncodingObject EncodeWith ::= "{" ENCODE CombinedEncodings "}" EncodeByValueMapping ::= "{" USE DefinedOrBuiltinEncodingClass MAPPING ValueMapping WITH ValueMappingEncodingObjects "}" ValueMappingEncodingObjects ::= EncodingObject | DefinedOrBuiltinEncodingObjectSet DifferentialEncodeDecodeObject ::= "{" ENCODE-DECODE SpecForEncoding DECODE AS IF SpecForDecoders "}" SpecForEncoding ::= EncodingObject SpecForDecoders ::= EncodingObject EncodingOptionsEncodingObject ::= "{" OPTIONS

EncodingOptionsList WITH AlternativesEncodingObject "}" EncodingOptionsList ::= OrderedEncodingObjectList AlternativesEncodingObject ::= EncodingObject NonECNEncodingObject ::= NON-ECN-BEGIN AssignedIdentifier anystringexceptnonecnend NON-ECN-END EncodeStructure ::= "{" ENCODE STRUCTURE "{" ComponentEncodingList StructureEncoding ? "}" CombinedEncodings ? "}" StructureEncoding ::= STRUCTURED WITH TagEncoding ? EncodingOrUseSet ComponentEncodingList ::= ComponentEncoding "," * ComponentEncoding := NonOptionalComponentEncodingSpec | OptionalComponentEncodingSpec NonOptionalComponentEncodingSpec ::= identifier ? TagAndElementEncoding OptionalComponentEncodingSpec::= identifier TagAndElementEncoding OPTIONAL-ENCODING

OptionalEncoding TagAndElementEncoding ::= TagEncoding ? EncodingOrUseSet TagEncoding ::= "[" EncodingOrUseSet "]" OptionalEncoding ::= EncodingOrUseSet EncodingOrUseSet ::= EncodingObject | USE-SET BuiltinEncodingClassReference ::= BitfieldClassReference | AlternativesClassReference | ConcatenationClassReference | RepetitionClassReference | OptionalityClassReference | TagClassReference | EncodingProcedureClassReference BitfieldClassReference ::= #NUL | #BOOL | #INT | #BITS | #OCTETS | #CHARS | #PAD | #BIT-STRING | #BOOLEAN | #CHARACTER-STRING | #EMBEDDED-PDV | #ENUMERATED | #EXTERNAL | #INTEGER | #NULL | #OBJECT-IDENTIFIER | #OCTET-STRING

| #OPEN-TYPE | #REAL | #RELATIVE-OID | #TIME | #DATE | #DATE-TIME | #TIME-OF-DAY | #DURATION | #GeneralizedTime | #UTCTime | #ObjectDescriptor | #BMPString | #GeneralString | #GraphicString | #IA5String | #NumericString | #PrintableString | #TeletexString | #UniversalString | #UTF8String | #VideotexString | #VisibleString AlternativesClassReference ::= #ALTERNATIVES | #CHOICE ConcatenationClassReference ::= #CONCATENATION | #SEQUENCE | #SET RepetitionClassReference ::= #REPETITION | #SEQUENCE-OF | #SET-OF OptionalityClassReference ::= #OPTIONAL

TagClassReference ::= #TAG EncodingProcedureClassReference ::= #TRANSFORM | #CONDITIONAL-INT | #CONDITIONAL-REPETITION | #OUTER EncodingStructureField ::= #NUL | #BOOL | #INT Bounds? | #BITS Size? | #OCTETS Size? | #CHARS Size? | #PAD | #BIT-STRING Size? | #BOOLEAN | #CHARACTER-STRING | #EMBEDDED-PDV | #ENUMERATED Bounds? | #EXTERNAL | #INTEGER Bounds? | #NULL | #OBJECT-IDENTIFIER | #OCTET-STRING Size? | #OPEN-TYPE | #REAL | #RELATIVE-OID | #TIME | #DATE | #DATE-TIME | #TIME-OF-DAY | #DURATION | #GeneralizedTime | #UTCTime

| #ObjectDescriptor Size? | #BMPString Size? | #GeneralString Size? | #GraphicString Size? | #IA5String Size? | #NumericString Size? | #PrintableString Size? | #TeletexString Size? | #UniversalString Size? | #UTF8String Size? | #VideotexString Size? | #VisibleString Size? Bounds ::= "(" EffectiveRange ")" EffectiveRange ::= MinMax | Fixed Size ::= "(" SIZE SizeEffectiveRange ")" SizeEffectiveRange ::= "(" EffectiveRange ")" MinMax ::= ValueOrMin ".." ValueOrMax ValueOrMin ::= SignedNumber | MIN ValueOrMax ::= SignedNumber | MAX Fixed ::= SignedNumber ValueMapping ::= MappingByExplicitValues | MappingByMatchingFields | MappingByTransformEncodingObjects | MappingByAbstractValueOrdering

| MappingByValueDistribution | MappingIntToBits MappingByExplicitValues ::= VALUES "{" MappedValues "," + "}" MappedValues ::= MappedValue1 TO MappedValue2 MappedValue1 ::= Value MappedValue2 ::= Value MappingByMatchingFields ::= FIELDS MappingByTransformEncodingObjects ::= TRANSFORMS "{" OrderedTransformList "}" OrderedTransformList ::= Transform "," + Transform ::= EncodingObject MappingByAbstractValueOrdering ::= ORDERED VALUES MappingByValueDistribution ::= DISTRIBUTION "{" Distribution "," + "}" Distribution ::= SelectedValues TO identifier SelectedValues ::=

SelectedValue | DistributionRange | REMAINDER DistributionRange ::= DistributionRangeValue1 ".." DistributionRangeValue2 SelectedValue ::= SignedNumber DistributionRangeValue1 ::= SignedNumber DistributionRangeValue2 ::= SignedNumber MappingIntToBits ::= TO BITS "{" MappedIntToBits "," + "}" MappedIntToBits ::= SingleIntValMap | IntValRangeMap SingleIntValMap ::= IntValue TO BitValue IntValue ::= SignedNumber BitValue ::= bstring | hstring IntValRangeMap ::= IntRange TO BitRange IntRange ::= IntRangeValue1 ".." IntRangeValue2

BitRange ::= BitRangeValue1 ".." BitRangeValue2 IntRangeValue1 ::= SignedNumber IntRangeValue2 ::= SignedNumber BitRangeValue1 ::= bstring | hstring BitRangeValue2 ::= bstring | hstring

ModuleIdentifier ::= modulereference DefinitiveIdentifier ? DefinitiveIdentifier ::= "{" DefinitiveObjIdComponentList "}" DefinitiveObjIdComponentList ::= DefinitiveObjIdComponent | DefinitiveObjIdComponent DefinitiveObjIdComponentList DefinitiveObjIdComponent ::= NameForm | DefinitiveNumberForm | DefinitiveNameAndNumberForm NameForm ::= identifier DefinitiveNumberForm ::= number DefinitiveNameAndNumberForm ::= identifier "(" DefinitiveNumberForm ")" Exports ::= EXPORTS SymbolsExported? ";" | EXPORTS ALL ";" SymbolsExported ::= SymbolList Imports ::= IMPORTS SymbolsImported? ";" SymbolsImported ::= SymbolsFromModuleList SymbolsFromModuleList ::= SymbolsFromModule | SymbolsFromModuleList SymbolsFromModule SymbolsFromModule ::= SymbolList FROM GlobalModuleReference GlobalModuleReference ::= modulereference AssignedIdentifier AssignedIdentifier ::= DefinitiveIdentifier | empty

SymbolList ::= Symbol | SymbolList "," Symbol Symbol ::= Reference | ParameterizedReference | BuiltinEncodingClassReference Reference ::= encodingclassreference | ExternalEncodingClassReference | encodingobjectreference | encodingobjectsetreference Value ::= BuiltinValue BuiltinValue ::= BitString | BooleanValue | CharacterStringValue | ChoiceValue | EnumeratedValue | IntegerValue | NullValue | ObjectIdentifierValue | OctetStringValue | RealValue | RelativeOIDValue

BitStringValue ::= bstring | hstring BooleanValue ::= TRUE | FALSE CharacterStringValue ::= RestrictedCharacterStringValue RestrictedCharacterStringValue ::= cstring | CharacterStringList | Quadruple | Tuple CharacterStringList ::= "{" CharSyms "}" CharSyms ::= CharsDefn | CharSyms "," CharsDefn CharsDefn ::= cstring | Quadruple | Tuple | AbsoluteCharReference Quadruple ::= "{" Group "," Plane "," Row "," Cell "}" Group ::= number Plane ::= number

Row ::= number Cell ::= number Tuple ::= "{" TableColumn "," TableRow "} TableColumn ::= number TableRow ::= number AbsoluteCharReference ::= ModuleIdentifier "." valuereference ChoiceValue ::= identifier ":" Value EnumeratedValue ::= identifier IntegerValue ::= SignedNumber SignedNumber ::= number | "-" number NullValue ::= NULL ObjectIdentifierValue ::= "{" ObjIdComponentsList "}" ObjIdComponentsList ::= ObjIdComponents | ObjIdComponents ObjldComponentsList ObjldComponents ::= NameForm | NumberForm | NameAndNumberForm

NameForm ::= identifier NumberForm ::= number NameAndNumberForm ::= identifier "(" NumberForm ")" OctetStringValue ::= bstring | hstring RealValue ::= NumericRealValue | SpecialRealValue NumericRealValue ::= | "-" realnumber | SequenceValue SpecialRealValue ::= PLUS-INFINITY | MINUS-INFINITY RelativeOIDValue ::= "{" RelativeOidComponentsList "}" RelativeOidComponentsList ::= RelativeOidComponents | RelativeOidComponents RelativeOidComponentsList RelativeOidComponents ::= NumberForm | NameAndNumberForm SequenceValue ::= "{" ComponentValueList "}" | "{" "}" ComponentValueList ::= NamedValue | ComponentValueList "," NamedValue

NamedValue ::= identifier Value SequenceOfValue ::= ValueList ::= SetValue ::= ValueSet ::= "{" ElementSetSpecs "}" ElementSetSpecs ::= RootElementSetSpec RootElementSetSpec ::= ElementSetSpec ElementSetSpec ::= Unions | ALL Exclusions Exclusions ::= EXCEPT Elements Unions ::= Intersections | UElems UnionMark Intersections UElems ::= Unions Intersections ::= Intersection Elements

IntersectionElements ::= Elements | Elems Exclusions UnionMark ::= "|" | UNION Elements ::= SubtypeElements SubtypeElements ::= SingleValue | ValueRange SingleValue ::= Value

DefinedSyntax ::= "{" DefinedSyntaxList ? "}" DefinedSyntaxList ::= DefinedSyntaxToken DefinedSyntaxList ? DefinedSyntaxToken ::= Literal | Setting Literal ::= word | "," Setting ::= Value | ValueSet | OrderedValueList | EncodingObject | EncodingObjectSet | OrderedEncodingObjectList | DefinedOrBuiltinEncodingClass | OUTER OrderedValueList ::= "{" Value "," + "}" OrderedEncodingObjectList ::= "{" EncodingObject "," + "}" InstanceOfValue ::= Value EncodingClassFieldType ::= DefinedEncodingClass "." FieldName FieldName ::= PrimitiveFieldName "." + PrimitiveFieldName ::= valuefieldreference | valuesetfieldreference | orderedvaluelistfieldreference

ParameterizedAssignment ::= ParameterizedEncodingObjectAssignment | ParameterizedEncodingClassAssignment | ParameterizedEncodingObjectSetAssignment ParameterizedEncodingObjectAssignment ::= encodingobjectreference ParameterList DefinedOrBuiltinEncodingClass "::=" EncodingObject ParameterizedEncodingClassAssignment ::= encodingclassreference ParameterList "::=" EncodingClass ParameterizedEncodingObjectSetAssignment ::= encodingobjectsetreference ParameterList #ENCODINGS "::=" EncodingObjectSet ParameterList ::= "{<" Parameter "," + ">}" Parameter ::= ParamGovernor ":" DummyReference | DummyReference ParamGovernor ::= Governor Governor ::= EncodingClassFieldType | REFERENCE | DefinedOrBuiltinEncodingClass | #ENCODINGS | Type

DummyReference ::= encodingclassreference | valuereference | typereferenc | identifier | encodingobjectreference | encodingobjectsetreference ParameterizedReference ::= Reference | Reference "{<" ">}" ParameterizedEncodingObject ::= SimpleDefinedEncodingObject ActualParameterList SimpleDefinedEncodingObject ::= ExternalEncodingObjectReference | encodingobjectreference ParameterizedEncodingObjectSet ::= SimpleDefinedEncodingObjectSet ActualParameterList SimpleDefinedEncodingObjectSet ::= ExternalEncodingObjectSetReference | encodingobjectsetreference ParameterizedEncodingClass ::= SimpleDefinedEncodingClass

ActualParameterList SimpleDefinedEncodingClass ::= ExternalEncodingClassReference | encodingclassreference ActualParameterList ::= "{<"ActualParameter "," + ">}" ActualParameter ::= Value | ValueSet | OrderedValueList | DefinedOrBuiltinEncodingClass | EncodingObject | EncodingObjectSet | OrderedEncodingObjectList | identifier | STRUCTURE | OU

Обозначение ссылочного международного стандарта	Степень соответствия	Обозначение и наименование соответствующего национального стандарта
ISO/IEC 9834-1:12005	IDT	ГОСТ Р ИСО/МЭК 9834-1-2009 "Информационная технология. Взаимосвязь открытых систем. Процедуры действий уполномоченных по регистрации ВОС. Часть 1. Общие процедуры и верхние дуги дерева идентификатора объекта АСН.1"
ISO/IEC 8824-1:2008	-	<*>
ISO/IEC 8824-2:2008	-	<*>
ISO/IEC 8824-3:2008	-	<*>
ISO/IEC 8824-4:2008	-	<*>
ISO/IEC 8825-1:2008	-	<*>
ISO/IEC 8825-2:2008	-	<*>
ISO/IEC 10646:2003	-	<*>
<*> Соответствующий национальный стандарт отсутствует. Примечание - В настоящей таблице использовано следующее условное обозначение степени соответствия стандарта: - IDT - идентичный стандарт.