Az ELASTIC programozási nyelv

Csomagok

Az elastiC programok alapvető fordítási egysége a csomag (package). Egy csomag felépítése: 

 
        package csomagnév;
 
        //import rész:
        import basic; //basic csomag importálása
 
        //utasítások, deklarációk:
 
        public function hello() 
        { 
               basic.print("Helló világ\n");
               return 0;
        }
        hello();

Mint látható, egy csomag két fő részből áll: az elsőben az import kulcsszóval jelezzük, hogy egy másik csomag szolgáltatásait használni akarjuk. Ezután következnek a deklarációk és utasítások, tetszőleges sorrendben. Lényeges különbség a C/C++ vagy Java nyelvhez képest, hogy nincs egy speciális nevű függvény (main), amit az interpreter a program indításakor végrehajt, hanem a forrásfájl maga képezi a legkülső programblokkot.

Láthatóság

A csomagok legfelső szintjén deklarált változókat (azaz nem egy függvény vagy osztály belsejében) két féle láthatósággal deklarálhatunk: public vagy private. A public kulcsszóval deklarált változók más csomagokból is láthatóak, míg a private kulcsszóval deklaráltak csak a csomagon belülről.


public v1; // "v1" egy public változó private v2; // "bar" egy private
Mivel az elastiC függvények és osztályok is objektumok ( azaz úgy tudjuk tárolni, használni őket mint paramétereket… ), ezért a függvények és osztályok is ezekkel a láthatósági tulajdonságokkal deklarálhatóak: 

    public function hello()
    {
        basic.print( "Hello világ!\n" );
    }

    private function how()
    {
        basic.print( "Hogy vagy?\n" );
    }

valójában ez ekvivalens a következővel:

    public hello;
    hello = function()
    {
        basic.print( "Hello világ!\n" );
    };

    private how;
    how = function()
    {
        basic.print( " Hogy vagy?\n" );
    };

Ha nem jelöljük, akkor a private láthatóság az alapértelmezett

Függvény változók láthatósága

A függvény törzsében bevezetett változóknak szintén két láthatósági jellemzőjük van: local és static. A lokális (local) változók csak a függvény belsejében láthatóak, és csak a függvény végrehajtása alatt léteznek (egy kivételtől eltekintve, amit később látni fogunk). A statikus (static) változók élettartama megegyezik a definiáló függvény élettartamával (ami különbözik a függvény végrehajtásától), és megőrzik értéküket a függvényhívások alatt.

Pl. 
    function negyzet_szamolas()
    {
        static val = 0;    // a statikus változó
        local  v;          // a lokális változó

        val = val + 1;
        v = val * val;
        basic.print( v, '\n' );
    }

    negyzet_szamolas ();
    negyzet_szamolas ();
    negyzet_szamolas ();

az eredmény: 

    1

    4

    9

Láttuk, hogy a függvények objektumok, ugyanúgy mint az egész vagy lebegő pontos számok, vagy bármi más, így kiderült hogy a következő kód helyes: 

    function trunky()
    {
        local funky;

        funky = function() {
            basic.print( "BUH !\n" );
        }

        funky();
    }

Ez nem túl érdekes, ha nem férünk hozzá a külső függvény változóihoz a belsőből, így kicsit átírva a kódot: 
   
 package trunky;

    import basic;

    function trunky()
    {
        local funky;
        local v;

        v = 5;

        funky = function() {
            basic.print( v, '\n' );
        };

        funky();
    }

    trunky();

Az eredmény: 

5

De most felmerülhet a kérdés, hogy mi történik, ha valami ilyesmit csinálunk: 

    package furcsa;

    import basic;

    function trunky()
    {
        local funky;
        local v;

        v = 5;

        funky = function() {
            basic.print( v, '\n' );
        };

        // visszaadjuk a funky változóban tárolt függvényt
        return funky;
    }

    local func;
    func = trunky();

    // a func a trunky() által visszaadott függvény...
    // ... hívjuk meg !
    func();

Mi történik? Egy függvényt hívunk, ami egy olyan változóra hivatkozik, ami a készítésekor volt aktív, és nyilvánvalóan nem aktív a hívása idején.

Az erdemény:

5

Ez azért van, mert a rendszer megengedi az ilyen programozási stílust, Ez az a változó élettartam kivétel, amit említettünk. A szabály intuitív módon definiálható: a változók aktívak maradnak az egész időre, amíg szükségesek lehetnek egy számításhoz.

Vannak még más láthatósági szabályok, amikről az objektum orientáltság témakörben lesz szó.

Alapcsomagok, szabványos könyvtár

A nyelv a fordító és az interpreter mellett tartalmaz néhány hasznos csomagot is. Mivel ezek dokumentálatlanok, ezért csak a nevükből következtethetünk a szerepükre. 

 
        basic
        sys
        math
        string
        list
        array
        re