Corso di PostScript: terza puntata

Una Chiave per il Desktop Publishing

Corso di PostScript - Marco A. Calamari

Terza Puntata

In questa puntata ci impadroniremo dell'uso di una sessantina di operatori PostScript; daremo le definizioni esatte di tutti gli operatori matematici, di gestione dei dizionari e di manipolazione dello stack, e definiremo anche gli operatori grafici e di gestione dei font fin qui utilizzati. Apprenderemo l'uso delle procedure e del meccanismo dei dizionari; faremo inoltre una breve digressione sul modo utilizzato dall'interprete PostScript per immagazzinare gli oggetti all'interno della memoria. Termineremo con un programma commentato ed una breve bibliografia di testi di riferimento.

Prima di parlare nuovamente di operatori PostScript è necessario conoscere come definire costanti, variabili, procedure ed altri oggetti di uso comune.

Numeri, numeri

Abbiamo già definito degli interi nel programma della seconda parte. In PostScript un intero è una sequenza di numeri, iniziante eventualmente con un segno, ma non contenente il punto decimale o spazi bianchi ; ad esempio

143 +78987 -14

sono numeri interi validi. I numeri reali invece contengono il punto decimale e/o l'esponente, ad esempio

32.3 0.25 .1111 2.76e6 -23.4E-05

Nel caso che un intero sia troppo grande per essere rappresentato come tale, esso viene automaticamente convertito a reale con esponente. In PostScript esistono anche i numeri interi con base diversa da 10, la base può essere un intero compreso fra 2 e 36 separata dal numero dal carattere #; le cifre del numero sono comprese da 0 a 9 e da A a Z, ad esempio

2#1100 16#123ABC 36#129az

E importante notare che la definizione di uno stesso numero intero in una qualunque base genera lo stesso oggetto; in parole povere l'oggetto numero intero non ricorda la base in cui è stato definito.

Stringhe e caratteri

Come già visto in precedenza, un oggetto stringa (per brevità d'ora in poi semplicemente stringa) viene definito racchiudendo una serie di caratteri ASCII fra parentesi tonde. All'interno di una coppia di parentesi tonde i soli caratteri che conservano un significato speciale sono \, (, ), tutti gli altri lo perdono.

All'interno di una stringa possono essere definiti, per mezzo del carattere \ (backslash), i seguenti caratteri speciali

\n linefeed (avanzamento carta)
\r carriage return (ritorno carrello)]
\t horizontal tab (tabulazione)
\b backspace (ritorno unitario)
\f form feed (salto pagina)
\\ backslash
\( parentesi tonda aperta
\) parentesi tonda chiusa

Inoltre il carattere \ permette di definire, all'interno di una stringa, un qualunque carattere, anche non-ASCII, fornendo il suo valore ottale, ad esempio

\40 \040

definiscono ambedue uno spazio bianco del set di caratteri ASCII.

Una stringa lunga può essere spezzata su più righe di testo scrivendo un backslash come ultimo carattere della riga e facendolo seguire dal ritorno a capo, che viene così ignorato.

Un altro modo di definire una stringa è di inserire fra parentesi angolate i valori dei singoli caratteri in formato esadecimale; questo è il metodo normalmente utilizzato per includere valori binari (ad esempio bitmap) in un programma PostScript. Si noti che, limitandosi ai caratteri stampabili e di controllo, la stessa stringa può essere definita sia con l'uso delle parentesi tonde che con le angolate. Vediamo degli esempi

L'istruzione Postscript

(stringa normale)

seguita dall'operatore show produce

stringa normale

(stringa strana {}[]%\)\)\))

produce

stringa strana {}[]%)))

(stringa su due\nlinee)

produce

stringa su due

linee

(stringa su \

una linea)

produce

stringa su una linea

(AAA)

produce

AAA

(\101\101\101)

produce

AAA

<414141>

produce

AAA

Gli operatori

È necessario cominciare a definire ed elencare gli operatori più importanti che dovremo usare; ecco quindi un elenco dei principali operatori matematici, di manipolazione degli stack e dei dizionari, e una prima parte degli operatori grafici. Le definizioni degli operatori saranno scritte in questo modo

num1 num2 add num3 : spiegazione

La definizione è suddivisa in quattro parti:

