source: project/chicken/branches/release/manual/faq @ 7276

Last change on this file since 7276 was 7276, checked in by felix winkelmann, 12 years ago

merged trunk

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