Come creare un linguaggio di programmazione

Molti programmatori o, appassionati di programmazione, durante il loro percorso professionale, si trovano a dover utilizzare svariati linguaggi di programmazione, e spesso a sfruttare tecniche e algoritmi, a volte anche molto sofisticati, per la risoluzione di problematiche che via via si manifestano.

Durante tale percorso, molti di loro, si pongono questa domanda: Come creare un linguaggio di programmazione?”, oppure, Cosa si nasconde dietro un comando di un qualsiasi linguaggio?.

Prima di rispondere a questa domanda, cercheremo di capire quanti tipi di linguaggi di programmazione esistono.

Oggi, abbiamo due tipologie di linguaggi, esistono linguaggi compilati e linguaggi interpretati. La differenza è sostanziale, nei linguaggi compilati, il codice sorgente, cioè il nostro programma, viene convertito in un file eseguibile direttamente dalla macchina senza l’ausilio di nessun software di traduzione intermedio. Nei linguaggi interpretati invece, il nostro sorgente, non viene convertito in un file eseguibile ma, tradotto comando per comando ed eseguiti di volta in volta da un programma intermedio chiamato interprete.

Riepilogando possiamo dire che, i linguaggi compilati vengono convertiti da un software chiamato compilatore, mentre i comandi di un linguaggio interpretato vengono eseguiti direttamente da un software chiamato interprete.

corso javascript per principianti

In questo articolo vi spiegherò come creare un linguaggio di programmazione, nello specifico un interprete, in quanto “più semplice ed immediato” della progettazione di un compilatore, che richiederebbe non solo una conoscenza approfondita di alcuni strumenti molto sofisticati, che vedremo, ma anche una conoscenza avanzata del tipo di processore che dovrà eseguire il codice.

Ma cosa sarai in grado di fare dopo la lettura di questo articolo? Beh, capirai l’uso di un Lexer e di un Parser, come programmarli fino a progettare una tua propria shell dei comandi e alla creazione di uno dei comandi essenziali per qualsivoglia linguaggio: “il comando Print”. Insomma scoprirai come creare comandi, passare loro parametri ed eseguirli all’interno della Shell di comandi, che progetterai e personalizzerai a tuo piacimento. Non solo ma vedrai anche come eseguire questi comandi salvandoli all’interno di uno script e creare il tuo interprete.

Software necessari

Come ogni progetto che si rispetti, abbiamo bisogno di scaricare il necessario, cioè allestire la nostra cassetta degli attrezzi, per poter configurare l’ambiente di progettazione indispensabile per tale scopo, gli strumenti che utilizzeremo sono tutti open source, cioè scaricabili e utilizzabili gratuitamente. Tutti i software che utilizzeremo sono disponibili per i più diffusi Sistemi Operativi, pertanto quello che vedremo in questo articolo non è orientato ad uno specifico sistema operativo ma, è applicabile sia a sistemi Windows che Linux.

Editor di testi

Dato che avremo bisogno di editare file di testo, abbiamo bisogno necessariamente di un editor di testi. Tra i tanti disponibili in rete, ti consiglio Visual studio Code, è l’editor di Microsoft gratuito e dalle ottime caratteristiche, ideale per ogni linguaggio e progetto software.

Per scaricare Visual Studio Code vai a questo link dove potrai scegliere il pacchetto per il S.O. desiderato e procedere con l’installazione, come mostrato in figura:

come creare un linguaggio di programmazione

Questo editor non ha bisogno, per la nostra esigenza, di configurazione o personalizzazione ma, qui trovi un video esplicativo del processo di download e installazione di Visual Studio Code.

Ad ogni modo, per questa tipologia di progetto, non sei obbligato ad utilizzare per forza Visual Studio Code ma, puoi scegliere tra tante altre alternative open source disponibili, e qui trovi gli editor di testo più utilizzati dagli sviluppatori.

Compilatore linguaggio C

