Questo semplice interprete si propone di realizzare una interfaccia user-friendly con il programmatore che puo' costruire un semplice programma utilizzando comandi con un linguaggio a lui famigliare (scrivi il file ..., apri l'archivio ..., ecc.).
L'interprete da me realizzato e' scritto in Java (vers. 1.1.5) ed e' volutamente semplice per mettere in evidenza tutta una serie di problemi legati a questo tipo di programmazione, come ad esempio il parsing di un file di testo, il controllo degli errori, ecc... . Tale interprete e' comunque espandibile, attraverso l'aggiunta di ulteriori comandi.
Inoltre, e' interessante notare che e' naturalmente possibile usare altri linguaggi di programmazione per codificare l'interprete. Ad esempio io ho impostato in Prolog (SICStus 3) alcune operazioni.
Tale interprete si presenterebbe utilissimo ad esempio per avvicinare i bambini alla programmazione: con un linguaggio simile al loro (ed in italiano) possono costruire semplici programmi, imparando i rudimenti essenziali della programmazione (come la lettura e scrittura di file, lettura e scrittura di variabili, operazioni con variabili e costanti, ecc...).

Ho pensato di mettere a disposizione del programmatore tutta una serie di comandi fondamentali (che ripeto puo' essere ampliata).

• apri : apre il file nomeFile

  apri il file nomeFile
  apri l'archivio nomeFile
  apri nomeFile



• leggi : legge il file nomeFile o una variabile var da tastiera

  leggi var : legge da tastiera e pone in var quanto letto
  
  leggi il file nomeFile : legge la riga corrente di nomeFile
  leggi l'archivio nomeFile : legge la riga corrente di nomeFile
  leggi nomeFile : legge la riga corrente di nomeFile
  

NOTA
Ad ogni comando leggi ... nomeFile, la riga corrente del file nomeFile viene letta e posta in una variabile istanza legata a quel particolare file; con un eventuale comando scrivi quella riga viene scritta su un altro file specificato dal comando scrivi o a video.
Una lettura consecutiva fa perdere il contenuto della riga letta precedentemente.
La prima volta che si incontra leggi ... nomeFile il file nomeFile viene aperto in input.



• scrivi : scrive quanto specificato in un file o a video

  scrivi var in|su nomeFile : scrive il contenuto di var nel file nomeFile
  scrivi var in|su|a video : scrive il contenuto di var a video
  scrivi nomeFile in|su|a video : scrive la riga corrente di nomeFile a video
  scrivi nomeFile1 in|su nomeFile2 : scrive la riga corrente di nomeFile1 sul file nomeFile2

  NOTA
  Costanti stringa o numeriche devono essere racchiuse tra doppi apici ("..."). Cosi' ad esempio il numero 24 deve essere scritto come "24"; "var1" rappresenta la stringa costante var1 e non il suo contenuto.
  La prima volta che si incontra scrivi nomeFile ... il file nomeFile viene aperto in output.




• ripeti [comandi] volte n : ripete i comandi specificati per n volte (n intero)
  
  NOTA
  Non e' possibile scrivere cicli nidificati.




• fai : esegue il calcolo specificato fra due interi

  fai var1 piu var2 in risvar : esegue la somma tra var1 e var2 mettendo il risultato in risvar
  fai var1 meno var2 in risvar : esegue la sottrazione tra var1 e var2 mettendo il risultato in risvar
  fai var1 per var2 in risvar : esegue il prodotto tra var1 e var2 mettendo il risultato in risvar
  fai var1 diviso var2 in risvar : esegue la divisione tra var1 e var2 mettendo il risultato in risvar

NOTA
var1 e var2 devono rappresentare numeri interi.



• fine : fa terminare l'interpretazione del file sorgente
  

Rispetto all'interprete piu' complesso per SCHEME (in Java), anche qui e' rispettata una certa estensibilita', permettendo cosi' al programmatore di sviluppare nuove istruzioni (nuovi comandi) per rendere piu' "potente" l'interprete.
Ma l'aspetto ancora piu' fondamentale e' quello di generalizzare il procedimento di costruzione che vede il passaggio del problema iniziale a una sua formalizzazione sintattica, in quanto la codifica con l'uno o l'altro linguaggio e' si importante, ma secondario rispetto alla generalizzazione suddetta.
Questa "generalizzazione" si ottiene appunto formulando una sintassi che sia chiara e che permetta di realizzare una grammatica non ambigua di classe LL(1).
Fatto questo esistono meccanismi (come i riconoscitori a tabelle di linguaggi LL(1) ) che permettono di codificare (automaticamente) la sintassi in esame attraverso un'analisi deterministica discendente con uno stile di programmazione guidato dai dati. (Uso di tabelle dette "parsing table" che indicano il comportamento dell'automa riconoscitore).
Per scrivere la sintassi adeguata ho utilizzato del formalismo BNF (Bakus Naus Form). Tale formalismo permette di isolare le categorie sintattiche al fine di definire (e successivamente di costruire) l'interprete vero e proprio.
Nella grammatica in esame le categorie sono legate alle istruzioni di ciclo (ripeti ... volte ...) e ai quattro comandi (apri, leggi, scrivi e fai), mentre, ad esempio, le categorie del meta-interprete LISP visto a lezione sono 8.
La realizzazione dell'interprete mediante il linguaggio Java ha messo in luce gli aspetti positivi legati all'adozione di tale linguaggio, come ad esempio la possibilita' di avere a disposizione classi e metodi gia' pronti (librerie di classi e metodi di Java) per il parsing di file di testo (StreamTokenizer()). Inoltre, per la realizzazione di un environment, ho potuto usare i metodi legati alla classe HashTable().
In Prolog, ad esempio, non si hanno meccanismi particolari per il parsing e per realizzare un environment.
Esistono pero' dei predicati (predicati definiti built-in) che permettono di realizzare in modo opportuno queste e altre operazioni. In particolare, per aprire un file in lettura (aprire il canale di input) esiste il predicato see(X).
Usando tali predicati e sfruttando le potenzialita' proprie del linguaggio Prolog e' possibile definire un interprete del mio linguaggio in Prolog invece che in Java.
Ovviamente la scelta del linguaggio di programmazione dipende da molti fattori : una ditta di sw puo' voler utilizzare un dato linguaggio ( o un insieme di linguaggi), oppure il programmatore conosce e preferisce programmare con un linguaggio particolare invece che un altro.
Supponendo pero' di avere una scelta libera e illimitata riguardo al linguaggio da utilizzare, la scelta cadra' naturalmente su quello che presenta piu' vantaggi.
Io ho scelto Java perche' tra le altre cose e' fornito di una vastissima libreria in grado di aiutare il programmatore a risolvere molti problemi, oltre ad essere un linguaggio particolarmente adatto alla programmazione su rete (vedi l'uso di applet su Internet). Infatti uno sviluppo interessante di un interprete e' quello di essere "portabile" su Internet e reso disponibile a chiunque ne abbia bisogno.
Da parte sua il Prolog permette un approccio piu' conversazionale, quindi piu' vicino alle esigenze umane, permettendo, grazie alle sua caratteristica dichiarativa, di concentrarsi sulle specifiche del problema ed a risolverlo, senza preoccuparsi molto dei dettagli della realizzazione in se. ( vedi E in Prolog?).
Cio' che e' importante osservare e' che qualsiasi sia il linguaggio scelto, la grammatica e in particolare le produzioni (sintassi) non cambiano. Quindi individuata una sintassi, la codifica puo' avvenire in un secondo momento e con il linguaggio scelto.
Occorre quindi definire in modo opportuno la grammatica, come piu' volte detto.
Volendo passare dall'interprete da me realizzato ad un interprete Prolog, ad esempio, basta modificare il componente software che effettua la valutazione di una frase F. Occorre poi introdurre una diversa interpretazione dei simboli di F, attraverso l'unificazionee la risoluzione, che rappresentano le caratteristiche peculiari (ed essenziali) del linguaggio Prolog.

L'interprete e' realizzato attraverso 3 classi appartenenti al package interp.
Ogni classe e' definita all'interno di un file. Il relativo file deve (e in effetti ha) lo stesso nome della classe che contiene.

• file FileF.java (contattatemi per avere il codice) : contiene la classe FileF e i metodo leggiF(), scriviF() e il costruttore della classe.
  • Il costruttore assegna le variabili istanza relative a tutti gli eventuali file aperti nel programma sorgente da interpretare
  • leggiF() legge una riga del file corrente ponendola nella variabile di istanza riga.
  • scriviF(String rig) scrive la riga rig passata come parametro nel file corrente.
  
  
• file Frasi.java (contattatemi per avere il codice) : contiene la classe Frasi e i metodi trovaF(), scanner(), calcola(), eseguiCom() e il costruttore della classe.
  • il costruttore della classe assegna le variabili istanza necessarie, cioe' il token corrente e un intero che permette di sapere se il token rappresenta una costante o no.
  • trovaF(String nnomeFile) cerca il file nomeFile passato come parametro e se esiste restituisce un numero intero che rappresenta l'indice dell'array che contiene tutte le variabili statiche che rappresentano i vari oggetti della classe FileF (ogni file un oggetto). Se il file nomeFile invece non esiste il metodo stampa un messaggio di errore e interrompe l'interpretazione.
  • scanner() controlla ogni token per poi decidere, chiamando eseguiCom o calcola(), quali azioni intraprendere. Questo metodo cerca anche di catturare eventuali errori contenuti nel file sorgente.
  • calcola(String a1,String a2,String oper,String r) esegue l'operazione indicata da oper sulle variabili a1 e a2 mettendo il risultato in r.
    Questo metodo controlla inoltre che le variabili abbiano un contenuto corretto cioe' che rappresentino numeri interi. Le variabili a1 e a2 potrebbero anche rappresentare delle costanti numeriche mentre r chiaramente no; r deve essere una variabile.
    Le variabili vengono memorizzate attraverso il meccanismo della Hashtable (coppie variabile,valore) fornito da java.
  • eseguiCom(String comando,String nome,int j) esegue il comando "comando" passato come parametro con nome (che puo' rappresentare un nome di file o una variabile a seconda del comando da eseguire) utilizzando j per sapere se il comando riguarda la tastiera o il video (allora j = 0) oppure un file (allora J = numero relativo nell'array degli oggetti della classe FileF).
  
  
• file Interp.java (contattatemi per avere il codice) : contiene la classe Interp e il metodo main().
  • Questa classe esegue, attraverso il metodo main(), il parsing del file sorgente passato come parametro all'atto dell'esecuzione dell'interprete (vedi Utilizzo dell'interprete).
    Il parsing e' ottenuto attraverso la classe StreamTokenizer di java. Ad ogni token viene creato un oggetto di Frasi e se diverso da "fine" o "ripeti" viene eseguito il metodo scanner() su quel token.
    Se il token e' "fine" allora il programma termina. Se il token e' "ripeti" allora siamo in presenza di un ciclo, che viene elaborato utilizzando la classe StreamTokenizer su uno StreamReader, dopo aver memorizzato in una stringa le righe di programma all'interno del ciclo.
    Vengono eseguiti all'interno del metodo main() numerosi controlli atti a prevenire errori di varia natura : esistenza del file sorgente, esistenza della parola chiave "volte" per terminare un ciclo, ecc... .

• Non e' possibile scrivere cicli (ripeti ... volte n) nidificati. inoltre all'interno di un ciclo possono trovare spazio al max 250 caratteri.
• E' possibile compiere le 4 operazioni fondamentali (somma, sottrazione, moltiplicazione, divisione) solo con numeri interi.
• E' possibile aprire al max 4 file (oltre al file sorgente da interpretare).
• Tutti i file aperti all'interno del file sorgente sono considerati dei file di testo.
• Tutte le variabili sono globali.