Newsgroup: it.comp.lang.c++
Titolo: come si crea un linguaggio (intepretato)?

come da topic ...
1) mi serve una grammatica giusto  ?
    come si crea una grammatica ?
2)non lo so chiedo info
in linguaggio è di mia invenzione quindi molto semplice...
-- 
~------------------------------------------~
...come sempre grazie Ciao... 


Nota:
Devo approffondire la domanda purtroppo ora non posso... quindi proseguirò 
dopo...


Non credo che questo ng sia il posto giusto per spiegare come si crea 
una grammatica, ma per creare un lexer+parser in C e C++ puoi usare flex 
e bison, invece che sporcarti le mani e scrivere il codice da zero. 
Ovviamente, devi esprimere la grammatica del tuo linguaggio in modo 
formale...
GNU flex: 
http://www.gnu.org/software/flex/
GNU bison: 
http://www.gnu.org/software/bison/
Daniele

 ha scritto nel messaggio
news:cpk003$q8d$1...@balena.cs.interbusiness.it...

Riprendo la mia domanda (eravate in ansia veroo?) :-)
Quello che devo realizzare non è proprio un linguaggio
di programmazione interpretato ma neanche uno script
Sinceramente non ho mai trattato queste cose (non nego che mi interesserebbe
molto)
quindi non so bene come definire il mio prolema.
Vado subito al sodo :
Io ho delle classi di dati (classi stupide senza inteligenza teoricamente
con soli metodi get /set)
queste classi caricano i loro dati tramite altre classi chiamate mappe le
mappe sono le classi che devo
appunto gestire tramite questo mio linguaggio (lo chiamo così.  In sostanza
questo mio linguaggio lo devo usare per manipolarele le mappe dentro il mio
codice sorgente.)
Ci sarà un engine che legge il codice e gestisce/crea queste mappe
per adesso non voglio crearle ma solo usarle in pratica il codice viene
usato  per
gestire una sola mappa(da questo punto di vista credo sia più semplice)
E' come se dentro il codice ho un'altro linguaggio (inventato da me ) il
tutto
potrebbe essere paragonato all'sql innestato nei sorgenti.
Solo che l'sql viene "visto" sotto forma di stringa il mio linguaggio lo
voglio gestire sotto forma di metodi! (classi)
Se è poco chiaro mi scuso (fattemelo sapere) e che io ho in mente cosa
voglio ma non conosco le problematiche che
si presentano sulla creazione di un linguaggio, quindi peccherò sicuramente
di chiarezza.
grazie ciao

Non c'ho capito una sega. Ma prova un po' con spirit:
 
http://boost.org/libs/spirit/doc/basic_concepts.html
-- 
int

"int i=0 0" <'@.'> ha scritto nel messaggio 
news:NGdwd.44672$C94....@tornado.fastwebnet.it...

Grassie la semplifico
devo gestire tramite un gerarchia di classi un linguaggio tipo sql .
esempio pratico:
classemetodo->aggiungicondizione() ecc.
se lo devo fare cosě ci riesco perň non seguo nessuna logica particolo 
prendo e scrivo.
a me serve capire come "creare" inventare un mini linguaggio interno ....

 
Posso dire che ci ho capito ancora meno? Perdonami...
Magari un esempio per iniziare?
  bye
	av.

 a me serve capire come "creare" inventare un mini linguaggio interno ....
