305 lines
8.2 KiB
Groff
305 lines
8.2 KiB
Groff
HardcoreSyntax DEFINITIONS AUTOMATIC TAGS ::=
|
|
|
|
BEGIN
|
|
|
|
-- basic object definition
|
|
Nul000 ::= [PRIVATE 1] NULL
|
|
Nul001 ::= [PRIVATE 2] EXPLICIT Nul000 (NULL)
|
|
Bool000 ::= [APPLICATION 3] IMPLICIT BOOLEAN
|
|
Bool001 ::= [APPLICATION 4] EXPLICIT Bool000 (TRUE, ..., FALSE)
|
|
Int000 ::= [5] INTEGER {un(1), deux(2)}
|
|
Int001 ::= [6] Int000 (0..10, ..., 20..100)
|
|
Real000 ::= [7] REAL
|
|
Real001 ::= [8] Real000 (1.2e-10..1e10, ...)
|
|
Real002 ::= [8002] Real000 (1e-100|1e-10|1<..<1e100, ..., 2e-50|3e-50)
|
|
Enum000 ::= [9] ENUMERATED {un, dos, tres}
|
|
Enum001 ::= [10] Enum000 (un | dos)
|
|
BStr000 ::= [11] BIT STRING {one(1), two(2), three(3)} (SIZE(0..256))
|
|
BStr001 ::= [12] BStr000 (SIZE(4)) ('0110'B|'1001'B, ..., '1111'B)
|
|
BStr002 ::= [13] BStr000 (CONTAINING Real000)
|
|
OStr000 ::= [14] OCTET STRING (SIZE(0..16))
|
|
OStr001 ::= [15] OStr000 (CONTAINING Enum001)
|
|
OStr002 ::= [16] OStr000 (CONTAINING BStr002)
|
|
Oid000 ::= [17] OBJECT IDENTIFIER
|
|
Oid001 ::= [18] Oid000 ({0 1 2}|{3 4 5})
|
|
ROid000 ::= [19] RELATIVE-OID
|
|
ROid001 ::= [20] ROid000 ({6 7 8}, ...)
|
|
IA5000 ::= [21] IA5String (SIZE(0..1000))
|
|
IA5001 ::= [22] IA5000 (FROM("a".."z"))
|
|
PStr000 ::= [23] PrintableString ("A"|"B"|"AB"|"O")
|
|
PStr001 ::= [24] PStr000 (SIZE(1))
|
|
GTim000 ::= [25] GeneralizedTime
|
|
GTim001 ::= [26] GTim000 ("2016062512+0200"|"20160625124539.5290")
|
|
UTim000 ::= [27] UTCTime
|
|
UTim001 ::= [28] UTim000 ("1606251200Z"|"160625123055-0230", ...)
|
|
SqOf000 ::= [29] SEQUENCE SIZE (1..10) OF Bool001
|
|
SqOf001 ::= [30] SEQUENCE (SIZE(0..1024, ...)) OF SqOf000
|
|
StOf000 ::= [31] SET OF bitString002 BStr002 (SIZE (64))
|
|
Cho000 ::= [PRIVATE 32] CHOICE {
|
|
cho0 Bool001,
|
|
cho1 Enum001,
|
|
cho2 IA5000 (SIZE(10..MAX)),
|
|
--cho2 IA5000 (SIZE(10..20)),
|
|
cho3 UTim000,
|
|
cho4 Cho000
|
|
}
|
|
Seq000 ::= [PRIVATE 33] SEQUENCE {
|
|
seq0 Int001,
|
|
seq1 OStr001,
|
|
seq2 SqOf000 (SIZE(2..5)),
|
|
seq3 Seq000
|
|
}
|
|
|
|
|
|
-- basic value parsing
|
|
null00 NULL ::= NULL
|
|
bool00 BOOLEAN ::= TRUE
|
|
bool01 BOOLEAN ::= FALSE
|
|
int00 INTEGER ::= -1
|
|
int01 INTEGER ::= 00
|
|
int02 INTEGER ::= 1024
|
|
real00 REAL ::= 25.386e12
|
|
real01 REAL ::= 1024.E-56
|
|
real02 REAL ::= -100.00e3
|
|
real03 REAL ::= {mantissa 25386, base 10, exponent 9}
|
|
real04 REAL ::= {mantissa 3, base 2, exponent -128}
|
|
Enum00 ::= ENUMERATED {e0 (0), e1 (1), e2 (2), ..., eX (100), eY (101)}
|
|
enum00 Enum00 ::= e0
|
|
enum01 Enum00 ::= eX
|
|
bs00 BIT STRING ::= '001111100 0011 001110 110 1110001101'B
|
|
bs01 BIT STRING ::= '0123 4567 89AB CDEF'H
|
|
os00 OCTET STRING ::= '001111100 0011 001110 110 1110001101'B
|
|
os01 OCTET STRING ::= '0123 4567 89AB CDEF'H
|
|
oid00 OBJECT IDENTIFIER ::= {root (0) dir (1) subdir (2) file (3) 4 5}
|
|
oid01 OBJECT IDENTIFIER ::= {itu-t recommendation m test (28) more-test (59)}
|
|
roid00 RELATIVE-OID ::= {rootdir (0) dir (1) subdir (2) file (3) 4 5}
|
|
roid01 RELATIVE-OID ::= {test (28) more-test (59) 2569 6533125}
|
|
utim00 UTCTime ::= "1606251200Z"
|
|
utim01 UTCTime ::= "160625123055-0230"
|
|
gtim00 GeneralizedTime ::= "2016062512+0200"
|
|
gtim01 GeneralizedTime ::= "20160625124539.5290"
|
|
gtim02 GeneralizedTime ::= "20160625124539,5290Z"
|
|
str00 IA5String ::= "abcd ""ABCD"" efgh ""EFGH"" 'test' OK;
|
|
go-there !"
|
|
|
|
|
|
-- content / constraint inheritance
|
|
Int0 ::= INTEGER {un (1), deux (2), trois (3)}
|
|
Int1 ::= Int0 (0..10, ...)
|
|
Int2 ::= Int1 (0..3)
|
|
|
|
|
|
-- INTEGER kung-fu
|
|
deux INTEGER ::= 2
|
|
dreI-3 INTEGER ::= 3
|
|
int Int ::= trois
|
|
Int ::= INTEGER {alpha(-1), beta (deux), trois(dreI-3), four( 4 )}
|
|
|
|
|
|
-- parameterization kung-fu
|
|
Bound ::= INTEGER (1..99)
|
|
|
|
Range {Bound:bound} ::= SEQUENCE {
|
|
low INTEGER (0..bound),
|
|
high INTEGER (bound..100),
|
|
bool BOOLEAN,
|
|
...,
|
|
null NULL
|
|
}
|
|
|
|
Wrap ::= SEQUENCE {
|
|
r10 Range {10},
|
|
r90 Range {90}
|
|
}
|
|
|
|
Final ::= SEQUENCE {
|
|
w1 Wrap,
|
|
w2 Wrap,
|
|
bool BOOLEAN
|
|
}
|
|
|
|
Bnd1 {INTEGER:lo} ::= INTEGER (lo..100)
|
|
Bnd2 ::= Bnd1 {10}
|
|
Bnd3 ::= Bnd2 (20..30)
|
|
|
|
INT01A {INTEGER:tagconst} ::= [tagconst] IMPLICIT INTEGER (0..tagconst)
|
|
Int01A ::= INT01A {20}
|
|
int01A Int01A ::= 8
|
|
|
|
int02A Int02A ::= second
|
|
Int02A ::= INT02A {50, 1, 2, 0, 1000}
|
|
INT02A {INTEGER:tag, INTEGER:st, INTEGER:nd, INTEGER:lo, INTEGER:hi} ::= [PRIVATE tag] IMPLICIT INTEGER
|
|
{zero (0), first (st), second (nd)}
|
|
(lo..hi, ...)
|
|
|
|
int03 INT03 {500} ::= 100
|
|
INT03 {Int02A:hi} ::= INTEGER (-1000..hi)
|
|
|
|
bs01A Bs01A ::= {first, second}
|
|
Bs01A ::= BS01A {1, 2}
|
|
BS01A {INTEGER:st, INTEGER:nd} ::= BIT STRING {first (st), second (nd)}
|
|
|
|
Unknown01 {Type} ::= [512] Type
|
|
Int04 ::= Unknown01 {Int01A} --not supported by OSS, but should be processable
|
|
Int05 ::= Unknown01 {INTEGER} --supported by OSS
|
|
int04 Int04 ::= 10
|
|
|
|
SeqOf {INTEGER:bound} ::= SEQUENCE (SIZE(0..bound)) OF BOOLEAN
|
|
SeqOf1 ::= SeqOf{1}
|
|
SeqOf2 ::= SeqOf{2}
|
|
SeqOf3 ::= SeqOf{100000}
|
|
|
|
|
|
-- CLASS object kung-fu
|
|
TEST ::= CLASS {
|
|
&Int INTEGER,
|
|
&Bool BOOLEAN
|
|
}
|
|
|
|
test TEST ::= { &Int {0|1}, &Bool {TRUE} }
|
|
|
|
Test TEST ::= { {&Int {0|1|2}, &Bool {TRUE|FALSE}} |
|
|
{&Int {3|4}, &Bool {TRUE, ...}} , ... }
|
|
|
|
WRAP ::= CLASS {
|
|
&Test TEST,
|
|
&id INTEGER
|
|
}
|
|
|
|
TEST1 ::= CLASS {
|
|
&Int,
|
|
&truc &Int
|
|
}
|
|
|
|
TEST2 ::= CLASS {
|
|
&id [100] INTEGER UNIQUE,
|
|
&seq [101] SEQUENCE SIZE (2) OF BOOLEAN DEFAULT {FALSE, FALSE},
|
|
&test10 [102] TEST1 OPTIONAL,
|
|
&Gratin BIT STRING OPTIONAL,
|
|
&de OCTET STRING OPTIONAL,
|
|
&Patates REAL OPTIONAL,
|
|
&test11 [103] TEST1 DEFAULT {&Int INTEGER (0..10), &truc 1}
|
|
}
|
|
WITH SYNTAX {
|
|
[TESTONE &test11]
|
|
WITH ID &id MY IDENTITY
|
|
[[[SEQ OF &seq BOOL] TESTZERO &test10] ON MANGE UN &Gratin [DE &de SUPER &Patates AU FROMAGE]]
|
|
}
|
|
|
|
Bs BIT STRING ::= {'11'B | '00'B, ...}
|
|
test2 TEST2 ::= { TESTONE {&Int INTEGER, &truc 1} WITH ID 27 MY IDENTITY ON MANGE UN {Bs | '110010'B | '001110'B, ...} }
|
|
|
|
|
|
-- constructed type kung-fu
|
|
Seq0A ::= [APPLICATION 2563] IMPLICIT SEQUENCE {
|
|
uint0 INTEGER (0..MAX) OPTIONAL,
|
|
uint1 INTEGER (0..MAX) OPTIONAL,
|
|
...,
|
|
[[1:neg0 INTEGER (MIN..0),
|
|
neg1 INTEGER (MIN..0, ...)]],
|
|
[[2:boo0 BOOLEAN DEFAULT TRUE,
|
|
boo1 BOOLEAN DEFAULT FALSE]]
|
|
}
|
|
|
|
Seq1A ::= [PRIVATE 65] EXPLICIT SEQUENCE {
|
|
COMPONENTS OF [66] Seq0A, -- this tag is (to my understanding) useless
|
|
bstr0 BIT STRING (SIZE (0..8)) DEFAULT '011011'B,
|
|
bstr1 BIT STRING {un(1), deux(2), quatre(4)} (SIZE (0..8)) DEFAULT {quatre},
|
|
seq1 Seq1A OPTIONAL, -- some recursive stuff
|
|
...
|
|
}
|
|
|
|
|
|
-- table constraint karate
|
|
TEST3 ::= CLASS {
|
|
&index INTEGER UNIQUE,
|
|
&bool BOOLEAN,
|
|
&Type
|
|
}
|
|
|
|
Test3 TEST3 ::= {
|
|
{&index 1, &bool TRUE, &Type Real000} |
|
|
{&index 2, &bool TRUE, &Type Int000} |
|
|
{&index 3, &bool TRUE, &Type OStr000} |
|
|
{&index 4, &bool TRUE, &Type SqOf000} |
|
|
{&index 5, &bool TRUE, &Type Cho000} |
|
|
{&index 6, &bool FALSE, &Type Seq000}
|
|
}
|
|
|
|
Seq2A ::= SEQUENCE {
|
|
myInd TEST3.&index ({Test3}),
|
|
myBool TEST3.&bool ({Test3}{@myInd}),
|
|
myType TEST3.&Type ({Test3}{@myInd})
|
|
}
|
|
|
|
|
|
-- cyclic referencing kung-fu
|
|
Seq00 ::= SEQUENCE {
|
|
bool BOOLEAN,
|
|
s00 Seq00 OPTIONAL
|
|
}
|
|
|
|
Seq01 ::= SEQUENCE {
|
|
bool BOOLEAN,
|
|
s02 Seq02 OPTIONAL
|
|
}
|
|
|
|
Seq02 ::= SEQUENCE {
|
|
bool BOOLEAN,
|
|
s01 Seq01
|
|
}
|
|
|
|
Recur0 ::= SEQUENCE {
|
|
recur Recur0 OPTIONAL,
|
|
null NULL
|
|
}
|
|
|
|
Recur1 ::= SEQUENCE {
|
|
recur Recur2 OPTIONAL,
|
|
int INTEGER
|
|
}
|
|
|
|
Recur2 ::= SEQUENCE {
|
|
recur Recur1 OPTIONAL,
|
|
bool BOOLEAN
|
|
}
|
|
|
|
Recur3 ::= SEQUENCE {
|
|
/*int INTEGER OPTIONAL,*/
|
|
recur Recur3 OPTIONAL,
|
|
wrap OCTET STRING (CONTAINING Recur3) OPTIONAL
|
|
}
|
|
|
|
-- recursive parameterized type, not supported yet
|
|
/*
|
|
Seq0 {INTEGER:lo, INTEGER:hi} ::= SEQUENCE {
|
|
int INTEGER (lo..hi, ...)
|
|
seq Seq0 {lo, hi} OPTIONAL
|
|
}
|
|
Seq1 ::= Seq0 {0, 100}
|
|
*/
|
|
|
|
-- (circular) recursive parameterized type, not supported yet
|
|
/*
|
|
Seq2 {INTEGER:lo, INTEGER:hi} ::= SEQUENCE {
|
|
int2 INTEGER (lo..hi, ...),
|
|
seq3 Seq3 {lo, hi} OPTIONAL
|
|
}
|
|
Seq3 {INTEGER:lo, INTEGER:hi} ::= SEQUENCE {
|
|
int3 INTEGER (lo..hi),
|
|
bool3 BOOLEAN,
|
|
seq2 Seq2 {lo, hi} OPTIONAL,
|
|
...
|
|
}
|
|
Seq4 ::= Seq3 {0, 100}
|
|
*/
|
|
|
|
-- ASN.1 wrapper objects
|
|
ASNWrapper ::= SEQUENCE {
|
|
ext EXTERNAL,
|
|
emb EMBEDDED PDV,
|
|
cst CHARACTER STRING
|
|
}
|
|
|
|
END
|