n - Index of

Appunti di informatica libera 2003.06.29
Volume VIII
Argomenti avanzati e accessori
1

Appunti Linux
Copyright © 1997-2000 Daniele Giacomini
Appunti di informatica libera
Copyright © 2000-2003 Daniele Giacomini
Via Morganella Est, 21 -- I-31050 Ponzano Veneto (TV) -- daniele @ swlibero.org
Le informazioni contenute in questa opera possono essere diffuse e riutilizzate in base alle condizioni
poste dalla licenza GNU General Public License, come pubblicato dalla Free Software
Foundation.
In caso di modifica dell’opera e/o di riutilizzo parziale della stessa, secondo i termini della licenza,
le annotazioni riferite a queste modifiche e i riferimenti all’origine di questa opera, devono
risultare evidenti e apportate secondo modalità appropriate alle caratteristiche dell’opera stessa.
In nessun caso è consentita la modifica di quanto, in modo evidente, esprime il pensiero,
l’opinione o i sentimenti del suo autore.
L’opera è priva di garanzie di qualunque tipo, come spiegato nella stessa licenza GNU General
Public License.
Queste condizioni e questo copyright si applicano all’opera nel suo complesso, salvo ove indicato
espressamente in modo diverso.
The informations contained inside this work can be spread and reused under the terms of the
GNU General Public License as published by the Free Software Foundation.
If you modify this work and/or reuse it partially, under the terms of the license, the notices about
these changes and the references about the original work, must be evidenced conforming to the
work characteristics. IN NO EVENT IS ALLOWED TO MODIFY WHAT ARE CLEARLY
THE THOUGHTS, THE OPINIONS AND/OR THE FEELINGS OF THE AUTHOR.
This work is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the GNU General Public License for more details.
These conditions and this copyright apply to the whole work, except where clearly stated in a
different way.
Una copia della licenza GNU General Public License, versione 2, si trova nell’appendice A.
A copy of GNU General Public License, version 2, is available in appendix A.
2

The main distribution for Appunti di informatica libera is described below. For every distribution
channel the maintainer’s name and address is also reported.
Ordering
Prosa srl distribute Appunti di informatica libera and possibly oder related products through
the commercial channel. Any request to buy something related to Appunti di informatica
libera, can be addressed to Prosa srl:
Internet mirrors with good bandwidth
• direct reading:
download:
Fabrizio Rubino, fabrizio @ koalasoft.org
• direct reading:
download:
download:
mirror-service @ garr.it
• direct reading:
download:
Fabrizio Rubino, fabrizio @ koalasoft.org
• direct reading:
download:
Italian Linux Society, info @ linux.it
Internet main distribution sites
• direct reading:
download: and
Michele Dalla Silvestra, mds @ swlibero.org
• direct reading: and
download: and
Fabrizio Rubino, fabrizio @ koalasoft.org
• direct reading:
download:
Carlo Perassi, carlo @ linux.it
• direct reading:
download:
Davide Barbieri, paci @ prosa.it
• direct reading:
download:
Fabrizio Zeno Cornelli, zeno @ filibusta.crema.unimi.it
3

• direct reading:
download:
Franco Lazzero, PCTIME, pctime @ pctime.net
• direct reading:
download:
David Pisa, david @ iglu.cc.uniud.it
• direct reading:
download:
Claudio Neri, Sincro Consulting, neri.c @ sincroconsulting.com
GNU distributions
• GNU/Linux Debian
Massimo Dal Zotto, dz @ cs.unitn.it
Italian magazine’s CD-ROM
• inter-punto-net
Michele Dalla Silvestra, mds @ swlibero.org
• Internet News
Francesco Facconi, francescofacconi @ libero.it
Fabio Ferrazzo, fabio.fr @ tiscalinet.it
• Linux Magazine
Emmanuele Somma, esomma @ ieee.org
• Linux Pro
Massimiliano Zagaglia, max @ linuxwaves.com
• PC Upgrade
info @ pcupgrade.it
La diffusione di questa opera è incoraggiata in base ai termini della licenza.
The spread of this work is encouraged under the terms of the license.
4

Parte lxix Prevenzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
351 Copie di sicurezza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
352 Dischetti di emergenza con GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Parte lxx Informatica gestionale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
353 Codici a barre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
354 Barcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
355 Trasformazione in lettere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Parte lxxi i86 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
356 Minix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
357 ELKS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Parte lxxii Dos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
358 Dos: introduzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
359 Dos: dischi, file system, directory e file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
360 Dos: configurazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
361 Dos: script dell’interprete dei comandi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
362 Dos: gestione della memoria centrale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .121
363 FreeDOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
364 Progetto GNUish . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
365 The valuable DOS Freeware page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
366 Clean the Clipper 5.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
367 nanoBase 1997 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
368 nanoBase 1997 user manual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Parte lxxiii Braille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
369 Introduzione al sistema braille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
370 Sistemi di interazione per non vedenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
Parte lxxiv Aspetti umani . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
371 Manifesto GNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
372 Il progetto GNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
373 La rivoluzione del Mimete, ovvero software e copyright . . . . . . . . . . . . . . . . . . . . . . . . . .355
374 Il copyright/diritto d’autore del software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
Indice analitico del volume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
5

Parte lxix
Prevenzione
351 Copie di sicurezza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
351.1 Scelta del sistema di copia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
351.2 Strategia nelle copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
351.3 Supporti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
351.4 Compressione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
351.5 Archiviazione e recupero attraverso tar e gzip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
351.6 Archiviazione di un file system . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
352 Dischetti di emergenza con GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
352.1 Dischetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
352.2 Personalizzazione di dischetti di emergenza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22
352.3 Dischetti Slackware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
352.4 Kernel per dischetti di emergenza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
352.5 Cavi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
352.6 Utenti e gruppi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27
352.7 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
7

Copie di sicurezza
Capitolo 351
L’amministrazione di un sistema Unix è da sempre un grosso problema sotto tutti i punti di vista.
Il primo tra tutti è quello della salvaguardia dei dati, ma al rischio della loro perdita si pone
rimedio solo attraverso una gestione corretta delle copie di sicurezza.
351.1 Scelta del sistema di copia
Gli strumenti a disposizione per eseguire copie di sicurezza sono molti e si possono distinguere
due estremi possibili:
• copiare i file e le directory;
• copiare una partizione o un disco intero.
La copia di una partizione o di un disco può avere il vantaggio di permettere l’archiviazione
della situazione esatta in cui si trova, problemi inclusi. Inoltre, non avendo un processo di lettura
sui file, la data di lettura di questi non viene modificata. Lo svantaggio fondamentale di tale
tipo di copia è che questa è riferita a un disco particolare (o a una partizione) di una macchina
particolare: è molto poco probabile che si possano recuperare dati archiviati in questo modo in un
disco fisso diverso. Questa tecnica, più che per eseguire delle copie di sicurezza, viene utilizzata
per archiviare dischetti nel loro stato originale.
La copia di file e directory non tiene conto del supporto fisico in cui si trovano e nemmeno del
tipo di file system utilizzato. Questo comporta una serie di conseguenze:
• i file e le directory vengono scanditi in lettura, alterando quindi le date di lettura;
• i collegamenti simbolici vanno copiati come tali e non devono essere copiati gli oggetti a
cui questi puntano;
• i collegamenti fisici potrebbero non essere distinti.
In generale, dal momento che una copia di file e directory è portabile, mentre una copia di un
dispositivo intero non lo è (quando non si tratta di un dispositivo standard come i dischetti),
dovrebbe essere preferibile la prima di queste due soluzioni.
351.1.1 Archiviazione
È intuitiva la ragione per la quale le copie di sicurezza non vanno fatte archiviando un dispositivo
intero come se fosse un file unico. La copia pura e semplice dei file e delle directory è una tecnica
possibile, ma richiede condizioni particolari:
• l’unità di destinazione deve essere in grado di accogliere i dati come sono all’origine, in
pratica dovrebbe trattarsi di un disco;
• deve trattarsi di unità rimovibili;
• la capacità di queste unità deve essere maggiore di quella del file più grande che si deve
archiviare.
8

Copie di sicurezza 9
Di solito si preferisce la tecnica dell’archiviazione dei dati in un file unico (che rappresenta
l’archivio), assieme a tutte le informazioni necessarie per riprodurre i file e le directory originali.
In questo modo si possono utilizzare unità di memorizzazione di qualunque tipo, eventualmente
suddividendo l’archivio in pezzi più piccoli contenibili al loro interno.
351.1.2 Archiviazione di file speciali
Gli oggetti contenibili in un file system possono essere di vario tipo (file puri e semplici, directory,
file di dispositivo, collegamenti, ecc.) e così pure i loro attributi (permessi, date, ecc.). Il sistema
di archiviazione che si utilizza deve essere in grado riprodurre correttamente tutti i dati del tipo
di file system che si utilizza.
Per esempio, non sarebbe possibile archiviare i dati di un file system Unix in un archivio ‘.zip’
che è nato per gli ambienti Dos.
351.1.3 Utenti e gruppi proprietari
Tra gli attributi dei file, è molto importante l’indicazione degli utenti e dei gruppi proprietari.
I programmi di archiviazione potrebbero non essere in grado di memorizzare il numero UID e
GID, limitandosi ad annotare solo i nomi degli utenti e dei gruppi. In tal modo, nel momento del
recupero, i numeri UID e GID verrebbero riprodotti in base alle caratteristiche del sistema, cioè
in base alla particolare configurazione dei file ‘/etc/passwd’ e ‘/etc/group’.
Il fatto che il programma di archiviazione memorizzi i numeri UID e GID, oppure che memorizzi
i nomi di utenti e gruppi, ha delle implicazioni che si traducono, a seconda delle circostanze, in
vantaggi o svantaggi.
Se i dati archiviati devono essere riprodotti in un sistema diverso da quello di origine, in cui ci
sono gli stessi nomi di utenti e di gruppi, che però potrebbero corrispondere a numeri UID e GID
differenti, diventa conveniente un metodo di archiviazione che ignori i numeri degli utenti e dei
gruppi. Tuttavia, se alcuni nomi di utenti o gruppi non sono presenti nel sistema di destinazione,
la proprietà di questi file verrebbe assegnata automaticamente all’utente ‘root’.
Quando si esegue una copia di sicurezza di un intero sistema e poi lo si vuole riprodurre altrove,
si agisce per mezzo di un sistema operativo minimo, avviato probabilmente attraverso dischetti o
CD-ROM. In queste condizioni, lo scopo è quello di riprodurre esattamente il sistema originale,
per cui, i numeri UID e GID andrebbero rispettati fedelmente, nell’attesa che sia ripristinato tutto,
compresi i file ‘/etc/passwd’ e ‘/etc/group’ originali.
Quando il programma di archiviazione memorizza entrambe le informazioni, sia UID/GID che
i nomi, nel momento del recupero si pone il problema di come comportarsi quando questi non
corrispondono. Si presentano queste alternative:
• se i numeri corrispondono ai nomi, non si pongono problemi nell’estrazione;
• se i numeri e i nomi non sono utilizzati nel sistema di destinazione, si possono estrarre i
dati utilizzando i numeri originali, anche se non sono abbinati ad alcun nome;
• se i numeri non sono utilizzati nel sistema di destinazione, mentre i nomi sì, si possono
cambiare i numeri in modo che corrispondano ai nomi;
• se i nomi non sono utilizzati nel sistema di destinazione, mentre i numeri corrispondono
a nomi differenti, non si può fare altro che recuperare i numeri come solo, assegnando in
pratica la proprietà a utenti e gruppi con nomi differenti;

10 volume VIII Argomenti avanzati e accessori
• se sono presenti sia i nomi che i numeri, ma questi non hanno lo stesso abbinamento (cioè
i numeri corrispondono a nomi diversi), dovrebbe essere preferibile cambiare i numeri in
modo che corrispondano ai nomi.
351.1.4 Percorsi assoluti o relativi
Quando si intende archiviare una porzione di file system e quindi solo ciò che si trova a partire da
una certa directory in poi, è importante sapere come si comporta il programma di archiviazione
al riguardo della registrazione dei percorsi (path). Se si vuole archiviare la directory ‘/home/
tizio/esempi/’, il programma di archiviazione potrebbe registrare il suo contenuto in uno dei
tre modi seguenti:
1. ‘/home/tizio/esempi/ * ’
2. ‘home/tizio/esempi/ * ’
3. ‘./ * ’
Naturalmente, ciò dipende anche dal modo in cui vengono date le istruzioni al programma stesso.
Nel primo caso, quando dovesse rendersi necessario il recupero dei dati, questi verrebbero collocati
esattamente nella directory indicata, in modo assoluto. Nel secondo, verrebbero collocati
in modo relativo a partire dalla directory corrente, ottenendo così la directory ‘./home/
tizio/esempi/ * ’. Nel terzo caso si avrebbe il recupero del contenuto di quella directory senza
informazioni sul percorso precedente.
351.2 Strategia nelle copie
Le copie di sicurezza permettono di conservare la situazione dei dati in un istante determinato,
ma i dati sono soggetti a continui aggiornamenti. Per questo occorre una procedura attraverso la
quale si possa avere una gestione ordinata e ragionevolmente sicura delle copie.
A parte i rischi connessi con il tipo di supporto utilizzato per le copie e il luogo in cui queste
vengono conservate, vanno almeno considerate le modalità sequenziali con cui queste possono
essere eseguite. È importante rispettare un paio di regole elementari:
1. non si riutilizzano i supporti contenenti la copia effettuata la volta precedente;
2. non si utilizzano supporti in cattive condizioni.
351.2.1 Generazioni delle copie
Per distinguere una copia effettuata in un momento rispetto a quella fatta in un altro, si parla
di generazione. In pratica, l’ultima copia di sicurezza effettuata è l’ultima generazione, mentre
le altre sono tutte generazioni precedenti. Questo termine si riferisce naturalmente a copie fatte
sullo stesso insieme di dati.
Il buon senso suggerisce di utilizzare almeno tre generazioni di copie: l’ultima, quella precedente
e quella ancora precedente.

Copie di sicurezza 11
351.2.2 Livelli delle copie
La copia di un file system intero comporta solitamente un impegno consistente, sia in termini di
tempo che di supporti impiegati. Il programma che si utilizza per le copie, oppure un gruppetto
opportuno di script di shell, potrebbe permettere di effettuare la copia successiva dei soli file che
sono stati modificati nel frattempo.
Quando si esegue una copia dei soli file che risultano diversi rispetto all’ultima copia completa,
si parla di copia di primo livello; quando se ne esegue un’altra in un momento successivo per le
variazioni avvenute dopo quella di primo livello, si parla di secondo livello e così di seguito.
A parte le difficoltà legate alla conservazione dell’informazione sullo stato dei file (di solito
si tratta della data di modifica e di creazione), si pongono poi dei problemi nel momento in
cui dovesse essere necessario un ripristino dalle copie. Si dovrebbe ripristinare l’ultima copia
completa, seguita da tutte quelle aggiuntive dei soli file modificati, nello stesso ordine in cui
sono state fatte: dalla più vecchia alla più recente.
Sotto questo aspetto, quando non si vuole ripetere una copia completa troppo frequentemente, si
cerca almeno di eseguire copie successive sempre di primo livello (si hanno quindi più generazioni
di copie di primo livello). In tal modo, un eventuale recupero richiederebbe solo il ripristino
dell’ultima generazione di copia completa e dell’ultima generazione di copia di primo livello.
Questo sistema potrebbe non tenere conto dei file cancellati dopo l’ultima generazione di copia
completa: in tal modo, un eventuale recupero dalle copie di sicurezza potrebbe comportare il
ripristino di file che non servono più.
351.2.3 Distribuire le responsabilità
In un sistema monoutente, l’unico utilizzatore è anche l’amministratore del proprio sistema e di
conseguenza anche l’unico responsabile. Sarà quindi lui (o lei) a sapere esattamente cosa ha fatto
e cosa è necessario copiare per sicurezza.
In un sistema multiutente o comunque quando si condividono dati in gruppo, anche se a prima
vista potrebbe sembrare conveniente la gestione delle copie in modo centralizzato, è comunque
utile affidarla in parte anche alla responsabilità dei singoli:
• periodicamente, un amministratore potrebbe occuparsi di eseguire la copia complessiva di
tutto il sistema;
• ogni giorno, gli utenti dovrebbero preoccuparsi di eseguire le copie dei dati di loro
competenza.
Nel momento in cui dovesse essere necessario, si dovrebbero recuperare i dati dalle copie generali
fatte dall’amministratore e successivamente da quelle particolari dei singoli utenti.
Se determinate attività vengono svolte in gruppo, si potrebbe eleggere ugualmente un
responsabile all’interno di questo che si occupi delle copie di quell’attività.
Il vantaggio di questo metodo sta nell’alleggerimento delle responsabilità dell’amministratore e
nella soluzione più facile di piccoli problemi locali:
• se un gruppo di lavoro ha alterato i dati a causa di un’operazione errata, è sufficiente
recuperare i dati di quel gruppo senza disturbare l’intero sistema;
• la distribuzione della responsabilità aumenta la consapevolezza da parte degli utenti.

12 volume VIII Argomenti avanzati e accessori
351.3 Supporti
La scelta del supporto di conservazione della copia è importante e comporta alcune conseguenze:
• il costo;
• la disponibilità di unità in grado di utilizzarli;
• la facilità o difficoltà nel recupero di porzioni dei dati archiviati.
Il supporto tradizionalmente più economico e più diffuso nel passato è il nastro magnetico. Questo
ha però lo svantaggio fondamentale di essere un mezzo di memorizzazione sequenziale: non
è possibile estrarre un file se prima non si scorre tutto il nastro (o tutti i nastri) che c’è prima di
quel dato. Un altro svantaggio importante sta nella necessità di rileggere il suo contenuto, dopo
la copia, per verificare che i dati siano stati registrati correttamente.
Da alcuni anni si possono trovare dischi rimovibili di grandi capacità a prezzi ragionevolmente
bassi, oppure dischi fissi esterni (collegati attraverso la porta USB). Questi hanno il vantaggio di
poter essere utilizzati come dischi normali, pertanto, il recupero di dati parziali diventa molto più
facile, anche quando la copia di sicurezza avviene per mezzo di un’archiviazione tradizionale.
Anche i CD-R sono diventati un ottimo mezzo di archiviazione, data l’economicità dei supporti:
benché sia possibile una sola registrazione, il prezzo di un CD vergine è molto contenuto. La
preparazione di un CD-ROM richiede una certa quantità di spazio libero su disco per la preparazione
dell’immagine prima dell’operazione di «incisione» (burn) e richiede anche l’investimento
del masterizzatore. Si tratta di soldi ben spesi: una copia di sicurezza fatta su CD-ROM può essere
letta ovunque ci sia un lettore, ma questo è ormai un accessorio standard degli elaboratori;
inoltre, il CD-ROM ha una vita media molto lunga, garantendo la durata delle copie di sicurezza.
Esiste tuttavia un problema nuovo: si deve essere prudenti con le copie obsolete. Infatti, quando
le copie di sicurezza sono molto vecchie e non servono più, si può essere tentati di conservare i
CD o di donarli a qualcuno, magari per gioco, o perché li usi come un addobbo. È evidente che
si tratta di un’idea sbagliata: dal momento che questi CD-ROM sono stati usati per delle copie di
sicurezza, contengono potenzialmente informazioni delicate e riservate.
I CD-ROM contenenti copie di sicurezza obsolete vanno distrutti prima di essere gettati! Per
distruggere un CD, basta tagliarlo a metà con una forbice normale.
A fianco dei CD-R ci sarebbero anche i CD-RW, ovvero i CD riscrivibili; tuttavia, il CD-RW
non è altrettanto affidabile di un CD-R, la velocità di scrittura è relativamente più bassa rispetto a
un CD-R e ci possono essere lettori che non sono in grado, successivamente, di accedere al loro
contenuto.
Quando i dati da archiviare sono pochi, può convenire l’utilizzo dei soliti dischetti: sono sicuramente
una scelta economica e le unità a dischetti sono disponibili ovunque. Per quanto riguarda la
facilità di estrazione dei dati, ciò dipende dal modo con cui questi vengono usati: se si registrano
i dati al loro interno senza fare uso di alcun file system, si ottiene un comportamento equivalente
ai nastri; se si utilizzano con un file system, è necessario che l’archivio sia contenibile all’interno
di un solo dischetto.

Copie di sicurezza 13
351.4 Compressione
Il problema della dimensione dei dati da archiviare può essere ridotto parzialmente con l’aiuto
della compressione. La tecnica della compressione può essere applicata all’archiviazione in due
modi possibili:
• prima della costruzione dell’archivio, ottenendo così un’archivio di file compressi;
• dopo la costruzione dell’archivio, ottenendo così un archivio compresso.
La differenza è enorme. La compressione introduce un elemento di rischio maggiore nella perdita
di dati: se una copia di sicurezza viene danneggiata parzialmente, l’effetto di questo danno si
riflette in una quantità di dati maggiore (spesso è compromesso tutto l’archivio).
351.4.1 Compressione prima dell’archiviazione
I programmi di archiviazione compressa maggiormente diffusi negli ambienti Dos utilizzano
la tecnica della compressione prima dell’archiviazione. È questo il caso degli archivi ‘.zip’,
‘.arj’, ‘.lzh’ e di altri ancora. Tale sistema ha il vantaggio di permettere una facile scansione
dell’archivio alla ricerca di file da estrarre (e decomprimere) o un ampliamento dell’archivio in
un momento successivo alla sua creazione. Un altro vantaggio è la minore sensibilità alla perdita
dei dati: se una parte dell’archivio è danneggiato, dovrebbe essere possibile ripristinare almeno il
resto. Lo svantaggio principale è che la compressione fatta in questo modo, a piccoli pezzi, non
è molto efficiente.
351.4.2 Compressione dopo l’archiviazione
La compressione fatta dopo l’archiviazione elimina ogni possibilità di accedere ai dati contenuti
nell’archivio e di poterlo ampliare, se non dopo averlo decompresso. Questo significa anche che
un danneggiamento parziale dell’archivio implica la perdita di tutti i dati da quel punto in poi. 1
Un altro tipo di problema deriva dalla difficoltà di distribuire un archivio compresso suddividendolo
su più unità di memorizzazione. In questo caso però, l’efficienza della compressione è
massima. Negli ambienti Unix, di fatto, è questa la scelta preferita.
351.5 Archiviazione e recupero attraverso tar e gzip
La coppia Tar e Gzip rappresenta lo standard nell’archiviazione dei dati: Tar genera un archivio
non compresso che può comprendere anche collegamenti simbolici e file speciali; Gzip lo
comprime generando un archivio più piccolo.
La coppia funziona così bene che Tar è in grado di utilizzare Gzip direttamente senza dover far
uso di pipeline, purché il risultato dell’archiviazione non debba essere suddiviso su più supporti.
L’origine del nome Tar è Tape archive, ma questo programma permette ugualmente di gestire
qualunque altro tipo di sistema di memorizzazione.
La versione GNU di Tar (quella utilizzata normalmente nelle distribuzioni GNU/Linux), non
memorizza percorsi assoluti.
I programmi Tar e Gzip sono descritti rispettivamente nelle sezioni 74.1.2 e 74.2.1.
1 Ci sono programmi di archiviazione che si comportano così anche se non subiscono compressioni successive.

14 volume VIII Argomenti avanzati e accessori
Negli esempi seguenti si immagina di dover archiviare il contenuto della directory ‘~/
lettere/’, equivalente a ‘/home/tizio/lettere/’, comprese eventuali sottodirectory
discendenti.
Negli esempi si cerca di utilizzare la forma tradizionale per l’indicazione delle opzioni standard
di Tar. Alcune di queste possono fare a meno del trattino iniziale, come nel caso di ‘c’ e ‘x’. Altre
opzioni hanno quel trattino, ma possono essere aggregate in un’unica serie di lettere, come nel
caso di ‘czvf’, dove si ha l’unione di: ‘c’, ‘-z’, ‘-v’ e ‘-f’.
351.5.1 Archiviazione diretta su dispositivi di memorizzazione
L’archiviazione attraverso la registrazione diretta sui dispositivi utilizza completamente il supporto
di memorizzazione destinatario, anche se la quantità di dati da archiviare è molto
piccola.
Quello sotto indicato è un esempio di archiviazione in un nastro magnetico singolo: l’opzione
‘c’ sta per Create; ‘-f’ sta per File e permette di definire la destinazione dell’archiviazione;
‘-z’ attiva la compressione attraverso ‘gzip’. Dal momento che si utilizza la compressione,
l’archiviazione multivolume non è ammissibile.
# tar czf /dev/ftape ~/lettere
I dischetti possono essere utilizzati come i nastri, in modo sequenziale, ma questo lo si fa soltanto
quando l’archivio generato non è contenibile in un solo dischetto: si ha quindi una copia
multivolume e in tal caso non è ammissibile l’uso della compressione.
# tar cf /dev/fd0u1440 -M ~/lettere
In questo caso, l’opzione ‘-M’ sta proprio per Multivolume indicando quindi la possibilità che il
supporto di destinazione non sia in grado di contenere l’intero archivio. In tal modo, Tar si prende
cura di sospendere l’archiviazione ogni volta che viene raggiunta la capienza massima. Tar non
è in grado di determinare da solo questa capacità, per cui, nell’esempio, il file di dispositivo
dell’unità a dischetti è stato indicato in modo da riconoscerne la geometria, ma in alternativa si
poteva utilizzare l’opzione ‘-L’ seguita dalla dimensione:
# tar cf /dev/fd0 -M -L 1440 ~/lettere
Quando si utilizzano in questo modo, i dischetti non contengono un file system e di conseguenza
non possono essere montati. La lettura del loro contenuto avviene nello stesso modo della
scrittura, attraverso il nome del dispositivo.
L’archiviazione su dischetti, attraverso l’indicazione del file di dispositivo, richiede comunque
che questi siano già stati inizializzati (a basso livello) secondo il formato che viene indicato.
Non conta che siano vuoti: è importante che ci siano le tracce e i settori come previsto.

Copie di sicurezza 15
351.5.2 Archiviazione normale su file
Quando l’archiviazione può essere fatta su dischi (con file system ) di dimensione sufficiente
a contenere l’archivio intero, invece di utilizzare l’opzione ‘-f’ per specificare un file di dispositivo,
si può indicare direttamente un normalissimo file al loro interno, come nell’esempio
seguente:
$ tar cf /mnt/mo1/lettere.tar ~/lettere
In pratica, nel caso appena visto, si utilizza un disco montato nella directory ‘/mnt/mo1/’ e si
crea il file ‘lettere.tar’ al suo interno.
L’archiviazione compressa, con l’utilizzo di ‘gzip’, può essere ottenuta semplicemente con
l’opzione ‘-z’, come nell’esempio seguente:
$ tar czf /mnt/mo1/lettere.tar.gz ~/lettere
In tal caso l’estensione standard utilizzata (ma non obbligatoria) è ‘.tar.gz’ che rende esplicito
il fatto che la compressione è stata fatta dopo l’archiviazione. In alternativa si può usare anche
‘.tgz’, diffusa nei sistemi Dos.
351.5.3 Archiviazione e percorsi
Gli esempi seguenti, pur archiviando gli stessi dati, mostrano un modo diverso di registrare i
percorsi all’interno dell’archivio. La directory di lavoro nel momento in cui si avvia il comando,
è ‘/home/tizio/’, corrispondente alla directory personale dell’utente.
/home/tizio$ tar czf /mnt/mo1/lettere.tar.gz ~/lettere
/home/tizio$ tar czf /mnt/mo1/lettere.tar.gz /home/tizio/lettere
/home/tizio$ tar czf /mnt/mo1/lettere.tar.gz lettere
/home/tizio$ tar czf /mnt/mo1/lettere.tar.gz ./lettere
Nei primi due esempi, viene archiviata l’indicazione del percorso precedente, ma pur essendo
stato dato in modo assoluto (‘/home/tizio/lettere’), questo viene reso relativo da Tar, eliminando
la prima barra obliqua che si riferisce alla directory radice. Questo comportamento
riguarda almeno la realizzazione GNU di Tar.
Negli ultimi due esempi, viene archiviata l’indicazione della sola directory ‘lettere/’, sempre
in modo relativo.
351.5.4 Archiviazione di periodi
I file sono forniti di informazioni orarie. In base a queste è possibile eseguire delle copie di sicurezza
riferite a dei periodi. Le copie di sicurezza a più livelli possono essere ottenute in modo
semplificato attraverso l’uso dell’opzione ‘-N’ seguita da una data di partenza: si ottiene l’archiviazione
di quanto variato a partire da una certa data; di solito si utilizza quella dell’ultima archiviazione
completa. Il concetto di variazione, in questo caso, si deve intendere come variazione
del contenuto o degli attributi. Quindi si tratta della data di modifica o della data di «creazione».
$ tar czf /mnt/mo1/lettere.tar.gz -N 20030801 ~/lettere

16 volume VIII Argomenti avanzati e accessori
In questo caso, la data che segue l’opzione ‘-N’ rappresenta la mezzanotte del primo agosto 2003.
$ tar czf /mnt/mo1/lettere.tar.gz -N "20030801 15:30" ~/lettere
Questo ultimo esempio aggiunge alla data l’indicazione di un’ora particolare, 15:30; per evitare
che sia interpretato in maniera errata, il gruppo data-orario viene racchiuso tra virgolette.
351.5.5 Archiviazione limitata a un’unità
Quando si eseguono delle copie di sicurezza, è probabile che si voglia archiviare solo la situazione
di una certa unità di memorizzazione (partizione o directory condivisa in rete). In tal caso si
deve indicare precisamente questo limite con l’opzione ‘-l’ (Limit).
351.5.6 Estrazione dei percorsi
Quando si accede all’archivio per estrarne il contenuto o per compararlo con i dati originali, entra
in gioco il problema dei percorsi. I dati vengono estratti normalmente nella directory corrente,
oppure vengono comparati utilizzando come punto di partenza la directory corrente. Quindi, se
l’archivio contiene la directory degli esempi precedenti, registrata a partire dalla radice (ma come
già spiegato, senza l’indicazione della radice stessa), questi verranno estratti in ‘./home/tizio/
lettere/’, oppure comparati con i dati contenuti a partire da questo percorso.
Se in fase di estrazione o comparazione si vuole fare riferimento a percorsi assoluti, si può utilizzare
l’opzione ‘-P’. In questo modo si afferma esplicitamente che i percorsi indicati nell’archivio
vanno considerati come discendenti dalla directory radice.
Questo particolare della gestione dei percorsi è molto importante quando si fanno le copie di
sicurezza: spesso si hanno dischi montati su punti di innesto provvisori, pertanto non è molto
conveniente memorizzare anche il percorso su cui sono montati.
351.5.7 Recupero
Per poter effettuare un recupero di dati da un archivio è necessario conoscere in particolare il
modo in cui questo era stato creato: normale, compresso, multivolume.
In generale, per recuperare dati da un archivio si utilizza l’opzione ‘x’ (Extract) al posto di ‘c’ e
a essa si devono eventualmente aggiungere ‘-z’ nel caso di estrazione da un archivio compresso
con ‘gzip’ o ‘-M’ nel caso di un archivio multivolume.
Durante il recupero di una copia di sicurezza è importante fare in modo che i dati riprodotti mantengano
gli stessi attributi originali (permessi e proprietà). Per questo si aggiungono le opzioni
‘-p’ (riproduce i permessi) e ‘--same-owner’ (riproduce le proprietà: UID e GID).
L’esempio seguente mostra un recupero da un archivio multivolume su dischetti:
~$ tar x -M -p --same-owner -f /dev/fd0u1440
L’esempio seguente mostra un recupero con percorso assoluto: i percorsi indicati all’interno
dell’archivio vengono aggiunti alla directory radice:
$ tar xz -P -p --same-owner -f /mnt/mo1/lettere.tar.gz

Copie di sicurezza 17
351.5.8 Recupero parziale
Il recupero parziale del contenuto di un archivio Tar può essere fatto per file singoli o per directory,
oppure attraverso l’uso di caratteri jolly. In questo ultimo caso però, occorre fare attenzione
a evitare che la shell esegua l’espansione: è compito di Tar determinare a cosa corrispondano
all’interno dei suoi archivi. Questo è un po’ quello che accade a Find con l’opzione ‘-name’: è
Find stesso ad analizzare i caratteri jolly.
Valgono le regole solite: l’asterisco rappresenta un insieme di caratteri qualunque; il punto interrogativo
rappresenta un carattere qualsiasi; le parentesi quadre rappresentano un carattere a
scelta tra un insieme o tra un intervallo determinato.
Quando si indicano nomi di file o directory, o quando si utilizzano i caratteri jolly, occorre tenere
presente che si sta facendo riferimento ai dati contenuti nell’archivio, con i percorsi memorizzati
originariamente. Inoltre, se con i caratteri jolly si determina la corrispondenza con una directory,
si ottiene l’estrazione del contenuto complessivo di quella.
L’esempio seguente mostra in che modo potrebbero essere recuperate le lettere contenute nella
directory ‘home/tizio/lettere/nuove/’ (l’esempio appare diviso su due righe, a causa della
sua lunghezza):
$ tar xz -P -p --same-owner -f /mnt/mo1/lettere.tar.gz ←↪
↩→home/tizio/lettere/nuove
L’esempio seguente mostra l’estrazione di tutti i file e delle directory corrispondenti a ‘home/
tizio/lettere/ve * ’. Gli apici sono necessari per evitare che intervenga la shell a espandere
l’asterisco, che invece deve essere interpretato da Tar.
$ tar xz -P -p --same-owner -f /mnt/mo1/lettere.tar.gz ←↪
↩→’home/tizio/lettere/ve*’
351.5.9 Elenco e controllo
Per ottenere un elenco del contenuto di un archivio e per compararne il contenuto con i dati
originali, valgono le stesse regole del recupero dei dati. In particolare, al posto dell’opzione ‘x’
si deve utilizzare ‘t’ (List) per gli elenchi e ‘d’ (Diff ) per la comparazione.
351.6 Archiviazione di un file system
L’archiviazione di un file system intero, va fatta considerando le caratteristiche di questo, in particolare
della sua struttura fisica: partizioni e condivisione attraverso la rete. In generale dovrebbe
essere conveniente l’archiviazione separata per ogni partizione e per ogni file system condiviso
in rete.
Oltre a questo occorre evitare di archiviare anche l’archivio che si sta creando: quando la destinazione
dell’archiviazione è un file su disco, questo deve essere montato da qualche parte e per
questo si potrebbe creare un circolo vizioso.
Ci sono directory che, per la loro natura, non conviene o non devono essere archiviate: per
‘/tmp/’ non conviene; con ‘/proc/’ dei sistemi GNU/Linux non si deve. In questi casi si deve
solo ricordare di ricreare queste directory, nel momento in cui fosse necessario il recupero.
Naturalmente non bisogna dimenticare i permessi: ‘/tmp/’ 17778 e ‘/proc/’ 05558.

18 volume VIII Argomenti avanzati e accessori
351.6.1 Strumenti per il recupero
L’archiviazione di copie di sicurezza non è sufficiente a garantirsi contro gli incidenti: in che
modo si può avviare un elaboratore in cui è appena stato sostituito il disco fisso? Evidentemente,
occorre essere più previdenti e predisporre in anticipo gli strumenti necessari per preparare le
partizioni di un nuovo disco fisso e per recuperare i dati archiviati precedentemente.
Questo argomento viene trattato nei prossimi capitoli.
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Dischetti di emergenza con GNU/Linux
Capitolo 352
Nel momento dell’imprevisto si può agire solo se si è stati previdenti, pensando ai tipi di situazioni
che si possono presentare e preparando gli strumenti necessari in anticipo. Le copie di
sicurezza sono la prima cosa da fare per prepararsi ai guai, ma da sole non bastano: occorrono
altri strumenti per rimettere in sesto un sistema prima di poter effettuare un eventuale recupero
dalle copie.
352.1 Dischetti
Di fronte a un problema qualunque di una gravità tale da non permettere l’avvio di un sistema
locale, l’unica possibilità di intervenire è data da strumenti su dischetti (oppure su CD-ROM, ma
non è questo l’argomento del capitolo). Esistono diversi tipi di dischetti che possono essere stati
preparati in precedenza:
• dischetti di avvio;
• dischetti di installazione della distribuzione GNU/Linux;
• dischetti preparati appositamente.
352.1.1 Dischetti di avvio
Un dischetto di avvio può essere utile quando, per qualche motivo, il metodo normale di caricamento
del sistema operativo non funziona più. Esistono almeno tre tipi di dischetti di questo
tipo:
• dischetti con un settore di avvio, ma senza kernel;
• dischetti con un settore di avvio e con il kernel;
• dischetti contenenti solo l’immagine del kernel.
352.1.2 Settore di avvio senza il kernel
La soluzione del dischetto senza kernel non è adatta per avviare un sistema in difficoltà: è solo
un modo per verificare una configurazione di un sistema di avvio come LILO quando non si
vuole interferire con l’MBR del disco fisso. In pratica, nel caso di LILO si ottiene semplicemente
indicando nel file ‘/etc/lilo.conf’ la riga ‘boot=/dev/fd0’, come nell’esempio seguente:
boot=/dev/fd0
prompt
timeout=50
image=/boot/vmlinuz
label=linux
root=/dev/hda2
read-only
Quando viene avviato l’eseguibile ‘lilo’ con questa configurazione, si ottiene la scrittura del
primo settore del primo dischetto (il dischetto deve essere stato inizializzato in precedenza e può
19

20 volume VIII Argomenti avanzati e accessori
anche non contenere alcun file system). Ma in questo modo si intende che i file per il caricamento
del sistema si devono trovare nella directory ‘/boot/’ del momento in cui si esegue ‘lilo’,
ovvero nel file system in funzione in quel momento e non nel dischetto. Inoltre, anche il kernel
‘/boot/vmlinuz’ si intende contenuto in quel file system e non nel dischetto.
Se si utilizza GRUB, il file ‘/boot/grub/menu.lst’ rimane lo stesso, ma si danno dei comandi
differenti per inserire il settore di avvio nel dischetto. Si osservi che il dischetto deve essere
inserito nell’unità prima di avviare l’eseguibile ‘grub’:
# grub [ Invio ]
grub> root (hd0,1) [ Invio ]
Filesystem type is ext2fs, partition type 0x83
grub> setup (fd0) [ Invio ]
Checking if "/boot/grub/stage1" exists... yes
Checking if "/boot/grub/stage2" exists... yes
Checking if "/boot/grub/e2fs_stage1_5" exists... yes
Running "embed /boot/grub/e2fs_stage1_5 (fd0)"... failed (this is not fatal)
Running "embed /boot/grub/e2fs_stage1_5 (hd0,1)"... failed (this is not fatal)
Running "install /boot/grub/stage1 d (fd0) /boot/grub/stage2 p ←↪
↩→/boot/grub/menu.lst"... succeeded
Done.
grub> quit [ Invio ]
Quando si avvia con un dischetto fatto in questo modo, il programma contenuto nel primo settore
va alla ricerca del kernel e degli altri file, necessari per il caricamento del sistema, nel disco fisso
nel momento dell’utilizzo di LILO o di GRUB. Se il sistema non si avvia perché questi file o il
kernel sono stati spostati, a nulla serve un dischetto fatto in questo modo.
352.1.3 Settore di avvio e kernel
Per fare in modo che il dischetto avvii un kernel contenuto al suo interno, è necessario che questo
dischetto contenga un file system e un sistema di avvio.
Nel caso di LILO deve contenere una copia della directory ‘/boot/’ con il suo contenuto, la
directory ‘/etc/’ con il file ‘lilo.conf’ e deve essere riprodotta anche directory ‘/dev/’ con
il file di dispositivo ‘fd0’ (assieme agli altri file di dispositivo necessari a individuare i dischi o
le partizioni a cui si vuole fare riferimento). Quindi è sufficiente eseguire ‘lilo’ con l’opzione
‘-r’, come descritto nella sezione 18.4.
Nel caso di GRUB, il dischetto deve contenere la directory ‘/boot/grub/’ con i file ‘stage1’,
‘stage2’ e ‘menu.lst’. Il file del kernel può trovarsi in qualunque posizione (con qualunque
nome), purché il file ‘menu.lst’ sia stato predisposto di conseguenza. Fatto questo, si rende
avviabile il dischetto nel modo consueto di GRUB:
# grub [ Invio ]
grub> root (fd0) [ Invio ]
grub> setup (fd0) [ Invio ]
grub> quit [ Invio ]

Dischetti di emergenza con GNU/Linux 21
È bene ricordare che esiste anche la possibilità di usare SYSLINUX, che permette di realizzare un
dischetto con le stesse caratteristiche e con meno difficoltà. SYSLINUX è descritto nel capitolo
16.
Rispetto alla prossima tecnica, un dischetto contenente il sistema di avvio e il kernel, come appena
descritto, è uno strumento di avvio più completo perché permette di specificare, sia attraverso
la configurazione del sistema di avvio, sia per mezzo dei comandi che, a seconda del tipo sistema
di avvio, possono essere impartiti prima del caricamento del kernel, alcuni parametri di avvio
particolari del quale il proprio sistema potrebbe avere bisogno.
352.1.4 Immagine del kernel
L’ultima possibilità è la più semplice e, sotto questo aspetto, anche la più sicura: il file del kernel
viene copiato sul dispositivo del dischetto, senza fare uso di alcun file system. Si può utilizzare
uno dei due modi seguenti.
# cp vmlinuz /dev/fd0
# dd if=vmlinuz of=/dev/fd0
Evidentemente, il file del kernel è speciale perché riesce ad avviare se stesso. Il kernel da solo,
però, potrebbe non sapere quale dispositivo contiene il file system principale da montare al momento
dell’avvio. È necessario utilizzare il programma ‘rdev’ per inserire questa e altre notizie
nel kernel.
Supponendo che si debba avviare la partizione ‘/dev/hda2’, inizialmente in sola lettura, si
procede come segue per fare queste annotazioni in un kernel copiato in un dispositivo ‘/dev/
fd0’:
# rdev /dev/fd0 /dev/hda2
# rdev -R /dev/fd0 1
352.1.5 Dischetti di una distribuzione
La maggior parte delle distribuzioni GNU/Linux predispone dei dischetti di emergenza che
consentono generalmente di accedere al disco fisso e di fare delle piccole riparazioni.
Tra tutti, i dischetti più rudimentali sono quelli della distribuzione Slackware. La loro semplicità
è da considerare un pregio, dal momento che utilizzandoli ci si trova di fronte un sistema
GNU/Linux più o meno tradizionale, senza ottimizzazioni particolari.
352.1.6 Dischetti realizzati appositamente
Ogni sistema ha le proprie caratteristiche ed esigenze. I dischetti di emergenza preparati da altri,
oppure ottenuti da una distribuzione GNU/Linux, possono adattarsi a un certo insieme di
situazioni, ma non a tutte.
Quando si vuole essere sicuri di avere gli strumenti giusti al momento giusto, occorre che questi
siano stati preparati e collaudati bene, in modo da non sprecare tempo inutilmente. In sostanza,
la realizzazione o la personalizzazione di dischetti di emergenza è una tappa importante per chi
vuole amministrare seriamente il proprio sistema.

22 volume VIII Argomenti avanzati e accessori
352.2 Personalizzazione di dischetti di emergenza
L’utilizzo di dischetti di emergenza preparati da altri è un buon punto di partenza, ma le
particolarità che ogni sistema può avere consigliano almeno una personalizzazione del kernel.
352.2.1 Loopback block device
Per poter costruire o almeno personalizzare dei dischetti di emergenza è particolarmente utile
attivare nel kernel la gestione diretta delle immagini di questi (sezione 29.2.7).
In questo modo, un’immagine non compressa di un dischetto può essere montata con un comando
simile a quello seguente:
mount -o loop -t tipo_di_file_system file_immagine punto_di_innesto
352.2.2 disco RAM
Il file system principale può essere caricato in memoria centrale (RAM) e montato da lì. Si ottiene
un cosiddetto disco RAM. A parte ogni considerazione sui vantaggi che questo può avere nelle
prestazioni del sistema, si tratta di una modalità quasi obbligata per l’utilizzo di dischetti di
emergenza. Infatti, un disco RAM può essere ottenuto a partire da un’immagine compressa: è il
kernel stesso che la espande in memoria all’atto del caricamento. Quindi, si può fare stare in un
dischetto un’immagine di dimensioni superiori alla sua capacità.
Oltre a questo vantaggio, che però richiede la presenza di molta memoria RAM, un dischetto
contenente un file system che è stato trasferito nella RAM, può essere rimosso subito dopo il
suo caricamento, permettendo il riutilizzo dell’unità a dischetti, magari per accedere ad altri
programmi di servizio non inclusi nel disco RAM.
Per la gestione di un disco RAM occorre che il kernel sia configurato appositamente (29.2.7).
352.2.3 Scostamento (offset)
Quando il kernel carica un disco RAM da un’immagine contenuta in un dischetto, deve conoscere
la posizione di inizio di questa immagine. Ciò è importante quando sia il kernel che l’immagine
da caricare risiedono nello stesso dischetto. Quando l’immagine da caricare nel disco RAM è
contenuta in un dischetto separato, questa si troverà normalmente a partire dall’inizio di questo,
cioè da uno scostamento pari a zero.
352.3 Dischetti Slackware
I dischetti della distribuzione Slackware sono i più semplici ed efficaci in situazioni di emergenza.
Per essere avviati necessitano di un dischetto di avvio (boot) contenente il kernel, ma questo può
essere eventualmente predisposto localmente in modo da avere a disposizione la configurazione
più adatta al proprio sistema. Questi dischetti sono reperibili normalmente presso gli indirizzi
seguenti:
Il dischetto migliore per la soluzione di problemi è rappresentato dall’immagine compressa
‘rescue.gz’. Se si intende utilizzare anche un dischetto di avvio ottenuto dalla distribuzione,

Dischetti di emergenza con GNU/Linux 23
occorre sceglierlo in base alle indicazioni che si trovano nei file di testo inclusi nelle directory
indicate.
L’immagine ‘rootdsks/rescue.gz’ è compressa e contiene in pratica un disco in formato
Ext2 di qualche mebibyte (simbolo: Mibyte). Questo implica che per poterne fare uso occorre
molta memoria RAM.
Nelle prime versioni della distribuzione Slackware era distribuita un’immagine ‘rescue.gz’
molto più piccola, che poteva essere espansa e collocata comodamente su un dischetto da
1440 Kibyte. Questa immagine è ancora disponibile e si trova nel percorso ‘rootdsks/
obsolete/rescue.gz’. Il fatto di poterla decomprimere su un dischetto da 1440 Kibyte permette
di evitare il caricamento nella RAM. Per elaboratori aventi fino a 8 Mibyte di memoria
RAM, questo è l’unico dischetto di emergenza che possa essere utilizzato ragionevolmente.
Se si intende utilizzare l’immagine ‘rootdsks/obsolete/rescue.gz’, è necessario
avviare con un kernel in grado di gestire i vecchi binari a.out.
352.3.1 Organizzazione dei dischetti Slackware
Come già accennato, la distribuzione Slackware mette a disposizione immagini di dischetti di avvio,
contenenti essenzialmente il kernel, assieme a immagini di dischetti contenenti il file system
principale (root).
Le immagini per l’avvio rappresentano dischetti con un file system normale, contenente un settore
di avvio, la directory ‘/boot/’ e il kernel. Si tratta in pratica di dischetti realizzati in modo
analogo a quanto descritto in precedenza nella sezione 352.1.1, quando si faceva riferimento a
dischetti contenenti questi elementi. Le immagini dei dischetti di avvio, anche se non sono di
dimensioni pari a quelle di un dischetto normale, non dovrebbero essere compresse e si possono
copiare semplicemente sul dispositivo del dischetto di destinazione.
# dd if=net.i of=/dev/fd0
Le immagini dei dischetti contenenti il sistema minimo (root), sono invece dischetti di qualche
mebibyte, compressi in modo da poter essere collocati all’interno di un dischetto da 1440 Kibyte,
costringendo però all’uso di un disco RAM.
352.3.2 Utilizzare un kernel personalizzato
Per abbinare un kernel personalizzato a un dischetto contenente il sistema minimo della distribuzione
Slackware, si potrebbe ricostruire un dischetto di avvio seguendo le stesse modalità usate
dalla distribuzione stessa, oppure in maniera più semplice, copiando il kernel in un dischetto
direttamente attraverso il suo dispositivo e poi intervenendo con il programma ‘rdev’. Viene
descritta l’ultima di queste modalità.
# dd if=bzImage of=/dev/fd0
La copia di un kernel in un dischetto, attraverso il suo dispositivo, genera il solito dischetto
di avviamento già descritto tante volte. Questo kernel su dischetto deve però essere informato
di dove e come fare il caricamento del sistema. Il file system principale viene caricato da un
dischetto, quindi si scrive questo messaggio nel kernel attraverso ‘rdev’.

24 volume VIII Argomenti avanzati e accessori
# rdev /dev/fd0 /dev/fd0
I dischetti contenenti il sistema minimo della distribuzione Slackware non prevedono il controllo
del file system e il successivo montaggio in lettura e scrittura. In pratica, il file system principale
deve essere montato inizialmente in lettura-scrittura.
# rdev -R /dev/fd0 0
Infine si deve specificare che:
• l’immagine del dischetto contenente il sistema (compressa o meno che sia) si trova in un
dischetto separato e parte dalla posizione iniziale: lo scostamento è pari a zero;
• si vuole, oppure non si vuole, che tale dischetto sia caricato in un disco RAM;
• si vuole un preavviso per sapere quando si può togliere il dischetto del kernel per inserire
il dischetto contenente il sistema.
Per fare questo si agisce su una serie di bit configurabili attraverso ‘rdev’ con l’opzione ‘-r’:
• i primi 11 (dal bit 0 al bit 10) permettono di definire l’indirizzo dello scostamento (in
blocchi di 1024 byte);
• il bit 14 indica che si vuole caricare un disco RAM;
• il bit 15 indica che si vuole avere una pausa per lo scambio dei dischetti.
Se si vuole caricare il file system principale in un disco RAM si deve utilizzare ‘rdev’ nel modo
seguente:
# rdev -r /dev/fd0 49152
infatti, 2 15 + 2 14 + 0 = 49152.
Se invece non si vuole il disco RAM si deve utilizzare ‘rdev’ nel modo seguente:
# rdev -r /dev/fd0 32768
infatti, 2 15 + 0 + 0 = 32768.
352.4 Kernel per dischetti di emergenza
Quando si configura un kernel da utilizzare assieme a dischetti di emergenza, occorre tenere presente
che non è ragionevolmente possibile utilizzare i moduli ed è importante attivare determinate
caratteristiche che di solito non vengono considerate per i sistemi normali.
• Gestione dei binari a.out.
I dischetti di emergenza obsoleti sono nel vecchio formato a.out. Il kernel deve essere stato
predisposto per gestirli:
Kernel support for a.out binaries

Dischetti di emergenza con GNU/Linux 25
• File system Minix.
Il file system più utilizzato in passato per i dischetti di emergenza, specialmente quando
questi dovevano essere di dimensioni minime, è Minix. Anche se adesso i dischetti di
emergenza che si trovano in circolazione sono prevalentemente in formato Ext2, conviene
includere la gestione di questo vecchio tipo di formato:
Minix fs support
• dischi RAM.
Anche se non si intendono utilizzare dischetti caricati in memoria RAM, vale la pena di
preparare un kernel che ne permetta comunque l’utilizzo:
RAM disk support
• Porta parallela PLIP.
Un kernel per un dischetto di emergenza deve permettere la gestione della rete (TCP/IP)
e, in particolare, invece di attivare la gestione della porta parallela per la stampa, conviene
attivare la gestione della connessione PLIP:
PLIP (parallel port) support
352.4.1 Tastiera
Quando si usano dei dischetti di emergenza si hanno già molte limitazioni e a queste si aggiunge
anche la scomodità di una tastiera che non combacia con quella USA.
Si può risolvere il problema direttamente nel kernel senza dover tentare di inserire il programma
‘loadkeys’ in dischetti già troppo piccoli. È sufficiente trovare il file della mappa della tastiera
italiana (di solito si tratta del file ‘it.kmap’ collocato nella directory ‘/usr/share/keymaps/
piattaforma/qwerty/’) e quindi generare il sorgente ‘defkeymap.c’. Si procede come segue,
nel caso si utilizzi la piattaforma i386.
# cd /usr/src/linux/drivers/char
# loadkeys --mktable /usr/share/keymaps/i386/qwerty/it.kmap ←↪
↩→> defkeymap.c
La compilazione successiva di un nuovo kernel utilizzerà la mappa italiana come predefinita e
non ci sarà bisogno di utilizzare ‘loadkeys’.
352.5 Cavi
Quando si ha la disponibilità di più elaboratori, è probabile che il danno presentatosi su uno di
questi non si sia riprodotto in tutti. Una piccola rete locale potrebbe essere di aiuto in situazioni di
emergenza e in sua mancanza potrebbero andare bene anche dei cavi paralleli PLIP. Questo tipo
di cavo viene descritto nella parte lxxxvii. La sua realizzazione non è difficile: basta un piccolo
saldatore, un po’ di stagno, due connettori maschi DB-25 e una piattina multipolare con almeno
13 fili. La schermatura non è necessaria.
Con i dischetti della distribuzione Slackware, preferibilmente con l’immagine ‘resque.gz’, è
possibile stabilire una semplice connessione con un servente NFS.

26 volume VIII Argomenti avanzati e accessori
352.5.1 Ethernet
Attraverso una connessione Ethernet, con un’interfaccia riconosciuta come ‘eth0’, si può agire
come nell’esempio seguente. Si suppone in particolare che l’indirizzo di rete sia 192.168.1.0,
che la maschera di rete sia 255.255.255.0 e di poter utilizzare l’indirizzo IP 192.168.1.17 per
l’elaboratore avviato con i dischetti di emergenza.
# ifconfig eth0 192.168.1.17 netmask 255.255.255.0
# route add -net 192.168.1.0 netmask 255.255.255.0 dev eth0
Per verificare la connessione si può fare un ‘ping’ verso l’elaboratore da raggiungere: potrebbe
trattarsi dell’indirizzo 192.168.1.1.
# ping 192.168.1.1
Se tutto è andato bene si può procedere. Si suppone che l’elaboratore 192.168.1.1 metta a
disposizione il suo file system a partire dalla directory radice.
# mount -t nfs 192.168.1.1:/ /mnt
352.5.2 PLIP
Nel caso di una connessione PLIP, la procedura è un po’ differente. In particolare bisogna ricordare
che l’elaboratore dal quale si vogliono attingere i dati attraverso il protocollo NFS, deve
avere un kernel compilato in modo da gestire questo tipo di connessione.
Si fa riferimento allo stesso esempio riportato nella sezione precedente. L’unica differenza sta
nell’interfaccia usata per la comunicazione: si suppone che sia stata riconosciuta la ‘plip1’ da
entrambi i lati.
Il procedimento di connessione va fatto da entrambi i capi, infatti, raramente un elaboratore
ha una connessione PLIP stabile, per cui non si trova ad avere un indirizzo e una tabella di
instradamento già pronti.
Dal lato dell’elaboratore avviato con i dischetti si procede come segue:
rescue# ifconfig plip1 192.168.1.17 pointopoint 192.168.1.1
rescue# route add -host 192.168.1.17 dev plip1
rescue# route add -host 192.168.1.1 dev plip1
Dal lato dell’elaboratore servente si effettua l’operazione inversa:
server# ifconfig plip1 192.168.1.1 pointopoint 192.168.1.17
server# route add -host 192.168.1.1 dev plip1
server# route add -host 192.168.1.17 dev plip1
Per verificare la connessione si può provare con una richiesta di eco:
rescue# ping 192.168.1.1
Se tutto è andato bene si può procedere montando il file system di rete:

Dischetti di emergenza con GNU/Linux 27
rescue# mount -t nfs 192.168.1.1:/ /mnt
352.5.3 Considerazioni accessorie
Il dischetto di emergenza ha bisogno di un altro punto di innesto per accedere a un disco fisso
locale. È sufficiente creare un’altra directory.
Quando si accede a un servente NFS e non è possibile farlo mantenendo i privilegi dell’utente
‘root’, una semplice copia attraverso ‘cp -dpR’ non dà un risultato garantito: alcuni file potrebbero
risultare inaccessibili in lettura. La cosa si risolve facilmente impacchettando quello che
serve nell’elaboratore di origine e dando a questo archivio tutti i permessi necessari.
352.6 Utenti e gruppi
Quando si utilizza un sistema operativo minimo, avviato attraverso dischetti di emergenza, per
recuperare i dati da uno o più archivi, occorre fare mente locale al problema dell’abbinamento
utenti/gruppi, UID/GID.
Trattandosi di un sistema minimo, conterrà alcuni nomi di utenti e di gruppi, presumibilmente
non «umani», ma comunque esistenti. Solitamente, questi nomi di utenti e di gruppi sono standardizzati,
tuttavia il loro abbinamento con numeri UID/GID non è sempre uniforme. A questo
punto, se si recuperano i dati di un sistema in cui questi nomi non corrispondono esattamente,
si rischia di riprodurre una copia differente, che non sarà valida quando il sistema normale sarà
ripristinato.
Se non ci sono alternative, si può accettare l’inconveniente, riavviare il sistema rigenerato e
ripetere il recupero. In questo modo, i file verranno sovrascritti e le proprietà saranno abbinate in
base ai nuovi file ‘/etc/passwd’ e ‘/etc/group’.
In generale, proprio per questo problema, sarebbe opportuno che il dischetto di emergenza
contenesse esclusivamente l’indicazione dell’utente e del gruppo ‘root’, eliminando
qualunque altro tipo di utente di sistema.
352.7 Riferimenti
• Small Linux
• LOAF: Linux on a floppy
• Tomsrtbt: the most GNU/Linux on one floppy
• Trinux
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

28 volume VIII Argomenti avanzati e accessori

Parte lxx
Informatica gestionale
353 Codici a barre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
353.1 Codice di controllo «modulo n» . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
353.2 UPC-E e UPC-A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
353.3 EAN-8 e EAN-13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
353.4 Code 39 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
353.5 Code 128 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .39
353.6 ITF, ovvero i25 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
353.7 Sistemi bidimensionali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
353.8 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
354 Barcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
354.1 Utilizzo del programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .46
354.2 Codifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47
355 Trasformazione in lettere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
355.1 Da numero a sequenza alfabetica pura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
355.2 Da numero a numero romano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .50
355.3 Da numero a lettere, nel senso verbale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .53
29

Codici a barre
Capitolo 353
I codici a barre sono dati memorizzati in forma ottica, attraverso l’uso di barre verticali che
possono essere lette e interpretate facilmente con strumenti non troppo complessi. La tecnica dei
codici a barre nasce negli anni 1960 e si diffonde negli anni 1970, con lo scopo di identificare
rapidamente imballaggi e merci.
Gli standard sui codici a barre sono molti e il problema più importante da risolvere quando
si vogliono usare è il decidere quale sia quello più conveniente per i propri fini. Si parla di
simbologia per fare riferimento al tipo di codice a barre, ovvero allo standard di rappresentazione
dei dati; la simbologia definisce implicitamente il tipo di dati che possono essere memorizzati.
Per fare un esempio abbastanza comune, i codici ISBN dei libri sono scritti usando codici a
barre di tipo EAN-13, che si compongono di 13 cifre numeriche; in questo caso, la simbologia è
EAN-13, con la quale si vanno a rappresentare in pratica i codici ISBN.
Le rappresentazioni normali di un codice a barre sono a una sola dimensione, ovvero, è prevista
una lettura orizzontale unica. Nella lettura vengono attraversate barre verticali nere e spazi bianchi;
queste barre di larghezze differenti e gli spazi di ampiezze diverse sono gli elementi della
simbologia; ogni simbologia usa un proprio numero di elementi differenti. Nel capitolo vengono
descritte brevemente alcune simbologie standard.
353.1 Codice di controllo «modulo n»
Alcuni tipi di codici numerici utilizzano un numero di controllo (o codice di controllo) per permettere
una verifica facile dell’integrità del dato rappresentato. Esiste un genere comune di algoritmi
per il calcolo di tali numeri di controllo, a cui si fa spesso riferimento con la definizione
modulo n, dove n è un numero intero maggiore di uno.
In questo modo si fa riferimento a una somma di valori, ottenuta moltiplicando ogni cifra del
numero di partenza, compreso il numero di controllo, per un certo peso (un altro numero intero
positivo), che deve essere un multiplo del numero n stabilito. Si osservi l’esempio seguente, in
cui il numero di controllo finale è calcolato con i pesi dati, dividendo per il modulo 5:
5 + 12 + 15 + 14 + 4 = 50
Valore 1 3 5 7 4
Peso 5 4 3 2 1
Peso*Valore 5 12 15 14 4
50 è divisibile perfettamente per cinque, senza lasciare resti, garantendo l’integrità del valore.
In pratica, il peso che si dà al valore da usare come numero di controllo è solitamente uno, per
cui diventa facile il calcolo di questa cifra:
5 + 12 + 15 + 14 = 46;
46 / 5 = 9, con il resto di 1;
5 - 1 = 4, ovvero il valore cercato come numero di controllo.
30

Codici a barre 31
353.2 UPC-E e UPC-A
UPC è un insieme di simbologie standard utilizzato in particolare negli Stati Uniti e nel Canada.
Con UPC-E e UPC-A si possono rappresentare solo cifre numeriche: UPC-A consente di rappresentare
11 cifre più una di controllo; UPC-E consente di rappresentare sei cifre, senza codice di
controllo (il controllo di integrità avviene in forma differente).
La figura 353.1 mostra rispettivamente l’esempio di 123456 con UPC-E e di 12345678901 con
UPC-A.
Figura 353.1. Esempi di codici a barre con simbologia UPC-E e UPC-A.
0 123456 5 1 23456 78901 2
Gli elementi utilizzati nella simbologia UPC sono otto, composti da quattro tipi di barre nere e
quattro tipi di spazi.
Il codice di controllo di UPC-A si calcola moltiplicando in modo alterno le cifre che compongono
il numero, per tre, o per uno, sommando alla fine i risultati. Ciò che si ottiene si divide per 10 e
si tiene il resto; infine, 10 meno il resto ottenuto dà il codice di controllo cercato (modulo 10).
Per esempio, nel caso di 12345678901 si ottiene il codice di controllo due, in base al calcolo
seguente:
Valore 1 2 3 4 5 6 7 8 9 0 1
Peso 3 1 3 1 3 1 3 1 3 1 3
Peso*Valore 3 2 9 4 15 6 21 8 27 0 3
Il totale che si ottiene è 98; pertanto: 98/10 = 9 con un resto di 8; 10-8 = 2.
353.3 EAN-8 e EAN-13
EAN (European article number) è un insieme di simbologie standard di origine europea,
utilizzato anche in altri paesi, nato come estensione delle simbologie UPC.
EAN-8 e EAN-13 permettono di rappresentare solo cifre numeriche: EAN-8 consente di rappresentare
sette cifre più una di controllo, mentre EAN-13 consente di rappresentare 12 cifre
numeriche più una di controllo.
La figura 353.2 mostra rispettivamente l’esempio di 1234567 con EAN-8 e di 123456789012
con EAN-13.
Figura 353.2. Esempi di codici a barre con simbologia EAN-8 e EAN-13.
1234 5670 1 234567 890128

32 volume VIII Argomenti avanzati e accessori
Il codice di controllo di EAN-8 e di EAN-13 si calcola nello stesso modo di UPC-A. Per esempio,
nel caso di 1234567 (EAN-8) si ottiene il codice di controllo zero, mentre nel caso di
123456789012 (EAN-13) si ottiene otto.
Valore 1 2 3 4 5 6 7
Peso 3 1 3 1 3 1 3
Peso*Valore 3 2 9 4 15 6 21
Il totale che si ottiene è 60; pertanto: 60/10 = 6 con un resto di 0; 10-0 = 10, da cui si prende
solo l’ultima cifra (lo zero).
Valore 1 2 3 4 5 6 7 8 9 0 1 2
Peso 1 3 1 3 1 3 1 3 1 3 1 3
Peso*Valore 1 6 3 12 5 18 7 24 9 0 1 6
Il totale che si ottiene è 92; pertanto: 92/10 = 9 con un resto di 2; 10-2 = 8.
La rappresentazione di ogni cifra numerica può avere tre forme differenti, a cui si attribuisce
convenzionalmente una lettera alfabetica maiuscola: A, B e C. Nella simbologia EAN-8, le prime
quattro cifre sono rappresentate secondo la forma A, mentre le ultime quattro secondo la forma C.
Invece, la rappresentazione delle cifre nella simbologia EAN-13 è più complessa, per l’esigenza
di essere compatibile con UPC-A.
Con EAN-13 si rappresentano effettivamente solo le ultime 12 cifre (incluso il codice di controllo),
mentre la prima viene determinata in base al modo in cui vengono rappresentate le sei cifre
successive. In pratica, a seconda del valore della prima cifra, si determina la combinazione delle
forme A e B, per le sei cifre che seguono la prima, mentre le ultime sei sono rappresentate con la
forma C.
Valore iniziale
0 A A A A A A
1 A A B A B B
2 A A B B A B
3 A A B B B A
4 A B A A B B
5 A B B A A B
6 A B B B A A
7 A B A B A B
8 A B A B B A
9 A B B A B A
Dallo specchietto si può notare che con una prima cifra pari a zero, le sei cifre successive si
rappresentano secondo la forma A, esattamente come avviene nella simbologia UPC-A. In pratica,
a parte qualche differenza estetica minima, un codice a barre realizzato con la simbologia
EAN-13 è uguale a un altro realizzato con la simbologia UPC-A, quando la prima cifra è pari a
zero, tenendo conto che lo zero iniziale non può cambiare nulla anche nel calcolo del codice di
controllo finale.

Codici a barre 33
353.3.1 Codici UCC ed EAN
In generale, la simbologia EAN-13 viene utilizzata per identificare degli «articoli», intesi principalmente
come prodotti in vendita. Per poter applicare un codice a barre del genere occorre
naturalmente avere ottenuto il numero per uno scopo preciso (l’ente italiano competente per
l’attribuzione dei codici EAN è Indicod); tuttavia esiste un prefisso iniziale che fa parte dello
standard e serve a stabilire l’origine del codice. l’origine è un concetto riferito precisamente a
chi ha rilasciato il numero, che nella maggior parte dei casi si riferisce a un’organizzazione con
competenza nazionale.
Questo prefisso iniziale dipende principalmente da due organizzazioni: UCC (Uniform code
council) ed EAN (European article number). La prima organizzazione, definisce codici in cui
la prima cifra identifica l’origine nell’area nell’ambito di Stati Uniti e Canada, mentre la seconda
copre tutto il mondo, includendo la codifica UCC a cui si aggiunge la cifra iniziale zero.
La tabella 353.6 mostra in pratica un elenco abbastanza completo dei prefissi EAN, che solitamente
si applicano ai codici a barre con simbologia EAN-13. Si può osservare che ormai i codici
assegnati all’area Stati Uniti e Canada non hanno più solo lo zero iniziale; resta comunque l’abbinamento
tra codice UCC e codice EAN, per cui il primo si trasforma nel secondo aggiungendo
uno zero iniziale.
Tabella 353.6. Attribuzione dei prefissi secondo la codifica EAN. Prima parte.
Prefisso Contesto
ISO
3166
Prefisso
Contesto
ISO 3166
00-13 USA, Canada US, CA 14-19
2 uso interno 30-37 Francia FR
380
384
Bulgaria BG 383
385
Slovenia
Croazia
Bosnia
SI
HR
386 387
Erzego- BA
vina
388-
389
400-440
GermaniaFede-
DE
45 Giappone JP 460-469 razione RU
russa
470 471 Taiwan TW
472-
473
475 Lettonia LV
474
476
Estonia
Azerbaijan
EE
AZ
477
479
481
Lituania
Sri Lanka
Belarus
LT
LK
BY
478
480
482
UzbekistanFilippine
Ucraina
UZ
PH
UA
483
485 Armenia AM
484
486
Moldavia
Georgia
MD
GE
487 Kazakistan KZ 488
489 Hong Kong HK 49
Giappone
JP
50 Gran Bretagna UK 51
520 Grecia GR 521-527
528 Libano LB 529 Cipro CY
530 531
Macedonia
MK

34 volume VIII Argomenti avanzati e accessori
Prefisso Contesto
ISO
3166
Prefisso
Contesto
ISO 3166
532-
534
536-
538
54
Belgio,
Lussemburgo
BE, LU
535
539
55
Malta
Irlanda
MT
IE
560 Portogallo PT 561-568
569
58
Islanda IS 57
590
Danimarca
Polonia
DK
PL
591-
593
595-
598
600-
601
Sud Africa ZA
594
599
602-608
RomaniaUngheria
RO
HU
609 Mauritius MU 610
611 Marocco MA 612
613 Algeria DZ 614-615
616 Kenia KE 617-618
619 Tunisia TN 620
621 Siria SY 622 Egitto EG
623 624 Libia LY
625 Giordania JO 626 Iran IR
627 Kuwait KW 628
Arabia
Saudita
SA
629 Emirati AE 63
64 Finlandia FI 65-68
690-
693
70
Cina
Norwegia
CN
NO
694-699
710-728
729 Israele IL 73 Svezia SE
740
742
Guatemala
Honduras
GT
HN
741
743
El SalvadorNicaragua
SV
NI
744 Costa Rica CR 745 Panama PA
746
Repubblica Dominicana
DO 747-749
750 Messico MX 751-758
759 Venezuela VE 76
Svizzera
CH
770 Colombia CO 771-772
773 Uruguay UY 774
775 Perù PE 776
777 Bolivia BO 778
779 Argentina AR 780 Cile CL
781-
783
784
Paraguay
PY
785
787-
788
80-83 Italia IT
786
789
84
Ecuador
Brasile
Spagna
EC
BR
ES
850 Cuba CU 851-857
858 Slovacchia SK 859 Czech CZ
860 Jugoslavia YU 861-866

Codici a barre 35
Prefisso Contesto
ISO
3166
Prefisso
Contesto
ISO 3166
867 Nord Korea KP 868
869 Turchia TR 87 Olanda NL
880 Sud Korea KR 881-884
885 Thailandia TH 886-887
888 Singapore SG 889
890 India IN 891-892
893 Vietnam VN 894-898
899 Indonesia ID 90-91 Austria AT
92 93
94 Nuova Zelanda NZ 950-954
955 Malaysia MY 956-957
958 Macau MO 959-976
977
980
983-
989
periodici
(ISSN)
ricevute di rimborso
(refund
receipts)
978-979
981-982
99
Australia
libri
(ISBN)
tagliandi
di
valuta
(commoncurrencycoupons)tagliandi(coupons)
Si può osservare in particolare che il prefissi 978 e 979 sono riservati per i libri, mentre il prefisso
977 è riservato per i periodici (riviste). Dal momento che il prefisso EAN definiva originariamente
un’area nazionale, era stato attribuito al codice 978 la denominazione bookland (la terra dei
libri). Molta documentazione sui codici a barre e sulla numerazione ISBN fa ancora riferimento
a questo nome per indicare tale prefisso.
Un altro prefisso interessante è il due, che rimane libero. Molti negozi usano codici a barre EAN-
13, con prefisso due per annotare il prezzo di qualcosa che non è identificabile diversamente,
come gli alimentari ottenuti da un banco di salumi e formaggi. La figura 353.3 mostra un esempio
reale in cui, tra le altre cose, si annota un prezzo di 11,24 e.
Figura 353.3. Esempio di un codice a barre con simbologia EAN-13, usato per
annotare un prezzo.
2 000123 011240
AU

36 volume VIII Argomenti avanzati e accessori
353.3.2 ISBN
La simbologia EAN-13 viene usata in diverse situazioni comuni, in particolare per ciò che
riguarda le pubblicazioni.
La codifica ISBN (International standard book number) permette di identificare un libro in una
sua edizione precisa, attraverso un numero composto da 10 cifre. Il numero in questione contiene
quattro parti: l’origine (ovvero l’ente che lo ha rilasciato), l’editore, il titolo (il libro) e un numero
di controllo finale (una sola cifra).
Per facilitare la lettura di queste informazioni, le quattro parti vengono mostrate solitamente
come separate, attraverso un trattino. Per esempio, ‘88-8331-223-6’ indica l’origine 88 (Italia),
l’editore 8331, il titolo 233 e il numero di controllo 6.
Le varie parti in cui si suddivide l’informazione contenuta in un numero ISBN non sono di
lunghezza fissa e la dimensione dell’una limita quella delle altre. In generale sono disponibili i
raggruppamenti seguenti.
1. La prima parte identifica l’area (nazionale, linguistica e geografica) e viene attribuita
dall’agenzia internazionale dell’ISBN. Il numero assegnato all’Italia è 88.
• 0-7
• 80-94
• 950-994
• 9950-9989
• 99900-99999
2. La seconda parte identifica l’editore e viene attribuito dall’agenzia ISBN competente
nell’area di riferimento.
• 00-19
• 200-699
• 7000-8499
• 85000-89999
• 900000-999999
3. La terza parte identifica il titolo, relativamente all’editore a cui si fa riferimento, utilizzando
lo spazio rimanente, escludendo il numero di controllo finale.
4. Il numero di controllo viene calcolato moltiplicando le cifre per un numero che va da 10 a
uno, sommando ciò che si ottiene e dividendo per il «modulo 11». In questo modo, il valore
che si ottiene può andare da 0 a 10, dove il 10 si rappresenta con una lettera «X».
Per comprendere il meccanismo del calcolo del numero di controllo, conviene vedere un esempio
reale, il numero ISBN ‘88-8331-223-6’. In pratica, si tratta di verificare che il numero sei sia
effettivamente il numero di controllo corretto.
Valore 8 8 8 3 3 1 2 2 3 6
Peso 10 9 8 7 6 5 4 3 2 1
Peso*Valore 80 72 64 21 18 5 8 6 6 6

Codici a barre 37
Il totale che si ottiene è 286, che diviso per 11 dà esattamente 26, senza resto, a conferma della
validità del numero di controllo. Non conoscendo il numero di controllo lo si potrebbe calcolare:
la somma che si otterrebbe sarebbe solo 280, che divisa per 11 dà 25 con il resto di 5, per cui, 11
- 5 dà 6, il numero cercato.
Il numero ISBN si trasforma in EAN-13 mettendo anteriormente il valore 978 e togliendo il
numero di controllo finale che va sostituito con quello calcolato secondo lo standard EAN-13;
naturalmente, i trattini di divisione sono perduti. La figura 353.4 mostra l’esempio del codice
ISBN 88-481-0113-5 rappresentato secondo la simbologia EAN-13, che si trasforma nel numero
9788848101134.
Figura 353.4. ISBN 88-481-0113-5.
ISBN 88-481-0113-5
9 788848 101134
A seconda del paese in cui si utilizza il numero ISBN, può essere obbligatorio o meno un codice
a barre aggiuntivo contenente l’informazione sul prezzo.
353.3.3 ISSN
La codifica ISSN permette di identificare una pubblicazione periodica attraverso una tecnica
simile a quella del numero ISBN per i libri. In questo caso, il numero è composto da otto cifre
numeriche (compreso il numero di controllo), che vanno inserite in una simbologia EAN-13
aggiungendo all’inizio il prefisso 977, togliendo il numero di controllo ISSN, aggiungendo due
cifre che rappresentano il codice del prezzo e aggiungendo il codice di controllo EAN-13. Inoltre,
va aggiunto un codice a barre ulteriore per rappresentare due o cinque cifre in cui si indica il
numero del fascicolo.
Per esempio, il numero ISSN ‘1129-1346’ di una rivista potrebbe tradursi nel codice a barre
9771129134006, con l’aggiunta di 10110, dove il codice del prezzo è assente e si fa riferimento
al fascicolo numero 110.
La figura 353.5 mostra l’esempio del codice di due riviste, in cui appare anche un’estensione
contenente il numero della pubblicazione.
Figura 353.5. Esempio di due codici ISSN, riferiti a riviste, con un’estensione
contenente il numero della pubblicazione (rispettivamente 106 e 23).
353.4 Code 39
La simbologia denominata Code 39, ovvero 3 of 9, consente di rappresentare 42 simboli, composti
da lettere maiuscole, cifre numeriche e pochi altri segni. La tabella 353.8 riepiloga l’insieme
di caratteri. Un codice a barre Code 39 è composto da un carattere di inizio, dai dati che deve
contenere, da un codice di controllo (che non appare tradotto per la lettura umana) e dal carattere
di fine. Il carattere usato per iniziare e per concludere la sequenza è l’asterisco, che quindi non
può essere utilizzato nei dati contenuti.

38 volume VIII Argomenti avanzati e accessori
Tabella 353.8. Insieme di caratteri per la simbologia Code 39.
Valore Carattere Valore Carattere
0 0 22 M
1 1 23 N
2 2 24 O
3 3 25 P
4 4 26 Q
5 5 27 R
6 6 28 S
7 7 29 T
8 8 30 U
9 9 31 V
10 A 32 W
11 B 33 X
12 C 34 Y
13 D 35 Z
14 E 36 -
15 F 37 .
16 G 38 space
17 H 39 $
18 I 40 /
19 J 41 +
20 K 42 %
21 L inizio/fine *
Figura 353.6. Esempio di codice a barre Code 39.
C I A O
Gli elementi utilizzati nella simbologia Code 39 sono quattro, composti da due tipi di barre nere
e due tipi di spazi. Ogni carattere o segno che può essere rappresentato con questa simbologia, si
avvale di cinque barre e di quattro spazi, per un totale di nove elementi. Il nome della simbologia,
che si può tradurre come «tre su nove», indica il fatto che tre elementi su nove sono sempre di
tipo largo (rispetto agli altri che invece sono stretti).
Il codice di controllo si ottiene sommando assieme i valori abbinati ai segni che si possono
rappresentare, secondo la tabella di conversione 353.8, dividendo per 43. Il resto della divisione
è il codice di controllo. Nel caso dell’esempio che appare in figura 353.6, si tratta della lettera
‘L’:
«CIAO» = 12 + 18 + 10 + 24 = 64
64 / 43 = 1 lasciando un resto di 21 = ‘L’

Codici a barre 39
353.4.1 Code 39 esteso
Esiste anche un’estensione della simbologia Code 39, allo scopo di consentire la rappresentazione
dell’ASCII standard completo. Si ottiene questo risultato scrivendo due simboli normali
al posto di uno. Naturalmente, dal momento che non esiste un modo per distinguere la codifica
standard da quella estesa, è necessario che il lettore di codice a barre sia impostato nel modo più
conveniente. La tabella 353.9 mostra l’insieme di caratteri esteso e la corrispondenza con i segni
della simbologia Code 39 normale.
Tabella 353.9. Insieme di caratteri esteso per la simbologia Code 39.
ASCII Code 39 ASCII Code 39 ASCII Code 39 ASCII Code 39
%U = @ %V ‘ %W
$A ! /A A A a +A
$B " /B B B b +B
$C # /C C C c +C
$D $ /D D D d +D
$E % /E E E e +E
$F & /F F F f +F
$G ’ /G G G g +G
$H ( /H H H h +H
$I ) /I I I i +I
$J * /J J J j +J
$K + /K K K k +K
$L , /L L L l +L
$M - /M M M m +M
$N . /N N N n +N
$O / /O O O o +O
$P 0 0 P P p +P
$Q 1 1 Q Q q +Q
$R 2 2 R R r +R
$S 3 3 S S s +S
$T 4 4 T T t +T
$U 5 5 U U u +U
$V 6 6 V V v +V
$W 7 7 W W w +W
$X 8 8 X X x +X
$Y 9 9 Y Y y +Y
$Z : /Z Z Z z +Z
%A ; %F [ %K { %P
%B < %G \ %L | %Q
%C = %H ] %M } %R
%D > %I ^ %N ~ %S
%E ? %J _ %O %T
353.5 Code 128
La simbologia denominata Code 128, ovvero USS Code 128, consente di rappresentare 106 simboli,
che possono essere interpretati secondo tre insiemi di caratteri, distinti in base a una lettera:
A, B e C. Per questa ragione, un codice a barre realizzato secondo la simbologia Code 128 inizia
sempre con la dichiarazione dell’insieme di caratteri. L’informazione non ha una lunghezza
predeterminata e può essere modificato l’insieme di caratteri quando serve. La simbologia Code
128 prevede l’inserimento di un codice di controllo, calcolato automaticamente per consentire
la verifica della lettura meccanica, ma questa cifra non viene mostrata per la lettura umana.

40 volume VIII Argomenti avanzati e accessori
Tabella 353.10. Insiemi di caratteri per la simbologia Code 128. L’ultima colonna ripor-
ta anche la descrizione della rappresentazione a barre, dove un numero da uno a
tre indica la larghezza della barra, ‘b’, o dello spazio, ‘s’, dalla grandezza più piccola
alla più grande. Si osservi che lo stop ha una barra in più alla fine.
Valore Code A Code B Code C Barre e spazi:
b s b s b s
0 00 2 1 2 2 2 2
1 ! ! 01 2 2 2 1 2 2
2 " " 02 2 2 2 2 2 1
3 # # 03 1 2 1 2 2 3
4 $ $ 04 1 2 1 3 2 2
5 % % 05 1 3 1 2 2 2
6 & & 06 1 2 2 2 1 3
7 ’ ’ 07 1 2 2 3 1 2
8 ( ( 08 1 3 2 2 1 2
9 ) ) 09 2 2 1 2 1 3
10 * * 10 2 2 1 3 1 2
11 + + 11 2 3 1 2 1 2
12 ’ ’ 12 1 1 2 2 3 2
13 - - 13 1 2 2 1 3 2
14 . . 14 1 2 2 2 3 1
15 / / 15 1 1 3 2 2 2
16 0 0 16 1 2 3 1 2 2
17 1 1 17 1 2 3 2 2 1
18 2 2 18 2 2 3 2 1 1
19 3 3 19 2 2 1 1 3 2
20 4 4 20 2 2 1 2 3 1
21 5 5 21 2 1 3 2 1 2
22 6 6 22 2 2 3 1 1 2
23 7 7 23 3 1 2 1 3 1
24 8 8 24 3 1 1 2 2 2
25 9 9 25 3 2 1 1 2 2
26 : : 26 3 2 1 2 2 1
27 ; ; 27 3 1 2 2 1 2
28 < < 28 3 2 2 1 1 2
29 = = 29 3 2 2 2 1 1
30 > > 30 2 1 2 1 2 3
31 ? ? 31 2 1 2 3 2 1
32 @ @ 32 2 3 2 1 2 1
33 A A 33 1 1 1 3 2 3
34 B B 34 1 3 1 1 2 3
35 C C 35 1 3 1 3 2 1
36 D D 36 1 1 2 3 1 3
37 E E 37 1 3 2 1 1 3
38 F F 38 1 3 2 3 1 1
39 G G 39 2 1 1 3 1 3
40 H H 40 2 3 1 1 1 3
41 I I 41 2 3 1 3 1 1
42 J J 42 1 1 2 1 3 3
43 K K 43 1 1 2 3 3 1
44 L L 44 1 3 2 1 3 1
45 M M 45 1 1 3 1 2 3
46 N N 46 1 1 3 3 2 1
47 O O 47 1 3 3 1 2 1
48 P P 48 3 1 3 1 2 1
49 Q Q 49 2 1 1 3 3 1

Codici a barre 41
Valore Code A Code B Code C Barre e spazi:
b s b s b s
50 R R 50 2 3 1 1 3 1
51 S S 51 2 1 3 1 1 3
52 T T 52 2 1 3 3 1 1
53 U U 53 2 1 3 1 3 1
54 V V 54 3 1 1 1 2 3
55 W W 55 3 1 1 3 2 1
56 X X 56 3 3 1 1 2 1
57 Y Y 57 3 1 2 1 1 3
58 Z Z 58 3 1 2 3 1 1
59 [ [ 59 3 3 2 1 1 1
60 \ \ 60 3 1 4 1 1 1
61 ] ] 61 2 2 1 4 1 1
62 ^ ^ 62 4 3 1 1 1 1
63 _ _ 63 1 1 1 2 2 4
64 ‘ 64 1 1 1 4 2 2
65 a 65 1 2 1 1 2 4
66 b 66 1 2 1 4 2 1
67 c 67 1 4 1 1 2 2
68 d 68 1 4 1 2 2 1
69 e 69 1 1 2 2 1 4
70 f 70 1 1 2 4 1 2
71 g 71 1 2 2 1 1 4
72 h 72 1 2 2 4 1 1
73 i 73 1 4 2 1 1 2
74 j 74 1 4 2 2 1 1
75 k 75 2 4 1 2 1 1
76 l 76 2 2 1 1 1 4
77 m 77 4 1 3 1 1 1
78 n 78 2 4 1 1 1 2
79 o 79 1 3 4 1 1 1
80 p 80 1 1 1 2 4 2
81 q 81 1 2 1 1 4 2
82 r 82 1 2 1 2 4 1
83 s 83 1 1 4 2 1 2
84 t 84 1 2 4 1 1 2
85 u 85 1 2 4 2 1 1
86 v 86 4 1 1 2 1 2
87 w 87 4 2 1 1 1 2
88 x 88 4 2 1 2 1 1
89 y 89 2 1 2 1 4 1
90 z 90 2 1 4 1 2 1
91 { 91 4 1 2 1 2 1
92 | 92 1 1 1 1 4 3
93 } 93 1 1 1 3 4 1
94 ~ 94 1 3 1 1 4 1
95 95 1 1 4 1 1 3
96 FNC 3 FNC 3 96 1 1 4 3 1 1
97 FNC 2 FNC 2 97 4 1 1 1 1 3
98 Shift Shift 98 4 1 1 3 1 1
99 Code C Code C 99 1 1 3 1 4 1
100 Code B FNC 4 Code B 1 1 4 1 3 1
101 FNC 4 Code A Code A 3 1 1 1 4 1
102 FNC 1 FNC 1 FNC 1 4 1 1 1 3 1
103 Start A Start A Start A 2 1 1 4 1 2
104 Start B Start B Start B 2 1 1 2 1 4

42 volume VIII Argomenti avanzati e accessori
Valore Code A Code B Code C Barre e spazi:
b s b s b s
105 Start C Start C Start C 2 1 1 2 3 2
Stop Stop Stop 2 3 3 1 1 1 2
Gli insiemi di caratteri A, B e C sono elencati nella tabella 353.10. Come si può vedere, l’insieme
A consente di rappresentare l’alfabeto maiuscolo, le cifre numeriche, vari simboli di punteggiatura
e caratteri di controllo; in pratica, ciò che si può rappresentare con la prima parte della codifica
ASCII, tenendo conto che le posizioni non corrispondono. L’insieme B consente di rappresentare
praticamente tutto l’alfabeto ASCII, compresa la distinzione tra lettere maiuscole e minuscole,
a esclusione dei caratteri di controllo. L’insieme C consente di rappresentare valori numerici a
coppie, per cui, un valore composto da un numero dispari di cifre acquisisce uno zero iniziale.
Figura 353.7. Esempio di due codici Code 128, realizzati usando l’insieme B e l’insieme
C, per rappresentare due dati equivalenti: «Ciao» e 35736579.
Ci ao 35736579
La figura 353.7 mostra la comparazione tra un codice a barre realizzato usando l’insieme B
e un altro con l’insieme C. L’informazione contenuta è la stessa dal punto di vista dei valori
rappresentabili (eventualmente si osservino le tabelle degli insiemi di caratteri). Se fosse possibile
sovrapporre i due codici, si noterebbe che cambia solo la parte iniziale, quella in cui si dichiara
l’insieme di caratteri, e la parte finale, dove si inserisce il codice di controllo. Si può anche
osservare che gli ultimi elementi rimangono uguali e sono quelli che contengono il codice di
conclusione.
Volendo entrare nel dettaglio, l’esempio di figura 353.7 si compone di: ‘Start B’, 35, 73,
65, 79, codice_di_controllo, ‘Stop’; ovvero, nel secondo caso, ‘Start C’, 35, 73, 65, 79,
codice_di_controllo, ‘Stop’.
Quando si vuole cambiare l’insieme di caratteri, si inserisce un simbolo ‘Code A’, ‘Code B’ o
‘Code C’, per introdurre l’insieme a cui si vuole fare riferimento da quel punto in poi.
Il codice di controllo finale si calcola sommando il valore corrispondente alla dichiarazione iniziale
dell’insieme di caratteri alla somma dei valori successivi, moltiplicati per la loro posizione.
La somma complessiva va divisa per 103 e il resto che si ottiene è il codice di controllo finale. Si
osservi l’esempio:
Pertanto:
104 + 35 + 146 + 195 + 316 = 796
Start B C i a o Stop
Peso 1 1 2 3 4
Valore 104 35 73 65 79
Peso*Valore 104 35 146 195 316
796 / 103 = 7 con resto di 75. Il codice di controllo è il simbolo corrispondente al valore 75.
Usando l’insieme di caratteri C la cosa cambia, perché il simbolo iniziale ha il valore 105, per
cui il codice di controllo finale è 76:

Codici a barre 43
Start C 35 73 65 79 Stop
Peso 1 1 2 3 4
Valore 105 35 73 65 79
Peso*Valore 105 35 146 195 316
Dalla simbologia Code 128 derivano diverse applicazioni speciali che si distinguono per avere
una struttura particolare. Esiste anche una variante che consente la rappresentazione di più
caratteri rispetto all’ASCII standard.
353.5.1 UCC/EAN 128
La simbologia UCC/EAN 128 è un’applicazione di Code 128, in cui si inizia dichiarando
l’insieme di caratteri e si inserisce subito dopo il simbolo ‘FNC 1’ (Function code one). 1
Dopo il simbolo ‘FNC 1’ viene indicato un codice che indica il tipo di applicazione. Si fa riferimento
a questo con la sigla AI (Application identifier). L’informazione in questione viene
rappresentata per la lettura umana tra parentesi tonde, proprio per facilitare l’interpretazione, a
sottolineare il fatto che si tratta di un prefisso. Naturalmente, l’informazione può essere anche
più complessa e altre parti dei dati successivi possono essere separate ed evidenziate nello stesso
modo o in modi differenti.
353.6 ITF, ovvero i25
La simbologia ITF, o i25, nota come Interleaved two of five, ovvero «interfogliata due su cinque»,
consente la rappresentazione di soli valori numerici, di lunghezza indefinita, purché in numero di
cifre pari. La simbologia prevede una cifra di controllo finale, opzionale.
La simbologia si compone di due tipi di barre e due tipi di spazi. Ogni simbolo si rappresenta
con cinque barre e cinque spazi, dove due barre su cinque e due spazi su cinque sono più larghi.
La simbologia è detta «interfogliata», perché una cifra è codificata nelle barre e la successiva
lo è negli spazi che separano gli elementi del carattere precedente. Prima dei dati è previsto un
simbolo iniziale, composto da una barra sottile, uno spazio breve, una barra sottile e un altro
spazio breve; alla fine c’è un simbolo finale, composto da una barra larga, uno spazio sottile e
una barra sottile.
Figura 353.8. Esempio di codice a barre con simbologia interfogliata due su cinque.
0 1 2 3 4 5 6 7 8
1 L’uso comune è dell’insieme di caratteri C, ma ciò non è imposto dallo standard.

44 volume VIII Argomenti avanzati e accessori
353.7 Sistemi bidimensionali
Il codice a barre comune è a una sola dimensione, nel senso che contiene una sola riga di informazioni,
eventualmente anche molto breve. Semplificando le cose, si può dire che quando si
sovrappongono più righe in un codice a barre, questo diventa a due dimensioni.
Un sistema di codice a barre a due dimensioni, con lo scopo di memorizzare dati, deve essere
organizzato in modo da permettere al lettore meccanico di riconoscere e seguire le righe; inoltre
deve essere previsto un sistema di informazioni ridondanti, anche molto complesso, in modo da
garantire la lettura in presenza di errori.
Lo standard più comune per i codici a barre a due dimensioni è il PDF417, che comunque qui
non viene descritto.
353.8 Riferimenti
• EAN international
• The EAN.UCC system
• Tino Hempel, Die Europäische Artikelnummer (EAN)
• Barcoding for Beginners & Bar Code FAQ
• Code 39 Barcode FAQ and Tutorial
• Code 128 / USS Code-128 Barcode FAQ & Tutorial
• PDF417 Barcode FAQ
• UPC / EAN Barcode Font Data Sheet
• PDF417
• Russ Adams, Barcode 1
• International ISBN Agency: Coordinator of the International Standard Book Number
system
• International ISBN Agency, The ISBN Users’ Manual

Codici a barre 45
• AIE - Agenzia ISBN
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Barcode
Capitolo 354
Barcode 1 è una libreria e anche un programma molto semplice per la realizzazione di codici
a barre standard a una sola dimensione. Il codice a barre viene realizzato in forma di file Post-
Script, che successivamente può essere utilizzato direttamente o convertito in altri formati grafici,
attraverso programmi standard.
354.1 Utilizzo del programma
Barcode, come programma, si compone in pratica dell’eseguibile ‘barcode’. Questo genera normalmente
un file PostScript che, salvo l’utilizzo dell’opzione ‘-o’, viene emesso attraverso lo
standard output.
barcode [opzioni]
Teoricamente si può usare Barcode anche senza l’indicazione di alcun argomento, per ottenere
la conversione automatica di quanto inserito attraverso lo standard input, scegliendo la simbologia
in modo automatico. Tuttavia, in genere è opportuno accertarsi di selezionare la simbologia
attraverso l’opzione ‘-e’.
Le opzioni che vengono mostrate qui sono poche; in particolare mancano quelle che servono a
definire la stampa di codici a barre in modo organizzato sul foglio, allo scopo di centrare delle
etichette adesive. Per approfondire basta leggere la documentazione originale: barcode.info.
Tabella 354.1. Alcune opzioni.
Opzione Descrizione
Consente di specificare la simbologia dei codici a barre che si
vogliono realizzare (encoding). Sono disponibili diverse pa-
-e simbologia
role chiave da usare come argomento dell’opzione, secondo
la tabella 354.2.
Stabilisce il nome di un file contenente un elenco di codici da
trasformare in codici a barre. Se manca questa indicazione e
-i file
se manca anche l’opzione ‘-b’, viene letto lo standard input.
La lettera dell’opzione richiama mnemonicamente la parola
«input».
Consente di indicare una stringa da convertire in un codice a
barre singolo. La stringa deve essere compatibile con i tipi di
dati che possono essere rappresentati con la simbologia pre-
-b stringa
scelta. La lettera dell’opzione richiama mnemonicamente la
parola barcode, ovvero il codice a barre che si vuole ottenere
dalla stringa.
-E Genera un file PostScript incapsulato (EPS).
Segue la descrizione di alcuni esempi.
• $ barcode -E -e i25 -b "12345678" > prova.ps
Converte il numero 12345678 in un codice a barre secondo la simbologia interfogliata due
su cinque, generando il file ‘prova.ps’, di tipo EPS.
• $ barcode -E -e i25 -b "12345678" -o prova.ps
1 Barcode GNU GPL
46

Barcode 47
Esattamente come nell’esempio precedente.
• $ barcode -E -e isbn -b "88-386-4177-3" -o prova.ps
Come nell’esempio precedente, usando la simbologia EAN-13 per rappresentare un codice
ISBN, come indicato con l’opzione ‘-b’.
354.2 Codifica
Generalmente, Barcode viene utilizzato indicando il tipo di simbologia, attraverso una parola
chiave secondo l’elenco della tabella 354.2. In generale, si tratta di nomi che fanno riferimento
al tipo di codice a barre; in alcuni casi, il nome indica anche altre caratteristiche. Per esempio,
la parola chiave ‘code128b’ indica la simbologia Code 128, nella quale si utilizza l’insieme di
caratteri B; inoltre, la parola chiave ‘isbn’ fa riferimento al codice ISBN, che viene rappresentato
correttamente secondo la simbologia EAN-13.
Tabella 354.2. Simbologie disponibili con Barcode.
Simbologia Parola chiave
UPC-A
upc-a
UPC-E
upc-e
UPC-A o UPC-E automaticamente
upc
EAN-8 ean8, ean-8
EAN-13 ean13, ean-13
EAN-8 o EAN-13 automaticamente
ean
Code 39 code39, 39
Code 128 insieme di caratteri B code128b, 128b
Code 128 insieme di caratteri C code128c, 128c
Code 128 insieme di caratteri A, B o C, automaticamente code128, 128
Code 128 libero 128raw
interfogliata due su cinque i25, interleaved 2 of 5
Codabar cdr, codabar
Plessey pls, plessey
ISBN attraverso EAN-13 isbn
Nel caso dell’uso della simbologia Code 128, si pone il problema di rappresentare i codici da
a , il codice e le funzioni speciali previste dalla simbologia. Usando l’eseguibile
‘barcode’ diventa difficile indicare questi simboli; con la libreria non ci sono problemi
a indicare i codici ASCII da a e il codice , mentre negli altri casi viene fatta
una trasformazione, come rappresentato nella tabella 354.3.
Tabella 354.3. Rappresentazione dei caratteri speciali per la simbologia Code 128,
quando si usa la libreria Barcode.
Codice o simbolo Ottale Decimale Esadecimale
2008 128 8016
FNC 1 3018 193 C116
FNC 2 3028 194 C216
FNC 3 3038 195 C316
FNC 4 3048 196 C416
Sempre a proposito della simbologia Code 128, è possibile utilizzando la parola chiave ‘128raw’
per indicare un codice attraverso una stringa espressa nella forma:

48 volume VIII Argomenti avanzati e accessori
n_1 n_2... n_n
In pratica, si indicano una serie di numeri separati tra loro da uno spazio. I numeri in questione
rappresentano il valore indicato nella tabella 353.10; inoltre occorre tenere in considerazione che
va fornito anche il valore iniziale, con il quale si definisce solitamente l’insieme di caratteri A, B
o C, mentre il codice di controllo finale e lo stop sono aggiunti automaticamente.
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Trasformazione in lettere
Capitolo 355
Nell’ambito della realizzazione di applicativi gestionali, capitano frequentemente problemi di
conversione di numeri interi in una qualche forma alfabetica. In questo capitolo vengono mostrati
degli algoritmi molto semplici per risolvere questo tipo di problemi.
355.1 Da numero a sequenza alfabetica pura
Esiste un tipo di numerazione in cui si utilizzano solo le lettere dell’alfabeto, dalla «a» alla «z»,
senza accenti o altri simboli speciali, senza distinguere tra maiuscole e minuscole. In generale,
i simboli da «a» a «z» consentono di rappresentare valori da 1 a 26, dove lo zero è escluso.
Per rappresentare valori superiori, si possono accoppiare più lettere, ma il calcolo non è banale,
proprio perché manca lo zero.
Attraverso la pseudocodifica introdotta nel capitolo 286, si può descrivere una funzione che calcoli
la stringa corrispondente a un numero intero positivo, maggiore di zero. Per prima cosa,
occorre definire una sotto funzione che sia in grado di trasformare un numero intero, compreso
tra 1 e 26 nella lettera alfabetica corrispondente; ciò si ottiene abbastanza facilmente, attraverso
la verifica di più condizioni in cascata. Il vero problema, purtroppo, sta nel costruire una stringa
composta da più lettere, quando si vuole rappresentare un valore superiore a 26. Non essendoci
lo zero, diventa difficile fare i calcoli. Se si parte dal presupposto che il numero da convertire
non possa essere superiore a 702, si sa con certezza che servono al massimo due lettere alfabetiche
(perché la stringa «ZZ» corrisponderebbe proprio al numero 702); in tal caso, è sufficiente
dividere il numero per 26, dove la parte intera rappresenta la prima lettera, mentre il resto rappresenta
la seconda. Tuttavia, se la divisione non dà resto, la stringa corretta è quella precedente.
Per esempio, il numero 53 corrisponde alla stringa «BA», perché 53/26 = 2 con un resto di 1.
Nello stesso modo, però, 52 si traduce nella stringa «AZ», perché 53/26 = 2, ma non c’è resto,
pertanto, «B_» diventa «AZ».
La pseudocodifica seguente riepiloga il concetto in modo semplificato, dove, a seconda delle
esigenze, la conversione è sempre limitata a un valore massimo. Le omissioni sono parti di codice
facilmente intuibili.
INTEGER_TO_ALPHABET (N)
ALPHABET_DIGIT (DIGIT)
IF DIGIT = 0
THEN
RETURN ""
ELSE IF DIGIT = 1
THEN
RETURN "A"
ELSE IF DIGIT = 2
THEN
RETURN "B"
...
...
ELSE IF DIGIT = 26
THEN
RETURN "Z"
ELSE
RETURN "##ERROR##"
FI
END ALPHABET_DIGIT
IF N

50 volume VIII Argomenti avanzati e accessori
THEN
RETURN "##ERROR##";
ELSE IF N

Trasformazione in lettere 51
Per risolvere il problema con un algoritmo relativamente semplice, si può scomporre il valore
di partenza in fasce: unità, decine, centinaia e migliaia (la conversione di valori superiori
genererebbe soltanto una serie lunghissima di «M» che risulta poi troppo difficile da leggere).
INTEGER_TO_ROMAN (N)
LOCAL DIGIT_1 INTEGER
LOCAL DIGIT_2 INTEGER
LOCAL DIGIT_3 INTEGER
LOCAL DIGIT_4 INTEGER
DIGIT_1 := 0
DIGIT_2 := 0
DIGIT_3 := 0
DIGIT_4 := 0
DIGIT_1_TO_ROMAN (DIGIT)
IF DIGIT = 0
THEN
RETURN ""
ELSE IF DIGIT = 1
THEN
RETURN "I"
ELSE IF DIGIT = 2
THEN
RETURN "II"
ELSE IF DIGIT = 3
THEN
RETURN "III"
ELSE IF DIGIT = 4
THEN
RETURN "IV"
ELSE IF DIGIT = 5
THEN
RETURN "V"
ELSE IF DIGIT = 6
THEN
RETURN "VI"
ELSE IF DIGIT = 7
THEN
RETURN "VII"
ELSE IF DIGIT = 8
THEN
RETURN "VIII"
ELSE IF DIGIT = 9
THEN
RETURN "IX"
END IF
END DIGIT_1_TO_ROMAN
DIGIT_2_TO_ROMAN (DIGIT)
IF DIGIT = 0
THEN
RETURN ""
ELSE IF DIGIT = 1
THEN
RETURN "X"
ELSE IF DIGIT = 2
THEN
RETURN "XX"
ELSE IF DIGIT = 3
THEN
RETURN "XXX"
ELSE IF DIGIT = 4
THEN

52 volume VIII Argomenti avanzati e accessori
RETURN "XL"
ELSE IF DIGIT = 5
THEN
RETURN "L"
ELSE IF DIGIT = 6
THEN
RETURN "LX"
ELSE IF DIGIT = 6
THEN
RETURN "LXX"
ELSE IF DIGIT = 8
THEN
RETURN "LXXX"
ELSE IF DIGIT = 9
THEN
RETURN "XC"
END IF
END DIGIT_2_TO_ROMAN
DIGIT_3_TO_ROMAN (DIGIT)
IF DIGIT = 0
THEN
RETURN ""
ELSE IF DIGIT = 1
THEN
RETURN "C"
ELSE IF DIGIT = 2
THEN
RETURN "CC"
ELSE IF DIGIT = 3
THEN
RETURN "CCC"
ELSE IF DIGIT = 4
THEN
RETURN "CD"
ELSE IF DIGIT = 5
THEN
RETURN "D"
ELSE IF DIGIT = 6
THEN
RETURN "DC"
ELSE IF DIGIT = 7
THEN
RETURN "DCC"
ELSE IF DIGIT = 8
THEN
RETURN "DCCC"
ELSE IF DIGIT = 9
THEN
RETURN "CM"
END IF
END DIGIT_3_TO_ROMAN
DIGIT_4_TO_ROMAN (DIGIT)
IF DIGIT = 0
THEN
RETURN ""
ELSE IF DIGIT = 1
THEN
RETURN "M"
ELSE IF DIGIT = 2
THEN
RETURN "MM"
ELSE IF DIGIT = 3

Trasformazione in lettere 53
THEN
RETURN "MMM"
ELSE IF DIGIT = 4
THEN
RETURN "MMMM"
ELSE IF DIGIT = 5
THEN
RETURN "MMMMM"
ELSE IF DIGIT = 6
THEN
RETURN "MMMMMM"
ELSE IF DIGIT = 7
THEN
RETURN "MMMMMMM"
ELSE IF DIGIT = 8
THEN
RETURN "MMMMMMMM"
ELSE IF DIGIT = 9
THEN
RETURN "MMMMMMMMM"
END IF
END DIGIT_4_TO_ROMAN
DIGIT_4 := int (N/1000)
N := N - (DIGIT_4 * 1000)
DIGIT_3 := int (N/100)
N := N - (DIGIT_3 * 100)
DIGIT_2 := int (N/10)
N := N - (DIGIT_2 * 10)
DIGIT_1 := N
RETURN DIGIT_4_TO_ROMAN (DIGIT_4)
DIGIT_3_TO_ROMAN (DIGIT_3)
DIGIT_2_TO_ROMAN (DIGIT_2)
DIGIT_1_TO_ROMAN (DIGIT_2)
END INTEGER_TO_ROMAN
Come si vede, dopo aver scomposto il valore in quattro fasce, si utilizzano quattro funzioni
distinte per ottenere la porzione di stringa che traduce il valore relativo. L’istruzione ‘RETURN’
finale intende concatenare tutte le stringhe risultanti.
355.3 Da numero a lettere, nel senso verbale
Quando si trasforma un numero in lettere, per esempio quando si vuole trasformare 123 in «centoventitre»,
l’algoritmo di conversione deve tenere conto delle convenzioni linguistiche e non
esiste una soluzione generale per tutte le lingue.
Per quanto riguarda la lingua italiana, esistono nomi diversi fino al 19, poi ci sono delle particolarità
per i plurali o i singolari. La pseudocodifica seguente risolve il problema in una sola funzione
ricorsiva. Le omissioni dovrebbero essere sufficientemente intuitive.
INTEGER_TO_ITALIAN (N)
LOCAL X INTEGER
LOCAL Y INTEGER

54 volume VIII Argomenti avanzati e accessori
IF N = 0
THEN
RETURN ""
ELSE IF N = 1
THEN
RETURN "UNO"
ELSE IF N = 2
THEN
RETURN "DUE"
ELSE IF N = 3
THEN
RETURN "TRE"
ELSE IF N = 4
THEN
RETURN "QUATTRO"
ELSE IF N = 5
THEN
RETURN "CINQUE"
ELSE IF N = 6
THEN
RETURN "SEI"
ELSE IF N = 7
THEN
RETURN "SETTE"
ELSE IF N = 8
THEN
RETURN "OTTO"
ELSE IF N = 9
THEN
RETURN "NOVE"
ELSE IF N = 10
THEN
RETURN "DIECI"
ELSE IF N = 11
THEN
RETURN "UNDICI"
ELSE IF N = 12
THEN
RETURN "DODICI"
ELSE IF N = 13
THEN
RETURN "TREDICI"
ELSE IF N = 14
THEN
RETURN "QUATTORDICI"
ELSE IF N = 15
THEN
RETURN "QUINDICI"
ELSE IF N = 16
THEN
RETURN "SEDICI"
ELSE IF N = 17
THEN
RETURN "DICIASSETTE"
ELSE IF N = 18
THEN
RETURN "DICIOTTO"
ELSE IF N = 19
THEN
RETURN "DICIANNOVE"
ELSE IF N = 20
THEN
RETURN "VENTI"
ELSE IF N = 21

Trasformazione in lettere 55
THEN
RETURN "VENTUNO"
ELSE IF (N >= 22) AND (N = 32) AND (N = 92) AND (N = 100) AND (N = 200) AND (N = 1000) AND (N = 2000) AND (N = 1000000) AND (N = 2000000) AND (N = 1000000000) AND (N = 2000000000) AND (N

56 volume VIII Argomenti avanzati e accessori
"MILIARDI"
INTEGER_TO_ITALIAN (Y)
ELSE
"##ERROR##"
END IF
END INTEGER_TO_ITALIAN
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Parte lxxi
i86
356 Minix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
356.1 Procurarsi il software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
356.2 Preparazione all’installazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
356.3 Avvio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
356.4 Installazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
356.5 Ricompilazione del kernel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
356.6 Parametri di avvio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .69
356.7 Configurazione della rete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
356.8 Personalizzazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
356.9 Tastiera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
356.10 Altri programmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
356.11 Copie di sicurezza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
356.12 Convivenza tra Minix e GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
356.13 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
357 ELKS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
357.1 Sperimentare ELKS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
357.2 Immagini di dischetti già pronti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .81
357.3 Avvio di ELKS all’interno di DOSEMU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
357.4 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
57

Minix
Capitolo 356
Minix 1 è nato originariamente come sistema didattico. Minix non ha avuto il successo e la
diffusione che avrebbe potuto avere a causa delle limitazioni della sua licenza iniziale. In seguito
le cose sono cambiate, fortunatamente, perché Minix resta probabilmente l’unica possibilità reale
per chi vuole utilizzare elaboratori con architettura i286 o inferiore.
Lo scopo di questo capitolo è introdurre all’uso di Minix per poter riutilizzare i vecchi elaboratori
i286, in particolare, collegandoli a una rete locale TCP/IP. Le informazioni seguenti si riferiscono
alla versione 2.0.0.
356.1 Procurarsi il software
Minix è ottenibile dalla rete, precisamente a partire dalla sua pagina di presentazione ufficiale,
quella del suo primo autore (La sigla «AST» rappresenta le iniziali di Andrew S. Tanenbaum),
oltre che dai vari siti speculari del relativo FTP.
Minix è nato assieme a un libro che tuttora dovrebbe essere accompagnato da un CD-ROM
contenente il sistema operativo:
• Andrew S. Tanenbaum, Alber S. Woodhull, Operating Systems: Design and Implementation,
2/e, Prentice-Hall
356.1.1 Pacchetti essenziali
Minix è un sistema molto piccolo e composto da pochi pacchetti. Questi hanno alcune particolarità:
i nomi sono composti con lettere maiuscole e gli archivi compressi utilizzano la combinazione
‘tar’+‘compress’ e sono evidenziati dall’uso dell’estensione ‘.TAZ’.
Per prima cosa è necessario riprodurre la coppia di dischetti ‘ROOT’ e ‘USR’, a partire dai file
omonimi. Il primo è in grado di avviarsi e contiene un file system minimo che si installa in
un disco RAM, il secondo contiene una piccola serie di programmi da montare nella directory
‘/usr/’, che servono per poter installare Minix nel disco fisso. Se si ha poca memoria a disposizione
(i classici 640 Kibyte sono il minimo in assoluto per poter fare funzionare Minix), si può
evitare l’utilizzo del disco RAM fondendo i due file in un solo dischetto. Data l’intenzione di
questo capitolo verrà descritta l’ultima di queste modalità di installazione.
Il mini sistema che si ottiene attraverso i due file appena citati, permette di installare, più o meno
automaticamente, un insieme minimo di programmi contenuto nell’archivio ‘USR.TAZ’
Esistono due versioni di questi tre file: una per architettura i386 o superiore e l’altra per i microprocessori
inferiori. Date le intenzioni, si dovranno utilizzare i file della versione denominata
‘i86’.
1 Minix licenza simile a BSD
58

Minix 59
356.2 Preparazione all’installazione
Il procedimento che viene descritto è valido sia per dischetti da 1440 Kibyte che da 1200 Kibyte.
I due file ‘ROOT’ e ‘USR’ vanno copiati uno di seguito all’altro. Utilizzando GNU/Linux, si può
fare nel modo seguente:
# cat ROOT USR > /dev/fd0
Dal punto di vista di Minix, il dischetto inserito nella prima unità a dischetti corrisponde al dispositivo
‘/dev/fd0’, come per GNU/Linux, ma risulta diviso in partizioni: l’immagine ‘ROOT’
risulta essere ‘/dev/fd0a’ e l’immagine ‘USR’ è ‘/dev/fd0c’ (la partizione ‘b’ è vuota). 2
L’archivio ‘USR.TAZ’ deve essere suddiviso in diversi dischetti, con un procedimento un po’ insolito:
viene semplicemente tagliato a fettine della dimensione massima contenibile dal tipo di dischetti
che si utilizza. Nel caso si tratti di dischetti da 1440 Kibyte, si può utilizzare GNU/Linux,
o un altro sistema Unix, nel modo seguente:
# dd if=/USR.TAZ of=/dev/fd0 bs=1440k count=1 skip=0
# dd if=/USR.TAZ of=/dev/fd0 bs=1440k count=1 skip=1
# dd if=/USR.TAZ of=/dev/fd0 bs=1440k count=1 skip=2
Se si trattasse di dischetti da 1200 Kibyte, occorrerebbe modificare la dimensione del blocco,
come nell’esempio seguente:
# dd if=/USR.TAZ of=/dev/fd0 bs=1200k count=1 skip=0
# dd if=/USR.TAZ of=/dev/fd0 bs=1200k count=1 skip=1
# dd if=/USR.TAZ of=/dev/fd0 bs=1200k count=1 skip=2
356.2.1 Nomi di dispositivo riferiti alle partizioni
Minix viene installato normalmente all’interno di una partizione primaria suddivisa in almeno
due partizioni secondarie. La prima partizione serve a contenere il file system principale ed è
di piccole dimensioni: 1440 Kibyte. La seconda serve per tutto il resto e viene montata in corrispondenza
della directory ‘/usr/’. Inizialmente le partizioni erano tre e ‘/usr/’ era la terza.
Attualmente, ‘/usr/’ continua a essere la terza partizione e si finge che esista una seconda
partizione senza alcuno spazio a disposizione.
Il primo disco fisso viene identificato dal dispositivo ‘/dev/hd0’, il secondo da ‘/dev/hd5’.
Le partizioni primarie del primo disco fisso vanno da ‘/dev/hd1’ a ‘/dev/hd4’; quelle del
secondo disco fisso da ‘/dev/hd6’ a ‘/dev/hd9’. Le partizioni secondarie corrispondono al
nome del dispositivo della partizione primaria con l’aggiunta di una lettera alfabetica che ne
indica l’ordine.
• /dev/hd0
– /dev/hd1
* /dev/hd1a
2 Se si trattasse della seconda unità a dischetti, si parlerebbe di ‘/dev/fd1’, ‘/dev/fd1a’ e ‘/dev/fd1c’.

60 volume VIII Argomenti avanzati e accessori
* /dev/hd1b
* /dev/hd1c
* ...
– /dev/hd2
– /dev/hd3
– /dev/hd4
• /dev/hd5
– /dev/hd6
– /dev/hd7
– /dev/hd8
– /dev/hd9
Minix può essere installato in una partizione primaria qualunque, purché ci siano almeno 40 Mibyte
a disposizione. Utilizzando la versione di Minix ‘i86’, non conviene tentare di superare i
128 Mibyte.
356.3 Avvio
Minix utilizza un sistema di avvio piuttosto sofisticato; per fare un paragone con GNU/Linux, si
tratta di qualcosa che compie le stesse funzioni di LILO, o di un cosiddetto bootloader.
Il sistema che svolge questa funzione in Minix si chiama boot monitor ed è importante capire
subito come si utilizza se non si ha molta memoria RAM a disposizione, quanta ne richiederebbe
un disco RAM per l’immagine ‘ROOT’.
Per cominciare, dopo aver preparato il dischetto ‘ROOT’+‘USR’, lo si inserisce senza la protezione
contro la scrittura e si avvia l’elaboratore. Questo è ciò che appare.
Minix boot monitor 2.5
Press ESC to enter the monitor
Hit a key as follows:
= Start Minix
Premendo il tasto [ Esc ] si attiva il boot monitor, mentre premendo [ = ] (si fa riferimento alla
tastiera americana e questo simbolo si trova in corrispondenza della nostra lettera «ì») si avvia
Minix con le impostazioni predefinite.
Dal momento che si immagina di avere a disposizione poca memoria (solo 1 Mibyte), non
si può avviare Minix così, perché il contenuto dell’immagine ‘ROOT’ verrebbe caricato come
disco RAM. È necessario utilizzare subito il boot monitor.
[ Esc ]
[ESC]
fd0>
Si ottiene un invito (prompt), attraverso il quale possono essere utilizzati alcuni comandi importanti
per predisporre l’avvio del sistema Minix. Per ottenere aiuto si può utilizzare il comando
‘help’.

Minix 61
fd0> help [ Invio ]
Si ottiene un riepilogo dei comandi e del modo con cui possono essere utilizzati. Le cose più importanti
che si possono fare con il boot monitor sono: l’avvio a partire da una partizione differente
da quella prestabilita; l’assegnamento o il ripristino al valore predefinito di una variabile.
Queste variabili sono solo entità riferite al sistema di avvio e la loro modifica permette di cambiare
il modo con cui si avvia il kernel. Il comando ‘set’ permette di elencare il contenuto di
queste variabili.
fd0> set [ Invio ]
rootdev = (ram)
ramimagedev = (bootdev)
ramsize = (0)
processor = (286)
bus = (at)
memsize = (640)
emssize = (330)
video = (vga)
chrome = (mono)
image = (minix)
main() = (menu)
I valori appaiono tutti tra parentesi tonde perché rappresentano le impostazioni predefinite.
Quando si cambia qualche valore, questo appare senza le parentesi.
La prima cosa da cambiare è il dispositivo di avvio, ‘rootdev’. Si deve assegnare il nome di
dispositivo riferito all’immagine ‘ROOT’ su dischetto. Si tratta di ‘/dev/fd0a’, come dire, la
prima partizione secondaria del dischetto. In questo caso, il nome del dispositivo può anche
essere indicato senza la parte iniziale, limitandolo al solo ‘fd0a’.
fd0> rootdev=fd0a [ Invio ]
fd0> set [ Invio ]
rootdev = fd0a
ramimagedev = (bootdev)
ramsize = (0)
processor = (286)
bus = (at)
memsize = (640)
emssize = (330)
video = (vga)
chrome = (mono)
image = (minix)
main() = (menu)
Per avviare il sistema, basta utilizzare il comando ‘boot’ senza argomenti.
fd0> boot [ Invio ]
In questo modo si lascia il boot monitor e si avvia il kernel. Una volta avviato il sistema, viene
richiesto immediatamente il montaggio della seconda immagine, ‘USR’, contenente gli strumenti
necessari all’installazione. Avendo avviato senza disco RAM, il dischetto contenente l’immagine
‘ROOT’ non può essere tolto e questo è il motivo per il quale deve essere contenuta nello stesso
dischetto insieme a ‘USR’. 3
3 Una cosa da sapere subito è che Minix non utilizza la sequenza [ Ctrl+C ] per interrompere un programma. Per questo
si usa il tasto [ Canc ] da solo.

62 volume VIII Argomenti avanzati e accessori
Minix 2.0.0 Copyright 1997 Prentice-Hall, Inc.
Executing in 16-bit protected mode
Memory size = 970K MINIX = 206K RAM disk = 0K Available = 765K
Mon Nov 3 15:24:15 MET 1997
Finish the name of device to mount as /usr: /dev/
Date le premesse, occorre specificare il nome del dispositivo corrispondente all’immagine ‘USR’:
si tratta di ‘fd0c’.
fd0c [ Invio ]
/dev/fd0c is read-write mounted on /usr
Starting standard daemons: update.
Login as root and run ’setup’ to install Minix.
Minix Release 2.0 Version 0
noname login:
root [ Invio ]
#
356.4 Installazione
L’installazione di Minix avviene in tre fasi:
1. preparazione della partizione di destinazione;
2. trasferimento del contenuto del dischetto, ovvero delle immagini ‘ROOT’ e ‘USR’;
3. dopo il riavvio, trasferimento dell’archivio ‘USR.TAZ’ e possibilmente, se si dispone di una
partizione di almeno 40 Mibyte, anche di ‘SYS.TAZ’ e ‘CMD.TAZ’.
356.4.1 Setup
Per iniziare l’installazione, dopo aver avviato il sistema Minix dal dischetto, si utilizza lo script
‘setup’.
# setup [ Invio ]

Minix 63
This is the Minix installation script.
Note 1: If the screen blanks suddenly then hit F3 to select "software
scrolling".
Note 2: If things go wrong then hit DEL and start over.
Note 3: The installation procedure is described in the manual page
usage(8). It will be hard without it.
Note 4: Some questions have default answers, like this: [y]
Simply hit RETURN (or ENTER) if you want to choose that answer.
Note 5: If you see a colon (:) then you should hit RETURN to continue.
:
[ Invio ]
Dopo la breve spiegazione, avendo premuto il tasto [ Invio ] si passa all’indicazione del tipo di
tastiera. La scelta è ovvia, ‘italian’, anche se non corrisponde esattamente: la barra verticale
(quella per le pipeline) si trova al posto della lettera «ì» (i accentata). Durante questa fase di
installazione conviene utilizzare la tastiera nazionale (‘italian’) per evitare spiacevoli incidenti
quando si utilizza il programma di gestione delle partizioni.
What type of keyboard do you have? You can choose one of:
french italian latin-am scandinavn uk us-swap
german japanese olivetti spanish us-std
Keyboard type? [us-std]
italian [ Invio ]
Minix needs one primary partition of at least 30 Mb (it fits in 20 Mb, but
it needs 30 Mb if fully recompiled. Add more space to taste.)
If there is no free space on your disk then you have to back up one of the
other partitions, shrink, and reinstall. See the appropriate manuals of the
the operating systems currently installed. Restart your Minix installation
after you have made space.
To make this partition you will be put in the editor "part". Follow the
advice under the ’!’ key to make a new partition of type MINIX. Do not
touch an existing partition unless you know precisely what you are doing!
Please note the name of the partition (hd1, hd2, ..., hd9, sd1, sd2, ...
sd9) you make. (See the devices section in usage(8) on Minix device names.)
:
Il programma di Minix che permette di accedere alla tabella delle partizioni è ‘part’ ed è ciò che
sta per essere avviato. Come sempre, l’uso di un programma di questo genere è molto delicato:
un piccolo errore mette fuori uso tutti i dati eventualmente contenuti in altre partizioni.
[ Invio ]

64 volume VIII Argomenti avanzati e accessori
Select device ----first---- --geom/last-- ------sectors-----
Device Cyl Head Sec Cyl Head Sec Base Size Kb
/dev/hd0 ? ? ?
? ? ? ? ? ? ? ? ?
Num Sort Type
? ? ? ? ? ? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ? ? ? ? ?
Type ’+’ or ’-’ to change, ’r’ to read, ’?’ for more help, ’!’ for advice
Prima di utilizzare questo programma conviene leggere la sua guida interna, ottenibile con la
pressione del tasto [ ? ]. Il cursore si presenta inizialmente sull’indicazione del disco, ‘/dev/
hd0’, e può essere cambiato semplicemente premendo i tasti [ + ] o [ - ]. Una volta raggiunto
il disco desiderato (in questo caso il primo disco va bene), si deve leggere la sua tabella delle
partizioni, in modo da rimpiazzare tutti i punti interrogativi che riempiono lo schermo.
[ r ]
Select device ----first---- --geom/last-- ------sectors-----
Device Cyl Head Sec Cyl Head Sec Base Size Kb
/dev/hd0 615 8 17
0 0 0 614 7 16 0 83640 41820
Num Sort Type
1* hd1 86 DOS-BIG 0 1 0 613 7 16 17 83487 41743
2 hd2 00 None 0 0 0 0 0 -1 0 0 0
3 hd3 00 None 0 0 0 0 0 -1 0 0 0
4 hd4 00 None 0 0 0 0 0 -1 0 0 0
Con questo esempio si suppone di avere solo un vecchio disco fisso MFM di circa 40 Mibyte, nel
quale la prima partizione primaria era stata dedicata in precedenza al Dos. Così, basta cambiare
il numero che identifica il tipo di partizione. Per farlo, vi si posiziona sopra il cursore, spostandolo
con i tasti freccia, quindi si usano i tasti [ + ] o [ - ] fino a fare apparire il numero 8116. Al
primo intervento per cambiare un valore qualsiasi, viene richiesto esplicitamente se si intende
modificare effettivamente i dati della tabella delle partizioni.
Do you wish to modify existing partitions (y/n) [ y ]
Una volta modificato il tipo, la prima partizione dovrebbe apparire così come segue:
Num Sort Type
1* hd1 81 MINIX 0 1 0 613 7 16 17 83487 41743
Quindi si conclude.
[ q ]
Save partition table? (y/n) [ y ]
Lo script di configurazione e installazione riprende richiedendo quale sia la partizione su cui
installare Minix. In questo caso si tratta della prima, cioè ‘/dev/hd1’.
Please finish the name of the primary partition you have created:
(Just type RETURN if you want to rerun "part") /dev/

Minix 65
hd1 [ Invio ]
You have created a partition named: /dev/hd1
The following subpartitions are about to be created on /dev/hd3:
Root subpartition: /dev/hd1a 1440 kb
/usr subpartition: /dev/hd1c rest of hd1
Hit return if everything looks fine, or hit DEL to bail out if you want to
think it over. The next step will destroy /dev/hd1.
:
Come accennato in precedenza, Minix viene installato in due partizioni secondarie: la prima
serve a contenere il file system principale, la seconda per il resto. In seguito si possono montare
anche partizioni successive.
Migrating from floppy to disk...
Scanning /dev/hd1c for bad blocks. (Hit DEL to stop the scan if are absolutely
sure that there can not be any bad blocks. Otherwise just wait.)
La scansione del disco fisso è necessaria se si utilizza un vecchio disco MFM, come si suppone
di avere in questo esempio, mentre può essere inutile con un disco ATA. È importante fare attenzione:
se ci sono settori inutilizzabili, vengono creati alcuni file ‘/usr/.Bad_ * ’ che non vanno
cancellati! Alla fine, lo script procede a copiare il contenuto del dischetto nel disco fisso.
What is the memory size of this system in kilobytes? [4096 or more]
La dimensione di memoria RAM disponibile effettivamente è solo di 970 Kibyte, quindi si inserisce
questo valore; se la memoria a disposizione fosse maggiore o uguale a 4 Mibyte, non
occorrerebbe indicare alcunché, basterebbe solo confermare.
970 [ Invio ]
Second level file system block cache set to 0 kb.
A questo punto, termina l’installazione del dischetto nel disco fisso e si può passare a riavviare il
sistema da lì.
Please insert the installation ROOT floppy and type ’halt’ to exit Minix.
You can type ’boot hd1’ to try the newly installed Minix system. See
"TESTING" in the usage manual.
# halt [ Invio ]
System Halted

66 volume VIII Argomenti avanzati e accessori
356.4.2 Avvio del sistema copiato nel disco fisso
Una volta conclusa l’esecuzione dello script di configurazione e installazione, si ritorna sotto il
controllo del boot monitor, attraverso il quale è possibile avviare il sistema dalla prima partizione
del disco fisso.
fd0> boot /dev/hd1 [ Invio ]
Minix 2.0.0 Copyright 1997 Prentice-Hall, Inc.
Executing in 16-bit protected mode
at-hd0: 615x8x17
Memory size = 970K MINIX = 206K RAM disk = 0K Available = 765K
Mon Nov 3 16:01:27 MET 1997
Starting standard daemons: update.
Login as root and run ’setup /usr’ to install floppy sets.
Minix Release 2.0 Version 0
noname login:
# root [ Invio ]
Il suggerimento dato all’avvio ricorda che è possibile installare altre serie di dischetti, a
cominciare da ‘USR.TAZ’, utilizzando il comando ‘setup /usr’.
356.4.3 Installazione delle serie di dischetti
Tra i pacchetti di Minix, ‘USR.TAZ’ è essenziale e cambia a seconda del tipo di architettura (i86
o i386). Però, dal momento che c’è spazio sufficiente nel disco fisso, conviene installare anche
‘SYS.TAZ’ per poter ricompilare il kernel e ‘CMD.TAZ’ che contiene i sorgenti dei vari programmi
di servizio.
Tutti questi pacchetti devono essere suddivisi in dischetti nel modo visto in precedenza per il
caso di ‘USR.TAZ’.
# setup /usr [ Invio ]
Lo script ‘setup’ chiede una serie di conferme.
What is the size of the images on the diskettes? [all]
Premendo semplicemente [ Invio ] si intende che i dischetti vadano letti nella loro interezza.
[ Invio ]
What floppy drive to use? [0]
Premendo semplicemente [ Invio ] si fa riferimento alla prima unità, ‘/dev/fd0’.
[ Invio ]
Please insert input volume 1 and hit return

Minix 67
Si inserisce il primo dischetto e si conferma
[ Invio ]
Inizia la fase di estrazione di quanto contenuto nel primo dischetto, a partire dalla directory
‘/usr/’. Quando termina l’estrazione del primo dischetto, viene richiesto il successivo, fino alla
conclusione.
Conviene ripetere la procedura fino a quando sono stati installati anche gli archivi ‘SYS.TAZ’ e
‘CMD.TAZ’.
356.4.4 Dischetto di avvio
Minix è molto semplice e non è necessario un dischetto di avvio realizzato appositamente. È sufficiente
il dischetto utilizzato per iniziare l’installazione. Se si hanno difficoltà con l’avviamento
di Minix dal disco fisso, si può avviare il boot monitor dal dischetto e con quello utilizzare il
comando ‘boot /dev/hd1’.
356.4.5 Conclusione
Per chiudere l’attività di Minix, si può fare nel solito modo comune a quasi tutti i sistemi Unix.
# shutdown -h now [ Invio ]
356.5 Ricompilazione del kernel
Anche Minix, nella sua semplicità, richiede una ricompilazione del kernel per la sua ottimizzazione.
In particolare, per poter attivare la gestione del TCP/IP occorre passare per la configurazione
e ricompilazione.
Il file del kernel, secondo la tradizione di Minix, dovrebbe trovarsi nella directory radice e avere
il nome ‘minix’. Se però, invece di trattarsi di un file, si tratta di una directory, nella fase di avvio
viene eseguito il file più recente contenuto in tale directory. Il kernel normale, cioè quello che si
trova dopo l’installazione, dovrebbe essere ‘/minix/2.0.0’.
Per poter ricompilare il kernel occorre avere installato il pacchetto ‘SYS.TAZ’. Si procede come
segue:
1. si modifica il file ‘/usr/include/minix/config.h’;
2. ci si posiziona nella directory ‘/usr/src/tools/’;
3. si avvia la compilazione con il comando ‘make’.
Al termine si ottiene il file del kernel (o immagine) corrispondente a ‘/usr/src/tools/image’
che si può copiare e rinominare come si ritiene più opportuno.

68 volume VIII Argomenti avanzati e accessori
356.5.1 /usr/include/minix/config.h
La configurazione che viene proposta deriva dagli esempi precedenti, in cui si ha una particolare
penuria di memoria. Seguono solo alcuni pezzi.
/* If ROBUST is set to 1, writes of i-node, directory, and indirect blocks
* from the cache happen as soon as the blocks are modified. This gives a more
* robust, but slower, file system. If it is set to 0, these blocks are not
* given any special treatment, which may cause problems if the system crashes.
*/
#define ROBUST 1 /* 0 for speed, 1 for robustness */
La macro ‘ROBUST’ permette di sincronizzare le operazioni di accesso al disco. Nell’esempio
mostrato si attiva questa opzione, in modo da poter utilizzare il sistema con tranquillità (e
ovviamente con maggiore lentezza).
/* Number of slots in the process table for user processes. */
#define NR_PROCS 32
Il numero massimo dei processi eseguibili può essere una seria limitazione all’uso simultaneo
dell’elaboratore da parte di più utenti, ma la scarsa memoria a disposizione consiglia di mantenere
basso questo valore.
/* Enable or disable the second level file system cache on the RAM disk. */
#define ENABLE_CACHE2 0
Sempre a causa della carenza di memoria, è opportuno disabilitare la memoria cache.
/* Include or exclude device drivers. Set to 1 to include, 0 to exclude. */
#define ENABLE_NETWORKING 1 /* enable TCP/IP code */
#define ENABLE_AT_WINI 1 /* enable AT winchester driver */
#define ENABLE_BIOS_WINI 1 /* enable BIOS winchester driver */
#define ENABLE_ESDI_WINI 1 /* enable ESDI winchester driver */
#define ENABLE_XT_WINI 0 /* enable XT winchester driver */
#define ENABLE_ADAPTEC_SCSI 0 /* enable ADAPTEC SCSI driver */
#define ENABLE_MITSUMI_CDROM 0 /* enable Mitsumi CD-ROM driver */
#define ENABLE_SB_AUDIO 0 /* enable Soundblaster audio driver */
In questa sezione è importante abilitare ciò che serve ed eliminare il resto. In particolare, è qui
che si attiva la connettività TCP/IP, che non risulta attivata in modo predefinito.
/* NR_CONS, NR_RS_LINES, and NR_PTYS determine the number of terminals the
* system can handle.
*/
#define NR_CONS 2 /* # system consoles (1 to 8) */
#define NR_RS_LINES 1 /* # rs232 terminals (0, 1, or 2) */
#define NR_PTYS 2 /* # pseudo terminals (0 to 64) */
Il numero predefinito di console virtuali è due, ma può essere espanso, sempre che ciò possa
avere senso date le limitazioni del sistema. Invece è importante attivare gli pseudoterminali, cioè
il numero massimo di connessioni remote. Volendo gestire la rete, è il caso di indicare almeno
uno pseduoterminale.
Per modificare il file ‘/usr/include/minix/config.h’ si può utilizzare ‘vi’, che è un
collegamento a ‘elvis’, oppure ‘elle’. 4
Si procede con la compilazione.
4 Il programma ‘elvis’ in particolare, è molto tradizionale: i tasti freccia generano proprio le lettere corrispondenti e
quindi non possono essere usati durante la fase di inserimento. ‘elle’ è un Emacs ridotto al minimo.

Minix 69
# cd /usr/src/tools [ Invio ]
# make [ Invio ]
Al termine della compilazione, se non sono occorsi incidenti, si ottiene il file ‘image’.
# cp image /minix/rete.0.1 [ Invio ]
Questo dovrebbe bastare, trattandosi del file più recente nella directory ‘/minix/’, è anche quello
che verrà avviato la prossima volta.
# shutdown -h [ Invio ]
356.5.2 File di dispositivo
Quando si ricompila il kernel è probabile che si renda necessaria la creazione di file di dispositivo
che prima non erano necessari. Nel caso della gestione della rete, sono necessari i file seguenti:
• ‘/dev/eth’;
• ‘/dev/ip’;
• ‘/dev/tcp’;
• ‘/dev/udp’;
• ‘/dev/ttyp0’ e successivi;
• ‘/dev/ptyp0’ e successivi.
Questo ragionamento vale anche per le console virtuali: se si vogliono molte console, forse è
necessario aggiungere i file relativi.
Probabilmente c’è già tutto ciò di cui si può avere bisogno, ma se manca si può creare con lo
script ‘MAKEDEV’.
MAKEDEV dispositivo
Per esempio, trovandosi già nella directory ‘/dev/’, si può creare il dispositivo ‘/dev/tcp’ nel
modo seguente:
# MAKEDEV tcp
356.6 Parametri di avvio
Anche Minix richiede alcuni parametri di avvio in presenza di hardware particolare. La gestione
di questi avviene in modo molto semplice attraverso il boot monitor: basta definire una nuova
variabile, assegnandole il valore corretto.

70 volume VIII Argomenti avanzati e accessori
356.6.1 Scheda di rete
Per gestire una rete occorre una scheda di rete Ethernet. Nell’esempio seguente si immagina di
disporre di una scheda compatibile con il modello NE2000 configurata con indirizzo di I/O 30016
e IRQ 11.
Il parametro di avvio per ottenere il riconoscimento della scheda Ethernet è ‘DPETHn’, dove n è
il numero della scheda, a partire da zero.
DPETHn=indirizzo_i/o:irq:indirizzo_di_memoria
La scheda NE2000 non utilizza alcun indirizzo di memoria, quindi, per il nostro esempio occorre
il parametro seguente:
DPETH0=300:11
Come si vede, l’indirizzo di I/O è espresso implicitamente in esadecimale e l’IRQ in decimale,
mentre l’indirizzo di memoria viene omesso trattandosi di una NE2000. Per inserire tale
parametro si utilizza il boot monitor nel modo seguente:
hd0> DPETH0=300:11 [ Invio ]
hd0> save [ Invio ]
L’ultima istruzione, ‘save’, salva questo parametro che altrimenti dovrebbe essere indicato ogni
volta che si avvia il sistema.
Se la scheda di rete viene riconosciuta, all’avvio appare il messaggio seguente:
Minix 2.0.0 Copyright 1997 Prentice-Hall, Inc.
Executing in 16-bit protected mode
ne2000: NE2000 at 300:11
356.7 Configurazione della rete
La configurazione della rete va fatta con cura, in modo da non avere bisogno di alcuni demoni che
permettono una sorta di autoconfigurazione. Negli esempi seguenti si configura il nuovo sistema
Minix tenendo conto di questa situazione:
• dinkel.brot.dg, IP 192.168.1.1, servizio DNS e router predefinito;
• minix.brot.dg, IP 192.168.1.25, elaboratore Minix.
Per quanto possibile, si fa in modo di non avere bisogno del DNS.

Minix 71
356.7.1 /etc/hosts
Volendo attivare localmente la risoluzione dei nomi e degli indirizzi è necessario il file ‘/etc/
hosts’, che va configurato come al solito, esattamente come si fa con GNU/Linux.
127.0.0.1 localhost
192.168.1.1 dinkel.brot.dg
192.168.1.25 minix.brot.dg
356.7.2 /etc/hostname.file
Il file ‘/etc/hostname.file’ serve solo a definire il nome dell’elaboratore locale, in senso
generale. Non ha niente a che vedere con le interfacce di rete.
# echo "minix.brot.dg" > /etc/hostname.file [ Invio ]
356.7.3 /etc/resolv.conf
Il file ‘/etc/resolv.conf’ permette di indicare gli indirizzi dei nodi che forniscono un servizio
DNS. Nell’esempio proposto si vuole fare in modo che il sistema di risoluzione dei nomi avvenga
localmente, per mezzo di quanto contenuto nel file ‘/etc/hosts’. Per questo viene indicato
come servente DNS anche l’indirizzo locale (loopback).
nameserver 127.0.0.1
nameserver 192.168.1.1
356.7.4 /etc/rc.net
Lo script ‘/etc/rc.net’ viene utilizzato da ‘/etc/rc’ per attivare la rete. Lo si può utilizzare
per attivare l’interfaccia di rete e per definire l’instradamento verso il router (l’instradamento
verso la rete connessa all’interfaccia è predefinito).
# Attiva l’interfaccia e l’instradamento verso la sua rete.
ifconfig -h 192.168.1.25
# Definisce l’instradamento predefinito verso il router
add_route -g 192.168.1.1
356.7.5 /etc/rc
Probabilmente, è utile ritoccare il file ‘/etc/rc’, per eliminare l’avvio automatico di alcuni
demoni inutili dal momento che la rete è configurata. Quello che segue è il pezzo che attiva la
gestione della rete.
# Network initialization.
(

72 volume VIII Argomenti avanzati e accessori
fi
ifconfig -h 192.9.200.1
if [ "$net" ]
then
echo -n "Starting network daemons: "
for daemon in rarpd nonamed irdpd talkd
do
if [ -f /usr/bin/$daemon ]
then
echo -n " $daemon"
$daemon &
fi
done
echo .
fi
# Get the nodename from the DNS and set it.
hostaddr -a >/etc/hostname.file || echo noname >/etc/hostname.file
echo -n "Starting network services:"
for pair in ’shell in.rshd’ ’login in.rld’ \
’telnet in.telnetd’ ’ftp in.ftpd’
do
set $pair
if [ -f /usr/bin/$2 ]
then
echo -n " $1"
tcpd $1 /usr/bin/$2 &
fi
done
echo .
Vale la pena di modificare quanto segue:
if [ "$net" ]
then
echo -n "Starting network daemons: "
for daemon in nonamed talkd ### rarpd nonamed irdpd talkd
do
...
Nel pezzo precedente non vengono avviati i demoni ‘rarpd’ e ‘irdpd’, che sono necessari rispettivamente
per ottenere l’indirizzo IP in base all’indirizzo hardware della scheda Ethernet
e a definire gli instradamenti verso i router. Eventualmente, si potrebbe anche evitare di avviare
‘talkd’ se non si intende utilizzare ‘talk’. Il demone ‘nonamed’ è necessario se non si vuole essere
obbligati ad avere un servizio DNS esterno; in pratica è necessario perché venga interpretato
il contenuto del file ‘/etc/hosts’.
356.8 Personalizzazione
Il sistema risulta configurato in maniera piuttosto disordinata, a cominciare dal fatto che la directory
personale dell’utente ‘root’ corrisponde alla directory radice; così, al suo interno si trovano
i file di configurazione dell’amministratore. Probabilmente, la prima cosa da fare è quella di
creare una directory ‘/root/’, porvi al suo interno i file di configurazione (dovrebbe trattarsi di
‘.ellepro.b1’, ‘.exrc’ e ‘.profile’), modificando anche il file ‘/etc/passwd’ in modo da
assegnare all’utente ‘root’ questa nuova directory.

Minix 73
356.8.1 /etc/passwd, /etc/group e /etc/shadow
Minix, nonostante la sua semplicità, utilizza le password shadow. Pertanto, se si tenta di inserire
un utente manualmente, occorre intervenire anche su questo file, ‘/etc/shadow’, altrimenti
l’utente non riuscirà ad accedere.
Il file ‘/etc/group’, se non va bene com’è, deve essere modificato manualmente, mentre per gli
utenti conviene affidarsi allo script ‘adduser’.
adduser utente gruppo directory_home
Dopo aver creato un utente, come al solito è opportuno utilizzare il programma ‘passwd’ per
assegnare la parola d’ordine. 5
356.9 Tastiera
La mappa della tastiera viene definita attraverso il programma ‘loadkeys’ e il file contenente la
mappa desiderata. Per cui,
# loadkeys ./tastiera.map
permette di caricare la mappa del file ‘tastiera.map’ contenuto nella directory corrente.
La mappa della tastiera, secondo la scelta fatta durante l’installazione di Minix, avviene per
mezzo del file ‘/etc/keymap’: se lo script ‘/etc/rc’ lo trova durante la fase di avvio, lo carica
attraverso ‘loadkeys’.
356.9.1 Modifica della mappa
La configurazione della tastiera italiana, per quanto riguarda la versione 2.0 di Minix, non è
perfetta. Per modificare la mappa occorre intervenire sul file ‘/usr/src/kernel/keymaps/
italian.src’. Dopo la modifica si deve compilare il sorgente in modo da ottenere il file
‘/usr/src/kernel/keymaps/italian.map’. Al termine, questo file va copiato e rinominato
in modo da sostituire ‘/etc/keymap’.
Il sorgente corretto potrebbe apparire come nell’esempio seguente, in particolare, per ottenere la
tilde (‘~’) si deve usare la combinazione [ AltGr+ì ], mentre per ottenere l’apostrofo inverso (‘‘’)
si deve usare la combinazione [ AltGr+’ ]. I caratteri che si trovano oltre il settimo bit, vengono
rappresentati in ottale.
/* Modified by Daniele Giacomini daniele @ swlibero.org 1998.12.22 */
/* Keymap for Italian standard keyboard, similar to Linux layout. */
u16_t keymap[NR_SCAN_CODES * MAP_COLS] = {
/* scan-code !Shift Shift Alt AltGr Alt+Sh Ctrl */
/* ==================================================================== */
/* 00 - none */ 0, 0, 0, 0, 0, 0,
/* 01 - ESC */ C(’[’), C(’[’), CA(’[’),C(’[’), C(’[’), C(’[’),
/* 02 - ’1’ */ ’1’, ’!’, A(’1’), ’1’, ’!’, C(’A’),
/* 03 - ’2’ */ ’2’, ’"’, A(’2’), ’2’, ’@’, C(’@’),
/* 04 - ’3’ */ ’3’, 0234, A(’3’), ’3’, 0234, C(’C’),
/* 05 - ’4’ */ ’4’, ’$’, A(’4’), ’4’, ’$’, C(’D’),
5 Lo script ‘adduser’ si avvale della directory personale dell’utente ‘ast’ per inserire i file di configurazione iniziali.
Questa directory, corrispondente a ‘/usr/ast/’, svolge il ruolo di scheletro delle directory personali da creare. Volendo
si può realizzare un proprio script per rendere la cosa più elegante.

74 volume VIII Argomenti avanzati e accessori
/* 06 - ’5’ */ ’5’, ’%’, A(’5’), ’5’, ’%’, C(’E’),
/* 07 - ’6’ */ ’6’, ’&’, A(’6’), ’6’, ’&’, C(’F’),
/* 08 - ’7’ */ ’7’, ’/’, A(’7’), ’{’, ’/’, C(’G’),
/* 09 - ’8’ */ ’8’, ’(’, A(’8’), ’[’, ’(’, C(’H’),
/* 10 - ’9’ */ ’9’, ’)’, A(’9’), ’]’, ’)’, C(’I’),
/* 11 - ’0’ */ ’0’, ’=’, A(’0’), ’}’, ’=’, C(’@’),
/* 12 - ’-’ */ ’\’’, ’?’, A(’\’’),’\‘’, ’?’, C(’@’),
/* 13 - ’=’ */ 0215, ’^’, 0215, ’~’, ’^’, C(’^’),
/* 14 - BS */ C(’H’), C(’H’), CA(’H’),C(’H’), C(’H’), 0177,
/* 15 - TAB */ C(’I’), C(’I’), CA(’I’),C(’I’), C(’I’), C(’I’),
/* 16 - ’q’ */ L(’q’), ’Q’, A(’q’), ’q’, ’Q’, C(’Q’),
/* 17 - ’w’ */ L(’w’), ’W’, A(’w’), ’w’, ’W’, C(’W’),
/* 18 - ’e’ */ L(’e’), ’E’, A(’e’), ’e’, ’E’, C(’E’),
/* 19 - ’r’ */ L(’r’), ’R’, A(’r’), ’r’, ’R’, C(’R’),
/* 20 - ’t’ */ L(’t’), ’T’, A(’t’), ’t’, ’T’, C(’T’),
/* 21 - ’y’ */ L(’y’), ’Y’, A(’y’), ’y’, ’Y’, C(’Y’),
/* 22 - ’u’ */ L(’u’), ’U’, A(’u’), ’u’, ’U’, C(’U’),
/* 23 - ’i’ */ L(’i’), ’I’, A(’i’), ’i’, ’I’, C(’I’),
/* 24 - ’o’ */ L(’o’), ’O’, A(’o’), ’o’, ’O’, C(’O’),
/* 25 - ’p’ */ L(’p’), ’P’, A(’p’), ’p’, ’P’, C(’P’),
/* 26 - ’[’ */ 0212, 0202, 0212, ’[’, ’{’, C(’[’),
/* 27 - ’]’ */ ’+’, ’*’, A(’+’), ’]’, ’}’, C(’]’),
/* 28 - CR/LF */ C(’M’), C(’M’), CA(’M’),C(’M’), C(’M’), C(’J’),
/* 29 - Ctrl */ CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,
/* 30 - ’a’ */ L(’a’), ’A’, A(’a’), ’a’, ’A’, C(’A’),
/* 31 - ’s’ */ L(’s’), ’S’, A(’s’), ’s’, ’S’, C(’S’),
/* 32 - ’d’ */ L(’d’), ’D’, A(’d’), ’d’, ’D’, C(’D’),
/* 33 - ’f’ */ L(’f’), ’F’, A(’f’), ’f’, ’F’, C(’F’),
/* 34 - ’g’ */ L(’g’), ’G’, A(’g’), ’g’, ’G’, C(’G’),
/* 35 - ’h’ */ L(’h’), ’H’, A(’h’), ’h’, ’H’, C(’H’),
/* 36 - ’j’ */ L(’j’), ’J’, A(’j’), ’j’, ’J’, C(’J’),
/* 37 - ’k’ */ L(’k’), ’K’, A(’k’), ’k’, ’K’, C(’K’),
/* 38 - ’l’ */ L(’l’), ’L’, A(’l’), ’l’, ’L’, C(’L’),
/* 39 - ’;’ */ 0225, 0207, 0225, ’@’, ’@’, C(’@’),
/* 40 - ’\’’ */ 0205, 0370, 0205, ’#’, ’#’, C(’@’),
/* 41 - ’‘’ */ ’\\’, ’|’, ’\\’, ’\\’, ’|’, C(’\\’),
/* 42 - l. SHIFT*/ SHIFT, SHIFT, SHIFT, SHIFT, SHIFT, SHIFT,
/* 43 - ’\\’ */ 0227, ’|’, 0227, 0227, ’|’, C(’@’),
/* 44 - ’z’ */ L(’z’), ’Z’, A(’z’), ’z’, ’Z’, C(’Z’),
/* 45 - ’x’ */ L(’x’), ’X’, A(’x’), ’x’, ’X’, C(’X’),
/* 46 - ’c’ */ L(’c’), ’C’, A(’c’), ’c’, ’C’, C(’C’),
/* 47 - ’v’ */ L(’v’), ’V’, A(’v’), ’v’, ’V’, C(’V’),
/* 48 - ’b’ */ L(’b’), ’B’, A(’b’), ’b’, ’B’, C(’B’),
/* 49 - ’n’ */ L(’n’), ’N’, A(’n’), ’n’, ’N’, C(’N’),
/* 50 - ’m’ */ L(’m’), ’M’, A(’m’), ’m’, ’M’, C(’M’),
/* 51 - ’,’ */ ’,’, ’;’, A(’,’), ’,’, ’;’, C(’@’),
/* 52 - ’.’ */ ’.’, ’:’, A(’.’), ’.’, ’:’, C(’@’),
/* 53 - ’/’ */ ’-’, ’_’, A(’-’), ’-’, ’_’, C(’_’),
/* 54 - r. SHIFT*/ SHIFT, SHIFT, SHIFT, SHIFT, SHIFT, SHIFT,
/* 55 - ’*’ */ ’*’, ’*’, A(’*’), ’*’, ’*’, C(’M’),
/* 56 - ALT */ ALT, ALT, ALT, ALT, ALT, ALT,
/* 57 - ’ ’ */ ’ ’, ’ ’, A(’ ’), ’ ’, ’ ’, C(’@’),
/* 58 - CapsLck */ CALOCK, CALOCK, CALOCK, CALOCK, CALOCK, CALOCK,
/* 59 - F1 */ F1, SF1, AF1, AF1, ASF1, CF1,
/* 60 - F2 */ F2, SF2, AF2, AF2, ASF2, CF2,
/* 61 - F3 */ F3, SF3, AF3, AF3, ASF3, CF3,
/* 62 - F4 */ F4, SF4, AF4, AF4, ASF4, CF4,
/* 63 - F5 */ F5, SF5, AF5, AF5, ASF5, CF5,
/* 64 - F6 */ F6, SF6, AF6, AF6, ASF6, CF6,
/* 65 - F7 */ F7, SF7, AF7, AF7, ASF7, CF7,
/* 66 - F8 */ F8, SF8, AF8, AF8, ASF8, CF8,
/* 67 - F9 */ F9, SF9, AF9, AF9, ASF9, CF9,
/* 68 - F10 */ F10, SF10, AF10, AF10, ASF10, CF10,
/* 69 - NumLock */ NLOCK, NLOCK, NLOCK, NLOCK, NLOCK, NLOCK,

Minix 75
/* 70 - ScrLock */ SLOCK, SLOCK, SLOCK, SLOCK, SLOCK, SLOCK,
/* 71 - Home */ HOME, ’7’, AHOME, AHOME, ’7’, CHOME,
/* 72 - CurUp */ UP, ’8’, AUP, AUP, ’8’, CUP,
/* 73 - PgUp */ PGUP, ’9’, APGUP, APGUP, ’9’, CPGUP,
/* 74 - ’-’ */ NMIN, ’-’, ANMIN, ANMIN, ’-’, CNMIN,
/* 75 - Left */ LEFT, ’4’, ALEFT, ALEFT, ’4’, CLEFT,
/* 76 - MID */ MID, ’5’, AMID, AMID, ’5’, CMID,
/* 77 - Right */ RIGHT, ’6’, ARIGHT, ARIGHT, ’6’, CRIGHT,
/* 78 - ’+’ */ PLUS, ’+’, APLUS, APLUS, ’+’, CPLUS,
/* 79 - End */ END, ’1’, AEND, AEND, ’1’, CEND,
/* 80 - Down */ DOWN, ’2’, ADOWN, ADOWN, ’2’, CDOWN,
/* 81 - PgDown */ PGDN, ’3’, APGDN, APGDN, ’3’, CPGDN,
/* 82 - Insert */ INSRT, ’0’, AINSRT, AINSRT, ’0’, CINSRT,
/* 83 - Delete */ 0177, ’.’, A(0177),0177, ’.’, 0177,
/* 84 - Enter */ C(’M’), C(’M’), CA(’M’),C(’M’), C(’M’), C(’J’),
/* 85 - ??? */ 0, 0, 0, 0, 0, 0,
/* 86 - ??? */ ’’, A(’’, C(’@’),
/* 87 - F11 */ F11, SF11, AF11, AF11, ASF11, CF11,
/* 88 - F12 */ F12, SF12, AF12, AF12, ASF12, CF12,
/* 89 - ??? */ 0, 0, 0, 0, 0, 0,
/* 90 - ??? */ 0, 0, 0, 0, 0, 0,
/* 91 - ??? */ 0, 0, 0, 0, 0, 0,
/* 92 - ??? */ 0, 0, 0, 0, 0, 0,
/* 93 - ??? */ 0, 0, 0, 0, 0, 0,
/* 94 - ??? */ 0, 0, 0, 0, 0, 0,
/* 95 - ??? */ 0, 0, 0, 0, 0, 0,
/* 96 - EXT_KEY */ EXTKEY, EXTKEY, EXTKEY, EXTKEY, EXTKEY, EXTKEY,
/* 97 - ??? */ 0, 0, 0, 0, 0, 0,
/* 98 - ??? */ 0, 0, 0, 0, 0, 0,
/* 99 - ??? */ 0, 0, 0, 0, 0, 0,
/*100 - ??? */ 0, 0, 0, 0, 0, 0,
/*101 - ??? */ 0, 0, 0, 0, 0, 0,
/*102 - ??? */ 0, 0, 0, 0, 0, 0,
/*103 - ??? */ 0, 0, 0, 0, 0, 0,
/*104 - ??? */ 0, 0, 0, 0, 0, 0,
/*105 - ??? */ 0, 0, 0, 0, 0, 0,
/*106 - ??? */ 0, 0, 0, 0, 0, 0,
/*107 - ??? */ 0, 0, 0, 0, 0, 0,
/*108 - ??? */ 0, 0, 0, 0, 0, 0,
/*109 - ??? */ 0, 0, 0, 0, 0, 0,
/*110 - ??? */ 0, 0, 0, 0, 0, 0,
/*111 - ??? */ 0, 0, 0, 0, 0, 0,
/*112 - ??? */ 0, 0, 0, 0, 0, 0,
/*113 - ??? */ 0, 0, 0, 0, 0, 0,
/*114 - ??? */ 0, 0, 0, 0, 0, 0,
/*115 - ??? */ 0, 0, 0, 0, 0, 0,
/*116 - ??? */ 0, 0, 0, 0, 0, 0,
/*117 - ??? */ 0, 0, 0, 0, 0, 0,
/*118 - ??? */ 0, 0, 0, 0, 0, 0,
/*119 - ??? */ 0, 0, 0, 0, 0, 0,
/*120 - ??? */ 0, 0, 0, 0, 0, 0,
/*121 - ??? */ 0, 0, 0, 0, 0, 0,
/*122 - ??? */ 0, 0, 0, 0, 0, 0,
/*123 - ??? */ 0, 0, 0, 0, 0, 0,
/*124 - ??? */ 0, 0, 0, 0, 0, 0,
/*125 - ??? */ 0, 0, 0, 0, 0, 0,
/*126 - ??? */ 0, 0, 0, 0, 0, 0,
/*127 - ??? */ 0, 0, 0, 0, 0, 0
};
Dopo la modifica, si avvia la compilazione.
# cd /usr/src/kernel/keymaps/ [ Invio ]

76 volume VIII Argomenti avanzati e accessori
# make [ Invio ]
Vengono generati tutti i file di configurazione che non siano già presenti (se si vuole ripetere la
compilazione occorre prima rimuovere il file ‘italian.map’).
# cp italian.map /etc/keymap [ Invio ]
Al prossimo riavvio sarà utilizzata la nuova mappa.
356.10 Altri programmi
Il software a disposizione per Minix non è molto e può essere trovato negli stessi FTP da cui
si accede ai file del sistema operativo citati qui. In particolare, tra i programmi riferiti alla rete,
vale la pena di ricordare i pacchetti ‘HTTPD.TAZ’ e ‘FROG.TAZ’. Il primo è un servente HTTP
molto semplice e il secondo è un programma per il tracciamento dell’instradamento (simile a
Traceroute). Sono entrambi molto utili e compilabili facilmente.
356.10.1 HTTPD.TAZ
Minix dispone di un servente HTTP elementare e lo si trova distribuito nel pacchetto
‘HTTPD.TAZ’. I pacchetti supplementari, come questo, vanno installati a partire dalla directory
‘/usr/local/’ e i sorgenti vanno collocati in ‘/usr/local/src/’.
# cd /usr/local/src [ Invio ]
Supponendo che il file ‘HTTPD.TAZ’ si trovi nel dischetto, montato nella directory ‘/mnt/’, si
può agire come segue:
# cat /mnt/HTTPD.TAZ | compress -d | tar xvf - [ Invio ]
Si ottiene la creazione della directory ‘httpd/’ a partire dalla posizione corrente, cioè ‘/usr/
local/src/’.
# cd httpd [ Invio ]
Si procede con la compilazione.
# make [ Invio ]
Quindi si installa il programma.
# make install [ Invio ]
L’installazione non si occupa di copiare i file di configurazione: bisogna farlo manualmente.
# cp httpd.conf /etc [ Invio ]
# cp httpd.mtype /etc [ Invio ]
Il demone ‘httpd’, installato in ‘/usr/local/bin/’, ha bisogno di un utente ‘www’, in base
alla configurazione predefinita del file ‘/etc/httpd.conf’ che non serve modificare.
# adduser www operator /usr/home/www [ Invio ]
Naturalmente la scelta della directory personale di questo utente fittizio è solo un fatto di gusto
personale. Sempre in base alla configurazione predefinita, occorre aggiungere alla directory
personale la directory ‘exec/’ e all’interno di questa si devono collocare un paio di file.

Minix 77
# mkdir /usr/home/www/exec [ Invio ]
# cp dir2html /usr/home/www/exec [ Invio ]
# cp dir2html.sh /usr/home/www/exec [ Invio ]
Per ultimo, occorre avviare il demone. Per questo conviene ritoccare il file ‘/etc/rc.net’ in
modo da aggiungere la riga seguente:
tcpd http /usr/local/bin/httpd &
356.10.2 FROG.TAZ
‘frog’ è un programma per il tracciamento dell’instradamento. È semplice, ma anche molto
importante. L’estrazione dell’archivio avviene nel modo solito, così come la compilazione e
l’installazione.
# cd /usr/local/src [ Invio ]
# cat /mnt/FROG.TAZ | compress -d | tar xvf - [ Invio ]
# cd frog [ Invio ]
# make [ Invio ]
# make install [ Invio ]
Tutto qui.
356.11 Copie di sicurezza
Le copie di sicurezza possono essere fatte soltanto utilizzano ‘tar’ e ‘compress’. Dal momento
che il sistema è organizzato in modo piuttosto rigido, con una partizione principale molto piccola
e una partizione ‘/usr/’, normalmente conviene preoccuparsi solo di questa seconda partizione.
Per la prima converrebbe realizzare un dischetto di avvio e installazione con gli stessi file di
configurazione, compresi ‘/etc/passwd’, ‘/etc/group’ e ‘/etc/shadow’.
356.11.1 Archiviazione
Se si dispone di abbastanza spazio libero nella partizione ‘/usr/’, se ne può fare la copia di
sicurezza in un file collocato all’interno della stessa partizione. Successivamente si può scaricare
su dischetti. Si può procedere nel modo seguente:
# cd /usr [ Invio ]
# tar cf - . | compress -c > .BKP.TAZ [ Invio ]
Si ottiene il file ‘/usr/.BKP.TAZ’ contenente la copia di quanto contenuto nella directory corrente
‘/usr/’. Successivamente si può copiare il file ottenuto, a pezzi, su una serie di dischetti
formattati in precedenza. Si comincia con la formattazione e si suppone di disporre di dischetti
da 1440 Kibyte.
# format /dev/fd0 1440 [ Invio ]

78 volume VIII Argomenti avanzati e accessori
...
Una volta preparati i dischetti formattati, si può scaricare il file nei dischetti.
# dd if=/usr/.BKP.TAZ of=/dev/fd0 bs=1440k count=1 skip=0 [ Invio ]
# dd if=/usr/.BKP.TAZ of=/dev/fd0 bs=1440k count=1 skip=2 [ Invio ]
...
356.11.2 Recupero
Per recuperare un sistema archiviato nel modo mostrato nella sezione precedente, si deve cominciare
dall’installazione con il dischetto iniziale. La cosa migliore sarebbe l’utilizzo di un dischetto
modificato opportunamente in modo che i file di configurazione corrispondano a quanto utilizzato
nel proprio sistema.
Dopo l’installazione iniziale che consiste nel trasferimento di quanto contenuto nel dischetto
iniziale nel disco fisso, si procede con l’installazione della copia (preparata in precedenza) della
partizione collocata a partire da ‘/usr/’.
# setup /usr [ Invio ]
Uno dopo l’altro verranno richiesti tutti i dischetti.
356.12 Convivenza tra Minix e GNU/Linux
Se lo si desidera, si può fare convivere Minix assieme a GNU/Linux, nello stesso disco fisso, su
partizioni distinte. Ma installare Minix in una partizione libera di un disco in cui GNU/Linux è
già stato installato richiede prudenza e attenzione.
• L’installazione di Minix provoca l’alterazione dell’MBR del disco fisso, di conseguenza, al
termine si avvia solo Minix. Quindi, prima di installare Minix occorre preparare uno o più
dischi di avvio di GNU/Linux, in modo da poter in seguito ripristinare il sistema di avvio
attraverso LILO.
• Quando si conclude il lavoro con Minix e si esegue un riavvio con un semplice
[ Ctrl+Alt+Canc ], si ottiene un avvio a caldo (warm boot), ma se dopo si vuole avviare un
kernel Linux, questo non potrà essere caricato. Pertanto, è necessario un riavvio a freddo,
al limite attraverso lo spegnimento e la riaccensione dell’elaboratore.
356.12.1 LILO
Una volta che si è riusciti a fare riavviare il sistema GNU/Linux, con i dischetti di avvio a cui si
faceva riferimento in precedenza, conviene modificare il file ‘/etc/lilo.conf’ in modo che si
possa scegliere tra l’avvio di GNU/Linux, Minix ed eventualmente altro.
Supponendo di avere installato Minix nella seconda partizione del primo disco fisso, le righe
necessarie nel file ‘/etc/lilo.conf’ sono quelle seguenti:
other=/dev/hda2
label=minix
table=/dev/hda

Minix 79
Volendo supporre che Minix sia stato installato nel secondo disco fisso, sempre nella seconda
partizione, le righe sarebbero quelle seguenti:
other=/dev/hdb2
label=minix
table=/dev/hdb
loader=/boot/chain.b
In pratica, è esattamente ciò che si fa quando si vuole controllare l’avvio del Dos.
356.13 Riferimenti
Minix è un sistema operativo molto limitato rispetto a GNU/Linux. Resta comunque l’unica
opportunità, almeno per ora, di fronte a vecchi elaboratori i286 o inferiori.
Molti particolari importanti non sono stati descritti, ma le informazioni relative sono comunque
accessibili dai siti FTP di distribuzione di Minix e dalla documentazione interna costituita delle
pagine di manuale (‘man’).
• Andrew S. Tanenbaum, Alber S. Woodhull, Operating Systems: Design and Implementation,
2/e, Prentice-Hall
•
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

ELKS
Capitolo 357
Il progetto ELKS (Embeddable linux kernel subset) vuole creare un sistema operativo per i
microprocessori ix86 di fascia bassa, a partire da un sottoinsieme di funzionalità di GNU/Linux.
È possibile avviare un mini sistema composto da un dischetto di avvio (boot) e un dischetto contenente
un sistema minimo; con un po’ di pazienza è anche possibile installarlo in una partizione
del disco fisso.
È disponibile un compilatore da utilizzare con GNU/Linux, per produrre binari ELKS, cioè
tutto il necessario per sviluppare questo nuovo sistema; è possibile eseguire i binari ELKS su
GNU/Linux, attraverso una libreria di emulazione; è possibile avviare ELKS anche all’interno di
DOSEMU.
357.1 Sperimentare ELKS
ELKS non è un sistema completo, quindi necessita di un pacchetto di sviluppo, composto essenzialmente
da un compilatore, da utilizzare in una piattaforma GNU/Linux normale. Questo
pacchetto è Dev86, distribuito normalmente in forma sorgente.
Una volta scaricato il pacchetto di sviluppo, questo può essere espanso a partire dalla directory
‘/usr/src/’, nell’elaboratore GNU/Linux, come mostrato dall’esempio seguente:
# cd /usr/src [ Invio ]
# tar xzvf Dev86src-0.13.4.tar.gz [ Invio ]
Si otterrà la directory ‘/usr/src/linux-86’ che si articola ulteriormente. Terminata
l’installazione occorre compilare questi sorgenti e installarli.
# cd /usr/src/linux-86 [ Invio ]
# make install [ Invio ]
A questo punto si può pensare ai sorgenti del kernel di ELKS e dei vari programmi di sistema e
di servizio. Anche questi vanno installati a partire da ‘/usr/src/’.
# cd /usr/src [ Invio ]
# tar xzvf elks-0.0.67.tar.gz [ Invio ]
# tar xzvf elkscmd.tar.gz [ Invio ]
Si ottengono le directory ‘/usr/src/elks/’ e ‘/usr/src/elkscmd/’. La prima contiene il
kernel, la seconda i programmi di contorno. Per compilare il kernel basta eseguire i passi seguenti.
# cd /usr/src/elks [ Invio ]
# make config [ Invio ]
# make dep ; make clean [ Invio ]
# make [ Invio ]
80

ELKS 81
Si ottiene il file ‘/usr/src/elks/Image’ che può essere trasferito nel modo solito in un
dischetto, attraverso ‘cp’ o ‘dd’.
Per compilare gli altri programmi occorre passare le varie directory in cui si articola ‘/usr/src/
elkscmd/’ e usare il comando ‘make’.
357.2 Immagini di dischetti già pronti
La realizzazione di un sistema ELKS è un po’ difficoltosa in questa fase iniziale del suo progetto
di realizzazione. La cosa migliore è partire dalle immagini già pronte, contenute normalmente in
un pacchetto unico. Per trasferirle nei dischetti ci si comporta nel modo solito, esattamente come
si fa per le immagini di dischetti di GNU/Linux.
Volendo, l’immagine ‘boot’ (quella di avvio) può essere sostituita semplicemente con un kernel
compilato personalmente, mentre l’immagine ‘root’ può essere rielaborata aggiungendo o
sostituendo altri programmi. L’immagine ‘root’ contiene un file system Minix.
Per mettere in funzione il sistema ELKS è sufficiente avviare l’elaboratore con il dischetto ottenuto
dall’immagine ‘boot’, sostituendolo con quello dell’immagine ‘root’, quando il kernel lo
richiede.
357.3 Avvio di ELKS all’interno di DOSEMU
ELKS può essere avviato all’interno di DOSEMU, sia in una console che in una finestra di X.
Per farlo basta avviare l’emulatore in modo che esegua il caricamento dal dischetto. Questo si
ottiene di solito utilizzando l’opzione ‘-A’.
# dos -A [ Invio ]
La figura 357.1 mostra la fase finale dell’avvio di ELKS. Si nota in particolare l’invito della
shell (il prompt), che è molto scarno: per ora non si possono usare i caratteri jolly e tutte le altre
funzioni cui si è abituati con le shell normali.
Figura 357.1. L’avvio di ELKS.

82 volume VIII Argomenti avanzati e accessori
357.4 Riferimenti
• ELKS: the embeddable Linux kernel system
• Source Forge: ELKS
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Parte lxxii
Dos
358 Dos: introduzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
358.1 Avvio del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
358.2 Dispositivi secondo il Dos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
358.3 Directory, file ed eseguibili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
358.4 Comandi e ambiente di avvio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89
358.5 Caratteri jolly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
358.6 Invito dell’interprete dei comandi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
358.7 Comandi interni principali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
358.8 Flussi standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .97
358.9 Accesso diretto ai dispositivi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
358.10 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
359 Dos: dischi, file system, directory e file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
359.1 Suddivisione in partizioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
359.2 Inizializzazione di un’unità di memorizzazione . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
359.3 Etichetta di un’unità di memorizzazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
359.4 Analisi e correzione del file system . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
359.5 Copia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
359.6 Trasferimento del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
359.7 Modifica delle unità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
359.8 Altre particolarità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
360 Dos: configurazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
360.1 CONFIG.SYS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
360.2 AUTOEXEC.BAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
360.3 Comandi ridondanti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
360.4 Localizzazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
360.5 Orologio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
361 Dos: script dell’interprete dei comandi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
361.1 Parametri, variabili ed espansione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
361.2 Chiamate di altri script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
361.3 Strutture di controllo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
361.4 Comandi utili negli script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
362 Dos: gestione della memoria centrale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .121
83

362.1 Gestione particolare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
362.2 Comandi appositi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
362.3 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
363 FreeDOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
363.1 Installazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .123
363.2 Impostazione e configurazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
363.3 RxDOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
363.4 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
364 Progetto GNUish . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
364.1 Programmi di servizio vari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
364.2 Gnuplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
364.3 Spreadsheet Calculator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
364.4 Ispell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
364.5 Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .127
364.6 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
365 The valuable DOS Freeware page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
365.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
365.2 OS and GUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
365.3 Utility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
365.4 Network . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
365.5 Compilers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
365.6 Typesetting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
365.7 More Dos software sources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
365.8 Search engines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
366 Clean the Clipper 5.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
366.1 Step 1: try to compile with the /P parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
366.2 Step 2: understand well the use of code blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
366.3 Step 3: understand the object programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
366.4 Step 4: understand the get object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
366.5 Step 5: trying to stop using commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
366.6 Step 6: free yourself from STD.CH - /U . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
366.7 Step 7: take control over all include files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
367 nanoBase 1997 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
367.1 What is it . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
367.2 The dot command line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
367.3 The menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
367.4 The macro recording, compiling and execution . . . . . . . . . . . . . . . . . . . . . . . . . . . .161
84

367.5 The report system . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
367.6 The integrated text editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
367.7 The internal documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
367.8 Download it . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
367.9 Bugs and known problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
368 nanoBase 1997 user manual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
368.1 Dos xBase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
368.2 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
368.3 How to use nB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
368.4 Status line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
368.5 The dot line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
368.6 The menu system . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
368.7 The text editor DOC() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
368.8 The help text file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
368.9 Macro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
368.10 Data types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
368.11 Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
368.12 Delimiters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
368.13 Code blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
368.14 Standard functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
368.15 nB functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
368.16 Normal command substitution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
368.17 nB command substitution functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
368.18 RPT: the nB print function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
368.19 How can I... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
368.20 The source files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
85

Dos: introduzione
Capitolo 358
DOS è acronimo di Disk Operating System e sta a indicare il nome di un sistema operativo per
micro elaboratori basati su microprocessori i86, successore del vecchio CP/M. Probabilmente,
data la sua estrema limitatezza, è un po’ azzardato voler parlare di «sistema operativo», tanto che
qualcuno lo appella: «gestore di interruzioni» (interrupt).
Questo sistema operativo nasce come software proprietario; tuttavia, attualmente il progetto più
attivo attorno a questo tipo di sistema è FreeDOS, il cui scopo è quello di realizzarne un’edizione
libera e completa.
358.1 Avvio del sistema
Un sistema Dos è composto essenzialmente da un kernel, un interprete dei comandi e da una
serie di programmi di servizio. Questo concetto è analogo ai sistemi Unix, con la differenza che
il kernel offre funzionalità molto scarse e solo per mezzo di interruzioni software (IRQ).
Nelle versioni proprietarie del Dos, il kernel era suddiviso in due file, che raccoglievano funzionalità
distinte in base all’importanza relativa. I nomi usati sono stati differenti e nel caso di
FreeDOS il kernel è contenuto tutto in un solo file (tabella 358.1).
Tabella 358.1. Comparazione tra i nomi dei file che compongono il kernel di un
sistema Dos.
Microsoft IBM Novell, Caldera RxDOS FreeDOS
IO.SYS
MSDOS.SYS
IBMBIO.COM
IBMDOS.COM
IBMBIO.COM
IBMDOS.COM
RXDO-
SBIO.SYS
RXDOS.SYS
KERNEL.SYS
--
I file del kernel devono trovarsi nella directory radice della partizione o del dischetto per poter
essere avviati. Per la precisione, l’avvio del kernel viene gestito direttamente dal codice inserito
nel settore di avvio della partizione o del dischetto (512 Kibyte), che a sua volta viene avviato
dal firmware (il BIOS, secondo la terminologia specifica dell’architettura i86 e successiva).
Il kernel, dopo essere stato avviato, non attiva una procedura di avvio, ma si limita a interpretare
uno script speciale, ‘CONFIG.SYS’, e subito dopo avvia l’interprete dei comandi, ovvero
la shell. Tradizionalmente, il programma in questione è ‘COMMAND.COM’. Secondo la tradizione,
l’interprete dei comandi che viene avviato dal kernel si occupa subito di eseguire lo script
‘AUTOEXEC.BAT’. Gli script ‘CONFIG.SYS’ e ‘AUTOEXEC.BAT’ devono trovarsi nella directory
radice del disco o della partizione da cui si avvia il sistema, ovvero quella in cui si trova già il
kernel che viene avviato.
L’interprete dei comandi, ‘COMMAND.COM’, è in grado di eseguire direttamente alcune funzionalità,
attraverso comandi interni che non si traducono in programmi di servizio veri e propri.
Tradizionalmente ‘COMMAND.COM’ si colloca nella directory radice del disco o della partizione
in cui si trova il kernel stesso. Ciò non è propriamente indispensabile, ma conviene attenersi a
questa linea per evitare fastidi inutili.
86

Dos: introduzione 87
358.2 Dispositivi secondo il Dos
I dispositivi secondo il Dos hanno un nome, composto da lettere e cifre numeriche, terminato da
due punti opzionali:
nome_dispositivo[:]
Il nome in questione può essere indicato utilizzando lettere maiuscole o minuscole, senza che la
cosa faccia differenza. I nomi più comuni sono elencati nella tabella 358.2. È il caso di osservare
che i due punti che concludono il nome, vanno usati necessariamente quando questo viene
abbinato ad altre informazioni da cui non potrebbe essere distinto (per esempio un percorso).
Tabella 358.2. Nomi dei dispositivi più comuni in Dos.
Dispositivo Descrizione
‘A:’ Disco nella prima unità a dischetti.
‘B:’ Disco nella seconda unità a dischetti.
‘C:’ Prima partizione Dos nel primo disco fisso.
‘D:’, ‘E:’,... ‘Z:’ Partizione Dos o altro tipo di disco.
‘CON:’ Console: tastiera e schermo.
‘PRN:’ Porta stampante principale.
‘LPT1:’, ‘LPT2:’,... Porte parallele.
‘COM1:’, ‘COM2:’,... Porte seriali.
Il Dos mantiene distinti i dischi e le partizioni, nel senso che questi non devono creare una
struttura unica come avviene nei sistemi Unix. Pertanto, quando si fa riferimento a un percorso
di un file o di una directory, si deve tenere in considerazione anche il disco o la partizione in cui
si trova.
Il modo utilizzato dal Dos per identificare i dischi e le partizioni, di fatto impedisce di accedere a
questi dispositivi in modo indipendente dal file system sottostante. Per intenderci, l’«unità» ‘X:’
può essere una partizione Dos di un disco non meglio identificato; mentre non esiste un modo
univoco per poter raggiungere il dispositivo fisico in cui si trova questo disco.
358.3 Directory, file ed eseguibili
Il Dos è nato dopo Unix e da questo sistema ha ereditato alcuni concetti elementari (forse troppo
pochi). I percorsi di file e directory si separano con una barra obliqua, che però è inversa rispetto
allo Unix. Anche con il Dos c’è una directory radice; tuttavia si aggiunge l’indicazione dell’unità
di memorizzazione (il disco o la partizione). Si può osservare a questo proposito la figura 358.1.
Figura 358.1. Struttura di un percorso in un file system Dos.
C:\PRIMO\SECONDO\TERZO\QUARTO
^ ^ ^ ^ ^
| | | | |
| | | | file o directory finale
| | | |
| | | directory
| | |
| | separazione tra una directory e la successiva
| |
| directory radice
|
unità di memorizzazione

88 volume VIII Argomenti avanzati e accessori
I nomi di file e directory possono essere indicati utilizzando lettere maiuscole o minuscole, senza
che la cosa possa fare differenza. Questi nomi possono essere composti utilizzando anche cifre
numeriche e altri simboli (che comunque è bene usare con parsimonia).
Per la precisione, sono esclusi i simboli: ‘/’, ‘\’, ‘[’, ‘]’, ‘’, ‘+’, ‘=’, ‘;’, ‘:’, ‘,’, ‘?’, ‘*’,
‘{’, ‘}’ e il punto che va usato esattamente come descritto nel seguito.
Tradizionalmente, il Dos utilizza un tipo di file system elementare, denominato FAT (Dos-FAT),
in cui i nomi dei file e delle directory possono essere composti utilizzando al massimo 11 caratteri,
di cui otto compongono un prefisso e tre un suffisso. Il prefisso e il suffisso di questi nomi
appaiono uniti attraverso un punto. Per esempio: ‘CIAO.COM’, ‘LETTERA.TXT’, ‘PIPPO.NB’,...
Questa conformazione dei nomi è una caratteristica fondamentale del Dos, da cui derivano una
serie di consuetudini e di limitazioni molto importanti.
È importante osservare che non è opportuno che i nomi dei file coincidano con quelli dei dispositivi
(senza i due punti finali). In pratica, non conviene creare file del tipo ‘CON:’, ‘PRN:’,
ecc. Tutto dipende dal contesto, ma in generale è bene fare attenzione a questo particolare.
Come nei sistemi Unix il Dos annovera il concetto di directory corrente, a cui si aggiunge il
concetto di unità di memorizzazione corrente. Infatti, la directory va collocata in un disco o
in una partizione. In base a questo principio, si possono indicare dei percorsi relativi, che fanno
riferimento alla posizione corrente (nell’unità di memorizzazione corrente). Tuttavia, in più,
ogni unità di memorizzazione ha una sua directory corrente. Per esempio, fare riferimento a un
file in una certa unità di memorizzazione ‘x:’, senza specificare il percorso, significa indicare
implicitamente la directory corrente di quella unità.
Per esempio, supponendo che la directory corrente dell’unità ‘X:’ sia ‘X:\PRIMO\SECONDO\’,
facendo riferimento al file ‘X:CIAO’, si intende indicare implicitamente il file ‘X:\PRIMO\
SECONDO\CIAO’.
In un percorso si possono usare anche i simboli ‘.’ e ‘..’, con lo stesso significato che hanno in
un sistema Unix: la directory stessa e la directory genitrice.
Il file system tradizionale del Dos consente di annotare solo poche informazioni per i file e le
directory: la data di modifica e quattro indicatori booleani, rappresentati da altrettante lettere:
• H file o directory nascosti;
• S file o directory di sistema;
• R file o directory in sola lettura e non cancellabile;
• A file o directory da archiviare (i dati sono stati modificati).
Si tratta di attributi completamente differenti da quelli di Unix. Si può osservare in particolare la
mancanza di un attributo che specifichi la possibilità di eseguire un programma o di attraversare
una directory. Secondo la tradizione Dos, gli attributi vanno considerati nel modo seguente:
• A viene attivato ogni volta che il file viene scritto o modificato e serve per automatizzare
i sistemi di copia periodica;
• R se attivo, il Dos non consente la scrittura o la rimozione;

Dos: introduzione 89
• S se attivo si tratta di un file di «sistema», ma in pratica si comporta come l’attributo H;
• H se attivo si tratta di un file «nascosto», che così non dovrebbe apparire nelle liste di file
e directory.
In generale, file e directory nascosti o di sistema non dovrebbero essere spostati fisicamente,
nemmeno nell’ambito della stessa unità di memorizzazione. Questa esigenza nasce in particolare
per i file del kernel, che non possono essere spostati se si vuole poter riavviare il sistema
operativo.
Dal momento che il file system non permette di determinare se un file è un eseguibile, l’unico
modo per permettere al sistema di conoscere questa caratteristica sta nell’uso di suffissi convenzionali
nei nomi: i file che terminano con l’estensione ‘.COM’ e ‘.EXE’ sono programmi binari
(la differenza tra i due tipi di estensione riguarda il formato del binario); quelli che terminano per
‘.BAT’ sono script dell’interprete dei comandi (‘COMMAND.COM’).
La prima stranezza che deriva da questa caratteristica del Dos sta nel fatto che per avviare un
eseguibile di questi, è sufficiente indicare il nome del file senza l’estensione, che diventa così
un componente opzionale agli occhi dell’utilizzatore.
358.4 Comandi e ambiente di avvio
L’interprete dei comandi tradizionale dei sistemi Dos è il programma ‘COMMAND.COM’, che viene
avviato direttamente dal kernel. ‘COMMAND.COM’ può essere avviato più volte successive, anche
se di solito ciò è di scarsa utilità, dal momento che il Dos non è un sistema operativo in multiprogrammazione.
In ogni caso, quando viene avviato dal kernel, si occupa di interpretare ed eseguire
lo script ‘AUTOEXEC.BAT’ che si trova nella directory radice dell’unità di avvio.
‘COMMAND.COM’ mostra un invito simile idealmente a quello delle shell Unix, dopo il quale possono
essere inseriti i comandi. A loro volta, questi possono essere riferiti a comandi interni
corrispondenti a funzionalità offerte direttamente dall’interprete, oppure possono rappresentare
la richiesta di avvio di un programma esterno.
Figura 358.2. Riga di comando.
C:\>DIR A: /W
^ ^ ^ ^
| | | |
| | | opzione
| | |
| | argomento
| |
| comando
|
invito
Il Dos ha ereditato da Unix anche il concetto di variabile di ambiente. Il meccanismo è lo stesso
ed è fondamentale la variabile di ambiente ‘PATH’, con la quale si possono indicare i percorsi di
ricerca degli eseguibili. Tuttavia, il Dos ha delle caratteristiche speciali, per cui, è il caso di fare
alcuni esempi di comandi:
• C:\>C:\PRIMO\SECONDO.EXE
questo comando avvia l’esecuzione del file ‘C:\PRIMO\SECONDO.EXE’;

90 volume VIII Argomenti avanzati e accessori
• C:\>C:\PRIMO\SECONDO
questo comando potrebbe avviare l’esecuzione del primo dei file seguenti che riesce a
trovare;
– ‘C:\PRIMO\SECONDO.COM’
– ‘C:\PRIMO\SECONDO.EXE’
– ‘C:\PRIMO\SECONDO.BAT’
• C:\>SECONDO
questo comando potrebbe avviare l’esecuzione del primo dei file seguenti che dovesse riuscire
a trovare, ma in mancanza può continuare la ricerca nei percorsi indicati nella variabile
di ambiente ‘PATH’.
– ‘C:.\SECONDO.COM’
– ‘C:.\SECONDO.EXE’
– ‘C:.\SECONDO.BAT’
I percorsi indicati nella variabile di ambiente ‘PATH’ sono separati da un punto e virgola; per
esempio:
C:\;C:\DOS;C:\FDOS\BIN
Di solito, il Dos dà per scontato che si cerchino gli eseguibili a cominciare dalla directory corrente.
Per questo, occorre considerare che è sempre come se la variabile di ambiente ‘PATH’
contenesse questa indicazione prima delle altre: ‘.;C:\;C:\DOS;C:\FDOS\BIN’. È da osservare
che FreeDOS si comporta in maniera differente, in quanto richiede espressamente
questa indicazione della directory corrente.
358.5 Caratteri jolly
Il Dos imita l’utilizzo dei caratteri jolly come avviene nei sistemi Unix per opera delle shell.
Tuttavia, nel Dos non si tratta di un’espansione che avviene per opera della shell, ma vi deve
provvedere ogni programma per conto proprio. Questo rappresenta una gravissima deficienza del
Dos, che però è irrimediabile.
Su questa base, i comandi tendono a richiedere l’indicazione di un argomento che rappresenta il
nome di uno o più file prima delle opzioni eventuali.
Ma c’è un altro problema. Il punto che divide in due i nomi dei file e delle directory è un muro
insuperabile per i caratteri jolly.
I simboli che si possono utilizzare sono solo l’asterisco e il punto interrogativo. L’asterisco vale
per una sequenza qualunque di caratteri, escluso il punto; il punto interrogativo vale per un
carattere qualunque. 1
1 Ci sono programmi di origine Unix, portati in Dos, che non hanno questa limitazione riferita al punto che separa
l’estensione.

Dos: introduzione 91
Modello
Tabella 358.3. Alcuni esempi.
Corrispondenza
*.* Corrisponde a un nome qualunque.
*.COM Un nome che termina con l’estensione ‘.COM’.
CIAO.X?X
Tutti i nomi che iniziano per ‘CIAO’ e hanno un’estensione composta da un lettera
«X» iniziale e finale, senza specificare cosa ci sia al secondo posto.
* Tutti i nomi che non hanno estensione (che non contengono il punto).
358.6 Invito dell’interprete dei comandi
Esiste un’altra variabile di ambiente fondamentale per il Dos. Si tratta di ‘PROMPT’, che consente
di modificare l’aspetto dell’invito dell’interprete dei comandi. La cosa funziona un po’ come nelle
shell Unix, per cui si assegna una stringa che può contenere dei simboli speciali, praticamente
delle sequenze di escape che vengono espanse prima della visualizzazione. La tabella 358.4 riepiloga
questi simboli particolari. In origine, il Dos mostrava in modo predefinito un invito simile
all’esempio seguente, in cui appare solo l’unità di memorizzazione corrente:
C:>
Questo tipo di impostazione corrisponderebbe alla stringa ‘$N$G’. In seguito, si è passati a
un invito simile al prossimo esempio, in cui si aggiunge anche l’informazione della directory
corrente:
C:\BIN\>
Questo corrisponde alla stringa ‘$P$G’.
Tabella 358.4. Sequenze di escape per definire dei componenti speciali all’interno di
una stringa di invito.
Simbolo
Corrispondenza
$Q =
$$ $
$T Ora corrente.
$D Data corrente.
$V Numero della versione.
$N Lettera dell’unità corrente.
$G >
$L <
$B |
$H (cancella il carattere precedente)
$E (1B16)
$_ Codice di interruzione di riga.
Cancellando il contenuto della variabile di ambiente ‘PROMPT’ si ripristina la stringa di invito
predefinita.

92 volume VIII Argomenti avanzati e accessori
358.7 Comandi interni principali
I comandi interni sono quelli che non corrispondono a programmi di servizio veri e propri,
ma sono funzionalità svolte direttamente dall’interprete dei comandi. Nelle sezioni seguenti ne
vengono descritti brevemente alcuni.
358.7.1 CH, CHDIR
CH [percorso]
CHDIR [percorso]
‘CH’, o ‘CHDIR’, è un comando interno dell’interprete dei comandi, che consente di visualizzare
o di cambiare la directory corrente. È indifferente l’uso di ‘CD’ o di ‘CHDIR’; se il comando non
è seguito dal percorso, si ottiene solo la visualizzazione della directory corrente. Si osservi che
se si indica un percorso assoluto di unità di memorizzazione, se questa non corrisponde a quella
attuale, si cambia la directory corrente di quella unità.
Segue la descrizione di alcuni esempi.
• C:\>CD
Visualizza la directory corrente.
• C:\>CD \TMP\LAVORO
Sposta la directory corrente in ‘\TMP\LAVORO\’.
• C:\TMP\LAVORO>CD DATI\LETTERE
Sposta la directory corrente in ‘DATI\LETTERE\’ che a sua volta discende dalla posizione
iniziale precedente.
• C:\TMP\LAVORO\DATI\LETTERE>CD ..
Sposta la directory corrente nella posizione della directory genitrice di quella iniziale.
• C:\TMP\LAVORO\DATI>CD F:\TMP
Cambia la directory corrente dell’unità ‘F:’, senza intervenire nell’unità corrente.
358.7.2 X:
{A|B| ...|Z}:
Il Dos gestisce le unità di memorizzazione in modo speciale. Per cambiare l’unità di memorizzazione
corrente, non esiste un comando analogo a ‘CD’: si deve indicare il nome dell’unità a cui si
vuole accedere.
Segue la descrizione di alcuni esempi.
• C:\>A:
Cambia l’unità di memorizzazione attuale, facendola diventare ‘A:’.

Dos: introduzione 93
• A:\>F:
Cambia l’unità di memorizzazione attuale, facendola diventare ‘F:’.
358.7.3 MD, MKDIR
MD directory
MKDIR directory
‘MD’, o ‘MKDIR’, è un comando interno dell’interprete dei comandi, che consente di creare una
directory vuota.
Segue la descrizione di alcuni esempi.
• C:\>MD LAVORO
Crea la directory ‘LAVORO\’ a partire da quella corrente.
• C:\>MD \TMP\DATA
Crea la directory ‘\TMP\DATA\’ nell’unità corrente.
• C:\>MD F:\TMP\DATA
Crea la directory ‘\TMP\DATA\’ nell’unità ‘F:’.
358.7.4 RD, RMDIR
RM directory
RMDIR directory
‘RD’, o ‘RMDIR’, è un comando interno dell’interprete dei comandi, che consente di cancellare
una directory vuota.
Segue la descrizione di alcuni esempi.
• C:\>RD LAVORO
Cancella la directory ‘LAVORO\’ a partire da quella corrente.
• C:\>RD \TMP\DATA
Cancella la directory ‘\TMP\DATA\’ nell’unità corrente.
• C:\>RD F:\TMP\DATA
Cancella la directory ‘\TMP\DATA\’ nell’unità ‘F:’.

94 volume VIII Argomenti avanzati e accessori
358.7.5 DIR
DIR [directory|file] [/P] [/W]
‘DIR’ è un comando interno dell’interprete dei comandi, che consente di visualizzare l’elenco del
contenuto di una directory o l’elenco di un gruppo di file. L’argomento del comando può essere
composto utilizzando caratteri jolly, secondo lo standard del Dos, ovvero i simboli ‘*’ e ‘?’.
Tabella 358.5. Alcune opzioni.
Opzione Descrizione
Blocca lo scorrimento dell’elenco in attesa della pressione di
/P
un tasto quando questo è più lungo del numero di righe che
possono apparire sullo schermo.
Visualizza solo i nomi dei file e delle directory, senza altre
/W
informazioni, permettendo così di vedere più nomi assieme in
un’unica schermata.
Segue la descrizione di alcuni esempi.
• C:\>DIR *.*
Visualizza l’elenco di tutti i file contenuti nella directory corrente.
• C:\>DIR ESEMPIO.*
Visualizza l’elenco di tutti i file il cui nome inizia per ‘ESEMPIO’ e continua con
un’estensione qualunque.
• C:\>DIR *.DOC
Visualizza l’elenco di tutti i file il cui nome termina con l’estensione ‘.DOC’.
• C:\>DIR F:\DOC\*.*
Visualizza l’elenco di tutti i file contenuti nella directory ‘\DOC\’ dell’unità ‘F:’.
• C:\>DIR F:
Visualizza l’elenco di tutti i file contenuti nella directory corrente dell’unità ‘F:’.
358.7.6 COPY
COPY file_origine [file_destinazione] [opzioni]
COPY file_1 + file_2 [+ ...] [file_destinazione] [opzioni]
‘COPY’ è un comando interno dell’interprete dei comandi, che consente di copiare uno o più file
(sono escluse le directory). Anche qui è consentito l’uso di caratteri jolly, ma al contrario dei
sistemi Unix, i caratteri jolly possono essere usati anche nella destinazione. Il ‘COPY’ del Dos
consente anche di unire assieme più file.

Dos: introduzione 95
Tabella 358.6. Alcune opzioni.
Opzione Descrizione
/V Fa in modo che venga verificato il risultato della copia.
a sì che la copia avvenga in modo «binario». Questa opzione
può servire quando si copia un file su un dispositivo e si
/B
vuole evitare che alcuni codici vengano interpretati in modo
speciale.
Non chiede conferma prima di sovrascrivere i file, se questi
/Y
esistono già nella destinazione.
Segue la descrizione di alcuni esempi.
• C:\>COPY ESEMPIO PROVA
Copia il file ‘ESEMPIO’ nella directory corrente ottenendo il file ‘PROVA’, sempre nella
directory corrente.
• C:\>COPY C:\DOS\*.* C:\TMP
Copia tutto il contenuto della directory ‘\DOS\’ dell’unità ‘C:’ nella directory ‘\TMP\’
nella stessa unità ‘C:’, mantenendo gli stessi nomi.
• C:\>COPY TESTA+CORPO+CODA LETTERA
Copia, unendoli, i file ‘TESTA’, ‘CORPO’ e ‘CODA’, ottenendo il file ‘LETTERA’.
• C:\>COPY *.DOC *.TXT
Copia tutti i file che nella directory corrente hanno un nome che termina con l’estensione
‘.DOC’, generando altrettanti file, con lo stesso prefisso, ma con l’estensione ‘.TXT’.
• C:\>COPY PROVA.PRN PRN: /B
Copia il file ‘PROVA.PRN’ nel dispositivo ‘PRN:’, ovvero sulla stampante, assicurandosi
che la copia avvenga senza alterare alcunché.
358.7.7 DEL, ERASE
DEL file
ERASE file
‘DEL’, o ‘ERASE’, è un comando interno dell’interprete dei comandi, che consente di cancellare
uno o più file (sono escluse le directory). È da considerare che i file che hanno l’attributo di sola
lettura attivo, non possono essere modificati e nemmeno cancellati.
Segue la descrizione di alcuni esempi.
• C:\TMP>DEL *.*
Cancella tutti i file nella directory corrente.
• C:\TMP>DEL ESEMPIO.*
Cancella tutti i file contenuti nella directory corrente, il cui nome inizia per ‘ESEMPIO’ e
termina con qualunque estensione.

96 volume VIII Argomenti avanzati e accessori
• C:\TMP>DEL *.BAK
Cancella tutti i file contenuti nella directory corrente, il cui nome termina con l’estensione
‘.BAK’.
358.7.8 REN, RENAME
REN file_origine nome_nuovo
RENAME file_origine nome_nuovo
‘REN’, o ‘RENAME’, è un comando interno dell’interprete dei comandi, che consente di cambiare
il nome di uno o più file (sono escluse le directory). Il primo argomento può essere un percorso
relativo o assoluto, completo anche dell’indicazione dell’unità, mentre il secondo argomento è il
nuovo nome, che implicitamente non può essere collocato altrove.
Segue la descrizione di alcuni esempi.
• C:\>REN ESEMPIO PROVA
Cambia il nome del file ‘ESEMPIO’, che si trova nella directory corrente, in ‘PROVA’.
• C:\>REN *.TXT *.DOC
Cambia il nome di tutti i file che, nella directory corrente, hanno l’estensione ‘.TXT’,
trasformandoli in modo tale da avere un’estensione ‘.DOC’.
358.7.9 SET
SET [variabile_di_ambiente=stringa]
‘SET’ è un comando interno dell’interprete dei comandi che ha lo scopo di assegnare un valore
a una variabile di ambiente, oppure di leggere lo stato di tutte le variabili di ambiente esistenti.
Quando si assegna un valore a una variabile, questa viene creata simultaneamente; quando non
si assegna nulla a una variabile, la si elimina.
Segue la descrizione di alcuni esempi.
• C:\>SET
Elenca le variabili di ambiente esistenti assieme al loro valore.
• C:\>SET PROMPT=$P$G$G
Assegna alla variabile di ambiente ‘PROMPT’ la stringa ‘$P$G$G’. Questo si traduce nella
modifica dell’aspetto dell’invito dell’interprete dei comandi.
• C:\>SET PATH=.;C:\BIN;D:\BIN
Assegna alla variabile di ambiente ‘PATH’ la stringa ‘.;C:\BIN;D:\BIN’.
• C:\>SET PROMPT=
Elimina la variabile di ambiente ‘PROMPT’, assegnandole la stringa nulla.

Dos: introduzione 97
358.7.10 TYPE
TYPE file
‘TYPE’ è un comando interno dell’interprete dei comandi, che consente di leggere ed emettere
il contenuto di un file attraverso lo standard output. Questo si traduce in pratica nella
visualizzazione del file in questione.
Segue la descrizione di alcuni esempi.
• C:\>TYPE LETTERA
Emette il contenuto del file ‘LETTERA’ che si trova nella directory e nell’unità corrente.
• C:\>TYPE C:\DOC\MANUALE
Emette il contenuto del file ‘MANUALE’ che si trova nella directory ‘\DOC\’ dell’unità ‘C:’.
358.8 Flussi standard
Il Dos ha ereditato da Unix anche i concetti legati ai flussi standard. In pratica, i programmi
hanno a disposizione tre flussi predefiniti: uno in lettura rappresentato dallo standard input, due
in scrittura rappresentati dallo standard output e dallo standard error. Il meccanismo è lo stesso di
Unix, anche se non funziona altrettanto bene; infatti, non è possibile ridirigere lo standard error
attraverso l’interprete dei comandi.
Secondo la tradizione delle shell Unix, la ridirezione dello standard output si ottiene con il simbolo
‘>’ posto alla fine del comando interessato, seguito poi dal nome del file che si vuole generare
in questo modo. Per esempio,
C:\>TYPE LETTERA > PRN:
invece di visualizzare il contenuto del file ‘LETTERA’, lo invia al dispositivo di stampa
corrispondente al nome ‘PRN:’; inoltre,
C:\>DIR *.* > ELENCO
invece di visualizzare l’elenco dei file che si trovano nella directory corrente, crea il file ‘ELENCO’
con questi dati.
La ridirezione dello standard output fatta in questo modo, va a cancellare completamente il contenuto
del file di destinazione, se questo esiste già; al contrario, si può utilizzare anche ‘>>’, con
il quale, il file di destinazione viene creato se non esiste, oppure viene solo esteso.
Lo standard input viene ridiretto utilizzando il simbolo ‘SORT < ELENCO > ORDINATO
In questo modo, ‘SORT’ riceve dallo standard input il file ‘ELENCO’ e genera attraverso la
ridirezione dello standard output il file ‘ORDINATO’.

98 volume VIII Argomenti avanzati e accessori
Per mettere in contatto lo standard output di un comando con lo standard input del successivo, si
utilizza il simbolo ‘|’. L’esempio seguente mostra un modo alternativo di ottenere l’ordinamento
di un file:
C:\>TYPE ELENCO | SORT > ORDINATO
In generale, tutti i comandi che generano un risultato visuale che scorre sullo schermo, utilizzano
semplicemente lo standard output, che può essere ridiretto in questo modo. Si osservi ancora
l’esempio seguente che riordina il risultato del comando ‘DIR’, mostrandolo comunque sullo
schermo:
C:\>DIR *.DOC | SORT
Nelle sezioni seguenti vengono mostrati alcuni comandi filtro.
358.8.1 SORT
SORT [opzioni] < file_da_ordinare > file_ordinato
Il comando ‘SORT’, che dovrebbe corrispondere a un programma di servizio vero e proprio, riordina
il file di testo che ottiene dallo standard input, generando un risultato che emette attraverso
lo standard output.
Tabella 358.7. Alcune opzioni.
Opzione Descrizione
/R Riordina in modo decrescente
Riordina in base al testo che inizia a partire dalla colonna in-
/+n_colonna
dicata come argomento (si tratta di un numero a partire da
uno, per indicare la prima colonna).
L’esempio seguente emette l’elenco della directory corrente riordinato in base all’estensione, che
è un’informazione collocata a partire dalla decima colonna:
C:\>DIR *.DOC | SORT /+10
358.8.2 MORE
MORE < file_da_leggere
MORE file_da_leggere
Il comando ‘MORE’ legge un file, fornito come argomento o attraverso lo standard input, mostrandolo
poi sullo schermo una pagina dopo l’altra. In questo modo, è possibile leggere il contenuto
dei file più lunghi delle righe a disposizione sullo schermo.
Per passare alla pagina successiva, basta premere un tasto qualunque, oppure ciò che viene
indicato espressamente.
Segue la descrizione di alcuni esempi.
• C:\>DIR | MORE
Permette di controllare lo scorrimento a video del risultato del comando ‘DIR’.

Dos: introduzione 99
• C:\>MORE LETTERA.TXT
Permette di controllare lo scorrimento a video del contenuto del file ‘LETTERA.TXT’.
• C:\>TYPE LETTERA.TXT | MORE
Si ottiene lo stesso risultato dell’esempio precedente, attraverso l’uso di una pipeline.
358.9 Accesso diretto ai dispositivi
Il Dos offre poche occasioni per accedere direttamente ai dispositivi. Si tratta generalmente solo
della console e della porta parallela. L’esempio seguente mostra come «copiare» un file sul
dispositivo di stampa, per ottenere così la sua stampa diretta:
C:\>COPY LETTERA PRN:
La stessa cosa avrebbe potuto essere ottenuta con la ridirezione dei flussi standard:
C:\>TYPE LETTERA > PRN:
Può essere interessante la possibilità di copiare il flusso di ingresso della console in un file:
C:\>COPY CON: LETTERA
In questo caso, l’inserimento nel file ‘LETTERA’ prosegue fino a quando viene ricevuto un codice
EOF, che si ottiene qui con la combinazione di tasti [ Ctrl+z ] seguita da [ Invio ].
È bene ricordare che la console, ovvero il dispositivo ‘CON:’, riceve dati in ingresso attraverso la
tastiera ed emette dati in uscita utilizzando lo schermo. In pratica, quando un programma attende
dati dallo standard input non ridiretto, li riceve dalla console, cioè dalla tastiera; nello stesso
modo, quando un programma emette dati attraverso lo standard output non ridiretto, li invia alla
console, cioè sullo schermo.
358.10 Riferimenti
• FreeDOS
• OpenDOS Unofficial Home Page
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Dos: dischi, file system, directory e file
Capitolo 359
La gestione dei dischi, ovvero delle unità di memorizzazione di massa, è molto particolare nel
Dos. In generale, si fa riferimento a queste cose attraverso un lettera che ne rappresenta il dispositivo;
tuttavia, tale dispositivo può indicare un disco intero o solo una partizione, riferendosi
sempre solo a dischi e partizioni Dos.
359.1 Suddivisione in partizioni
Nel Dos, tutti i dischi rimovibili, come i dischetti, non vanno suddivisi in partizioni, mentre i
dischi fissi devono essere preparati in questo modo. Il programma che si usa per queste cose è
‘FDISK’.
Secondo il Dos, le partizioni di un disco possono essere solo quattro. Tuttavia, una partizione
normale può essere suddivisa in sottopartizioni, che vengono definite tradizionalmente «estese»,
dove anche queste possono essere al massimo quattro. Una tale struttura ha condizionato
in pratica anche altri sistemi operativi, per esempio GNU/Linux. Bisogna tenere in considerazione
l’origine storica per comprendere che altri sistemi operativi possono comportarsi in
modo completamente differente.
Di solito, ‘FDISK’ ha una visione delle partizioni tutta orientata verso il Dos. Infatti, consente
di creare una sola partizione primaria (ovvero una partizione normale) e altre partizioni estese
(ovvero altre sottopartizioni di una seconda partizione primaria).
Bisogna considerare che il settore di avvio del Dos viene collocato nel primo settore della partizione
primaria utilizzata per il Dos. In questo modo, manca la sistemazione del primo settore del
disco, l’MBR, che deve contenere il codice necessario a raggiungere il settore di avvio.
FDISK [/MBR]
In generale, sembra che le varie edizioni di ‘FDISK’ per Dos funzionino solo con il primo disco
fisso.
Fondamentalmente, il programma è interattivo, per cui si avvia una maschera con la quale si
interviene per mezzo di un menù. Di norma viene consentito di cancellare le partizioni, di crearne
una primaria e probabilmente una sola di estesa.
Di solito, è possibile riscrivere il settore di avvio MBR attraverso l’opzione ‘/MBR’.
359.2 Inizializzazione di un’unità di memorizzazione
L’inizializzazione di un’unità di memorizzazione, intesa come un dischetto o una partizione, si
ottiene con il comando ‘FORMAT’. Questo si occupa anche di predisporre il file system Dos-FAT
ed eventualmente anche di trasferire il kernel, per renderlo avviabile.
FORMAT lettera_unità: [/N:settori] [/T:cilindri] [/S] [/U]
In alcune edizioni del Dos, questo comando non inizializza l’unità di memorizzazione, ma si
limita a sovrascrivere la parte iniziale. Ciò viene fatto per accelerare il procedimento e per
permettere eventualmente il recupero dei dati, in caso di ripensamenti. In generale, sarebbe
meglio evitare questa scorciatoia quando si tratta di unità corrispondenti ai dischetti; così, per
confermare la richiesta di un’inizializzazione tradizionale, si può aggiungere l’opzione ‘/U’.
100

Dos: dischi, file system, directory e file 101
Segue la descrizione di alcuni esempi.
• C:\>FORMAT A: /U
Inizializza l’unità ‘A:’, corrispondente a un dischetto. L’inizializzazione avviene in modo
completo, essendo stata usata l’opzione ‘/U’; inoltre, dal momento che non sono state
indicate altre cose, il formato usato è quello predefinito in base alla configurazione del
firmware.
• C:\>FORMAT A: /N:9 /T:40 /U
Come nell’esempio precedente, con l’aggiunta dell’indicazione della geometria: nove settori
per traccia e 40 cilindri; si sottintende la presenza di due tracce per cilindro. Pertanto,
dal momento che ogni settore è di 512 byte: 2 * 40 * 9 * 512 byte = 360 Kibyte.
• C:\>FORMAT A: /N:9 /T:80 /U
Come nell’esempio precedente, ma con 80 cilindri: 2 * 80 * 9 * 512 byte = 720 Kibyte.
• C:\>FORMAT A: /N:15 /T:80 /U
Come nell’esempio precedente, ma con 15 settori per traccia: 2 * 80 * 15 * 512 byte =
1200 Kibyte.
• C:\>FORMAT A: /N:18 /T:80 /U
Come nell’esempio precedente, ma con 18 settori per traccia: 2 * 80 * 18 * 512 byte =
1440 Kibyte.
• C:\>FORMAT A: /S
Inizializza il dischetto corrispondente all’unità ‘A:’, trasferendo successivamente il kernel
e probabilmente anche l’interprete dei comandi (‘COMMAND.COM’). Ciò avviene perché è
stata usata l’opzione ‘/S’.
359.3 Etichetta di un’unità di memorizzazione
Tradizionalmente, il Dos prevede la possibilità di attribuire un nome a un’unità di memorizzazione.
Questo nome viene definito solitamente «etichetta» e di fatto viene annotato come un file
speciale nella directory radice (anche se poi non appare nell’elenco). Per modificare o attribuire
questo nome si utilizza il comando ‘LABEL’:
LABEL [lettera_unità:][nome]
Se non si indica la lettera dell’unità di memorizzazione su cui intervenire, si tratta implicitamente
di quella da cui è stato avviato il sistema; se non si indica il nome da attribuire, ‘LABEL’ funziona
in modo interattivo, chiedendo il da farsi.
In linea di principio, l’etichetta di un’unità non serve, salvo il caso di qualche programma che
potrebbe utilizzarla per uno scopo particolare (per esempio i programmi di installazione per
identificare i dischetti).

102 volume VIII Argomenti avanzati e accessori
Esiste anche un altro comando interno per la verifica del nome di un’unità; si tratta di ‘VOL’:
VOL [lettera_unità:]
Il risultato è solo l’informazione del nome stesso, con l’aggiunta del numero di serie se questo
dato è disponibile.
359.4 Analisi e correzione del file system
Esistono pochi strumenti di analisi e correzione degli errori nel file system. In origine si tratta del
comando ‘CHKDSK’, a cui in seguito si è aggiunto ‘SCANDISK’.
CHKDSK lettera_unità: [/F]
‘CHKDSK’ può essere usato solo con l’indicazione di un’unità di memorizzazione; in tal caso
restituisce le informazioni disponibili su questa. Se si aggiunge l’opzione ‘/F’, si richiede
esplicitamente la correzione, per quanto possibile, degli errori rilevati.
L’errore tipico di un file system Dos-FAT si traduce in «concatenamenti perduti», ovvero file,
interi o parziali, di cui non si può conoscere il nome. Questi file potrebbero essere solo dati
temporanei che è bene siano cancellati, ma questa non è la regola. ‘CHKDSK’ tende a salvare
questi file assegnando loro un nome più o meno casuale, lasciando all’utilizzatore l’onere di
decidere cosa farne.
359.5 Copia
Nei sistemi Dos la copia è un’attività piuttosto articolata. In pratica, il comando interno ‘COPY’
consente solo di copiare file puri e semplici. Per copiare un dischetto occorre il comando
‘DISKCOPY’; per copiare file e directory occorre il comando ‘XCOPY’.
359.5.1 DISKCOPY
DISKCOPY unità_di_origine: unità_di_destinazione:
‘DISKCOPY’ permette di eseguire la copia di un’unità di memorizzazione, purché si tratti di un
dischetto. Il dischetto di destinazione dovrebbe essere inizializzato preventivamente.
L’unità indicata come secondo argomento, che rappresenta la destinazione, può essere la stessa
di quella di origine. In questo caso, i dischetti andranno alternati nel dispositivo che li ospita,
seguendo le istruzioni che dà ‘DISKCOPY’ stesso.
L’esempio seguente esegue la copia di un dischetto usando lo stesso dispositivo fisico:
C:\>DISKCOPY A: A:
359.5.2 XCOPY
XCOPY percorso_origine [percorso_destinazione] [/E] [/S] [/H] [/V]
‘XCOPY’ consente di copiare uno o più file assieme alla struttura di directory. In altri termini, ciò
significa che è possibile copiare anche una directory intera.

Dos: dischi, file system, directory e file 103
Tabella 359.1. Alcune opzioni.
Opzione Descrizione
/S Copia solo le directory e le sottodirectory non vuote.
/E Copia tutte le sottodirectory, anche se vuote.
/H Copia anche i file nascosti e di sistema.
/V Verifica la copia.
L’esempio seguente copia tutta la struttura che si articola a partire dalla directory ‘\PIPPO\’,
nella directory ‘\PAPPA\’, includendo anche i file nascosti e quelli di sistema:
C:\>XCOPY \PIPPO\*.* \PAPPA\*.* /E /S /H /V
359.6 Trasferimento del sistema
Il Dos è un sistema operativo elementare. L’essenziale in assoluto è costituito dal kernel e dall’interprete
dei comandi. Per rendere «avviabile» un dischetto o una partizione basta copiare questi
file e sistemare il settore di avvio, in modo che punti correttamente al kernel. Questo si può ottenere
con il comando ‘FORMAT’, quando lo si usa con l’opzione ‘/S’ (cosa che naturalmente
implica anche l’inizializzazione dell’unità), oppure con il comando ‘SYS’, fatto appositamente
per questo:
FORMAT lettera_unità: /S
SYS lettera_unità:
A seconda del tipo di Dos, vengono copiati solo i file del kernel, oppure anche l’interprete dei
comandi (necessario per avviare il sistema).
359.7 Modifica delle unità
La caratteristica del Dos per cui si distinguono le unità di memorizzazione, introduce l’esigenza
di comandi particolari, che vengono descritti brevemente nelle sezioni seguenti. In particolare,
si tratta della possibilità di attribuire una lettera di unità differente e di poter inserire un’unità in
una directory come avviene con l’innesto di un file system nei sistemi Unix.
359.7.1 ASSIGN
ASSIGN lettera_unità_1[:]=lettera_unità_2[:]
ASSIGN /STATUS
ASSIGN
Il comando ‘ASSIGN’ permette di modifica il nome di un’unità di memorizzazione. Per ottenere
questo risultato, rimane attivo come programma residente in memoria. Quando si usa senza
argomenti, ‘ASSIGN’ elimina tutte le ridefinizioni; con l’opzione ‘/STATUS’ si ottiene lo stato
attuale delle ridefinizioni; quando si indicano le lettere di unità, la prima è l’unità virtuale che
viene creata come riproduzione della seconda.
Segue la descrizione di alcuni esempi.
• C:\>ASSIGN E:=A:
Dopo questo comando, per accedere all’unità corrispondente al primo dischetto, si potrà
indicare l’unità ‘E:’.

104 volume VIII Argomenti avanzati e accessori
• C:\>ASSIGN
Cancella tutte le ridefinizioni delle unità di memorizzazione.
359.7.2 JOIN
JOIN lettera_unità: percorso
JOIN lettera_unità: /D
JOIN
Il comando ‘JOIN’ permette di attaccare un’unità di memorizzazione in corrispondenza di un
percorso (una directory). Si tratta in pratica di montare l’unità, come avviene nei sistemi Unix.
Quando si usa ‘JOIN’ senza argomenti, si ottiene un elenco degli innesti attivi; quando si usa
l’opzione ‘/D’, si vuole annullare il collegamento dell’unità.
Segue la descrizione di alcuni esempi.
• C:\>JOIN A: C:\MNT\A
Innesta l’unità ‘A:’ nella directory ‘C:\MNT\A\’.
• C:\>JOIN A: /D
Distacca l’unità ‘A:’ da un collegamento precedente.
359.7.3 SUBST
SUBST lettera_unità: percorso
SUBST /D
Il comando ‘SUBST’ permette di creare un’unità virtuale a partire da una directory di un’altra
unità. In pratica, si fa in modo di permettere l’identificazione di una certa directory attraverso
l’uso di una lettera di unità.
Quando si usa ‘JOIN’ con l’opzione ‘/D’, si vuole annullare l’unità virtuale relativa.
Segue la descrizione di alcuni esempi.
• C:\>SUBST E: C:\EXTRA\E
Crea l’unità virtuale ‘E:’ a partire dal contenuto delle directory ‘C:\EXTRA\E\’.
• C:\>JOIN E: /D
Elimina l’unità virtuale ‘E:’.

Dos: dischi, file system, directory e file 105
359.8 Altre particolarità
La gestione del Dos di file e directory è molto strana. Nelle sezioni seguenti vengono descritti
alcuni programmi tipici dei sistemi Dos riguardanti la gestione di file e directory, che non hanno
trovato un’altra collocazione in questo documento, a causa della loro particolarità.
359.8.1 VERIFY
VERIFY [ON|OFF]
Il comando interno ‘VERIFY’ permette di richiedere al sistema operativo di verificare la registrazione
nelle unità di memorizzazione. Come si vede dallo schema sintattico, si attiva o si disattiva
la modalità, attraverso l’uso delle parole chiave ‘ON’ oppure ‘OFF’. Di solito, questa modalità è
disabilitata ed è difficile definire la reale importanza di questa impostazione.
Se si usa il comando senza alcun argomento, si ottiene di sapere quale sia l’impostazione attuale.
359.8.2 APPEND
APPEND directory
APPEND ;
APPEND
Il comando ‘APPEND’ consente di definire un percorso per la ricerca dei file di dati. In pratica,
si vuole permettere ai programmi di accedere a file di dati anche quando questi si trovano fuori
della collocazione prevista. ‘APPEND’ può essere usato più volte, per aggiungere altre directory.
Se viene usato con l’argomento ‘;’, si intende cancellare tutto l’elenco di directory di ricerca dei
file di dati. Se viene usato senza argomenti, si ottiene l’elenco di queste directory.
L’esempio seguente aggiunge la directory ‘C:\DATI\’ all’elenco dei percorsi di ricerca per i file
di dati:
C:\>APPEND C:\DATI
359.8.3 ATTRIB
ATTRIB [+R|-R] [+A|-A] [+S|-S] [+H|-H] file
Il comando ‘ATTRIB’ permette di visualizzare o cambiare gli attributi del file. In pratica,
utilizzando la forma ‘+x’ si attiva l’attributo x, mentre con ‘-x’ si disattiva l’attributo stesso.
Segue la descrizione di alcuni esempi.
• C:\>ATTRIB *.*
Mostra gli attributi di tutti i file contenuti nella directory corrente.
• C:\>ATTRIB +R *.*
Imposta l’attributo di sola lettura per tutti i file della directory corrente.

106 volume VIII Argomenti avanzati e accessori
359.8.4 DELTREE
DELTREE directory
Il comando ‘DELTREE’ consente di eliminare una directory con tutto il suo contenuto,
ricorsivamente.
L’esempio seguente elimina la directory ‘C:\TEMP\CIAO\’ assieme a tutto il suo contenuto:
C:\>DELTREE C:\TEMP\CIAO
359.8.5 FIND
FIND [opzioni] "stringa" [file]
Il comando ‘FIND’ è uno dei più complessi nei sistemi Dos. Serve per fare una ricerca di una
stringa in uno o più file, in base a quanto indicato nell’ultimo argomento, oppure all’interno
dello standard input. Il risultato normale della ricerca è l’emissione delle righe che contengono
la stringa cercata, assieme all’indicazione del file a cui appartengono.
Tabella 359.2. Alcune opzioni.
Opzione Descrizione
/V
La ricerca avviene per le righe che non contengono la stringa
cercata.
/C
Mostra solo il totale delle righe che contengono la stringa
cercata.
/N Mostra il numero di ogni riga che contiene la stringa cercata.
Ignora la differenza tra maiuscole e minuscole per il confronto
/I
con la stringa di ricerca.
In alcune edizioni del Dos, questa modalità di funzionamento
è predefinita.
Segue al descrizione di alcuni esempi.
• C:\>FIND "ciao" *.*
Cerca la stringa ‘ciao’ in tutti i file della directory corrente.
• C:\>FIND "ciao" < MIO.TXT
Cerca la stringa ‘ciao’ nel file ‘MIO.TXT’ che viene fornito attraverso lo standard input.
359.8.6 MOVE
MOVE file_origine directory_destinazione
MOVE directory_origine directory_destinazione
Il comando ‘MOVE’ consente di spostare file o directory in altre collocazioni. In generale, ‘MOVE’
si occupa di spostare e non di rinominare i file, che invece è una funzione del comando ‘REN’.
Il comando ‘MOVE’ è ambiguo e si comporta in maniera differente da una realizzazione all’altra
dei sistemi Dos. In generale bisogna considerare che la destinazione può esistere o meno,
implicando dei comportamenti differenti da valutare.

Dos: dischi, file system, directory e file 107
L’esempio seguente sposta i file e le directory contenute in ‘C:\CIAO\’ nella directory ‘C:\
MIA\’. Se la directory di destinazione non c’è, questa dovrebbe essere creata automaticamente,
ma la cosa va verificata:
C:\>MOVE C:\CIAO\*.* C:\MIA
359.8.7 TREE
TREE [directory]
Il comando ‘TREE’ consente di visualizzare la struttura della directory corrente, oppure di un’altra
directory indicata come argomento.
L’esempio seguente mostra la struttura della directory ‘C:\CIAO\’:
C:\>TREE C:\CIAO
359.8.8 COMP e FC
COMP file_1 file_2 [opzioni]
FC file_1 file_2 [opzioni]
I comandi ‘COMP’ e ‘FC’ permettono di verificare se due file sono identici, oppure no. Non sono
molto facili da utilizzare, specialmente il primo; probabilmente vale la pena di sapere che ci sono,
senza poi pretendere di sfruttare tutte le loro possibilità.
‘FC’ assomiglia molto vagamente a un comando ‘diff’ di Unix, dal momento che di fronte a file
di testo cerca di comprendere quale cambiamento è stato fatto. In questo senso, è probabile che
‘FC’ sia il più utile tra questi due.
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Dos: configurazione
Capitolo 360
Nel Dos è un po’ difficile scindere i concetti di configurazione e script, perché per configurare il
sistema, occorre predisporre degli script. Si tratta dei file ‘\CONFIG.SYS’ e ‘\AUTOEXEC.BAT’,
collocati nell’unità di avvio. Questo fatto è già stato accennato nel capitolo introduttivo; in questo
si vuole approfondire un po’ la cosa.
360.1 CONFIG.SYS
Il file ‘CONFIG.SYS’, collocato nella directory radice dell’unità di avvio, è uno script speciale
avviato dal kernel prima dell’interprete dei comandi. In linea di massima, si tratta di una sequenza
di direttive che occupano ognuna una riga; alcune versioni recenti del Dos consentono di
suddividere le direttive in sezioni da scegliere in base a un menù iniziale.
Le direttive di ‘CONFIG.SYS’ hanno la forma seguente:
nome=valore
In pratica, si assegna una stringa (senza delimitatori espliciti) a un nome che ha un significato
particolare.
In questo file, vengono ignorate le righe vuote, quelle bianche e quelle che iniziano con la parola
chiave ‘REM’:
REM annotazione
È importante osservare che i nomi delle direttive non fanno differenza tra lettere maiuscole
e minuscole. In generale, questo vale anche per le stringhe che vengono assegnate a questi
nomi.
360.1.1 BREAK
BREAK={ON|OFF}
Teoricamente, questa istruzione consente di attivare o di disattivare la funzionalità abbinata alla
combinazione di tasti [ Ctrl+c ]. In condizioni normali, quando si assegna la parola chiave ‘ON’, si
attiva il funzionamento della combinazione [ Ctrl+c ].
360.1.2 BUFFERS
BUFFERS=n_buffer[,n_buffer_secondari]
Questa istruzione consente di definire la quantità di memoria tampone per gli accessi ai dischi.
Si assegnano uno o due valori numerici, separati da una virgola. Il primo valore va da 1 a 99 ed
esprime il numero di aree da usare come memoria tampone; il secondo valore, facoltativo, indica
delle memorie tampone secondarie, con valori che vanno da uno a otto.
108

Dos: configurazione 109
360.1.3 COUNTRY
COUNTRY=n_codice_paese[,[n_codifica][,file_informazioni_nazionali]]
Questa istruzione, attraverso quanto contenuto in un file che tradizionalmente si chiama
‘COUNTRY.SYS’, permette di configurare il sistema in base alla nazionalità. Per la precisione,
si può specificare un codice riferito alla nazionalità, attraverso il quale si ottiene una forma particolare
per le date e gli orari, con l’aggiunta eventuale di un altro codice che specifica la codifica
dei caratteri prescelta (codepage). La tabella 360.1 riepiloga questi codici che fanno riferimento
tradizionalmente anche a paesi che non esistono più.
Si può osservare che la stringa assegnata alla direttiva ‘COUNTRY’ può contenere l’indicazione
di un file (con il percorso, completo di unità o meno). Questo file è quello che contiene poi
le indicazioni relative alla nazionalità prescelta; come già accennato, di solito si tratta del file
‘COUNTRY.SYS’.
Tabella 360.1. Codici di nazionalità.
Località Codice di nazionalità Codifiche utili
USA 001 437, 850
Canada francese 002 863, 850
America latina 003 850, 437
Russia 007 866, 437
Olanda 031 850, 437
Belgio 032 850, 437
Francia 033 850, 437
Spagna 034 850, 437
Ungheria 036 850, 852
Jugoslavia 038 850, 852
Italia 039 850, 437
Svizzera 041 850, 437
Cecoslovacchia 042 850, 852
Regno unito 044 850, 437
Danimarca 045 850, 865
Svezia 046 850, 437
Norvegia 047 850, 865
Polonia 048 850, 852
Germania 049 850, 437
Brasile 055 850, 860
Australia 061 850, 437
Giappone 081 932, 437, 850, 942
Corea 082 934, 437, 850, 944
Cina 088 938, 437, 850, 948
Turchia 090 857, 850
Asia (inglese) 099 850, 437
Portogallo 351 850, 860
Islanda 354 850, 861
Finlandia 358 850, 437
L’esempio seguente predispone l’impostazione nazionale per l’Italia, utilizzando la codifica 850,
che ha il vantaggio di essere quella più comune dei paesi che usano l’alfabeto latino:
COUNTRY=039,850,C:\DOS\COUNTRY.SYS

110 volume VIII Argomenti avanzati e accessori
360.1.4 DEVICE, DEVICEHIGH
DEVICE=programma_di_gestione_dispositivo [opzioni]
DEVICEHIGH=programma_di_gestione_dispositivo [opzioni]
Si tratta di un modo per avviare un programma speciale che ha lo scopo di rimanere residente
in memoria. In generale, tali programmi servono per la gestione di qualche dispositivo,
indispensabile prima di avviare l’interprete dei comandi.
La differenza tra le due direttive sta nel fatto che la seconda cerca di caricare il programma nella
memoria «alta».
Le opzioni riguardano il programma.
L’esempio seguente avvia il programma ‘MOUSE.SYS’ che presumibilmente gestisce il mouse
(l’opzione ‘/2’ serve probabilmente a utilizzare il mouse collegato alla seconda porta seriale):
DEVICE=C:\MOUSE\MOUSE.SYS /2
360.1.5 DOS
DOS={HIGH|LOW}[,{UMB|NOUMB}]
DOS=[{HIGH|LOW},]{UMB|NOUMB}
Questa istruzione richiede al kernel di allocarsi nella memoria convenzionale, ‘LOW’, o in quella
alta, ‘HIGH’. La parola chiave ‘UMB’ richiede di mantenere un collegamento tra la UMB e la
memoria convenzionale; la parola chiave ‘NOUMB’ fa sì che questo collegamento non abbia luogo.
360.1.6 DRIVEPARM
DRIVEPARM=[opzioni]
Si tratta di una direttiva attraverso cui si possono definire i parametri relativi ai dispositivi a
blocchi, per la precisione si tratta solo di dischi, se questo può essere necessario. Le opzioni
assomigliano a quelle dei programmi di servizio, iniziando con una barra obliqua normale: ‘/x...’.
Tabella 360.2. Alcune opzioni.
Opzione Descrizione
/d:n_dispositivo_fisico
Consente di indicare il dispositivo attraverso un numero, da 0
a 255. Lo zero corrisponde alla prima unità a dischetti.
/c
Se si utilizza questa opzione, si intende che l’unità fisica è in
grado di sapere se il disco è inserito o meno.
/f:n_formato
Stabilisce il formato del dispositivo fisico; in pratica, fissa la
geometria.
/f:0 Dischetto 160 Kibyte, 180 Kibyte, 320 Kibyte, 360 Kibyte.
/f:1 Dischetto 1200 Kibyte.
/f:2 Dischetto 720 Kibyte.
/f:5 Disco fisso.
/f:6 Nastro.
/f:7 Dischetto 1440 Kibyte.
/f:9 Dischetto 2880 Kibyte.
/h:n_testine Definisce il numero di testine.
/i Indica che si tratta di un dischetto da 3,5 pollici.

Dos: configurazione 111
Opzione Descrizione
/n Si tratta di un disco fisso.
/s:n_settori Definisce il numero di settori per traccia.
/t:n_cilindri
Definisce il numero dei cilindri (in altri termini: il numero di
tracce per faccia).
360.1.7 FCBS
FCBS=n_blocchi
Permette di definire il numero di blocchi di controllo dei file (file control block). Il valore va da 1
a 255, mentre il valore normale è di quattro blocchi.
360.1.8 FILES
FILES=n_blocchi
Permette di indicare il numero massimo di file aperti. Il numero che può essere assegnato va da
8 a 255. Il valore predefinito dovrebbe essere di otto file.
360.1.9 INSTALL
INSTALL=programma [opzioni]
Si tratta di un’istruzione con la quale si può avviare preventivamente un programma (che dovrebbe
essere residente in memoria), prima dell’avvio dell’interprete dei comandi. In questo caso, a
differenza della direttiva ‘DEVICE’, o ‘DEVICEHIGH’, si tratta di un programma normale.
Le opzioni riguardano il programma.
360.1.10 LASTDRIVE
LASTDRIVE=lettera_unità_finale
Consente di specificare l’ultima lettera di unità che può essere richiesta. Questo consente di
risparmiare risorse, se si è consapevoli del fatto che non servono lettere oltre un certo punto. La
lettera in questione può essere indifferentemente maiuscola o minuscola, senza che ciò possa fare
differenza.
360.1.11 SHELL
SHELL=programma [opzioni]
Permette di indicare esplicitamente il programma da avviare alla fine della procedura di avvio
del kernel. In generale si tratta dell’interprete dei comandi. Questa direttiva può consentire di avviare
un interprete alternativo a quello normale, oppure permette di avviarlo da una collocazione
insolita; inoltre permette di dare al programma in questione delle opzioni particolari.
L’esempio seguente avvia il programma ‘COMMAND.COM’ che si trova nella directory ‘C:\DOS\’:
SHELL=C:\DOS\COMMAND.COM

112 volume VIII Argomenti avanzati e accessori
360.1.12 STACK
STACK=n_livelli[,dimensione_in_byte]
Con questa istruzione è possibile fissare la dimensione dello stack, utilizzando valori da 8 a 64,
oltre allo zero. Il valore dopo la virgola indica la dimensione in byte di ogni livello dello stack.
In questo caso i valori vanno da 32 a 512.
360.2 AUTOEXEC.BAT
Il file ‘AUTOEXEC.BAT’ collocato nella directory radice dell’unità di avvio, è inteso essere uno
script che viene eseguito dall’interprete dei comandi, ‘COMMAND.COM’, dopo l’avvio del sistema.
Questo script viene realizzato normalmente in modo sequenziale, senza strutture di controllo.
In generale è importante per due cose: impostare alcune variabili di ambiente fondamentali, per
esempio ‘PATH’; avviare dei programmi che poi restano residenti in memoria, quando questo non
si ottiene già attraverso il file ‘\CONFIG.SYS’.
360.3 Comandi ridondanti
Anche nel Dos è molto importante l’uso delle variabili di ambiente. È già stato mostrato il
comando ‘SET’, attraverso il quale si impostano o si annullano le variabili di ambiente:
SET nome_variabile=stringa_assegnata
Alcune variabili hanno un’importanza particolare, per cui esiste un comando interno apposito
(dell’interprete dei comandi), che serve a inizializzarle senza nemmeno l’uso del comando ‘SET’.
• PROMPT stringa_di_invito
Il comando interno ‘PROMPT’ rappresenta un modo alternativo per impostare la variabile di
ambiente con lo stesso nome. Se si usa il comando senza l’argomento, si ripristina l’invito
predefinito.
• PATH [percorsi_degli_eseguibili]
Il comando interno ‘PATH’ rappresenta un modo alternativo per impostare la variabile di
ambiente con lo stesso nome. Se non si indica l’argomento, si ottiene la visualizzazione
dell’elenco dei percorsi attivo.
Esistono altri comandi particolari che si sovrappongono alle istruzioni del file ‘CONFIG.SYS’.
• BREAK [ON|OFF]
Abilita o disabilita la funzionalità abbinata alla combinazione di tasti [ Ctrl+c ]. Utilizzando
il comando senza argomento, si ottiene la visualizzazione dello stato attuale.

Dos: configurazione 113
360.4 Localizzazione
La localizzazione del Dos si riduce alla configurazione della mappa della tastiera e alla definizione
dell’insieme di caratteri. L’insieme di caratteri dipende dalla scelta della nazionalità, fatta
nel file ‘CONFIG.SYS’, attraverso la direttiva ‘COUNTRY’.
Nelle sezioni seguenti vengono mostrati alcuni comandi utili per le impostazioni che riguardano
la localizzazione.
360.4.1 CHCP
CHCP [n_codifica]
Si tratta di un comando interno dell’interprete dei comandi che interviene nella definizione della
codifica utilizzata. In pratica, se si utilizza senza argomenti, mostra il numero della codifica attiva;
se si indica un numero come argomento, cambia la codifica attiva, purché questa sia una di quelle
ammissibili in base alla nazionalità stabilita con la direttiva ‘COUNTRY’ nel file di configurazione
‘CONFIG.SYS’.
L’esempio seguente fa in modo che sia attivata la codifica corrispondente al numero 850:
C:\>CHCP 850
360.4.2 KEYB
KEYB [sigla_nazionale[,[n_codifica][,file_informazioni_tastiere]]]
‘KEYB’ è un comando esterno che consente di cambiare la configurazione della tastiera secondo
alcuni modelli di nazionalità predefiniti. La sigla nazionale è un codice di due lettere che, assieme
alla nazionalità, dovrebbe indicare anche la lingua utilizzata. La tabella 360.3 elenca queste sigle.
Tabella 360.3. Sigle nazionali-linguistiche per l’impostazione della mappa della
tastiera.
Segue la descrizione di alcuni esempi.
Sigla Corrispondenza
US USA (predefinito)
FR Francia
GR Germania
IT Italia
SP Spagna
UK Gran Bretagna
PO Portogallo
SG Svizzera tedesca
SF Svizzera francese
DK Danimarca
BE Belgio
NL Olanda (Nederland)
NO Norvegia
LA America latina
SV Svezia
SU Finlandia (Suomi)
CF Canada francese

114 volume VIII Argomenti avanzati e accessori
• C:\>KEYB
Mostra la configurazione attuale.
• C:\>KEYB IT
Predispone la mappa dei tasti per la disposizione italiana.
• C:\>KEYB IT,850,C:\DOS\KEYBOARD.SYS
Predispone la mappa dei tasti per la disposizione italiana, specificando l’uso della codifica
850 e del file ‘C:\DOS\KEYBOARD.SYS’ per trovare le impostazioni standard delle tastiere.
360.4.3 GRAFTABL
GRAFTABL [n_codifica]
GRAFTABL /STATUS
‘GRAFTABL’ è un comando esterno che consente di cambiare la codifica per i caratteri visualizzati
sullo schermo. L’opzione ‘/STATUS’ permette di conoscere la situazione attuale, mentre
l’indicazione di un numero di codifica cambia l’impostazione.
L’esempio seguente imposta l’uso della codifica 850:
C:\>GRAFTABL 850
360.5 Orologio
Il Dos consente di accedere all’orologio dell’elaboratore, per leggere la data e l’ora, o per cambiare
tali informazioni. In generale, il Dos non prevede la gestione di un orologio hardware allineato
al tempo universale; pertanto, l’orologio hardware deve corrispondere necessariamente all’ora
locale, lasciando all’utente il problema legato alle variazioni dell’ora estiva.
I comandi per accedere all’orologio sono ‘DATE’ e ‘TIME’:
DATE [data]
TIME [orario]
Se non si indica la data o l’orario, viene mostrato quello attuale e viene richiesto all’utente di
modificarlo o di confermarlo.
Il modo in cui va scritta da data o l’ora, dipende dalla localizzazione. Per conoscere quello giusto,
basta osservare in che modo vengono visualizzate tali informazioni.
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Dos: script dell’interprete dei comandi
Capitolo 361
Uno script dell’interprete dei comandi, conosciuto solitamente con il nome di file batch, potrebbe
essere definito come un file di testo normale in cui può essere indicato un elenco di comandi da
eseguire. Tuttavia, questi script consentono l’uso anche di strutture di controllo elementari, per
cui si possono realizzare dei programmi molto semplici, senza troppe pretese.
È interessante osservare che questi script vengono individuati solo attraverso l’estensione che ha
il nome: ‘.BAT’. Inoltre, non esiste la necessità di renderli «eseguibili» come si fa nei sistemi
Unix.
361.1 Parametri, variabili ed espansione
Gli script dell’interprete dei comandi hanno accesso agli argomenti che vengono loro forniti. Si
possono gestire solo nove di questi argomenti alla volta, attraverso i parametri posizionali relativi,
da ‘%1’ a ‘%9’. Come avviene nelle shell Unix, è disponibile il comando interno ‘SHIFT’ per fare
scorrere in avanti gli argomenti nei parametri disponibili.
Bisogna ricordare che in Dos i caratteri jolly non vengono espansi dalla shell, per cui la
limitazione a soli nove parametri posizionali, non dovrebbe costituire un problema.
Nell’ambito di uno script possono essere dichiarate e utilizzate delle variabili di ambiente. È già
stato mostrato in precedenza l’uso del comando ‘SET’ per impostare o eliminare le variabili di
ambiente. Per fare riferimento al contenuto di una variabile, si usa la notazione seguente:
%nome_variabile%
L’esempio seguente rappresenta il caso tipico di estensione di un percorso di ricerca degli
eseguibili, quando si ritiene che la variabile ‘PATH’ sia già stata usata:
SET PATH=%PATH%;C:\PIPPO
361.2 Chiamate di altri script
Tradizionalmente, il Dos ha un baco molto grave, ormai divenuto una caratteristica fondamentale,
riguardante l’avvio di script all’interno di altri script. In generale, quando si chiama un
programma che in realtà corrisponde a uno script, al termine di questo non riprende l’esecuzione
di quello chiamante. Per ottenere la ripresa dell’interpretazione dello script di partenza occorre
usare il comando speciale ‘CALL’.
CALL nome_script [argomenti_dello_script]
361.3 Strutture di controllo
Le strutture di controllo per la programmazione attraverso gli script dell’interprete dei comandi
sono molto limitate. È disponibile una struttura condizionale semplificata e un ciclo di scansione
di file, che vengono descritti brevemente.
115

116 volume VIII Argomenti avanzati e accessori
361.3.1 IF
IF [NOT] ERRORLEVEL valore_di_uscita_ultimo_comando comando
IF [NOT] stringa_1==stringa_2 comando
IF [NOT] EXIST file comando
La struttura condizionale degli script dell’interprete dei comandi Dos è in pratica un comando
interno dello stesso interprete. Come si può vedere dagli schemi sintattici, viene fornita una
condizione che può essere invertita con la parola chiave ‘NOT’ e il risultato è solo l’esecuzione di
un altro comando se la condizione risulta vera.
Nel primo caso, la condizione si riferisce alla verifica del valore di uscita dell’ultimo comando
eseguito. La condizione si verifica se il numero indicato è inferiore o uguale al valore restituito
effettivamente da tale comando; nel secondo, la condizione si verifica se le due stringhe
(non delimitate) sono identiche; nel terzo si verifica la condizione se il file indicato esiste
effettivamente.
Segue la descrizione di alcuni esempi.
• IF ERRORLEVEL 1 GOTO :errore
Se il comando precedente ha restituito un valore maggiore o uguale a uno, salta all’etichetta
‘:errore’.
• IF %1==ciao ECHO L’argomento è corretto
In questo caso, se l’espansione del parametro ‘%1’, corrispondente al primo argomento
ricevuto all’avvio, si traduce nella stringa ‘ciao’, viene emesso un messaggio per mezzo
del comando ‘ECHO’.
• IF %1x==x ECHO L’argomento è mancante
Quello che si vede è il trucco necessario per poter verificare se un parametro contiene
la stringa nulla: si aggiunge una lettera, in questo caso una «x», verificando che la
corrispondenza avvenga solo con la stessa lettera.
• IF NOT EXIST LETTERA.TXT ECHO Scrivi! > LETTERA.TXT
Qui, se non esiste il file ‘LETTERA.TXT’ nella directory corrente, questo file viene creato
attraverso il comando ‘ECHO’ che invia il suo standard output verso un file con lo stesso
nome.
361.3.2 FOR
FOR [%]%x IN (nome...) DO comando [argomenti_del_comando]
Si tratta di un comando interno che svolge un ciclo di scansione di un gruppo di nomi, generalmente
file, attraverso il quale viene creato un parametro variabile speciale, il cui nome si compone
di una sola lettera, a cui viene assegnato a ogni ciclo uno dei nomi contenuti tra parentesi tonde.
A ogni ciclo viene eseguito il comando, che a sua volta può fare uso del parametro. 1
1 Questo parametro assomiglia a una variabile di ambiente, ma non si comporta allo stesso modo. Si tratta di una
particolarità del comando ‘FOR’.

Dos: script dell’interprete dei comandi 117
Quando viene usato all’interno di uno script dell’interprete dei comandi, il parametro viene
indicato con due simboli di percentuale (‘%%x’); al contrario, se il comando viene impartito
dalla riga di comando, se ne usa uno solo.
Segue la descrizione di alcuni esempi.
• FOR %A IN (uno due tre) DO ECHO %A
•
In questo modo, si ottiene la visualizzazione delle parole ‘uno’, ‘due’ e ‘tre’. In pratica, è
come se fosse stato fatto:
ECHO uno
ECHO due
ECHO tre
Volendo fare la stessa cosa dalla riga di comando, è necessario il raddoppio del simbolo ‘%’:
C:\>FOR %%A IN (uno due tre) DO ECHO %%A
• FOR %A IN (*.TMP *.BAD) DO DEL %A
Cancella, uno a uno, tutti i file che terminano con le estensioni ‘.TMP’ e ‘.BAD’.
361.3.3 GOTO
GOTO etichetta
Gli script dell’interprete dei comandi dispongono dell’istruzione di salto incondizionato, non
avendo di meglio. Anche questa istruzione può essere presa come un comando interno
dell’interprete, con la differenza che non c’è modo di utilizzarlo al di fuori di uno script.
Nel corso di uno script del genere, possono apparire delle righe che contengono solo un’etichetta,
nella forma:
:nome_etichetta
La posizione corrispondente a queste etichette può essere raggiunta con il comando ‘GOTO’, che
può fare riferimento solo al nome dell’etichetta, oppure a tutta l’etichetta, includendo anche i due
punti.
Segue la descrizione di alcuni esempi.
•
•
IF EXIST LETTERA.TXT GOTO riprendi
ECHO Il file LETTERA.TXT è assente
:riprendi
In questo esempio, se il file ‘LETTERA.TXT’ esiste, si salta all’etichetta ‘:riprendi’;
altrimenti si esegue il comando ‘ECHO’.
IF EXIST LETTERA.TXT GOTO :riprendi
ECHO Il file LETTERA.TXT è assente
:riprendi
Esattamente come nell’esempio precedente, con la differenza che il comando ‘GOTO’ indica
l’etichetta con i suoi due punti iniziali.

118 volume VIII Argomenti avanzati e accessori
361.3.4 Emulazione di un ciclo iterativo
Dal momento che non è disponibile una struttura di controllo per il ciclo iterativo, questo può
essere ottenuto solo attraverso l’uso del comando ‘GOTO’. Vale la pena di mostrare in che modo
si può ottenere tale risultato.
:etichetta_di_ingresso
IF condizione GOTO :etichetta_di_uscita
...
...
...
GOTO etichetta_di_ingresso
:etichetta_di_uscita
:etichetta_di_ingresso
...
...
...
IF condizione GOTO :etichetta_di_ingresso
:etichetta_di_uscita
I due modelli sintattici mostrano due esempi di cicli iterativi. Nel primo caso si verifica una
condizione, in base alla quale si decide se proseguire o se terminare il ciclo; nel secondo si
esegue una volta il ciclo e quindi si verifica una condizione per decidere se ripeterlo o se uscire.
361.4 Comandi utili negli script
Alcuni comandi sono particolarmente utili all’interno di script dell’interprete dei comandi.
Vengono descritti brevemente nelle sezioni seguenti.
361.4.1 REM
REM commento
I commenti negli script dell’interprete dei comandi si indicano attraverso un comando apposito:
‘REM’. Il funzionamento è evidente: tutto quello che segue il comando, fino alla fine della riga,
viene ignorato.
Alcune edizioni del Dos hanno introdotto anche l’uso del punto e virgola, come simbolo per
indicare l’inizio di un commento. Segue un esempio tipico di utilizzo di questo comando:
REM
REM (c) 2000 Pinco pallino
REM
361.4.2 ECHO
ECHO [ON|OFF]
ECHO stringa
Il comando interno ‘ECHO’ ha un significato duplice: da una parte consente di visualizzare un testo;
dall’altra controlla la visualizzazione dei comandi contenuti in uno script. Infatti, si distingue
il fatto che l’eco dei comandi sia attivo o meno. utilizzando il comando ‘ECHO’ senza argomenti,
si ottiene l’informazione sul suo stato di attivazione. Di solito si disattiva l’eco dei comandi negli
script.

Dos: script dell’interprete dei comandi 119
Per disattivare l’eco di un comando particolare, senza disattivare l’eco in generale, basta
inserire inizialmente il simbolo ‘@’.
Segue la descrizione di alcuni esempi.
• @ECHO OFF
Disattiva l’eco dei comandi, facendo in modo che anche questo comando non venga
visualizzato (si usa per questo il simbolo ‘@’).
• ECHO Premi un tasto per continuare
Mostra un messaggio per spiegare come comportarsi.
361.4.3 PAUSE
PAUSE
Il comando interno ‘PAUSE’ sospende l’esecuzione di uno script in attesa della pressione di un
tasto. Il comando emette attraverso lo standard output un messaggio di avvertimento in tal senso.
Di solito, per evitare di vedere tale messaggio, si ridirige lo standard output in un file nullo.
L’esempio seguente, prima mostra un messaggio in cui si avverte che per proseguire occorre
premere un tasto, quindi si usa il comando ‘PAUSE’ che sospende l’esecuzione dello script, senza
però mostrare altri messaggi:
ECHO Premere un tasto per proseguire
PAUSE > C:\NULL
361.4.4 CLS
CLS
Il comando interno ‘CLS’ ripulisce lo schermo. Si utilizza senza argomenti.
361.4.5 CHOICE
CHOICE [opzioni] [testo_di_invito]
Il comando ‘CHOICE’ serve a presentare una richiesta per l’inserimento di una lettera, tra un elenco
determinato. La pressione del tasto corrispondente alla lettera scelta, da parte dell’utilizzatore,
provoca la conclusione del funzionamento di ‘CHOICE’ che restituisce un valore corrispondente
alla scelta: zero per la prima lettera, uno per la seconda,...
Si osservi che l’ultimo argomento rappresenta un messaggio che serve all’utente per comprendere
il senso della scelta che sta facendo.

120 volume VIII Argomenti avanzati e accessori
Tabella 361.1. Alcune opzioni.
Opzione Descrizione
Permette di fissare l’elenco di lettere che possono essere usate
/C:lettera[lettera...]
nella risposta. Se non si indica questa opzione, la scelta sarà
solo tra ‘y’ e ‘n’.
Questa opzione fa in modo di escludere la visualizzazione
delle lettere che possono essere scelte. In questo modo si fa
/N
affidamento esclusivamente sul testo indicato come ultimo
argomento.
Distingue tra maiuscole e minuscole per quanto riguarda le
/S
lettere tra cui scegliere.
L’esempio seguente, salta a un punto differente dello script in base alla scelta di una lettera da «a»
a «f». Si osservi che non sarebbe possibile eseguire l’analisi secondo una sequenza differente,
perché ‘IF ERRORLEVEL’ prende in considerazione tutti i valori di uscita maggiori o uguali a
quanto indicato nella condizione.
CHOICE /C:abcdef Inserisci una lettera
IF ERRORLEVEL 5 GOTO :f
IF ERRORLEVEL 4 GOTO :e
IF ERRORLEVEL 3 GOTO :d
IF ERRORLEVEL 2 GOTO :c
IF ERRORLEVEL 1 GOTO :b
IF ERRORLEVEL 0 GOTO :a
...
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Dos: gestione della memoria centrale
Capitolo 362
Quando è nato il Dos non si prevedeva l’uso di memoria centrale oltre il singolo mebibyte (1 Mibyte).
In base a questa considerazione veniva articolata l’architettura hardware degli elaboratori
«XT» e poi «AT», dove si prevedeva l’uso di un massimo di 640 Kibyte di memoria centrale,
riservando la parte successiva, fino alla fine di 1 Mibyte, per la memoria video e altri dispositivi
fisici.
In questo senso, il Dos tradizionale può operare con un massimo di 640 Kibyte di memoria
centrale; per sfruttarne di più occorrono degli accorgimenti non facili da applicare.
362.1 Gestione particolare
Per sfruttare la memoria oltre il primo mebibyte, si fa uso normalmente di due programmi, avviati
attraverso ‘CONFIG.SYS’, prima ancora dell’interprete di comandi. Si tratta di ‘HIMEM.SYS’ e di
‘EMM386.EXE’. In generale, le cose si fanno nel modo seguente:
DEVICE=C:\DOS\HIMEM.SYS
DEVICE=C:\DOS\EMM386.EXE
Il primo dei due programmi può essere utilizzato a partire da architetture i286, mentre il secondo
si può inserire solo a partire da architetture i386.
‘HIMEM.SYS’ è in grado di utilizzare solo una piccola parte di memoria aggiuntiva, mentre
‘EMM386.EXE’ permette teoricamente di sfruttare tutto il resto.
In generale, è molto difficile la gestione ottimale della memoria centrale, perché le applicazioni
si comportano in maniera differente. Di solito si possono solo fare dei tentativi.
362.2 Comandi appositi
Per sfruttare la memoria centrale che supera la soglia convenzionale, sono disponibili alcuni comandi
specifici. In generale, si comincia dalla configurazione con il file ‘CONFIG.SYS’: dopo
l’attivazione dei gestori speciali della memoria, è possibile indicare di collocare parte dell’interprete
dei comandi e dello spazio richiesto dai programmi residenti in memoria, oltre il limite
della memoria convenzionale:
DOS=HIGH,UMB
In seguito, sempre nell’ambito del file ‘CONFIG.SYS’, si può richiedere esplicitamente l’avvio di
programmi nella memoria alta attraverso la direttiva ‘DEVICEHIGH’, come si vede nell’esempio
seguente:
DEVICEHIGH=C:\MOUSE\MOUSE.SYS /2
Per quanto riguarda i programmi avviati attraverso l’interprete dei comandi, è disponibile il
comando ‘LH’, ovvero ‘LOADHIGH’:
LH programma [argomenti_del_programma]
LOADHIGH programma [argomenti_del_programma]
Per esempio, si potrebbe tentare di avviare in questo modo il programma di gestione della tastiera:
C:\>LH KEYB IT
121

122 volume VIII Argomenti avanzati e accessori
362.3 Verifica
Il Dos offre un solo programma molto semplice per la verifica dell’utilizzo della memoria: ‘MEM’.
MEM [opzioni]
Se ‘MEM’ viene usato senza opzioni, visualizza brevemente la quantità di memoria utilizzata rispetto
al totale disponibile. È interessante l’opzione ‘/CLASSIFY’, attraverso la quale è possibile
distinguere l’utilizzo della memoria da parte dei programmi residenti; inoltre è interessante
l’opzione ‘/FREE’, con cui si hanno informazioni dettagliate sulla memoria libera.
Le opzioni disponibili del comando ‘MEM’ variano molto da una realizzazione all’altra. In
generale conviene verificare prima di utilizzarlo, per conoscere le possibilità effettive.
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

FreeDOS
Capitolo 363
FreeDOS è il nome di un progetto per la realizzazione di un sistema operativo libero compatibile
con il Dos. Il Dos, per quanto limitato, ha delle caratteristiche che lo possono rendere ancora
interessante per elaboratori con architettura i86 particolarmente poveri di risorse, come nel caso
dei sistemi cosiddetti embedded.
363.1 Installazione
L’installazione della distribuzione standard di FreeDOS è abbastanza semplice. Si parte da un dischetto
di avvio, con il quale si predispone la partizione e la si inizializza, quindi si prosegue con
il programma di installazione che chiede l’inserimento dei dischetti successivi. La riproduzione
del dischetto di avvio a partire dalla sua immagine avviene come al solito attraverso il programma
‘RAWRITE.EXE’, oppure per mezzo di un sistema Unix nei modi già mostrati per GNU/Linux
e altri sistemi simili.
C:\>RAWRITE FULL.BIN A:
L’esempio mostra l’uso di ‘RAWRITE.EXE’ per ottenere un dischetto dall’immagine
rappresentata dal file ‘FULL.BIN’.
La distribuzione standard di FreeDOS si compone di un file-immagine del dischetto di avvio,
che potrebbe chiamarsi ‘FULL.BIN’, e da una serie di file con estensione ‘.ZIP’ che servono
per ottenere i dischetti successivi. Ognuno di questi file compressi rappresenta il contenuto di un
dischetto, che quindi deve essere prima estratto:
C:\>A:
A:\>UNZIP C:\TMP\BASE1.ZIP
L’esempio mostra in breve il procedimento: ci si sposta nell’unità ‘A:’ e da lì si estrae il file
compresso che probabilmente si trova da qualche parte nel disco fisso.
Questi file compressi rappresentano una raccolta di applicativi e hanno una struttura particolare
che viene descritta nel seguito.
• nome_raccolta.1
L’archivio compresso deve contenere un file che rappresenta il nome della raccolta, con
un’estensione numerica. La raccolta potrebbe essere suddivisa in più archivi ed è per questo
che si usa l’estensione numerica, che indica il numero di sequenza dell’archivio nell’ambito
della raccolta.
Il file contiene l’elenco dei pacchetti contenuti, con l’indicazione dell’opzione di installazione
predefinita o meno. Si osservi l’estratto seguente (la lettera «Y» rappresenta la
conferma all’installazione predefinita):
asgn14x: Y
attr063x: Y
bwb210x: Y
choic20x: Y
• nome_raccolta.END
Si tratta di un file vuoto, che rappresenta la conclusione della raccolta, nel senso che non ci
sono altri dischetti ulteriori.
123

124 volume VIII Argomenti avanzati e accessori
• nome_pacchetto.LSM
Si tratta di un file che descrive un pacchetto applicativo. Quello che segue è l’esempio del
contenuto del file ‘DELTR10X.LSM’:
Begin3
Title: deltree
Version: 1.02b
Entered-date: 27 Jul 1999
Description: Delete a directory and all directories under it
Keywords: freedos delete
Author: raster@highfiber.com
Maintained-by: raster@highfiber.com
Primary-site: http://www.highfiber.com/~raster/freeware.htm
Alternate-site: www.freedos.org
Original-site: http://www.highfiber.com/~raster/freeware.htm
Platforms: dos
Copying-policy: GPL
End
• nome_pacchetto.ZIP
Si tratta dell’archivio compresso che contiene i file dell’applicativo. In base alla struttura
standard di FreeDOS, potrebbe distribuirsi nelle directory ‘BIN\’, ‘DOC\’ e ‘HELP\’.
Dopo aver preparato i dischetti, si può procedere con l’avvio del sistema attraverso il dischetto
di avvio; quindi si passa a predisporre la partizione:
A:\>FDISK
Purtroppo, il kernel di FreeDOS non è in grado di gestire partizioni più grandi di 512 Mibyte,
per cui occorre tenerne conto durante l’uso di ‘FDISK’. Dopo aver preparato la partizione la si
inizializza:
A:\>FORMAT C: /U
Successivamente si trasferisce il sistema, con il comando ‘SYS’:
A:\>SYS C:
Infine si avvia il programma di installazione che provvederà a chiedere la sostituzione dei
dischetti:
A:\>INSTALL
363.2 Impostazione e configurazione
Da quanto è stato descritto sull’installazione di FreeDOS si intende che, pur trattandosi di un
sistema Dos, si cerca di introdurre qualche buona idea proveniente da Unix. In particolare, è
prevista una struttura per la collocazione dei file:
• ‘BIN\’ per contenere i file eseguibili;
• ‘DOC\’ per contenere la documentazione che si articola in altre sottodirectory successive,
come avviene con GNU/Linux
• ‘HELP\’ per contenere i file della guida interna relativa.

FreeDOS 125
Questa struttura potrebbe essere collocata anche a partire da un punto differente della radice
dell’unità, in base alle scelte fatte in fase di installazione. In ogni caso, occorre poi predisporre
coerentemente alcune variabili di ambiente: ‘PAGER’ per indicare il programma da utilizzare per
lo scorrimento dei file delle guide; ‘HELPPATH’ per indicare la directory contenente i file delle
guide; ‘EMACS’ per indicare la directory contenente i file di Emacs.
In condizioni normali, gli applicativi FreeDOS vengono installati a partire dalla directory
‘\FDOS\’, per cui la configurazione si traduce nelle istruzioni seguenti nel file ‘AUTOEXEC.BAT’:
SET PAGER=MORE
SET HELPPATH=C:\FDOS\HELP
SET EMACS=C:\FDOS\EMACS\
In base alla documentazione originale, nel caso della variabile di ambiente ‘EMACS’ deve essere
indicata la barra obliqua inversa finale.
A seconda della distribuzione di FreeDOS, può darsi che il file ‘CONFIG.SYS’ debba essere
sostituito con uno avente un nome differente. Potrebbe trattarsi del file ‘FDCONFIG.SYS’.
363.3 RxDOS
RxDOS è un altro progetto analogo a FreeDOS, scritto in maniera indipendente. È provvisto di
un proprio interprete dei comandi e non ha ancora un suo sistema di installazione. Per provare il
funzionamento di RxDOS ci si può avvalere solo di un dischetto, realizzato nel modo seguente:
1. si inizializza il dischetto in qualche modo, assicurando che alla fine sia disponibile un
file system Dos-FAT; 1
2. si esegue lo script ‘MAKEBOOT.BAT’, il cui scopo è la predisposizione del settore di avvio
nel dischetto;
3. si copiano ordinatamente nel dischetto i file elencati qui sotto.
• ‘RXDOSBIO.SYS’
• ‘RXDOS.SYS’
• ‘RXDOSCMD.EXE’
• ‘RXDVDISK.SYS’
• ‘AUTOEXEC.DEF’
• ‘CONFIG.DEF’
363.4 Riferimenti
• FreeDOS
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org
1 Il dischetto non deve avere l’etichetta, ovvero non deve avere un nome.

Progetto GNUish
Capitolo 364
Il progetto «GNUish» è una sorta di derivazione povera del progetto GNU, con lo scopo di
rendere disponibile parte del software che compone il sistema GNU anche nei sistemi Dos. Il
progetto ha un’importanza molto piccola, ma viene ancora mantenuto. Evidentemente, date le
peculiarità dei sistemi Dos, il software che viene adattato non può avere le stesse potenzialità che
ha invece in un sistema Unix.
I siti principali da cui si può ottenere copia del materiale prodotto dal progetto GNUish sono
quelli elencati all’interno dal documento seguente:
•
In questo capitolo viene mostrato il funzionamento di alcuni programmi, nell’ambito del sistema
Dos, per i quali è il caso di spendere qualche parola.
364.1 Programmi di servizio vari
Molti dei programmi di servizio del progetto GNU sono disponibili anche per Dos. Tuttavia, è il
caso di osservare alcune particolarità che possono confondere chi è abituato a usare sistemi Dos.
La prima cosa da notare è il fatto che i percorsi si possono indicare secondo lo stile Unix,
utilizzando barre oblique normali. Per esempio:
C:\>MV C:/PRIMO/SECONDO C:/TERZO
Diversamente, utilizzando lo stesso comando, ma secondo l’indicazione tipica del Dos, la cosa
può funzionare ugualmente, oppure si possono presentare delle segnalazioni di errore. Bisogna
tenere presente la possibilità.
Un’altra cosa da notare è l’uso dei caratteri jolly, che con questi programmi segue la logica
di Unix, dove l’asterisco indica qualunque nome, senza trattare in modo speciale il punto di
separazione dell’estensione:
C:\>CP C:/PRIMO/SECONDO/* C:/TERZO
L’esempio mostra proprio questo fatto: vengono copiati tutti i file contenuti nella directory ‘C:\
PRIMO\SECONDO\’, nella directory ‘C:\TERZO\’.
364.2 Gnuplot
Il funzionamento generale di Gnuplot è descritto nel capitolo 337. Per funzionare, questa edizione
di Gnuplot richiede due file: ‘GNUPLOT.EXE’ e ‘GNUPLOT.GIH’. Il primo dei due è l’eseguibile in
grado di gestire la grafica VGA, mentre il secondo contiene le informazioni della guida interna.
Se si vuole accedere alla guida interna, è necessario che il file ‘GNUPLOT.GIH’ si trovi nella
directory corrente. Forse è sufficiente utilizzare il comando ‘APPEND’ del Dos per risolvere il
problema.
126

Progetto GNUish 127
364.3 Spreadsheet Calculator
Il funzionamento generale di SC (Spreadsheet Calculator) è descritto nel capitolo 336. La versione
per Dos funziona correttamente (è sufficiente disporre dell’eseguibile ‘SC.EXE’), riconoscendo
anche l’uso dei tasti freccia, per cui non si è più costretti a utilizzare le lettere ‘h’, ‘j’, ‘k’ e
‘l’.
364.4 Ispell
Ispell è descritto in generale nel capitolo 273. Questa edizione di Ispell richiede due file:
‘ISPELL.EXE’ e ‘ISPELL.DIC’. Come si intuisce, il primo è l’eseguibile, mentre il secondo
è il file del dizionario. Purtroppo, il file ‘ISPELL.DIC’ non è sostituibile o eliminabile; l’unica
cosa che si può fare è predisporre un dizionario personalizzato che si richiama con l’opzione
‘-p’.
ISPELL [-d dizionario_standard] [-p dizionario_personale] file
Quella che si vede è la sintassi essenziale su cui si può contare nell’edizione di Ispell per Dos. Il
file del dizionario standard, ‘ISPELL.DIC’, può essere collocato nella stessa directory in cui si
trova il file eseguibile; altrimenti si deve usare l’opzione ‘-d’ per indicarlo esplicitamente.
Il dizionario personale è un file di testo normale (Dos), che può anche essere creato inizialmente
dallo stesso Ispell. L’esempio seguente, mostra il caso in cui si voglia analizzare il file
‘LETTERA.TXT’ attraverso il dizionario standard e il dizionario personale ‘VOCAB.TXT’. Se il
file ‘VOCAB.TXT’ non dovesse esistere, verrebbe creato per l’occasione.
C:\LETTERE>ISPELL -p VOCAB.TXT LETTERA.TXT
364.5 Perl
Perl è un linguaggio di programmazione descritto in generale a partire dal capitolo 299. L’edizione
Dos dell’interprete Perl richiede due file: ‘PERL.EXE’ e ‘PERLGLOB.EXE’. È sufficiente che
questi siano disponibili nei percorsi degli eseguibili della variabile di ambiente ‘PATH’.
Bisogna tenere a mente che si tratta di una versione molto vecchia del linguaggio, per cui alcune
novità non saranno disponibili. Inoltre, l’avvio dei programmi può avvenire solo richiamando
direttamente l’interprete:
C:\ESERCIZI>PERL FATT.PL 5
L’esempio mostra l’avvio del programma Perl contenuto nel file ‘FATT.PL’, che riceve un
argomento costituito dal numero cinque.
364.6 Riferimenti
• François Pinard, GNUish MSDOS Project
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

The valuable DOS Freeware page
Links to valuable free Dos programs working on low equipped computers.
Chapter 365
This material appeared originally at ‘http://www.geocities.com/SiliconValley/
7737/’, in 1996. Now it is incorporated inside the Italian document ‘‘Appunti
di informatica libera’’, and it might be reached at the URI .
Questo materiale è apparso in origine, nel 1996, presso ‘http://www.geocities.com/
SiliconValley/7737/’. Adesso viene incorporato nel documento «Appunti di
informatica libera» e può essere raggiunto attraverso l’URI . L’intento dell’autore è solo quello di continuare a curare
un vecchio lavoro che potrebbe essere ancora utile, nonostante si tratti di riferimenti a
software in parte libero e in parte solo gratuito, oltre che evidentemente obsoleto.
365.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
365.2 OS and GUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
365.3 Utility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
365.4 Network . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
365.5 Compilers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
365.6 Typesetting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
365.7 More Dos software sources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
365.8 Search engines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
365.1 Introduction
The Dos operating system meant much for many people. Today, proprietary Dos-like operating
systems seem to be no more developed. In this situation, the only possible future for Dos is the
‘‘free’’ software, and it is not just a matter of money anymore.
Unfortunately, ‘‘free’’ is a word with many meanings. Today, this is still the biggest obstacle to
the future of the Dos world. There is so much software for Dos, with so many different license
agreements. The typical Dos user doesn’t mind to it. But this problem prevents the realization of
big serious projects based on it.
Today, the Dos world needs philosophy, and the GNU idea is still the right one ().
The author of this space would like to list here only ‘‘free software’’ in the sense stated by the
Free Software Foundation, but it is impossible, as there isn’t enough good real free software for
Dos.
The listed software is meant to work on i286 and below.
It is attempted to give some kind of classification about the legal condition of the software presented
here. The definition used might be outdated, or there might be other wrong assumption.
128

The valuable DOS Freeware page 129
In particular, the definition ‘‘public domain’’ means here, in most cases, that there is the source,
but there is no clear license statement.
Beside the URI links of some FTP services there is an additional ‘‘search link’’ that queries a
FTP search engine for the same file. These additional links should be used when there are troubles
with the main links.
Anyone can link this document anywhere, so, there is no need to ask for it. Anyway, it is better to
link to this document using at the file name .
In the future, many links may disappear on this page, because of more selective choices
concerning software license.
365.2 OS and GUI
• FreeDOS 1
• FreeGEM 2
365.3 Utility
archive, backup
• Gzip 3 - ‘.GZ’ archive compressor and extractor.
• TAR 4 - portable TAR - DOS/UNIX backup, compressor, with hardware
support.
• Untgz 5 - ‘.TGZ’, ‘.TAR’, ‘.GZ’, ‘.ZIP’ file extractor.
• Info-ZIP 6 - ‘.ZIP’ compatible compression and extraction utility.
• Restaur 7 - Replacement for Dos Restore,
communication
• DosFax 8 - Send a fax using Dos command line
• Bgfax 9
• Rifs 10 - Disk sharing over a serial line,
1
FreeDOS GNU GPL
2
FreeGEM GNU GPL
3
Gzip GNU GPL
4
TAR (Dos) public domain
5
Untgz GNU GPL
6
Info-ZIP free software with special license
7
Restaur cannot be sold for profit
8
DosFax public domain
9
Bgfax promised to become free software
10
Rifs cannot be sold for profit

130 volume VIII Argomenti avanzati e accessori
directory, file
disk
help
shell
system
text
See also:
• WCD 11 - Powerful chdir for Dos and Unix
• Fips 12 - Non-destructive splitting of hard disk partitions
• Part 13 - MBR partition manager
• NG_clone 14 - Norton Guides clone
• DC 15 - The Dos Controller - A Norton Commander clone
• Cmos 16 - Save/Restore extended C/MOS
• KGB 17 - Utility to monitor some Dos functions and reporting into a
log file
• Vim 18 - VI improved, a small text editor that can handle very big files with low
RAM
• Richard L. Green, Free software for Dos
365.4 Network
packet driver
11
WCD GNU GPL
12
Fips GNU GPL
13
Part public domain
14
NG_clone public domain
15
DC public domain (no license at all, and no sources)
16
Cmos public domain
17
KGB public domain
18
Vim free software with special license

The valuable DOS Freeware page 131
TCP/IP
See also:
• PC/TCP Packet Driver Collection 19
• WATTCP 20 - TCP/IP library routines
• DOS PPPD 21 - Dos port of Linux PPP packet driver
• Comring 22 - packet driver emulating ethernet over serial link(s)
• WATTCP apps 23 - some common client application using WATTCP library
• MiniTelnet 24 - TELNET client
• Bobcat 25 - Text based web browser (derived
from DosLynx, )
• PCroute 26 - IP routing program for IBM PC
• PPRD 27 - Turn a dedicated PC (XT/AT) into a LPD server
• NCSA Telnet 28 - Telnet, Ftp,... NCSA
• NOS (KA9Q) 29 - A complete mini TCP/IP system
To use NOS you need documentation, for example the package
• SSHDOS 30 - SSH client for Dos
• Talk 31 - Talk client for Dos
• ABC-nslookup 32 - DNS query clients for Dos
• Marc S. Ressl, Dos Internet Pages
• Smash-Co Communications, TCP/IP for MS-DOS
19
Crynwr packet driver collection GNU GPL
20
WATTCP free of charge library
21
DOS PPPD mixed licenses
22
Comring GNU GPL
23
WATTCP apps cannot be sold
24
MiniTelnet free software with a special license
25
Bobcat GNU GPL
26
PCroute cannot distribute modifications
27
PPRD software non libero: licenza Artistic
28
NCSA Telnet public domain
29
NOS public domain
30
SSHDOS GNU GPL
31
Talk GNU GPL
32
ABC-nslookup UCB BSD

132 volume VIII Argomenti avanzati e accessori
• The U-M Software Archive
365.5 Compilers
assembler
batch
C/C++
Perl
Rexx
xBase
See also:
See the FreeDOS project () for assembler compilers.
• BAT2EXE 33 - Compile batch files for speed
See the FreeDOS project () for C and C++ compilers.
Perl 34 - Practical Extraction Report Language
• BREXX 35 - Rexx interpreter for Dos/Unix
• nanoBase 36 - Mini, but nearly complete xBase
• David Muir Shamoff, Catalog of free compilers and interpreters
365.6 Typesetting
• Nro 37 - A Nroff implementation for Dos
• Ghostscript 38 - ‘‘GNU’’ original edition - PostScript previewing, conversion, and printing
• emTeX 39 - TeX-LaTeX distribution for Dos
33 BAT2EXE public domain
34 Perl GNU GPL or Artistic
35 BREXX public domain
36 nanoBase GNU GPL
37 Nro public domain
38 Ghostscript GNU GPL
39 emTeX LPPL but some files have different conditions

The valuable DOS Freeware page 133
365.7 More Dos software sources
•
•
365.8 Search engines
•
•
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Clean the Clipper 5.2
Chapter 366
A different way to program using Clipper 5.2 without commands, that is, without the file
‘STD.CH’.
This material appeared originally at ‘http://www.geocities.com/SiliconValley/
7737/clipper52clean.html’, in 1996. Now it is incorporated inside the Italian document
‘‘Appunti di informatica libera’’, and might be reached at the URI .
Questo materiale è apparso in origine, nel 1996, presso ‘http://www.geocities.com/
SiliconValley/7737/clipper52clean.html’. Adesso viene incorporato nel documento
«Appunti di informatica libera» e può essere raggiunto attraverso l’URI . L’intento dell’autore è solo quello di conservare un
vecchio lavoro che potrebbe essere ancora utile, nonostante si tratti di considerazioni su un
compilatore proprietario, ormai obsoleto.
366.1 Step 1: try to compile with the /P parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
366.2 Step 2: understand well the use of code blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .136
366.3 Step 3: understand the object programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
366.3.1 Classes and methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .137
366.3.2 Class definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
366.3.3 Object creation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .137
366.3.4 Instantiating an object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
366.3.5 The ‘‘send’’ symbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
366.3.6 More about objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
366.4 Step 4: understand the get object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
366.5 Step 5: trying to stop using commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
366.5.1 ?/?? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
366.5.2 @...BOX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
366.5.3 @...GET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .141
366.5.4 @...SAY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
366.5.5 @...TO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
366.5.6 APPEND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
366.5.7 APPEND FROM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
366.5.8 CLEAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
366.5.9 CLOSE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
366.5.10 COMMIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
366.5.11 CONTINUE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
366.5.12 COPY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
366.5.13 COUNT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .143
366.5.14 CREATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
134

Clean the Clipper 5.2 135
366.5.15 DEFAULT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .144
366.5.16 DELETE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
366.5.17 EJECT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
366.5.18 ERASE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
366.5.19 FIND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
366.5.20 GO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
366.5.21 INDEX ON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
366.5.22 JOIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
366.5.23 KEYBOARD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
366.5.24 LABEL FORM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
366.5.25 LIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .145
366.5.26 LOCATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
366.5.27 PACK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .146
366.5.28 QUIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
366.5.29 READ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
366.5.30 RECALL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .146
366.5.31 REINDEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
366.5.32 RELEASE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
366.5.33 RENAME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
366.5.34 REPLACE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
366.5.35 REPORT FORM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
366.5.36 RESTORE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
366.5.37 RESTORE FROM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
366.5.38 RUN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
366.5.39 SAVE SCREEN TO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
366.5.40 SAVE TO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
366.5.41 SEEK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
366.5.42 SELECT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
366.5.43 SET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
366.5.44 SKIP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
366.5.45 SORT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
366.5.46 STORE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
366.5.47 SUM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
366.5.48 TOTAL ON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
366.5.49 UNLOCK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
366.5.50 UPDATE FROM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
366.5.51 USE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
366.5.52 ZAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
366.6 Step 6: free yourself from STD.CH - /U . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
366.7 Step 7: take control over all include files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

136 volume VIII Argomenti avanzati e accessori
Clipper 5.2, as the xBase tradition imposes, is not an ordered, clear, simple programming language.
The question is: which is the right way to write a Clipper program? If the intention is not
to make a xBase program, but a Clipper program, maybe it can be decided that it is better to use
Clipper without commands.
366.1 Step 1: try to compile with the /P parameter
Supposing to compile the file ‘TEST.PRG’ this way:
C:\>CLIPPER TEST.PRG /P
It generates a preprocessed output file (‘test.PPO’), that is a source file without comments,
where commands are translated into real Clipper instructions. That is, all the ‘#COMMAND’ substitution
are executed and the translation is sent to the ‘.PPO’ file. It may be difficult to read this
file the first time.
366.2 Step 2: understand well the use of code blocks
The code block is a small piece of executable program code that can be stored inside a variable,
or can be used as a literal constant. The good of it, is that pieces of code may be sent to functions.
A code block is something like a little user defined function where only a sequence of expressions
(functions and/or assignments) may appear: no loops, no conditional structures.
A code block may receive arguments and return a value after execution, just like a function. The
syntax is the following, where curly brackets are part of the code block:
{ | [argument_list] | exp_list }
That is: the argument_list is optional; the exp_list may contain one or more expressions separated
with a comma.
For example, calling the following code block will give the string ‘‘hello world’’ as result.
{ || "hello world" }
The following code block requires a numeric argument and returns the number passed as argument
incremented:
{ | n | n+1 }
The following code block requires two numeric arguments and returns the sum of the two square
radix:
{ | nFirst, nSecond | SQRT(nFirst) + SQRT(nSecond) }
But code blocks may contain more expressions and the result of the execution of the code block
is the result of the last expression. The following code block executes in sequence some functions
and gives ‘‘hello world’’ as a result.
{ | a, b | functionOne(a), functionTwo(b), "hello world" }
To start the execution of a code block a function is used: ‘EVAL()’. For example, a code block is
assigned to a variable and then executed.
B := { || "hello world" }
EVAL( B ) == "hello world"

Clean the Clipper 5.2 137
Another example with one parameter.
B := { | n | n+1 }
EVAL( B, 1 ) == 2
Another example with two parameters.
B := { | nFirst, nSecond | SQRT(nFirst) + SQRT(nSecond) }
EVAL( B, 2, 4 ) == 20
And so on.
366.3 Step 3: understand the object programming
Clipper 5.2 do not permit to create objects, but it gives some good objects to use: ‘GET’ and
‘TBROWSE’. Before starting to clean programming from commands, it is necessary to understand
how to use well the Clipper objects.
366.3.1 Classes and methods
A class defines the structure of a ‘‘black box’’, that is a data container; a method is an action
to make on a piece of data contained inside the black box. There is no way to reach the data
contained inside the black box without a method.
The black box can be called object.
The methods may be seen as they where special functions which interact with a specific piece of
data contained inside the object.
366.3.2 Class definition
Supposing that Clipper permits to define classes (unluckily only predefined classes can be used),
the hypothetical syntax could be:
CLASS ClassName [FROM ParentClass]
VAR Var1 [,Var2[,...VarN]]
METHOD {method_definition_1} [, ...{method_definition_n} ]
ENDCLASS
This way, the class defines a group of variables and a group of method to use with these variables.
366.3.3 Object creation
The presence of classes permits to create objects: the black boxes.
Variable_name := ClassName
This way, a variable contains (is) an object. Please note that inside Clipper, an object may be
generated also from a function, that is, a function can return an object. This way the example can
be:
Variable_name := classfunction( ... )
The next problem is to handle this object.

138 volume VIII Argomenti avanzati e accessori
366.3.4 Instantiating an object
As already stated before, methods are used to handle data contained inside an object. This is said
to be instantiating an object. Clipper permits also to handle directly (apparently without methods)
some variables contained inside objects. These are called ‘‘Exported Instance Variables’’. So, an
object can be instantiated this way:
object:exported_instance_variable := new_value
object:method()
An exported instance variable may be read and/or modified depending on the allowed access to it;
a method, inside Clipper, is something like a function with or without parameters (if parameters
are present, these are usually used to modify data inside the object), that normally returns a value.
366.3.5 The ‘‘send’’ symbol
To instantiate an object or simply to access an exported instance variable, the ‘‘send’’ symbol
(colon) is used.
366.3.6 More about objects
If this is not enough to understand objects inside Clipper, the following document should be read:
Peter M. Freese, o:Clip - An Object Oriented Extension to Clipper 5.01 1991, CyberSoft
366.4 Step 4: understand the get object
What happens with a command like the following:
@ nTop, nLeft GET Var
A get object is created containing all the necessary information for editing the variable Var at
the screen position nTop, nLeft. After that, this get object is added to a get objects array (usually
called ‘GetList’). The get objects array will contain all the get objects used during a ‘READ’.
So, what happens when a ‘READ’ command is encountered. The get objects array (‘GetList’) is
read and the editing of all get objects is executed. After that, the get objects array is cleared.
This method hides what Clipper really makes. The suggestion here is to create a ‘GET()’ function
that will substitute the ‘@...GET’ command and to use the ‘READMODAL()’ function to read the get
objects array. Here is an example of it:
function GET( aoGet, nRow, nCol, bVar, cGetPicture,
cColorString, bPreValid, bPostValid )
// declare a local get object
local oGet
// create the get object using the function GETENV()
oGet := GETENV( nRow, nCol, bVar, NIL, cGetPicture, cGetColor )
// send to the get object the pre-validation condition code block (WHEN)
oGet:preBlock := bPreValid

Clean the Clipper 5.2 139
// send to the get object the post-validation condition code block (VALID)
oGet:postBlock := bPostValid
// display the get on the screen using the display() method
oGet:display()
// add the get object to the get objects array
AADD( aoGet, oGet )
return NIL
• ‘aoGet’ is the get objects array (so here is explicitly passed). This get objects array is
modified (grown) and there is no need to return it as inside Clipper, arrays are always
passed by reference to functions.
• ‘nRow’ and ‘nCol’ are the screen coordinates where the get field should appear at, as it
works with the ‘@...GET’ command.
• ‘bVar’ is a special code block that permits the editing of a variable. If the variable ‘Var’ is
to be edited, the code block is:
{ |x| iif( pcount() > 0, Var := x, Var }
• ‘cGetPicture’ is the picture to use: same as the ‘@...GET’ command.
• ‘cColorString’ is the color string to use: same as the ‘@...GET’ command.
• ‘bPreValid’ is a code block containing the condition that must be valid before the cursor
can reach this get field. It is equivalent to the ‘WHEN’ condition used with the ‘@...GET’
command, but it must be converted into a code block. For example, if the condition is
‘A > B’, the code block is ‘{|| A > B}’
• ‘bPostValid’ is a code block containing the condition that must be valid before the cursor
can leave this get field. It is equivalent to the ‘VALID’ condition used with the ‘@...GET’
command, but it must be converted into a code block. For example, if the condition is
‘A > B’, the code block is ‘{|| A > B}’
If there is a get function like the above one, screen I/O may be performed like the following
example:
function do_some_editing()
// define a variable to use as a get objects array
// and initialise it to the empty array
local aoGet := {}
...
...
// add a new get object to the get objects array
get(;
aoGet,;
10, 10,;
{ |x| iif( pcount() > 0, myVariable := x, myVariable },;
"@s30@",;
"gb+/b, n/w, n, n, w/n",;
{ || .T. },;
{ || .T. };
)

140 volume VIII Argomenti avanzati e accessori
...
// read the get objects array
readmodal( aoGet )
// clear the get objects array
aoGet := {}
...
return ...
If the function ‘GET()’ is not liked, the above I/O may be done as it follows:
function do_some_editing()
// define a variable to use as a get object
local aoGet
// define a variable to use as a get objects array
// and initialise it to the empty array
local aoGet := {}
...
...
// add a new get object to the get objects array
oGet :=;
GETENV(;
10, 10,;
{ |x| iif( pcount() > 0, myVariable := x, myVariable },;
NIL,;
"@s30@",;
"gb+/b, n/w, n, n, w/n",;
)
AADD( aoGet, oGet )
...
// read the get objects array
readmodal( aoGet )
// clear the get objects array
aoGet := {}
...
return ...
366.5 Step 5: trying to stop using commands
To stop using commands, it is important to understand how commands are or may be translated
into functions. Sometimes Clipper uses some undocumented functions: these are functions that
start with a underline.

Clean the Clipper 5.2 141
366.5.1 ?/??
? [exp_list]
qout([exp_list])
?? [exp_list]
qqout([exp_list])
366.5.2 @...BOX
@ nTop, nLeft, nBottom, nRight BOX cnBoxString [COLOR cColorString]
dispbox(nTop, nLeft, nBottom, nRight, [cnBoxString], [cColorString])
366.5.3 @...GET
@ nTop, nLeft GET Var [PICTURE cGetPicture] [COLOR cColorString] [WHEN lPreExpression] ←↪
↩→[VALID lPostExpression]
setpos(nTop, nLeft)
aadd( GetList, _GET_( Var, "Var", cGetPicture, [{|| lPostExpression}],←↪
↩→[{|| lPreExpression}] ):display() ) atail(GetList):colorDisp(cColorString)
This is the command substitution made automatically, but it shouldn’t be used to make clean
programs. The step 4 (366.1) suggests to create a get function.
366.5.4 @...SAY
@ nTop, nLeft SAY exp [COLOR cColorString]
devpos(nTop, nLeft)
devout(exp [, cColorString])
@ nTop, nLeft SAY exp PICTURE cSayPicture [COLOR cColorString]
devpos(nTop, nLeft)
devoutpic(exp, cSayPicture, [cColorString])
366.5.5 @...TO
@ nTop, nLeft TO nBottom, nRight DOUBLE [COLOR cColorString]
dispbox(nTop, nLeft, nBottom, nRight, 2 [,cColorString])
@ nTop, nLeft TO nBottom, nRight [COLOR cColorString]
dispbox(nTop, nLeft, nBottom, nRight, 1 [,cColorString])
@ nTop, nLeft CLEAR [TO nBottom, nRight]
scroll([nTop], [nLeft], [nBottom, nRight])
setpos(nRow, nCol)

142 volume VIII Argomenti avanzati e accessori
366.5.6 APPEND
APPEND BLANK
dbappend()
366.5.7 APPEND FROM
APPEND FROM xcFile [FIELDS idField_list] [scope] [WHILE lCondition]←↪
↩→[FOR lCondition] [VIA xcDriver]
__dbApp( cFileName, [acFields], [bForCondition], [bWhileCondition], [nNextRecords],←↪
↩→[nRecord], [lRest], [cDriver] )
APPEND FROM xcFile [FIELDS idField_list] [scope] [WHILE lCondition] [FOR lCondition]←↪
↩→DELIMITED xcDelimiter
__dbDelim( .f., cFileName, [cDelimiter], [acFields], [bForCondition], [bWhileCondition]
,←↪
↩→[nNextRecords], [nRecord], [lRest] )
APPEND FROM xcFile [FIELDS idField_list] [scope] [WHILE lCondition]←↪
↩→[FOR lCondition] SDF
__dbSDF( .f., cFileName, [acFields], [bForCondition], [bWhileCondition], [nNextRecords]
,←↪
↩→[nRecord], [lRest] )
366.5.8 CLEAR
CLEAR
Scroll()
SetPos(0,0)
ReadKill(.T.)
GetList := {}
CLEAR GETS
ReadKill(.T.)
GetList := {}
CLEAR SCREEN | CLS
Scroll()
SetPos(0,0)
366.5.9 CLOSE
CLOSE
dbCloseArea()
CLOSE idAlias
idAlias->( dbCloseArea() )
CLOSE ALTERNATE
Set(19, "")
CLOSE DATABASES
dbCloseAll()
CLOSE INDEXES
dbClearIndex()

Clean the Clipper 5.2 143
366.5.10 COMMIT
COMMIT
dbCommitAll()
366.5.11 CONTINUE
CONTINUE
__dbContinue()
366.5.12 COPY
COPY FILE xcSourceFile TO xcTargetFile|xcDevice
__CopyFile( cSourceFile, cTargetFile|cDevice )
COPY STRUCTURE [FIELDS idField_list] TO xcDatabase
__dbCopyStruct( cDatabase, [acFields] )
COPY STRUCTURE EXTENDED TO xcExtendedDatabase
__dbCopyXStruct( cExtendedDatabase )
COPY TO xcFile [FIELDS idField_list] [scope] [WHILE lCondition]←↪
↩→[FOR lCondition] [VIA xcDriver]
__dbCopy( cFileName, [acFields], [bForCondition], [bWhileCondition], [nNextRecords],←↪
↩→[nRecord], [lRest], [cDriver] )
COPY TO xcFile [FIELDS idField_list] [scope] [WHILE lCondition] [FOR lCondition]←↪
↩→DELIMITED xcDelimiter
__dbDelim( .t., cFileName, [cDelimiter], [acFields], [bForCondition], [bWhileCondition]
,←↪
↩→[nNextRecords], [nRecord], [lRest] )
COPY TO xcFile [FIELDS idField_list] [scope] [WHILE lCondition]←↪
↩→[FOR lCondition] SDF
__dbSDF( .t., cFileName, [acFields], [bForCondition], [bWhileCondition], [nNextRecords]
,←↪
↩→[nRecord], [lRest] )
366.5.13 COUNT
COUNT TO idVar [FOR lForCondition] [WHILE lWhileCondition] [NEXT nNextRecords]←↪
↩→[RECORD nRecord] [REST] [ALL]
dbeval( {||idVar:=idVar+1}, {||lForCondition}, {||lWhileCondition},←↪
↩→nNextRecords, nRecord, lRest )

144 volume VIII Argomenti avanzati e accessori
366.5.14 CREATE
CREATE xcDatabase FROM xcExtendedDatabase [NEW] [ALIAS cAlias] [VIA cDriver]
__dbCreate( cDatabase, cExtendedDatabase, [cDriver], [lNew], [cAlias] )
366.5.15 DEFAULT
DEFAULT xVar TO xDefaultValue
if xVar == NIL
xVar := xDefaultValue
end
366.5.16 DELETE
DELETE
dbDelete()
DELETE [FOR lForCondition] [WHILE lWhileCondition] [NEXT nNextRecords]←↪
↩→[RECORD nRecord] [REST] [ALL]
dbeval( {||dbDelete()}, {||lForCondition}, {||lWhileCondition},←↪
↩→nNextRecords, nRecord, lRest )
DELETE FILE xcFile
ferase( cFile )
366.5.17 EJECT
EJECT
qqout( chr(13) )
366.5.18 ERASE
ERASE xcFile
ferase( cFile )
366.5.19 FIND
FIND xcSearchString
dbSeek( cSearchString )
366.5.20 GO
GO[TO] nRecord
dbgoto(nRecord)
GO[TO] BOTTOM
dbGoBottom()
GO[TO] TOP
dbgotop()

Clean the Clipper 5.2 145
366.5.21 INDEX ON
INDEX ON expKey TO xcIndexName [UNIQUE] [FOR lForCondition]←↪
↩→[WHILE lWhileCondition] [[EVAL lEvalCondition] [EVERY nRecords]] [ASCENDING|
DESCENDING]
ordCondSet( [cForCondition], [bForCondition], , [bWhileCondition],←↪
↩→[bEvalCondition], [nRecords], RECNO(), , , , lDescending )
ordCreate( cIndexName, , cExpKey, bExpKey, lUnique )
366.5.22 JOIN
JOIN WITH xcAlias TO xcDatabase [FOR lCondition] [FIELDS idField_list]
__dbJoin( cAlias, cDatabase, [acFields], [bForCondition] )
366.5.23 KEYBOARD
KEYBOARD cString
__Keyboard( [cString] ) --> NIL
366.5.24 LABEL FORM
LABEL FORM xcLabel [TO PRINTER] [TO FILE xcFile] [NOCONSOLE] [scope]←↪
↩→[WHILE lCondition] [FOR lCondition] [SAMPLE]
__LabelForm( cLabel, [lToPrinter], [cFile], [lNoConsole],←↪
↩→[bForCondition], [bWhileCondition], [nNextRecords], [nRecord],←↪
↩→[lRest], [lSample] )
366.5.25 LIST
LIST exp_list [TO PRINTER] [TO FILE xcFile] [scope]←↪
↩→[WHILE lCondition] [FOR lCondition] [OFF]
__dbList( [lToDisplay], abListColumns, [lAll], [bForCondition], [bWhileCondition],←↪
↩→[nNextRecords], [nRecord], [lRest], [lToPrinter], [cFileName] )
366.5.26 LOCATE
LOCATE [scope] FOR lCondition [WHILE lCondition]
__dbLocate( [bForCondition], [bWhileCondition], [nNextRecords], [nRecord], [lRest] )

146 volume VIII Argomenti avanzati e accessori
366.5.27 PACK
PACK
__dbPack()
366.5.28 QUIT
QUIT
__Quit()
366.5.29 READ
READ
ReadModal(GetList)
GetList := {}
READ SAVE
ReadModal(GetList)
366.5.30 RECALL
RECALL
dbRecall()
RECALL [FOR lForCondition] [WHILE lWhileCondition] [NEXT nNextRecords]←↪
↩→[RECORD nRecord] [REST] [ALL]
dbeval( {||dbRecall()}, {||lForCondition}, {||lWhileCondition},←↪
↩→nNextRecords, nRecord, lRest )
366.5.31 REINDEX
REINDEX [EVAL lEvalCondition] [EVERY nRecords]
ordCondSet(, , , , [bEvalCondition], [nRecords], , , , , , , )
ordListRebuild()
366.5.32 RELEASE
RELEASE idMemvar
__MXRelease( "idMemvar" )
RELEASE ALL
__MRelease("*", .t.)
RELEASE ALL LIKE skeleton
__MRelease( "skeleton", .t. )
RELEASE ALL EXCEPT skeleton
__MRelease( "skeleton", .F. )

Clean the Clipper 5.2 147
366.5.33 RENAME
RENAME xcOldFile TO xcNewFile
frename( cOldFile, cNewFile )
366.5.34 REPLACE
REPLACE idField1 WITH exp1 [, idField2 WITH exp2...]←↪
↩→[FOR lForCondition] [WHILE lWhileCondition] [NEXT nNextRecords]←↪
↩→[RECORD nRecord] [REST] [ALL]
dbeval( {|| idField1 := exp1 [, idField2 := exp2...]},←↪
↩→{||lForCondition}, {||lWhileCondition}, nNextRecords,←↪
↩→nRecord, lRest )
REPLACE idField1 WITH exp1
idField1 := exp1
366.5.35 REPORT FORM
REPORT FORM xcReport [TO PRINTER] [TO FILE xcFile] [NOCONSOLE] [scope]←↪
↩→[WHILE lCondition] [FOR lCondition] [PLAIN | HEADING cHeading] [NOEJECT] ←↪
↩→[SUMMARY]
__ReportForm( cForm, [lToPrinter], [cToFile], [lNoConsole], [bForCondition], ←↪
↩→[bWhileCondition], [nNext], [nRecord], [lRest], [lPlain], [cbHeading], ←↪
↩→[lBeforeEject], [lSummary] )
366.5.36 RESTORE
RESTORE SCREEN FROM cScreen
restscreen( 0, 0, Maxrow(), Maxcol(), cScreen )
366.5.37 RESTORE FROM
RESTORE FROM xcMemFile [ADDITIVE]
__MRestore( cMemFileName, [lAdditive] )
366.5.38 RUN
RUN xcCommandLine
__Run( cCommand )

148 volume VIII Argomenti avanzati e accessori
366.5.39 SAVE SCREEN TO
SAVE SCREEN TO cScreen
cScreen := savescreen( 0, 0, maxrow(), maxcol() )
366.5.40 SAVE TO
SAVE TO xcMemFile [ALL [LIKE|EXCEPT skeleton]]
_MSave( cMemFileName, [cSkeleton], [lLike] )
366.5.41 SEEK
SEEK expSearch [SOFTSEEK]
dbSeek( expSearch [, lSoftSeek] )
366.5.42 SELECT
SELECT xnWorkArea | idAlias
dbSelectArea( nWorkArea | cIdAlias )
366.5.43 SET
Most of the ‘SET...’ commands are translated into the ‘SET()’ function that distinguishes different
modes depending on a number. As this number is difficult to handle during programming
(essentially because it is difficult to remember the meaning of it), Clipper offers the ‘SET.CH’
include file that helps with manifest constants.
#define _SET_EXACT 1
#define _SET_FIXED 2
#define _SET_DECIMALS 3
#define _SET_DATEFORMAT 4
#define _SET_EPOCH 5
#define _SET_PATH 6
#define _SET_DEFAULT 7
#define _SET_EXCLUSIVE 8
#define _SET_SOFTSEEK 9
#define _SET_UNIQUE 10
#define _SET_DELETED 11
#define _SET_CANCEL 12
#define _SET_DEBUG 13
#define _SET_TYPEAHEAD 14
#define _SET_COLOR 15
#define _SET_CURSOR 16
#define _SET_CONSOLE 17
#define _SET_ALTERNATE 18
#define _SET_ALTFILE 19
#define _SET_DEVICE 20
#define _SET_EXTRA 21
#define _SET_EXTRAFILE 22
#define _SET_PRINTER 23

Clean the Clipper 5.2 149
#define _SET_PRINTFILE 24
#define _SET_MARGIN 25
#define _SET_BELL 26
#define _SET_CONFIRM 27
#define _SET_ESCAPE 28
#define _SET_INSERT 29
#define _SET_EXIT 30
#define _SET_INTENSITY 31
#define _SET_SCOREBOARD 32
#define _SET_DELIMITERS 33
#define _SET_DELIMCHARS 34
#define _SET_WRAP 35
#define _SET_MESSAGE 36
#define _SET_MCENTER 37
#define _SET_SCROLLBREAK 38
SET ALTERNATE TO xcFile [ADDITIVE]
Set( _SET_ALTFILE, cFile, lAdditive )
SET ALTERNATE ON | OFF | xlToggle
Set( _SET_ALTERNATE, "ON" | "OFF" | lToggle )
SET BELL ON | OFF | xlToggle
Set( _SET_BELL, "ON" | "OFF" | lToggle )
SET COLOR | COLOUR TO (cColorString)
SetColor( cColorString )
SET CONFIRM ON | OFF | xlToggle
Set( _SET_CONFIRM, "ON" | "OFF" | lToggle )
SET CONSOLE ON | OFF | xlToggle
Set( _SET_CONSOLE, "ON" | "OFF" | lToggle )
SET CURSOR ON | OFF | xlToggle
SetCursor( 1 | 0 | iif( lToggle, 1, 0 ) )
SET DATE FORMAT [TO] cDateFormat
Set( _SET_DATEFORMAT, cDateFormat )
SET DECIMALS TO
Set( _SET_DECIMALS, 0 )
SET DECIMALS TO nDecimals
Set( _SET_DECIMALS, nDecimals )
SET DEFAULT TO
Set( _SET_DEFAULT, "" )
SET DEFAULT TO xcPathspec
Set( _SET_DEFAULT, cPathspec )
SET DELETED ON | OFF | xlToggle
Set( _SET_DELETED, "ON" | "OFF" | lToggle )

150 volume VIII Argomenti avanzati e accessori
SET DELIMITERS ON | OFF | xlToggle
Set( _SET_DELIMITERS, "ON" | "OFF" | lToggle )
SET DELIMITERS TO [DEFAULT]
Set( _SET_DELIMCHARS, "::" )
SET DELIMITERS TO cDelimiters
Set( _SET_DELIMCHARS, cDelimiters )
SET DEVICE TO SCREEN | PRINTER
Set( _SET_DEVICE, "SCREEN" | "PRINTER" )
SET EPOCH TO nYear
Set( _SET_EPOCH, nYear )
SET ESCAPE ON | OFF | xlToggle
Set( _SET_ESCAPE, "ON" | "OFF" | lToggle )
SET EXACT ON | OFF | xlToggle
Set( _SET_EXACT, "ON" | "OFF" | lToggle )
SET EXCLUSIVE ON | OFF | xlToggle
Set( _SET_EXCLUSIVE, "ON" | "OFF" | lToggle )
SET FILTER TO
dbclearfilter()
SET FILTER TO lCondition
dbsetfilter( bCondition, cCondition )
SET FIXED ON | OFF | xlToggle
Set( _SET_FIXED, "ON" | "OFF" | lToggle )
SET FUNCTION nFunctionKey TO cString
__SetFunction( nFunctionKey, cString )
SET INDEX TO [xcIndex [, xcIndex1... ] ]
ordListClear()
ordListAdd( cIndex )
ordListAdd( cIndex1 )
...
SET INTENSITY ON | OFF | xlToggle
Set( _SET_INTENSITY, "ON" | "OFF" | lToggle )
SET KEY nInkeyCode [TO]
SetKey( nInkeyCode, NIL )
SET KEY nInkeyCode TO [idProcedure]
SetKey( nInkeyCode, { |p, l, v| idProcedure(p, l, v)} )
SET MARGIN TO
Set( _SET_MARGIN, 0 )
SET MARGIN TO [nPageOffset]
Set( _SET_MARGIN, nPageOffset )

Clean the Clipper 5.2 151
SET MESSAGE TO
Set( _SET_MESSAGE, 0 )
Set( _SET_MCENTER, .F. )
SET MESSAGE TO [nRow [CENTER | CENTRE]]
Set( _SET_MESSAGE, nRow )
Set( _SET_MCENTER, lCenter )
SET ORDER TO [nIndex]
ordSetFocus( nIndex )
SET PATH TO
Set( _SET_PATH, "" )
SET PATH TO [xcPathspec [, cPathspec1... ] ]
Set( _SET_PATH, cPathspec [, cPathspec1... ] )
SET PRINTER ON | OFF | xlToggle
Set( _SET_PRINTER, "ON" | "OFF" | lToggle )
SET PRINTER TO
Set( _SET_PRINTFILE, "" )
SET PRINTER TO [xcDevice|xcFile [ADDITIVE]]
Set( _SET_PRINTFILE, cDevice|cFile, lAdditive )
SET RELATION TO
dbclearrelation()
SET RELATION TO [expKey1 INTO xcAlias1] [, [TO] expKey2 INTO xcAlias2...]
dbClearRel()
dbSetRelation( cAlias1, {||expKey1}, ["expKey1"] )
dbSetRelation( cAlias2, {||expKey2}, ["expKey1"] )
SET RELATION TO [expKey1 INTO xcAlias1]←↪
↩→[, [TO] expKey2 INTO xcAlias2...] ADDITIVE
dbSetRelation( cAlias1, {||expKey1}, ["expKey1"] )
dbSetRelation( cAlias2, {||expKey2}, ["expKey1"] )
SET SCOREBOARD ON | OFF | xlToggle
Set( _SET_SCOREBOARD, "ON" | "OFF" | lToggle )
SET SOFTSEEK ON | OFF | xlToggle
Set( _SET_SOFTSEEK, "ON" | "OFF" | lToggle )
SET TYPEAHEAD TO nKeyboardSise
Set( _SET_TYPEAHEAD, nKeyboardSise )
SET UNIQUE ON | OFF | xlToggle
Set( _SET_UNIQUE, "ON" | "OFF" | lToggle )
SET WRAP ON | OFF | xlToggle
Set( _SET_WRAP, "ON" | "OFF" | lToggle )

152 volume VIII Argomenti avanzati e accessori
366.5.44 SKIP
SKIP [nRecords] [ALIAS idAlias|nWorkArea]
[idAlias|nWorkArea -> ]( dbSkip([nRecords]) )
366.5.45 SORT
SORT TO xcDatabase ON idField1 [/[A|D][C]] [, idField2 [/[A|D][C]] ...]←↪
↩→[scope] [WHILE lCondition] [FOR lCondition]
__dbSort( cDatabase, [acFields], [bForCondition], [bWhileCondition],←↪
↩→[nNextRecords], [nRecord], [lRest] )
366.5.46 STORE
STORE value TO variable
variable := value
366.5.47 SUM
SUM nExp1 [, nExp2...] TO idVar1 [, idVar2...] [FOR lForCondition]←↪
↩→[WHILE lWhileCondition] [NEXT nNextRecords] [RECORD nRecord] [REST] [ALL]
dbeval( {||idVar1:=idVar1+nExp1 [, idVar2:=idVar2+nExp2...] },←↪
↩→{||lForCondition}, {||lWhileCondition}, nNextRecords, nRecord, lRest )
366.5.48 TOTAL ON
TOTAL ON expKey [FIELDS idField_list] TO xcDatabase [scope]←↪
↩→[WHILE lCondition] [FOR lCondition]
__dbTotal( cDatabase, bKey, [acFields], [bForCondition], [bWhileCondition],←↪
↩→[nNextRecords], [nRecord], [lRest] )
366.5.49 UNLOCK
UNLOCK
dbUnlock()
UNLOCK ALL
dbUnlockAll()
366.5.50 UPDATE FROM
UPDATE FROM xcAlias ON expKey [RANDOM] REPLACE idField1←↪
↩→WITH exp [, idField2 WITH exp ...]
__dbUpdate( cAlias, bKey, [lRandom], [bReplacement] )
Example:

Clean the Clipper 5.2 153
__dbUpdate( "INVOICE", {|| LAST}, .T.,; {|| FIELD->TOTAL1 := ←↪
↩→INVOICE->SUM1,; FIELD->TOTAL2 := INVOICE->SUM2 } )
366.5.51 USE
USE
dbclosearea()
USE [xcDatabase]←↪
↩→[INDEX xcIndex1 [, xcIndex2...] [ALIAS xcAlias] [EXCLUSIVE|SHARED] [NEW] ←↪
↩→[READONLY] [VIA cDriver]]
dbUseArea( [lNewArea], [cDriver], cDatabase, [cAlias], [lShared], [lReadOnly] )
[dbSetIndex( cIndex1 )]
[dbSetIndex( cIndex2 )]
...
366.5.52 ZAP
ZAP
dbZap()
366.6 Step 6: free yourself from STD.CH - /U
Now that no command is used, the standard include file ‘STD.CH’ is no more necessary. Clipper
uses ‘STD.CH’ automatically, unless specified differently. Just compile this way:
C:>CLIPPER TEST.PRG /U
366.7 Step 7: take control over all include files
Clipper comes with so many include files (‘ * .CH’). To avoid confusion, a single ‘STANDARD.CH’
file containing all what is needed for the application may be prepared. At least, it is necessary the
following.
*=================================================================
* DISPBOX()
*=================================================================
* Single-line box
#define BOX_SINGLE;
(;
CHR(218) +;
CHR(196) +;
CHR(191) +;
CHR(179) +;
CHR(217) +;
CHR(196) +;
CHR(192) +;
CHR(179);
)
* Double-line box

154 volume VIII Argomenti avanzati e accessori
#define BOX_DOUBLE;
(;
CHR(201) +;
CHR(205) +;
CHR(187) +;
CHR(186) +;
CHR(188) +;
CHR(205) +;
CHR(200) +;
CHR(186);
)
* Single-line top, double-line sides
#define BOX_SINGLE_DOUBLE;
(;
CHR(214) +;
CHR(196) +;
CHR(183) +;
CHR(186) +;
CHR(189) +;
CHR(196) +;
CHR(211) +;
CHR(186);
)
* Double-line top, single-line sides
#define BOX_DOUBLE_SINGLE;
(;
CHR(213) +;
CHR(205) +;
CHR(184) +;
CHR(179) +;
CHR(190) +;
CHR(205) +;
CHR(212) +;
CHR(179);
)
*=================================================================
* ERRORS
*=================================================================
* Severity levels (e:severity)
#define ERROR_SEVERITY_WHOCARES 0
#define ERROR_SEVERITY_WARNING 1
#define ERROR_SEVERITY_ERROR 2
#define ERROR_SEVERITY_CATASTROPHIC 3
* Generic error codes (e:genCode)
#define ERROR_GENERIC_ARG 1
#define ERROR_GENERIC_BOUND 2
#define ERROR_GENERIC_STROVERFLOW 3
#define ERROR_GENERIC_NUMOVERFLOW 4
#define ERROR_GENERIC_ZERODIV 5
#define ERROR_GENERIC_NUMERR 6
#define ERROR_GENERIC_SYNTAX 7
#define ERROR_GENERIC_COMPLEXITY 8
#define ERROR_GENERIC_MEM 11
#define ERROR_GENERIC_NOFUNC 12
#define ERROR_GENERIC_NOMETHOD 13
#define ERROR_GENERIC_NOVAR 14
#define ERROR_GENERIC_NOALIAS 15

Clean the Clipper 5.2 155
#define ERROR_GENERIC_NOVARMETHOD 16
#define ERROR_GENERIC_BADALIAS 17
#define ERROR_GENERIC_DUPALIAS 18
#define ERROR_GENERIC_CREATE 20
#define ERROR_GENERIC_OPEN 21
#define ERROR_GENERIC_CLOSE 22
#define ERROR_GENERIC_READ 23
#define ERROR_GENERIC_WRITE 24
#define ERROR_GENERIC_PRINT 25
#define ERROR_GENERIC_UNSUPPORTED 30
#define ERROR_GENERIC_LIMIT 31
#define ERROR_GENERIC_CORRUPTION 32
#define ERROR_GENERIC_DATATYPE 33
#define ERROR_GENERIC_DATAWIDTH 34
#define ERROR_GENERIC_NOTABLE 35
#define ERROR_GENERIC_NOORDER 36
#define ERROR_GENERIC_SHARED 37
#define ERROR_GENERIC_UNLOCKED 38
#define ERROR_GENERIC_READONLY 39
#define ERROR_GENERIC_APPENDLOCK 40
#define ERROR_GENERIC_LOCK 41
*=================================================================
* INKEY()
*=================================================================
#define K_UP 5 // Up arrow, Ctrl-E
#define K_DOWN 24 // Down arrow, Ctrl-X
#define K_LEFT 19 // Left arrow, Ctrl-S
#define K_RIGHT 4 // Right arrow, Ctrl-D
#define K_HOME 1 // Home, Ctrl-A
#define K_END 6 // End, Ctrl-F
#define K_PGUP 18 // PgUp, Ctrl-R
#define K_PGDN 3 // PgDn, Ctrl-C
#define K_CTRL_UP 397 // * Ctrl-Up arrow
#define K_CTRL_DOWN 401 // * Ctrl-Down arrow
#define K_CTRL_LEFT 26 // Ctrl-Left arrow, Ctrl-Z
#define K_CTRL_RIGHT 2 // Ctrl-Right arrow, Ctrl-B
#define K_CTRL_HOME 29 // Ctrl-Home, Ctrl-
#define K_CTRL_END 23 // Ctrl-End, Ctrl-W
#define K_CTRL_PGUP 31 // Ctrl-PgUp, Ctrl-Hyphen
#define K_CTRL_PGDN 30 // Ctrl-PgDn, Ctrl-^
#define K_ALT_UP 408 // * Alt-Up arrow
#define K_ALT_DOWN 416 // * Alt-Down arrow
#define K_ALT_LEFT 411 // * Alt-Left arrow
#define K_ALT_RIGHT 413 // * Alt-Right arrow
#define K_ALT_HOME 407 // * Alt-Home
#define K_ALT_END 415 // * Alt-End
#define K_ALT_PGUP 409 // * Alt-PgUp
#define K_ALT_PGDN 417 // * Alt-PgDn
#define K_ENTER 13 // Enter, Ctrl-M
#define K_RETURN 13 // Return, Ctrl-M
#define K_SPACE 32 // Space bar
#define K_ESC 27 // Esc, Ctrl-
#define K_CTRL_ENTER 10 // Ctrl-Enter
#define K_CTRL_RETURN 10 // Ctrl-Return

156 volume VIII Argomenti avanzati e accessori
#define K_CTRL_RET 10 // Ctrl-Return (Compat.)
#define K_CTRL_PRTSCR 379 // * Ctrl-Print Screen
#define K_CTRL_QUESTION 309 // Ctrl-?
#define K_ALT_ENTER 284 // * Alt-Enter
#define K_ALT_RETURN 284 // * Alt-Return
#define K_ALT_EQUALS 387 // * Alt-Equals
#define K_ALT_ESC 257 // * Alt-Esc
#define KP_ALT_ENTER 422 // * Keypad Alt-Enter
#define KP_CTRL_5 399 // * Keypad Ctrl-5
#define KP_CTRL_SLASH 405 // * Keypad Ctrl-/
#define KP_CTRL_ASTERISK 406 // * Keypad Ctrl-*
#define KP_CTRL_MINUS 398 // * Keypad Ctrl--
#define KP_CTRL_PLUS 400 // * Keypad Ctrl-+
#define KP_ALT_5 5 // * Keypad Alt-5
#define KP_ALT_SLASH 420 // * Keypad Alt-/
#define KP_ALT_ASTERISK 311 // * Keypad Alt-*
#define KP_ALT_MINUS 330 // * Keypad Alt--
#define KP_ALT_PLUS 334 // * Keypad Alt-+
#define K_INS 22 // Ins, Ctrl-V
#define K_DEL 7 // Del, Ctrl-G
#define K_BS 8 // Backspace, Ctrl-H
#define K_TAB 9 // Tab, Ctrl-I
#define K_SH_TAB 271 // Shift-Tab
#define K_CTRL_INS 402 // * Ctrl-Ins
#define K_CTRL_DEL 403 // * Ctrl-Del
#define K_CTRL_BS 127 // Ctrl-Backspace
#define K_CTRL_TAB 404 // * Ctrl-Tab
#define K_ALT_INS 418 // * Alt-Ins
#define K_ALT_DEL 419 // * Alt-Del
#define K_ALT_BS 270 // * Alt-Backspace
#define K_ALT_TAB 421 // * Alt-Tab
#define K_CTRL_A 1 // Ctrl-A, Home
#define K_CTRL_B 2 // Ctrl-B, Ctrl-Right arrow
#define K_CTRL_C 3 // Ctrl-C, PgDn, Ctrl-ScrollLock
#define K_CTRL_D 4 // Ctrl-D, Right arrow
#define K_CTRL_E 5 // Ctrl-E, Up arrow
#define K_CTRL_F 6 // Ctrl-F, End
#define K_CTRL_G 7 // Ctrl-G, Del
#define K_CTRL_H 8 // Ctrl-H, Backspace
#define K_CTRL_I 9 // Ctrl-I, Tab
#define K_CTRL_J 10 // Ctrl-J
#define K_CTRL_K 11 // Ctrl-K
#define K_CTRL_L 12 // Ctrl-L
#define K_CTRL_M 13 // Ctrl-M, Return
#define K_CTRL_N 14 // Ctrl-N
#define K_CTRL_O 15 // Ctrl-O
#define K_CTRL_P 16 // Ctrl-P
#define K_CTRL_Q 17 // Ctrl-Q
#define K_CTRL_R 18 // Ctrl-R, PgUp
#define K_CTRL_S 19 // Ctrl-S, Left arrow
#define K_CTRL_T 20 // Ctrl-T
#define K_CTRL_U 21 // Ctrl-U
#define K_CTRL_V 22 // Ctrl-V, Ins
#define K_CTRL_W 23 // Ctrl-W, Ctrl-End
#define K_CTRL_X 24 // Ctrl-X, Down arrow
#define K_CTRL_Y 25 // Ctrl-Y

Clean the Clipper 5.2 157
#define K_CTRL_Z 26 // Ctrl-Z, Ctrl-Left arrow
#define K_ALT_A 286 // Alt-A
#define K_ALT_B 304 // Alt-B
#define K_ALT_C 302 // Alt-C
#define K_ALT_D 288 // Alt-D
#define K_ALT_E 274 // Alt-E
#define K_ALT_F 289 // Alt-F
#define K_ALT_G 290 // Alt-G
#define K_ALT_H 291 // Alt-H
#define K_ALT_I 279 // Alt-I
#define K_ALT_J 292 // Alt-J
#define K_ALT_K 293 // Alt-K
#define K_ALT_L 294 // Alt-L
#define K_ALT_M 306 // Alt-M
#define K_ALT_N 305 // Alt-N
#define K_ALT_O 280 // Alt-O
#define K_ALT_P 281 // Alt-P
#define K_ALT_Q 272 // Alt-Q
#define K_ALT_R 275 // Alt-R
#define K_ALT_S 287 // Alt-S
#define K_ALT_T 276 // Alt-T
#define K_ALT_U 278 // Alt-U
#define K_ALT_V 303 // Alt-V
#define K_ALT_W 273 // Alt-W
#define K_ALT_X 301 // Alt-X
#define K_ALT_Y 277 // Alt-Y
#define K_ALT_Z 300 // Alt-Z
#define K_ALT_1 376 // Alt-1
#define K_ALT_2 377 // Alt-2
#define K_ALT_3 378 // Alt-3
#define K_ALT_4 379 // Alt-4
#define K_ALT_5 380 // Alt-5
#define K_ALT_6 381 // Alt-6
#define K_ALT_7 382 // Alt-7
#define K_ALT_8 383 // Alt-8
#define K_ALT_9 384 // Alt-9
#define K_ALT_0 385 // Alt-0
#define K_F1 28 // F1, Ctrl-Backslash
#define K_F2 -1 // F2
#define K_F3 -2 // F3
#define K_F4 -3 // F4
#define K_F5 -4 // F5
#define K_F6 -5 // F6
#define K_F7 -6 // F7
#define K_F8 -7 // F8
#define K_F9 -8 // F9
#define K_F10 -9 // F10
#define K_F11 -40 // * F11
#define K_F12 -41 // * F12
#define K_CTRL_F1 -20 // Ctrl-F1
#define K_CTRL_F2 -21 // Ctrl-F2
#define K_CTRL_F3 -22 // Ctrl-F4
#define K_CTRL_F4 -23 // Ctrl-F3
#define K_CTRL_F5 -24 // Ctrl-F5
#define K_CTRL_F6 -25 // Ctrl-F6
#define K_CTRL_F7 -26 // Ctrl-F7
#define K_CTRL_F8 -27 // Ctrl-F8
#define K_CTRL_F9 -28 // Ctrl-F9
#define K_CTRL_F10 -29 // Ctrl-F10
#define K_CTRL_F11 -44 // * Ctrl-F11
#define K_CTRL_F12 -45 // * Ctrl-F12

158 volume VIII Argomenti avanzati e accessori
#define K_ALT_F1 -30 // Alt-F1
#define K_ALT_F2 -31 // Alt-F2
#define K_ALT_F3 -32 // Alt-F3
#define K_ALT_F4 -33 // Alt-F4
#define K_ALT_F5 -34 // Alt-F5
#define K_ALT_F6 -35 // Alt-F6
#define K_ALT_F7 -36 // Alt-F7
#define K_ALT_F8 -37 // Alt-F8
#define K_ALT_F9 -38 // Alt-F9
#define K_ALT_F10 -39 // Alt-F10
#define K_ALT_F11 -46 // * Alt-F11
#define K_ALT_F12 -47 // * Alt-F12
#define K_SH_F1 -10 // Shift-F1
#define K_SH_F2 -11 // Shift-F2
#define K_SH_F3 -12 // Shift-F3
#define K_SH_F4 -13 // Shift-F4
#define K_SH_F5 -14 // Shift-F5
#define K_SH_F6 -15 // Shift-F6
#define K_SH_F7 -16 // Shift-F7
#define K_SH_F8 -17 // Shift-F8
#define K_SH_F9 -18 // Shift-F9
#define K_SH_F10 -19 // Shift-F10
#define K_SH_F11 -42 // * Shift-F11
#define K_SH_F12 -43 // * Shift-F12
*=================================================================
* MEMOEDIT()
*=================================================================
* User function entry modes
#define MEMOEDIT_IDLE 0 // idle, all keys processed
#define MEMOEDIT_UNKEY 1 // unknown key, memo unaltered
#define MEMOEDIT_UNKEYX 2 // unknown key, memo altered
#define MEMOEDIT_INIT 3 // initialization mode
* User function return codes
#define MEMOEDIT_DEFAULT 0 // perform default action
#define MEMOEDIT_IGNORE 32 // ignore unknown key
#define MEMOEDIT_DATA 33 // treat unknown key as data
#define MEMOEDIT_TOGGLEWRAP 34 // toggle word-wrap mode
#define MEMOEDIT_TOGGLESCROLL 35 // toggle scrolling mode
#define MEMOEDIT_WORDRIGHT 100 // perform word-right operation
#define MEMOEDIT_BOTTOMRIGHT 101 // perform bottom-right operation
*=================================================================
* SET()
*=================================================================
#define _SET_EXACT 1
#define _SET_FIXED 2
#define _SET_DECIMALS 3
#define _SET_DATEFORMAT 4
#define _SET_EPOCH 5
#define _SET_PATH 6
#define _SET_DEFAULT 7
#define _SET_EXCLUSIVE 8
#define _SET_SOFTSEEK 9
#define _SET_UNIQUE 10

Clean the Clipper 5.2 159
#define _SET_DELETED 11
#define _SET_CANCEL 12
#define _SET_DEBUG 13
#define _SET_TYPEAHEAD 14
#define _SET_COLOR 15
#define _SET_CURSOR 16
#define _SET_CONSOLE 17
#define _SET_ALTERNATE 18
#define _SET_ALTFILE 19
#define _SET_DEVICE 20
#define _SET_EXTRA 21
#define _SET_EXTRAFILE 22
#define _SET_PRINTER 23
#define _SET_PRINTFILE 24
#define _SET_MARGIN 25
#define _SET_BELL 26
#define _SET_CONFIRM 27
#define _SET_ESCAPE 28
#define _SET_INSERT 29
#define _SET_EXIT 30
#define _SET_INTENSITY 31
#define _SET_SCOREBOARD 32
#define _SET_DELIMITERS 33
#define _SET_DELIMCHARS 34
#define _SET_WRAP 35
#define _SET_MESSAGE 36
#define _SET_MCENTER 37
#define _SET_SCROLLBREAK 38
*=================================================================
* SETCURSOR()
*=================================================================
#define SETCURSOR_NONE 0 // No cursor
#define SETCURSOR_NORMAL 1 // Normal cursor (underline)
#define SETCURSOR_INSERT 2 // Insert cursor (lower half block)
#define SETCURSOR_SPECIAL1 3 // Special cursor (full block)
#define SETCURSOR_SPECIAL2 4 // Special cursor (upper half block)
*=================================================================
* RDD REQUESTs
*=================================================================
external dbfndx
external dbfntx // default
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

nanoBase 1997
A free xBase for Dos.
Chapter 367
This material appeared originally at ‘http://www.geocities.com/SiliconValley/
7737/nanobase.html’, in 1997. Now it is incorporated inside the Italian document
‘‘Appunti di informatica libera’’, and might be reached at the URI .
Questo materiale è apparso in origine, nel 1997, presso ‘http://www.geocities.com/
SiliconValley/7737/nanobase.html’. Adesso viene incorporato nel documento «Appunti
di informatica libera» e può essere raggiunto attraverso l’URI .
367.1 What is it
nanoBase 1 is a Dos program that works essentially as:
• a dot command line xBase,
• a menu driven xBase,
• a xBase program interpreter.
nanoBase 1997 is compiled in two versions: a small one to be used with old computers (i86 with
640 Kibyte RAM), and a second one to be used with better computers, at least i286 (or better)
with 2 Mibyte RAM.
367.2 The dot command line
Figure 367.1. The dot line.
The dot command line is the first face of nanoBase, the one that appears starting the program
normally. It recalls the dot line command of the old xBases.
Please note that nanoBase recognise only expressions (that is: no commands).
1 nanoBase GNU GPL
160

nanoBase 1997 161
367.3 The menu
Figure 367.2. The file menu.
Pressing [ F10 ] the nanoBase menu appears.
From this menu the operations are easier than writing all commands on a prompt line, but it is
always possible to come back to the dot line to do an operation not available from the menu.
367.4 The macro recording, compiling and execution
Figure 367.3. The macro menu.
nanoBase is able to record some actions made with the menu and all what is correctly typed from
the dot prompt. This may be the begin for a little program (called macro inside nanoBase) that
can be executed as it is (ASCII), or compiled into another format, faster to execute.
Macros for nanoBase are made with a reduced set of the Clipper syntax. The statements recognised
from nanoBase are:
PROCEDURE procedure_name
statements...
[RETURN]
statements...
ENDPROCEDURE

162 volume VIII Argomenti avanzati e accessori
DO PROCEDURE procedure_name
BEGIN SEQUENCE
statements...
[BREAK]
statements...
END
DO CASE
CASE lCondition1
statements...
[CASE lCondition2]
statements...
[OTHERWISE]
statements...
END
WHILE lCondition
statements...
[EXIT]
statements...
[LOOP]
statements...
END
IF lCondition1
statements...
[ELSE]
statements...
END
• the ‘FOR’ loop is not available (too difficult to implement),
• there may be no user defined functions (code blocks may be created instead),
• procedure calls cannot transfer variables,
• there are only public (global) variables.
Beside these limitations, there are many added functions to the standard language that make the
programming easier.
All you need is inside ‘NB.EXE’:
• the utility to handle manually the data,
• the macro compiler,
• the macro executor.

nanoBase 1997 163
367.5 The report system
Figure 367.4. The report menu.
nanoBase can handle label (‘.LBL’) and form (‘.FRM’) files in the dBaseIII format. Labels and
forms may be created and edited inside nanoBase. Beside these old report system there is another
way to make a little bit complicated reports without making a complex macro: it is called RPT.
A RPT file is a ASCII file with text mixed with code. The text may contain variables (usually a
field or an expression containing fields).
To make a complex report some work is needed, but surely less than the time needed to make a
report program.
The main purpose of it was to be able to print text with variables (typically names and addresses)
for every record of a particular ‘.DBF’ file. Now the RPT system makes something more.
367.6 The integrated text editor
Figure 367.5. The integrated text editor.
nanoBase contains an integrated text editor not particularly good, but very usefull for RPT files
(as the expression insertion is very easy with the use of the [ F2 ] key) and whenever there isn’t
any other editor there.

164 volume VIII Argomenti avanzati e accessori
367.7 The internal documentation
Figure 367.6. The internal documentation.
nanoBase’s documentation si translated also inside the HTF format: ‘NB.HLP’. Pressing [ F1 ],
normally, a contextual piece of the manual appears.
Some standard functions have its own internal help, contained inside the ‘.EXE’ file. This was
made to help programming with nanoBase.
367.8 Download it
Here is the 1997 edition of nanoBase.
• EXE for small computers.
• EXE for i286 with more than 2 Mibyte.
• Runtime for small computers.
• Documentation in many different formats.
• Macro programming examples.
• Source for version 96.06.16, without mouse support (1996).

nanoBase 1997 165
• Source for version 1997.
367.9 Bugs and known problems
Here is the list of known bugs and problems.
• Comparison with floating point numbers may fail. It is better to convert numbers into string
before comparing them.
• Macros may be contained inside ASCII files or a ‘‘compiled’’ ‘.DBF’ file. In the second
case, when nanoBase executes the macro, a work area (the last available one) is used, so it
should not be closed or the macro execution will be stopped. A ‘dbcloseall()’ will stop
execution of the macro. In substitution of ‘dbcloseall()’, ‘DBCLOSE()’ should be used.
• To simplify the macro interpretation, lines such as this:
qqout( "You can’t do that // you can’t do that!" )
will generate an error as the interpreter will read only:
qqout( "You can’t do that
• nanoBase works good also if you have a screen configuration that permits you to show more
than the usual 80 columns and 25 lines, but the library used to handle the mouse is not able
to work outside the 80×25 area.
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

nanoBase 1997 user manual
Chapter 368
This is the documentation of nanoBase 1997, with minor modifications, that appeared originally
at ‘http://www.geocities.com/SiliconValley/7737/nb.htm’. Now it is incorporated
inside the Italian document ‘‘Appunti di informatica libera’’, and might be reached at
the URI .
Questo è il manuale di nanoBase 1997, modificato leggermente, che è apparso inizialmente
presso ‘http://www.geocities.com/SiliconValley/7737/nb.htm’. Adesso
viene incorporato nel documento «Appunti di informatica libera» e può essere raggiunto attraverso
l’URI .
368.1 Dos xBase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
368.2 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
368.3 How to use nB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
368.4 Status line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
368.5 The dot line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
368.6 The menu system . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
368.7 The text editor DOC() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
368.8 The help text file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
368.9 Macro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
368.10 Data types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
368.11 Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .200
368.12 Delimiters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
368.13 Code blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
368.14 Standard functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
368.15 nB functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
368.16 Normal command substitution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
368.17 nB command substitution functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
368.18 RPT: the nB print function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
368.19 How can I... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
368.20 The source files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
nB (‘‘nano Base’’: ‘‘n’’ = ‘‘nano’’ = 10**(-9) = ‘‘very little’’) is a little Dos xBase written in
Clipper 5.2 that can help to access ‘.DBF’ file created with different standards.
nB is:
• a dot command interpreter,
166

nanoBase 1997 user manual 167
• a menu driven xBase,
• a xBase program interpreter.
368.1 Dos xBase
This section is a brief description of the functionality of a typical Dos xBase.
The first purpose of a xBase program is to handle data inside a ‘.DBF’ file. These files may be
indexed with the help of index files and more ‘.DBF’ files may be linked with a relation to obtain
something like a relational database.
368.1.1 .DBF files
‘.DBF’ files are files organised in a table structure:
.--------------------------.
| field1 | field2 | field3 | record1
|--------|--------|--------|
| | | | record2
|--------|--------|--------|
| | | | record3
|--------|--------|--------|
| | | | record4
|--------|--------|--------|
| | | | record5
|--------|--------|--------|
| | | | record6
‘--------------------------’
The lines of this table are records and the columns are fields. Records are numbered starting from
the first that is number 1.
Columns are defined as fields and fields are distinguished by name and these names are saved
inside the ‘.DBF’ file.
Every field (column) can contain only one specified kind of data with a specified dimension:
• ‘C’, character, originally the maximum dimension was 254 characters, minimum is 1;
• ‘N’, numeric, a numeric field that can contain also sign and decimal values;
• ‘D’, date, a field dedicated to date information;
• ‘L’, logic, a filed that may contain only ‘T’ for True or ‘F’ for False used as a boolean
variable;
• ‘M’, memo, a character field with no predefined dimension, not allocated directly inside the
‘.DBF’, but inside a ‘.DBT’ file, automatically linked.
No other field type is available for a typical xBase ‘.DBF’ file.
To access the data contained inside a ‘.DBF’ file the following list of action may be followed:
• Open a ‘.DBF’ file inside the current area, where these areas are something like file handlers.
• After the ‘.DBF’ file is opened, it referenced only by the alias name that usually correspond
to the original filename without extention.

168 volume VIII Argomenti avanzati e accessori
• Move the record pointer to the desired location.
• Lock the current record to avoid access from other users.
• Do some editing with the data contained inside the current record using the field names like
they were variables.
• Release the lock.
• Move the record pointer to another desired location.
• Lock the current record to avoid access from other users.
• ...
• Close the alias.
Before you go further, you have to understand that:
• A ‘.DBF’ file is opened using a free WORK AREA that may be associated to the concept
of the file handler.
• The ‘.DBF’ file is opened with a alias name that permit to open the same ‘.DBF’ file more
times when using different alias names.
• After the ‘.DBF’ file is opened, we don’t speak any more of file, but alias.
• If the work area "n" is used from the alias "myAlias", speaking of work area "n" or of alias
"myAlias" is the same thing.
368.1.2 Index files
‘.DBF’ files are organised with record number, that is, you can reach a specific record and not a
specific information unless that you scan record by record.
To obtain to "see" a ‘.DBF’ file somehow logically ordered (when physically it is not), index files
are used.
A index file, also called INDEX BAG, is a file that contains one or more indexes
Indexes are rules by which a ‘.DBF’ file may be seen ordered.
A typical index file may contain only one index.
A index file may have the following extention:
• ‘.NDX’, single index, dBase III and dBase III plus;
• ‘.NTX’, single index, Clipper;
• ‘.MBX’, multiple index, dBase IV;
• ‘.CDX’, multiple index, FoxPro.
Every index file may be used only in association with the ‘.DBF’ for what it was made. The
problem is that normally there is no way to avoid errors when the user try to associate the right
‘.DBF’ file with the wrong index.

nanoBase 1997 user manual 169
To access the data contained inside a ‘.DBF’ file the following list of action may be followed:
• Open a ‘.DBF’ file.
• Open a index file.
• Select a particular order.
• Search for a key or move the record pointer on a different way.
• Lock the current record to avoid access from other users.
• Do some editing with the data contained inside the current record using the field names like
they were variables.
• Release the lock.
• Move the record pointer to another desired location.
• Lock the current record to avoid access from other users.
• ...
• Close the alias.
Before you go further, you have to understand that:
• As orders are contained inside a INDEX BAG file physically distinguished form the ‘.DBF’
file, it may happen that a ‘.DBF’ file is wrongly opened and edited without the index. In
this case, the INDEX BAG is not updated and when the INDEX BAG will be opened, the
records contained inside the ‘.DBF’ file may not correspond.
• For the same reason, an improper program termination may result in an incomplete data
update. That is: ‘.DBF’ file may be all right, INDEX BAG not.
• This is why xBase programs are "weak" relational databases or they are not relational
databases at all.
• When troubles occurs, indexes must be rebuild.
368.1.3 Relations
Many ‘.DBF’ files with indexes may be opened simultaneously. Data contained inside more
‘.DBF’ files may be somehow connected together. See the example.

170 volume VIII Argomenti avanzati e accessori
.----------------------------------------.
| Date | Time IN | Time OUT | Employee # |
|------|---------|-----------------------|
| xxxx | xxxxxxx | xxxxxxxx | 01 | -------->.
|------|---------|----------|------------| |
| yyyy | yyyyyyy | yyyyyyyy | 02 | |
|------|---------|----------|------------| |
| zzzz | zzzzzzz | zzzzzzzz | 01 | -------->|
‘----------------------------------------’ |
[...] |
|
.| 01 | aaaaaaa | aaaaaaa |.....|
|------------|---------|---------|-----|
| 02 | bbbbbbb | bbbbbbb |.....|
|------------|---------|---------|-----|
| 03 | ccccccc | ccccccc |.....|
‘--------------------------------------’
The first ‘.DBF’ file contains some data that refers to an Employee number that may appear
repeated on more records.
Employee informations are stored inside another ‘.DBF’ file that contains only one record for
every employee.
Establishing a relation from the first ‘.DBF’ file to the second, moving the record pointer of the
first ‘.DBF’ file, that is the first alias, the record pointer of the second, the child alias, is moved
automatically to the record containing the right data.
The relation is an expression that should result in a number if the child alias is opened without
index, or in a valid index key if the child alias is opened with an index.
To relate two ‘.DBF’ files the following list of action may be followed:
• Open the first ‘.DBF’ file.
• Open a index file for the first alias.
• Select a particular order.
• Open the second ‘.DBF’ file.
• Open a index file for the second alias.
• Select a particular order.
• Select the first alias.
• Define a relation form the first alias and the second alias: the child alias.
• Search for a key or move the record pointer of the first alias (don’t care about the Child
alias).
• Lock the current record to avoid access from other users.
• If data contained inside the Child alias should be edited (usually it doesn’t happen), lock
the current record of the Child alias.

nanoBase 1997 user manual 171
• Do some editing with the data contained inside the current record using the field names like
they were variables.
• Release the lock (also with the Child alias if a lock was made).
• Move the record pointer to another desired location.
• Lock the current record to avoid access from other users.
• [...]
• Release the relation.
• Close the Child alias.
• Close the first alias.
As may be seen, relations are not saved inside files, but are obtained with lines of code.
368.2 Composition
nB is composed from the following files, where xx is the the version code.
NBASExx1.ZIP EXEs for small PCs
NBASExx2.ZIP Runtime EXEs for small PCs
NBASExx3.ZIP EXEs for i286 with 2M+
NBASExx4.ZIP DOCs
NBASExx5.ZIP EXAMPLEs
NBASExx6.ZIP SRCs for version 96.06.16
NBASExx7.ZIP SRCs for the current version
Every archive file contains:
‘COPYING.TXT’ GNU General Public License version 2 in Dos text format.
‘README.TXT’ the readme file.
‘FILE_ID.DIZ’ definition.
The file ‘NBASExx1.ZIP’ contains also the following files.
‘NB.EXE’
the executable program for DBFNTX and DBFNDX files,
linked with RTLINK.
‘NB.HLP’ this manual in "Help Text File" format.
The file NBASExx2.ZIP contains also the following files.
‘NB.EXE’
The file ‘NBASExx3.ZIP’ contains also the following files.
the run-time to execute macro programs for DBFNTX and
DBFNDX files handling, linked with RTLINK.
‘NB.EXE’
the executable program for DBFCDX, DBFMDX, DBFNDX
and DBFNTX files, linked with EXOSPACE.
‘NB.HLP’ the user manual in "Help Text File" format.

172 volume VIII Argomenti avanzati e accessori
The file ‘NBASExx4.ZIP’ contains also the following files.
‘NB.PRN’ the user manual in printed text format.
‘NB.RTF’ the user manual in RTF format.
‘NB.TXT’ the user manual in ASCII text format.
‘NB.HTM’ the user manual in HTML format.
The file ‘NBASExx5.ZIP’ contains also the following files.
‘_ADDRESS.DBF’ an example database file.
‘_ADDRESS.NTX’ index file associated to ‘_ADDRESS.DBF’.
‘_ADDRESS.LBL’
a label form file used to print data contained inside
‘_ADDRESS.DBF’ .
‘_ADDRESS.FRM’
a report form file used to print data contained inside
‘_ADDRESS.DBF’ .
‘_ADDRESS.RPT’
a RPT text file
‘_ADDRESS.DBF’ .
used to print data contained inside
‘_MAINMNU.&’
a macro program source example of a menu that executes
some others macro programs. This example is made to
demonstrate how nB can execute directly a source code without
compiling it. This example is made only to taste it: it is
very slow and only a speedy machine can give the idea of it.
a macro program source example of a menu that executes
‘0MAINMNU.&’
some others macro programs. It is the same as ‘_MAINMNU.&’
but it is made to start the execution of the compiled macros.
‘0MAINMNU.NB’ compiled macro program ‘0MAINMNU.&’
‘0MAINMNU.BAT’
a batch file to
‘0MAINMNU.NB’
show how to run the execution of
‘1ADDRESS.&’
a macro program source example for handling a ‘.DBF’ file
containing addresses in various ways.
‘1ADDRESS.NB’ compiled macro ‘1ADDRESS.&’ .
a macro program source example for handling a ‘.DBF’ file
‘2ADDRESS.&’
containing addresses in various ways: a little bit more complicated
than 1ADDRESS.&.
‘2ADDRESS.NB’ compiled macro ‘2ADDRESS.&’ .
a macro program source example for handling a ‘.DBF’ file
‘3ADDRESS.&’
containing addresses in various ways: a little bit more complicated
than ‘2ADDRESS.&’ .
‘3ADDRESS.NB’ compiled macro ‘3ADDRESS.&’.
a macro program source example for handling a ‘.DBF’ file
‘4ADDRESS.&’
containing addresses in various ways: a little bit more complicated
than ‘3ADDRESS.&’ .
‘4ADDRESS.NB’ compiled macro ‘4ADDRESS.&’ .
‘ABIORITM.&’
a macro program source example for calculating the personal
bio wave.
‘ABIORITM.NB’ compiled macro ‘ABIORITM.&’ .
‘_STUDENT.DBF’ a ‘.DBF’ file used inside the BSTUDENT macro example.
‘_STUDENT.NTX’ index file used for ‘_STUDENT.DBF’ .
‘_STUDSTD.DBF’ a ‘.DBF’ file used inside the BSTUDENT macro example.
‘_STUDENT.RPT’
a RPT text file
‘_STUDENT.DBF’ .
used to print data contained inside
‘_STUDSTD.RPT’
a RPT text file
‘_STUDSTD.DBF’ .
used to print data contained inside
‘BSTUDENT.&’
a macro program source example for students evaluation: a
description about students is obtained linking other standard
descriptions.
‘BSTUDENT.NB’ compiled macro ‘BSTUDENT.&’ .

nanoBase 1997 user manual 173
‘CBATMAKE.&’
a macro program source example to generate a batch file to be
used to back up an entire hard disk.
‘CBATMAKE.NB’ compiled macro ‘CBATMAKE.&’ .
‘BROWSE.&’
‘BROWSE.NB’ compiled macro ‘BROWSE.&’ .
a macro program source example to start an automatic
browse.
‘BROWSE.BAT’
batch file to start a ‘.DBF’ browse with the BROWSE macro
program.
‘MENU.&’ a macro program source example for a Dos menu.
‘MENU.NB’ compiled macro ‘MENU.&’ .
‘MENU.BAT’ batch file to use the MENU macro.
The file ‘NBASExx6.ZIP’ contains also the following files: source code for the version 96.06.16.
‘NB.PRG’ the main source file for version 96.06.16.
‘NB_REQ.PRG’ the source file containing links to all the standard functions.
‘NB.LNK’ link file for compilation.
‘NB_NRMAL.RMK’ rmake file to compile with RTLink.
‘NB_EXOSP.RMK’ rmake file to compile with Exospace.
‘NB_RUNTI.RMK’
rmake file to compile with RTLink defining RUNTIME to obtain
a small nB runtime version.
‘MACRO.LNK’ link file to compile and link a macro.
‘MACRO.RMK’ rmake file to compile and link a macro.
The file ‘NBASExx7.ZIP’ contains also the following files: source code for the current version.
‘NB.PRG’ the main source file.
‘REQUEST.PRG’ the source file containing links to all the Clipper functions.
‘STANDARD.PRG’ the source file for standard functions.
‘EXTRA.PRG’ the source file for other standard functions.
‘STANDARD.CH’
general include file that substitutes all include file normally
used for normal Clipper compilations.
‘NB.CH’ include file specific for nB.
‘NB.LNK’ link file for compilation.
‘NB_RUNTI.LNK’ link file for runtime compilation.
‘NB_NRMAL.RMK’ rmake file to compile with RTLink.
‘NB_EXOSP.RMK’ rmake file to compile with Exospace.
‘NB_RUNTI.RMK’
rmake file to compile with RTLink defining RUNTIME to obtain
a small nB runtime version.
‘MACRO.CH’ include file to compile and link a macro.
‘MACRO.LNK’ link file to compile and link a macro.
‘MACRO.RMK’ rmake file to compile and link a macro.
‘CLIPMOUSE.ZIP’
368.3 How to use nB
nB normal syntax is:
nB [nB_parameters] [macro_filename] [macro_parameters]
a simple free library for mouse support under Clipper (c) 1992
Martin Brousseau.
To run nB, just type the word "NB" and press [ Enter ] to execute. It will run in command mode,
this means that it will look like an old xBASE command prompt.

174 volume VIII Argomenti avanzati e accessori
To run the program as a macro interpreter, type the word NB followed from the macro file name
with extention (no default extention is supposed). If parameters are given, after the macro file
name, these will be available inside the public variables: c_Par1, c_Par2, ..., c_Par9. c_Par0 will
contain the macro file name (see the macro file BROWSE.&). nB will terminate execution when
the macro terminates.
These parameters are available for nB:
-c
-w
-?
nB macro "compilation" syntax is:
nB -m source_macro_filename [destination_macro_filename]
Suppress the copyright notice. It is usefull when using nB for
macro interpretation.
Suppress the "Wait-Wheel" if not desired. It is the "Wheel"
that appears at top-left when a macro is interpreted or other
long elaborations are executed.
Shows a short help.
With the -m parameter, nB "compiles" the ASCII source_macro_filename into
destination_macro_filename.
368.4 Status line
nB shows a "status line" at the top of the screen when the nB command prompt or the menu
system is active. It shows some important informations.
| |DBFNTX ||*| 1|ADDRESS | 1/ 4|ADDRESS.NTX |
| | | | | | |
| | | | | | |
| | | | | | Last record (7).
| | | | | |
| | | | | Record pointer position (6).
| | | | |
| | | | Active alias (5).
| | | |
| | | Current Work Area (4)
| | |
| | Deleted record appearance (3)
| |
| Actual default database driver (2).
|
Macro recorder indicator (1).
| 1/ 4|ADDRESS.NTX | 1|ADDRESS |
| | |
| | |
| | Order Tag Name (10)
| |
| Order number (9)
|
Order Bag name (8)
(1) This is the place for the macro recorder indicator. The symbol used is "&". Blank means that
the macro recorder is OFF; & blinking means that the macro recorder is ON; & fixed means that
the macro recorder is PAUSED.
(2) The name of the default database driver. It is not necessarily the database driver for the active
alias; it is only the database driver that will be used for the next open/create operation.

nanoBase 1997 user manual 175
(3) An asterisk (*) at this position indicates that SET DELETED is OFF. This means that deleted
records are not filtered. When a BLANK is in this place, SET DELETED is ON, so that deleted
records are filtered.
(4) The active work area number, that is, the area of the active alias.
(5) The active alias name. Note that the alias name is not necessarily equal to the ‘.DBF’ file
name.
(6) The actual record pointer position for the active alias.
(7) The number of records contained inside the active alias.
(8) The Order Bag name; that is the index file name.
(9) The order number.
(10) The order tag (name). When DBFNTX database driver is used, it correspond to the Order
Bag name.
368.5 The dot line
Starting nB without parameters, the dot line appears. This is the place where commands in form
of functions may be written and executed like a old xBase.
The functions written inside the command line that don’t result in an error, are saved inside a
history list. This history list may be recalled with [ F2 ] and then the selected history line may be
reused (eventually edited). Key [ up ]/[ down ] may be used to scroll inside the history list without
showing the all list with [ F2 ].
[ Enter ] is used to tell nB to execute the written function.
As the dot line is not an easy way to use such a program, a menu is available pressing [ F10 ] or
[ Alt+M ]. The [ F10 ] key starts the ASSIST() menu. This menu may be started also entering the
name of the function: "ASSIST()".
nB includes a simple built-in text editor: DOC(). It may be started from the dot line entering
"DOT()". No special key is dedicated to start this function.
368.6 The menu system
The nB menu system appears differently depending on the place where it is "called". When
available, the menu system appears pressing [ Alt+M ] or [ F10 ].
The Menu system is organised into horizontal menu, vertical menu, and pop-up menu.
The horizontal menu contains selectable items organised horizontally:
One Two Three Four Five
The cursor may be moved on a different position using arrow keys [ Left ]/[ Right ]; [ Esc ] terminates
the menu; [ Enter ] opens a vertical menu.
The vertical menu contains selectable items organised vertically:
One Two Three Four Five
.----------.
|First |
|Second |
|Third |
‘----------’

176 volume VIII Argomenti avanzati e accessori
The cursor may be moved on a different position using arrow keys [ Up ]/[ Down ]; the arrow keys
[ Left ]/[ Right ] change the vertical menu; [ Esc ] closes the vertical the menu; [ Enter ] starts the selected
menu function.
The vertical menu contains selectable items organised vertically:
One Two Three Four Five
.----------.
|First |
|Second >|--------------.
|Third |Sub function 1|
‘----------|Sub function 2|
‘--------------’
The cursor may be moved on a different position using arrow keys [ Up ]/[ Down ]; [ Esc ] closes the
pop-up the menu; [ Enter ] starts the selected menu function.
The following sections describe the menu system.
368.6.1 Menu File
The menu File contains important function on ‘.DBF’ file, indexes, relations and Replaceable
database drivers.
For database files are considered two aspects: the physical aspect, and the logical alias. When a
‘.DBF’ file is opened, it becomes a alias.
Indexes are considered as index files and index orders.
It follows a brief menu function description.
Change directory
Changes the actual drive and directory.
File .DBF
Contains a pop-up menu for ‘.DBF’ operations.
New .DBF
A ‘.DBF’ file is a table where columns, called Fields, must be specified and lines,
called records, are added, edited and deleted by the program.
Field characteristics are:
the field name must be unique inside the same file, it is
NAME
composed of letters, number and underscore (_), but it
must start with a letter and it is not case sensitive.
TYPE the field type determinates the type of data it can hold.
is the field total length in characters; it doesn’t matter
LENGTH
DECIMAL
Field Types:
of the type of data.
is the length of positions after decimal point. This information
is used normally for numeric fields. In this
case, take note that the DECIMAL length, together
with the decimal point, will subtract space for the integer
part of the number from the total LENGTH of the
filed.

nanoBase 1997 user manual 177
C Character
it is a text field long LENGTH characters.
it is a numeric field long LENGTH characters with
DECIMAL characters for decimal positions. Note that
if LENGTH is 4 and DECIMAL is 0 (zero), the
N Numeric
field may contain integers from -999 to 9999; but if
LENGTH is 4 and DECIMAL 1, the field may contain
numbers from -9.9 to 99.9: two position for the integer
part, one position for the decimal point and one position
for decimal.
D Date
it is a date field: it contains only dates; the length
should not be specified as it is automatically 8.
it is a logical (boolean) field: it contains only TRUE,
L Logic
represented by "Y" or "T", or FALSE, represented by
"N" or "F". The length should not be specified as it is
automatically 1.
it is a character field with unknown dimension. It is
recorded into a parallel file with ‘.DBT’ extention. The
M Memo
original ‘.DBF’ file holds a space for a pointer inside
the ‘.DBT’ file. The length of a Memo field is automatically
10 and is referred to the memo pointer.
After the function "NEW .DBF" is selected, a table for the field specifications appears.
+--------------------------------+
| Database file structure |
| |
| Field Name Type Length Decimal |
|--------------------------------|
| | | 0| 0 |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
To navigate and to edit the table use the following keys:
[ Up ]/[ Down ]/[ Left ][ Right ] move the cursor one position (up, down, left or right);
[ PgUp ] move to previous screen page;
[ PgDn ] move to next screen page;
[ Ctrl+PgUp ] move to top of table;
[ Ctrl+PgDn ] move to bottom of table;
[ Ctrl+Home ] move to first column;
[ Ctrl+End ] move to last column;
[ Ctrl+Enter ] append a new empty line;
[ Ctrl+F1 ]
delete (cut) the current line and save a copy into the
"clipboard";
[ Ctrl+F2 ] copy current line into the table "clipboard";
insert (paste) the content of the "clipboard" in the cur-
[ Ctrl+F3 ]
rent position;
[ Enter ] start editing in the current position;
[ Esc ] terminate;
[ x ] any other key will be written in the current position.
When the editing is terminated, press [ Esc ] and a dialog box will ask for the file name
and the RDD.
xBase files (.DBF) are not all equal, this way, when a new ‘.DBF’ file si created, the
RDD (Replaceable Database Driver) is asked. The normal RDD is DBFNTX, the one
used by Clipper.

178 volume VIII Argomenti avanzati e accessori
Modify .DBF structure
The modification of a ‘.DBF’ file structure is a delicate matter if it contains data.
In fact, it is a data transfer from a source ‘.DBF’ file to a destination ‘.DBF’ file with
a different structure. This way, the destination ‘.DBF’ will be updated only for the
fields with the same name of the source one. The position may be different, but names
cannot be changed (not so easily).
Mistakes may be dangerous, so, before doing it, it is recommended a backup copy of
the original ‘.DBF’ file.
Open .DBF
When a ‘.DBF’ file is opened, it becomes a alias, a logical file, placed inside a work
area. The same ‘.DBF’ file may be opened inside different areas with different alias
names.
The required information to open the file are:
File .NTX
FILENAME
ALIAS
RDD
SHARED
READ ONLY
Contains a pop-up menu for physical indexes operations.
the physical file name.
the alias name. If not assigned, it becomes automatically
the same of FILENAME without extention.
the Replaceable Database Driver to use to access to this
file.
a logical value: TRUE means that the file will be accessible
to other users, FALSE means use exclusive.
a logical value: TRUE means that the file will be only
readable and no modification will be allowed, FALSE
means that no restriction on editing will be made.
New .NTX / new tag
If the active area is used we have an active alias. In this case a index may be created.
The index is a way to see the active alias ordered without changing the physical
position of records.
There are two words to understand: ORDER and INDEX-BAG. The index bag is the
file that contains the information on the record ordering, the order is the rule followed
to order the records. A index bag may contains one or more orders depending on the
Replaceable Database Driver in use.
Typical ‘.NTX’ file are index bag containing only one order.
Depending on the RDD in use the following field may be filled.
INDEX FILENAME
this is the name of the index bag.
the expression that defines the rule for the record or-
KEY EXPRESSION
dering.
this is the name to give to the order (tag) when the RDD
permits to have a index bag containing more than one
ORDER NAME
order. In the other case, the index bag name correspond
to the order name.
FOR EXPRESSION
a FOR condition to filter records before indexing.
Open index
If a index file already exists, it can be associated to the active alias simply opening it.
Take note that the system is not able to verify if the index belong the active alias
and if it is not so a error will result.

nanoBase 1997 user manual 179
Alias
Order
INDEX NAME
is the name of the index bag file to open.
Contains a pop-up menu for logical databases (alias) operations.
Select
Only one may be the active alias and with this function the active alias may be changed
choosing from the list of used areas.
Selecting the area number zero, no alias is active.
Display structure
With this function the active alias structure may be viewed.
Close active alias
Selecting this function the active alias is closed. That is: the ‘.DBF’ file and eventual
indexes are closed.
Close all aliases
With this function all Aliases are closed.
Contains a pop-up menu for logical indexes (orders).
Relation
Order list rebuild
This function rebuild the indexes opened and associated to the active alias.
Order set focus
This function permits to change the active order selecting form the ones opened and
associated to the active alias.
Order list clear
This function closes all orders associated to the active alias.
Contains a pop-up menu for relations (links with other Aliases).
Set relation
This function permits to establish a relation between a alias and a Child alias showing
as a result a unique database.
CHILD is the alias name to connect to the active alias.
is the relation expression that specify the rule for the relation.
The value of this expression is the key to access
EXPRESSION
the Child alias: if this Child alias is accessed without
index, it must be the record number, if this Child alias
is accessed via index, it must be a valid index key.
Clear relation
This function eliminates any relation that originate form the active alias.
RDD default
Contains a pop-up menu for Replaceable Database Driver defaults.
Show actual RDD default
It simply shows the actual Replaceable Database Driver.

180 volume VIII Argomenti avanzati e accessori
Set default RDD
Select a new default Replaceable Database Driver.
368.6.2 Menu Edit
The menu Edit contains functions to access data from the active alias (the actual area).
View
This function permits you to view the active alias with eventual relations as a table.
No edit is allowed.
To navigate the table use the following keys.
[ Enter ] start field editing.
[ PgUp ] show previous screen page.
[ PgDn ] show next screen page.
[ Ctrl+PgUp ] show top of alias.
[ Ctrl+PgDn ] show bottom of file.
[ Ctrl+Home ] show the first column.
[ Ctrl+End ] show last column.
Edit/browse
This function permits you to edit the active alias with eventual relations as a table.
To navigate and edit the table use the following keys.
[ Enter ] start field editing.
[ PgUp ] show previous screen page.
[ PgDn ] show next screen page.
[ Ctrl+PgUp ] show top of alias.
[ Ctrl+PgDn ] show bottom of file.
[ Ctrl+Home ] show the first column.
[ Ctrl+End ] show last column.
[ Ctrl+Enter ] append a new empty record.
[ Ctrl+F2 ] copy the current record.
[ Ctrl+F3 ] append and paste a record.
[ Ctrl+F4 ]
paste a previously copied record, overwriting the content
of the current one.
[ Ctrl+Y ] delete or recall the current record.
[ Ctrl+Del ] delete or recall the current record.
When a memo field is edited:
Replace
[ Esc ] cancel and close the memo window.
[ Ctrl+Y ] line delete.
[ Ctrl+W ] save and close the memo window.
The content of a Field of the active alias may be replaced with an expression.
The required data is:

nanoBase 1997 user manual 181
Recall
Delete
Pack
FIELD TO REPLACE
NEW VALUE EXPRESSION
WHILE EXPRESSION
FOR EXPRESSION
the Field name to be replaced.
the expression that obtain the new value for the selected
Field.
the WHILE condition expression: the replacement continue
until this expression results True. The constant ‘.T.’
is ever True and is the default.
the FOR condition expression: the replacement is made
for all records that satisfy the condition. The constant
‘.T.’ is ever True and is the default.
The records signed for deletion (deleted but still there), may be recalled (undeleted).
The required data is:
WHILE EXPRESSION
FOR EXPRESSION
the WHILE condition expression: the record recall continue
until this expression results True. The constant ‘.T.’
is ever True and is the default.
the FOR condition expression: the record recall is made
for all records that satisfy the condition. The constant
‘.T.’ is ever True and is the default.
Deletes (sign for deletion) a group of record depending on the required conditions.
The required data is:
WHILE EXPRESSION
FOR EXPRESSION
the WHILE condition expression: the record deletion continue
until this expression results True. The constant ‘.T.’
is ever True and is the default.
the FOR condition expression: the record deletion is made
for all records that satisfy the condition. The constant
‘.T.’ is ever True and is the default.
This function eliminates definitely records previously deleted (signed for deletion).
It may work only if the active alias was opened in exclusive mode.
368.6.3 Menu Report
The menu Report contains functions for data report (print). In particular, label files ‘.LBL’ and
report file ‘.RPT’ may be created and used for printing. There is also another way to print, with
the RPT() system that is available inside the nB internal editor DOC().
DBGOTOP()
Moves the record pointer for the active alias at the first logical record.
New label
With this function can be created a standard label file (.LBL under the dBaseIII standard).
Labels may be printed in more than one column and can contain 16 lines maximum.
The label data is the following.

182 volume VIII Argomenti avanzati e accessori
REMARK
a label remark that will not be printed.
HEIGHT the label vertical dimension.
WIDTH the label horizontal dimension.
MARGIN
the left margin in characters.
LINES
the vertical spacing between labels.
SPACES
the horizontal spacing between labels in characters.
ACROSS the number of label columns.
LINE 1 The first line inside labels.
LINE n The n-th line inside labels.
LINE 16 The 16th line inside labels.
The number of lines inside the labels depend on the HEIGHT and the maximum value is
16.
The label lines can contain constant string and/or string expressions.
See the example below.
Modify label
Margin
XXXXXXX|XXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XXXXXXX|XXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XXXX Height XXXX XXXXXXXXXXXXXXXX
XXXXXXX|XXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XXXXXXX|XXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
|
| Lines
| Spaces
XX Line 1 XXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XX Line 2 XXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XX Line 3 XXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XX Line 4 XXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XX Line 5 XXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
| | |
| | |
| | |
+---------------- Across ---------------+
This function permits you to modify a label file.
Label form
This function permits you to print labels with the data provided by the active alias: one
label each record.
The following data is required.
LABEL FILENAME the label filename.
WHILE
the WHILE condition: the label printing goes on as long
as this condition remain True.
FOR
the FOR condition: only the records from the active alias
that satisfy the condition are used for the label print.

nanoBase 1997 user manual 183
New report
This function permits you to create a standard report form file (.FRM under the dBaseIII
standard).
The informations to create a ‘.FRM’ file are divided into two parts: the head and groups; the
columns.
The first part: head and groups, requires the folliwing informations:
PAGE WIDTH
the page width in characters.
LINES PER PAGE
the usable lines per per page.
LEFT MARGIN
the left margin in characters.
DOUBLE SPACED?
double spaced print, yes or no.
PAGE EJECT BEFORE PRINT? form feed before print, yes or no.
PAGE EJECT AFTER PRINT? form feed after print, yes or no.
PLAIN PAGE?
plain page, yes or no.
PAGE HEADER
the page header, max 4 lines (the separation between one
line and the other is obtained writing a semicolon, ";").
GROUP HEADER
the group title.
GROUP EXPRESSION
the group expression (when it changes, the group changes)
SUMMARY REPORT ONLY? only totals and no columns, yes or no.
PAGE EJECT AFTER GROUP? form feed when the group changes, yes or no.
SUB GROUP HEADER
sub group title.
SUB GROUP EXPRESSION the sub group expression.
The second part: columns, requires the following informations structured in table form:
COLUMN HEADER
column head description (it can contain 4 lines separated
with a semicolon).
CONTENT
the column expression.
WIDTH the column width.
DEC.
the decimal length for numeric columns.
TOTALS
totals to be calculated, yes or no (usefull only for numeric
columns).
To navigate and to edit the table use the following keys:
[ Up ]/[ Down ]/[ Left ][ Right ] move the cursor one position (up, down, left or right);
[ PgUp ] move to previous screen page;
[ PgDn ] move to next screen page;
[ Ctrl+PgUp ] move to top of table;
[ Ctrl+PgDn ] move to bottom of table;
[ Ctrl+Home ] move to first column;
[ Ctrl+End ] move to last column;
[ Ctrl+Enter ] append a new empty line;
[ Ctrl+F1 ]
delete (cut) the current line and save a copy into the "clipboard";
[ Ctrl+F2 ] copy current line into the table "clipboard";
[ Ctrl+F3 ]
insert (paste) the content of the "clipboard" in the current
position;
[ Enter ] start editing in the current position;
[ Esc ] terminate;
[ x ] any other key will be written in the current position.
When the editing is terminated, press [ Esc ] and a dialog box will ask for the name to give
to the report form file.
Modify report
This function permits you to modify a standard report form file (.FRM under the dBaseIII

184 volume VIII Argomenti avanzati e accessori
standard).
Report form
This function permits you to print a report form with the data provided by the active alias.
The following data is required.
REPORT FORM FILENAME the label filename.
WHILE
the WHILE condition: the form printing goes on as long
as this condition remain True.
FOR
the FOR condition: only the records from the active alias
that satisfy the condition are used for the report form print.
Create/modify/print text
This function activates the text editor.
368.6.4 Menu HTF
The menu Htf helps on creating and accessing the "Help Text Files". This name, help text file, is
just the name given to it.
A text (Ascii) file prepared like this manual may be transformed into a "Help Text File" that is a
simple text with pointers.
Open help text file
This function permits to open a Help Text File and browse it. The Help Text File name is
required.
New help text file
This function permits to create a new "Help Text File" that is a help file under the nB style.
The source is an Ascii file where three kind of information are available: Normal text,
Indexes and pointers.
Indexes and Pointers are word or phrases delimited with user defined delimiters; indexes
are placed inside the text to indicate an argument, pointers are placed inside the text to
indicate a reference to indexes.
Inside this manual, indexes are delimited with ## and ##, so the titles are here indexes;
pointers are delimited with < and >.
Only one index per line is allowed, only one pointer per line is allowed.
The Delimiters used do identify indexes and pointers are user defined; the _start_ identifier
symbol can be equal to the _end_ identifier symbol. The symbols used for indexes cannot
be used for the pointers.
So, the informations required are:
SOURCE TEXT FILENAME the filename of the text source file.
DESTINATION FILENAME
the filename of the destination Help Text File (suggested
‘.HLP’ extention).
INDEX START CODE
the index start symbol; suggested ##.
INDEX END CODE
the index end symbol; suggested ##.
POINTER START CODE
the pointer start symbol; suggested .

nanoBase 1997 user manual 185
New HTML file
This function permits to create a new HTML file form a text file formatted to obtain a HTF
file.
The informations required are:
SOURCE TEXT FILENAME the filename of the text source file.
DESTINATION FILENAME
the filename of the destination Help Text File (suggested
‘.HLP’ extention).
INDEX START CODE
the index start symbol; suggested ##.
INDEX END CODE
the index end symbol; suggested ##.
POINTER START CODE
the pointer start symbol; suggested .
HTML TITLE the title for the html page.
368.6.5 Menu Macro
The menu Macro helps on creating macros (programs) with a macro recorder, a macro "compiler"
and a macro executor.
Start recording
This function simply starts or pause the macro recording. The menu items that end with
"&", may be recorded by this macro recorder.
Save recording
A recorded macro may be saved into a ASCII file that may be later modified or simply used
as it is. The filename is requested.
Erase recording
While recording or when the macro recorder is paused, it is possible to erase all previous
recording with this function.
Edit recording
While recording or when the macro recorder is paused, it is possible to edit all previous
recording, for example adding more comments or simply to see what the recorder does.
Macro compilation
A macro file (a program) contained inside a ASCII file, may be compiled into a different
file format to speed up execution. The source filename and the destination filename are
requested.
Load + execute macro
A macro file (a program) in ASCII form or compiled, may be executed.
A macro file may require some parameters.
This function asks for the macro filename to start and the possible parameter to pass to it.

186 volume VIII Argomenti avanzati e accessori
368.6.6 Menu Info
The menu Info is the information menu.
ABOUT
a brief copyright notice.
starts the browse of ‘NB.HLP’ , the nB Help Text File manual
MANUAL BROWSE
if it is present in the current directory or it is found in the
PATH (the Dos SET PATH).
[F1] HELP [F1] reminder.
[F3] ALIAS INFO
[F3] reminder. It shows all the available information on the
active alias.
[F5] SET OUTPUT TO [F5] reminder. It defines the output peripheral or file.
368.6.7 Menu Doc
This menu actually appears only inside the DOC() function, the nB text editor.
New
Open
Save
Save as
It starts the editing of a new empty text.
It opens for editing a new textfile.
It saves the text file under editing.
It saves the text file under editing asking for a new name.
Set output to
It permits to change the default output peripheral: the default is the screen.
Print as it is
It prints on the output peripheral the content of the text as it is.
Print with RPT() once
It prints on the output peripheral the content of the text only once replacing possible text
variables.
Print with RPT() std
It prints on the output peripheral the content of the text repeating this print for every record
contained inside the archive alias.
Exit DOC()
Terminates the use of DOC() the text/document editing/print function.

nanoBase 1997 user manual 187
368.7 The text editor DOC()
The function Doc() activates a simple text editor usefull to build some simple reports.
Inside this function a menu is available and is activated pressing [ Alt+M ] or [ F10 ]. The Doc()
menu is part of the nB menu system.
DOC() may handle text files of a teorical maximum of 64K.
DOC() may be particularly useful to create formatted text with variables identified by CHR(174)
and CHR(175) delimiters: when an active alias exists, [ F2 ] gives a list of insertable fields.
[ Esc ] Exit DOC().
[ F1 ] Call the help.
[ F2 ] Field list.
[ up ] / [ Ctrl+E ] Line up.
[ down ] / [ Ctrl+X ] Line down.
[ left ] / [ Ctrl+S ] Character left.
[ right ] / [ Ctrl+D ] Character right.
[ Ctrl+right ] / [ Ctrl+A ] Word left.
[ Ctrl+left ] / [ Ctrl+F ] Word right.
[ Home ] Line start.
[ End ] Line end.
[ Ctrl+Home ] Top window.
[ Ctrl+End ] Bottom window.
[ PgUp ] Previous window.
[ PgDn ] Next window.
[ Ctrl+PgUp ] Document start.
[ Ctrl+PgDn ] End document.
[ Del ] Delete character (right).
[ Backspace ] Delete character Left.
[ Tab ] Insert tab.
[ Ins ] Toggle insert/overwrite.
[ Enter ] Next line.
[ Ctrl+Y ] Delete line.
[ Ctrl+T ] Delete word right.
[ F10 ] / [ Alt+M ] DOC() menu.
368.8 The help text file
nB provides a basic hypertext system to build simple help files. A source text file with "indexes"
and "pointers" to indexes is translated into a "help text file" (a ‘.DBF’ file); then, this file is
browsed by nB.
The source file can have a maximum line width of 80 characters; each line can terminate with
CR or CR+LF.
"Indexes" are string delimited by index delimiters (default "##"); "pointers" are string delimited
by pointer delimiters (default "") and refers to indexes.
Inside a text, indexes must be unique; pointers can be repeated anywhere. A text can contain a
maximum of 4000 indexes.
Inside this manual, titles are delimited with "##" as they are indexes; strings delimited with "" identify a reference to a title with the same string.

188 volume VIII Argomenti avanzati e accessori
To browse a previously created Help Text File, use the following keys:
[ Esc ] Exit.
[ UpArrow ] Move cursor up.
[ DownArrow ] Move cursor down.
[ PgUp ] Move cursor PageUp.
[ PgDn ] Move cursor Pagedown.
[ Ctrl+PgUp ] Move cursor Top.
[ Ctrl+PgDn ] Move cursor Bottom.
[ Enter ] Select a reference (pointer).
[ ] Go to next selected reference (pointer).
[ Shift+F3 ] Search for a new pattern.
[ F3 ] Repeat previous search.
368.9 Macro
nB can execute (run) macro files. There may be three kind of macro files: ASCII (usually with
.& extention); "compiled" (usually with .NB extention); EXE files (compiled with Clipper and
linked).
"Compiled" macro files are executed faster then the ASCII source files.
EXE macro files are the fastest.
368.9.1 Macro statements
The statements recognised from nB are very similar to Clipper, with some restrictions.
Note that: the FOR statement is not included; there is no function declaration; procedure calls
cannot transfer variables; only public variables are allowed.
PROCEDURE
Procedures are the basic building blocks of a nB macro.
Procedures are visible only inside the current macro file.
The procedure structure is as follows:
PROCEDURE procedure_name
statements...
[RETURN]
statements...
ENDPROCEDURE
A procedure definition begins with a PROCEDURE declaration followed with the
procedure_name and ends with ENDPROCEDURE.
Inside the PROCEDURE - ENDPROCEDURE declaration are placed the executable
statements which are executed when the procedure is called.
Inside the PROCEDURE - ENDPROCEDURE declaration, the RETURN statement may
appear. In this case, encountering this RETURN statement, the procedure execution is immediately
terminated and control is passed to the statement following the calling one.
The procedure definition do not permit to receive parameters from the calling statement.

nanoBase 1997 user manual 189
DO PROCEDURE
There is only one way to call a procedure:
DO PROCEDURE procedure_name
When the statement DO PROCEDURE is encountered, the control is passed to the begin of
the called PROCEDURE. After the PROCEDURE execution, the control is returned to the
statement following DO PROCEDURE.
The procedure call do not permit to send parameters to the procedure.
BEGIN SEQUENCE
The BEGIN SEQUENCE - END structure permits to define a sequence of operation that
may be broken.
Inside nB, this control structure is useful only because there is the possibility to break the
execution and pass control over the end of it.
This way, encountering BREAK means: "go to end".
BEGIN SEQUENCE
statements...
[BREAK]
statements...
END
Inside nB, error exception handling is not supported.
DO CASE
This is a control structure where only the statements following a True CASE condition are
executed.
When the DO CASE statement is encountered, the following CASE statements are tested.
The first time that a condition returns True, the CASE’s statements are executed and then
control is passed over the END case.
That is: only one CASE is taken into consideration.
If no condition is True, the statements following OTHERWISE are executed.
DO CASE
CASE lCondition1
statements...
[CASE lCondition2]
statements...
[OTHERWISE]
statements...
END
WHILE
The structure WHILE - END defines a loop based on a condition: the loop is repeated until
the condition is True.
The loop execution may be broken with the EXIT statement: it transfer control after the
END while.
The LOOP statement may be use to repeat the loop: it transfer the control to the beginning
of the loop.
WHILE lCondition
statements...
[EXIT]
statements...
[LOOP]
statements...
END

190 volume VIII Argomenti avanzati e accessori
IF
The IF - END control structure executes a section of code if a specified condition is True.
The structure can also specify alternative code to execute if the condition is False.
IF lCondition1
statements...
[ELSE]
statements...
END
368.9.2 Variable declaration
Inside nB, variables are created using a specific function:
MEMPUBLIC( "cVarName" )
For example,
MEMPUBLIC( "Name" )
creates the variable Name.
The scope of the created variable is global and there is no way to restrict the visibility of it.
When a variable is no more needed or desired, it can be released:
MEMRELEASE( "cVarName" )
The variable declaration do not defines the variable type. Every variable may receive any kind of
data; that is that the type depends on the type of data contained.
368.9.3 Macro structure
A nB macro must be organised as follow. There may be two situations: Macros with procedures
and macros without procedures.
Macro with procedures:
PROCEDURE procedure_name_1
statements...
[RETURN]
statements...
ENDPROCEDURE
PROCEDURE procedure_name_2
statements...
[RETURN]
statements...
ENDPROCEDURE
...
...
DO PROCEDURE procedure_name_n
Macro without procedures:
statements...
statements...
statements...
statements...
statements...
nB Macros may be compiled with Clipper. To do so, the first structure example must be changed
as follows:

nanoBase 1997 user manual 191
#INCLUDE MACRO.CH
DO PROCEDURE procedure_name_nth
...
PROCEDURE procedure_name_1
statements...
[RETURN]
statements...
ENDPROCEDURE
PROCEDURE procedure_name_2
statements...
[RETURN]
statements...
ENDPROCEDURE
...
...
To compile a macro with Clipper, the macro file name can be changed into ‘MACRO.PRG’ and
RTLINK MACRO.RMK [Enter]
should be started.
368.9.4 Macro comments
A nB Macro source file can contain comments. only the "//" comment is recognised! This way:
* and /*...*/ will generate errors!
ATTENTION: to simplify the macro interpretation, lines such as this:
qqout( "You can’t do that // you can’t do that!" )
will generate an error as the interpreter will read only:
qqout( "You can’t do that
Sorry!
368.9.5 Macro long lines split
Inside a nB macro, long lines may be splitted using ";" (semicolon). Please note that: lines can
only be splitted and not joined; a resulting command line cannot be longer then 254 characters.
368.9.6 The macro recorder
Inside the functions ASSIST() and DOC() is available the Macro recorder menu.
When a macro recording is started, a "&" appears on the left side of the status bar. It it blinks, the
recording is active, if it is stable, the recording is paused.
The macro recording is not exactly a step-by-step recording of all action taken, but a translation
(as good as possible) of what you have done.

192 volume VIII Argomenti avanzati e accessori
The macro recorder is able to record only the menu functions that terminates with the "&" symbol
and all what is inserted at the dot command line.
The macro recording can be viewed and edited during the recording. The macro recording can
be saved into a text file (a macro file).
368.10 Data types
The data types supported in the nB macro language are the same as Clipper:
Array
Character
Code Block
Numeric
Date
Logical
Memo
NIL
368.10.1 Character
The character data type identifies character strings of a fixed length. The character set corresponds
to: CHR(32) through CHR(255) and the null character, CHR(0).
Valid character strings consist of zero or more characters with a theoretical maximum of 65535
characters. The real maximum dimension depends on the available memory.
Character string constants are formed by enclosing a valid string of characters within a designed
pair of delimiters. There are three possible delimiter pairs:
two single quotes like ‘’string_constant’’;
two double quotes like ‘"string_constant"’;
left and right square brackets like ‘[string_constant]’.
These three different kind of delimiters are available to resolve some possible problems:
I don’t want it -> "I don’t want it"
She said, "I love hin" -> ’She said, "I love hin"’
He said, "I don’t want it" -> [He said, "I don’t want it"]
The following table shows all operations available inside nB for character data types. These
operations act on one or more character expressions and the result is not necessarily a character
data type.
+ Concatenate.
- Concatenate without intervening spaces.
== Compare for exact equity.
!=, , # Compare for inequity.
< Compare for sorts before

nanoBase 1997 user manual 193
Compare for sorts after.
>= Compare for sorts after or same as.
:= In line assign.
$ Test for substring existence.
ALLTRIM() Remove leading and trailing spaces.
ASC() Convert to numeric ASCII code equivalent.
AT() Locate substring position.
CTOD() Convert to date.
DESCEND() Convert to complemented form.
EMPTY() Test for null or blank string.
ISALPHA() Test for initial letter.
ISDIGIT() Test for initial digit.
ISLOWER() Test for initial lowercase letter.
ISUPPER() Test for initial uppercase letter.
LEFT() Extract substring form the left.
LEN() Compute string length in characters.
LOWER() Convert letters to lowercase.
LTRIM() Remove leading spaces.
PADC() Pad with leading and trailing spaces.
PADL() Pad with leading spaces.
PADR() Pad with trailing spaces.
RAT() Locate substring position starting from the right.
RIGHT() Extract substring form the right.
RTRIM() Remove trailing spaces.
SOUNDEX() Convert to soundex equivalent.
SPACE() Create a blank string of a defined length.
STRTRAN() Search and replace substring.
STUFF() Replace substring.
SUBSTR() Extract substring.
TRANSFORM() Convert to formatted string.
UPPER() Convert letters to uppercase
VAL() Convert to numeric.
VALTYPE() Evaluates data type directly.
368.10.2 Memo
The memo data type is used to represent variable length character data that can only exist in the
form of a database field.
Memo fields are not stored inside the main database file (.DBF) but inside a separate file (.DBT).
A memo field can contain up to 65535 characters, that is the same maximum dimension of character
fields. In fact, originally xBases, couldn’t have character string longer than 254 characters.
As here memo fields are very similar to long character strings, you may forget that there is a
difference.
All the operations that may be applied to character strings, may be used with memo fields; the
following functions may be use especially for memo fields or long character strings.
HARDCR() Replace soft with hard carriage returns.
MEMOEDIT() Edit contents.
MEMOLINE() Extract a line of a text.

194 volume VIII Argomenti avanzati e accessori
MEMOREAD() Read form a disk text file.
MEMOTRAN() Replace soft and hard carriage returns.
MEMOWRIT() Write to disk text file.
MLCOUNT() Count lines.
MLPOS() Compute position.
368.10.3 Date
The date data type is used to represent calendar dates.
Supported dates are from 0100.01.01 to 2999.12.31 and null or blank date.
The appearance of a date is controlled from SETVERB("DATEFORMAT"). The default is
"dd/mm/yyyy" and it may easily changed for example with SETVERB("DATEFORMAT",
"MM/DD/YYYY") to the US standard.
There is no way to represent date constants; these must be replaced with the CTOD() function.
For example if the date 11/11/1995 is to be written, the right way is:
CTOD( "11/11/1995" )
The character string "11/11/1995" must respect the date format defined as before explained.
The function CTOD() will accept only valid dates, and null dates:
CTOD( "" )
A null date is ever less than any other valid date.
The following table shows all operations available inside nB for date data types. These operations
act on one or more date expressions and the result is not necessarily a character data type.
+ Add a number of days to a date.
- Subtract days to a date.
== Compare for equity.
!=, , # Compare for inequity.
< Compare for earlier
Compare for later.
>= Compare for later or same as.
:= In line assign.
CDOW() Compute day of week name.
CMONTH() Compute month name.
DAY() Extract day number.
DESCEND() Convert to complemented form.
DOW() Compute day of week.
DTOC()
Convert to character string with the format defined with
SETVERB( "DATEFORMAT" ).
DOTOS() Convert to character string in sorting format (YYYYMMDD).
EMPTY() Test for null date.
MONTH() Extract month number.
VALTYPE() Evaluates data type directly.
YEAR() Extract entire year number, including century.

nanoBase 1997 user manual 195
368.10.4 Numeric
The numeric data type identifies real number. The theoretical range is form 10^-308 to 10^308
but the numeric precision is guaranteed up to 16 significant digits, and formatting a numeric
value for display is guaranteed up to a length of 32 (30 digits, a sign, and a decimal point). That
is: numbers longer than 32 bytes may be displayed as asterisks, and digits other then most 16
significant ones are displayed as zeroes.
Numeric constants are written without delimiters. The following are valid constant numbers:
12345
12345.678
-156
+1256.789
-.789
If a numeric constant is delimited like character strings, it becomes a character string.
The following table shows all operations available inside nB for numeric data types. These operations
act on one or more numeric expressions and the result is not necessarily a numeric data
type.
+ Add or Unary Positive.
- Subtract or Unary Negative.
*
Multiply.
/ Divide.
% Modulus.
^, ** Exponentiate.
== Compare for equity.
!=, , # Compare for inequity.
< Compare for less than.
>= Compare for less than or equal.
> Compare for greater than.
>= Compare for greater than or equal.
:= In line assign.
ABS() Compute absolute value.
CHR() Convert to ASCII character equivalent.
DESCEND() Convert to complemented form.
EMPTY() Test for zero.
EXP() Exponentiate with e as the base.
INT() Convert to integer.
LOG() Compute natural logarithm.
MAX() Compute maximum.
MIN() Compute minimum.
ROUND() Round up or down()
SQRT() Compute square root.
STR() Convert to character.
TRANSFORM() Convert to formatted string.
VALTYPE() Evaluates data type directly.
Number appearence may be affected by SETVERB("FIXED") and consequently by
SETVERB("DECIMALS"). If SETVERB("FIXED") is True, numbers are displayed with a fixed
decimal position. The number of decimal positions is defined by SETVERB("DECIMALS"). For

196 volume VIII Argomenti avanzati e accessori
that reason, the default is SETVERB("FIXED", .F.) and SETVERB("DECIMALS", 2), that is,
no fixed decimal position, but if they will be activated, the default is two decimal digits.
368.10.5 Logical
The logical data type identifies Boolean values.
Logical constants are:
‘.T.’ True.
‘.F.’ False.
When editing a logical field, inputs may be:
y, Y, t, T for True
n, N, f, F for False
The following table shows all operations available inside nB for logical data types. These operations
act on one or more logical expressions and the result is not necessarily a logical data
type.
.AND. And.
.OR. Or.
.NOT. or !
Negate.
== Compare for equity.
!=, , or # Compare for inequity.
Comparing two logical values, False (‘.F.’) is always less than True (‘.T.’).
368.10.6 NIL
NIL is not properly a data type, it represent the value of an uninitialised variable.
Inside nB (like what it happens inside Clipper), variables are not declared with the data type that
they will contain. This means that a variable can contain any kind of data. In fact, nB variables
are pointer to data and a pointer to "nothing" is NIL.
NIL may be used as constant for assignment or comparing purpose:
NIL
Fields (database fields) cannot contain NIL.
The following table shows all operations available inside nB for the NIL data type. Except for
these operations, attempting to operate on a NIL results in a runtime error.
== Compare for equity.
!=, , # Compare for inequity.
< Compare for less than.
Compare for greater than.
>= Compare for greater than or equal.
:= In line assign.
EMPTY() Test for NIL.
VALTYPE() Evaluates data type directly.

nanoBase 1997 user manual 197
For the purpose of comparison, NIL is the only value that is equal to NIL. All other values are
greater than NIL.
Variables are created inside nB with MEMPUBLIC(). This function creates variables which will
be automatically initialised to NIL.
368.10.7 Array
The array data type identifies a collection of related data items that share the same name. Each
value in an array is referred to as an element.
Array elements can be of any data type except memo (memo is available only inside database
fields). For example the first element can be a character string, the second a number, the third a
date and so on. Arrays can contain other arrays and code blocks as elements.
The variable containing the array does not contains the entire array, but the reference to it.
When the NIL type was described, it was cleared that variables doesn’t contains real data,
but pointer to data. But this happens in a transparent way, that is that when the a variable is
assigned to another (for example A := B) the variable receiving the assignment will receive
a pointer to a new copy of the source data. This is not the same with arrays: assigning to a
variable an array, will assign to that variable a pointer to the same source array and not to a
new copy of it.
If arrays are to be duplicated, the ACLONE() function is to be used.
An array constant may be expressed using curly brackets {}. See the examples below.
A := { "first_element", "second_element", "third_element" }
With this example, the variable A contain the reference to an array with three element containing
character string.
A[1] == "first_element"
A[2] == "second_element"
A[3] == "third_element"
Arrays may contain also no element: empty array and may be expressed as:
{}
The array element is identified by a number enclosed with square brackets, following the variable
name containing the reference to the array. The first array element is one.
If an array contains arrays, we obtain a multidimensional array. For example:
A := { { 1, 2 }, { 3, 4 }, { 5, 6 } }
is equivalent to the following table.
1 2
3 4
5 6

198 volume VIII Argomenti avanzati e accessori
With this example, the variable A contain the reference to a bidimensional array containing numbers.
A[1,1] or A[1][1] contains 1
A[1,2] or A[1][2] contains 2
A[2,1] or A[2][1] contains 3
and so on.
As arrays may contain mixed data, it is the user who have to handle correctly the element numbers.
For example:
A := { "hello", { 3, 4 }, 1234 }
A[1] == "hello"
A[2] == reference to { 3, 4 }
A[3] == 1234
A[2,1] or A[2][1] contains 3
A[2,2] or A[2][2] contains 4
A[1,1] is an error!
The following table shows all operations available inside nB for arrays.
:= In line assign.
AADD() Add dynamically an element to an array.
ACLONE() Create a copy of an array.
ACOPY() Copy element by element an array to another.
ADEL() Delete one element inside an array.
AFILL() Fill all array elements with a value.
AINS() Insert an element inside an array.
ARRAY() Creates an array of empty elements.
ASCAN() Scan the array elements.
ASIZE() Resize an array.
ASORT() Sort the array elements.
EMPTY() Test for no elements.
VALTYPE() Evaluates data type directly.
368.10.8 Code block
The code block data type identifies a small piece of executable program code.
A code block is something like a little user defined function where only a sequence of functions
or assignments may appear: no loops, no IF ELSE END.
A code block may receive argument and return a value after execution, just like a function.
The syntax is:
{ | [argument_list] | exp_list }
That is: the argument_list is optional; the exp_list may contain one or more expressions separated
with a comma.

nanoBase 1997 user manual 199
For example, calling the following code block will give the string "hello world" as result.
{ || "hello world" }
The following code block require a numeric argument an returns the number passed as argument
incremented:
{ | n | n+1 }
The following code block requires two numeric arguments and returns the sum of the two square
radix:
{ | nFirst, nSecond | SQRT(nFirst) + SQRT(nSecond) }
But code blocks may contains more expressions and the result of the execution of the code block
is the result of the last expression.
The following code block executes in sequence some functions and give ever "hello world" as a
result.
{ | a, b | functionOne(a), functionTwo(b), "hello world" }
To start the execution of a code block a function is used: EVAL()
For example, a code block is assigned to a variable and then executed.
B := { || "hello world" }
EVAL( B ) == "hello world"
Another example with a parameter.
B := { | n | n+1 }
EVAL( B, 1 ) == 2
Another example with two parameters.
B := { | nFirst, nSecond | SQRT(nFirst) + SQRT(nSecond) }
EVAL( B, 2, 4 ) == 20
And so on.
The following table shows some operations available inside nB for code blocks: many functions
use code blocks as argument.
:= In line assign.
AEVAL() Evaluate (execute) a code block for each element in an array.
BCOMPILE() Convert (compile) a character string into a code block.
DBEVAL()
Evaluate (execute) a code block for each record in the active
alias.
EVAL() Evaluate a code block once.
VALTYPE() Evaluates data type directly.

200 volume VIII Argomenti avanzati e accessori
368.11 Operators
Here is a list with a brief description of the operators available inside nB.
cString1 $ cString2
Substring comparison.
If cString1 is contained inside cString2 the result is true (‘.T.’).
nNumber1 % nNumber2
Modulus.
The result is the remainder of nNumber1 divided by nNuber2.
()
Function or grouping indicator.
nNumber1 * nNumber2
Multiplication.
nNumber1 ** nNumber2
nNumber1 ^ nNumber2
Exponentiation.
nNumber1 + nNumber2
dDate + nNumber
Addition, unary positive.
cString1 + cString2
String concatenation.
The result is a string beginning with the content of cString1 and following with the content of
cString2.
nNumber1 - nNumber2
dDate1 - dDate2
dDate - nNumber
Subtraction, unary negative.
cString1 - cString2
String concatenation.
The result is a string containing cString1 after trimming trailing blanks and cString2.
idAlias->idField
FIELD->idVar
MEMVAR->idVar
Alias assignment.
The alias operator implicitly SELECTs the idAlias before evaluating idField. When the evaluation
is complete, the original work area is SELECTed again.
lCondition1 .AND. lCondition2
Logical AND.
.NOT. lCondition

nanoBase 1997 user manual 201
Logical NOT.
lCondition1 .OR. lCondition2
Logical OR.
nNumber1 / nNumber2
Division.
object:message[(argument list)]
Send.
idVar := exp
Inline assign.
exp1 exp2
Greater than.
exp1 >= exp2
Greater than or equal.
@idVar
Pass-by-reference.
[]
aArray[nSubscript, ...]
aArray[nSubscript1][nSubscript2] ...
Array element indicator.
368.12 Delimiters
Here is the delimiter list recognised from nB.
{ exp_list }
Literal array delimiters.
{ |param_list| exp_list }
Code block delimiters.
"cString"
’cString’
[cString]

202 volume VIII Argomenti avanzati e accessori
String delimiters.
368.13 Code blocks
A code block is a sequence of function, assignments and constant like the following:
sqrt(10)
nResult := 10 * nIndex
Suppose that the above sequence of operations has a meaning for you. We want to create a box
containing this sequence of operation. This box is contained inside a variable:
bBlackBox := { || sqrt(10), nResult := 10 * nIndex }
Note the comma used as separator.
Now bBlackBox contains the small sequence seen before. To execute this sequence, the function
EVAL() is used:
EVAL(bBlackBox)
The execution of the code block gives a result: the value of the last operation contained inside
the code block. In this case it is the result of 10*nIndex. For that reason, if the execution of the
code block must give a fixed result, it can terminate with a constant.
A code block may receive parameters working like a function. Try to imagine that we need to do
the following.
function multiply( nVar1, nVar2 )
return nVar * nVar2
endfunction
A code block that does the same is:
bMultiply := { | nVar1, nVar2 | nVar1 * nVar2 }
To evaluate it, for example trying to multiply 10 * 5:
nResult := EVAL( bMultiply, 10, 5 )
and nResult will contain 50.
368.14 Standard functions
With nB all Clipper standard functions may be used. Here follows a short description.
368.14.1 AADD()
Array add
AADD(aTarget, expValue) ⇒ Value
aTarget is the array to add a new element to.
expValue is the value assigned to the new element.
It increases the actual length of the target array by one. The newly created array element is

nanoBase 1997 user manual 203
assigned the value specified by expValue.
368.14.2 ABS()
Absolute
ABS(nExp) ⇒ nPositive
nExp is the numeric expression to evaluate.
ABS() returns a number representing the absolute value of its argument.
368.14.3 ACLONE()
Array clone
ACLONE(aSource) ⇒ aDuplicate
aSource
ACLONE() returns a duplicate of aSource.
368.14.4 ACOPY()
Array copy
is the array to duplicate.
ACOPY(aSource, aTarget,
[nStart], [nCount], [nTargetPos]) ⇒ aTarget
aSource
is the array to copy elements from.
aTarget is the array to copy elements to.
is the starting element position in the aSource array. If not
nStart
specified, the default value is one.
is the number of elements to copy from the aSource array
beginning at the nStart position. If nCount is not specified,
nCount
all elements in aSource beginning with the starting element
are copied.
is the starting element position in the aTarget array to receive
nTargetPos
elements from aSource. If not specified, the default value is
one.
ACOPY() is an array function that copies elements from the aSource array to the aTarget array.
The aTarget array must already exist and be large enough to hold the copied elements.

204 volume VIII Argomenti avanzati e accessori
368.14.5 ADEL()
Array delete
ADEL(aTarget, nPosition) ⇒ aTarget
aTarget is the array to delete an element from.
nPosition
is the position of the target array element to delete.
ADEL() is an array function that deletes an element from an array. The contents of the specified
array element is lost, and all elements from that position to the end of the array are shifted up one
element. The last element in the array becomes NIL.
368.14.6 AEVAL()
Array evaluation
AEVAL(aArray, bBlock,
[nStart], [nCount]) ⇒ aArray
aArray is the array to be evaluated.
bBlock is a code block to execute for each element encountered.
nStart
is the starting element. If not specified, the default is element
one.
nCount
is the number of elements to process from nStart. If not specified,
the default is all elements to the end of the array.
AEVAL() is an array function that evaluates a code block once for each element of an array,
passing the element value and the element index as block parameters. The return value of the
block is ignored. All elements in aArray are processed unless either the nStart or the nCount
argument is specified.
368.14.7 AFILL()
Array fill
AFILL(aTarget, expValue,
[nStart], [nCount]) ⇒ aTarget
aTarget is the array to fill.
expValue
is the value to place in each array element. It can be an expression
of any valid data type.
nStart
is the position of the first element to fill. If this argument is
omitted, the default value is one.
is the number of elements to fill starting with element nStart.
nCount
If this argument is omitted, elements are filled from the starting
element position to the end of the array.
AFILL() is an array function that fills the specified array with a single value of any data type
(including an array, code block, or NIL) by assigning expValue to each array element in the
specified range.

nanoBase 1997 user manual 205
368.14.8 AINS()
Array insert
AINS(aTarget, nPosition) ⇒ aTarget
aTarget is the array into which a new element will be inserted.
nPosition
is the position at which the new element will be inserted.
AINS() is an array function that inserts a new element into a specified array. The newly inserted
element is NIL data type until a new value is assigned to it. After the insertion, the last element
in the array is discarded, and all elements after the new element are shifted down one position.
368.14.9 ALERT()
ALERT( cMessage, [aOptions] ) ⇒ nChoice
is the message text displayed, centered, in the alert box. If the
cMessage
message contains one or more semicolons, the text after the
semicolons is centered on succeeding lines in the dialog box.
aOptions defines a list of up to 4 possible responses to the dialog box.
ALERT() returns a numeric value indicating which option was chosen. If the Esc key is pressed,
the value returned is zero. The ALERT() function creates a simple modal dialog. The user can
respond by moving a highlight bar and pressing the Return or SpaceBar keys, or by pressing
the key corresponding to the first letter of the option. If aOptions is not supplied, a single "Ok"
option is presented.
368.14.10 ALIAS()
ALIAS([nWorkArea]) ⇒ cAlias
nWorkArea
is any work area number.
ALIAS() returns the alias of the specified work area as a character string. If nWorkArea is not
specified, the alias of the current work area is returned. If there is no database file in USE for the
specified work area, ALIAS() returns a null string ("").
368.14.11 ALLTRIM()
ALLTRIM(cString) ⇒ cTrimmedString
cString is the character expression to trim.
ALLTRIM() returns a character string with leading and trailing spaces removed.

206 volume VIII Argomenti avanzati e accessori
368.14.12 ARRAY()
ARRAY(nElements [, nElements...]) ⇒ aArray
nElements
is the number of elements in the specified dimension.
ARRAY() is an array function that returns an uninitialized array with the specified number of
elements and dimensions.
368.14.13 ASC()
ASCII
ASC(cExp) ⇒ nCode
cExp is the character expression to convert to a number.
ASC() returns an integer numeric value in the range of zero to 255 , representing the ASCII value
of cExp.
368.14.14 ASCAN()
Array scan
ASCAN(aTarget, expSearch,
[nStart], [nCount]) ⇒ nStoppedAt
aTarget is the array to scan.
is either a simple value to scan for, or a code block. If
expSearch
expSearch is a simple value it can be character, date, logical,
or numeric type.
is the starting element of the scan. If this argument is not spec-
nStart
ified, the default starting position is one.
is the number of elements to scan from the starting position.
nCount
If this argument is not specified, all elements from the starting
element to the end of the array are scanned.
ASCAN() returns a numeric value representing the array position of the last element scanned.
If expSearch is a simple value, ASCAN() returns the position of the first matching element, or
zero if a match is not found. If expSearch is a code block, ASCAN() returns the position of the
element where the block returned true (‘.T.’).
368.14.15 ASIZE()
Array size
ASIZE(aTarget, nLength) ⇒ aTarget
aTarget is the array to grow or shrink.
nLength is the new size of the array.

nanoBase 1997 user manual 207
ASIZE() is an array function that changes the actual length of the aTarget array. The array is
shortened or lengthened to match the specified length. If the array is shortened, elements at the
end of the array are lost. If the array is lengthened, new elements are added to the end of the array
and assigned NIL.
368.14.16 ASORT()
Array sort
ASORT(aTarget, [nStart],
[nCount], [bOrder]) ⇒ aTarget
aTarget is the array to sort.
nStart
is the first element of the sort. If not specified, the default
starting position is one.
nCount
is the number of elements to sort. If not specified, all elements
in the array beginning with the starting element are sorted.
bOrder
is an optional code block used to determine sorting order. If
not specified, the default order is ascending.
ASORT() is an array function that sorts all or part of an array containing elements of a single data
type. Data types that can be sorted include character, date, logical, and numeric. If the bOrder
argument is not specified, the default order is ascending. Each time the block is evaluated, two
elements from the target array are passed as block parameters. The block must return true (‘.T.’)
if the elements are in sorted order.
368.14.17 AT()
AT(cSearch, cTarget) ⇒ nPosition
cSearch
is the character substring for which to search.
cTarget is the character string to search.
AT() returns the position of the first instance of cSearch within cTarget as an integer numeric
value. If cSearch is not found, AT() returns zero.
AT() is a character function used to determine the position of the first occurrence of a character
substring within another string.
368.14.18 ATAIL()
Array TAIL
ATAIL(aArray) ⇒ Element
aArray is the array.
ATAIL() is an array function that returns the highest numbered element of an array. It can be used
in applications as shorthand for aArray[LEN(aArray)] when you need to obtain the last element
of an array.

208 volume VIII Argomenti avanzati e accessori
368.14.19 BIN2I()
Binary to integer
BIN2I(cSignedInt) ⇒ nNumber
cSignedInt
is a character string in the form of a 16-bit signed integer
number--least significant byte first.
BIN2I() returns an integer obtained converting the first two byte contained inside cSignedInt.
368.14.20 BIN2L()
Binary to long
BIN2L(cSignedInt) ⇒ nNumber
cSignedInt
is a character string in the form of a 32-bit signed integer
number--least significant byte first.
BIN2L() returns an integer obtained from the first tour characters contained in cSignedInt.
368.14.21 BIN2W()
Binary to word
BIN2W(cUnsignedInt) ⇒ nNumber
cUnsignedInt
is a character string in the form of a 16-bit unsigned integer
number--least significant byte first.
BIN2W() returns an integer obtained from the first two characters contained in cSignedInt.
368.14.22 BOF()
Begin of file
BOF() ⇒ lBoundary
BOF() returns true (‘.T.’) after an attempt to SKIP backward beyond the first logical record in
a database file; otherwise, it returns false (‘.F.’). If there is no database file open in the current
work area, BOF() returns false (‘.F.’). If the current database file contains no records, BOF()
returns true (‘.T.’).

nanoBase 1997 user manual 209
368.14.23 CDOW()
Character day of week
CDOW(dExp) ⇒ cDayName
dExp is the date value to convert.
CDOW() returns the name of the day of the week as a character string. The first letter is uppercase
and the rest of the string is lowercase. For a null date value, CDOW() returns a null string ("").
368.14.24 CHR()
Character
CHR(nCode) ⇒ cChar
nCode
is an ASCII code in the range of zero to 255.
CHR() returns a single character value whose ASCII code is specified by nCode.
368.14.25 CMONTH()
Character month
CMONTH(dDate) ⇒ cMonth
dDate is the date value to convert.
CMONTH() returns the name of the month as a character string from a date value with the first
letter uppercase and the rest of the string lowercase. For a null date value, CMONTH() returns a
null string ("").
368.14.26 COL()
Column
COL() ⇒ nCol
COL() is a screen function that returns the current column position of the cursor. The value of
COL() changes whenever the cursor position changes on the screen.
368.14.27 COLORSELECT()
COLORSELECT(nColorIndex) ⇒ NIL
nColorIndex
is a number corresponding to the ordinal positions in the current
list of color attributes, as set by SETCOLOR().
COLORSELECT() activates the specified color pair from the current list of color attributes (es-

210 volume VIII Argomenti avanzati e accessori
tablished by SETCOLOR()).
368.14.28 CTOD()
Character to date
CTOD(cDate) ⇒ dDate
cDate
is a character string consisting of numbers representing the
month, day, and year separated by any character other than a
number. The month, day, and year digits must be specified in
accordance with the SET DATE format. If the century digits
are not specified, the century is determined by the rules of
SET EPOCH.
CTOD() returns a date value. If cDate is not a valid date, CTOD() returns an empty date.
368.14.29 CURDIR()
Current directory
CURDIR([cDrivespec]) ⇒ cDirectory
cDrivespec
specifies the letter of the disk drive to query. If not specified,
the default is the current DOS drive.
CURDIR() returns the current DOS directory of the drive specified by cDrivespec as a character
string without either leading or trailing backslash (\) characters.
368.14.30 DATE()
DATE() ⇒ dSystemDate
DATE() returns the system date as a date value.
368.14.31 DAY()
DAY(dDate) ⇒ nDay
dDate is a date value to convert.
DAY() returns the day number from dDate.

nanoBase 1997 user manual 211
368.14.32 DBAPPEND()
DBAPPEND([lReleaseRecLocks]) ⇒ NIL
lReleaseRecLocks
DBAPPEND() adds a new empty record to the active alias.
368.14.33 DBCLEARFILTER()
DBCLEARFILTER() ⇒ NIL
is a logical data type that if true (‘.T.’), clears all
pending record locks, then appends the next record. If
lReleaseRecLocks is false (‘.F.’), all pending record locks
are maintained and the new record is added to the end of
the Lock List. The default value of lReleaseRecLocks is true
(‘.T.’).
DBCLEARFILTER() clears the logical filter condition, if any, for the current work area.
368.14.34 DBCLEARINDEX()
DBCLEARINDEX() ⇒ NIL
DBCLEARINDEX() closes any active indexes for the active alias.
368.14.35 DBCLEARRELATION()
DBCLEARRELATION() ⇒ NIL
DBCLEARRELATION() clears any active relations for the active alias.
368.14.36 DBCLOSEALL()
DBCLOSEALL() ⇒ NIL
DBCLOSEALL() releases all occupied work areas from use. It is equivalent to calling DB-
CLOSEAREA() on every occupied work area.
Attention: DBCLOSEALL() cannot be used inside a "compiled" macro as this will stop the
macro execution. In substitution, DBCLOSE() should be used.
368.14.37 DBCLOSEAREA()
DBCLOSEAREA() ⇒ NIL
DBCLOSEAREA() releases the current work area from use.

212 volume VIII Argomenti avanzati e accessori
368.14.38 DBCOMMIT()
DBCOMMIT() ⇒ NIL
DBCOMMIT() causes all updates to the current work area to be written to disk. All updated
database and index buffers are written to DOS and a DOS COMMIT request is issued for the
database (.dbf) file and any index files associated with the work area. Inside a network environment,
DBCOMMIT() makes database updates visible to other processes. To insure data integrity,
issue DBCOMMIT() before an UNLOCK operation.
368.14.39 DBCOMMITALL()
DBCOMMITALL() ⇒ NIL
DBCOMMITALL() causes all pending updates to all work areas to be written to disk. It is equivalent
to calling DBCOMMIT() for every occupied work area.
368.14.40 DBCREATE()
DBCREATE(cDatabase, aStruct, [cDriver]) ⇒ NIL
cDatabase
aStruct
cDriver
is the name of the new database file, with an optional drive and
directory, specified as a character string. If specified without
an extension (.dbf) is assumed.
is an array that contains the structure of cDatabase as a series
of subarrays, one per field. Each subarray contains the definition
of each field’s attributes and has the following structure:
aStruct[n][1] == cName
aStruct[n][2] == cType
aStruct[n][3] == nLength
aStruct[n][4] == nDecimals
specifies the replaceable database driver (RDD) to use to process
the current work area. cDriver is name of the RDD specified
as a character expression.
DBCREATE() is a database function that creates a database file from an array containing the
structure of the file.
368.14.41 DBCREATEINDEX()
DBCREATEINDEX(cIndexName, cKeyExpr, bKeyExpr, [lUnique])
⇒ NIL
cIndexName
cKeyExpr
bKeyExpr
lUnique
is a character value that specifies the filename of the index file
(order bag) to be created.
is a character value that expresses the index key expression in
textual form.
is a code block that expresses the index key expression in executable
form.
is an optional logical value that specifies whether a unique
index is to be created. If lUnique is omitted, the current global
_SET_UNIQUE setting is used.

nanoBase 1997 user manual 213
DBCREATEINDEX() creates an index for the active alias. If the alias has active indexes, they
are closed.
368.14.42 DBDELETE()
DBDELETE() ⇒ NIL
DBDELETE() marks the current record as deleted (*). Records marked for deletion can be filtered
using SET DELETED or removed from the file using the PACK command.
368.14.43 DBEVAL()
DB evaluate
DBEVAL(bBlock,
[bForCondition],
[bWhileCondition],
[nNextRecords],
[nRecord],
[lRest]) ⇒ NIL
bBlock
bForCondition
bWhileCondition
nNextRecords
nRecord
lRest
is a code block to execute for each record processed.
the FOR condition expressed as code block.
the WHILE condition expressed as code block.
is an optional number that specifies the number of records to
process starting with the current record. It is the same as the
NEXT clause.
is an optional record number to process. If this argument is
specified, bBlock will be evaluated for the specified record.
This argument is the same as the RECORD clause.
is an optional logical value that determines whether the scope
of DBEVAL() is all records, or, starting with the current
record, all records to the end of file.
DBEVAL() is a database function that evaluates a single block for each record within the active
alias.
368.14.44 DBFILTER()
DBFILTER() ⇒ cFilter
BFILTER() returns the filter condition defined in the current work area as a character string. If
no FILTER has been SET, DBFILTER() returns a null string ("").
368.14.45 DBGOBOTTOM()
DBGOBOTTOM() ⇒ NIL
DBGOBOTTOM() moves to last logical record in the active alias.

214 volume VIII Argomenti avanzati e accessori
368.14.46 DBGOTO()
DBGOTO(nRecordNumber) ⇒ NIL
nRecordNumber
is a numeric value that specifies the record number of the desired
record.
DBGOTO() moves to the record whose record number is equal to nRecordNumber. If no such
record exists, the work area is positioned to LASTREC() + 1 and both EOF() and BOF() return
true (‘.T.’).
368.14.47 DBGOTOP()
DBGOTOP() ⇒ NIL
DBGOTOP() moves to the first logical record in the current work area.
368.14.48 DBRECALL()
DBRECALL() ⇒ NIL
DBRECALL() causes the current record to be reinstated if it is marked for deletion.
368.14.49 DBREINDEX()
DBREINDEX() ⇒ NIL
DBREINDEX() rebuilds all active indexes associated with the active alias.
368.14.50 DBRELATION()
DBRELATION(nRelation) ⇒ cLinkExp
nRelation
is the position of the desired relation in the list of active alias
relations.
DBRELATION() returns a character string containing the linking expression of the relation specified
by nRelation. If there is no RELATION SET for nRelation, DBRELATION() returns a null
string ("").
368.14.51 DBRLOCK()
DB record lock
DBRLOCK([nRecNo]) ⇒ lSuccess
nRecNo
is the record number to be locked. The default is the current
record.
DBRLOCK() is a database function that locks the record identified by nRecNo or the current

nanoBase 1997 user manual 215
record.
368.14.52 DBRLOCKLIST()
DBRLOCKLIST() ⇒ aRecordLocks
DBRLOCKLIST() returns a one-dimensional array of the locked records in the active alias.
368.14.53 DBRSELECT()
DB relation select
DBRSELECT(nRelation) ⇒ nWorkArea
nRelation
is the position of the desired relation in the list of current work
area relations.
DBRSELECT() returns the work area number of the relation specified by nRelation as an integer
numeric value. If there is no RELATION SET for nRelation, DBRSELECT() returns zero.
368.14.54 DBRUNLOCK()
DB relation unlock
DBRUNLOCK([nRecNo]) ⇒ NIL
nRecNo
is the record number to be unlocked. The default is all previously
locked records.
DBRUNLOCK() is a database function that unlocks the record identified by nRecNo or all
locked records.
368.14.55 DBSEEK()
DBSEEK(expKey, [lSoftSeek]) ⇒ lFound
expKey
lSoftSeek
is a value of any type that specifies the key value associated
with the desired record.
is an optional logical value that specifies whether a soft seek
is to be performed. This determines how the work area is positioned
if the specified key value is not found. If lSoftSeek is
omitted, the current global _SET_SOFTSEEK setting is used.
DBSEEK() returns true (‘.T.’) if the specified key value was found; otherwise, it returns false
(‘.F.’).

216 volume VIII Argomenti avanzati e accessori
368.14.56 DBSELECTAREA()
DBSELECTAREA(nArea | cAlias) ⇒ NIL
nArea
cAlias
is a numeric value between zero and 250, inclusive, that specifies
the work area being selected.
is a character value that specifies the alias of a currently occupied
work area being selected.
DBSELECTAREA() causes the specified work area to become the current work area. All subsequent
database operations will apply to this work area unless another work area is explicitly
specified for an operation.
368.14.57 DBSETDRIVER()
DBSETDRIVER([cDriver]) ⇒ cCurrentDriver
cDriver
DBSETDRIVER() returns the name of the current default driver.
368.14.58 DBSETFILTER()
DBSETFILTER(bCondition, [cCondition]) ⇒ NIL
bCondition
cCondition
is an optional character value that specifies the name of the
database driver that should be used to activate and manage
new work areas when no driver is explicitly specified.
is a code block that expresses the filter condition in executable
form.
is a character value that expresses the filter condition in textual
form. If cCondition is omitted, the DBSETFILTER()
function will return an empty string for the work area.
DBSETFILTER() sets a logical filter condition for the current work area. When a filter is set,
records which do not meet the filter condition are not logically visible. That is, database operations
which act on logical records will not consider these records. The filter expression supplied
to DBSETFILTER() evaluates to true (‘.T.’) if the current record meets the filter condition;
otherwise, it should evaluate to false (‘.F.’).
368.14.59 DBSETINDEX()
DBSETINDEX(cOrderBagName) ⇒ NIL
cOrderBagName
is a character value that specifies the filename of the index file
(index bag) to be opened.
DBSETINDEX() is a database function that adds the contents of an Order Bag into the Order List
of the current work area. Any Orders already associated with the work area continue to be active.

nanoBase 1997 user manual 217
If the newly opened Order Bag is the only Order associated with the work area, it becomes the
controlling Order; otherwise, the controlling Order remains unchanged. If the Order Bag contains
more than one Order, and there are no other Orders associated with the work area, the first Order
in the new Order Bag becomes the controlling Order.
368.14.60 DBSETORDER()
DBSETORDER(nOrderNum) ⇒ NIL
nOrderNum
is a numeric value that specifies which of the active indexes is
to be the controlling index.
DBSETORDER() controls which of the active alias’ active indexes is the controlling index.
368.14.61 DBSETRELATION()
DBSETRELATION(nArea | cAlias, bExpr, [cExpr]) ⇒ NIL
nArea
cAlias
bExpr
cExpr
is a numeric value that specifies the work area number of the
child work area.
is a character value that specifies the alias of the child work
area.
is a code block that expresses the relational expression in executable
form.
is an optional character value that expresses the relational expression
in textual form. If cExpr is omitted, the DBRELA-
TION() function returns an empty string for the relation.
DBSETRELATION() relates the work area specified by nArea or cAlias (the child work area),
to the current work area (the parent work area). Any existing relations remain active.
368.14.62 DBSKIP()
DBSKIP([nRecords]) ⇒ NIL
nRecords
is the number of logical records to move, relative to the current
record. A positive value means to skip forward, and a
negative value means to skip backward. If nRecords is omitted,
a value of 1 is assumed.
DBSKIP() moves either forward or backward relative to the current record. Attempting to skip
forward beyond the last record positions the work area to LASTREC() + 1 and EOF() returns
true (‘.T.’). Attempting to skip backward beyond the first record positions the work area to the
first record and BOF() returns true (‘.T.’).

218 volume VIII Argomenti avanzati e accessori
368.14.63 DBSTRUCT()
DBSTRUCT() ⇒ aStruct
DBSTRUCT() returns the structure of the current database file in an array whose length is equal
to the number of fields in the database file. Each element of the array is a subarray containing
information for one field. The subarrays have the following format:
aStruct[n][1] == cName
aStruct[n][2] == cType
aStruct[n][3] == nLength
aStruct[n][4] == nDecimals
If there is no database file in USE in the current work area, DBSTRUCT() returns an empty array
({}).
368.14.64 DBUNLOCK()
DBUNLOCK() ⇒ NIL
DBUNLOCK() releases any record or file locks obtained by the current process for the current
work area. DBUNLOCK() is only meaningful on a shared database in a network environment.
368.14.65 DBUNLOCKALL()
DBUNLOCKALL() ⇒ NIL
DBUNLOCKALL() releases any record or file locks obtained by the current process for any work
area. DBUNLOCKALL() is only meaningful on a shared database in a network environment.
368.14.66 DBUSEAREA()
DBUSEAREA( [lNewArea], [cDriver], cName, [xcAlias],
[lShared], [lReadonly]) ⇒ NIL
lNewArea
cDriver
cName
xcAlias
lShared
is an optional logical value. A value of true (‘.T.’) selects the
lowest numbered unoccupied work area as the current work
area before the use operation. If lNewArea is false (‘.F.’)
or omitted, the current work area is used; if the work area is
occupied, it is closed first.
is an optional character value. If present, it specifies the name
of the database driver which will service the work area. If
cDriver is omitted, the current default driver is used.
specifies the name of the database (.dbf) file to be opened.
is an optional character value. If present, it specifies the alias
to be associated with the work area. The alias must constitute
a valid identifier. A valid xcAlias may be any legal identifier
(i.e., it must begin with an alphabetic character and may contain
numeric or alphabetic characters and the underscore). If
xcAlias is omitted, a default alias is constructed from cName.
is an optional logical value. If present, it specifies whether the
database (.dbf) file should be accessible to other processes
on a network. A value of true (‘.T.’) specifies that other processes
should be allowed access; a value of false (‘.F.’) specifies
that the current process is to have exclusive access. If
lShared is omitted, the current global _SET_EXCLUSIVE
setting determines whether shared access is allowed.

nanoBase 1997 user manual 219
lReadonly
DBUSEAREA() opens the specified database (.DBF).
368.14.67 DBDELETE()
DELETED() ⇒ lDeleted
is an optional logical value that specifies whether updates to
the work area are prohibited. A value of true (‘.T.’) prohibits
updates; a value of false (‘.F.’) permits updates. A value
of true (‘.T.’) also permits read-only access to the specified
database (.dbf) file. If lReadonly is omitted, the default value
is false (‘.F.’).
DELETED() returns true (‘.T.’) if the current record is marked for deletion; otherwise, it returns
false (‘.F.’). If there is no database file in USE in the current work area, DELETED() returns
false (‘.F.’).
368.14.68 DESCEND()
DESCEND(exp) ⇒ ValueInverted
exp
is any valid expression of character, date, logical, or numeric
type.
DESCEND() returns an inverted expression of the same data type as the exp, except for dates
which return a numeric value. A DESCEND() of CHR(0) always returns CHR(0).
368.14.69 DEVOUT()
Device output
DEVOUT(exp, [cColorString]) ⇒ NIL
exp is the value to display.
cColorString is an optional argument that defines the display color of exp.
DEVOUT() is a full-screen display function that writes the value of a single expression to the
current device at the current cursor or printhead position.
368.14.70 DEVOUTPICT()
Device output picture
DEVOUTPICT(exp, cPicture, [cColorString]) ⇒ NIL
exp is the value to display.
cPicture
defines the formatting control for the display of exp.
cColorString is an optional argument that defines the display color of exp.

220 volume VIII Argomenti avanzati e accessori
DEVOUTPICT() is a full-screen display function that writes the value of a single expression to
the current device at the current cursor or printhead position.
368.14.71 DEVPOS()
Device position
DEVPOS(nRow, nCol) ⇒ NIL
nRow, nCol
are the new row and column positions of the cursor or printhead.
DEVPOS() is an environment function that moves the screen or printhead depending on the
current DEVICE.
368.14.72 DIRECTORY()
DIRECTORY(cDirSpec, [cAttributes]) ⇒ aDirectory
cDirSpec
cAttributes
identifies the drive, directory and file specification for the directory
search. Wildcards are allowed in the file specification.
If cDirSpec is omitted, the default value is *.*.
specifies inclusion of files with special attributes in the returned
information. cAttributes is a string containing one or
more of the following characters:
H Include hidden files
S Include system files
D Include directories
V Search for the DOS volume label only
Normal files are always included in the search, unless you
specify V.
DIRECTORY() returns an array of subarrays, with each subarray containing information about
each file matching cDirSpec. The subarray has the following structure:
aDirectory[n][1] == cName
aDirectory[n][2] == cSize
aDirectory[n][3] == dDate
aDirectory[n][4] == cTime
aDirectory[n][5] == cAttributes
If no files are found matching cDirSpec or if cDirSpec is an illegal path or file specification,
DIRECTORY() returns an empty ({}) array.
368.14.73 DISKSPACE()
DISKSPACE([nDrive]) ⇒ nBytes
nDrive
is the number of the drive to query, where one is drive A, two
is B, three is C, etc. The default is the current DOS drive if
nDrive is omitted or specified as zero.

nanoBase 1997 user manual 221
DISKSPACE() returns the number of bytes of empty space on the specified disk drive as an
integer numeric value.
368.14.74 DISPBOX()
Display box
DISPBOX(nTop, nLeft, nBottom, nRight,
[cnBoxString], [cColorString]) ⇒ NIL
nTop, nLeft, nBottom, nRight define the coordinates of the box.
is a numeric or character expression that defines the border
characters of the box. If specified as a numeric expression, a
value of 1 displays a single-line box and a value of 2 displays
cnBoxString
a double-line box. All other numeric values display a singleline
box. If cnBoxString is a character expression, it specifies
the characters to be used in drawing the box. This is a string
of eight border characters and a fill character.
cColorString defines the display color of the box that is drawn.
DISPBOX() is a screen function that draws a box at the specified display coordinates in the
specified color.
368.14.75 DISPOUT()
Display out
DISPOUT(exp, [cColorString]) ⇒ NIL
exp is the value to display.
cColorString is an optional argument that defines the display color of exp.
cColorString is a character expression containing the standard color setting.
DISPOUT() is a simple output function that writes the value of a single expression to the display
at the current cursor position. This function ignores the SET DEVICE setting; output always goes
to the screen.
368.14.76 DOW()
Day of week
DOW(dDate) ⇒ nDay
dDate is a date value to convert.
DOW() returns the day of the week as a number between zero and seven. The first day of the
week is one (Sunday) and the last day is seven (Saturday). If dDate is empty, DOW() returns
zero.

222 volume VIII Argomenti avanzati e accessori
368.14.77 DTOC()
Date to character
DTOC(dDate) ⇒ cDate
dDate is the date value to convert.
DTOC() returns a character string representation of a date value. The return value is formatted in
the current date format. A null date returns a string of spaces equal in length to the current date
format.
368.14.78 DTOS()
Date to sort
DTOS(dDate) ⇒ cDate
dDate is the date value to convert.
DTOS() returns a character string eight characters long in the form, yyyymmdd. When dDate is
a null date (CTOD("")), DTOS() returns a string of eight spaces.
368.14.79 EMPTY()
EMPTY(exp) ⇒ lEmpty
exp is an expression of any data type.
EMPTY() returns true (‘.T.’) if the expression results in an empty value; otherwise, it returns
false (‘.F.’):
Array {}
Character/Memo
Spaces, tabs, CR/LF, or ""
Numeric 0
Date CTOD("")
Logical ‘.F.’
NIL NIL
368.14.80 EOF()
End of file
EOF() ⇒ lBoundary
EOF() returns true (‘.T.’) when an attempt is made to move the record pointer beyond the last
logical record in a database file; otherwise, it returns false (‘.F.’). If there is no database file
open in the current work area, EOF() returns false (‘.F.’). If the current database file contains
no records, EOF() returns true (‘.T.’).

nanoBase 1997 user manual 223
368.14.81 EVAL()
Code block evaluation
EVAL(bBlock, [BlockArg_list]) ⇒ LastBlockValue
bBlock is the code block to evaluate.
BlockArg_list
is a list of arguments to send to the code block before it is
evaluated.
To execute or evaluate a code block, call EVAL() with the block value and any parameters.
The parameters are supplied to the block when it is executed. Code blocks may be a series of
expressions separated by commas. When a code block is evaluated, the returned value is the
value of the last expression in the block.
368.14.82 EXP()
Exponent
EXP(nExponent) ⇒ nAntilogarithm
nExponent
is the natural logarithm for which a numeric value is to be
calculated.
EXP() returns a numeric value that is equivalent to the value e raised to the specified power.
368.14.83 FCLOSE()
File close
FCLOSE(nHandle) ⇒ lError
nHandle
is the file handle obtained previously from FOPEN() or
FCREATE().
FCLOSE() is a low-level file function that closes binary files and forces the associated DOS
buffers to be written to disk. If the operation fails, FCLOSE() returns false (‘.F.’). FERROR()
can then be used to determine the reason for the failure.
368.14.84 FCOUNT()
Field count
FCOUNT() ⇒ nFields
FCOUNT() returns the number of fields in the database file in the active alias as an integer
numeric value. If there is no database file open, FCOUNT() returns zero.

224 volume VIII Argomenti avanzati e accessori
368.14.85 FCREATE()
Field create
FCREATE(cFile, [nAttribute]) ⇒ nHandle
cFile
nAttribute
is the name of the file to create. If the file already exists, its
length is truncated to zero without warning.
is the binary file attribute, the default value is zero.
nAttribute = 0 Normal (default)
nAttribute = 1 Read-only
nAttribute = 2 Hidden
nAttribute = 4 System
FCREATE() returns the DOS file handle number of the new binary file in the range of zero to
65,535. If an error occurs, FCREATE() returns -1 and FERROR() is set to indicate an error code.
368.14.86 FERASE()
File erase
FERASE(cFile) ⇒ nSuccess
cFile
is the name (with or without path) of the file to be deleted
from disk.
FERASE() is a file function that deletes a specified file from disk. FERASE() returns -1 if the
operation fails and zero if it succeeds.
368.14.87 FERROR()
File error
FERROR() ⇒ nErrorCode
FERROR() returns the DOS error from the last file operation as an integer numeric value. If there
is no error, FERROR() returns zero.
nErrorCode value
Meaning
0 Successful
2 File not found
3 Path not found
4
Too many files open
5 Access denied
6 Invalid handle
8
Insufficient memory
15
Invalid drive specified
19 Attempted to write to a write-protected disk
21
Drive not ready
23 Data CRC error
29 Write fault
30 Read fault
32
Sharing violation
33 Lock Violation

nanoBase 1997 user manual 225
FERROR() is a low-level file function that indicates a DOS error after a file function is used.
368.14.88 FIELDBLOCK()
FIELDBLOCK(cFieldName) ⇒ bFieldBlock
cFieldName
is the name of the field to which the set-get block will refer.
FIELDBLOCK() returns a code block that, when evaluated, sets (assigns) or gets (retrieves) the
value of the given field. If cFieldName does not exist in the current work area, FIELDBLOCK()
returns NIL.
368.14.89 FIELDGET()
FIELDGET(nField) ⇒ ValueField
nField
is the ordinal position of the field in the record structure for
the current work area.
FIELDGET() returns the value of the specified field. If nField does not correspond to the position
of any field in the current database file, FIELDGET() returns NIL.
368.14.90 FIELDNAME()
FIELDNAME(nPosition) ⇒ cFieldName
nPosition
is the position of a field in the database file structure.
FIELDNAME() returns the name of the specified field as a character string. If nPosition does
not correspond to an existing field in the current database file or if no database file is open in the
current work area, FIELDNAME() returns a null string ("").
368.14.91 FIELDPOS()
Field position
FIELDPOS(cFieldName) ⇒ nFieldPos
cFieldName
is the name of a field in the current or specified work area.
FIELDPOS() returns the position of the specified field within the list of fields associated with
the current or specified work area. If the current work area has no field with the specified name,
FIELDPOS() returns zero.

226 volume VIII Argomenti avanzati e accessori
368.14.92 FIELDPUT()
FIELDPUT(nField, expAssign) ⇒ ValueAssigned
nField
expAssign
is the ordinal position of the field in the current database file.
is the value to assign to the given field. The data type of this
expression must match the data type of the designated field
variable.
FIELDPUT() is a database function that assigns expAssign to the field at ordinal position nField
in the current work area. This function allows you to set the value of a field using its position
within the database file structure rather than its field name.
368.14.93 FIELDWBLOCK()
Field work area block
FIELDWBLOCK(cFieldName, nWorkArea) ⇒ bFieldWBlock
cFieldName
nWorkArea
is the name of the field specified as a character string.
is the work area number where the field resides specified as a
numeric value.
FIELDWBLOCK() returns a code block that, when evaluated, sets (assigns) or gets (retrieves)
the value of cFieldName in the work area designated by nWorkArea. If cFieldName does not
exist in the specified work area, FIELDWBLOCK() returns NIL.
368.14.94 FILE()
FILE(cFilespec) ⇒ lExists
cFilespec
is in the current default directory and path. It is a standard file
specification that can include the wildcard characters * and ?
as well as a drive and path reference.
FILE() returns true (‘.T.’) if there is a match for any file matching the cFilespec pattern; otherwise,
it returns false (‘.F.’).
368.14.95 FLOCK()
File lock
FLOCK() ⇒ lSuccess
FLOCK() tries to lock the active alias and returns true (‘.T.’) if it succeeds; otherwise, it returns
false (‘.F.’).

nanoBase 1997 user manual 227
368.14.96 FOPEN()
File open
FOPEN(cFile, [nMode]) ⇒ nHandle
cFile
nMode
is the name of the file to open including the path if there is
one.
is the requested DOS open mode indicating how the opened
file is to be accessed. The open mode is composed of the sum
of two elements: the Open mode and the Sharing mode.
Open mode:
0 Open for reading (default)
1 Open for writing
2 Open for reading or writing
Sharing mode:
0 Compatibility mode (default)
16 Exclusive use
32 Prevent others from writing
48 Prevent others from reading
64 Allow others to read or write
FOPEN() returns the file handle of the opened file in the range of zero to 65,535. If an error
occurs, FOPEN() returns -1.
368.14.97 FOUND()
FOUND() ⇒ lSuccess
FOUND() returns true (‘.T.’) if the last search command was successful; otherwise, it returns
false (‘.F.’).
368.14.98 FREAD()
File read
FREAD(nHandle, @cBufferVar, nBytes) ⇒ nBytes
is the file handle obtained from FOPEN(), FCREATE(), or
nHandle
predefined by DOS.
is the name of an existing and initialized character variable
used to store data read from the specified file. The length
cBufferVar
of this variable must be greater than or equal to nBytes.
cBufferVar must be passed by reference and, therefore, must
be prefaced by the pass-by-reference operator (@).
nBytes is the number of bytes to read into the buffer.
FREAD() tries to read nBytes of the binary file nHandle inside cBufferVar. It returns the number
of bytes successfully read as an integer numeric value. A return value less than nBytes or
zero indicates end of file or some other read error.

228 volume VIII Argomenti avanzati e accessori
368.14.99 FREADSTR()
File read string
FREADSTR(nHandle, nBytes) ⇒ cString
nHandle
nBytes
is the file handle obtained from FOPEN(), FCREATE(), or
predefined by DOS.
is the number of bytes to read, beginning at the current DOS
file pointer position.
FREADSTR() returns a character string up to 65,535 (64K) bytes. A null return value ("") indicates
an error or end of file. FREADSTR() is a low-level file function that reads characters from
an open binary file beginning with the current DOS file pointer position. Characters are read up
to nBytes or until a null character (CHR(0)) is encountered. All characters are read including
control characters except for CHR(0). The file pointer is then moved forward nBytes. If nBytes
is greater than the number of bytes from the pointer position to the end of the file, the file pointer
is positioned to the last byte in the file.
368.14.100 FRENAME()
File rename
FRENAME(cOldFile, cNewFile) ⇒ nSuccess
cOldFile
cNewFile
is the name of the file to rename, including the file extension.
A drive letter and/or path name may also be included as part
of the filename.
is the new name of the file, including the file extension. A
drive letter and/or path name may also be included as part of
the name.
FRENAME() returns -1 if the operation fails and zero if it succeeds.
368.14.101 FSEEK()
File seek
FSEEK(nHandle, nOffset, [nOrigin]) ⇒ nPosition
is the file handle obtained from FOPEN(), FCREATE(), or
nHandle
predefined by DOS.
is the number of bytes to move the file pointer from the position
defined by nOrigin. It can be a positive or negative
nOffset
number. A positive number moves the pointer forward, and
a negative number moves the pointer backward in the file.
defines the starting location of the file pointer before FSEEK()
is executed. The default value is zero, representing the begin-
nOrigin
ning of file. If nOrigin is the end of file, nOffset must be zero
or negative.
nOrigin == 0 Seek from beginning of file
nOrigin == 1 Seek from the current pointer position
nOrigin == 2 Seek from end of file

nanoBase 1997 user manual 229
FSEEK() returns the new position of the file pointer relative to the beginning of file (position
0) as an integer numeric value. This value is without regard to the original position of the file
pointer. FSEEK() is a low-level file function that moves the file pointer forward or backward
in an open binary file without actually reading the contents of the specified file. The beginning
position and offset are specified as function arguments, and the new file position is returned.
368.14.102 FWRITE()
File write
FWRITE(nHandle, cBuffer, [nBytes]) ⇒ nBytesWritten
nHandle
is the file handle obtained from FOPEN(), FCREATE(), or
predefined by DOS.
cBuffer is the character string to write to the specified file.
nBytes
indicates the number of bytes to write beginning at the current
file pointer position. If omitted, the entire content of cBuffer
is written.
FWRITE() returns the number of bytes written as an integer numeric value. If the value returned
is equal to nBytes, the operation was successful. If the return value is less than nBytes or zero,
either the disk is full or another error has occurred.
368.14.103 GETENV()
Get environment
GETENV(cEnvironmentVariable) ⇒ cString
cEnvironmentVariable
is the name of the DOS environment variable. When specifying
this argument, you can use any combination of upper and
lowercase letters; GETENV() is not case- sensitive.
GETENV() returns the contents of the specified DOS environment variable as a character string.
If the variable cannot be found, GETENV() returns a null string ("").
368.14.104 HARDCR()
Hard carriage return
HARDCR(cString) ⇒ cConvertedString
cString is the character string or memo field to convert.
HARDCR() is a memo function that replaces all soft carriage returns (CHR(141)) with hard carriage
returns (CHR(13)). It is used to display long character strings and memo fields containing
soft carriage returns with console commands.

230 volume VIII Argomenti avanzati e accessori
368.14.105 HEADER()
HEADER() ⇒ nBytes
HEADER() returns the number of bytes in the header of the current database file as an integer
numeric value. If no database file is in use, HEADER() returns a zero (0).
368.14.106 I2BIN()
Integer to binary
I2BIN(nInteger) ⇒ cBinaryInteger
nInteger
is an integer numeric value to convert. Decimal digits are truncated.
I2BIN() returns a two-byte character string containing a 16-bit binary integer.
368.14.107 IF()
[I]IF(lCondition, expTrue, expFalse) ⇒ Value
lCondition
expTrue
expFalse
is a logical expression to be evaluated.
is the value, a condition-expression, of any data type, returned
if lCondition is true (‘.T.’).
is the value, of any date type, returned if lCondition is false
(‘.F.’). This argument need not be the same data type as
expTrue.
IF() returns the evaluation of expTrue if lCondition evaluates to true (‘.T.’) and expFalse if it
evaluates to false (‘.F.’).
368.14.108 INDEXEXT()
Index extention
INDEXEXT() ⇒ cExtension
INDEXEXT() returns the default index file extension by determining which database driver is
currently linked.
368.14.109 INDEXKEY()
INDEXKEY(nOrder) ⇒ cKeyExp
nOrder
is the ordinal position of the index in the list of index files
opened by the last USE...INDEX or SET INDEX TO command
for the current work area. A zero value specifies the
controlling index, without regard to its actual position in the
list.

nanoBase 1997 user manual 231
INDEXKEY() returns the key expression of the specified index as a character string. If there is
no corresponding index or if no database file is open, INDEXKEY() returns a null string ("").
368.14.110 INDEXORD()
Index order
INDEXORD() ⇒ nOrder
INDEXORD() returns an integer numeric value. The value returned is equal to the position of the
controlling index in the list of open indexes for the current work area. A value of zero indicates
that there is no controlling index and records are being accessed in natural order. If no database
file is open, INDEXORD() will also return a zero.
368.14.111 INKEY()
Input key
INKEY([nSeconds]) ⇒ nInkeyCode
nSeconds
specifies the number of seconds INKEY() waits for a keypress.
You can specify the value in increments as small as
one-tenth of a second. Specifying zero halts the program until
a key is pressed. If nSeconds is omitted, INKEY() does not
wait for a keypress.
INKEY() returns an integer numeric value from -39 to 386, identifying the key extracted from
the keyboard buffer. If the keyboard buffer is empty, INKEY() returns zero. INKEY() returns
values for all ASCII characters, function, Alt+function, Ctrl+function, Alt+letter, and Ctrl+letter
key combinations.
nInkeyCode value Key or key combination
5 [ Up arrow ], [ Ctrl ]+E
24 [ Down arrow ], [ Ctrl ]+X
19 [ Left arrow ], [ Ctrl ]+S
4 [ Right arrow ], [ Ctrl ]+D
1 [ Home ], [ Ctrl ]+A
6 [ End ], [ Ctrl ]+F
18 [ PgUp ], [ Ctrl ]+R
3 [ PgDn ], [ Ctrl ]+C
397
[ Ctrl ]+[ Up arrow ]
401
[ Ctrl ]+[ Down arrow ]
26 [ Ctrl ]+[ Left arrow ], [ Ctrl ]+Z
2 [ Ctrl ]+[ Right arrow ], [ Ctrl ]+B
29
[ Ctrl ]+[ Home ]
23 [ Ctrl ]+[ End ], [ Ctrl ]+W
31
[ Ctrl ]+[ PgUp ], [ Ctrl ]+Hyphen
30 [ Ctrl ]+[ PgDn ], [ Ctrl ]+^
408
[ Alt ]+[ Up arrow ]
416
[ Alt ]+[ Down arrow ]
411
[ Alt ]+[ Left arrow ]
413
[ Alt ]+[ Right arrow ]
407
[ Alt ]+[ Home ]

232 volume VIII Argomenti avanzati e accessori
nInkeyCode value Key or key combination
415
[ Alt ]+[ End ]
409
[ Alt ]+[ PgUp ]
417
[ Alt ]+[ PgDn ]
13 [ Enter ], [ Ctrl ]+M
32
Space bar
27 Esc
10
[ Ctrl ]+[ Enter ]
379 [ Ctrl ]+Print Screen
309 [ Ctrl ]+?
284
[ Alt ]+[ Enter ]
387
[ Alt ]+Equals
257 [ Alt ]+Esc
422
Keypad [ Alt ]+[ Enter ]
399 Keypad [ Ctrl ]+5
405
Keypad [ Ctrl ]+/
406
Keypad [ Ctrl ]+*
398 Keypad [ Ctrl ]+-
400
Keypad [ Ctrl ]++
5
Keypad [ Alt ]+5
420
Keypad [ Alt ]+/
311
Keypad [ Alt ]+*
330
Keypad [ Alt ]+-
334
Keypad [ Alt ]++
22 [ Ins ], [ Ctrl ]+V
7 [ Del ], [ Ctrl ]+G
8 [ Backspace ], [ Ctrl ]+H
9 [ Tab ], [ Ctrl ]+I
271
[ Shift ]+[ Tab ]
402
[ Ctrl ]+[ Ins ]
403
[ Ctrl ]+[ Del ]
127
[ Ctrl ]+[ Backspace ]
404
[ Ctrl ]+[ Tab ]
418
[ Alt ]+[ Ins ]
419
[ Alt ]+[ Del ]
270
[ Alt ]+[ Backspace ]
421
[ Alt ]+[ Tab ]
1 [ Ctrl ]+A, [ Home ]
2 [ Ctrl ]+B, [ Ctrl ]+[ Right arrow ]
3 [ Ctrl ]+C, [ PgDn ], [ Ctrl ]+[ ScrollLock ]
4 [ Ctrl ]+D, [ Right arrow ]
5 [ Ctrl ]+E, [ Up arrow ]
6 [ Ctrl ]+F, [ End ]
7 [ Ctrl ]+G, [ Del ]
8 [ Ctrl ]+H, [ Backspace ]
9 [ Ctrl ]+I, [ Tab ]
10 [ Ctrl ]+J
11 [ Ctrl ]+K
12 [ Ctrl ]+L
13 [ Ctrl ]+M, Return
14 [ Ctrl ]+N
15 [ Ctrl ]+O
16 [ Ctrl ]+P
17 [ Ctrl ]+Q

nanoBase 1997 user manual 233
nInkeyCode value Key or key combination
18 [ Ctrl ]+R, [ PgUp ]
19 [ Ctrl ]+S, [ Left arrow ]
20 [ Ctrl ]+T
21 [ Ctrl ]+U
22 [ Ctrl ]+V, [ Ins ]
23 [ Ctrl ]+W, [ Ctrl ]+[ End ]
24 [ Ctrl ]+X, [ Down arrow ]
25 [ Ctrl ]+Y
26 [ Ctrl ]+Z, [ Ctrl ]+[ Left arrow ]
286 [ Alt ]+A
304 [ Alt ]+B
302 [ Alt ]+C
288 [ Alt ]+D
274 [ Alt ]+E
289 [ Alt ]+F
290 [ Alt ]+G
291 [ Alt ]+H
279 [ Alt ]+I
292 [ Alt ]+J
293 [ Alt ]+K
294 [ Alt ]+L
306 [ Alt ]+M
305 [ Alt ]+N
280 [ Alt ]+O
281 [ Alt ]+P
272 [ Alt ]+Q
275 [ Alt ]+R
287 [ Alt ]+S
276 [ Alt ]+T
278 [ Alt ]+U
303 [ Alt ]+V
273 [ Alt ]+W
301 [ Alt ]+X
277 [ Alt ]+Y
300 [ Alt ]+Z
376 [ Alt ]+1
377 [ Alt ]+2
378 [ Alt ]+3
379 [ Alt ]+4
380 [ Alt ]+5
381 [ Alt ]+6
382 [ Alt ]+7
383 [ Alt ]+8
384 [ Alt ]+9
385 [ Alt ]+0
28 F1, [ Ctrl ]+[ Backslash ]
-1 F2
-2 F3
-3 F4
-4 F5
-5 F6
-6 F7
-7 F8

234 volume VIII Argomenti avanzati e accessori
nInkeyCode value Key or key combination
-8 F9
-9 F10
-40 F11
-41 F12
-20 [ Ctrl ]+F1
-21 [ Ctrl ]+F2
-22 [ Ctrl ]+F4
-23 [ Ctrl ]+F3
-24 [ Ctrl ]+F5
-25 [ Ctrl ]+F6
-26 [ Ctrl ]+F7
-27 [ Ctrl ]+F8
-28 [ Ctrl ]+F9
-29 [ Ctrl ]+F10
-44 [ Ctrl ]+F11
-45 [ Ctrl ]+F12
-30 [ Alt ]+F1
-31 [ Alt ]+F2
-32 [ Alt ]+F3
-33 [ Alt ]+F4
-34 [ Alt ]+F5
-35 [ Alt ]+F6
-36 [ Alt ]+F7
-37 [ Alt ]+F8
-38 [ Alt ]+F9
-39 [ Alt ]+F10
-46 [ Alt ]+F11
-47 [ Alt ]+F12
-10 [ Shift ]+F1
-11 [ Shift ]+F2
-12 [ Shift ]+F3
-13 [ Shift ]+F4
-14 [ Shift ]+F5
-15 [ Shift ]+F6
-16 [ Shift ]+F7
-17 [ Shift ]+F8
-18 [ Shift ]+F9
-19 [ Shift ]+F10
-42 [ Shift ]+F11
-43 [ Shift ]+F12
368.14.112 INT()
Integer
INT(nExp) ⇒ nInteger
nExp is a numeric expression to convert to an integer.
INT() is a numeric function that converts a numeric value to an integer by truncating all digits
to the right of the decimal point. INT() is useful in operations where the decimal portion of a

nanoBase 1997 user manual 235
number is not needed.
368.14.113 ISALPHA()
ISALPHA(cString) ⇒ lBoolean
cString is the character string to examine.
ISALPHA() returns true (‘.T.’) if the first character in cString is alphabetic; otherwise, it returns
false (‘.F.’).
368.14.114 ISCOLOR()
ISCOLOR() | ISCOLOUR() ⇒ lBoolean
ISCOLOR() returns true (‘.T.’) if there is a color graphics card installed; otherwise, it returns
false (‘.F.’).
368.14.115 ISDIGIT()
ISDIGIT(cString) ⇒ lBoolean
cString is the character string to examine.
ISDIGIT() returns true (‘.T.’) if the first character of the character string is a digit between zero
and nine; otherwise, it returns false (‘.F.’).
368.14.116 ISLOWER()
ISLOWER(cString) ⇒ lBoolean
cString is the character string to examine.
ISLOWER() returns true (‘.T.’) if the first character of the character string is a lowercase letter;
otherwise, it returns false (‘.F.’).
368.14.117 ISPRINTER()
ISPRINTER() ⇒ lReady
ISPRINTER() returns true (‘.T.’) if ‘LPT1:’ is ready; otherwise, it returns false (‘.F.’).

236 volume VIII Argomenti avanzati e accessori
368.14.118 ISUPPER()
ISUPPER(cString) ⇒ lBoolean
cString is the character string to examine.
ISUPPER() returns true (‘.T.’) if the first character is an uppercase letter; otherwise, it returns
false (‘.F.’).
368.14.119 L2BIN()
Long to binary
L2BIN(nExp) ⇒ cBinaryInteger
nExp is the numeric value to convert. Decimal digits are truncated.
L2BIN() returns a four-byte character string formatted as a 32- bit binary integer.
368.14.120 LASTKEY()
LASTKEY() ⇒ nInkeyCode
LASTKEY() is a keyboard function that reports the INKEY() value of the last key fetched from
the keyboard buffer by the INKEY() function, or a wait state. LASTKEY() retains its current
value until another key is fetched from the keyboard buffer.
368.14.121 LASTREC()
Last record
LASTREC() ⇒ nRecords
LASTREC() returns the number of physical records in the active alias as an integer numeric
value.
368.14.122 LEFT()
LEFT(cString, nCount) ⇒ cSubString
cString is a character string from which to extract characters.
nCount is the number of characters to extract.
LEFT() returns the leftmost nCount characters of cString as a character string. If nCount is
negative or zero, LEFT() returns a null string (""). If nCount is larger than the length of the
character string, LEFT() returns the entire string.

nanoBase 1997 user manual 237
368.14.123 LEN()
Length
LEN(cString | aTarget) ⇒ nCount
cString is the character string to count.
aTarget is the array to count.
LEN() returns the length of a character string or the number of elements in an array as an integer
numeric value.
368.14.124 LOG()
LOG(nExp) ⇒ nNaturalLog
nExp
is a numeric value greater than zero to convert to its natural
logarithm.
LOG() returns the natural logarithm as a numeric value. If nExp is less than or equal to zero,
LOG() returns a numeric overflow (displayed as a row of asterisks).
368.14.125 LOWER()
LOWER(cString) ⇒ cLowerString
cString is a character string to convert to lowercase.
LOWER() returns a copy of cString with all alphabetic characters converted to lowercase.
368.14.126 LTRIM()
Left trim
LTRIM(cString) ⇒ cTrimString
cString is the character string to copy without leading spaces.
LTRIM() returns a copy of cString with the leading spaces removed.
368.14.127 LUPDATE()
Last update
LUPDATE() ⇒ dModification
LUPDATE() returns the date of last change to the open database file in the current work area.

238 volume VIII Argomenti avanzati e accessori
368.14.128 MAX()
MAX(nExp1, nExp2) ⇒ nLarger
MAX(dExp1, dExp2) ⇒ dLarger
nExp1, nExp2 are the numeric values to compare.
dExp1, dExp2 are the date values to compare.
MAX() returns the larger of the two arguments. The value returned is the same type as the arguments.
368.14.129 MAXCOL()
Max column
MAXCOL() ⇒ nColumn
MAXCOL() returns the column number of the rightmost visible column for display purposes.
368.14.130 MAXROW()
MAXROW() ⇒ nRow
MAXROW() returns the row number of the bottommost visible row for display purposes.
368.14.131 MEMOEDIT()
MEMOEDIT([cString],
[nTop], [nLeft],
[nBottom], [nRight],
[lEditMode],
[cUserFunction],
[nLineLength],
[nTabSize],
[nTextBufferRow],
[nTextBufferColumn],
[nWindowRow],
[nWindowColumn]) ⇒ cTextBuffer
cString
nTop, nLeft, nBottom, nRight
lEditMode
cUserFunction
nLineLength
is the character string or memo field to copy to the MEM-
OEDIT() text buffer.
are window coordinates. The default coordinates are 0, 0,
MAXROW(), and MAXCOL().
determines whether the text buffer can be edited or merely
displayed. If not specified, the default value is true (‘.T.’).
is the name of a user-defined function that executes when the
user presses a key not recognized by MEMOEDIT() and when
no keys are pending in the keyboard buffer.
determines the length of lines displayed in the MEMOEDIT()
window. If a line is greater than nLineLength, it is word
wrapped to the next line in the MEMOEDIT() window. The
default line length is (nRight - nLeft).

nanoBase 1997 user manual 239
nTabSize
nTextBufferRow,
nTextBufferColumn
nWindowRow, nWindowColumn
determines the size of a tab character to insert when the user
presses Tab. The default is four.
define the display position of the cursor within the text buffer
when MEMOEDIT() is invoked. nTextBufferRow begins
with one and nTextBufferColumn begins with zero. Default
is the beginning of MEMOEDIT() window.
define the initial position of the cursor within the MEM-
OEDIT() window. Row and column positions begin with zero.
If these arguments are not specified, the initial window position
is row zero and the current cursor column position.
MEMOEDIT() is a user interface and general purpose text editing function that edits memo fields
and long character strings. Editing occurs within a specified window region placed anywhere on
the screen.
[ Uparrow ]/[ Ctrl ]+E Move up one line
[ Dnarrow ]/[ Ctrl ]+X Move down one line
[ Leftarrow ]/[ Ctrl ]+S Move left one character
[ Rightarrow ]/[ Ctrl ]+D Move right one character
[ Ctrl ]-[ Leftarrow ]/[ Ctrl ]+A Move left one word
[ Ctrl ]-[ Rightarrow ]/[ Ctrl ]+F Move right one word
[ Home ] Move to beginning of current line
[ End ] Move to end of current line
[ Ctrl ]+[ Home ] Move to beginning of current window
[ Ctrl ]+[ End ] Move to end of current window
[ PgUp ] Move to previous edit window
[ PgDn ] Move to next edit window
[ Ctrl ]+[ PgUp ] Move to beginning of memo
[ Ctrl ]+[ PgDn ] Move to end of memo
[ Return ] Move to beginning of next line
[ Delete ] Delete character at cursor
[ Backspace ] Delete character to left of cursor
[ Tab ] Insert tab character or spaces
Printable characters Insert character
[ Ctrl ]+Y Delete the current line
[ Ctrl ]+T Delete word right
[ Ctrl ]+B Reform paragraph
[ Ctrl ]+V/[ Ins ] Toggle insert mode
[ Ctrl ]+W Finish editing with save
[ Esc ] Abort edit and return original
368.14.132 MEMOLINE()
MEMOLINE(cString,
[nLineLength],
[nLineNumber],
[nTabSize],
[lWrap]) ⇒ cLine
cString
nLineLength
is the memo field or character string from which to extract a
line of text.
specifies the number of characters per line and can be between
four and 254 . If not specified, the default line length is 79.

240 volume VIII Argomenti avanzati e accessori
nLineNumber
is the line number to extract. If not specified, the default value
is one.
nTabSize defines the tab size. If not specified, the default value is four.
lWrap
toggles word wrap on and off. Specifying true (‘.T.’) toggles
word wrap on; false (‘.F.’) toggles it off. If not specified, the
default value is true (‘.T.’).
MEMOLINE() returns the line of text specified by nLineNumber in cString as a character string.
If the line has fewer characters than the indicated length, the return value is padded with blanks.
If the line number is greater than the total number of lines in cString, MEMOLINE() returns a
null string (""). If lWrap is true (‘.T.’) and the indicated line length breaks the line in the middle
of a word, that word is not included as part of the return value but shows up at the beginning of
the next line extracted with MEMOLINE(). If lWrap is false (‘.F.’), MEMOLINE() returns only
the number of characters specified by the line length. The next line extracted by MEMOLINE()
begins with the character following the next hard carriage return, and all intervening characters
are not processed.
368.14.133 MEMOREAD()
MEMOREAD(cFile) ⇒ cString
cFile
is the name of the file to read from disk. It must include an
extension if there is one, and can optionally include a path.
MEMOREAD() returns the contents of a text file as a character string.
368.14.134 MEMORY()
MEMORY(nExp) ⇒ nKbytes
nExp
is a numeric value that determines the type of value MEM-
ORY() returns.
MEMORY() returns an integer numeric value representing the amount of memory available.
MEMORY(0) Estimated total space available for character values
MEMORY(1) Largest contiguous block available for character values
MEMORY(2) Area available for RUN commands
368.14.135 MEMOTRAN()
Memo translate
MEMOTRAN(cString,
[cReplaceHardCR],
[cReplaceSoftCR]) ⇒ cNewString
cString is the character string or memo field to search.
cReplaceHardCR
is the character to replace a hard carriage return/linefeed pair
with. If not specified, the default value is a semicolon (;).

nanoBase 1997 user manual 241
cReplaceSoftCR
is the character to replace a soft carriage return/linefeed pair
with. If not specified, the default value is a space.
MEMOTRAN() returns a copy of cString with the specified carriage return/linefeed pairs replaced.
368.14.136 MEMOWRIT()
Memo write
MEMOWRIT(cFile, cString) ⇒ lSuccess
cFile
is the name of the target disk file including the file extension
and optional path and drive designator.
cString is the character string or memo field to write to cFile.
MEMOWRIT() is a memo function that writes a character string or memo field to a disk file.
If a path is not specified, MEMOWRIT() writes cFile to the current DOS directory and not the
current DEFAULT directory. If cFile already exists, it is overwritten. MEMOWRIT() returns true
(‘.T.’) if the writing operation is successful; otherwise, it returns false (‘.F.’).
368.14.137 MEMVARBLOCK()
MEMVARBLOCK(cMemvarName) ⇒ bMemvarBlock
cMemvarName
is the name of the variable referred to by the set-get block,
specified as a character string.
MEMVARBLOCK() returns a code block that when evaluated sets (assigns) or gets (retrieves)
the value of the given memory variable. If cMemvarName does not exist, MEMVARBLOCK()
returns NIL.
368.14.138 MIN()
MIN(nExp1, nExp2) ⇒ nSmaller
MIN(dExp1, dExp2) ⇒ dSmaller
nExp1, nExp2 are the numeric values to compare.
dExp1, dExp2 are the date values to compare.
MIN() returns the smaller of the two arguments. The value returned is the same data type as the
arguments.

242 volume VIII Argomenti avanzati e accessori
368.14.139 MLCOUNT()
Memo line count
MLCOUNT(cString, [nLineLength],
[nTabSize], [lWrap]) ⇒ nLines
cString is the character string or memo field to count.
nLineLength
specifies the number of characters per line and can range from
four to 254 . If not specified, the default line length is 79.
nTabSize defines the tab size. If not specified, the default value is four.
toggles word wrap on and off. Specifying true (‘.T.’) toggles
lWrap
word wrap on; false (‘.F.’) toggles it off. If not specified, the
default value is true (‘.T.’).
MLCOUNT() returns the number of lines in cString depending on the nLineLength, the
nTabSize, and whether word wrapping is on or off.
368.14.140 MLCTOPOS()
Memo line column to position
MLCTOPOS(cText, nWidth, nLine,
nCol, [nTabSize], [lWrap]) ⇒ nPosition
cText
nWidth
nLine
nCol
nTabSize
lWrap
is the text string to scan.
is the line length formatting width.
is the line number counting from 1.
is the column number counting from 0.
is the number of columns between tab stops. If not specified,
the default is 4.
is the word wrap flag. If not specified, the default is true
(‘.T.’).
MLCTOPOS() returns the byte position within cText counting from 1.
368.14.141 MLPOS()
Memo line position
MLPOS(cString, nLineLength,
nLine, [nTabSize], [lWrap]) ⇒ nPosition
cString is a character string or memo field.
nLineLength specifies the number of characters per line.
nLine
specifies the line number.
nTabSize defines the tab size. The default is four.
toggles word wrap on and off. Specifying true (‘.T.’) toggles
lWrap
word wrap on, and false (‘.F.’) toggles it off. The default is
true (‘.T.’).
MLPOS() returns the character position of nLine in cString as an integer numeric value. If
nLine is greater than the number of lines in cString, MLPOS() returns the length of cString.

nanoBase 1997 user manual 243
368.14.142 MONTH()
MONTH(dDate) ⇒ nMonth
dDate is the date value to convert.
MONTH() returns an integer numeric value in the range of zero to 12. Specifying a null date
(CTOD("")) returns zero.
368.14.143 MPOSTOLC()
Memo position to line column
MPOSTOLC(cText, nWidth, nPos,
[nTabSize], [lWrap]) ⇒ aLineColumn
cText
nWidth
nPos
nTabSize
lWrap
is a text string.
is the length of the formatted line.
is the byte position within text counting from one.
is the number of columns between tab stops. If not specified,
the default is four.
is the word wrap flag. If not specified, the default is true
(‘.T.’).
MPOSTOLC() returns an array containing the line and the column values for the specified byte
position, nPos. MPOSTOLC() is a memo function that determines the formatted line and column
corresponding to a particular byte position within cText. Note that the line number returned is
one-relative, the column number is zero-relative. This is compatible with MEMOEDIT(). nPos
is one-relative, compatible with AT(), RAT(), and other string functions.
368.14.144 NETERR()
Net error
NETERR([lNewError]) ⇒ lError
lNewError
if specified sets the value returned by NETERR() to the specified
status. lNewError can be either true (‘.T.’) or false
(‘.F.’). Setting NETERR() to a specified value allows the
runtime error handler to control the way certain file errors are
handled.
NETERR() returns true (‘.T.’) if a USE or APPEND BLANK fails. The initial value of
NETERR() is false (‘.F.’). If the current process is not running under a network operating system,
NETERR() always returns false (‘.F.’).

244 volume VIII Argomenti avanzati e accessori
368.14.145 NETNAME()
NETNAME() ⇒ cWorkstationName
NETNAME() returns the workstation identification as a character string up to 15 characters in
length. If the workstation identification was never set or the application is not operating under
the IBM PC Network, it returns a null string ("").
368.14.146 NEXTKEY()
NEXTKEY() ⇒ nInkeyCode
NEXTKEY() returns an integer numeric value ranging from -39 to 386. If the keyboard buffer
is empty, NEXTKEY() returns zero. If SET TYPEAHEAD is zero, NEXTKEY() always returns
zero. NEXTKEY() is like the INKEY() function, but differs in one fundamental respect.
INKEY() removes the pending key from the keyboard buffer and updates LASTKEY() with the
value of the key. NEXTKEY(), by contrast, reads, but does not remove the key from the keyboard
buffer and does not update LASTKEY().
368.14.147 NOSNOW()
NOSNOW(lToggle) ⇒ NIL
lToggle
NOSNOW() is used to suppress snow on old CGA monitors.
368.14.148 ORDBAGEXT()
ORDBAGEXT() ⇒ cBagExt
is a logical value that toggles the current state of snow suppression.
A value of true (‘.T.’) enables the snow suppression
on, while a value of false (‘.F.’) disables snow suppression.
ORDBAGEXT() returns a character expression that is the default Order Bag extension of the
current work area. cBagExt is determined by the RDD active in the current work area.
368.14.149 ORDBAGNAME()
ORDBAGNAME(nOrder | cOrderName) ⇒ cOrderBagName
nOrder
cOrderName
is an integer that identifies the position in the Order List of the
target Order whose Order Bag name is sought.
is a character string that represents the name of the target Order
whose Order Bag name is sought.
ORDBAGNAME() returns a character string, the Order Bag name of the specific Order.

nanoBase 1997 user manual 245
368.14.150 ORDCREATE()
ORDCREATE(cOrderBagName,[cOrderName], cExpKey, [bExpKey],
[lUnique]) ⇒ NIL
cOrderBagName is the name of a disk file containing one or more Orders.
cOrderName is the name of the Order to be created.
is an expression that returns the key value to place in the Order
cExpKey
for each record in the current work area. The maximum length
of the index key expression is determined by the database
driver.
bExpKey
is a code block that evaluates to a key value that is placed in
the Order for each record in the current work area.
lUnique
specifies whether a unique Order is to be created. Default is
the current global _SET_UNIQUE setting.
ORDCREATE() is an Order management function that creates an Order in the current work area.
It works like DBCREATEINDEX() except that it lets you create Orders in RDDs that recognize
multiple Order Bags.
368.14.151 ORDDESTROY()
ORDDESTROY(cOrderName [, cOrderBagName ]) ⇒ NIL
cOrderName
is the name of the Order to be removed from the current or
specified work area.
cOrderBagName is the name of a disk file containing one or more Orders.
ORDDESTROY() is an Order management function that removes a specified Order from
multiple-Order Bags. ORDDESTROY() is not supported for DBFNDX and DBFNTX.
368.14.152 ORDFOR()
ORDFOR(cOrderName | nOrder [, cOrderBagName]) ⇒ cForExp
cOrderName
is the name of the target Order, whose cForExp is sought.
nOrder
is an integer that identifies the position in the Order List of the
target Order whose cForExp is sought.
cOrderBagName is the name of an Order Bag containing one or more Orders.
ORDFOR() returns a character expression, cForExp, that represents the FOR condition of the
specified Order. If the Order was not created using the FOR clause the return value will be an
empty string (""). If the database driver does not support the FOR condition, it may either return
an empty string ("") or raise an "unsupported function" error, depending on the driver.

246 volume VIII Argomenti avanzati e accessori
368.14.153 ORDKEY()
ORDKEY(cOrderName | nOrder [, cOrderBagName]) ⇒ cExpKey
cOrderName
is the name of an Order, a logical ordering of a database.
nOrder
is an integer that identifies the position in the Order List of the
target Order whose cExpKey is sought.
cOrderBagName is the name of a disk file containing one or more Orders.
ORDKEY() is an Order management function that returns a character expression, cExpKey, that
represents the key expression of the specified Order.
368.14.154 ORDLISTADD()
ORDLISTADD(cOrderBagName [, cOrderName]) ⇒ NIL
cOrderBagName is the name of a disk file containing one or more Orders.
the name of the specific Order from the Order Bag to be added
to the Order List of the current work area. If you do not spec-
cOrderName
ify cOrderName, all orders in the Order Bag are added to the
Order List of the current work area.
ORDLISTADD() is an Order management function that adds the contents of an Order Bag , or
a single Order in an Order Bag, to the Order List. Any Orders already associated with the work
area continue to be active. If the newly opened Order Bag contains the only Order associated
with the work area, it becomes the controlling Order; otherwise, the controlling Order remains
unchanged.
368.14.155 ORDLISTCLEAR()
ORDLISTCLEAR() ⇒ NIL
ORDLISTCLEAR() is an Order management function that removes all Orders from the Order
List for the current work area.
368.14.156 ORDLISTREBUILD()
ORDLISTREBUILD() ⇒ NIL
ORDLISTREBUILD() is an Order management function that rebuilds all the orders in the current
Order List.
368.14.157 ORDNAME()
ORDNAME(nOrder[,cOrderBagName]) ⇒ cOrderName
nOrder
is an integer that identifies the position in the Order List of the
target Order whose database name is sought.
cOrderBagName is the name of a disk file containing one or more Orders.

nanoBase 1997 user manual 247
ORDNAME() returns the name of the specified Order in the current Order List or the specified
Order Bag if opened in the Current Order list.
368.14.158 ORDNUMBER()
ORDNUMBER(cOrderName [, cOrderBagName]) ⇒ nOrderNo
cOrderName
the name of the specific Order whose position in the Order
List is sought.
cOrderBagName is the name of a disk file containing one or more Orders.
ORDNUMBER() returns nOrderNo, an integer that represents the position of the specified Order
in the Order List.
368.14.159 ORDSETFOCUS()
ORDSETFOCUS([cOrderName | nOrder] [,cOrderBagName])
⇒ cPrevOrderNameInFocus
cOrderName
is the name of the selected Order, a logical ordering of a
database.
nOrder
is a number representing the position in the Order List of the
selected Order.
cOrderBagName is the name of a disk file containing one or more Orders.
ORDSETFOCUS() is an Order management function that returns the Order Name of the previous
controlling Order and optionally sets the focus to an new Order.
368.14.160 OS()
OS() ⇒ cOsName
OS() returns the operating system name as a character string.
368.14.161 OUTERR()
Output error
OUTERR(exp_list) ⇒ NIL
exp_list
is a list of values to display and can consist of any combination
of data types including memo.
OUTERR() is identical to OUTSTD() except that it writes to the standard error device rather
than the standard output device. Output sent to the standard error device bypasses the console
and output devices as well as any DOS redirection. It is typically used to log error messages in a
manner that will not interfere with the standard screen or printer output.

248 volume VIII Argomenti avanzati e accessori
368.14.162 OUTSTD()
Output standard
OUTSTD(exp_list) ⇒ NIL
exp_list
is a list of values to display and can consist of any combination
of data types including memo.
OUTSTD() is a simple output function similar to QOUT(), except that it writes to the STDOUT
device (instead of to the console output stream).
368.14.163 PAD?()
PADL(exp, nLength, [cFillChar]) ⇒ cPaddedString
PADC(exp, nLength, [cFillChar]) ⇒ cPaddedString
PADR(exp, nLength, [cFillChar]) ⇒ cPaddedString
exp
is a character, numeric, or date value to pad with a fill character.
nLength is the length of the character string to return.
cFillChar
is the character to pad exp with. If not specified, the default is
a space character.
PADC(), PADL(), and PADR() are character functions that pad character, date, and numeric
values with a fill character to create a new character string of a specified length. PADC() centers
exp within nLength adding fill characters to the left and right sides; PADL() adds fill characters
on the left side; and PADR() adds fill characters on the right side.
368.14.164 PCOL()
Printed column
PCOL() ⇒ nColumn
PCOL() returns an integer numeric value representing the last printed column position, plus one.
The beginning column position is zero.
368.14.165 PROW()
Printed row
PROW() ⇒ nRow
PROW() returns an integer numeric value that represents the number of the current line sent to
the printer. The beginning row position is zero.

nanoBase 1997 user manual 249
368.14.166 QOUT()
QOUT([exp_list]) ⇒ NIL
QQOUT([exp_list]) ⇒ NIL
exp_list
is a comma-separated list of expressions (of any data type
other than array or block) to display to the console. If no argument
is specified and QOUT() is specified, a carriage return/linefeed
pair is displayed. If QQOUT() is specified without
arguments, nothing displays.
QOUT() and QQOUT() are console functions. They display the results of one or more expressions
to the console. QOUT() outputs carriage return and linefeed characters before displaying
the results of exp_list. QQOUT() displays the results of exp_list at the current ROW() and COL()
position. When QOUT() and QQOUT() display to the console, ROW() and COL() are updated.
368.14.167 RAT()
Right at
RAT(cSearch, cTarget) ⇒ nPosition
cSearch
is the character string to locate.
cTarget is the character string to search.
RAT() returns the position of cSearch within cTarget as an integer numeric value, starting the
search from the right. If cSearch is not found, RAT() returns zero.
368.14.168 RDDLIST()
RDDLIST([nRDDType]) ⇒ aRDDList
nRDDType
is an integer that represents the type of the RDD you wish to
list.
nRDDType = 1 Full RDD implementation
nRDDType = 2 Import/Export only driver.
RDDLIST() returns a one-dimensional array of the RDD names registered with the application
as nRDDType.
368.14.169 RDDNAME()
RDDNAME() ⇒ cRDDName
RDDNAME() returns a character string, cRDDName, the registered name of the active RDD in
the current or specified work area.

250 volume VIII Argomenti avanzati e accessori
368.14.170 RDDSETDEFAULT()
RDDSETDEFAULT([cNewDefaultRDD]) ⇒ cPreviousDefaultRDD
cNewDefaultRDD
is a character string, the name of the RDD that is to be made
the new default RDD in the application.
RDDSETDEFAULT() is an RDD function that sets or returns the name of the previous default
RDD driver and, optionally, sets the current driver to the new RDD driver specified by
cNewDefaultRDD.
368.14.171 READINSERT()
READINSERT([lToggle]) ⇒ lCurrentMode
lToggle
toggles the insert mode on or off. True (‘.T.’) turns insert on,
while false (‘.F.’) turns insert off. The default is false (‘.F.’)
or the last user-selected mode in READ or MEMOEDIT().
READINSERT() returns the current insert mode state as a logical value.
368.14.172 READMODAL()
READMODAL(aGetList) ⇒ NIL
aGetList
is an array containing a list of Get objects to edit.
READMODAL() is like the READ command, but takes a GetList array as an argument and does
not reinitialize the GetList array when it terminates. The GET system is implemented using a
public array called GetList. Each time an @...GET command executes, it creates a Get object and
adds to the currently visible GetList array. The standard READ command is preprocessed into a
call to READMODAL() using the GetList array as its argument.
368.14.173 READVAR()
READVAR() ⇒ cVarName
READVAR() returns the name of the variable associated with the current Get object or the variable
being assigned by the current MENU TO command as an uppercase character string.
368.14.174 RECNO()
Record number
RECNO() ⇒ nRecord
RECNO() returns the current record number as an integer numeric value. If the work area contains
a database file with zero records, RECNO() returns one, BOF() and EOF() both return
true (‘.T.’), and LASTREC() returns zero. If the record pointer is moved past the last record,

nanoBase 1997 user manual 251
RECNO() returns LASTREC() + 1 and EOF() returns true (‘.T.’). If an attempt is made to
move before the first record, RECNO() returns the record number of the first logical record in the
database file and BOF() returns true (‘.T.’). If no database file is open, RECNO() will return a
zero.
368.14.175 RECSIZE()
Record size
RECSIZE() ⇒ nBytes
RECSIZE() returns, as a numeric value, the record length, in bytes, of the database file open in
the current work area. RECSIZE() returns zero if no database file is open.
368.14.176 REPLICATE()
REPLICATE(cString, nCount) ⇒ cRepeatedString
cString is the character string to repeat.
nCount
is the number of times to repeat cString.
REPLICATE() returns a character string. Specifying a zero as the nCount argument returns a
null string ("").
368.14.177 RESTSCREEN()
Restore screen
RESTSCREEN([nTop], [nLeft],
[nBottom], [nRight], cScreen) ⇒ NIL
nTop, nLeft, nBottom, nRight
cScreen
define the coordinates of the screen information contained in
cScreen. If the cScreen was saved without coordinates to preserve
the entire screen, no screen coordinates are necessary
with RESTSCREEN().
is a character string containing the saved screen region.
RESTSCREEN() is a screen function that redisplays a screen region saved with SAVE-
SCREEN(). The target screen location may be the same as or different than the original location
when the screen region was saved.
368.14.178 RIGHT()
RIGHT(cString, nCount) ⇒ cSubString
cString is the character string from which to extract characters.
nCount is the number of characters to extract.
RIGHT() returns the rightmost nCount characters of cString. If nCount is zero, RIGHT() returns
a null string (""). If nCount is negative or larger than the length of the character string,

252 volume VIII Argomenti avanzati e accessori
RIGHT() returns cString.
368.14.179 RLOCK()
Record lock
RLOCK() ⇒ lSuccess
RLOCK() is a network function that locks the current record, preventing other users from updating
the record until the lock is released. RLOCK() provides a shared lock, allowing other users
read-only access to the locked record while allowing only the current user to modify it. A record
lock remains until another record is locked, an UNLOCK is executed, the current database file is
closed, or an FLOCK() is obtained on the current database file.
368.14.180 ROUND()
ROUND(nNumber, nDecimals) ⇒ nRounded
nNumber is the numeric value to round.
nDecimals
defines the number of decimal places to retain. Specifying a
negative nDecimals value rounds whole number digits.
ROUND() is a numeric function that rounds nNumber to the number of places specified by
nDecimals. Specifying a zero or negative value for nDecimals allows rounding of whole numbers.
A negative nDecimals indicates the number of digits to the left of the decimal point to
round. Digits between five to nine, inclusive, are rounded up. Digits below five are rounded
down.
368.14.181 ROW()
ROW() ⇒ nRow
ROW() returns the cursor row position as an integer numeric value. The range of the return value
is zero to MAXROW().
368.14.182 RTRIM()
Right trim
[R]TRIM(cString) ⇒ cTrimString
cString is the character string to copy without trailing spaces.
RTRIM() returns a copy of cString with the trailing spaces removed. If cString is a null string
("") or all spaces, RTRIM() returns a null string ("").

nanoBase 1997 user manual 253
368.14.183 SAVESCREEN()
SAVESCREEN([nTop], [nLeft],
[nBottom], [nRight]) ⇒ cScreen
nTop, nLeft, nBottom, nRight
define the coordinates of the screen region to save. Default is
the entire screen.
SAVESCREEN() returns the specified screen region as a character string.
368.14.184 SCROLL()
SCROLL([nTop], [nLeft],
[nBottom], [nRight], [nVert] [nHoriz]) ⇒ NIL
nTop, nLeft, nBottom, nRight define the scroll region coordinates.
nVert
nHoriz
defines the number of rows to scroll, vertically. A positive
value scrolls up the specified number of rows. A negative
value scrolls down the specified number of rows. A value of
zero disables vertical scrolling. If nVert is not specified, zero
is assumed.
defines the number of rows to scroll horizontally. A positive
value scrolls left the specified number of columns. A negative
value scrolls right the specified number of columns. A value
of zero disables horizontal scrolling. If nHoriz is not specified,
zero is assumed. If you supply neither nVert or nHoriz
parameters to SCROLL(), the area specified by the first four
parameters will be blanked.
SCROLL() is a screen function that scrolls a screen region up or down a specified number of
rows. When a screen scrolls up, the first line of the region is erased, all other lines are moved
up, and a blank line is displayed in the current standard color on the bottom line of the specified
region. If the region scrolls down, the operation is reversed. If the screen region is scrolled more
than one line, this process is repeated.
368.14.185 SECONDS()
SECONDS() ⇒ nSeconds
SECONDS() returns the system time as a numeric value in the form seconds.hundredths. The numeric
value returned is the number of seconds elapsed since midnight, and is based on a twentyfour
hour clock in a range from zero to 86399.
368.14.186 SELECT()
SELECT([cAlias]) ⇒ nWorkArea
cAlias
is the target work area alias name.

254 volume VIII Argomenti avanzati e accessori
SELECT() returns the work area of the specified alias as a integer numeric value.
368.14.187 SET()
SET(nSpecifier, [expNewSetting], [lOpenMode])
⇒ CurrentSetting
nSpecifier
expNewSetting
lOpenMode
SET() returns the current value of the specified setting.
is a numeric value that identifies the setting to be inspected or
changed.
is an optional argument that specifies a new value for
the nSpecifier. The type of expNewSetting depends on
nSpecifier.
is a logical value that indicates whether or not files are opened
for some settings. A value of false (‘.F.’) means the file
should be truncated. A value of true (‘.T.’) means the file
should be opened in append mode. In either case, if the file
does not exist, it is created. If this argument is not specified,
the default is append mode.
Inside nB, the function SET() is not so easy to use as inside the Clipper environment. This
because nB cannot support manifest constants and a numeric specifier nSpecifier is not easy to
manage. Instead of SET() you can use SETVERB().
368.14.188 SETBLINK()
SETBLINK([lToggle]) ⇒ lCurrentSetting
lToggle
SETBLINK() returns the current setting as a logical value.
368.14.189 SETCANCEL()
SETCANCEL([lToggle]) ⇒ lCurrentSetting
lToggle
SETCANCEL() returns the current setting as a logical value.
changes the meaning of the asterisk (*) character when it
is encountered in a SETCOLOR() string. Specifying true
(‘.T.’) sets character blinking on and false (‘.F.’) sets background
intensity. The default is true (‘.T.’).
changes the availability of Alt-C and Ctrl-Break as termination
keys. Specifying true (‘.T.’) allows either of these keys
to terminate an application and false (‘.F.’) disables both
keys. The default is true (‘.T.’).

nanoBase 1997 user manual 255
368.14.190 SETCOLOR()
SETCOLOR([cColorString]) ⇒ cColorString
cColorString
368.14.191 SETCURSOR()
SETCURSOR([nCursorShape]) ⇒ nCurrentSetting
nCursorShape
is a character string containing a list of color attribute settings
for subsequent screen painting.
is a number indicating the shape of the cursor.
nCursorShape == 0 None
nCursorShape == 1 Underline
nCursorShape == 2 Lower half block
nCursorShape == 3 Full block
nCursorShape == 4 Upper half block
SETCURSOR() returns the current cursor shape as a numeric value.
368.14.192 SETKEY()
SETKEY(nInkeyCode, [bAction]) ⇒ bCurrentAction
nInkeyCode is the INKEY() value of the key to be associated or queried.
bAction
specifies a code block that is automatically executed whenever
the specified key is pressed during a wait state.
SETKEY() returns the action block currently associated with the specified key, or NIL if the
specified key is not currently associated with a block.
368.14.193 SETMODE()
SETMODE(nRows, nCols) ⇒ lSuccess
nRows
nCols
is the number of rows in the desired display mode.
is the number of columns in the desired display mode.
SETMODE() is an environment function that attempts to change the mode of the display hardware
to match the number of rows and columns specified. The change in screen size is reflected
in the values returned by MAXROW() and MAXCOL().

256 volume VIII Argomenti avanzati e accessori
368.14.194 SETPOS()
Set position
SETPOS(nRow, nCol) ⇒ NIL
nRow, nCol
define the new screen position of the cursor. These values may
range from 0, 0 to MAXROW(), MAXCOL().
SETPOS() is an environment function that moves the cursor to a new position on the screen.
After the cursor is positioned, ROW() and COL() are updated accordingly.
368.14.195 SETPRC()
Set printer row column
SETPRC(nRow, nCol) ⇒ NIL
nRow is the new PROW() value.
nCol is the new PCOL() value.
SETPRC() is a printer function that sends control codes to the printer without changing the
tracking of the printhead position.
368.14.196 SOUNDEX()
SOUNDEX(cString) ⇒ cSoundexString
cString is the character string to convert.
SOUNDEX() returns a four-digit character string in the form A999.
368.14.197 SPACE()
SPACE(nCount) ⇒ cSpaces
nCount
is the number of spaces to return.
SPACE() returns a character string. If nCount is zero, SPACE() returns a null string ("").
368.14.198 SQRT()
SQRT(nNumber) ⇒ nRoot
nNumber
is a positive number to take the square root of.
SQRT() returns a numeric value calculated to double precision. The number of decimal places
displayed is determined solely by SET DECIMALS regardless of SET FIXED. A negative

nanoBase 1997 user manual 257
nNumber returns zero.
368.14.199 STR()
String
STR(nNumber, [nLength], [nDecimals]) ⇒ cNumber
nNumber
nLength
nDecimals
STR() returns nNumber formatted as a character string.
368.14.200 STRTRAN()
STRTRAN(cString, cSearch,
[cReplace], [nStart], [nCount]) ⇒ cNewString
is the numeric expression to convert to a character string.
is the length of the character string to return, including decimal
digits, decimal point, and sign.
is the number of decimal places to return.
cString is the character string or memo field to search.
cSearch
is the sequence of characters to locate.
is the sequence of characters with which to replace cSearch.
cReplace
If this argument is not specified, the specified instances of the
search argument are replaced with a null string ("").
nStart
is the first occurrence that will be replaced. If this argument is
omitted, the default is one.
nCount
is the number of occurrences to replace. If this argument is
not specified, the default is all.
STRTRAN() returns a new character string with the specified instances of cSearch replaced with
cReplace.
368.14.201 STUFF()
STUFF(cString, nStart,
nDelete, cInsert) ⇒ cNewString
cString
is the target character string into which characters are inserted
and deleted.
nStart
is the starting position in the target string where the insertion/deletion
occurs.
nDelete is the number of characters to delete.
cInsert
is the string to insert.
STUFF() returns a copy of cString with the specified characters deleted and with cInsert inserted.

258 volume VIII Argomenti avanzati e accessori
368.14.202 SUBSTR()
Sub string
SUBSTR(cString, nStart, [nCount]) ⇒ cSubstring
cString is the character string from which to extract a substring.
is the starting position in cString. If nStart is positive, it is
nStart
relative to the leftmost character in cString. If nStart is negative,
it is relative to the rightmost character in the cString.
is the number of characters to extract. If omitted, the substring
begins at nStart and continues to the end of the string. If
nCount
nCount is greater than the number of characters from nStart
to the end of cString, the extra is ignored.
SUBSTR() is a character function that extracts a substring from another character string or memo
field.
368.14.203 TIME()
TIME() ⇒ cTimeString
TIME() returns the system time as a character string in the form hh:mm:ss. hh is hours in 24-hour
format, mm is minutes, and ss is seconds.
TIME() is a time function that displays the system time on the screen or prints it on a report.
368.14.204 TONE()
TONE(nFrequency, nDuration) ⇒ NIL
nFrequency
nDuration
is a positive numeric value indicating the frequency of the
tone to sound.
is a positive numeric value indicating the duration of the tone
measured in increments of 1/18 of a second. For example, an
nDuration value of 18 represents one second.
For both arguments, noninteger values are truncated (not rounded) to their integer portion.
368.14.205 TRANSFORM()
TRANSFORM(exp, cSayPicture) ⇒ cFormatString
exp
cSayPicture
is the value to format. This expression can be any valid data
type except array, code block, and NIL.
is a string of picture and template characters that describes the
format of the returned haracter string.
TRANSFORM() converts exp to a formatted character string as defined by cSayPicture.

nanoBase 1997 user manual 259
368.14.206 TYPE()
TYPE(cExp) ⇒ cType
cExp
TYPE() returns one of the following characters:
A
Array
B Block
C Character
D Date
L Logical
M Memo
N Numeric
O
Object
U NIL, local, or static
UE Error syntactical
UI Error indeterminate
is a character expression whose type is to be determined.
cExp can be a field, with or without the alias, a private or
public variable, or an expression of any type.
TYPE() is a system function that returns the type of the specified expression. TYPE() is like
VALTYPE() but uses the macro operator (&) to determine the type of the argument. VALTYPE(),
by contrast, evaluates an expression and determines the data type of the return value.
368.14.207 UPDATED()
UPDATED() ⇒ lChange
UPDATED() returns true (‘.T.’) if data in a GET is added or changed; otherwise, it returns false
(‘.F.’).
368.14.208 UPPER()
UPPER(cString) ⇒ cUpperString
cString is the character string to convert.
UPPER() returns a copy of cString with all alphabetical characters converted to uppercase. All
other characters remain the same as in the original string.
368.14.209 USED()
USED() ⇒ lDbfOpen
USED() returns true (‘.T.’) if there is a database file in USE in the current work area; otherwise,
it returns false (‘.F.’).

260 volume VIII Argomenti avanzati e accessori
368.14.210 VAL()
Value
VAL(cNumber) ⇒ nNumber
cNumber
is the character expression to convert.
VAL() is a character conversion function that converts a character string containing numeric
digits to a numeric value. When VAL() is executed, it evaluates cNumber until a second decimal
point, the first non-numeric character, or the end of the expression is encountered.
368.14.211 VALTYPE()
Value type
VALTYPE(exp) ⇒ cType
exp is an expression of any type.
VALTYPE() returns a single character representing the data type returned by exp. VALTYPE()
returns one of the following characters:
A
Array
B Block
C Character
D Date
L Logical
M Memo
N Numeric
O
Object
U NIL
VALTYPE() is a system function that takes a single argument, evaluates it, and returns a one
character string describing the data type of the return value.
368.14.212 YEAR()
YEAR(dDate) ⇒ nYear
dDate is the date value to convert.
YEAR() returns the year of the specified date value including the century digits as a four-digit
numeric value. The value returned is not affected by the current DATE or CENTURY format.
Specifying a null date (CTOD("")) returns zero.

nanoBase 1997 user manual 261
368.15 nB functions
Some functions made into nB are available for macro use. Not all available functions are here
documented.
368.15.1 ACCEPT()
ACCEPT( Field, [cMessage], [cHeader] ) ⇒ updatedField|NIL
It is a prompt function that shows cMessage asking to type something into Field. It returns the
updated data or NIL if [ Esc ] was pressed. The string cHeader is showed centered at the top
window.
368.15.2 ACHOICE()
ACHOICE(nTop, nLeft, nBottom, nRight,
acMenuItems,
[alSelectableItems],
[nInitialItem],
[lButtons | aButtons]) ⇒ nPosition
nTop, nLeft, nBottom, nRight are the window coordinates.
acMenuItems
is an array of character strings to display as the menu items.
is a parallel array of logical values (one element for each item
in acMenuItems) that specify the selectable menu items. Elements
can be logical values or character strings. If the ele-
alSelectableItems
ment is a character string, it is evaluated as a macro expression
which should evaluate to a logical data type. A value of
false (‘.F.’) means that the corresponding menu item is not
available, and a value of true (‘.T.’) means that it is available.
By default, all menu items are available for selection.
nInitialItem
is the position in the acMenuItems array of the item that will
be highlighted when the menu is initially displayed.
lButtons
if True means that default buttons will appear.
aButtons
is an array of buttons.
aButtons[n][1] == N the nth button row position;
aButtons[n][2] == N the nth button column position;
aButtons[n][3] == C the nth button text;
aButtons[n][4] == B the nth button code block.
ACHOICE() returns the numeric position in the acMenuItems array of the menu item selected.
If no choice is made, ACHOICE() returns zero.
368.15.3 ACHOICEWINDOW()
ACHOICEWINDOW( acMenuItems, [cDescription],
nTop, nLeft, nBottom, nRight,
[alSelectableItems],
[nInitialItem] ) ⇒ nPosition
acMenuItems
is an array of character strings to display as the menu items.

262 volume VIII Argomenti avanzati e accessori
cDescription is a header to be shown at the top of window.
nTop, nLeft, nBottom, nRight are the window coordinates.
is a parallel array of logical values (one element for each item
in acMenuItems) that specify the selectable menu items. Elements
can be logical values or character strings. If the element
is a character string, it is evaluated as a macro expres-
alSelectableItems
sion which should evaluate to a logical data type. A value of
false (‘.F.’) means that the corresponding menu item is not
available, and a value of true (‘.T.’) means that it is available.
By default, all menu items are available for selection.
is the position in the acMenuItems array of the item that will
nInitialItem
be highlighted when the menu is initially displayed.
ACHOICEWINDOW() calls ACHOICE() with a window border around the ACHOICE() screen
area.
368.15.4 ALERTBOX()
ALERTBOX( cMessage, [aOptions] ) ⇒ nChoice
is the message text displayed, centered, in the alert box. If the
cMessage
message contains one or more semicolons, the text after the
semicolons is centered on succeeding lines in the dialog box.
aOptions defines a list of up to 4 possible responses to the dialog box.
ALERTBOX() returns a numeric value indicating which option was chosen. If the [ Esc ] key is
pressed, the value returned is zero. The ALERTBOX() function creates a simple modal dialog.
The user can respond by moving a highlight bar and pressing the Return or SpaceBar keys, or
by pressing the key corresponding to the first letter of the option. If aOptions is not supplied, a
single "Ok" option is presented.
ALERTBOX() is similar to ALERT() but it accept mouse input.
368.15.5 ATB()
ATB( [nTop], [nLeft], [nBottom], [nRight],
aArray, [nSubscript],
[acColSayPic],
[acColTopSep], [acColBodySep], [acColBotSep],
[acColHead], [acColFoot],
[abColValid],
[abColMsg],
[cColor], [abColColors],
[lModify],
[lButtons | aButtons] ) ⇒ NIL
nTop, nLeft, nBottom, nRight defines the screen area where browse have to take place.
aArray bidimensional array to be browsed.
nSubscript starting array position.
acColSayPic is the picture array.
acColTopSep is the top separation array: default is chr(194)+chr(196).

nanoBase 1997 user manual 263
acColBodySep is the body separation array: default is chr(179).
acColBotSep is the bottom separation array: default is chr(193)+chr(196).
acColHead
is the header array for every column.
acColFoot
is the footer array for every column.
abColValid
is the validation array that specify when a field is properly
filled. The condition must be specified in code block format.
is the message array that permits to show information at the
abColMsg
bottom of browse area. The array must be composed with
code blocks which result with a character string.
cColor
is the color string: it may be longer than the usual 5 elements.
is the color code block array. The code block receive as pa-
abColColors
rameter the value contained inside the field and must return
an array containing two numbers: they correspond to the two
color couple from cColor.
lModify indicates whether the browse can modify data.
lButtons
if True, default buttons are displayed.
aButtons
array of buttons.
aButtons[n][1] N the nth button row position;
aButtons[n][2] N the nth button column position;
aButtons[n][3] C the nth button text;
aButtons[n][4] B the nth button code block.
This function starts the browse of a bidimensional array. Only arrays containing monodimensional
array containing the same kind of editable data are allowed. The function can handle a
maximum of 61 columns.
368.15.6 BCOMPILE()
BCOMPILE( cString ) ⇒ bBlock
Compiles the string cString and returns the code block bBlock
368.15.7 BUTTON()
BUTTON( @aButtons,
[nRow], [nCol], [cText], [cColor],
[bAction] ) ⇒ NIL
aButtons
the array of buttons to be increased with a new button array.
nRow and nCol
is the row and column starting position for the button string.
cText
is the text that make up the button.
cColor
is the color string.
bAction is the code block associated to the button.
This function adds to aButtons a new button array. Please note that the button array added is
compatible only with the READ() function and not the other function using array of buttons: the
others do not have a color string.

264 volume VIII Argomenti avanzati e accessori
368.15.8 COLORARRAY()
COLORARRAY( cColor ) ⇒ aColors
cColors
a color string to be translated into a color array.
This function transform a color string into a color array. The array has as many elements as the
colors contained inside cColor string.
368.15.9 COORDINATE()
COORDINATE( [@nTop, @nLeft], @nBottom, @nRight,
[cHorizontal], [cVertical] ) ⇒ NIL
nTop, nLeft, nBottom and nRight
cHorozontal
cVertical
are the starting position of a window that is to be differently
aligned.
determinates the horizontal alignment:
"L" all left;
"l" middle left;
"C" center;
"c" center;
"R" all right;
"r" middle right.
determinate the vertical alignment:
"T" top;
"t" up;
"C" center;
"c" center;
"B" bottom;
"b" down.
This function helps with the windows alignment recalculating and modifying nTop, nLeft,
nBottom and nRight in the way to obtain the desired alignment.
368.15.10 COPYFILE()
COPYFILE( cSourceFile, cTargetFile|cDevice ) ⇒ NIL
cSourceFile the source filename.
cTargetFile the target filename.
cDevice
the target devicename.
This function copies the cSourceFile to cTargetFile or to cDevice.

nanoBase 1997 user manual 265
368.15.11 DBAPP()
DBAPP( cFileName, [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords],
[nRecord],
[lRest],
[cDriver] ) ⇒ NIL
cFileName
acFields
bForCondition
bWhileCondition
nNextRecord
nRecord
lRest
cDriver
the filename containing data to append to the active alias.
array of fieldnames indicating the fields that should be updated
on the active alias (default is all).
a code block containing the FOR condition to respect for the
data append. Will be appended data that makes the evaluation
of this code block True.
a code block containing the WHILE condition to respect for
the data append. Will be appended data as long as the evaluation
of this code block is True: the first time it becomes False,
the data appending is terminated.
if used, means that only the first nNextRecords will be appended.
if used, means that that only the record nRecord will be appended.
this option is not available here also if the function saves a
place for it.
is the optional driver name to use to open the cFileName file.
This function is used to append data to the active alias using data from the cFileName file, that
in this case is a ‘.DBF’ file.
368.15.12 DBCLOSE()
DBCLOSE() ⇒ NIL
It is a substitution function of DBCLOSEALL() to use inside "compiled" macros, as a true DB-
CLOSEALL() will close the macro file too.
368.15.13 DBCONTINUE()
DBCONTINUE() ⇒ NIL
This function resumes a pending DBLOCATE().
368.15.14 DBCOPY()
DBCOPY( cFileName, [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords],
[nRecord],
[lRest],
[cDriver] ) ⇒ NIL

266 volume VIII Argomenti avanzati e accessori
cFileName
acFields
bForCondition
bWhileCondition
nNextRecord
nRecord
lRest
cDriver
the target filename for the data contained inside the active
alias.
array of fieldnames indicating the fields that should be used
from the active alias (default is all).
a code block containing the FOR condition to respect for the
data copy. Will be copied the data that makes the evaluation
of this code block True.
a code block containing the WHILE condition to respect for
the data copy. Will be copied data as long as the evaluation
of this code block is True: the first time it becomes False, the
data copying is terminated.
if used, means that only the first nNextRecords will be
copied.
if used, means that that only the record nRecord will be
copied.
if used means that only the remaining records inside the active
alias are copied.
is the optional driver name to use to open the cFileName file.
This function is used to copy data to cFileName form the active alias.
368.15.15 DBCOPYSTRUCT()
DBCOPYSTRUCT( cDatabase, [acFields] ) ⇒ NIL
cDatabase
acFields
is a structure ‘.DBF’ file that will be filled with structure information
about the active alias.
is an array of fieldnames that should be taken into consideration.
This function creates a structure ‘.DBF’ file copying the structure of the active alias.
368.15.16 DBCOPYXSTRUCT()
DBCOPYXSTRUCT( cExtendedDatabase ) ⇒ NIL
cExtendedDatabase
is a structure ‘.DBF’ file that will be filled with structure information
about the active alias, accepting extended structure
informations.
This function creates a structure ‘.DBF’ file copying the structure of the active alias. This function
accept non-standard structure, that is, the extended structure available inside Clipper.
368.15.17 DBDELIM()
DBDELIM( lCopyTo, cFileName, [cDelimiter], [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest] ) ⇒ NIL

nanoBase 1997 user manual 267
lCopyTo
cFileName
cDelimiter
acFields
bForCondition
bWhileCondition
nNextRecord
nRecord
lRest
if True the function work copying data to cFileName from the
active alias, if False the function work appending data from
cFileName to the active alias.
the filename containing data to append to the active alias or
to use as the target of the data copy from the active alias.
the delimiter string (or character) used to separate fields inside
cFileName.
array of fieldnames indicating the fields of the active alias that
should be taken into consideration (default is all).
a code block containing the FOR condition to respect. The operation
will be made for all records that respect the condition.
a code block containing the WHILE condition to respect. The
first time it becomes False, the operation is terminated.
if used, means that only the first nNextRecords will be appended/copied.
if used, means that that only the record nRecord will be ap-
pended/copied.
if used means that only the remaining records will be taken
into consideration.
This function is used to append data to the active alias using data from the cFileName file or to
copy data into cFileName using the active alias as the source. cFileName is a delimited ASCII
file.
368.15.18 DBISTATUS()
DBISTATUS() ⇒ cDBInformations
This function returns the informations on the active alias in a text form.
368.15.19 DBISTRUCTURE()
DBISTRUCTURE() ⇒ cTextStructure | NIL
This function returns the structure information on the active alias in a text form.
368.15.20 DBJOIN()
DBJOIN( cAlias, cDatabase,
[acFields], [bForCondition] ) ⇒ NIL
cAlias
cDatabase
acFields
the name of the alias to use to merge with records from the
active alias.
the target ‘.DBF’ filename.
the array of fieldnames which represent the projection of
fields form both Aliases into the new ‘.DBF’ file. If not specified,
all fields from the primary work area are included in the
target ‘.DBF’ file.
This function creates a new database file by merging selected records and fields form two work
areas (Aliases) based on a general condition. It works by making a complete pass through the
secondary work area cAlias for each record in the primary work area (the active alias), evaluating

268 volume VIII Argomenti avanzati e accessori
the condition for each record in the secondary work area. When bForCondition is evaluated True,
a new record is created in the target database file cDatabase using the fields specified from both
work areas inside acFields.
368.15.21 DBLABELFORM()
DBLABELFORM( cLabel, [lToPrinter], [cFile],
[lNoConsole], [bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest], [lSample] )
⇒ NIL
cLabel
is the name of the label file (.LBL) that contains the label
format definition.
lToPrinter
if True, the output is copied to printer (‘LPT1:’).
cFile
if present, it is the name of a ASCII file where the output is
copied.
lNoConsole
if True, the output is not sent to the console.
a code block containing the FOR condition to respect for label
bForCondition
print. Only the records contained inside the active alias that
respect the condition will be used for labels.
a code block containing the WHILE condition to respect for
bWhileCondition
the label print. The first time that the condition is False, the
label print terminates.
nNextRecord
if used, means that only the first nNextRecords will be used.
nRecord
if used, means that that only the record nRecord will be used.
lRest
if used means that only the remaining records inside the active
alias will be used.
lSample if True displays test labels as rows of asterisks.
This function prints labels to the console.
368.15.22 DBLIST()
DBLIST( [lToDisplay], abListColumns,
[lAll],
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest],
[lToPrinter], [cFileName] )
lToDisplay if True the printout is sent to the console screen.
abListColumns
is an array of columns expressions to list.
lAll
if True prints all the records contained inside the active alias.
a code block containing the FOR condition to respect. Only
bForCondition
the records contained inside the active alias that respect the
condition will be used for list.
bWhileCondition
a code block containing the WHILE condition to respect. The
first time that the condition is False, the list terminates.
nNextRecord
if used, means that only the first nNextRecords will be used.
nRecord
if used, means that that only the record nRecord will be used.
lRest
if used means that only the remaining records inside the active
alias will be used.
lToPrinter
if True, the output is copied to printer (‘LPT1:’).
cFileName
if present, it is the name of a ASCII file where the output is
copied.

nanoBase 1997 user manual 269
This function prints a list of records to the console.
368.15.23 DBLOCATE()
DBLOCATE( [bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest] ) ⇒ NIL
bForCondition
bWhileCondition
nNextRecord
nRecord
lRest
a code block containing the FOR condition to respect. Only
the records contained inside the active alias that respect the
condition will be taken into consideration.
a code block containing the WHILE condition to respect. The
first time that the condition is False, the locate terminates.
if used, means that only the first nNextRecords will be used.
if used, means that that only the record nRecord will be used.
if used means that only the remaining records inside the active
alias will be used.
This function searches sequentially for the first record matching the FOR and WHILE conditions.
Once a DBLOCATE() has been issued you can resume the search from the current record pointer
position with DBCONTINUE().
The WHILE condition and the scope (nNextRecord, nRecord and lRest) apply only to the initial
DBLOCATE() and are not operational for any subsequent DBCONTINUE() call.
368.15.24 DBOLDCREATE()
DBOLDCREATE( cDatabase, cExtendedDatabase,
[cDriver], [lNew], [cAlias] ) ⇒ NIL
cDatabase
cExtendedDatabase
cDriver
lNew
cAlias
is the name of the new database file, with an optional drive and
directory, specified as a character string. If specified without
an extension (.dbf) is assumed.
is a ‘.DBF’ file containing the structure information of the file
to create.
specifies the replaceable database driver (RDD) to use to process
the current work area. cDriver is the name of the RDD
specified as a character expression.
if True the newly created ‘.DBF’ file is opened using the next
available work area making it the current work area (the active
alias).
if lNew is set to True, this is the alias name to use to open the
file.
This function is a old database function (superseded form DBCREATE() ) that creates a database
file from the structure information contained inside a structure file.

270 volume VIII Argomenti avanzati e accessori
368.15.25 DBPACK()
DBPACK() ⇒ NIL
This function eliminates definitively the active alias records previously signed for deletion. It
works only if the active alias is opened in exclusive mode.
368.15.26 DBSDF()
DBSDF( lCopyTo, cFileName, [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest] ) ⇒ NIL
lCopyTo
cFileName
acFields
bForCondition
bWhileCondition
nNextRecord
nRercord
lReset
if True the function works copying data to cFileName from
the active alias, if False the function work appending data
from cFileName to the active alias.
the filename containing data to append to the active alias or to
use as the target of the data copy from the active alias.
array of fieldnames indicating the fields of the active alias that
should be taken into consideration (default is all).
a code block containing the FOR condition to respect. The operation
will be made for all records that respect the condition.
a code block containing the WHILE condition to respect. The
first time it becomes False, the operation is terminated.
if used, means that only the first nNextRecords will be appended/copied.
if used, means that that only the record nRecord will be ap-
pended/copied.
if used means that only the remaining records will be taken
into consideration.
This function is used to append data to the active alias using data from the cFileName file or to
copy data into cFileName using the active alias as the source. cFileName is a SDF ASCII file.
368.15.27 DBSORT()
DBSORT( cDatabase, [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest] ) ⇒ NIL
cDatabase the ‘.DBF’ file to create.
acFields
the array of fields to be used to create the new sorted
cDatabase file.
a code block containing the FOR condition to respect. Only
bForCondition
the records contained inside the active alias that respect the
condition will be taken into consideration.
bWhileCondition
a code block containing the WHILE condition to respect. The
first time that the condition is False, the sort terminates.
nNextRecord
if used, means that only the first nNextRecords inside the active
alias will be used.
nRecord
if used, means that that only the record nRecord will be used.
lRest
if used means that only the remaining records inside the active
alias will be used.

nanoBase 1997 user manual 271
Copy the active alias to a ‘.DBF’ file in sorted order.
368.15.28 DBTOTAL()
DBTOTAL( cDatabase, bKey, [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest] ) ⇒ NIL
cDatabase
bKey
acFields
bForCondition
bWhileCondition
nNextRecords
nRecord
lRest
the ‘.DBF’ file to create that will contain the copy of summarised
records.
the code block key expression that should correspond to the
key expression of the active index of the active alias.
the array of fields to be used to create the new cDatabase file.
a code block containing the FOR condition to respect. Only
the records contained inside the active alias that respect the
condition will be taken into consideration.
a code block containing the WHILE condition to respect. The
first time that the condition is False, the sort terminates.
if used, means that only the first nNextRecords inside the active
alias will be used.
if used, means that that only the record nRecord will be used.
if used means that only the remaining records inside the active
alias will be used.
This function summarises records by key value to a ‘.DBF’ file. It sequentially process the active
alias scanning the specified scope of records. Records with the same key will be summarised
inside the destination ‘.DBF’ file. The value of numeric fields of records with the same key are
added.
368.15.29 DBUPDATE()
DBUPDATE( cAlias, bKey, [lRandom], [bReplacement] )
cAlias
bKey
lRandom
bReplacement
is the alias containing data to be used to update the active
alias.
is a code block expression using information form the cAlias
to obtain a key to refer to the active alias.
if True, allows record in the cAlias to be in any order. In this
case, the active alias must be indexed with the same key as
bKey.
is the code block that will be executed when records matches:
it should contains the criteria for data update.
This function updates the active alias with data from another .DBF file.
Example:
dbUpdate( "INVOICE", {|| LAST}, .T.,;
{|| FIELD->TOTAL1 := INVOICE->SUM1,;
FIELD->TOTAL2 := INVOICE->SUM2 } )

272 volume VIII Argomenti avanzati e accessori
368.15.30 DBZAP()
DBZAP() ⇒ NIL
This function erases immediately all the records contained inside the active alias.
368.15.31 DISPBOXCOLOR()
DISPBOXCOLOR( [nColorNumber], [cBaseColor] ) ⇒ cColor
nColorNumber
cBaseColor
may be 1 or 2 and are the two color used to create shadowed
borders. 1 is usually used for the left and top line; 2 is used
for the right and bottom line.
is the starting color string. The default is the actual color.
This function return a color string used for DISPBOXSHADOW() the function that create a
shadowed border around a screen window.
368.15.32 DISPBOXSHADOW()
DISPBOXSHADOW( nTop, nLeft, nBottom, nRight,
[cBoxString], [cColor1], [cColor2] ) ⇒ NIL
nTop, nLeft, nBottom and nRight are the screen coordinate where the box is to be displayed.
cBoxString
is the box string containing the character to use to build the
box. Default is a single line box.
cColor1
is the color string to use for the left and top side of the box.
cColor2
is the color string to use for the right and bottom side of the
box.
This function draws a screen box like DISPBOX() but allowing the variation of colors around the
border to simulate a sort of shadow.
368.15.33 DIR()
DIR( [cFileSpec], [lDrives], [lDirs], [lFiles],
[lNoDirReturn], [nSortColumn] ) ⇒ cPathname
cFileSpec the filename or Pathname, also with wildcards, to be searched.
lDrives true (‘.T.’) means: include drives letters.
lDirs
true (‘.T.’) means: include directory names.
lFiles true (‘.T.’) means: include file names.
true (‘.T.’) means: do not return the shown directory if [ Esc ]
lNoRirReturn
is used to exit.
the column number to use to sort the list. The columns are:
Name = 1,
Size = 2,
nSortColumn
Date = 3,
Time = 4,
Attribute = 5.
It is not possible to sort for extention.

nanoBase 1997 user manual 273
It is a window function useful to search a file or a directory. The complete pathname of the
selected file is returned.
368.15.34 DOC()
DOC( [cTextFileName] ) ⇒ NIL
cTextFileName
can contain the text file to open and edit; if empty, the editing
of ‘UNTITLED.TXT’ will start.
It is the nB Text editor useful for small text files (less then 64K) and contains a complete menu
that can be started with[F10].
Attention: doc() should not be used inside macros.
368.15.35 DOTLINE()
DOTLINE() ⇒ NIL
This function is a "dot" command line useful for calculations resolution. The dot-line content
may be passed to the keyboard buffer.
368.15.36 DTEMONTH()
Date of month
DTEMONTH( nMonth, cLanguage ) ⇒ cMonth
nMonth the month number.
cLanguage the language name.
This function translates the nMonth number into the month name translated using the
cLanguage language.
368.15.37 DTEWEEK()
Date of week
DTEWEEK( nWeek, cLanguage ) ⇒ cWeek
nWeek
cLanguage
is the week number (1 is Sunday, 7 is Saturday) to be translated
into text.
is the language name into which the week must be expressed.
At the moment it works only for Italian, so cLanguage can
only contain "ITALIANO".
This function translates the week number into the week name translated using the cLanguage
language.

274 volume VIII Argomenti avanzati e accessori
368.15.38 EX()
Execute
EX( cFileMacro ) ⇒ nExitCode
Executes the macro file cFileName. The extention must be specified.
cFileMacro may be the name of a "compiled" macro or a text macro file.
368.15.39 GET()
GET( @aGetList,
[nTop], [nLeft],
{ |x| iif( pcount() > 0, Var := x, Var ) }
[cGetPicture], [cColorString],
[bPreExpression], [bValid] )
aGetList
is the get list array that will be increased with this get().
nTop and nLeft define the starting position of this get object on the screen.
Var
is the variable that is to be edited with this get. Var is in fact
sent to the GET() function using a code block.
cGetPicture
is the get picture to use for Var.
cColorString is the color string to use for the get.
is a code block that will be evaluated before the get object
bPreExpression
will became active. It must result True to obtain that the get
object became active.
is a code block that will be evaluated after the get object is
bValid
edited. It must result True to obtain that the get object may
become inactive.
Create screen editing masks.
368.15.40 GVADD()
Get validation add
GVADD( @cField, cAdd ) ⇒ .T.
cField the field to fill with more data.
cAdd
is the string to be added to the content of cField.
This function is to be used inside GETs for pre/post validation, when a the content of a field
should be added with more data.
cField is returned with the same length as before to avoid troubles with current and future GETs.

nanoBase 1997 user manual 275
368.15.41 GVDEFAULT()
Get validation default
GVDEFAULT( @cField, cDefault ) ⇒ .T.
@cField
the field to check and if empty correct with cDefault.
cDefault is the default value to be used to replace cField.
This function is to be used inside GETs for pre/post validation, when a field should have a default
value.
cField is returned with the same length as before to avoid troubles with current and future GETs.
368.15.42 GVFILEDIR()
Get validation file directory
GVFILEDIR( @cWildName ) ⇒ .T.
cWildName
is the file name taken from the current get to be used for search
with DIR().
This function is to be used inside GETs for pre validation: the cWildName is a file name with
wild cards that can be searched with the DIR() function after that a specific key is pressed.
cWildName is returned with the same length as before to avoid troubles with current and future
GETs.
368.15.43 GVFILEEXIST()
GVFILEEXIST( @cNameToTest, [cExtention] ) ⇒ lSuccess
@cNameToTest
is the file name taken from the current get to test for existence.
cExtention is the normal extention of the file.
This function is to be used inside GETs for post validation: the file name have to exist.
cNameToTest is returned with the same length as before to avoid troubles with current and future
GETs.
368.15.44 GVFILEEXTENTION()
GVFILEEXTENTION( @cName, cExt ) ⇒ .T.
@cName
the file name to be eventually corrected with file extention.
cExt the file extention to use as default.
This function is to use inside GETs for pre/post validation, when the content of a field should
contain a file name that should be corrected adding a default extention if not given from the user.

276 volume VIII Argomenti avanzati e accessori
368.15.45 GVSUBST()
GVSUBST( @cField, cSubst ) ⇒ .T.
@cField
cSubst
the field to be replaced with cSubst.
is the string to be used to replace the content of cField.
This function is to use inside GETs for pre/post validation, when the content of a field should be
replaced with other data.
cField is returned with the same length as before to avoid troubles with current and future GETs.
368.15.46 HTF()
HTF( [nInitialRecord] ) ⇒ NIL
nInitialRecord
is the record number where to start the Help Text File browse.
Default is the actual record pointer.
This function browse a Help Text File that must be already opened and be the active alias.
368.15.47 ISFILE()
ISFILE( cName ) ⇒ lFileExists
cName
is the file name (with or without path) to be checked for existence.
This function returns true (‘.T.’) if the file cName exists. The difference between this function
and the standard FILE() function is that ISFILE() checks for wildcards before. If cName contains
wildcards, the result is false (‘.F.’).
368.15.48 ISWILD()
ISWILD( cName ) ⇒ lIsWild
cName
This function returns true (‘.T.’) if cName contains wildcards.
368.15.49 ISMEMVAR()
ISMEMVAR( cName ) ⇒ lIsMemvar
cName
is the file name (with or without path) to be checked for wildcards
presence.
is the name of a possible memvar.
This function returns true (‘.T.’) if the cName is a declared Memvar.

nanoBase 1997 user manual 277
368.15.50 ISCONSOLEON()
ISCONSOLEON() ⇒ lConsoleIsOn
This function returns true (‘.T.’) if the console will show the result of QOUT() and QQOUT().
368.15.51 ISPRINTERON()
ISPRINTERON() ⇒ lPrinterIsOn
This function returns true (‘.T.’) if the default printer will report the the result of QOUT() and
QQOUT().
The default printer is ‘PRN:’ or ‘LPT1:’. If SET ALTERNATE TO is configured to send outputs
to ‘LPT2:’ or another printer, the function will report false (‘.F.’).
368.15.52 KEYBOARD()
KEYBOARD( [cString] ) ⇒ NIL
This function stuff a string into the keyboard buffer.
368.15.53 LISTWINDOW()
LISTWINDOW( acMenuItem, [cDescription],
[nTop], [nLeft], [nBottom], [nRight],
[cColorTop], [cColorBody] ) ⇒ nPosition
acMenuItem
is the character array containing the list of choices.
cDescription is the header to be shown at the top window.
nTop, nLeft, nBottom, nRight are the window coordinates.
cColorTop is the color to use for window header and footer.
cColorBody
is the color to use for the window body that is the space where
the text appears.
This function is an similar to achoice(), but it shows a header and footer, and it saves the screen,
acting like a window.
368.15.54 MEMOWINDOW()
MEMOWINDOW( cVar, [cDescription], [nTop], [nLeft],
[nBottom], [nRight], [cColorTop], [cColorBody],
[lEditMode], [nLineLength], [nTabSize] ) ⇒ cVar
cVar is the character field (variable) to be edited.
cDescription is the header to be shown at the top window.
nTop, nLeft, nBottom, nRight are the window coordinates.
cColorTop is the color to use for window header and footer.
cColorBody
is the color to use for the window body that is the space where
the text appears.
lEditMode
is equivalent to memoedit().

278 volume VIII Argomenti avanzati e accessori
nLineLength is equivalent to memoedit().
nTabSize is equivalent to memoedit().
This function lets you easily edit a long character field (memo) defining automatically a simple
window and providing a simple help.
368.15.55 MEMPUBLIC()
MEMPUBLIC( cMemvarName|acMemvarNames ) ⇒ NIL
cMemvarName
acMemvarNames
Creates a PUBLIC variables or a group of variables.
368.15.56 MEMRELEASE()
MEMRELEASE( cMemvarName|acMemvarNames ) ⇒ NIL
is the name of the PUBLIC variable to create (max 10 characters).
is an array of PUBLIC variable names to create (max 10 characters).
cMemvarName is the name of the PUBLIC variable to be released.
acMemvarNames
is an array of PUBLIC variable names to be released.
This function releases a previously created PUBLIC variables or a group of variables.
368.15.57 MEMRESTORE()
MEMRESTORE( cMemFileName, [lAdditive] ) ⇒ NIL
cMemFileName
lAdditive
Retrieve memory variables form a memory file (.MEM).
368.15.58 MEMSAVE()
MEMSAVE( cMemFileName, [cSkeleton], [lLike] ) ⇒ NIL
cMemFileName
cSkeleton
lLike
the memory file (.MEM) to load from disk.
if True causes memory variables loaded from the memory file
to be added to the existing pool of memory variables. If False,
the existing memory variables are automatically released.
the memory file (.MEM) where public variables should be
saved.
the skeleton mask for defining a group of variables. Wildcard
characters may be used: _*_ and _?_.
if True, the variables grouped with cSkeleton are saved, else
only the other variables are saved.

nanoBase 1997 user manual 279
Saves memory variables to a memory file (.MEM).
368.15.59 MENUPROMPT()
MENUPROMPT( @aoGet,
[nRow], [nCol],
[cPrompt], [bBlock] ) ⇒ NIL
aoGet
is an array of get objects where a new get is added by
MENUPROMPT(). These gets are read only.
nRow and nCol
are the screen coordinates where the menu prompt will appear.
cPrompt is the menu prompt string.
is the code block to execute when the cursor is on the current
bBlock
menu prompt. It is usually a code block that shows a message
somewhere on the screen.
This function should substitute the @...PROMPT command and handle the mouse.
368.15.60 MENUTO()
MENUTO( aoGet, nPos ) ⇒ nChoice
aoGet
nPos
array of get objects.
starting position to be edited.
Like MENU TO. It returns the selected menu item created with MENUPROMPT(). It supports
the mouse.
368.15.61 MESSAGELINE()
MESSAGELINE( [cMessage], [cColor], [nPosTop], [nPosLeft] )
⇒ NIL
aMessage the message to be displayed.
cColor
the color string.
the starting position where the string message would appear
nPosTop and nPosLeft
on the screen. Default values are respectively ROW() and
COL().
MESSAGELINE() is a function that display a message on the screen on the selected position. If
cMessage is NIL, the message is eliminated from screen restoring the previous screen content.

280 volume VIII Argomenti avanzati e accessori
368.15.62 MOUSESCRSAVE()
MOUSESCRSAVE( [nTop], [nLeft], [nBottom], [nRight] )
⇒ cSavedScreen
nTop, nLeft, nBottom and nRight are the screen coordinates that will be to save the screen.
This function works line SAVESCREEN() but it hide the mouse cursor before a screen save is
made.
368.15.63 MOUSESCRRESTORE()
MOUSESCRRESTORE( [nTop], [nLeft], [nBottom], [nRight],
[cScreen] ) ⇒ cSavedScreen
nTop, nLeft, nBottom and nRight
cScreen
are the screen coordinates where the saved screen will be restored.
is the previously saved screen to restore.
This function works line RESTSCREEN() but it hide the mouse cursor before a screen restore is
made.
368.15.64 PICCHRMAX()
PICCHRMAX( [nCol], [nMaxCol] ) ⇒ cPictureString
nCol
nMaxCol
is the starting position on the screen for the get field.
is the end position on the screen of the get field.
This function is useful when a character field is to be used on a get object. The generated picture
will be the of the maximum possible extention, eventually with scroll.
368.15.65 QUIT()
QUIT() ⇒ NIL
Terminates program execution.
368.15.66 READ()
READ( aoGet, [nPos], [aButtons], [lReadOnly] )
⇒ lUpdated
aoGet
nPos
aButtons
lReadOnly
is the array of get objects.
is the starting position.
is the array of buttons.
if True, get fields cannot be modified; the default value is
False.

nanoBase 1997 user manual 281
This function is made to substitute the READMODAL() allowing the use of the mouse. The array
aButtons is made with the help of the function BUTTON().
368.15.67 RF()
RF( cFRMName,
[bForCondition], [bWhileCondition],
[nNext], [nRecord], [lRest], [lPlain],
[cbHeading], [lBeforeEject], [lSummary],
[lDate], [acExtra] ) ⇒ NIL
cFRMName
the form (.FRM) file to use to print the active alias.
bForCondition code block for the FOR condition.
bWhileCondition code block for the WHILE condition.
nNext see REPORT FORM.
nRecord see REPORT FORM
lRest see REPORT FORM
lPlain
if true (‘.T.’), force the print in a simple way.
additional header in character or code block form. If a code
cbHeading
block is sent, the final result must be a character string.
lBeforeEject if true (‘.T.’), force a form feed before the print.
lSummary if true (‘.T.’), force a summary print only.
lDate
if false (‘.F.’), force the print without date at the top of page.
a character array that may be used for translating standard
printed report form words and to add vertical and horizontal
separations. The default value of acExtra is:
acExtra[1] "Page No."
acExtra
acExtra[2] "** Subtotal **"
acExtra[3] "* Subsubtotal *"
acExtra[4] "*** Total ***"
acExtra[5] " " vertical column separation
axExtra[6] "" horizontal separation: no separation.
This function does the same work of REPORT FORM or __ReportForm or dbReportForm, but it
prints where qout() and qqout() print.
368.15.68 RPT()
RPT( cText ) ⇒ NIL
This function prints the text contained into cText using print commands. This function accepts
other parameters here not described, as they are not to be used for macro purpose. The printing
is made using QOUT() and QQOUT(), this way it is sensible to the "alternate" file definition.
368.15.69 RPTMANY()
RPTMANY( cText, [bWhileCondition], [bForCondition] )
⇒ NIL
cText
bWhileCondition
bForCondition
is the text to be printed.
is a code block for a WHILE condition to respect for the
records to print.
is a code block for a FOR condition to respect for the records
to print.

282 volume VIII Argomenti avanzati e accessori
This function prints the text contained into cText many times: one for every record contained
into the active alias.
368.15.70 RPTTRANSLATE()
RPTTRANSLATE( cText ) ⇒ cTranslatedText
This function translates once cText replacing variables with memvars or Fields.
368.15.71 RUN()
RUN( cCommand ) ⇒ NIL
This function start execution of cCommand in a DOS session. It works only if there is enough
available memory.
368.15.72 SAY()
SAY( nTop, nLeft, Expr,
[cSayPicture], [cColorString] ) ⇒ NIL
nTop and nLeft
define the starting position on the screen where the Expr
should be displayed.
nLeft is an expression that will be solved and displayed.
cSayPicture is the picture to use to display Expr.
cColorString is the color string to use.
This function displays the result of Expr on the screen on the desired position.
368.15.73 SETCOLORSTANDARD()
SETCOLORSTANDARD( [nColor], [cColor|acColor] )
nColor
cColor
acColor
⇒ cPreviousColor|acPreviousColor
is the color number to take into consideration:
0 All colors
1 Base
2 Menu
3 Head
4 Body (Say - Get)
5 Button (Mouse buttons)
6 Message
7 Alert
the color string to be associated with nColor.
it the color array
This function is a way to handle colors inside the application. The functions that display something
use a default color depending on what they does. These colors may be changed with SET-
COLORSTANDARD(), all together or only one.

nanoBase 1997 user manual 283
368.15.74 SETFUNCTION()
SETFUNCTION( nFunctionKey, cString ) ⇒ NIL
nFunctionKey
the number of the function key ( 1=F1, 12=F12) to be assigned.
cString the character string.
This function assigns a character string to a function key (obsolete).
368.15.75 SETMOUSE()
SETMOUSE( [lShow] )⇒ lPrevious
lShow
True shows the mouse cursor, False hide the mouse cursor,
NIL reports only the status.
This function is made to show, hide or report only the mouse cursor status.
368.15.76 SETOUTPUT()
SETOUTPUT( [cPeriperal|aPeripheral] )
⇒ aPrevious_Output_Peripherals
cPeripheral is the new output peripheral for qout() and qqout() functions.
aPeripheral
are the new output peripherals configurations for qout() and
qqout() functions.
nB is organised in the way to have only one output peripheral at the time. This function help to
make order inside SET CONSOLE, SET PRINTER and SET ALTERNATE.
If cPeripheral contains:
"CON"
"PRN"
SET CONSOLE is set to ON,
SET PRINTER is set to OFF,
SET ALTERNATE is set to OFF;
SET CONSOLE is set to OFF,
SET PRINTER is set to ON,
SET ALTERNATE is set to OFF;
"LPT1"
same as "PRN";
otherwise
SET CONSOLE is set to OFF,
SET PRINTER is set to OFF,

284 volume VIII Argomenti avanzati e accessori
SET ALTERNATE is set to ON,
SET ALTERNATE TO is set to cPeripheral.
aPeripheral is organised this way:
aPeripheral[1] = _SET_CONSOLE
aPeripheral[2] = _SET_PRINTER
aPeripheral[3] = _SET_ALTERNATE
aPeripheral[4] = _SET_ALTFILE
aPeripheral[5] = _SET_EXTRA
aPeripheral[6] = _SET_EXTRAFILE
This function is necessary because SET ALTERNATE alone is not enough to print on the screen
when the peripheral name is "CON" or to print on the printer when the peripheral name is "PRN"
or "LPT1". In fact, in the first case, ROW() and COL() will not be updated, in the second case,
PROW() and PCOL() will not be updated.
This function returns an array organised in the same way as aPeripheral is, that shows the active
output configuration.
368.15.77 SETRPTEJECT()
SETRPTEJECT( [lbEject] ) ⇒ lPreviousEjectMode
This function is used to set the eject mode after every page print for RPT(). If single sheet paper is
used, then SETRPTEJECT(.T.) must be set; for continuous paper, SETRPTEJECT(.F.) is correct.
The default value is .F..
lbEject
368.15.78 SETRPTLINES()
SETRPTLINES() ⇒ nRemainingLines
logical or code block, is the eject mode to set. Default is no
change, the starting value is ‘.F.’
This function is used to report the number of lines available before the completion of the page
print for RPT().
368.15.79 SETVERB()
Set verbose
SETVERB( cSpecifier, [xNewSetting], [lOpenMode] )
⇒ xPreviousValueSet
cSpecifier a word that defines the kind of set is going to be considered.
xNewSetting is the new value to set up.
lOpenMode used only for some kind of set.
This function is analogue to SET() but it uses a character string (with cSpecifier) and not a

nanoBase 1997 user manual 285
number to select the set. This is made to make easier the work with macros.
cSpecifier may contain:
"EXACT"
"FIXED"
"DECIMALS"
"DATEFORMAT"
"EPOCH"
"PATH"
"DEFAULT"
"EXCLUSIVE"
"SOFTSEEK"
"UNIQUE"
"DELETED"
"CANCEL"
"TYPEAHEAD"
"COLOR"
"CURSOR"
"CONSOLE"
"ALTERNATE"
"ALTFILE"
"DEVICE"
"EXTRA"
"EXTRAFILE"
"PRINTER"
"PRINTFILE"
"MARGIN"
"BELL"
"CONFIRM"
"ESCAPE"
"INSERT"
"EXIT"
"INTENSITY"
"SCOREBOARD"
"DELIMITERS"
"DELIMCHARS"
"WRAP"
"MESSAGE"
"MCENTER"
368.15.80 SETVERB("EXACT") (obsolete)
SETVERB( "EXACT", [lExact] ) ⇒ lPrevious
If lExact is True, it forces exact comparison of character strings, including length. If it is False,
character strings are compared until the left string length is exhausted; that is that "" (the null
string) is equal to any other string.
Please note that the == operator is a comparison operator for exact match and using it,
SETVERB("EXACT", ‘.F.’) will not work.

286 volume VIII Argomenti avanzati e accessori
The starting value is True; the recommended value is True.
368.15.81 SETVERB("FIXED")
SETVERB( "FIXED", [lFixed] ) ⇒ lPrevious
If lFixed contains True, numeric values are displayed ever with a fixed number of decimal digits,
depending on the value set by SETVERB("DECIMALS").
The starting value is False.
The recommended value is False: if you have to display a fixed number of decimal digits it is
better to define a good display picture.
368.15.82 SETVERB("DECIMALS")
SETVERB( "DECIMALS", [nDecimals] ) ⇒ nPrevious
nDecimals is the number of digits to display after the decimal position. This set is enabled of
disabled with SETVERB("FIXED").
The starting value is 8.
368.15.83 SETVERB("DATEFORMAT")
SETVERB( "DATEFORMAT", [cDateFormat] ) ⇒ cPrevious
cDateFormat is a character expression that specifies the date format.
The starting value is "dd/mm/yyyy".
Some date format examples:
AMERICAN
ANSI
BRITISH
FRENCH
GERMAN
ITALIAN
JAPAN
USA
368.15.84 SETVERB("EPOCH")
SETVERB( "EPOCH", [nYear] ) ⇒ nPrevious
"mm/dd/yyyy"
"yyyy.mm.dd"
"dd/mm/yyyy"
"dd/mm/yyyy"
"dd.mm.yyyy"
"dd-mm-yyyy"
"yyyy/mm/dd"
"mm-dd-yyyy"
nYear specifies the base year of 100-year period in which all dates containing only two year
digits are assumed to fall.
The starting value is 1900.

nanoBase 1997 user manual 287
368.15.85 SETVERB("PATH")
SETVERB( "PATH", [cPath] ) ⇒ cPrevious
cPath identifies the paths that nB uses when searching for a file not found in the current directory.
The list of paths can be separated by commas or semicolons.
The starting value is "".
368.15.86 SETVERB("DEFAULT")
SETVERB( "DEFAULT", [cPath] ) ⇒ cPrevious
cPath identifies the default disk drive and directory.
The starting value is "".
368.15.87 SETVERB("EXCLUSIVE")
SETVERB( "EXCLUSIVE", [lExclusive] ) ⇒ lPrevious
If lPath is True, the default database (.DBF) file open is made in exclusive mode; in the other
case, in shared mode.
The starting value is True.
368.15.88 SETVERB("SOFTSEEK")
SETVERB( "SOFTSEEK", [lSoftSeek] ) ⇒ lPrevious
If lSoftSeek is True, if a DBSEEK() index search fails, the record pointer is moved to the next
record with a higher key. If it is False, in case of a DBSEEK() index search failure, the record
pointer is moved at EOF().
The starting value is False.
368.15.89 SETVERB("UNIQUE") (obsolete)
SETVERB( "UNIQUE", [lUnique] ) ⇒ lPrevious
If lUnique is True, during creation or update of ‘.DBF’ indexes, if two or more records are found
with the same key, only the first record will be included inside the index.
If lUnique is False, duplicated record keys are allowed.
The starting value is False.

288 volume VIII Argomenti avanzati e accessori
368.15.90 SETVERB("DELETED")
SETVERB( "DELETED", [lDeleted] ) ⇒ lPrevious
If lDeleted is True, record signed for deletion are not filtered, that is, these are still normally
visible as they were not deleted. In the other case, they hare (in most cases) hidden to the user.
The starting value is False.
368.15.91 SETVERB("CANCEL")
SETVERB( "CANCEL", [lCancel] ) ⇒ lPrevious
If lCancel is True, enables [ Alt+c ] and [ Ctrl+Break ] as termination keys. In the other case, not.
The starting value is True.
368.15.92 SETVERB("TYPEAHEAD")
SETVERB( "TYPEAHEAD", [nTypeAhead] ) ⇒ nPrevious
nTypeAhead is the number of keystrokes the keyboard buffer can hold from a minimum of zero
to a maximum of 4096.
The starting value is 15.
368.15.93 SETVERB("COLOR")
SETVERB( "COLOR", [cColorString] ) ⇒ cPrevious
nColorString defines the normal screen colors. There are five couple of colors, but only three are
really operative:
standard
This is the standard color used for screen output.
enhanced
This is the color used for highlighted screen output.
border
Normally unused.
background Normally unused.
unselected This is the color used for GET fields without focus.
The default color string is "BG+/B,N/W,N/N,N/N,W/N" that is:
standard
bright Cyan on Blue
enhanced Black on White
border Black on Black
background Black on Black
unselected White on Black
The following table explains the use of letters inside the color string. Note that the plus sign (+)
means high intensity, the star (*) means blink and that + and * can be allowed only to the first
letter inside a couple.
Color Letter Monochrome
Black N, Space Black

nanoBase 1997 user manual 289
Color Letter Monochrome
Blue B Underline
Green G White
Cyan BG White
Red R White
Magenta RB White
Brown GR White
White W White
Gray N+ Black
Bright Blue B+ Bright Underline
Bright Green G+ Bright White
Bright Cyan BG+ Bright White
Bright Red R+ Bright White
Bright Magenta RB+ Bright White
Bright Brown GR+ Bright White
Bright White W+ Bright White
Black U Underline
Inverse Video I Inverse Video
Blank X Blank
368.15.94 SETVERB("CURSOR")
SETVERB( "CURSOR", [lCursor] ) ⇒ lPrevious
If lCursor is True, the cursor is showed, else it is hidden.
The starting value is True.
368.15.95 SETVERB("CONSOLE")
SETVERB( "CONSOLE", [lConsole] ) ⇒ lPrevious
If lConsole is True, the output of console commands is displayed on the screen, else it is not.
The starting value is True.
368.15.96 SETVERB("ALTERNATE")
SETVERB( "ALTERNATE", [lAlternate] ) ⇒ lPrevious
If lAlternate is True, the output of console commands is send also to a standard ASCII text file.
The starting value is False.
368.15.97 SETVERB("ALTFILE")
SETVERB( "ALTFILE", [cAlternateFilename], [lAdditive] )
⇒ cPrevious
If SETVERB("ALTERNATE") is True, the output of the console is send also to
cAlternateFilename, a standard ASCII file.

290 volume VIII Argomenti avanzati e accessori
If lAdditive is True, the output is appended to the ASCII file if it already exists, else it is erased
first.
368.15.98 SETVERB("DEVICE")
SETVERB( "DEVICE", [cDevice] ) ⇒ cPrevious
cDevice is the name of the device where SAY() will display its output.
The starting value is "SCREEN", the alternative is "PRINTER".
The recommended value is "SCREEN".
368.15.99 SETVERB("EXTRA")
SETVERB( "EXTRA", [lExtra] ) ⇒ lPrevious
If lExtra is True, the output of console commands is send also to a standard ASCII text file.
The starting value is False.
368.15.100 SETVERB("EXTRAFILE")
SETVERB( "EXTRAFILE", [cExtraFilename], [lAdditive] )
⇒ cPrevious
If SETVERB("EXTRA") is True, the output of the console is send also to cExtraFilename, a
standard ASCII file.
If lAdditive is True, the output is appended to the ASCII file if it already exists, else it is erased
first.
368.15.101 SETVERB("PRINTER")
SETVERB( "PRINTER", [lPrinter] ) ⇒ lPrevious
If lPrinter is True, the output of console commands is also printed, else it is not.
The starting value is False.
368.15.102 SETVERB("PRINTFILE")
SETVERB( "PRINTFILE", [cPrintFileName] ) ⇒ cPrevious
cPrintFileName is the name of the printer peripheral name.
The starting value is "" (null string).

nanoBase 1997 user manual 291
368.15.103 SETVERB("MARGIN")
SETVERB( "MARGIN", [nPageOffset] ) ⇒ nPrevious
nPageOffset is the positive number of column to be used as a left margin for all printer output.
The starting value is 0.
368.15.104 SETVERB("BELL")
SETVERB( "BELL", [lBell] ) ⇒ lPrevious
If lBell is True, the sound of the bell is used to get the attention of the user when some wrong
actions are made.
The starting value is False.
368.15.105 SETVERB("CONFIRM")
SETVERB( "CONFIRM", [lConfirm] ) ⇒ lPrevious
If lConfirm is False, the GET is simply terminated typing over the end of the get field; in the
other case (True), the GET is terminated only pressing an "exit key". The starting value is True.
368.15.106 SETVERB("ESCAPE")
SETVERB( "ESCAPE", [lEscape] ) ⇒ lPrevious
If lEscape is True, the [ Esc ] key is enabled to be a READ exit key, in the other case not.
The starting value is True.
The recommended value is True.
368.15.107 SETVERB("INSERT")
SETVERB( "INSERT", [lInsert] ) ⇒ lPrevious
If lInsert is True, the data editing is in INSERT mode, in the other case, it is in OVERWRITE
mode.
The starting value is True.
368.15.108 SETVERB("EXIT")
SETVERB( "EXIT", [lExit] ) ⇒ lPrevious
If lExit is True,[Up] and[Down] key may be used as exit key when the cursor is (respectively)
on the first or on the last GET field. In the other case not.
The starting value is False.
The recommended value is False.

292 volume VIII Argomenti avanzati e accessori
368.15.109 SETVERB("INTENSITY")
SETVERB( "INTENSITY", [lIntensity] ) ⇒ lPrevious
If lIntensitiy is True, the display of standard and enhanced display colors are enabled. In the
other case, only standard colors are enabled.
The starting value is True.
The recommended value is True.
368.15.110 SETVERB("SCOREBOARD")
SETVERB( "SCOREBOARD", [lScoreboard] ) ⇒ lPrevious
If lScoreboard is True, the display of messages from READ() and MEMOREAD() is allowed;
in the order case not.
The starting value is False.
The recommended value is False: nB do not support scoreboard.
368.15.111 SETVERB("DELIMITERS")
SETVERB( "DELIMITERS", [lDelimiters] ) ⇒ lPrevious
If lDelimiters is True, GET variables appear on the screen delimited with the delimiter symbols.
In the other case, GET variables are not delimited this way, but only with the use of different
colors.
The starting value is False.
The recommended value is False: the use of delimiters creates one more trouble when designing
a screen mask.
368.15.112 SETVERB("DELIMCHARS")
SETVERB( "DELIMCHARS", [cDelimterCharacters] ) ⇒ cPrevious
cDelimterCharacters are the delimiter characters used to delimit a GET field when
SETVERB("DELIMITERS") is True.
The starting value is "::".
368.15.113 SETVERB("WRAP")
SETVERB( "WRAP", [lWrap] ) ⇒ lPrevious
If lWrap is True, the wrapping of the highlight in MENUs should be active, but this option is
actually not active and all works as it is False.
The starting value is False.

nanoBase 1997 user manual 293
368.15.114 SETVERB("MESSAGE")
SETVERB( "MESSAGE", [nMessageRow] ) ⇒ nPrevious
nMessageRow is the row number where the @..PROMPT message line should appear on the
screen. This option is not supported.
The starting value is 0.
368.15.115 SETVERB("MCENTER")
SETVERB( "MCENTER", [lMessageCenter] ) ⇒ lPrevious
If lMessageCenter is True, the @..PROMPT message line should appear centered on the screen.
This option is not supported.
The starting value is False.
368.15.116 STRADDEXTENTION()
STRADDEXTENTION( cName, cExt ) ⇒ cCompleteName
cName
the file name (with or without path) that is probably without
extention.
cExt the extention that must be added to cName if it has not one.
This function check cName for the presence of an extention. It it has not one, cExt will be added.
368.15.117 STRCUTEXTENTION()
STRCUTEXTENTION( cName ) ⇒ cName
cName
the file name (with or without path) that is probably with extention.
This function check cName for the presence of an extention. It it has one, the extention is removed.
368.15.118 STRDRIVE()
STRDRIVE( cName ) ⇒ cDrive
cName
the file name (with or without path) that contains the drive
letter.
This function tries to extract the drive letter information from cName.

294 volume VIII Argomenti avanzati e accessori
368.15.119 STREXTENTION()
STREXTENTION( cName ) ⇒ cExtention
cName
the file name (with or without path) that contains an extention.
This function tries to extract the extention information from cName.
368.15.120 STRFILE()
STRFILE( cName ) ⇒ cFileName
cName
the file name with or without path.
This function tries to extract the file name without path from cName.
368.15.121 STRFILEFIND()
STRFILEFIND( cName, cPath ) ⇒ cFileName
cName
cPath
the file name or pathname containing the file name to search
inside the cPath list.
a list of paths separated with semicolon (just like Dos does),
where cFile should be searched.
If your file is to be found on different possible positions, this function search the first place where
the file is found and returns a valid pathname to that file.
368.15.122 STRGETLEN()
STRGETLEN( xExpr, cPicture ) ⇒ nFieldLength
xExpr a generic expression.
cPicture
the picture string.
This function returns the length of field when using xExpr with cPicture.
368.15.123 STRLISTASARRAY()
STRLISTASARRAY( cList, [cDelimiter] ) ⇒ aList
cList
cDelimiter
This function transform a character string list into an array.
a character string containing a list separated with cDelimiter.
the delimiter used to separate the elements contained inside
the list.

nanoBase 1997 user manual 295
368.15.124 STROCCURS()
STROCCURS( cSearch, cTarget ) ⇒ nOccurrence
cSearch
the search string to find inside cTarget.
cTarget the string to be searched for the presence of cSearch.
This function returns the number of occurrence that cSearch is contained inside cTarget.
368.15.125 STRPARENT()
STRPARENT( cName ) ⇒ cParentPath
cName
the pathname.
This function tries to return a parent path from cName.
368.15.126 STRPATH()
STRPATH( cName ) ⇒ cPath
cName
the pathname.
This function tries to extract the path from cName.
368.15.127 STRTEMPPATH()
STRTEMPPATH() ⇒ cTempPath
This function returns a temporary path searching for possible definitions inside the environmental
variables.
368.15.128 STRXTOSTRING()
STRXTOSTRING( xVar, [cType] ) ⇒ cTrasformed_to_string
xVar
is the data of any type to be converted into string.
cType is the type of the data contained inside xVar.
This function returns xVar transformed into a character string.

296 volume VIII Argomenti avanzati e accessori
368.15.129 TB()
TB( [nTop], [nLeft], [nBottom], [nRight],
[acCol], [acColSayPic],
[acColTopSep], [acColBodySep], [acColBotSep],
[acColHead], [acColFoot],
[alColCalc],
[abColValid],
[abColMsg],
[cColor], [abColColors],
[nFreeze],
[lModify],
[lAppend],
[lDelete],
[lButtons | aButtons] ) ⇒ NIL
nTop, nLeft, nBottom, nRight defines the screen area where browse have to take place.
acCol
is the columns array to be included into the browse.
acColSayPic is the picture array.
acColTopSep is the top separation array: default is chr(194)+chr(196).
acColBodySep is the body separation array: default is chr(179).
acColBotSep is the bottom separation array: default is chr(193)+chr(196).
acColHead
is the header array for every column.
acColFoot
is the footer array for every column.
alColCalc
is the array that identify the calculated column (not editable).
True (‘.T.’) means calculated.
abColValid
is the validation array that specify when a field is properly
filled. The condition must be specified in code block format.
is the message array that permits to show information at the
abColMsg
bottom of browse area. The array must be composed with
code blocks which result with a character string.
cColor
is the color string: it may be longer than the usual 5 elements.
is the color code block array. The code block receive as pa-
abColColors
rameter the value contained inside the field and must return
an array containing two numbers: they correspond to the two
color couple from cColor.
nFreeze
indicates the number of columns to be left frozen on the left
side.
lModify indicates whether the browse can modify data.
lDelete indicates whether the browse can delete and recall records.
lButtons
if True, default buttons are displayed.
aButtons
array of buttons.
aButtons[n][1] N the nth button row position;
aButtons[n][2] N the nth button column position;
aButtons[n][3] C the nth button text;
aButtons[n][4] B the nth button code block.
This function, called without parameters, starts the browse of the active alias, and if relations are
established, the browse includes also related data.
Please note that due to an unresolved problem, the field names contained inside acCol should
better contain also the alias (ALIAS->FIELD_NAME). See also the examples.

nanoBase 1997 user manual 297
368.15.130 TEXT()
TEXT( cText ) ⇒ NIL
Shows the text contained into cText.
368.15.131 TGLINSERT()
TGLINSERT() ⇒ NIL
Toggle the global insert mode and the cursor shape.
368.15.132 TIMEX2N()
TIMEX2N( [nHH], [nMM], [nSS] ) ⇒ nTime
nHH is the number of hours.
nMM is the number of minutes.
nSS is the number of seconds.
This function calculate the "time number" that is a number representing days and/or portion of a
day: 1 is 1 day or 24 hours, 0.5 is 12 hours, and so on.
368.15.133 TIMEN2H()
TIMEN2H( nTime ) ⇒ nHours
nTime
is the "time number" that is a number representing days and/or
portion of a day: 1 is 1 day or 24 hours, 0.5 is 12 hours, and
so on.
This function returns the integer number of hours contained inside nTime.
368.15.134 TIMEN2M()
TIMEN2M( nTime ) ⇒ nMinutes
nTime
is the "time number" that is a number representing days and/or
portion of a day: 1 is 1 day or 24 hours, 0.5 is 12 hours, and
so on.
This function returns the integer number of minutes contained inside nTime after subtracting the
hours.

298 volume VIII Argomenti avanzati e accessori
368.15.135 TIMEN2S()
TIMEN2S( nTime ) ⇒ nSeconds
nTime
is the "time number" that is a number representing days and/or
portion of a day: 1 is 1 day or 24 hours, 0.5 is 12 hours, and
so on.
This function returns the number of seconds (with eventual decimals) contained inside nTime
after subtracting the hours and the minutes.
368.15.136 TRUESETKEY()
TRUESETLEY( nInkeyCode, bAction ) ⇒ .T.
This function is equivalent to SETKEY() but it returns always ‘.T.’
368.15.137 WAITFILEEVAL()
WAITFILEEVAL( lClose ) ⇒ .T.
Shows a wait bar calling WAITPROGRESS() for operation on records of a database.
If there is no index active, it is equivalent to WAITPROGRES(RECNO()/LASTREC()).
if an index is active, this cannot work, so an increment for each call is made: WAITPRO-
GRES((nIncrement++)/LASTREC()).
This function must be closed calling it with the lClose parameter to true (‘.T.’). This way,
internal counters are closed and WAITPROGRESS() is closed too.
368.15.138 WAITFOR()
WAITFOR( [cMessage] ) ⇒ NIL
Shows cMessage until it is called again. The wait window is closed when called without parameter
or with NIL.
368.15.139 WAITPROGRESS()
WAITPROGRESS( [nPercent] ) ⇒ .T.
Shows a wait bar on the screen top depending on the value contained into nPercent. nPercent
starts form 0 and ends to 1 (100%). If a value of one or more, or NIL is passed, the wait window
is closed.

nanoBase 1997 user manual 299
368.16 Normal command substitution
Clipper works only with functions and commands that are converted into function using the
‘STD.CH’. Here are described some command replacement that can be used also with nB macros.
?
@BOX
@TO
@GET
@SAY
? [exp_list]
qout([exp_list])
?? [exp_list]
qqout([exp_list])
@ nTop, nLeft, nBottom, nRight BOX cnBoxString [COLOR cColorString]
dispbox(nTop, nLeft, nBottom, nRight, [cnBoxString], [cColorString])
@ nTop, nLeft TO nBottom, nRight DOUBLE [COLOR cColorString]
dispbox(nTop, nLeft, nBottom, nRight, 2 [,cColorString])
@ nTop, nLeft TO nBottom, nRight [COLOR cColorString]
dispbox(nTop, nLeft, nBottom, nRight, 1 [,cColorString])
@ nTop, nLeft CLEAR [TO nBottom, nRight]
scroll([nTop], [nLeft], [nBottom, nRight])
setpos(nRow, nCol)
@ nTop, nLeft GET Var [PICTURE cGetPicture] [COLOR cColorString] [WHEN lPreExpression] ←↪
↩→[VALID lPostExpression]
setpos(nTop, nLeft)
aadd( GetList, _GET_( Var, "Var", cGetPicture, [{|| lPostExpression}],←↪
↩→[{|| lPreExpression}] ):display() ) atail(GetList):colorDisp(cColorString)
@ nTop, nLeft SAY exp [COLOR cColorString]
devpos(nTop, nLeft)
devout(exp [, cColorString])
@ nTop, nLeft SAY exp PICTURE cSayPicture [COLOR cColorString]
devpos(nTop, nLeft)
devoutpic(exp, cSayPicture, [cColorString])
APPEND
CLEAR
APPEND BLANK
dbappend()
CLEAR
Scroll()
SetPos(0,0)

300 volume VIII Argomenti avanzati e accessori
CLOSE
ReadKill(.T.)
GetList := {}
CLEAR GETS
ReadKill(.T.)
GetList := {}
CLEAR SCREEN | CLS
Scroll()
SetPos(0,0)
CLOSE
dbCloseArea()
CLOSE idAlias
idAlias->( dbCloseArea() )
CLOSE ALTERNATE
Set(19, "")
CLOSE DATABASES
dbCloseAll()
CLOSE INDEXES
dbClearIndex()
COMMIT
COMMIT
COUNT
dbCommitAll()
COUNT TO idVar [FOR lForCondition] [WHILE lWhileCondition] [NEXT nNextRecords]←↪
↩→[RECORD nRecord] [REST] [ALL]
dbeval( {||idVar:=idVar+1}, {||lForCondition}, {||lWhileCondition},←↪
↩→nNextRecords, nRecord, lRest )
DEFAULT
DEFAULT xVar TO xDefaultValue
DEFAULT( @xVar, xDefaultValue ) ⇒ xVar
DELETE
EJECT
DELETE
dbDelete()
DELETE [FOR lForCondition] [WHILE lWhileCondition] [NEXT nNextRecords]←↪
↩→[RECORD nRecord] [REST] [ALL]
dbeval( {||dbDelete()}, {||lForCondition}, {||lWhileCondition},←↪
↩→nNextRecords, nRecord, lRest )
DELETE FILE xcFile
ferase( cFile )
EJECT
ERASE
qqout( chr(13) )
ERASE xcFile
ferase( cFile )

nanoBase 1997 user manual 301
FIND
GO
FIND xcSearchString
dbSeek( cSearchString )
GO[TO] nRecord
dbgoto(nRecord)
GO[TO] BOTTOM
dbGoBottom()
GO[TO] TOP
dbgotop()
INDEX ON
READ
INDEX ON expKey TO xcIndexName [UNIQUE] [FOR lForCondition]←↪
↩→[WHILE lWhileCondition] [[EVAL lEvalCondition] [EVERY nRecords]] [ASCENDING|
DESCENDING]
ordCondSet( [cForCondition], [bForCondition], , [bWhileCondition],←↪
↩→[bEvalCondition], [nRecords], RECNO(), , , , lDescending )
ordCreate( cIndexName, , cExpKey, bExpKey, lUnique )
READ
ReadModal(GetList)
GetList := {}
READ SAVE
ReadModal(GetList)
RECALL
RECALL
dbRecall()
RECALL [FOR lForCondition] [WHILE lWhileCondition] [NEXT nNextRecords]←↪
↩→[RECORD nRecord] [REST] [ALL]
dbeval( {||dbRecall()}, {||lForCondition}, {||lWhileCondition},←↪
↩→nNextRecords, nRecord, lRest )
REINDEX
REINDEX [EVAL lEvalCondition] [EVERY nRecords]
ordCondSet(, , , , [bEvalCondition], [nRecords], , , , , , , )
ordListRebuild()
RENAME
RENAME xcOldFile TO xcNewFile
frename( cOldFile, cNewFile )
REPLACE
REPLACE idField1 WITH exp1 [, idField2 WITH exp2...]←↪
↩→[FOR lForCondition] [WHILE lWhileCondition] [NEXT nNextRecords]←↪
↩→[RECORD nRecord] [REST] [ALL]
dbeval( {|| idField1 := exp1 [, idField2 := exp2...]},←↪
↩→{||lForCondition}, {||lWhileCondition}, nNextRecords,←↪
↩→nRecord, lRest )

302 volume VIII Argomenti avanzati e accessori
REPLACE idField1 WITH exp1
idField1 := exp1
RESTORE
SAVE
SEEK
RESTORE SCREEN FROM cScreen
restscreen( 0, 0, Maxrow(), Maxcol(), cScreen )
SAVE SCREEN TO cScreen
cScreen := savescreen( 0, 0, maxrow(), maxcol() )
SEEK expSearch [SOFTSEEK]
dbSeek( expSearch [, lSoftSeek] )
SELECT
SET
SELECT xnWorkArea | idAlias
dbSelectArea( nWorkArea | cIdAlias )
SET ALTERNATE TO xcFile [ADDITIVE]
Set( 19, cFile, lAdditive )
SET ALTERNATE ON | OFF | xlToggle
Set( 18, "ON" | "OFF" | lToggle )
SET BELL ON | OFF | xlToggle
Set( 26, "ON" | "OFF" | lToggle )
SET COLOR | COLOUR TO (cColorString)
SetColor( cColorString )
SET CONFIRM ON | OFF | xlToggle
Set( 27, "ON" | "OFF" | lToggle )
SET CONSOLE ON | OFF | xlToggle
Set( 17, "ON" | "OFF" | lToggle )
SET CURSOR ON | OFF | xlToggle
SetCursor( 1 | 0 | iif( lToggle, 1, 0 ) )
SET DATE FORMAT [TO] cDateFormat
Set( 4, cDateFormat )
SET DECIMALS TO
Set( 3, 0 )
SET DECIMALS TO nDecimals
Set( 3, nDecimals )
SET DEFAULT TO
Set( 7, "" )
SET DEFAULT TO xcPathspec
Set( 7, cPathspec )

nanoBase 1997 user manual 303
SET DELETED ON | OFF | xlToggle
Set( 11, "ON" | "OFF" | lToggle )
SET DELIMITERS ON | OFF | xlToggle
Set( 33, "ON" | "OFF" | lToggle )
SET DELIMITERS TO [DEFAULT]
Set( 34, "::" )
SET DELIMITERS TO cDelimiters
Set( 34, cDelimiters )
SET DEVICE TO SCREEN | PRINTER
Set( 20, "SCREEN" | "PRINTER" )
SET EPOCH TO nYear
Set( 5, nYear )
SET ESCAPE ON | OFF | xlToggle
Set( 28, "ON" | "OFF" | lToggle )
SET EXACT ON | OFF | xlToggle
Set( 1, "ON" | "OFF" | lToggle )
SET EXCLUSIVE ON | OFF | xlToggle
Set( 8, "ON" | "OFF" | lToggle )
SET FILTER TO
dbclearfilter()
SET FILTER TO lCondition
dbsetfilter( bCondition, cCondition )
SET FIXED ON | OFF | xlToggle
Set( 2, "ON" | "OFF" | lToggle )
SET INDEX TO [xcIndex [, xcIndex1... ] ]
ordListClear()
ordListAdd( cIndex )
ordListAdd( cIndex1 )
...
SET INTENSITY ON | OFF | xlToggle
Set( 31, "ON" | "OFF" | lToggle )
SET KEY nInkeyCode [TO]
SetKey( nInkeyCode, NIL )
SET KEY nInkeyCode TO [idProcedure]
SetKey( nInkeyCode, { |p, l, v| idProcedure(p, l, v)} )
SET MARGIN TO
Set( 25, 0 )
SET MARGIN TO [nPageOffset]
Set( 25, nPageOffset )
SET MESSAGE TO
Set( 36, 0 )

304 volume VIII Argomenti avanzati e accessori
SKIP
STORE
Set( 37, .F. )
SET MESSAGE TO [nRow [CENTER | CENTRE]]
Set( 36, nRow )
Set( 37, lCenter )
SET ORDER TO [nIndex]
ordSetFocus( nIndex )
SET PATH TO
Set( 6, "" )
SET PATH TO [xcPathspec [, cPathspec1... ] ]
Set( 6, cPathspec [, cPathspec1... ] )
SET PRINTER ON | OFF | xlToggle
Set( 23, "ON" | "OFF" | lToggle )
SET PRINTER TO
Set( 24, "" )
SET PRINTER TO [xcDevice|xcFile [ADDITIVE]]
Set( 24, cDevice|cFile, lAdditive )
SET RELATION TO
dbclearrelation()
SET RELATION TO [expKey1 INTO xcAlias1]
[, [TO] expKey2 INTO xcAlias2...]
[ADDITIVE]
if !lAdditive
dbClearRel()
end
dbSetRelation( cAlias1, {|| expKey1}, ["expKey1"] )
dbSetRelation( cAlias2, {|| expKey2}, ["expKey1"] )
SET SCOREBOARD ON | OFF | xlToggle
Set( 32, "ON" | "OFF" | lToggle )
SET SOFTSEEK ON | OFF | xlToggle
Set( 9, "ON" | "OFF" | lToggle )
SET TYPEAHEAD TO nKeyboardSise
Set( 14, nKeyboardSise )
SET UNIQUE ON | OFF | xlToggle
Set( 10, "ON" | "OFF" | lToggle )
SET WRAP ON | OFF | xlToggle
Set( 35, "ON" | "OFF" | lToggle )
SKIP [nRecords] [ALIAS idAlias|nWorkArea]
[idAlias|nWorkArea -> ]( dbSkip([nRecords]) )
STORE value TO variable

nanoBase 1997 user manual 305
SUM
variable := value
SUM nExp1 [, nExp2...] TO idVar1 [, idVar2...] [FOR lForCondition]←↪
↩→[WHILE lWhileCondition] [NEXT nNextRecords] [RECORD nRecord] [REST] [ALL]
dbeval( {||idVar1:=idVar1+nExp1 [, idVar2:=idVar2+nExp2...] },←↪
↩→{||lForCondition}, {||lWhileCondition}, nNextRecords, nRecord, lRest )
UNLOCK
USE
UNLOCK
dbUnlock()
UNLOCK ALL
dbUnlockAll()
USE
dbclosearea()
USE [xcDatabase]←↪
↩→[INDEX xcIndex1 [, xcIndex2...] [ALIAS xcAlias] [EXCLUSIVE|SHARED] [NEW] [READONLY
] [VIA cDriver]]
dbUseArea( [lNewArea], [cDriver], cDatabase, [cAlias], [lShared], [lReadOnly] )
[dbSetIndex( cIndex1 )]
[dbSetIndex( cIndex2 )]
...
368.17 nB command substitution functions
Inside nB there are many functions made only in substitution to other Clipper commands.
GET
aGetList
SAY
@ nTop, nLeft GET Var
[PICTURE cGetPicture]
[COLOR cColorString]
[WHEN lPreExpression]
[VALID lPostExpression]
Get( @aGetList,
[nTop], [nLeft],
{ |x| iif( pcount() > 0, Var := x, Var ) }
[cGetPicture], [cColorString],
[bPreExpression], [bValid] )
@ nTop, nLeft SAY exp
PICTURE cSayPicture
[COLOR cColorString]
Say( nTop, nLeft, cVar, [cSayPicture], [cColorString] )
is the get list array that will be increased with this get().

306 volume VIII Argomenti avanzati e accessori
APPEND FROM
APPEND FROM xcFile
[FIELDS idField_list]
[scope]
[WHILE lCondition]
[FOR lCondition]
[VIA xcDriver]
dbApp( cFileName, [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords],
[nRecord],
[lRest],
[cDriver] )
APPEND FROM xcFile
[FIELDS idField_list]
[scope]
[WHILE lCondition]
[FOR lCondition]
DELIMITED xcDelimiter
dbDelim( .f., cFileName, [cDelimiter], [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest] )
APPEND FROM xcFile
[FIELDS idField_list]
[scope]
[WHILE lCondition]
[FOR lCondition]
SDF
dbSDF( .f., cFileName, [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest] )
CONTINUE
COPY
CONTINUE
dbContinue()
COPY FILE xcSourceFile TO xcTargetFile|xcDevice
CopyFile( cSourceFile, cTargetFile|cDevice )
COPY STRUCTURE [FIELDS idField_list]
TO xcDatabase
dbCopyStruct( cDatabase, [acFields] )
COPY STRUCTURE EXTENDED
TO xcExtendedDatabase
dbCopyXStruct( cExtendedDatabase )
COPY TO xcFile
[FIELDS idField_list]
[scope]
[WHILE lCondition]
[FOR lCondition]
[VIA xcDriver]

nanoBase 1997 user manual 307
dbCopy( cFileName, [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords],
[nRecord],
[lRest],
[cDriver] )
COPY TO xcFile
[FIELDS idField_list]
[scope]
[WHILE lCondition]
[FOR lCondition]
DELIMITED xcDelimiter
dbDelim( .t., cFileName, [cDelimiter], [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest] )
COPY TO xcFile
[FIELDS idField_list]
[scope]
[WHILE lCondition]
[FOR lCondition]
SDF
dbSDF( .t., cFileName, [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest] )
CREATE
JOIN
CREATE xcDatabase
FROM xcExtendedDatabase
[NEW]
[ALIAS cAlias]
[VIA cDriver]
dbOldCreate( cDatabase, cExtendedDatabase,
[cDriver], [lNew], [cAlias] )
JOIN WITH xcAlias TO xcDatabase
[FOR lCondition] [FIELDS idField_list]
dbJoin( cAlias, cDatabase,
[acFields], [bForCondition] )
KEYBOARD
KEYBOARD cString
Keyboard( [cString] ) ⇒ NIL
LABEL FORM
LABEL FORM xcLabel
[TO PRINTER]
[TO FILE xcFile]
[NOCONSOLE]
[scope]
[WHILE lCondition]
[FOR lCondition]
[SAMPLE]
dbLabelForm( cLabel, [lToPrinter], [cFile],
[lNoConsole], [bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest], [lSample] )

308 volume VIII Argomenti avanzati e accessori
LIST
LIST exp_list
[TO PRINTER]
[TO FILE xcFile]
[scope]
[WHILE lCondition]
[FOR lCondition]
[OFF]
dbList( [lToDisplay], abListColumns,
[lAll],
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest],
[lToPrinter], [cFileName] )
LOCATE
PACK
LOCATE [scope] FOR lCondition
[WHILE lCondition]
dbLocate( [bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest] )
PACK
dbPack()
PUBLIC
QUIT
PUBLIC idMemvar
MemPublic( cMemvarName|acMemvarNames )
QUIT
Quit()
RELEASE
RELEASE idMemvar
MemRelease( cMemvarName|acMemvarNames )
REPORT FORM
REPORT FORM xcReport
[TO PRINTER]
[TO FILE xcFile]
[NOCONSOLE]
[scope]
[WHILE lCondition]
[FOR lCondition]
[PLAIN | HEADING cHeading]
[NOEJECT] [SUMMARY]
RF( cForm,
[bForCondition], [bWhileCondition],
[nNext], [nRecord], [lRest], [lPlain],
[cbHeading], [lBeforeEject], [lSummary],
[lDate], [acExtra] ) ⇒ NIL
RESTORE FROM
RESTORE FROM xcMemFile [ADDITIVE]
MemRestore( cMemFileName, [lAdditive] )

nanoBase 1997 user manual 309
RUN
RUN xcCommandLine
Run( cCommand )
SAVE TO
SAVE TO xcMemFile
[ALL [LIKE|EXCEPT skeleton]]
MemSave( cMemFileName, [cSkeleton], [lLike] )
SET FUNCTION
SORT
TOTAL
SET FUNCTION nFunctionKey TO cString
SetFunction( nFunctionKey, cString )
SORT TO xcDatabase
ON idField1 [/[A|D][C]]
[, idField2 [/[A|D][C]] ...]
[scope]
[WHILE lCondition]
[FOR lCondition]
dbSort( cDatabase, [acFields],
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord], [lRest] )
TOTAL ON expKey
[FIELDS idField_list] TO xcDatabase
[scope]
[WHILE lCondition]
[FOR lCondition]
dbTotal( cDatabase, bKey, [acFields,
[bForCondition], [bWhileCondition],
[nNextRecords], [nRecord]], [lRest] )
UPDATE
ZAP
UPDATE FROM xcAlias
ON expKey [RANDOM]
REPLACE idField1 WITH exp
[, idField2 WITH exp ...]
dbUpdate( cAlias, bKey, [lRandom], [bReplacement] )
Example:
ZAP
dbZap()
dbUpdate( "INVOICE", {|| LAST}, .T.,;
{|| FIELD->TOTAL1 := INVOICE->SUM1,;
FIELD->TOTAL2 := INVOICE->SUM2 } )

310 volume VIII Argomenti avanzati e accessori
368.18 RPT: the nB print function
The function RPT() helps to print ASCII file containing Memvars, Fields and print commands.
RPT() is accessible from the DOC() menu.
368.18.1 Memvars and fields
As usual with standard word processors, variables are written delimited with "" (Alt+175).
Inside these delimiters can find place character Memvars, character Fields and functions giving
a character result.
The RPT() function generates a public variable n_Lines that contains the available lines inside
the actual sheet. Every time a line is written, this value is reduced, until a new page is reached and
then it will start again from the maximum value. It is useful to read this variable to determinate
if there is enough space or it is better to change page.
368.18.2 Commands
The function RPT() recognise some print commands. These commands starts with the asterisk
(*) symbol. This means that "*" is a print command prefix.
It follows the command syntax.
*COMMAND
*COMMAND
cStatement
cStatement
...
*END
The lines contained inside *COMMAND - *END are executed with the nB macro interpreter.
*DBSKIP
*DBSKIP [nSkip]
It Executes a dbskip() on the active alias.
*FOOT
*FOOT
cFooter
cFooter
...
*END
The lines contained inside *FOOT - *END are printed each time at the bottom of pages.
*HEAD
*HEAD
cHeader
cHeader
...
*END
The lines contained inside *HEAD - *END are printed each time at the top of pages.

nanoBase 1997 user manual 311
*IF
*IF lCondition
...
...
*END
If the condition lCondition is true, the lines contained inside *IF - *END are printed.
*INSERT
*LEFT
*LPP
*INSERT cFileName
Includes the text contained into the file cFileName.
*LEFT nLeftBorder
The nLeftBorder is the number of column to be left blank as a left border.
*LPP nLinesPerPage
It determinates the page length expressed in lines. After printing the nLinesPerPageth line,
a form feed is sent.
*NEED
*PA
*NEED nLinesNeeded
If the available lines are less then nLinesNeeded, the follwing text will be printed on the
next page.
*PA
*REM
Jumps to a new page.
*REM | *COMMENT [comment_line]
It adds a comment that will not be printed.
*WHILE
*WHILE lCondition
...
...
*END
The lines contained inside *WHILE - *END are printed as long as lCondition is true.
368.18.3 Examples
It follows some example of text to be printed with the RPT() function. Example’s lines are numbered.
Line numbers must not be part of a real RPT text files.
PAGE DEFINITION
Margins are defined with *HEAD, *FOOT and *LEFT commands. In the following example
is defined:

312 volume VIII Argomenti avanzati e accessori
Top 2 lines;
Bottom 2 lines;
Left 10 characters.
The right margin is not defined as it depends on the lines length that will be printed.
The only considered page dimension is the height, *LPP (lines per page):
Page height 66 lines.
Here starts the example:
001 *lpp 66
002 *head
003
004
005 *end
006 *foot
007
008
009 *end
010 *left 10
011 ... text text text
012 ... test text text
...
At line 001 is defined the page height in lines. At line 002 is defined the header; it contains
two empty lines (003 and 004) which will be printed at the top of every page. At line 006
starts the footer definition that contains two empty lines (007 and 008) that will be printed
at the end of every page. At line 010 is defined the space on the left that will be added to
every line printed. From line 011 starts the normal text.
HEADER AND FOOTER
The commands *HEAD and *FOOT are used to define the top and bottom border if they
contains empty lines, it these lines are not empty, they became real head and foot.
The dimensions are as it follows:
Top 6 lines (should be one inch);
Bottom 6 lines;
Left 10 characters (should be an inch).
Page height 66 lines (should be 11 inch).
At position 0.5 in (after 3 lines) a one line header appears.

nanoBase 1997 user manual 313
001 *lpp 66
002 *head
003
004
005
006 ------------------- MYFILE.TXT -------------------
007
008
009 *end
010 *foot
011
012
013
014
015
016
017 *end
018 *left 10
019 ... text text text
020 ... test text text
...
At line 006 (the fourth header line) a text appears. It will be printed on every page at the
absolute fourth page line.
CODE INSERTION
Pieces of code can be inserted inside *COMMAND - *END. It can be useful to make
complicated reports.
The following example declares a public variable used to number pages.
001 *command
002 mempublic("PageNo")
003 PageNo := 0
004 *end
005 *lpp 66
006 *head
007 *command
008 PageNo := PageNo +1
009 *end
010
011
012 *end
013 *foot
014
015 Page
016
017 *end
018 *left 10
019 ... text text text
020 ... test text text
...
At line 001 starts a *COMMAND definition: lines 002 and 003 will be interpreted from the
function EX(), the nB interpreter. These lines define a public variable and initialize it at 0.
This variable will be use to count pages.
At line 007, inside the header (nested), start another *COMMAND definition that contains
an increment for the "PageNo" variable. As the header is read and "executed" for every new
page, and that before the footer, the variable "PageNo" will contain the right page number.
At line 015, inside the footer, a reference to "PageNo" appears. Here will be printed the
page number.
A more complicated example can be found in ‘ADDRESS.TXT’ the RPT text file used for
the ADDRESS.& macro examples.

314 volume VIII Argomenti avanzati e accessori
368.19 How can I...
nB is a little bit complicated as it may do many things. Here are some examples.
Create a UDF function
UDF means User Defined Function. Inside nB there isn’t the possibility to create functions,
but there is an alternative: code blocks.
Create a big code block
A code block cannot be longer than 254 characters, as any other instruction inside nB.
So, there is no way to make a bigger code block, but a code block can call another code
block, and so on. For example:
mempublic( { "first", "second", "third" } )
first := {|| eval( second, "hello" ) }
second := {|x| eval( third, x ) }
third := {|x| alertbox( x ) }
eval( first )
This stupid example simply will show the alert box containing the word "hello".
368.20 The source files
The nB source is composed of four files:
‘NB.PRG’ The main source file containing essentially the nB menu.
‘REQUEST.PRG’ Contains a link to all Clipper standard functions.
‘STANDARD.PRG’ Contains the most important standard functions.
‘EXTRA.PRG’
Contains some extra function not absolutely necessary during
macro execution.
The file ‘REQUEST.PRG’ source file generates some warnings because not all functions listed
there are directly called form nB. Don’t worry about that warning message.
Different ‘.RMK’ (rmake) files are included to compile nB differently, including/excluding some
program parts, for example to obtain a runtime executor.
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Parte lxxiii
Braille
369 Introduzione al sistema braille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
369.1 Origini e caratteristiche del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
369.2 Codifica semplificata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
369.3 Braille a otto punti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
369.4 Tabelle di conversione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
369.5 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
370 Sistemi di interazione per non vedenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
370.1 Lettura di ciò che appare sullo schermo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
370.2 Terminali braille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
370.3 Brltty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
370.4 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
315

Introduzione al sistema braille
Capitolo 369
Lo scopo di questo capitolo è quello di descrivere brevemente il codice usato dal sistema braille,
in modo di facilitare la comprensione del funzionamento di un terminale per non vedenti. Ciò
potrebbe servire per verificare l’installazione e la configurazione corretta di un dispositivo del
genere.
369.1 Origini e caratteristiche del sistema
Il sistema di scrittura per non vedenti è stato inventato da Louis Braille nel 1829, da cui viene
il nome. Luis Braille era francese e in questo senso vanno viste le scelte che possono sembrare
insolite, per chi è abituato a convenzioni derivanti dalla lingua inglese.
Il sistema codifica 63 simboli rappresentati ognuno da una cella in cui possono essere collocati
un massimo di sei punti in rilievo:
.----.
|* *|
|* *|
|* *|
‘----’
Tanto per fare un esempio, se si possono immaginare gli asterischi della figura seguente come
altrettanti punti in rilievo, la parola «ciao!» si può rappresentare in questo modo:
* * * * *
* * * *
* *
Il sistema braille è fatto fondamentalmente per una scrittura manuale, che avviene attraverso
l’uso di una tavoletta speciale, come si può vedere nelle figure 369.3 e 369.4.
Figura 369.3. Tavoletta di scrittura braille normale.
316

Introduzione al sistema braille 317
La scrittura avviene su un foglio di cartoncino bloccato sulla tavoletta, con l’aiuto di un punteruolo,
guidato dalle feritoie poste su un regolo mobile (nel caso della tavoletta tascabile, il regolo
è fisso). Dal momento che la scrittura avviene attraverso l’incisione del cartoncino, la lettura tattile,
in rilievo, potrà avvenire solo sull’altro lato; pertanto, per quanto riguarda le lingue latine, la
scrittura avviene da destra verso sinistra e la lettura da sinistra a destra.
Figura 369.4. Tavoletta di scrittura braille tascabile. La fase si scrittura avviene inciden-
do il cartoncino. In questo caso, non si vede la fila superiore, perché rimane coperta
dall’ombra.
Figura 369.5. Testo inciso da destra verso sinistra.
Figura 369.6. Testo in rilievo da sinistra verso destra.
Il braille standard è composto da celle con un massimo di sei punti in rilievo, per un massimo
di 2 6 -1 segni, più lo spazio; tuttavia, possono esistere anche dispositivi braille predisposti per
un massimo di otto punti in rilievo.
369.2 Codifica semplificata
La disposizione classica della codifica del braille è sintetizzata dalle figure 369.9 e 369.10. Chi
volesse studiare ed esercitarsi con il braille, farebbe bene a copiare le due figure in modo da
mettere a sinistra quella dei segni in scrittura e a destra quella dei segni in lettura.
Come si può comprendere a livello intuitivo, i 63 simboli non consentono di distinguere le lettere
minuscole da quelle maiuscole; in generale si tratta sempre solo di lettere minuscole che
diventano maiuscole se precedute dal segno relativo. Per esempio, «Daniele» si scrive così:
* * * * * * * * * *
* * * * * *
* * *

318 volume VIII Argomenti avanzati e accessori
Nello stesso modo, come si vede, non sono previsti i numeri. Questi si ottengono indicando il
segno di numero davanti alle prime 10 lettere alfabetiche. Per esempio, 123 si indica così:
* * * * *
* *
* *
Pertanto, a differenza delle maiuscole, il segno di numero vale per tutta la sequenza di simboli
successiva.
Esistono naturalmente altri dettagli molto importanti per chi deve usare il braille, che però qui
non vengono descritti. Purtroppo, i segni a disposizione sono molto pochi e di conseguenza, tutto
quanto ha sempre un valore relativo al contesto.
369.3 Braille a otto punti
La codifica a otto punti consente di utilizzare una sola cella per indicare una lettera maiuscola o
un numero. Ciò diventa particolarmente importante in un terminale braille, in cui è bene che si
possa mantenere una corrispondenza tra celle e caratteri.
369.4 Tabelle di conversione
L’abbinamento del braille all’informatica, impone l’introduzione di tabelle di conversione dalla
codifica dei caratteri al braille stesso. In pratica, in base alla nazionalità, si utilizza una codifica
particolare; oltre a questo, deve essere definito un abbinamento tra codice binario (ASCII, ISO
8859-n, ecc.) e rappresentazione braille. Quando si utilizza un terminale braille o un sistema di
stampa braille, occorre stabilire anche questo tipo di conversione.

Introduzione al sistema braille 319
Figura 369.9. La codifica braille per la scrittura da destra verso sinistra, secondo
l’ordine classico.
j i h g f e d c b a
* . * . . * * * * * . * * * * * . * . *
* * . * * * * * . * * . * . . . . * . .
. . . . . . . . . . . . . . . . . . . .
t s r q p o n m l k
* . * . . * * * * * . * * * * * . * . *
* * . * * * * * . * * . * . . . . * . .
. * . * . * . * . * . * . * . * . * . *
ù è à é ç z y x v u
* . * . . * * * * * . * * * * * . * . *
* * . * * * * * . * * . * . . . . * . .
* * * * * * * * * * * * * * * * * * * *
w æ ü ï ë û ô î ê â
* . * . . * * * * * . * * * * * . * . *
* * . * * * * * . * * . * . . . . * . .
* . * . * . * . * . * . * . * . * . * .
« * » () ! ? . : ; ,
. . . . . . . . . . . . . . . . . . . .
* . * . . * * * * * . * * * * * . * . *
* * . * * * * * . * * . * . . . . * . .
numero ò verso ì lineetta apostrofo
* . * . * . * * . . . .
* . . . * . . . . . . .
* * * * . * * . * * . *
maiuscole corsivo
. . . . * . . . * . * . * .
. . * . . . * . * . * . . .
* . * . * . . . * . . . . .

320 volume VIII Argomenti avanzati e accessori
Figura 369.10. La codifica braille per la lettura da sinistra verso destra, secondo
l’ordine classico.
a b c d e f g h i j
* . * . * * * * * . * * * * * . . * . *
. . * . . . . * . * * . * * * * * . * *
. . . . . . . . . . . . . . . . . . . .
k l m n o p q r s t
* . * . * * * * * . * * * * * . . * . *
. . * . . . . * . * * . * * * * * . * *
* . * . * . * . * . * . * . * . * . * .
u v x y z ç é à è ù
* . * . * * * * * . * * * * * . . * . *
. . * . . . . * . * * . * * * * * . * *
* * * * * * * * * * * * * * * * * * * *
â ê î ô û ë ï ü æ w
* . * . * * * * * . * * * * * . . * . *
. . * . . . . * . * * . * * * * * . * *
. * . * . * . * . * . * . * . * . * . *
, ; : . ? ! () « * »
. . . . . . . . . . . . . . . . . . . .
* . * . * * * * * . * * * * * . . * . *
. . * . . . . * . * * . * * * * * . * *
apostrofo lineetta ì verso ò numero
. . . . * * . * . * . *
. . . . . . . * . . . *
* . * * . * * . * * * *
corsivo maiuscole
. * . * . * . . . * . . . .
. . . * . * . * . . . * . .
. . . . . * . . . * . * . *
369.5 Riferimenti
• Dottless braille
• A (slightly) different introduction to braille
Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

Sistemi di interazione per non vedenti
Capitolo 370
I sistemi standard di interazione per non vedenti con un elaboratore sono di due tipi, che si
integrano convenientemente assieme: il terminale braille e la lettura automatica di ciò che appare
sullo schermo. Il terminale braille è un’unità che si collega generalmente a una porta seriale o
parallela e richiede la presenza di un programma in grado di leggere ciò che appare sullo schermo
normale; il sistema di lettura automatica richiede naturalmente un programma simile.
Un sistema di lettura automatico è apparentemente un problema semplice da risolvere; in pratica
le cose non sono così, perché deve anche essere in grado di individuare la struttura del testo (si
pensi a un’organizzazione in più colonne). Il sistema che sembra essere più efficace per la lettura
sonora del testo è Emacspeack, che comunque qui non viene descritto. Si vedano eventualmente
i riferimenti bibliografici alla fine del capitolo.
370.1 Lettura di ciò che appare sullo schermo
Qualunque sistema di lettura per non vedenti (braille o audio), deve avere un modo per accedere
a ciò che appare sullo schermo. Esistono evidentemente due modi: ciò che appare sullo schermo
è controllato direttamente dal programma di lettura, oppure questo programma deve interagire
con il sistema operativo per ottenere una copia dello schermo.
Un programma che controlla ciò che si deve leggere potrebbe essere una shell, oppure una sorta
di navigatore ipertestuale, che eventualmente incorpori anche delle funzionalità per la creazione
e la modifica dei documenti (dovrebbe essere questo il caso di Emacspeack).
Nel caso di GNU/Linux si accede a una copia di ciò che appare sullo schermo della console
attiva attraverso il file di dispositivo ‘/dev/vcsa’ o ‘/dev/vcsa0’. In particolare questi file di
dispositivo consentono di ottenere informazioni anche sugli attributi del testo, cosa che permette
di localizzare il cursore, per esempio; esistono infatti anche i file di dispositivo ‘/dev/vcs * ’
che consentono di ottenere una pura copia testuale delle console virtuali.
Questi file di dispositivo sono normalmente inaccessibili a utenti diversi dall’amministratore;
pertanto, per consentire una lettura a programmi con privilegi limitati, occorre intervenire nei
permessi. Supponendo di dover creare da zero il file di dispositivo ‘/dev/vcsa0’, probabilmente
si dovrebbe agire come segue:
# mknod /dev/vcsa0 c 7 128 [ Invio ]
# chown root.tty /dev/vcsa0 [ Invio ]
# chmod 660 /dev/vcsa0 [ Invio ]
In pratica, si arriva alla fine a dare i permessi di lettura e scrittura anche al gruppo, supponendo
che il programma che deve utilizzarlo funzioni, in questo caso, con i privilegi del gruppo ‘tty’
(SGID-‘tty’). Ciò consente di mantenere un minimo di riservatezza, nonostante il problema
contingente da risolvere.
Volendo verificare che il file di dispositivo ‘/dev/vcsa0’ consente di accedere al contenuto
dello schermo della console virtuale attuale, si può inviarne una copia in una console inattiva o
comunque non utilizzata. Per esempio:
# cat /dev/vcsa0 > /dev/tty12 [ Invio ]
321

322 volume VIII Argomenti avanzati e accessori
Manda una copia alla 12-esima console virtuale e si può verificare facilmente con la
combinazione di tasti [ Alt+F12 ].
370.2 Terminali braille
Il terminale braille è solitamente un componente da collocare al di sotto della tastiera normale,
attraverso il quale è possibile leggere una riga di testo, senza allontanare troppo le dita dalla
tastiera stessa.
Vicino alla barra contenente le celle braille, devono essere disponibili alcuni tasti per il controllo
del terminale stesso, per poter navigare sulla superficie di quello che appare sullo schermo. Infatti,
di solito si dispone di una sola riga di celle braille, ma anche se potessero essere disponibili più di
una, non sarebbero mai quante le righe che si vedono su uno schermo normale; inoltre, anche la
quantità di celle è limitata, per cui diventa necessario poter spostare la «visualizzazione» braille
anche in orizzontale.
Figura 370.1. Collocazione tipica di un terminale braille, sotto la tastiera o sotto un
elaboratore portatile.
La figura 370.2 mostra in particolare un dettaglio delle celle di un terminale braille a otto punti.
Figura 370.2. Dettaglio delle celle di un terminale braille.

Sistemi di interazione per non vedenti 323
370.3 Brltty
Brltty 1 è un programma in grado di comunicare con un terminale braille, allo scopo di inviargli
ciò che accade sullo schermo della console virtuale attiva di un sistema GNU/Linux.
Il funzionamento del programma è relativamente semplice: si tratta di un demone, ‘brltty’, da
avviare e fermare automaticamente attraverso la procedura di inizializzazione del sistema, che
comunica con il terminale braille seguendo la configurazione relativa al terminale stesso e la
configurazione della conversione braille.
In pratica, Brltty deve conoscere il tipo di terminale braille utilizzato e deve disporre di una tabella
di conversione adatta per quanto riguarda la codifica usata e l’alfabeto braille dell’utilizzatore.
370.3.1 Configurazione
Brltty è accompagnato da una serie di file di libreria, per l’adattamento alle caratteristiche del
terminale braille e per la conversione finale della codifica in braille. Questi file dovrebbero essere
collocati nella directory ‘/etc/brltty/’.
Il file di configurazione in cui occorre intervenire dovrebbe essere ‘/etc/brltty.conf’, il cui
contenuto potrebbe apparire come nell’esempio seguente:
braille-device /dev/ttyS0
braille-driver ec
dot-translation text.us.tbl
Si comprende intuitivamente il significato delle direttive: il terminale viene connesso alla prima
porta seriale, corrispondente al file di dispositivo ‘/dev/ttyS0’; il terminale braille viene gestito
attraverso un protocollo definito dalla sigla ‘ec’; la trasformazione della codifica in braille
avviene secondo il modello denominato ‘text.us.tbl’, che in pratica è un file contenuto nella
directory ‘/etc/brltty/’, facente riferimento a un adattamento per la lingua inglese.
Tabella 370.1. Sigle attraverso le quali si abbinano le librerie di controllo del terminale
braille.
Sigla Terminale corrispondente
al
Alva (ABT3xx/Delphi)
b1 BrailleLite 18
b4 BrailleLite 40
cb Tieman CombiBraille
ec EcoBraille
eu EuroBraille
md
pm
MDV braille
Papenmeier
ts TSI (PowerBraille/Navigator)
va BAUM Vario
Brltty è anche in grado di gestire terminali parlanti. Eventualmente, si può usare la direttiva
‘speech-driver’ per il controllo della sintesi vocale. Di solito, la funzionalità è disabilitata,
con la direttiva seguente:
speech-driver no
1 Brltty GNU GPL

324 volume VIII Argomenti avanzati e accessori
Tabella 370.2. Sigle relative alla gestione della sintesi vocale.
Sigla Sintesi vocale
no No Speech
al
Alva (Delphi)
bl BrailleLite
cb Tieman CombiBraille
fv
Festival Text to Speech Package
gs Generic Say (invia allo standard input di ‘/usr/local/bin/say’)
tv Televox Speech Interface
370.3.2 Accesso alla copia della console virtuale corrente
Come già spiegato in precedenza, anche Brltty deve poter accedere a una copia della console
virtuale corrente. Ciò avviene precisamente attraverso il file di dispositivo ‘/dev/vcsa0’, che in
alcuni sistemi GNU/Linux potrebbe anche essere assente, perché equivalente a ‘/dev/vcsa’. Si
riepilogano nuovamente i passi necessari a creare il file e ad attribuirgli i permessi necessari per
il funzionamento corretto con Brltty.
# mknod /dev/vcsa0 c 7 128 [ Invio ]
# chown root.root /dev/vcsa0 [ Invio ]
# chmod 600 /dev/vcsa0 [ Invio ]
In questo caso, si presume che il demone ‘brltty’ sia avviato attraverso la procedura di inizializzazione
del sistema, in modo tale da funzionare con tutti i privilegi dell’utente ‘root’.
Diversamente, occorre cambiare strategia per quanto riguarda i permessi e la proprietà del file di
dispositivo.
370.4 Riferimenti
• BRLTTY - official home
• BRLSPEAK: a braille and speech mini-distribution of GNU/Linux
• Blind + Linux = BLINUX

Parte lxxiv
Aspetti umani
371 Manifesto GNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
372 Il progetto GNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
372.1 La prima comunità di condivisione del software . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
372.2 La comunità si dissolve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
372.3 Una difficile scelta morale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
372.4 "Free" come libero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
372.5 Software GNU e il sistema GNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
372.6 L’inizio del progetto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
372.7 I primi passi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
372.8 GNU Emacs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
372.9 Un programma è libero per tutti? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
372.10 Il permesso d’autore (copyleft) e la GNU GPL . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
372.11 La Free Software Foundation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
372.12 Il supporto per il software libero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .346
372.13 Obiettivi tecnici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
372.14 Donazioni di computer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
372.15 L’elenco dei compiti GNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .347
372.16 La licenza GNU per le librerie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
372.17 Togliersi il prurito? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
372.18 Sviluppi inattesi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
372.19 GNU-Hurd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
372.20 Alix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
372.21 Linux e GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
372.22 Le sfide che ci aspettano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
372.23 Hardware segreto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
372.24 Librerie non libere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
372.25 Brevetti sul software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
372.26 Documentazione libera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
372.27 Dobbiamo parlare di libertà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
372.28 "Open Source" . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
372.29 Prova! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
373 La rivoluzione del Mimete, ovvero software e copyright . . . . . . . . . . . . . . . . . . . . . . . . . .355
373.1 Che cosa è il software? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
373.2 Cenni di storia del software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
325

374 Il copyright/diritto d’autore del software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
374.1 Una breve storia del diritto d’autore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
374.2 I sei punti della rivoluzione digitale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
374.3 I vantaggi del «free software» . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
Indice analitico del volume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
375 Configurazione di una distribuzione Debian . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
375.1 Procedura di inizializzazione del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
375.2 Configurazione del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13
375.3 Configurazione di shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
375.4 Utenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
375.5 Stampa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15
375.6 Configurazione del nome del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .16
375.7 Configurazione dei permessi degli eseguibili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
375.8 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
376 Accorgimenti per una distribuzione Debian . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
376.1 Raccogliere gli aggiornamenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
376.2 Realizzazione di una copia personale della distribuzione . . . . . . . . . . . . . . . . . . . . 23
376.3 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
377 nanoRouter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
377.1 Kernel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
377.2 Lo stretto indispensabile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
377.3 Dimensioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
377.4 File system in sola lettura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
378 nanoLinux II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .33
378.1 Lavoro di cesello . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
378.2 Dischi più grandi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37
378.3 Provare nanoLinux II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
378.4 Organizzazione di nanoLinux II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
378.5 Personalizzazione della procedura di inizializzazione del sistema . . . . . . . . . . . . 46
379 Dischetti di emergenza delle distribuzioni GNU/Linux e di altre fonti . . . . . . . . . . . . . . . 48
379.1 SuSE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
380 Accorgimenti per usare GNU/Linux nella didattica di massa . . . . . . . . . . . . . . . . . . . . . . . 52
380.1 Utente speciale per uno scopo speciale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
380.2 Spegnimento da parte di utenti comuni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
380.3 Autorizzare chiunque ad aggiungersi come nuovo utente . . . . . . . . . . . . . . . . . . . . 55
326

380.4 Sincronizzazione di file di configurazione senza NIS . . . . . . . . . . . . . . . . . . . . . . . .56
381 Introduzione a SMB con GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .59
381.1 Nomi NetBIOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
381.2 Trasporto TCP/IP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
381.3 Servente SMB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
381.4 Cliente SMB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
381.5 Connessione con una rete NetBIOS-TCP/IP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
381.6 Stampa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71
381.7 Montare una risorsa di condivisione dei file nel file system GNU/Linux . . . . . . .72
381.8 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
382 DOSEMU: l’emulatore di hardware DOS compatibile . . . . . . . . . . . . . . . . . . . . . . . . . . . . .75
382.1 Predisporre un ambiente adatto al Dos all’interno di DOSEMU . . . . . . . . . . . . . . 75
382.2 La configurazione di DOSEMU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
382.3 Installare e utilizzare il Dos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
383 LeeOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Indice analitico del volume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
384 Amministrazione del sistema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26
384.1 Installazione di GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
384.2 Avvio e arresto del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
384.3 Tipi di file system e partizioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
384.4 Swap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
384.5 Montare i dischi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
384.6 LILO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
384.7 Kernel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
384.8 Moduli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .64
384.9 Configurazione del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65
384.10 Utenti e password . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
384.11 Permessi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
384.12 File, collegamenti (link) e directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
384.13 Configurazione della console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
384.14 File di log . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
384.15 Cron e At . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
384.16 Processi ed utilizzo delle risorse del sistema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .104
384.17 Risoluzione di problemi di una certa entità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
384.18 Caratteri speciali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
384.19 Documentazione di aiuto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
385 Reti e rete Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
327

385.1 Generalità e configurazione di una rete locale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
385.2 FTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
385.3 Telnet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .118
385.4 SSH. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .122
385.5 La condivisione delle risorse in rete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
385.6 Terminali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
385.7 Server web (Apache, ecc.) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
385.8 Samba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
385.9 Plip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
385.10 Connessione al provider - ppp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
385.11 Connessione remota tra macchine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
385.12 Posta elettronica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
385.13 Navigatori (browser) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
385.14 Gruppi di discussione (newsgroup) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
385.15 IRC - chat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .157
385.16 Scaricamento file - riproduzione (mirror) di siti . . . . . . . . . . . . . . . . . . . . . . . . . . 157
386 Programmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
386.1 Installazione ed esecuzione programmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
386.2 File ‘core’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
386.3 I pacchetti - generalità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
386.4 I pacchetti - ‘tar.gz’, ‘tgz’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
386.5 I pacchetti - ‘deb’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
386.6 I pacchetti - RPM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
386.7 La compressione - ‘.gz’ ‘.bz2’ ‘.zip’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
387 X . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
387.1 Avvio, conclusione, configurazione e risoluzione . . . . . . . . . . . . . . . . . . . . . . . . . . 174
387.2 Gnome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .181
387.3 X - Gestori delle finestre (window manager) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
387.4 Terminale grafico (‘xterm’) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .184
388 Applicazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
388.1 Editor di testi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
388.2 Applicazioni per comunicazioni telefoniche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
388.3 Applicazioni fax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .188
388.4 Applicazioni grafica bidimensionale non vettoriale . . . . . . . . . . . . . . . . . . . . . . . . . 188
388.5 Applicazioni matematiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
388.6 Applicazioni base di dati (database) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .189
389 Stampa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
328

389.1 Impostazioni generali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
389.2 Stampa da riga di comando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
390 Editoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
390.1 Conversione tra formati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
390.2 I file PostScript (‘.ps’) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
390.3 I file ‘.pdf’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
390.4 I File ‘.sgml’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
390.5 I file ‘.doc’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
390.6 Compatibilità formati GNU/Linux-Dos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
391 I Caratteri (font) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
391.1 Impostazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
392 Immagini . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
392.1 Generalità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
393 Masterizzazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
393.1 Masterizzare da riga di comando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
394 Audio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
394.1 Impostazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
394.2 CD audio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
394.3 mp3, wav, ecc. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
395 Programmazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
395.1 Script per la shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
395.2 Linguaggio C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
395.3 Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
395.4 Cobol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
395.5 Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .228
396 Computer portatili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
396.1 Problematiche di installazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
397 Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
397.1 Processori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
397.2 Monitor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
397.3 Dispositivi video (scheda, telecamera, ecc.) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
397.4 Tastiera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
397.5 Mouse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .237
397.6 Disco fisso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
397.7 CD-ROM e masterizzatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
329

397.8 Schede di rete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
397.9 Scheda audio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .244
397.10 Lettori ZIP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
397.11 Nastri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
397.12 RAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
397.13 Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
397.14 Modem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .254
397.15 Stampante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
397.16 Periferiche SCSI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
397.17 Unità disco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
397.18 Periferiche Plug & Play . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
397.19 Porte (seriale, parallela, PS/2, USB, ecc.) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .261
Indice analitico del volume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
398 Licenza GNU GPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
399 Traduzione della licenza GNU GPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
400 Licenza GNU LGPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .18
401 Licenza GNU FDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
402 Licenza Artistic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
403 Licenza UCB BSD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
404 Licenza MIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35
405 Licenza LPPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
406 Licenza QPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
407 Licenza SSLeay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
408 Licenza DSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
409 Licenza Open publication license . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
410 Licenze e altri dettagli sul software citato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
330

Manifesto GNU
Testo originale:
Traduzione originale:
Copyright (C) 1985, 1993 Free Software Foundation, Inc.
Capitolo 371
non modificabile
Chiunque è autorizzato a fare o distribuire copie letterali di questo documento, con qualsiasi
mezzo, a condizione che siano riprodotte la nota sul copyright e la nota di autorizzazione, e che
il distributore conceda al destinatario l’autorizzazione di ridistribuirlo a sua volta alle condizioni
permesse da questa nota.
Non sono consentite versioni modificate.
Il Manifesto GNU
Il Manifesto GNU (che appare sotto) venne scritto da Richard Stallman all’inizio
del progetto GNU, per sollecitare sostegno e partecipazione. Durante i primi anni il
manifesto venne lievemente aggiornato per tener conto degli sviluppi, ma adesso la
scelta migliore sembra essere quella di lasciarlo immutato nella forma in cui molti lo
hanno visto.
Da allora abbiamo preso atto di alcuni fraintendimenti che si potrebbero evitare con
una diversa scelta di termini. Le note in calce aggiunte nel 1993 aiutano a chiarire
questi punti.
Per informazioni aggiornate sulla disponibilità del software GNU, consultate quelle
disponibili sul nostro server web, in particolare il nostro elenco del software.
Cos’è GNU? Gnu Non è Unix!
GNU, che sta per "Gnu’s Not Unix" (Gnu Non è Unix), è il nome del sistema software completo
e Unix-compatibile che sto scrivendo per distribuirlo liberamente a chiunque lo possa utilizzare. 1
Molti altri volontari mi stanno aiutando. Abbiamo gran necessità di contributi in tempo, denaro,
programmi e macchine.
Fino ad ora abbiamo un editor Emacs fornito di Lisp per espanderne i comandi, un debugger simbolico,
un generatore di parser compatibile con yacc, un linker e circa 35 utility. È quasi pronta
una shell (interprete di comandi). Un nuovo compilatore C portabile e ottimizzante ha compilato
se stesso e potrebbe essere pubblicato quest’anno. Esiste un inizio di kernel, ma mancano molte
delle caratteristiche necessarie per emulare Unix. Una volta terminati il kernel e il compilatore
sarà possibile distribuire un sistema GNU utilizzabile per lo sviluppo di programmi. Useremo
1 La scelta delle parole è stata poco accurata. L’intenzione era che nessuno dovesse pagare per il *permesso* di usare
il sistema GNU. Ma le parole non lo esprimono chiaramente, e la gente le interpreta spesso come asserzione che GNU
debba sempre essere distribuito in forma gratuita o a basso prezzo. Non è mai stato questo l’intento; più oltre il manifesto
parla della possibile esistenza di aziende che forniscano il servizio di distribuzione a scopo di lucro. Di conseguenza ho
imparato a distinguere tra "free" nel senso di libero e "free" nel senso di gratuito. Il software libero è il software che gli
utenti sono liberi di distribuire e modificare. Alcuni lo avranno gratuitamente, altri dovranno pagare per ottenere le loro
copie, e se dei finanziamenti aiutano a migliorare il software tanto meglio. La cosa importante è che chiunque ne abbia
una copia sia libero di cooperare con altri nell’usarlo.
331

332 volume VIII Argomenti avanzati e accessori
TeX come formattatore di testi, ma lavoriamo anche su un nroff. Useremo inoltre il sistema a
finestre portabile libero X. Dopo di che aggiungeremo un Common Lisp portabile, il gioco Empire,
un foglio elettronico e centinaia di altre cose, oltre alla documentazione in linea. Speriamo
di fornire, col tempo, tutte le cose utili che normalmente si trovano in un sistema Unix, ed anche
di più.
GNU sarà in grado di far girare programmi Unix, ma non sarà identico a Unix. Apporteremo tutti
i miglioramenti che sarà ragionevole fare basandoci sull’esperienza maturata con altri sistemi
operativi. In particolare abbiamo in programma nomi più lunghi per i file, numeri di versione per
i file, un filesystem a prova di crash, forse completamento automatico dei nomi dei file, supporto
indipendente dal terminale per la visualizzazione e forse col tempo un sistema a finestre basato
sul Lisp, attraverso il quale più programmi Lisp e normali programmi Unix siano in grado di
condividere lo schermo. Sia C che Lisp saranno linguaggi per la programmazione di sistema. Per
le comunicazioni vedremo di supportare UUCP, Chaosnet del MIT ed i protocolli di Internet.
GNU è inizialmente orientato alle macchine della classe 68000/16000 con memoria virtuale,
perché sono quelle su cui è più facile farlo girare. Lasceremo agli interessati il lavoro necessario
a farlo girare su macchine più piccole.
Vi preghiamo, per evitare confusioni, di pronunciare la ’G’ nella parola ’GNU’ quando indica il
nome di questo progetto. [N.d.T.: questa avvertenza serve ad evitare che in inglese "GNU" sia
pronunciato come la parola "new"].
Perché devo scrivere GNU
Io credo che il punto fondamentale sia che, se a me piace un programma, io debba condividerlo
con altre persone a cui piace. I venditori di software usano il criterio "divide et impera" con
gli utenti, facendo sì che non condividano il software con altri. Io mi rifiuto di spezzare così
la solidarietà con gli altri utenti. La mia coscienza non mi consente di firmare un accordo per
non rivelare informazioni o per una licenza d’uso del software. Ho lavorato per anni presso
il laboratorio di intelligenza artificiale per resistere a queste tendenze e ad altri atteggiamenti
sgradevoli, ma col tempo queste sono andate troppo oltre: non potevo rimanere in una istituzione
dove ciò viene fatto a mio nome contro la mia volontà.
Per poter continuare ad usare i computer senza disonore, ho deciso di raccogliere un corpus di
software libero in modo da andare avanti senza l’uso di alcun software che non sia libero. Mi
sono dimesso dal laboratorio di Intelligenza Artificiale per togliere al MIT ogni scusa legale che
mi impedisca di distribuire GNU.
Perché GNU sarà compatibile con Unix
Unix non è il mio sistema ideale, ma non è poi così male. Le caratteristiche essenziali di Unix
paiono essere buone e penso di poter colmare le lacune di Unix senza rovinarne le caratteristiche.
E adottare un sistema compatibile con Unix può risultare pratico anche per molti altri.
Come sarà reso disponibile GNU
GNU non è di pubblico dominio. A tutti sarà permesso di modificare e ridistribuire GNU, ma a
nessun distributore sarà concesso di porre restrizioni sulla sua ridistribuzione. Questo vuol dire
che non saranno permesse modifiche proprietarie. Voglio essere sicuro che tutte le versioni di
GNU rimangano libere.
Perché molti altri programmatori desiderano essere d’aiuto
Ho trovato molti altri programmatori molto interessati a GNU che vogliono dare una mano.
Molti programmatori sono scontenti della commercializzazione del software di sistema. Li può
aiutare a far soldi, ma li costringe in generale a sentirsi in conflitto con gli altri programmatori,

Manifesto GNU 333
invece che solidali. L’atto di amicizia fondamentale tra programmatori è condividere programmi;
le politiche di commercializzazione attualmente in uso essenzialmente proibiscono ai programmatori
di trattare gli altri come amici. Gli acquirenti del software devono decidere tra l’amicizia
e l’obbedienza alle leggi. Naturalmente molti decidono che l’amicizia è più importante. Ma quelli
che credono nella legge non si sentono a proprio agio con queste scelte. Diventano cinici e
pensano che programmare sia solo un modo per fare soldi.
Lavorando e utilizzando GNU invece che programmi proprietari, possiamo comportarci amichevolmente
con tutti e insieme rispettare la legge. Inoltre GNU è un esempio che ispira gli altri e
una bandiera che li chiama a raccolta perché si uniscano a noi nel condividere il software. Questo
ci può dare una sensazione di armonia che sarebbe irraggiungibile se usassimo software che non
sia libero. Per circa la metà dei programmatori che conosco è una soddisfazione importante, che
il denaro non può sostituire.
Come si può contribuire
Chiedo ai produttori di computer donazioni in denaro e macchine, ed ai privati donazioni in
programmi e lavoro.
Donare delle macchine può far sì che su di esse giri ben presto GNU. Le macchine devono
essere sistemi completi e pronti all’uso approvati per l’utilizzo in aree residenziali e non devono
richiedere raffreddamento o alimentazione di tipo sofisticato.
Ho conosciuto moltissimi programmatori desiderosi di contribuire a GNU part-time. Per la gran
parte dei progetti, un lavoro part-time distribuito risulterebbe troppo difficile da coordinare, perché
le varie parti scritte indipendentemente non funzionerebbero insieme. Ma per scrivere un
sostituto di Unix questo problema non si pone, perché un sistema Unix completo contiene centinaia
di programmi di servizio, ognuno con la propria documentazione separata, e con gran parte
delle specifiche di interfaccia date dalla compatibilità con Unix. Se ogni partecipante scrive un
solo programma da usare al posto di una utility di Unix, il quale funzioni correttamente al posto
dell’originale su un sistema Unix, allora questi programmi funzioneranno bene una volta messi
assieme. Anche considerando qualche imprevisto dovuto a Murphy, assemblare tali componenti
è un lavoro fattibile. Il kernel invece richiederà una più stretta cooperazione, e verrà sviluppato
da un gruppo piccolo e affiatato.
Donazioni in denaro possono mettermi in grado di assumere alcune persone a tempo pieno o parttime.
Lo stipendio non sarà alto rispetto agli standard dei programmatori, ma io cerco persone
per le quali lo spirito della comunità GNU sia importante quanto il denaro. Io lo vedo come un
modo di permettere a degli appassionati di dedicare tutte le loro energie al lavoro su GNU senza
essere costretti a guadagnarsi da vivere in un altro modo.
Perché tutti gli utenti dei computer ne trarranno beneficio
Una volta scritto GNU, ognuno potrà avere liberamente del buon software di sistema, così come
può avere l’aria. 2
Questo significa molto di più che far risparmiare a ciascuno il costo di una licenza Unix: vuol dire
evitare l’inutile spreco di ripetere ogni volta lo sforzo della programmazione di sistema. Queste
energie possono essere invece impiegate ad avanzare lo stato dell’arte.
I sorgenti completi del sistema saranno a disposizione di tutti. Di conseguenza, un utente che
abbia necessità di apportare dei cambiamenti al sistema sarà sempre in grado di farlo da solo o
di commissionare i cambiamenti ad un programmatore o ad un’impresa. Gli utenti non saranno
2 Questo è un altro punto dove non sono riuscito a distinguere chiaramente tra i due significati di "free". La frase, così
com’è, non è falsa, si possono ottenere gratuitamente copie del software GNU, o dagli amici o attraverso la rete. Ma in
effetti suggerisce un’idea sbagliata.

334 volume VIII Argomenti avanzati e accessori
più in balia di un solo programmatore o di una impresa che, avendo la proprietà esclusiva dei
sorgenti, sia la sola a poter fare le modifiche.
Le scuole avranno la possibilità di fornire un ambiente molto più educativo, incoraggiando gli
studenti a studiare e migliorare il software di sistema. I laboratori di informatica di Harvard avevano
una politica per cui nessun programma poteva essere installato nel sistema senza che i sorgenti
fossero pubblicamente consultabili, e la praticarono rifiutandosi effettivamente di installare
alcuni programmi. Questo comportamento mi è stato di grande ispirazione.
Infine, scompariranno le necessità burocratiche di tener conto di chi sia il proprietario del
software di sistema e di chi abbia il diritto di farci cosa.
Ogni sistema per imporre tariffe d’uso di un programma, comprese le licenze d’uso per le copie,
è sempre estremamente costoso in termini sociali a causa del complesso meccanismo necessario
per decidere quanto (cioè per quali programmi) ognuno debba pagare, e solo uno stato di polizia
può costringere tutti all’obbedienza. Immaginate una stazione spaziale dove l’aria deve essere
prodotta artificialmente ad un costo elevato: far pagare ogni litro d’aria consumato può essere
giusto, ma indossare la maschera col contatore tutto il giorno e tutta la notte è intollerabile,
anche se tutti possono permettersi di pagare la bolletta. E le videocamere poste in ogni dove per
controllare che nessuno si tolga mai la maschera sono offensive. Meglio finanziare l’impianto di
ossigenazione con una tassa pro capite e buttar via le maschere.
Copiare un programma in tutto o in parte è tanto naturale per un programmatore quanto respirare
ed è altrettanto produttivo. Dovrebbe essere altrettanto libero.
Alcune obiezioni facilmente confutabili agli obiettivi GNU
«La gente non lo userà se è gratuito, perché non potrà avere l’assistenza.»
«Un programma deve essere a pagamento, per poter fornire supporto adeguato.»
Se la gente preferisse pagare per GNU più l’assistenza piuttosto che avere GNU gratis senza
assistenza, allora un’impresa che fornisse assistenza a chi si è procurato GNU gratis potrebbe
operare con profitto. 3
Si deve distinguere tra il supporto sotto forma di lavoro di programmazione e la semplice gestione.
Il primo non è ottenibile da un venditore di software. Se il problema non è sentito da un
numero sufficiente di clienti allora il venditore dirà al cliente di arrangiarsi.
Per chi deve poter contare su questo tipo di supporto l’unica soluzione è di disporre dei sorgenti
e degli strumenti necessari, in modo da poter commissionare il lavoro a chi sia disposto a farlo,
invece che rimanere in balia di qualcuno. Con Unix il prezzo dei sorgenti rende ciò improponibile
per la maggior parte delle imprese. Con GNU questo sarà invece facile. Si darà sempre il caso
che non siano disponibili persone competenti, ma questo non potrà essere imputato al sistema di
distribuzione. GNU non elimina tutti i problemi del mondo, solo alcuni.
Allo stesso tempo, gli utenti che non sanno nulla di computer hanno bisogno di manutenzione,
cioè di cose che potrebbero fare facilmente da soli ma che non sono in grado di fare.
Servizi di questo genere potrebbero essere forniti da aziende che vendono solo gestione e manutenzione.
Se è vero che gli utenti sono disposti a pagare per un prodotto con servizio, allora
saranno anche disposti a pagare per il servizio avendo avuto il prodotto gratuitamente. Le aziende
di servizi si faranno concorrenza sul prezzo e sulla qualità; gli utenti d’altra parte non saranno
legati a nessuna di esse in particolare. Nel frattempo, coloro che non avranno bisogno del servizio
saranno sempre in grado di usare il programma senza pagare il servizio.
3 Adesso esistono effettivamente molte ditte di questo tipo.

Manifesto GNU 335
«Non si può raggiungere molta gente senza pubblicità, e per finanziarla si deve far pagare il
programma.»
«È inutile reclamizzare un programma gratuito.»
Ci sono molte forme di pubblicità gratuita o a basso costo che possono essere usate per informare
un gran numero di utenti di computer riguardo a cose come GNU. Ma può essere vero che la
pubblicità può raggiungere molti più utenti di microcomputer. Se fosse veramente così, una ditta
che reclamizzasse il servizio di copia e spedizione per posta di GNU a pagamento dovrebbe
aver abbastanza successo commerciale da rientrare dai costi della pubblicità e da guadagnarci. In
questo modo, pagano la pubblicità solo gli utenti che ne beneficiano.
D’altro canto, se molta gente ottiene GNU da amici e queste aziende non hanno successo, vorrà
dire che la pubblicità non era necessaria per diffondere GNU. Perché tutti questi difensori del
libero mercato non vogliono lasciare che sia il libero mercato a decidere? 4
«La mia azienda ha bisogno di un sistema operativo proprietario per essere più avanti della
concorrenza.»
Con GNU, i sistemi operativi non rientreranno più fra gli elementi di concorrenza. La vostra
azienda non potrà essere concorrenziale in quest’area, ma egualmente non potranno esserlo i
concorrenti. Vi farete concorrenza in altre aree, mentre in questa godrete di mutui benefici. Se
vendete sistemi operativi non apprezzerete GNU, ma è un problema vostro. Se avete un’attività
di altro tipo, GNU vi può evitare di essere spinti nel costoso campo della vendita di sistemi
operativi.
Mi piacerebbe che lo sviluppo di GNU fosse sostenuto da donazioni da parte di numerosi
produttori ed utenti, riducendo così la spesa per tutti. 5
«Ma i programmatori non meritano una ricompensa per la loro creatività?»
Se qualcosa merita una ricompensa questo è il contribuire al bene sociale. La creatività può essere
un contributo al bene sociale, ma solo nella misura in cui la società è libera di usarne i risultati.
Se i programmatori meritano una ricompensa per la creazione di programmi innovativi, allora
con la stessa logica meritano una punizione se pongono restrizioni all’uso di questi programmi.
«Un programmatore non dovrebbe poter chiedere una ricompensa per la sua creatività?»
Non c’è niente di male nel chiedere di esser pagati per il proprio lavoro, o mirare ad incrementare
le proprie entrate, fintanto che non si utilizzino metodi che siano distruttivi. Ma i metodi comuni
nel campo del software, al giorno d’oggi, sono distruttivi.
Spremere denaro dagli utenti di un programma imponendo restrizioni sull’uso è distruttivo perché
riduce i modi in cui il programma può essere usato. Questo diminuisce la quantità di ricchezza
che l’umanità ricava dal programma. Quando c’è una scelta deliberata di porre restrizioni, le
conseguenze dannose sono distruzione deliberata.
La ragione per cui un buon cittadino non usa questi metodi distruttivi per diventare più ricco è che,
se lo facessero tutti, diventeremmo tutti più poveri a causa delle distruzioni reciproche. Questa
è etica kantiana, la Regola Aurea: poiché non mi piacciono le conseguenze che risulterebbero
se tutti impedissero l’accesso alle informazioni, devo considerare sbagliato che uno lo faccia.
4 La Free Software Foundation raccoglie la maggior parte dei suoi fondi da un servizio di distribuzione, anche se
è più un ente senza fini di lucro che un’azienda. Se *nessuno* sceglie di ottenere copie del software ordinandole alla
FSF, questa sarà impossibilitata a proseguire la propria opera. Ma questo non vuole dire che siano giustificate restrizioni
proprietarie per costringere gli utenti a pagare. Se una piccola frazione degli utenti ordina le sue copie dalla FSF, questo
sarà sufficiente per tenerla a galla. Quindi chiediamo agli utenti di aiutarci in questo modo. Hai fatto la tua parte?
5 Un gruppo di imprese di software ha recentemente costituito dei finanziamenti per sostenere la manutenzione del
nostro compilatore C.

336 volume VIII Argomenti avanzati e accessori
In particolare, il desiderio di una ricompensa per la propria creatività non giustifica il privare il
mondo nel suo insieme di tutta o parte di questa creatività.
«Ma i programmatori non moriranno di fame?»
Potrei rispondere che nessuno è obbligato a fare il programmatore. La maggior parte di noi non è
in grado di andare per strada a fare il mimo, ma ciò non vuol dire che siamo condannati a passare
la vita per strada a fare i mimi, e morire di fame. Facciamo un altro lavoro.
Ma è la risposta sbagliata, perché accetta l’assunzione implicita di chi pone la domanda, e cioè
che senza proprietà del software non è possibile pagare ai programmatori il becco di un quattrino.
Un’assunzione del tipo tutto o niente.
La vera ragione per cui i programmatori non moriranno di fame è che sarà per loro egualmente
possibile essere pagati per programmare, solo non pagati così tanto come ora.
Porre restrizioni sulle copie non è l’unico modello di affari nel campo del software. È il modello
più comune perché è il più redditizio. Se fosse vietato, o rifiutato dagli utenti, l’industria del
software si sposterebbe su altri modelli organizzativi, adottandone altri ora meno comuni. Ci
sono sempre numerosi modi per organizzare un qualunque tipo di affari.
Probabilmente programmare nel nuovo modello organizzativo non sarà più così redditizio come
lo è ora. Ma questo non è un argomento contro il cambiamento. Che gli addetti alle vendite
ricevano i salari che ora ricevono non è considerata un’ingiustizia. Se i programmatori avessero
gli stessi stipendi (in pratica guadagnerebbero molto di più), non sarebbe nemmeno quella
un’ingiustizia.
«Ma le persone non hanno diritto di controllare come la loro creatività viene usata?»
Il "controllo sull’uso delle proprie idee" in realtà costituisce un controllo sulle vite degli altri; e
di solito viene usato per rendere più difficili le loro vite.
Le persone che hanno studiato con cura i vari aspetti del diritto alla proprietà intellettuale (come
gli avvocati) dicono che non c’è alcun diritto intrinseco alla proprietà intellettuale. I tipi dei
supposti diritti alla proprietà intellettuale riconosciuti dal governo furono creati da specifici atti
legislativi per scopi specifici.
Per esempio la legislazione sui brevetti fu introdotta per incoraggiare gli inventori a rivelare i
dettagli delle loro invenzioni. Lo scopo era avvantaggiare la società più che avvantaggiare gli
inventori. A quel tempo la validità di 17 anni per un brevetto era breve se confrontata con la
velocità di avanzamento dello stato dell’arte. Poiché i brevetti riguardano solo i produttori, per
i quali il costo e lo sforzo degli accordi di licenza sono piccoli in confronto all’organizzazione
della produzione, spesso i brevetti non costituiscono un gran danno. E non ostacolano la gran
parte degli individui che usano prodotti coperti da brevetto.
L’idea del copyright non esisteva in tempi antichi, quando gli autori copiavano estesamente altri
autori in opere non narrative. Questa pratica era utile, ed è il solo modo attraverso cui almeno
parte del lavoro di alcuni autori è sopravvissuto. La legislazione sul copyright fu creata espressamente
per incoraggiare l’originalità. Nel campo per cui fu inventata, cioè i libri, che potevano
essere copiati a basso costo solo con apparecchiature tipografiche, non fece molto danno e non
pose ostacoli alla maggior parte dei lettori.
Tutti i diritti di proprietà intellettuale sono solo licenze concesse dalla società perché si riteneva,
correttamente o meno, che concederle avrebbe giovato alla società nel suo complesso. Ma data
una situazione particolare dobbiamo chiederci: facciamo realmente bene a concedere queste
licenze? Che atti permettiamo di compiere con esse?

Manifesto GNU 337
Il caso dei programmi ai giorni nostri differisce enormemente da quello dei libri un secolo fa. Il
fatto che la via più facile per passare una copia di un programma sia da persona a persona, che il
programma abbia un codice sorgente ed un codice oggetto che sono cose distinte, ed infine il fatto
che un programma venga usato più che letto e gustato, combinandosi creano una situazione in
cui qualcuno che impone un copyright minaccia la società nel suo insieme, sia materialmente che
spiritualmente, una situazione in cui quel qualcuno non dovrebbe farlo, che la legge lo permetta
o no.
«La competizione fa sì che le cose siano fatte meglio.»
Il paradigma della competizione è la gara: premiando il vincitore incoraggia ognuno a correre più
veloce. Quando veramente il capitalismo funziona in questo modo, fa un buon lavoro; ma chi lo
difende ha torto nell’asserire che agisce sempre così. Se i corridori dimenticano il motivo per cui
è offerto il premio e si concentrano solo sul vincere non curandosi di come, possono trovare altre
strategie, come ad esempio attaccare gli altri concorrenti. Se i corridori si azzuffano, arrivano
tutti in ritardo al traguardo.
Il software proprietario e segreto è l’equivalente morale dei corridori che si azzuffano. Triste a
dirsi, l’unico arbitro che abbiamo pare non muovere alcuna obiezione alle zuffe, al più le regolamenta
("ogni dieci metri puoi tirare un pugno"). Dovrebbe invece dividerli e penalizzarli anche
se solo provassero a combattere.
«Ma senza un incentivo economico non smetterebbero tutti di programmare?»
In realtà molta gente programmerebbe senza alcun incentivo economico. Programmare ha un
fascino irresistibile per alcune persone, solitamente per quelli che ci riescono meglio. Non mancano
certo i musicisti professionisti che insistono pur non avendo speranza di guadagnarsi da
vivere suonando.
Ma in realtà questa domanda, benché posta spesso, non è appropriata. La paga per i programmatori
non sparirà, semplicemente diminuirà. Quindi la domanda corretta è: «qualcuno si metterà
mai a programmare per un minore incentivo economico?». La mia esperienza dice che sì, ci si
metterà.
Per più di dieci anni molti tra i migliori programmatori del mondo hanno lavorato nel laboratorio
di Intelligenza Artificiale per molti meno soldi di quanti ne avrebbero potuti ricevere in ogni
altro posto. Hanno avuto soddisfazioni non economiche di moltissimi tipi, ad esempio fama e
riconoscenza. E la creatività è anche divertente, un premio di per sé.
Poi molti se ne sono andati quando hanno avuto la possibilità di fare lo stesso interessante lavoro
per un mucchio di soldi.
Ciò che i fatti mostrano è che la gente programma per altre ragioni che non siano il denaro; ma
se viene data la possibilità di fare la stessa cosa per un mucchio di soldi, allora cominceranno ad
aspettarseli e a richiederli. Le organizzazioni che pagano poco sono svantaggiate in confronto a
quelle che pagano molto, ma non sarebbero necessariamente in questa posizione se quelle che
pagano molto fossero bandite.
«Abbiamo un disperato bisogno dei programmatori. Se ci chiedono di smettere di aiutare i nostri
vicini dobbiamo obbedire.»
Non si è mai così disperati da dover obbedire a questo genere di pretese. Ricorda: milioni in
difesa, ma non un centesimo in tributi [N.d.T.: è una famosa frase di George Washington].
«I programmatori devono guadagnarsi da vivere in qualche modo.»
A breve termine è vero. Ma ci sono un’infinità di modi in cui i programmatori possono guadagnarsi
da vivere senza vendere i diritti d’uso dei programmi. Questo metodo è comune ai giorni

338 volume VIII Argomenti avanzati e accessori
nostri perché porta la maggior quantità di denaro a programmatori e aziende, non perché sia l’unica
strada per guadagnarsi da vivere. È facile trovarne altre se se ne vogliono trovare. Ecco una
serie di esempi.
Un produttore che immette sul mercato un nuovo computer pagherà per il porting dei sistemi
operativi sul nuovo hardware.
I servizi a pagamento di insegnamento, gestione e manutenzione possono impiegare dei
programmatori.
Persone con idee nuove possono distribuire i programmi gratuitamente, chiedendo donazioni
agli utenti soddisfatti, o vendendo servizi di gestione. Ho incontrato persone che già lavorano
con successo in questo modo.
Utenti con necessità simili possono formare gruppi e pagare. Un gruppo potrebbe stipulare un
contratto con un’impresa di programmazione per scrivere i programmi che i membri del gruppo
vorrebbero usare.
Tutti i tipi di sviluppo possono essere finanziati da una Tassa per il Software:
Supponiamo che chiunque compri un computer debba pagare un x per cento del costo del computer
come tassa per il software. Il governo girerebbe questi fondi ad un’agenzia come la NSF
[N.d.T.: più o meno l’equivalente del nostro CNR] per impiegarli nello sviluppo del software.
Ma se l’acquirente fa lui stesso una donazione per lo sviluppo del software, potrebbe ottenere
un credito nei confronti di queste tasse. Potrebbe fare una donazione ad un progetto di sua scelta
-- tipicamente scelto perché spera di usarne i risultati quando questo verrà completato. Potrebbe
ottenere un credito per ogni donazione fatta, fino al valore totale della tassa che dovrebbe pagare.
Il gettito complessivo di questa tassa potrebbe essere deciso dal voto di chi la paga, pesato
secondo l’ammontare pagato.
Le conseguenze:
• La comunità degli utenti di computer sosterrebbe lo sviluppo del software.
• La comunità sceglierebbe il livello di sostegno necessario.
• Gli utenti che fossero interessati a sapere su che progetto vengano spesi i loro soldi
avrebbero la possibilità di gestire personalmente la cosa.
Nel lungo periodo, rendere liberi i programmi è un passo verso l’epoca della fine del bisogno,
quando nessuno sarà obbligato a lavorare molto duramente solo per guadagnarsi di che vivere.
La gente sarà libera di dedicarsi ad attività divertenti, come programmare, dopo aver passato le
dieci ore settimanali necessarie in compiti come legiferare, fare consulenza familiare, riparare i
robot e prevedere il moto degli asteroidi. Non ci sarà bisogno di guadagnarsi da vivere con la
programmazione.
Abbiamo già ridotto moltissimo la quantità di lavoro che la società nel suo complesso deve fare
per ottenere la sua produttività attuale, ma poco di questo si è tradotto in benessere per i lavoratori
perché è necessario accompagnare l’attività produttiva con molta attività non produttiva. Le cause
principali sono la burocrazia e gli sforzi a tutto campo contro la concorrenza. Il software libero
ridurrà di molto questo drenaggio di risorse nell’area della produzione del software. Dobbiamo
farlo affinché i guadagni tecnici in produttività si traducano in meno lavoro per noi.

Il progetto GNU
Testo originale:
Traduzione originale:
Copyright © 1998 Richard Stallman
Capitolo 372
non modificabile
La copia letterale e la distribuzione di questo articolo nella sua integrità sono permesse con ogni
mezzo, a patto che questa nota sia riprodotta.
1
372.1 La prima comunità di condivisione del software
Quando cominciai a lavorare nel laboratorio di Intelligenza Artificiale del MIT [N.d.T. Massachusset
Institute of Technology] nel 1971, entrai a far parte di una comunità in cui ci si scambiavano
i programmi, che esisteva già da molti anni. La condivisione del software non si limitava
alla nostra comunità; è un cosa vecchia quanto i computer, proprio come condividere le ricette è
antico come il cucinare. Ma noi lo facevamo più di quasi chiunque altro.
Il laboratorio di Intelligenza Artificiale usava un sistema operativo a partizione di tempo (timesharing)
chiamato ITS (Incompatible Timesharing System) che il gruppo di hacker 2 del laboratorio
aveva progettato e scritto in linguaggio assembler per il Digital PDP-10, uno dei grossi
elaboratori di quel periodo. Come membro di questa comunità, hacker di sistema nel gruppo
laboratorio, il mio compito era migliorare questo sistema.
Non chiamavamo il nostro software "software libero", poiché questa espressione ancora non esisteva,
ma si trattava proprio di questo. Quando persone di altre università o di qualche società volevano
convertire il nostro programma per il proprio sistema ed utilizzarlo, erano le benvenute. Se
si vedeva qualcuno usare un programma sconosciuto ed interessante, si poteva sempre chiedere di
vederne il codice sorgente, in modo da poterlo leggere, modificare, o prenderne (cannibalizzarne)
alcune parti per creare un nuovo programma.
372.2 La comunità si dissolve
La situazione cambiò drasticamente all’inizio degli anni ’80 quando la Digital smise di produrre
la serie PDP-10. La sua architettura, elegante e potente negli anni ’60, non poteva essere estesa in
modo naturale ai più grandi spazi di indirizzamento che si stavano rendendo possibili negli anni
’80. Questo significò che quasi tutti i programmi che formavano ITS divennero obsoleti.
La comunità di hacker del laboratorio di Intelligenza Artificiale si era già dissolta non molto
tempo prima. Nel 1981 la Symbolics, nata da una costola del laboratorio stesso, gli aveva sottratto
quasi tutti gli hacker; l’ormai esiguo gruppo rimasto fu dunque incapace di sostenersi (il libro
1 [NdR: il testo che appare qui è stato ritoccato leggermente per correggere alcuni errori evidenti.]
2 L’uso del termine "hacker" nel senso di "pirata" è una confusione di termini creata dai mezzi di informazione. Noi
hacker ci rifiutiamo di riconoscere questo significato, e continuiamo ad utilizzare la parola nel senso di "uno che ami
programmare, e a cui piaccia essere bravo a farlo".
339

340 volume VIII Argomenti avanzati e accessori
"Hackers" di Steve Levy narra questi eventi, oltre a fornire una fedele ricostruzione di questa
comunità ai suoi inizi). Quando il laboratorio di Intelligenza Artificiale nel 1982 acquistò un
nuovo PDP-10, i sistemisti decisero di utilizzare il sistema timesharing non libero della Digital
piuttosto che ITS.
I moderni elaboratori di quell’epoca, come il VAX o il 68020, avevano il proprio sistema operativo,
ma nessuno di questi era libero: si doveva firmare un accordo di non-diffusione persino per
ottenerne una copia eseguibile.
Questo significava che il primo passo per usare un computer era promettere di negare aiuto al
proprio vicino. Una comunità cooperante era vietata. La regola creata dai proprietari di software
proprietario era: «se condividi il software col tuo vicino sei un pirata. Se vuoi modifiche, pregaci
di farle».
L’idea che la concezione sociale di software proprietario -- cioè il sistema che impone che il
software non possa essere condiviso o modificato -- sia antisociale, contraria all’etica, semplicemente
sbagliata, può apparire sorprendente a qualche lettore. Ma che altro possiamo dire di un
sistema che si basa sul dividere utenti e lasciarli senza aiuto? Quei lettori che trovano sorprendente
l’idea possono aver data per scontata la concezione sociale di software proprietario, o averla
giudicata utilizzando lo stesso metro suggerito dal mercato del software proprietario. I produttori
di software hanno lavorato a lungo e attivamente per diffondere la convinzione che c’è un solo
modo di vedere la cosa.
Quando i produttori di software parlano di "difendere" i propri "diritti" o di "fermare la pirateria",
quello che dicono è in realtà secondario. Il vero messaggio in quelle affermazioni sta nelle
assunzioni inespresse, che essi danno per scontate; vogliono che siano accettate acriticamente.
Esaminiamole, dunque.
Una prima assunzione è che le aziende produttrici di software abbiano il diritto naturale indiscutibile
di proprietà sul software, e di conseguenza, abbiano controllo su tutti i suoi utenti. Se
questo fosse un diritto naturale, non potremmo sollevare obiezioni, indipendentemente dal danno
che possa recare ad altri. È interessante notare che, negli Stati Uniti, sia la costituzione che
la giurisprudenza rifiutano questa posizione: il diritto d’autore non è un diritto naturale, ma un
monopolio imposto dal governo che limita il diritto naturale degli utenti ad effettuare delle copie.
Un’altra assunzione inespressa è che la sola cosa importante del software sia il lavoro che consente
di fare -- vale a dire che noi utenti non dobbiamo preoccuparci del tipo di società in cui ci
è permesso vivere.
Una terza assunzione è che non avremmo software utilizzabile (o meglio, che non potremmo mai
avere un programma per fare questo o quell’altro particolare lavoro) se non riconoscessimo ai
produttori il controllo sugli utenti di quei programmi. Questa assunzione avrebbe potuto sembrare
plausibile, prima che il movimento del software libero dimostrasse che possiamo scrivere quantità
di programmi utili senza bisogno di metterci dei catenacci.
Se rifiutiamo di accettare queste assunzioni, giudicando queste questioni con comuni criteri di
moralità e di buon senso dopo aver messo al primo posto gli interessi degli utenti, tenendo conto
che gli utenti vengono prima di tutto, arriviamo a conclusioni del tutto differenti. Chi usa un
calcolatore dovrebbe essere libero di modificare i programmi per adattarli alle proprie necessità,
ed essere libero di condividere il software, poiché aiutare gli altri è alla base della società.
Non c’è modo in questa sede di trattare approfonditamente i ragionamenti che portano a questa
conclusione; il lettore interessato può cercare le informazioni in rete a questo indirizzo: .

Il progetto GNU 341
372.3 Una difficile scelta morale
Una volta che il mio gruppo si fu sciolto, continuare come prima fu impossible. Mi trovai di
fronte ad una difficile scelta morale.
La scelta facile sarebbe stata quella di unirsi al mondo del software proprietario, firmando accordi
di non-diffusione e promettendo di non aiutare i miei compagni hacker. Con ogni probabilità
avrei anche sviluppato software che sarebbe stato distribuito secondo accordi di non-diffusione,
contribuendo così alla pressione su altri perché a loro volta tradissero i propri compagni.
In questo modo avrei potuto guadagnare, e forse mi sarei divertito a programmare. Ma sapevo
che al termine della mia carriera mi sarei voltato a guardare indietro, avrei visto anni spesi a
costruire muri per dividere le persone, e avrei compreso di aver contribuito a rendere il mondo
peggiore.
Avevo già sperimentato cosa significasse un accordo di non diffusione per chi lo firmava, quando
qualcuno rifiutò a me e al laboratorio AI del MIT il codice sorgente del programma di controllo
della nostra stampante; l’assenza di alcune funzionalità nel programma rendeva oltremodo frustrante
l’uso della stampante. Per cui non mi potevo dire che gli accordi di non-diffusione fossero
innocenti. Ero molto arrabbiato quando quella persona si rifiutò di condividere il programma con
noi; non potevo far finta di niente e fare lo stesso con tutti gli altri.
Un’altra possibile scelta, semplice ma spiacevole, sarebbe stata quella di abbandonare l’informatica.
In tal modo le mie capacità non sarebbero state mal utilizzate, tuttavia sarebbero state
sprecate. Non sarei mai stato colpevole di dividere o imporre restrizioni agli utenti di calcolatori,
ma queste cose sarebbero comunque successe.
Allora cercai un modo in cui un programmatore potesse fare qualcosa di buono. Mi chiesi dunque:
c’erano un programma o dei programmi che io potessi scrivere, per rendere nuovamente possibile
l’esistenza di una comunità?
La risposta era semplice: innanzitutto serviva un sistema operativo. Questo è difatti il software
fondamentale per iniziare ad usare un computer. Con un sistema operativo si possono fare molte
cose; senza, non è proprio possibile far funzionare il computer. Con un sistema operativo libero,
avremmo potuto avere nuovamente una comunità in cui hacker possono cooperare, e invitare
chiunque ad unirsi al gruppo. E chiunque sarebbe stato in grado di usare un calcolatore, senza
dover cospirare fin dall’inizio per sottrarre qualcosa ai propri amici.
Essendo un programmatore di sistemi, possedevo le competenze adeguate per questo lavoro.
Così, anche se non davo il successo per scontato, mi resi conto di essere la persona giusta per
farlo. Scelsi di rendere il sistema compatibile con Unix, in modo che fosse portabile, e che gli
utenti Unix potessero passare facilmente ad esso. Il nome GNU fu scelto secondo una tradizione
hacker, come acronimo ricorsivo che significa "GNU’s Not Unix" [N.d.T. GNU non è Unix].
Un sistema operativo non si limita solo al suo nucleo, che è proprio il minimo per eseguire
altri programmi. Negli anni ’70, qualsiasi sistema operativo degno di questo nome includeva
interpreti di comandi, assemblatori, compilatori, interpreti di linguaggi, debugger, editor di testo,
programmi per la posta e molto altro. ITS li aveva, Multics li aveva, VMS li aveva e Unix li
aveva. Anche il sistema operativo GNU li avrebbe avuti.
Tempo dopo venni a conoscenza di questa massima, attribuita a Hillel:
3
detto.
3 Essendo ateo, non seguo alcuna guida religiosa, ma a volte mi trovo ad ammirare qualcosa che qualcuno di loro ha

342 volume VIII Argomenti avanzati e accessori
Se non sono per me stesso, chi sarà per me?
E se sono solo per me stesso, che cosa sono?
E se non ora, quando?
La decisione di iniziare il progetto GNU si basò su uno spirito simile.
372.4 "Free" come libero
Il termine "free software" [N.d.T. il termine free in inglese significa sia gratuito che libero] a volte
è mal interpretato: non ha niente a che vedere col prezzo del software; si tratta di libertà. Ecco,
dunque, la definizione di software libero: un programma è software libero per un dato utente se:
• l’utente ha la libertà di eseguire il programma per qualsiasi scopo;
• l’utente ha la libertà di modificare il programma secondo i propri bisogni (perché questa
libertà abbia qualche effetto in pratica, è necessario avere accesso al codice sorgente
del programma, poiché apportare modifiche ad un programma senza disporre del codice
sorgente è estremamente difficile);
• l’utente ha la libertà di distribuire copie del programma, gratuitamente o dietro compenso;
• l’utente ha la libertà di distribuire versioni modificate del programma, così che la comunità
possa fruire dei miglioramenti apportati.
Poiché "free" si riferisce alla libertà e non al prezzo, vendere copie di un programma non contraddice
il concetto di software libero. In effetti, la libertà di vendere copie di programmi è essenziale:
raccolte di software libero vendute su CD-ROM sono importanti per la comunità, e la loro vendita
è un modo di raccogliere fondi importante per lo sviluppo del software libero. Di conseguenza,
un programma che non può essere liberamente incluso in tali raccolte non è software libero.
A causa dell’ambiguità del termine "free", si è cercata a lungo un’alternativa, ma nessuno ne ha
trovata una valida. La lingua inglese ha più termini e sfumature di ogni altra, ma non ha una
parola semplice e non ambigua che significhi libero; "unfettered" è la parola più vicina come
significato [NdT: unfettered è una parola di tono aulico o arcaico che significa libero da ceppi,
vincoli o inibizioni]. Alternative come "liberated", "freedom" e "open" hanno altri significati o
non sono adatte per altri motivi [NdT: rispettivamente, liberato, libertà, aperto].
372.5 Software GNU e il sistema GNU
Sviluppare un intero sistema è un progetto considerevole. Per raggiungere l’obiettivo decisi di
adattare e usare parti di software libero tutte le volte che fosse possibile. Per esempio, decisi fin
dall’inizio di usare TeX come il principale programma di formattazione di testo; qualche anno
più tardi, decisi di usare l’X Window System piuttosto che scrivere un altro sistema a finestre per
GNU.
A causa di questa decisione, il sistema GNU e la raccolta di tutto il software GNU non sono
la stessa cosa. Il sistema GNU comprende programmi che non sono GNU, sviluppati da altre
persone o gruppi di progetto per i propri scopi, ma che possiamo usare in quanto software libero.

Il progetto GNU 343
372.6 L’inizio del progetto
Nel gennaio 1984 lasciai il mio posto al MIT e cominciai a scrivere software GNU. Dovetti
lasciare il MIT, per evitare che potesse interferire con la distribuzione di GNU come software
libero. Se fossi rimasto, il MIT avrebbe potuto rivendicare la proprietà del lavoro, ed avrebbe
potuto imporre i propri termini di distribuzione, o anche farne un pacchetto proprietario. Non
avevo alcuna intenzione di fare tanto lavoro solo per vederlo reso inutilizzabile per il suo scopo
originario: creare una nuova comunità di condivisione di software. Ad ogni buon conto, il professor
Winston -- allora responsabile del laboratorio AI del MIT -- mi propose gentilmente di
continuare ad utilizzare le attrezzature del laboratorio stesso.
372.7 I primi passi
Poco dopo aver iniziato il progetto GNU, venni a sapere del Free University Compiler Kit, noto
anche come VUCK (la parola olandese che sta per "free" inizia con la V). Era un compilatore
progettato per trattare più linguaggi, fra cui C e Pascal, e per generare codice binario per diverse
architetture. Scrissi al suo autore chiedendo se GNU avesse potuto usarlo. Rispose in modo
canzonatorio, dicendo che l’università era sì libera, ma non il compilatore. Decisi allora che
il mio primo programma per il progetto GNU sarebbe stato un compilatore multilinguaggio e
multipiattaforma.
Sperando di evitare di dover scrivere da me l’intero compilatore, ottenni il codice sorgente del
Pastel, un compilatore multipiattaforma sviluppato ai Laboratori Lawrence Livermore. Il linguaggio
supportato da Pastel, in cui il Pastel stesso era scritto, era una versione estesa del Pascal,
pensata come linguaggio di programmazione di sistemi. Io vi aggiunsi un frontend per il C, e cominciai
il porting per il processore Motorola 68000, ma fui costretto a rinunciare quando scoprii
che il compilatore richiedeva diversi megabyte di memoria sullo stack, mentre il sistema Unix
disponibile per il processore 68000 ne permetteva solo 64K.
Mi resi conto allora che il compilatore Pastel interpretava tutto il file di ingresso creandone un
albero sintattico, convertiva questo in una catena di "istruzioni", e quindi generava l’intero file di
uscita senza mai liberare memoria. A questo punto, conclusi che avei dovuto scrivere un nuovo
compilatore da zero. Quel nuovo compilatore è ora noto come Gcc; non utilizza niente del compilatore
Pastel, ma riuscii ad adattare e riutilizzare il frontend per il C che avevo scritto. Questo
però avvenne qualche anno dopo; prima, lavorai su GNU Emacs.
372.8 GNU Emacs
Cominciai a lavorare su GNU Emacs nel settembre 1984, e all’inizio del 1985 cominciava ad
essere utilizzabile. Così potei iniziare ad usare sistemi Unix per scrivere; fino ad allora, avevo
scritto sempre su altri tipi di macchine, non avendo nessun interesse ad imparare vi né ed.
A questo punto alcuni cominciarono a voler usare GNU Emacs, il che pose il problema di come
distribuirlo. Naturalmente lo misi sul server ftp anonimo del computer che usavo al MIT (questo
computer, prep.ai.mit.edu, divenne così il sito ftp primario di distribuzione di GNU; quando
alcuni anni dopo andò fuori servizio, trasferimmo il nome sul nostro nuovo ftp server). Ma allora
molte delle persone interessate non erano su Internet e non potevano ottenere una copia via ftp,
così mi si pose il problema di cosa dir loro.
Avrei potuto dire: «trova un amico che è in rete disposto a farti una copia». Oppure avrei potuto
fare quel che feci con l’originario Emacs su PDP-10, e cioè dir loro: «spediscimi una busta

344 volume VIII Argomenti avanzati e accessori
affrancata ed un nastro, ed io te lo rispedisco con sopra Emacs». Ma ero senza lavoro, e cercavo
un modo di far soldi con il software libero. E così feci sapere che avrei spedito un nastro a chi lo
voleva per 150 dollari. In questo modo, creai un’impresa di distribuzione di software libero, che
anticipava le compagnie che oggi distribuiscono interi sistemi GNU basati su Linux.
372.9 Un programma è libero per tutti?
Se un programma è software libero quando esce dalle mani del suo autore, non significa necessariamente
che sarà software libero per chiunque ne abbia una copia. Per esempio, il software
di pubblico dominio (software senza copyright) è software libero, ma chiunque può farne una
versione modificata proprietaria. Analogamente, molti programmi liberi sono protetti da diritto
d’autore, ma vengono distribuiti con semplici licenze permissive che permettono di farne versioni
modificate proprietarie.
L’esempio emblematico della questione è l’X Window System. Sviluppato al MIT, e pubblicato
come software libero con una licenza permissiva, fu rapidamente adottato da diverse società informatiche.
Queste aggiunsero X ai loro sistemi Unix proprietari, solo in forma binaria, e coperto
dello stesso accordo di non-diffusione. Queste copie di X non erano software più libero di quanto
lo fosse Unix.
Gli autori dell’X Window System non ritenevano che questo fosse un problema, anzi se lo aspettavano
ed era loro intenzione che accadesse. Il loro scopo non era la libertà, ma semplicemente
il "successo", definito come "avere tanti utenti". Non erano interessati che questi utenti fossero
liberi, ma solo che fossero numerosi.
Questo sfociò in una situazione paradossale, in cui due modi diversi di misurare la quantità di
libertà risultavano in risposte diverse alla domanda «questo programma è libero»? Giudicando
sulla base della libertà offerta dai termini distributivi usati dal MIT, si sarebbe dovuto dire che X
era software libero. Ma misurando la libertà dell’utente medio di X, si sarebbe dovuto dire che
X era software proprietario. La maggior parte degli utenti di X usavano le versioni proprietarie
fornite con i sistemi Unix, non la versione libera.
372.10 Il permesso d’autore (copyleft) e la GNU GPL
Lo scopo di GNU consisteva nell’offrire libertà agli utenti, non solo nell’ottenere ampia diffusione.
Avevamo quindi bisogno di termini di distribuzione che evitassero che il software GNU fosse
trasformato in software proprietario. Il metodo che usammo si chiama "permesso d’autore".
4
Il permesso d’autore (copyleft) 5 usa le leggi sul diritto d’autore (copyright), ma le capovolge per
ottenere lo scopo opposto: invece che un metodo per privatizzare il software, diventa infatti un
mezzo per mantenerlo libero.
Il succo dell’idea di permesso d’autore consiste nel dare a chiunque il permesso di eseguire il programma,
copiare il programma, modificare il programma, e distribuirne versioni modificate, ma
senza dare il permesso di aggiungere restrizioni. In tal modo, le libertà essenziali che definiscono
il "free software" (software libero) sono garantite a chiunque ne abbia una copia, e diventano
diritti inalienabili.
4 Nel 1984 o 1985, Don Hopkins, persona molto creativa, mi mandò una lettera. Sulla busta aveva scritto diverse
frasi argute, fra cui questa: "Permesso d’autore--tutti i diritti rovesciati". Utilizzai l’espressione "permesso d’autore" per
battezzare il concetto di distribuzione che allora andavo elaborando.
5 [NdT: si tratta di un gioco di parole, che qui viene reso con "permesso di autore": copyright (diritto di autore) è
formato dalle parola "copy" (copia) e "right" (diritto, ma anche destra), opposto di "left" (sinistra, ma anche lasciato).]

Il progetto GNU 345
Perché un permesso d’autore sia efficace, anche le versioni modificate devono essere libere. Ciò
assicura che ogni lavoro basato sul nostro sia reso disponibile per la nostra comunità, se pubblicato.
Quando dei programmatori professionisti lavorano su software GNU come volontari, è
il permesso d’autore che impedisce ai loro datori di lavoro di dire: «non puoi distribuire quei
cambiamenti, perché abbiamo intenzione di usarli per creare la nostra versione proprietaria del
programma».
La clausola che i cambiamenti debbano essere liberi è essenziale se vogliamo garantire libertà
a tutti gli utenti del programma. Le aziende che privatizzarono l’X Window System di solito
avevano apportato qualche modifica per per portare il programma sui loro sistemi e sulle loro
macchine. Si trattava di modifiche piccole rispetto alla mole di X, ma non banali. Se apportare
modifiche fosse una scusa per negare libertà agli utenti, sarebbe facile per chiunque approfittare
di questa scusa.
Una problematica correlata è quella della combinazione di un programma libero con codice non
libero. Una tale combinazione sarebbe inevitabilmente non libera; ogni libertà che manchi dalla
parte non libera mancherebbe anche dall’intero programma. Permettere tali combinazioni aprirebbe
non uno spiraglio, ma un buco grosso come una casa. Quindi un requisito essenziale per il
permesso d’autore è tappare il buco: tutto ciò che venga aggiunto o combinato con un programma
protetto da permesso d’autore dev’essere tale che il programma risultante sia anch’esso libero e
protetto da permesso d’autore.
La specifica implementazione di permesso d’autore che utilizziamo per la maggior parte del
software GNU è la GNU General Public License (licenza pubblica generica GNU), abbreviata in
GNU GPL. Abbiamo altri tipi di permesso d’autore che sono utilizzati in circostanze specifiche.
I manuali GNU sono anch’essi protetti da permesso d’autore, ma ne usano una versione molto
più semplice, perché per i manuali non è necessaria la complessità della GPL.
372.11 La Free Software Foundation
Man mano che l’interesse per Emacs aumentava, altre persone parteciparono al progetto GNU,
e decidemmo che era di nuovo ora di cercare finanziamenti. Così nel 1985 fondammo la Free
Software Foundation (Fondazione per il software libero), una organizzazione senza fini di lucro
per lo sviluppo di software libero. La FSF fra l’altro si prese carico della distribuzione dei nastri
di Emacs; più tardi estese l’attività aggiungendo sul nastro altro software libero (sia GNU che
non GNU) e vendendo manuali liberi.
La FSF accetta donazioni, ma gran parte delle sue entrate è sempre stata costituita dalle vendite:
copie di software libero e servizi correlati. Oggi vende CD-ROM di codice sorgente, CD-ROM
di programmi compilati, manuali stampati professionalmente (tutti con libertà di ridistribuzione
e modifica), e distribuzioni Deluxe (nelle quali compiliamo l’intera scelta di software per una
piattaforma a richiesta).
I dipendenti della Free Software Foundation hanno scritto e curato la manutenzione di diversi
pacchetti GNU. Fra questi spiccano la libreria C e la shell. La libreria C di GNU è utilizzata da
ogni programma che gira su sistemi GNU/Linux per comunicare con Linux. È stata sviluppata da
un membro della squadra della Free Software Foundation, Roland McGrath. La shell usata sulla
maggior parte dei sistemi GNU/Linux è Bash, la Bourne Again Shell 6 , che è stata sviluppata da
Brian Fox, dipendente della FSF.
6 "Bourne Again Shell" è un gioco di parole sul nome "Bourne Shell", che era la normale shell di Unix [NdT: "Bourne
again" richiama l’espressione cristiana "born again", "rinato" (in Cristo)].

346 volume VIII Argomenti avanzati e accessori
Finanziammo lo sviluppo di questi programmi perché il progetto GNU non riguardava solo strumenti
di lavoro o un ambiente di sviluppo: il nostro obiettivo era un sistema operativo completo,
e questi programmi erano necessari per raggiungere quell’obiettivo.
372.12 Il supporto per il software libero
La filosofia del software libero rigetta una diffusa pratica commerciale in particolare, ma non
è contro il commercio. Quando un’impresa rispetta la libertà dell’utente, c’è da augurarle ogni
successo.
La vendita di copie di Emacs esemplifica un modo di condurre affari col software libero. Quando
la FSF prese in carico quest’attività, dovetti trovare un’altra fonte di sostentamento. La trovai
nella vendita di servizi relativi al software libero che avevo sviluppato, come insegnare argomenti
quali programmazione di Emacs e personalizzazione di GCC, oppure sviluppare software,
soprattutto adattamento di GCC a nuove architetture.
Oggi tutte queste attività collegate al software libero sono esercitate da svariate aziende. Alcune
distribuiscono raccolte di software libero su CD-ROM, altre offrono consulenza a diversi livelli,
dall’aiutare gli utenti in difficoltà, alla correzione di errori, all’aggiunta di funzionalità non banali.
Si cominciano anche a vedere aziende di software che si fondano sul lancio di nuovi programmi
liberi.
Attenzione, però: diverse aziende che si fregiano del marchio "open source" (software aperto) in
realtà fondano le loro attività su software non libero che funziona insieme con software libero.
Queste non sono aziende di software libero, sono aziende di software proprietario i cui prodotti
attirano gli utenti lontano dalla libertà. Loro li chiamano "a valore aggiunto", il che riflette i valori
che a loro farebbe comodo che adottassimo: la convenienza prima della libertà. Se noi riteniamo
che la libertà abbia più valore, li dovremmo chiamare prodotti "a libertà sottratta".
372.13 Obiettivi tecnici
L’obiettivo principale di GNU era essere software libero. Anche se GNU non avesse avuto alcun
vantaggio tecnico su Unix, avrebbe avuto sia un vantaggio sociale, permettendo agli utenti di
cooperare, sia un vantaggio etico, rispettando la loro libertà.
Tuttavia risultò naturale applicare al lavoro le regole classiche di buona programmazione;
per esempio, allocare le strutture dati dinamicamente per evitare limitazioni arbitrarie sulla
dimensione dei dati, o gestire tutti i possibili codici a 8 bit in tutti i casi ragionevoli.
Inoltre, al contrario di Unix che era pensato per piccole dimensioni di memoria, decidemmo di
non supportare le macchine a 16 bit (era chiaro che le macchine a 32 bit sarebbero state la norma
quando il sistema GNU sarebbe stato completo), e di non preoccuparci di ridurre l’occupazione
di memoria a meno che eccedesse il megabyte. In programmi per i quali non era essenziale la
gestione di file molto grandi, spingemmo i programmatori a leggere in memoria l’intero file di
ingresso per poi analizzare il file senza doversi preoccupare delle operazioni di I/O.
Queste decisioni fecero sì che molti programmi GNU superassero i loro equivalenti Unix sia in
affidabilità che in velocità di esecuzione.

Il progetto GNU 347
372.14 Donazioni di computer
Man mano che la reputazione del progetto GNU andava crescendo, alcune persone iniziarono
a donare macchine su cui girava Unix. Queste macchine erano molto utili, perché il modo più
semplice di sviluppare componenti per GNU era di farlo su di un sistema Unix così da sostituire
pezzo per pezzo i componenti di quel sistema. Ma queste macchine sollevavano anche una
questione etica: se fosse giusto per noi anche solo possedere una copia di Unix.
Unix era (ed è) software proprietario, e la filosofia del progetto GNU diceva che non avremmo
dovuto usare software proprietario. Ma, applicando lo stesso ragionamento per cui la violenza
è ammessa per autodifesa, conclusi che fosse legittimo usare un pacchetto proprietario, se ciò
fosse stato importante nel crearne un sostituto libero che permettesse ad altri di smettere di usare
quello proprietario.
Tuttavia, benchè fosse un male giustificabile, era pur sempre un male. Oggi non abbiamo più
alcuna copia di Unix, perché le abbiamo sostituite con sistemi operativi liberi. Quando non fu
possibile sostituire il sistema operativo di una macchina con uno libero, sostituimmo la macchina.
372.15 L’elenco dei compiti GNU
Mentre il progetto GNU avanzava, ed un numero sempre maggiore di componenti di sistema
venivano trovati o sviluppati, diventò utile stilare un elenco delle parti ancora mancanti. Usammo
questo elenco per ingaggiare programmatori che scrivessero tali parti, e l’elenco prese il nome
di elenco dei compiti GNU. In aggiunta ai componenti Unix mancanti inserimmo nell’elenco
svariati progetti utili di programmazione o di documentazione che a nostro parere non dovrebbero
mancare in un sistema operativo veramente completo.
Oggi non compare quasi nessun componente Unix nell’elenco dei compiti GNU; tutti questi
lavori, a parte qualcuno non essenziale, sono già stati svolti. D’altro canto l’elenco è pieno di
quei progetti che qualcuno chiamerebbe "applicazioni": ogni programma che interessi ad una
fetta non trascurabile di utenti sarebbe un’utile aggiunta ad un sistema operativo.
L’elenco comprende anche dei giochi, e così è stato fin dall’inizio: Unix comprendeva dei giochi,
perciò era naturale che così fosse anche per GNU. Ma poiché non c’erano esigenze di compatibilità
per i giochi, non ci attenemmo alla scelta di giochi presenti in Unix, preferendo piuttosto
fornire un elenco di diversi tipi di giochi potenzialmente graditi agli utenti.
372.16 La licenza GNU per le librerie
La libreria C del sistema GNU utilizza un tipo speciale di permesso d’autore, la "Licenza Pubblica
GNU per le Librerie" 7 , che permette l’uso della libreria da parte di software proprietario.
Perché quest’eccezione?
Non si tratta di questioni di principio: non c’è nessun principio che dica che i prodotti software
proprietari abbiano il diritto di includere il nostro codice (perché contribuire ad un progetto
fondato sul rifiuto di condividere con noi?). L’uso della licenza LGPL per la libreria C, o per
qualsiasi altra libreria, è una questione di strategia.
La libreria C svolge una funzione generica: ogni sistema operativo proprietario ed ogni compilatore
includono una libreria C. Di conseguenza, rendere disponibile la nostra libreria C solo
7 [NdT: nel 1999 la FSF ha cambiato nome alla licenza LGPL che ora si chiama "Lesser GPL", GPL attenuata, per
non suggerire che si tratti della forma di licenza preferenziale per le librerie.]

348 volume VIII Argomenti avanzati e accessori
per i programmi liberi non avrebbe dato nessun vantaggio a tali programmi liberi, avrebbe solo
disincentivato l’uso della nostra libreria.
C’è un’eccezione a questa situazione: sul sistema GNU (termine che include GNU/Linux) l’unica
libreria C disponibile è quella GNU. Quindi i termini di distribuzione della nostra libreria C
determinano se sia possibile o meno compilare un programma proprietario per il sistema GNU.
Non ci sono ragioni etiche per permettere l’uso di applicazioni proprietarie sul sistema GNU, ma
strategicamente sembra che impedirne l’uso servirebbe più a scoraggiare l’uso del sistema GNU
che non a incoraggiare lo sviluppo di applicazioni libere.
Ecco perché l’uso della licenza LGPL è una buona scelta strategica per la libreria C, mentre per
le altre librerie la strategia va valutata caso per caso. Quando una libreria svolge una funzione
particolare che può aiutare a scrivere certi tipi di programmi, distribuirla secondo la GPL, quindi
limitandone l’uso ai soli programmi liberi, è un modo per aiutare gli altri autori di software libero,
dando loro un vantaggio nei confronti del software proprietario.
Prendiamo come esempio GNU-Readline, una libreria scritta per fornire a Bash la modificabilità
della linea di comando: Readline è distribuita secondo la normale licenza GPL, non la LGPL. Ciò
probabilmente riduce l’uso di Readline, ma questo non rappresenta una perdita per noi; d’altra
parte almeno una applicazione utile è stata resa software libero proprio al fine di usare Readline,
e questo è un guadagno tangibile per la comunità.
Chi sviluppa software proprietario ha vantaggi economici, gli autori di programmi liberi hanno
bisogno di avvantaggiarsi a vicenda. Spero che un giorno possiamo avere una grande raccolta di
librerie coperte dalla licenza GPL senza che esista una raccolta equivalente per chi scrive software
proprietario. Tale libreria fornirebbe utili moduli da usare come i mattoni per costruire nuovi
programmi liberi, e costituendo un sostanziale vantaggio per la scrittura di ulteriori programmi
liberi.
372.17 Togliersi il prurito?
Eric Raymond afferma che «ogni buon programma nasce dall’iniziativa di un programmatore
che si vuole togliere un suo personale prurito». È probabile che talvolta succeda così, ma molte
parti essenziali del software GNU sono state sviluppate al fine di completare un sistema operativo
libero. Derivano quindi da una idea e da un progetto, non da una necessità contingente.
Per esempio, abbiamo sviluppato la libreria C di GNU perché un sistema di tipo Unix ha bisogno
di una libreria C, la Bourne-Again Shell (bash) perché un sistema di tipo Unix ha bisogno di una
shell, e GNU tar perché un sistema di tipo Unix ha bisogno un programma tar. Lo stesso vale per
i miei programmi: il compilatore GNU, GNU Emacs, GDB, GNU Make.
Alcuni programmi GNU sono stati sviluppati per fronteggiare specifiche minacce alla nostra
libertà: ecco perché abbiamo sviluppato gzip come sostituto per il programma Compress, che la
comunità aveva perduto a causa dei brevetti sull’algoritmo LZW. Abbiamo trovato persone che
sviluppassero LessTif, e più recentemente abbiamo dato vita ai progetti GNOME e Harmony per
affrontare i problemi causati da alcune librerie proprietarie (come descritto più avanti). Stiamo
sviluppando la GNU Privacy Guard per sostituire i diffusi programmi di crittografia non liberi,
perché gli utenti non siano costretti a scegliere tra riservatezza e libertà.
Naturalmente, i redattori di questi programmi sono coinvolti nel loro lavoro, e varie persone
vi hanno aggiunto diverse funzionalità secondo le loro personali necessità ed i loro interessi.
Tuttavia non è questa la ragione dell’esistenza di tali programmi.

Il progetto GNU 349
372.18 Sviluppi inattesi
All’inizio del progetto GNU pensavo che avremmo sviluppato l’intero sistema GNU e poi lo
avremmo reso disponibile tutto insieme, ma le cose non andarono così.
Poiché i componenti del sistema GNU sono stati implementati su un sistema Unix, ognuno di
essi poteva girare su sistemi Unix molto prima che esistesse un sistema GNU completo. Alcuni
di questi programmi divennero diffusi e gli utenti iniziarono ad estenderli e a renderli utilizzabili
su nuovi sistemi: sulle varie versioni di Unix, incompatibili tra loro, e talvolta anche su altri
sistemi.
Questo processo rese tali programmi molto più potenti e attirò finanziamenti e collaboratori al
progetto GNU; tuttavia probabilmente ritardò di alcuni anni la realizzazione di un sistema minimo
funzionante, perché il tempo degli autori GNU veniva impiegato a curare la compatibilità di
questi programmi con altri sistemi e ad aggiungere nuove funzionalità ai componenti esistenti,
piuttosto che a proseguire nella scrittura di nuovi componenti.
372.19 GNU-Hurd
Nel 1990 il sistema GNU era quasi completo, l’unica parte significativa ancora mancante era il
kernel. Avevamo deciso di implementare il nostro kernel come un gruppo di processi server che
girassero sul sistema Mach. Mach è un microkernel sviluppato alla Carnegie Mellon University
e successivamente all’Università dello Utah; GNU Hurd è un gruppo di server (o "herd of gnus":
mandria di gnu) che gira su Mach svolgendo le funzioni del kernel Unix. L’inizio dello sviluppo
fu ritardato nell’attesa che Mach fosse reso disponibile come software libero, come era stato
promesso.
Una ragione di questa scelta progettuale fu di evitare quella che sembrava la parte più complessa
del lavoro: effettuare il debugging del kernel senza un debugger a livello sorgente. Questo lavoro
era già stato fatto, appunto in Mach, e avevamo previsto di effettuare il debugging dei server
Hurd come programmi utente, con GDB. Ma questa fase si rivelò molto lunga, ed il debugging
dei server multi-thread che si scambiano messaggi si è rivelato estremamente complesso. Per
rendere Hurd robusto furono così necessari molti anni.
372.20 Alix
Originariamente il kernel GNU non avrebbe dovuto chiamarsi Hurd; il suo nome originale era
Alix, come la donna di cui ero innamorato in quel periodo. Alix, che era amministratrice di
sistemi Unix, aveva sottolineato come il suo nome corrispondesse ad un comune schema usato per
battezzare le versioni del sistema Unix: scherzosamente diceva ai suoi amici: «qualcuno dovrebbe
chiamare un kernel come me». Io non dissi nulla ma decisi di farle una sorpresa scrivendo un
kernel chiamato Alix.
Le cose non andarono così. Michael Bushnell (ora Thomas), principale autore del kernel, preferì
il nome Hurd, e chiamò Alix una parte del kernel, quella che serviva a intercettare le chiamate di
sistema e a gestirle inviando messaggi ai server che compongono HURD.
Infine io e Alix ci lasciammo e lei cambiò nome; contemporaneamente la struttura di Hurd veniva
cambiata in modo che la libreria C mandasse messaggi direttamente ai server, e così il componente
Alix scomparve dal progetto. Prima che questo accadesse, però, un amico di Alix si accorse
della presenza del suo nome nel codice sorgente di Hurd e glielo disse. Così il nome raggiunse il
suo scopo.

350 volume VIII Argomenti avanzati e accessori
372.21 Linux e GNU/Linux
GNU Hurd non è pronto per un uso non sperimentale, ma per fortuna è disponibile un altro
kernel: nel 1991 Linus Torvalds sviluppò un Kernel compatibile con Unix e lo chiamò Linux.
Attorno al 1992, la combinazione di Linux con il sistema GNU ancora incompleto produsse un
sistema operativo libero completo (naturalmente combinarli fu un notevole lavoro di per sé). È
grazie a Linux che oggi possiamo utilizzare una versione del sistema GNU.
Chiamiamo GNU/Linux questa versione del sistema, per indicare la sua composizione come una
combinazione del sistema GNU col kernel Linux.
372.22 Le sfide che ci aspettano
Abbiamo dimostrato la nostra capacità di sviluppare un’ampia gamma di software libero, ma
questo non significa che siamo invincibili e inarrestabili. Diverse sfide rendono incerto il futuro
del software libero, e affrontarle richiederà perseveranza e sforzi costanti, talvolta per anni. Sarà
necessaria quella determinazione che le persone sanno dimostrare quando danno valore alla
propria libertà e non permettono a nessuno di sottrargliela. Le quattro sezioni seguenti parlano di
queste sfide.
372.23 Hardware segreto
Sempre più spesso, i costruttori di hardware tendono a mantenere segrete le specifiche delle
loro apparecchiature; questo rende difficile la scrittura di driver liberi che permettano a Linux e
XFree86 di supportare nuove periferiche. Anche se oggi abbiamo sistemi completamente liberi,
potremmo non averli domani se non saremo in grado di supportare i calcolatori di domani.
Esistono due modi per affrontare il problema. Un programmatore può ricostruire le specifiche
dell’hardware usando tecniche di reverse engineering. Oppure si può scegliere hardware supportato
dai programmi liberi: man mano che il nostro numero aumenta, la segretezza delle specifiche
diventerà una pratica controproducente.
Il reverse engineering è difficile: avremo programmatori sufficientemente determinati da dedicarvisi?
Sì, se avremo costruito una forte consapevolezza che avere programmi liberi sia una
questione di principio e che i driver non liberi non sono accettabili. E succederà che molti di noi
accettino di spendere un po’ di più o perdere un po’ più di tempo per poter usare driver liberi?
Sì, se il desiderio di libertà e la determinazione ad ottenerla saranno diffusi.
372.24 Librerie non libere
Una libreria non libera che giri su sistemi operativi liberi funziona come una trappola per i creatori
di programmi liberi. Le funzionalità attraenti della libreria fungono da esca; chi usa la libreria
cade nella trappola, perché il programma che crea è inutile come parte di un sistema operativo
libero (a rigore, il programma potrebbe esservi incluso, ma non funzionerebbe, visto che manca
la libreria). Peggio ancora, se un programma che usa la libreria proprietaria diventa diffuso, può
attirare altri ignari programmatori nella trappola.
Il problema si concretizzò per la prima volta con la libreria Motif, negli anni ’80. Sebbene non
ci fossero ancora sistemi operativi liberi, i problemi che Motif avrebbe causato loro erano già
chiari. Il progetto GNU reagì in due modi: interessandosi presso diversi progetti di software
libero perché supportassero gli strumenti grafici X liberi in aggiunta a Motif, e cercando qualcuno

Il progetto GNU 351
che scrivesse un sostituto libero di Motif. Il lavoro richiese molti anni: solo nel 1997 LessTif,
sviluppato dagli "Hungry Programmers", divenne abbastanza potente da supportare la maggior
parte delle applicazioni Motif.
Tra il 1996 e il 1998 un’altra libreria non libera di strumenti grafici, chiamata Qt, veniva usata in
una significativa raccolta di software libero: l’ambiente grafico KDE.
I sistemi liberi GNU/Linux non potevano usare KDE, perché non potevamo usare la libreria;
tuttavia, alcuni distributori commerciali di sistemi GNU/Linux, non scrupolosi nell’attenersi solo
ai programmi liberi, aggiunsero KDE ai loro sistemi, ottenendo così sistemi che offrivano più
funzionalità, ma meno libertà. Il gruppo che sviluppava KDE incoraggiava esplicitamente altri
programmatori ad usare Qt, e milioni di nuovi "utenti Linux" non sospettavano minimamente che
questo potesse costituire un problema. La situazione si faceva pericolosa.
La comunità del software libero affrontò il problema in due modi: GNOME e Harmony.
GNOME (GNU Network Object Model Environment, modello di ambiente per oggetti di rete)
è il progetto GNU per l’ambiente grafico (desktop). Intrapreso nel 1997 da Miguel de Icaza e
sviluppato con il supporto di Red Hat Software, GNOME si ripromise di fornire funzionalità
grafiche simili a quelle di KDE, ma usando esclusivamente software libero. GNOME offre anche
dei vantaggi tecnici, come il supporto per svariati linguaggi di programmazione, non solo il C++.
Ma il suo scopo principale era la libertà: non richiedere l’uso di alcun programma che non fosse
libero.
Harmony è una libreria compatibile con Qt, progettata per rendere possibile l’uso del software
KDE senza dover usare Qt.
Nel novembre 1998 gli autori di Qt annunciarono un cambiamento di licenza che, una volta
operativo, avrebbe reso Qt software libero. Non c’è modo di esserne certi, ma credo che questo
fu in parte dovuto alla decisa risposta della comunità al problema posto da Qt quando non era
libero (la nuova licenza è scomoda ed iniqua, per cui rimane comunque preferibile evitare l’uso
di Qt).
Come risponderemo alla prossima allettante libreria non libera? Riuscirà la comunità in toto a
comprendere l’importanza di evitare la trappola? Oppure molti di noi preferiranno la convenienza
alla libertà, creando così ancora un grave problema? Il nostro futuro dipende dalla nostra filosofia.
372.25 Brevetti sul software
Il maggior pericolo a cui ci troviamo di fronte è quello dei brevetti sul software, che possono
rendere inaccessibili al software libero algoritmi e funzionalità per un tempo che può estendersi
fino a vent’anni. I brevetti sugli algoritmi di compressione LZW furono depositati nel 1983, e
ancor oggi non possiamo distribuire programmi liberi che producano immagini GIF compresse.
Nel 1998 un programma libero per produrre audio compresso MP3 venne ritirato sotto minaccia
di una causa per violazione di brevetto.
Ci sono modi per affrontare la questione brevetti: possiamo cercare prove che un brevetto non sia
valido oppure possiamo cercare modi alternativi per ottenere lo stesso risultato. Ognuna di queste
tecniche, però, funziona solo in certe circostanze; quando entrambe falliscono un brevetto può
obbligare tutto il software libero a rinunciare a qualche funzionalità che gli utenti desiderano.
Cosa dobbiamo fare quando ciò accade?
Chi fra noi apprezza il software libero per il valore della libertà rimarrà comunque dalla parte dei
programmi liberi; saremo in grado di svolgere il nostro lavoro senza le funzionalità coperte da
brevetto. Ma coloro che apprezzano il software libero perché si aspettano che sia tecnicamente

352 volume VIII Argomenti avanzati e accessori
superiore probabilmente grideranno al fallimento quando un brevetto ne impedisce lo sviluppo.
Perciò, nonostante sia utile parlare dell’efficacia pratica del modello di sviluppo "a cattedrale",
e dell’affidabilità e della potenza di un dato programma libero, non ci dobbiamo fermare qui;
dobbiamo parlare di libertà e di principi.
372.26 Documentazione libera
La più grande carenza nei nostri sistemi operativi liberi non è nel software, quanto nella carenza
di buoni manuali liberi da includere nei nostri sistemi. La documentazione è una parte
essenziale di qualunque pacchetto software; quando un importante pacchetto software libero non
viene accompagnato da un buon manuale libero si tratta di una grossa lacuna. E di queste lacune
attualmente ne abbiamo molte.
La documentazione libera, come il software libero, è una questione di libertà, non di prezzo. Il
criterio per definire libero un manuale è fondamentalmente lo stesso che per definire libero un
programma: si tratta di offrire certe libertà a tutti gli utenti. Deve essere permessa la redistribuzione
(compresa la vendita commerciale), sia in formato elettronico che cartaceo, in modo che il
manuale possa accompagnare ogni copia del programma.
Autorizzare la modifica è anch’esso un aspetto cruciale; in generale, non credo sia essenziale
permettere alle persone di modificare articoli e libri di qualsiasi tipo. Per esempio, non credo che
voi o io dobbiamo sentirci in dovere di autorizzare la modifica di articoli come questo, articoli
che descrivono le nostre azioni e il nostro punto di vista.
Ma c’è una ragione particolare per cui la libertà di modifica è cruciale per la documentazione
dei programmi liberi. Quando qualcuno esercita il proprio diritto di modificare il programma,
aumentandone o alterandone le funzionalità, se è coscienzioso modificherà anche il manuale,
in modo da poter fornire una documentazione utile e accurata insieme al programma modificato.
Un manuale che non permetta ai programmatori di essere coscienziosi e completare il loro lavoro
non soddisfa i bisogni della nostra comunità.
Alcuni limiti sulla modificabilità non pongono alcun problema; per esempio, le richieste di conservare
la nota di copyright dell’autore originale, i termini di distribuzione e la lista degli autori
vanno bene. Non ci sono problemi nemmeno nel richiedere che le versioni modificate dichiarino
esplicitamente di essere tali, così pure che intere sezioni non possano essere rimosse o modificate,
finché queste sezioni vertono su questioni non tecniche. Restrizioni di questo tipo non creano
problemi perché non impediscono al programmatore coscienzioso di adattare il manuale perché
rispecchi il programma modificato. In altre parole, non impediscono alla comunità del software
libero di beneficiare appieno dal manuale.
D’altro canto, deve essere possibile modificare tutto il contenuto tecnico del manuale e poter
distribuire il risultato in tutti i formati usuali, attraverso tutti i normali canali di distribuzione;
diversamente, le restrizioni creerebbero un ostacolo per la comunità, il manuale non sarebbe
libero e avremmo bisogno di un altro manuale.
Gli sviluppatori di software libero avranno la consapevolezza e la determinazione necessarie a
produrre un’intera gamma di manuali liberi? Ancora una volta, il nostro futuro dipende dalla
nostra filosofia.

Il progetto GNU 353
372.27 Dobbiamo parlare di libertà
Stime recenti valutano in dieci milioni il numero di utenti di sistemi GNU/Linux quali Debian
GNU/Linux e Red Hat Linux. Il software libero ha creato tali vantaggi pratici che gli utenti
stanno approdando ad esso per pure ragioni pratiche.
Gli effetti positivi di questa situazione sono evidenti: maggior interesse a sviluppare software
libero, più clienti per le imprese di software libero e una migliore capacità di incoraggiare le
aziende a sviluppare software commerciale libero invece che prodotti software proprietari.
L’interesse per il software, però, sta crescendo più in fretta della coscienza della filosofia su cui è
basato, e questa disparità causa problemi. La nostra capacità di fronteggiare le sfide e le minacce
descritte in precedenza dipende dalla determinazione nell’essere impegnati per la libertà. Per
essere sicuri che la nostra comunità abbia tale determinazione, dobbiamo diffondere l’idea presso
i nuovi utenti man mano che entrano a far parte della comunità.
Ma in questo stiamo fallendo: gli sforzi per attrarre nuovi utenti nella comunità sono di gran lunga
maggiori degli sforzi per l’educazione civica della comunità stessa. Dobbiamo fare entrambe le
cose, e dobbiamo mantenere un equilibrio fra i due impegni.
372.28 "Open Source"
Parlare di libertà ai nuovi utenti è diventato più difficile dal 1998, quando una parte della
comunità decise di smettere di usare il termine "free software" e usare al suo posto "open source".
Alcune delle persone che suggerirono questo termine intendevano evitare che si confondesse
"free" con "gratis", un valido obiettivo. D’altra parte, altre persone intendevano mettere da parte
lo spirito del principio che aveva dato la spinta al movimento del software libero e al progetto
GNU, puntando invece ad attrarre i dirigenti e gli utenti commerciali, molti dei quali afferiscono
ad una ideologia che pone il profitto al di sopra della libertà, della comunità, dei principi. Perciò la
retorica di "open source" si focalizza sul possibilità di creare software di buona qualità e potente
ma evita deliberatamente le idee di libertà, comunità, principio.
Le riviste che si chiamano "Linux..." sono un chiaro esempio di ciò: sono piene di pubblicità di
software proprietario che gira sotto GNU/Linux; quando ci sarà il prossimo Motif o Qt, queste
riviste avvertiranno i programmatori di starne lontano o accetteranno la sua pubblicità?
L’appoggio delle aziende può contribuire alla comunità in molti modi; a parità di tutto il resto è
una cosa utile. Ma ottenere questo appoggio parlando ancor meno di libertà e principi può essere
disastroso; rende ancora peggiore lo sbilanciamento descritto tra diffusione ed educazione civica.
"Software libero" (free software) e "sorgente aperto" (open source) descrivono più o meno la
stessa categoria di software, ma dicono cose differenti sul software e sui valori. Il progetto GNU
continua ad usare il termine "software libero" per esprimere l’idea che la libertà sia importante,
non solo la tecnologia.
372.29 Prova!
La filosofia di Yoda ("Non c’è provare") suona bene, ma per me non funziona. Ho fatto la maggior
parte del mio lavoro angustiato dal timore di non essere in grado di svolgere il mio compito e nel
dubbio, se fossi riuscito, che non fosse sufficiente per raggiungere l’obiettivo. Ma ci ho provato
in ogni caso perché nessuno tranne me si poneva tra il nemico e la mia città. Sorprendendo me
stesso, qualche volta sono riuscito.

354 volume VIII Argomenti avanzati e accessori
A volte ho fallito, alcune delle mie città sono cadute; poi ho trovato un’altra città minacciata e
mi sono preparato ad un’altra battaglia. Con l’andar del tempo ho imparato a cercare le possibili
minacce e a mettermi tra loro e la mia città, facendo appello ad altri hacker perché venissero e si
unissero a me.
Oggigiorno spesso non sono da solo. È un sollievo ed una gioia quando vedo un reggimento di
hacker che scavano trincee per difendere il confine e quando mi rendo conto che questa città
può sopravvivere; per ora. Ma i pericoli diventano più grandi ogni anno, ed ora Microsoft ha
esplicitamente preso di mira la nostra comunità. Non possiamo dare per scontato il futuro della
libertà; non diamolo per scontato! Se volete mantenere la vostra libertà dovete essere pronti a
difenderla.

Capitolo 373
La rivoluzione del Mimete, ovvero software e
copyright
di Giulio Mazzolini giuliomazzolini @ libero.it
non modificabile
Lo scrittore Primo Levi immaginò un particolare tipo di duplicatore, chiamato Mimete, capace
di duplicare un oggetto esattamente come l’originale. Da una parte si poteva inserire un foglio
protocollo con i bolli, dall’altra usciva un foglio protocollo identico all’originale con su dei bolli
veri, un clone perfetto. Il protagonista prova quindi a duplicare vari oggetti, dapprima una banconota,
poi un diamante, poi ancora una salamandra, riuscendoci felicemente. Alla fine duplicò
la moglie e poi, stanco di avere due mogli, duplicò se stesso, per riformare due coppie uguali...
Ci sono delle macchine per fotocopie che fanno delle copie «quasi» uguali all’originale, ma non
perfettamente uguali, se continuiamo a fare una copia dall’ultima copia, la qualità degraderà più
o meno velocemente in funzione della qualità della macchina. Quindi non è un Mimete.
Eppure la fantasia dello scrittore ha visto giusto, esiste un Mimete e molti di voi l’hanno in casa.
Non duplica tutto, ma duplica perfettamente il software. La copia di un dischetto è esattamente
uguale all’originale, non c’è modo di capire quale è l’originale e quale la copia, posso fare quante
copie voglio, l’ultima copia sarà esattamente uguale all’originale. Il vostro PC è un Mimete
limitato al software e la sua capacità di duplicazione è un fatto assolutamente rivoluzionario.
Non solo è possibile duplicare, ma costa poco e lo possono fare tutti.
Si tratta di una rivoluzione importante, che mi piace chiamare «La rivoluzione del Mimete» in
onore di Primo Levi.
373.1 Che cosa è il software?
Il software non è altro che una ricetta, un qualcosa di immateriale che congiungendosi a qualcosa
di materiale, l’hardware, trasfigura la materia informe facendola diventare qualcosa di ordinato e
utilizzabile.
Dire che il software sia un’opera d’autore assimilabile a un’opera letteraria è sicuramente forzato,
inoltre la legislazione corrente che protegge il software è molto più severa di quella per esempio
che protegge i libri.
Un libro posso leggerlo così com’è, ne godo direttamente, non devo metterlo in una macchina
per goderne. Un libro posso imprestarlo a un amico, in ufficio posso tenere una sola copia del
«Manuale dell’ingegnere» anche se ci sono dieci ingegneri che lo usano. Esistono biblioteche
pubbliche dove posso prendere in prestito un libro e leggerlo, quindi «usarlo» completamente
per quello che è stato fatto, con poca spesa.
È vero che gli editori che fanno libri per la scuola si lamentano del fenomeno delle fotocopie, in
Francia si è trovata una soluzione che prevede il versamento da parte delle scuole di un tantum
a un fondo che risarcisce autori ed editori. Non so se sia il sistema migliore, ma sicuramente
prende atto della facilità di copiare e cerca una soluzione non poliziesca.
355

356 volume VIII Argomenti avanzati e accessori
373.2 Cenni di storia del software
La prima macchina che si considera essere un calcolatore digitale moderno è l’ENIAC, costruito
nei laboratori della Moore School of Electrical Engineering dell’Università della Pensilvania,
agli inizi degli anni 1940. Iniziò a lavorare nel 1946, venne spento nel 1955. Vale la pena di
accennare all’architettura della macchina: 18000 valvole, memoria a flip-flop, quindi ancora a
valvole, 20 parole di memoria.
Usa un sistema digitale e non più analogico, ma non ancora il sistema binario. La macchina
seguente, progettata da Von Neumann mentre l’ENIAC era in fase di realizzazione, usa ancora
valvole, ma per la memoria usa una linea di ritardo acustica a mercurio, ed è una delle prime a
usare il codice binario, propugnato appunto da Von Neumann ed ha un’architettura che sarà poi
seguita da quasi tutte le macchine seguenti. La macchina di Von Neumann entra in operatività
nel 1950.
Entrambe le macchine furono costruite su iniziativa dell’Esercito Americano e furono usate per
fare calcoli balistici, le usò anche Fermi per i laboratori di Los Alamos. Infatti i calcolatori
precedenti a relè elettromeccanici erano molto più lenti, circa un secondo per una moltiplicazione,
mentre l’ENIAC impiegava circa un millisecondo.
In quegli anni i dati venivano inseriti tramite schede perforate, i programmi venivano scritti in
linguaggio mnemonico e poi tradotti da umani in codice binario. Solo nel 1949 si iniziò a tradurre
il codice mnemonico in binario con uno speciale software di traduzione.
Il primo vero linguaggio per calcolatori fu il Fortran, che iniziato nel 1954 e ultimato nel 1957,
divenne il linguaggio più diffuso al mondo.
I calcolatori conobbero una prima rivoluzione con l’introduzione dei transistor, nel 1956 infatti
appare il TX-0, una macchina molto più piccola, che non usava schede per l’input ma la flexowriter,
un perforatore di nastro cartaceo che molti di voi avranno visto sui telex in uso fino a qualche
anno fa.
La seconda rivoluzione delle macchine è l’introduzione dei circuiti integrati, 1961. Le macchine
diventano ancora più piccole e potenti, la memoria aumenta e la velocità di calcolo pure.
Nel 1959 John McCarty, padre dell’intelligenza artificiale, inizia a scrivere il linguaggio LISP,
nel 1961 arriva al MIT il PDP-1, una macchina con schermo ma con input ancora a nastro,
prototipo di una lunga serie di macchine PDP che assomigliano sempre di più ai calcolatori
moderni. Nei primi anni 1960 John Kemeny scrive il Basic, nello stesso periodo l’agenzia ARPA
(Advanced Research Project Agency) dell’Esercito USA inizia a finanziare progetti di ricerca sui
calcolatori.
Siamo ancora nella preistoria del software, ci sono pochi programmi o non ce ne sono affatto, i
ricercatori si scrivono i codici di cui hanno bisogno e se lo passano liberamente senza problemi.
Le macchine vengono vendute con un po’ di software come fosse un set di istruzioni per l’uso.
Ogni anno segna un progresso importante, nel 1967, appare il primo floppy disk, nel 1969 inizia
lo sviluppo di UNIX nel laboratori Bell di AT&T, nel 1970 Intel, con la collaborazione di
Federico Faggin, produce il 4004.
Se vogliamo dare una data alla fine del periodo iniziale questa potrebbe essere il 1968, per il nuovo
atteggiamento dell’opinione pubblica e in particolare degli studenti che vedono con sospetto
le ricerche fatte al MIT con i finanziamenti dell’Esercito, che culmina con l’assalto ai laboratori.
In quel periodo nasce e si sviluppa un movimento per portare il computer al popolo, di cui un
protagonista è stato Lee Feldestain.

La rivoluzione del Mimete, ovvero software e copyright 357
L’IBM, pressata dagli ambienti antimonopolisti, decise una mossa che voleva dimostrare come
essa monopolista non fosse: scorporò il prezzo delle macchine, l’hardware, da quello del
software, il famoso «unbundling», dando così spazio a potenziali concorrenti nel settore del
software.
Gli anni seguenti sono di grande fermento, nasce il primo PC, una macchina venduta in kit che si
chiamava Altair. Molti di voi l’avranno vista nel film «War Games», era una scatola con dentro
un microprocessore, sul fronte delle levette per l’input e delle lucine per l’output! Costava 300 $
e aveva 256 byte di memoria. Non serviva praticamente a niente, eppure ebbe un grandissimo
successo, portava finalmente in casa di tutti un computer, quello che Lee Feldstein e i suoi amici
predicavano da tempo.
Poi ancora una accelerazione incredibile: nel 1976 appare il Sol, progettato da Lee e nel 1977
l’Apple. Nel 1974 Brian Kernighan e Dennis Ritchie sviluppano il linguaggio C.
Il 1976 segna la nascita del software proprietario e dei principi che ci stanno dietro. Infatti assieme
all’Altair si poteva comperare una versione del Basic, a circa 150 $. L’autore del programma
che chiedeva un prezzo così esoso era Bill Gates.
A causa del prezzo elevato qualcuno fece delle copie del programma (allora i programmi stavano
su nastro perforato), Gates molto irritato, scrisse una storica lettera sui giornali letti allora dagli
hacker, nella quale lamentava il fatto che si copiasse senza pagare e che questo fatto avrebbe
ostacolato che del buon software venisse scritto.
Chi può affrontare di fare del lavoro professionale per nulla? Quale hobbista può
mettere tre anni di tempo-uomo nella programmazione, trovare tutti i bug, documentare
il suo prodotto, il tutto gratuitamente?... Francamente, la cosa che voi fate è
rubare.
1
Argomentazioni sulle quali Bill ha costruito i suo impero, certamente con buona parte di verità ma
che non tengono conto che già allora esisteva un Mimete con il quale si poteva copiare facilmente,
velocemente e a basso costo.
Sul Doctor Dobbs Journal, Jim Warren scriveva:
Quando sarà gratis o così poco costoso che sarà più facile pagarlo che duplicarlo,
non verrà più rubato
Tim Pittman scrisse allora un Tiny Basic e lo mise in vendita a 5 $! Lo fa teorizzando che il
software deve essere disponibile per tutti e che quindi deve costare il meno possibile.
Oggi questo discorso è stato ripreso dal mondo del software libero, con ben maggior
consapevolezza e forza.
1 Bill Gates, lettera aperta sulla pirateria, apparsa sul bollettino dell’Homebrew Computer Club, il 03/02/1976.

Il copyright/diritto d’autore del software
di Giulio Mazzolini giuliomazzolini @ libero.it
Capitolo 374
non modificabile
Fino a circa la fine degli anni 1980, il software veniva ceduto assieme alla macchina o veniva
scritto su richiesta dei clienti. Se c’erano dei pacchetti pronti, questi dovevano venir personalizzati
per ogni utente. È solo con la nascita del PC IBM, 1981, quando il computer si diffonde in
milioni di pezzi che nasce una richiesta di massa di software.
Su come proteggere i diritti dell’autore del programma software esisteva un dibattito teorico sin
da una decina d’ anni. In Francia nel 1968, una legge dichiarava il software non brevettabile.
Negli USA, con approccio più pragmatico, semplicemente il software non veniva brevettato in
quanto l’ufficio brevetti non aveva la più pallida idea di come si potesse brevettare un programma
software. Il problema esiste tuttora, essendo quasi impossibile riconoscere se un software in
qualche modo lede i diritti brevettuali di un altro.
Oggi tuttavia si brevettano gli algoritmi, una assurdità totale, che però sull’onda del successo
del concetto di «proprietà intellettuale», riesce a venir accettata dai legislatori e dall’opinione
comune.
Sarebbe come se oggi la tabellina del nove o i logaritmi fossero brevettati e doveste pagare per
usarli.
Nel 1980, su pressione dei produttori di software, il governo americano promulgò il Copyright
Act con il quale si riconosceva al software lo stesso tipo di protezione accordata sino ad allora ai
testi letterari o alle altre forme d’opere d’arte.
Non sfuggiva ai legislatori l’effetto «Mimete», ma venne semplicemente risolto vietando severamente
ogni forma di duplicazione del software. Tanto era rigida la legge che un po’ dopo
dovettero chiarire che la duplicazione per uso di «back-up» era lecita!
Senza entrare nei dettagli, voglio solo far notare con l’ultima legge anti pirateria italiana, la copia
illecita di software è punita con reclusione da tre mesi a tre anni, come mi ha ricordato vigorosamente
un immenso cartellone a Malpensa: ci vogliono 3 minuti per copiare un programma ma ti
può costare 3 anni...
374.1 Una breve storia del diritto d’autore
L’idea del copyright e la legislazione relativa nasce dopo l’invenzione della macchina da stampa
di Gutemberg (1400-1468). L’idea era semplice: stampare un libro costa, quindi se lo stampo io
non deve poterlo stampare un altro.
La legislazione originale quindi proteggeva gli interessi degli stampatori, l’autore non veniva
preso in considerazione, anche perché spesso poi i libri contenevano testi di antichi scrittori
morti da secoli. Il libro più stampato infatti era la Bibbia.
Il monopolio librario relegava gli autori in una posizione palesemente subalterna o inesistente.
Dal 1709 (data che segna la nascita del diritto positivo del copyright) fino al 1774, la proprietà
letteraria dell’autore fu affermata a beneficio degli editori più che degli autori.
Solo nel 1777 gli Editti che precedono la Rivoluzione Francese, riconoscono il diritto d’autore,
nasce allora la concezione moderna della tutela dell’autore. Il diritto d’autore è la proprietà più
sacra in quanto si considera «inscindibile l’oggetto dal soggetto».
358

Il copyright/diritto d’autore del software 359
Si riconosce finalmente la figura dell’autore e se ne tutelano i suoi diritti. L’autore dell’opera
possiede tutti i diritti per il semplice fatto di esserne l’autore. Può poi cedere alcuni o tutti i diritti
a terzi con un patto esplicito. Se si tratta di un testo, in genere i diritti sono quelli di riprodurre il
testo in un libro, eventualmente di farne delle traduzione e ancora delle ristampe. Se l’opera è un
quadro, l’ autore può cedere il diritto di copia dell’opera, per esempio per farne una copertina, o
un manifesto.
Un autore può tutelare la sua opera anche se ha ceduto i diritti di riproduzione. Può esigere che
l’opera resti integra, o che non subisca modificazioni. Hanno quindi ragione quei registi che
pretendono che il loro film passi senza interruzioni pubblicitarie, o che rifiutano che vengano
tagliati (o censurati) in alcune scene.
In via generale se comperate un quadro, con il possesso e la proprietà legittima dello stesso, non
avete automaticamente il diritto di riprodurlo.
I diritti d’autore sono ereditari, per cui gli eredi potranno godere dei vantaggi economici derivanti
dai diritti d’autore anche dopo la morte dell’autore.
Le multinazionali (americane) del cinema, della musica e del software sono riuscite a ottenere il
prolungamento della durata dei diritti d’autore fino a 70 anni dopo la morte.
Quando il legislatore dice «autore» intende «di opera artistica». Negli USA il concetto di copyright
tende a venir esteso anche in mancanza di un’opera d’arte. Persino una lettera commerciale
è stata considerata soggetta a copyright.
Negli USA è oramai prassi brevettare anche il software, non programmi interi, ma pezzi particolari.
È brevettato il cestino dell’Apple, l’algoritmo di compressione usato dal programma Zip,
l’XOR del puntatore grafico. La Microsoft deposita migliaia di brevetti e così pure le altre grandi
case.
Oggi nessuno può seriamente pensare di scrivere del software commerciale se non ha capitali
molto grandi. Infatti deve utilizzare schiere di avvocati a tempo pieno per assistere chi scrive,
affinché non incorra in infrazioni di brevetti o di copyright. Poiché è impossibile che uno studio
di avvocati conosca tutti i brevetti di software, c’è la quasi certezza di incappare in qualche azione
legale. Cause che costano molto o si chiudono con costosi accordi.
Avevamo detto che la legislazione USA ha assimilato il software a una opera d’autore e quindi
ha utilizzato il corpo legislativo del copyright per proteggerlo.
374.2 I sei punti della rivoluzione digitale
L’avvocato Pamela Samuelson ha così voluto riassumere i sei punti principali della rivoluzione
digitale:
1. È molto facile duplicare, si fa presto, costa poco, le copie sono dei duplicati
perfetti dell’originale.
2. È facilissimo trasmettere i dati e si trasmettono quasi istantaneamente,
si trasmettono in tutto il mondo scavalcando barriere nazionali, doganali,
censorie.
3. Il dato digitale è malleabile, si può trasformare quanto si vuole, si può deformare
quanto si vuole, un originale ne diventa facilmente un altro deformato o
rielaborato.
4. Le opere letterarie, sonore, grafiche, una volta messe in forma digitale, subiscono
la stessa sorte, sono indistinguibili nel supporto, non sono più differenziate

360 volume VIII Argomenti avanzati e accessori
tra libro, quadro e disco, mettendo in crisi i concetti di copyright che sono diversi
se si tratta di quadro disco o libro.
5. Il dato digitale è compatto, è piccolo si trasporta facilmente.
6. Il dato digitale non si visita più linearmente come si fa con un libro, ma in modo
non lineare. Tutti coloro che hanno visitato un sito in Internet non hanno letto
pagina dopo pagina, ma sono saltati da una pagina a un altro sito, creandosi
percorsi individuali.
Ciascuna delle caratteristiche precedenti è sufficiente a causare una rottura delle dottrine
esistenti sulla proprietà intellettuale. Tutte e sei assieme sicuramente costringeranno
i legislatori a una modifica radicale del concetto di copyright e di proprietà
intellettuale.
374.3 I vantaggi del «free software»
Le sei caratteristiche citate da Pamela Samuelson riguardano in generale tutti gli aspetti del digitale,
per quanto riguarda in particolare il software, invece questi sono gli argomenti principali a
favore del software libero.
1. La diffusione del sapere funziona se l’informazione circola: Jefferson ha detto che se alla
luce di una candela studiano due persone, il sapere dell’umanità aumenta, senza che per
questo si consumino più candele.
2. Le limitazioni imposte dai «privilegi» del copyright e dei brevetti impediscono lo sviluppo
tecnologico e scientifico, facilitando i monopoli.
3. Il mantenimento delle licenze con le quali il software oggi è venduto, e la relativa assimilazione
del software a una opera letteraria, induce una legislazione oppressiva assurda e la
sua applicazione necessita di un sistema poliziesco da grande fratello.
4. Il software libero è meglio per gli utilizzatori, in quanto hanno a disposizione il codice sorgente
per fare delle modifiche a degli adattamenti alle loro necessità specifiche rapidamente
e senza esborsi onerosi.
5. Il software libero è meglio per i programmatori, che non devono avere un avvocato alle
spalle e in quanto hanno a disposizione dei codici che possono utilizzare per scrivere altro
codice, in un processo di accumulazione e di sviluppo del sapere.
6. Il «free» è meglio per gli utenti perché non ci sono licenze da pagare.
Ci sono al mondo 6 miliardi di individui e 100 milioni di PC, il «free» è il futuro, non soppianterà
il software proprietario per quanto riguarda applicazioni complesse professionali, ma lo costringerà
a tornare a prendere in considerazione la vecchia affermazione di Jim Warren: «quando
costerà così poco che sarà più facile comperarlo che copiarlo»...

Indice analitico del volume
/dev/vcsa*, 321
/dev/vcs*, 321
/etc/brltty.conf, 323
/etc/brltty/, 323
backup, 8
Barcode, 46
braille, 316
Code 128, 39
Code 3 of 9, 37
Code 39, 37
Code 39 esteso, 39
codice a barre, 30, 46
copia di sicurezza, 8
copia di sicurezza: generazioni, 10
copia di sicurezza: livelli, 11
dischetto di emergenza, 19
dischetto di emergenza: Slackware, 22
DOS: APPEND, 105
DOS: ASSIGN, 103
DOS: ATTRIB, 105
DOS: AUTOEXEC.BAT, 112
DOS: BREAK, 108
DOS: BUFFERS, 108
DOS: CALL, 115
DOS: CH, 92
DOS: CHCP, 113
DOS: CHDIR, 92
DOS: CHKDSK, 101
DOS: CHOICE, 119
DOS: CLS, 119
DOS: COMP, 107
DOS: CONFIG.SYS, 108
DOS: COPY, 94
DOS: COUNTRY, 109
DOS: DATE, 114
DOS: DEL, 95
DOS: DELTREE, 106
DOS: DEVICE, 110
DOS: DEVICEHIGH, 110
DOS: DIR, 94
DOS: DISKCOPY, 102
DOS: DOS, 110
DOS: DRIVEPARM, 110
DOS: ECHO, 118
DOS: ERASE, 95
DOS: FC, 107
DOS: FCBS, 111
DOS: FILES, 111
DOS: FIND, 106
361

DOS: FOR, 116
DOS: FORMAT, 100
DOS: GOTO, 117
DOS: GRAFTABL, 114
DOS: IF, 116
DOS: INSTALL, 111
DOS: JOIN, 104
DOS: KEYB, 113
DOS: LABEL, 101
DOS: LASTDRIVE, 111
DOS: LH, 121
DOS: LOADHIGH, 121
DOS: MD, 92
DOS: MEM, 121
DOS: MKDIR, 92
DOS: MORE, 98
DOS: MOVE, 106
DOS: PAUSE, 119
DOS: REM, 118
DOS: REN, 96
DOS: RENAME, 96
DOS: RM, 93
DOS: RMDIR, 93
DOS: SET, 96
DOS: SHELL, 111
DOS: SHIFT, 115
DOS: SORT, 98
DOS: STACK, 111
DOS: SUBST, 104
DOS: SYS, 103
DOS: TIME, 114
DOS: TREE, 107
DOS: TYPE, 97
DOS: VERIFY, 105
DOS: VOL, 101
DOS: XCOPY, 102
EAN: European Article Number, 33
EAN-13, 31
EAN-8, 31
ELKS, 80
Ethernet, 26
GNU: Manifesto, 331
Gnuplot, 126
i25, 43
interfogliata due su cinque, 43
Interleaved two of five, 43
ISBN, 36
Ispell, 127
ISSN, 37
ITF, 43
Minix, 58
362

Perl, 127
PLIP, 26
SC, 127
Slackware, 22
Spreadsheet Calculator, 127
UCC/EAN 128, 43
UCC: Uniform Code Council, 33
UPC-A, 31
UPC-E, 31
USS Code 128, 39
363

364