"A me serve capire come 'creare', 'inventare' un mini-linguaggio interno"
interno a chi? che mini-linguaggio? sei sempre meno chiaro, anche una 
volta che le tue frasi sono tradotte in italiano! :-(
-- 
Mat/tia Belletti - Graduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://mbellett.web.cs.unibo.it/
Jabber: RedGlow  - Linux registered user 299762 @ machine 213003


Come hai ragione e che la maggior parte delle volte
quando scrivo sono "difrettissima..."  (capisco che alla fine quello a
perderci sono io..)
Comunque parto dalle origini, il mio mitico "mini framework" per gestire la
persistenza degli oggetti, in modo che si possano utilizzare
si con un database relazione, con un file xml, con un file di testo o con un
database ad oggetti.
Insomma slegare completamente il modo in cui gli oggetti
serializzano,deserializzano i loro dati.
Questo è il mio obiettivo primario poi vabè ho divagato un pò perchè alla
fine questo è lo scopo principale, ma per potere arrivare a questo bisogna
sapere
prima altre cose.Una di queste è quella relativa alla domanda fatta in
questo thread (o post?) che ora cercherò di spiegare.
In pratica vorrei "creare" (e qua chiedo aiuto a voi perchè sono proprio a
secco) un linguaggio da utilizzare dentro il mio codice,
una sorta di sql da dare in pasto ad un'altro oggettino che lo "interpreta"
ed esegue il caricamento lo scaricamento dei dati
confronti ecc. degli oggetti di cui ho parlato sopra .( questa è una mia
idea , se avete qualche consiglio son tutto "orecchi") la funzione di questo
linguaggio è proprio quella di slegare completamente l'oggetto dal tipo di
struttura in cui è memorizzato.
spero perlomeno di aver chiarito
grazie ciao.

 grazie ciao.
Si', finalmente si'. E bisognava metterci tanto prima di obbligarti a 
esprimere dei concetti in modo chiaro? :P
Allora: il tuo obiettivo e' decisamente difficile da raggiungere. Tu 
vorresti scrivere un linguaggio per lo storage dei dati su un supporto 
generico. Questa e' una richiesta assai complessa - specie perche', a 
quanto ho capito, tu non hai ancora nessuna idea su che linguaggio 
utilizzare.
Tuttavia: perche' non utilizzare direttamente l'SQL standard come 
linguaggio?
Altre considerazioni: ti serve veramente un framework cosi' complesso? 
Se lo fai per 'divertimento', o per imparare, va bene tutto, pero'... 
valuta bene.


 linguaggio?
Potrei utilizzare l'sql  ma come sintassi non l'sql vero e proprio , in
effetti questo è stato il mio primo
pensiero gestire decentemente/direttamente l'sql tramite delle classi (e'
gia' questo mi darebbe le mie porche soddisfazioni)
Ma se poi voglio utilizzare lo stesso framework per caricare i dati da un
file xml, oppure da un file binario ?
torno punto e a capo...
---
grazie ciao

 torno punto e a capo...
Dunque, stiamo andando decisamente OT, quindi non approfondirei 
l'argomento qua, anche se avrei da ribattere. Ti consiglio di spostarti 
su un newsgroup di sql e/o database per chiedere quanto sia fattibile il 
tuo progetto e se c'e' qualcosa di gia' realizzato.



Ok posso chiudere tranquillamente .. però non capisco perchè OT ?
qua si tratta di scrivere codice c++ a ruota libera , trovare soluzioni
eleganti Object Oriented
(Tipo pattern e simili) Darci dentro anche sotto il punto di vista
ottimizzazzioni
(Cache  ecc.)
questi argomenti non credo siano OT (fuori topic) il fatto che sia uscita la
parola
sql è database, non significa che un progettista di database mi possa dare
una (o almento non detto)
quello e' come dire il dominio di applicazione
(anche se alla fine non è proprio così perchè il database era un esempio e
l'sql era il mezzo non il fine)
Penso al contrario che se posto una domanda cosi' in un newsgroup di
Database O Sql li sono sicuramente OT
grazie cmq...

 ...come sempre grazie Ciao...
L'argomento è abbastanza vasto per essere trattato velocemente, cmq ci si
può provare almeno nel tentativo di dare qualche indicazione... Tieni anche
presente che non mi è chiaro cosa vuoi implementare di preciso, quindi sto
ragionado in termini generali.
Bisogna ragionare in due fasi e, come tu stesso hai rilevato, il primo passo
ti obbliga a creare una grammatica del linguaggio di programmazione, mentre
il secondo attiene all'implementazione. Bisogna ricordare che il linguaggio
deve essere consistente dal punto di vista sintattico prima ancora della
effettiva implementazione di un compilatore o interprete. In parole povere,
deve funzionare sulla carta...
Una tecnica standard per definire la sintassi di un linguaggio di
programmazione è l'uso di Backus-Naur Form (BNF). Immagino che on-line
potrai trovare parecchio materiale a proposito della suddetta. Magari non la
userai, in quanto può rivelarsi un po' troppo sofisticata per il semplice
uso che ti prefiggi, ma almeno ti da un'idea di come si formalizzano le
regole del linguaggio.
Prendi spunto anche dalla grammatica del C che puoi trovare ovunque e
soprattutto alla sezione A13 del testo di K&R 2nd edition. Allo stesso modo
puoi dare un'occhiata alla grammatica del C++ sul libro "The C++ Programming
Language" di B.S.
Per quanto riguarda l'implementazione dell'inteprete avrai almeno bisogno di
5 elementi:
1) un pilota (driver or starter)
2) una funzione di input
3) un parser+elaboratore (come si dice in Italiano? Boh!)
4) una tabella dei simboli
5) una gestione degli errori
6) una funzione di output e log
1) il pilota serve ad inizializzare l'ambiente dove avverrà la digitazione
del codice o la lettura dello script da file. in questa fase si caricano le
variabili costanti e comunque si fa tutto il lavoro preparatorio per
consentire l'utilizzo dell'ambiente di lavoro. Puo' chiedere se si vuole
eseguire un file oppure digitare il codice riga per riga. Ovviamente per un
ambiente semplice può essere un piccolo main() che carica le costanti e le
enumerazioni e cede il controllo alla funzione di input.
2) la funzione di input si occupa appunto di ciò che il nome suggerisce e
man mano che legge in un buffer le righe intere inviate dall'utente, oppure
lette da uno script, trasferisce al parser carattere per carattere.
3) il parser mette insieme i vari tokens, cioè acquisisce le variabili,
literals, operatori passati dall'input e richiama le varie funzioni preposte
al calcolo e manipolazioni dei tokens acquisiti. Ovviamente fa un controllo
di matching con la grammatica. Ad esempio se acquisisce una variabile ad
inizio riga, e dalla grammatica ci si apetta che dopo ci sia un operatore
"=", trasferisce il controllo ad una funzione che si aspetta un operatore
"=" e se invece quest'ultima riceve un altra variabile o altre cose non
previste dalla grammatica può sollevare un eccezione e passare il controllo
alla gestione degli errori. In questa fase si calcolano i valori da
assegnare alle variabili e si comunica con la tabella dei simboli.
In questa sezione si lavora con alberi e stacks. Vedi ad esempio la semplice
implementazione di una calcolatrice con notazione polacca postfissa che puoi
trovare facilmente in rete.
4) la tabella dei simboli è comunemente implementata tramite una "map" (come
quella della Libreria C++ ad esempio). Per ogni variabile elaborata dal
parser+elaboratore il contenuto attuale di una coppia "variabile->valore" è
modificato e conservato per futuri riferimenti.
La tabella non dovrebbe contenere però i valori costanti predefiniti, già
inizializzati dal driver, come "pi greco" e simili.
5) sulla gestione degli errori c'è poco da dire in quanto è intuibile a cosa
serve e come implementarla. Ovviamente sfrutterà i servizi della sezione di
output per comunicare con l'utente.
6) lo output può comunicare sia (1) la buona andata a fine delle
elaborazioni che (2) eventuali valori specifici richiamati con ad esempio un
istruzione "print var" che va a leggere sulla tabella dei simboli.
Quanto ho scritto è solo uno dei tanti modi di costruire un interprete e non
ha pretesa di essere esaustivo. Non è neanche detto che ci sia una così
rigida separazione delle parti coinvolte nella implementazione reale, ma
almeno forse dal punto di vista logico.
Non sono un esperto in campo in quanto ho fatto qualcosa del genere solo
come esercizio in un corso sulle strutture dati e algoritmi, ma spero almeno
di averti dato qualche spunto per iniziare una ricerca più approfondita
dell'argomento.
Buon divertimento,
fabiomdf
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 Buon divertimento,
Ultima cosa bibliografia in riguardo ? non in rete mi piacciono più i
libri...?
Grazie mi metto a lavoro.

 libri...?
