Start development on 386BSD 0.0

[unix-history] / .ref-BSD-4_3_Net_2 / usr / src / contrib / isode / pepsy / t1.py

T1 { joint-iso-ccitt rubbish(999) modid(1) } DEFINITIONS ::=


BEGIN

IMPORTS
	+ Info,
	+ Sset,
	+ Sseq,
	- Sany,
	+ Soid
		FROM T2
	Pepy-refs,
	Single-type,
	Repeated,
	Defined,
	CodeTest,
	AllSimples,
	UAction
		FROM T3;

-- Embedded Sequences test


    -- Test of Embedded Strings
Emb-Strings ::= SEQUENCE {
	atest INTEGER,
	btest OCTET STRING,
	ctest BIT STRING,
	big-test Strings,
	emb-test SEQUENCE {
	    em-int INTEGER,
	    em-oct OCTET STRING,
	    em-bit BIT STRING
	}
    }


Strings ::= SEQUENCE { -- Test Octet strings, bit strings and character
		       -- Strings in general
	ostring OCTET STRING,
	bstring BIT STRING,
	nstring NumericString,
	pstring PrintableString,
	tstring TeletexString,
	t61string T61String,
	vstring	VideotexString,
	vis-string VisibleString,
	i646string ISO646String,
	ia5string IA5String,
	graphstring GraphicString,
	genstring GeneralString
	}

Embedded ::= SEQUENCE {
	anMPDU MPDU,
	ei INTEGER
	}

MPDU ::=
	SEQUENCE {
	    a-seq SEQUENCE {
		fred [0] IMPLICIT INTEGER,

		    george BOOLEAN
	    }
	}

ServiceMPDU ::=
	SET {
	    a-set SET {
		    a-data [1] IMPLICIT BIT STRING,

		a-more-data [2] IMPLICIT INTEGER
	    },
	    b-set SET {
		    b-data [1] IMPLICIT BIT STRING,

		b-more-data [2] IMPLICIT INTEGER
	    }
	}
-- Implicit tags

Impl-Tags ::= SEQUENCE {
	i-impl [1] IMPLICIT INTEGER,
	o-impl [2] IMPLICIT OCTET STRING,
	b-impl [3] IMPLICIT BIT STRING,
	f-impl [4] IMPLICIT BOOLEAN,
	obj-impl [5] IMPLICIT Emb-Strings,

    -- Test of Embedded Strings
	i-emb-test [APPLICATION 88] IMPLICIT SEQUENCE {
	    i-em-int INTEGER,
	    i-em-oct OCTET STRING,
	    i-em-bit BIT STRING
	}
    }

-- Explicit tags

Expl-Tags ::= SEQUENCE {
	i-expl [1] INTEGER,
	o-expl [2] OCTET STRING,
	b-expl [3] BIT STRING,
	f-expl [4] BOOLEAN,
	obj-expl [5] Emb-Strings,

    -- Test of Embedded Strings
	i-exp-test [APPLICATION 88] SEQUENCE {
	    i-ex-int INTEGER,
	    i-ex-oct OCTET STRING,
	    i-ex-bit BIT STRING
	}
    }

  -- Test of Sequence of
Seqof-Test ::= SEQUENCE {
	sqof-test1 SEQUENCE OF Expl-Tags,
	stof-test1 SET OF Expl-Tags,
	i-test1 INTEGER,
	sqof-test2 SEQUENCE OF SEQUENCE {
	    sqof-in Expl-Tags,
	    sqof-i INTEGER,
	    sqof-o OCTET STRING
	},
	stof-test2 SET OF SEQUENCE {
	    stof-in Expl-Tags,
	    stof-i INTEGER,
	    stof-o OCTET STRING
	},
	i-test2 INTEGER
    }


   -- Test data for the Choice type