Un altro tool necessario è un compilatore del linguaggio C, noi utilizzeremo MinGW,

MinGW è il porting in ambiente Windows del famoso compilatore GCC per Linux.

Solo e soltanto se usi Windows, devi scaricare il compilatore C MinGW da questo link, per Linux non c’è bisogno, lo installeremo con un semplice comando da terminale, come vedremo più avanti.

Successivamente, sempre e solo in Windows, estrai, copia e incolla la cartella mingw in C:, aggiorna la variabile di sistema PATH inserendo c:\mingw\bin. Se hai problemi nell’impostare la variabile d’ambiente “PATH” in Windows, clicca qui.

Comunque se segui questi semplici passaggi effettuerai questa operazione in un secondo. Per prima cosa clicca con il tasto destro del mouse sulla voce “Questo PC” e successivamente su “proprietà”, come in figura:

come creare un linguaggio di programmazione

Clicca sulla voce “Impostazioni di sistema avanzate” e poi su “variabili di ambiente”, come in figura:

come creare un linguaggio di programmazione

Seleziona, nel riquadro in basso relativo alle variabili di sistema, la riga che evidenzia il contenuto della variabile path, e poi clicca su modifica, come in figura:

come creare un linguaggio di programmazione

Clicca sul pulsante “Nuovo”, inserisci il seguente percorso: c:\mingw\bin, e successivamente su “Ok”, come in figura:

come creare un linguaggio di programmazione

Riavvia il computer, per rendere effettive le modifiche apportate, alla variabile di sistema Path.

Per quanto riguarda l’installazione del compilatore C in Linux, le cose sono leggermente più semplici, questo significa che il tutto si riduce ad impartire il seguente comando da terminale: sudo apt-get install gcc.

Installare il Parser

Adesso è venuto il momento di installare un software che, farà da parte attiva, insieme al successivo che installeremo, parliamo di Bison. Sostanzialmente Bison è un software che analizza un flusso di dati, ricevuto dalla shell dei comandi o da uno script, al fine di riconoscere la grammatica di un comando o di un costrutto di un linguaggio di programmazione.

Attraverso Bison, genereremo il parser per il nostro interprete. Più avanti vedremo nel dettaglio come funziona, adesso limitiamoci ad installarlo.

Se disponi di un sistema Windows, non devi installare nulla, in quanto, Bison è già stato integrato, da me, nel pacchetto che hai scaricato al punto precedente. Ma se disponi di una distribuzione Linux, così come è avvenuto con il compilatore C, non dobbiamo fare altro che digitare il seguente comando da terminale: sudo apt-get install bison

Ti potrebbe Interessare: come installare windows 10 su raspberry Pi. 4 e Pi 3

Installare l’analizzatore lessicale

Prima ho parlato di Bison come la parte attiva insieme ad un altro software, per la progettazione di un interprete. Quest’altro software è Flex, Flex è un analizzatore lessicale, cioè un generatore di scanner, in grado di analizzare un flusso dati, ricevuto dalla shell dei comandi o da uno script, al fine di riconoscere le keywords, i simboli e quant’altro, e compiere una determinata azione ogni volta che incontra una determinata combinazione di caratteri, chiamata TOKEN.

Tranquillo niente di complesso ma, come ho detto per Bison, adesso preoccupiamoci solo di installare Flex e successivamente capirai anche come funziona.

Per cui, se possiedi un sistema Windows non devi installare nulla, in quanto Flex è già stato integrato, da me, nel pacchetto che hai appena scaricato precedentemente. Ma se disponi di una distribuzione Linux, così come è avvenuto con il compilatore C e Bison, non dobbiamo fare altro che digitare il seguente comando da terminale: sudo apt-get install flex

Verifica della corretta installazione dei software

La nostra cassetta degli attrezzi è pronta ma, dobbiamo verificare che tutto quello che è stato appena fatto è funzionante e regolarmente configurato. Quindi, non devi fare altro che digitare i seguenti comandi da prompt dei comandi di Windows o, da terminale Linux:

gcc –version

Premi Invio, in risposta se otterrai indicazioni, circa la versione di gcc installato, significa che il compilatore C è stato installato correttamente, come mostrato in figura:

come creare un linguaggio di programmazione

bison –version

Premi Invio, in risposta se otterrai indicazioni, circa la versione di bison installata, significa che il generatore di Parser è stato installato correttamente, come mostrato in figura:

come creare un linguaggio di programmazione

flex –version

Premi Invio, in risposta se otterrai indicazioni, circa la versione di flex installata, significa che il generatore di scanner è stato installato correttamente, come mostrato in figura:

come creare un linguaggio di programmazione

Le espressioni regolari

Adesso dobbiamo prendere in considerazione un oggetto, molto usato dagli sviluppatori, che è conosciuto come “espressione regolare”. Sicuramente avrai già sentito parlare di espressioni regolari oppure le hai già utilizzate in passato.

Sono utilizzate per ricercare e sostituire porzioni di testo in stringhe, per cui sono ampiamente usate da tutti i linguaggi di programmazione, non solo, vengono ad esempio utilizzate anche dagli editor di testo per ricercare e sostituire stringhe nel codice sorgente.

Se sei un abile utilizzatore, delle espressioni regolari, puoi anche tralasciare questo paragrafo e passare al successivo, altrimenti ti consiglio di proseguire con la lettura in quanto, questo tipo di oggetto, inventato nel lontano 1950 e attualmente ancora insostituibile, rappresenta uno dei pilastri fondamentali della programmazione.

Ad ogni modo, in questo articolo, non tratterò le espressioni regolari nel suo complesso, ci sono libri interi che trattano l’argomento ma, vedremo solo l’aspetto riguardante la ricerca di stringhe all’interno di flussi di dati, come potrebbe essere, ad esempio, un file di testo.

Quindi, senza entrare troppo nello specifico, le espressioni regolari verranno utilizzate da Flex, cioè dal generatore di scanner, per individuare i TOKEN, cioè le keywords del nostro interprete, all’interno di uno script o file sorgente.

La cosa sembra complessa ma non lo è affatto. Quando vedrai come lavora Flex ti renderai subito conto della semplicità delle espressioni regolari e del loro irrinunciabile vantaggio offerto allo sviluppo.

Ti consiglio di dare un’occhiata a questo video tutorial, non è necessario, ma avrai già da subito l’idea, di cosa sono le espressioni regolari e di come utilizzarle.

La struttura dell’interprete

Prima di passare alla fase di implementazione del lessico e della grammatica del nostro interprete, dobbiamo scaricare un ultimo pacchetto software. Riguarda un file, compresso, preparato, da me, e che contiene la struttura dell’interprete, composta da cartelle e file, già preparate ad hoc, per metterti nelle condizioni di capire subito, aprendo opportuni file che ti spiegherò, come avviene la progettazione vera e propria dell’interprete.

Quindi, scarica da questo link, ed estrai il contenuto, cioè l’interprete, nella posizione sul pc che ritieni più opportuna, già compilabile ed eseguibile. Nei paragrafi successivi, ti spiegherò passo passo, il contenuto dei file e come personalizzare il lessico e la grammatica, programmando opportunamente il lexer e il parser.

A termine download, troverai una cartella nominata “linguaggio”, che conterrà questa struttura:

come creare un linguaggio di programmazione

Tanto per completezza e, sicuramente lo avrai già notato, io sto utilizzando Windows 10, ed ho decompresso il file linguaggio.zip sul mio desktop. Tengo a precisare, come ho ribadito già precedentemente che, tutto quello che faremo con questo progetto in Windows 10 è applicabile anche a qualsiasi altra distribuzione Linux.

Implementazione del lessico

Adesso entra in gioco Visual Studio Code. Quindi, non devi fare altro che aprire l’editor della Microsoft, e cliccare sulla voce “File” del menù principale e successivamente sulla voce “Open Folder”, scegliere la cartella “linguaggio” e cliccare su “Selezione cartella”.

