A TTCN-3 programozási nyelv

Típusok és típuskonstrukciók

A TTCN-3 kialakításakor fontos szempont volt az ASN.1 nyelvvel történő magas szintű kompatibilitás, mivel nagyon sok, protokollok által használt típus leírása ebben a formában állt rendelkezésre. Ennek megfelelően a nyelv típusainak legtöbbje egyértelműen megfeleltethető egy ASN.1-beli típusnak.

A TTCN-3 rendelkezik a sok más programozási nyelvben is megtalálható egyszerű alaptípusokkal, valamint néhány speciális, beépített típussal is. Ezek mellett természetesen lehetőségünk van saját adatszerkezeteket is definiálni a strukturált típusok segítségével. A TTCN-3 típusrendszere az alábbi elemekből áll:

1. táblázat: TTCN-3 típusok
Típus Altípusdefiníció példa Érték példa Ekvivalens ASN.1 típus
Alaptípusok
integer
type integer MyInt;
10
INTEGER
float
type float MyFloat;
10.0
REAL
boolean
type boolean MyBool;
true
BOOLEAN
bitstring
type bitstring MyBitstring;
'1101'B
BIT STRING
hexstring
type hexstring MyHexstring;
'AF3'H
-
octetstring
type octetstring MyOctetstring;
'AF31'O
OCTET STRING
charstring
type charstring MyCharstring;
"Hello, world!"
IA5String
char (obsolete)
type char MyChar;
"A"
IA5String(SIZE(1))
universal charstring
type universal charstring MyUC;
"Ελληνικά"
UniversalString
universal char (obsolete)
type universal char MyUChar;
"λ"
UniversalString (SIZE(1))
objid
type objid MyObjid;
objid { itu_t(0) 4 etsi(0) }
OBJECT IDENTIFIER
Strukturált típusok
record
type record MyRecord { BIT_4 protVersion, integer typeCode, charstring payload }
{ protVersion := '0010'B, typeCode := 25, payload := "Hello, world!" }
SEQUENCE
record of
type record of integer MyRoi;
{ 1, 2, 3, 4, 5 }
SEQUENCE OF
set
type set MySet { BIT_4 protVersion, integer typeCode, charstring payload }
{ typeCode := 25, payload := "Hello, world!", protVersion := '0010'B }
SET
set of
type set of integer MySoi;
{ 2, 3, 4, 1, 5 }
SET OF
union
type union MyUnion { integer variant1, BIT_1 variant2, OCT_2 variant3 }
{ variant2 := '1'B }
CHOICE
enumerated
type enumerated MyEnum { E_REQ, E_IND(1), E_ERR }
E_IND
ENUMERATED
Speciális típusok
verdicttype

-

pass
-
default

-

- -
anytype

-

- -
port

-

type port MyMessagePortType message { inout MyMsgType; }
-
component

-