Choice-Test ::= SET {
	c1 CHOICE {
	i-c1 [1] IMPLICIT INTEGER,
	o-c1 [2] IMPLICIT OCTET STRING,
	b-c1 [3] IMPLICIT BIT STRING,
	f-c1 [4] IMPLICIT BOOLEAN,
	obj-c1 [5] IMPLICIT Emb-Strings
	},
	c2 CHOICE {
	i-c2 [6] INTEGER,
	o-c2 [7] OCTET STRING,
	b-c2 [8] BIT STRING,
	f-c2 [9] BOOLEAN,
	obj-c2 [10] Emb-Strings
	},
	c3 CHOICE {
	    seq-c3 SEQUENCE {
		seq-c3-in Expl-Tags,
		seq-c3-i INTEGER,
		seq-c3-o OCTET STRING
	    },
	    set-c3 SET {
		set-c3-in Expl-Tags,
		set-c3-i INTEGER,
		set-c3-o OCTET STRING
	    },
	    i-c3 INTEGER
	},
	c4 [12] IMPLICIT SEQUENCE {
	    c4-choice CHOICE {
		c4-i INTEGER,
		c4-obj [2] IMPLICIT Expl-Tags,
		c4-subch CHOICE {
		    sc-a-i [0] IMPLICIT INTEGER,
		    sc-b-i [1] IMPLICIT INTEGER
		}
	    }
	}


    }

  -- Test of Optional fields

Opt-Strings ::= SEQUENCE {
	a-opt INTEGER OPTIONAL,
	b-opt OCTET STRING,
	c-opt BIT STRING OPTIONAL,
	d-opt BOOLEAN OPTIONAL,
	e-opt NULL OPTIONAL,
	big-opt Strings OPTIONAL,
	emb-opt SEQUENCE {
	    oem-int INTEGER OPTIONAL,
	    oem-oct OCTET STRING OPTIONAL,
	    oem-bit BIT STRING OPTIONAL
	}	OPTIONAL,
	st-opt SET {
	    st-int0 [0] IMPLICIT INTEGER OPTIONAL,
	    st-int1 [1] IMPLICIT INTEGER OPTIONAL,
	    st-int2 [2] IMPLICIT INTEGER OPTIONAL
	}	OPTIONAL,
	obj-opt [APPLICATION 1] IMPLICIT  MPDU OPTIONAL,
	etag-opt [APPLICATION 2] INTEGER OPTIONAL,
	ch-opt CHOICE {
	    ch-1 [10] IMPLICIT INTEGER,
	    ch-2 [20] IMPLICIT INTEGER
	} OPTIONAL
    }

  -- Test of Default fields

Def-Strings ::= SEQUENCE {
	a-def INTEGER  { a-def-0 (0), a-def-1(1) } DEFAULT a-def-0,
	-- posy bug does not allow handling of 'xxx'b or 'xx'h notation
	-- so we don't use proper posy notation
	-- b-def OCTET STRING DEFAULT 'ff01ab20'h,
	b-def PrintableString   DEFAULT "hello, world",
	c-def BIT STRING  { c-def-one(3), c-def-two (1)}
		DEFAULT { c-def-one },
	okay BOOLEAN DEFAULT TRUE,
	e-def NULL DEFAULT NULL,
	big-def Strings,
	emb-def SEQUENCE {
	    colour INTEGER { red(1), green(2), yellow(3) } DEFAULT green,
	    oem-oct OCTET STRING OPTIONAL,
	    version BIT STRING { basic(0), patch1(1), patch2(2) }
		DEFAULT { basic }
	}    DEFAULT { red, { basic } },
	st-def SET {
	    wine [0] IMPLICIT INTEGER { claret(1), burgundy(2), moselle(3) }
		DEFAULT claret,
	    beer [1] IMPLICIT INTEGER { vb(0), fosters(1), hieneken(2) }
		DEFAULT vb,
	    spirit [2] IMPLICIT INTEGER { brandy(0), vodka(1), wisky(2) }
		DEFAULT vodka
	}	DEFAULT { vb, vodka }
    }