E si, i libri stampati sono tutta un altra cosa...
Lasciamo perdere i testi sulla Compiler Theory, come quelli di Aho oppure
Muchnick, perchè probabilmente non ti servono.
Invece ti consiglio di leggere "lex & yacc, 2nd Edition (A Nutshell
Handbook)" di Levine et altri - O'Reilly" dove si spiega con esempi e codice
come da una grammatica si può derivare un parser e uno scanner attraverso
lex & yacc (sono trattati anche GNU/Bison e GNU/Flex). E' un ottimo libro e
costa solo $20.00 in edizione originale, ma dovrebbe esserci anche una
traduzione in Italiano.
Ciao,


 
Per favore, il quoting...
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

 Ok posso chiudere tranquillamente .. però non capisco perchè OT ?
Perche' qui non stiamo parlando di codice C++, ma di come disegnare e 
progettare un nuovo linguaggio, come per l'appunto anche il topic dice. 
E il genere di piega che stava prendendo il discorso dimostrava 
abbastanza bene questo fatto (non si e' nominato il C++ neppure una volta).


 abbastanza bene questo fatto (non si e' nominato il C++ neppure una volta).
Beh.. a questo si puo` rimediare :)
-- 
RiK0
Non credo negli schemi non vincenti.


Ciao,
sono molto contento di leggere quanto hai scritto e anche io solleciterei
una discussione in questo senso. Cerchiamo di approfondire che cosa è
veramente da ammettersi o meno.
Mi sembra che il gruppo si stia appiattendo (lasciatemi passare il termine)
solo su discussioni che attengono i testi da leggere, la sintassi del C++ e
l'utilizzo della Libreria Standard (e questo è sacrosanto, soprattutto per
dare una mano ai più nuovi del C++).
In altri Gruppi sui linguaggi di programmazione (anche C++) non è insolito
trovare anche discussioni sugli argomenti che hai citato, anzi sono
incoraggiati.
Ho paura che altrimenti chi voglia fare qualcosa che è più di un esercizio
per capire come usare il C++, e quindi voglia realizzare applicazioni vere,
finisca per dovere migrare da qualche altra parte e definitivamente.
Corriamo il rischio di perdere il contributo della gente più preparata e che
non ha più voglia di spiegare e/o semplicemente leggere solo di come si usa
un puntatore o un container della Libreria.
Ripeto che queste discussioni servono, ma anche parlare di librerie di uso
comune tra i programmatori C++, oppure di progetti per un nuovo interprete
di linguaggio da realizzarsi poi in C++, un algoritmo per una nuova STL, e
ancora di tante altre cose già da te immaginate sarebbe come fare entrare
una ventata di aria fresca e rinnovamento nel Gruppo e attirerebbe molta
gente preparata alle nostre discussioni.
Spero ci sia un seguito alla proposta di Enrico Franchi... Fatevi tutti
sentire ed esprimete il vostro parere al riguardo.
Saluti,



Concordo pienamente anche perch+ io sono uno di quelli "fruguni" amo
sperimentare fare sempre cose
nuove e stimolanti...
ciao.

 gente preparata alle nostre discussioni.
Non so. Secondo me si rischia invece di minimizzare quella che è la vera
difficoltà del linguaggio C++ e cioè la sua complessità. Argomenti ce ne
sarebbero un'infinità. Purtroppo molti usano il newsgroup al posto di un
buon libro e forse è questo uno dei problemi.


 sperimentare fare sempre cose nuove e stimolanti...
Quindi conosci già in modo approfondito l'intero C++ standard? Beato
te...



No assolutamente ... :-) non mi permetterei mai dirlo :-)
appoggiavo solamente il commento di fabio.
ciao :-)


Ovviamente, faccio il bastian contrario :-).
Allora, nulla in contrario a varie cose che avete citato. Non sono 
contrario all'implementazione di un linguaggio in C++ ("come si potrebbe 
costruire un parser LALR in C++?"), ma non spiegare i concetti dietro 
("cos'e' una grammatica LALR?") o tanto meno al design dei linguaggi, 
cosa a cui ad esempio stavamo arrivando con questo discorso (per non 
dire che c'eravamo gia' arrivati in altri post).
Nulla in contrario a parlare di varie parti di Boost - per il banale 
fatto che moltissima roba e' basata su standard C++, ma soprattutto 
perche' e' possibile e probabile che confluira' nel prossimo standard.
Sono incerto sulle librerie multipiattaforma. Quindi non mi pronuncio.
Rispondo a un esempio in particolare per tirar fuori qual e' il vero 
problema secondo me: se uno mi chiedesse qualcosa riguardo a come 
progetterei un'interfaccia per i socket in C++, non avrei problemi. Il 
socket e' un'astrazione che si presta bene ad essere modellata ad 
oggetti, e il C++ standard non fa eccezione. Il problema e' che nessuno 
chiede mai questo, ma bensi' come si apre un socket su Windows, o linux, 
o come si sniffano pacchetti da un'interfaccia di rete.
Quindi, secondo me, il punto e' proprio che di argomenti stimolanti ce 
ne sono. Sono gli stimoli che mancano, e ampliare gli argomenti ammessi 
non fara' altro che allargare la fetta di utenti che fanno domande 
stupide. So che sono cattivo & bastardo... perdonatemi, soprattutto dato 
che non mi considero affatto un esperto dello standard C++, e del fatto 
che pure io piu' e piu' volte sono andato OT, rispetto ai parametri da 
me ora espressi, dimostrando quindi scarsa coerenza.
Alla base di tutto: il C++ e' stato pensato in modo modulare. Un 
linguaggio, una sola astrazione, e tante librerie, ambiente, ecc sopra. 
Io credo fortemente in questa idea di fondo, e quindi altrettanto credo 
che i newsgroup dovrebbero essere strutturati secondo questa medesima idea.