Il risultato è mostrato in figura:

come creare un linguaggio di programmazione

nel frame di sinistra, noterai elencato tutto il contenuto della cartella “linguaggio”, adesso dovrai aprire il file “lexer.l”, cliccandoci sopra, che ci permetterà di programmare lo scanner. Questo file successivamente verrà dato in pasto a Flex, che genererà lo scanner perfetto per il nostro interprete.

Questo file è composto da quattro sezioni. Nella prima sezione, cioè quella racchiusa tra i caratteri “%{“ e “%}”, sono presenti solo istruzioni di inclusione di file header della libreria standard di C. in questa sezione per il momento non apporteremo nessuna modifica.

Nella seconda sezione, cioè quella racchiusa tra i caratteri “%}” e “%%”, sono presenti istruzioni già più interessanti della prima. Infatti il codice seguente:

Number       	([0-9]+)|([0-9]+\.[0-9]+)|(\.[0-9]+)
Argument	(([-*./|a-zA-Z])|([-*./|_a-zA-Z][-*./|_a-zA-Z0-9]+))
String        	\"(([^\"]*)|([\!]*))\"
Identifier    	@?(([a-zA-Z])|([_a-zA-Z][_a-zA-Z0-9]+))

Non hanno bisogno di commenti, si capisce subito, leggendo gli identificatori che, tutto quello che segue la dicitura Number, rappresenta l’espressione regolare che serve allo scanner per ricercare un numero presente all’interno del flusso dati ricevuto dallo scanner stesso, o dal nostro script di comandi. Anche qui, e giusto per richiamare quanto detto precedentemente con le espressioni regolari, non devi apportare nessuna modifica. Questo identificatore ritorna il token NUMBER al parser.

La stessa cosa vale per l’identificatore String, la cui espressione regolare, da indicazioni allo scanner per ricercare eventuali stringhe, contenute nel flusso dati, o nel nostro script di comandi. Questo identificatore ritorna il token STRING al parser.

La stessa cosa vale per l’identificatore Argument, la cui espressione regolare, da indicazioni allo scanner per ricercare eventuali argomenti o parametri, passati ai comandi che creeremo, contenute nel flusso dati, o nel nostro script di comandi. Questo identificatore ritorna il token ARGUMENT al parser.

La stessa cosa vale per l’identificatore Identifier, la cui espressione regolare, da indicazioni allo scanner per ricercare eventuali identificatori, ad esempio nomi di variabili o quant’altro, passati ai comandi che creeremo, contenute nel flusso dati, o nel nostro script di comandi. Questo identificatore ritorna il token IDENTIFIER al parser.

Queste righe di codice:

A [aA]
B [bB]
C [cC]
D [dD]
E [eE]
…
…

rendono il nostro interprete No Case Sensitive. Cioè i comandi che creeremo, e tutto ciò che scriveremo nei nostri script di comandi, potrà essere scritto indifferentemente in minuscolo o maiuscolo, e di conseguenza lo scanner individuerà senza problemi, ad esempio, il comando PRINT, in ognuna di queste forme: PRINT che Print sia pRiNt, ecc…

Nella terza sezione, cioè quella che contiene le seguenti istruzioni:

P}{R}{I}{N}{T}	{ return PRINT; }
{C}{L}{E}{A}{R}	{ return CLEAR; }
{H}{E}{L}{P}	{ return HELP; }
{Q}{U}{I}{T}	{ return QUIT; }
{E}{X}{I}{T}	{ return EXIT; }
{D}{I}{R}	{ return DIR; }
{C}{L}{S}	{ return CLS; }
"("		{ return OPENBRACKET;}
")"		{ return CLOSEBRACKET;}
","		{ return COMMA;}

