-- EDM module extracted from ITU-T X.692 (11/2008)

Example1-EDM {joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) edm-module1(3)}
ENCODING-DEFINITIONS ::=
BEGIN

EXPORTS Example1Encodings;

IMPORTS #Married1, #Married2, #Married3, #Altitude, #EvenPositiveInteger, 
	#EvenNegativeInteger, 
        #IntegerWithHole, #PositiveInteger, #NegativeInteger, 
	#PositiveIntegerBCD, #Fax,
        #BinaryFile, #Password, #CharacterStringToBit, #Sequence1, #Choice1,#Choice2,
	#Sequence2, #Sequence3
        FROM Example1-ASN1-Module 
	{ joint-iso-itu-t(2) asn1(1) ecn(4) examples(5) asn1-module1(2) };

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

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

marriedEncoding-1 #Married1 ::= booleanEncoding

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

marriedEncoding-3 #Married3 ::= {
	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
                -- Note: -1 / 2 = 0 - see clause 24.3.7 -- }}
	WITH PER-BASIC-UNALIGNED}

#NonPositiveInt ::= #INT(MIN..0)

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

integerWithHoleEncoding #IntegerWithHole ::= {
	USE #IntFrom0To1280
	MAPPING ORDERED VALUES
	WITH PER-BASIC-UNALIGNED}

#IntFrom0To1280 ::= #INT (0..1280)

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

positiveIntegerBCDEncoding #PositiveIntegerBCD ::= {
	USE #CHARS
	MAPPING TRANSFORMS{{
        INT-TO-CHARS
		-- We convert to characters (e.g., integer 42
		-- becomes character string "42") and encode the characters
		-- with the encoding object "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
	-- We convert each character to a bitstring
	--(e.g., character "4" becomes '0100'B and "2" becomes '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
	-- We determine the concatenation of the bitstrings for the
	-- characters and add a terminator (e.g.,
	-- '0100'B + '0010'B becomes '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}}

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

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

#IntFrom0To2 ::= #INT (0..2)

sequence1Encoding #Sequence1 ::= {
	ENCODE STRUCTURE {
	b USE-SET OPTIONAL-ENCODING parameterizedPresenceEncoding {< a >},
	c binaryFileEncoding
	-- "binaryFileEncoding" is defined in D.1.8.2 -- }
        	WITH PER-BASIC-UNALIGNED}

parameterizedPresenceEncoding {< REFERENCE:reference >}  #OPTIONAL ::= {
	PRESENCE
	DETERMINED BY field-to-be-used
	USING reference}

choice1Encoding	#Choice1 ::= {
	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

choice2Encoding	#Choice2 ::= {
	ENCODE STRUCTURE {
	STRUCTURED WITH {
		ALTERNATIVE
			DETERMINED BY handle
				HANDLE "Tag"}}
	WITH MyEncodings}

sequence2Encoding #Sequence2 ::= {
	ENCODE STRUCTURE {
	b 	{ REPETITION-ENCODING {
		REPETITION-SPACE
			SIZE 8
			MULTIPLE OF bit}
	CONTENTS-ENCODING {sequence3Encoding}}}
	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
	}

END