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; |