source: project/wiki/man/4/Extensions @ 25875

Last change on this file since 25875 was 25875, checked in by felix winkelmann, 9 years ago

merged some manual changes from master into wiki

File size: 24.8 KB
Line 
1== Extensions
2
3[[tags: manual]]
4[[toc:]]
5
6=== Extension libraries
7
8Extension libraries (''eggs'') are extensions to the core
9functionality provided by the basic CHICKEN system, to be built and
10installed separately.  The mechanism for loading compiled extensions
11is based on dynamically loadable code and as such is only available on
12systems on which loading compiled code at runtime is
13supported. Currently these are most UNIX-compatible platforms that
14provide the {{libdl}} functionality like Linux, Solaris, BSD, Mac OS X
15and Windows using Cygwin.
16
17Note: Extension may also be normal applications or shell scripts, but
18are usually libraries.
19
20Extensions are technically nothing but dynamically loadable compiled
21files with added meta-data that describes dependencies to other
22extensions, version information and things like the author/maintainer
23of the extension. Three tools provide an easy to use interface for
24installing extensions, removing them and querying the current
25status of installed extensions.
26
27
28=== Installing extensions
29
30To install an extension library, run the {{chicken-install}} program
31with the extension name as argument. The extension archive is
32downloaded, its contents extracted and the contained ''setup'' script
33is executed. This setup script is a normal Scheme source file, which
34will be interpreted by {{chicken-install}}. The complete language
35supported by {{csi}} is available, and the library units {{srfi-1
36regex utils posix tcp}} are loaded. Additional libraries can be loaded
37at run-time.
38
39The setup script should perform all necessary steps to build the new
40library (or application). After a successful build, the extension can
41be installed by invoking one of the procedures {{install-extension}},
42{{install-program}} or {{install-script}}.  These procedures will copy
43a number of given files into the local extension repository or in the
44path where the CHICKEN executables are located (in the case of
45executable programs or scripts). Additionally the list of installed
46files, and user-defined metadata is stored in the repository.
47
48If no extension name is given on the command-line, then all {{.setup}}
49scripts in the current directory are processed, in the order given
50on the command line.
51
52==== Installing extensions that use libraries
53
54Sometimes an extension requires a C library to compile. Compilation
55can fail when your system has this library in a nonstandard
56location. Normally the C compiler searches in the default locations
57{{/usr}} and {{/usr/local}}, and in the prefix where Chicken itself
58was installed. Sometimes this is not enough, so you'll need to supply
59{{chicken-install}} with some extra hints to the C compiler/linker. Here's
60an example:
61
62  CSC_OPTIONS='-I/usr/pkg/include/mysql -L/usr/pkg/lib/mysql -L -R/usr/pkg/lib/mysql' chicken-install mysql
63
64This installs the mysql egg with the extra compiler options -I and -L
65to set the include path and the library search path. The second -L
66switch passes the -R option directly to the linker, which causes the
67library path to get hardcoded into the resulting extension file (for
68systems that do not use {{ld.so.conf}}).
69
70The environment variables {{CHICKEN_C_INCLUDE_PATH}} and {{CHICKEN_C_LIBRARY_PATH}}
71can also be used to override include- and linker-paths. Each of these variables
72may contain one or more directory names, separated by {{:}} or {{;}} and will
73be passed using {{-I}} and {{-L}} to the C compiler.
74
75=== Creating extensions
76
77An extension can be created by placing its code and some special
78files in a directory named after it. For example, if your
79extension is called {{foo}}, create a directory called {{foo}}
80and put the extension code in it.
81
82Extensions need two special files: an {{<extension name>.setup}}
83file and an {{<extension name>.meta}} file (where {{<extension
84name>}} is the name of your extension).  The former indicates how
85the egg is to be copiled and the latter provides some information
86about the extension (author, license, dependencies etc).  See the
87[[/eggs tutorial|eggs tutorial]] for further information about
88how to create extensions.
89
90
91=== Procedures and macros available in setup scripts
92
93==== install-extension
94
95<procedure>(install-extension ID FILELIST [INFOLIST])</procedure>
96
97Installs the extension library with the name {{ID}}. All files given in the list of strings
98{{FILELIST}} will be copied to the extension repository. It should be noted here that
99the extension id has to be identical to the name of the file implementing the extension. The
100extension may load or include other files, or may load other extensions at runtime specified
101by the {{require-at-runtime}} property.
102
103{{FILELIST}} may be a filename, a list of filenames, or a list of pairs of
104the form {{(SOURCE DEST)}} (if you want to copy into a particular sub-directory - the
105destination directory will be created as needed). If {{DEST}} is a relative pathname,
106it will be copied into the extension repository.
107
108The optional argument {{INFOLIST}} should be an association list that
109maps symbols to values, this list will be stored as {{ID.setup-info}} at the same
110location as the extension code. Currently the following properties are used:
111
112===== syntax
113
114 [extension property] (syntax)
115
116Marks the extension as syntax-only. No code is compiled, the extension is intended
117as a file containing macros to be loaded at compile/macro-expansion time.
118
119===== require-at-runtime
120
121 [extension property] (require-at-runtime ID ...)
122
123Specifies extensions that should be loaded (via {{require}}) at runtime. This is mostly
124useful for syntax extensions that need additional support code at runtime.
125
126===== import-only
127
128  [extension property] (import-only)
129
130Specifies that this extension only provides a expansion-time code in an import library and
131does not require code to be loaded at runtime.
132
133===== version
134
135 [extension property] (version STRING)
136
137Specifies version string.
138
139==== install-program
140
141<procedure>(install-program ID FILELIST [INFOLIST])</procedure>
142
143Similar to {{install-extension}}, but installs an executable program in the
144executable path (usually {{/usr/local/bin}}).
145
146==== install-script
147
148<procedure>(install-script ID FILELIST [INFOLIST])</procedure>
149
150Similar to {{install-program}}, but additionally changes the file permissions of all
151files in {{FILELIST}} to executable (for installing shell-scripts).
152
153==== standard-extension
154
155<procedure>(standard-extension ID [VERSION] #!key info)</procedure>
156
157A convenience procedure that combines the compilation and installation of
158a simple single-file extension. This is roughly equivalent to:
159
160  (compile -s -O2 -d1 ID.scm -j ID)
161  (compile -s -O2 -d0 ID.import.scm)
162 
163  (install-extension
164   'ID
165   '("ID.o" "ID.so" "ID.import.so")
166   '((version 1.0)
167     ... `INFO' ...
168     ))
169
170{{VERSION}} may be {{#f}} or can be omitted, in that case the version
171obtained from where the extension has been retrieved wil be taken. If
172installed directly from a local directory, the version will default to
173{{"unknown"}}.
174
175
176==== run
177
178<macro>(run FORM ...)</macro>
179
180Runs the shell command {{FORM}}, which is wrapped in an implicit {{quasiquote}}.
181{{(run (csc ...))}} is treated specially and passes {{-v}} (if {{-verbose}} has been given
182to {{chicken-install}}) and {{-feature compiling-extension}} options to the compiler.
183
184
185==== compile
186
187<macro>(compile FORM ...)</macro>
188
189Equivalent to {{(run (csc FORM ...))}}.
190
191
192==== make
193
194<macro>(make ((TARGET (DEPENDENT ...) COMMAND ...) ...) ARGUMENTS)</macro>
195
196A ''make'' macro that executes the expressions {{COMMAND ...}}, when any of the dependents
197{{DEPENDENT ...}} have changed, to build {{TARGET}}. This is the same as the {{make}}
198extension, which is available separately. For more information, see
199[[http://wiki.call-cc.org/egg/make|make]].
200
201
202==== patch
203
204<procedure>(patch WHICH REGEX SUBST)</procedure>
205
206Replaces all occurrences of the regular expression {{REGEX}} with the string {{SUBST}},
207in the file given in {{WHICH}}. If {{WHICH}} is a string, the file will be patched and
208overwritten. If {{WHICH}} is a list of the form {{OLD NEW}}, then a different file named
209{{NEW}} will be generated.
210
211==== copy-file
212
213<procedure>(copy-file FROM TO)</procedure>
214
215Copies the file or directory (recursively) given in the string {{FROM}} to the destination
216file or directory {{TO}}.
217
218==== move-file
219
220<procedure>(move-file FROM TO)</procedure>
221
222Moves the file or directory (recursively) given in the string {{FROM}} to the destination
223file or directory {{TO}}.
224
225==== remove-file*
226
227<procedure>(remove-file* PATH)</procedure>
228
229Removes the file or directory given in the string {{PATH}}, if it exists.
230
231
232==== find-library
233
234<procedure>(find-library NAME PROC)</procedure>
235
236Returns {{#t}} if the library named {{libNAME.[a|so]}} (unix) or {{NAME.lib}} (windows)
237could be found by compiling and linking a test program. {{PROC}} should be the name of a
238C function that must be provided by the library. If no such library was found or the function could not
239be resolved, {{#f}} is returned.
240
241==== find-header
242
243<procedure>(find-header NAME)</procedure>
244
245Returns {{#t}} if a C include-file with the given name is available, or {{#f}} otherwise.
246
247==== try-compile
248
249<procedure>(try-compile CODE #!key cc cflags ldflags compile-only c++)</procedure>
250
251Returns {{#t}} if the C code in {{CODE}} compiles and links successfully, or {{#f}} otherwise.
252The keyword parameters {{cc}} (compiler name, defaults to the C compiler used to build this system),
253{{cflags}} and {{ldflags}} accept additional compilation and
254linking options. If {{compile-only}} is true, then no linking step takes place.
255If the keyword argument {{c++}} is given and true, then the code will be compiled in C++ mode.
256
257
258==== create-directory/parents
259
260<procedure>(create-directory/parents PATH)</procedure>
261
262Creates the directory given in the string {{PATH}}, with all parent directories as needed.
263
264
265==== extension-name-and-version
266
267<parameter>extension-name-and-version</parameter>
268
269Returns a list containing the name and version of the currently installed
270extension as strings. If the setup script is not invoked via {{chicken-install}},
271then name and version will be empty.
272
273
274==== version>=?
275
276<procedure>(version>=? V1 V2)</procedure>
277
278Compares the version numbers {{V1}} and {{V2}} and returns {{#t}} if
279{{V1}} is "less" than {{V2}} or {{#f}} otherwise. A version number can
280be an integer, a floating-point number or a string. {{version>=?}}
281handles dot-separated version-indicators of the form {{"X.Y. .."}}.
282
283If one version number is the prefix of the other, then the shorter version
284is considered "less" than the longer.
285
286
287==== installation-prefix
288
289<procedure>(installation-prefix)</procedure>
290
291An alternative installation prefix that will be prepended to extension
292installation paths if specified. It is set by the {{-prefix}}
293option or environment variable {{CHICKEN_INSTALL_PREFIX}}.
294
295
296==== program-path
297
298<parameter>(program-path [PATH])</parameter>
299
300Holds the path where executables are installed and defaults to either {{$CHICKEN_PREFIX/bin}},
301if the environment variable {{CHICKEN_PREFIX}} is set or the
302path where the CHICKEN binaries ({{chicken}}, {{csi}}, etc.) are installed.
303
304
305==== setup-root-directory
306
307<parameter>(setup-root-directory [PATH])</parameter>
308
309Contains the path of the directory where {{chicken-install}} was invoked.
310
311
312==== setup-install-mode
313
314<parameter>(setup-install-mode [BOOL])</parameter>
315
316Reflects the setting of the {{-no-install}} option, i.e. is {{#f}}, if {{-no-install}} was
317given to {{chicken-install}}.
318
319==== host-extension
320
321<parameter>host-extension</parameter>
322
323For a cross-compiling CHICKEN, when compiling an extension, then it
324should be built for the host environment (as opposed to the target
325environment). This parameter is controlled by the {{-host}} command-line
326option. A setup script should perform the proper steps of compiling any
327code by passing {{-host}} when invoking {{csc}} or using the {{compile}}
328macro.
329
330
331=== Examples for extensions
332
333==== A simple library
334
335The simplest case is a single file that does not export any syntax. For example
336
337<enscript highlight=scheme>
338;;;; hello.scm
339
340(define (hello name)
341  (print "Hello, " name " !") )
342</enscript>
343
344We need a {{.setup}} script to build and install our nifty extension:
345
346<enscript highlight=scheme>
347;;;; hello.setup
348
349;; compile the code into a dynamically loadable shared object
350;; (will generate hello.so)
351(compile -s hello.scm)
352
353;; Install as extension library
354(install-extension 'hello "hello.so")
355</enscript>
356
357Lastly, we need a file {{hello.meta}} defining a minimal set of properties:
358
359<enscript highlight=scheme>
360;;;; hello.meta
361
362((author "Me")
363 (synopsis "A cool hello-world library")
364 (license "GPLv3")
365 (files "hello.scm" "hello.setup"))
366</enscript>
367
368(for more information about available properties, see
369[[/Metafile reference|the metafile reference]])
370
371After entering
372
373 $ chicken-install
374
375at the shell prompt (and in the same directory where the two files
376exist), the file {{hello.scm}} will be compiled into a dynamically
377loadable library. If the compilation succeeds, {{hello.so}} will
378be stored in the repository, together with a file named
379{{hello.setup-info}} containing an a-list with metadata (what
380you stored above in {{hello.meta}}).
381If no extension name is given to {{chicken-install}}, it will simply
382execute the any files with the {{.setup}} extension it can find.
383
384Use it like any other CHICKEN extension:
385
386 $ csi -q
387 #;1> (require-library hello)
388 ; loading /usr/local/lib/chicken/4/hello.so ...
389 #;2> (hello "me")
390 Hello, me!
391 #;3>
392
393==== An application
394
395Here we create a simple application:
396
397<enscript highlight=scheme>
398;;;; hello2.scm
399
400(print "Hello, ")
401(for-each (lambda (x) (printf "~A " x)) (command-line-arguments))
402(print "!")
403</enscript>
404
405We also need a setup script:
406
407<enscript highlight=scheme>
408;;;; hello2.setup
409
410(compile hello2.scm)  ; compile `hello2'
411(install-program 'hello2 "hello2") ; name of the extension and files to be installed
412</enscript>
413
414<enscript highlight=scheme>
415;;;; hello2.meta
416
417((author "Me")
418 (synopsis "A cool hello-world application")
419 (license "proprietary")
420 (files "hello.scm" "hello.setup"))
421</enscript>
422
423To use it, just run {{chicken-install}} in the same directory:
424
425 $ chicken-install
426
427(Here we omit the extension name)
428
429Now the program {{hello2}} will be installed in the same location as
430the other CHICKEN tools (like {{chicken}}, {{csi}}, etc.), which will
431normally be {{/usr/local/bin}}.  Note that you need write-permissions
432for those locations and may have to run {{chicken-install}} with
433administrative rights or use the {{-sudo}} option.
434
435The extension can be used from the command line:
436
437 $ hello2 one two three
438 Hello,
439 one two three !
440
441De-installation is just as easy - use the {{chicken-uninstall}}
442program to remove one or more extensions from the local repository:
443
444 $ chicken-uninstall hello2
445
446==== A module exporting syntax
447
448The hello module was just a shared library, and not a module.
449
450To create an extension that exports syntax see the chapter on
451[[http://wiki.call-cc.org/man/4/Modules%20and%20macros|Modules and
452macros]].  We will show a simple example here: a module {{my-lib}}
453that exports one macro ({{prog1}}) and one procedure ({{my-sum}}):
454
455<enscript highlight=scheme>
456;;; my-lib.scm
457
458(module my-lib
459  *
460  (import scheme chicken)
461
462(define-syntax prog1
463  (syntax-rules ()
464    ((_ e1 e2 ...)
465     (let ((result e1))
466       (begin e2 ...)
467       result))))
468
469(define my-sum
470  (lambda (numbers)
471    (prog1
472      (apply + numbers)
473      (display "my-sum used one more time!")
474      (newline))))
475
476)
477</enscript>
478
479The {{prog1}} macro is similar to Common Lisp's {{prog1}}: it
480evaluates a list of forms, but returns the value of the first form.
481
482The meta file:
483
484<enscript highlight=scheme>
485;;; my-lib.meta
486
487((files "my-lib.setup"
488        "my-lib.scm")
489 (licence "BSD")
490 (author "Me again")
491 (synopsis "My own cool libraries"))
492</enscript>
493
494The setup file is:
495
496<enscript highlight=scheme>
497;;; my-lib.setup
498
499(compile -s -O3 -d1 "my-lib.scm" -j my-lib)
500(compile -s -O3 -d0 "my-lib.import.scm")
501
502(install-extension
503 'my-lib
504 '("my-lib.o" "my-lib.so" "my-lib.import.so")
505 '((version 1.0)))
506</enscript>
507
508The first line tells the compiler to create a shared ({{-s}}) library
509and to create an import file ({{my-lib.import.scm}}, because of the
510{{-j}} flag).  The second line compiles the import file created by the
511first one.
512
513IMPORTANT: the module name exported by my-lib.scm must be the same
514module name passed to the compiler using the -j option, otherwise the
515imports file will not be generated!
516
517Running {{chicken-install}} on the same directory will install the extension.
518
519Next, it should be possible to load the library:
520
521 $ csi -q
522 #;1> (use my-lib)
523 ; loading /usr/local/lib/chicken/6/my-lib.import.so ...
524 ; loading /usr/local/lib/chicken/6/scheme.import.so ...
525 ; loading /usr/local/lib/chicken/6/chicken.import.so ...
526 ; loading /usr/local/lib/chicken/6/my-lib.so ...
527 #;2> (my-sum '(10 20 30))
528 my-sum used one more time!
529 60
530 #;3> (my-sum '(-1 1 0))
531 my-sum used one more time!
532 0
533 #;4> (prog1 (+ 2 2) (print "---"))
534 ---
535 4
536
537==== Notes on chicken-install
538
539When running {{chicken-install}} with an argument {{NAME}}, for which
540no associated {{.setup}} file exists, then it will try to download the
541extension via HTTP from the CHICKEN code repository at
542[[http://code.call-cc.org/svn/chicken-eggs/]]. Extensions that are
543required to compile and/or use the requested extension are downloaded
544and installed automatically.
545
546To query the list of currently installed extensions, use
547{{chicken-status}}. It can list what extensions are installed and
548what files belong to a particular installed extension.
549
550
551=== chicken-install reference
552
553Available options:
554
555; {{-h   -help}} : show this message and exit
556; {{-v   -version}} : show version and exit
557; {{-force}} : don't ask, install even if versions don't match
558; {{-k   -keep}} : keep temporary files
559; {{-l   -location LOCATION}} : install from given location instead of default
560; {{-t   -transport TRANSPORT}} : use given transport instead of default
561; {{-proxy HOST[:PORT]}} : connect via HTTP proxy
562; {{-s   -sudo}} : use {{sudo(1)}} for installing or removing files
563; {{-r   -retrieve}} : only retrieve egg into current directory, don't install
564; {{-n   -no-install}} : do not install, just build (implies {{-keep}})
565; {{-p   -prefix PREFIX}} : change installation prefix to {{PREFIX}}
566; {{-host}} : when cross-compiling, compile extension for host only
567; {{-target}} : when cross-compiling, compile extension for target only
568; {{-test}} : run included test-cases, if available
569; {{-username USER}} : set username for transports that require this
570; {{-password PASS}} : set password for transports that require this
571; {{-i   -init DIRECTORY}} : initialize empty alternative repository
572; {{-u   -update-db}} : update export database
573; {{-repository}} : print path to extension repository
574; {{-deploy}} : install extension in the application directory for a deployed application (see [[Deployment]] for more information)
575; {{-trunk}} : build trunk instead of tagged version (only local)
576; {{-D   -feature FEATURE}} : pass this on to subinvocations of {{csi}} and {{csc}} (when done via {{compile}} or {{(run (csc ...))}})
577; {{-debug}} : print full call-trace when encountering errors in the setup script
578; {{-keep-going}} : continue installation, even if a dependency fails
579; {{-show-foreign-depends}} :  display a list of foreign dependencies for the given egg(s)
580
581{{chicken-install}} recognizes the {{http_proxy}} environment variable, if set.
582
583
584=== chicken-uninstall reference
585
586; {{-h   -help}} : show usage information and exit
587; {{-v   -version}} : show version and exit
588; {{-force}} : don't ask, delete whatever matches
589; {{-s   -sudo}} : use {{sudo(1)}} for deleting files
590; {{-host}} : when cross-compiling, remove extensions for host system only
591; {{-target}} : when cross-compiling, remove extensions for target system only
592; {{-exact}} : match extension-name exactly (do not match as pattern)
593
594=== chicken-status reference
595
596; {{-h   -help}} : show usage information and exit
597; {{-v   -version}} : show version and exit
598; {{-f   -files}} : list installed files
599; {{-host}} : when cross-compiling, show extensions for host system only
600; {{-target}} : when cross-compiling, show extensions for target system only
601; {{-exact}} : match extension-name exactly (do not match as pattern)
602
603
604=== Security
605
606When extensions are downloaded and installed one is executing code
607from potentially compromised systems. This applies also when
608{{chicken-install}} executes system tests for required extensions. As
609the code has been retrieved over the network effectively untrusted
610code is going to be evaluated. When {{chicken-install}} is run as
611''root'' the whole system is at the mercy of the build instructions
612(note that this is also the case every time you install software via
613{{sudo make install}}, so this is not specific to the CHICKEN
614extension mechanism).
615
616Security-conscious users should never run {{chicken-install}} as root.
617A simple remedy is to keep the repository inside a user's home
618directory (see the section "Changing repository location" below).
619Alternatively obtain write/execute access to the default location of the repository
620(usually {{/usr/local/lib/chicken}}) to avoid running as
621root. {{chicken-install}} also provides a {{-sudo}} option to perform
622the last installation steps as root user, but do building and other
623.setup script processing as normal. A third solution is to
624override {{VARDIR}} when building the system
625(for example by passing {{"VARDIR=/foo/bar"}} on the make command line,
626or by modifying {{config.make}}. Eggs will then be installed in
627{{$(VARDIR)/chicken/5}}.
628
629=== Changing repository location
630
631When Chicken is installed a repository for eggs is created and initialized
632in a default location (usually something like {{/usr/local/lib/chicken/6/}}).
633It is possible to keep an eggs repository in another location. This can be
634configured at build-time by passing {{VARDIR=<directory>}} to {{make(3)}}
635or by modifying the {{config.make}} configuration file. If you want to
636override this location after chicken is installed, you can create an
637initial repository directory with some default extensions and set the
638{{CHICKEN_REPOSITORY}} environment variable:
639
640Note that your binary version can differ from the examples here, if your
641chicken version is older or newer than the one used in these examples.
642Check your default location for the correct binary-version number.
643
644First, initialize the new repository with
645
646  mkdir -p ~/myeggs/lib/chicken/6               # to create directory structure
647  chicken-install -init ~/myeggs/lib/chicken/6
648
649Then set this environment variable:
650
651  export CHICKEN_REPOSITORY=~/myeggs/lib/chicken/6
652
653{{CHICKEN_REPOSITORY}} is the place where extensions are to be
654loaded from for all chicken-based programs (which includes all
655the tools).
656
657If you want to install eggs somewhere other than the default or
658your environment variable, you can use
659
660  chicken-install -p ~/myeggs <package>
661
662See that the argument to chicken-install is just {{~/myeggs}}, while everywhere else it's
663{{~/myeggs/lib/chicken/5}}.
664
665When you load eggs from the interpreter, you will see messages showing
666where libraries are being loaded from:
667
668 #;1> (use numbers)
669 ; loading /home/jdoe/myeggs/lib/chicken/6/numbers.import.so ...
670 ; loading /home/jdoe/myeggs/lib/chicken/6/scheme.import.so ...
671 ; loading /home/jdoe/myeggs/lib/chicken/6/chicken.import.so ...
672 ; loading /home/jdoe/myeggs/lib/chicken/6/foreign.import.so ...
673 ; loading /home/jdoe/myeggs/lib/chicken/6/regex.import.so ...
674 ; loading /home/jdoe/myeggs/lib/chicken/6/numbers.so ...
675 #;2>
676
677==== Upgrading
678
679After a main upgrade, you need to reinstall all the eggs. First,
680reset the repository environment variable:
681
682  export CHICKEN_REPOSITORY=/usr/lib/chicken/6
683
684Then, make a new directory that reflects the systematic one:
685
686  mkdir ~/myeggs/lib/chicken/6
687
688After that, do the same steps above for the new directory (initialize, set repository environment variable)
689and reinstall all the eggs.
690
691=== Other modes of installation
692
693It is possible to install extensions directly from a
694[[http://subversion.apache.org/|Subversion]] repository or from a local
695checkout of the repository tree by using the {{-transport}} and
696{{-location}} options when invoking {{chicken-install}}. Three possible
697transport mechanisms are currently supported:
698
699; {{http}} : download extension sources via HTTP from a web-server (this is the default)
700; {{svn}} : perform an {{svn export}} from the central extension repository; this will require a {{svn(1)}} client to be installed on the machine
701; {{local}} : use sources from the local filesystem and build directly in the source directory
702
703The {{-location}} option specifies where to look for the source
704repository and names a web URL, a subversion repository URL or a
705filesystem path, respectively. A list of locations to try when
706retrieving extensions is stored in the file {{setup.defaults}}
707(usually installed in {{/usr/local/share/chicken}}). For {{http}}
708transports, {{chicken-install}} will detect networking timeouts and
709try alternative locations, as listed in the file.
710
711Dependency information, which is necessary to ensure required
712extensions are also installed, is processed automatically.
713
714
715---
716Previous: [[Interface to external functions and variables]]
717
718Next: [[Deployment]]
Note: See TracBrowser for help on using the repository browser.