home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Monster Media 1994 #1
/
monster.zip
/
monster
/
FREQ_QA
/
LISP_2.ZIP
/
00000148.TXT
Wrap
Text File
|
1994-03-15
|
47KB
|
729 lines
Uï∞ü∞WVìF≡PÜ(αâ─ìF≡PÜ0αâ─Ä┬ï╪ï√îF÷&èO╕╙αëF°&ïGï╚&ïG║ï≥Ö≈■╛<ï┴ï╩ï╨ï┴ëå⌠■ï┬Ö≈■ï╞ï╩≈«⌠■ï≡±╗Ä$6ë₧·■îåⁿ■&╟ ╗~Ä&6ë₧÷■îå°■&ïÄF÷&9EtLÉΦ2╕pP3└P ╢°■ ╢÷■Üαâ─ÄF÷&ïE─₧÷■&ëÄ(6&â>ptÄ*6&â>vt
Ü£┘ÜT┘ÄF÷& E╟F·Ä,6&â>Θ▀ë~⌠╟F■╕⌠╣ùëå≡■ëÄ≥■ëvⁿïFⁿ─₧≡■&─^■ë₧∞■îåε■&9~ΘÖï├î┬ì~öï≤Ä┌╣-≤ÑñèFó*ΣàF°tz8f╥tèF╥─^⌠&8GuiÇ~╤tèF╤─^⌠&8GuWïFⁿ+Fö;Fû| ïFⁿ9Föuâ~ût÷Fÿ@t8èFú─^⌠&8Gt,ïFⁿ+Fö;Fû~<Ä.6&â>t0─^⌠&èG─₧≡■&─ïv■&ê@âF■[ F·ïF·Ä,6&9~Θ2 Θ⌡èFú─^⌠&8Gu÷FÖu╙ïv·Θzïv·─₧·■&ë7╗XÄ06ë₧Φ■îåΩ■&─?& ╡& ╡Ü£┘â─ìDP─₧Φ■&─& ╖╥& ╖╨Ü┌α â─Ä26&â>|uÄ46&╟zÄ66&╟¬─^⌠&èGï╚ï╞╗[≈δï╪Ä86&─>⌠&êIÄ86&─⌠ï°&Ça■ÉΦÇ~¿t;èF¿*ΣP─₧Φ■&─& ╖╓& ╖╘Ü┌α â─Ä46&╟zèF¿*ΣPܵ┘â─ΘvÄ:6&í▓&░uΘdÄ26&â>|uÄ46&╟z─₧Φ■&─& ╖┌& ╖╪Ü┌α â─Ä<6& 6¿& 6ªÜ`┘â─Üû┘ܼα ╕PÜ,╣â─Ä>6&íF&ïHëåΣ■ëûµ■╨t8 ╢µ■Pìå■■PÜ╝
αâ─÷|ìF▒Pìå■■PÜh
αâ─ìå■■PÜ╠┘â─Ä:6& 6▓& 6░ìå■■PÜ╝
αâ─÷|ìF▒Pìå■■PÜh
αâ─ìå■■PÜ╠┘â─Ä*6&â>vtܼα Ü«┘ÜB┘Ül┘░P░PÜ╢] â─Ä@6& 6á& 6₧Ü`┘â──₧Φ■&─& ╖▐& ╖▄Ü┌α â─╕pPÜ╒ â─ÄB6&úR&ëT─₧·■&ë7ïF₧ÄD6&úïFáÄF6&ú Üf┘─₧·■&ë7÷FÿtÄH6&Ç&│ÄJ6&╞ƒδÉÄH6&Ç│ÇÄJ6&╞ƒèfÖ%=└≈╪ÄL6&úïF₧ÄD6&úïFáÄF6&ú ^_ïσ]╦ÉUï∞ü∞▐VÄN6& 6 & 6ìår PÜ╝
αâ─ÄN6& 6 & 6ìå" PÜ╝
αâ─╕vPìår PÜh
αâ─╕éPìå" PÜh
αâ─ìFαPìår PÜXXαâ─@uΘNìF┬Pìå" PÜXXαâ─@uQÄN6& 6 & 6ìå" PÜ╝
αâ─ÄP6& 6(& 6&ìå" PÜh
αâ─ìF┬Pìå" PÜXXαâ─@uΘτïF≥ïV⌠9V╓vΘ┘r9F╘vΘ╧â~≡}Θ╞ â~ε[sΘ╗╕ÇPìår PܬCαâ─ï≡â■ uΘƒ╞år ╕Pìår PVÜj3αâ─ 6d 6bìår PÜ°
αâ─└ud╕pP╕~╣ùQPVÜj3αâ─ìF■PïFε-ÇPÄ86& 6÷& 6⌠VÜPαâ─ÄR6&╟╕[ÖRPïFεïV≡-Çâ┌RPÜ║αÄ,6&úVÜ╚2αâ─^ïσ]╦Uï∞ü∞╘WV+└PPÜ(αâ─ëFⁿëV■ÄN6& 6 & 6ìFäPÜ╝
αâ─ÄN6& 6 & 6ìå4 PÜ╝
αâ─╕ÄPìFäPÜh
αâ─╕ÜPìå4 PÜh
αâ─ìF╘Pìå4 PÜXXαâ─@uQÄN6& 6 & 6ìå4 PÜ╝
αâ─ÄP6& 6(& 6&ìå4 PÜh
αâ─ìF╘Pìå4 PÜXXαâ─@uΘ3ïFµïVΦ9V■w1r9Fⁿs*ëF≥ëV⌠ëF÷ëV°Ä06&─X& ╖Γ& ╖αÜ┌α â─δÉïFⁿïV■ëF≥ëV⌠ëF÷ëV°╕ÇP╕üPìFäPܬCαâ─ï≡â■ uΘ╞╕P 6d 6bVÜh4αâ─╕pP╕~╣ùQPVÜh4αâ─3 ╗Ä,6ë₧0 îå2 &9?~Dëvⁿ3╔ëN■ï±╕ùÄ╪─⌠▐â├ë₧, îå. &÷Gt&÷u&Çg■â╞[G─₧0 &9?╨ïvⁿìF·P╕[─₧0 &≈/PÄ86& 6÷& 6⌠VÜWαâ─VÜ╚2αâ─ìF≥PìFäPÜ«Rαâ─^_ïσ]╦ÉUï∞â∞TWVÄN6& 6 & 6ìF¼PÜ╝
αâ─╕ªPìF¼PÜh
αâ─╕▓PìF¼PÜ¿αâ─ï≡ëV■╨t)ïF■PV╣Q╣pQ╣~║ùRQï°Üxαâ─WVܪαâ─^_ïσ]╦ÉUï∞â∞"WVìFΦPÜ(αâ─ìFΦPÜ0αâ─ï°ëVε╕<Ä┬&≈m&EëF⌠ÄT6&╟ ÄFε&èM╕╙αëF≡╟F÷╕& E╟F·ë~∞Ä,6&íëFµ└Θ╔Ä86&í⌠&ï÷ï╪ëV■Ä$6&íëFΣïN·╕╘Ä╪9NΣuΘïâ~t ÄF■&÷-------------------------------------
;;; *EOF*
JÄF■&èG9êFα
└tÄFε&èD8Fαu0ÄF■ìwⁿ&ïëF▐;F⌠ÄF■&÷@t┐δï°+~⌠9~÷~ë~÷ëâ├[A9Nµ~Θa ü~÷í}Θ╡╕á+F⌠ëF≥╤f≡â~≡@~╟F≡3╔9NµΘöÄ86&í⌠&ï÷>ï╪ëV■ï~∞╕╘Ä╪â~tÄF■ìw╞&÷uZÄF■ìw╨&è*ΣàF≡tJÄF■&èêFΓ
└t ÄFε&8Eu4ÄF■ìw &èêFα
└t ÄFε&8EuÄF■ìw┬&ïF≥ëF°;F÷}ëF÷ëâ├[A9Nµïü~÷áïV÷δ║áâ~tâ·}║ï┬^_ïσ]╦Éear all searchUï∞ü∞╢WV╕╚Pܬαâ─ï≡ëV■╨t5╕╨PÜ6 â─└u$ïF■PVìåV PÜ╝
αâ─ìåV PÜ┘â─δÉ╞åV ╕▄PìåV PÜh
αâ─ìF╓PìåV PÜXXαâ─└t$ìåV P╕ΦP╕╠(PÜ─αâ─╕·PÜ≤αâ─ï~ΣW╕PÜαâ─ï≡ëV·╨u╕P╕╠(PÜ─αâ─╕·PÜ≤αâ─╕P╕-PìåV PÜ26 â─
ëFⁿëV■╨u$ìåV P╕0P╕╠(PÜ─αâ─╕·PÜ≤αâ─ v■ vⁿW╕P v·VÜαâ─;╟t2ìåV P╕LP╕╠(PÜ─αâ─ v■ vⁿܪαâ─╕·PÜ≤αâ─ v■ vⁿܪαâ─└t$ìåV P╕wP╕╠(PÜ─αâ─╕·PÜ≤αâ─ïF·╗
Ä 3ë₧R îåT &ë7&ëGìL╗XÄ"3ë₧N îåP &ë&ëGÄ└&ï<ü pt#╕pPW╕ÖP╕╠(PÜ─αâ─╕·PÜ≤αâ──₧N &ï&ïWï╧╤ß╤ß┴ï≡ëVⁿ╟F°â ~>║ìM ëV■ëv·ë~÷ï≥ï~·╕ùÄ╪ÄZïX&ï&+╟ïVⁿ&ë&ëPâ╞IuΣïv·─₧N &─ïFⁿ&ë7&ëG─₧R &─&ï╤α╤α&G├î┬ï°ëV÷ï╪&ïÄ$3&ú· â╟ï┬&ë>
&ú
&ï· ╤π╤π▀Ä┬&ïÄ&3&ë║ìOëF÷&ë└&ú┬&ï║╤Γ╤Γ╩ï∙╗HÄ(3ë₧J îåL &ë&ëGâ┴Ä*3&ë┤&ú╢ÄF÷&ï╤Γ╤Γ╩ï±ëFⁿPQÜ"αâ─@≡╟F°─₧J &─&â?~Gë~⌠║ëV■ëv·ï≥ïN°ï~·╕ùÄ╪─┤&ï&+╟ïVⁿ&ë&ëPâ╞A─₧J &─&9┌ï~⌠ïv·Ä*3&─┤ïFⁿ&ë7&ëG─₧J &─&ï@╤α╤α&G°ïF÷Ä,3&ë>ä
&úå
ìMÄ.3&ë▄&ú▐╕^_ïσ]╦É&àÜuΘ0 Uï∞â∞.WVÜ4┘ÄZ9&╟3└Ä\9&ú6Ä^9&ú"Ä`9&ú╓Äb9&úrÄd9&ïbÄf9&ëdÄh9&ïfÄj9&ëh+╔ëN÷ëN⌠ v vÜZ α â─RP╕╠"P╕r╣ùQPÜααâ─╕÷╣ùïVï^ï±Vï°ï≥Ä┴Ä█╣≤Ñ^║╢╣ùëV≡ëN≥Vï·ï≡Ä┴╣≤ÑÄl9&â>nu-Än9&─X& ╖B& ╖@Ü┌α â─╕╧"PÜ|α â─3└Θb╕r╣ùQPÜÆ┘â─└tτï~
Θ╛╕P v≥ v≡PÜ┘â─└t!2└P░PÜ╢] â─Äp9&àÜt¡ÜN┘δªÉ2└P░PÜ╢] â─Äp9&àÜuÜ╬┘╕,
╣ùQPÜ╚┘â─2└P░PÜ╢] â─Äp9&àÜuΘ0 ~+└PPÜ(αâ─ëF⌠ëV÷╕PÜⁿ┘â─+└PPÜ(αâ─ï╚ï┌+F⌠V÷Ä~9&ú║&ë╝SQ v÷ v⌠ï≡ï∙ëvΓëVΣï≤Ürα â─ëFⁿëV■Ä~9&Ω&∞╣d3█SQRPÜåαëF°ëV·╕dÖRP v■ vⁿÜ║αëFⁿëV■ v· v°RP╕<ÖRP╣─ ╗ SQ╕ÖRP vΣ vΓÜ║αRPëF▐ëVαÜTα╣─ ╗ SQ vα v▐ëF┌ëV▄ÜTα╣<3█SQ vΣ vΓëF╓ëV╪Ü║αF╓V╪ïN┌ï^▄+╚┌SQëF╥ëV╘ÜTα╟╓+F⌠V÷RP v╘ v╥ vα v▐ v vÜZ α â─RPÄn9&─X& ╖r& ╖pÜ┌α â─ÜN┘Ä~9& å╗pÄr9ë^µîFΦ&â?tÄt9&â>vtÜ£┘Ü÷┘─^µ&â?t;Ä^9&â>"uÄ\9&â>6uÄ`9&â>╓t╕ P v vÜ╪┘â─ÉΦé─^µ&â?tMÄt9&â>vtA╕P╕PÄv9& 68& 66Ü`┘â─╕PÄx9&áGPÄv9& 68& 66Ü≡┘â─╕Θå tΘ╣╕╘Ä╪╕[≈.ï╪╕ùÄ└&í⌠&ï÷Ä┬╪îFε&÷GÇt1&9}&ïG≈╪╣ùÄ┴&;z
~3└Θ6╕ùÄ└&íz
ÄFε&9G|τ╕╘Ä└&íëFΩ└u╕╘Ä└&â>tÄFε&÷Gu╕ùÄ└&÷Ç
t│â~Ωu╕╘Ä└&â>tÄFε&÷Gt╕ùÄ└&÷Ç
uë╕P v≥ v≡PÜ┘â─└tΘ}ⁿÜ╬┘╗pÄr9ë^µîFΦ&â?tMÄt9&â>vtA╕P╕PÄv9& 68& 66Ü`┘â─╕PÄx9&áJPÄv9& 68& 66Ü≡┘â─+└PPÜ(αâ─ëF⌠ëV÷Äz9&â>|uÄ|9&╟z╕,
╣ùQPÜî┘â─ï≡÷|Θ%ⁿ─^µ&â?tMÄt9&â>vtA╕P╕PÄv9& 68& 66Ü`┘â─╕PÄx9&áGPÄv9& 68& 66Ü≡┘â─╕P v≥ v≡╕PÜ┘â─ï╞ΘÆÄn9&─X& ╖F& ╖DÜ┌α â─╕P v≥ v≡╕PÜ┘â─Är9&â>ptMÄt9&â>vtA╕P╕PÄv9& 68& 66Ü`┘â─╕PÄx9&áGPÄv9& 68& 66Ü≡┘â─Ü÷┘╕^_ïσ]╦Uï∞â∞WV╕P3└ÄZ9&úP╕÷╣ùQPÜαâ─ÄÇ9+└&ú&ú■ï~ u1Äé9&9>"t2└P░PÜ╢] â─Äp9&àÜuÜ|] ÷─uΘ╗Ää9&╟Äå9&íëF·└|#╕[≈n·ï≡Äê9&─⌠&÷@tÄä9&╟2└P░PÜ╢] â─= tΘ╨Äz9&â>|uÄ|9&╟zÄr9&â>ptÄt9&â>vtÜT┘Äé9&â>"t2└P░PÜ╢] â─Äp9&àÜtΘ t╛3 δÉ╕⌠PÜ▐┘â─ï≡â■tΘéÄè9&íN&Lts╕dPÜ╒ â─ëFⁿëV■Ü|] ÷─t6ë~ v■ vⁿÜ`╒ â─└u!╕dPÜ╒ â─ëFⁿëV■Üè] Ü|] ÷─u═Ü°] 3└PÄè9& 6N& 6LÜ└┘â─ΘΩ■â■tm╕pPÜ╒ â─ëFⁿëV■RPÜ`╒ â─└tΘP■ë~Ü|] ÷─tΘ@■2└P░PÜ╢] â─= tΘ*■Ü─α v■ vⁿÜ`╒ â─└t╞Θ■Ü─α 3└δbÉ2└P░PÜ╢] â─Äp9&àÜt;3└PÜⁿ┘â─ÜN┘Ä^9&â>"uÄ\9&â>6uÄ`9&â>╓tÉΦδÜN┘ÉΦ(╕^_ïσ]╦ÉUï∞ü∞·WV╗Äå9ë₧
îå &â?|%╕[&≈/Äê9&⌠&ï÷ì~ñï≡Ä┌╣-≤Ññ─₧
&â?}ΘÄÄ^9&â>"t5Ç~║t/èF║*ΣPÄn9&─X& ╖N& ╖LÜ┌α â─èF║*ΣPÉΦⁿâ─3÷ì~πÄî9&Ç╝&t1èB╗*ΣPWÄn9&─X& ╖R& ╖PÜ┌α â─
èB╗*ΣPÉΦ║â─Fâ╟ìF√;°r╕╗╓Ä`9ë₧ îå &â?uÄ\9&â>6t?─₧
&â?|5Ç~╣t/èF╣*ΣPÄn9&─X& ╖V& ╖TÜ┌α â─èF╣*ΣPÉΦOâ─ÄÄ9&í▓&░uΘ─₧ &â?uÄ\9&â>6uÄ^9&â>"uΘ⌡Än9&─X& ╖Z& ╖XÜ┌α â─ÄÉ9& 6¿& 6ªÜ`┘â─Üû┘ܼα ╕PÜ,╣â─ÄÄ9& 6▓& 6░ìå PÜ╝
αâ──₧
&â?|ìF┴Pìå PÜh
αâ─Ü╥┘ìå PÜ╠┘â─Ü╞┘░P░PÜ╢] â─Än9&─X& ╖^& ╖\Ü┌α â─ÄÆ9& 6á& 6₧Ü`┘â─Ü┘╕pPÜ╒ â─Äö9&úR&ëT3└Ä^9&ú"Ä\9&ú6─₧ &ë^_ïσ]╦ÉUï∞ÜÇ┘╕╨"PÄû9& 6°& 6÷Än9&─X& ╖å& ╖äÜ┌α ïσÄÉ9& 6¿& 6ªÜ`┘ïσÜû┘Ät9&â>vtÄÿ9& 6╕3└PÜ≥] ïσÄÜ9&â>LtÜr╣Ä£9&â>duÜ.] vÜ≤αïσ]╦Uï∞Vïv÷u3└Öδ,Ü─αï╚ï╞Ö+┬╤°ìTï╪ï┴ï╩Ö≈∙ï┬├╣d≈ΘPÜ╒ â─^ïσ]╦ÉUï∞â∞WVï~Ä₧9&íB&ïDÄF&9Eu &9U
uΘ&ïE
&EuΘÄá9&─α&╞Äó9& 6▐& 6▄╕╞KPÜ╝
αâ─╕╞KPÜ"αâ─╞KëF÷î^°╟F■Äñ9&í&uΘ╗ï~■─N╕ùÄ╪ï±ïïW&9Du&9T
tGâ├ïGuΓΘφÉĪ9ï▀╤π╤π&ïç╢&ïù╕ëV⌠╨uΘ╠ïV⌠ï≡ëVⁿÄ┬ï▐&Ç?u$ï~÷Ä¿9&â>t3╕┌"P v°WÜααâ─ΘùÉï~÷Ä^ⁿÄF°ï▐Fèï▀G&êÇ<u≡δ┬É─^& 7╕▄"P v°Wδ_ÉĬ9& 6╓& 6╘╕╞KPÜ╝
αâ─╕╞KPÜ"αâ─╞Kï≡î^°Ä¼9&í≡ÄF&9t&Ä¿9&â>uÄF& 5╕π"PìD v°PÜααâ─
╕╞Kî┌^_ïσ]╦ÉUï∞â∞Ät9&â>vuΘ½Är9&â>puΘ£3└PÜ,╣â─Äå9&í@P╕Ω"P╕r╣ùQPÜαα╕
αP╣QÄ«9& 6·& 6°Ü`┘â─╕r╣ùQPÄ«9& 6·& 6°ÜZ┘â─Ä░9&í£@PÄ▓9& 6╛
╕∩"P╕r╣ùQPÜααâ─╕
P╕PÄ«9& 6·& 6°Ü`┘â─╕r╣ùQPÄ«9& 6·& 6°ÜZ┘â─ÉΦΣÄ┤9&íbëF■└t'PÄ╢9& 6& 6╕·"P╕r╣ùQPÜααâ─δ$ÉÄ╢9& 6& 6╕#P╕r╣ùQPÜααâ─╕P╣QÄ«9& 6·& 6°Ü`┘â─╕#PÄ«9& 6·& 6°ÜZ┘â─╕P╕PÄ«9& 6·& 6°Ü`┘â─╕r╣ùQPÄ«9& 6·& 6°ÜZ┘â─3└PÄ╕9& 6^Üα ïσ]╦ÉÄt9&â>vt&Är9&â>pt╕ PÄ║9& 6û& 6öÜÉ┘â─╦ÉUï∞â∞.WVï~╗FLï≤î^·╞ }Θdï╟╣[≈ΘëF╘╗⌠Äê9ë^╓îF╪&─╪&÷Gt╞FLBï╞î┌@ï≡ëV·â~t Ä┬ï╪F&╞ ─^╓&─^╘&÷GtÄF·ï▐F&╞Câ~t
ÄF·ï▐F&╞ ─^╓&─^╘&÷GtÄF·ï▐F&╞Dâ~t
ÄF·ï▐F&╞ â~t$─^╓&─^╘&÷G@tÄF·ï▐F&╞FÄF·ï▐F&╞ ─^╓&─^╘&÷GtÄF·ï▐F&╞Hâ~t
ÄF·ï▐F&╞ ─^╓&─^╘&÷GtÄF·ï▐F&╞Kâ~t
ÄF·ï▐F&╞ ─^╓&─^╘&÷GÇtyÄF·ï▐F&╞Lâ~ti─^╓&─^╘&ïGëF╥└|@P╕+#δÉ╕ +F╥P╕0#PìF┌PÜααâ─
ìF┌î╥ï╚Ä┌ï╪6Ç?t!ëv°ëNⁿï°ï▀Gè─^° F°&êÇ=uφïv°ï~â~t$─^╓&─^╘&÷GtÄF·ï▐F&╞MÄF·ï▐F&╞ ─^╓&─^╘&÷GtÄF·ï▐F&╞Nâ~t
ÄF·ï▐F&╞ ─^╓&─^╘&÷GtÄF·ï▐F&╞Sâ~t
ÄF·ï▐F&╞ ─^╓&─^╘&÷G tÄF·ï▐F&╞Râ~t
ÄF·ï▐F&╞ â~tï^╘─~╓&─=&÷At
ÄF·ï▐F&╞XÄF·&╞╕FLî┌^_ïσ]├ÉUï∞Ät9&â>vuΘ╚Är9&â>puΘ╣Ä╝9&â>≡uÉΦ²3└PÄå9& 6Φ+²ïσRPÄå9&í@P╕5#P╕r╣ùQPÜααïσ╕
P╣QÄ«9& 6·& 6°Ü`┘ïσ╕r╣ùQPÄ«9& 6·& 6°ÜZ┘ïσ╕
P╕PÄ«9& 6·& 6°Ü`┘ïσ v vÄ«9& 6·& 6°ÜZ┘ïσÜT┘ïσ]╦Uï∞ü∞¼WV3└PÜz┘â─ï°╗Ä╛9ë₧` îåb &â?}ΘTÄt9&â>vuΘEÉΦⁿW─₧` &ï@P╛XÄn9ë╢\ îå^ &─& ╖f& ╖dìåd PÜααâ─╕P╕P╗öÄ║9ë₧X îåZ & w& 7Ü`┘â─ìåd P─₧X & w& 7ÜZ┘â─╕P─₧` & 7Φ╦√â─Ä┬ï╪ï≤îF·&Ç?tTï┬PV─₧\ &─& ╖j& ╖hìåd PÜααâ─╕PP─₧X & w& 7Ü`┘â─ìåd P─₧X & w& 7ÜZ┘â─╗╠Ä└9ë₧T îåV &ïG&uΘ9& w& 7ìåd PÜ╝
αâ─╕A#Pìåd PÜh
αâ─╕P╕J#Pìåd PÜ26 â─
ï≡ëV·╨uΘεïF·PV╣QQìN⌠Qï°Üαâ─ëFⁿWVܪαâ─â~ⁿuΘ┐ïvⁿ╤µïr≥─₧T & w& 7ìåd PÜ╝
αâ─╕M#Pìåd PÜh
αâ─3└PìÄd QìN╚QÜ*6 â─
└uqëv■ìFµPÜóαâ─;╞╕Pìåd PìF╚PÜ*6 â─
└t╘δ@É╕2P╕P─₧X & w& 7Ü`┘â──₧\ &─& ╖n& ╖l─₧X & w& 7ÜZ┘â─ÜT┘^_ïσ]╦R$bàCLS╦░Uï∞â∞.WVÄ╬4╕ù┐µ╛ΦÄ╪╣≤ÑÄ╨4&╟╝
╕&╣╘QPÜ(αâ─Ä╥4+└&ú,&ú*&ú(&ú0&ú.╗pÄ╘4ë^ΣîFµ&9t&Ä╓4&9vtÄ╪4&─X& ╖& ╖Ü£┘â─╟Fⁿ≥Ä┌4ï^ⁿ&â?uΘ╟ï├-╣ùì~Φï≡Ä┘╣≤Ñâ~εt%ïFεëF∞╟FεÄ▄4&íèëFΓ└~ëFΩδÉ╟FΩìFΦPÜ■α â─RPÄ╬4& 6°& 6÷╕Γ
P╕r╣ùQPÜααâ─╕r╣ùQPÜéBαâ─ìFΦPÜ■α â─RP╕δ
P╕r╣ùQPÜααâ─╕r╣ùQPÜéBαâ─âFⁿü~ⁿjsΘ) +└ëF≥ëF≡ëFΦëFΩëF∞ëFε╗εÄ▐4ë^▐îFα&ëÄα4&â>v└%╗ΣÄΓ4ë^┌îF▄&ëÄΣ4&â>x╔≈┘┴─^┌&ëĵ4&í╛
ÄΦ4&9«sÄΩ4&â> t─^┌&Ç3└P╣╢║ùëN╓ëV╪RQ╣QÉΦDâ─â~uΘ╬╕÷╣ùQP╕PÜ╝α â─Üÿ┘└tΘuÜ░┘HtpHtHHtMΘcܬ┘└uΘW─^▐&ï─^┌&àub╕Ä∞4&úhÄε4&údÄ╪4&─X& ╖Æ& ╖ÉÜ┌α â─δñÜñ┘└uΘ─^▐&ï─^┌&àu2δ┤Ä∞4&╟h3└PÜ₧┘ΘΣÄ≡4&╟T ╕Ä∞4&úhΘ┼É╕Θ╛╕t╣ùëF╥ëN╘ÉΦ3 ─^╥&9?~1╛Ä≥4& t& 4╕ª ╣ùQPÜ╠Fαâ─└uΘâ╞G─^╥&9?╥Ü╢┘ï°HuΘ≤HuΘGHtvHuΘ╛â }ΘWÄ⌠4&ít;╟ΘE2└P░PÜ╢] â─Ä÷4&àÜuΘ)ìFΦP╕PÜ╝α â─3└P v╪ v╓╕PÉΦ⌐â─Ä°4╤τ& ╡Ü┌┘ΘφÉÜ╘┘└uΘπ─^▐&ï─^┌&àtΘü╕Äε4&údÄ∞4&úhÄ╪4&─X& ╖Æ& ╖ÉÜ┌α â─Θµ■Ü╬┘└uΘò─^▐&ï─^┌&àtΘπδ░Éâ╟Θ6 2└P░PÜ╢] â─Ä÷4&àÜuΘ_Ä·4&â>tΘPìFΦP╕PÜ╝α â─3└P v╪ v╓╕PÉΦ╨â─Ü╚┘Θ"É2└P░PÜ╢] â─Ä÷4&àÜuΘ╟FΦⁿìFΦP╣QÜ╝α â─╟FΦÄⁿ4& é─^Σ&â?tpÄ╓4&â>vtdÄⁿ4& 6é& 6Ç╕≥
P╕r╣ùQPÜααâ─╕P╕PÄ■4& 6& 6Ü`┘â─╕r╣ùQPÄ■4& 6& 6ÜZ┘â─ÜT┘Ä∞4&╟h3└PÜ┬┘ΘOÉ╕÷╣ùQP╕PÜ╝α â─Äⁿ4& é─^Σ&â?tpÄ╓4&â>vtdÄⁿ4& 6é& 6Ç╕°
P╕r╣ùQPÜααâ─╕P╕PÄ■4& 6& 6Ü`┘â─╕r╣ùQPÄ■4& 6& 6ÜZ┘â─ÜT┘Ä≡4&╟T Ä∞4&╟hΘùÉ╕÷╣ùQP╕PÜ╝α â─Äⁿ4& é─^Σ&â?tpÄ╓4&â>vtdÄⁿ4& 6é& 6Ç╕■
P╕r╣ùQPÜααâ─╕P╕PÄ■4& 6& 6Ü`┘â─╕r╣ùQPÄ■4& 6& 6ÜZ┘â─ÜT┘3└PÜ╝┘â─Ä5&╞ª Ä5&íbÄε4&údÄ5&ífÄ∞4&úh╕P v╪ v╓╕PÉΦfâ─3└P v╪ v╓╕PÉΦQâ─^_ïσ]╦WV╕ùÄ╪+└úú■úⁿú·ú°ú÷╣ùÄ┴&úε╣ùÄ┴&úr╣ùÄ┴&ú╓╣ùÄ┴&ú6╣ùÄ┴&ú"╣╘Ä┴&úµ╣ùÄ┴&ú╝
╣ùÄ┴&ú≥╕ùÄ└╕ù┐µ╛ΦÄ╪╣≤Ñ^_╦ÉUï∞â∞V╕XPÜ╒ â─ëF·ëVⁿRPÜ`╒ â─└uuïv2└P░PÜ╢] â─Ä÷4&àÜtYܵα └uP2└P░PÜ╢] â─÷─ tÄFï▐F&è
└t*<t&PÜ÷] â─δÉÜ─α vⁿ v·Ü`╒ â─└tùδÉ╕δ'É2└P░PÜ╢] â─Ü:] ╕
PÜÄα â─Ü°] 3└^ïσ]╦ÉUï∞ü∞(WV╗bÄ5ë₧▐■îåα■&â?uΘ] v
vÜα┘â─ëFⁿëV■ïF└tHt#HuΘëHuΘòHuΘτ╕Θ)É╟FΘ╫É3÷96F~(┐εD╕P v
vWÜdαâ─
└uΘ÷â╟F;6F|█ï~ÄF
&â}t=& u& u v■ vⁿ╕Pìåb PÜααâ─ÄF
& u╕/PìFΓPÜααâ─
δ2É v■ vⁿìåb PÜ╝
αâ─ÄF
& u& u╕8PìFΓPÜααâ─ïF╤π╟çF─₧▐■& 7ìåb P╕EPìåΓ■PÜααâ─╕TPìåΓ■PÜ¿αâ─ï≡ëV■╨usÄ5&í╪&ï┌ëå┌■ëû▄■╨tZïF╤π╟çF ╢▄■ ╢┌■ìåb PÜ╝
αâ──₧▐■& 7ìåb P╕WPìåΓ■PÜααâ─╕fPìåΓ■PÜ¿αâ─ï≡ëV■ïF■╞u-â~uΘy■ìåΓ■PÄ╪4&─X& ╖>& ╖<Ü┌α â─ΘU■ïF■PVܪαâ─ìFΓPìåb PÜh
αâ─ìåb PìåΓ■PÜ<αâ─└uX9Ft!ìåb PÄ╪4&─X& ╖B& ╖@Ü┌α â─íFï╚╤α┴╤α╤αεDëFⁿî^■ FïFïV
ï≡Ä┌─~ⁿ╣≤ÑΘ≤Éâ~t+ v
vÜZ α â─RPÄ╪4&─X& ╖F& ╖DÜ┌α â─ìåΓ■PÜéBαâ─Θâ²â>FuΘy²3÷96F~%┐εD╕P v
vWÜdαâ─
└t
â╟F;6F|▐96F/â~uΘ=² v
vÜZ α â─RPÄ╪4&─X& ╖J& ╖HΘ╖■ï~ÄF
&â}t=& u& u v■ vⁿ╕iPìåb PÜααâ─ÄF
& u╕yPìFΓPÜααâ─
δ2É v■ vⁿìåb PÜ╝
αâ─ÄF
& u& u╕éPìFΓPÜααâ─ï▐╤πü├Fë₧╪■â?tÄ5& 6┌& 6╪ìåb PÜ╝
αâ─ìFΓPìåb PÜh
αâ─ï₧╪■╟ï■F;6F}rï╞╤αFëF·ï╟╤αFëF°ï╞╤α╞╤α╤αεDëF■ï╟╤α╟╤α╤αεDëFⁿíF+╞ëF÷ë~≥ëv⌠ïF■ï^ⁿï√ï≡╣≤Ñï^·âF·ïï^°âF°ëâFⁿâF■ N÷u╨ Fìåb PÜéBαâ─└u$9FuΘ╗√ìåb PÄ╪4&─X& ╖N& ╖LΘ?²â~uΘ├ìåb PÄ╪4&─X& ╖R& ╖PÜ┌α â─ΘƒÉÄ5&í╪&ï┌ëå┌■ëû▄■╨uΘé─₧▐■& 7 ╢▄■P╕Pìåb PÜααâ─╕Pìåb PÜ¿αâ─RPܪαδDÉÄ5&í╪&ï┌ëå┌■ëû▄■╨t-─₧▐■& 7 ╢▄■P╕Pìåb PÜααâ─ìåb PÜéBαâ─3└^_ïσ]╦Uï∞â∞(╗$Ä
5ë^▐îFα&â?uΘ≡╗╪Ä5ë^┌îF▄&ïG&uΘ╫íÆÉt 6Æ 6ÉÜ`╒ â─└uΘ╖╕dPÜ╒ â─úÉëÆÄ5&íbëF╪└tP─^┌& w& 7╕öP╕NFPÜααâ─δ─^┌& w& 7╕óP╕NFPÜααâ─ìFΓP╕NFPÜXXαâ─└uD╕NFPÜéBαâ──^▐& 7Ä╪4&─X& ╖₧& ╖£Ü┌α â─Ä5&╟z─^▐& 7ܵ┘ïσ]╦3└Ä╪9&úRúzLúxLÄ┌9&9ptIÄ▄9&9vt>╕PPÄ▐9& 6û& 6öÜ`┘â─╕╠#PÄ▐9& 6û& 6öÜZ┘â─ÜT┘δÉ╕ε#PÜ|α â─Ü°] Äα9&á£$■P░PÜ╢] â─╕PΦ½â─└u ÄΓ9&─X& ╖N& ╖LÜ┌α â─3└δnÉÄ┌9&â>ptJÄ▄9&â>vt>╕PPÄ▐9& 6û& 6öÜ`┘â─╕∙#PÄ▐9& 6û& 6öÜZ┘â─ÜT┘δÉ╕$PÜ|α â─╕PΦΣâ─╦V3└Ä╪9&úRúzLúxLÄ┌9&9ptHÄ▄9&9vt=╕PPÄ▐9& 6û& 6öÜ`┘â─╕&$PÄ▐9& 6û& 6öÜZ┘â─ÜT┘δ╕H$PÜ|α â─Ü:] Äα9&á£$■P░PÜ╢] â─3└PΦNâ─└tzÄ┌9&â>ptKÄ▄9&â>vt?╕PPÄ▐9& 6û& 6öÜ`┘â─╕S$PÄ▐9& 6û& 6öÜZ┘â─ÜT┘δÉÉ╕u$PÜ|α â─3└PΦâ─ï≡÷uÜ4┘ï╞^╦ÉUï∞â∞WVÄΣ9&í╕
&ï║
ï°ëV≡ï╚ï┌Ç─ëF≥ëV⌠╕Ç$PSQÜ╝
αâ─╕ç$P v≡WΦöâ─╕÷╣ùQPΦrâ─ĵ9&íµï╚╤α┴╤α╤α≡╣ùQPÜZ α â─RP╕ë$PÜ┌α â─ĵ9&íµï╚╤α┴╤α╤α≡╣ùQPÜZ α â─RP v≡WΦ'â─3└ëF■ëF·ÄΦ9&9Σ~Që~ε╛≡ï°Äµ9&9>µt,╕ù$P v≡ vεΦ≡â─╕ùPVÜZ α â─RP v≡ vεΦ╒â─â╞GÄΦ9&9>Σ║ï~ε╕Ö$P v≡WΦ┤â─╗8ÄΩ9ë^µîFΦ+└&ëG&ë9Ft╕÷╣ùQPÜ:┘â─└'â~uZízLï╚╤α┴╤α╤α0╣ùQPÜ:┘â─└~9─^µ&ïG&t-╕P& w& 7 v⌠ v≥Ü<αâ─
─^≥&╞GS v≡WΦ%â─╕£$P v≡WΦâ─â~t)Ä∞9&â>^uÄε9&â>`t╕ó$δ6╕º$δ1É╕¼$δ+ÉÄ≡9&÷▓t╕▒$P v≡WΦ╠â─Ä≡9&÷│Çu╕╢$P v≡WΦ▒â─╕╗$P v≡WΦóâ─Ä≥9&â>Σ└≈╪¿t+╕ùÄ└&ÇΣâ~u:&íΣ╣ùÄ┘#εëFΣ¿t╛δ&É╕ùÄ└δ┘É÷FΣt╛δÉïv■¿t
╛δ&ï6Σâ■└≈╪¿t╕╛$δ`Éâ~t6≈╞t╕├$P v≡WΦâ─≈╞t╕╚$P v≡WΦ√â─ï╞¿t3╕═$δ"É≈╞t╕╥$δÉ≈╞t╕╫$δ
Éï╞¿t╕▄$P v≡WΦ┬â─Ä≡9&÷│Çtâ~tÄ⌠9&â>zu╕ß$P v≡WΦòâ─╕µ$P v≡WΦåâ─╕ε$P v≡WΦwâ─╕≤$P v≡WΦhâ─Ä÷9&â>j uÄΓ9&─X&ïç╝&ïù╛δ╕⌡$î┌ëFⁿëV■RPÄ°9& 6⌠Ä·9& 6≥╕÷$P╕P╕%P v⌠ v≥Üααâ─ v⌠ v≥ v≡WΦⁿâ─╕%P v≡WΦφâ─Äⁿ9& 6║& 6╕Ä■9& 6╛& 6╝Ä:& 6╢& 6┤╕#%P v⌠ v≥Üααâ─ v⌠ v≥ v≡WΦBâ─Ä:& 6╞& 6─Ä:& 6╩& 6╚Ä:& 6┬& 6└╕0%P v⌠ v≥Üααâ─ v⌠ v≥ v≡WΦ⌡â─╕=%P v≡WΦDâ─Ä:&í&&ï(Ç─0ü╥T|RP╕E%P v⌠ v≥Üααâ─ v⌠ v≥ v≡WΦâ─ v≡WÜ"αâ─ï≡Äα9&á£$■P░PÜ╢] â─╟FΩ╕pPÜ╒ â─ëF÷ëV°ëv∞ë~εïv≥ v∞╕O%P v⌠VÜααâ─
v⌠VÜ"αâ─P v⌠VÜj!α â─ëF■╕P╣Q╣\%QÜJ] â─╕P v⌠VÜ"αâ─P v⌠VÜJ] â─╕P v∞ v≡ vεÜJ] â─╟F·â~∞~;ï~■ïv·Ä^≡ï^εèÿï╪ï╟è─*Σ3╪╤π╕QÄ└ï╟èα*└&3çZï°F;v∞|╓ë~■ïv≥Ü°] v■╕_%P v⌠VÜααâ─
╕P v⌠VÜ"αâ─P v⌠VÜJ] â─ïFΩ FΩ=vΘτ╕╨PÜ╒ â─ëFⁿëV■ v° v÷Ü`╒ â─└tΘ 2└P░PÜ╢] â─Ä
:&àÜuΘ v■ vⁿÜ`╒ â─└tΘº■Ü|] ÷─uܵα └tΘ▒Ü─α δ¥3└PÜ(α â─ï°-*uï╕i%P v⌠VÜ╝
αâ─ v⌠VΦ2â─└uΘi 6`# 6^# v⌠VÜ╠Fαâ─└uΘN 6p# 6n# v⌠ v≥Ü╠Fαâ─└tΘ■╕Θ╩ï~εÄΓ9&─X& ╖Ω& ╖Φ╕e%PïF≡PWï≡Üααâ─ï╞ï≈ëF■ëvⁿΘàÉ2└P░PÜ╢] â─ÄΓ9&─X&ïçá&ïùóï°ëV■δ\2└P░PÜ╢] â─Ä
:&àÜuÄΓ9&─X&ïçÇ&ïùéδ╦ÄΓ9&─X& ╖Ω& ╖Φ╕k%PïF⌠PVï°Üααâ─ï╟ï■ëF■ v■WÜ┌α â─3└^_ïσ]├Uï∞ü∞WV╟Få╟åP ╞å{ ╟å8 o%î₧: ╟å< w%î₧> ╟å@ ~%î₧B ╟åD à%î₧F ╟åH ï%î₧J +└ëåN ëåL ÄΣ9&í╕
&ï║
ëåv ëûx Ç─ï≡ëû~ Ç─ï°ëûp Ç─ëår ëût ╗8ÄΩ9ë₧■îå
■+└&ëG&ëë╛n Ä┌9&9ptHÄ▄9&9vt=╕PPÄ▐9& 6û& 6öÜ`┘â─╕æ%PÄ▐9& 6û& 6öÜZ┘â─ÜT┘δ╕╡%PÜ|α â─╗TÄ:ë₧■îå■&╟╕╨PÜ╒ â─ëF∞ëVε╕pPÜ╒ â─ëF≡ëV≥+└ëF÷ëF⌠èå{ ■å{ <vΘvâ~uZ 6`# 6^#╕└%P ╢~ VÜααâ─╕P ╢~ VÜ"αâ─P ╢~ VÜJ]
the next cell in memory contains the CDR pointer as described above. If
the CDR code is CDR-NEXT, the next cell in memory contains the next CAR
cell; in other words, the CDR pointer is implicitly thisaddress+1, where
thisaddress is the memory address of the CAR cell. If the CDR code is
CDR-NIL, then this cell is the last element of the list; the CDR pointer is
implicitly a reference to the object NIL. When a list is constructed
incrementally using CONS, a chain of ordinary pairs is created; however,
when a list is constructed in one step using LIST or MAKE-LIST, a block of
memory can be allocated for all the CAR cells, and their CDR codes all set
to CDR-NEXT (except the last, which is CDR-NIL), and the list will only
take half as much storage (because all the CDR pointers are implicit).
If this were all there were to it, it would not be difficult to implement
in software on ordinary processors; it would add a small amount of overhead
to the CDR function, but the reduction in paging might make up for it. The
problem arises when a program uses RPLACD on a CONS cell that has a CDR
code of CDR-NEXT or CDR-NIL. Normally RPLACD simply stores into the CDR
cell of a CONS, but in this case there is no CDR cell -- its contents are
implicitly specified by the CDR code, and the word that would normally
contain the CDR pointer contains the next CONS cell (in the CDR-NEXT case)
to which other data structures may have pointers, or the first word of some
other object (in the CDR-NIL case). When CDR-coding is used, the
implementation must also provide automatic "forwarding pointers"; an
ordinary CONS cell is allocated, the CAR of the original cell is copied
into its CAR, the value being RPLACD'ed is stored into its CDR, and the old
CAR cell is replaced with a forwarding pointer to the new CONS cell.
Whenever CAR or CDR is performed on a CONS, it must check whether the
location contains a forwarding pointer. This overhead on both CAR and CDR,
coupled with the overhead on CDR to check for CDR codes, is generally
enough that using CDR codes on conventional hardware is infeasible.
There is some evidence that CDR-coding doesn't really save very much
memory, because most lists aren't constructed at once, or RPLACD is done on
them enough that they don't stay contiguous. At best this technique can
save 50% of the space occupied by CONS cells. However, the savings probably
depends to some extent upon the amount of support the implementation
provides for creating CDR-coded lists. For instance, many system functions
on Symbolics Lisp Machines that operate on lists have a :LOCALIZE option;
when :LOCALIZE T is specified, the list is first modified and then copied
to a new, CDR-coded block, with all the old cells replaced with forwarding
pointers. The next time the garbage collector runs, all the forwarding
pointers will be spliced out. Thus, at a cost of a temporary increase in
memory usage, overall memory usage is generally reduced because more lists
may be CDR-coded. There may also be some benefit in improved paging
performance due to increased locality as well (putting a list into
CDR-coded form makes all the "cells" contiguous). Nevertheless, modern
Lisps tend to use lists much less frequently, with a much heavier
reliance upon code, strings, and vectors (structures).
----------------------------------------------------------------
Subject: [2-10] What is garbage collection?
Garbage Collection (GC) refers to the automatic storage allocation
mechanisms present in many Lisps. There are several kinds of storage
allocation algorithms, but most fall within two main classes:
1. Stop and Copy. Systems which copy active objects from "old"
storage to "new" storage and then recycle the old storage.
2. Mark and Sweep. Systems which link together storage
used by discarded objects.
Generational scavenging garbage collection (aka emphemeral GC) is a
variation in which memory is allocated in layers, with tenured
(long-lived) objects in the older layers. Rather than doing a full GC
of all of memory every time more room is needed, only the last few
layers are GCed during an ephemeral GC, taking much less time.
Short-lived objects are quickly recycled, and full GCs are then much
less frequent. It is most often used to improve the performance of
stop and copy garbage collectors. It is possible to implement
ephemeral GC in mark and sweep systems, just much more difficult.
Stop and copy garbage collection provides simpler storage allocation,
avoids fragmentation of memory (intermixing of free storage with used
storage). Copying, however, consumes more of the address space, since up to
half the space must be kept available for copying all the active objects.
This makes stop and copy GC impractical for systems with a small address
space or without virtual memory. Also, copying an object requires that you
track down all the pointers to an object and update them to reflect the new
address, while in a non-copying system you need only keep one pointer to andiocre programmer (or even a good programmer, who isn't being careful) to
generate a large amount of inefficient Lisp code. A good example is the use
of APPEND to link successive lists together, instead of keeping a pointer
to the tail of the list. Often a programmer can obtain significant
speed increases by using a time/space profiler to identify the
functions which waste time (often small functions which are called
frequently) and rewriting those functions.
----------------------------------------------------------------
Subject: [2-5] Why does Common Lisp have "#'"?
#' is a macro-character which expands #'FOO to (FUNCTION FOO). Symbols in
Lisp have two bindings, one for values and one for functions, allowing them
to represent both variables and functions, depending on context. #'FOO
accesses FOO's lexical function binding in a context where the value
interpretation would normally occur. #' is also used to create lexical
closures for lambda expressions. A lexical closure is a function which when
invoked executes the body of the lambda-expression in the lexical
environment within which the closure was created. See pp. 115-117 of CLtL2
for more details.
----------------------------------------------------------------
Subject: [2-6] How do I call non-Lisp functions from Lisp?
Most Lisp implementations for systems where Lisp is not the most common
language provide a "foreign function" interface. As of now there has been
no significant standardization effort in this area. They tend to be
similar, but there are enough differences that it would be inappropriate to
try to describe them all here. In general, one uses an
implementation-dependent macro that defines a Lisp function, but instead of
supplying a body for the function, one supplies the name of a function written
in another language; the argument list portion of the definition is
generally augmented with the data types the foreign function expects and
the data type of the foreign function's return value, and the Lisp
interface function arranges to do any necessary conversions. There is also
generally a function to "load" an object file or library compiled in a
foreign language, which dynamically links the functions in the file being
loaded into the address space of the Lisp process, and connects the
interface functions to the corresponding foreign functions.
If you need to do this, see the manual for your language implementation for
full details. In particular, be on the lookout for restrictions on the
data types that may be passed. You may also need to know details about the
linkage conventions that are used on your system; for instance, many C
implementations prepend an underscore onto the names of C functions when
generating the assembler output (this allows them to use names without
initial underscores internally as labels without worrying about conflicts),
and the foreign function interface may require you to specify this form
explicitly.
Franz Allegro Common Lisp's "Foreign Function Call Facility" is
described in chapter 10 of the documentation. Calling Lisp Functions
from C is treated in section 10.8.2. The foreign function interface in
Macintosh Common Lisp is similar. The foreign function interface for
KCL is described in chapter 10 of the KCL Report. The foreign function
interfaces for Lucid on the Vax and Lucid on the Sun4 are
incompatible. Lucid's interface is described in chapter 5 of the
Advanced User's Guide.
----------------------------------------------------------------
Subject: [2-7] Can I call Lisp functions from other languages?
In implementations that provide a foreign function interface as described
above, there is also usually a "callback" mechanism. The programmer may
associate a foreign language function name with a Lisp function. When a
foreign object file or library is loaded into the Lisp address space, it is
linked with these callback functions. As with foreign functions, the
programmer must supply the argument and result data types so that Lisp may
perform conversions at the interface. Note that in such foreign function
interfaces Lisp is often left "in control" of things like memory
allocation, I/O channels, and startup code (this is a major nuisance
for lots of people).
----------------------------------------------------------------
Subject: [2-8] I want to call a function in a package that might not exist at
compile time. How do I do this?
Use (funcall (find-symbol "SYMBOL-NAME" :pkg-name) ...).
----------------------------------------------------------------
Subject: [2-9] What is CDR-coding?
CDR-coding is a space-saving way to store lists in memory. It is normally
only used in Lisp implementations that run on processors that are
specialized for Lisp, as it is difficult to implement efficiently
in software. In normal list structure, each element of the
list is represented as a CONS cell, which is basically two pointers (the
CAR and CDR); the CAR points to the element of the list, while the CDR
points to the next CONS cell in the list or NIL. CDR-coding takes
advantage of the fact that most CDR cells point to another CONS, and
further that the entire list is often allocated at once (e.g. by a call to
LIST). Instead of using two pointers to implement each CONS cell, the CAR
cell contains a pointer and a two-bit "CDR code". The CDR code may contain
one of three values: CDR-NORMAL, CDR-NEXT, and CDR-NIL. If the code is
CDR-NORMAL, this cell is the first half of an ordinary CONS cell pair, and Interlisp (originally BBNLisp) and MacLisp.
early 70s Development of special-purpose computers known as Lisp
Machines, designed specificly to run Lisp programs.
Xerox D-series Lisp Machines run Interlisp-D.
Early MIT Lisp Machines run Lisp Machine Lisp
(an extension of MacLisp).
1969 Anthony Hearn and Martin Griss define Standard Lisp to
port REDUCE, a symbolic algebra system, to a variety
of architectures.
late 70s Macsyma group at MIT developed NIL (New Implementation
of Lisp), a Lisp for the VAX.
Stanford and Lawrence Livermore National Laboratory
develop S-1 Lisp for the Mark IIA supercomputer.
Franz Lisp (dialect of MacLisp) runs on stock-hardware
Unix machines.
Gerald J. Sussman and Guy L. Steele developed Scheme,
a simple dialect of Lisp with lexical scoping and
lexical closures, continuations as first-class objects,
and a simplified syntax (i.e., only one binding per symbol).
Advent of object-oriented programming concepts in Lisp.
Flavors was developed at MIT for the Lisp machine,
and LOOPS (Lisp Object Oriented Programming System) was
developed at Xerox.
early 80s Development of SPICE-Lisp at CMU, a dialect of MacLisp
designed to run on the Scientific Personal Integrated
Computing Environment (SPICE) workstation.
1980 First biannual ACM Lisp and Functional Programming Conf.
1981 PSL (Portable Standard Lisp) runs on a variety of platforms.
1981+ Lisp Machines from Xerox, LMI (Lisp Machines Inc)
and Symbolics available commercially.
April 1981 Grass roots definition of Common Lisp as a description
of the common aspects of the family of languages (Lisp
Machine Lisp, MacLisp, NIL, S-1 Lisp, Spice Lisp, Scheme).
1984 Publication of CLtL1. Common Lisp becomes a de facto
standard.
1986 X3J13 forms to produce a draft for an ANSI Common Lisp
standard.
1987 Lisp Pointers commences publication.
1990 Steele publishes CLtL2 which offers a snapshot of
work in progress by X3J13. (Unlike CLtL1, CLtL2
was NOT an output of the standards process and was
not intended to become a de facto standard. Read
the Second Edition Preface for further explanation
of this important issue.) Includes CLOS,
conditions, pretty printing and iteration facilities.
1992 X3J13 creates a draft proposed American National
Standard for Common Lisp. This document is the
first official successor to CLtL1.
[Note: This summary is based primarily upon the History section of the
draft ANSI specification. More detail and references can be obtained from
that document. See [4-12] for information on obtaining a copy.]
Gabriel and Steele's "The Evolution of Lisp", which appeared in the
1993 ACM History of Programming Languages conference, is available by
anonymous ftp from
ftp.cs.umbc.edu:/pub/Memoization/Misc/ [130.85.100.53]
as Evolution-of-Lisp.ps.Z.
----------------------------------------------------------------
Subject: [2-14] How do I find the argument list of a function?
How do I get the function name from a function object?
There is no standard way to find the argument list of a function,
since implementations are not required to save this information.
However, many implementations do remember argument information, and
usually have a function that returns the lambda list. Here are the
commands from some Lisp implementations:
Lucid: arglist
Allegro: excl::arglist
Symbolics: arglist
LispWorks: lw:function-lambda-list
CMU Common Lisp, new compiler:
#+(and :CMU :new-compiler)
(defun arglist (name)
(let* ((function (symbol-function name))
(stype (system:%primitive get-vector-subtype function)))
(when (eql stype system:%function-entry-subtype)
(cadr (system:%primitive header-ref function
system:%function-entry-type-slot)))))
The draft ANSI standard does include FUNCTION-LAMBDA-EXPRESSION and
FUNCTION-KEYWORDS, which can be used to create an ARGLIST function.
If you're interested in the number of required arguments you could use
(defun required-arguments (name)
(or (position-if #'(lambda (x) (member x lambda-list-keywords))
(arglist name))
(length (arglist name))))
To extract the function name from the function object, as in
(function-name #'car) ==> 'car
use the following vendor-dependent functions:
Symbolics: (si::compiled-function-name <fn>)
(unless (si:lexical-closure-p <fn>) ...)
Lucid: (sys::procedure-ref <fn> SYS:PROCEDURE-SYMBOL)
(when (sys:procedurep <fn>) ..)
Allegro: (xref::object-to-function-name <fn>)
CMU CL: (kernel:%function-header-name <fn>)
AKCL: (system::compiled-function-name <fn>)
MCL: (ccl::function-name <fn>)
Harlequin: (system::function-name <fn>)
If a vendor-dependent function does not exist, the following
(inefficient) code maps over all symbols looking for one whose
function-cell matches the function object.
(defun function-name (fobject)
(do-all-symbols (fsymbol)
(when (and (fboundp fsymbol)
(eq (symbol-function fsymbol) fobject))
(return fsymbol))))
If a vendor supports FUNCTION-LAMBDA-EXPRESSION, the third value is
the name of the function, if available.
----------------------------------------------------------------
Subject: [2-15] How can I have two Lisp processes communicate via unix sockets?
CLX uses Unix sockets to communicate with the X window server. Look at
the following files from the CLX distribution for a good example of
using Unix sockets from Lisp:
defsystem.lisp Lucid, AKCL, IBCL, CMU.
socket.c, sockcl.lisp AKCL, IBCL
excldep.lisp Franz Allegro CL
You will need the "socket.o" files which come with Lucid and Allegro.
To obtain CLX, see the entry for CLX in the answer to question [7-1].
See the file sockets.tar.gz in the Lisp Utilities repository
described in the answer to question [6-1].
----------------------------------------------------------------
Subject: [2-16] How can I create a stream that acts like UNIX's /dev/null
(i.e., gobbles any output and immediately signals EOF on
input operations)?
(defparameter *dev-null*
#-lispm
(make-two-way-stream (make-concatenated-stream) (make-broadcast-stream))
;; Since Lisp Machines have a built-in /dev/null which handles
;; additional, non-standard operations, we'll use that instead.
#+lispm #'system:null-stream)
----------------------------------------------------------------
Subject: [2-17] Read-time conditionalization of code (#+ #- and *features*)
The #+ and #- syntax provides for the read-time conditionalization of
lisp code, depending on the presence or absence of keywords on the
*features* list. The nascent Common Lisp standard does not specify
what keywords an implementation must have on its features list.
Nevertheless, most implementations have features that allow one to
distinguish the implementation from other implementations. This allows
one to write implementation-dependent code that is run only in the
relevant implementations.
Here is a list of the features to use to specify a particular Common
Lisp implementation. Unfortunately, not every vendor has a
unique keyword that distinguishes their family of implementations from
those of other vendors, nor major and minor versions of the implementation.
:lucid Lucid Common Lisp
:lcl3.0 Lucid Common Lisp v3.0 and above
:lcl4.0 Lucid Common Lisp v4.0 and above
----------------
(and :allegro :franz-inc) Franz Allegro Common Lisp
:excl Franz Allegro Common Lisp
:aclpc Franz Allegro Common Lisp\PC.
:allegro-v3.0 Franz Allegro Common Lisp v3.0
:allegro-v3.1 Franz Allegro Common Lisp v3.1
:allegro-v4.0 Franz Allegro Common Lisp v4.0
:allegro-v4.1 Franz Allegro Common Lisp v4.1
----------------
:cmu CMU Common Lisp
(and :cmu :new-compiler) CMU Common Lisp w/Python compiler
(and :cmu :python) CMU Common Lisp w/Python compiler
:cmu17 CMU Common Lisp v17 and above
----------------
kcl Kyoto Common Lisp
akcl Austin KCL
:ibcl Ibuki Common Lisp
----------------
:mcl Macintosh Common Lisp
:coral Coral Lisp; bought by Apple to become
MACL, then MCL
:ccl Coral Common Lisp
[Note: Harlequin LispWorks also uses :ccl]
:ccl-1 Coral Common Lisp v1
:ccl-1.3 Coral Common Lisp v1.3 and higher
:ccl-2 present in Macintosh Common Lisp 2.0 and higher
----------------
:harlequin-common-lisp Harlequin Common Lisp
:harlequin-unix-lisp Harlequin on Unix platforms
:harlequin-PC-lisp Harlequin on PC platforms
:lispworks Harlequin Lispworks development environment
:lispworks3 major release of Harlequin Lispworks
:lispworks3.1 major and minor release of Harlequin Lispworks
:harlequin All Harlequin products. not always present?
----------------
:clisp CLISP Common Lisp
----------------
:symbolics Symbolics Genera
:imach Symbolics Genera for Ivory architecture
:cloe-runtime Symbolics CLOE
:cloe CLOE 3.1
----------------
:procyon Procyon Common Lisp
(and :procyon :macintosh) Procyon Common Lisp, Macintosh version
(and :procyon :os2) Procyon Common Lisp, OS2 version
----------------
:gclisp Golden Common Lisp
----------------
(and dec vax common) DEC VAXlisp
----------------
:explorer TI Explorer Lisp Machine | used
:TI TI Explorer Lisp Machine | interchangeably
:elroy TI Explorer release 3 and successors
----------------
:Xerox Medley (Venue's CL/InterLisp combo) to rel2.01
:medley Medley releases 3.0 and up
Use (IL:UNIX-GETPARM "mach") and (IL:UNIX-GETPARM "arch") to
distinguish platforms under Medley.
----------------
:ecl ECoLisp
----------------
:lispm Symbolics, TI, and LMI Lisp machines
In the cases where a feature is not a keyword, it is almost always
in the LISP package.
The draft ANSI standard defines some other useful features:
:cltl1 Compatible with the 1st edition of Steele
:cltl2 Compatible with the 2nd edition of Steele
:IEEE-Floating-Point IEEE floating point support
:X3J13 conforms to some particular draft of the ANSI
CL specification
:draft-ANSI-CL conforms to first full public review draft
:ANSI-CL conforms to ANSI CL after its adoption
:common-lisp language family "Common Lisp"
Other features used by some Lisps include:
:clos Contains a native CLOS implementation.
:pcl Contains the PCL implementation of CLOS.
:flavors Has an implementation of Symbolics Flavors
:loop Contains the :cltl1 version of the Loop macro
:ansi-loop Contains the ANSI Loop macro
:clx or :xlib Contains CLX
:clxr4 or :CLX-MIT-R4 Contains CLX for X11R4
:clxr5 or :CLX-MIT-R5 Contains CLX for X11R5
:compiler Contains a compiler
:windows MS Windows version
:color Color display
:monochrome Monochrome display
:multiprocessing Has multiprocessing capabilities.
:profiler Has a PC-monitoring based profiler.
Platform-specific features, CPU-dependent features, and
operating-system specific features are also important because they can
indicate changes between different implementations of the same lisp,
such as compiled file extensions (e.g., .sbin, .hbin, etc.).
Unfortunately, not every vendor includes such features, and the naming
conventions are inconsistent. Where there are several names for the
same feature, we've put the preferred name first. Hopefully the
vendors will begin to standardize their use of these features.
CPU-dependent features include :sparc (used in CMU CL, Lucid CL,
Harlequin, and Allegro CL), :mips (used in Allegro CL), :r2000 (used
in Allegro CL even on r4000 machines), :mc68000, and :pa (HP's
9000/800 RISC cpu). Platform-specific features include :sun (used in
Allegro CL and Lucid), :sun4 (used in CMU CL and Allegro CL), :sgi
(used in Allegro CL), :hp300, :hp400, :hp500, :sun3, :vax, :prime,
:dec, :dec3100, :macintosh (used in Procyon but not MCL), :ibm-pc,
:ibm-rt-pc. OS-specific features include :unix (used in CMU CL, IBCL,
and Lucid CL), :vms, :sunos (used in CMU CL), :sun-os (used in Lucid),
:sunos4.0 and :sunos4 (used in various Allegro versions independent of
the actual version of SunOS), :mach (used in CMU CL), :hpux, :ultrix,
:os2, and :svr4.
Notes:
:allegro alone doesn't suffice to distinguish Franz Allegro Common
Lisp from Macintosh Allegro Common Lisp (an early version of
Macintosh Common Lisp). :excl specifies that the EXCL package (a
set of Allegro extensions to Common Lisp) is present, but this has
since become synonymous with Franz Allegro Common Lisp.
Thanks to Vincent Keunen for gathering the information in this list.
----------------------------------------------------------------
Subject: [2-18] What reader macro characters are used in major Lisp systems?
The draft ANSI standard for Common Lisp leaves many dispatching macro
characters unassigned. Of these, the following are explicitly reserved
for the user and hence will never be defined by Common Lisp:
#!, #?, #[, #], #{, and #}.
All other unassigned macro characters are not reserved for the user,
and hence the user has no guarantee that they won't be used by some
Lisp implementation.
As a result, there is the potential of portability clashes between
systems that use the same macro characters. This question lists the
non-standard macro character usage of major Lisp systems, in an effort
to avoid such conflicts.
#" AKCL; pathnames
#$ Macintosh Common Lisp; traps
#% Cyc; references to constants in the representation language
#% Harlequin Lispworks; ?
#@ Macintosh Common Lisp; Points notation
#@ Defsystem
#I Portable Infix Package
#L Allegro Common Lisp; logical pathnames
#M Series
#T Allegro Common Lisp; ?
#Y CLISP; ?
#Z Series
#_ Macintosh Common Lisp; traps
#` Harlequin Lispworks; ?
There is a proposal in the ANSI draft to have COMPILE-FILE and LOAD
bind *READTABLE*, which would allow one to locally redefine syntax
through private readtables. Unfortunately, this doesn't help with the
Infix Package, where one wants to globally extend syntax.
----------------------------------------------------------------
Subject: [2-19] How do I determine if a file is a directory or not?
How do I get the current directory name from within a Lisp
program? Is there any way to create a directory?
There is no portable way in Common Lisp of determining whether a file
is a directory or not. Calling DIRECTORY on the pathname will not
always work, since the directory could be empty. For UNIX systems
(defun DIRECTORY-P (pathname)
(probe-file (concatenate 'string pathname "/.")))
seems to work fairly reliably. (If "foo" is a directory, then "foo/."
will be a valid filename; if not, it will return NIL.) This won't, of
course, work on the Macintosh, or on other operating systems (e.g.,
MVS, CMS, ITS).
Moreover, some operating systems may not support the concept of
directories, or even of a file system. For example, recent work on
object-oriented technology considers files to be collections of
objects. Each type of collection defines a set of methods for reading
and writing the objects "stored" in the collection.
There's no standard function for finding the current directory from
within a Lisp program, since not all Lisp environments have the
concept of a current directory. Here are the commands from some Lisp
implementations:
Lucid: WORKING-DIRECTORY (which is also SETFable)
PWD and CD also work
Allegro: CURRENT-DIRECTORY (use excl:chdir to change it)
CMU CL: DEFAULT-DIRECTORY
LispWorks: LW:*CURRENT-WORKING-DIRECTORY*
(use LW:CHANGE-DIRECTORY to change it)
Allegro also uses the variable *default-pathname-defaults* to resolve
relative pathnames, maintaining it as the current working directory.
So evaluating (truename "./") in Allegro (and on certain other
systems) will return a pathname for the current directory. Likewise,
in some VMS systems evaluating (truename "[]") will return a pathname
for the current directory.
There is no portable way of creating a new directory from within a
Lisp program.
----------------------------------------------------------------
Subject: [2-20] What is a "Lisp Machine" (LISPM)?
A Lisp machine (or LISPM) is a computer which has been optimized to run lisp
efficiently and provide a good environment for programming in it. The
original Lisp machines were implemented at MIT, with spinoffs as LMI (defunct)
and Symbolics (bankrupt). Xerox also had a series of Lisp machines
(Dandylion, Dandytiger), as did Texas Instruments (TI Explorer). The
TI and Symbolics Lisp machines are currently available as cards that
fit into Macintosh computers (the so-called "Lisp on a chip").
Optimizations typical of Lisp machines include:
- Hardware Type Checking. Special type bits let the type be checked
efficiently at run-time.
- Hardware Garbage Collection.
- Fast Function Calls.
- Efficient Representation of Lists.
- System Software and Integrated Programming Environments.
For further information, see:
Paul Graham, "Anatomy of a Lisp Machine", AI Expert, December 1988.
Pleszkun and Thazhuthaveetil, "The Architecture of Lisp Machines",
IEEE Computer, March 1987.
Ditzel, Schuler and Thomas, "A Lisp Machine Profile: Symbolics 3650",
AI Expert, January 1987.
Peter M. Kogge, "The Architecture of Symbolic Computers",
McGraw-Hill 1991. ISBN 0-07-035596-7.
[Derived from a post by Arthur Pendragon <apendragon@delphi.com>.]
----------------------------------------------------------------
;;; *EOF*