Dustyscript

DustySript è un linguaggio in evoluzione, creato in Java e di cui ricalca, a parte la terminologia, le caratteristiche, la parte più evidente è infatti l’utilizzo di una nomenclatura poco usuale, una sintassi che permette alternative e comandi con sinonimi; ad esempio la moltiplicazione può essere indicata con gli operatori *, times e multiplied by. Anche per i confronti è disponibile una sintassi English-like alternativa alla sintassi ad operatori.

Caratteri, stringhe, numeri e booleani sono i tipi di dato previsti, quest’ultimi sono indicati con yes_no ed ovviamente i valori possibili sono yes e no.

Il linguaggio è estensibile tramite librerie, e di queste, la libreria System inclusa automaticamente, offre qualche funzione aggiuntiva al trattamento delle stringhe, ed il supporto delle funzioni per numeri casuali.

Le variabili si possono dichiarare esplicitamente (declare tipo nome;) oppure si deve distinguere la prima assegnazione tramite la sintassi tipo nome is espressione; dalle successive: nome is now espressione;; copies è l’assegnazione di una variabile ad un’altra. Inoltre le variabili possono essere eliminate (destroy).

Se nella dichiarazionetipo è al plurale, essa diventa la dichiarazione di un array (vuoto), che nella terminologia Dustyscript é detto group. Apposite istruzioni, grow e srink, variano la dimensione del group. E’ possibile dichiarare un group con una data dimensione, ad esempio: group mesi contains 12 strings;. Anche qui il tipo è al plurale.

Un elemento del group è individuato da un numero intero, tramite le forme sintattiche quasi equivalenti: nomegroup:n oppure nomegroup[espressione]. La proprietà size e last forniscono rispettivamente la dimensione del group ed il suo ultimo elemento.

Le variabili string si comportano come dei group di caratteri, quindi è disponibile la proprietà size e l’accesso per indice numerico ad un singolo carattere.

Fra gli operatori relazionali, esprimibili sia con gli usuali simboli o con espressioni linguistiche (ad esempio >= oppure is greater than or equal to), sono presenti contains e does not contains per le stringhe e degli operatori di introspezione, ad esempio if variabile is a string ....

L’iterazione è count from integer through integer {istruzioni}; oppure count using variabile from integer through integer {istruzioni};. Nel secondo caso variabile che non è utilizzata per il controllo del ciclo, è ovviamente incrementata di 1 ad ogni passo. La struttura While ha sintassi: as long as espressione {istruzioni};. Il comando break provoca l’uscita da un ciclo.

L’accesso ai file è limitato alla lettura o scrittura dell’intero file che deve essere in una directory fissa: load variabile from nomefile;, qui nome file, incongruamente, può essere una variabile o il nome del file ma non sotto forma di stringa. L’input output è completato dalle istruzioni ask  e say:

ask for integer radius; /* input con conversione da stringa a ... */

say "area is" + (radius multiplied by radius times 3.1415);

Funzioni e procedure devono essere dichiarate prima dell’utilizzo tramite la dichiarazione action, le variabili, con la loro dichirazione di tipo, sono introdotte dalla parola takes e gives indica il tipo di dato restituito. Il carattere ~ indica la mancanza di parametri e o la mancanza di valori restituiti. L’istruzione give esce dalla funzione fornendo il risultato esplicito o implicito (l’ultima assegnazione eseguita). Le funzioni accettano un polimorfismo completo, vale a dire esteso anche ai valori di ritorno.

Dustyscript presenta aspetti evoluti quali trehad, gestione degli errori (try {...} catch {...}; ma anche attempt the following {...} and if it fails {...};) ed oggetti con vari aspetti di ereditarietà.

La gestione dei thread è semplice, tuttavia le poche cose previste si possono fare in modi diversi:

thread as th {count using k from 20 through 100 {};say "k ends";};

do separately {count using i from 1 through 10000 {}; say "i ends";};

run separately {count using j from 1 through 10 {};say "j ends";};

sleep th;

awaken th;

j ends

k ends

i ends