valori (od oggetti) di input, elencati nell'ordine in cui devono essere posti sullo stack, scritti in corsivo;
nome dell'operatore, scritto in neretto;
valori (od oggetti) di output, elencati nell'ordine in cui sono stati posti sullo stack, scritti in corsivo;
spiegazione ed eventuali esempi di utilizzo dell'operatore.

Segnaleremo con un trattino - l'assenza di valori di input e/o di output, e sottointenderemo (salvo indicazione contraria) che i valori di input vengono rimossi dallo stack degli operandi, e che quelli di output vi vengono aggiunti.

Indicheremo inoltre con

any, any1, any2 ... degli oggetti di tipo qualunque;

num, num1, num2 ... degli oggetti numerici indifferentemente interi o reali;

int, int1, int2 ... degli oggetti numerici interi;

real, real1, real2 ... degli oggetti numerici reali;

bool, bool1, bool2 ... dei valori logici;

string, string1, string2 ... delle stringhe di caratteri;

proc, proc1, proc2 ... delle procedure, o vettori eseguibili;

vect, vect1, vect2 ... dei vettori non eseguibili;

name, name1, name2 ... degli oggetti nominali;

dict, dict1, dict2 ... dei dizionari

Tutti gli altri tipi di oggetti verranno indicati con i loro nomi scritti in corsivo.

Operatori matematici

num1 num2 add num3 : calcola la somma num1+num2 dei due numeri e la pone in cima allo stack.
num1 num2 div num3 : calcola il quoziente num1/num2 dei due numeri e lo pone in cima allo stack.
num1 num2 idiv num3 : calcola il quoziente intero di num1/num2 dei due numeri e lo pone in cima allo stack.
num1 num2 mod num3 : calcola il resto num1 modulo num2 dei due numeri e lo pone in cima allo stack.
num1 num2 mul num3 : calcola il prodotto num1*num2 dei due numeri e lo pone in cima allo stack.
num1 num2 sub num3 : calcola la differenza num1-num2 dei due numeri e la pone in cima allo stack.
num1 abs num2 : calcola il valore assoluto di |num1| e lo pone in cima allo stack.
num1 neg num2 : cambia il segno a num1 e lo pone in cima allo stack.
num1 round num2 : calcola l'intero più vicino a num1 e lo pone in cima allo stack.
num1 floor num2 : calcola l'intero immediatamente inferiore a num1 e lo pone in cima allo stack.
num1 ceiling num2 : calcola l'intero immediatamente superiore a num1 e lo pone in cima allo stack.
num1 sqrt num2 : calcola la radice quadrata di num1 e la pone in cima allo stack.
num1 num2 atan num3 : calcola l'arcotangente di num1/num2 in gradi e la pone in cima allo stack.
num1 cos num2 : calcola il coseno di num1/num2 in gradi e lo pone in cima allo stack.
num1 sin num2 : calcola il seno dell'angolo num1 (espresso in gradi) e lo pone in cima allo stack.
num1 num2 exp num3 : calcola il valore di num1 elevato alla num2 e lo pone in cima allo stack.
num1 ln num2 : calcola il logaritmo naturale di num1 e lo pone in cima allo stack.
num1 log num2 : calcola il logaritmo decimale di num1 e lo pone in cima allo stack.
- rand int : non usa argomenti; genera un intero pseudocasuale int compreso fra 0 e 2^31 -1, e lo pone in cima allo stack.
int srand - : inizializza il generatore di numeri pseudocasuali, in modo da poter riprodurre sempre la stessa sequenza di numeri.
any1 ... anyn clear - : cancella tutti i contenuti dello stack degli operandi.

Operatori di manipolazione dello stack

any1 ... anyn pstack any1 ... anyn : non usa argomenti; stampa sullo standard output tutti gli elementi contenuti nello stack, senza alterarlo.
any == - : stampa il primo argomento dello stack in output, rimuovendolo.
any dup any any : copia il primo argomento dello stack e lo pone in cima ad esso.
any1 any2 exch any2 any1 : scambia tra loro i primi due argomenti dello stack.
any pop - : rimuove il primo argomento dello stack.
any1 ... anyn int1 int2 roll any1 ... anyn : dopo aver rimosso int1 e int2 dallo stack, ruota gli int1 elementi rimanenti di int2 posizioni.
any1 ... anyn int copy any1 ... anyn any1 ... anyn : dopo aver rimosso l'intero int dallo stack, copia i primi int elementi rimasti sullo stack e li pone in cima ad esso.
- count int : non usa argomenti; conta gli elementi presenti sullo stack e pone l'intero int corrispondente in cima ad esso.
- mark mark : non usa argomenti; genera un oggetto particolare di tipo mark e lo pone in cima allo stack. Come indica il suo nome, un oggetto di tipo mark viene utilizzato per marcare una posizione sullo stack.
mark any1 ... anyn counttomark mark any1 ... anyn int : conta gli elementi presenti sullo stack partendo dalla cima e fino al primo mark incontrato, e pone l'intero int corrispondente in cima allo stack.
mark any1 ... anyn cleartomark - : cancella gli elementi sullo stack partendo dalla cima fino (ed incluso) al primo mark trovato.