qui sono contenuti i comandi che creeremo, in questo caso sono già stati inseriti i comandi: PRINT, CLEAR, HELP, QUIT, EXIT, DIR, CLS. Come puoi notare a destra di ogni comando e specificato tra parentesi graffe il TOKEN che verrà inviato al parser, cioè a Bison, ma vedremo successivamente come il parser verificherà la grammatica del comando, eseguendo il codice associato.

Nella quarta sezione, cioè quella che contiene le seguenti istruzioni:

int main(int argc, char **argv) {
    ++argv;
    yyin = stdin;
    if ( --argc > 0 ) {
       // il flusso dati è lo script
       prompt = "";
       yyin = fopen(argv[0], "r");
   } else {
      // il flusso dati è la shell di comandi
      printf("%s", consoleMex);
      printf(prompt);
   }
    while(true) {
        if (yyparse() != 0) {
// richiamata yyerror, se nessun TOKEN viene individuato
// parliamo del classico syntax error
        }
    } 
}
int yywrap(void) {
   return 0;
}
int yyerror(const char *errormsg) {
   fprintf(stderr, "%s\n", errormsg);
   exit(1);
}

è la parte di codice C, che mette in moto lo scanner. Stiamo parlando di quella parte di codice che scansiona il flusso dati, attraverso la funzione yyparse(), cioè il nostro script di comandi, riconosce i TOKEN specificati nella terza sezione, e li invia al parser. Nel prossimo paragrafo vedremo come, quest’ultimo riconosce la grammatica di un comando, e ne esegue il codice C associato.

Prima di passare alla descrizione del parser, voglio fare una precisazione. La parte di codice che segue l’istruzione: yyin = stdin; serve ad eseguire i comandi o le istruzioni che creeremo, in due ambienti diversi. Cioè se quando esegui l’interprete, passi come argomento un file, il nostro script di comandi, allora lo scanner leggere lo script e lo considererà come flusso dati da verificare. se invece quando esegui l’interprete, non passi nessun argomento, allora lo scanner aprirà una shell di comandi, e tutto ciò che digiterai da tastiera verrà verificato dallo scanner. Di conseguenza verrà visualizzata una shell di comandi, il nostro terminale, con un messaggio iniziale, e da lì in poi tutto quello che digiti verrà processato dallo scanner e considerato come flusso dati in ingresso da gestire.

Ribadisco che in questa sezione, per il momento, non devi apportare nessuna modifica.

Implementazione della grammatica

Adesso entriamo nel vivo del discorso, stiamo per vedere come lavora un parser. Per il momento, sempre nel frame di sinistra, apri il file “parser.y” cliccandoci sopra. Questo file è composto da varie sezioni, ma la più interessante è questa:

commands:  
         printstmt 
       | dirstmt
       | helpstmt
       | quitstmt
       | clsstmt
       | clearstmt
       ;

gli identificatori che seguono la direttiva “commands”, non sono altro che nomi associati alla grammatica di ogni comando creato. Per esempio, al comando PRINT ho associato il nome print+stmt che sta per statement (istruzione), ma tu puoi dare il nome che desideri. Per cui, il comando DIR (lista di cartelle e file, comando molto conosciuto… che avrai usato mille volte) ho associato il nome dir+stmt, ecc…

Ogni altro comando deve essere aggiunto in questa sezione specificandone il nome che assocerai alla grammatica. Ma lo vedremo tra un po’.

Tutto il codice che segue la dichiarazione “commands” è la grammatica vera è propria, ad esempio:

printstmt:
   PRINT STRING { 
      printStatement($2);    
      if(strlen(prompt) > 0) printf("\n");
   }
;

Questo codice, è di una semplicità disarmante, ma vediamo nel dettaglio cosa fa. Innanzitutto la dichiarazione “printstmt:” sta ad indicare che il codice che segue è associato alla direttiva “printstmt” richiamata in “commands” e verificata ciclicamente tutte le volte che viene ripetuta all’interno dello script o digitato nella shell di comandi.

