|
SCOPO DEL PROGRAMMA
Uda Script File Maker e' un software utile per la generazione
di Files Script molto grandi e ripetitivi.
Per files script si intendono files contenenti
istruzioni che producono direttamente o indirettamente, a seconda del contesto,
una qualche elaborazione automatizzata; in linea di massima, vengono utilizzati
per produrre elaborazioni molto ripetitive su un elevato quantitativo di
files, in modo da risparmiare tempo, evitando cosi', di dovere eseguire
le medesime operazioni manualmente.
Il contesto nel quale questi files script devono lavorare e,
soprattutto, quali istruzioni devono contenere e' un problema esclusivo
dell'utente; lo scopo del programma e' unicamente quello di facilitarne
la creazione.
Prima di procedere alla generazione di un file script, soprattutto
attraverso USFM, e' necessario valutare 2 parametri:
-
Numero di files, o comunque di elaborazioni, che il file script dovra'
gestire: in pratica si tratta del numero di istruzioni che lo script
dovra' contenere; normalmente, e' direttamente proporzionale al numero
di files che si intende elaborare. Quanto piu' grande e' il numero
di files coinvolti nell'elaborazione, tanto piu' conviene generare uno
script anziche' procedere manualmente.
-
Ripetitibilita', per ogni singolo file, delle medesime operazioni:
in linea di massima gli script vengono impiegati per eseguire un certo
numero di operazioni moltiplicate per un certo quantitativo di files; ne
consegue che e' necessario estrapolare una sorta di Routine
(cioe' una serie di istruzioni) che deve esse svolta per ogni singolo file.
Se non risultasse che ogni file coinvolto nell'elaborazione necessita delle
stesse medesime operazioni e' possibile che la complessita risulti tale
al punto da convenire piu' un'azione manuale.
Fatte queste due premesse, affinche' l'uso del software sia vantaggioso
e' necessario che siano coinvolti molti file (almeno 20 o 30) e che le
operazioni da compiere siano abbastanza facili e molto ripetitive (in realta'
non e' detto che l'elaborazione coinvolga files, ma spesso e' cosi').
SINTASSI DEL PROGRAMMA
USFM accetta la seguente sintassi:
usfm <routine> <values> [-c count] [-e] [-f
output] [-h] [-o] [-r rip] [-s sost]
dove:
-
<routine> identifica il nome del File Routine.
-
<values> identifica il nome del File Values.
-
-c e' un parametro che indica al programma che il contatore non
deve essere incrementato secondo il valore di default (e cioe' ad ogni
ricorrenza della variabile stessa) e count deve essere un numero
che specifica ogni quante manifestazioni della variabile $counter$
(o analoga) si deve avere un incremento.
-
-e permette di Eliminare dal File Values (il file non viene
modificato, solo l'immagine in memoria) tutti i Valori che
risultano duplicati, mantenendone solo la prima istanza; il confronto tra
i valori non e' case-sensitive.
-
-f e' un parametro che indica al programma che l'output non deve
essere inviato allo schermo ma direttamente ad un file e output
deve essere il nome di quest'ultimo (ex: script.bat).
-
-h serve per ottenere, anche abbinato a qualsiasi altro parametro,
comunque la guida interna di USFM.
-
-o anziche' redirigere l'output sullo stdout (cioe' lo schermo)
direttamente al Sistema Operativo; questo puo' evitare il dover salvare
l'output in un file batch (o analogo) per poi doverlo lanciare.
-
-r e' un parametro che indica al programma che la Routine non
deve essere moltiplicata per il numero di Valori presenti
nel File Values ma bensi' per il numero specificato nell'opzione
rip.
-
-s e' un parametro che indica al programma che ogni occorrenza
della variabile $val$ non deve essere sostituita con un
rispettivo Valore del File Values ma solo ogni
sost
volte.
Se i valori che devono assumere count, rip o sost
non sono noti a priori (e comunque non vanno bene quelli previsti di default)
e' possibile specificare, anziche' un numero, la lettera x; volendo,
e' possibile effetturare su quest'ultima (ma anche su valori puramente
numerici) piccole operazioni aritmetiche (ex: x/2, x*5,
x+10,
x-4).
Le Variabili accettate all'interno del File
Routine sono le seguenti:
| Nome Variabile |
Descrizione |
Esempio |
| $val$ |
Variabile da sostituire con i Valori del File Values |
|
| $counter$ |
Contatore semplice |
1, 2, 3, ... |
| $counter0$ |
Resetta ad 1 il valore del contatore
Quando il software incontra questa variabile si limita a resettare
il valore dell'eventuale successiva variabile di Tipo Contatore al valore
1 e partire da quest'ultimo l'incremento delle successive. |
|
| $counter1$ |
Contatore formattato da spazi
Il numero di spazi utilizzati (e, precisamente, anteposti), sono
determinati dal numero specificato nel nome della variabile stessa; $counter1$
rappresenta uno (1) spazio, $counter2$ rappresenta due (2) e cosi'
via fino a $counter9$ che ne prevede un massimo di 9. |
1, 2, 3, ...
1, 2,
3, ... |
| $counter01$ |
Contatore formattato con zeri
Il numero di zeri (0) utilizzati (e, precisamente, anteposti),
sono determinati dal numero specifico nel nome della variabile stessa;
$counter01$
rappresenta uno (1) zero, $counter02$ rappresenta due (2) e cosi'
via fino a $counter09$ che ne prevede un massimo di 9. |
01, 02, 03, ...
0001, 0002, 0003, 0004, ... |
| $lastval#$ |
Valore numero # precedentemente usato
Al posto del carattere # e' necessario specificare un valore
(necessariamente numerico, altrimenti il software produrra' errore) che
rappresenta il numero di variabili, a ritroso, che il software deve scartare
per cercare il valore da utilizzare.
Questo tipo di variabile e' fondamentale per riuscire a riutilizzare
i medesimi valori in piu' punti del File Routine a prescindere dal parametro
-s
. |
$lastval3$ indica al programma di sostituire la
variabile
con il terzultimo valore utilizzato. |
Di seguito sono invece riportati i Comandi Speciali,
in ordine di priorita', accettati dal software:
|
Nome Comando Speciale
|
Descrizione
|
| $pipe(<command>$parse$[string])pipe$ |
Permette di eseguire il comando (<command>) specificato
spedendogli in modalita' PIPE un'eventuale stringa ([string]).
E' importante che il parametro <command> non contenga al
suo interno delle redirezioni (ex: dir > miofile.txt).
Il parametro [string], che e' facoltativo, puo' ovviamente
contenere delle Variabili (ex: $val$).
Non sono supportati piu' comandi di tipo $pipe(...)pipe$ concatenati,
tuttavia, e' possibile eseguire all'interno dello stesso comando piu' pipe
concatenate. (ex: $pipe(date /t | tr [:punct:] _$parse$)pipe$). |
| $ltrim(<string>)ltrim$ |
Consente di eliminare tutti gli spazi eventualmente presenti a "sinistra"
di <string>. |
| $rtrim(<string>)rtrim$ |
Consente di eliminare tutti gli spazi eventualmente presenti a "destra"
di <string>. |
| $tolower(<string>)tolower$ |
Converte i caratteri di <string> tutti in minuscolo. |
| $toupper(<string>)toupper$ |
Converte i caratteri di <string> tutti in maiuscolo. |
| $far(<origin>$find$<find>$replace$[replace])far$ |
Permette di cercare nella stringa <origin> tutte le ricorrenze
di <find> e sostituirle con [replace].
Il parametro <find> accetta anche sequenza speciali come
\n
(ritorno a capo) e \t (tabulazione).
Il parametro [replace] e' facoltativo; se viene omesso, il
programma si limita ad eliminare dalla stringa <origin> ogni
ricorrenza di <find>.
E' anche possibile concatenare piu' comandi ricorsivamente. |
Questi Comandi Speciali permettono di eseguire operazioni
su stringhe e variabili di grande utilita'; giusto per dare un'idea, si
puo' dire che:
-
$pipe(...)pipe$ e' utile quando sia necessario fare elaborare
una stringa ad un programma esterno; ecco un possibile esempio:
$pipe(data /t$parse$)pipe$
-
$ltrim(...)ltrim$ e $rtrim(...)rtrim$ sono necessarie
per eliminare solo gli spazi in testo o in coda da una stringa; ovviamente,
combinandoli, e' possibile ottenere entrambi i risultati contemporaneamente,
come ad esempio:
$rtrim($ltrim($var$)ltrim$)rtrim$
-
$tolower(...)tolower$ e $toupper()toupper$ permettono
di convertire i caratteri di una stringa rispettivamente in minuscolo o
in maiuscolo; l'uso concatenato di questi comandi e' pressocche' insensato,
pero' non lo e' la combinazione con altri:
$toupper($rtrim($ltrim($var$)ltrim$)rtrim$)toupper$
-
$far(...)far$ e' invece fondamentale in cuei casi in cui si renda
necessario operare un Cerca/Sostituisci. Puo' risultare particolarmente
comodo per eliminare un ritorno a capo o caratteri indesiderati:
$far($far($pipe(data /t$parse$)pipe$$find$\n$replace$)far$$find$/$replace$)far$
ESEMPIO: GENERAZIONE DI UN FILE SCRIPT
Al fine di comprendere meglio l'utilizzo di questo programma (cosa
tutt'altro che semplice, nonostante la sua modesta entita') verra'
qui proposto un piccolo esempio: si supponga di dovere, tramite un Sistema
CAD che permette l'uso di files script, aprire un certo numero di disegni
(dei quali se ne conosce a priori il nome, un codice di 2 lettere che ne
identifica la tipologia di cio' che rappresentano ed il formato cartaceo
sul quale sono rappresentati), eseguire su ognuno rispettivamente uno zoom
estensivo, aggiornare il codice della tabella (gia' presente nel disegno)
tramite un'opportuna funzione MACRO supportata dal CAD (che accetta come
parametro il codice stesso) e che, infine, si voglia salvare suddetto disegno
non piu' con il nome originale ma con il codice riportato precedentemente
anche nella tabella.
Per un'ipotetico disegno boccola_centrale.dis, appartenente alla
categoria BO (stabiliamo che queste due lettere identificano tutte le BOccole)
che viene rappresentato su un formato UNI A3, stabiliamo che sono necessari
i seguenti comandi (i quali vanno impartiti, a mano, al prompt del CAD
ipotetico preso in esame):
open boccola_centrale.dis
zoom extension
call "numerazione_disegno.macro" : BO-A3-000000001
purge block
saveas BO-A3-000000001.dis
Praticamente viene aperto il file boccola_centrale.dis,
viene fatto lo zoom estensivo, viene invocata una MACRO (numerazione_disegno.macro)
alla quale gli si dice di modificare la tabella andando ad inserire il
codice BO-A3-000000001 , si eliminano i blocchi non applicati
(una sorta di pulizia del disegno da cio' che non serve piu') ed, infine,
si salva il tutto dando il nuovo nome BO-A3-000000001.dis .
Finche' questa operazione e' da eseguire su 3-4 disegni, non
e' un grosso problema farlo anche "a mano" ma, se il numero aumenta nell'ordine
delle decine, ecco che automatizzare il tutto puo' risultare un grossissimo
risparmio, soprattutto nel caso in cui questa operazione risulti frequente.
Per risolvere il problema tramite USFM dobbiamo come prima cosa creare
la lista di variabili che saranno interessate, la quale sara composta da:
-
Il Nome del disegno da elaborare
-
La Categoria del pezzo rappresentato nel disegno
-
Il Formato UNI utilizzato per rappresentare il disegno
Suddetta lista di variabili andra' poi salvata in opportuno file
di testo ASCII (con qualsiasi editor, come ad esempio il NOTEPAD di Windows
- il file potremmo chiamarlo values.txt); potremmo immaginarla
come la seguente:
albero_motore.dis
AL
A2
flangia.dis
FL
A3
coperchio.dis
CP
A4
ghiera.dis
GH
A4
tavola_rotante.dis
TV
A0
Ora e' il turno del File Routine, praticamente un derivato
delle istruzioni proposte per il disegno boccola_centrale.dis
e quindi potremmo generare il seguente file routine.txt:
open $val$
zoom extension
call "numerazione_disegno.macro" : $val$-$val$-$counter09$
purge block
saveas $lastval2$-$lastval1$-$counter09$.dis
L'unica differenza e' che ora abbiamo delle Variabili
(vedi: $val$, $counter09$, $lastval2$, $lastval1$)
al posto di Valori; per generare direttamente a video il file script
che dovra' eseguire il Sistema CAD, dobbiamo utilizzare USFM con la seguente
sintassi:
usfm routine.txt values.txt -c 2 -r x/3
la quale va a generare il seguente output:
open albero_motore.dis
zoom extension
call "numerazione_disegno.macro" : AL-A2-000000001
purge block
saveas AL-A2-000000001.dis
open flangia.dis
zoom extension
call "numerazione_disegno.macro" : FL-A3-000000002
purge block
saveas FL-A3-000000002.dis
open coperchio.dis
zoom extension
call "numerazione_disegno.macro" : CP-A4-000000003
purge block
saveas CP-A4-000000003.dis
open ghiera.dis
zoom extension
call "numerazione_disegno.macro" : GH-A4-000000004
purge block
saveas GH-A4-000000004.dis
open tavola_rotante.dis
zoom extension
call "numerazione_disegno.macro" : TV-A0-000000005
purge block
saveas TV-A0-000000005.dis
E' fondamentale prestare attenzione alle seguenti cose:
-
Le prime 3 Variabili intercettate ($val$) vengono sostituite
con i rispettivi Valori. In pratica il programma quando incontra
la stringa $val$ cerca il corrispondente valore e la sostituisce.
-
Il Contatore $counter09$ (il quale e' un contatore con
9 zeri di spaziatura meno il numero stesso) viene incrementato ogni 2 manifestazioni
dello stesso perche' e' stata specificata l'opzione -c con il
parametro 2 (-c 2) che significa: incrementa il valore
del contatore ogni 2 manifestazioni della variabile $counter09$.
-
Il secondo ed il terzo Valore viene ripetuto perche' si e' utilizzato
la variabile di tipo $lastval#$; $lastval2$ indica al
programma di ricercare il penultimo valore utilizzato (cioe' sostituito
al posto di $val$) ed eseguire la sostituzione, mentre $lastval1$
fa la stessa cosa con l'ultimo valore utilizzato.
-
L'opzione -r x/3 indica al programma di ripetere la routine per
1/3 (e' il software ad individuare quanti Valori contiene il File
Values) dei Valori presenti nel file values.txt. Nell'esempio
mostrato i Valori da sostituire alle Variabili sono 15 e,
dato che il programma ripete per default la routine tante volte quanti
sono, appunto, i valori, omettendo il parametro citato l'output risultante
risulta errato perche' si ottengono 3 ripetizioni delle stesse istruzioni
(questo perche' sono 3 le variabili usate nel File Routine).
-
Per salvare direttamente su file l'output del programma si puo' usare il
parametro -f (ex: usfm routine.txt values.txt -c 2 -r x/3
-f rinomina.scr).
COMPILAZIONE DEL PROGRAMMA
Per compilare il programma e' necessario possedere il compilatore
GCC o compatibile. Nella directory dove sono contenuti i sorgenti lanciare
i seguenti comandi (da una shell BASH):
./configure
make
La procedura e' stata testata con successo sul sistema operativo
Linux Mandrake 8.0 e su Windows NT 4.0 (SP6) utilizzando il compilatore
CygWin ( http://gcc.gnu.org ).
Utilizzando il compilatore MingW32 (miscelato al CygWin, al fine
di sfruttare i relativi tool) si puo' verificare il seguente errore:
bash-2.05a$ ./configure
creating cache ./config.cache
checking for a BSD compatible install... /usr/bin/install
-c
checking whether build environment is sane... yes
checking whether make sets ${MAKE}... eval: 1: Syntax error:
Unterminated quoted string
Se cio' si verifica e' necessario ricreare i files di configurazione
utilizzando la sintassi:
aclocal && autoconf && automake -a
A questo punto e' possibile procedere alla compilazione del software
con i comandi:
./configure
make
Alla fine della procedura si dovrebbe ottenere il file usfm.exe.
Nonostante il programma sia stato pensato per ambiente MS-DOS e' possibile
compilarlo ed utilizzarlo anche in ambiente UNIX (e' stato creato e testato
su ambiente Linux Mandrake 8.0).
|