~ chicken-core (master) /README


  1
  2
  3
  4     _/_/_/  _/    _/  _/_/_/    _/_/_/  _/    _/  _/_/_/_/  _/      _/
  5  _/        _/    _/    _/    _/        _/  _/    _/        _/_/    _/
  6 _/        _/_/_/_/    _/    _/        _/_/      _/_/_/    _/  _/  _/
  7_/        _/    _/    _/    _/        _/  _/    _/        _/    _/_/
  8 _/_/_/  _/    _/  _/_/_/    _/_/_/  _/    _/  _/_/_/_/  _/      _/
  9
 10
 11
 12  README file for the CHICKEN Scheme system
 13  =========================================
 14
 15
 16  (c) 2008-2022, The CHICKEN Team
 17  (c) 2000-2007, Felix L. Winkelmann
 18
 19  version 6.0.0
 20
 21
 22 1. Introduction
 23
 24    CHICKEN is a Scheme-to-C compiler supporting the language
 25    features as defined in the 'Revised^5 Report on
 26    Scheme'. Separate compilation is supported and full
 27    tail-recursion and efficient first-class continuations are
 28    available.
 29
 30    Some things that CHICKEN has to offer:
 31
 32    1. CHICKEN generates quite portable C code and compiled files
 33       generated by it (including itself) should work without any
 34       changes on Windows, most UNIX-like platforms, and with
 35       minor changes on other systems.
 36
 37    2. The whole package is distributed under a BSD style license
 38       and as such is free to use and modify as long as you agree
 39       to its terms.
 40
 41    3. Linkage to C modules and C library functions is
 42       straightforward. Compiled programs can easily be embedded
 43       into existing C code.
 44
 45    4. Loads of extra libraries.
 46
 47    Note: Should you have any trouble in setting up and using
 48    CHICKEN, please ask questions on the CHICKEN users mailing
 49    list.  Check http://wiki.call-cc.org/discussion-groups for
 50    information on how to subscribe to CHICKEN mailing lists.
 51
 52
 53 2. Installation
 54
 55    Building CHICKEN requires GNU Make. Other "make" derivates are
 56    not supported.
 57
 58    Configuration and customization of the build process is done by
 59    either using the "configure" script, setting makefile variables
 60    on the "make" command line or by editing the platform-specific
 61    makefile.
 62
 63    2.1. Building from a release tarball
 64
 65    To build CHICKEN, first extract the archive ("tar xzf
 66    chicken-<version>.tar.gz" on UNIX or use your favorite
 67    extraction program on Windows), then change to the
 68    chicken-<version> directory and invoke "configure" like this:
 69
 70        ./configure [OPTION ...]
 71
 72    This will overwrite a configuration file for the subsequent
 73    "make" invocation that builds the CHICKEN tools and libraries.
 74    Enter "./configure --help" to see the available options.
 75    Usually you want to set the installation prefix where the
 76    results of the build should be installed:
 77
 78        ./configure --prefix $HOME/.local
 79
 80    If not given, the installation prefix defaults to "/usr/local".
 81    You can also define the build platform and whether you want to
 82    build with debug-information, in addition to other specialized
 83    settings. The platform is determined automatically if not
 84    specified.
 85
 86    Once you have configured the system you can start building it
 87    by entering
 88
 89        make
 90
 91    Note that GNU make is currently required, so use
 92
 93        gmake
 94
 95    On systems that use BSD make.
 96
 97    The old style invocation of "make" is still supported, where
 98    you pass platform and prefix information on the make command
 99    line, like this:
100
101        make PLATFORM=<platform> PREFIX=<destination>
102
103    Out-of-directory builds are currently not supported, so you must
104    be in the toplevel source directory to invoke "configure" and
105    "make".
106
107    If CHICKEN somehow detects the wrong platform, type
108
109        ./configure --platform=list
110
111    to get a list of available platforms, and re-run "configure" using
112    the correct platform.
113
114    If you invoke "make" later with different configuration parameters,
115    it is advisable to run:
116
117        make confclean
118
119    to remove old configuration files.
120
121    2.2. Building from Git
122
123    If you build CHICKEN directly from the development sources out
124    of the git repository, you will need a "chicken" executable to
125    generate the compiled C files from the Scheme library sources.
126    See section 2.1 for platform detection issues.
127
128    Configuration is the same as when building from the distribution
129    tarball. You may have to use the "--chicken" option to define
130    which "chicken" compiler binary should be used to translate the
131    Scheme source code in the repository:
132
133        ./configure --prefix ... --chicken <install-dir>/bin/chicken
134
135    If you do not want to use the "configure" script, create an empty
136    "config.make", like this:
137
138        touch config.make
139
140    "Config.make" is required by the build process, even if it
141    contains no settings.
142
143    If you are building in a checkout where you have built other
144    versions of chicken, you need to make sure that all traces of
145    the previous build are removed. "make clean" is insufficient,
146    and you should do the following:
147
148        make spotless
149
150    You will need to have a "chicken" binary installed, ideally
151    from the development snapshot tarball that is closest to the
152    git version you are trying to build (significantly older or
153    newer ones are unlikely to work), and then use that chicken
154    to build from your git sources.  Installing this CHICKEN is
155    recommended, if necessary you can install it to a temporary
156    location in your homedir for example.
157
158    In some cases, the sources may have diverged enough to
159    become unbuildable even with the snapshot.  Then you'll need
160    to first build a bootstrapping compiler with the installed
161    CHICKEN and then use that to build the version from git.
162    See the "Bootstrapping" section below.
163
164    2.3. Verifying your installation is correct
165
166    You can check whether CHICKEN is functioning correctly by
167    running
168
169        make check
170
171    This will run the test scripts, which show a lot of output.
172    The only thing that matters is the exit status at the end.
173    If it exits with status 0, everything is fine, if it exits
174    with a nonzero status, the failing test's output should be
175    the final lines before Make's "error; exit" output.  If the
176    check fails on unmodified sources, please file a bugreport.
177
178    2.4. Finishing the installation
179
180    If CHICKEN is built successfully, you can install it on your
181    system by entering
182
183        make install
184
185    To install CHICKEN for a particular prefix on a different
186    location, set the "DESTDIR" variable: It designates the
187    directory where the files are installed into.
188
189    2.5. Optional features
190
191    You can further enable various optional features by adding
192    one or more of the following variables to the "configure"
193    invocation:
194
195    --debugbuild
196      Disable optimizations in compiled C code and enable
197      debug information.
198
199    --staticbuild
200      Build only static versions of the runtime library, compiler
201      and interpreter.
202
203    --program-prefix PREFIX
204      A prefix to prepend to the names of all generated executables.
205      This allows having multiple CHICKEN versions in your PATH
206      (but note that they have to be installed at different locations).
207
208    --program-suffix SUFFIX
209      A suffix to be appended to the names of all generated executables.
210
211    --host SYSTEM
212      A "<machine>-<platform>" name prefix to use for the C compiler to
213      use to compile the runtime system and executables. Set this variable
214      if you want to compile CHICKEN for a different architecture than
215      the one on which you are building it.
216
217    --target SYSTEM
218      Similar to "HOSTSYSTEM", but specifies the name
219      prefix to use for compiling code with the "csc" compiler
220      driver. This is required for creating a "cross chicken", a
221      specially built CHICKEN that invokes a cross C compiler to
222      build the final binaries. You will need a cross compiled
223      runtime system by building a version of CHICKEN with the
224      "HOST" option mentioned above. More information about this
225      process and the variables that you should set are provided
226      in the manual (see the "Cross development" chapter).
227
228    --srcdir DIRECTORY
229      Specifies that CHICKEN should be built outside of its source
230      tree. The SRCDIR variable indicates the location of the
231      CHICKEN source tree. The executables and object files will
232      be generated in the current directory.
233
234    --vardir DIRECTORY
235      If set, this directory overrides the location where
236      extensions along with their metadata are stored. Normally
237      this will be equivalent to "<PREFIX>/lib/chicken/<BINARYVERSION>".
238      When VARDIR is specified, extensions will be stored in
239      "<VARDIR>/chicken/<BINARYVERSION>", conforming to the FHS.
240
241    --c-compiler PROGRAM
242      If set, determines the C compiler used to compiler C sources.
243
244    --linker PROGRAM
245      Determines the executable used for linking compiled object files,
246      usually the same as the C compiler executable.
247
248    --profile-object "FILENAME ..."
249      This option allows you to profile (parts of) CHICKEN itself.
250      Just pass in a whitespace-separated list of objects, without
251      the .scm-extension.  (An "object" here is an individual
252      .scm-file which gets compiled to a .c-file)
253      To build with profiling support, run "make spotless" first.
254      Be warned that this is a highly experimental option and
255      profiling doesn't work for every component of CHICKEN.
256
257    The "configure" script respects the "CC" and "CFLAGS" environment
258    variables which allow overriding the C compiler to use and any
259    additional C compiler flags that should be used when compiling
260    the runtime system and C files generated by "chicken".
261
262    The default compiler is "gcc" ("cc" on *BSD systems). CHICKEN
263    can be built with the LLVM version of gcc and with "clang",
264    the LLVM-based C compiler, just set C_COMPILER to "llvm-gcc"
265    or "clang". CHICKEN has also been successfully built with "zig cc",
266    the C frontend of the "Zig" language toolchain.
267
268    Less frequently used settings are available by variables that can
269    be passed on the "make" command line:
270
271    2.6. Uninstalling CHICKEN
272
273    To remove CHICKEN from your file-system, enter (probably as
274    root):
275
276        make uninstall
277
278    (If you gave DESTDIR during installation, you have to pass
279    the same setting to "make" when uninstalling)
280
281    2.7. What gets installed
282
283    These files will be installed under the prefix given during
284    build and installation:
285
286    <PREFIX>
287    |-- bin
288    |   |-- chicken
289    |   |-- chicken-install
290    |   |-- chicken-profile
291    |   |-- chicken-status
292    |   |-- chicken-uninstall
293    |   |-- libchicken.dll                        (Windows)
294    |   |-- csc
295    |   `-- csi
296    |-- include
297    |   `-- chicken
298    |       |-- chicken-config.h
299    |       `-- chicken.h
300    |-- lib
301    |   |-- chicken
302    |   |   `-- 12
303    |   |       |-- chicken.base.import.so
304    |   |       |-- chicken.bitwise.import.so
305    |   |       |-- chicken.bytevector.import.so
306    |   |       |-- chicken.compiler.user-pass.import.so
307    |   |       |-- chicken.condition.import.so
308    |   |       |-- chicken.continuation.import.so
309    |   |       |-- chicken.csi.import.so
310    |   |       |-- chicken.errno.import.so
311    |   |       |-- chicken.eval.import.so
312    |   |       |-- chicken.file.import.so
313    |   |       |-- chicken.file.posix.import.so
314    |   |       |-- chicken.fixnum.import.so
315    |   |       |-- chicken.flonum.import.so
316    |   |       |-- chicken.foreign.import.so
317    |   |       |-- chicken.format.import.so
318    |   |       |-- chicken.gc.import.so
319    |   |       |-- chicken.internal.import.so
320    |   |       |-- chicken.io.import.so
321    |   |       |-- chicken.irregex.import.so
322    |   |       |-- chicken.keyword.import.so
323    |   |       |-- chicken.load.import.so
324    |   |       |-- chicken.locative.import.so
325    |   |       |-- chicken.memory.import.so
326    |   |       |-- chicken.memory.representation.import.so
327    |   |       |-- chicken.pathname.import.so
328    |   |       |-- chicken.platform.import.so
329    |   |       |-- chicken.plist.import.so
330    |   |       |-- chicken.port.import.so
331    |   |       |-- chicken.pretty-print.import.so
332    |   |       |-- chicken.process.import.so
333    |   |       |-- chicken.process.signal.import.so
334    |   |       |-- chicken.process-context.import.so
335    |   |       |-- chicken.process-context.posix.import.so
336    |   |       |-- chicken.random.import.so
337    |   |       |-- chicken.repl.import.so
338    |   |       |-- chicken.sort.import.so
339    |   |       |-- chicken.string.import.so
340    |   |       |-- chicken.read-syntax.import.so
341    |   |       |-- chicken.syntax.import.so
342    |   |       |-- chicken.tcp.import.so
343    |   |       |-- chicken.time.import.so
344    |   |       |-- chicken.time.posix.import.so
345    |   |       |-- chicken.version.import.so
346    |   |       |-- scheme.file.import.so
347    |   |       |-- scheme.process-context.import.so
348    |   |       |-- scheme.time.import.so
349    |   |       |-- scheme.write.import.so
350    |   |       |-- modules.db
351    |   |       |-- srfi-4.import.so
352    |   |       `-- types.db
353    |   |-- libchicken-static.a
354    |   |-- libchicken.dll.a                      (Windows)
355    |   |-- libchicken.dylib                      (Macintosh)
356    |   |-- libchicken.so -> libchicken.so.12     (Unix)
357    |   `-- libchicken.so.12                      (Unix)
358    `-- share
359        |-- chicken
360        |   |-- doc
361        |   |   |-- LICENSE
362        |   |   |-- README
363        |   |   |-- DEPRECATED
364        |   |   |-- chicken.png
365        |   |   |-- manual-html
366        |   |       `-- *.html
367        |   |-- chicken.rc.o                      (Windows)
368        |   `-- setup.defaults
369        `-- man
370        `-- man1
371            |-- chicken-install.1
372            |-- chicken-profile.1
373            |-- chicken-status.1
374            |-- chicken-uninstall.1
375            |-- chicken.1
376            |-- csc.1
377            `-- csi.1
378
379
380 3. Usage
381
382    Documentation can be found in the directory
383    PREFIX/share/chicken/doc in HTML format. The manual is
384    maintained in a wiki at http://wiki.call-cc.org. Go there to
385    read the most up to date documentation.
386
387
388 4. Extensions
389
390    A large number of extension libraries for CHICKEN are
391    available at http://wiki.call-cc.org/eggs. You can
392    automatically download, compile and install extensions with
393    the "chicken-install" program. See the CHICKEN User's Manual
394    for more information.
395
396    A selection of 3rd party libraries, together with source and
397    binary packages for tools helpful for development with CHICKEN
398    are also available at:
399    <http://www.call-with-current-continuation.org/tarballs/>.
400
401
402 5. Platform issues
403
404    Android:
405
406      - The Android SDK and NDK are required. Make sure you have
407        set up a project and have a suitable NDK toolchain
408        available. You will have to override the make(1) variable
409        C_COMPILER to contain the correct compiler; see
410        docs/STANDALONE-TOOLCHAIN.html in your NDK root for notes
411        on how to call the correct compiler. You will also need to
412        override the ARCH variable to match the device you're
413        targeting.  The build will produce a libchicken.so that
414        can then be integrated into your project as a prebuilt
415        shared library.  See the android section on
416        http://wiki.call-cc.org/embedding for a complete example.
417
418      - It is possible to use eggs, by copying them into the right
419        place and probably renaming the files. This is somewhat
420        awkward and requires various hacks to make the
421        loading/linking of eggs work. It may be easier to build
422        the eggs you need manually and linking them statically to
423        your executable.
424
425      - By default debug-logging is enabled and written to the
426        Android log.
427
428    FreeBSD/NetBSD/OpenBSD:
429
430      - *BSD system users *must* use GNU make ("gmake") - the makefiles
431        can not be processed by BSD make.
432
433      - On NetBSD it might be possible that compilation fails with a
434        "virtual memory exhausted error".  Try the following:
435
436        % unlimit datasize
437
438      - When using -deploy on NetBSD, currently the kernel only
439        supports running the program through its absolute path,
440        otherwise you will get an error message stating:
441
442          execname not specified in AUX vector: No such file or directory
443
444        Deployed binaries can also be run without an explicit path,
445        through $PATH; only relative pathnames do not work.
446
447      - Using external libraries on NetBSD may also be easier, if
448        you add the following definitions to `Makefile.bsd':
449
450          C_COMPILER_OPTIONS += -I/usr/pkg/lib
451          LINKER_OPTIONS += -L/usr/pkg/lib -Wl,-rpath=/usr/pkg/lib
452
453        Note that this may cause build-problems, if you already have
454        an existing CHICKEN installation in the /usr/pkg prefix.
455
456    Linux:
457
458      - If you want to build Linux binaries which use the "X32 ABI",
459        you can pass ARCH=x32 on the Make command line.
460
461      - There have been reports where the library directory
462        "/usr/lib64" could not be found at build-time on a Fedora
463        12 system. If you build a 64-bit version of CHICKEN and
464        the library directory is set incorrectly, you can override
465        it by passing "LIBDIR=/usr/lib64" as an additional
466        argument when you invoke "make".
467
468    Solaris:
469
470      - By default, CHICKEN is build with the GNU C compiler (`gcc').
471        To use the SunPro C compiler (`cc') instead, override the
472        used compiler like this:
473
474          CC=cc ./configure ...
475
476      - Older versions of Solaris have a bug in ld.so that causes
477        trouble with dynamic loading.  Patching Solaris fixes the
478        problem. Solaris 7 needs patch 106950-18. Solaris 8 has an
479        equivalent patch, 109147-16.
480
481        You can find out if you have these patches installed by
482        running:
483
484        % showrev -p | grep 106950    # solaris 7
485        % showrev -p | grep 109147    # solaris 8
486
487    Mac OS X:
488
489      - The build currently assumes the C toolchain is in the path,
490        use the "xcode-select(1)" tool to make them available on the
491        command line if you haven't already done so.
492
493      - CHICKEN will normally select a 32-bit or 64-bit build
494        automatically when you use the normal build step:
495
496          make
497
498        Specifically, the defaults are:
499
500          10.4: 32-bit
501          10.5: 32-bit
502          10.6: 64-bit (32-bit on original Core Duo, circa early 2006)
503          10.7: 64-bit
504
505        On 10.5, you can optionally build in 64-bit mode on machines
506        released in late 2006 or later (i.e. with a Core 2 Duo or Xeon
507        CPU), by specifying ARCH=x86-64:
508
509          make ARCH=x86-64
510
511      - Universal binaries: On 10.4 and 10.5 only, CHICKEN and its eggs
512        can be built as universal binaries which will work on either
513        Intel or PowerPC.  Most users will not want to do this.
514
515        For 10.4 universal build:
516          make ARCH=universal
517
518        For 10.5 universal build:
519          export MACOSX_DEPLOYMENT_TARGET=10.4
520          make C_COMPILER=gcc-4.0 ARCH=universal
521
522        For 10.6 and later, universal builds are not supported.
523
524      - On 10.3 and earlier, you must first install `dlcompat'
525        which can be found at http://distfiles.macports.org/dlcompat/.
526
527    iOS:
528
529      - Make sure the "XCODE_PATH" setting is correct (see
530        Makefile.ios), it defaults to "/Applications/Xcode.app".
531
532      - The paths for the the various build tools changed between
533        Xcode 4 and 5. The makefile used for iOS builds of CHICKEN
534        assume Xcode 5 is used. If you are using Xcode 4, override
535        the XCODE_TOOLPATH and C_COMPILER make-variables providing
536        the correct paths, see Makefile.ios for suggestions.
537
538      - The iOS build is static (iOS doesn't support dynamic
539        loading of executable code). Only the runtime library
540        (libchicken.a) is of interest. To use it, integrate
541        libchicken.a in your Xcode project and use a normal MacOS
542        build to compile your Scheme sources into C files, adding
543        them to you project.
544
545      - Core library units must by accessed via "(declare (uses
546        ...))" and "(import ...)", "require", "require-library",
547        "require-extension" and "use" will not work, due to the
548        reasons mentioned above.
549
550      - As dynamic loading is not supported, eggs can not be used
551        as usual, you will have to compile them manually and
552        integrate what you need into your project.
553
554      - If you want to build for the iPhone Simulator, override
555        the ARCH and XCODE_SDK variables accordingly, see also in
556        Makefile.ios for suggestions.
557
558    Windows:
559
560      - On Windows, native builds using the "MingW" toolchain and
561        Cygwin are supported (Microsoft Visual Studio is *NOT*).
562        Makefiles for MingW are provided (`Makefile.MingW').
563        GNU make and a POSIX sh(1) are required to build the system.
564        Please also read the notes below.
565
566      - Since there are various distributions of the MingW toolchain
567        we recommend to use "w64devkit" by Chrstopher Wellons:
568
569          https://github.com/skeeto/w64devkit
570
571        This toolset is very complete, includes GNU make and a
572        POSIX shell and is the development environment we use to
573        test CHICKEN. Other distributions of MingW may work but
574        are not tested by us.
575
576      - When installing under the MingW platform, PREFIX must be an
577        absolute path name (i.e. it must include the drive letter) and
578        must use forward slashes (no backward slashes), for example
579
580          ./configure --prefix C:/chicken/
581
582      - Under MingW, the "csc" compiler driver and "chicken-install"
583        expect the compiler executable and the usual UNIX tools are
584        in the PATH, so make sure to run them inside a shell that
585        provides the necessary stuff.
586
587      - Cygwin will not be able to find the chicken shared libraries
588        until Windows is rebooted.
589
590      - During "make check" you may see these intermittent errors:
591
592          ld.exe: cannot open output file a.out: Permission denied
593
594        When this happens, the virusscanner is holding open
595        the file of the previous test while the compiler is
596        preparing the next test.
597        To work around this in Windows Defender (the default),
598        disable "realtime protection" under tools->options.
599
600    AIX:
601
602      - CHICKEN is built with the GNU C compiler (`gcc').  IBM's XL
603        C compiler is not supported at this time.
604
605      - AIX users *must* use GNU make ("gmake") - the makefiles can not be
606        processed with IBM's version of make.
607
608      - Deployment doesn't work.  See manual/Deployment for more details.
609
610      - The AIX linker may occasionally show warnings of the form:
611
612          ld: 0711-783 WARNING: TOC overflow. TOC size: 66656
613          Maximum size: 65536
614          Extra instructions are being generated for each reference to a TOC
615          symbol if the symbol is in the TOC overflow area.
616
617        Such messages indicate that lookups for some symbols in the
618        effected library/executable may be somewhat slower at runtime as an
619        auxiliary symbol table is needed to accommodate all of the symbols.
620
621      - The AIX assembler may show warnings of the form:
622
623          /tmp//ccycPGzK.s: line 527244: 1252-171 The displacement must be
624          greater than or equal to -32768 and less than or equal to 32767.
625
626        This is a known issue between the GNU toolchain and IBM's assembler:
627
628        http://gcc.gnu.org/bugzilla/show_bug.cgi?id=4587
629
630        The problem arises because the PPC architecture cannot perform jumps
631        to addresses that differ more than what a 16-bit integer can
632        represent.  Adding support for IBM's XL C compiler may resolve this
633        issue.
634
635        Instructing gcc to optimize the size of generated code (-Os)
636        mitigates this to some degree, but very large C files may still be
637        uncompilable.  This is known to affect the html-tags egg.
638
639    Haiku:
640
641      - The default GCC compiler is too old to support the -fwrapv
642        option.  You can either remove the flag from Makefile.haiku,
643        use a newer GCC, or supply your own C_COMPILER_OPTIONS on
644        the Make command line.
645
646      - The default Haiku BFS file system only supports timestamps
647        with a granularity of one second.  This may cause trouble
648        with pregenerated release or development snapshot tarballs
649        due to the way files are pre-translated to C.  You'll either
650        need to have CHICKEN installed, or touch the
651        build-version.c file before building.
652
653
654 6. Bootstrapping
655
656    To build a bootstrapping compiler yourself, get the most
657    recent development snapshot tarball from
658    http://code.call-cc.org, unpack it, build and install everything.
659    Then change to the directory containing the git code and run:
660
661        ./configure --chicken <path-to-existing-chicken>
662        make boot-chicken
663
664    This will produce a statically linked binary with the name
665    "chicken-boot[.exe]" that can be given as the value of the
666    "--chicken" configuration option. Note that the path to an
667    existing `chicken' binary must be given to use it for
668    compiling the Scheme code of the runtime-system and compiler.
669
670    "scripts/bootstrap.sh" automates this process; use this script
671    if you are unsure how to build from the repository sources. It
672    downloads the necessary development snapshot with wget(1) and
673    builds the boot-chicken that you can use to compile the
674    development sources. The invocation is:
675
676        ./scripts/bootstrap.sh ...
677
678    You can add additional parameters if you like to customize the
679    build, but this should not be necessary. Note that your current
680    working directory must be the root directory of the CHICKEN
681    git(1) repository. Once the boot-chicken is built, proceed by
682    invoking make(1) as described above (in 2.2, Building from Git),
683    with the additional parameter:
684
685        make CHICKEN=./chicken-boot ...
686
687    or run "configure" again:
688
689        ./configure --chicken ./chicken-boot ...
690        make
691
692
693 7. Emacs support
694
695    See http://wiki.call-cc.org/emacs for tips and links to emacs
696    extensions for Scheme and CHICKEN programming.
697
698
699 8. What's next?
700
701    If you find any bugs, or want to report a problem, please send
702    a detailed bug report.
703
704    If you have any more questions or problems (even the slightest
705    problems, or the most stupid questions), then please subscribe
706    to the "chicken-users"
707    (http://lists.nongnu.org/mailman/listinfo/chicken-users)
708    mailing list and ask for help. It will be answered.
Trap