Operatori di gestione dei dizionari

int dict dict : crea un oggetto di tipo dizionario con capacità per int elementi.
dict length int : restituisce il numero int di elementi presenti in dict .
dict maxlength int : restituisce la capacità int di dict .
dict begin - : pone dict sullo stack dei dizionari.
- end - : toglie dict dallo stack dei dizionari.
name any def - : definisce l'oggetto any col nome name nel dizionario corrente.
name load any : cerca il nome name nei dizionari presenti sullo stack e ritorna l'oggetto any associato.
dict name any put - : definisce l'oggetto any nel dizionario dict col nome name.
dict name get any : cerca il nome name nel dizionario dict e ritorna l'oggetto any associato.
dict name known bool : cerca name in dict e restituisce true o false.
name where dict bool : cerca name nei dizionari e restituisce il dizionario dict che lo contiene ed il valore logico bool=true; se name non viene trovato viene restituito solo bool=false.
- errordict dict : pone errordict sullo stack degli operandi.
- systemdict dict : pone systemdict sullo stack degli operandi.
- userdict dict : pone userdict sullo stack degli operandi.
- currentdict dict : pone il primo dizionario dello stack dei dizionari sullo stack degli operandi.
- countdictstack int : restituisce il numero int dei dizionari presenti sullo stack dei dizionari.

Operatori di gestione dei font

name findfont dict : cerca fra i font disponibili, cioè quelli permanentemente registrati nelle ROM (memoria permanente a sola lettura) del controller, oppure caricati temporaneamente nella RAM (memoria volatile a lettura/scrittura), quello di nome name e lo pone sullo stack degli operandi. Si noti che un font non è un tipo di oggetto a se, ma semplicemente un dizionario i cui contenuti (complicatissimi) devono essere definiti secondo regole ben precise.
dict1 int scalefont dict2 : preleva il font dict1 e l'altezza int dallo stack genera un nuovo font dict2 scalato nell'altezza di int punti e lo pone sullo stack degli operandi.
dict setfont - : preleva il font dict e lo rende il font corrente.
string show - : preleva l'oggetto stringa string dallo stack e lo stampa nel font corrente, a partire dal current point.

Operatori grafici

