source: project/chicken/trunk/manual/faq @ 13813

Last change on this file since 13813 was 13813, checked in by felix winkelmann, 11 years ago

added test scripts

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