                          Pag. 1






Graphic Lisp

Manuale Utente








Scritto da :    Zoia Andrea Michele 
                Via Pergola #1 23037 TIRANO (Sondrio) Italia
                Tel. ita-342-704210


                             
                         Sommario
                             

1. IL LINGUAGGIO GRAPHIC LISP                             4
 
 1.1 INTRODUZIONE                                        4
 
 1.2 S-ESPRESSIONI                                       5
 
 1.3 VALUTAZIONE                                         7
   1.3.1 ALGORITMO DI VALUTAZIONE                        8
 
 1.4 LEGAMI DI UN SIMBOLO ATOMICO E FUNZIONI            10
 
 1.5 VARIABILI GLOBALI, LOCALI E SPECIALI               13
 
 1.6 MACRO                                              16
 
 1.7 TIPI DI NODI                                       17
   1.7.1 NODI CON NOME O SIMBOLI ATOMICI                17
   1.7.2 NODI CONS                                      18
   1.7.3 NODI VALORE                                    19
     1.7.3.1 INTERI                                     19
     1.7.3.2 REALI                                      20
     1.7.3.3 RAZIONALI                                  20
     1.7.3.4 STRINGHE                                   20
     1.7.3.5 STREAM                                     21
     1.7.3.6 FUNZIONI DI SISTEMA                        21
     1.7.3.7 ACCESSORI                                  22
     1.7.3.8 FUNZIONI UTENTE                            22
     1.7.3.9 METODI UTENTE                              22
     1.7.3.10 MACRO UTENTE                              23
     1.7.3.11 ISTANZE DI CLASSI                         23
     1.7.3.12 NODI DUEPUNTI (:)                         23
     1.7.3.13 NODI &                                    24

2. FUNZIONI DI GRAPHIC LISP                              25
 
 2.1 FUNZIONI STANDARD                                  27
   2.1.1 FUNZIONI LAMBDA, DEFUN, DEFMACRO               27
   2.1.2 FUNZIONI DEFMETHOD, DEFCLASS, MAKE-INSTANCE    28
     2.1.2.1 ESEMPIO DI GESTIONE DELLE CLASSI DELLE
     PRECEDENZE E DEI METODI                            30
   2.1.3 FUNZIONI DO E DO*                              35
   2.1.4 FUNZIONI DOLIST E DOTIMES                      36
   2.1.5 FUNZIONI LET, PROG, PROG1, E PROGN             37
 
 2.2 FUNZIONI DI SISTEMA                                39
   2.2.1 DEBUGGING                                      39
   2.2.2 FUNZIONI VARIE DI SISTEMA                      40
 
 2.3 FUNZIONI MATEMATICHE E TIPI DI DATO NUMERICI       41
   2.3.1 IL TIPO INTERO                                 41
   2.3.2 IL TIPO REALE                                  42
   2.3.3 IL TIPO RAPPORTO O RAZIONALE                   42
   2.3.4 CONVERSIONI DI TIPO                            43
 
 2.4 PREDICATI                                          46
   2.4.1 PREDICATI DI TIPO                              46
   2.4.2 PREDICATI COMMON LISP                          47
     2.4.2.1 PREDICATI STANDARD                         47
     2.4.2.2 PREDICATI NUMERICI                         47
     2.4.2.3 PREDICATI DI STRINGA                       48
 
 2.5 FUNZIONI DI STRINGA                                49
   2.5.1 CARATTERI E CODICI ASCII                       49
   2.5.2 CONCATENAZIONE LUNGHEZZA E SOTTOSTRINGHE       49
   2.5.3 CONVERSIONE DI INTERI, REALI E SIMBOLI ATOMICI 49
   2.5.4 STRINGA FORMATTATA                             50
     2.5.4.1 SPECIFICATORI DI FORMATO DI STRPRINTF      50
     2.5.4.2 CARATTERI DI FLAG DI STRPRINTF [FLAGS]     51
     2.5.4.3 FORME ALTERNATIVE PER LA CONVERSIONE DI
     STRPRINTF                                          52
     2.5.4.4 SPECIFICATORI DI LARGHEZZA DI STRPRINTF
     [WIDTH]                                            52
     2.5.4.5 SPECIFICATORI DI PRECISIONE DI STRPRINTF
     [.PREC]                                            53
     2.5.4.6 CARATTERI DI CONVERSIONE TIPO DI STRPRINTF
     [TYPE_CHAR]                                        54
     2.5.4.7 ESEMPI DI STRPRINTF                        56
 
 2.6 FUNZIONI DI FILE I/O                               57
   2.6.1 APRIRE E CHIUDERE UN FILE                      57
   2.6.2 ERRORI DI FILE                                 58
   2.6.3 POSIZIONAMENTO NEL FILE                        58
   2.6.4 LETTURA E SCRITTURA DI BYTE                    59
   2.6.5 LETTURA E SCRITTURA DI STRINGHE E S-ESPRESSIONI
   SU FILE                                              59
 
 2.7 FUNZIONI GRAFICHE                                  61
   2.7.1 MODALIT GRAFICHE E COLORI                     61
   2.7.2 PUNTI E LINEE                                  62
   2.7.3 POLIGONI ED ELLISSI                            62
   2.7.4 TESTO IN MODALIT GRAFICA                      63
   2.7.5 PENNE                                          63
   2.7.6 PENNELLI                                       64

3. INDICE ANALITICO DELLE FUNZIONI DI GRAPHIC LISP CITATE
NEL MANUALE                                              65

ELENCO DELLE FUNZIONI                                    69



1.   Il linguaggio Graphic Lisp






1.1  Introduzione
Questo  capitolo    una  breve  panoramica  su  linguaggio

Graphic   Lisp,   riassume  brevemente   i   concetti   pi

importanti, e mostra soprattutto le particolarit di questa

implementazione  che  risulta,  comunque,   aderente   allo

standard Common Lisp.

Successivamente  verranno  introdotti  i   tipi   di   dato

supportati dall'interprete.

Nel   secondo   capitolo  vengono  spiegate   le   funzioni

incorporate.

Nella sezione finale del manuale verranno elencate tutte le

funzioni  incorporate  con  la loro  sintassi,  l'eventuale

effetto laterale ed il valore ritornato.



                         *   *   *

                             

Per  maggiori delucidazioni riguardo al Common Lisp rimando

ad un testo specifico.

Un libro interessante da consultare 

  Lisp 3rd Edition di P.H Winston B.K.P. Horn ed. Addison

                       Wesley 1988.


1.2

 S-espressioni
  il  nome  di  un qualunque oggetto Lisp, possono  essere
sostanzialmente  di  due  tipi  diversi:  atomi  o   coppie
puntate.

Gli   atomi  possono  a  loro  volta  essere  di  due  tipi
differenti:   nomi   o  valori,  differenza   che   risulta
fondamentale durante la valutazione della s-espressione.
Gli  atomi  valore sono gli interi, i reali,  le  stringhe,
ecc...
Ad esempio 1 , 2 , 3.4 , "stringa"
Gli  atomi  con  nome  o  simboli atomici  sono  tutti  gli
identificatori
Ad esempio A , NOME , ATOMO

Le  coppie puntate sono raggruppamenti di due s-espressioni
chiamate la parte destra e la parte sinistra della coppia.
Tramite  le  coppie puntate possono essere costruite  delle
liste  che sono costruite racchiudendo ricorsivamente delle
coppie puntate all'interno di altre.
Le coppie puntate si rappresentano cos:

             ( s-espressione . s-espressione )

Esempio:
( 10 . NOME )

Mentre le liste vengono rappresentate cos:

     ( s-espressione s-espressione ... s-espressione)
                             
Esempio:
( 10 NOME ( SOTTOLISTA 20 ) 30 )