Nella terminologia Dustyscript gli oggetto sono chiamati things, cose; hanno un costruttore ed eventuali metodi, ma non proprietà che, d’altronde, si possono simulare con I metodi. C’è il supporto dell’ereditarietà e dei metodi di classe, cioè metodi utilizzabili senza necessariamente instanziare un oggetto. Le interfaces sono schemi di metodi che possono essere implementati in things dell’utente.

thing quadrato {

  declare decimal surface;

  action quadrato takes decimal a gives ~ { /* constructor */

      surface is now (a times a);  };

action area takes ~  gives decimal { give surface; };   /* metodo d'istanza */

global {  /* metodo di classe */

    action numlati  takes ~  gives integer { give 4;}};

};

interface opbin {

   action binop takes integer uno, integer due gives integer;};

thing somma implements opbin {

action somma takes ~ gives ~ {};  /* constructor */

action binop takes integer one, integer two gives integer {

   integer three is one + two ; give three;};

};

thing prodotto implements opbin {

action prodotto takes ~ gives ~ {};  /* constructor */

action binop takes integer one, integer two gives integer {

   integer three is (one * two) ; give three;};

};

create somma op1;

create prodotto op2;

say "somma " + op1.binop using 1,7;

say "prodotto " + op2.binop using 7,3;

create quadrato q1 using 1.2 ;

say "area " + q1.area;

say "lati " + quadrato.numlati;

Esiste in Dustiscript qualche aspetto introspettivo quali debug, il test sul tipo di dato, poco significativo data la forte tipizzazione del linguaggio ed il testo sul tipo di oggetto: is type.

Dustyscript permette l’utilizzo dei package JAVA, utile per  disporre di un’interfaccia grafica.

L’esempio che segue è un programma che legge la descrizione di una macchina di Touring (Macchina di Turing par. 2.47 ) e produce un programma ML ( ML par. 2.50 ).

string head is "fun mdt (\"hlt\",m,_,_) = m\r\n  | mdt ";

declare string blocco ;  /* input */

integer seek is 0;

string lsb is "[";

string rsb is "]";

String q is "\"\"";

action word takes String in, integer n gives string {

    integer i is 1;

    integer ckw is 1;

    string w is "";

    as long as ckw < n {

        if i == in:size {give "";};

        if in:i == ' ' {ckw is now ckw +1;};

         i is now i+1;

       };

    character chr is  in:i;

    as long as chr != ' '   {

      w is now w +chr;

      i is now i + 1;

      if i > in:size {give "";};

      chr is now in:i;

     };

    give w;

};

 

action takeLine takes String blk gives String {

    string line is "";

       as long as seek < blocco:size  {

          seek is now seek + 1;

          if (blk:seek == '\r' )   { give; }

          else   {

              if (blk:seek != '\n')  {line is now line + blk:seek; };

          };

    };

     give line;

 };

say "Welcome to the Touring Machine program: input MdT source name'";

string flsource is ask;

if flsource:size is equal to 0 {flsource is now "mdt.src";};

say "reading "+flsource;

load blocco from flsource;   /* read Mdt source */

string source is "";

as long as seek < blocco:size {

    string line is takeLine using blocco;

    if (seek < blocco:size)  {

      if  line:1 is equal to  '-' {  say line;

      } else {

          if  (line:1 is equal to  '%') {

             line:1 is now ' ';

             source is now source  + line +"\r\n";

          } else {      /* state generation */

            

              string move is word using line,4;      /* move head */           

              if move == "R" {move is now "pc+1";} else  {move is now "pc-1";};

              string state is head;

              state is now state +"("+q:1 + word using line,1 + q:1;   /* State */

              state is now state + ",m,";            /* memoria */

              state is now state + lsb + word using line,2 +rsb + ",pc) = mdt(";

              state is now state + q:1 + word using line,5 + q:1;      /* Next State*/

              state is now state + ",exrep(m,pc,"+lsb+ word using line,3 + rsb +","+move+"),take(m," + move + ")," + move +")";

              source is now source  + state +"\r\n";

               head is now "  | mdt ";

           };

         };

    };

};

/* some final things */

source is now source + "  | mdt (_,_,_,_) = "+lsb+rsb+";\r\n"; /* close Mdt function */

source is now source + "fun run(m)  = mdt(\"S0\",m,take(m,1),1);\r\n";

say source;

save source to mdt.sm;