Gli Script

Per inserire elementi in un catalogo il metodo che garantisce maggior controllo ed efficacia consiste nel fare uso di Geppetto, il linguaggio di scripting di Mobilia.

Per lanciare la compilazione di uno script in Mobilia, bisogna creare con Mobilia Builder un catalogo nuovo (menu File -> Nuovo) dopo di chè si lancia con il comando "Esegue Script" (menu Builder -> Esegue Script)

Un linguaggio di scripting consiste in un insieme di istruzioni che, assemblate seguendo adeguate regole sintattiche, 'spiegano' ad un programma o ad un sistema operativo quali azioni compiere.
Le istruzioni sono memorizzate dall'utente in formato ASCII su un file di testo e poi vengono passate al programma attraverso specifici comandi.
Esempi di linguaggi di scripting sono i files batch (*.bat) di Windows, gli script AppleScript del Macintosh o i files contenenti istruzioni nel linguaggio di una delle innumerevoli shell di UNIX (sh, bash, csh, zsh).
Quelli appena citati sono linguaggi di scripting cosiddetti 'di sistema', e vengono impiegati per eseguire compiti al livello del sistema operativo, ma esistono anche innumerevoli esempi di linguaggi di scripting specifici per i singoli programmi:

autolisp di AutoCAD,
Javascript nelle pagine web,
ActionScript in Flash. ecc.

solo per citarne alcuni.

Il linguaggio di scripting di Mobilia lo abbiamo battezzato 'Geppetto'.
Geppetto si compone di un insieme di comandi specializzati per la realizzazione di elementi da inserire nei cataloghi di Mobilia.
Un comando altro non è che una parola chiave che innesca una qualche azione: il comando %colore, ad esempio, corrisponde all'azione "crea un colore".

Ognuno dei comandi di Geppetto si aspetta un certo numero di parametri:
imporre semplicemente la creazione di un colore infatti non è di per sé sufficiente, se non si specificano nel contempo i valori RGB del colore da creare, il grado di trasparenza, il nome ed il codice con il quale identificarlo ecc.

Pertanto, l'azione "crea un colore" deve essere in realtà espressa come "crea il colore 'verde acquamarina' il cui valore RGB è (0;255;0), avente grado di trasparenza pari a 3".

Quindi, come regola generale, quando Mobilia interpreta uno script e trova un comando, deve fornire a quest'ultimo tutti i parametri necessari per la sua corretta esecuzione.
Il comando %colore, ad esempio, si aspetta i parametri nome, codice, materiale, colore e trasparenza (ed altri che qui non citiamo).
I parametri ed i valori ad essi associati sono specificati nello script insieme ai comandi secondo adeguate regole sintattiche, e vengono registrati in una apposita area di memoria mano a mano che vengono letti da Mobilia, pronti ad essere recuperati all'occorrenza: è qui che subentra il concetto di Stack.

Stack è un termine inglese che sta per pila. Un esempio classico utilizzato per chiarire il concetto di stack è quello della pila di piatti: quando formiamo una pila di piatti, non facciamo altro che posizionare ciascun piatto in cima alla pila stessa; quando ci occorre prendere un piatto dalla pila, recuperiamo sempre e solo il piatto in cima ad essa, mai un piatto nel mezzo.
Questo meccanismo è noto in informatica con un acronimo 'LIFO'; che sta per Last In First Out, ovvero l'ultimo entrato è il primo ad uscire.

L'area di memoria che Mobilia utilizza è organizzata in modo che ogni volta che si inserisce una informazione in questa area di memoria, l'informazione viene collocata nella prima locazione libera a partire dal basso:

Questa area di memoria viene chiamata appunto stack di Mobilia (d'ora in avanti quando si leggerà il termine 'stack' vorrà dire che ci stiamo riferendo a questa area di memoria). Uno stack, oltre ad essere caratterizzato dal fatto che le informazioni che vi vengono registrate si posizionano ordinatamente una sopra l'altra dal basso verso l'alto, si distingue per un'altra proprietà: non è possibile eliminare informazioni nel mezzo dello stack, mentre è possibile eliminarle dalla cima; conseguentemente, riferendoci allo stack d'esempio appena visto, non è consentito eliminare "Terza informazione" senza prima aver eliminato, nell'ordine, "Quinta informazione" e "Quarta informazione".

Vediamo a titolo esemplificativo come viene utilizzato in pratica lo stack da Mobilia: impartiremo a Mobilia le istruzioni necessarie alla creazione di un colore da inserire in un catalogo.
Innanzitutto dobbiamo scrivere le corrette istruzioni in un file di testo con un qualsiasi editor ASCII (noi usiamo "Scite" su Windows, "TextWrangler" su Macintosh, ma si possono usare altri come ad esempio "Eclipse")

(N.B.: Gli script di esempio sono incompleti per chiarezza di esposizione):

%colore {
	&descrizione:vetro grigio
	&codice:5001
	&color:(0;35535;0)
	&trasparenza:8
}

in Geppetto i comandi sono preceduti da un segno di percentuale (%) e racchiudono i propri parametri tra parentesi graffe ({ e }); i parametri sono invece preceduti da una 'e commerciale' (&) ed indicano il proprio valore dopo i due punti (:). Quindi nel nostro esempio abbiamo un comando (colore) e quattro parametri, ciascuno con il proprio valore: nome, codice, colore e trasparenza. Le informazioni che Mobilia registra nello stack non sono altro che i comandi ed i parametri dello script che interpreta: Mobilia legge il testo dello script e registra sullo stack ciascuna riga formando una pila di comandi e parametri:

Come si vede, ciascuna riga è inserita nella prima locazione libera a partire dalla base dello stack, cosicché le righe appaiono sullo stack in ordine inverso rispetto al testo dello script.
Quando Mobilia trova una parentesi graffa chiusa (}) ne deduce che tutti i parametri necessari all'esecuzione del comando corrispondente alla parentesi graffa aperta sono disponibili sullo stack; a questo punto Mobilia esegue una serie di azioni:

