source: trunk/source/doc/src/install.xml @ 8606

Last change on this file since 8606 was 8606, checked in by gb, 14 years ago

Rename chapter-level files to not include chapter numbers (so that it'd be
less confusing to change chapter order, remove/introduce chapters, etc.)

Ensure that all chapter-level files have ENTITY definitions in their
DOCTYPE forms.

Define a CCL entity (currently just <literal>CCL</literal>; change all
references to "OpenMCL" to "&CCL;"

File size: 27.0 KB
1<?xml version="1.0" encoding="utf-8"?>
2<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
4<!ENTITY rest "<varname>&amp;rest</varname>">
5<!ENTITY key "<varname>&amp;key</varname>">
6<!ENTITY optional "<varname>&amp;optional</varname>">
7<!ENTITY body "<varname>&amp;body</varname>">
8<!ENTITY aux "<varname>&amp;aux</varname>">
9<!ENTITY allow-other-keys "<varname>&amp;allow-other-keys</varname>">
10<!ENTITY CCL "<literal>CCL</literal>">
13 <chapter><title>Obtaining, Installing, and Running &CCL;</title>
15  <sect1><title>Releases and System Requirements</title>
17   <para>There are three active versions of &CCL;.  Version 1.0 was
18   a stable release (released in late 2005); it is no longer under
19   active development.  Version 1.1 has been under active development
20   since shortly after 1.0 was released; it's been distributed as a
21   series of development "snapshots" and CVS updates.  1.1 snapshots
22   have introduced support for x86-64 platforms, internal use of
23   Unicode, and many other features, but have presented something of a
24   moving target.  Version 1.2 (being released in early 2008) is
25   intended to both a more stable and predictable release schedule and
26   to make it a bit easier for users who wish to track the "bleeding
27   edge" of development to do so.</para>
29      <para>Version 1.0 is available for three platform configurations:</para>
30      <itemizedlist>
31        <listitem>
32          <para>Linux on PowerPC (32-bit implementation)</para>
33        </listitem>
34        <listitem>
35          <para>Mac OS X on PowerPC (32-bit implementation)</para>
36        </listitem>
37        <listitem>
38          <para>Mac OS X on PowerPC (64-bit implementation)</para>
39        </listitem>
40      </itemizedlist>
42      <para>Versions 1.1 and 1.2 are available for five platform
43      configurations:</para>
44      <itemizedlist>
45        <listitem>
46          <para>Linux on PowerPC (32-bit and 64-bit implementations)</para>
47        </listitem>
48        <listitem>
49          <para>>Mac OS X on PowerPC (32-bit and 64-bit implementations)</para>
50        </listitem>
51        <listitem>
52          <para>Linux on X86-64 (64-bit implementation)</para>
53        </listitem>
54        <listitem>
55          <para>Mac OS X on X86-64 (64-bit implementation)</para>
56        </listitem>
57        <listitem><para>FreeBSD on X86-64 (64-bit implementation)</para></listitem>
58      </itemizedlist>
60      <para>A 64-bit version of &CCL; requires a 64-bit processor
61      (obviously) running a 64-bit OS variant.</para>
63      <para>There are ongoing efforts to port &CCL; to the Windows
64      operating system and 32-bit x86 processors.</para>
67      <para>Additional platform-specific information is given in the
68      following subsections.</para>
70      <sect2><title>LinuxPPC</title> 
72        <para>&CCL; versions 1.0 and later run under relatively
73        recent versions of LinuxPPC. All versions of &CCL; require
74        version 2.2.13 (or later) of the Linux kernel and version
75        2.1.3 (or later) of the GNU C library (glibc) at a bare
76        minimum.</para>
77      </sect2>
79      <sect2><title>LinuxX8664</title> 
81        <para>Version 1.1 and later of &CCL; runs on relatively
82        recent Linux distributions for the x86-64 architecture.  It
83        requires a Linux with Thread Local Storage support in the
84        toolchain and standard libraries, and the New Posix Thread
85        Library (NPTL).  Fortunately, these features seem to be
86        present in all current Linux distributions for x86-64, though
87        there may be some problems with early Linux distributions for
88        x86-64.  (Some GCC versions older than 4.0 on Linux have been
89        known to have problems compiling some of the C code in the
90        kernel, some very old Linux distributions don't follow the
91        current ABI standards wrt segment register usage, some early
92        Linux kernels for x86-64 had problems mapping large regions of
93        the address space ... it's difficult to enumerate exactly what
94        versions of what Linux distributions have what problems.  A
95        rule of thumb is that - since much of the development of
96        &CCL; for x86-64 took place in that time frame - Linux
97        distributions released earlier than early 2006 may have
98        problems running &CCL;.) </para>
99      </sect2>
101      <sect2><title>FreeBSD-amd64</title>
102        <para>Versions 1.1 and later of &CCL; runs on FreeBSD on
103        x86-64 (FreeBSD releases generally call the platform "and64")
104        &CCL; should run under FreeBSD 6.0 or later; as of this
105        writing, FreeBSD 7.0 is about to be released and it may be
106        necessary for FreeBSD 7 users to install the "compat6x"
107        package in order to use a version of &CCL; built on FreeBSD
108        6.x under FreeBSD 7.  .</para>
109      </sect2>
111      <sect2><title>DarwinPPC-MacOS-X</title>
113        <para> &CCL; 1.0 runs on MacOS X versions 10.2, 10.3 and
114        10.4 on the PowerPC.</para>
116        <para>Current development on version 1.1 and later takes place
117        under OS X versions 10.4 and 10.5 and requires at least
118        version 10.3.9</para>
120        <para>The 64-bit DarwinPPC version of &CCL; requires
121        functionality introduced in OSX 10.4 (namely, the ability to
122        run 64-bit binaries).  It also, obviously, requires a G5
123        processor.</para>
125        <para>&CCL; hasn't been tested under Darwin proper, but
126        &CCL; doesn't intentionally use any MacOS X features beyond
127        the Darwin subset and therefore it seems likely that &CCL;
128        would run on PPC Darwin versions that correspond to recent OSX
129        versions.</para>
130      </sect2>
132      <sect2><title>Darwinx8664-MacOS-X</title>
133        <para>Versions 1.1 and later of &CCL; runs on 64-bit
134        DarwinX86 (MacOS on Intel).</para>
136        <para>&CCL; Darwinx8664/MacOS X requires a 64-bit processor.
137        All Macintoshes currently sold by Apple (as of early 2008) and
138        all Macintoshes introduced by Apple since August 2006 have
139        such processors.  However, the original MacBooks, MacBook Pros
140        and Intel iMacs (models introduced in early 2006) used 32-bit
141        Core Duo processors, and so &CCL; will not (yet) run on
142        them.</para>
144      </sect2>
145    </sect1>
147    <sect1><title>Installation</title>
148      <para>Installing &CCL; consists of</para>
149      <orderedlist> 
150        <listitem>
151          <para>Downloading an appropriate distribution of &CCL;;</para>
152        </listitem>
153        <listitem>
154          <para>If necessary, extracting the archive somewhere on your
155          computer;</para>
156        </listitem>
157        <listitem>
158          <para>Configuring a shell script so &CCL; can locate
159          necessary library files and other auxilliary files.</para>
160        </listitem>
161      </orderedlist>
163      <sect2><title>Downloading and untarring &CCL; binary source
164      releases</title> <para> &CCL; releases and snapshots are
165      distributed as tarballs (compressed tar archives).</para>
167      <para>Tarballs of version 1.0 for supported platforms are
168      available from the download page of the &CCL; website.</para>
170      <para>Tarballs of the latest development snapshots of version
171      1.1, along with release notes, are available from the testing
172      directory on</para>
173      <para>Both the release and snapshot archives contain a directory
174      named <literal>ccl</literal>, which in turn contains a number of
175      files and subdirectories.  The <literal>ccl</literal> directory
176      can reside anywhere in the filesystem, assuming appropriate
177      permissions. If you wanted the <literal>ccl</literal> directory
178      to reside in <literal>``~/openmcl/ccl''</literal> and the
179      directory <literal>``~/openmcl/''</literal> already existed, you
180      could do anything equivalent to:</para>
181      <programlisting>
182shell&gt; cd ~/openmcl
183shell&gt; tar xvzf <emphasis>path-to-downloaded-openmcl-archive.tar.gz</emphasis>
184      </programlisting>
185      <para><emphasis>Important Note for Macintosh Users:</emphasis>
186      Double-clicking the archive in the Finder may work, but it also
187      may have unintended side-effects.  In some versions of the Mac
188      OS double-clicking an archive will invoke Stuffit, which may try
189      to replace linefeeds with carriage returns as it extracts
190      files. Also, tar can be used to merge the archive contents into
191      an existing <literal>ccl</literal> directory, whereas
192      double-clicking in the Finder will create a new directory named
193      <literal>ccl 2</literal> (or <literal>ccl 3</literal>, or...)
194      Bottom line is that you're better off using tar from the
195      shell.</para>
197      <para>Once the <literal>ccl</literal> directory is installed,
198      it's necessary to install and configure a shell script
199      distributed with &CCL; before using it.</para>
200      </sect2>
202      <sect2><title>The-openmcl-Shell-Script"</title>
203      <para>&CCL; needs to be able to find the
204      <literal>ccl</literal> directory in order to support features
205      such as <literal>require</literal> and
206      <literal>provide</literal>, access to foreign interface
207      information (see ) and the lisp build process (see
208      ). Specifically, it needs to set up logical pathname
209      translations for the <literal>"ccl:"</literal> logical host.  If
210      this logical host isn't defined (or isn't defined correctly),
211      some things might work, some things might not... and it'll
212      generally be hard to invoke and use &CCL; productively.</para>
214        <para>&CCL; uses the value of the environment variable
215        <literal>CCL_DEFAULT_DIRECTORY</literal> to determine the
216        filesystem location of the <literal>ccl</literal> directory;
217        the openmcl shell script is intended to provide a way to
218        invoke &CCL; with that environment variable set
219        correctly.</para>
220        <para>There are two versions of the shell script:
221        <literal>"ccl/scripts/openmcl"</literal> is used to invoke
222        32-bit implementations of &CCL; and
223        <literal>"ccl/scripts/openmcl64"</literal> is used to invoke
224        64-bit implementations.</para>
225        <para>To use the script:</para>
226        <orderedlist>
227          <listitem>
228            <para>Edit the definition of
229            <literal>CCL_DEFAULT_DIRECTORY</literal> near the
230            beginning of theshell script so that it refers to your ccl
231            directory.  Alternately,set
232            <literal>CCL_DEFAULT_DIRECTORY</literal> in your .cshrc,
233            .tcshrc, .bashrc,.bash_profile, .MacOSX/environment.plist,
234            or wherever you usually set environment variables.  If
235            there is an existing definition of thevariable, the
236            openmcl script will not override it.The shell script sets
237            a local variable (<literal>OPENMCL_KERNEL</literal>) to
238            the standard name of the &CCL; kernel approprate for the
239            platform (asdetermined by 'uname -s'.) You might prefer to
240            set this variable manually in the shell script</para>
241          </listitem>
243          <listitem>
244            <para>Ensure that the shell script is executable, for
245            example:<literal>$ chmod +x
246            ~/openmcl/ccl/scripts/openmcl64</literal>This command
247            grants execute permission to the named script. If you
248            areusing a 32-bit platform, substitute "openmcl" in place
249            of "openmcl64".
250            <warning>
251              <para>The above command won't work if you are not the
252              owner of the installed copy of &CCL;. In that case,
253              you can use the "sudo" command like this:</para>
254              <para><literal>$ sudo chmod +x
255              ~/openmcl/ccl/scripts/openmcl64</literal></para>
256              <para>Give your password when prompted.</para>
257              <para>If the "sudo" command doesn't work, then you are
258              not an administrator on the system you're using, and you
259              don't have the appropriate "sudo" permissions. In that
260              case you'll need to get help from the system's
261              administrator.</para>
262            </warning></para>
263          </listitem>
264          <listitem>
265            <para>Install the shell script somewhere on your shell's
266            search path</para>
267          </listitem>
268        </orderedlist>
270        <para>Once this is done, it should be possible to invoke
271        &CCL; by typing <literal>openmcl</literal> at a shell
272        prompt:</para>
273        <programlisting>
274&gt; openmcl [args ...]
275Welcome to &CCL; Version whatever (DarwinPPC32)!
278        <para>The openmcl shell script will pass all of its arguments
279        to the &CCL; kernel.  See <xref linkend="Invocation"/> for
280        more information about "args".  When invoked this way, the
281        lisp should be able to initialize the
282        <literal>"ccl:"</literal> logical host so that its
283        translations refer to the <literal>"ccl"</literal>
284        directory. To test this, you can call
285        <literal>probe-file</literal> in &CCL;'s read-eval-print
286        loop:</para>
287        <programlisting>
288? (probe-file "ccl:level-1;level-1.lisp")  ;will return the physical pathname of the file
291      </sect2>
292      <sect2 id="Invocation">
293        <title>Invocation</title>
294        <para>Assuming that the shell script is properly installed, it can be used to invoke &CCL; from a shell prompt:
295        <programlisting>
296shell&gt;<replaceable>ccl</replaceable> <emphasis>args</emphasis>
297        </programlisting>
298        <literal>ccl</literal> will run a 32-bit session;
299        <literal>ccl64</literal> will run a 64-bit session.
300        </para>
301      </sect2>
302      <sect2 id="Personal-Customization-with-the-Init-File">
303        <title>Personal Customization with the Init File</title>
304        <para>By default &CCL; will try to load the file
305        <literal>"home:openmcl-init.lisp"</literal> or the compiled
307        <literal>"home:openmcl-init.fasl"</literal> upon starting
308        up. It does this by executing <literal>(load
309        "home:openmcl-init")</literal>.  If it is unable to load the
310        file (for example because it does not exist) no action is
311        taken; an error is not signalled.</para>
312        <para>The <literal>"home:"</literal> prefix to the filename is
313        a Common Lisp logical host, which &CCL; initializes to refer
314        to your home directory, so this looks for either of the files
315        <literal>~/openmcl-init.lisp</literal> or
316        <literal>~/openmcl-init.fasl</literal>.</para>
317        <para>Since the init file is loaded the same way as normal
318        Lisp code is, you can put anything you want in it.  For
319        example, you can change the working directory, and load
320        packages which you use frequently.</para>
321        <para>To suppress the loading of this init-file, invoke &CCL; with the
322<literal>--no-init</literal> option.</para>
323      </sect2>
325      <sect2 id="Some--hopefully--useful-options">
326        <title>Some (hopefully) useful options</title>
327        <para> The exact set of command-line arguments accepted by
328        &CCL; may vary slightly from release to release;
329        <literal>openmcl --help</literal> will provide a definitive
330        (if somewhat terse) summary of the options accepted by the
331        current implementation and then exit. Some of those options
332        are described below.</para>
333        <itemizedlist>
334          <listitem>
335            <para>-S (or --stack-size). Specify the size of the initial process
336            stack.</para>
337          </listitem>
339          <listitem>
340            <para>-b (or --batch). Execute in &#34;batch mode&#34;. End-of-file
341            from *STANDARD-INPUT* will cause &CCL; to exit, as will attempts to
342            enter a break loop.</para>
343          </listitem>
345          <listitem>
346            <para>-n (or --no-init). If this option is given, the init file
347            is not loaded.  This is useful if &CCL; is being invoked by a
348            shell script which should not be affected by whatever
349            customizations a user might have in place.
350            </para>
351          </listitem>
353          <listitem>
354            <para>-e &#60;form&#62; (or --eval &#60;form&#62;). An expression is
355            read (via READ-FROM-STRING from the string &#60;form&#62; and
356            evaluated. If &#60;form&#62; contains shell metacharacters, it may be
357            necessary to escape or quote them to prevent the shell from
358            interpreting them.</para>
359          </listitem>
361          <listitem>
362            <para>-l &#62;path&#62; (or --load &#60;path&#62;). Executes (load
363            &#34;&#60;path&#62;&#34;).</para>
364          </listitem>
365        </itemizedlist>
367        <para>The <literal>--load</literal> and
368        <literal>--eval</literal> options can each be provided
369        multiple times.  They're executed in the order specified on
370        the command line, after the init file (if there is one) is
371        loaded and before the toplevel read-eval-print loop is
372        entered.</para>
373      </sect2>
374    </sect1>
376    <sect1 id="Using-&CCL;-with-GNU-Emacs-and-SLIME">
377      <title>Using &CCL; with GNU Emacs and SLIME</title>
378      <para>A very common way to use &CCL; is to run it within the
379      GNU Emacs editor, using a Lisp interface called SLIME ("Superior
380      Lisp Interaction Mode for Emacs"). SLIME is an Emacs package
381      designed to provide good support within Emacs for any of several
382      Common Lisp implementations; one of the supported
383      implementations is &CCL;. This page describes how you can
384      download SLIME and set it up to work with your &CCL;
385      installation.</para>
386      <para>Why use SLIME? With SLIME, you can do the following things from within
387an Emacs editing session:</para>
388      <itemizedlist>
389        <listitem><para>run and control Lisp</para></listitem>
390        <listitem><para>evaluate, compile, and load files or expressions</para></listitem>
391        <listitem><para>macroexpand expressions</para></listitem>
392        <listitem><para>fetch documentation and source code for Lisp symbols</para></listitem>
393        <listitem><para>autocomplete symbols and package names</para></listitem>
394        <listitem><para>cross-reference function calls</para></listitem>
395        <listitem><para>examine stack traces and debug errors</para></listitem>
397      </itemizedlist>
398      <para>There is an excellent SLIME tutorial video available at  For
400complete information about SLIME, see the
401SLIME home page.</para>
403      <sect2 id="Assumptions-and-Requirements">
404        <title>Assumptions and Requirements</title>
405        <para>In order to simplify these instructions, we'll make
406        several assumptions about your system. Specifically, we
407        assume:</para>
408        <itemizedlist>
409          <listitem>
410            <para>You have a working installation of GNU Emacs. If you
411            don't have a working copy of GNU Emacs, see the web page on
412            obtaining Emacs.  If you prefer to use XEmacs instead of
413            GNU Emacs,these instructions should still work; SLIME
414            supports XEmacs Version21. Mac OS X includes an Emacs
415            installation.  If you want to look into different versions,
416            you can check out theEmacsWiki, whichmaintains a
417            page,EmacsForMacOS,that provides much more information
418            about using Emacs on the Mac.
419            <warning>
420              <para>A popular version of Emacs among Mac users is
421              Aquamacs. This application is a version of GNU Emacs
422              with a number of customizations meant to make it behave
423              more like a standard Maciontosh application, with
424              windows, a menubar, etc.  Aquamacs includes SLIME; if
425              you like Aquamacs then you can use SLIME right away,
426              without getting and installing it separately. You just
427              need to tell SLIME where to find your installation of
428              &CCL;. (See FIXTHIS.)</para>
429            </warning>
430          </para>
431          </listitem>
432          <listitem>
433            <para>You have a working copy of &CCL;, installed in
434            <literal>"~/openmcl/ccl"</literal>If you prefer to install
435            &CCL; in some directory other
436            than<literal>"~/openmcl/ccl"</literal> then these
437            instructions still work, but you must remember to use your
438            path to your ccl directory instead of theone that we give
439            here.</para>
440          </listitem>
441          <listitem>
442            <para>You install emacs add-ons in the folder
443            <literal>"~/emacs/site/"</literal>If this directory
444            doesn't exist on your system, you can just create it.If
445            you prefer to install Emacs add-ons in some place other
446            than<literal>"~/emacs/site/"</literal> then you must
447            remember to use your path toEmacs add-ons in place of
448            ours.</para>
449          </listitem>
451        </itemizedlist>
452      </sect2>
454      <sect2 id="Getting_Slime"><title>Getting SLIME</title>       
456        <para>You can get SLIME from the SLIME Home Page. Stable
457        releases and CVS snapshots are available as archive files, or
458        you can follow the instructions on the SLIME Home Page to
459        check out the latest version from their CVS repository.</para>
461        <para>It's worth noting that stable SLIME releases happen very
462        seldom, but the SLIME developers often make changes and
463        improvements that are available through CVS updates. If you
464        asked the SLIM developers, they would most likely recommend
465        that you get SLIME from their CVS repository and update it
466        frequently.</para>
468        <para>Whether you get it from CVS, or download and unpack one
469        of the available archives, you should end up with a folder
470        named "slime" that contains the SLIME distribution.</para>
471      </sect2>
473      <sect2><title>Installing SLIME</title> 
475        <para>Once you have the "slime" folder described in the
476        previous section,installation is a simple matter of copying
477        the folder to the proper place. You can drag it into the
478        "~/emacs/site/" folder, or you can use a terminal command to
479        copy it there. For example, assuming your working directory
480        contains the unpacked "slime" folder:</para> <para><literal>$
481        cp -R slime ~/emacs/site/</literal></para> <para>That's all it
482        takes.</para>
484      </sect2>
486      <sect2 id="Telling-Emacs-About-SLIME">
487        <title>Telling Emacs About SLIME</title>
488        <para> Once SLIME and &CCL; are installed, you just need to
489        add a line to your "~/.emacs" file that tells SLIME where to
490        find the script that runs &CCL;:</para>
491        <para><literal>(setq inferior-lisp-program "~/openmcl/ccl/scripts/openmcl64")</literal></para>
492        <para>or</para>
493        <para><literal>(setq inferior-lisp-program "~/openmcl/ccl/scripts/openmcl")</literal></para>
494        <warning>
495          <para>Aquamacs users should add this line to the file "~/Library/Preferences/Aquamacs Emacs/Preferences.el".</para>
496        </warning>
497      </sect2>
499      <sect2 id="Running-&CCL;-with-SLIME">
500        <title>Running &CCL; with SLIME</title>
501        <para>Once the preparations in the previous section are
502        complete, exit Emacs and restart it, to ensure that it reads
503        the changes you made in your ".emacs" file (alternatively, you
504        could tell Emacs to reload the ".emacs" file). If all went
505        well, you should now be ready to run &CCL; using
506        SLIME.</para>
507        <para>To run &CCL;, execute the command "M-x slime". SLIME
508        should start an &CCL; session in a new buffer.  (If you are
509        unfamiliar with the Emacs notation "M-x command", see the GNU
510        Emacs FAQ; specifically, take a look at questions 1, 2, and
511        128.)</para>
512      </sect2>
514      <sect2 id="What-if-a-New-Version-of-&CCL;-Breaks-SLIME-">
515        <title>What if a New Version of &CCL; Breaks SLIME?</title>
516        <para>Sometimes you'll get a new version of &CCL;, set up
517        Emacs to use it with SLIME, and SLIME will fail. Most likely
518        what has happened is that the new version of &CCL; has a
519        change in the output files produced by the compiler (&CCL;
520        developers will say "the fasl version has changed." fasl
521        stands for "fast load" aka compiled files). This
522        problem is easy to fix: just delete the existing SLIME fasl
523        files. The next time you launch Emacs and start SLIME, it will
524        automatically recompile the Lisp files, and that should fix
525        the problem.</para>
526        <para>SLIME's load process stores its fasl files in a hidden
527        folder inside your home folder. The path is</para>
528        <para><literal>~/.slime/fasl</literal></para>
529        <para>You can use a shell command to remove the fasl files, or
530        remove them using your system's file browser.</para>
531        <screen><emphasis role="bold">Note for Macintosh Users:</emphasis> 
532        The leading "." character in the ".slime" folder's name
533        prevents the Finder from showing this folder to you. If you
534        use the "Go To Folder" menu item in the Finder's "Go" menu,
535        you can type in "~/.slime" and the Finder will show it to
536        you. You can then drag the "fasl" folder to the trash.
537        </screen>
538      </sect2>
540      <sect2 id="Known-Bugs">
541        <title>Known Bugs</title>
542        <para>SLIME has not been updated to account for recent changes
543        made in &CCL; to support x86-64 processors. You may run into
544        bugs running on those platforms.</para>
545        <para>The SLIME backtrace sometimes shows incorrect information.</para>
546        <para><literal>return-from-frame</literal> and
547        <literal>apply-in-frame</literal> do not work reliably.  (If
548        they work at all, it's pure luck.)</para>
549        <para>Some versions of Emacs on the Macintosh may have trouble
550        finding the shell script that runs &CCL; unless you specify
551        a full path to it. See the above section "Telling Emacs About
552        SLIME" to learn how to specify the path to the shell
553        script.</para>
554        <para>For more help with &CCL; on Mac OS X, consult the
555        &CCL; mailing lists.</para>
556      </sect2>
557    </sect1>
559    <sect1 id="Example-Programs">
560      <title>Example Programs</title>
561      <para>Beginning with release 0.9, a number (ok, a
562      <emphasis>small</emphasis> number, at least initially) of
563      example programs are distributed in the "ccl:examples;"
564      directory of the source distribution. See the
565      README-OPENMCL-EXAMPLES text file in that directory for
566      information about prerequisites and usage.</para>
567      <para>Some of the example programs are derived from C examples
568      in textbooks, etc.; in those cases, the original author and work
569      are cited in the source code.</para>
570      <para>It may be a stretch to imply that the examples have a
571      great deal of value as "intellectual property", but I might as
572      well say this: Unless the original author or contributor claims
573      other rights, you're free to incorporate any of this example
574      code or derivative thereof in any of you're own works without
575      restriction. In doing so, you agree that the code was provided
576      "as is", and that no other party is legally or otherwise
577      responsible for any consequences of your decision to use
578      it.</para>
579      <para>If you've developed &CCL; examples that you'd like to
580      see added to the distribution, please send mail to let me
581      know. Any such contributions would be welcome and appreciated
582      (as would bug fixes and improvements to the existing
583      examples.)</para>
584    </sect1>
585  </chapter>
Note: See TracBrowser for help on using the repository browser.