Notare che la lista sopra  perfettamente equivalente  alla
seguente coppia puntata:
(  10  . ( NOME . ( ( SOTTOLISTA . ( 20 . NIL ) ) . ( 30  .
NIL ) ) )

                         *   *   *

Esistono due s-espressioni speciali:
     NIL  che  rappresenta  la  condizione  logica  FALSO,
 inoltre  usato come terminatore di liste.
    T  che rappresenta la condizione logica VERO, comunque
 per VERO si intende qualunque espressione che non  FALSA,
 cio  che  non    NIL. Inoltre T rappresenta  la  massima
 superclasse,  ovvero  l'estremo genitore  di  ogni  classe
 dell'interprete.

1.3

 Valutazione
Per   valutazione  di  una  s-espressione  si  intende  una
chiusura   sull'insieme   delle  s-espressioni,   cio   la
valutazione  di  una  s-espressione  ne  produce  un  altra
seguendo un algoritmo ben preciso.

Con   l'insieme  delle  s-espressioni  e  la  funzione   di
valutazione  si  costruisce ( in  teoria  )  un  linguaggio
puramente  funzionale,  cio  il  nostro  algoritmo    una
funzione che applicata ai parametri di ingresso :

   ( funzione + parametri = s-espressione nella forma (
     FUNZIONE PARAMETRO1 PARAMETRO2 .. PARAMETRON ) )
                             
produce il risultato, senza provocare effetti laterali.
Gli  effetti  laterali  sono degli  effetti  ulteriori  che
esulano  dal risultato in se della funzione. Ad esempio  la
funzione  SETF restituisce una s-espressione ma lega  anche
un nome di atomo ad un valore, mentre la funzione + ( somma
)  "pura" dato che produce un risultato e nulla pi.
Pi  esattamente  si chiamano funzioni solo  quelle  "pure"
mentre  le altre, tipo la SETF, si chiamano procedure.  Nel
manuale si user sempre ( a volte impropriamente, ma    la
dizione corrente ) la parola "funzione".
Per valutare una funzione si usa la forma seguente:
( NOME-FUNZIONE PARAMETRO1 .. PARAMETROn )
Prima  si  valutano tutti i parametri e poi li  si  passano
alla funzione e si restituisce il risultato.
Questo   modo   di   procedere    detto  prefisso   perch
l'operatore (funzione) precede gli operandi.
Esempio:
Si vuole calcolare  1 + 2 * 5, innanzitutto si calcola 2  *
5  che  con  la notazione Lisp diventa ( *  2  5  )   (  La
funzione *  applicata agli operandi 2 e 5 ) quest'ultima 
una  s-espressione  che  pu benissimo  essere  usata  come
parametro per una nuova funzione in questo caso + .
Digitando  (  +  1  ( * 2 5 ) ) la valutazione  procede  in
questo modo:
prima  si  focalizza  la funzione +, poi  si  valutano  gli
argomenti; 1 viene valutato in se stesso, ( * 2 5  )  viene
valutato  in 10, poi si applicano i parametri 1 e  10  alla
funzione + che restituisce il risultato cio 11.
Ovunque  nel manuale si user la notazione E(s-espressione)
per indicare la valutazione di una s-espressione

Esempio:
E( (+ 3 2) )  equivale a 5
Esempio:
E(  (SETF  CINQUE 5) ) equivale a 5 dato che  SETF  ritorna
l'ultimo parametro per come effetto laterale lega il  nome
CINQUE al valore 5, quindi se successivamente si valuta  il
nome CINQUE si otterr il valore 5.



1.3.1     Algoritmo di valutazione
La  valutazione  effettuata da Graphic  Lisp  segue  questo
algoritmo:

1.  Se  la  s-espressione in ingresso  un atomo  -  valore
allora la ritorna
    Esempio:
        E( 1 ) = 1
    
2.  Se  la  s-espressione in ingresso  un simbolo  atomico
allora controlla
    se  ha un legame valore: se lo trova allora ritorna  la
    s-espressione   legata   al  legame-valore   altrimenti
    genera un messaggio di errore.
    Esempio:
         Se  preventivamente si  valutata la s-espressione
    (SETF UNO 1)
        allora E( UNO )  = 1
    Esempio:
        E( NON-DEF )   ERRORE: Unbound atom NON-DEF
         Significa che l'atomo NON-DEF non ha alcun legame-
    valore.
    
3.  Se la s-espressione in ingresso  un CONS allora valuta
la parte sinistra
    e  si  controlla che questo risultato abbia  un  legame
    funzionale.  Poi  si valuta la funzione  passandole  la
    lista  dei parametri attuali trovata nella parte destra
    del  CONS, il risultato restituito dalla funzione  sar
    il risultato della valutazione.
    I  parametri  attuali vengono preventivamente  valutati
    per i seguenti tipi di funzioni:
     Funzioni utente ( LAMBDA e DEFUN )
     Metodi utente ( DEFMETHOD )
    Non  vengono, invece, valutati per i seguenti  tipi  di
    funzioni:
     Funzioni di sistema (ad.es CAR e CDR )
     Accessori di membri di classe
     Macro utente ( DEFMCARO )

1.4

 Legami di un simbolo atomico e funzioni
Un simbolo atomico ha quattro legami:
1.  Legame valore globale
2.  Legame funzionale
3.  Legame lista di propriet
4.  Legame definizione di classe
Questi 4 legami possono coesistere contemporaneamente ed  i
primi 3 possono essere recuperati con le seguenti funzioni:
1.  EVAL o valutazione normale
2.  FUNCTION
3.  PLIST
Il   legame   di   classe   non   pu   essere   recuperato
esplicitamente ma viene utilizzato dalle funzioni  DEFCLASS
e MAKE-INSTANCE.
Il legame funzionale  quello controllato dalla valutazione
della  parte  sinistra di un CONS e dovrebbe contenere  una
funzione.   Pu,  comunque,  contenere  una   s-espressione
qualunque.  In  questo caso l'algoritmo di valutazione  non
trova una funzione e genera un errore.

                         *   *   *
                             
La funzione SETF serve per instaurare i legami ed a seconda
dei casi viene utilizzata cos:
1.  ( SETF SIMBOLO `VALORE )
2.   ( SETF ( FUNCTION SIMBOLO ) ( FUNCTION ( LAMBDA ( ...)
 ... ) ) )
3.  ( SETF ( PLIST SIMBOLO ) `LISTA )
Il  primo  argomento di SETF recupera il legame  mentre  il
secondo specifica cosa legare.
Il  legame  funzionale   instaurato anche  dalle  funzioni
DEFUN, DEFMACRO, DEFMETHOD, DEFCLASS.
   ( DEFUN        SIMBOLO ( ... ) ... )
   ( DEFMACRO SIMBOLO ( ... ) ... )
   ( DEFMETHODSIMBOLO ( ... ) ... )
    (  DEFCLASS ( ... ) ( ( NOME :ACCESSOR SIMBOLO  ...  )
 ... ) )

Si  pu  notare  che  una DEFUN o una LAMBDA  ritornano  un
messaggio del genere:
                  <#Anonymous node xxxx>
                             
Questo    un  simbolo atomico senza  nome,    uno  strano
oggetto  introdotto  per uniformit di funzionamento  (  si
veda anche il manuale tecnico ).
Confrontando  le  valutazioni  di  due  s-espressioni   del
genere:
               ( (LAMBDA ( ... ) ... ) ... )
                     ( FUNZIONE ... )
E tenendo presente che si valuta la parte sinistra di un
CONS per vedere se ha un legame funzionale allora
l'algoritmo di valutazione nel primo caso, valutando la
LAMBDA, si trova con un simbolo atomico anonimo che ha un
legame funzionale mentre nel secondo caso si accorge di
avere gi un simbolo atomico e ne recupera immediatamente
il legame funzionale.
Dunque la LAMBDA non ritorna una funzione, ma bens un
simbolo atomico con attaccata la funzione. Per poterla
recuperare si deve utilizzare la funzione FUNCTION come in
questo caso.

             ( FUNCTION ( LAMBDA ( V ) `V ) )
                             
L'interprete stamper il contenuto della vera e propria
funzione utente:

 #<Lexical Closure par:( V ) type:( NIL ) opt:NIL rest:NIL
          key:NIL aux:NIL sex:((QUOTE V)) env:NIL

Il significato dei vari campi stampati  il seguente:
1.  par:  Lista dei parametri formali.
2.  type: Lista delle classi dei parametri formali ( se
 specificate ).
3.  opt:Lista di coppie puntate (nome.valore) dei
parametri &OPTIONAL.
4.  rest:    Simbolo atomico del parametro &REST.
5.  key:Lista di coppie puntate ( nome . valore)  dei
parametri &KEY.
6.  aux:Lista di coppie puntate ( nome . valore)  dei
parametri &AUX.
7.  sex:S-espressioni della LAMBDA.
8.  env:  Environment locale incapsulato sotto forma di A-
 lista ovvero lista di coppie puntate (nome . valore ).

Dato  che  si  pu recuperare la funzione definita  da  una
LAMBDA  la  si  pu collegare ad un simbolo  atomico  senza
utilizzare la DEFUN:

                  ( DEFUN FOO ( V ) `V )
               perfettamente equivalente a:
 ( SETF ( FUNCTION FOO ) ( FUNCTION ( LAMBDA ( V ) `V ) )

Per concludere dico che la s-espressione (FUNCTION s-
espressione)  abbreviabile con #'s-espressione
analogamente alla (QUOTE s-espressione) abbreviabile con `s-
espressione. L'esempio sopra  dunque riscrivibile cos:

           ( SETF #'FOO #'( LAMBDA ( V ) `V ) )
                             

1.5

 Variabili globali, locali e speciali
Quando  si  valuta una funzione utente, cio  una  funzione
definita   con  DEFUN,  DEFMACRO  o  DEFMETHOD,  allora   i
parametri  formali vengono collegati agli  attuali  tramite
uno stack interno in modo da permettere la ricorsione.

Esempio:
(DEFUN FATT ( I ) ( IF ( =0 I ) 1 ( * ( FATT (- I 1 ) ) I )
) )
Se la variabile I non fosse messa sullo stack allora questa
funzione non potrebbe funzionare correttamente.

Le  variabili come I, nell'esempio precedente,  sono  dette
locali  poich  sono  visibili  esclusivamente  all'interno
della funzione che le ha dichiarate.

Esempio:
( DEFUN F1 ( V1 ) ( PRINT V1 ) ( F2 10 ) )
( DEFUN F2 ( V2 ) ( PRINT V1 V2 ) )
( F1 20 )
Risultato: Stampa il numero 20 e poi d un errore:  unbound
atom V1.

 successo che si  tentato di accedere alla variabile V1 la
quale non  dichiarata all'interno di V2.

Se si vuole che una variabile, pur rimanendo sullo stack si
comporti  in  questo modo speciale, cio che, nell'esempio,
V1 sia visibile anche da F2, allora bisogna dichiararla con
DEFVAR all'esterno di qualunque funzione.
Se  prima  si  digita ( DEFVAR V1 ) e poi si  procede  come
nell'esempio  allora non si avr pi  l'errore,  V1  ora  
detta variabile speciale.

Tutte  le  variabili  locali ( ma  non  quelle  speciali  )
rimangono  incapsulate nelle funzioni utente.  La  funzione
cos ottenuta  detta chiusura lessicale.

Esempio:
(
  ( LAMBDA ( CONTATORE )
     ( DEFUN CONTA ( ) ( SETF CONTATORE (+ 1 CONTATORE )  )
)
  )
 0
)
Ora ogni volta che si chiama la funzione CONTA il risultato
sar un intero che incrementa sempre:
(CONTA) Ritorna 1
(CONTA) Ritorna 2
(CONTA) Ritorna 3
ecc.
La variabile CONTATORE rimane incapsulata all'interno della
funzione CONTA e non sar pi visibile altrove.

Le  funzioni  di assegnamento SETF, SETQ, SET collegano  la
variabile in modo coerente con la sua definizione:
    Se  una variabile  locale allora SETx ne modifica  il
 legame locale.
    Se una variabile  speciale allora SETx ne modifica il
 legame speciale.
   Altrimenti SETx crea una variabile globale (o
statica).
Se  una  variabile legata con SETF non  locale ne speciale
allora  diventa una variabile globale visibile  all'interno
di tutte le funzioni.
Il  legame globale  pensabile come statico, ovvero  se  si
dichiara  una  funzione  con un parametro  formale  con  un
legame globale allora questo legame copre quello locale ( o
quello  speciale  )  e la variabile non viene  messa  sullo
stack.


Esempio:
( SETF GLOBALE 10 )
La variabile GLOBALE  una variabile statica (o globale).

Esempio:
( SETF I 0 )
(  DEFUN FATT ( I ) ( IF ( =0 I ) 1 ( * ( FATT (- I 1 ) ) I
) ) )
La   funzione  FATT  non  procede  correttamente  dato  che
all'uscita  di  essa il valore di I non viene  riportato  a
quello  della  chiamata precedente.  In  questo  caso  FATT
ritorna sempre 0.

1.6

 Macro
Le  macro  si  definiscono con DEFMACRO e si  differenziano
dalle normali forme lambda per due motivi:
1.  I parametri attuali non vengono valutati
2.   L'ambiente locale del chiamante  visibile all'interno
 della macro.
Che implicano queste due caratteristiche:
1.   possibile implementare delle forme speciali
2.   Una  macro agisce come una vera e propria sostituzione
 lessicale.
Le  forme  speciali sono delle funzioni  che  non  valutano
necessariamente  tutti  i  loro argomenti.  Ad  esempio  la
funzione  QUOTE  non  valuta  il  suo  argomento  e  non  
possibile  implementarla con DEFUN o LAMBDA. Con una  macro
il problema lo si risolve cos:

              ( DEFMACRO NEW-QUOTE ( V )  V )

Una macro  utilizzabile come una sostituzione lessicale.
Esempio:
    ( DEFMACRO INCVAR ( ) ( SETF VAR ( + 1 VAR ) ) )
    ( DEFUN PLUSONE ( VAR ) ( INCVAR ) )
    
    La macro INCVAR "vede" anche la variabile locale della
    funzione PLUSONE.

1.7

 Tipi di nodi
Come  gi visto le s-espressioni si dividono in vari  tipi,
questo  interprete rappresenta qualunque s-espressione  con
un oggetto chiamato nodo.
Esistono tre tipi di nodi:
   Nodi con nome o simboli atomici
   Nodi CONS
   Nodi valore o atomi valore
Il loro tipo pu essere controllato con opportuni predicati
elencati nel prossimo capitolo.


1.7.1     Nodi con nome o simboli atomici
Possono avere fino a 4 legami contemporaneamente:
1.  Legame  valore  che viene prelevato  dalla  valutazione
normale  del  simbolo atomico e pu essere  instaurato  con
SETF.

Esempio:
(SETF A 'VALORE)
Il  nome  A viene valutato ritornando un puntatore  al  suo
legame valore e SETF lo lega all'atomo VALORE

2.  Legame  funzionale che viene prelevato  dalla  funzione
FUNCTION e pu essere legato con SETF oltre che con DEFUN.
La s-espressione (FUNCTION sx) pu essere abbreviata con la
macro #'sx.

Esempio:
(SETF (FUNCTION A) (LAMBDA (V)(PRINT V)))  equivalente a
(SETF #'A (LAMBDA(V)(PRINT V)))  equivalente a
(DEFUN A (V)(PRINT V))
3.  Legame  lista  di propriet che viene  prelevato  dalla
funzione PLIST e pu essere legato con SETF .

Esempio:
(SETF (PLIST A) '((p1 . v1)(p2 . v2)))
  cos  possibile scrivere delle funzioni in stile  Common
Lisp che usano la lista di propriet di un nodo.

4.  Legame classe che viene legato dalla funzione DEFCLASS,
e  non pu essere prelevato direttamente, ovvero quando una
classe    stata  definita non pu  pi  essere  distrutta.
Questo per preservare la gerarchia tra le classi.

Esempio:
(DEFCLASS A ( )(( FIELD1 :ACCESSOR CAMPO1 :INITFORM 'C1)))

I  4  legami  possono  coesistere insieme,  se  ad  esempio
all'atomo A sono state legate le s-espressioni degli esempi
sopra  allora  si potr usare A come atomo, come  funzione,
come classe ed usare la sua lista di propriet.

1.7.2     Nodi CONS
Sono  le  classiche  coppie puntate del  Lisp  che  possono
essere  combinate in liste. Pi esattamente un nodo CONS  
un nodo con due legami ad altrettanti nodi.
Per  introdurre  direttamente un CONS si  usa  la  sintassi
seguente:
             ( s-espressione . s-espressione )
Una  lista    identificata da un CONS dentro  l'altro,  ad
esempio digitando
'( A . ( B . ( C . D ) ) )
L'interprete stampa
(A B C . D)
Cio  quando stampa associa il pi possibile i CONS in  una
lista.
                             
La  valutazione di un CONS procede controllando se la parte
sinistra    legata ad una funzione, se   cos  allora  la
applica alla parte destra.

1.7.3     Nodi valore
Sono  nodi  (o  s-espressioni) che vengono valutati  in  se
stessi, ad esempio valutando 1 si avr sempre 1.
Questi nodi sono sottotipizzati in 13 modi differenti:
1.   Interi
2.   Reali
3.   Razionali
4.   Stringhe
5.   Stream
6.   Funzioni di sistema
7.   Accessori ( di membri di una classe )
8.   Funzioni utente
9.   Metodi utente
10.  Macro utente
11.  Istanze di classi
12.  &Nodi ( nodi preceduti da & )
13.  :Nodi ( nodi preceduti da : )

1.7.3.1   Interi
Sintassi:
    [+ | -]? [0-9]+

Esempi:
    1 ; +1 ; -1 ; 0345 ; -02

Per  maggiori  dettagli si veda il paragrafo relativo  alle
funzioni matematiche.

1.7.3.2   Reali
Sintassi:
    real1        [+ | -]? [0 - 9]* "." [0-9]+
     real2         [+ | -]? [0 - 9]* "." [0 - 9]+  [Ee]  [+
| -]? [0-9]+
     real3         [+  | -]? [0 - 9]+ [Ee] [+ |  -]?  [0  -
9]+
    real    real1 | real2 | real3

Esempi:
     .1  ;  0.1  ; +.1 ; +3.1e4 ; 1E2 ; 1E+2  ;  1E-2  ;  -
3.1415926e-23

Per  maggiori  dettagli si veda il paragrafo relativo  alle
funzioni matematiche.

1.7.3.3   Razionali
Sintassi:
    Non sono introducibili direttamente.

Vengono  generati dalla funzione / (diviso)  con  argomenti
interi,  ad  esempio  (/ 2 3) ritorna  2/3,  questi  numeri
possono  essere  usati  da tutte le  funzioni  matematiche,
possono  essere  convertiti con le funzioni  ROUND,  FLOAT,
REM.
Per  maggiori  dettagli si veda il paragrafo relativo  alle
funzioni matematiche.

1.7.3.4   Stringhe
Sintassi:
     Una  stringa  pu contenere ogni carattere  tranne  il
newline o gli apici
     a  meno che gli apici non siano preceduti dallo  slash
inverso '\'.

Esempi:
    "aaa" ; "asdf" ; "Stringa" ; "\"Apici\""

Per  maggiori  dettagli si veda il paragrafo relativo  alle
funzioni di stringa.

1.7.3.5   Stream
Sintassi:
    Non sono introducibili direttamente.

Vengono   restituiti   dalla   funzione   (FOPEN   nomefile
attributi)  e  sono utilizzabili da tutte  le  funzioni  di
lettura - scrittura su file.
Attenzione  a non buttare via un handle di un file  aperto:
ad  esempio  digitando solamente (FOPEN "mio.fil"  "w")  si
apre il file ma si butta via l'handle ritornato dalla open,
dunque  bisogna  sempre usare la open  all'interno  di  una
SETF: (SETF MIO (OPEN "mio.fil" "w")).
Esistono anche dei file predefiniti:
   STDIN rappresenta la tastiera
   STDOUTrappresenta lo schermo
   STDPRNrappresenta la stampante
    STDERRrappresenta il dispositivo standard  di  errore,
 solitamente lo schermo.

Per  maggiori  dettagli si veda il paragrafo relativo  alle
funzioni di File I / O .

1.7.3.6   Funzioni di sistema
Sintassi:
    Non sono introducibili direttamente

Vengono restituite dalla funzione FUNCTION applicata ad una
funzione predefinita

Esempio:
    ( FUNCTION CAR )



1.7.3.7   Accessori
Sintassi:
    Non sono introducibili direttamente

Vengono restituite dalla funzione FUNCTION applicata ad  un
accessore definito dalla funzione DEFCLASS.

Esempio:
    ( DEFCLASS PROVA ( ) ( ( C1 :ACCESSOR ACCESSORE ) )
    ( FUNCTION ACCESSORE )

1.7.3.8   Funzioni utente
Sintassi:
    Non sono introducibili direttamente

Vengono restituite dalla funzione FUNCTION applicata ad una
funzione definita dall'utente

Esempio:
    ( FUNCTION (DEFUN PROVA ( ) NIL ) )

1.7.3.9   Metodi utente
Sintassi:
    Non sono introducibili direttamente

Vengono restituite dalla funzione FUNCTION applicata ad  un
metodo definito dall'utente

Esempio:
    ( FUNCTION (DEFMETHOD PROVA ( ) NIL ) )

1.7.3.10  Macro utente
Sintassi:
    Non sono introducibili direttamente

Vengono restituite dalla funzione FUNCTION applicata ad una
macro definita dall'utente

Esempio:
    ( FUNCTION (DEFMACRO PROVA ( ) NIL ) )


1.7.3.11  Istanze di classi
Sintassi:
    Non sono introducibili direttamente

Vengono ritornate dalla (MAKE-INSTANCE nomeclasse)  e  sono
utilizzabili sia come parametri attuali di un  metodo,  sia
usate con un accessore generato da DEFCLASS.

Esempio:
    ( DEFCLASS PROVA ( ) ( ( C1 :ACCESSOR ACCESSORE ) )
    ( MAKE-INSTANCE PROVA )

1.7.3.12  Nodi duepunti (:)
Sintassi:
    :s-espressione

Esempio:
    :(ATOM) Ritorna :(ATOM)

1.7.3.13  Nodi &
Sintassi:
    &s-espressione

Esempio:
    &(ATOM) Ritorna &(ATOM)




2.   Funzioni di Graphic Lisp





Le   varie  funzioni  incorporate  da  Graphic  Lisp   sono
idealmente divise nelle seguenti classi:
   Funzioni Standard
   Funzioni di Sistema
   Funzioni matematiche
   Predicati
   Funzioni di Stringa
   Funzioni di File I/O
   Funzioni Grafiche
Queste funzioni vengono spiegate nei prossimi paragrafi  ed
elencate  nella seconda parte del manuale dove si trova  un
riferimento completo con la sintassi, il valore ritornato e
gli eventuali effetti laterali.
Le  convenzioni  sintattiche utilizzate  sono  le  seguenti
(espressioni regolari):
   { }   Raggruppamento
   ?       Zero o una occorrenza
   +       Una o pi occorrenze
   *       Zero o pi occorrenze
   |       Una delle occorrenze ai lati del
metasimbolo.



Esempi:
(EQUAL sx1 {sxi}*) pu essere espansa in questi modi:
(EQUAL sx1 sx2) , (EQUAL sx1 sx2 sx3) , (EQUAL sx1 sx2  sx3
sx4 ) , ecc ...

(LET  (  { sxn | (sxn sxv) }* ) {sxi}* ) pu essere espansa
in questi modi:
(LET  () ) , (LET (A) A) , (LET ( (A 10) B (C "c") ) (PRINT
A B) C) , ecc ...

(- {sxi}+) pu essere espansa in questi modi:
(- 3) , (- a b) , (- 2 a c) , ecc ...

Inoltre  si  usa la forma E(sx) per indicare la valutazione
di sx.
Esempio:
E( (CONS A B) ) = (A . B)

2.1

 Funzioni standard
Sono  quelle  classiche del Common Lisp  e  ne  seguono  la
sintassi.  Qui  sotto  vengono  elencate  le  funzioni  pi
complesse,  mentre  per  quelle pi semplici  rimando  alla
sezione  finale del manuale dove verranno elencate  con  la
sintassi ed il valore restituito.

2.1.1     Funzioni LAMBDA, DEFUN, DEFMACRO
La  funzione LAMBDA ha una sintassi molto particolare  dato
che  possibile dichiarare funzioni con un numero variabile
di  argomenti  e  mettere  anche  delle  chiavi  per  poter
inizializzare delle variabili usando il loro nome.
La  lista dei parametri di una LAMBDA pu contenere  questi
campi:
               &OPTIONAL, &REST, &KEY, &AUX.
                             
                         *   *   *
                             
NOTA:   Tutto  ci  che  riguarda  la  funzione  Lambda   
applicabile di riflesso anche alle DEFUN e DEFMACRO.
Scrivendo: (DEFUN FUN (A &REST B) (PRINT A " " B "\n"))  si
ha  lo  stesso effetto di  (SETF #'FUN (LAMBDA (A &REST  B)
(PRINT A " " B "\n"))).
Una  MACRO, a differenza di una forma LAMBDA, non valuta  i
parametri  attuali  permettendo di  implementare  le  forme
speciali.

                         *   *   *
                             
Con  Optional  si  specificano dei nomi  di  variabile  che
possono  o  meno  essere passate alla  Lambda,  inoltre  si
possono specificare anche i valori di default.
Esempio:
(DEFUN  FUN  (&OPTIONAL  A (B 3)) ...  )  la  funzione  FUN
accetta 0 o 1 o 2 parametri, la variabile A  inizializzata
con NIL, la variabile B con 3.
Chiamando (FUN 'UNO) i legami sono A - UNO  e  B - 3.

Con  Rest si specifica una variabile che conterr la  lista
di  tutte quei parametri attuali che non si sono legati  ai
nomi di variabile.
Esempio:
(DEFUN FUN (A &OPTIONAL B &REST C) ...)
Chiamando (FUN 1 2 3 4 5) si instaureranno questi legami:
 A - 1 B - 2 C - (3 4 5)

Con   Key   si  specificano  delle  variabili  nominalmente
accessibili dalla chiamata di funzione
Esempio:
(DEFUN FUN (A &KEY CHIAVE (ALTRA-CHIAVE 'TRE)) ...)
Chiamando (FUN 1 :CHIAVE 2) i legami saranno A - 1 CHIAVE -
2 ALTRA-CHIAVE - TRE

Con Aux si specificano delle variabili locali alla Lambda
Es: (DEFUN FUN (&AUX (A 1) B (C 3))...)
Chiamando (FUN)
I legami saranno A - 1 B - NIL C - 3.

                         *   *   *
Creando la funzione:
(DEFUN PROVA ( A (&OPTIONAL B (C 200)) (&REST D) (&KEY E (F
300)) (&AUX G ) )
E chiamando
( PROVA 1 2 3 4 5 6 :F 7)
I legami saranno
A - 1 ; B - 2 ; C - 3 ; D - (4 5 6)  ; E - NIL ; F - 7 ; G
- NIL

2.1.2     Funzioni DEFMETHOD, DEFCLASS, MAKE-INSTANCE
DEFMETHOD
Sintassi:
( DEFMETHOD ( { var | ( var class) }* ....) ...  )
La  restante  parte  della dichiarazione    identica  alla
DEFMACRO.
Naturalmente    possibile dichiarare  pi  metodi  con  lo
stesso nome.

DEFCLASS:
Sintassi:
( DEFCLASS NomeClasse  (  {NomeSuper}* )
    ( { (
        NomeCampo    :ACCESSOR NomeAccessore
           { :INITFORM    s-espressione }?
           { :INITARG     NomeInitarg       }?
    ) }+)
)
Crea  una definizione di classe chiamata NomeClasse  con  i
campi   NomeCampo   e   gli  accessori  NomeAccessore.   Le
superclassi  sono le NomeSuper. Se non vengono  specificate
la superclasse usata  quella di default cio T.
Opzionalmente  possibile definire un valore di default per
il  campo utilizzando la :INITFORM ed un identificatore  di
assegnamento  di  valore  :INITARG utilizzato  nella  MAKE-
INSTANCE.

MAKE-INSTANCE:
Sintassi:
(MAKE-INSTANCE NomeClasse { :InitName s-espressione }* )
Crea una istanza di classe NomeClasse. I campi della classe
possono essere aggiornati con gli InitName che sono i  nomi
specificati   nel   campo  :INITFORM  della   DEFCLASS   di
NomeClasse o delle sue superclassi.

2.1.2.1   Esempio di gestione delle classi delle
precedenze e dei metodi
Dato  che  non potrebbe risultare molto chiara la  gestione
delle  classi  e  dei  metodi faccio  questo  esempio  dove
riassumo  le  caratteristiche  dell'implementazione   delle
classi di Graphic Lisp1.

                         *   *   *
                             
Creiamo 4 definizioni di classi con le seguenti precedenze:

                             
       Figura 2-1 : Esempio di precedenze fra Classi

( DEFCLASS  A ( )      ( ( VA :ACCESSOR VA-AC ) ) )
Restituisce la lista  ( ( T ) ( NIL ) ( NIL ) ) che indica,
rispettivamente,  le  superclassi,  gli  initforms  e   gli
initargs.
( DEFCLASS  B ( A )( ( VB :ACCESSOR VB-AC ) ) )
Restituisce la lista    (  ( A ) ( NIL ) ( NIL )  )
( DEFCLASS  C ( A )( ( VC :ACCESSOR VC-AC ) ) )
Restituisce la lista    (  ( A ) ( NIL ) ( NIL )  )
( DEFCLASS  D ( B C )   ( ( VD :ACCESSOR VD-AC ) ) )
Restituisce la lista    (  ( B C ) ( NIL ) ( NIL )  )
Le  liste restituite non hanno alcuna importanza operativa,
servono solo per verificare cosa viene messo dentro ad  una
dichiarazione di classe. NB: queste liste non devono essere
modificate.
NOTA:  In  Common Lisp non  possibile creare delle  classi
che ereditino 2 istanze di una medesima classe. Ad esempio:

                             
      Figura 2-2 : Precedenze non consentite in Lisp

Questo  albero  delle precedenze , invece,  consentito  da
altri  linguaggi ad esempio il C++. Paragonando il Lisp  al
C++  si  pu dire che tutte le ereditariet nel  Lisp  sono
virtual.
                         *   *   *
                             
Ora creiamo 4 istanze di queste classi:
( SETF A-IST ( MAKE-INSTANCE A ) )
Restituisce la classe #< Class  :( ( A T ) )  ( NIL )  )  >
Le due liste rappresentano, rispettivamente, la lista delle
precedenze  della classe e la lista dei valori  dei  membri
della classe.
( SETF B-IST ( MAKE-INSTANCE B ) )
Restituisce #< Class  :( ( B A T ) )  ( NIL ) ( NIL )  )  >
Ha  due liste di membri dato che il primo  ereditato dalla
classe A
( SETF C-IST ( MAKE-INSTANCE C ) )
Restituisce #< Class  :( ( C A T ) )  ( NIL ) ( NIL ) ) >
( SETF D-IST ( MAKE-INSTANCE D ) )
Restituisce #< Class  :( ( D B C A T ) )  ( NIL ) ( NIL ) (
NIL  )  ( NIL ) ) > La prima lista rappresenta la lista  di
precedenze della classe D mentre le quattro liste  seguenti
rappresentano i membri delle varie classi interessate.
La lista delle precedenze  costruita con l'algoritmo Up to
Join  Left  to  Right2 che, semplicemente, scorre  l'albero
dalla  foglia  - classe fino alla foglia  -  T  e  ad  ogni
ereditariet  multipla  aggiunge le  classi  incontrate  da
sinistra a destra insieme alla loro lista di precedenze. Al
termine  del  processo si collassano fra loro  i  pezzi  di
lista delle precedenze comuni.

                         *   *   *
                             
Ora possiamo assegnare alcuni valori ai membri delle classi
utilizzando gli accessori di membro di classe.
( SETF ( VA-AC A-IST ) 1 )
( SETF ( VA-AC B-IST ) 2 )
( SETF ( VA-AC C-IST ) 3 )
( SETF ( VA-AC D-IST ) 4 )
( SETF ( VB-AC D-IST ) 5 )
( SETF ( VC-AC D-IST ) 6 )
Richiamando la istanza di classe D, ovvero valutando il
simbolo D-IST, otteniamo la seguente risposta:
#< Class  :( ( D B C A T ) )  ( NIL ) ( 6 ) ( 5 ) ( 4 ) ) >
Che ci indica i valori contenuti nei campi della classe.
Analogamente richiamando, rispettivamente, le istanze A-IST
B-IST C-IST otteniamo:
             #< Class  :( ( A T ) )  ( 1 ) ) >
        #< Class  :( ( B A T ) )  ( NIL ) ( 2 ) ) >
        #< Class  :( ( C A T ) )  ( NIL ) ( 3 ) ) >
                             
                         *   *   *


Scriviamo alcuni metodi per osservare come vengono scelti
in base alle classi dei parametri attuali:
1.  ( DEFMETHOD PROVA ( V1 V2 )            ( PRINT "
 NIL NIL \n" ) )
2.  ( DEFMETHOD PROVA ( ( V1 A ) V2 )       ( PRINT " A
 NIL \n" ) )
3.  ( DEFMETHOD PROVA ( ( V1 A ) ( V2 B ) )  ( PRINT " A
 B  \n" ) )
4.  ( DEFMETHOD PROVA ( ( V1 C ) ( V2 D ) )  ( PRINT " C
 D \n" ) )
5.  ( DEFMETHOD PROVA ( ( V1 D ) ( V2 D ) )  ( PRINT " D
 D \n" ) )

Il metodo PROVA  composto da 4 funzioni distinte. Quale di
queste funzioni verr chiamata?

( PROVA 2 3 )
Stampa NIL NIL
 stato chiamato il metodo 1 dato che i parametri attuali
non sono delle classi.

( PROVA A-IST A-IST )
Stampa A NIL.
La prima classe, A-IST, ha selezionato i metodi 1 2 3
mentre i metodi 4 5 non sono compatibili con il primo
parametro attuale dato che la classe A non contiene le
classi C e D ovvero C e/o D non sono superclassi, e nemmeno
coincidono, con A.
La seconda classe, sempre A-IST, non pu essere associata
alla classe B dato che non  una sua superclasse e nemmeno
coincide con essa. Dunque il metodo 3 non  utilizzabile e
viene scartato dall'algoritmo.
Rimangono i metodi 1 2 : viene scelto il secondo dato che 
il pi aderente alle istanze di classe attuali.

( PROVA D-IST C-IST )
Stampa A NIL.
La prima classe seleziona tutti i metodi.
La seconda classe  associabile ai metodi 1 2.
Viene scelto il secondo dato che  il pi aderente alle
istanze di classe attuali.

( PROVA C-IST B-IST )
Stampa A B
La prima classe seleziona i metodi 1 2 3 4.
La seconda classe seleziona i metodi 1 2 3.
Viene scelto il terzo dato che  il pi aderente alle
istanze di classe attuali.

                         *   *   *
L'algoritmo di scelta del metodo pi corretto segue,
dunque, questi passi:
1.  Per ogni classe attuale crea l'insieme dei metodi
 applicabili in funzione delle classi formali.
2.  Crea l'intersezione di tutti gli insiemi. Se  vuota
 genera un errore. Se  composta da un solo elemento chiama
 il metodo corrispondente. Se  composta da pi elementi
 allora :
3.  Per ogni classe attuale, partendo da sinistra cio
 dalla prima, seleziona i metodi con la classi formali pi
 vicina, nella precedenza, alla classe attuale. Se si
 seleziona un solo metodo allora lo applica altrimenti
 utilizza la prossima coppia classe attuale - classe formale
 e cos via.
4.  Se rimangono ancora due o pi metodi allora genera un
 errore di ambiguit.
L'errore di ambiguit avviene se si definiscono ad  esempio
due metodi con la stessa lista di parametri formali:
( DEFMETHOD A ( ) `A1)
( DEFMETHOD A ( ) `A2)
( A ) Genera un errore.

2.1.3

 Funzioni DO e DO*
Servono per costruire dei cicli.

DO
Sintassi:
(DO ( {(Nome Valore Incremento)}* ) (Condizione Ritorno) {s-
espressioni}* )
Innanzitutto si inizializzano tutte le variabili  Nome  con
Valore,  poi  si  controlla se  Condizione    falsa  e  si
eseguono  tutte  le  s-espressioni, poi si  assegnano  alle
variabili  Nome  i  valori  Incremento  si  ricontrolla  la
condizione e cos via finch la condizione  vera.
A  questo punto si valuta Ritorno e lo si restituisce  come
risultato.
Se  le variabili non sono globali ne speciali allora DO  le
mette automaticamente nell'ambiente locale.
Esempio:
(DO
   ( ( I 0 (1+ I) ) ( J '(A B C) (CDR J) ) )
   ( (NULL J) 'FINITO)
   (PRINT "I=" I " J=" J "\n")
)
Si otterr
I=0 J=(A B C)
I=1 J=(B C)
I=2 J=(C)
FINITO

La  funzione  DO*  identica solo che valuta le espressioni
di  inizializzazione considerando anche le variabili locali
appena inizializzate.
Se si tenta di usare (DO ( (I 0 (+1 I)) (J I (1+ I))) ... )
si  ottiene un messaggio di errore dato che la variabile  I
non esiste al momento di inizializzare J, se si fosse usato
DO* allora la variabile I si sarebbe vista e non si avrebbe
il messaggio di errore.
Una  (RETURN s-espressione) rompe la sequenza valutativa  e
causa la restituzione di E(s-espressione).

2.1.4     Funzioni DOLIST E DOTIMES
Servono  per  costruire un ciclo con un contatore  numerico
(DOTIMES) o un contatore che preleva i propri valori da una
lista (DOTIMES).

DOLIST
Sintassi:
(DOLIST ( Nome Lista {Ritorno}?) {sxi}*)
Si inizializza Nome con il CAR di Lista e si valutano tutte
le sxi, poi si assegna a Nome il prossimo elemento di Lista
e  si  rivalutano  tutte le sxi, e  cosi'  via  finch  non
finisce  Lista,  poi si ritorna E(Ritorno)  oppure  NIL  se
Ritorno non  specificato.
Nome  automaticamente aggiunto all'ambiente locale se  non
 gi definito.
Una  (RETURN s-espressione) rompe la sequenza valutativa  e
causa la restituzione di E(s-espressione).

DOTIMES
Sintassi:
(DOTIMES ( Nome Valore {Ritorno}?) {sxi}*)
Si  inizializza Nome con 0 e si valutano tutte le sxi,  poi
si incrementa Nome e si rivalutano tutte le sxi, e cos via
finch  Nome<>Valore, poi si ritorna E(Ritorno) oppure  NIL
se Ritorno non  specificato.
Nome  automaticamente aggiunto all'ambiente locale se  non
 gi definito.
Una  (RETURN s-espressione) rompe la sequenza valutativa  e
causa la restituzione di E(s-espressione).

2.1.5     Funzioni LET, PROG, PROG1, e PROGN
Servono  per  la valutazione di una serie di s-espressioni,
LET aggiunge anche delle variabili all'environment locale.

LET
Sintassi:
(LET ( {(Nome Valore)}* ) {s-espressioni}* )
Si inizializzano le variabili Nome con i valori Valore e si
valutano   tutte  le  s-espressioni  restituendo   l'ultima
incontrata.
Se  le variabili non sono globali ne speciali allora LET le
mette automaticamente nell'ambiente locale.

PROG1
Sintassi:
(PROG1 {s-espressioni}* )
Si  eseguono  le  s-espressioni in sequenza restituendo  il
valore  della  prima. Una (RETURN s-espressione)  rompe  la
sequenza  valutativa  e  causa  la  restituzione  di   E(s-
espressione).

PROGN
Sintassi:
(PROGN {s-espressioni}* )
Si  eseguono  le  s-espressioni in sequenza restituendo  il
valore  dell'ultima.  Una (RETURN s-espressione)  rompe  la
sequenza  valutativa  e  causa  la  restituzione  di   E(s-
espressione).
PROG
Sintassi:
(PROG ( {(Nome Valore)}* )  { label | s-espressione }* )
Crea  l'environment formato dalle varie coppie Nome  Valore
esattamente come la LET. Poi valuta in sequenza tutte le s-
espressioni ritornando il valore dell'ultima incontrata.
Se si specifica una label cio un simbolo atomico non verr
valutato  ma utilizzato come etichetta di salto  utilizzata
dalla funzione (GO label).
Una  (RETURN s-espressione) rompe la sequenza valutativa  e
causa la restituzione di E(s-espressione).

2.2

 Funzioni di sistema
Sono specifiche dell'implementazione e della gestione della
memoria  di  Graphic Lisp. Vi sono funzioni  utili  per  il
debugging e funzioni varie.

2.2.1     Debugging

TRACE
Sintassi:
(TRACE Nome)
Attiva  la  traccia  della  funzione  Nome.  Chiamando   la
funzione verranno stampati, oltre al nome, gli argomenti  e
l'environment.

UNTRACE
Sintassi:
(UNTRACE Nome)
Disattiva la traccia della funzione Nome.

STACKTRACE
Sintassi:
(STACKTRACE sx)
Se  E(sx)  non NIL allora attiva la traccia dello stack in
caso  di  errore altrimenti la disattiva. La traccia  dello
stack  mostra  tutte  le  valutazioni  eseguite  fino  alla
condizione di errore.

BREAK
Sintassi:
(BREAK)
Blocca    la   valutazione   permettendo   di   controllare
l'environment locale
Si riparte con (CONTINUE).

2.2.2     Funzioni varie di sistema
GC
Sintassi:
(GC)
Forza  un  garbage  collection  e  stampa  lo  stato  della
memoria.

HASHSTAT
Sintassi:
(HASHSTAT)
Stampa lo stato della Hashtable.

GET-TIME
Sintassi:
(GET-TIME)
Ritorna  un  intero rappresentante l'orologio  del  sistema
espresso in millisecondi.

GET-LENV
Sintassi:
(GET-LENV)
Recupera  l'environment locale. Non bisogna  modificare  la
lista ritornata.

GET-GENV
Sintassi:
(GET-GENV)
Recupera l'environment speciale. Non bisogna modificare  la
lista ritornata.

FIXLIST
Sintassi:
(FIXLIST)
Recupera la lista dei nodi FIX. Vedi il manuale tecnico.

2.3  Funzioni Matematiche e tipi di dato numerici
Vi  sono  ovviamente le +, -, *, /, oltre  a  tutte  quelle
trigonometriche classiche, vi sono anche delle funzioni  di
conversione fra i 3 tipi di numeri: ROUND, FLOAT, REM.
Tutte  le  funzioni  matematiche sono elencate  nell'elenco
alla  fine  del  manuale alla voce "Funzioni  Matematiche".
Tenere presente che gli angoli sono espressi e ritornati in
Radianti.
Un   approfondimento  lo  merita  il   trattamento   e   le
conversioni  dei  tre tipi di dato numerico dell'interprete
ovvero i tipi INTERO, REALE, RAPPORTO.

2.3.1     Il tipo intero
Immettendo  un  numero senza virgola e senza  esponente  si
ottiene un nodo valore di tipo intero.

Esempio:
100
Ritorna 100.

I  limiti per i numeri interi sono quelli del tipo LONG INT
del  compilatore C utilizzato. Per un LONG INT di  32  bit3
l'intervallo :

           [ -2.147.483.648     +2.147.483.647 ]
                             
In generale su N bit l'intervallo 

           [ 2 ^ ( N - 1 )   1 - 2 ^ ( N - 1 ) ]
                             

2.3.2     Il tipo reale
Immettendo un numero con la virgola4 e/o con l'esponente si
ottiene un nodo valore di tipo intero.

Esempio:
100.0
Ritorna 100.000000

I limiti per i numeri reali sono quelli del tipo DOUBLE del
compilatore  C  utilizzato. Per un  DOUBLE  di  64  bit  in
formato IEEE gli intervalli sono:

[ - 2 ^ 1024   - 2 ^ ( - 1022) ]  0 [ + 2 ^ ( - 1022 )   +
                        2 ^ 1024 ]
                             
Corrispondenti a (circa)

[- 1.8 x 10 ^ 308    - 2.23 x 10 ^ ( - 308 ) ]  0  [ + 2.23
           x 10 ^ ( - 308 )   + 1.8 x 10 ^ 308 ]
                             

2.3.3     Il tipo rapporto o razionale
Quando si dividono due o pi numeri interi, se il risultato
non    intero lo si rappresenta con un nuovo tipo di  dato
chiamato Rapporto.
I  limiti del numeratore e del denominatore sono quelli del
tipo intero.

Esempio:
(/ 10 3)
Ritorna 10/3

Questo tipo di dato  un numero a tutti gli effetti  e  pu
essere dato a qualunque funzione matematica.
L'interprete  comunque cercher sempre di riconvertirlo  in
un numero intero non appena  possibile.

Esempio:
(* (/ 10 3) 3) Ritorna 3 (intero)

In  questo modo, se si hanno da eseguire calcoli con numeri
solo  razionali,  si  evita la perdita di  precisione  data
dalla  conversione  in floating-point ottenendo  sempre  un
risultato esatto.

2.3.4     Conversioni di tipo
Chiamando  una  funzione  con  argomenti  tutti  interi  il
risultato sar comunque un intero.

Esempi:
(SQRT 10) Ritorna 3 (intero)
(+ 1 3) Ritorna 4 (intero)

Chiamando  una  funzione con almeno un argomento  reale  il
risultato sar sempre un reale.

Esempi:
(SQRT 10.0) Ritorna 3.3333... (reale)
(+  1  3E0) Ritorna 4.0000... (reale) NB: 3E0  considerato
un reale dato che ha l'esponente.
(+  1.0 (/ 10 3)) Ritorna 4.3333... (reale) NB: il rapporto
10/3 viene convertito in reale.

Chiamando  una  funzione con argomenti tutti  rapporti  ed,
eventualmente,  interi  il risultato  sar  calcolato  come
rapporto,  ma poi si controlla se il risultato  pu  essere
convertito  in un intero, se  cos allora verr restituito
un intero altrimenti un rapporto.

Esempi:
(+ 2 (/ 5 2)) Ritorna 9/2 (rapporto)
(+ 2 (/ 5 2) (/1 2)) Ritorna 5 (intero)

Chiamando una funzione matematica, diversa da + - * / , con
un rapporto il risultato sar reale.

Esempi:
(SQRT (/ 3 4)) Ritorna 0.866025403784439
(SIN (/ 4 3)) Ritorna 0.971937901363313

                         *   *   *

 possibile forzare una conversione di tipo con le funzioni
ROUND e FLOAT.
ROUND converte un reale in un intero troncando i decimali.
FLOAT converte un intero in un reale.

La funzione REM ritorna la parte decimale di un reale.

Esempio:
(REM 2.6) Ritorna 0.6

  cos  possibile costruire una funzione che arrotondi  un
reale in un intero tenendo conto della parte decimale.

(DEFUN ARROTONDA (N) (+ (ROUND N) (IF (< 0.5 (REM N)) 1 0]

O pi semplicemente:

(DEFUN ARROTONDA (N) (ROUND (+ N 0.5))

Volendo   possibile estendere la funzione controllando  la
validit del parametro NUM.

(DEFUN ARROTONDA-EXT (N)
 (COND
    ( (REALP N) (ARROTONDA N) )
    ; controlla se N  un reale

    ( (RATIOP N) (ARROTONDA (FLOAT N)))
    ; controlla se N  un rapporto e convertilo

    ( (INTP N) N)
    ; controlla se N  un intero

    ( T (PRINT 'ERRORE))
 )
)

2.4

 Predicati
I predicati si dividono in due categorie:
   Predicati sul tipo di un nodo
   Predicati Common Lisp
Ritornano  T  o  NIL  a  seconda dell'interpretazione  data
all'argomento.

2.4.1     Predicati di tipo
L'interprete  ha  3 tipi di nodi riconoscibili  con  questi
predicati:
    SYMBOLP     Riconosce  un simbolo  atomico  (nodo  con
 nome).
   CONSP     Riconosce un CONS.
   VALUEP    Riconosce un atomo valore.
Gli  atomi  valore  sono  ulteriormente  sottotipizzati   a
seconda del tipo di dato contenuto che si riconosce  con  i
seguenti predicati:
   INTP      Riconosce un intero.
   REALP     Riconosce un reale.
   RATIOP    Riconosce un rapporto.
   STRINGP        Riconosce una stringa.
     STREAMP      Riconosce  uno  stream  ad.es.  (STREAMP
 STDIN).
   CLASSP    Riconosce una istanza di classe.
    SYSFUNCP    Riconosce una funzione di  sistema  ad.es.
 (SYSFUNCP #'CAR).
     UFUNCP      Riconosce  una  funzione  utente   ad.es.
 (UFUNCP     #'(DEFUN ... )).
    METHODP     Riconosce  un  metodo  ad.es.     (METHODP
 #'(DEFMETHOD ...)).
     MACROPRiconosce  una  macro  utente  ad.es.   (MACROP
 #'(DEFMACRO ...).
   ACCESSORP  Riconosce un accessore di classe.
     CNAMEP      Riconosce  un  nodo  :   ad.es.   (CNAMEP
 :NODO).
   ENAMEP    Riconosce un nodo & ad.es. (ENAMEP :NODO).

2.4.2     Predicati Common Lisp
Li ho divisi in tre gruppi:
   Predicati standard
   Predicati numerici
   Predicati di stringa

2.4.2.1   Predicati standard
     ATOM        Riconosce  un  atomo  ovvero  un  simbolo
 atomico od un atomo valore.
    ENDP       Riconosce la fine di una lista ovvero  NIL.
  identico a NULL.
    EQ             Riconosce  se 2 s-espressioni  sono  lo
 stesso simbolo atomico.
    EQUAL      Riconosce se 2 s-espressioni  sono  uguali.
 Funziona con tutti i tipi di nodo.
     FUNCTIONP   Riconosce  se  la  s-espressione     una
 funzione. Riconosce tutti i 5 tipi di funzioni.
   LISTP     Riconosce una lista od un NIL.
   NULL      Riconosce NIL. Identico a ENDP.
    NUMBERP     Riconosce un numero. Riconosce tutti  i  3
 tipi di numeri.

2.4.2.2   Predicati numerici
     <          Riconosce  se  i  numeri  sono  in  ordine
 crescente.
     >          Riconosce  se  i  numeri  sono  in  ordine
 decrescente.
   =           Riconosce se i numeri sono uguali.
   =0          Riconosce se il numero  uguale a Zero.
   EVENP     Riconosce se un numero intero  pari.
   ODDP      Riconosce se un numero intero  dispari.
   MINUSP    Riconosce se un numero  negativo.
   PLUSP     Riconosce se un numero  positivo.
   ZEROP     Riconosce se un numero  uguale a Zero.

2.4.2.3   Predicati di stringa
     STRING=          Controlla  se  due   stringhe   sono
 uguali.
    STRING-EQUAL    Controlla se due stringhe sono  uguali
 ignorando il "case" ovvero il maiuscolo - minuscolo.

2.5

 Funzioni di Stringa
Le   stringhe  utilizzate  dall'interprete  possono  essere
lunghe da 0 a N caratteri. Il numero N di caratteri massimo
  80  (valore  predefinito) e lo  si  pu  modificare  con
l'opzione sulla linea di comando -Rnnn dove nnn va da  2  a
128.
Per leggere una stringa da tastiera si vedano le READ-LINE,
FSCANF, FINPUT e INPUT.

2.5.1     Caratteri e codici ASCII
Per  creare  una  stringa di 1 carattere di un  particolare
codice ASCII si usa la (STRNUM Intero).
Per  recuperare il codice ASCII del primo carattere di  una
stringa si usa la (STR2ASCII Stringa).
Esempio:
(STRNUM 65) ritorna "A".
(STR2ASCII "ZOIA") ritorna 90 codice ASCII di Z.
Per leggere un tasto si veda la READCHAR.

2.5.2     Concatenazione lunghezza e sottostringhe
Per concatenare pi stringhe si usi la (STRCAT Stringa1 ...
Stringan).
Per  recuperare una sottostringa si usi la (STRSUB  Stringa
Posizione Lunghezza). Posizione > 0 e Lunghezza > 0.
Per  ottenere la lunghezza di una stringa si usi la (STRLEN
Stringa).
Esempio:
(STRUB "ANDREA" 2 3) ritorna "NDR".

2.5.3     Conversione di INTERI, REALI e SIMBOLI ATOMICI
Per  convertire una stringa in un intero si usi la (STR2INT
Stringa Base), non contano eventuali spazi prima e dopo  il
numero, ritorna un INTERO o il simbolo atomico SYNTAX_ERROR
se  il  numero  non   valido, la Base  opzionale  (10  di
default).
Per  convertire una stringa in un reale si usi la (STR2REAL
Stringa),  non  contano eventuali spazi  prima  e  dopo  il
numero,  ritorna un REALE o il simbolo atomico SYNTAX_ERROR
se il numero non  valido.
Per convertire un simbolo atomico in una stringa si usi  la
(NAME2STR Simbolo).
Per convertire una stringa in un simbolo atomico si usi  la
(STR2NAME Stringa). Con questa funzione  possibile  creare
dei generatori di simboli atomici.
Esempio:
(SETF (STR2NAME "Andrea") `VALORE) lega all'atomo Andrea il
valore  VALORE,  si  noti  che il simbolo  Andrea  (con  le
lettere minuscole) non  accessibile da tastiera.
(STR2INT "ff" 16) ritorna 255.

2.5.4     Stringa formattata
Questo interprete non ha una funzione di stampa formattata,
ha  invece una funzione per generare una stringa contenente
i  numeri  formattati. Creata questa stringa  la  si  potr
emettere  sullo  schermo o sulla stampante ottenendo  delle
stampe di buona qualit visiva ed informativa.
La  funzione  che implementa tutto questo   la  (STRPRINTF
Stringa S-espressione1 ... S-espressionen ) che ritorna una
STRINGA.  Il  formato  del parametro  Stringa    piuttosto
complesso essendo identico a quello della printf dell'Ansi-
C.
La  stringa di formato controlla la funzione STRPRINTF  che
converte,  formatta  e  ritorna  una  STRINGA  con  i  suoi
argomenti.
La  stringa  di  formato   una stringa  di  caratteri  che
contiene due tipi di oggetti:
   caratteri comuni;
   specifiche di conversione.
I  caratteri comuni vengono semplicemente copiati cos come
sono nella stringa ritornata.
Le   specifiche  di  conversione  prelevano  gli  argomenti
seguenti e gli applicano la formattazione.

2.5.4.1   Specificatori di formato di STRPRINTF
Nelle stringhe di formato di STRPRINTF gli specificatori di
formato hanno la forma seguente:
      % [flags] [width] [.prec] [F|N|h|l|L] type_char
Ogni  specificatore  di  formato inizia  con  il  carattere
percento  (%).  Dopo  il % vengono i  seguenti  componenti,
nell'ordine:
    Tabella 2-1 : Specificatori di formato di STRPRINTF
Component  Opz./Nec.    Che cosa controlla o specifica.
e
[flags]    (opzionale)  carattere(i)    di    flag      la
                        giustificazione dell'output, segni
                        numerici, punti decimali, zeri non
                        significativi, prefisso ottale  ed
                        esadecimale.
[width]    (opzionale)  specificatore di larghezza  numero
                        minimo  di  caratteri da  stampare
                        allineati con spazi o zeri.
[.prec]    (opzionale)  specificatore    di     precisione
                        massimo  numero  di  caratteri  da
                        stampare;   per  gli  interi,   il
                        numero   minimo   di   cifre    da
                        stampare.
[ l ]      (opzionale)  modificatore  della dimensione  di
                        ingresso   ha la precedenza  sulla
                        dimensione    di    default    del
                        prossimo argomento in ingresso.  l
                        (long int) necessario per il  tipo
                        INTERO.
type_char  (NECESSARIO  carattere di conversione tipo.
           )


2.5.4.2   Caratteri di flag di STRPRINTF [flags]
I    caratteri    di   flag   di   STRPRINTF    specificano
giustificazione di output, segni numerici, punti  decimali,
zeri non significativi e prefissi ottali ed esadecimali.
I  caratteri di flag possono apparire in qualunque ordine e
combinazione.
            Tabella 2-2 : [Flags] di STRPRINTF
[Fla Che cosa significa
gs]
-    Giustifica  a  sinistra il risultato,  allinea  sulla
     destra  con  spazi.  Se non indicato,  giustifica  il
     risultato verso destra, allinea a sinistra  con  zeri
     o spazi.
+    I  risultati di conversioni con segno iniziano sempre
     con un segno pi (+) o un segno meno (-).
Spaz Se  il valore non  negativo, l'output inizia con uno
io   spazio  invece  di  un pi; valori negativi  iniziano
     comunque con un meno.
#    Specifica  che  l'argomento  deve  essere  convertito
     utilizzando una forma alternativa .

Se  vengono  forniti  entrambi, il  segno  pi  (+)  ha  la
precedenza sullo spazio.

2.5.4.3   Forme alternative per la conversione di
STRPRINTF
  Se si utilizza il flag # con un carattere di conversione,
esso   ha  l'effetto  seguente  (sull'argomento  che  viene
convertito).
       Tabella 2-3 : Forme alternative di STRPRINTF
Conversione    Come # influenza l'argomento
carattere
c s d i u      non ha nessun effetto;
0              fa  precedere da 0 un argomento diverso  da
               zero;
x or X         fa precedere da 0x (o 0X) l'argomento;
e E f          il   risultato  contiene  sempre  un  punto
               decimale  anche se nessuna cifra lo  segue;
               normalmente,  un punto decimale  appare  in
               questi  risultati  solo  se  una  cifra  lo
               segue;
g G            uguale   ad   e   ed  E;   gli   zeri   non
               significativi non vengono rimossi.


2.5.4.4   Specificatori di larghezza di STRPRINTF [width]
Lo  specificatore  di  larghezza di  STRPRINTF  imposta  la
larghezza  minima  per  un valore di output.  La  larghezza
viene specificata in uno dei due modi seguenti:
   direttamente, tramite una stringa di cifre decimali;
   indirettamente, tramite un asterisco (*);
Se  si  utilizza un * come specificatore di  larghezza,  il
prossimo  argomento  nella chiamata  (che  deve  essere  un
intero) specifica la larghezza minima del campo di output .
Larghezze  di campo non esistenti o piccole NON causano  il
troncamento di un campo. Se il risultato di una conversione
   pi  largo  della dimensione del campo, il campo  viene
espanso per contenere il risultato della conversione.

            Tabella 2-4 : [Width] di STRPRINTF
[Widt  Come viene influenzata la larghezza dell'output
h]
n      Vengono  stampati almeno n caratteri. Se il  valore
       dell'output ha meno di n caratteri, l'output  viene
       allineato con spazi (a destra se viene dato il flag
       "-", a sinistra altrimenti).
0n     Vengono  stampati almeno n caratteri. Se il  valore
       dell'output ha meno di n caratteri, viene allineato
       a sinistra con degli zeri.
*      L'elenco  degli argomenti fornisce lo specificatore
       di   larghezza,  che  deve  precedere   l'argomento
       attuale di formattazione.


2.5.4.5   Specificatori di precisione di STRPRINTF [.Prec]
Gli specificatori di precisione di STRPRINTF  impostano  il
massimo  numero di caratteri (o il numero minimo  di  cifre
intere)  da  stampare.  Una  specifica  di  precisione   di
STRPRINTF  inizia sempre con un punto (.) per separarlo  da
qualunque  specificatore di larghezza precedente.   Quindi,
come  [width], la precisione pu essere specificata in  uno
dei due modi seguenti:
   direttamente, tramite una stringa di cifre decimali;
   indirettamente, tramite un asterisco (*).
Se  si utilizza uno * come specificatore di precisione,  il
prossimo  argomento della chiamata (trattato come  un  int)
specifica la precisione.
Se   si  utilizza  un  asterisco  per  la  larghezza  o  la
precisione,  o per entrambe, l'argomento di larghezza  deve
seguire    immediatamente   gli   specificatori,    seguito
dall'argomento  precisione, quindi  dall'argomento  per  il
dato da convertire.
            Tabella 2-5 : [.Prec] di STRPRINTF
[.Prec] Come viene influenzata la precisione dell'output
(nessun La precisione  impostata al valore di default:
o)
        1 per i tipi d,i,o,u,x,X;
        6 per i tipi e,E,f;
        tutte le cifre significative per i tipi  g,G;
        stampa fino al carattere null per i  tipi s;
        nessun effetto sui tipi c;
 0      per   i   tipi  d,i,o,u,x,  la  precisione   viene
        impostata ai valori di default; per i tipi  e,E,f,
        non viene stampato nessun punto decimale;
*       l'elenco  di  argomenti fornisce lo  specificatore
        di  precisione,  che  deve  precedere  l'argomento
        attuale da formattare.
.n      vengono  stampati n caratteri o n posti  decimali.
        Se  il  valore dell'output ha pi di n  caratteri,
        l'output   pu   essere  troncato  o   arrotondato
        (quello  che  accade  dipende  dal  carattere   di
        tipo.)
Non  viene  scritto nessun carattere in un campo (il  campo
rimane vuoto) se si verificano le seguenti condizioni:
   si specifica una precisione esplicita di 0;
   lo specificatore di formato per il campo  uno dei
formati interi (d, i, o, u, or x);
   il valore da stampare  0.

2.5.4.6   Caratteri di conversione tipo di STRPRINTF
[type_char]
Le   informazioni  in  questa  tabella  sono  basate  sulla
assunzione  che nessun carattere di flag, specificatore  di
larghezza,   specificatore  di  precisione  o  modificatore
della  dimensione  in  ingresso  sia  stato  incluso  nello
specificatore di formato.
           Tabella 2-6 [type_char] di STRPRINTF
Tipo   Caratt  Input        Formato dell'output
       ere     atteso
Numer  d       Intero       Intero   decimale  con  segno.
ici                         Deve essere preceduto da l.
       i       Intero       Intero   decimale  con  segno.
                            Deve essere preceduto da l.
       o       Intero       Intero   ottale  senza  segno.
                            Deve essere preceduto da l.
       u       Intero       Intero  decimale senza  segno.
                            Deve essere preceduto da l.
       x       Intero       Intero esadecimale senza segno
                            (con  a, b, c, d, e, f).  Deve
                            essere preceduto da l.
       X       Intero       Intero esadecimale senza segno
                            (con  A, B, C, D, E, F).  Deve
                            essere preceduto da l.
       f       Reale        Valore con segno nel formato[-
                            ]dddd.dddd.
       e       Reale        Valore con segno nel formato[-
                            ]d.dddd or e[+/-]ddd .
       g       Reale        Valore   con  segno  sia   nel
                            formato  e  che f, basato  sul
                            valore   e   sulla  precisione
                            indicati.   Gli    zeri    non
                            significativi in  coda  ed  il
                            punto     decimale     vengono
                            stampati se  necessario.
       E       Reale        Uguale   ad  e;  con   E   per
                            l'esponente.
       G       Reale        Uguale   a   g;  con   E   per
                            l'esponente      se      viene
                            utilizzato il formato e.
Carat  s       Stringa    o Stampa  caratteri fino  a  che
teri           Simbolo      incontra      un     carattere
               Atomico      terminatore null, oppure viene
                            raggiunta la precisione.
       %       Nessuno      Stampa il carattere %.
Punta  p       Funzione  Di Stampa l'argomento in ingresso
tori           Sistema    o come  un puntatore; il formato
               Stream       dipende  da  quale modello  di
                            memoria viene utilizzato.  Pu
                            essere sia XXXX:YYYY che  YYYY
                            (solo l'offset).

Nota  Bene: Se non si seguono rigorosamente i tipi di  dati
riportati   in   tabella  la  STRPRINTF  genera   risultati
inattesi.
Numeri  infiniti  in virgola mobile vengono  stampati  come
+INF e -INF.
Un non - numero IEEE viene stampato come +NAN o  -NAN.

2.5.4.7   Esempi di STRPRINTF
( STRPRINTF "Dec %ld, Hex %lx, Float %d"  100 100 100.0 )
"Dec 100, Hex 64, Float 100.000000"
( STRPRINTF "Hex1 %lx, Hex2 %lX, Atom %s" 75 75  'Andrea)
"Hex1 4b, Hex2 4B, Atom Andrea"
( STRPRINTF "% 3.3f" 10.2345 )
" 10.235"

2.6

 Funzioni di File I/O

2.6.1     Aprire e chiudere un file
Un  file su disco viene aperto con la FOPEN che ritorna  un
tipo  di  dato  STREAM  oppure NIL  se  c'  un  errore  di
apertura.
Esempio:
(SETF  file  (FOPEN   "test.dat"   "w+b"))  crea  il   file
test.dat e lo assegna alla variabile file.
L'interprete  stampa i tipi di dato STREAM in questo  modo:
#<Stream  xxxx:xxxx>  dove le x vengono  sostituite  da  un
puntatore interno.
Per leggere e scrivere dal file "test.dat" si usa dunque lo
stream memorizzato nella variabile file.
FOPEN  richiede  due parametri di tipo  STRINGA,  il  primo
rappresenta  il  nome  del  file con  l'eventuale  cammino,
mentre  il  secondo rappresenta la modalit di apertura  in
stile Ansi-C.
          Tabella 2-7 : Modalit di apertura File
 Stringa  Significato
    r     apre in sola lettura.
    w     crea  in  scrittura; se un file  con  tale  nome
          esiste gi, viene sovrascritto.
    a     append; apre in scrittura alla fine del  file  o
          crea in scrittura se il file non esiste.
   r+     apre   un   file   esistente  in   aggiornamento
          (lettura e scrittura).
   w+     crea  un nuovo file in aggiornamento (lettura  e
          scrittura);  se  un file con  tale  nome  esiste
          gi, viene sovrascritto.
   a+     apre  in  aggiunta;  apre in aggiornamento  alla
          fine del file o crea se il file non esiste.

Per  specificare che un file indicato deve essere aperto  o
creato in modalit testo,  si aggiunga t alla stringa  (rt,
w+t,  eccetera).  Per specificare la modalit  binaria,  si
aggiunga b alla stringa (wb, a+b, eccetera).
Un  file  lo  si chiude con la FCLOSE che ritorna  T  se  
riuscita a chiudere il file oppure NIL se c' stato qualche
errore.
Esempio:
(FCLOSE file)
FCLOSE inoltre pone lo stream al valore NULL in modo da non
poter pi essere utilizzato.

2.6.2     Errori di File
Ogni  stream ha associato un flag di errore ed un  flag  di
fine  file (EOF). Per leggere il flag di errore si  usi  la
(FERROR  Stream) (ritorna T se c' stato  un  errore  o  lo
stream   NULL, NIL altrimenti), per resettare questo  flag
si  usi la (FCLEARERR Stream) (ritorna T o NIL se lo stream
 NULL),  per leggere lo stato di fine file si usi la (FEOF
Stream) (ritorna T se c' stato un EOF o lo stream   NULL,
NIL altrimenti).

2.6.3     Posizionamento nel File
Ogni  stream  ha  associato un intero  che  rappresenta  la
posizione della testina di lettura - scrittura. Per leggere
questa  posizione si usi la (FTELL Stream) (ritorna NIL  se
c'   stato  un  errore  o  se  lo  stream    NULL),   per
posizionarsi  si usi la FSEEK che richiede 3  parametri:  (
FSEEK Stream Posizione DaDove ) Stream deve essere di  tipo
STREAM  mentre  Posizione e DaDove devono  essere  di  tipo
INTERO.   La   testina  viene  spostata  di  una   quantit
specificata da Posizione a partire dalla posizione  DaDove.
Vedere la tabella seguente:
               Tabella 2-8 : Parametro FSEEK
       Parametro DaDove                   Da ...
               0                     Inizio del file
               1                    Posizione corrente
               2                      Fine del file

Il parametro Posizione pu essere negativo o Zero.

2.6.4     Lettura e scrittura di byte
Per  leggere  un  byte da uno stream si usi  la  (FREADBYTE
Stream) che ritorna un INTERO tra 0 e 255, per scrivere  un
byte  su  di uno stream usare la (FWRITEBYTE Stream Valore)
dove Valore deve essere un INTERO tra 0 e 255.
NOTA BENE: Per  evitare le traduzioni dei caratteri di fine
           -  linea  bisogna  usare uno stream  in  formato
           binario   altrimenti  si  avranno  (giustamente)
           strani  comportamenti delle due  funzioni.  Vedi
           FOPEN e il parametro "b" di apertura.

2.6.5     Lettura e scrittura di stringhe e s-espressioni
su File
Per scrivere una s-espressione (e dunque anche una stringa)
su  di  uno stream si usi la (FPRINT Stream S-espressioni).
Si possono specificare un numero qualsiasi di S-espressioni
che  verranno  scritte  esattamente come  vengono  stampate
sullo  schermo senza appendere il carattere di fine - riga.
(FPRINT  STDOUT S-espressioni)  equivalente  a  (PRINT  S-
espressioni). Quando si stampa una lista molto lunga allora
si  stampa  automaticamente anche un fine -  riga  ogni  80
(circa) caratteri.
Per leggere una s-espressione (terminata da un fine - riga)
da   un   file   si  usi  la  (FINPUT  StreamIn   StreamOut
StringPrompt  ).  Su  StreamOut  verr  emesso  il   prompt
StringPrompt quando richiesto. StreamOut pu essere NULL  o
NIL per evitare l'emissione del prompt.
Per leggere dei numeri ASCII da un file in formato INTERO o
REALE  oppure  per leggere delle stringhe terminate  da  un
fine  -  riga  si  usi la (FSCANF Stream Tipo)   dove  Tipo
rappresenta  il  tipo  di  dato  letto  e  ritornato  dalla
funzione,  se  si tenta di leggere un numero  lessicalmente
sbagliato  allora la funzione ritorna l'atomo SYNTAX_ERROR.
Non contano eventuali spazi prima del numero.
Vedi la tabella seguente.
            Tabella 2-9  : Parametro di FSCANF
        Parametro Tipo                Tipo ritornato
               0                          INTERO
               1                          REALE
               2                         STRINGA

La  scansione termina su un fine - riga (se lo si incontra)
o  sul  primo  carattere che non compete al  tipo  di  dato
richiesto. Vedi anche le funzioni STR2INT e STR2REAL.

2.7

 Funzioni grafiche

2.7.1     Modalit grafiche e colori
La  modalit  grafica viene impostata mediante la  funzione
GMODE  la  quale  richiede un parametro di  tipo  INTERO  a
seconda  del  quale  viene impostato  un  diverso  tipo  di
risoluzione grafica. Se il parametro  0 (zero) si  ritorna
in  modalit  testo. L'origine dello schermo grafico    in
alto  a  sinistra e le sue coordinate sono 0,0.  Il  numero
massimo  di colori rappresentabili  sullo schermo  varia  a
seconda  dell'hardware impiegato, comunque i colori vengono
sempre specificati come un intero RGB a 24 bit.
La funzione GMODE ritorna una lista di due interi (X Y) che
rappresentano  la  larghezza  (X)  e  l'altezza  (Y)  dello
schermo  grafico. Quando si chiude la grafica,  con  (GMODE
0), viene ritornata la lista (0 0).
La tabella qui sotto rappresenta le varie modalit grafiche
DOS  e  WINDOWS. L'interprete per DOS richiede la VGA,  con
Windows funziona sempre: ScrnX, ScrnY  la risoluzione  X,Y
dello  schermo Windows, ScrnC  la risoluzione dei  colori.
Generalmente ScrnX, ScrnY sono 640, 480 o 800, 600 o  1024,
768 e ScrnC  16 o 256 o 24 milioni (true color).
             Tabella 2-10 : Modalit grafiche
Parametro     DOS + VGA                 WINDOWS
di GMODE
    0       Modalit testo    Chiude la finestra grafica
    1       320, 200, 256         ScrnX, ScrnY, ScrnC
    2        640, 480, 16     4*ScrnX/5, 4*ScrnY/5, ScrnC
    3        640, 350, 16     4*ScrnX/6, 4*ScrnY/6, ScrnC
    4        640, 200, 16     4*ScrnX/7, 4*ScrnY/7, ScrnC

Con  Windows  possibile specificare anche valori di  GMODE
pi elevati in modo da ridurre la dimensione della finestra
grafica, questo al fine di risparmiare memoria.
    I colori vanno indicati con un intero RGB a 24 bit con
 R,  G, B tra 0 e 255. Esempio: R = 255, G = 128, B = 1  si
 trasforma in Colore = 255 * 65536  + 128 * 256 + 1
    Le  coordinate vanno rappresentare con  numeri  interi
 maggiori o uguali a Zero, e verranno eventualmente troncate
 se risultano eccessive.
    Tutte  le  funzioni grafiche usate in  modalit  testo
 (tranne GMODE) ritornano NIL.

2.7.2     Punti e Linee
Per   accendere  un  punto  si  usa  (GPUTPIXEL  X   Y   C)
specificando le coordinate X,Y ed il colore C, per avere il
colore di un punto si usa (GGETPIXEL X Y). Il colore  viene
restituito nel formato RGB.
Per tracciare una linea si tenga presente che (GLINETO X Y)
traccia  una  linea dall'ultimo punto passato a  GLINETO  o
GMOVETO. La linea verr tracciata con la penna corrente.

2.7.3     Poligoni ed ellissi
Per  tracciare e riempire un poligono si usa  la  GFILLPOLY
che  richiede  un numero di parametri variabile:  il  primo
specifica il numero delle coppie X,Y seguenti.
Esempio:
( GFILLPOLY 5  0 0  100 0  100 100  0 100  0 0 ) traccia un
quadrato.
Il  poligono  viene tracciato usando la  penna  corrente  e
riempito col pennello corrente.
Per  tracciare e riempire un'ellisse si usa la GFILLELLIPSE
la quale richiede 4 parametri: centro X,Y e raggi RX,RY.
Esempio:
(GFILLELLIPSE 100 100  50 70) traccia un'ellisse di  centro
100, 100, raggio X 50, raggio Y 70.
(GFILLELLIPSE 100 100 20 20) traccia un cerchio.
Per  tracciare e riempire un settore di ellisse si  usa  la
GFILLSECTOR  la  quale  richiede 6 parametri:  centro  X,Y,
angolo  di  partenza e di arrivo in gradi e raggi  RX,RY.Il
settore viene tracciato in senso orario.
Esempio:
(GFILLSECTOR  100 100  0 90  20 20 ) traccia un  quarto  di
cerchio.
Le  ellissi  vengono  tracciate con  la  penna  corrente  e
riempite con il pennello corrente.

2.7.4     Testo in modalit grafica
Si   pu   emettere  una  stringa  sullo  schermo   grafico
specificandone  le  coordinate X,Y  del  punto  in  alto  a
sinistra  del primo carattere. La funzione da utilizzare  
(GOUTTEXT  X  Y  STRINGA). Il colore usato   quello  della
penna corrente.


2.7.5     Penne
Le  linee  ed i contorni delle ellissi, dei settori  e  dei
poligoni  sono tracciati mediante una penna della  quale  
possibile definire il colore con GPENCOLOR, lo spessore con
GPENTICK  e  l'aspetto con GPENTYPE.  Si  veda  la  tabella
seguente.
               Tabella 2-11 : Tipi di penne
   Parametro di      Apparenza       Stile della penna
     GPENTYPE
        0                               TRASPARENTE
        1            ---------            SOLIDA
        2            - - - - -         TRATTEGGIATA
        3            .........          PUNTEGGIATA
        4            -.-.-.-.-        TRATTO - PUNTO
        5            -..-..-..    TRATTO - PUNTO - PUNTO

Nota:  Lo spessore della linea  usato solo quando il  tipo
della linea  solido (1) altrimenti verr usato lo spessore
unitario.

2.7.6

 Pennelli
I  riempimenti  delle ellissi, dei settori e  dei  poligoni
vengono  effettuati con il pennello del quale    possibile
definire  colore con GBRUSHCOLOR e tipo con GBRUSHTYPE.  Si
veda la tabella seguente.

                  Tabella 2-12 : Pennelli
    Parametro di         Apparenza     Stile del pennello
     GPENCOLOR
         0                                 TRASPARENTE
         1                                   SOLIDO
         2                                 ORIZZONTALE
         3                                  VERTICALE
         4                                    CROCE
         5                                DIAGONALE DX
         6                                DIAGONALE SX
         7                                     ICS




3.  Indice analitico delle funzioni di Graphic Lisp citate
nel manuale





                             
                            _A_
ACCESSOR                         10; 16; 20; 21; 27; 28; 29
ACCESSORP                                                44
ASCII                                             3; 45; 54
ATOM                                                 22; 44
                             
                            _C_
CAR                                           9; 20; 34; 43
CDR                                                   9; 33
Class                                                29; 30
CLASSP                                                   43
Closure                                                  11
CNAMEP                                                   44
COND                                                     42
CONS                        2; 8; 9; 10; 15; 16; 17; 24; 43
CONSP                                                    43
                             
                            _D_
Debugging                                             2; 36
DEFCLASS                   2; 9; 10; 16; 20; 21; 27; 28; 29
DEFMACRO                      2; 10; 12; 14; 21; 25; 27; 44
DEFMCARO                                                  9
DEFMETHOD                  2; 8; 10; 12; 21; 27; 31; 32; 44
DEFUN  2; 8; 10; 11; 12; 13; 14; 15; 16; 20; 25; 26; 42; 43
DEFVAR                                                   12
DO                                                    2; 33
DOLIST                                                2; 34
DOTIMES                                               2; 34
DOUBLE                                                   39
                             
                            _E_
ENAMEP                                                   44
ENDP                                                     44
Environment                                              11
EOF                                                      53
EQ
 44
EQUAL                                        23; 24; 44; 45
EVAL                                                      9
EVENP                                                    45
                             
                            _F_
FCLEARERR                                                53
FCLOSE                                                   53
FEOF                                                     53
FERROR                                                   53
FINPUT                                               45; 54
FIX                                                      38
FIXLIST                                                  38
FLOAT                                    18; 38; 41; 42; 52
FOPEN                                            19; 52; 54
FPRINT                                                   54
FREADBYTE                                                54
FSCANF                                           45; 54; 55
FSEEK                                                    53
FTELL                                                    53
FUNCTION                          9; 10; 11; 15; 19; 20; 21
FUNCTIONP                                                44
FWRITEBYTE                                               54
                             
                            _G_
GBRUSHCOLOR                                              58
GBRUSHTYPE                                               58
GFILLELLIPSE                                             57
GFILLPOLY                                                56
GFILLSECTOR                                              57
GGETPIXEL                                                56
GLINETO                                                  56
GMODE                                                55; 56
GMOVETO                                                  56
GOUTTEXT                                                 57
GPENCOLOR                                            57; 58
GPENTICK                                                 57
GPENTYPE                                                 57
GPUTPIXEL                                                56
                             
                            _H_
HASHSTAT                                                 37
Hashtable                                                37
                             
                            _I_
IEEE                                                 39; 51
IF                                               12; 14; 42
INITARG                                                  27
INITFORM                                             16; 27
INTP                                                     43
                             
                            _L_
LET                                           2; 24; 35; 36
Lexical                                                  11
LISTP                                                    44
                             
                            _M_
MACROP                                                   44
METHODP                                                  44
MINUSP                                                   45
MsDos                                                    39
                             
                            _N_
NAME2STR                                                 46
NULL                                         33; 44; 53; 54
NUMBERP                                                  44
                             
                            _O_
ODDP                                                     45
                             
                            _P_
PLIST                                                 9; 16
PLUSP                                                    45
PRINT                    12; 15; 16; 24; 25; 31; 33; 43; 54
PROG                                                  2; 35
PROG1                                                 2; 35
PROGN                                                 2; 35
                             
                            _R_
RATIOP                                               42; 43
READCHAR                                                 45
REALP                                                42; 43
REM                                              18; 38; 42
RETURN                                           34; 35; 36
RGB                                                  55; 56
                             
                            _S_
SETF6; 7; 8; 9; 10; 11; 13; 14; 15; 16; 19; 25; 29; 30; 46;
 52
SETQ                                                     13
SQRT                                                 40; 41
STACKTRACE                                               36
STDERR                                                   19
STDIN                                                19; 43
STDOUT                                               19; 54
STDPRN                                                   19
STR2ASCII                                                45
STR2INT                                              46; 55
STR2NAME                                                 46
STR2REAL                                             46; 55
STRCAT                                                   45
Stream                            2; 17; 19; 51; 52; 53; 54
STREAMP                                                  43
STRING=                                                  45
STRINGP                                                  43
STRLEN                                                   46
STRNUM                                                   45
STRPRINTF                     3; 46; 47; 48; 49; 50; 51; 52
STRSUB                                                   46
STRUB                                                    46
SYMBOLP                                                  43
SYNTAX_ERROR                                         46; 54
SYSFUNCP                                                 43
                             
                            _T_
TRACE                                                    36
                             
                            _U_
UFUNCP                                                   43
Unbound                                                   8
UNTRACE                                                  36
                             
                            _V_
VALUEP                                                   43
VGA                                                      55
                             
                            _W_
Windows                                          39; 55; 56
                             
                            _Z_
ZEROP                                                    45






Graphic Lisp

Elenco delle funzioni








Scritto da : Zoia Andrea Michele   Mat. 588823

La  sintassi  delle funzioni elencate  riportata  mediante
l'ausilio  di metasimboli caratteristici delle  espressioni
regolari.
   { }   Raggruppamento
   ?    Zero o una occorrenza
   +       Una o pi occorrenze
   *       Zero o pi occorrenze
   |       Una delle occorrenze ai lati del
metasimbolo.
Inoltre la scrittura
                    E ( s-espressione )

Indica la valutazione della s-espressione tra parentesi.

                         *   *   *
                             
Le funzioni sono elencate in 8 raggruppamenti differenti
pi un elenco di atomi globali:
1.  Elenco completo di tutte le funzioni in ordine
 alfabetico
2.  Funzioni standard Common Lisp
3.  Predicati
4.  Funzioni matematiche
5.  Funzioni di stringa
6.  Funzioni di file I / O
7.  Funzioni grafiche
8.  Funzioni di sistema
9.  Elenco degli atomi globali predefiniti



     Ogni funzione  descritta secondo questo schema:




    Nome         :   Nome della funzione

    Tipo        :   Tipologia estesa della funzione

    Sintassi     :   Sintassi

    Valore   ritornato     :    Valore   restituito   dalla

    funzione

    Effetto laterale   :   Eventuale azione procedurale

    Note            :       Eventuali    annotazioni     di

    funzionamento.





_______________________________
1  Vedi LISP 3rd Edition di P.H. Winston e B.K.P. Horn Ed.
Addison Wesley . L'implementazione delle classi e dei
metodi di Graphic Lisp  identica a quella riportata dal
testo che , tra l'altro, identica a quella del Common
Lisp.
2 Vedi LISP 3rd Edition di P.H. Winston e B.K.P. Horn Ed.
Addison Wesley pagg. 200 - 201
3 Usato da MsDos e da Windows
4 Usando il punto per separare i decimali