type component MyMTCType { var integer MyLocalInteger; port MyMessagePortType MyPCO1; port MyProcedurePortTypes[3][3] PCO2; // 9 port }
-
timer

-

timer T2 := 2.9
-

Alaptípusok

A más nyelvekben megszokottakhoz képest nincs eltérés az alaptípusok használatának tekintetében. Az integer egész, a float lebegőpontos értékek tárolására alkalmas, a boolean értékhalmaza a true és a false kulcsszavak. Lehetőségünk van különböző formájú szövegek tárolására, a charstring feleltethető meg a hagyományos string típusnak, a bitekből álló szöveget a bitstring, az oktetekből álló szöveget az octetstring, míg a hexadecimális értékekből álló szöveget a hexstring típus valósítja meg.

Strukturált típusok

A nyelvben struktúrált típusokat a record, set és union kulcsszavakkal hozhatunk létre. A record lényegében egy C/C++ struct-nak feleltethető meg. A set a recordhoz hasonló, különbség azonban, hogy míg a recordban a belső elemek sorrendje kötött, addig a set-nél ez tetszőleges lehet. Set esetében teljesül tehát a

{a := 0, b := true}={b := true, a := 0}
recordra azonban ez nem igaz.

A union típus segítségével összeállított konstrukció tetszőleges mezői közül egy pillanatban legfennebb egy tárolhat értéket, azt pedig, hogy melyik az a mező az ischosen függvénnyel kérdezhetjük le:

ischosen(myUnionVariable.fieldName)

Strukturált típusok mezőit opcionálisnak jelölhetjük az optional kulcsszóval, ekkor az adott mező típusértékei mellett az értéke lehet omit is.

type record/set MyType { integer field1 optional, boolean field2 } var MyType myVar := { field1 := omit, field2 := false }

A record of illetve a set of konstrukciót elemek egy csoportjának tárolására használhatjuk, azonos típusú elemek absztrakt konténereként tekinthetjük őket. A különbség közöttük az, hogy record of esetén fontos az elemek sorrendje, míg set of-nál ez nem számít. Két record of struktúra egyenlő, ha ugyanazokat az elemeket tartalmazzák ugyanabban a sorrendben, két set of struktúra pedig egyenlő, ha ugyanazokat az elemeket tartalmazzák akár tetszőleges sorrendben.

A típusok egymásbaágyazhatóságának természetesen nincs korlátja, sőt akár „névtelen” típusokat is használhatunk típusdefiníciókor:

type record of set of integer KulsoTipus;
ekvivalens a
type set of integer BelsoTipus; type record of BelsoTipus KulsoTipus;
definíciókkal.

Speciális típusok

A fentiek mellett a nyelvben lévő beépített speciális adattípus a verdicctype, amely a teszt futtatás eredményeinek kezelésére alkalmas, lehetséges értékei pedig none, pass, inconc, fail, error.

Egy másik speciális típus az anytype, ez az adott modul által ismert összes (alaptípusok, felhasználó által definiáltak valamint importáltak) típus unionjaként értelmezhető.

További speciális típusokat jelölnek az address, port, component és default kulcsszavak szintén speciális típusokat vezetnek be, ezeket a későbbiekben bemutatjuk.

Altípusozás

A nyelv segítségével az ADA-hoz nagyon hasonló altípus megszorításokat vezethetünk be, ezeket az alábbi tálázat írja le.

2. táblázat: Altípus megszorítások a TTCN-3-ban
Megszorítási osztály Alkalmazhatóság Példa megszorított típusokra
Alapszintű megszorítások
érték lista minden típus
type integer MyInt(1, 2, 3); type float MyFloat(1.0, 2.0); type boolean MyBool(not true); // ugyanaz mint a (false) type bitstring MyBitstring(''B, '1'B, '101'B); type hexstring MyHexstring('F'H, '5AE'H); type octetstring MyOctetstring('A4'O, '15AC'O); type charstring MyCharstring(";AB";, ";CD";, ";EFG";); type universal charstring MyUC(";Ελληνικά";, ";Русский";); type objid MyObjid(objid { 1 2 3 }, objid { m(0) 1 }); type MyBaseRecord MyRestrictedRecord ({ f1 := 1, f2 := 5 }, { f1 := 3, f2 := 4 }, MyRecConst); type MyBaseRecOfInt MyRestrictedRecOfInt ({ 1, 2, 3 }, { 4, 5 }); type MyBaseSet MyRestrictedSet ({ f1 := 1, f2 := 5 }, { f2 := 4, f1 := 3 }); type MyBaseSetOfInt MyRestrictedSetOfInt ({ 1, 2, 3 }, { 5, 4 }); type MyBaseUnion MyRestrictedUnion ({ u1 := 5 }, { u2 := '11'B }, MyUnionConst); type MyBaseEnum MyRestrictedEnum(E_REQ, E_IND); type verdicttype MyVerdictType(pass, fail); type MyDefinedIntType MyRestrictedInt(10, 20);
érték intervallum
  • integer
  • float
type integer MyInt(0 .. 255); type integer NaturalNumbers(1 .. infinity); type integer NegativeNumbers(-infinity .. -1); type float MyFloat(0.0 .. 1.0); type float NonNegative(0.0 .. infinity); type float NonPositive(-infinity .. 0.0);
character intervallum minden karakteres szöveg típus
// minden karakter a MyCharstring típusban // a ["a" .. "z"] zárt intervallum eleme: // type charstring MyCharstring("a" .. "z");
hossz megszorítás
  • minden szöveg típus
  • record of
  • set of
type bitstring MyBitstring length(5); type hexstring MyHexstring length(2..4); type octetstring MyOctetstring length(0..10); type charstring MyCharstring length(10..infinity); type universal charstring MyUC length(5); type record length(5..infinity) of integer MyRecOfInt; type set length (15) of integer MySetOfInt;
pattern minden karakteres szöveg típus
type charstring MyStr1(pattern "abc*xyz";); // ugyanaz, mint: type charstring MyStr2("a" .. "z"); type charstring MyStr2(pattern "[a-z]#(0,)");
Összetett megszorítások
kevert érték lista és érték intervallum
  • integer
  • float
type integer MyInt(-1000, -100..-90, -10, 1..infinity); type float MyFloat(-1E3, -1E2..-90.0, -10.0, 1.0..infinity);
postfixing hossz megszorítás minden szöveges típus
// hosszmegszorításokat tetszőleges szöveges // megszorítás alaphoz köthetünk type charstring MyStr1(pattern "abc*xyz") length(10..20); type charstring MyStr2(pattern "abc*xyz") length(15); // ugyanaz, mint: type charstring MyStr3(pattern "[a-z]#(10,20)"); type charstring MyStr3("a" .. "z") length(10..20); // ugyanaz, mint: type charstring MyStr4(pattern "[a-z]#(1,)"); type charstring MyStr4("a" .. "z") length(1..infinity); // ugyanaz, mint: type charstring MyStr5(pattern "[a-z]#(,10)"); type charstring MyStr5("a" .. "z") length(0..10); // ugyanaz, mint: type charstring MyStr6(pattern "[a-z]#(10)"); type charstring MyStr6("a" .. "z") length(10);

Leszármazott típusok esetén (pl. hosszmegszorítás) az új típus értékei kompatibilisek maradnak a régi típussal, amennyiben az a származási szabályt nem sérti. Kizárólag az fogadott és várt üzenet összehasonlításakor szükséges erősebb típusmegkötés, tehát amennyiben a leszármazott típusú üzenetet várunk de az őstípus érkezik (akár megfelelő értékkel) úgy az üzenet fogadása sikertelen.

Típuskonverziók

A nyelv nem támogatja sem az implicit, sem pedig az explicit típuskonverziót, azonban beépített függvényeket nyújt a típusok közötti konvertálásra.

3. táblázat: Beépített típuskonverziós függvények TTCN-3-ban
Hova/Honnan integerfloatbitstringhexstringoctetstringcharstringuniversal charstring
integer-float2intbit2inthex2intoct2intchar2int, str2intunichar2int
floatint2float----str2float-
bitstringint2bit--hex2bitoct2bitstr2bit-
hexstringint2hex-bit2hex-oct2hexstr2hex-
octetstringint2oct-bit2octhex2oct-char2oct, str2oct-
charstringint2char, int2strfloat2strbit2strhex2stroct2char, oct2str--
universal charstringint2unichar------