Cerca sullo stack il nome del comando corrispondente alla parentesi graffa chiusa (reperendo in questo caso il comando "%colore {"); le ricerche sullo stack sono condotte in ordine inverso rispetto alla memorizzazione delle righe, e partono dall'ultimo elemento registrato; qui in posizione 6; e proseguono verso la base dello stack posizione 1.

Una volta individuato il nome del comando da eseguire, Mobilia individua sullo stack, sempre attraversandolo dall'alto verso il basso, il valore associato a ciascuno dei parametri richiesti per eseguire il commando.

Esegue il comando, nello specifico creando un colore e registrandolo nel catalogo.

Elimina dallo stack tutte le informazioni comprese tra le parentesi graffe, comando incluso.

Pertanto, alla fine dell'interpretazione dello script, avremo il nuovo colore registrato nel catalogo e lo stack svuotato dei parametri e del comando appena eseguito.

Sembra complicato? Forse un po', ma questo sistema ci permette di dichiarare parametri comuni a più comandi.
Per esempio immaginiamo di dover inserire nel catalogo diversi colori con la stessa trasparenza (di solito sono opachi) e materiale, e poi il vetro dell'esempio precedente: scriveremmo uno script cosi':

%begin{
	&trasparenza:0
	&materiale:Trucc. Laccato

	%colore{
		&descrizione:Rosso
		&codice:5001
		&color:(65535;0;0)
		# punto 1
		}
		# punto 2

	%colore{
		&descrizione:Verde
		&codice:5002
		&color:(0;65535;0)
		}
	%colore{
		&descrizione:Blu
		&codice:5003
		&color:(0;0;65535)
		}
	%colore {
		&trasparenza:8
		&materiale:vetro
		&descrizione:vetro grigio
		&codice:5004
		&color:(35535;35535;35535)
		# punto 3
		}
		# punto 4
}

Analiziamo adesso l'andamento dello stack durante l'esecuzione dello script, fermandoci nelle righe segnate con #punto 1-4 (in Geppetto il testo compresso tra un cancelletto (#) e la fine della riga, e' considerato un commento al codice ed e' ignorato)

Sfruttando questa caratteristica di Geppetto, e' possibile eseguire dei comandi senza bisogno di dichiarare ogni volta tutti i parametri richiesti.

Il commando %begin e' un comando che non fa nulla, ma serve per controllare l'uscita dei parametri dallo stack

Anche se nell'esempio, con il comando %colore che ha pochi parametri, il vantaggio non e' enorme, ci sono altri comandi per la creazione d'elementi che richiedono un centinaio di parametri, la maggior parte dei quali poco usati: e qui il vantaggio si vede.

C'è però una situazione nella quale questa caratteristica viene sfruttata al massimo, ed e' legata al comando %include.

Il comando %include fa' proseguire l'interpretazione dello script in un altro file - specificato con il parametro &file: -, come se il file "incluso" fosse stato incollato al posto del comando %include

	%include{
          &file:parametri_di_default
          } 

	&colore:rosso
	%include{
          &file:script_che_crea_un_elemento
          } 
       # e' stato creato un elemento rosso

	&colore:verde
	%include{
          &file:script_che_crea_un_elemento
          } 
       # e' stato creato un elemento verde

Bisogna tener presente come Geppetto cerca i file da includere (in quanto viene fornito soltanto il nome del file).
Geppetto fa una ricerca cominciando con il primo file (in ordine alfabetico) nella cartella contenente lo script iniziale; se nella ricerca trova una cartella, continua la ricerca all'interno di questa cartella, e così via - le cartelle il cui nome e' racchiuso tra parentesi, vengono ignorate -.
Finita la ricerca nella cartella - e sottocartelle - dello script iniziale, Geppetto cerca nel contenuto di una cartella speciale chiamata "Includes" situata nella cartella del programma Mobilia.

La cartella "Includes" contiene una serie di files, pronti da usare, che implementano le costruzioni più comuni, necessarie nella costruzione di mobili; tra questi c'è il file "defaults", che inizializza tutti i parametri usati da tutti i comandi. Tutti gli script devono cominciare includendo questo file.

Altri files presenti nella cartella "Includes" sono: colori, files con textures (legni, marmi) piu' comuni, definizioni di modelli di ante di uso comune, disposizioni di ante e cassetti, scocche, mensole, zoccoli, maniglie, sanitari, accessori vari ecc.

Proseguiremo adesso con un esempio commentato della definizione di un mobile in Geppetto

Index