source: project/chicken/branches/prerelease/manual/faq @ 9424

Last change on this file since 9424 was 9424, checked in by Ivan Raikov, 12 years ago

Merged with trunk

File size: 27.1 KB
Line 
1[[toc:]]
2[[tags:faq]]
3
4== FAQ
5
6This is the list of Frequently Asked Questions about Chicken Scheme.
7If you have a question not answered here, feel free to post to the chicken-users mailing list;
8if you consider your question general enough, feel free to add it to this list.
9
10=== General
11
12==== Why yet another Scheme implementation?
13
14Since Scheme is a relatively simple language, a large number of implementations exist and
15each has its specific advantages and disadvantages. Some are fast, some provide a rich
16programming environment. Some are free, others are tailored to specific domains, and so on. The reasons
17for the existence of CHICKEN are:
18
19* CHICKEN is portable because it generates C code that runs on a large number of platforms.
20
21* CHICKEN is extendable, since its code generation scheme and runtime system/garbage collector fits neatly into a C environment.
22
23* CHICKEN is free and can be freely distributed, including its source code.
24
25* CHICKEN offers better performance than nearly all interpreter based implementations, but still provides full Scheme semantics.
26
27* As far as we know, CHICKEN is the first implementation of Scheme that uses Henry Baker's [[http://home.pipeline.com/~hbaker1/CheneyMTA.html|Cheney on the M.T.A]] concept.
28
29==== Why call it 'Chicken'?
30
31According to [[http://chicken.wiki.br/felix winkelmann|felix]]:
32
33> Well, it's pretty boring, really: when I started the project and needed some
34> name, the first thing that met my eyes was the "chicken" (actually a disguised penguin)
35> from the Wallace + Gromit movie...
36> And then there is of course the ever occurring chicken-and-egg problem
37> with bootstrapped compilers.
38
39==== What should I do if I find a bug?
40
41Send e-mail to felix@call-with-current-continuation.org
42with some hints about the problem, like
43version/build of the compiler, platform, system configuration, code that
44causes the bug, etc.
45
46==== Why are values defined with {{define-foreign-variable}} or {{define-constant}} or {{define-inline}} not seen outside of the containing source file?
47
48Accesses to foreign variables are translated directly into C constructs that access the variable,
49so the Scheme name given to that variable does only exist during compile-time.
50The same goes for constant- and inline-definitions: The name is only there to tell the compiler
51that this reference is to be replaced with the actual value.
52
53==== How does {{cond-expand}} know which features are registered in used units?
54
55Each unit used via {{(declare (uses ...))}} is registered as a feature and
56so a symbol with the unit-name can be tested by {{cond-expand}} during macro-expansion-time.
57Features registered using the {{register-feature!}} procedure are only
58available during run-time of the compiled file. You can use the {{eval-when}} form
59to register features at compile time.
60
61==== Why are constants defined by {{define-constant}} not honoured in {{case}} constructs?
62
63{{case}} expands into a cascaded {{if}} expression, where the first item in each arm
64is treated as a quoted list. So the {{case}} macro can not infer wether
65a symbol is to be treated as a constant-name (defined via {{define-constant}}) or
66a literal symbol.
67
68
69==== How can I enable case sensitive reading/writing in user code?
70
71To enable the {{read}} procedure to read symbols and identifiers case sensitive, you can set the
72parameter {{case-sensitivity}} to {{#t}}.
73
74
75==== How can I change {{match-error-control}} during compilation?
76
77Use {{eval-when}}, like this:
78
79<enscript highlight=scheme>
80(eval-when (compile)
81(match-error-control #:unspecified) )
82</enscript>
83
84
85==== Why doesn't CHICKEN support the full numeric tower by default?
86
87The short answer:
88
89<enscript highlight=scheme>
90% chicken-setup numbers
91% csi -q
92#;1> (use numbers)
93</enscript>
94
95The long answer:
96
97There are a number of reasons for this:
98
99- For most applications of Scheme fixnums (exact word-sized integers) and flonums (64-bit floating-point
100numbers) are more than sufficient;
101
102- Interfacing to C is simpler;
103
104- Dispatching of arithmetic operations is more efficient.
105
106There is an extension based on the GNU Multiprecision Package that implements most of the full
107numeric tower, see [[http://chicken.wiki.br/numbers|numbers]].
108
109
110==== How can I specialize a generic function method to match instances of every class?
111
112Specializing a method on {{<object>}} doesn't work on primitive data objects like
113numbers, strings, etc. so for example
114
115<enscript highlight=scheme>
116(define-method (foo (x <my-class>)) ...)
117(define-method (foo (x <object>)) ...)
118(foo 123)
119</enscript>
120
121will signal an error, because to applicable method can be found. To specialize a method for primitive
122objects, use {{<top>}}:
123
124<enscript highlight=scheme>
125(define-method (foo (x <top>)) ...)
126</enscript>
127
128
129==== Does CHICKEN support native threads?
130
131Currently native threads are not supported. The runtime system is not reentrant, and the garbage-collection
132algorithm would be made much more complicated, since the location of every object (whether it is allocated
133on the stack or on the heap or completely outside the GC-able data space) has to be checked - this would
134be rather complex and inefficient in a situation where multiple threads are involved.
135
136
137==== Does CHICKEN support Unicode strings?
138
139Yes, as an extension.
140
141By default all string and character functions operate bytewise, so that characters with an iteger value greater than 255 don't make much sense and multibyte UTF-8 characters are seen and manipulated as separate bytes, analogous to what a C program would see.
142
143You can enable UTF-8 support by placing the following two lines at the beginning of your source file (or in your ~/.csirc for interactive sessions) before any other code, including other use directives:
144
145<enscript highlight=scheme>
146(use iset syntax-case utf8)
147(import utf8)
148</enscript>
149
150This will replace all builtin string operators with UTF-8-aware versions, that will treat strings as sequences of multibyte UTF-8 characters, thus enabling you to represent and manipulate Unicode characters while remaining compatible with most C libraries and system interfaces.
151
152Most eggs should work correctly in utf8 mode, including the regex extension, but you still have the option of working around incompatibilities of specific eggs by loading them before the (import utf8) directive. Keep in mind that some operations, such as string-length, are much more expensive in utf8 (multibyte) mode, and should be used with care. See the [[http://www.call-with-current-continuation.org/eggs/utf8.html|utf8 egg documentation]] for details.
153
154
155==== Why do I get an "Error: invalid syntax: ..." using 'match' and 'syntax-case'?
156
157The built-in 'match' macro is incompatible with 'syntax-case'. Use the  [[http://www.call-with-current-continuation.org/eggs/matchable.html|matchable egg]] instead.
158
159
160=== Platform specific
161
162==== How do I generate a DLL under MS Windows (tm) ?
163
164Use {{csc}} in combination with the {{-dll}} option:
165
166{{C:\> csc foo.scm -dll}}
167
168==== How do I generate a GUI application under Windows(tm)?
169
170Invoke {{csc}} with the {{-windows}} option. Or pass the {{-DC_WINDOWS_GUI}}
171option to the C compiler and link with the GUI version of the runtime system (that's {{libchicken-gui[-static].lib}}.
172The GUI runtime displays error messages in a message box and does some rudimentary command-line
173parsing.
174
175==== Compiling very large files under Windows with the Microsoft C compiler fails with a message indicating insufficient heap space.
176
177It seems that the Microsoft C compiler can only handle files up to a certain size, and it doesn't utilize virtual memory as
178well as the GNU C compiler, for example. Try closing running applications. If that fails, try to break up the Scheme code
179into several library units.
180
181==== When I run {{csi}} inside an emacs buffer under Windows, nothing happens.
182
183Invoke {{csi}} with the {{-:c}} runtime option. Under Windows the interpreter thinks it
184is not running under control of a terminal and doesn't print the prompt and does not flush the output stream properly.
185
186==== I load compiled code dynamically in a Windows GUI application and it crashes.
187
188Code compiled into a DLL to be loaded dynamically must be linked with the same runtime system as the loading
189application. That means that all dynamically loaded entities (including extensions built and installed with
190{{chicken-setup}}) must be compiled with the {{-windows}} {{csc}} option.
191
192==== On Windows, {{csc.exe}} seems to be doing something wrong.
193
194The Windows development tools include a C# compiler with the same name. Either invoke {{csc.exe}} with a full
195pathname, or put the directory where you installed CHICKEN in front of the MS development tool path in the {{PATH}}
196environment variable.
197
198==== On Windows source and/or output filenames with embedded whitespace are not found.
199
200There is no current workaround. Do not use filenames with embedded whitespace for code. However, command
201names with embedded whitespace will work correctly.
202=== Customization
203
204
205==== How do I run custom startup code before the runtime-system is invoked?
206
207When you invoke the C compiler for your translated Scheme source program, add the C compiler option
208{{-DC_EMBEDDED}}, or pass {{-embedded}} to the {{csc}}
209driver program, so no entry-point function will be generated ({{main()}}).
210When your are finished with your startup processing, invoke:
211
212<enscript highlight=c>
213CHICKEN_main(argc, argv, C_toplevel);
214</enscript>
215
216where {{C_toplevel}} is the entry-point into the compiled Scheme code. You
217should add the following  declarations at the head of your code:
218
219<enscript highlight=c>
220#include "chicken.h"
221extern void C_toplevel(C_word,C_word,C_word) C_noret;
222</enscript>
223
224==== How can I add compiled user passes?
225
226To add a compiled user pass instead of an interpreted one, create a library unit and recompile
227the main unit of the compiler (in the file {{chicken.scm}}) with an additional {{uses}}
228declaration. Then link all compiler modules and your (compiled) extension to create a new version of
229the compiler, like this (assuming all sources are in the
230current directory):
231
232<enscript highlight=scheme>
233% cat userpass.scm
234;;;; userpass.scm - My very own compiler pass
235
236(declare (unit userpass))
237
238;; Perhaps more user passes/extensions are added:
239(let ([old (user-pass)])
240(user-pass
241(lambda (x)
242(let ([x2 (do-something-with x)])
243          (if old
244              (old x2)
245              x2) ) ) ) )
246</enscript>
247
248 % csc -c -x userpass.scm
249 % csc chicken.scm -c -o chicken-extended.o -uses userpass
250 % gcc chicken-extended.o support.o easyffi.o compiler.o optimizer.o batch-driver.o c-platform.o \
251 c-backend.o userpass.o `csc -ldflags -libs` -o chicken-extended
252
253On platforms that support it (Linux ELF, Solaris, Windows + VC++), compiled code can be loaded via {{-extend}}
254just like source files (see {{load}} in the User's Manual).
255
256
257=== Compiled macros
258
259==== Why is {{define-macro}} complaining about unbound variables?
260
261Macro bodies that are defined and used in a compiled source-file are
262evaluated during compilation and so have no access to anything created with {{define}}. Use {{define-for-syntax}} instead.
263
264==== Why isn't {{load}} properly loading my library of macros?
265
266During compile-time, macros are only available in the source file in which they are defined. Files included via {{include}} are considered part of the containing file.
267
268==== Why is {{include}} unable to load my hygienic macros?
269
270It is not sufficient for the included file to require the {{syntax-case}} extension. Call {{(require-extension syntax-case)}} ''before'' calling {{include}}.
271
272==== Why are macros not visible outside of the compilation unit in which they are defined?
273
274Macros are defined during compile time, so when a file has been compiled, the definitions are gone. An exception
275to this rule are macros defined with {{define-macro}}, which are also visible at run-time, i.e.
276in {{eval}}. To use macros defined in other files, use the {{include}} special
277form.
278
279=== Warnings and errors
280
281==== Why does my program crash when I use callback functions (from Scheme to C and back to Scheme again)?
282
283There are two reasons why code involving callbacks can crash out of no apparent reason:
284
285# It is important to use {{foreign-safe-lambda/foreign-safe-lambda*}} for the C code that is to call back into Scheme. If this is not done than sooner or later the available stack space will be exhausted.
286
287# If the C code uses a large amount of stack storage, or if Scheme-to-C-to-Scheme calls are nested deeply, then the available nursery space on the stack will run low. To avoid this it might be advisable to run the compiled code with a larger nursery setting, i.e. run the code with {{-:s...}} and a larger value than the default (for example {{-:s300k}}), or use the {{-nursery}} compiler option.  Note that this can decrease runtime performance on some platforms.
288
289==== Why does the linker complain about a missing function {{_C_..._toplevel}}?
290
291This message indicates that your program uses a library-unit, but that the
292object-file or library was not supplied to the linker. If you have the unit
293{{foo}}, which is contained in {{foo.o}} than you have to supply it to the
294linker like this (assuming a GCC environment):
295
296{{% csc program.scm foo.o -o program}}
297
298==== Why does the linker complain about a missing function {{_C_toplevel}}?
299
300This means you have compiled a library unit as an application. When a unit-declaration (as in {{(declare (unit ...))}})
301is given, then this file has a specially named toplevel entry procedure. Just remove the declaration,
302or compile this file to an object-module and link it to your application code.
303
304==== Why does my program crash when I compile a file with {{-unsafe}} or unsafe declarations?
305
306The compiler option {{-unsafe}} or the declaration {{(declare (unsafe))}} disable
307certain safety-checks to improve performance, so code that would normally
308trigger an error will work unexpectedly or even crash the running application.
309It is advisable to develop and debug a program in safe mode (without unsafe
310declarations) and use this feature only if the application works properly.
311
312==== Why do I get a warning when I define a global variable named {{match}}?
313
314Even when the {{match}} unit is not used, the macros from that package are visible in the compiler.
315The reason for this is that macros can not be accessed from library units (only when explicitly evaluated in running
316code). To speed up macro-expansion time, the compiler and the interpreter both already provide the compiled
317{{match-...}} macro definitions. Macros shadowed lexically are no problem, but global definitions
318of variables named identically to (global) macros are useless - the macro definition shadows the global
319variable.
320
321This problem can be solved using a different name or undefining the macro, like this:
322
323<enscript highlight=scheme>
324(eval-when (compile eval) (undefine-macro! 'match))
325</enscript>
326==== Why don't toplevel-continuations captured in interpreted code work?
327
328Consider the following piece of code:
329
330<enscript highlight=scheme> 
331(define k (call-with-current-continuation (lambda (k) k)))
332(k k)
333</enscript>
334
335When compiled, this will loop endlessly. But when interpreted, {{(k k)}} will return
336to the read-eval-print loop! This happens because the continuation captured will eventually read the
337next toplevel expression from the standard-input (or an input-file if loading from a file). At the moment
338{{k}} was defined, the next expression was {{(k k)}}. But when {{k}}
339is invoked, the next expression will be whatever follows after {{(k k)}}.
340In other words, invoking a captured continuation will not rewind the file-position of the input source.
341A solution is to wrap the whole code into a {{(begin ...)}} expression, so all toplevel
342expressions will be loaded together.
343
344==== Why does {{define-reader-ctor}} not work in my compiled program?
345
346The following piece of code does not work as expected:
347
348<enscript highlight=scheme>
349(eval-when (compile)
350(define-reader-ctor 'integer->char integer->char) )
351(print #,(integer->char 33))
352</enscript>
353
354The problem is that the compiler reads the complete source-file before doing any processing on it,
355so the sharp-comma form is encountered before the reader-ctor is defined. A possible solution is to include
356the file containing the sharp-comma form, like this:
357
358<enscript highlight=scheme>
359(eval-when (compile)
360(define-reader-ctor 'integer->char integer->char) )
361
362(include "other-file")
363</enscript>
364
365<enscript highlight=scheme>
366;;; other-file.scm:
367(print #,(integer->char 33))
368</enscript>
369
370==== Why do built-in units, such as srfi-1, srfi-18, and posix fail to load?
371
372When you try to {{use}} a built-in unit such as {{srfi-18}}, you may get the following error:
373
374<enscript highlight=scheme>
375#;1> (use srfi-18)
376; loading library srfi-18 ...
377Error: (load-library) unable to load library
378srfi-18
379"dlopen(libchicken.dylib, 9): image not found"                ;; on a Mac
380"libchicken.so: cannot open shared object file: No such file or directory"  ;; Linux
381</enscript>
382
383Another symptom is that {{(require 'srfi-18)}} will silently fail.
384
385This typically happens because the Chicken libraries have been installed in a non-standard location, such as your home directory.  The workaround is to explicitly tell the dynamic linker where to look for your libraries:
386
387 export DYLD_LIBRARY_PATH=~/scheme/chicken/lib:$DYLD_LIBRARY_PATH ;; Mac
388 export LD_LIBRARY_PATH=~/scheme/chicken/lib:$LD_LIBRARY_PATH    ;; Linux
389
390==== How can I increase the size of the trace shown when runtime errors are detected?
391
392When a runtime error is detected, Chicken will print the last entries from the trace of functions called
393(unless your executable was compiled with the {{-no-trace}} option.
394By default, only 16 entries will be shown.
395To increase this number pass the {{-:aN}} parameter to your executable.
396
397=== Optimizations
398
399==== How can I obtain smaller executables?
400
401If you don't need {{eval}} or the stuff in the {{extras}} library unit,
402you can just use the {{library}} unit:
403
404<enscript highlight=scheme>
405        (declare (uses library))
406        (display "Hello, world!\n")
407</enscript>
408
409(Don't forget to compile with the {{-explicit-use}} option)
410Compiled with Visual C++ this generates an executable of around 240 kilobytes.
411It is theoretically possible to compile something without the library, but
412a program would have to implement quite a lot of support code on its own.
413
414==== How can I obtain faster executables?
415
416There are a number of declaration specifiers that should be used to speed up
417compiled files: declaring {{(standard-bindings)}} is mandatory, since this enables
418most optimizations. Even if some standard procedures should be redefined, you can
419list untouched bindings in the declaration.
420Declaring {{(extended-bindings)}} lets the compiler choose faster versions of certain
421internal library functions. This might give another speedup. You can also use the
422the {{usual-integrations}} declaration, which is identical to declaring
423{{standard-bindings}} and {{extended-bindings}}
424(note that {{usual-integrations}} is set by default).
425Declaring {{(block)}} tells the compiler that global procedures are not changed
426outside the current compilation unit, this gives the compiler some more
427opportunities for optimization.
428If no floating point arithmetic is required, then declaring {{(number-type fixnum)}}
429can give a big performance improvement, because the compiler can now inline
430most arithmetic operations.
431Declaring {{(unsafe)}} will switch off most safety checks.
432If threads are not used, you can declare {{(disable-interrupts)}}.
433You should always use maximum optimizations settings for your C compiler.
434Good GCC compiler options on Pentium (and compatible) hardware are:
435{{-Os -fomit-frame-pointer -fno-strict-aliasing}}
436Some programs are very sensitive to the setting of the nursery (the first heap-generation). You
437should experiment with different nursery settings (either by compiling with the {{-nursery}}
438option or by using the {{-:s...}} runtime option).
439
440==== Which non-standard procedures are treated specially when the {{extended-bindings}} or {{usual-integrations}} declaration or compiler option is used?
441
442The following standard bindings are handled specially, depending on optimization options
443and compiler settings:
444
445 {{+}} {{*}} {{-}} {{/}} {{quotient}} {{eq?}} {{eqv?}} {{equal?}} {{apply}} {{c...r}} {{values}} {{call-with-values}}
446 {{list-ref}} {{null?}} {{length}} {{not}} {{char?}} {{string?}} {{symbol?}} {{vector?}} {{pair?}} {{procedure?}}
447 {{boolean?}} {{number?}} {{complex?}} {{rational?}} {{real?}} {{exact?}} {{inexact?}} {{list?}} {{eof-object?}}
448 {{string-ref}} {{string-set!}} {{vector-ref}} {{vector-set!}} {{char=?}} {{char<?}} {{char>?}} {{char<=?}} {{char>=?}}
449 {{char-numeric?}} {{char-alphabetic?}} {{char-whitespace?}} {{char-upper-case?}}
450 {{char-lower-case?}} {{char-upcae}} {{char-downcase}} {{list-tail}} {{assv}} {{memv}} {{memq}} {{assoc}}
451 {{member}} {{set-car!}} {{set-cdr!}} {{abs}} {{exp}} {{sin}} {{cos}} {{tan}} {{log}} {{asin}} {{acos}} {{atan}} {{sqrt}}
452 {{zero?}} {{positive?}} {{negative?}} {{vector-length}} {{string-length}} {{char->integer}}
453 {{integer->char}} {{inexact->exact}} {{=}} {{>}} {{<}} {{>=}} {{<=}} {{for-each}} {{map}} {{substring}}
454 {{string-append}} {{gcd}} {{lcm}} {{list}} {{exact->inexact}} {{string->number}} {{number->string}}
455 {{even?}} {{odd?}} {{remainder}} {{floor}} {{ceiling}} {{truncate}} {{round}} {{cons}} {{vector}} {{string}}
456 {{string=?}} {{string-ci=?}} {{make-vector}} {{call-with-current-continuation}}
457 {{write-char}} {{read-string}}
458
459The following extended bindings are handled specially:
460
461{{bitwise-and}} {{bitwise-ior}} {{bitwise-xor}} {{bitwise-not}}
462{{bit-set?}} {{add1}} {{sub1}}
463{{fx+}}
464{{fx-}} {{fx*}} {{fx/}} {{fxmod}}
465{{fx=}} {{fx>}} {{fx>=}} {{fixnum?}} {{fxneg}} {{fxmax}} {{fxmin}}
466{{fxand}} {{fxior}} {{fxxor}} {{fxnot}} {{fxshl}} {{fxshr}}
467{{flonum?}} {{fp+}}
468{{fp-}} {{fp*}} {{fp/}} {{atom?}}
469{{fp=}} {{fp>}} {{fp>=}} {{fpneg}} {{fpmax}} {{fpmin}}
470{{arithmetic-shift}} {{signum}} {{flush-output}} {{thread-specific}} {{thread-specific-set!}}
471{{not-pair?}} {{null-list?}} {{print}} {{print*}} {{u8vector->blob/shared}}
472{{s8vector->blob/shared}} {{u16vector->blob/shared}} {{s16vector->blob/shared}}
473{{u32vector->blob/shared}}
474{{s32vector->blob/shared}} {{f32vector->blob/shared}} {{f64vector->blob/shared}} {{block-ref}}
475{{blob-size}}
476{{u8vector-length}}
477{{s8vector-length}}
478{{u16vector-length}}
479{{s16vector-length}}
480{{u32vector-length}}
481{{s32vector-length}}
482{{f32vector-length}}
483{{f64vector-length}}
484{{u8vector-ref}}
485{{s8vector-ref}}
486{{u16vector-ref}}
487{{s16vector-ref}}
488{{u32vector-ref}}
489{{s32vector-ref}}
490{{f32vector-ref}}
491{{f64vector-ref}}
492{{u8vector-set!}}
493{{s8vector-set!}}
494{{u16vector-set!}}
495{{s16vector-set!}}
496{{u32vector-set!}}
497{{s32vector-set!}}
498{{hash-table-ref}}
499{{block-set!}} {{number-of-slots}}
500{{first}} {{second}} {{third}} {{fourth}} {{null-pointer?}} {{pointer->object}}
501{{make-record-instance}}
502{{locative-ref}} {{locative-set!}} {{locative?}} {{locative->object}} {{identity}}
503{{cpu-time}} {{error}} {{call/cc}} {{any?}}
504{{substring=?}} {{substring-ci=?}} {{substring-index}} {{substring-index-ci}}
505
506==== Can I load compiled code at runtime?
507
508Yes.
509You can load compiled at code at runtime with {{load}} just as
510well as you can load Scheme source code.
511Compiled code will, of course, run faster.
512
513To do this, pass to {{load}} a path for a shared object.
514Use a form such as {{(load "foo.so")}} and run
515{{csc -shared foo.scm}} to produce {{foo.so}} from {{foo.scm}} (at
516which point {{foo.scm}} will no longer be required).
517
518=== Garbage collection
519
520==== Why does a loop that doesn't {{cons}} still trigger garbage collections?
521
522Under CHICKENs implementation policy, tail recursion is achieved simply by avoiding
523to return from a function call. Since the programs are CPS converted, a continuous
524sequence of nested procedure calls is performed. At some stage the stack-space has
525to run out and the current procedure and its parameters (including the current
526continuation) are stored somewhere in the runtime system. Now a minor garbage collection
527occurs and rescues all live
528data from the stack (the first heap generation) and moves it into the the second heap
529generation. Then the stack is cleared (using
530a {{longjmp}}) and execution can continue from the saved state.
531With this method arbitrary recursion (in tail- or non-tail position) can happen,
532provided the application doesn't run out of heap-space.
533(The difference between a tail- and a non-tail call is that the tail-call has no
534live data after it invokes its continuation - and so the amount of heap-space needed stays constant)
535
536==== Why do finalizers not seem to work in simple cases in the interpeter?
537
538Consider the following interaction in CSI:
539
540 #;1> (define x '(1 2 3))
541 #;2> (define (yammer x) (print x " is dead"))
542 #;3> (set-finalizer! x yammer)
543 (1 2 3)
544 #;4> (gc #t)
545 157812
546 #;5> (define x #f)
547 #;6> (gc #t)
548 157812
549 #;7>
550
551While you might expect objects to be reclaimed and "''(1 2 3) is dead''" printed, it won't happen:
552the literal list gets held in the interpreter history, because it is the
553result value of the set-finalizer! call.
554Running this in a normal program will work fine.
555
556When testing finalizers from the interpreter, you might want to define a trivial macro such as
557
558 (define-macro (v x) `(begin (print ,x) (void)))
559
560and wrap calls to {{set-finalizer!}} in it.
561
562=== Interpreter
563
564==== Does CSI support history and autocompletion?
565
566CSI doesn't support it natively but it can be activated with the [[http://www.call-with-current-continuation.org/eggs/readline.html]] egg.
567After installing the egg, add the following to your {{~/.csirc}} or equivalent file:
568
569<enscript highlight=scheme>
570(require-extension readline)
571(current-input-port (make-gnu-readline-port))
572(gnu-history-install-file-manager (string-append (or (getenv "HOME") ".") "/.csi.history"))
573</enscript>
574
575Users of *nix-like systems (including Cygwin), may also want to check out [[http://utopia.knoware.nl/~hlub/rlwrap/|rlwrap]].  This program lets you "wrap" another process (e.g. {{rlwrap csi}}) with the readline library, giving you history, autocompletion, and the ability to set the keystroke set. Vi fans can get vi keystrokes by adding "set editing-mode vi" to their {{.inputrc}} file.
576
577==== Does code loaded with {{load}} run compiled or interpreted?
578
579If you compile a file with a call to {{load}}, the code will be loaded at
580runtime and, if the file loaded is a Scheme source code file
581(instead of a shared object), it will be
582interpreted (even if the caller program is compiled).
583
584=== Extensions
585
586==== How can I install Chicken eggs to a non-default location?
587
588You can just set the {{CHICKEN_REPOSITORY}} environment variable.
589It should contain the path where you want eggs to be installed:
590
591 $ export CHICKEN_REPOSITORY=~/chicken/
592 $ chicken-setup extensionname
593
594In order to make programs (including csi) see these eggs, you should set this variable when you run them.
595Alternatively, you can call the {{repository-path}} Scheme procedure before loading the eggs, as in:
596
597<enscript highlight=scheme>
598(repository-path "/home/azul/chicken")
599(use format-modular)
600</enscript>
601
602Note, however, that using {{repository-path}} as above hard-codes the location of your eggs in your source files.  While this might not be an issue in your case, it might be safe to keep this configuration outside of the source code (that is, specifying it as an environment variable) to make it easier to maintain.
603
604==== Can I install chicken eggs as a non-root user?
605
606Yes, just [[FAQ#Extensions#How can I install Chicken eggs to a non-default location?|install them in a directory you can write]].
607
608----
609
610Previous: [[Bugs and limitations]]
611
612Next: [[Acknowledgements]]
Note: See TracBrowser for help on using the repository browser.