A Theta programozási nyelv

Hatáskörök, deklarációk, egyenlőségek

Ez a fejezet a Theta hatáskörrel való szabályait adja meg. A fejezet szól a változó deklarációkról, és az egyenlőségekről is, két fontos szerkezet, amelyek bemutatják a hatáskörrel ellátott azonosítókat.

Ha azt mondjuk, hogy egy azonosító hatáskörrel van ellátva, vagy rendelkezik hatáskörrel, az azt jelenti, hogy az azonosító
egy konkrét hatáskörben lett definiálva. A hatásköri szabályok biztosítják, hogy egy adott azonosító vagy nincs definiálva
egy hatáskörön belül, vagy pontosan egyszer van definiálva, és ezek a külső nevek soha nem kavarodnak
össze a hatáskörrel rendelkező azonosítókkal a programon belül.

Ha azt mondjuk, hogy egy azonosító hatáskörrel van ellátva, vagy rendelkezik hatáskörrel, az azt jelenti, hogy az azonosító egy konkrét hatáskörben lett definiálva. A hatásköri szabályok biztosítják, hogy egy adott azonosító vagy nincs definiálva egy hatáskörön belül, vagy pontosan egyszer van definiálva, és ezek a külső nevek soha nem kavarodnak össze a hatáskörrel rendelkező azonosítókkal a programon belül.

Hatáskörrel rendelkező azonosítók

A hatáskörrel rendelkező azonosítóknak két fajtája van a Theta-ban: konstans azonosítok és változók. A konstansok immutable típusúak, és az egész fennállásuk (létezésük) alatt ugyanarra az objektumra mutatnak. A változók mutable típusúak, változhat az értékük, tehát eltérő objektumra mutathatnak. Ha egy változót létrehozunk, akkor nem feltétlenül kell objektumra mutatnia.

Konstansok lesznek bevezetve az egyenlőségeknél, típus specifikációnál, rutin megvalósításoknál, metódus megvalósításoknál, formális paraméterek deklarációjánál, osztályoknál, ősosztály (superclass) deklarációjánál. Változók lesznek bevezetve a deklarációknál, (instance) példány-változók deklarálásánál, formális argumentum deklarációknál, valamint a tagcase és typecase utasítások speciális deklarációjában.

Az egyenlőséggel definiált azonosító (konstans) hatásköre az egész blokkban érvényes lesz, amely tartalmazza a definícióját,
és a deklarációtól a deklarációt tartalmazó blokk végéig tart.

Hatásköri blokkok (szakaszok)

A változó deklarációk és egyenlőségek hatáskörét a hatásköri blokkok termeivel definiáljuk. Ez a rész tartalmazza a Theta hatásköri blokkjainak listáit.

  1. a típus vagy rutin specifikációjának kezdetétől a végéig.
  2. a modul, a rutin implementáció, vagy osztály elejétől kezdve a végéig.
  3. a for, do, begin, vagy a then-től kezdve make utasításban a megfelelő utasítás végéig.
  4. egy if utasítás then, elseif, vagy else ágától a megfelelő blokk (törzs) végéig.
  5. egy tagcase, typecase, vagy except utasítás when-jétől (vagy mástól) a megfelelő törzs végéig.

Ha egy hatásköri blokk felüldefiniál egy másikat (szöveg szerint), ha azt teljesen tartalmazza a másik. A tartalmazott (belül levő) hatáskört beágyazott hatáskörnek, a tartalmazó hatáskört pedig körülzáró hatáskörnek nevezzük.

 

Külső (másodlagos) nevek

Egy azonosítót - amit egy olyan hatáskörben használunk, ahol nincs értelmezve, külső névnek nevezzük. A külső neveket arra használjuk, hogy specifikációkat és egyenlőségeket írjunk le másik programegységekből kiindulva.

 

Hatásköri szabályok

