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


T3 DEFINITIONS ::=

%{
/*
 * this stuff is to test the verbatim actions at the start of the 
 * type definitions
 */
%}

BEGIN


Pepy-refs [[ P struct pepy_refs * ]] ::= SEQUENCE {
    [1] IMPLICIT INTEGER [[ i parm->t_int ]],
    [2] IMPLICIT ENUMERATED [[ i parm->t_enum ]] {
	orange(1), apple(2), pear(3), bannana(4) },

    [3] IMPLICIT OCTET STRING [[ q parm->t_qbuf ]],
    [4] IMPLICIT OCTET STRING [[ s parm->t_string ]],
    [5] IMPLICIT OCTET STRING [[ o parm->t_ostring $ parm->t_olen ]],
    [6] IMPLICIT BIT STRING [[ t parm->t_pe ]],
    [7] IMPLICIT BIT STRING [[ x parm->t_bstring $ t_blen ]],
    [8] IMPLICIT BOOLEAN [[ b parm->t_bool ]],
    [9] IMPLICIT OBJECT IDENTIFIER [[ O parm->t_oid ]],
    [10] IMPLICIT REAL [[ r parm->t_real ]],
    [11] ANY [[ a parm->t_any ]],
    [12] Def-types [[ p parm->t_def ]],
    [13] Opt-types [[ p parm->t_opt ]] OPTIONAL

    }

-- Optional and Default test cases

Def-types [[ P struct pepy_refs1 * ]] ::= SEQUENCE {
    [1] INTEGER [[ i parm->t_int ]] DEFAULT 2,
    [2] IMPLICIT INTEGER [[ i parm->t_int1 ]] DEFAULT 2,
    [3] IMPLICIT ENUMERATED [[ i parm->t_enum ]]
	{ orange(1), apple(2), pear(3), bannana(4) } DEFAULT pear,

    [4] ENUMERATED [[ i parm->t_enum1 ]] {
	orange(1), apple(2), pear(3), bannana(4) } DEFAULT pear,
    [5] IMPLICIT OCTET STRING [[ q parm->t_qbuf ]]
			DEFAULT '536f6d65206973206f757420746865726521'H,
    [6] OCTET STRING [[ q parm->t_qbuf1 ]]
			DEFAULT '536f6d65206973206f757420746865726521'H,
    [7] IMPLICIT OCTET STRING [[ s parm->t_string ]] DEFAULT '003132'h,
    [8] OCTET STRING [[ s parm->t_string1 ]] DEFAULT '003132'h,
    [9] IMPLICIT OCTET STRING [[ o parm->t_ostring $ parm->t_olen ]]
			DEFAULT 'ff01ab20'h,
    [10] OCTET STRING [[ o parm->t_ostring1 $ parm->t_olen1 ]]
			DEFAULT 'ff01ab20'h,
    [11] IMPLICIT BIT STRING [[ t parm->t_pe ]]
	DEFAULT '00010010001100010001101000110111001010101'B,
    [12] BIT STRING [[ t parm->t_pe1 ]]
	DEFAULT '00010010001100010001101000110111001010101'B,
    [13] IMPLICIT BIT STRING [[ x parm->t_bstring $ t_blen ]]
	DEFAULT '00000000001100010011001000110011'B,
    [14] BIT STRING [[ x parm->t_bstring1 $ t_blen1 ]]
	DEFAULT '00000000001100010011001000110011'B,
    [15] IMPLICIT BOOLEAN [[ b parm->t_bool ]] DEFAULT TRUE,
    [16] BOOLEAN [[ b parm->t_bool ]] DEFAULT TRUE,
    [17] IMPLICIT OBJECT IDENTIFIER [[ O parm->t_oid ]], -- one day  DEFAULT 1.17.42,
    [18] OBJECT IDENTIFIER [[ O parm->t_oid1 ]] OPTIONAL, -- one day  DEFAULT 1.17.42,
    [19] IMPLICIT REAL [[ r parm->t_real ]] DEFAULT { 306998, 10, -5 },
    [20] REAL [[ r parm->t_real1 ]] DEFAULT { 306998, 10, -5 },
    [21] ANY [[ a parm->t_any ]] OPTIONAL

    }

