Changeset 9071


Ignore:
Timestamp:
Apr 8, 2008, 9:12:54 PM (11 years ago)
Author:
mikel
Message:

mechanical and style edits in install and build chapters

Location:
trunk/source/doc/src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/doc/src/about.xml

    r9026 r9071  
    2323    <para>When it was forked from MCL in 1998, the new Lisp was named
    2424      OpenMCL. Recently, Clozure renamed its Lisp to &CCL;, partly
    25       because its parent product, MCL, has lately been released as
    26       open source. Clozure thought it might be confusing if there were
    27       two independent open-source projects, one called "OpenMCL", and
    28       the other called "(open) MCL". In addition, the new name
    29       reflects &CCL;'s current status as the flagship product of
    30       Clozure Associates, and also refers to its ancestry: in its
    31       early years, MCL was known as Coral Common Lisp, or
    32       "CCL". Because of that heritage, the package used for most
    33       implementation-specific symbols in &CCL; has always been named
    34       "CCL"; with the adoption of the name &CCL;, that package name
    35       once again refers to the name of the Lisp.</para>
     25      because its ancestor MCL has lately been released as open
     26      source. Clozure thought it might be confusing for users if there
     27      were two independent open-source projects with such similar
     28      names. The new name also reflects &CCL;'s current status as the
     29      flagship product of Clozure Associates.</para>
     30
     31    <para>Furthermore, the new name refers to &CCL;'s ancestry: in its
     32      early years, MCL was known as Coral Common Lisp, or "CCL". For
     33      years the package that contains most of &CCL;'s
     34      implementation-specific symbols has been named "CCL", an acronym
     35      that once stood for the name of the Lisp product. It seems
     36      fitting that "CCL" once again stands for the name of the
     37      product.</para>
    3638
    3739    <para>Some commands and source files may still refer to "OpenMCL"
  • trunk/source/doc/src/build.xml

    r9026 r9071  
    1818    written in Lisp, and compiled into the heap image.  Both parts are
    1919    needed to have a working Lisp implementation; neither the kernel
    20     nor the heap image can stand on their own.</para>
     20    nor the heap image can stand alone.</para>
    2121
    2222    <para>You may already know that, when you have a C compiler which
    23     is written in C, to build the compiler, you need to already have a
    24     C compiler available.  The heap image includes a Lisp compiler,
    25     which is written in Lisp.  Therefore, you need a working Lisp
    26     compiler in order to build the heap image!</para>
     23    is written in C, you need a working C compiler to build the
     24    compiler. Similarly, the &CCL; heap image includes a Lisp
     25    compiler, which is written in Lisp. You therefore need a working
     26    Lisp compiler in order to build the Lisp heap image.</para>
    2727   
    2828    <para>Where will you get a working Lisp compiler?  No worries; you
    2929    can use a precompiled copy of a (slightly older and compatible)
    30     version of &CCL;.  For help, read on.</para>
    31 
    32     <para>In principle it would be possible to use another Lisp as the
    33     host compiler, rather than an old &CCL;; this would be a
    34     challenging and experimental way to build, and is not described
    35     here.</para>
     30    version of &CCL;. This section explains how to do all this.</para>
     31
     32    <para>In principle it should be possible to use another
     33    implementation of Common Lisp as the host compiler, rather than an
     34    older &CCL;; this would be a challenging and experimental way to
     35    build, and is not described here.</para>
    3636
    3737    <sect1 id="building-definitions"><title>Building Definitions</title>
     
    3939      may be helpful to refer to these definitions.</para>
    4040
    41       <para><indexterm><primary>fasl files</primary></indexterm> are
    42       the object files produced by<literal>compile-file</literal>.
    43       fasl files store the machine codeassociated with function
    44       definitions and the external representationof other lisp objects
    45       in a compact, machine-readable form. fasl is short for
     41      <para><indexterm><primary>fasl
     42      files</primary></indexterm><glossterm linkend="fasl-file">fasl
     43      files</glossterm> are the object files produced
     44      by <literal>compile-file</literal>.  fasl files store the
     45      machine code associated with function definitions and the
     46      external representation of other lisp objects in a compact,
     47      machine-readable form. fasl is short for
    4648      &ldquo;<literal>FAS</literal>t
    47       <literal>L</literal>oading&rdquo;.&CCL; uses different
    48       pathname types (extensions) to name faslfiles on different
    49       platforms; see <xref
    50       linkend="Platform-specific-filename-conventions"/> </para>
    51 
    52       <para>The <indexterm><primary>lisp kernel</primary></indexterm> is
    53       a C program (with a fair amount ofplatform-specific assembly
    54       language code as well.)  Its basic job isto map a lisp heap
    55       image into memory, transfer control to somecompiled lisp code
    56       that the image contains, handle any exceptionsthat occur during
    57       the execution of that lisp code, and provide variousother forms
    58       of runtime support for that code.&CCL; uses different
    59       filenames to name the lisp kernel fileson different platforms;
    60       see FIXTHIS.</para>
    61 
    62       <para>A <indexterm><primary>heap image</primary></indexterm> is
    63       a file that can be quickly mapped into aprocess's address space.
    64       Conceptually, it's not too different from anexecutable file or
    65       shared library in the OS's native format (ELF orMach-O/dyld
    66       format); for historical reasons, &CCL;'s own heap images are in
    67       their own (fairly simple) format.The term <literal>full heap
    68       image</literal> refers to a heap image file thatcontains all of
    69       the code and data that comprise &CCL;.&CCL; uses different
    70       filenames to name the standard full heapimage files on different
    71       platforms; see FIXTHIS .</para>
     49      <literal>L</literal>oading&rdquo;. &CCL; uses different pathname
     50      types (extensions) to name fasl files on different platforms;
     51      see
     52      <xref linkend="Platform-specific-filename-conventions"/> </para>
     53
     54      <para>The <indexterm><primary>lisp
     55      kernel</primary></indexterm> <glossterm linkend="lisp_kernel">Lisp
     56      kernel</glossterm> is a C program with a fair amount of
     57      platform-specific assembly language code. Its basic job is to
     58      map a lisp heap image into memory, transfer control to some
     59      compiled lisp code that the image contains, handle any
     60      exceptions that occur during the execution of that lisp code,
     61      and provide various other forms of runtime support for that
     62      code. &CCL; uses different filenames to name the lisp kernel
     63      files on different platforms; see
     64      <xref linkend="Platform-specific-filename-conventions"/>.</para>
     65
     66      <para>A <indexterm><primary>heap
     67      image</primary></indexterm> <glossterm linkend="lisp_image">heap
     68      image</glossterm> is a file that can be quickly mapped into a
     69      process' address space. Conceptually, it's not too different
     70      from an executable file or shared library in the OS's native
     71      format (ELF orMach-O/dyld format); for historical reasons,
     72      &CCL;'s own heap images are in their own (fairly simple)
     73      format. The term <literal>full heap image</literal> refers to a
     74      heap image file that contains all of the code and data that
     75      comprise &CCL;. &CCL; uses different filenames to name the
     76      standard full heap image files on different platforms; see
     77      <xref linkend="Platform-specific-filename-conventions"/>.</para>
    7278
    7379      <para>A <indexterm><primary>bootstrapping
    74       image</primary></indexterm> is a minimal heap image used in
    75       the process of building &CCL; itself.  The bootstrapping image
    76       containsjust enough code to load the rest of &CCL; from fasl
    77       files.  It mayhelp to think of the bootstrapping image as the
    78       egg and the full heapimage as the chicken...&CCL; uses
    79       different filenames to name the standardbootstrapping image
    80       files on different platforms; see FIXTHIS .</para>
     80      image</primary></indexterm> bootstrapping image is a minimal
     81      heap image used in the process of building &CCL; itself.  The
     82      bootstrapping image contains just enough code to load the rest
     83      of &CCL; from fasl files.  It may help to think of the
     84      bootstrapping image as the egg and the full heap image as the
     85      chicken. &CCL; uses different filenames to name the standard
     86      bootstrapping image files on different platforms; see
     87      <xref linkend="Platform-specific-filename-conventions"/>
     88      .</para>
    8189
    8290      <para>Each supported platform (and possibly a few
     
    8593      <indexterm><primary>kernel build directory</primary></indexterm>
    8694      contains a Makefile and may contain some auxiliary files (linker
    87       scripts, etc.) that are used to build the lispkernel on a
     95      scripts, etc.) that are used to build the lisp kernel on a
    8896      particular platform.The platform-specific name of the kernel
    89       build directory is described in FIXTHIS.</para>
     97      build directory is described in
     98      <xref linkend="Platform-specific-filename-conventions"/>.</para>
    9099
    91100      <sect2 id="filename_conventions">
  • trunk/source/doc/src/glossary.xml

    r8981 r9071  
    8585  </glossdiv>
    8686
     87  <glossdiv id="F">
     88        <!-- ******************** F ********************  -->
     89        <title>F</title>
     90
     91        <glossentry id="fasl-file">
     92          <glossterm>fasl file</glossterm>
     93
     94          <glossdef>
     95
     96                <para>A file containing compiled lisp code that the Lisp is
     97                able to quickly load and use. A "fast-load" file.</para>
     98
     99          </glossdef>
     100        </glossentry>
     101
     102  </glossdiv>
     103
    87104  <glossdiv id="H">
    88105        <!-- ******************** H ********************  -->
     
    132149                containing archived versions of these data in a format that
    133150                can be loaded and reconstituted by the
    134                 Lisp <glossterm linkend="lisp_image">kernel</glossterm>. A
     151                Lisp <glossterm linkend="lisp_kernel">kernel</glossterm>. A
    135152                working &CCL; system consists of the kernel and
    136153                an <glossterm linkend="lisp_image">image</glossterm>.</para>
  • trunk/source/doc/src/install.xml

    r9026 r9071  
    2222      updates.  1.1 snapshots have introduced support for x86-64
    2323      platforms, internal use of Unicode, and many other features, but
    24       have presented something of a moving target.  Version 1.2 (being
    25       released in early 2008) is intended to be a more stable release
     24      have presented something of a moving target.  Version 1.2
     25      (released in early 2008) is intended to be a more stable release
    2626      and provide a more predictable release schedule, and to make it
    2727      a bit easier for users who wish to track the "bleeding edge" of
     
    6060
    6161    <para>A 64-bit version of &CCL; requires a 64-bit processor
    62       (obviously) running a 64-bit OS variant.</para>
     62      running a 64-bit OS variant.</para>
    6363   
    6464    <para>There are ongoing efforts to port &CCL; to the Windows
    65       operating system and 32-bit x86 processors.</para>
     65      operating system and to 32-bit x86 processors.</para>
    6666   
    6767   
     
    8080    <sect2><title>Linux X8664</title>
    8181
    82       <para>Version 1.1 and later of &CCL; runs on relatively
    83         recent Linux distributions for the x86-64 architecture.  It
    84         requires a Linux with Thread Local Storage support in the
    85         toolchain and standard libraries, and the New Posix Thread
    86         Library (NPTL).  Fortunately, these features seem to be
    87         present in all current Linux distributions for x86-64, though
    88         there may be some problems with early Linux distributions for
    89         x86-64.  (Some GCC versions older than 4.0 on Linux have been
    90         known to have problems compiling some of the C code in the
    91         kernel, some very old Linux distributions don't follow the
    92         current ABI standards wrt segment register usage, some early
    93         Linux kernels for x86-64 had problems mapping large regions of
    94         the address space ... it's difficult to enumerate exactly what
     82      <para>Version 1.1 and later of &CCL; runs on relatively recent
     83        Linux distributions for the x86-64 architecture.  It requires
     84        a Linux with Thread Local Storage support in the toolchain and
     85        standard libraries, and the New Posix Thread Library (NPTL).
     86        Fortunately, these features seem to be present in all current
     87        Linux distributions for x86-64, though there may be some
     88        problems with early Linux distributions for x86-64. Some GCC
     89        versions older than 4.0 on Linux have been known to have
     90        problems compiling some of the C code in the kernel; some very
     91        old Linux distributions don't follow the current ABI standards
     92        wrt segment register usage; some early Linux kernels for
     93        x86-64 had problems mapping large regions of the address
     94        space; and so on. It's difficult to enumerate exactly what
    9595        versions of what Linux distributions have what problems.  A
    96         rule of thumb is that&mdash;since much of the development of
     96        rule of thumb is that&mdash;because much of the development of
    9797        &CCL; for x86-64 took place in that time frame&mdash;Linux
    9898        distributions released earlier than early 2006 may have
    99         problems running &CCL;.) </para>
     99        problems running &CCL;. </para>
    100100    </sect2>
    101101
    102102    <sect2><title>FreeBSD-amd64</title>
    103       <para>Versions 1.1 and later of &CCL; runs on FreeBSD on
    104         x86-64 (FreeBSD releases generally call the platform "amd64")
    105         &CCL; should run under FreeBSD 6.0 or later; as of this
    106         writing, FreeBSD 7.0 is about to be released and it may be
    107         necessary for FreeBSD 7 users to install the "compat6x"
    108         package in order to use a version of &CCL; built on FreeBSD
    109         6.x under FreeBSD 7.  .</para>
     103      <para>Versions 1.1 and later of &CCL; runs on FreeBSD on x86-64
     104        (FreeBSD releases generally call the platform "amd64").  &CCL;
     105        should run under FreeBSD 6.0 or later; as of this writing,
     106        FreeBSD 7.0 is about to be released and it may be necessary
     107        for FreeBSD 7 users to install the "compat6x" package in order
     108        to use a version of &CCL; built on FreeBSD 6.x.</para>
    110109    </sect2>
    111110
     
    121120      <para>The 64-bit DarwinPPC version of &CCL; requires
    122121        functionality introduced in OSX 10.4 (namely, the ability to
    123         run 64-bit binaries).  It also, obviously, requires a G5
    124         processor.</para>
     122        run 64-bit binaries). The 64-bit DarwinPPC version also,
     123        obviously, requires a G5 processor.</para>
    125124
    126125      <para>&CCL; hasn't been tested under Darwin proper, but
     
    132131
    133132    <sect2><title>Darwinx8664-MacOS-X</title>
    134       <para>Versions 1.1 and later of &CCL; runs on 64-bit
    135         DarwinX86 (MacOS on Intel).</para>
     133      <para>Versions 1.1 and later of &CCL; run on 64-bit DarwinX86
     134        (MacOS on Intel).</para>
    136135
    137136      <para>&CCL; Darwinx8664/MacOS X requires a 64-bit processor.
     
    158157    <para> There are three popular ways to use Clozure CL: as a
    159158      stand-alone double-clickable application (Mac OS X only), as a
    160       command-line application, or with EMACS and SLIME.  These are
    161       described in the following sections.</para>
     159      command-line application, or with EMACS and SLIME. The following
     160      sections describe these options.</para>
    162161
    163162    <sect2><title>The Mac Way</title>
     
    165164         Clozure CL in the usual Macintosh way.  Download and mount a
    166165         disk image, then drag Clozure CL to the Applications folder.
    167          After that you can double-click on the Clozure CL application
    168          to run it.  The disk images are found at
     166         After that you can double-click the Clozure CL application to
     167         run it.  The disk images are available at
    169168         <ulink url="ftp://clozure.com/pub/testing/"/> </para>
    170169
    171170      <para>So that &CCL; can locate its source code (and for other
    172171        reasons explained in
    173         <xref linkend="Predefined-Logical-Hosts"/>) either the
    174         <literal>ccl</literal> directory should be in the same
    175         directory as the Clozure CL application, or the Clozure CL
    176         application should be in the <literal>ccl</literal> directory.
    177         If you use a shell, then you can set the value of the
     172        <xref linkend="Predefined-Logical-Hosts"/>) you should either put the
     173        <literal>ccl</literal> directory in the same directory as the
     174        Clozure CL application, or else put the Clozure CL application
     175        in the <literal>ccl</literal> directory.  If you use a shell,
     176        you can set the value of the
    178177        <varname>CCL_DEFAULT_DIRECTORY</varname> environment variable
    179178        to explicitly indicate the location of
     
    218217        Packages page</ulink>.</para>
    219218
    220       <para>Create the directory where Clozure CL will live, <literal>cd</literal> to that directory, then type a Subversion checkout command.  For example:
     219      <para>Create the directory where Clozure CL will live, <literal>cd</literal> to that directory, then type a Subversion checkout command.  For example:</para>
    221220
    222221        <programlisting>
     
    224223joe:~> mkdir ccl
    225224joe:~> cd ccl
    226 joe:ccl> svn co svn+ssh://svn.clozure.com/usr/local/publicsvn/openmcl]]>
     225joe:ccl> svn co http://svn.clozure.com/publicsvn/openmcl/trunk/darwinx8664]]>
    227226        </programlisting>
    228         Once the checkout is complete you can build Clozure CL by
     227       
     228        <para>This example fetches the complete sources and binaries
     229        for the Darwin X8664 build of &CCL;. You can fetch a different
     230        version by substituting its name in place of
     231        "darwinx8664". Current available versions are:</para>
     232
     233        <itemizedlist>
     234          <listitem><para>darwinppc</para></listitem>
     235          <listitem><para>darwinx8664</para></listitem>
     236          <listitem><para>freebsdx8664</para></listitem>
     237          <listitem><para>linuxppc</para></listitem>
     238          <listitem><para>linuxx8664</para></listitem>
     239        </itemizedlist>
     240
     241        <para>These distributions contain complete sources and
     242        binaries. They use Subversion's "externals" features to share
     243        common sources; the majority of source code is the same across
     244        all versions.</para>
     245
     246        <para>Once the checkout is complete you can build Clozure CL by
    229247        running the lisp kernel and executing
    230         the <literal>rebuild-ccl</literal> function. For example:
     248        the <literal>rebuild-ccl</literal> function. For
     249        example:</para>
     250
    231251        <programlisting>
    232252          <![CDATA[
     
    238258  joe:ccl>]]>
    239259        </programlisting>
    240       </para>
    241260    </sect2>
    242261
     
    250269        <varname>CCL_DEFAULT_DIRECTORY</varname> and start up the
    251270        appropriate Clozure CL kernel. See
    252         <xref linkend="The-openmcl-Shell-Script"/> for more
     271        <xref linkend="The-ccl-Shell-Script"/> for more
    253272        information about the &CCL; shell scripts.</para>
    254273    </sect2>
     
    256275
    257276  <sect1><title>Command Line Set Up</title>
    258     <para>Sometimes it is convenient to use Clozure CL from a Unix
    259       shell command line.  This is especially true when using Clozure CL
    260       as a way to run Common Lisp utilities.</para>
    261 
    262     <sect2 id="The-openmcl-Shell-Script"><title>The openmcl Shell Script</title>
     277    <para>Sometimes it's convenient to use Clozure CL from a Unix
     278      shell command line.  This is especially true when using Clozure
     279      CL as a way to run Common Lisp utilities.</para>
     280
     281    <sect2 id="The-ccl-Shell-Script"><title>The ccl Shell Script</title>
    263282      <para>&CCL; needs to be able to find the
    264283        <literal>ccl</literal> directory in order to support features
     
    278297        <literal>CCL_DEFAULT_DIRECTORY</literal> to determine the
    279298        filesystem location of the <literal>ccl</literal> directory;
    280         the openmcl shell script is intended to provide a way to
     299        the ccl shell script is intended to provide a way to
    281300        invoke &CCL; with that environment variable set
    282301        correctly.</para>
    283302      <para>There are two versions of the shell script:
    284         <literal>"ccl/scripts/openmcl"</literal> is used to invoke
     303        <literal>"ccl/scripts/ccl"</literal> is used to invoke
    285304        32-bit implementations of &CCL; and
    286         <literal>"ccl/scripts/openmcl64"</literal> is used to invoke
     305        <literal>"ccl/scripts/ccl64"</literal> is used to invoke
    287306        64-bit implementations.</para>
    288307      <para>To use the script:</para>
     
    297316            .bashrc,.bash_profile, .MacOSX/environment.plist, or
    298317            wherever you usually set environment variables.  If there
    299             is an existing definition of the variable, the openmcl
     318            is an existing definition of the variable, the ccl
    300319            script will not override it. The shell script sets a local
    301320            variable (<literal>OPENMCL_KERNEL</literal>) to the
    302321            standard name of the &CCL; kernel approprate for the
    303322            platform, as determined by 'uname -s'. You might prefer to
    304             set this variable manually in the shell script</para>
     323            set this variable manually in the shell script.</para>
    305324        </listitem>
    306325
     
    309328            example:</para>
    310329          <para><literal>$ chmod +x
    311             ~/openmcl/ccl/scripts/openmcl64</literal></para>
     330            ~/ccl/ccl/scripts/ccl64</literal></para>
    312331          <para>This command grants execute permission to the named
    313332            script. If you are using a 32-bit platform, substitute
    314             "openmcl" in place of "openmcl64".
     333            "ccl" in place of "ccl64".
    315334            <warning>
    316335                  <para>The above command won't work if you are not the
     
    318337                    you can use the "sudo" command like this:</para>
    319338              <para><literal>$ sudo chmod +x
    320                   ~/openmcl/ccl/scripts/openmcl64</literal></para>
     339                  ~/ccl/ccl/scripts/ccl64</literal></para>
    321340              <para>Give your password when prompted.</para>
    322341              <para>If the "sudo" command doesn't work, then you are
     
    335354
    336355      <para>Once this is done, it should be possible to invoke &CCL;
    337         by typing <literal>openmcl</literal>
    338         or <literal>openmcl64</literal> at a shell prompt:</para>
     356        by typing <literal>ccl</literal>
     357        or <literal>ccl64</literal> at a shell prompt:</para>
    339358      <programlisting>
    340 &gt; openmcl [args ...]
     359&gt; ccl [args ...]
    341360Welcome to &CCL; Version whatever (DarwinPPC32)!
    342361?
    343362      </programlisting>
    344       <para>The openmcl shell script passes all of its arguments to
    345         the &CCL; kernel.  See <xref linkend="Invocation"/> for more
    346         information about "args".  When invoked this way, the Lisp
    347         should be able to initialize the
     363      <para>The ccl shell script passes all of its arguments to the
     364        &CCL; kernel.  See <xref linkend="Invocation"/> for more
     365        information about these arguments.  When invoked this way, the
     366        Lisp should be able to initialize the
    348367        <literal>"ccl:"</literal> logical host so that its
    349368        translations refer to the <literal>"ccl"</literal>
     
    352371        loop:</para>
    353372      <programlisting>
    354 ? (probe-file "ccl:level-1;level-1.lisp")  ;will return the physical pathname of the file
     373? (probe-file "ccl:level-1;level-1.lisp")  ;returns the physical pathname of the file
    355374#P"/Users/alms/my_lisp_stuff/ccl/level-1/level-1.lisp"
    356375      </programlisting>
     
    362381shell&gt;<replaceable>ccl</replaceable> <emphasis>args</emphasis>
    363382            </programlisting>
    364             <literal>ccl</literal> will run a 32-bit session;
    365             <literal>ccl64</literal> will run a 64-bit session.
     383            <literal>ccl</literal> runs a 32-bit session;
     384            <literal>ccl64</literal> runs a 64-bit session.
    366385          </para>
    367386    </sect2>
     
    372391      <literal>"home:openmcl-init.lisp"</literal> or the compiled
    373392         
    374       <literal>"home:openmcl-init.fasl"</literal> upon starting
    375       up. It does this by executing <literal>(load
    376         "home:openmcl-init")</literal>.  If it is unable to load the
    377       file (for example because it does not exist) no action is
    378       taken; an error is not signaled.</para>
    379     <para>The <literal>"home:"</literal> prefix to the filename is
    380       a Common Lisp logical host, which &CCL; initializes to refer
    381       to your home directory, so this looks for either of the files
     393      <literal>"home:openmcl-init.fasl"</literal> upon starting up. It
     394      does this by executing <literal>(load
     395      "home:openmcl-init")</literal>.  If it's unable to load the file
     396      (for example because the file doesn't exist), &CCL; doesn't
     397      signal an error or warning, it just completes its startup
     398      normally.</para>
     399    <para>The <literal>"home:"</literal> prefix to the filename is a
     400      Common Lisp logical host, which &CCL; initializes to refer to
     401      your home directory. &CCL; therefore looks for either of the
     402      files
    382403      <literal>~/openmcl-init.lisp</literal> or
    383404      <literal>~/openmcl-init.fasl</literal>.</para>
    384     <para>Since the init file is loaded the same way as normal Lisp
     405    <para>Because the init file is loaded the same way as normal Lisp
    385406      code is, you can put anything you want in it.  For example, you
    386407      can change the working directory, and load packages that you use
     
    552573     
    553574    </itemizedlist>
    554     <para>There is an excellent SLIME tutorial video available at
    555       Common-Lisp.net.  For
    556       complete information about SLIME, see the
    557       SLIME home page.</para>
     575    <para>For complete information about SLIME, see the
     576      SLIME <ulink url="http://common-lisp.net/project/slime/">home
     577      page</ulink>. The SLIME home page provides up-to-date downloads,
     578      plus documentation, tutorials, and instructional
     579      screencasts.</para>
    558580
    559581    <sect2 id="Assumptions-and-Requirements">
     
    572594                you can check out theEmacsWiki, which maintains a
    573595                page,EmacsForMacOS,that provides much more information
    574                 about using Emacs on the Mac.
    575             <warning>
    576               <para>A popular version of Emacs among Mac users is
    577                 Aquamacs. This application is a version of GNU Emacs
    578                 with a number of customizations meant to make it behave
    579                 more like a standard Macintosh application, with
    580                 windows, a menubar, etc.  Aquamacs includes SLIME; if
    581                 you like Aquamacs then you can use SLIME right away,
    582                 without getting and installing it separately. You just
    583                 need to tell SLIME where to find your installation of
    584                 &CCL;.</para>
    585             </warning>
    586               </para>
     596                about using Emacs on the Mac.</para>
     597          <para>A popular version of Emacs among Mac users is
     598            Aquamacs. This application is a version of GNU Emacs
     599            with a number of customizations meant to make it behave
     600            more like a standard Macintosh application, with
     601            windows, a menubar, etc.  Aquamacs includes SLIME; if
     602            you like Aquamacs then you can use SLIME right away,
     603            without getting and installing it separately. You just
     604            need to tell SLIME where to find your installation of
     605            &CCL;.</para>
    587606            </listitem>
    588607        <listitem>
    589608          <para>You have a working copy of &CCL;, installed in
    590             <literal>"~/openmcl/ccl"</literal>If you prefer to install
     609            <literal>"~/ccl"</literal>If you prefer to install
    591610            &CCL; in some directory other
    592             than<literal>"~/openmcl/ccl"</literal> then these
     611            than<literal>"~/ccl"</literal> then these
    593612            instructions still work, but you must remember to use your
    594613            path to your ccl directory instead of the one that we give
     
    629648    <sect2><title>Installing SLIME</title>
    630649
    631       <para>Once you have the "slime" folder described in the
    632         previous section,installation is a simple matter of copying
    633         the folder to the proper place. You can drag it into the
    634         "~/emacs/site/" folder, or you can use a terminal command to
    635         copy it there. For example, assuming your working directory
    636         contains the unpacked "slime" folder:</para> <para><literal>$
    637           cp -R slime ~/emacs/site/</literal></para> <para>That's all it
     650      <para>Once you have the "slime" folder described in the previous
     651        section, installation is a simple matter of copying the folder
     652        to the proper place. You can drag it into the "~/emacs/site/"
     653        folder, or you can use a terminal command to copy it
     654        there. For example, assuming your working directory contains
     655        the unpacked "slime" folder:</para> <para><literal>$ cp -R
     656        slime ~/emacs/site/</literal></para> <para>That's all it
    638657        takes.</para>
    639658
     
    645664        add a line to your "~/.emacs" file that tells SLIME where to
    646665        find the script that runs &CCL;:</para>
    647       <para><literal>(setq inferior-lisp-program "~/openmcl/ccl/scripts/openmcl64")</literal></para>
     666      <para><literal>(setq inferior-lisp-program "~/ccl/scripts/ccl64")</literal></para>
    648667      <para>or</para>
    649       <para><literal>(setq inferior-lisp-program "~/openmcl/ccl/scripts/openmcl")</literal></para>
     668      <para><literal>(setq inferior-lisp-program "~/ccl/scripts/ccl")</literal></para>
    650669      <warning>
    651670        <para>Aquamacs users should add this line to the file "~/Library/Preferences/Aquamacs Emacs/Preferences.el".</para>
     
    685704      <para>You can use a shell command to remove the fasl files, or
    686705        remove them using your system's file browser.</para>
    687       <screen><emphasis role="bold">Note for Macintosh Users:</emphasis>
     706      <para><emphasis role="bold">Note for Macintosh Users:</emphasis>
    688707            The leading "." character in the ".slime" folder's name
    689708            prevents the Finder from showing this folder to you. If you
     
    691710            you can type in "~/.slime" and the Finder will show it to
    692711            you. You can then drag the "fasl" folder to the trash.
    693           </screen>
     712          </para>
    694713    </sect2>
    695714
     
    708727        SLIME" to learn how to specify the path to the shell
    709728        script.</para>
    710       <para>For more help with &CCL; on Mac OS X, consult the
    711         &CCL; mailing lists.</para>
     729      <para>For more help with &CCL; on Mac OS X, consult the &CCL;
     730        mailing lists. You can find information about the mailing
     731        lists on the
     732        &CCL; <ulink url="http://trac.clozure.com/openmcl">wiki</ulink>.</para>
    712733    </sect2>
    713734  </sect1>
     
    724745      in textbooks, etc.; in those cases, the original author and work
    725746      are cited in the source code.</para>
    726     <para>It may be a stretch to imply that the examples have a
    727       great deal of value as "intellectual property", but I might as
    728       well say this: Unless the original author or contributor claims
    729       other rights, you're free to incorporate any of this example
    730       code or derivative thereof in any of you're own works without
     747    <para>Unless the original author or contributor claims other
     748      rights, you're free to incorporate any of this example code or
     749      derivative thereof in any of you're own works without
    731750      restriction. In doing so, you agree that the code was provided
    732751      "as is", and that no other party is legally or otherwise
    733752      responsible for any consequences of your decision to use
    734753      it.</para>
    735     <para>If you've developed &CCL; examples that you'd like to
    736       see added to the distribution, please send mail to let me
    737       know. Any such contributions would be welcome and appreciated
     754    <para>If you've developed &CCL; examples that you'd like to see
     755      added to the distribution, please send mail to the &CCL; mailing
     756      lists. Any such contributions would be welcome and appreciated
    738757      (as would bug fixes and improvements to the existing
    739758      examples.)</para>
  • trunk/source/doc/src/using.xml

    r8993 r9071  
    11311131        is set to the value of the environment variable
    11321132        <varname>CCL_DEFAULT_DIRECTORY</varname>, which is set by the
    1133         openmcl shell script <xref linkend="The-openmcl-Shell-Script"/>.  If
     1133        openmcl shell script <xref linkend="The-ccl-Shell-Script"/>.  If
    11341134        <varname>CCL_DEFAULT_DIRECTORY</varname> is not set, then it is set
    11351135        to the directory containing the current heap image.</para>
Note: See TracChangeset for help on using the changeset viewer.