iorfader
29-11-2013, 06:08
qualcuno sà spiegarmelo?
View Full Version : come si crea un linguaggio di programmazione
DoctorT
29-11-2013, 08:12
qualcuno sà spiegarmelo?
non proprio però so che ci sono dei tools che ti aiutano a creare un linguaggio e qualche guida online tipo http://gnuu.org/2009/09/18/writing-your-own-toy-compiler/
non proprio però so che ci sono dei tools che ti aiutano a creare un linguaggio e qualche guida online tipo http://gnuu.org/2009/09/18/writing-your-own-toy-compiler/
AnonimoVeneziano
29-11-2013, 09:25
Ci sono due fasi:
1) Design del linguaggio
2) Implementazione
(che sono le stesse per la produzione di molte altre cose)
Nel Design si specifica bene la sintassi del linguaggio e la semantica di ogni costrutto.
Quello che si fa è in genere costruire una "Grammatica", che definisce la sintassi del linguaggio, una serie di "token" disponibili al linguaggio (gli equivalenti in C++ di "int, float, for, if, il punto e virgola, le parentesi ... etc") che rappresentano i caratteri o parole chiave che hanno un significato particolare all'interno del linguaggio e il possibile ordine che questi possono avere in un ipotetico programma scritto nel linguaggio.
Le Grammatiche più comuni per i linguaggi di programmazione sono le Context Free Grammars (http://en.wikipedia.org/wiki/Context-free_grammar), perchè sono più facili da parsificare.
Come esempio qui trovi la grammatica del C++ in formato BNF (uno dei formati standard per la rappresentazione delle grammatiche):
http://www.nongnu.org/hcb/
Una volta che il linguaggio è specificato bisogna implementarlo. Per implementarlo bisogna scrivere un inteprete o un compilatore per il linguaggio. Se il linguaggio è dinamico sarà necessario scrivere anche la libreria o virtual-machine di supporto a runtime.
Il compilatore è composto da 3 parti:
1) Front-end
2) Middle-end
3) Back-end
Il front-end è la parte che capisce il sorgente del programma e lo trasforma in un formato facilmente analizzabile e trasformabile (cosiddetta "Rappresentazione Intermedia" o IR).
Il middle-end in genere è composto di una serie di passi che trasformano la rappresentazione intermedia applicando algoritmi di ottimizzazione ben noti (constant folding, loop unswitching, loop unrolling ... etc) e altri meno noti che generano un programma ottimizzato. Il middle-end è in genere target independent (ossia non dipende dalla macchina su cui gira).
Il back-end è la fase finale che si occupa di trasformare la rappresentazione intermedia target independent in linguaggio macchina o assembly per la macchina target. Il back-end applica anche ottimizzazioni specifiche per la macchina target.
In particolare il Front-end è di interesse quando si implementa un linguaggio nuovo, in quanto per le architetture più famose compilatori come GCC o LLVM hanno ha disposizione Middle e Back-ends già belli completi ai quali si possono attaccare un nuovo front-end per il linguaggio che si sta sviluppando ottenendo un compilatore completo in breve tempo (in particolare LLVM va molto di moda al momento: http://llvm.org/ . Un front-end famoso per il linguaggio C/C++/Objective-C costruito su LLVM è CLANG: http://clang.llvm.org/ ) Il front-end è composto tipicamente da 3 parti:
1) Lexer
2) Parser
3) Analizzatore semantico
Il Lexer (analizzatore lessicale in italiano) è un programma che prende in input il sorgente del programma e riconosce le parole chiave e i simboli del linguaggio ( virgole, punti e virgola, parentesi .. etc) e li trasforma in TOKENS facilmente analizzabili. Inoltre il Lexer rimuove tutti gli spazi in genere dall'input, perchè non sono semanticamente rilevanti ( anche se in alcuni linguaggi lo sono come il python, dove credo vengano gestiti diversamente).
Il Parser prende in input l'output del Lexer e , applicando le regole della grammatica sull'input, esso riconosce la struttura del sorgente costruendo un albero sintattico (Abstract Syntax Tree) che rappresenta il programma. Ci sono vari algoritmi di parsing. I più famosi sono quelli di tipo "a discesa ricorsiva" (più intuitivi, comuni per grammatiche di tipo LL) o quelli "ad ascesa ricorsiva" (comuni per grammatiche di tipo LR o LALR).
CLANG per esempio usa un parser "a discesa ricorsiva"
L'analizzatore semantico in fine prende in input l'albero sintattico e lo trasforma in IR applicando delle regole semantiche al riconoscimento di ogni nodo dell'albero sintattico (ad esempio vedendo un nodo di addizione "+" emette una istruzione della rappresentazione intermedia "add" e via dicendo per esempio).
Alla fine di questi passaggi si ha un IR che si può dare in pasto ai middle e back ends del compilatore che generano un codice oggetto/eseguibile.
Ciao
1) Design del linguaggio
2) Implementazione
(che sono le stesse per la produzione di molte altre cose)
Nel Design si specifica bene la sintassi del linguaggio e la semantica di ogni costrutto.
Quello che si fa è in genere costruire una "Grammatica", che definisce la sintassi del linguaggio, una serie di "token" disponibili al linguaggio (gli equivalenti in C++ di "int, float, for, if, il punto e virgola, le parentesi ... etc") che rappresentano i caratteri o parole chiave che hanno un significato particolare all'interno del linguaggio e il possibile ordine che questi possono avere in un ipotetico programma scritto nel linguaggio.
Le Grammatiche più comuni per i linguaggi di programmazione sono le Context Free Grammars (http://en.wikipedia.org/wiki/Context-free_grammar), perchè sono più facili da parsificare.
Come esempio qui trovi la grammatica del C++ in formato BNF (uno dei formati standard per la rappresentazione delle grammatiche):
http://www.nongnu.org/hcb/
Una volta che il linguaggio è specificato bisogna implementarlo. Per implementarlo bisogna scrivere un inteprete o un compilatore per il linguaggio. Se il linguaggio è dinamico sarà necessario scrivere anche la libreria o virtual-machine di supporto a runtime.
Il compilatore è composto da 3 parti:
1) Front-end
2) Middle-end
3) Back-end
Il front-end è la parte che capisce il sorgente del programma e lo trasforma in un formato facilmente analizzabile e trasformabile (cosiddetta "Rappresentazione Intermedia" o IR).
Il middle-end in genere è composto di una serie di passi che trasformano la rappresentazione intermedia applicando algoritmi di ottimizzazione ben noti (constant folding, loop unswitching, loop unrolling ... etc) e altri meno noti che generano un programma ottimizzato. Il middle-end è in genere target independent (ossia non dipende dalla macchina su cui gira).
Il back-end è la fase finale che si occupa di trasformare la rappresentazione intermedia target independent in linguaggio macchina o assembly per la macchina target. Il back-end applica anche ottimizzazioni specifiche per la macchina target.
In particolare il Front-end è di interesse quando si implementa un linguaggio nuovo, in quanto per le architetture più famose compilatori come GCC o LLVM hanno ha disposizione Middle e Back-ends già belli completi ai quali si possono attaccare un nuovo front-end per il linguaggio che si sta sviluppando ottenendo un compilatore completo in breve tempo (in particolare LLVM va molto di moda al momento: http://llvm.org/ . Un front-end famoso per il linguaggio C/C++/Objective-C costruito su LLVM è CLANG: http://clang.llvm.org/ ) Il front-end è composto tipicamente da 3 parti:
1) Lexer
2) Parser
3) Analizzatore semantico
Il Lexer (analizzatore lessicale in italiano) è un programma che prende in input il sorgente del programma e riconosce le parole chiave e i simboli del linguaggio ( virgole, punti e virgola, parentesi .. etc) e li trasforma in TOKENS facilmente analizzabili. Inoltre il Lexer rimuove tutti gli spazi in genere dall'input, perchè non sono semanticamente rilevanti ( anche se in alcuni linguaggi lo sono come il python, dove credo vengano gestiti diversamente).
Il Parser prende in input l'output del Lexer e , applicando le regole della grammatica sull'input, esso riconosce la struttura del sorgente costruendo un albero sintattico (Abstract Syntax Tree) che rappresenta il programma. Ci sono vari algoritmi di parsing. I più famosi sono quelli di tipo "a discesa ricorsiva" (più intuitivi, comuni per grammatiche di tipo LL) o quelli "ad ascesa ricorsiva" (comuni per grammatiche di tipo LR o LALR).
CLANG per esempio usa un parser "a discesa ricorsiva"
L'analizzatore semantico in fine prende in input l'albero sintattico e lo trasforma in IR applicando delle regole semantiche al riconoscimento di ogni nodo dell'albero sintattico (ad esempio vedendo un nodo di addizione "+" emette una istruzione della rappresentazione intermedia "add" e via dicendo per esempio).
Alla fine di questi passaggi si ha un IR che si può dare in pasto ai middle e back ends del compilatore che generano un codice oggetto/eseguibile.
Ciao
iorfader
29-11-2013, 11:02
Ci sono due fasi:
1) Design del linguaggio
2) Implementazione
(che sono le stesse per la produzione di molte altre cose)
Nel Design si specifica bene la sintassi del linguaggio e la semantica di ogni costrutto.
Quello che si fa è in genere costruire una "Grammatica", che definisce la sintassi del linguaggio, una serie di "token" disponibili al linguaggio (gli equivalenti in C++ di "int, float, for, if, il punto e virgola, le parentesi ... etc") che rappresentano i caratteri o parole chiave che hanno un significato particolare all'interno del linguaggio e il possibile ordine che questi possono avere in un ipotetico programma scritto nel linguaggio.
Le Grammatiche più comuni per i linguaggi di programmazione sono le Context Free Grammars (http://en.wikipedia.org/wiki/Context-free_grammar), perchè sono più facili da parsificare.
Come esempio qui trovi la grammatica del C++ in formato BNF (uno dei formati standard per la rappresentazione delle grammatiche):
http://www.nongnu.org/hcb/
Una volta che il linguaggio è specificato bisogna implementarlo. Per implementarlo bisogna scrivere un inteprete o un compilatore per il linguaggio. Se il linguaggio è dinamico sarà necessario scrivere anche la libreria o virtual-machine di supporto a runtime.
Il compilatore è composto da 3 parti:
1) Front-end
2) Middle-end
3) Back-end
Il front-end è la parte che capisce il sorgente del programma e lo trasforma in un formato facilmente analizzabile e trasformabile (cosiddetta "Rappresentazione Intermedia" o IR).
Il middle-end in genere è composto di una serie di passi che trasformano la rappresentazione intermedia applicando algoritmi di ottimizzazione ben noti (constant folding, loop unswitching, loop unrolling ... etc) e altri meno noti che generano un programma ottimizzato. Il middle-end è in genere target independent (ossia non dipende dalla macchina su cui gira).
Il back-end è la fase finale che si occupa di trasformare la rappresentazione intermedia target independent in linguaggio macchina o assembly per la macchina target. Il back-end applica anche ottimizzazioni specifiche per la macchina target.
In particolare il Front-end è di interesse quando si implementa un linguaggio nuovo, in quanto per le architetture più famose compilatori come GCC o LLVM hanno ha disposizione Middle e Back-ends già belli completi ai quali si possono attaccare un nuovo front-end per il linguaggio che si sta sviluppando ottenendo un compilatore completo in breve tempo (in particolare LLVM va molto di moda al momento: http://llvm.org/ . Un front-end famoso per il linguaggio C/C++/Objective-C costruito su LLVM è CLANG: http://clang.llvm.org/ ) Il front-end è composto tipicamente da 3 parti:
1) Lexer
2) Parser
3) Analizzatore semantico
Il Lexer (analizzatore lessicale in italiano) è un programma che prende in input il sorgente del programma e riconosce le parole chiave e i simboli del linguaggio ( virgole, punti e virgola, parentesi .. etc) e li trasforma in TOKENS facilmente analizzabili. Inoltre il Lexer rimuove tutti gli spazi in genere dall'input, perchè non sono semanticamente rilevanti ( anche se in alcuni linguaggi lo sono come il python, dove credo vengano gestiti diversamente).
Il Parser prende in input l'output del Lexer e , applicando le regole della grammatica sull'input, esso riconosce la struttura del sorgente costruendo un albero sintattico (Abstract Syntax Tree) che rappresenta il programma. Ci sono vari algoritmi di parsing. I più famosi sono quelli di tipo "a discesa ricorsiva" (più intuitivi, comuni per grammatiche di tipo LL) o quelli "ad ascesa ricorsiva" (comuni per grammatiche di tipo LR o LALR).
CLANG per esempio usa un parser "a discesa ricorsiva"
L'analizzatore semantico in fine prende in input l'albero sintattico e lo trasforma in IR applicando delle regole semantiche al riconoscimento di ogni nodo dell'albero sintattico (ad esempio vedendo un nodo di addizione "+" emette una istruzione della rappresentazione intermedia "add" e via dicendo per esempio).
Alla fine di questi passaggi si ha un IR che si può dare in pasto ai middle e back ends del compilatore che generano un codice oggetto/eseguibile.
Ciao
grazie per la risposta completa :)
1) Design del linguaggio
2) Implementazione
(che sono le stesse per la produzione di molte altre cose)
Nel Design si specifica bene la sintassi del linguaggio e la semantica di ogni costrutto.
Quello che si fa è in genere costruire una "Grammatica", che definisce la sintassi del linguaggio, una serie di "token" disponibili al linguaggio (gli equivalenti in C++ di "int, float, for, if, il punto e virgola, le parentesi ... etc") che rappresentano i caratteri o parole chiave che hanno un significato particolare all'interno del linguaggio e il possibile ordine che questi possono avere in un ipotetico programma scritto nel linguaggio.
Le Grammatiche più comuni per i linguaggi di programmazione sono le Context Free Grammars (http://en.wikipedia.org/wiki/Context-free_grammar), perchè sono più facili da parsificare.
Come esempio qui trovi la grammatica del C++ in formato BNF (uno dei formati standard per la rappresentazione delle grammatiche):
http://www.nongnu.org/hcb/
Una volta che il linguaggio è specificato bisogna implementarlo. Per implementarlo bisogna scrivere un inteprete o un compilatore per il linguaggio. Se il linguaggio è dinamico sarà necessario scrivere anche la libreria o virtual-machine di supporto a runtime.
Il compilatore è composto da 3 parti:
1) Front-end
2) Middle-end
3) Back-end
Il front-end è la parte che capisce il sorgente del programma e lo trasforma in un formato facilmente analizzabile e trasformabile (cosiddetta "Rappresentazione Intermedia" o IR).
Il middle-end in genere è composto di una serie di passi che trasformano la rappresentazione intermedia applicando algoritmi di ottimizzazione ben noti (constant folding, loop unswitching, loop unrolling ... etc) e altri meno noti che generano un programma ottimizzato. Il middle-end è in genere target independent (ossia non dipende dalla macchina su cui gira).
Il back-end è la fase finale che si occupa di trasformare la rappresentazione intermedia target independent in linguaggio macchina o assembly per la macchina target. Il back-end applica anche ottimizzazioni specifiche per la macchina target.
In particolare il Front-end è di interesse quando si implementa un linguaggio nuovo, in quanto per le architetture più famose compilatori come GCC o LLVM hanno ha disposizione Middle e Back-ends già belli completi ai quali si possono attaccare un nuovo front-end per il linguaggio che si sta sviluppando ottenendo un compilatore completo in breve tempo (in particolare LLVM va molto di moda al momento: http://llvm.org/ . Un front-end famoso per il linguaggio C/C++/Objective-C costruito su LLVM è CLANG: http://clang.llvm.org/ ) Il front-end è composto tipicamente da 3 parti:
1) Lexer
2) Parser
3) Analizzatore semantico
Il Lexer (analizzatore lessicale in italiano) è un programma che prende in input il sorgente del programma e riconosce le parole chiave e i simboli del linguaggio ( virgole, punti e virgola, parentesi .. etc) e li trasforma in TOKENS facilmente analizzabili. Inoltre il Lexer rimuove tutti gli spazi in genere dall'input, perchè non sono semanticamente rilevanti ( anche se in alcuni linguaggi lo sono come il python, dove credo vengano gestiti diversamente).
Il Parser prende in input l'output del Lexer e , applicando le regole della grammatica sull'input, esso riconosce la struttura del sorgente costruendo un albero sintattico (Abstract Syntax Tree) che rappresenta il programma. Ci sono vari algoritmi di parsing. I più famosi sono quelli di tipo "a discesa ricorsiva" (più intuitivi, comuni per grammatiche di tipo LL) o quelli "ad ascesa ricorsiva" (comuni per grammatiche di tipo LR o LALR).
CLANG per esempio usa un parser "a discesa ricorsiva"
L'analizzatore semantico in fine prende in input l'albero sintattico e lo trasforma in IR applicando delle regole semantiche al riconoscimento di ogni nodo dell'albero sintattico (ad esempio vedendo un nodo di addizione "+" emette una istruzione della rappresentazione intermedia "add" e via dicendo per esempio).
Alla fine di questi passaggi si ha un IR che si può dare in pasto ai middle e back ends del compilatore che generano un codice oggetto/eseguibile.
Ciao
grazie per la risposta completa :)
paolomec
29-11-2013, 13:42
David Gries - Principi di progettazione di compilatori 1978 Franco Angeli ed. (1971 John Wiley & Sons Inc.)
Aho -Ullman - Principles of Compiler Design addison wensley 1977
... Bei tempi ....
Aho -Ullman - Principles of Compiler Design addison wensley 1977
... Bei tempi ....
vBulletin® v3.6.4, Copyright ©2000-2025, Jelsoft Enterprises Ltd.