Opt-types [[ P struct pepy_refs1 * ]] ::= SEQUENCE {
    [1] IMPLICIT INTEGER [[ i parm->t_int ]] OPTIONAL << opt_set $ OPT_INT1 >>,
    [2] INTEGER [[ i parm->t_int1 ]] OPTIONAL << opt_set $ OPT_INT2 >>,
    [3] IMPLICIT ENUMERATED [[ i parm->t_enum ]] {
	orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM1 >>,
    [4] ENUMERATED [[ i parm->t_enum1 ]] {
	orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM2 >>,

    [5] IMPLICIT OCTET STRING [[ q parm->t_qbuf ]] OPTIONAL,
    [6] OCTET STRING [[ q parm->t_qbuf1 ]] OPTIONAL,
    [7] IMPLICIT OCTET STRING [[ s parm->t_string ]] OPTIONAL,
    [8] OCTET STRING [[ s parm->t_string1 ]] OPTIONAL,
    [9] IMPLICIT OCTET STRING [[ o parm->t_ostring $ parm->t_olen ]]
			OPTIONAL,
    [10] OCTET STRING [[ o parm->t_ostring1 $ parm->t_olen1 ]]
			OPTIONAL,
    [11] IMPLICIT BIT STRING [[ t parm->t_pe ]] OPTIONAL,
    [12] BIT STRING [[ t parm->t_pe1 ]] OPTIONAL,
    [13] IMPLICIT BIT STRING [[ x parm->t_bstring $ t_blen ]] OPTIONAL,
    [14] BIT STRING [[ x parm->t_bstring1 $ t_blen1 ]] OPTIONAL,
    [15] IMPLICIT BOOLEAN [[ b parm->t_bool ]] OPTIONAL << opt_set $ OPT_BOOL1>>,
    [16] BOOLEAN [[ b parm->t_bool1 ]] OPTIONAL << opt_set $ OPT_BOOL2>>,
    [17] IMPLICIT OBJECT IDENTIFIER [[ O parm->t_oid ]], -- one day  OPTIONAL,
    [18] IMPLICIT REAL [[ r parm->t_real ]] OPTIONAL << opt_set $ OPT_REAL1 >>,
    [19] REAL [[ r parm->t_real1 ]] OPTIONAL << opt_set $ OPT_REAL2 >>,
    [20] ANY [[ a parm->t_any ]]

    }

    Single-type [[ P struct pepy_refs1 * ]] ::= SEQUENCE {
	a SEQUENCE [[ T struct pepy_refs1 * $ * ]] {
		[1] IMPLICIT INTEGER [[ i parm->t_int ]] OPTIONAL << opt_set $ OPT_INT1 >>
	    },
	b SEQUENCE [[ T struct pepy_refs1 * $ * ]] {
		[2] INTEGER [[ i parm->t_int1 ]] OPTIONAL << opt_set $ OPT_INT2 >>
	    },

	c SET [[ T struct pepy_refs1 * $ *parm ]] {
	    [3] IMPLICIT ENUMERATED [[ i parm->t_enum ]] {
orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM1 >>
	},
	d SET [[ T struct pepy_refs1 *  $ *parm ]] {
	    [4] ENUMERATED [[ i parm->t_enum1 ]] {
orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM2 >>
	}
    }

    Repeated [[ P struct repeats * ]]::= SEQUENCE {
	a SEQUENCE OF [[ T struct rep_int * $ rp_sq1 ]]
	    <<r>> [1] INTEGER [[ i i ]],

	b SEQUENCE OF [[ T struct rep_elem * $ rp_sq2 ]] <<r_next>>
		Rep-elem [[ p * ]],

	c SET OF [[ T struct rep_int * $ rp_st1 ]] <<r>> INTEGER [[ i i ]],

	d SET OF [[ T struct rep_elem * $ rp_st2 ]] <<r_next>>
		[3] IMPLICIT Rep-elem [[ p * ]],

	e CHOICE [[ T struct repeats  * $ * ]] <<rp_choice>> {
		[1] INTEGER [[ i rp_int ]],
		[2] BOOLEAN [[ b rp_bool ]],
		[3] OCTET STRING [[ o rp_ostring $ rp_int ]]
	    }
	}

    Rep-elem [[ P struct rep_elem * ]]
	::= SEQUENCE {
	    a INTEGER [[ i r_int ]],
	    b OCTET STRING [[ s r_ostring ]],
	    c BIT STRING [[ x r_bstring $ r_int ]]
	}

    Defined [[ P struct pepy_refs * ]] ::= 
	SEQUENCE {
	a PrintableString [[ s t_string ]],
	b [ APPLICATION 3 ] AString [[ q t_qbuf ]],
	c [ APPLICATION 3 ] IMPLICIT AnOctetString [[ o t_ostring $ t_olen ]],
	d BitsAndPieces [[ x t_bstring $ t_blen ]],
	e AnAny [[ a t_any ]],
	ABitString [[ t t_pe ]],
	AnotherType [[ i t_int ]],
	[12] AReal [[ r t_real ]],
	[99] IMPLICIT AnOID [[ O t_oid ]],
	[13] IMPLICIT Boodles [[ b t_bool ]],
	AnEnumerated [[ i t_enum ]]
	}

    AString ::= GraphicString

    AnOctetString ::= OCTET STRING

    BitsAndPieces ::= [31] SomeBits

    SomeBits ::= [APPLICATION 10] IMPLICIT ABitString

    ABitString ::= BIT STRING

    AnAny ::= ANY

    AnotherType ::= [21] AnInteger

    AnInteger ::= INTEGER

    AReal ::= REAL

    AnOID ::= OBJECT IDENTIFIER

    Boodles ::= [PRIVATE 9] ABoolean

    ABoolean ::= [APPLICATION 12] BOOLEAN

    AnEnumerated ::= [4] ENUMERATED { orange(1), apple(2), pear(3), bannana(4) } 
    -- Coding functions tests

    CodeTest [[ P struct codedata * ]] ::= SEQUENCE {
	a BasicANY [[ p cd_a ]],
	b [42] E-ANY [[ p cd_b ]],
	c [36] D-ANY [[ p cd_c ]],
	d DE-ANY [[ p cd_d ]],
	e [APPLICATION 44] IMPLICIT INTEGER [[ i cd_int ]]
	    [[ E get_int ]] [[ D put_int ]] DEFAULT 1,
	f [17] GraphicString [[ s cd_string ]]
	    [[ E get_string ]][[ D put_string ]] [[ F fr_string ]] OPTIONAL,
	left CodeOpt [[ p cd_left ]] OPTIONAL,
	right CodeDflt [[ p cd_right ]] OPTIONAL
    }

   BasicANY ::= ANY [[ a * ]] 

   E-ANY ::= ANY [[ a * ]] [[ E get_pe ]]

   D-ANY ::= ANY [[ a * ]]  [[ D put_pe ]] [[ F fr_pe ]]

   DE-ANY ::= ANY [[ a * ]]  [[ D put_pe ]] [[ E get_pe ]]

    CodeOpt [[ P struct codedata * ]] ::= SEQUENCE {
	a [PRIVATE 5] BasicANY [[ p cd_a ]] OPTIONAL,
	b [35] E-ANY [[ p cd_b ]] OPTIONAL,
	c [45] EXPLICIT D-ANY [[ p cd_c ]] OPTIONAL <<cd_opt_set $ CD_C>>,
	d [1] DE-ANY [[ p cd_d ]] OPTIONAL <<cd_opt_set $ CD_D>>,
	e [15] IMPLICIT INTEGER [[ i cd_int ]] [[ E get_int ]] [[ D put_int ]]
		OPTIONAL << cd_opt_set $ CD_INT >>,
	f GraphicString [[ s cd_string ]] [[ E get_string ]][[ D put_string ]]
		OPTIONAL
    }

    -- It would be nice to do DEFAULTs for ANY but how do we specify
    -- DEFAULT ANY in the ASN.1 ?? Let alone parse it

    CodeDflt [[ P struct codedata * ]] ::= SEQUENCE {
	a [1] BasicANY [[ p cd_a ]] OPTIONAL,
	b [2] E-ANY [[ p cd_b ]] OPTIONAL,
	c [3] D-ANY [[ p cd_c ]] OPTIONAL <<cd_opt_set $ CD_C>>,
	d [4] DE-ANY [[ p cd_d ]] OPTIONAL <<cd_opt_set $ CD_D>>,
	e [APPLICATION 4] INTEGER [[ i cd_int ]] [[ E get_int ]] [[ D put_int ]]
		DEFAULT 3,
	f [90] IMPLICIT GraphicString [[ s cd_string ]] [[ E get_string2 ]]
	    [[ D put_string2 ]] DEFAULT '536f6d65206973206f7574'H
    }

    Simple1 [[ P struct codedata * ]] ::= CodeDflt [[ p cd_right ]]

    Simple2 [[ P struct codedata * ]] ::= INTEGER [[ i cd_int ]]

    Simple3 [[ P struct codedata * ]] ::= [1] INTEGER [[ i cd_int1 ]]

    Simple4 [[ P struct codedata * ]] ::= [1] IMPLICIT INTEGER [[ i cd_int2 ]]

    Simple5 [[ P struct codedata * ]] ::= OCTET STRING [[ s cd_string ]]

    Simple6 [[ P struct codedata * ]] ::= [1] OCTET STRING [[ s cd_string1 ]]

    Simple7 [[ P struct codedata * ]] ::= [1] IMPLICIT OCTET STRING
						[[ s cd_string2 ]]

    Simple8 [[ P struct codedata * ]] ::= OBJECT IDENTIFIER [[ O cd_oid ]]

    Simple9 [[ P struct codedata * ]] ::= [1] OBJECT IDENTIFIER [[ O cd_oid1 ]]

    Simple10 [[ P struct codedata * ]] ::= [1] IMPLICIT OBJECT IDENTIFIER
						[[ O cd_oid2 ]]

    Simple11 [[ P struct codedata * ]] ::= ANY [[ a cd_a ]]

    Simple12 [[ P struct codedata * ]] ::= BIT STRING [[ t cd_bit ]]

    Simple13 [[ P struct codedata * ]] ::= REAL [[ r cd_real ]]

    Simple14 [[ P struct codedata * ]] ::= BOOLEAN [[ b cd_bool ]]

    AllSimples [[ P struct codedata * ]] ::= SEQUENCE {

	a Simple1 [[ p * ]],
	b Simple2 [[ p * ]],
	c Simple3 [[ p * ]],
	d Simple4 [[ p * ]],
	e Simple5 [[ p * ]],
	f Simple6 [[ p * ]],
	g Simple7 [[ p * ]],
	h Simple8 [[ p * ]],
	i Simple9 [[ p * ]],
	j Simple10 [[ p * ]],
	k Simple11 [[ p * ]],
	l Simple12 [[ p * ]],
	m Simple13 [[ p * ]],
	n Simple14 [[ p * ]]

    }

    UAction [[ P struct repeats * ]]::= SEQUENCE {
	a SEQUENCE OF [[ T struct rep_int * $ rp_sq1 ]]
	    <<r>> [1] INTEGER [[ i i ]],

	b SEQUENCE OF [[ T struct rep_elem * $ rp_sq2 ]] <<r_next>>
		Rep-action [[ p * ]],

	c SET OF [[ T struct rep_int * $ rp_st1 ]] <<r>> INTEGER [[ i i ]],

	d SET OF [[ T struct rep_elem * $ rp_st2 ]] <<r_next>>
		%E{ (void) printf("encoding SET OF Rep-action\n");%}
		[3] IMPLICIT Rep-action [[ p * ]],

	e CHOICE [[ T struct repeats  * $ * ]] <<rp_choice>> {
	    %D{ (void) printf("Before Encoding CHOICE\n"); %}
		[1] INTEGER [[ i rp_int ]],
		[2]
		%E{ (void) printf("encoding Boolean %d\n", parm->rp_bool);%}
		BOOLEAN [[ b rp_bool ]]
		%D{ (void) printf("Decoding Boolean\n"); %},
		[3] OCTET STRING [[ o rp_ostring $ rp_int ]]
	    }
	%D{ (void) printf("After Decoding CHOICE: chosen %d\n", (*parm)->rp_choice); %}
	}  %D{ (void) printf("After Decoding UAction\n"); %}

    Rep-action [[ P struct rep_elem * ]]
	::=
		%D{ (void) printf("Before Decoding Rep-action\n"); %}
	SEQUENCE {
		%E{ (void) printf("before encoding INTEGER %d\n", parm->r_int);%}
	    a INTEGER [[ i r_int ]],
		%E{ (void) printf("before encoding OCTET STRING \"%s\"\n",
			    parm->r_ostring);
	    %}
	    b OCTET STRING [[ s r_ostring ]],
		%E{
		    int i;

		    (void) printf("before encoding BIT STRING: ");
		    for (i = 0; i < parm->r_int; i++) {
			if (BITTEST(parm->r_bstring, i))
			    (void) putchar('1');
			else
			    (void) putchar('0');
		    }
		    (void) putchar('\n');

		%}
	    c BIT STRING [[ x r_bstring $ r_int ]]
		%E{
		    (void) printf("After Bitstring encoding:");
		    vunknown(*ppe);
		%}
	}
		%E{
		    (void) printf("After Sequence encoding:\n");
		    vunknown(*ppe);
		%}
		%D{
		    int i;

		    (void) printf("After Decoding Rep-action:\n");
		    (void) printf("rp_int %d\n", (*parm)->r_int);
		    (void) printf("r_ostring \"%s\"\n", (*parm)->r_ostring);
		    (void) printf("r_bstring: ");

		    for (i = 0; i < (*parm)->r_int; i++) {
			if (BITTEST((*parm)->r_bstring, i))
			    (void) putchar('1');
			else
			    (void) putchar('0');
		    }
		    (void) putchar('\n');

		%}

END
%{

/*
 * Encoding function for test examples of the Coding functions in t3.py
 */

get_pe(parm, ppe)
PE	parm;
PE	*ppe;
{
    if (ppe == (PE *)0) {
	if (parm == NULLPE)	/* Optional */
	    return (OK + 1);
	return (OK);
    }

    *ppe = pe_cpy(parm);
    return (OK);
}

put_pe(parm, pe)
PE	*parm;
PE	pe;
{
    *parm = pe_cpy(pe);
    return (OK);
}

get_int(parm, ppe)
struct codedata	*parm;
PE	*ppe;
{
    if (ppe == (PE *)0) {
	if (parm->cd_int == 1)	/* Default case */
	    return (OK + 1);
	return (OK);
    }

    *ppe = int2prim(parm->cd_int);
    return (OK);
}

put_int(parm, pe)
struct codedata	**parm;
PE	pe;
{
    if (pe)
	(*parm)->cd_int = prim2num(pe);
    else
	(*parm)->cd_int = 1;	/* Default */
    return (OK);
}

get_string(parm, ppe)
struct codedata	*parm;
PE	*ppe;
{
    if (ppe == (PE *)0) {
	if (parm->cd_string == NULLCP) /* Not present */
	    return (OK + 1);
	return (OK);
    }

    *ppe = str2prim(parm->cd_string, strlen(parm->cd_string), 0, 0);
    return (OK);
}

put_string(parm, pe)
struct codedata	**parm;
PE	pe;
{
    int	len;

    if (pe)
	(*parm)->cd_string = prim2str(pe, &len);
    else
	(*parm)->cd_string = NULLCP;	/* Default */

    return (OK);
}
get_string2(parm, ppe)
struct codedata	*parm;
PE	*ppe;
{
    if (ppe == (PE *)0) {
	if (parm->cd_string == NULLCP
	 || strcmp(parm->cd_string, "Some is out") == 0)/* Not present */
	    return (OK + 1);
	return (OK);
    }

    *ppe = str2prim(parm->cd_string, strlen(parm->cd_string), 0, 0);
    return (OK);
}

put_string2(parm, pe)
struct codedata	**parm;
PE	pe;
{
    int	len;

    if (pe)
	(*parm)->cd_string = prim2str(pe, &len);
    else
	(*parm)->cd_string = strdup("Some is out");	/* Default */

    return (OK);
}

fr_string(parm)
struct codedata	*parm;
{
     if (parm->cd_string)
	free(parm->cd_string);

     return (OK);
}

fr_pe(parm)
PE	parm;
{
    if (parm)
	pe_free(parm);

    return (OK);
}

%}
Commit	Line	Data
459ebbd7 C	1
	2	T3 DEFINITIONS ::=
	3
	4	%{
	5	/*
	6	* this stuff is to test the verbatim actions at the start of the
	7	* type definitions
	8	*/
	9	%}
	10
	11	BEGIN
	12
	13
	14
	15	Pepy-refs [[ P struct pepy_refs * ]] ::= SEQUENCE {
	16	[1] IMPLICIT INTEGER [[ i parm->t_int ]],
	17	[2] IMPLICIT ENUMERATED [[ i parm->t_enum ]] {
	18	orange(1), apple(2), pear(3), bannana(4) },
	19
	20	[3] IMPLICIT OCTET STRING [[ q parm->t_qbuf ]],
	21	[4] IMPLICIT OCTET STRING [[ s parm->t_string ]],
	22	[5] IMPLICIT OCTET STRING [[ o parm->t_ostring $ parm->t_olen ]],
	23	[6] IMPLICIT BIT STRING [[ t parm->t_pe ]],
	24	[7] IMPLICIT BIT STRING [[ x parm->t_bstring $ t_blen ]],
	25	[8] IMPLICIT BOOLEAN [[ b parm->t_bool ]],
	26	[9] IMPLICIT OBJECT IDENTIFIER [[ O parm->t_oid ]],
	27	[10] IMPLICIT REAL [[ r parm->t_real ]],
	28	[11] ANY [[ a parm->t_any ]],
	29	[12] Def-types [[ p parm->t_def ]],
	30	[13] Opt-types [[ p parm->t_opt ]] OPTIONAL
	31
	32	}
	33
	34	-- Optional and Default test cases
	35
	36	Def-types [[ P struct pepy_refs1 * ]] ::= SEQUENCE {
	37	[1] INTEGER [[ i parm->t_int ]] DEFAULT 2,
	38	[2] IMPLICIT INTEGER [[ i parm->t_int1 ]] DEFAULT 2,
	39	[3] IMPLICIT ENUMERATED [[ i parm->t_enum ]]
	40	{ orange(1), apple(2), pear(3), bannana(4) } DEFAULT pear,
	41
	42	[4] ENUMERATED [[ i parm->t_enum1 ]] {
	43	orange(1), apple(2), pear(3), bannana(4) } DEFAULT pear,
	44	[5] IMPLICIT OCTET STRING [[ q parm->t_qbuf ]]
	45	DEFAULT '536f6d65206973206f757420746865726521'H,
	46	[6] OCTET STRING [[ q parm->t_qbuf1 ]]
	47	DEFAULT '536f6d65206973206f757420746865726521'H,
	48	[7] IMPLICIT OCTET STRING [[ s parm->t_string ]] DEFAULT '003132'h,
	49	[8] OCTET STRING [[ s parm->t_string1 ]] DEFAULT '003132'h,
	50	[9] IMPLICIT OCTET STRING [[ o parm->t_ostring $ parm->t_olen ]]
	51	DEFAULT 'ff01ab20'h,
	52	[10] OCTET STRING [[ o parm->t_ostring1 $ parm->t_olen1 ]]
	53	DEFAULT 'ff01ab20'h,
	54	[11] IMPLICIT BIT STRING [[ t parm->t_pe ]]
	55	DEFAULT '00010010001100010001101000110111001010101'B,
	56	[12] BIT STRING [[ t parm->t_pe1 ]]
	57	DEFAULT '00010010001100010001101000110111001010101'B,
	58	[13] IMPLICIT BIT STRING [[ x parm->t_bstring $ t_blen ]]
	59	DEFAULT '00000000001100010011001000110011'B,
	60	[14] BIT STRING [[ x parm->t_bstring1 $ t_blen1 ]]
	61	DEFAULT '00000000001100010011001000110011'B,
	62	[15] IMPLICIT BOOLEAN [[ b parm->t_bool ]] DEFAULT TRUE,
	63	[16] BOOLEAN [[ b parm->t_bool ]] DEFAULT TRUE,
	64	[17] IMPLICIT OBJECT IDENTIFIER [[ O parm->t_oid ]], -- one day DEFAULT 1.17.42,
65	[18] OBJECT IDENTIFIER [[ O parm->t_oid1 ]] OPTIONAL, -- one day DEFAULT 1.17.42,
66	[19] IMPLICIT REAL [[ r parm->t_real ]] DEFAULT { 306998, 10, -5 },
67	[20] REAL [[ r parm->t_real1 ]] DEFAULT { 306998, 10, -5 },
68	[21] ANY [[ a parm->t_any ]] OPTIONAL
69
70	}
71
72	Opt-types [[ P struct pepy_refs1 * ]] ::= SEQUENCE {
73	[1] IMPLICIT INTEGER [[ i parm->t_int ]] OPTIONAL << opt_set $ OPT_INT1 >>,
74	[2] INTEGER [[ i parm->t_int1 ]] OPTIONAL << opt_set $ OPT_INT2 >>,
75	[3] IMPLICIT ENUMERATED [[ i parm->t_enum ]] {
76	orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM1 >>,
77	[4] ENUMERATED [[ i parm->t_enum1 ]] {
78	orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM2 >>,
79
80	[5] IMPLICIT OCTET STRING [[ q parm->t_qbuf ]] OPTIONAL,
81	[6] OCTET STRING [[ q parm->t_qbuf1 ]] OPTIONAL,
82	[7] IMPLICIT OCTET STRING [[ s parm->t_string ]] OPTIONAL,
83	[8] OCTET STRING [[ s parm->t_string1 ]] OPTIONAL,
84	[9] IMPLICIT OCTET STRING [[ o parm->t_ostring $ parm->t_olen ]]
85	OPTIONAL,
86	[10] OCTET STRING [[ o parm->t_ostring1 $ parm->t_olen1 ]]
87	OPTIONAL,
88	[11] IMPLICIT BIT STRING [[ t parm->t_pe ]] OPTIONAL,
89	[12] BIT STRING [[ t parm->t_pe1 ]] OPTIONAL,
90	[13] IMPLICIT BIT STRING [[ x parm->t_bstring $ t_blen ]] OPTIONAL,
91	[14] BIT STRING [[ x parm->t_bstring1 $ t_blen1 ]] OPTIONAL,
92	[15] IMPLICIT BOOLEAN [[ b parm->t_bool ]] OPTIONAL << opt_set $ OPT_BOOL1>>,
93	[16] BOOLEAN [[ b parm->t_bool1 ]] OPTIONAL << opt_set $ OPT_BOOL2>>,
94	[17] IMPLICIT OBJECT IDENTIFIER [[ O parm->t_oid ]], -- one day OPTIONAL,
95	[18] IMPLICIT REAL [[ r parm->t_real ]] OPTIONAL << opt_set $ OPT_REAL1 >>,
96	[19] REAL [[ r parm->t_real1 ]] OPTIONAL << opt_set $ OPT_REAL2 >>,
97	[20] ANY [[ a parm->t_any ]]
98
99	}
100
101	Single-type [[ P struct pepy_refs1 * ]] ::= SEQUENCE {
102	a SEQUENCE [[ T struct pepy_refs1 * $ * ]] {
103	[1] IMPLICIT INTEGER [[ i parm->t_int ]] OPTIONAL << opt_set $ OPT_INT1 >>
104	},
105	b SEQUENCE [[ T struct pepy_refs1 * $ * ]] {
106	[2] INTEGER [[ i parm->t_int1 ]] OPTIONAL << opt_set $ OPT_INT2 >>
107	},
108
109	c SET [[ T struct pepy_refs1 * $ *parm ]] {
110	[3] IMPLICIT ENUMERATED [[ i parm->t_enum ]] {
111	orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM1 >>
112	},
113	d SET [[ T struct pepy_refs1 * $ *parm ]] {
114	[4] ENUMERATED [[ i parm->t_enum1 ]] {
115	orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM2 >>
116	}
117	}
118
119	Repeated [[ P struct repeats * ]]::= SEQUENCE {
120	a SEQUENCE OF [[ T struct rep_int * $ rp_sq1 ]]
121	<<r>> [1] INTEGER [[ i i ]],
122
123	b SEQUENCE OF [[ T struct rep_elem * $ rp_sq2 ]] <<r_next>>
124	Rep-elem [[ p * ]],
125
126	c SET OF [[ T struct rep_int * $ rp_st1 ]] <<r>> INTEGER [[ i i ]],
127
128	d SET OF [[ T struct rep_elem * $ rp_st2 ]] <<r_next>>
129	[3] IMPLICIT Rep-elem [[ p * ]],
130
131	e CHOICE [[ T struct repeats * $ * ]] <<rp_choice>> {
132	[1] INTEGER [[ i rp_int ]],
133	[2] BOOLEAN [[ b rp_bool ]],
134	[3] OCTET STRING [[ o rp_ostring $ rp_int ]]
135	}
136	}
137
138	Rep-elem [[ P struct rep_elem * ]]
139	::= SEQUENCE {
140	a INTEGER [[ i r_int ]],
141	b OCTET STRING [[ s r_ostring ]],
142	c BIT STRING [[ x r_bstring $ r_int ]]
143	}
144
145	Defined [[ P struct pepy_refs * ]] ::=
146	SEQUENCE {
147	a PrintableString [[ s t_string ]],
148	b [ APPLICATION 3 ] AString [[ q t_qbuf ]],
149	c [ APPLICATION 3 ] IMPLICIT AnOctetString [[ o t_ostring $ t_olen ]],
150	d BitsAndPieces [[ x t_bstring $ t_blen ]],
151	e AnAny [[ a t_any ]],
152	ABitString [[ t t_pe ]],
153	AnotherType [[ i t_int ]],
154	[12] AReal [[ r t_real ]],
155	[99] IMPLICIT AnOID [[ O t_oid ]],
156	[13] IMPLICIT Boodles [[ b t_bool ]],
157	AnEnumerated [[ i t_enum ]]
158	}
159
160	AString ::= GraphicString
161
162	AnOctetString ::= OCTET STRING
163
164	BitsAndPieces ::= [31] SomeBits
165
166	SomeBits ::= [APPLICATION 10] IMPLICIT ABitString
167
168	ABitString ::= BIT STRING
169
170	AnAny ::= ANY
171
172	AnotherType ::= [21] AnInteger
173
174	AnInteger ::= INTEGER
175
176	AReal ::= REAL
177
178	AnOID ::= OBJECT IDENTIFIER
179
180	Boodles ::= [PRIVATE 9] ABoolean
181
182	ABoolean ::= [APPLICATION 12] BOOLEAN
183
184	AnEnumerated ::= [4] ENUMERATED { orange(1), apple(2), pear(3), bannana(4) }
185	-- Coding functions tests
186
187	CodeTest [[ P struct codedata * ]] ::= SEQUENCE {
188	a BasicANY [[ p cd_a ]],
189	b [42] E-ANY [[ p cd_b ]],
190	c [36] D-ANY [[ p cd_c ]],
191	d DE-ANY [[ p cd_d ]],
192	e [APPLICATION 44] IMPLICIT INTEGER [[ i cd_int ]]
193	[[ E get_int ]] [[ D put_int ]] DEFAULT 1,
194	f [17] GraphicString [[ s cd_string ]]
195	[[ E get_string ]][[ D put_string ]] [[ F fr_string ]] OPTIONAL,
196	left CodeOpt [[ p cd_left ]] OPTIONAL,
197	right CodeDflt [[ p cd_right ]] OPTIONAL
198	}
199
200	BasicANY ::= ANY [[ a * ]]
201
202	E-ANY ::= ANY [[ a * ]] [[ E get_pe ]]
203
204	D-ANY ::= ANY [[ a * ]] [[ D put_pe ]] [[ F fr_pe ]]
205
206	DE-ANY ::= ANY [[ a * ]] [[ D put_pe ]] [[ E get_pe ]]
207
208	CodeOpt [[ P struct codedata * ]] ::= SEQUENCE {
209	a [PRIVATE 5] BasicANY [[ p cd_a ]] OPTIONAL,
210	b [35] E-ANY [[ p cd_b ]] OPTIONAL,
211	c [45] EXPLICIT D-ANY [[ p cd_c ]] OPTIONAL <<cd_opt_set $ CD_C>>,
212	d [1] DE-ANY [[ p cd_d ]] OPTIONAL <<cd_opt_set $ CD_D>>,
213	e [15] IMPLICIT INTEGER [[ i cd_int ]] [[ E get_int ]] [[ D put_int ]]
214	OPTIONAL << cd_opt_set $ CD_INT >>,
215	f GraphicString [[ s cd_string ]] [[ E get_string ]][[ D put_string ]]
216	OPTIONAL
217	}
218
219	-- It would be nice to do DEFAULTs for ANY but how do we specify
220	-- DEFAULT ANY in the ASN.1 ?? Let alone parse it
221
222	CodeDflt [[ P struct codedata * ]] ::= SEQUENCE {
223	a [1] BasicANY [[ p cd_a ]] OPTIONAL,
224	b [2] E-ANY [[ p cd_b ]] OPTIONAL,
225	c [3] D-ANY [[ p cd_c ]] OPTIONAL <<cd_opt_set $ CD_C>>,
226	d [4] DE-ANY [[ p cd_d ]] OPTIONAL <<cd_opt_set $ CD_D>>,
227	e [APPLICATION 4] INTEGER [[ i cd_int ]] [[ E get_int ]] [[ D put_int ]]
228	DEFAULT 3,
229	f [90] IMPLICIT GraphicString [[ s cd_string ]] [[ E get_string2 ]]
230	[[ D put_string2 ]] DEFAULT '536f6d65206973206f7574'H
231	}
232
233	Simple1 [[ P struct codedata * ]] ::= CodeDflt [[ p cd_right ]]
234
235	Simple2 [[ P struct codedata * ]] ::= INTEGER [[ i cd_int ]]
236
237	Simple3 [[ P struct codedata * ]] ::= [1] INTEGER [[ i cd_int1 ]]
238
239	Simple4 [[ P struct codedata * ]] ::= [1] IMPLICIT INTEGER [[ i cd_int2 ]]
240
241	Simple5 [[ P struct codedata * ]] ::= OCTET STRING [[ s cd_string ]]
242
243	Simple6 [[ P struct codedata * ]] ::= [1] OCTET STRING [[ s cd_string1 ]]
244
245	Simple7 [[ P struct codedata * ]] ::= [1] IMPLICIT OCTET STRING
246	[[ s cd_string2 ]]
247
248	Simple8 [[ P struct codedata * ]] ::= OBJECT IDENTIFIER [[ O cd_oid ]]
249
250	Simple9 [[ P struct codedata * ]] ::= [1] OBJECT IDENTIFIER [[ O cd_oid1 ]]
251
252	Simple10 [[ P struct codedata * ]] ::= [1] IMPLICIT OBJECT IDENTIFIER
253	[[ O cd_oid2 ]]
254
255	Simple11 [[ P struct codedata * ]] ::= ANY [[ a cd_a ]]
256
257	Simple12 [[ P struct codedata * ]] ::= BIT STRING [[ t cd_bit ]]
258
259	Simple13 [[ P struct codedata * ]] ::= REAL [[ r cd_real ]]
260
261	Simple14 [[ P struct codedata * ]] ::= BOOLEAN [[ b cd_bool ]]
262
263	AllSimples [[ P struct codedata * ]] ::= SEQUENCE {
264
265	a Simple1 [[ p * ]],
266	b Simple2 [[ p * ]],
267	c Simple3 [[ p * ]],
268	d Simple4 [[ p * ]],
269	e Simple5 [[ p * ]],
270	f Simple6 [[ p * ]],
271	g Simple7 [[ p * ]],
272	h Simple8 [[ p * ]],
273	i Simple9 [[ p * ]],
274	j Simple10 [[ p * ]],
275	k Simple11 [[ p * ]],
276	l Simple12 [[ p * ]],
277	m Simple13 [[ p * ]],
278	n Simple14 [[ p * ]]
279
280	}
281
282	UAction [[ P struct repeats * ]]::= SEQUENCE {
283	a SEQUENCE OF [[ T struct rep_int * $ rp_sq1 ]]
284	<<r>> [1] INTEGER [[ i i ]],
285
286	b SEQUENCE OF [[ T struct rep_elem * $ rp_sq2 ]] <<r_next>>
287	Rep-action [[ p * ]],
288
289	c SET OF [[ T struct rep_int * $ rp_st1 ]] <<r>> INTEGER [[ i i ]],
290
291	d SET OF [[ T struct rep_elem * $ rp_st2 ]] <<r_next>>
292	%E{ (void) printf("encoding SET OF Rep-action\n");%}
293	[3] IMPLICIT Rep-action [[ p * ]],
294
295	e CHOICE [[ T struct repeats * $ * ]] <<rp_choice>> {
296	%D{ (void) printf("Before Encoding CHOICE\n"); %}
297	[1] INTEGER [[ i rp_int ]],
298	[2]
299	%E{ (void) printf("encoding Boolean %d\n", parm->rp_bool);%}
300	BOOLEAN [[ b rp_bool ]]
301	%D{ (void) printf("Decoding Boolean\n"); %},
302	[3] OCTET STRING [[ o rp_ostring $ rp_int ]]
303	}
304	%D{ (void) printf("After Decoding CHOICE: chosen %d\n", (*parm)->rp_choice); %}
305	} %D{ (void) printf("After Decoding UAction\n"); %}
306
307	Rep-action [[ P struct rep_elem * ]]
308	::=
309	%D{ (void) printf("Before Decoding Rep-action\n"); %}
310	SEQUENCE {
311	%E{ (void) printf("before encoding INTEGER %d\n", parm->r_int);%}
312	a INTEGER [[ i r_int ]],
313	%E{ (void) printf("before encoding OCTET STRING \"%s\"\n",
314	parm->r_ostring);
315	%}
316	b OCTET STRING [[ s r_ostring ]],
317	%E{
318	int i;
319
320	(void) printf("before encoding BIT STRING: ");
321	for (i = 0; i < parm->r_int; i++) {
322	if (BITTEST(parm->r_bstring, i))
323	(void) putchar('1');
324	else
325	(void) putchar('0');
326	}
327	(void) putchar('\n');
328
329	%}
330	c BIT STRING [[ x r_bstring $ r_int ]]
331	%E{
332	(void) printf("After Bitstring encoding:");
333	vunknown(*ppe);
334	%}
335	}
336	%E{
337	(void) printf("After Sequence encoding:\n");
338	vunknown(*ppe);
339	%}
340	%D{
341	int i;
342
343	(void) printf("After Decoding Rep-action:\n");
344	(void) printf("rp_int %d\n", (*parm)->r_int);
345	(void) printf("r_ostring \"%s\"\n", (*parm)->r_ostring);
346	(void) printf("r_bstring: ");
347
348	for (i = 0; i < (*parm)->r_int; i++) {
349	if (BITTEST((*parm)->r_bstring, i))
350	(void) putchar('1');
351	else
352	(void) putchar('0');
353	}
354	(void) putchar('\n');
355
356	%}
357
358	END
359	%{
360
361	/*
362	* Encoding function for test examples of the Coding functions in t3.py
363	*/
364
365	get_pe(parm, ppe)
366	PE parm;
367	PE *ppe;
368	{
369	if (ppe == (PE *)0) {
370	if (parm == NULLPE) /* Optional */
371	return (OK + 1);
372	return (OK);
373	}
374
375	*ppe = pe_cpy(parm);
376	return (OK);
377	}
378
379	put_pe(parm, pe)
380	PE *parm;
381	PE pe;
382	{
383	*parm = pe_cpy(pe);
384	return (OK);
385	}
386
387	get_int(parm, ppe)
388	struct codedata *parm;
389	PE *ppe;
390	{
391	if (ppe == (PE *)0) {
392	if (parm->cd_int == 1) /* Default case */
393	return (OK + 1);
394	return (OK);
395	}
396
397	*ppe = int2prim(parm->cd_int);
398	return (OK);
399	}
400
401	put_int(parm, pe)
402	struct codedata **parm;
403	PE pe;
404	{
405	if (pe)
406	(*parm)->cd_int = prim2num(pe);
407	else
408	(parm)->cd_int = 1; / Default */
409	return (OK);
410	}
411
412	get_string(parm, ppe)
413	struct codedata *parm;
414	PE *ppe;
415	{
416	if (ppe == (PE *)0) {
417	if (parm->cd_string == NULLCP) /* Not present */
418	return (OK + 1);
419	return (OK);
420	}
421
422	*ppe = str2prim(parm->cd_string, strlen(parm->cd_string), 0, 0);
423	return (OK);
424	}
425
426	put_string(parm, pe)
427	struct codedata **parm;
428	PE pe;
429	{
430	int len;
431
432	if (pe)
433	(*parm)->cd_string = prim2str(pe, &len);
434	else
435	(parm)->cd_string = NULLCP; / Default */
436
437	return (OK);
438	}
439	get_string2(parm, ppe)
440	struct codedata *parm;
441	PE *ppe;
442	{
443	if (ppe == (PE *)0) {
444	if (parm->cd_string == NULLCP
445	\|\| strcmp(parm->cd_string, "Some is out") == 0)/* Not present */
446	return (OK + 1);
447	return (OK);
448	}
449
450	*ppe = str2prim(parm->cd_string, strlen(parm->cd_string), 0, 0);
451	return (OK);
452	}
453
454	put_string2(parm, pe)
455	struct codedata **parm;
456	PE pe;
457	{
458	int len;
459
460	if (pe)
461	(*parm)->cd_string = prim2str(pe, &len);
462	else
463	(parm)->cd_string = strdup("Some is out"); / Default */
464
465	return (OK);
466	}
467
468	fr_string(parm)
469	struct codedata *parm;
470	{
471	if (parm->cd_string)
472	free(parm->cd_string);
473
474	return (OK);
475	}
476
477	fr_pe(parm)
478	PE parm;
479	{
480	if (parm)
481	pe_free(parm);
482
483	return (OK);
484	}
485
486	%}
487