-- External References
--
E-ref	::= SEQUENCE {
    a-ref T2.Info,
    b-ref [APPLICATION 33] IMPLICIT T2.Info,
    c-ref [1] T1.Choice-Test,
    d-ref [2] T2.Info OPTIONAL,
    e-ref [APPLICATION 33] IMPLICIT T2.Info OPTIONAL
    }


-- Simple type optimisations of POSY/PEPY

 Bstring ::= [APPLICATION 8] BIT STRING

 Ostring ::= [31] IMPLICIT OCTET STRING

 Obj ::= [101] IMPLICIT MPDU

 Sset ::= SET

 Sseq ::= SEQUENCE

 Sany ::= ANY

 Soid ::= OBJECT IDENTIFIER


Optimised ::= SEQUENCE {
    o1 Bstring,
    o2 Ostring,
    o3 Obj,
    o4 [APPLICATION 3] IMPLICIT Sset OPTIONAL,
    [APPLICATION 21] SET {
	o5 [PRIVATE 9] IMPLICIT Sseq,
	o6 [PRIVATE 33] IMPLICIT Sany,
	o7 [PRIVATE 8] IMPLICIT Soid
    }
}

-- Use of External Simple types
Ext-Opt ::= SEQUENCE {
    o1 T2.Bstring,
    o2 T2.Ostring,
    o3 T2.Obj,
    o4 [PRIVATE 38] IMPLICIT T2.Sset OPTIONAL,
    [APPLICATION 21] SET {
	o5 [PRIVATE 1] IMPLICIT T2.Sseq,
	o6 [PRIVATE 2] IMPLICIT T2.Sany,
	o7 [PRIVATE 3] IMPLICIT T2.Soid
    }
}

-- External type and ANY usage

Ext-typ ::= SEQUENCE {
     ext EXTERNAL,
     a-ny	[APPLICATION 32] ANY,
     ext-impl	[PRIVATE 6] IMPLICIT EXTERNAL,
     any-impl	[APPLICATION 7] ANY,
     ext-expl	[PRIVATE 9] EXTERNAL,
     any-expl	[APPLICATION 10] ANY
   }

SExt ::= [PRIVATE 99] IMPLICIT EXTERNAL

-- check of posy's %[ name $ head %] stuff
Names ::=
	SEQUENCE {
	    SEQUENCE %[ seq_str $ ptr %] {
		fred [0] IMPLICIT INTEGER
	    }
	}

-- Test explicit tags as the first field of an object
Etags ::=
	[APPLICATION 3]
	   CHOICE {
		aE [0] IMPLICIT INTEGER,
		bE [1] IMPLICIT INTEGER
	    }

Stest ::=
    [APPLICATION 4] SET {
	    st1 Sint DEFAULT 33,
	    st2 Soctet DEFAULT "goodbye, world"
	}

Sint ::= INTEGER

Soctet ::= OCTET STRING

Simpl-test ::= SEQUENCE { si-t [23] IMPLICIT Sbstring }

Sbstring ::= BIT STRING { bit0(0), bit1(1), bit2(2) }

SStest ::= [101] IMPLICIT Simpl-test

Enum-type ::= ENUMERATED { pork(0), beef(1), chicken(3), lamb(-1) }

T-enum ::= SEQUENCE {
		ae1 Enum-type,
		ae2 [12] Enum-type,
		ae3 [13] IMPLICIT Enum-type,
		ae4 [15] IMPLICIT Enum-type DEFAULT chicken,
		ae5 Enum-type OPTIONAL
	    }
Real ::= REAL

T-real ::= SEQUENCE {
		r1 Real,
		r2 [99] Real,
		r3 [101] IMPLICIT Real,
		r4 [501] IMPLICIT Real DEFAULT { 31415962, 10, -7 },
		r5 Real OPTIONAL
	    }

T-pepy ::= T3.Pepy-refs

T3-Single ::= T3.Single-type

T3-Repeat ::= T3.Repeated

T3-Defined ::= T3.Defined

T3-CodeTest ::= T3.CodeTest

T3-AllSimples ::= T3.AllSimples

T3-UAction ::= T3.UAction

END