- newpath - : non altera lo stack, ma cancella la path corrente, che diventa vuota. Serve per iniziare la definizione di una nuova path; resetta il punto corrente rendendolo indefinito.
num1 num2 moveto - : muove la posizione corrente del cursore al punto di coordinate assolute x=num1 e y=num2 specificate, senza aggiungere nuovi segmenti alla path corrente.
num1 num2 rmoveto - : muove la posizione corrente del cursore al punto di coordinate relative x=num1 e y=num2 specificate (cioè considerando come origine la posizione precedente del cursore), senza aggiungere nuovi segmenti alla path corrente.
num1 num2 lineto - : aggiunge un segmento alla path corrente, partendo dalla posizione precedente del cursore, fino al punto di coordinate assolute x=num1 e y=num2 specificate.
num1 num2 rlineto - : aggiunge un segmento alla path corrente, partendo dalla posizione precedente del cursore, fino al punto di coordinate relative x=num1 e y=num2 specificate (cioè considerando come origine la posizione precedente del cursore).
num1 num2 num3 num4 num5 arc - : aggiunge un arco alla path corrente, partendo dal punto corrente, con centro x=num1 e y=num2, raggio=num3, angolo iniziale=num4, angolo finale=num5 (gli angoli crescono in senso antiorario e l'arco viene tracciato in senso antiorario).
- currentpoint num1 num2 : non usa argomenti; pone sullo stack due numeri rappresentanti le coordinate del punto corrente x=num1 e y=num2 .
- closepath - : non usa argomenti; chiude la path corrente, aggiungendovi un segmento che unisce il primo punto tracciato all'ultimo. Se la path corrente è formata da più parti esse vengono chiuse separatamente.
num setgray - : fissa il tono di grigio corrente al valore num, che deve essere compreso fra 0 (nero) e 1 (bianco).
- currentgray num : non usa argomenti; restituisce sullo stack il valore del tono di grigio corrente num.
- fill - : non usa argomenti; riempie la path corrente col tono di grigio corrente e la copia sulla pagina in memoria, cancellando eventualmente ogni altro contenuto sottostante. Questo operatore esegue implicitamente un closepath prima del riempimento, e un newpath dopo, resettando così la path ed il punto correnti.
num setlinewidth - : fissa lo spessore corrente delle linee.
- currentlinewidth num : non usa argomenti; restituisce il valore dello spessore di linea corrente num sullo stack.
- stroke - : non usa argomenti; copia la path corrente sulla pagina in memoria, utilizzando lo spessore di linea corrente. Come l'operatore fill, esegue implicitamente un closepath prima del riempimento, e un newpath dopo, resettando così la path ed il punto correnti.
- showpage - : stampa la pagina in memoria sulla pagina fisica, espelle quest'ultima dalla LaserWriter e resetta la pagina in memoria rendendola completamente bianca.
- copypage - : stampa la pagina in memoria sulla pagina fisica e la espelle, ma lascia invariata la pagina in memoria.
- erasepage - : resetta la pagina in memoria rendendola completamente bianca.

Vettori, procedure, variabili e dizionari

Come abbiamo già visto, un oggetto vettore si definisce racchiudendo una qualunque sequenza di oggetti PostScript fra parentesi quadre. Una procedura PostScript, che non compare nell'elenco dei tipi di oggetti PostScript, non è altro che un vettore con l'attributo eseguibile; è per questo che talora parleremo di vettori eseguibili per indicare le procedure. Una procedura PostScript viene definita racchiudendo una sequenza di comandi validi fra parentesi graffe; quando viene incontrata la parentesi graffa chiusa, l'interprete PostScript genera un oggetto di tipo vettore eseguibile e lo pone sullo stack degli operandi.

Per dare un nome alla procedura, si devono porre due oggetti sullo stack, il nome della procedura ed il vettore eseguibile che la contiene, ed associarli poi con l'operatore def; ad esempio

/cubo { dup dup mul mul } def

definisce una procedura di nome cubo (si ricordi che per convenzione i nomi delle procedure iniziano con la minuscola), che calcola il cubo di un numero; e successivamente l'operatore def memorizza la procedura nel dizionario corrente.

Vediamo ora come definire una variabile; per definire la variabile Pippo (si ricordi che i nomi di variabile iniziano con la maiuscola) con valore 22 scriveremo

/Pippo 22 def

Ogni volta che il programma incontrerà il nome eseguibile Pippo, il valore 22 verrà posto sullo stack e potrà essere utilizzato da altri operatori. Per modificare il valore di una variabile la si deve ridefinire; ad esempio, per incrementarne il valore di Pippo di 1 (solo dopo averla definita) scriveremo

/Pippo Pippo 1 add def

Il valore di Pippo è adesso 23.

Ma dove sono state immagazzinate le procedure e le variabili che abbiamo definito? Tutti gli oggetti PostScript vengono memorizzati nella VM o memoria virtuale dell'interprete PostScript, che è gestita direttamente da esso; lo stack non contiene realmente gli oggetti, ma solo dei puntatori agli oggetti stessi, i quali si trovano ancora nel punto della VM in cui sono stati memorizzati all'atto della definizione. Un oggetto PostScript, una volta definito, non può più essere rimosso dalla VM; esistono comunque meccanismi che permettono di cancellare oggetti dalla VM, che esamineremo più avanti

È chiaro che deve esistere un meccanismo che permetta di suddividere gli oggetti definiti in memoria, permettendone il controllo della visibilità; qualcosa insomma di analogo al meccanismo di visibilità dei nomi di variabili e procedure nei linguaggi tipo Fortran, Pascal o C. Questo meccanismo esiste, ed è basato sull'uso degli oggetti di tipo dizionario; dato che il suo funzionamento è abbastanza diverso dalle normali regole che governano la visibilità dei nomi negli altri linguaggi, sarà necessario comprenderlo a fondo prima di proseguire.

Quando l'interprete PostScript incontra un nome eseguibile (cioè un nome non preceduto dal carattere /) non cerca l'oggetto od il comando corrispondente a quel nome direttamente nella VM, ma solo tramite lo stack dei dizionari. Nelle prime due posizioni di questo stack sono permanentemente memorizzati due dizionari userdict e systemdict; systemdict contiene gli operatori PostScript predefiniti e non è modificabile, ed userdict contiene inizialmente alcuni operatori e variabili (come il numero di copie da stampare) ed è modificabile. La ricerca di un nome parte dal dizionario più in alto nello stack (detto dizionario corrente) dei dizionari (inizialmente userdict) e prosegue fino all'ultimo (sempre systemdict). I nuovi oggetti definiti (variabili, procedure, ecc.) vengono normalmente memorizzati nel dizionario corrente, quindi inizialmente userdict.

Se vogliamo memorizzare una serie di oggetti in modo da poterne controllare la visibilità possiamo quindi creare un nuovo dizionario, porlo sullo stack dei dizionari, immagazzinarvi gli oggetti e toglierlo dallo stack; a questo punto tutti i contenuti del dizionario sono invisibili al normale meccanismo di ricerca dei nomi. Possiamo renderli visibili a piacere caricando e scaricando il nuovo dizionario dallo stack dei dizionari.

Facciamo un esempio; supponiamo (programma 1) di voler definire le costanti Pi e E, ed usarle con diversi numeri di cifre significative secondo necessità. Nel programma seguente, le linee che iniziano con il carattere speciale % sono commenti PostScript; queste linee possono anche non essere inserite nel programma, cosi come le linee vuote. Un commento può inoltre essere iniziato anche in mezzo ad una linea; ponendo il carattere % nel punto in cui si desidera iniziare il commento, tutti i caratteri seguenti fino alla fine della linea saranno ignorati dall'interprete PostScript.

% Corso PostScript - III parte - programma 1

% Prova di utilizzo di un dizionario

% per controllare la visibilità di

% variabili e procedure.

/cost3dict 10 dict def

% Creiamo il nuovo dizionario di

% costanti con 3 cifre significative

cost3dict begin

% Poniamolo sullo stack dei dizionari

% che ora contiene:

% cost3dict

% userdict

% systemdict

% Definiamo Pi ed E a 3 cifre

% significative.

/Pi 3.14 def

/E 2.71 def

% Togliamo cost3dict dallo stack

% dei dizionari.

end

% Analogamente definiamo cost4dict

% e Pi ed E a 4 cifre significative.

/cost4dict 10 dict def

cost4dict begin

/Pi 3.141 def

/E 2.718 def

end

% Utilizziamo le costanti a 3 cifre

% Il risultato stampato a

% terminale sarà 5.85

cost3dict begin

Pi E add ==

end

% Utilizziamo le costanti a 4 cifre

% Il risultato stampato a

% terminale sarà 5.859

cost4dict begin

Pi E add ==

end

Il meccanismo dei dizionari ha numerosi altri usi, che presenteremo nei prossimi esempi di programmazione.

Un esempio di grafica

L'esempio che segue (programma 2) utilizzerà alcuni dei nuovi operatori che abbiamo definito. L'utilizzo di alcuni di essi è fatto a scopo didattico, e non sarebbe strettamente necessario; ad esempio non è necessario porre tutte le procedure che usiamo in un dizionario diverso da userdict, ma lo faremo per impratichirci nell'uso dei dizionari. In altri casi il programma potrebbe essere migliorato da un uso più intenso dello stack e dall'eliminazione delle variabili locali alle procedure, ma, trattandosi dei primi programmi, è stata privilegiata la chiarezza a scapito dell'efficienza del programma.

Il risultato grafico che otterremo dall'esempio (vedi figura 1) non sarà molto artistico (del resto siamo ancora alle elementari del PostScript), ma i prodotti dei nostri programmi PostScript miglioreranno rapidamente col tempo.

D'ora in poi, a definizione di ogni procedura sarà sempre preceduta da alcuni commenti:

il primo commento contiene il nome della procedura;
il secondo contiene gli eventuali argomenti prelevati dallo stack degli operandi da parte della procedura, uno slash, e quelli eventualmente depositati;
il terzo è opzionale e contiene le eventuali variabili locali della procedura;
il quarto è pure opzionale e contiene le variabili globali usate per l'input e/o per l'output dalla procedura;
i commenti successivi descrivono brevemente lo scopo della procedura.

Si noti che la distinzione fra variabili locali e globali è solo una convenzione, in realtà tutte le variabili definite nel prossimo esempio sono globali e contenute in userdict; è a carico del programmatore evitare conflitti fra i due tipi di variabili, scegliendo magari un prefisso od un suffisso particolare da assegnare a tutti i nomi di variabili locali

% Corso PostScript - III parte - programma 2

% Stampa di un paesaggio stilizzato

% Creiamo il nuovo dizionario e

% poniamolo sullo stack.

/paesaggiodict 10 dict def

paesaggiodict begin

% Procedura inch

% Argomenti: XInches / XPoints

% Converte misure da pollici

% a punti tipografici.

/inch { 72 mul } def

% Procedura tracciaCornice

% Argomenti: - / -

% Traccia una cornice su pagina

% A4 ad un pollice dal margine.

/tracciaCornice {

newpath

1 inch 1 inch moveto

6 inch 0 inch rlineto

0 inch 10 inch rlineto

-6 inch 0 inch rlineto

closepath

.1 inch setlinewidth

0 setgray stroke

} def

% Procedura tracciaSfondo

% Argomenti: - / -

% Traccia lo sfondo del paesaggio

/tracciaSfondo {

newpath

1 inch 1 inch moveto

6 inch 0 inch rlineto

0 inch 4.5 inch rlineto

-6 inch 0 inch rlineto

closepath

.3 setgray fill

1 inch 4.5 inch moveto

6 inch 0 inch rlineto

0 inch 6.5 inch rlineto

-6 inch 0 inch rlineto

closepath

.9 setgray fill

} def

% Procedura tracciaTriangolo

% Argomenti Base, TonoGrigio / -

% Variabili locali: BaseTriangolo,

% TonoTriangolo

% Traccia un triangolo pieno a

% partire dal punto corrente.

/tracciaTriangolo {

/TonoTriangolo exch def

/BaseTriangolo exch def

currentpoint newpath moveto

BaseTriangolo 0 rlineto

BaseTriangolo 2 div neg dup neg

rlineto closepath

TonoTriangolo setgray fill

} def

% Procedura tracciaSole

% Argomenti Raggio, TonoGrigio / -

% Variabili locali: RaggioSole,

% TonoSole

% Traccia un cerchio pieno a

% partire dal punto corrente.

/tracciaSole{

/TonoSole exch def

/RaggioSole exch def

currentpoint newpath moveto

currentpoint RaggioSole 0 180 arc

closepath

TonoSole setgray fill

} def

% Togliamo il dizionario completo

% dallo stack

end

% Inizio programma principale

% Si rende disponibile il

% contenuto del dizionario.

paesaggiodict begin

% Sitraccia il paesaggio

tracciaSfondo

tracciaCornice

4 inch 4.5 inch moveto

.5 inch 1 inch tracciaSole

1.2 inch 4.4 inch moveto

2.5 inch .2 tracciaTriangolo

4 inch 4.5 inch moveto

2 inch .1 tracciaTriangolo

2.5 inch 4.3 inch moveto

2 inch .1 tracciaTriangolo

1.5 inch 4.3 inch moveto

1 inch .05 tracciaTriangolo

2.2 inch 4.2 inch moveto

1 inch .05 tracciaTriangolo

5 inch 4.3 inch moveto

1.5 inch .05 tracciaTriangolo

% Stampa della pagina

showpage

% Rimozione del dizionario dallo

% stack dei dizionari

end

Bibliografia

Nel seguito, elenchiamo alcuni testi che vi potranno essere utili per approfondire la conoscenza del PostScript; vi raccomando particolarmente i primi due, che sono la bibbia del PostScript, e sono reperibili in ogni buona libreria specializzata in testi tecnici.

1) Adobe Systems Inc., PostScript language reference manual, Addison-Wesley, Reading Massachusetts U.S.A., 1985

2) Adobe Systems Inc., PostScript language tutorial and cookbook, Addison-Wesley, Reading Massachusetts U.S.A., 1985

3) Adobe Systems Inc., PostScript language program design, Addison-Wesley, Reading Massachusetts U.S.A., 198

4) John Warnock e Douglas Wyatt, A device independent graphics imaging model for use with raster devices, su COMPUTER GRAPHICS volume 16 numero 3 del Giugno 1982 pagg. 313-320

5) David A. Holzgang, Understanding PostScript programming, Sybex Inc., Alameda California U.S.A.,1987