source: project/wiki/man/4/Using the compiler

Last change on this file was 39575, checked in by sjamaan, 6 months ago

Add outdated note to CHICKEN 4 manual pages

File size: 26.3 KB
Line 
1== Outdated CHICKEN release
2
3This is a manual page for an old and unsupported version of CHICKEN.
4If you are still using it, please consider migrating to the latest
5version. You can find the manual for the latest release [[/manual|here]].
6
7[[tags: manual]]
8[[toc:]]
9
10== Using the compiler
11
12The {{csc}} compiler driver provides a convenient interface to
13the basic Scheme-to-C translator ({{chicken}}) and takes care
14for compiling and linking the generated C files into executable
15code. Enter
16
17 csc -help
18
19on the command line for a list of options.
20
21=== Compiler command line format
22
23 csc FILENAME-OR-OPTION
24
25{{FILENAME}} is the pathname of the source file that is to
26be compiled. A filename argument of {{-}} (a single dash) specifies that
27the source text should be read from standard input.
28
29==== Basic command-line options
30
31; -analyze-only : Stop compilation after first analysis pass.
32
33; -block : Enable block-compilation. When this option is specified, the compiler assumes that global variables are not modified outside this compilation-unit.  Specifically, toplevel bindings are not seen by {{eval}} and unused toplevel bindings are removed.
34
35; -case-insensitive : Enables the reader to read symbols case insensitive. The default is to read case sensitive (in violation of R5RS).  This option registers the {{case-insensitive}} feature identifier.
36
37; -check-syntax : Aborts compilation process after macro-expansion and syntax checks.
38
39; -clustering : Combine groups of local procedures into dispatch-loops, if possible.
40
41; -consult-inline-file FILENAME : load file with definitions for cross-module inlining generated by a previous compiler invocation via {{-emit-inline-file}}. Implies {{-inline}}.
42
43; -debug MODES : Enables one or more compiler debugging modes. {{MODES}} is a string of characters that select debugging information about the compiler that will be printed to standard output. Use {{-debug h}} to see a list of available debugging options.
44
45; -debug-level LEVEL : Selects amount of debug-information. {{LEVEL}} should be an integer.
46
47     -debug-level 0             is equivalent to -no-trace -no-lambda-info
48     -debug-level 1             is equivalent to -no-trace
49     -debug-level 2             is equivalent to -scrutinize
50
51; -disable-interrupts : Equivalent to the {{(disable-interrupts)}} declaration. No interrupt-checks are generated for compiled programs.
52
53; -disable-stack-overflow-checks : Disables detection of stack overflows. This is equivalent to running the compiled executable with the {{-:o}} runtime option.
54
55; -dynamic : This option should be used when compiling files intended to be loaded dynamically into a running Scheme program.
56
57; -epilogue FILENAME : Includes the file named {{FILENAME}} at the end of the compiled source file. The include-path is not searched. This option may be given multiple times.
58
59; -emit-all-import-libraries : emit import libraries for all modules defined in the current compulation unit (see also: {{-emit-import-library}}).
60
61; -emit-external-prototypes-first : Emit prototypes for callbacks defined with {{define-external}} before any other foreign declarations. This is sometimes useful, when C/C++ code embedded into the a Scheme program has to access the callbacks. By default the prototypes are emitted after foreign declarations.
62
63; -emit-import-library MODULE : Specifies that an import library named {{MODULE.import.scm}} for the named module should be generated (equivalent to using the {{emit-import-library}} declaration).
64
65; -emit-inline-file FILENAME : Write procedures that can be globally inlined in internal form to {{FILENAME}}, if global inlining is enabled. Implies {{-inline -local}}. If the inline-file would be empty (because no procedure would be inlinable) no file is generated and any existing inline-file with that name is deleted.
66
67; -emit-type-file FILENAME : Write type-information for declarations of user-defined and globally visible variables to a file of the given name. The generated file is suitable for use with the {{-types}} option.
68
69; -explicit-use : Disables automatic use of the units {{library, eval}} and {{expand}}. Use this option if compiling a library unit instead of an application unit.
70
71; -extend FILENAME : Loads a Scheme source file or compiled Scheme program (on systems that support it) before compilation commences. This feature can be used to extend the compiler.  This option may be given multiple times. The file is also searched in the current include path and in the extension-repository.
72
73; -feature SYMBOL : Registers {{SYMBOL}} to be a valid feature identifier for {{cond-expand}}. Multiple symbols may be given, if comma-separated.
74
75; -fixnum-arithmetic : Equivalent to {{(fixnum-arithmetic)}} declaration. Assume all mathematical operations use small integer arguments.
76
77; -heap-size NUMBER : Sets a fixed heap size of the generated executable to {{NUMBER}} bytes. The parameter may be followed by a  {{M}} ({{m}}) or {{K}} ({{k}}) suffix which stand for mega- and kilobytes, respectively.  The default heap size is 5 kilobytes. Note that only half of it is in use at every given time.
78
79; -help : Print a summary of available options and the format of the command line parameters and exit the compiler.
80
81; -ignore-repository : Do not load any extensions from the repository (treat repository as empty). Also do not consult compiled (only interpreted) import libraries in {{import}} forms.
82
83; -include-path PATHNAME : Specifies an additional search path for files included via the {{include}} special form. This option may be given multiple times. If the environment variable {{CHICKEN_INCLUDE_PATH}} is set, it should contain a list of alternative include pathnames separated by {{;}}.
84
85; -inline : Enable procedure inlining for known procedures of a size below the threshold (which can be set through the {{-inline-limit}} option).
86
87; -inline-global : Enable cross-module inlining (in addition to local inlining). Implies {{-inline}}. For more information, see also [[Declarations]].
88
89; -inline-limit THRESHOLD : Sets the maximum size of a potentially inlinable procedure. The default threshold is {{20}}.
90
91; -keyword-style STYLE : Enables alternative keyword syntax, where {{STYLE}} may be either {{prefix}} (as in Common Lisp, e.g. :keyword), {{suffix}} (as in DSSSL, e.g. keyword:) or {{none}}. Any other value is ignored. The default is {{suffix}}.
92
93; -keep-shadowed-macros : Do not remove macro definitions with the same name as assigned toplevel variables (the default is to remove the macro definition).
94
95; -local : Assume toplevel variables defined in the current compilation unit are not externally modified. This gives the compiler more opportunities for inlining. Note that this may result in counter-intuitive and non-standard behaviour: an asssignment to an exported toplevel variable executed in a different compilation unit or in evaluated code will possibly not be seen by code executing in the current compilation unit.
96
97; -lfa2 : Does an additional lightweight flow-analysis pass on the fully optimized program to remove more type checks.
98
99; -module : wraps the compiled code in an implicit module named {{main}}, importing the {{scheme}} and {{chicken}} modules.
100
101; -no-argc-checks : disable argument count checks
102
103; -no-bound-checks : disable bound variable checks
104
105; -no-feature SYMBOL : Disables the predefined feature-identifier {{SYMBOL}}. Multiple symbols may be given, if comma-separated.
106
107; -no-lambda-info : Don't emit additional information for each {{lambda}} expression (currently the argument-list, after alpha-conversion/renaming).
108
109; -no-module-registration : Do not generate module-registration code in the compiled code. This is only needed if you want to use an import library that is generated by other means (manually, for example).
110
111; -no-parentheses-synonyms : Disables list delimiter synonyms, [..] and {...} for (...).
112
113; -no-procedure-checks : disable procedure call checks
114
115; -no-procedure-checks-for-usual-bindings :  disable procedure call checks only for usual bindings
116
117; -no-procedure-checks-for-toplevel-bindings :  disable bound and procedure call checks for calls to procedures referenced through a toplevel variable.
118
119; -no-symbol-escape : Disables support for escaped symbols, the |...| form.
120
121; -no-trace : Disable generation of tracing information. If a compiled executable should halt due to a runtime error, then a list of the name and the line-number (if available) of the last procedure calls is printed, unless {{-no-trace}} is specified. With this option the generated code is slightly faster.
122
123; -no-warnings : Disable generation of compiler warnings.
124
125; -nursery NUMBER :
126; -stack-size NUMBER : Sets the size of the first heap-generation of the generated executable to {{NUMBER}} bytes. The parameter may be followed by a {{M}} ({{m}}) or {{K}} ({{k}}) suffix.  The default stack-size depends on the target platform.
127
128; -optimize-leaf-routines : Enable leaf routine optimization.
129
130; -optimize-level LEVEL : Enables certain sets of optimization options. {{LEVEL}} should be an integer.
131
132     -optimize-level 0          is equivalent to -no-usual-integrations -no-compiler-syntax
133     -optimize-level 1          is equivalent to -optimize-leaf-routines
134     -optimize-level 2          is equivalent to -optimize-leaf-routines -inline
135     -optimize-level 3          is equivalent to -optimize-leaf-routines -local -inline -inline-global -specialize
136     -optimize-level 4          is equivalent to -optimize-leaf-routines -local -inline -inline-global -specialize -unsafe
137     -optimize-level 5          is equivalent to -optimize-leaf-routines -block -inline -inline-global -specialize -unsafe -disable-interrupts -no-trace -no-lambda-info -clustering -lfa2
138
139; -output-file FILENAME : Specifies the pathname of the generated C file. Default is {{FILENAME.c}}.
140
141; -postlude EXPRESSIONS : Add {{EXPRESSIONS}} after all other toplevel expressions in the compiled file.  This option may be given multiple times. Processing of this option takes place after processing of {{-epilogue}}.
142
143; -prelude EXPRESSIONS : Add {{EXPRESSIONS}} before all other toplevel expressions in the compiled file.  This option may be given multiple times. Processing of this option takes place before processing of {{-prologue}}.
144
145; -profile :
146; -accumulate-profile : Instruments the source code to count procedure calls and execution times. After the program terminates (either via an explicit {{exit}} or implicitly), profiling statistics are written to a file named {{PROFILE.<randomnumber>}}. Each line of the generated file contains a list with the procedure name, the number of calls and the time spent executing it. Use the {{chicken-profile}} program to display the profiling information in a more user-friendly form. Enter {{chicken-profile -help}} at the command line to get a list of available options. The {{-accumulate-profile}} option is similar to {{-profile}}, but the resulting profile information will be appended to any existing {{PROFILE}} file. {{chicken-profile}} will merge and sum up the accumulated timing information, if several entries for the same procedure calls exist. Only profiling information for global procedures will be collected.  See the {{-:p}} option under [[#runtime-options|"Runtime options"]] below for statistical profiling support.
147
148; -profile-name FILENAME : Specifies name of the generated profile information (which defaults to {{PROFILE.<randomnumber>}}. Implies {{-profile}}.
149
150; -prologue FILENAME : Includes the file named {{FILENAME}} at the start of the compiled source file.  The include-path is not searched. This option may be given multiple times.
151
152; -r5rs-syntax : Disables the CHICKEN extensions to R5RS syntax. Does not disable [[Non-standard read syntax|non-standard read syntax]].
153
154; -raw : Disables the generation of any implicit code that uses the Scheme libraries (that is all runtime system files besides {{runtime.c}} and {{chicken.h}}).
155
156; -require-extension NAME : Loads the extension {{NAME}} before the compilation process commences. This is identical to adding {{(require-extension NAME)}} at the start of the compiled program. If {{-uses NAME}} is also given on the command line, then any occurrences of {{-require-extension NAME}} are replaced with {{(declare (uses NAME))}}. Multiple names may be given and should be separated by commas.
157
158; -setup-mode : When locating extension, search the current directory first. By default, extensions are located first in the ''extension repository'', where {{chicken-install}} stores compiled extensions and their associated metadata.
159
160; -specialize : Enable simple flow-analysis for doing some type-directed optimizations.
161
162; -strict-types : Assume that the type of variables is not changed by assignments. This gives more type-information during specialization, but violating this assumption will result in unsafe and incorrectly behaving code.
163
164; -types FILENAME : load additional type database from {{FILENAME}}. Type-definitions in {{FILENAME}} will override previous type-definitions.
165
166; -compile-syntax : Makes macros also available at run-time. By default macros are not available at run-time.
167
168; -to-stdout : Write compiled code to standard output instead of creating a {{.c}} file.
169
170; -unit NAME : Compile this file as a library unit. Equivalent to {{-prelude "(declare (unit NAME))"}}
171
172; -unsafe : Disable runtime safety checks.
173
174; -uses NAME : Use definitions from the library unit {{NAME}}. This is equivalent to {{-prelude "(declare (uses NAME))"}}. Multiple arguments may be given, separated by {{,}}.
175
176; -no-usual-integrations : Specifies that standard procedures and certain internal procedures may be redefined, and can not be inlined. This is equivalent to declaring {{(not usual-integrations)}}.
177
178; -version : Prints the version and some copyright information and exit the compiler.
179
180; -verbose : enables output of notes that are not necessarily warnings but might be of interest.
181
182The environment variable {{CHICKEN_OPTIONS}} can be set to a string
183with default command-line options for the compiler.
184
185==== Further options
186
187Enter
188
189  csc -help
190
191to see a list of all supported options and short aliases to basic options.
192
193=== Runtime options
194
195After successful compilation a C source file is generated and can be
196compiled with a C compiler. Executables generated with CHICKEN (and the
197compiler itself) accept a small set of runtime options:
198
199; {{-:?}} : Shows a list of the available runtime options and exits the program.
200
201; {{-:aNUMBER}} : Specifies the length of the buffer for recording a trace of the last invoked procedures. Defaults to 16.
202
203; {{-:ANUMBER}} : Specifies fixed "temporary stack" size. This is used mostly for {{apply}}. If you supply a zero size (the default), the stack will be dynamically reallocated as needed.
204
205; {{-:b}} : Enter a read-eval-print-loop when an error is encountered.
206
207; {{-:B}} : Sounds a bell (ASCII 7) on every major garbage collection.
208
209; {{-:c}} : Forces console mode. Currently this is only used in the interpreter ({{csi}}) to force output of the {{#;N>}} prompt even if stdin is not a terminal (for example if running in an {{emacs}} buffer under Windows).
210
211; {{-:d}} : Prints some debug-information at runtime.
212
213; {{-:D}} : Prints some more debug-information at runtime.
214
215; {{-:g}} : Prints information about garbage-collection.
216
217; {{-:G}} : Force GUI mode (show error messages in dialog box, suitable for platform).
218
219; {{-:H}} : Before terminating, dump heap usage to stderr.
220
221; {{-:fNUMBER}} : Specifies the maximal number of currently pending finalizers before finalization is forced.
222
223; {{-:hNUMBER}} : Specifies fixed heap size
224
225; {{-:hgPERCENTAGE}} : Sets the growth rate of the heap in percent. If the heap is exhausted, then it will grow by {{PERCENTAGE}}. The default is 200.
226
227; {{-:hiNUMBER}} : Specifies the initial heap size
228
229; {{-:hmNUMBER}} : Specifies a maximal heap size. The default is (2GB - 15).
230
231; {{-:hsPERCENTAGE}} : Sets the shrink rate of the heap in percent. If no more than a quarter of {{PERCENTAGE}} of the heap is used, then it will shrink to {{PERCENTAGE}}. The default is 50.  Note: If you want to make sure that the heap never shrinks, specify a value of {{0}}.  (this can be useful in situations where an optimal heap-size is known in advance).
232
233; {{-:o}} : Disables detection of stack overflows at run-time.
234
235; {{-:p}} : Enable collection of statistics for profiling purposes and write to PROFILE.{{pid}} on exit.  This functions at a granularity defined by the trace information in the binary and libraries: each traced function will show up in the output.  See the {{-profile}} compiler option for instrumentation-based profiling.  The {{PROFILE.pid}} format is compatible with the format generated by instrumentation-based profiling.
236
237; {{-:PFREQUENCY}} : Same as {{-:p}} but set the sampling frequency in microseconds (default is 10000 microseconds or every 10 milliseconds).
238
239; {{-:r}} : Writes trace output to stderr. This option has no effect with in files compiled with the {{-no-trace}} options.
240
241; {{-:sNUMBER}} : Specifies stack size.
242
243; {{-:tNUMBER}} : Specifies symbol table size.
244
245; {{-:w}} : Enables garbage collection of unused symbols. By default unused and unbound symbols are not garbage collected.
246
247; {{-:x}} : Raises uncaught exceptions of separately spawned threads in primordial thread. By default uncaught exceptions in separate threads are not handled, unless the primordial one explicitly joins them. When warnings are enabled (the default) and {{-:x}} is not given, a warning will be shown, though.
248
249Runtime argument values should be given as integers, optionally followed
250by a unit modifier for kilobytes (suffixed with {{K}} or {{k}}),
251megabytes (suffixed with {{M}} or {{m}}), or gigabytes (suffixed with
252{{G}} or {{g}}).
253
254Runtime options may be combined, like {{-:dc}}, but everything following
255an argument is ignored. So {{-:wh64m}} is OK, but {{-:h64mw}} will not
256enable GC of unused symbols.
257
258=== Examples
259
260==== A simple example (with one source file)
261
262To compile a Scheme program (assuming a UNIX-like environment) consisting of a single source file, perform the following steps.
263
264===== Writing your source file
265
266In this example we will assume your source file is called {{foo.scm}}:
267
268<enscript highlight=scheme>
269;;; foo.scm
270
271(define (fac n)
272  (if (zero? n)
273      1
274      (* n (fac (- n 1))) ) )
275
276(write (fac 10))
277(newline)
278</enscript>
279
280===== Compiling your program
281
282Compile the file {{foo.scm}}:
283
284 % csc foo.scm
285
286This will produce the {{foo}} executable:
287
288 % ls
289 foo  foo.scm
290
291===== Running your program
292
293To run your newly compiled executable use:
294
295 % ./foo
296 3628800
297
298
299==== An example with multiple files
300
301If multiple bodies of Scheme code are to be combined into a single
302executable, then we have to compile each file and link the resulting
303object files together with the runtime system.
304
305Let's consider an example where your program consists of multiple source files.
306
307===== Writing your source files
308
309The declarations in these files specify which of the compiled files is the main
310module, and which is the library module. An executable can only have
311one main module, since a program has only a single entry-point. In this
312case {{foo.scm}} is the main module, because it doesn't have a
313{{unit}} declaration:
314
315<enscript highlight=scheme>
316;;; foo.scm
317
318; The declaration marks this source file as dependant on the symbols provided
319; by the bar unit:
320(declare (uses bar))
321
322(write (fac 10)) (newline)
323</enscript>
324
325{{bar.scm}} will be our library:
326
327<enscript highlight=scheme>
328;;; bar.scm
329
330; The declaration marks this source file as the bar unit.  The names of the
331; units and your files don't need to match.
332(declare (unit bar))
333
334(define (fac n)
335  (if (zero? n)
336      1
337      (* n (fac (- n 1))) ) )
338</enscript>
339
340===== Compiling and running your program
341
342You should compile your two files with the following commands:
343
344 % csc -c bar.scm
345 % csc -c foo.scm
346
347That should produce two files, {{bar.o}} and {{foo.o}}.
348They contain the code from your source files in compiled form.
349
350To link your compiled files use the following command:
351
352 % csc foo.o bar.o -o foo
353
354This should produce the {{foo}} executable, which you can run just as in the previous example.
355At this point you can also erase the {{*.o}} files.
356
357You could avoid one step and link the two files just as {{foo.scm}} is compiled:
358
359 % csc -c bar.scm
360 % csc foo.scm bar.o -o foo
361
362Note that if you want to distribute your program, you might want it to
363follow the GNU Coding Standards.  One relatively easy way to achieve
364this is to use Autoconf and Automake, two tools made for this specific
365purpose.
366
367=== Extending the compiler
368
369The compiler supplies a couple of hooks to add user-level passes to the
370compilation process. Before compilation commences any Scheme source files
371or compiled code specified using the {{-extend}} option are loaded
372and evaluated.  The parameters {{user-options-pass, user-read-pass,
373user-preprocessor-pass, user-pass}} and {{user-post-analysis-pass}} can be set
374to procedures that are called to perform certain compilation passes
375instead of the usual processing (for more information about parameters
376see: [[Supported language]].
377
378<parameter>user-options-pass</parameter>
379
380Holds a procedure that will be called with a list of command-line arguments and should return two values: the source filename and the actual list of options, where compiler switches have their leading {{-}} (hyphen) removed and are converted to symbols.  Note that this parameter is invoked '''before''' processing of the {{-extend}} option, and so can only be changed in compiled user passes.
381
382<parameter>user-read-pass</parameter>
383
384Holds a procedure of three arguments. The first argument is a list of strings with the code passed to the compiler via {{-prelude}} options. The second argument is a list of source files including any files specified by {{-prologue}} and {{-epilogue}}. The third argument is a list of strings specified using {{-postlude}} options. The procedure should return a list of toplevel Scheme expressions.
385
386<parameter>user-preprocessor-pass</parameter>
387
388Holds a procedure of one argument. This procedure is applied to each toplevel expression in the source file '''before''' macro-expansion. The result is macro-expanded and compiled in place of the original expression.
389
390<parameter>user-pass</parameter>
391
392Holds a procedure of one argument. This procedure is applied to each toplevel expression '''after''' macro-expansion.  The result of the procedure is then compiled in place of the original expression.
393
394<parameter>user-post-analysis-pass</parameter>
395
396Holds a procedure that will be called after every performed program analysis pass. The procedure (when defined) will be called with seven arguments: a symbol indicating the analysis pass, the program database, the current node graph, a getter and a setter-procedure which can be used to access and manipulate the program database, which holds various information about the compiled program, a pass iteration count, and an analysis continuation flag. The getter procedure should be called with two arguments: a symbol representing the binding for which information should be retrieved, and a symbol that specifies the database-entry. The current value of the database entry will be returned or {{#f}}, if no such entry is available. The setter procedure is called with three arguments: the symbol and key and the new value. The pass iteration count currently is meaningful only for the 'opt pass. The analysis continuation flag will be {{#f}} for the last 'opt pass. For information about the contents of the program database contact the author.
397
398Loaded code (via the {{-extend}} option) has access to the library
399units {{extras, srfi-1, srfi-4, utils, regex}} and the pattern matching macros.
400Multithreading is not available.
401
402Note that the macroexpansion/canonicalization phase of the compiler adds
403certain forms to the source program.  These extra expressions are not
404seen by {{user-preprocessor-pass}} but by {{user-pass}}.
405
406=== Distributing compiled C files
407
408It is relatively easy to create distributions of Scheme projects that
409have been compiled to C.  The runtime system of CHICKEN consists of only
410three handcoded C files ({{runtime.c}} and {{chicken.h}}), plus
411the file {{chicken-config.h}}, which is generated by the build process. All
412other modules of the runtime system and the extension libraries are just
413compiled Scheme code.The following example shows a minimal application, which
414should run without changes on the most frequent operating systems, like Windows,
415Linux or FreeBSD (Static binaries are NOT supported on Mac OS X):
416
417
418Let's take a simple example.
419
420<enscript highlight=scheme>
421; hello.scm
422
423(print "Hello, world!")
424</enscript>
425
426  % csc -t hello.scm -optimize-level 3 -output-file hello.c
427
428Compiled to C, we get {{hello.c}}. We need the files {{chicken.h}},
429{{chicken-config.h}}, {{build-version.c}}, {{buildtag.h}} and
430{{runtime.c}}, which contain the basic runtime system, plus the five
431basic library files {{library.c}}, {{eval.c}}, {{expand.c}},
432{{modules.c}} and {{build-version.c}} which contain the same
433functionality as the library linked into a plain CHICKEN-compiled
434application, or which is available by default in the interpreter,
435{{csi}}:
436
437
438  % cd /tmp
439  % echo '(print "Hello World.")' > hello.scm
440  % cp $CHICKEN_BUILD/runtime.c  .
441  % cp $CHICKEN_BUILD/library.c  .
442  % cp $CHICKEN_BUILD/eval.c     .
443  % cp $CHICKEN_BUILD/extras.c   .
444  % cp $CHICKEN_BUILD/expand.c   .
445  % cp $CHICKEN_BUILD/modules.c  .
446  % cp $CHICKEN_BUILD/build-version.c  .
447  % cp $CHICKEN_BUILD/chicken.h  .
448  % cp $CHICKEN_BUILD/chicken-config.h  .
449  % cp $CHICKEN_BUILD/buildtag.h  .
450  % gcc -static -Os -fomit-frame-pointer -DHAVE_CHICKEN_CONFIG_H runtime.c build-version.c \
451     library.c eval.c expand.c modules.c hello.c -o hello -lm
452
453Now we have all files together, and can create an tarball containing all the files:
454
455 % tar cf hello.tar hello.c runtime.c build-version.c library.c eval.c extras.c \
456   expand.c modules.c chicken.h chicken-config.h
457 % gzip hello.tar
458
459This is naturally rather simplistic. Things like enabling dynamic
460loading and selecting supported features of the host system would need
461more configuration- and build-time support. All this can be addressed
462using more elaborate build-scripts, makefiles or by using
463autoconf/automake.
464
465The {{chicken-config.h}} file may contain wrong settings for your
466deployment target. Especially when the architecture is different.
467In that case you will have to adjust the values as needed.
468
469Note also that the size of the application can still be reduced by removing
470{{eval}} and compiling {{hello.scm}} with the {{-explicit-use}} option.
471
472For more information, study the CHICKEN source code and/or ask on the CHICKEN
473mailing list.
474
475---
476Previous: [[Basic mode of operation]]
477
478Next: [[Using the interpreter]]
Note: See TracBrowser for help on using the repository browser.