^%H Aide en ligne de Xbvl
^Description de Lisp
^^Interface au TopLevel et description du systme
^
bibliothques
	Au moment de son lancement, bVLISP lit une bibliothque de
	fonctions et macros nomme "bvlisp.sys". Ce fichier 
	est connu par le systme mais il peut tre change par 
	l'utilisateur en dfinissant la variable d'environnement 
	BVLISP-SYS.
	Puis bVLISP tente de lire dans le rpertoire courant deux
	bibliothques personnelles nommes "vlisp.ini" et "bvlisp.ini".
	Puis bVLISP passe au toplevel et attend les expressions  excuter.
	En l'absence de la bibliothque concerne, bVLISP signale:
			bvlisp.sys absente
		ou	vlisp.ini absente
		ou	bvlisp.ini absente

	selon le cas.
	Notez qu'on peut avoir autant de "vlisp.ini" et des "bvlisp.ini"
que de rpertoires ou de sous rpertoires. Regardez galement
	(aide EOF)
^
commenter
Deux faons de commenter :
	- tout ce qui est entre deux ";" sur la MEME ligne.
	- s'il n'y a qu'UN ";" dans la ligne, le commentaire est le reste
	  de la ligne.
	Les commentaires sont gardes  l'intrieur des listes comme des 
	annotations.
^
interrompre
	Si vous entrez dans une vilaine boucle, vous pouvez en sortir
	en appuyant sur la touche "ESCAPE".

	
	Une interruption au clavier, (touche "ESCAPE"), de mme qu'une 
	interruption du systme rsultant d'une erreur de programmation,
	est droute par bVLISP qui vous dit alors :

	  "(s)ortir de bVLISP ou (c)ontinuer ? (s/c):"

	et attend votre rponse, i.e. "s" pour se retrouver sous Unix,
	ou "c" pour continuer au toplevel de bVLISP.
	Votre rponse doit tre suivie de RETURN, bien sur.
	La frappe de ESCAPE suivie de "s" est une faon presse et
	radicale de sortir de bVLISP; on peut en sortir plus calmement
	en utilisant la fonction "(stop)".
	
^
toplevel
(toplevel)	subr 0
	Vous pouvez redfinir une boucle toplevel qui vous est propre.
	exemple:
^%L
	(de toplevel ()
	  (princ "sous-systeme-foo ?")
	  (setq foo-it (foo (read)))
	  (print '= foo-it))

	bVLISP boucle alors l-dessus et y redescend en cas d'erreur.
^
eval
(eval e)	subr 1
	value l'expression e.

^
apply
(apply f l)	subr 2
	applique la fonction f  la liste l d'arguments supposs dj
	valus.

		f peut tre: une fonction standard.
			une lambda expression.
			une variable.
			une fonction dfinie.
			un entier n, la valeur ramene sera le n-ieme lment de l.
			une expression, qui sera alors value.

	exemples :
^%T2
		(apply 'car '((a b c)))		-> a
		(apply 'eval '((car '(a b c))))	-> a
^
prompt
	L'atome prompt a pour valeur courante "? ". Si vous lui affectez
	autre chose (atome ou chane), vous changez le prompt de lecture.
	exemples:
		(setq prompt "-->")
		(setq prompt "")	dans ce cas rien.
		(setq prompt "login:")	Mmmmm

	On peut l'affecter par setq set let ou passage d'argument.

	A l'intrieur de boucles 'break', le prompt correspond  
	l'argument de 'break' (cf. break)
^
it
	La valeur de la dernire valuation au toplevel est toujours
	prsente dans la variable "it".

	exemples:

		(setq x 3)  ->  3
		it	    ->  3
		(+ it it)   ->  6
		(+ it it)   ->  12
^
printlength
	La variable standard "printlength" a pour valeur courante 800. Elle
	permet de contrler le nombre maximum d'lments  imprimer lors de 
	l'impression d'une liste. S'il y en a plus, vlisp imprime ...) et
	arrte. Pour faire diffremment, reaffectez "printlength".
^
time
(time)		subr 0
	Donne une liste  3 lments:
	      (minutes secondes mili secondes)
	Ces temps reprsentent les dures de calculs effectues par
	vlisp depuis le lancement de celui.
^
oblist
(oblist)	subr 0
	ramne la liste de tous les atomes.
^
gc
(gc e)		subr 1
	provoque une garbage collection. Si e est diffrent de nil, des
	informations sont imprimes: le nombre total de garbage collections
	effectues, le nombre de doublets libres restants, le nombre
	d'"assez-grands-nombres-entiers" libres restants, le nombre d'atomes
	libres, la taille de la pile, et la place libre restante en octets
	pour les chanes, puis le nombre de garbage-collections de chanes
	et la place restante pour les chanes aprs garbage-collection
	de celles-ci.
	Si, par contre, e est nil, l'impression de ces informations est
	supprime.
	Sont rcuprs les doublets, les entiers et les atomes. Pour raisons
	d'efficacit, les chanes ne sont garbages que lorsque l'espace des
	chanes est plein.
^
stop
(stop)		subr 0
	fait sortir de bVLISP. On retourne  Unix.
^
sh
(sh e)		subr 1
	La valeur de "e" doit tre une chane. La fonction sh
	appelle alors la commande place dans cette chane. La
	valeur retourne est "e" elle-mme.
	"sh" sont les deux premires lettres de "shell" qui dsigne
	le toplevel Unix.

	exemples:
		(sh "who")
		(sh "mail pg")
		(sh "ls -l")
		(sh "ed foo.vlisp")
^
ssh
(ssh e)		subr 1
	lance une fentre X et excute la commande avec affichage dans
	cette fentre. Celle-ci est dtruite aussitt que la commande est
	termine.
^
ls
(ls path) subr 1

	Liste les fichiers contenus dans le rpertoire donne en argument
	et retourne les fichiers sous la forme d'une liste.
Si path est nil, c'est le rpertoire courant qui est pris en compte.

^
cwd
(cwd path) subr 1

	Change le rpertoire par dfaut pour la lecture et l'criture des fichiers.

^
session
(session e)		subr 1
	Pour sauver une image mmoire de vlisp.
	ide:
	prparer vos affaires dans un vlisp frais.
	puis quand vous tes contents faites:
		(session 'FORME-A-EVALUER-POUR-COMMENCER)
	ca sort avec une indication de nom de fichier ou c'est sauv.
	C'est 'session.vlisp'.
	Pour charger directement votre image mmoire faites:
		vlisp -s NOM-DE-FILE-SAUVE
	en l'occurrence (si vous n'avez pas change le nom)
		vlisp -s session.vlisp
	exemple d'usage:
	dans vlisp
^%L
	(de foo ()
	  (princ "Bjour msieu! qui vous tes, dites?")
	  (setq nom (read)) 
	  (print "Merci Msieu" nom)
	  (foo))

	et, ceci dfini vous faites
		(session '(progn (print "C'est reparti !") (foo)))
	et ca sort.
	Vous aurez ce que vous mritez si vous faites, sous shell bien sur :
		vlisp -s session.vlisp
	NOTE: cette petite douceur cote environ 60.000 octets de fichier,
	ne multipliez donc pas les sessions sauves en cas de saturation disque!
^
argc
(argc)		subr 0
	ramne le nombre d'arguments de l'appel de vlisp sous shell.
	Exemple:

		xbvl -fn 9x15
		(argc)  ->   3
^
argv
(argv n)	subr 1
ramne la n-ime chane,  partir de 0, de l'appel de vlisp sous shell.
	Exemple:

		vlisp -s session.vlisp
		(argv 2)  ->  "session.vlisp"
^
user
(user)		subr 0
	ramne votre nom sous forme de chane.
^
tty
(tty)		subr 0
	ramne le nom de votre tty sous forme de chane.
^
getenv
(getenv c)	subr 1
	ramne la chane associe dans l'environnement shell  chane (ou
	l'atome) "c".
	Exemple:
	(getenv "TERM")  ->  tvi	si c'est le cas.
^
status
(status at n)	fsubr
	- (status toplevel 1) : imprime la ligne lue, au clavier ou sur file.
	  utilit no 1 : dans les "dmos", pour imprimer
	  le truc mis comme commande d'entre.
	- (status print 1) : imprime les '"' des chanes.
	  (status print 0) : ne les imprime pas.
	  (status print 2) : pas d'espace avant les impressions.
	  en fait : 1 = bit 0.	imprime les '"' des chanes.
	            2 = bit 1.	pas d'espace avant impression.
	            3 = bit 0 et bit 1.
	  (status print) : ramne le status print courant.
^
aide
(aide at [widget] [fichier])	 subr 1

	Vous donne la documentation on-line sur le sujet 'at' si
	l'argument 'at' est prsent. Sinon, aide vous donne la liste des
	sujets disponibles. Si pour l'argument donn aucune aide n'est
	disponible, aide donne la liste	des sujets dont l'argument fait
	partie du nom. 
	(exemple : (aide br) donne : break, ce qui
	est le seul sujet contenant la chane 'br'.)
	exemples d'appels :
		(aide "getcar")
		(aide 'line-editor)
		(aide)
	Si l'on ne veut connatre que les sujets se rapportant  un
	certain thme, on doit faire prcder l'argument par le caractre
	'~'. Ainsi, l'appel (aide ~car) livre la liste mapcar car careful ... etc.
	des seuls sujets qui ont la sous chane 'car'.
	
	L'utilisateur peut dfinir les noms des fichiers composant la base
	de donnes de la documentation en ligne positionnant les variables
	d'environnement BVLISP-AIDEDFILE avec le nom du fichier contenant
	l'indice BVLISP-AIDEINFILE avec le nom du fichier contenant les
	dfinitions. Un autre moyen de spcifier les noms des fichiers d'aide
	et d'index sur l'aide est de spcifier en troisime argument la base
	du nom de fichier contenant ces informations. Il ne doit pas avoir
	d'extension : le nom de fichier spcifie + ".dat" contiendra le
	texte de l'aide et le nom de fichier + ".:dat" contiendra l'index.

	Personnalisation de l'aide.

	Si l'argument <widget> est prsent et il est un widget
	d'interaction avec le systme, l'aide est affiche sur ce widget.
	Si non, l'aide est affiche sur la hirarchie suivante:
		Aide-root->aide-form->aide
		Aide-root est d'un widget "ApplicationShell",
		aide-form est un widget "awForm",
		aide d'un widget "Xbvlisp"

	L'aide en ligne est d'une structure trs simple et peut tre
	intgre dans l'interface du systme de plusieurs manires. On
	peut, par exemple, ajouter d'autres widgets  la hirarchie de base,
	dposer des callbacks dans ces widgets pour automatiser ainsi
	accs  la documentation de certains sujets et modifier
	l'interface elle-mme.

	La liste de sujets disponibles

	Au premier appel de (aide) une nouvelle hirarchie de widgets
	est automatiquement construite. Cette interface s'occupe de lister
	les titres de sujets d'aide disponibles. Si on clique sur un titre
	les informations disponibles sont affiches. On peut ajouter une
	callback au widget qui s'occupe d'afficher les titres de la
	documentation et personnaliser d'avantage le module d'aide.
	Cette hirarchie est compose des la manire suivante: 
		Doc-root->doc-form->doc-viewpor->doc-list
		Doc-root appartient  la classe "ApplicationShell",
		doc-form est un conteneur "awForm",
		doc-viewport pour scroller la liste de sujet,
		doc-list contient la liste de sujet, ce widget appartient  la
			classe "awList" est peut avoir un callback
			supplmentaire. 
^
sections
(sections [fichier d'aide])

	retourne la liste des sections d'un fichier d'aide. Ces sections
	sont indiques, dans ces fichiers, par la prsence en dbut de ligne
	de ^^ suivit du titre de la section.

	voir aussi: aide, listesection
^
listesection
(listesection <numro d'ordre ou titre de la section> [fichier d'aide])

	retourne la liste des entres d'une section d'un fichier d'aide.
	
	voir aussi: aide, sections
^^Fonctions de contrle
^
quote
(quote e)	fsubr
	ramne e sans l'valuer. Peut aussi s'crire 'e.
	Une autre vision dit que la fonction quote ramne le cadr
	de son appel.
^
progn
(progn e1 ... en)	fsubr
	value en squence les expressions e1 ... eN et ramne la valeur
	de la dernire.
^
eprogn
(eprogn l)	subr 1
	value en squence les lments de la liste l, et ramne le
	rsultat d'valuation de son dernier lment.
^
prog1
(prog1 e1 ... eN)	fsubr
	value en squence les e1 ... eN et ramne la valeur de e1.
^
if
(if et esv esf1 ... esfN)	fsubr
	value l'expression_test "et", si la valeur obtenue est diffrente
	de nil if value esv (i.e. expression_si_vrai) et ramne sa
	valeur. Mais si la valeur de "et" est nil, on value en squence
	les esf1 ... esfN (i.e. expressions_si_faux) et on ramne la
	valeur de la dernire.
	C'est un "if-then-else".
^
ifn
(ifn et esf esv1 ... esvN)	fsubr
	quivalent  (if (not et) ... )
^
when
(when et e1 ... eN)	    fsubr
	value l'expression_test "et" puis, si la valeur est diffrente
	de nil, value en squence les e1 ... eN et ramne la valeur de eN.
	Si valuation de "et" donne nil, when ramne alors simplement nil.
	C'est un "if-then".
^
unless
(unless et e1 ... eN)		fsubr
	quivalent  (when (not et) ... )
^
cond
(cond i1 ... iN)	fsubr
	Les diffrents arguments i1 ... iN sont des listes appeles
	clauses qui ont la structure suivante:

	(a_test a1 ... aN)

	cond va choisir une seule de ces clauses, la 1ere dont
	valuation de son lment "a_test" est diffrente de nil.
	Les expressions a1 ... aN sont alors values en squence, et
	on sort de cond en ramenant la valeur de aN. Si la clause choisie
	n'a qu'un seul lment i.e. "(a_test)", la valeur ramene est
	celle de a_test: la valeur qui a prcisment dclench l'valuation
	de la clause.
	Si aucune des clauses n'est choisie, cond ramne nil.
^
selectq
(selectq e i1 ... iN)	fsubr
	Les diffrents arguments i1 ... iN sont des listes appeles
	clauses qui ont la structure suivante:

	(ob a1 ... aN)
	selectq value l'expression "e". Puis cette valeur est compare
	(avec equal) avec les "ob" des clauses (atomes, chanes
	ou nombres). Si la valeur de "e" est equalisable avec un de ces
	"ob", les a1 ... aN sont values en squences, et on sort du
	selectq en ramenant la valeur de aN.
	La dernire clause devra tre de la forme
	(t a1 ... aN)
	et les a1 ... aN seront values en squence en ramenant la valeur
	de aN, si aucun "ob" n'est equalisable avec la valeur de "e".

	On notera que lorsque un "ob" est une liste, le test consiste
	a regarder si la valeur de "e" a une occurrence comme lment de
	"ob", ce test occurrence tant fait avec member.
^
repeat
(repeat n e1 ... eN)	fsubr
	rpte n fois (si n est positif) valuation en squence des
	expressions e1 ... eN. Ne ramne en valeur rien de trs rgulier.
^
while
(while et e1 ... eN)	fsubr
	Tant que valuation de l'expression_test "et" donne un rsultat
	diffrent de nil, les expressions e1 ... eN sont values en
	squence. Ramne nil en valeur quand ce n'est plus le cas.
^
until
(until et e1 ... eN)	fsubr
	quivalent  (while (not et) ... )
^
do
(do ltriples test e1 ... eN)	macro
	macro d'itration.
	ltriples est une liste de triples chacun de la forme:
	(variable init step)
	test est de la forme
	(predicat es1 ... esN)
	"do" initialise en parallle (comme let e.g.) les variables
	des triples avec les valeurs des expressions "init".
	Puis teste le prdicat. Si bon, value les es1 ... esN en
	squence et sort du "do" en ramenant la valeur de "esN".
	Si pas bon, value les e1 ... eN.
	Puis affecte aux variables (toujours en parallle) les
	valeurs des expressions "step" et recommence le tout (i.e.
	le prdicat, le corps u.s.g.).
	Il est la  titre de curiosit.

^^Lambda
^
de
(de nom args corps)	fsubr
	dfinit une fonction de type "expr".
	La partie "args" peut tre:
	une liste de variables :  cas le plus ordinaire.
	une liste pointe :  dans ce cas, le reste des valeurs des
	paramtres actuels de l'appel positionns
	"a partir du point" sera rassemble en une
	liste et place dans la variable suivant
	le point.

	exemple: 
	((lambda (x y . z) corps) 1 2 3 4 5)
	x = 1, y = 2, z = (3 4 5)

	une variable : dans ce cas la liste des valeurs des paramtres
	actuel sera place dans la variable.

	exemple:
	((lambda x corps) 1 2 3)
	x = (1 2 3)

	On notera que les fonctions de type "expr" dfinies par "de", ou
	par lambda-expressions, sont "post-recursives", 
	et "co-post-recursives" en cas d'appels croiss.
^
df
(df nom args corps)	fsubr
	dfinit une fonction de type "fexpr".
	On notera que les "fexprs" ne sont pas "post-recursives".
	Une fexpr n'value pas ses arguments et le premier paramtre
	est lie  la liste de tous les arguments.
^
pretty
(pretty f1 .. fN)	fexpr
	vous fait un magnifique pretty-print des fonctions de nom
	f1 ... fN.
^
trace
(trace {nombre-de-ligne y-coordonne} nom1 ... nom-n) FEXPR
	naturellement, c'est une trace plus ou moins classique, avec
	l'exception toutefois, que la fonction N'EST PAS modifie, et
	reste donc (si elle l'tait) tail-recursive. La fonction
	trace est autoloade. 
	ATTENTION : afin d'viter tout effet de bord possible, la fonction
	trace utilise 

	1) le print interne (ce qui veux dire que - mme si
	vous avez redfini la fonction print (hein Daniel!?) - trace se
	comporte encore normalement. 
	2) pendant la trace, les macro-de-sortie sont inhibes (ceci, 
	puisqu'il existe des gens bizarre comme Daniel Goossens, qui 
	dfinissent des dmo avec effet de bord!).

	MAIS : si vous voulez que trace utilise une autre fonction 
	d'impression que celle disponible de manire standard, 
	redfinissez la fonction
	'traceprint' (aprs avoir regarde la dfinition par dfaut).

	Si le premier argument est de valeur numrique, il donne le nombre
	de lignes de la fentre de trace, le deuxime argument peut indiquer la
	ligne ou dbute cette fentre.
	Par dfaut, cette fentre prend les 12 premires lignes de l'cran.
^
untrace
(untrace ftn1 ftn2 ...) FEXPR
	enlve la trace des fonctions ftn1, ftn2, .. etc.
^
lambda
(lambda (v1 ... vN) e1 ... eN)	fsubr
	se ramne elle-mme par auto-quote.
^
let
(let ((v1 e1) ... (vN eN)) corps)	macro
	value les e1 ... eN dans l'environnement de l'appelant, puis
	lie les rsultats de valuation des eI aux variables vI
	correspondantes, et, dans ce nouvel environnement, value le
	corps.
	L'emploi de "let" est quivalent a
^%L
	((lambda (v1 ... vN) corps) e1 ... eN)

	Le second des exemples prcdents illustrant le "self"
	s'crira ici
^%L
	(let ((l '(a b c d)))
	  (if (cdr l) (self (cdr l)) (car l)))

	On notera que quand il n'y a qu'une seule variable on peut
	crire

	(let (v e) corps)
^
self
(self e1 ... eN)	fsubr
	ne marche que si on est dj dans une fonction dfinie. "self"
	value les expressions e1 ... eN et les passe en argument a
	cette fonction (d'o le nom de self).

	exemples:
	(lambda () (self))   boucle tout particulirement.
^%L
	((lambda (l)
	  (if (cdr l) (self (cdr l)) (car l)))
	 '(a b c d))

	->  d
^
letdic
(letdic arbvars arbvals e1 ... eN)	fsubr
	"arbvars" est une expression dont valuation doit donner
	un arbre de variables. "arbvals" est une expression dont
	valuation doit donner un arbre de valeurs.
	letdic tablit un contexte ou les variables de l'arbre de variables
	sont lies aux valeurs de l'arbre des valeurs en position
	homologues.
Dans ce contexte, les e1 ... eN sont values en squences en
	ramenant la valeur de eN.

	exemple:
^%L
	(letdic '(classe (numero . peres) . messages)
	  '(tortue (12 . mobile animal) av: dr:)
	  (print classe numero peres messages))
	
	imprimera:
	  tortue 12 (mobile animal) (av: dr:)
^
letdicq
(letdicq arbvars arbvals e1 ... eN)	fsubr
	comme letdic, mais arbvars n'est pas value.
^
letf
(letf (nom largs . corps) e1 ... eN)	fsubr
	redfinit dans la porte du letf la fonction "nom",
	lui donne le type EXPR, l'affuble de la liste d'arguments "largs"
	et du corps de fonction "corps".
	Ceci fait value en squence les e1 ... eN, ramne
	la valeur de eN, et revient en restituant ces anciennes
	caractristiques  la fonction "nom".

	L'exemple classique:
	(setq chose '(a b c))
	(letf (car (x) (cdr x)) (car chose)) -> (b c)
	(car chose) -> a

	On peut bien entendu redfinir temporairement des choses utiles.
^
closure
(closure lvars fonction)	subr 2
	"lvars" est une expression dont la valeur doit tre une liste
	de variables.
	Ramne une fermeture dans laquelle les variables sont "cltures".
	Cette fermeture est appelable comme une fonction normale, acceptant
	des arguments qui se trouveront lies aux paramtres de la "fonction"
	de l'appel de closure. Le corps de la fonction sera alors value
	dans un contexte o les variables cltures auront leur valeurs
	cltures. Leur affectation sera faite dans la closure, ne
	touchant pas au contexte externe.
	A l'intrieur d'une fermeture, la variable SELF contient la
	fermeture elle-mme (utile pour les appels rcursifs ou l'auto-
	passage de messages).
	Tous les chappements provoquent un basculement de contexte : les
	valeurs des variables sont re-cltures et celles du contexte
	externes sont rtablies.
	C'est une trs belle fonction utile.

	exemples:
	calcul de moyenne incrmental
^%L
	(de incmoy ()
	  (let ((n 0) (m 0))
	     (closure '(n m) (lambda (x)
	     (setq m (/ (+ x (* n m)) (incr n)))))))
^%L
		(setq m1 (incmoy) m2 (incmoy))
		(m1 1) -> 1	(m2 3)  -> 3
		(m1 5) -> 3     (m2 2)  -> 2
		(m1 7) -> 4	(m2 11) -> 5

	redfinition de cons, car, cdr, rplaca, rplacd.
^%L
	(de cons (car cdr)
	  (closure '(car cdr)
	   (lambda (m)
	     (m car cdr (lambda (z) (setq car z))
	        (lambda (z) (setq cdr z))))))

^%L
	(de car (cell) 
	    (cell (lambda (a d setcar setcdr) a)))
	(de cdr (cell)
	    (cell (lambda (a d setcar setcdr) d)))
	(de rplaca (cell x)
	    (cell (lambda (a d setcar setcdr) (setcar x) cell)))
	(de rplacd (cell x)
	    (cell (lambda (a d setcar setcdr) (setcdr x) cell)))

				la "classe" triangle
^%L
	(de faire-triangle (taille position)
	  (closure '(taille position) 'fonction-triangle))

^%L
	(de fonction-triangle message
	    (selectq (car message)
	      (TAILLE (setq taille (cadr message)))
	      (POSITION (setq position (cadr message)))
	      (VOIR (let (nb-etoiles 1)
	            (repeat taille
	            (princh " " (+ position (- taille nb-etoiles)))
	            (princh "*" (1- (+ nb-etoiles nb-etoiles)))
	            (terpri)
	            (incr nb-etoiles)))
	      "Vous devez tre srement trs content!")
	      (NATURE 'triangle)
	      (VALEURS ["taille" taille "position-en-colonne" position])
	      (MESSAGES "TAILLE <n>, POSITION <n>, VOIR, NATURE, VALEURS")
	      (t "je n'y comprends rien, ce doit tre MERVEILLEUX !!!")))
^
exit
(exit e1 ... eN)		fsubr
	ne marche que si on est dj dans une fonction dfinie. "exit"
	value en squence les expressions e1 ... eN et sort de la
	fonction, en ramenant la valeur de eN.

^
escape
(escape nom e1 ... eN)		fsubr
	value en squence les e1 ... eN, et si au cours d'une valuation
	de niveau quelconque, on trouve un appel de (nom a1 ... aM), on
	value en squence les expressions a1 ... aM, et on sort d'un
	coup de l'escape en ramenant aM en valeur.
	Si par contre, nul appel de (nom ... ) n'est trouve, escape ramne
	la valeur de la dernire expression eN.
^
lock
(lock f e1 ... eN)	fsubr
	f est une fonction. Les e1 ... eN sont values en squence.
	Si rien ne se passe on ramne la valeur de eN.
	Mais si un chappement se produit dans la porte du lock, lock
	le bloque et appelle la fonction avec 2 arguments.
	Le premier est le nom de la fonction chappement en question.
	Le second est la valeur ramene par la fonction chappement.

	lock value alors la fonction avec les arguments, et ramne
	en valeur l'appel de la fonction. Sauf si vous le relancez  la
	main dans f, chappement est passe aux oubliettes.

	exemple: si on avait  dfinir unwind-protect en vlisp

^%L
	(df protect (p . u)
	   (prog1
	      (lock
	         (lambda (f l) (f (eprogn u) l))
	         (eval p))
	      (eprogn u)))

	ou p est la partie  valuer sous protection
	   u la partie  valuer sans protection.
   
	la lambda est appele seulement en cas chappement
	f est le nom de la fonction chappement qu'on veut bloquer.
	l est la valeur qu'elle doit ramener.

	Cet exemple rare est du  Eugen Neidl.
^
unwind-protect
(unwind-protect expression-protege e1 e2 ... eN)	fsubr

	ide: cas normal: l'expression protge est value, puis les e1 e2 ...
	en squence et on ramne la valeur de expression-
	protge, un 'prog1' en somme.
	cas spcial:
qqpart dans la forme-protege il y a un appel de fonction-
	escape, au lieu de rentrer immdiatement avec la 
valeur on value en squence quand mme les e1 e2 ...
	de l'unwind-protect, puis on rentre de l'escape
	comme d'habitude avec les bonnes valeurs usuelles.
	NOTER que les e1 ... eN se font valuer dans le
	contexte de l'appel  unwind-protect.
	exemple:
^%L
	(de foo1 ()
	  (unwind-protect (foo2) (print "et de un")))
^%L
	(de foo2 ()
	  (unwind-protect (foo3) (print "et de deux")))
^%L
	(de foo3 () (f 'vu?))
^%L
	(escape f (foo3))  -> vu?.
	(escape f (foo2))  -> imprime "et de deux" et ramne vu?.
	(escape f (foo1))  -> imprime "et de deux" "et de un" et ramne vu?.
^
unwind
(unwind)		subr 0
	redescend toute la pile comme un chappement jusqu'au top-level,
	en dliant toutes les variables.
	Est attrap par: unwind-protect, lock.

^
mapc
(mapc l f)		expr
	applique la fonction mono-argument f  tous les lments en
	succession de la liste l. Ramne nil.
	exemples:
	(mapc '(a b c) (lambda (x)(print x)))
	imprime:
		a
		b
		c
		et ramne nil
	la mme chose plus compacte:
	(mapc '(a b c) 'print)
	imprime:
		a
		b
		c
		et ramne nil
^
mapcar
(mapcar l f)		expr
	Ramne la liste des rsultats de l'application de la fonction mono-
	argument f  tous les lments en squence de la liste l.
	exemple:
	(mapcar '(a b c) (lambda (x)(print x)))
	imprime:
		a
		b
		c
		et ramne (a b c)
^
mapct 
(mapct -l- -f- -x-) fsubr
	le mapcar arborescent : seules les valeurs non nulles de (-f- (car -l-))
	sont construites dans le rsultat final
	exemple :
^%L
	(mapct '(a 1 b 2 c 3) (lambda (x) (when (numbp x) x)))  ->  (a b c)
^%%prog
^%%(prog lvars e1 ... eN)	fexpr
^%%	fabrique un contexte ou les variables de la liste de variables lvars
^%%	sont lies  nil. Puis value en squence les e1 ... eN. Ces
^%%	derniers peuvent tre des atomes: dans ce cas ce sont des etiquettes
^%%	qui ne seront pas values. Ou tre des listes: dans ce cas 
^%%	valuation. Si ya pas occurrence d'appel de la fonction "return", 
^%%	prog ramne nil.
^%%
^%%	Notez que "return" et "go" agissent comme des chappements en ce
^%%	qui concerne le retablissement correct des contextes.
^%%^
^%%return
^%%(return e)			expr 1
^%%	sort du prog immdiatement englobant en ramenant la valeur de
^%%	l'expression e.
^%%^
^%%go
^%%(go etiq)			fexpr
^%%      reprend valuation du corps du prog courant  partir de l'etiquette
^%%      "etiq".
^%%
^^Macros et macro-caracteres
^
dm
(dm nom args corps)	fsubr
	dfinit une fonction de type "macro".
	On notera que les "macros" ne sont pas "post-recursives".
	Le paramtre d'une macro sera lie  la forme de l'appel mme.
	La macro value le corps de la macro et ensuite elle value
	le rsultat de valuation du corps!
^
defmacro
(defmacro nom args corps)	macro
	Macro gnratrice de macros. Produit une macro de mme nom,
	mais ou les variables de l'arbre de variables "args" sont
	associes aux lments en position correspondante de l'appel
	de macro. C'est difficile  comprendre mais simple  utiliser.
	Exemples:

	Une boucle for incrmentante.

^%L
	(defmacro for (var bas haut . corps)
	  `((setq ,var ,bas)
	    (while (< ,var ,haut)
	       ,@corps
	       (incr ,var))))

	Un accs pratique.

^%L
	(defmacro quatrieme (liste)
	  `(caddr (cdr ,liste)))

	Voil, pour l'tudier, comment en vlisp est dfinie defmacro.
	C'est en fait assez vident, aprs rflexion, et ce n'est
	pas inlgant.

^%L
	(dm defmacro (call)
	  `(dm ,(cadr call) (call)
	       (letdicq ,(caddr call) (cdr call) 
	         (rplacb call (progn ,@(cdddr call))))))
^
macroexpand
(macroexpand e)		subr 1
	Ramne le rsultat de l'expansion de e vu comme un appel de macro
	(la macro tant dfinie par dm). Trs pratique pour tester
	ses macros.
^
backquote
	c'est un dispositif typographique mettant en jeu les caractres
	`  ,  et  @.
	Exemples d'utilisation:
^%T3
		`(a b c)		->	(a b c)
	avec x=(d e), y=g		
		`(a b c ,x f)		->	(a b c (d e) f)
		`(a b c ,@x f)		->	(a b c d e f)
		`(a b ,(cadr x) . ,y)	->	(a b e . g)

	En bref, dans la porte du backquote, c'est--dire  l'intrieur de
	`( ... ), une expression prcde de (,) donne sa
	valeur qui est insre comme ELEMENT dans le rsultat final.
	Une expression prcde des caractres (,@) donne sa valeur
	qui est insre comme SEGMENT dans le rsultat final.
	Trs pratique pour crire des macros lisibles par l'il humain.
	Notez que hors de la porte de backquote (,) et (@) se comportent
	comme d'habitude.
^
quasiquote
(quasiquote . a)  fsubr
	Fonction rsultant de l'utilisation de la backquote.
^
diese
	C'est encore un autre dispositif typographique. Si dans votre
	texte vlisp vous placez:
	#/<un-caractere>		e.g. #/A
	c'est le code ascii de ce caractre qui est insr (65 dans 
	l'exemple) Si vous placez:
	#^<un-caractere>		e.g. #^A
	c'est le code ascii de ce caractre de contrle qui est insr.
	(1 dans l'exemple).
	Assez pratique pour crire des commandes d'diteurs.
	Notez que les caractres de contrle sont compris dans l'intervalle
	de 0  31 : #^@ #^A #^B ... #^Z #^[ #^\ #^] #^^ #^_
	et que le caractre ESCAPE est #^[, c'est  dire 27
^
dmc
(dmc a args corps)	fexpr
	dfinit un "macro-caractere". A la place de "a" vous pouvez
	avoir un nom de 1 caractre ou une chane de 1 caractre.
	Lorsque bVLISP lira ce caractre, il lancera valuation
	du corps, les variables de la liste d'arguments "args"
	serviront de variables locales si besoin est. Puis le rsultat
	de valuation sera place  la place du dit caractre dans
	le flot d'entre.
	Une vision de "dmc" est qu'il s'agit d'une fonction d'entre.

	exemples:
^%L
	(dmc "&" () ['VAR (read)])  ->  &
^%L
	'(a b &v c &w)  ->  (a b (VAR v) c (VAR w))
^%L
	(dmc { () (let (x 'ENSEMBLE) (and (neq x '}) [x . (self (read))])))
	(dmc } () '})
^%L
	'{a b c d}  ->  (ENSEMBLE a b c d)
^
dmo
(dmo nom largs e1 ... eN)	fsubr
	pour dfinir des "macros de sorties".
	Lorsque une impression est faite d'une liste dont le car
	est le "nom", le reste de la liste est lie aux arguments
	de la liste largs. Les e1 ... eN sont alors values en squence.
	Dans les eI un ordre d'impression sera alors incorpore au flot
	de sortie.

	exemple:
	(dmo quasiquote e (prin1 "`" e))

	Ca permet d'une faon gnrale de contrler un tant soit peu
	l'allure de l'impression des listes.

^^Prdicats
^
atom
(atom e)		subr 1
	ramne nil si e est une liste. Ramne au contraire "t" si
	e est une non-liste, i.e. un nombre, un atome littral, ou une chane.
^
listp
(listp e)		subr 1
	ramne "t" si e est une liste, nil si e n'est pas une liste.
^
numbp
(numbp e)		subr 1
	ramne "t" si e est un nombre, nil sinon.
^
litatom
(litatom e)		subr 1
	ramne "t" si e est un atome littral, nil sinon.
^
stringp
(stringp e)		subr 1
	teste si e est une chane. t si vrai, nil sinon.
^
null
(null e)	subr 1
	teste si e est nil. Ramne "t" si oui, "nil" si non.
	On notera que la fonction "not" a exactement le mme effet.
^
eq
(eq e1 e2)	subr 2
	teste si l'expression e1 pointe sur le mme lieu en mmoire
	que l'expression e2.
	teste aussi, si e1 et e2 sont des nombres, si ce sont les mmes.
	Ramne "t" si oui, "nil" si non.
	Peut galement crire: (= e1 e2).
^
=
(= n1 n2)	subr 2
	teste si n1 = n2. Ramne "t" si oui, "nil" si non.
	Peut aussi crire (eq n1 n2).
^
equal
(equal e1 e2)	subr 2
	selon les cas:
		si e1 et e2 sont des listes, ramne "t" si elles sont mutuellement copies.
		si e1 et e2 sont des nombres, ramne "t" si e1 et e2 sont le mme nombre.
		si e1 et e2 sont des chanes, ramne "t" si elles sont identiques.
		si l'un est un atome et l'autre une chane c'est le 
			nom de l'atome qui est compare  la chane ex:  (equal 'foo "foo") -> t
		si e1 et e2 sont autre chose, ramne "t" si e1 et e2
			occupent la mme adresse en mmoire.
		ramne nil dans tous les autres cas.
^
neq
(neq n1 n2)	subr 2
	Teste si n1 est diffrent de n2. Ramne "t" si oui, "nil" si non.
^
>
(> n1 n2)	subr 2
	Teste si n1 est > n2. Ramne "t" si oui, "nil" si non.
^
ge
(ge n1 n2)	subr 2
	Teste si n1 est suprieur ou gal  n2.
	Ramne "t" si oui, "nil" si non.
^
<
(< n1 n2)	subr 2
	Teste si n1 < n2. Ramne "t" si oui, "nil" si non.
^
le
(le n1 n2)	subr 2
	teste si n1 est infrieur ou gal  n2. Ramne "t" si oui,
	"nil" si non.
^
zerop
(zerop n)	subr 1
	teste si n est gal  zro. Ramne t si oui, nil sinon.
^
or
(or e1 ... eN)		fsubr
	value successivement les diffrentes expressions eI jusqu'
	ce que l'une de ces valuations ait une valeur diffrente de nil.
	"or" ramne alors cette valeur. Noter que  (or) -> nil.
^
and
(and e1 ... eN)		fsubr
	value successivement les diffrentes expressions eI. Si la valeur
	d'une de ces expressions est nil, "and" ramne nil sinon "and"
	ramne la valeur de eN. Noter que (and) -> t.
^
not
(not e)		subr 1
	fait exactement comme (null e)
^^Instructions relatives aux listes
^
car
(car e)		subr 1
	ramne le car de e.
	Dans une autre vision "car" ramne le premier lment de "e".
	On notera que (car 'un_atome) -> la CVAL de cet atome.
	exemple:
^%L
	(car nil) -> nil.
	(car '(a b c)) -> a
	(setq foo 5) (car 'foo)  ->  5
^
cdr
(cdr e)		subr 1
ramne le cdr de e, c..d. la liste e sans le premier lment.
	On notera que (cdr nil) -> nil. Pour un atome, cdr ramne sa P-liste.
	exemple:
	(cdr '(a b c)) -> (b c)
^
cons
(cons e1 e2)	subr 2
	Construit une nouvelle liste dont le car est e1 et le cdr est e2.
	ramne le cons de e1 et e2. Peut aussi crire: [e1 . e2]
	exemple:
	(cons '(a b) '(c d)) -> ((a b) c d)
^
caar
(caar e)	subr 1
	ramne le car du car de e.
	exemple:
	(caar '((a b c) d e f)) -> a
^
cadr
(cadr e)	subr 1
	ramne le second lment de e.
	exemple:
	(cadr '((a b c) d e f)) -> d
^
cdar
(cdar e)	subr 1
	ramne le cdr du car de e.
	exemple:
	(cdar '((a b c) d e f)) -> (b c)
^
cddr
(cddr e)	subr 1
	ramne le cdr du cdr de e.
	exemple:
	(cddr '((a b c) d e f)) -> (e f)
^
caaar
(caaar e)	subr 1
	ramne le car du car du car de e.
	exemple:
	(caaar '(((a b c) d) e f)) -> a
^
caadr
(caadr e)	subr 1
	ramne le car du car du cdr de e.
	exemple:
	(caadr '((a b c) (d e f))) -> d
^
cadar
(cadar e)	subr 1
	ramne le car du cdr du car de e.
	exemple:
	(cadar '((a b c) (d e f))) -> b
^
caddr
(caddr e)	subr 1
	ramne le troisime lment de e.
	exemple:
	(caddr '((a b c) (d e f) (g h i))) -> (g h i)
^
cdaar
(cdaar e)	subr 1
	ramne le cdr du car du car de e.
	exemple:
	(cdaar '(((a b c)) (d e f) (g h i))) -> (b c)
^
cdadr
(cdadr e)	subr 1
	ramne le cdr du car du cdr de e.
	exemple:
	(cdadr '((a b c) (d e f) (g h i))) -> (e f)
^
cddar
(cddar e)	subr 1
	ramne le cdr du cdr du car de e.
	exemple:
	(cddar '((a b c) (d e f) (g h i))) -> (c)
^
cdddr
(cdddr e)	subr 1
	ramne le cdr du cdr du cdr de e.
	exemple:
	(cdddr '((a b c) (d e f) (g h i) j)) -> (j)
^
nth
(nth n l)	subr 2

	ramne le (n-1)-me cdr de la liste l.
	exemple:
	(nth 3 '(a b c d e)) -> (c d e)
^
n
(n l)		subr 1
	"n" est un nombre: ramne le n-me lment de la liste l.
	exemple:
	(2 '((a b)(c d)(e f))) -> (c d)
^
list
(list e1 ... eN)	fsubr
	ramne la liste des valeurs de e1 ... eN.
	Peut crire aussi: [e1 ... eN].
^
mcons
(mcons e1 ... eN)	nsubr
	ramne la "liste pointe" des valeurs de e1 ... eN.
	exemple:
	(mcons 1 2 3) -> (1 2 . 3)

	L'exemple peut aussi crire: [1 2 . 3]
	Une autre vision de "mcons" est qu'il place les lments
	e1 ... eN-1 en tte de eN, si eN est une liste.
^
append
(append e1 e2)	subr 2
	selon les cas,
	- e1 et e2 listes : concatne une copie de e1  e2, et ramne
	cette concatnation.
	- e1 pas une liste: mme effet que [e1 . e2].
	- e1 liste et e2 pas une liste: concatne une copie de e1  [e2] et ramne
	cette concatnation.

	Trs pratique.
	Notez cependant que "nil" est toujours neutre

	(append CHOSE nil)  ->  CHOSE.
	(append nil CHOSE)  ->  CHOSE.

	Pour mettre "nil" en fin d'une liste faites

	(append LISTE [nil])
^
length
(length l)	subr 1
	ramne le nombre lments de la liste l
	exemple:
	(length '((a b)(c d)(e f))) -> 3
^
last
(last l n)	subr 2
	ramne les n derniers lments de la liste l
	exemple:
	(last '(a b c d e) 2)   ->   (c d)
	si n est omis last ramne le dernier cdr de l
	exemple:
	(last '(a b c d e))      ->      (e)
	dans le cas d'une liste pointe last ramne vraiment
	le(s) dernier(s) cdr(s)
	exemple:
	(last '(a b c . d))	->	 (c . d)
	attention: c'est un pointeur dans la liste originale l
	qui est ramene, pas une copie!
^
evlis
(evlis l)	subr 1
	ramne la liste des valeurs des lments de la liste l.
^
reverse
(reverse e1 e2)	subr 2
	ramne une copie inverse de la liste e1 si e2 est nil.
	Sinon ramne la concatnation de cette copie inverse  la
	liste e2.

	exemples:
	(reverse '(a b c))        -> (c b a)
	(reverse '(a b c) '(d e)) -> (c b a d e)
^
delete
(delete e l)		subr 2
	livre une copie de la liste "l" d'ou toutes les occurrences
	au premier niveau de l'expression "e" ont t limines.
	le test occurrence est fait avec la fonction "equal".
	exemple:
	(delete '(a) '((a)(b) c (a) a d)) -> ((b) c a d)
^
delq
(delq e l)		subr 2
	Comme delete mais le test occurrence est fait avec la fonction "eq".
^
member
(member e l)		subr 2
	teste si une occurrence de l'expression "e" apparat au premier
	niveau de la liste "l". Si c'est le cas, member ramne cette
	partie de "l" ou apparat en tte la premire occurrence de "e".
	Si "e" n'apparat pas dans "l"  ce premier niveau, member ramne
	nil.
	Le test occurrence est fait avec la fonction "equal".
	exemple:
	(member '(a) '(a (b) (a) c)) -> ((a) c)
^
memq
(memq e l)	subr 2
	Comme member mais le test occurrence est fait avec la fonction "eq".
^
vmemq
(vmemq at l)  subr 2
	Comme memq, mais recherche  tous les niveaux de la liste.
^
nmemq
(nmemq at l)  subr 2
	Si 'at' est un lment de 'l', la liste du reste 
	des lments est ramene, sinon ramne nil
^%L
	(nmemq 'a (k a b c)) -> (b c)
^
copy
(copy l)	subr 1
	ramne une copie de la liste l.
^
copy-all
(copy-all e) subr 1
	copie l'expression e, avec toutes les annotations.
^
subst
(subst new old e)	subr 3
	ramne une copie de e ou toutes les occurrences de old sont
	remplaces par new.
	Le test occurrence est fait avec equal.
	exemple:
	(subst 'A 'a '(a b a c)) -> (A b A c)
^
a-listes
	Une a-liste (ou liste d'associations) est une liste de sous-listes.
^
assoc
(assoc e a)	subr 2
	Ramne le 1er couple de "a" ou "e" est occurrente en partie gauche.
	Si il n'y a pas, ramne nil.
	le test occurrence est fait avec equal.
^
assq
(assq e a)	subr 2
	Comme assoc, mais le test occurrence est fait avec eq.
^
pairlis
(pairlis e1 e2 a)	subr 3

	construit et concatne  "a" une a-liste formes des lments
	de e1 en partie gauche et des lments de mme rang de e2 en
	partie droite.
^%L
	(pairlis '(a b c) '(1 2 3) '((d . 4)(e . 5)))
	->  ((a . 1)(b . 2)(c . 3)(d . 4)(e . 5))
^
sublis
(sublis a e)		subr 2
	construit une copie de e ou toutes les occurrences des parties
	gauches des couples (paires pointes) de "a" sont remplaces par leur partie droite.
	Le test occurrence est fait avec equal.
^%L
	(sublis '((a . A)(c . C)) '((a . 1)(b . 2)(c . 3)(d . 4)(e . 5)))
	->  ((A . 1)(b . 2)(C . 3)(d . 4)(e . 5))
^^Instructions relatives aux atomes
^
atomes
	Un atome est en mmoire un groupe de cellules:
	D'abord la c-val: valeur de l'atome vu comme une variable 
	(accessible par (car 'NOM-ATOME). Quand la variable 
	n'est pas encore affecte elle contient l'adresse 
	de l'atome
	(trs) spcial "undef".
	Puis:
	p-val:
	c'est une p-liste. 
	f-val:
	c'est une cellule ou est mise l'adresse de l'atome
	vu comme une fonction. Adresse de code-C si c'est
	une fonction standard, adresse de liste si c'est
	une fonction dfinie par nous utilisateurs.
	Accessible par (fval 'NOM-ATOME).
	f-typ:
	c'est le type de la fonction. C'est un petit entier.
	Accessible par (ftyp 'NOM-ATOME).
	ival: 
	c'est une cellule ou sont stockes les valeurs
	internes, principalement pour la
	documentation. (accessible avec (ival 'nom)
	p-nom:
	c'est l'adresse d'une chane de caractre, qui est
	le nom,  lire ou crire de l'atome.
	Il y a d'autres champs, mais ils sont exprimentaux, et pas accessibles
	en vlisp de toute faon.
^
p-listes
	Une p-liste (ou liste de proprits) d'atome est range dans la partie 
	p-val de cet atome, et est accessible (bien que ce ne soit pas en 
	gnral ncessaire) par (cdr 'NOM-ATOME).
	Elle est organise comme:
		(attribut1 valeur1 ... attributN valeurN)
	Tant qu'on veut. C'est une a-liste deparenthse!
^
get
(get at attribut)		subr 2
	Ramne la valeur associe  l'attribut sur la p-liste de l'atome.
	nil si l'attribut n'existe pas.
^
put
(put at attribut valeur)	subr 3
	Place (ou remplace) la valeur associe  l'attribut sur la p-liste
	de l'atome. Ramne l'atome en valeur.
^
addprop
(addprop at attribut valeur)	subr 3
	Place en tte de la p-liste de l'atome l'association 
	attribut-valeur. Ne tient pas compte si l'attribut existe dj ou 
	nom. Ramne l'atome en valeur.
^
remprop
(remprop at attribut)		subr 2
	Enlve la 1ere occurrence dans la p-liste de l'atome de l'association
	attribut-valeur.
	Ramne l'atome en valeur.
^
gensym
(gensym . l)		subr n
	Plusieurs cas:
	(gensym)  ->   un atome de la forme g00N avec N incrment  chaque appel.

	(gensym e1 ... eN)
	fait comme strcat, mais le rsultat n'est pas
	une chane, mais un atome.
	Notez que (gensym s) ou "s" est une chane donne un atome qui
	aura pour p-nom une copie de la chane "s".
^
explode
(explode e)		subr 1
	Fabrique une liste d'atomes mono-caracteres forme de tout ce qui
	aurait t imprime si vous aviez demande l'impression de "e".
	"e" peut tre n'importe quoi d'imprimable: atome, chane, liste,
	nombre ...
	exemples:
	(explode 122) -> (1 2 2)
	(explode 'atom) -> (a t o m)
^
implode
(implode e)		subr 1
	"e" est une liste d'atomes mono-caracteres. Fait avec ce que
	vlisp aurait fait si vous aviez tape ces caractres au clavier,
	l'un  la suite de l'autre.
	Cela peut donner une liste ou un atome.

^
atoi
(atoi e)		subr 1
	"e" est un atome ou une chane mono-caracteres. "atoi" ramne alors
	l'entier qui est le code ascii de ce caractre. Si l'atome ou la 
	chane ne sont pas mono-caracteres, seul le 1er caractre est pris 
	en compte.
^
itoa
(itoa n)		subr 1
	Ramne un atome mono-caractere qui a pour p-nom le caractre de code
	ascii "n". Si cet atome n'existe pas dj il est cre.
^
remob
(remob at)		subr 1
	Elimine physiquement l'atome du systme. Ramne l'atome en valeur,
ce qui n'est paradoxal que en apparence.
^
fval
(fval e1 e2)		subr 2
	si e2 est nil, ramne la valeur fonctionnelle de e1.
	exemple:
	(de foo (x) (+ (car x) (truc (cdr x))))

	(fval 'foo) -> ((x) (+ (car x) (truc (cdr x))))

	si e2 n'est pas nil, e2 est place comme valeur fonctionnelle
	de e1.
	exemple:
	(fval 'foo '((x y) (* (+ x y) (- x y))))

	Dans les 2 cas, la valeur ramene est la valeur fonctionnelle de e1.
^
ftyp
(ftyp e1 e2)		subr 2
	si e2 est nil, ramne le type fonctionnel de e1.
	Ce type est:
^%T2
		0	pour une non-fonction.
		1	pour une subr  0 argument.
		2	pour une subr  1 argument.
		3	pour une subr  2 arguments.
		4	pour une subr  3 arguments.
		5	pour une subr  n arguments.
		6	pour une fsubr.
		7	pour une expr.
		8	pour une fexpr.
		9	pour une macro.
		10	pour une fonction-escape.
		11	pour une macro-de-sortie (dfinie par dmo).

	exemples:
^%L
	(ftyp 'car)  ->  2.
	(de foo (x) [x x])
	(ftyp 'foo)  ->  7.

	Si e2 n'est pas nil, e2 DOIT tre un des types dcrits, ce type
	est alors affecte  e1. A utiliser avec prcautions !
	Dans les deux cas le type final est ramne en valeur.

^^Instructions relatives aux nombres
^
flottants
	bVLISP autorise les entres-sorties de constantes flottantes.
	Elles s'crivent comme suit:

^%T2
		le caractre "-" ou rien	SUIVI DE 
		chiffre(s)			SUIVI(S) DE
		le caractre "."		SUIVI DE
		chiffre(s)	

	exemples:
	1.1  0.056  -0.00145  12345.6    52000.0   0.0   3.14159

	ou si c'est TRES grand ou petit:

^%T2
		le caractre "-" ou rien	SUIVI DE
		chiffres(s)			SUIVI(S) DE
		le caractre "e"		SUIVI DE
		le caractre "+" ou "-"		SUIVI DE
		chiffre(s)	

	exemples:
		12e+045   0e-012   -14e+123

	Les erreurs de dbordement flottant sont trappes, vlisp se
	plaint et vous met au top-level.

	Dans les fonctions flottantes suivantes on peut mlanger
	entiers et flottants, la rgle est que s'il n'y a pas de flottants
	comme arguments le rsultat sera entier, mais s'il y a au moins
	un flottant en argument, le rsultat est flottant.
	Ceci pour les fonctions numriques.
	Mme rgle pour les prdicats, en cas de flottaison d'un argument,
	la comparaison est faite comme si tous les arguments taient
	flottants par conversion automatique.

	(+ n1 n2)
	(- n1 n2)	et  (- n)
	(* n1 n2)
	(/ n1 n2)

	(=  n1 n2)
	(>  n1 n2)
	(ge n1 n2)
	(<  n1 n2)
	(le n1 n2)

	exemple d'utilisation:

^%L
	  (de fac (n)
	    (if (= n 0) 1 (* n (fac (- n 1)))))

	puis:

^%L
	  (de caf ()
	    (let ((n 1.0))
	      (print "fac" (fix n) (fac n))
	      (self (+ n 1))))

	et on appelle:

	  (caf)
^
+
(+ n1 n2)	subr 2
	ramne la somme de n1 et n2.
^
-
(- n1 n2)	subr 2
	ramne la diffrence de n1 et n2.

(- n)		subr 1
	ramne l'oppose de n.
^
*
(* n1 n2)	subr 2
	ramne le produit de n1 et n2.
^
/
(/ n1 n2)	subr 2
	divise n1 par n2,
	ramne la partie entire du quotient de n1 par n2 si n1 et n2
	sont des entiers, le quotient rel sinon.
^
rem
(rem n1 n2)	subr 2
	ramne le reste de la division entire de n1 par n2.
^
1+
(1+ n)		subr 1
	ramne le successeur de n.
^
1-
(1- n)		subr 1
	ramne le prdcesseur de n.
^
ibase
(ibase n) subr 1
	si l'argument n est omis, (ibase) donne la base courante de lecture
	des nombres, sinon, ca affecte la variable ibase avec la valeur de 
	n. Cette variable dtermine la base des nombres en entre. A 
	l'initialisation du systme la base d'entre est 10. Pour la 
	changer, il suffit d'affecter cette variable avec la bonne valeur.
	Ainsi, aprs avoir fait:
	(ibase 2)
	a la lecture:
	1010 sera gal  10 (dcimal)
	et 1111 sera gal  15 (dcimal)

	Naturellement, si vous avez une base plus grande que 10, afin 
	d'entrer des nombres se composant exclusivement de lettres, 
	vous devrez le faire prcder par un '0'.

	si vous donnez une valeur infrieure  1 ou une valeur plus grande 
	que 62 (dcimal)  ibase, le comportement du systme n'est plus 
	garanti.
^
obase
(obase n) subr 1
	si l'argument n est omis, (obase) donne la base courante d'criture
	des nombres, sinon, ca affecte la variable obase avec la valeur de 
	n. Cette variable dtermine la base des nombres en sortie. A
	l'initialisation du systme la base de sortie est 10. Pour la 
	changer, il suffit d'affecter cette variable avec la bonne valeur.
	Ainsi, aprs avoir fait
	(obase 2)
	valuation de
	10 imprimera 1010 (binaire)
	et 15 donnera 1111 (binaire)

	si vous donnez une valeur infrieure  1 ou une valeur plus grande
	que 62 (dcimal)  obase, le comportement du systme n'est plus 
	garanti.
^
random
(random n)		subr 1
	ramne un entier non-negatif alatoire modulo n.
	On peut initialiser soi-mme (pour rendre rptable) cette
	fonction en faisant:
	(setq random UN-ENTIER) puis
	(random) pour initialiser le random et
	(random n) pour tirer des valeurs alatoires.
^
lognot
(lognot n)		subr 1
	ramne le complment logique de n.
^
logand
(logand n1 n2)		subr 2
	ramne le et logique de n1 et n2.
^
logor
(logor n1 n2)		subr 2
	ramne le ou logique de n1 et n2.
^
logxor
(logxor n1 n2)		subr 2
	ramne le ou exclusif logique de n1 et n2.
^
logshift
(logshift n1 n2)	subr 2
	ramne n1 dcale  gauche de n2 cran: si n2 est >= 0,
	sinon dcale  droite de n2 crans.
^
fix
(fix n)		subr 1		
	donne l'entier converti du flottant n.
^
float
(float n)	subr 1		
	donne le flottant converti de l'entier n.
^
sqrt
(sqrt n)	subr 1		
	donne la racine carre du flottant n.
^
sin
(sin n)		subr 1		
	donne le sinus du flottant n (n est exprime en radians).
^
cos
(cos n)		subr 1		
	donne le cosinus du flottant n (n est exprime en radians).
^
asin
(asin n)	subr 1
	donne l'arc sinus du flottant n (l'angle retourn est exprim
	en radian compris entre -PI/2 et PI/2)
^
acos
(acos n)	subr 1
	donne l'arc cosinus du flottant n (l'angle retourn est exprim
	en radian compris entre 0 et PI)
^
atan
(atan n)	subr 1
	donne l'arc tangente du flottant n (l'angle retourn est exprim
	en radian compris entre -PI/2 et PI/2)


^^Instructions relatives aux chanes
^
chanes
	Il y a des chanes de caractres en vlisp.
	Une chane s'crit "SUITE-DE-CARACTERES".
	exemples:
		"abc"
		"ab
		 c"
	Une chane peut tre de longueur quelconque.
	Dans la chane on peut mettre \n  pour placer un 'fin-de-ligne'
		\t  pour une tabulation
		\r  pour un carriage-return (CR)
		\b  pour un back-space.
		\0<nombre-octal> pour placer le caractre correspondant, exemple:  "BE\07P"
		\<caractre> pour placer le caractre correspondant, exemples:  "anti\\slash"  "double\"quote"

	Le caractre delimiteur-de-chaine (") est redfinissable comme d'habitude.
	Les chanes sont garbage-collectes. (voir galement (aide 'ANTISL))
^
dupl
(dupl e n)		subr 2
	fabrique une chane forme de la concatnation de n copies de e.
	e peut tre un atome ou une chane.
	Si n <= 0, e est ramne.
^
strcmp
(strcmp e1 e2)		subr 2
	pour la comparaison lexicographique de e1 et e2, chanes ou atomes.
	ramne un entier ngatif si e1 <LEX e2.
	 zro		 si e1 =LEX e2.
	 un entier positif si e1 >LEX e2.
^
strlen
(strlen str) subr1
	retourne la longueur de la chane donne en argument.
^
strcat
(strcat e1 e2 ... eN)	nsubr
	fabrique une chane forme de la concatnation de copies des
	e1 ... eN.
	Les e1 ... eN peuvent tre des atomes, des chanes, ou des nombres,
	mmes ngatifs!
	Notez que (strcat at) ou "at" est un atome donne une copie de la
	chane qui est le p-nom de "at".
^
strcar
(strcar e n)		subr 2
	ramne 1 chane forme des n 1ers caractres de e, atome ou chane.
	Si n est absent on prend le 1er caractre.
^
strcdr
(strcdr e n)		subr 2
	ramne une copie de la chane (ou atome) e ampute de ses n 1ers
	caractres. Si n est absent on en enlve 1 caractre.
^
plength
(plength atom) subr 1
	vous donne le nombre de caractres de l'atom donne en argument
^
strincp
(strincp str1 str2) subr 2
	Si 'str1' fait partie de 'str2' ramne t, nil si non.

	Par exemple le programme suivant ramne la liste des lments a
	l'intrieur de 'l' qui contiennent la chane 'str'.

^%L
	(de index (str l)                                                               
	    (if	(or (null l) (atom l)) 'mauvais-arguments
	       (m-index str l)))

        ; auxiliaire de index
^%L
	(de m-index (str l)
	    (cond
	    	((null l) ())
	        ((strincp str (car l))
	            (cons (car l) (m-index str  (cdr l) )))
	        (t (m-index str (cdr l) ))))

^%% bufstr
^%% (bufstr)   subr 0
^%%	?


^^Affectations et Modifications physiques
^
setq
(setq v1 e2 ... vN eN)	fsubr
	place les rsultats de valuation des eI dans les variables vI
	correspondantes. Evaluation se fait en squence. La valeur
	ramene est celle de eN.
^
set
(set e1 e2)		subr 2
	place le rsultat de valuation de e2 dans le lieu (variable ou
	place dans une liste) rsultat de valuation de e1. Ramne la
	valeur de e2.

	exemples:
^%T2
	(set 'x 1) -> 1			et affecte 1  la variable x.
	(setq y '(a b)) -> (a b)	si je fais suivre par:
	(set y 1) -> 1			la nouvelle valeur de y 
	 	 			sera (1 b),
	(set (cdr y) 2) -> 2		et la nouvelle valeur de y
		 		    	sera (1 2).
^
deset
(deset a e)		subr 2
	Lie les variables de l'arbre de variables "a" aux lments de
	l'expression "e" en position correspondante, et ramne t pour
	faire bonne mesure. Il s'agit d'une affectation: les anciennes
	valeurs des variables sont perdues.

	exemple:
^%L
	(deset '(parents (serpent . enfants)) 
		'((adam eve) (Sss Cain)))

	va lier:
^%T3
		parents 	A	 (adam eve)
		serpent 	A	 Sss
		enfants 	A	 (Cain)

	pour ce que ca vaut.
^
rplaca
(rplaca e1 e2)		subr 2
	agit comme "set", mais ramne e1 en valeur.
^
rplacd
(rplacd e1 e2)		subr 2
	remplace le cdr de e1 par e2, et ramne e1 en valeur.
^
rplacb
(rplacb e1 e2)		subr 2
	remplace le car de e1 par le car de e2, remplace galement
	le cdr de e1 par le cdr de e2, et ramne e1 en valeur.
^
rplac
(rplac e1 e2 e3)	subr 3
	remplace le car de e1 par e2, et remplace galement le cdr
	de e1 par e3, et ramne e1 en valeur.
^
nextl
(nextl v)		fsubr
	ramne le car de la liste contenue dans la variable v, et "avance"
	dans la liste.

	exemples:
^%T3
	(setq x '(a b c))  	->	  (a b c)
	(nextl x)	   	->	  a
	x		   	->	  (b c)
^
newl
(newl v e)		fsubr
	"conse" en tte de la liste contenue dans la variable v, le rsultat
	de valuation de e, et ramne e en valeur.

^%T3
	exemples:
	(setq x '(b c))    	->	  (b c)
	x			->	  (b c)
	(newl x 'a)		->	  a
	x			->	  (a b c)
^
incr
(incr v)	fsubr
	affecte  la variable v le successeur de sa valeur, et ramne
	cette valeur.

(incr v n)	fsubr
	comme incr, mais c'est la valeur de n et non 1 qui est ajoute  la
	variable v.
^
decr
(decr v)	fsubr
	affecte  la variable v le prdcesseur de sa valeur, et ramne
	cette valeur.

(decr v n)	fsubr
	comme decr, mais c'est la valeur de n et non 1 qui est retire  la
	variable v.
^
nconc
(nconc e1 e2)		subr 2

	fait comme "append", mais sans effectuer une copie de la liste e1.
	e2 est physiquement concatne  e1, qui se trouve ainsi modifie.
^
nreverse
(nreverse e1 e2)	subr 2

	inverse physiquement la liste e1 et lui concatne e2.
	Si e2 est nil, comme dans l'appel (nreverse e1), ramne
	simplement l'inverse de e1.
	Mais dans tous les cas e1 est physiquement modifie.
^
:=
(:= expr1 expr1) MACRO
	:= est l'instruction d'affectation gnrale. Le premier argument,
	expr1, peut tre une variable, dans ce cas l'instruction :=
	est identique a` l'instruction setq, un appel de la fonction
	car, := est alors identique a` un rplaca, etc.

	exemples :
	(:= a 1)	=	(setq a 1)
	(:= (car l) 1)	=	(rplaca l 1)
	(:= (cdr l) '(a b))  =	(rplacd l '(a b))
	(:= (cadr l) 3)	=	(rplaca (cdr l) 3)
	(:= (car (foo l)) 4)  =	(rplaca (foo l) 4)
	(:= (get x 'foo) 5)  =	(put x 'foo 5)
	(:= (get x 'foo) (1+ *-*))  =	(put x 'foo (1+ (get x 'foo)))

	Le symbole *-*, dans le deuxime argument de :=, est une
	abrviation pour une occurrence du premier argument.

	Cette macro est particulirement utile en combinaison avec les records.
^
attach
(attach e l)		subr 2
	place e en tte de l, mais de telle sorte que l'adresse de l
	reste constante. Pour mieux comprendre autant lire la dfinition
	de attach en vlisp:
		(de attach (e l)
		  (rplac l e [(car l) . (cdr l)]))
^^Entre Sortie
^
print
(print e1 ... eN)	nsubr
	imprime en squence sur la mme ligne les valeurs des expressions
	e1 ... eN, effectue  la fin un passage  la ligne, et ramne en
	valeur celle de eN.
^
princ
(princ e1 ... eN)	nsubr
	fait comme "print", mais ne fait pas de passage  la ligne en
	fin d'impression, ce qui est utile pour faire une impression
	immdiatement suivie d'une question.

	exemple:
		(princ "La rponse est" x " c'est ca ou non (oui/non):")
^
prin1
(prin1 e1 ... eN)	nsubr
	prpare l'impression des e1 ... eN sans nanmoins les afficher
	tant que la marge droite n'est pas dpasse. Le prochain "print",
	"princ" ou "terpri" les fera apparatre.
^
terpri
(terpri)	fsubr
	effectue un passage  la ligne. Ramne "nil" en valeur.
^
princh
(princh e n)	subr 2
	imprime n fois l'expression e. Si n est absent: 1 fois.
Si e est une chane, les dlimiteurs (") n'apparaissent
	jamais dans l'impression.
^
read
(read)		subr 0
	lit un objet: liste, nombre, nom, ou chane, et ramne cet
	objet en valeur
^
readch
(readch)	subr 0
	lit le caractre suivant du flot d'entre et le ramne en valeur
	sous forme d'un atome mono-caractere.
	readch lit vraiment n'importe quoi.
^
peekch
(peekch)	subr 0
	comme readch mais le caractre lu est remis dans le flot d'entre
	et sera lu normalement lors de la prochaine lecture.
	"peekch" sert  voir ce qu'on s'apprte  lire.
^
readline
(readline)	subr 0
	lit une ligne dans le flot d'entre et la ramne sous forme
	d'une chane. Le caractre NEWLINE en fin de ligne est enlve
	de la chaine-resultat.
^
lib
(lib nom_de_fichier)	fsubr
	lit un fichier d'expressions dans le fichier donne en argument,
	dfinitions de fonctions, affectations, ce qu'on veut, puis
	revient lire au terminal comme d'habitude, en ramenant le
	nom_de_fichier en valeur.
	Le nom_de_fichier peut tre un atome ou une chane.

	exemples:
	(lib foo.vlisp)  ->  foo.vlisp
	et lit sur disque le dit fichier, comme si on en
	avait tape le contenu au terminal.
	Notons que l'extension ".vlisp" est cherche
	automatiquement. On aurait pu dire: (lib foo).

	(lib /usr/grp/litp/pg/vlisp/tests.vlisp) ->
	/usr/grp/litp/pg/vlisp/tests.vlisp

	et lit en valuant le contenu de cette file.
^
include
(include fichier)  fsubr
	fait l'inclusion du fichier passe en paramtre, comme lib
^
input
(input fichier) subr 1
	xbvl fait la lecture dans le fichier passe en
	paramtre. Si le fichier est nil, retour  la lecture
	sur la fentre d'interaction.
	
^
output
(output fichier)  subr 1
	xbvl fait toutes les sorties sur le fichier passe
	en paramtre. Si fichier est nil, les sorties son faites
	normalement vers la fentre d'interaction .
^
open
(open fichier)  fsubr
	ouvre le fichier et
	ramne un descripteur de fichier,
	ramne nil si l'ouverture du fichier est impossible.
	
^
fread
(fread fdes)  fsubr
	Fait la lecture d'un objet Lisp sur le descripteur de fichier, fdes, 
	ramne prcdemment par (open fichier).	
^
close
(close fdes) fsubr
	ferme un descripteur de fichier prcdemment ramne
	par <open>. Ramne nil si la fermeture du descripteur
	est impossible. Voir open.
^
tyo
(tyo n)		subr 1
	affiche sur l'cran,  la position courante du curseur, le
	caractre dont la valeur ascii est n. La valeur ramene est n.
	Ne fonctionne pas pour les caractres non imprimables

	exemples:
^%% ^%T3
^%% Ne semble pas trs utilisable sous X11 (fb, 21/3/97)
^%%	(tyo 7)   	->	   7   et fait un bruit.
^%%	(tyo  9)   	->	  9   et crit une tabulation.
^%%
^%%	(tyo 65)   	->	  65  et affiche le caractre "A".
^%% Ne semble pas trs utilisable sous X11 (fb, 21/3/97)
^%% ^
^%% tyoesc
^%% (tyoesc n)	subr 1
^%%	agit comme "tyo", mais de plus la valeur affiche est prcde
^%%	de la valeur "ESCAPE" i.e. 27. Trs commode pour envoyer des
^%%	"sequences-escape"  un terminal pour contrler ses fonctions.
^%%	exemple:
^%%	(tyoesc 69)  ->  69   et efface l'cran d'une H19.
^
tyi
(tyi)		subr 0
	lit un caractre au clavier du terminal, et retourne la valeur
	ascii du caractre tape aussitt aprs cette frappe. Nul
	besoin de terminer la ligne par un return. Utile pour faire
	des programmes trs nerveux et ractifs.
	On notera que le caractre tap n'apparat pas sur l'cran,
	l'cho est inhibe, si on veut le voir on pourra faire

	(tyo (tyi))
^
typch
(typch e n)	subr 2
	"e" peut tre un atome ou une string
	si n = nil -> donne la valeur de caractre courante de e.
	sinon re-affecte la valeur-de-caractere de 'e' avec n.
	ex: pour donner  "~" le statut de "." faire:
	(typch '~ (typch "."))
	les vals de caractres sont:
^%T2
	deb-commentaire: 	1
	fin-commentaire: 	2
	rserv  [pg]		3
	(		 	4
	)		 	5
	[		 	6
	]		 	7
	.		 	8
	sparateur	 	9
	macro-carac	 	10
	delimiteur-chaines	11
	normal		 	12
	rserv  [pg]		13

^
outpos
(outpos n)	subr 1
	place l'index du buffer de sortie  la position "n".
	Si l'argument "n" est absent, ramne la position courante de
	cet index. Dans les deux cas la position de l'index est
	ramene en valeur.
^
probef
(probef nom_de_fichier)	subr 1
	ramne le nom_de_fichier si le fichier existe, nil sinon.
	"nom_de_fichier" peut tre un atome ou une chane.
^%% ^
^%% eol
^%% (eol) subr 0
^%%	?
^
rtext
(rtext at)   subr 1
	Le fichier passe en paramtre est lu par bVLISP mais non pas
	value. Ramne une liste compose des chanes de caractres dont
	les lments sont les lignes de texte lues.  
^^Editeurs Intgrs 
^%% et Annotations
^
diteur
	il existe deux diteurs : un diteur de ligne (pour en savoir
	plus faites (aide 'page-editor)) et un diteur de programme (pour
	en savoir plus faites (aide 'edit))
	REMARQUE : edit n'a pas encore t porte sous X11
^
page-editor
	Vous avez en permanence un diteur  votre disposition. Les
	commandes son celles d'un diteur EMACS :

^%T2
	^a	ramne le curseur vers le dbut de la ligne
	^b	recule le curseur d'un caractre
	^d	delete le caractre  gauche du curseur
	^e	met le curseur vers la fin de la ligne
	 	blancs non compris
	^f	avance le curseur d'un caractre
	^g	delete l'atome suivant
	^h <BS>	delete le caractre sur lequel pointe le curseur
	^j	positionne le curseur sur le mot de gauche
	^k	delete le reste de la ligne 
	 	(a partir de la position du curseur)
	^i	efface l'atome  gauche du curseur
	^l	raffiche l'cran
	^n	met le curseur une ligne plus bas de la ligne
	^m	insre un fichier interactivement 
	^p	met le curseur une ligne plus haut
	^v	scroll d'une page vers le bas
	^t	transpose les caractres sur  la position du curseur
	^y	re-insre,  la position du curseur, le bout de ligne delete 
	 	par la dernire commande ^k. Naturellement, ce bout de ligne
	 	se garde jusqu' ce que vous re-activiez un ^k.
	^w	affiche cette aide dans la barre de menu
	^z	scroll d'une ligne vers le haut
	^0	insre la slection 1
	^1	insre la slection 2
	^n	insre la slection n
	 	diteur garde la trace des 7 dernires  slections
	F1	cherche de l'aide pour le mot slectionne (en surbrillance)
	F2	liste tous les sujets d'aide disponibles
	F3 	affiche cette aide dans la barre de menu
	F4	toggle du mode d'insertion des caractres (insr ou refrappe)
	*un click du bouton gauche	positionne le curseur  la position du pointeur
	 	et commence une slection
	*deux clicks du bouton gauche	ralisent la slection d'un mot
	*le mouvement avec le bouton de gauche	augmente la slection
	*cliquer le bouton de droite	augmente la slection
	*le mouvement avec le bouton de droite	augmente la slection
	*cliquer le bouton du centre	insre la slection  la position du curseur
	^s	recherche ou remplace (interactivement) vers l'avant 
	^r	recherche ou remplace (interactivement) vers l'arrire
^%%	M-b	le curseur recule d'un mot
^%%	M-D	les caractres  la droite du curseur sont dplacs 
^%%	 	vers la droite
^%%	M-<	positionne le curseur au dbut du texte
^%%	M->	positionne le curseur  la fin du texte
^%%	M-[	scroll vers le bas d'un paragraphe
^%%	M-]	scroll vers le haut d'un paragraphe
^%%	*Ctrl+cliquer le bouton de droite	communique la slection  l'valuateur
^%%	 	et la slection est value.
^%%	 	pour la version 4 et 5 de X11 seulement	
^%%	^m	formate le paragraphe sur lequel est situe le curseur.
^
edit
(edit ftn [typ])
	LE PORTAGE DE L'EDITEUR DE PROGRAMMES A LA NOUVELLE INTERFACE
	X EST ENCORE A FAIRE, UN JOLI SUJET DE MAITRISE !
	Cette fonction vous fait entrer dans l'dition de la fonction
	ftn. Si ftn est dj dfinie, le deuxime argument est superflu,
	sinon, ce deuxime argument doit tre l'un des mots clefs
	suivant : de, df, dm, dmc ou dml.
	Editeur garde tous les tats d'une fonction.
	Des aides supplmentaires sur diteur LISP se trouvent sous les
	mots clefs :
	anoted edhelp add-anote ed-entre ed-sortie ed-time
	add-entre add-sortie get-entre get-sortie get-time
	clear-entre clear-sortie fs fsr bs bsr mv ex del rpl
	ins insl p unp picks pickl puts dpl see-version see-time
	sabt edptr fnptr from timeptr pickptr ed-version ev
^
crossfile
(crossfile file_de_sortie file_d'entre header ntroff) EXPR
	pour faire un joli listing accompagne d'une jolie cross-reference
	(ca prend BEAUCOUP de temps!!!) Si le premier argument est nil,
	le rsultat se trouve dans le fichier 'cross.cro' du rpertoire
	courant.
	Exemple :
	(crossfile () "foo.vlisp")
	cre un fichier 'cross.cro' dans lequel vous trouvez le cross
	du fichier 'foo.vlisp'
	si l'argument 'header' = t, chaque page commence par un entte.
	si l'argument 'ntroff' = t, le fichier sortie est prpare 
		spcialement pour ntroff (changement de fonts, etc.).
^
prettyfile
(prettyfile file_de_sortie file_d'entre) EXPR
	pour faire un joli listing.	
	(ca prend BEAUCOUP de temps!!!) Si le premier argument est nil,
	l'impression se fera sur votre terminal.
	Exemple :
	(prettyfile "foo.prt" "foo.vlisp")
	cre un fichier 'foo.prt' dans lequel vous trouvez joliment
	imprime le contenu du fichier 'foo.vlisp'
^
crossf
(crossf fichier header ntroff) FEXPR
	fait dans le fichier 'fichier.cro' un crossfile de fichier.
	Exemple :
	(crossf foo)
	fait dans le fichier 'foo.cro' un cross-reference listing du
	fichier 'foo.vlisp'.
	(crossf "vlisp.ini")
	fait dans le fichier 'vlisp.ini.cro' un cross-reference listing
	du fichier 'vlisp.ini'.
	si l'argument 'header' = t, chaque page commence par un entte
	si l'argument 'ntroff' = t, le fichier sortie est prpare 
		spcialement pour ntroff (changement de fonts, etc.)
^
prettyf
(prettyf fichier) FEXPR
	comme 'crossf' mais l'extension du fichier rsultat est 'prt' et
	non 'cro'.
^
user-doc
	il existe plusieurs possibilits d'augmenter la puissance des
	utilitaires de documentation: une possibilit de dfinir le format
	de fonctions dfinies par l'utilisateur pour le grand pretty-printeur
	(prettyfile, crossfile, crossf et prettyf) et une possibilit de
	dfinir le format syntactique de fonctions utilisateurs pour
	la documentation on-line.	 
	Pour le Pretty-Print :
	Afin de faire connatre au pretty-printeur le format prfr pour
	l'impression de vos fonctions utilisateurs, mettez sur la P-liste
	du nom de la fonction, sous l'indicateur 'PRETTY' (en majuscule!)
	le type d'impression particulier que vous voulez. Les types reconnus
	par le Pretty-Print sont :
^%T2
	quote	l'appel de cette fonction sera alors imprime comme un
	 	appel de la fonction quote
	mcons	la fonction sera formate comme le mcons (avec des crochets)
	cons
	progn
	setq
	escape
	de
	while
	prog
	selectq
	cond

	Pour la doc on-line :
	La fonction 'ind' sert  faire connatre  bvlisp le format
	syntactique pour l'analyse syntactique de fonctions dfinies par
	l'utilisateur. Avant de donner la liste de tous les types possibles,
	voici un petit exemple :
	Supposons que l'utilisateur ait dfini une fonction 'test' comme 
	suit:

^%L
	(df test (x)
	  (put (car x) 'args (cadr x))
	  (eval ['de . x]))

	et qu'il ait fait SUIVRE cette dfinition par un appel de 'ind' :

	(ind test de)

	un appel de la fonction test comme :

	(test bar (a b) (cons a (list (1+ b)))

	aura videmment l'effet de dfinir la fonction 'bar'.
	Mais galement que si l'utilisateur demande ensuite une description
	de bar, par :

	(%descr bar)

	le rsultat en serait :

		------- bar ------
		type : test
		variables locales : (a b)

	i.e., l'analyseur garde une trace de l'origine de cette fonction.
	c'est trs utile pour la mise au point de programmes.

	Voici les diffrents types que bvlisp peut connatre :

^%T2
	prog	l'analyseur suppose alors que le premier argument est
	 	une liste de variables, le reste des s-expressions  valuer
	quote	l'analyseur suppose alors qu'il n'y a rien  analyser
	escape	le premier argument est un nom-de-fonctions, le reste
	 	une suite de s-expressions
	selectq	le premier argument est  valuer, le reste est une suite
	 	de liste du mme style que les clauses d'un selectq
	cond	une suite de clause style cond
	let	le premier argument est une liste de couples 
	 	variables-valeurs, le reste une suite de s-expressions
	lambda	comme le prog (mais sans les tiquettes)
	setq	comme le setq : un nom suivi d'une valeur etc.
	nconc	une fonction qui modifie physiquement son premier argument
	apply	une fonction suivie d'une liste des arguments
	de	comme une fonction de dfinition
^
ind
(ind nom_de_fonction type)
	pour faire connatre  bvlisp le type de votre fonction. Faites
	donc un (aide 'user-doc)

^^Directives systme
^
background
(background . l)  Fsubr 
	excute la suite d'instructions donne en argument dans un processus
	spar, qui n'existe que pendant l'excution de cette suite
	d'instructions. C'est trs utile pour le prettyf ou crossf, par 
	exemple, que vous pouvez lancer en faisant:

		(background (crossf nom_du_fichier))

	et ensuite vous pouvez tranquillement continuer  faire votre
	lisp ordinaire, pendant qu'un autre processus vous construit
	le cross-reference.
	Ca peut galement servir  faire des processus parallles :
	Par exemple, si vous lancez un processus `foo' dans le background,
	ca active un nouveau processus et ramne le numro du processus
	en valeur. Si un autre processus doit travailler sur le rsultat
	de celui-ci, alors vous devez faire un:
		
		(wait numero_du_processus)

	(cf. wait)
^
wait
(wait n) subr 1
	attend que le processus numro `n' soit termine.
	(cf. background)
^
break
(break nom) Fsubr 
	break interrompt le calcul en cours et entre dans une boucle
	PRINT-READ-EVAL d'inspection. Dans cette boucle vous avez accs
	a toutes vos variables etc.
	A l'intrieur de la boucle, le caractre prompte n'est plus le '?'
	habituel, mais l'atome donne en argument. Pour sortir de la boucle
	il suffit d'valuer cet atome.
	Si vous voulez compltement abandonner le calcul en cours tapez
	un '-', ensuite vous vous retrouvez dans un toplevel ordinaire.
^%% ^
^%% pour
^%% (pour ftn . l) Fsubr 
^%%	pour, principalement, aide  crire des utilitaires travaillant
^%%	sur des programmes.
^%%	(pour eval suite_d'actions_a_faire)
^%%	excute normalement la fonction
^%%	(pour ftn_different_de_'eval' suite_d'actions_a_faire)
^%%	ramne nil. Cette fonction permet de diriger le comportement
^%%	d'un programme lisant un fichier. Ainsi, par exemple, dans
^%%	quelques-uns de mes programmes, j'ai l'instruction
^%%	(pour pretty faire_ceci faire_cela)
^%%	et cette instruction est ignore par tous sauf le pretty-printeur.
^%%	Si vous voulez dterminer des actions pour plusieurs utilitaires,
^%%	donnez comme premier argument  'pour' une liste avec les noms 
^%%	adquats :
^%%	(pour (pretty foo) ... )
^%%	n'est valuer que dans l'utilitaire 'pretty' et 'foo'
^
date
(date) subr 0
	ramne la chane compose de la date courante et de l'heure 
^
time
(time nil/t) subr 1
	ramne la chane compose de l'heure, les minutes et les secondes
	si l'argument est t, sinon, si pas d'arguments, (time) ramne
	un nombre correspondant  l'heure.
^
EOF
	Quand vous utilisez la fonction 'input', vous avez la possibilit
	de dfinir vous-mme ce que vous voulez faire si vous rencontrez,
	normalement!, un end-of-file. Pour cela, vous devez dfinir une
	fonction du nom 'EOF' (en majuscules!). N'oubliez pas de dtruire
	cette fonction, une fois que vous n'en avez plus besoin!
^
undmc
(undmc c) Fsubr 
	Cette fonction  un argument, qui est obligatoirement une chane
	de caractres de UN caractre, indique au systme bvlisp d'ignorer
	temporairement la dfinition de l'argument 'c' comme 
	macro-caractere. 'undmc' veux dire 'undefine macro caractre'. 
	(Regardez aussi 'redmc')
^
redmc
(redmc c x) Fsubr 
	'RE-Define MacroCaratere' ractive le macrocaractere 'c'. 
	Naturellement, cette fonction n'a aucun sens si vous n'avez pas
	pralablement fait un 'undmc'. Si l'argument 'x' est nil, le
	caractre 'c' sera une dmc, si l'argument 'x' est 't', le
	caractre 'c' sera une dml, sinon 'x' doit tre un nombre qui
	dtermine le type du caractre 'c':

		si 'x' = 1 ou 2, 'c' sera un caractre 'dbut ou fin de commentaire'
		si 'x' = 4, 'c' sera un caractre 'parenthse gauche'
		si 'x' = 5, 'c' sera un caractre 'parenthse droite' 
		si 'x' = 6, 'c' sera un caractre 'crochet gauche'
		si 'x' = 7, 'c' sera un caractre 'crochet droite'
		si 'x' = 8, 'c' sera un caractre 'point'
		si 'x' = 9, 'c' sera un caractre 'sparateur'
		si 'x' = 10, 'c' sera un macro-caractere 'dmc'
		si 'x' = 11, 'c' sera un caractre 'dbut de chane'
		si 'x' = 12, 'c' sera un caractre normal
		si 'x' = 10, 'c' sera un sharp-caractere
		si 'x' = 16, 'c' sera un caractre 'dbut annotation'
		si 'x' = 17, 'c' sera un caractre 'fin annotation'

	Par exemple, pour temporairement enlever l'effet du caractre ';',
	vous faites d'abord :
	(undmc ";")
	ensuite vous faites tout ce que vous voulez, sachant que le
	caractre ';' est maintenant un caractre comme les autres,
	ensuite, pour le ractiver dans son sens standard, vous faites:
	(redmc ";" 1)
^
isuser
(isuser at) subr 1
	ramne t si at est un atome utilisateur, nil sinon.
	Exemple :
	(isuser 'aa)  --> t.
	(isuser 'car) --> nil.
^
getpackage
(getpackage at) subr 1
	ramne le nom du package dont l'atome 'at' fait partie.
^
package
(package at) Fsubr 
	La fonction 'package' sert  circonvenir les problmes des conflits
	des noms de vos fonctions. C'est surtout utile dans des packages
	utilitaires. Quiconque  eu une fois le problme d'une 
	erreur due  ce que vous avez eu un nom de variable qui tait 
	utilise dj ailleurs, comprendra. '(package un_nom)' indique au 
	lecteur lisp de prcder TOUS les nouveaux noms apparaissant dans le 
	flux d'entre par "un_nom.". Ainsi, le fichier contenant le 
	pretty-printeur commence par l'valuation de (package pretty), ainsi 
	tous les noms suivants jusqu' l'appel de (package) (sans arguments!)
	suivants seront prcds par 'pretty.', par exemple 'x' deviendra 
	'pretty|x' . Si toutefois vous 	voulez garder un nom tel quel, 
	placez le macro-caractere '|' avant le nom. Dans le fichier 
	pretty.vlisp, la dfinition de la fonction pretty dbute, par 
	exemple comme	 
			(de |pretty ...
	assurant ainsi que le nom 'pretty' sera pris en compte tel quel.
	N'oubliez pas de terminer la dfinition d'un package par l'appel
	de (package) sans arguments, sinon, le lecteur continuera 
	joyeusement de prfixer chaque nom.
^
|
	c'est le caractre d'inhibition de l'effet du package courant,
	cf. (aide package).
	Ainsi, si vous tes dans le package "user", l'criture
	|un_atom
	rfre  l'atome un_atom du niveau suprieur externe  tout
	package, et l'criture
	test|un_atom
	rfre  l'atome un_atom dans le package "test".
^
unstep
(unstep ftn1 ftn2 .. ftn-n) Fsubr 
	enlve les fonctions donnes en argument de la liste des fonctions
	a excuter en pas--pas.
^
step
(step ftn numro t/nil) Nsubr 
	step vous permet une excution pas  pas. Une excution pas-a-pas
	vous met  des instant bien dtermins dans des boucles break.
	Si vous ne donnez aucun	argument  l'appel, i.e. vous appelez 
	(step)
	toutes les fonctions-utilisateurs seront 'steppes'. Ca veux dire :
	a chaque appel d'une fonction utilisateur QUELCONQUE vous vous
	trouverez dans une boucle break. Si vous donnez un nom de fonction,
	seulement les appels de cette fonction seront steppes. Le nom peut
	tre une fonction utilisateur ou une fonction standard. Le numro 
	'n' optionnel vous permet d'indiquer  partir du combien-tieme appel
	d'une fonction vous voulez stepper.
	Notez que l'entre dans la boucle break se fait AVANT valuation des
	arguments, sauf si vous donnez un troisime argument 't', l'entre
	dans le pas-a-pas des fonctions utilisateurs se fera APRES 
	valuation des arguments (et aprs liaison des paramtres).
	Ca se perfectionnera au fur et  mesure...(regardez aussi 'steptr')
^
steptr
(steptr nom_de_fonction) FEXPR
	REMARQUE : cette fonction n'a pas encore t porte sous X11
	'steptr' est une aide visuelle pour 

	1) activer des pas-a-pas sur des fonctions utilisateurs.
	2) avoir un film du droulement de votre programme.

	voici comment ca fonctionne :
	quand vous appeler 'steptr', bvlisp partage l'cran en deux 
	fentres, la fentre du haut contient l'arbre des appels de 
	fonctions engendre par la fonction donne en argument (c'est le 
	mme arbre que celui que vous obtenez en faisant 
	(%a nom_de_fonction)), la fentre 
	du bas est la fentre d'interaction avec lisp. Vous avez alors la 
	possibilit de positionner interactivement le curseur sur la 
	fonction de votre
	choix. Pour dplacer le curseur vous avez les commandes :

		l pour aller  droite
		h pour aller  gauche
		k pour aller vers le haut
		j pour aller vers le bas

	(c'est les mmes commandes que celles de rogue!) D'ailleurs, steptr
	vous donne un menu en haut de l'cran vous rappelant ces commandes.
	Si vous voulez entrer en pas-a-pas dans une fonction, il suffit de
	donner la commande 's' quand le curseur se trouve devant le nom de
	cette fonction, pour sortir de ce mode, la commande 'u' vous servira
	trs bien. Pour sortir de ce mode de positionnement interactif, 
	tapez un caractre quelconque qui n'est pas une commande.
	La machine vous demande alors si vous voulez une trace vido; si
	vous rpondez par 'y', alors, pendant excution, vous verrez
	dans cet arbre les fonctions actives prcdes par un '*'. Si vous
	le faites avec la fonction 'vc', du gnrateur de condition de
	vrification dans /usr/vlisp80/hw/lisp/src/vcg.vlisp, ca vous
	donnera un trs joli film. L'utilit de cette chose est, entre
	autre, de VOIR les fonctions qui sont le plus utilises. Pour sortir
	de ce mode, appelez la fonction 'end-step'. 
	La commande 'e' vous mets en dition de la fonction pointe.
	Pour, aprs excution, ou pendant un breakpoint, re-entrer dans le
	mode de positionnement interactif, lancez la fonction 'stp' sans
	arguments.
^
stp
(stp)	EXPR
	fonction auxiliaire pour 'steptr' vous permettant de re-
	entrer dans un mode de positionnement interactif.
^^Activits supplmentaires
^
undo
(undo {n}) subr 1
	cette fonction vous permet,  l'intrieur d'une boucle d'inspection
	(option 'i' du menu du traitement des erreurs) de descendre dans la
	pile de travail, c'est  dire: de dfaire des appels de fonctions.
	L'argument 'n' permet de descendre 'n' blocs de contrles (cf. frame)
	a la fois. La fonction 'restart' permet de reprendre le calcul  
	partir de l'endroit d'ou vous vous trouvez.
^
done
(done x . l) Fsubr 
	s'appelle comme :
	(done () . l)
	ou:
	(done n . l)
	sans arguments l, done vous sort de la fonction et vous met au 
	niveau 	DE RETOUR du n-ieme block de contrle. Alors, vous vous 
	trouvez dans une boucle break et vous pouvez inspecter l'tat de vos
	variables, de la pile (soit dit en passant, l'image de la pile est 
	beaucoup plus lisible qu'en vlisp). Vous sortez de la boucle break 
	comme d'habitude. MAIS, n'oubliez pas de donner comme dernier truc
	a valuer dans la boucle, la valeur que vous voulez ramener de
	votre dernire lambda. Cette valeur est calcule dans le contexte
	APRES le unbind!
	Avec arguments l, done vous sort de la fonction et value les 
	arguments dans le contexte APRES le unbind.
	Le premier argument DOIT tre une valeur numrique ou nil. Si c'est
	une valeur numrique, ca indique alors de combien de blocs lambda
	vous sortez. Si c'est nil, vous ne sortez que d'un bloc lambda.

	Bref, 'done' est presque comme 'exit', mais seulement presque!
	ATTENTION, il peut vous arriver que des liaisons soient 
	dfaites parce que vous avez trop dpile!
^
first-call
(first-call nom-de-fonction nombre) EXPR
	ce prdicat permet de savoir,  l'intrieur d'une activit
	supplmentaire de sortie, si l'on se trouve  la sortie du n-ieme
	appel rcursif de la fonction nom-de-fonction. 
	Exemple:
	(sortie 'foo '(if (first-call 'foo 1) 
	  (changeval ['a sortie])))
	change la valeur ramne de foo en une liste compose de deux lments:
	le premier est l'atome a, le deuxime lment est le rsultat calcule
	par l'appel de foo.

	(sortie 'foo '(if (first-call 'foo 3) 
	  (changeval ['a sortie])))
	cet deuxime appel change la valeur du 3-ieme appel rcursif.
^
chemin-entre
(chemin-entre ftn-1 ftn-2 ... ftn-n) FEXPR
	comme chemin, mais pour les activits supplmentaires  l'entre
	des fonctions
^
chemin-sortie
(chemin-sortie ftn-1 ftn-2 ... ftn-n) FEXPR
	comme chemin, mais pour les activits supplmentaires  la sortie
	des fonctions
^
chemin
(chemin ftn-1 ftn-2 ... ftn-n) FEXPR
	ce prdicat est vrai si l'on se trouve  l'intrieur d'une fonction
	ftn-n en ayant suivi le chemin d'appel
		ftn-1 -> ftn-2 -> ... -> ftn-n
	chemin est une fonction  utiliser dans les programmes utilisateurs.
	SI l'on veut savoir les chemins  l'intrieur d'une activit 
	supplmentaire d'entre ou de sortie IL FAUT UTILISER les fonctions
	chemin-entre ou chemin-sortie.
	Le prdicat chemin-entre
	utilis  l'intrieur d'une activit d'entre est vrai au lancement
	du premier appel de ftn-n (si l'on vient bien du chemin indique),
	le prdicat chemin-sortie
	utilis  l'intrieur d'une activit supplmentaire de sortie
	est vrai  la sortie du premier appel de ftn-n (ce qui 
	implique qu'il a bien pu avoir d'autres appels rcursifs de ftn-n qui
	ont t ignore.
^
changeval
(changeval valeur) subr 1
	fonction de mise au point qui permet de changer,  l'intrieur
	d'une activit supplmentaire de sortie d'une fonction,
	la valeur retourne de cette fonction.
^
getcar
(getcar x) subr 1
	vous ramne soit nil, si x est une liste normale, soit
	la liste compose du car de x et de l'annotation de ce car. Les
	commentaires sont alors considrs comme des chanes. (Soit dit
	en passant, les commentaires sont TOUJOURS associes au car. Et
	la liste des annotations est organise comme une p-liste, 
	l'indicateur de commentaire tant l'atome COM).

^
getcdr
(getcdr x) subr 1
	mme chose que getcar mais pour le cdr

^
putcar
(putcar x y) subr 2
	'cons' y  la liste d'annotation du car de x. Ceci vous permet
	de mettre toute sorte d'information cache dans vos listes.
^
putcdr
(putcdr x y) subr 2
	mme chose que putcar mais pour le cdr

^
clearcar
(clearcar x) subr 1
	si le car de x possde des annotations, clearcar les enlve.
	Ramne x en valeur.

^
clearcdr
(clearcdr x) subr 1
	enlve les annotations du cdr de x. Cette fonction ramne x en 
	valeur, de mme que la fonction clearcar.

^
careful
(careful t)	subr 1
	met en mode careful. TOUT ce qui suit ne marche qu'en mode careful
	il est donc conseille de se mettre immdiatement en mode careful
	en valuant (careful t)
(careful)
	vous sort temporairement de ce mode. C'est utile si vous voulez
	lire des fichier sans les analyser (ex : pretty, trace etc.)
(careful 1)
	vous sort dfinitivement du mode careful et en efface toutes les
	traces
^
%i
(%i f1 f2 ... fn) FEXPR
	vous livre les arbres d'appels des fonctions f1, f2 etc. AINSI
	qu'une description de TOUTES les variables utilises  l'intrieur
	de ces fonctions
	sans arguments, cette fonction vous livre l'ensemble des arbres
	d'appels et une description de toutes les variables.
^
%a
(%a f1 f2 ... fn) FEXPR
	vous livre les arbres d'appels des fonctions f1, f2 etc. 
	sans arguments, cette fonction vous livre l'ensemble des arbres
	d'appels

^
%descr
(%descr obj1 obj2 .. objn) FEXPR
	vous livre une description des diffrents objets obj1, obj2 etc.
	sans arguments, cette fonction livre la description de la totalit
	des objets connus (sous mode careful)
^
example
(example 'nom_de_fonction liste_d'exemples) EXPR
	attache  la fonction (donne en premier argument) les exemples
	que vous donne la liste en deuxime argument. A la premire
	excution de la fonction, valuation normale sera interrompue
	et la fonction sera d'abord teste sur ces exemples. Ainsi
	essayez donc:
^%L
	(de test (x) (cons 1 [x]))
	et:
	(example 'test '(((test 1)(1 1))
	  ((test 2)(2 1))
	  ((test 3)(1 3))
	  ((test 4)(4 1)) ))
	ensuite appelez:
	(test 111)

	(example 'nom_de_fonction)
	vous donne les exemples attaches  la fonction

	(example 'nom_de_fonction t)
	ractive le test sur les exemples

^
erreurs
LES ERREURS :
	les erreurs "variable non dfinie" et "fonction non dfinie"
	sont trappes de la manire suivante :

	 "variable non dfinie" :
	si vous valuez une variable qui n'a pas encore de valeur,
	BVLISP vous demande de donner interactivement une valeur. La
	valeur que vous donnez est naturellement value! Donc, si
	vous voulez donner une valeur, quotez la!.

	 "fonction non dfinie" :
	si pendant excution d'une fonction vous tombez sur une erreur
	de ce type, bvlisp vous permet de trapper l'erreur de plusieurs
	manires :

	1) la fonction non dfinie correspond  une erreur de frappe. Dites
	alors que vous voulez donner le nom de la fonction correcte (en
	tapant 'f<return>') et ensuite donnez le nom de la fonction.
	Ceci modifiera votre programme et continuera excution avec
	cette nouvelle fonction.
	2) la fonction non dfinie est une fonction que vous n'avez pas 
	encore dfinie. Vous avez alors la possibilit de donner  la 
	machine une valeur (en tapant 'v<return>' suivi de la valeur). 
	Ce sera cette valeur qui sera considre comme valeur de l'appel 
	de la fonction errone, et le calcul continue avec cette valeur.
	Vous pouvez galement donner le nom d'une fonction, sans modifier
	votre programme (en tapant 'e<return>' suivi du nom 
	de la fonction).
	3) si  l'entre d'une erreur de ce type vous tapez 'i<return>', 
	vous entrez alors dans une boucle d'inspection (une boucle break).
	cette boucle doit tre termine par 'fin', et ensuite vous vous
	trouvez dans les mmes cas que les prcdents.
^
entre
(entre ftn expression) EXPR
	ajoute l'expression expression comme activit supplmentaire
	a votre fonction. Comme le nom l'indique, cette activit sera
	excute  chaque entre dans la fonction
	Si des appels de fonction existe dans l'expression donne, 
	les fonction correspondantes seront ajoutes dans les 'ival' de
	la fonction au premier appel. Si cet effet est indsir, 
	la fonction (a dfinir par l'utilisateur) 'f-entre' ne sera
	pas ajoute dans les 'ival'.
^
sortie
(sortie ftn expression) EXPR
	ajoute l'expression  la sortie de la fonction ftn. (Comme 'entre',
	mais pour la sortie). De mme que pour 'entre', la fonction
	utilisateur 'f-sortie' ne serra pas prise en compte dans les 'ival'.
^
enlve
(enleve-entree ftn at) EXPR
	si vous voulez annuler l'effet d'une activit
	supplmentaire d'entre utilisez cette fonction-ci. Par exemple,
	si vous avez fait un 
	(entre 'foo '(truc-muche ... ))
	pour enlever cette spcification d'entre, il faut appeler :
	(enleve-entree 'truc-muche 'foo)  
^
enleve-sortie
(enleve-sortie ftn at) EXPR
	mme chose que enleve-entree, mais pour la sortie
^
assert-entree
(assert-entree ftn assertion) EXPR
	si vous tes en mode careful, ceci vous permet de tester  chaque
	entre dans la fonction ftn, des conditions de vrifications
	sur les entres. L'argument 'assertion' doit tre UNE expression
	LISP, dans laquelle vous pouvez naturellement utiliser les
	variables de la fonction 'ftn'.
^
assert-sortie
(assert-sortie ftn assertion) EXPR
	si vous tes en mode careful, ceci vous permet de tester  chaque
	sortie de la fonction ftn, si la condition de vrification
	'assertion' est vrifie. Comme pour assert-entree, si la
	condition n'est pas vrifie, la machine vous informe trs
	amplement des problmes. Dans l'assertion, vous pouvez vous
	rfrer au rsultat de l'appel de la fonction avec la variable
	'sortie'. Cette variable contient  tout instant le rsultat du
	dernier appel (dynamique) de l'EXPR ou de la FEXPR dont vous tes
	juste en train de terminer excution.
	(pour un exemple, regardez les assertions (bidon) dans le fichier
	 /usr/vlisp80/hw/lisp/src/vlisp.ini)
^
unassert
(unassert-e ftn1 ftn2 ...) FEXPR
	enlve temporairement les assertions d'entre des fonctions ftn1,
	ftn2, .. etc. Pour les ractiver, il faut utiliser la fonction
	reassert-e.

(unassert-s ftn1 ftn2 ...) FEXPR 
	enlve temporairement les assertions de sortie des fonctions ftn1,
	ftn2, .. etc. Pour les ractiver, il faut utiliser la fonction
	reassert-s.
^
reassert
(reassert-e ftn1 ftn2 ...) FEXPR
	re-active les assertions de sortie des fonctions ftn1, ftn2, .. etc.

(reassert-e ftn1 ftn2 ...) FEXPR
	re-active les assertions de sortie des fonctions ftn1, ftn2, .. etc.
^
test-entree
(test-entree x . expression) EXPR
	attache au CAR de x l'expression 'expression' comme activit  faire
	AVANT excution du CAR de la liste. 
^
test-sortie
(test-sortie x . expression) EXPR
	attache au CAR de x l'expression 'expression' comme activit  faire
	APRES excution du CAR de la liste. Naturellement, ca revient au
	mme comme une activit  faire AVANT excution  du CDR de la liste.
^
ival
(ival atom valeur) subr 2
	si valeur est donne, met le ival de l'atom  valeur
	sinon ca ramne le ival de l'atome
	(normalement le ival (Internal VALue) ne devrait pas tre utilise
	 par vous. Il est rserv au systme).

	Les valeurs que le systme place dans l'ival d'un atome correspondes  :

^%T2
	Nom		Signification
	pour les VARIABLES:	
	globalvar	var est variable globale
	localvar	var est variable locale
	incr		var est variable globale modifie
	pour les FONCTIONS:	
	0		liste de toutes les variables locales
	1		liste de toutes les variables globales
	2		liste des variables globales modifies
	3		liste des fonctions appelantes
	4		liste des fonctions appeles
	5		liste des clauses appeles (pour les clauses)
	6		liste des clauses appelantes
	7		liste des fonctions appeles dans une clause
	20		fichier dfinissant la fonction
	100		temporaire de construction pour les fonctions
	200		temporaire de construction pour les clauses

	Variables Globales accessibles en LISP:
	globalvar -> liste des variables globales.
	localvar -> liste des variables locales.
	all_functions -> liste des fonctions dfinie sous careful=t.
	all_clauses -> liste des clauses prolog dfinies sous careful=t.
^
clrival
(clrival atom) subr 2
	remet le ival de l'atome donne en argument  nil
^
globalvar
	contient la liste de toutes vos variables globales utilises dans
	des fonctions dfinies sous mode careful.
^
localvar
	contient la liste de toutes les variables qui sont argument de vos
	fonctions dfinies sous mode careful.
^
all_functions
	la liste de toutes les fonctions que vous avez dfinies sous mode
	careful
^
sortie
	une variable interne qu'il est TRES souhaitable de ne pas toucher.
	Consultez sa valeur tant que vous voulez, mais surtout ne la modifiez
	pas.
^
all
(all)	EXPR
	la fonction all positionne un indicateur pour que pretty imprime
	(joliment) la fonction avec toutes ses annotations, assertions,
	commentaires, etc.
^
not-all
(not-all) EXPR
	enlve l'indicateur positionne par all.
^^Contrle des formats d'entre/sortie
^
nomacout
(nomacout) subr 0
	inhibe le lancement des dmo's. C'est principalement pour des 
	utilitaires de style trace etc.
^
macout
(macout) subr 0
	ractive les dmo's.
^
boundp
(boundp x) subr 1
	ramne t si x a une c-valeur diffrente de 'undef', sinon 'nil'.
^
readlin
(readlin) subr 0
	readlin (SANS 'e'  la fin!) est comme la fonction 'readline' mais
	n'attend pas un newline. C'est trs utile pour des macrocaracteres
	qui veulent lire ce qui suit dans la ligne sans entrer dans le
	lecteur-lisp standard. Comme exemple, regardez la dfinition
	du macrocaractere ^ dans le fichier ~hw/lisp/src/ef.vlisp.
^
dml
(dml () . corps) Fsubr	 (OBLIGATOIREMENT la liste des variables = () !!!)
	avec 'dml' vous pouvez dfinir des macrocaracteres qui prennent 
	effet directement  la lecture. Dans la suite, leur effet est NUL!!!
	MAIS : les dml ne sont reconnus que pendant l'utilisation interactive
	a votre terminal. Pendant la lecture de fichiers tous les dml sont
	considrs comme des caractres normaux.
	Exemple : si vous voulez en plein milieu d'criture avoir la 
	possibilit de consulter votre programme, une bonne manire de le 
	faire est la suivante :

	(dml # ()(princ "des renseignements")(break >)
		 (princ "maintenant continuez  taper :"))

	Si pendant la frappe, vous tapez un '#', la machine vous dit alors :

	des renseignements >  la vous tapez alors n'importe quoi... vous vous
	trouvez dans une boucle break et quand vous en sortez en tapant '>'
	la machine rpond :
	maintenant continuez  taper : ? et l vous continuez comme si 
	rien ne tait passe. 

	Ca servira principalement  la doc on-line.... Naturellement, si
	vous voulez rellement entrer un caractre qui a t dfini comme
	dml, il faut le quoter par ^w (cf. le page-editeur).

^%% ^
^%% del
^%%	Actuellement, vous pouvez interrompre tout calcul en tapant 
^%%	le caractre '\' ou le caractre 'ESC'.
^%%	A ce deuxime caractre d'interruption, vous pouvez accrocher
^%%	des activits dfinies par l'utilisateur en dfinissant une fonction
^%%	de nom 'onintr'. Normalement ceci peut tre utile si vous avez
^%%	un trs long calcul et que vous ne savez plus si votre programme
^%%	boucle ou pas. Ainsi la dfinition suivante :
^%%	
^%%	(de onintr () (print (2 (frame 100)))(break i>))
^%%
^%%	vous donne, aprs avoir tape le DEL, la fonction dans laquelle vous
^%%	vous trouviez  l'instant de l'interruption, et entre dans une 
^%%	boucle d'inspection. A la sortie de cette boucle, le calcul 
^%%	interrompu est repris, sauf si vous tes sorti de la boucle 
^%%	par le '-'.
^%%
^
ANTISL
	cette variable guide l'impression de chanes de caractres.
	Normalement sa valeur est nil. Si sa valeur est gale  't',
	les backslashs ('\') ne sont pas pris en compte  l'intrieur
	des chanes. Si sa valeur est gale  '1', les backslashs ne
	sont non seulement pas pris en compte, mais ils sont doubles.
	Cette variable est d'une grande utilit si vous faites, sous
	BVLISP, des fichiers pour 'troff'. Autrement, je ne vois
	pas  quoi ca pourrait servir.
^
extprint
(extprint . l) fsubr
	comme allprint sans la restitution force des '"' autour des
	chanes.
^
extprin1
(extprin1 . l) fsubr
	comme allprin1 sans la restitution force des '"' autour des
	chanes.
^
allprint
(allprint . l) fsubr
	Cette fonction imprime ses arguments AVEC toutes les annotations, tous
	les atomes sont imprime avec leur package et les chanes sont imprimes
	avec les caractres '"'. 'allprint' ramne la valeur du dernier argument 
	en valeur.
^
allprin1
(allprin1 . l) fsubr
	comme 'allprint', sans imprimer pas un newline.
^
getdoc
(getdoc . l) fexpr
	getdoc attend en argument un ou plusieurs noms de fonctions.
	getdoc imprime le commentaire (suivant la liste des variables)
	associe  une fonction.
^
allpretty
(allpretty ftn1 ftn2 ... ftn-n) FEXPR
	 Fait un pretty-print des fonctions donnes en arguments, AVEC toutes
	 les annotations. 
^%% ^
^%% record
^%%	appel :
^%%	(record-type <nom><flag> ( .. <slot> ..))
^%%
^%%	exemples :
^%%	(record-type terminal (result))
^%%	(record-type node nil (test node-if-t node-if-nil))
^%%	(record-type goal-node $gn (char state . plan))
^%%
^%%	 exemples d'utilisation :
^%%	(is :terminal foo) -> test de type
^%%	(result :terminal foo) -> file le slot <result> de foo
^%%	(terminal 'machin) -> construit (terminal machin)
^%%
^%%	 notes :
^%%	si flag est absent -> flag est le <nom>
^%%	le flag ne sert qu'a permettre (si ncessaire) un test de type
^%% 
^%% ^
^%% monitor
^%% (monitor var ycoord xccord {quoi} {quand}) EXPR
^%%	Cette fonction permet le monitoring des variables. Pour monitorer la
^%%	variable `a', par exemple, faites
^%%	(monitor 'a 12 60)
^%%	ca aura comme effet la cration d'une fentre de nom a-win dans
^%%	la ligne 12 colonne 60 (d'une ligne imprimable de 18 caractres).
^%%	Dans cette fentre sera affiche la valeur de cette variable a` chaque 
^%%	consultation. L'argument optionel 'quoi' donne l'expression  imprimer
^%%	a chaque consultation et l'argument 'quand' donne un prdicat determinant
^%%	dans quelles circonstances il faut faire 'quoi' (l'impression de la 
^%%	valeur de la variable par defaut).
^%% ^
^%% unmonitor
^%% (unmonitor at1 at2 .. atn) FEXPR
^%%	Desactive le monitoring des variables 'at1', 'at2', ... 'atn'