A hatásköri szabályok a következők:

  1. egy azonosító nem lehet deklarálva kétszer egy hatáskörön belül. Megjegyezzük, hogy ez a szabály magában foglalja azt, hogy egy adott hatáskörben definiált azonosítót nem lehet újradefiniálni egy másik beágyazott hatáskörben.
  2. Egy egyszerű (sima) programon unit-on belül, egy azonosító nem jelenhet meg külső névként egy hatáskörben, és hatáskörrel rendelkező azonosítóként egy másik hatáskörben.

 

Változók és deklarációk

A Theta-ban az objektumok alap (primitív) futási időben létező (run-time) entitások. Változók objektumok leírására vagy megnevezésére alkalmasak.

A deklarációk új változókat vezetnek be. Változók hatásköre a deklarációtól kezdődik, és annak a törzsnek a végéig tart, amelyben a deklaráció volt. Ennél fogva tehát a változót használat előtt deklarálni kell.

Egy változónak két tulajdonsága van: a típusa (ami meghatározza, hogy mire lehet használni) és az objektum, ami leírja őt. Egy változó megszűnik, ha nem mutat semmilyen objektumra sem. Egy lehetőség egy változó megszüntetésére futási időben, hogy előidézzük a "failure(uninitialized variable)" kivétel kiváltódását.

Inicializálás nélkül deklaráció éppen bevezet néhány új, "uninitialized" (megszűnő) változót:

        <decl> -> <idn_list> ":" <type_designator>

Ez a szerkezet bevezeti a megadott típus egy vagy több új változóját. A következő példák megengedett deklarációk:

	x, y: int            % két egész típusú változót deklarál
	parts: set[part]     % deklarál egy set[part] változót

Mint ahogy a későbbi fejezetekben láthatjuk, új változót deklarálhatunk és inicializálhatunk egyidőben, egy speciális (hozzárendelő) utasítással.

 

Egyenlőségek

Az egyenlőségek használata lehetővé teszi, hogy egy sima azonosítót rövidítésként használjunk egy konstans helyett, ami lehet hogy hosszabb szöveg reprezentációt igényelne. Szintén előállít egy emlékeztető azonosítót, amit elhelyezhetünk a konstansban, mint egy numerikus értéket.

Az egyenlőségek szintaxisa a következő:

        <equate> -> <idn> "=" <expr> | <idn> "=" <type_designator>

Az első alaknál, az expr konstans kifejezés kell hogy legyen, különben fordítási hiba lép fel.

Ha egy azonosítót egy kifejezéssel teszünk egyenlővé, akkor azt kifejezésként használhatjuk; Egy ilyen kifejezés értéke az a konstans lesz, amellyel az azonosítót egyenlővé tettük. Ha egy azonosítót típus minősítővel tettük egyenlővé, akkor önmaga egy típus minősítő lesz, ami ugyanazt a típust írja le, mint az a típus minősítő, amivel egyenlővé tettük. Egy egyenlőséggel meghatározott azonosítót nem használhatunk értékadások baloldalán.

Megengedett egyenlőségekre néhány példa:

as = array[string] % egy típus egyenlőség
pi = 3.1416 % egy konstans kifejezés egyenlőség

Egy egyenlőséggel meghatározott azonosító a legkisebb hatáskört kapja, abban a törzsben, amiben definiálták. Ezt úgy értjük, hogy az egész hatásköri blokk, nem csak a definiálás utáni rész. Egy szerkezet törzsében előforduló egyenlőségnek meg kell jelennie a törzsbeli szerkezeteket megelőzően. Az egyenlőségek bárhol megjelenhetnek a hatáskörükön belül.

Egy hatáskörön belüli összes egyenlőségeket a fordító egységként dolgozza fel, és az előre hivatkozás van érvényben. A fordító hibát jelez, ha egy körkörös függőséget fedez fel, kivéve, ha néhány "közbelépéses" felhasználó által definiált típust. Például, a következő egyenlőségek halmaza nem megengedett:

tree = maybe[tree_node]
tree_node = record[left: tree, right: tree, val: int]

Azonban, a "tree" típus implementációján belül ezt megtehetjük.

tree = class ...
tree_node = record[left: tree, right: tree, val: int]
t: tree_node
...
end tree

Ezek az egyenlőségek megengedettek, mert a felhasználó által definiált "tree" megsemmisíti a kört.