I token PRINT STING, specificano la grammatica del comando PRINT. Cioè il comando PRINT è costituito dal token PRINT + un argomento, che in questo caso è una stringa, STRING. Ad esempio, potremmo digitare qualcosa del genere: print “Hello world”.

Il codice che segue la grammatica di PRINT, cioè: printStatement($2); esegue la funzione printStatement che troverai nella sottocartella “statements” posizionata sotto “linguaggio”, ricordi?

Solo una precisazione, circa l’argomento $2, della function printStatement. Nella dichiarazione della grammatica del comando PRINT e cioè: PRINT STRING, il parser associa ad ogni TOKEN presente, un progressivo preceduto dal simbolo $. In questo caso a PRINT è associato $1 e a STRING è associato $2. Questo significa che quando viene richiamata la function printStatement, il parametro $2 conterrà la stringa passata come argomento a PRINT, e così via, per cui potremmo avere anche un $3, un $4 e così via. Parliamo di parametri, che compongono la grammatica del comando e che potrebbero contenere stringhe, numeri e quant’altro.

Torniamo al comando PRINT. In questo caso, e per ogni comando, creerai due file nella cartella “statements”, è cioè printstmt.c e printstmt.h, il primo che contiene il codice vero è proprio del comando print e il secondo non è altro che il file header, così come prevede il linguaggio C.

Vediamo cosa contiene il file printstmt.c:

#include <stdio.h>
#include <stdlib.h>
#include "../global.h"
#include <string.h>
#include "printstmt.h"
void printStatement(const char* stringLiteral) {
   printf("%s", stringLiteral);
}

Qui vediamo che, una volta verificata la grammatica, il parser esegue questa porzione di codice:

void printStatement(const char* stringLiteral) {
   printf("%s", stringLiteral);
}

E il parametro stringLiteral, contiene il contenuto passato dall’argomento $2. Pertanto ogni comando sarà composto esattamente come PRINT. Per cui il comando PRINT non fa altro che stampare a video il contenuto a video, passato dal token STRING, e associato a $2 dal parser, con questa istruzione: printf(“%s”, stringLiteral);

A te, lascio il compito di vedere cosa è stato fatto per gli altri comandi che troverai descritti in parser,y, per quanto riguarda la grammatica e, nei relativi file contenuti nella sottocartella “statements”, per quanto riguarda l’azione associata ad ogni comando.

Compilazione dell’interprete

il compito legato alla programmazione dei comandi e della relativa shell è terminato, adesso dobbiamo vedere in esecuzione il nostro interprete ed iniziare ad eseguire qualche comando da shell o da file script.

La prima operazione necessaria da effettuare è compilare il nostro interprete, non solo, devono essere generati anche lo scanner e il parser. Ricordi quanto detto precedentemente con Flex e Bison?

A tal proposito ho implementato un file make sia per windows che per ambiente Linux. I due file li trovi sotto la root del progetto e cioè la cartella “linguaggio”.

Quindi, basta lanciare, da prompt dei comandi o da terminale linux, rispettivamente il file make.bat per windows e make.sh per linux. Questo è tutto, il file make genererà un eseguibile chiamato “console.exe”, rinominabile a tuo piacimento, che è l’interprete. Se esegui console.exe senza argomenti apre il solo prompt dei comandi dell’interprete e tutto ciò che digiti verrà direttamente interpretato dallo scanner a video, mentre se passi a console.exe un file, come ad esempio il file script.prg, tutto quanto contenuto all’interno dello script verrà interpretato dallo scanner.

Va precisato che, volutamente, tutti gli altri comandi, parlo di: CLEAR, HELP, QUIT, EXIT, DIR, CLS, non hanno un corrispondente file “.c” nella cartella “statements”. Questo perché non sempre è necessario associare l’azione di un comando in un file separato. Ma come per questi comandi ho preferito associare l’azione del comando, direttamente all’interno della grammatica, e cioè nel file parser.y. Questa tecnica è consigliabile quando l’azione da associare è eseguibile con poche righe di codice.

