; .EnTete "Le-Lisp (c) version 15.2" " " "Le fichier initial"
; .EnPied "startup.ll" "A-%" " "
; .Annexe A "Le Fichier Initial"
;
; .Centre "*****************************************************************"
; .Centre " Ce fichier est en lecture seule hors du projet ALE de l'INRIA. "
; .Centre " Il est maintenu par ILOG SA, 2 Avenue Gallie'ni, 94250 Gentilly "
; .Centre " (c) Le-Lisp est une marque de'pose'e de l'INRIA "
; .Centre "*****************************************************************"
;
; .Centre "$Header: startup.ll,v 4.26 89/01/11 20:37:01 nuyens Exp $"
; Il est ne'cessaire de charger ce fichier avant toute utilisation
; du syste`me Le-Lisp version 15.2 a` cause de la rede'finition de
; la boucle principale (toplevel).
(if (>= (version) 15.2)
(list "Version: " (version))
(error 'load 'erricf 'startup))
;; Ces 2 fcts sont a modifier a` chaque distribution ce maintenance.
(de subversion ()
;; donne la version de maintenance de 15.2 de l'anne'e en cours.
1)
(de herald ()
;; Change le herald du lelispbin pour tenir compte de la nouvelle date
;; dans les distributions de maintenance.
;; On le redefinis me↑me quand la date est la meme que dans llm3, parce que
;; ttymsg n'est pas la me↑me que print. Comme c,a les distributions
;; de maintenance se comportent exactement de la me↑me fac,on.
(with ((outchan ()))
(print "; Le-Lisp (by INRIA) version 15.22 "
" (6/Jan/89) [" (system) "]"))
nil)
; .Section "Les variables globales internes du syste`me"
(progn
(defvar #:system:loaded-from-file 'startup)
; et maintenant refaisons le pour mettre 'startup
; dans #:system:loaded-from-file .....
(defvar #:system:loaded-from-file 'startup)
(defvar #:system:in-read-flag #:system:in-read-flag)
(defvar #:system:print-for-read #:system:print-for-read)
(defvar #:system:print-package-flag #:system:print-package-flag)
(defvar #:system:print-case-flag #:system:print-case-flag)
(defvar #:system:real-terminal-flag #:system:real-terminal-flag)
(defvar #:system:line-mode-flag #:system:line-mode-flag)
(defvar #:system:gensym-counter #:system:gensym-counter)
(defvar #:system:read-case-flag #:system:read-case-flag)
(defvar #:system:foreign-language ()) ; pour les messages.
(defvar #:system:unixp ()) ; =T c'est un syste`me UNIX.
(defvar #:system:print-with-abbrev-flag t)
'DEFVAR
)
; .Section "Les variables de'pendantes du syste`me"
; Toutes ces variables re'sident dans le package "SYSTEM:"
; et contiennent les noms absolus des pre'fixes et suffixes
; des bibliothe`ques Le-Lisp.
; Pour les syste`mes UNIX la variable #:SYSTEM:DIRECTORY
; permet de calculer tous les autres directory.
; Le fichier "root-of-lelisp" mis a` jour au moment de l'installation
; du systeme lelisp permet d'initialiser cette variable.
(progn ; pour rester silencieux pendant le chargement
#.(defvar unix ; liste des syste`mes UN*X
'(vaxunix vme pe32unix bell sps9 sm90 unigraph
micromega metheus apollo cadmus sun hp9300
metaviseur ibmrt pyramid sequent gouldpn
|tektronix 43xx| |C| dpx1000 sun4 convex))
(if (memq (system) '#.unix)
(progn (defvar #:system:directory "/tmp←mnt/net/chroma/rojo/franchi/CENTAUR/lelisp/v15.22/")
(defvar #:system:unixp t)
#- #:system:foreign-language "syste`me unix"
#+ #:system:foreign-language "unix system"
)
(progn (defvar #:system:unixp ())
#- #:system:foreign-language "Pas un syste`me unix"
#+ #:system:foreign-language "Not a unix system"
)
))
(progn ; pour rester silencieux pendant le chargement
(defvar #:system:cloadp
(and #:system:unixp
(memq (system) '(vaxunix sun sun4 sequent))))
; Catalogue (pre'fixe) contenant la bibliothe`que syste`me Le-Lisp
(unless (boundp '#:system:llib-directory)
(defvar #:system:llib-directory
#.(selectq (system)
(#.unix (catenate #:system:directory "llib/"))
(vaxvms "lelisp$disk:[lelisp.LLIB]")
(multics ">lib>Le←Lisp>lelispv15.2>llib>")
(pcdos "\lelisp\llib\")
(t ""))) )
; Catalogue (pre'fixe) contenant la bibliothe`que utilisateur Le-Lisp
(unless (boundp '#:system:llub-directory)
(defvar #:system:llub-directory
#.(selectq (system)
(#.unix (catenate #:system:directory "llub/"))
(vaxvms "lelisp$disk:[lelisp.LLUB]")
(multics ">lib>Le←Lisp>lelispv15.2>llub>")
(pcdos "\lelisp\llub\")
(t ""))) )
; Catalogue (pre'fixe) contenant la bibliothe`que des tests du syste`me
(unless (boundp '#:system:lltest-directory)
(defvar #:system:lltest-directory
#.(selectq (system)
(#.unix (catenate #:system:directory "lltest/"))
(vaxvms "lelisp$disk:[lelisp.LLTEST]")
(multics ">lib>Le←Lisp>lelispv15.2>lltest>")
(pcdos "\lelisp\lltest\")
(t ""))) )
; Catalogue (pre'fixe) contenant les modules syste`me Le-Lisp.
(unless (boundp '#:system:llmod-directory)
(defvar #:system:llmod-directory
#.(selectq (system)
(#.unix (catenate #:system:directory "llmod/"))
(vaxvms "lelisp$disk:[lelisp.LLMOD]")
(multics ">lib>Le←Lisp>lelispv15.2>llmod>")
(pcdos "\lelisp\llmod\")
(t ""))) )
; Catalogue (pre'fixe) contenant les fichiers syste`me format objet Le-Lisp.
(unless (boundp '#:system:llobj-directory)
(defvar #:system:llobj-directory
#.(selectq (system)
(#.unix (catenate #:system:directory "llobj/"))
(vaxvms "lelisp$disk:[lelisp.LLOBJ]")
(multics ">lib>Le←Lisp>lelispv15.2>llobj>")
(pcdos "\lelisp\llobj\")
(t ""))) )
; Catalogue (pre'fixe) contenant les de'finitions des terminaux virtuels
(unless (boundp '#:system:virtty-directory)
(defvar #:system:virtty-directory
#.(selectq (system)
(#.unix (catenate #:system:directory "virtty/"))
(vaxvms "lelisp$disk:[lelisp.VIRTTY]")
(multics ">lib>Le←Lisp>lelispv15.2>virtty>")
(pcdos "\lelisp\virtty\")
(t ""))) )
; Catalogue (pre'fixe) contenant les de'finitions des bitmaps virtuels
(unless (boundp '#:system:virbitmap-directory)
(defvar #:system:virbitmap-directory
#.(selectq (system)
(#.unix (catenate #:system:directory "virbitmap/"))
(vaxvms "lelisp$disk:[lelisp.VIRBITMAP]")
(multics ">lib>Le←Lisp>lelispv15.2>virbitmap>")
(pcdos "\lelisp\virbit\")
(t ""))) )
; Catalogue (pre'fixe) syste`me de Le-Lisp spe'cifique a` une machine
(unless (boundp '#:system:system-directory)
(defvar #:system:system-directory
#.(selectq (system)
(#.unix (catenate #:system:directory
(let ((name (car (memq (system) '#.unix))))
(selectq name
(vaxunix "vax")
(|tektronix 43xx| "tektro")
(t name)))
"/"))
(vaxvms "lelisp$disk:[lelisp.VAX]")
(multics ">lib>Le←Lisp>lelispv15.2>multics>")
(pcdos "\lelisp\pcdos\")
(t ""))) )
; Catalogue (pre'fixe) contenant les images-me'moire standard
(unless (boundp '#:system:core-directory)
(defvar #:system:core-directory
#.(selectq (system)
(#.unix (catenate #:system:directory
(let ((name (car (memq (system)
'#.unix))))
(selectq name
(vaxunix "vax")
(|tektronix 43xx| "tektro")
(t name)))
"/llcore/"))
(vaxvms "lelisp$disk:[lelisp.LLCORE]")
(multics ">lib>Le←Lisp>lelispv15.2>multics>core>")
(pcdos "\lelisp\pcdos\core\")
(t ""))) )
; Liste des Catalogue (pre'fixe) contenant des fichiers Le-Lisp.
(defvar #:system:path (list
""
#:system:llib-directory
#:system:llub-directory
#:system:llmod-directory
#:system:llobj-directory
#:system:lltest-directory
#:system:virtty-directory
#:system:virbitmap-directory
#:system:system-directory
))
; Extension (suffixe) des fichiers source Le-Lisp
(defvar #:system:lelisp-extension
#.(selectq (system)
(#.unix ".ll")
(vaxvms ".ll")
(multics ".ll")
(pcdos ".ll")
(t "")))
; Extension (suffixe) des fichiers de description de module Le-Lisp,
(defvar #:system:mod-extension
#.(selectq (system)
(#.unix ".lm")
(vaxvms ".lm")
(multics ".lm")
(pcdos ".lm")
(t "")))
; Extension (suffixe) des fichiers format objet Le-Lisp
(defvar #:system:obj-extension
#.(selectq (system)
(#.unix ".lo")
(vaxvms ".lo")
(multics ".lo")
(pcdos ".lo")
(t "")))
; Extension (suffixe) des fichiers images-me'moire
(defvar #:system:core-extension
#.(selectq (system)
(#.unix ".core")
(vaxvms ".cor")
(multics ".core")
(pcdos ".cor")
(t "")))
; Fichier contenant la base de donne'es "termcap"
(defvar #:system:termcap-file
#.(selectq (system)
(#.unix "/etc/termcap")
(vaxvms "lelisp$disk:[lelisp.VIRTTY]termcap.db")
(multics ">lib>Le←Lisp>lelispv15.2>virtty>termcap.data")
(pcdos "\lelisp\termcap")
(t "")))
; Catalogue (pre'fixe) contenant la base de donne'es "terminfo"
(defvar #:system:terminfo-directory
#.(selectq (system)
(#.unix "/usr/lib/terminfo/")
(vaxvms "lelisp$disk[lelisp.terminfo]")
(multics ">lib>Le←Lisp>lelispv15.2>virtty>terminfo>")
(pcdos "\lelisp\terminfo\")
(t "")))
; Nom de l'e'diteur a` appeler par ↑F
(defvar #:system:editor
#.(selectq (system)
(pe32unix "emin")
(bell "vi")
(sps9 "redit")
((sm90 micromega metheus apollo pe32unix)
"emin")
(#.unix "emacs")
(vaxvms "edit")
(multics "emacs -task")
(t "")))
; .Section "Les codes ASCII symboliques pour la macro #\"
(mapc
(lambda (x y) (putprop x y '#:sharp:value))
'(null bell bs tab lf return cr esc sp del rubout)
'(#↑@ #↑G #↑H #↑I #↑J #↑M #↑M #↑[ #/ 127 127))
; .Section "Quelques autres fonctions"
; Toutes ces fonctions doivent e↑tre re-e'crites en LLM3.
(de explodech (s)
(mapcar 'ascii (explode s)))
(de implodech (l)
(implode (mapcar 'cascii l)))
(de lhoblist (s)
; retourne tous les symboles qui de'butent par la chai↑ne s
(maploblist (lambda (x) (index s x 0))))
; .Section "Les macros-caracte`res standard"
(dmc ↑L ()
; ↑L : pour charger un fichier d'extension #:system:lelisp-extension
(list 'libloadfile (readstring) t))
(dmc ↑A ()
; Pour charger un module.
(list 'loadmodule (readstring)))
(dmc ↑E ()
(cond ((eq (peekcn) 13)
; juste ↑E suivi de 'return'
'(pepefile ()))
((memq (peekcn) '(#/( #↑P))
; expression : de'bute par ( ou ↑P))
(list 'pepefile (kwote (read))))
(t ; un nom de fichier (symbole)
(list 'pepefile (kwote (concat (readstring)))))))
(dmc ↑F ()
(let ((lu (readline)))
(ifn lu
(list 'comline #:system:editor)
(lets ((fct (implode lu))
(file (getprop fct '#:system:loaded-from-file))
;; pour prendre resetfn en compte.
(type (or (car (getprop fct 'resetfn)) (typefn fct))))
(ifn (memq type '(expr fexpr macro dmacro))
(list 'pretty fct)
(if file
(list 'progn
(list 'comline
(catenate #:system:editor " " file))
(list 'load file t))
(setq file
(catenate
(gensym) #:system:lelisp-extension))
(list 'progn
(list 'prettyf file fct)
(list 'comline
(catenate #:system:editor " " file))
(list 'load file t)
(list 'remprop
(kwote fct)
''#:system:loaded-from-file)
(kwote fct))))))))
(dmc ↑P ()
(cons 'pretty
(implode (pname (catenate "(" (readstring) ")")))))
(dmc |!| () ; pour appeler le shell
(let ((l (readstring)))
(comline (if (equal l "") "$SHELL" l))))
;;; Definitions to allow path syntax before path is loaded.
(defsharp u () (list (read)))
(defsharp p () (list (read)))
; .Section "Load primitif"
(defvar #:system:redef-flag ()) ; Pour ne pas avertir des redefinitions.
; (de eof (n)
; ; traitement standard de la fin de fichier.
; (close n)
; (inchan ())
; (if #:system:in-read-flag
; (error 'read 'errsxt 11)
; (exit eof n)))
(de loadfile (file redef?)
(let ((#:system:loaded-from-file file)
(#:system:redef-flag redef?)
(#:sys-package:colon #:sys-package:colon)
(#:system:in-read-flag ())
(inchan (inchan)) )
(inchan (openi file))
(protect
(untilexit eof (eval (read)))
(let ((in (inchan))) (when in (close in)))
(inchan inchan) )
file ))
; .Section "La liste des fichiers de l'environnement standard"
(de all-the-files ()
'( ;
; 1 - Syste`me minimum
;
(virtty virbitmap display llpatch)
;
; 2 - Emacs ou PEPE
;
(pepe)
;
; 3 - Environnement standard
;
(setf defstruct sort array callext trace path
pretty debug ttywindow abbrev microceyx)
;
; 4 - Le chargeur
;
(loader)
;
; 5 - Compilateur
;
(cpmac llcp peephole)))
; .Section "Construction de l'environnement standard"
; Si cet indicateur = T, un INITTY est re'alise' apre`s
; chaque restore-core d'images fabrique'es par SAVE-STD.
(defvar #:system:initty-after-restore-flag t)
; Si cet indicateur = T, un INIBITMAP est re'alise' apre`s
; chaque restore-core d'images fabrique'es par SAVE-STD.
(defvar #:system:inibitmap-after-restore-flag t)
(de core-init-std (msg)
; rea'lise la se'quence d'initialisation apre`s un restore-core.
; msg est le message de bienvenue.
(when #:system:initty-after-restore-flag
(initty))
(when #:system:inibitmap-after-restore-flag
(inibitmap))
(herald)
#.(selectq (system)
(#.unix
'(let ((f (catenate (getenv "HOME") "/.lelisp")))
(when (probefile f)
(loadfile f t))))
(vaxvms
'(let ((f "sys$login:startup.ll"))
(when (probefile f)
(loadfile f t))))
(multics
'(let ((f (catenate (getenv "HOME") ">start←up.ll")))
(when (probefile f)
(loadfile f t))))
(t ()))
(print "; " msg " : " #:system:save-std-date)
(sortl (list-features)))
; Cette variable contient les diffe'rents GCINFO au moment
; des "save-std".
(defvar #:system:save-std-gcinfo-list (list (cons 'initial (gcinfo t))))
(defvar #:system:save-std-date ())
(de save-std (nom msg . user-functions)
;; Sauve une image standard de type "save-core" de nom NOM.
;; MSG sera la bannie`re de rappel de l'image.
;; USER-FUNCTIONS sont des fonctions a` lancer optionellement
;; apre`s save-core et apre`s restore-core. Si seulement une
;; fonction est fournie, elle est utilise' au save-core et restore-core.
;; Si aucune n'est fournie, les valeurs par de'faut sont "core-init-std".
(print "Attendez, je sauve : " msg)
(unless (featurep 'date)
(libload "date"))
(setq #:system:save-std-date (date))
(gc)
(newl #:system:save-std-gcinfo-list (cons nom (gcinfo)))
(setq #:system:real-terminal-flag t ; On force a` un terminal
#:system:line-mode-flag ()) ; normal avant save-core
(prompt |? |) ; y compris le prompt standard
(let* ((save-fn (or (car user-functions) 'core-init-std))
(restore-fn (or (cadr user-functions) save-fn 'core-init-std)))
(if (save-core (catenate #:system:core-directory
nom
#:system:core-extension))
(funcall save-fn msg)
(funcall restore-fn msg))))
(de load-std (nom . load-std)
; charge l'image standard
; 'nom' indique s'il faut faire une image me'moire (et c,a devient le nom)
; 'load-std' est la liste des indicateurs
; (min editeur environ loader compilateur)
(when (nth 3 load-std)
(libload module t)
(print "Je charge loader")
(loadmodule 'loader)
(rplaca (nthcdr 3 (all-the-files)) ())
)
(mapc (lambda (lf i)
(when i
(mapc (lambda (x)
(setq x (catenate #:system:llib-directory
x
#:system:lelisp-extension))
(print "Je charge " x)
(loadfile x t))
(or (consp i) lf))))
(all-the-files)
load-std)
(print " (llcp-std '<nom>) pour compiler l'environnement standard")
(when nom
(save-std nom "Systeme standard interprete")))
(de llcp-std (nom . flags)
; compilation de l'environnement standard
; et fabrication du core "nom"
(when (featurep 'compiler)
; essaie de de'gager un peu le compile-all-in-core
(and (eq (typefn 'pprint) 'expr)
(print "Je compile pprint.")
(let ((#:ld:special-case-loader t))
(compiler 'pprint t (car flags) (cadr flags))))
(and (eq (typefn '#:compiler:peephole) 'expr)
(print "Je compile #:compiler:peephole.")
(let ((#:ld:special-case-loader t))
(compiler '#:compiler:peephole
t (car flags) (cadr flags))))
(and (eq (typefn '#:compiler:macroexpand) 'expr)
(print "Je compile #:compiler:macroexpand.")
(let ((#:ld:special-case-loader t))
(compiler '#:compiler:macroexpand
t (car flags) (cadr flags))))
(and (eq (typefn 'loader) 'expr)
(print "Je compile loader.")
(let ((#:ld:special-case-loader t))
(compiler 'loader t (car flags) (cadr flags))))
(and (eq (typefn 'compiler) 'expr)
(print "Je compile compiler.")
(let ((#:ld:special-case-loader t))
(compiler 'compiler t (car flags) (cadr flags))))
(and (eq (typefn 'pepefile) 'expr)
(print "Je compile pepefile.")
(compiler 'pepefile t (car flags) (cadr flags)))
(mapc 'remob
'(all-the-files load-std llcp-std load-stm load-cpl))
(print "Je compile tout le reste.")
(compile-all-in-core (car flags) (cadr flags))
(when nom
(save-std nom "Systeme standard compile"))))
(de load-stm (nom . load-stm)
; charge l'image standard avec les modules complice's
; 'nom' indique s'il faut faire une image me'moire (et c,a devient le nom)
; 'load-stm' est la liste des indicateurs
; (min editeur environ loader compilateur)
; Il faut au minimum le code du chargeur et celui des modules.
(libload module t) ; llib/module.ll
(loadmodule 'loader) ; <system>/loader.lm --> llib/lapxxx.ll
; On charge les fichiers compile's indispensables.
(print "Je charge " (probepathm 'loader))
(let ((#:ld:special-case-loader t))
(loadmodule 'loader t))
(mapc
(lambda (m)
(print "Je charge " (probepathm m))
(unless (memq m #:module:compiled-list) (loadmodule m)) )
'(toplevel files module defs) )
; On charge le compilateur en premier s'il doit etre charge'
(setq load-stm (cons (car (cddddr load-stm)) load-stm))
; Et maintenant le reste.
(mapc (lambda (lf i)
(when i
(mapc (lambda (m)
(print "Je charge " (probepathm m))
(unless
(or (memq m #:module:compiled-list)
(memq m #:module:interpreted-list) )
(loadmodule m) ))
(or (consp i) lf))))
'((llcp)
(virtty virbitmap llpatch)
(pepe)
(setf defstruct sort array callext trace path
pretty debug ttywindow abbrev microceyx)
())
load-stm)
; On vire ce qu'il y a en trop.
(mapc 'remob
'(all-the-files load-std llcp-std load-stm load-cpl))
(when (featurep 'compiler) (compile-all-in-core))
(when nom (save-std nom
"Systeme standard modulaire")))
(de load-cpl (nom . load-cpl)
; charge l'image complice
; 'nom' indique s'il faut faire une image me'moire (et c,a devient le nom)
; 'load-cpl' est la liste des indicateurs
; (min editeur environ loader compilateur)
; Il faut au minimum le code du chargeur et celui des modules.
(libload module t) ; llib/module.ll
(loadmodule 'loader) ; <system>/loader.lm --> llib/lapxxx.ll
; On charge les fichiers compile's indispensables.
(print "Je charge " (probepathm 'loader))
(let ((#:ld:special-case-loader t))
(loadmodule 'loader t))
(mapc
(lambda (m)
(print "Je charge " (probepathm m))
(unless (memq m #:module:compiled-list) (loadmodule m)) )
'(toplevel files module defs) )
; On charge le compilateur en premier s'il doit etre charge'
(setq load-cpl (cons (car (cddddr load-cpl)) load-cpl))
; Et maintenant le reste.
(mapc (lambda (lf i)
(when i
(mapc (lambda (m)
(print "Je charge " (probepathm m))
(unless
(or (memq m #:module:compiled-list)
(memq m #:module:interpreted-list) )
(loadmodule m) ))
(or (consp i) lf))))
'((complice)
(virtty virbitmap llpatch)
(meme)
(setf defstruct sort array callext trace path
pretty debug ttywindow abbrev microceyx)
())
load-cpl)
; On vire ce qu'il y a en trop.
(mapc 'remob
'(all-the-files load-std llcp-std load-stm load-cpl))
; Patch les appels de Complice pour imprimer des fichiers
; objet sans abre'viations.
(when (featurep 'compiler)
(let ((#:system:redef-flag t))
(synonymq #:complice:patch:compilemodule compilemodule)
(de compilemodule l
(let ((#:system:print-with-abbrev-flag ()))
(apply '#:complice:patch:compilemodule l)))
(synonymq #:complice:patch:compilefiles compilefiles)
(de compilefiles l
(let ((#:system:print-with-abbrev-flag ()))
(apply '#:complice:patch:compilefiles l)))))
(when (featurep 'compiler) (compile-all-in-core))
(when nom (save-std nom "Systeme Complice modulaire")))
; .Section "Fin de chargement de l'environnement minimum"
(loadfile
(catenate #:system:llib-directory 'toplevel #:system:lelisp-extension)
() )
(loadfile
(catenate #:system:llib-directory 'files #:system:lelisp-extension)
() )
(loadfile
(catenate #:system:llib-directory 'defs #:system:lelisp-extension)
() )
(loadfile
(catenate #:system:llib-directory 'genarith #:system:lelisp-extension)
() )
(libautoload debug debug)
(libautoload module loadmodule readdefmodule)
; .Section "Les fonctions Autoloads"
; 0 - les fonctions standard
(libautoload virtty initty)
(libautoload virbitmap inibitmap)
(libautoload topwin topwindow)
; 1 - les utilitaires
(libautoload defstruct defstruct)
(libautoload array makearray aref aset)
(libautoload sort sort sortl sortn sortp)
(libautoload callext defextern cload defextern-cache #:system:cached-getglobal)
(libautoload trace trace untrace step)
(libautoload schedule parallel parallelvalues tryinparallel)
(libautoload pretty pretty pprint prettyf)
(libautoload format format prinf)
; 2 - les e'diteurs
(libautoload minimore more morend)
(libautoload edlin edlin edlinend)
(libautoload emacs emacs)
(libautoload pepe pepe pepefile)
; 3 - les jeux
(libautoload hanoi hanoi)
(libautoload whanoi whanoi)
(libautoload vdt vdt)
; .Section "Final de l'initialisation"
(defvar #:system:loaded-from-file ())
(remob 'unix)
(rmargin 78)
(print
#- #:system:foreign-language
" (load-std sav min pepe env ld llcp) pour charger l'environnement std,"
#+ #:system:foreign-language
" (load-std sav min pepe env ld llcp) to load standard environment,"
)
(print
#- #:system:foreign-language
" (load-stm sav min pepe env ld llcp) pour l'environnement std modulaire,"
#+ #:system:foreign-language
" (load-stm sav min pepe env ld llcp) to load modular environment,"
)
(print
#- #:system:foreign-language
" (load-cpl sav min meme env ld cmpl) pour l'environnement complice."
#+ #:system:foreign-language
" (load-cpl sav min meme env ld cmpl) to load complice environment."
)
(input ())
#- #:system:foreign-language "Fin du startup."
#+ #:system:foreign-language "End of startup."
) ; fin du progn silencieux