Tanto per chiarezza ti ripropongo il codice associato al comando DIR:

dirstmt:
         DIR ARGUMENT {  
            if(strlen(prompt) > 0) {
               char *dest;
               char *src;
               strcpy(dest, "dir ");
	   strcpy(src, $2);
	   strcat(dest, src);
	   system(dest); 
	}
         }
         | DIR { 
            if(strlen(prompt) > 0) system("dir *.*"); 
         }
  ;

Come puoi vedere, questo comando agiste solo all’interno della shell, questo si evince dal fatto che le istruzioni sono tutte inserite all’interno di: if(strlen(prompt) > 0). Il comando non fa altro che eseguire il comando “dir *.*” se non ha argomenti, altrimenti esegue DIR con l’argomento contenuto all’interno della variabile $2. $2 potrebbe essere qualsiasi cosa, ad esempio, *.prg, cioè qualsiasi cosa digitata da te da shell. Il tutto è eseguito attraverso la function “system” della libreria standard di C, che consente di lanciare comandi del sistema operativo.

Da notare che il comando, nel file parser.y, ha due varianti della grammatica, cioè DIR ARGUMENT e DIR. Le due grammatiche sono interpretate ed associate dal carattere “|”, vale a dire o questa grammatica: DIR ARGUMENT o quest’altra DIR.

Conclusione

Cercherò di riepilogare il processo di creazione di un altro comando. Quindi, come prima cosa devi modificare il file lexer.l, ed aggiungere, subito dopo questa istruzione: {C}{L}{S} { return CLS; } il tuo comando, ad esempio: {M}{I}{O}{C}{O}{M}{A}{N}{D}{O} { return MIOCOMANDO; }.

Successivamente, devi modificare il file parser,y e, aggiungere subito dopo la seguente istruzione: | clearstmt, a riga 37, la dichiarazione che identificherà lo statement relativo al token MIOCOMANDO, e cioè: | miocomandostmt.

Aggiungi, prima del carattere “%%” di fine file, un blocco identico a questo:

miocomandostmt:
       MIOCOMANDO { 
          // istruzioni in pura filosofia C 
      }
 ;

nel caso in cui hai deciso di apportare l’azione corrispondente alla grammatica di MIOCOMANDO in un file .c separato, allora devi aggiungere due file nella cartella “statements”, e cioè: miocomandostmt.c e miocomandostmt.h, ed aggiungere dopo la riga gcc -w -c statements/printstmt.c -o statements/printstmt.o,la seguente istruzione: gcc -w -c statements/miocomandostmt.c -o statements/miocomandostmt.o, e modificare l’istruzione: gcc -w -o console.exe global.o statements/printstmt.o y.tab.o lex.yy.o, in questo modo: gcc -w -o console.exe global.o statements/printstmt.o statements/miocomandostmt.o y.tab.o lex.yy.o lasciando inalterato il resto.

Le stesse modifiche vanno apportate anche al file make.sh, per ambiente linux, alla stessa stregua di quanto fatto in make.bat. A questo punto non ti resta che eseguire da prompt dei comandi “make.bat” o, “make.sh” in Linux, come mostrato in figura:

come creare un linguaggio di programmazione

A termine esecuzione del file make, si aprirà automaticamente l’interprete “eseguendo il file “console.exe”, digita il tuoi comandi direttamente da shell, oppure con console.exe script.prg, farai eseguire all’interprete i comandi memorizzati all’interno del file script.prg, come mostrato in figura:

come creare un linguaggio di programmazione

Spero di esserti stato di aiuto e di aver fugato ogni tuo tipo di dubbio su un argomento relativamente ostico.

Seguimi su

Antonio Lamorgese

Amministratore di rete, programmatore ed esperto di pratiche SEO. Dopo anni di esperienza nel settore, ho ideato un generatore di codice PHP Scopri di più su https://www.phpcodewizard.it.

x