◄►The Ciao System » PART XII - Appendices »

Installing Ciao from the source distribution

Author(s): Manuel Carro, Daniel Cabeza, Manuel Hermenegildo.

This describes the installation procedure for the Ciao system, including libraries and manuals, from a source distribution. This applies primarily to Unix-type systems (Linux, Mac OS X, Solaris, SunOS, etc.). However, the sources can also be compiled if so desired on Windows systems -- see Installation and compilation under Windows for details.

If you find any problems during installation, please refer to Troubleshooting (nasty messages and nifty workarounds). See also Downloading new versions and Reporting bugs.

Un*x installation summary

Note: It is recommended that you read the full installation instructions (specially if the installation will be shared by different architectures). However, in many cases it suffices to follow this summary:

  1. Uncompress and unpackage (using gunzip and tar -xpf) the distribution. This will put everything in a new directory whose name reflects the Ciao version.

  2. Type ./ciaosetup configure. This will autodetect and configure the system for your specific platform. If you need more control about what configure does, just add the option --help to see more arguments.

    The option --menu show a menu with configurable options. You must follow the instructions that appears on it.

    Note that the GNU implementation of the make Un*x command is used internally in some specific parts. It is available in many systems (including all Linux systems and Mac OS X) simply as make. If this or next steps stop right away with make error messages it is probably an older version and you need to install gmake.

  3. Type ./ciaosetup build. This will build executables and compile libraries.

  4. Type ./ciaosetup install. This will install everything in the specified directories.

  5. The system will do the right modifications in your startup scripts. This will make the documentation accessible, set the correct mode when opening Ciao source files in emacs, etc. The modified files are tagged with the names \'DOTBASHRC\', \'DOTCSHRC\' and \'DOTEMACS\', which are the startup files for bash, csh and emacs respectively.

    The following modifications are done automatically in your startup scripts, and you don't need to do it manually. This will make the documentation accessible, set the correct mode when opening Ciao source files in emacs, etc. Note that <v>libroot</v> must be replaced with the appropriate value:

    • For users a csh-compatible shell (csh, tcsh, ...), add to ~/.cshrc:

              if ( -e <v>libroot</v>/ciao/DOTcshrc ) then
           source <v>libroot</v>/ciao/DOTcshrc
        endif

      Note: while this is recognized by the terminal shell, and therefore by the text-mode Emacs which comes with Mac OS X, the Aqua native Emacs 21 does not recognize that initialization. It is thus necessary, at this moment, to set manually the Ciao shell (ciaosh) and Ciao library location by hand. This can be done from the Ciao menu within Emacs after a Ciao file has been loaded. We believe that the reason is that Mac OS X does not actually consult the per-user initialization files on startup. It should also be possible to put the right initializations in the .emacs file using the setenv function of Emacs-lisp, as in

      (setenv "CIAOLIB" "<v>libroot</v>/ciao")

      The same can be done for the rest of the variables initialized in <v>libroot</v>/ciao/DOTcshrc

    • For users of an sh-compatible shell (sh, bash, ...), the installer will add to ~/.bashrc the next lines:

              if [ -f <v>libroot</v>/ciao/DOTprofile ]; then
           . <v>libroot</v>/ciao/DOTprofile
        fi

      This will set up things so that the Ciao executables are found and you can access the Ciao system manuals using the info command. Note that, depending on your shell, you may have to log out and back in for the changes to take effect.

    • Also, if you use emacs (highly recommended) the install will add the next line to your ~/.emacs file:

              (load-file "<v>libroot</v>/ciao/ciao-mode-init.el")
        (if (file-exists-p "<v>libroot</v>/ciao/ciao-mode-init.el")
          (load-file "<v>libroot</v>/ciao/ciao-mode-init.el")
        )

    If you are installing Ciao globally in a multi-user machine, make sure that you instruct all users to do the same. If you are the system administrator, the previous steps can be done once and for all, and globally for all users by including the lines above in the central startup scripts (e.g., in Linux /etc/bashrc, /etc/csh.login, /etc/csh.cshrc, /etc/skel, /usr/share/emacs/.../lisp/site-init.pl, etc.).

  6. Finally, if the (freely available) emacs editor/environment is not installed in your system, we highly recommend that you also install it at this point (see Un*x full installation instructions for instructions). While it is easy to use Ciao with any editor of your choice, the Ciao distribution includes a very powerful application development environment which is based on emacs and which enables, e.g., source-level debugging, syntax coloring, context-sensitive on-line help, etc.

  7. You may want now want to check your installation (see Checking for correct installation on Un*x) and read the documentation, which is stored in DOCDIR (copied from CIAOSRC/doc/reference) and can be easily accessed as explained in that same section. There are special “getting started” sections at the beginning of the manual.

  8. If you have any problems you may want to check the rest of the instructions. The system can be uninstalled by typing ./ciaosetup uninstall.

Un*x full installation instructions

  1. Uncompress and unpackage: (using gunzip and tar -xpf) the distribution in a suitable directory. This will create a new directory called ciao-X.Y, where X.Y is the version number of the distribution. The -p option in the tar command ensures that the relative dates of the files in the package are preserved, which is needed for correct operation of the Makefiles.

  2. Select installation options: Run the ./ciaosetup configure command and answer the questions that appears in the menu. The meaning of some important options in the menu is as follows:

      %

    • CIAOSRC: directory where the sources are % stored.

    • BINDIR: directory where the Ciao executables will go. For example, if BINDIR=/usr/local/bin, then the Ciao compiler (ciaoc) will be stored at /usr/local/bin/ciaoc. Actually, it will be a link to ciaoc-VersionNumber. This applies also to other executables below and is done so that several versions of Ciao can coexist on the same machine. Note that the version installed latest will be the one started by default when typing ciao, ciaoc, etc.

    • LIBROOT: directory where the run-time libraries will be installed. The Ciao installation procedure will create a new subdirectory ciao below LIBROOT and a subdirectory below this one for each Ciao version installed. For example, if LIBROOT=/usr/local/lib and you have Ciao version x.y, then the libraries will be installed under /usr/local/lib/ciao/ciao-x.y. This allows you to install site-specific programs under /usr/local/lib/ciao and they will not be overwritten if a new version of Ciao is installed. It also again allows having several Ciao versions installed simultaneously.

    • DOCDIR: directory where the manuals will be installed. It is often convenient if this directory is accessible via WWW (DOCDIR=/home/httpd/html/ciao, or something like that).

    For network-based installations, it is of utmost importance that the configured paths be reachable in all the networked machines. Different machines with different architectures can share the same physical source directory during installation, since compilations for different architectures take place in dedicated subdirectories. Also, different machines/architectures can share the same LIBROOT directory (LIBROOT is configured in the menu). This saves space since the architecture-independent libraries will be shared. See Multiarchitecture support below.

  3. Compile Ciao: At the ciao top level directory type ./ciaosetup build.

    This will:

    • Build an engine in $(CIAOSRC)/bin/$(CIAOARCH), where $(CIAOARCH) depends on the architecture. The engine is the actual interpreter of the low level code into which Ciao programs are compiled.

    • Build a new Ciao standalone compiler (ciaoc), with the default paths set for your local configuration (nonetheless, these can be overridden by environment variables, as described below).

    • Precompile all the libraries under $(CIAOSRC)/lib and $(CIAOSRC)/library using this compiler.

    • Compile a toplevel Ciao shell and a shell for Ciao scripts, under the $(CIAOSRC)/shell directory.

    • Compile some small, auxiliary applications (contained in the etc directory, and documented in the part of the manual on 'Miscellaneous Standalone Utilities').

    This step can be repeated successively for several architectures in the same source directory. Only the engine and some small parts of the libraries (those written in C) differ from one architecture to the other. Standard Ciao code compiles into bytecode object files (.po) and/or executables which are portable among machines of different architecture, provided there is an executable engine accessible in every such machine. See more details below under Multiarchitecture support.

  4. Check compilation: If the above steps have been satisfactorily finished, the compiler has compiled itself and all the distribution modules, and very probably everything is fine.

  5. Install Ciao: To install Ciao in the directories selected in the configuration script during step 2 above, type ./ciaosetup install. This will:

    • Install the executables of the Ciao program development tools (i.e., the general driver/top-level ciao, the standalone compiler ciaoc, the script interpreter ciao-shell, miscellaneous utilities, etc.) in BINDIR (see below). In order to use these tools, the PATH environment variable of users needs to contain the path BINDIR.

    • Install the Ciao libraries under LIBROOT/ciao (these will be automatically found).

    • Install under DOCDIR the Ciao manuals in several formats (such as GNU info, html, postscript, etc.), depending on the distribution. In order for these manuals to be found when typing M-x info within emacs, or by the standalone info and man commands, the MANPATH and INFOPATH environment variables of users both need to contain the path DOCDIR.

    • Install under LIBROOT/ciao the Ciao GNU emacs interface (ciao.el, which provides an interactive interface to the Ciao program development tools, as well as some other auxiliary files) and a file ciao-mode-init containing the emacs initialization commands which are needed in order to use the Ciao emacs interface.

  6. Set up user environments: In order to automate the process of setting the variables above, the installation process leaves the files LIBROOT/ciao/DOTcshrc (for csh-like shells), LIBROOT/ciao/DOTprofile (for sh-like shells), and LIBROOT/ciao/ciao-mode-init (for emacs) with appropriate definitions which will take care of all needed environment variable definitions and emacs mode setup. If you has indicated in the menu that the startup files must be modified, then the install process will do it for you, otherwise you can modify by hand these files making the following modifications in your startup scripts, so that these files are used (<v>libroot</v> must be replaced with the appropriate value):

    • For users a csh-compatible shell (csh, tcsh, ...), add to ~/.cshrc:

              if ( -e <v>libroot</v>/ciao/DOTcshrc ) then
           source <v>libroot</v>/ciao/DOTcshrc
        endif

      Note: while this is recognized by the terminal shell, and therefore by the text-mode Emacs which comes with Mac OS X, the Aqua native Emacs 21 does not recognize that initialization. It is thus necessary, at this moment, to set manually the Ciao shell (ciaosh) and Ciao library location by hand. This can be done from the Ciao menu within Emacs after a Ciao file has been loaded. We believe that the reason is that Mac OS X does not actually consult the per-user initialization files on startup. It should also be possible to put the right initializations in the .emacs file using the setenv function of Emacs-lisp, as in

      (setenv "CIAOLIB" "<v>libroot</v>/ciao")

      The same can be done for the rest of the variables initialized in <v>libroot</v>/ciao/DOTcshrc

    • For users of an sh-compatible shell (sh, bash, ...), the installer will add to ~/.bashrc the next lines:

              if [ -f <v>libroot</v>/ciao/DOTprofile ]; then
           . <v>libroot</v>/ciao/DOTprofile
        fi

      This will set up things so that the Ciao executables are found and you can access the Ciao system manuals using the info command. Note that, depending on your shell, you may have to log out and back in for the changes to take effect.

    • Also, if you use emacs (highly recommended) the install will add the next line to your ~/.emacs file:

              (load-file "<v>libroot</v>/ciao/ciao-mode-init.el")
        (if (file-exists-p "<v>libroot</v>/ciao/ciao-mode-init.el")
          (load-file "<v>libroot</v>/ciao/ciao-mode-init.el")
        )

    If you are installing Ciao globally in a multi-user machine, make sure that you instruct all users to do the same. If you are the system administrator, the previous steps can be done once and for all, and globally for all users by including the lines above in the central startup scripts (e.g., in Linux /etc/bashrc, /etc/csh.login, /etc/csh.cshrc, /etc/skel, /usr/share/emacs/.../lisp/site-init.pl, etc.).

  7. Download and install Emacs (highly recommended): If the (freely available) emacs editor is not installed in your system, its installation is highly recommended (if you are installing in a multi-user machine, you may want to do it in a general area so that it is available for other users, even if you do not use it yourself). While it is easy to use Ciao with any editor of your choice, the Ciao distribution includes a very powerful application development environment which is based on emacs and which enables, e.g., source-level debugging, syntax coloring, context-sensitive on-line help, etc.

    The emacs editor (in all its versions: Un*x, Windows, etc.) can be downloaded from, for example, http://www.emacs.org/, and also from the many GNU mirror sites worldwide (See http://www.gnu.org/ for a list), in the gnu/emacs and gnu/windows/emacs directories. You can find answers to frequently asked questions (FAQ) about emacs in general at http://www.gnu.org/software/emacs/emacs-faq.text and about the Windows version at http://www.gnu.org/software/emacs/windows/ntemacs.html (despite the ntemacs name it runs fine also as is on Win9X and Win2000 machines).

  8. Check installation / read documentation: You may now want to check your installation (see Checking for correct installation on Un*x) and read the documentation, which is stored in DOCDIR (copied from CIAOSRC/doc/reference) and can be easily accessed as explained that same section. There are special “getting started” sections at the beginning of the manual.

If you have any problems you may want to check Troubleshooting (nasty messages and nifty workarounds).

The system can be uninstalled by typing ./ciaosetup uninstall in the top directory. Configuration should have not changed since installation, so that the same directories are cleaned (i.e. the variables in SETTINGS should have the same value as when the install was performed).

Checking for correct installation on Un*x

If everything has gone well, several applications and tools should be available to a normal user. Try the following while logged in as a normal user (important in order to check that permissions are set up correctly):

  • Typing ciao (or ciaosh) should start the typical Prolog-style top-level shell.

  • In the top-level shell, Ciao library modules should load correctly. Type for example use_module(library(dec10_io)) --you should get back a prompt with no errors reported.

  • To exit the top level shell, type halt. as usual, or ^D.

  • Typing ciaoc should produce the help message from the Ciao standalone compiler.

  • Typing ciao-shell should produce a message saying that no code was found. This is a Ciao application which can be used to write scripts written in Ciao, i.e., files which do not need any explicit compilation to be run.

Also, the following documentation-related actions should work:

  • If the info program is installed, typing info should produce a list of manuals which should include Ciao manual(s) in a separate area (you may need to log out and back in so that your shell variables are reinitialized for this to work).

  • Opening with a WWW browser (e.g., netscape) the directory or URL corresponding to the DOCDIR setting should show a series of Ciao-related manuals. Note that style sheets should be activated for correct formatting of the manual.

  • Typing man ciao should produce a man page with some very basic general information on Ciao (and pointing to the on-line manuals).

  • The DOCDIR directory should contain the manual also in the other formats such as postscript or pdf which specially useful for printing. See Printing manuals (Un*x) for instructions.

Finally, if emacs is installed, after starting it (typing emacs) the following should work:

  • Typing ^H i (or in the menus Help->Manuals->Browse Manuals with Info) should open a list of manuals in info format in which the Ciao manual(s) should appear.

  • When opening a Ciao file, i.e., a file with .pl or .pls ending, using ^X^Ffilename (or using the menus) the code should appear highlighted according to syntax (e.g., comments in red), and Ciao/Prolog menus should appear in the menu bar on top of the emacs window.

  • Loading the file using the Ciao/Prolog menu (or typing ^C l) should start in another emacs buffer the Ciao toplevel shell and load the file. You should now be able to switch the the toplevel shell and make queries from within emacs.

Note: when using emacs it is very convenient to swap the locations of the (normally not very useful) Caps Lock key and the (very useful in emacs) Ctrl key on the keyboard. How to do this is explained in the emacs frequently asked questions FAQs (see the emacs download instructions for their location).

Cleaning up the source directory

After installation, the source directory can be cleaned up in several ways:

  • ./ciaosetup uninstall removes the installation but does not touch the source directories.

  • ./ciaosetup totalclean leaves the distribution is its original form, throwing away any intermediate files (as well as any unneeded files left behind by the Ciao developers), while still allowing recompilation.

Multiarchitecture support

As mentioned before, Ciao applications (including the compiler and the top level) can run on several machines with different architectures without any need for recompiling, provided there is one Ciao engine (compiled for the corresponding architecture) accessible in each machine. Also, the Ciao libraries (installed in LIBROOT, which contain also the engines) and the actual binaries (installed in BINDIR) can themselves be shared on several machines with different architectures, saving disk space.

For example, assume that the compiler is installed as:

/usr/local/share/bin/ciaoc

and the libraries are installed under

/usr/local/share/lib

Assume also that the /usr/local/share directory is mounted on, say, a number of Linux and a number of Solaris boxes. In order for ciaoc to run correctly on both types of machines, the following is needed:

  1. Make sure you that have done ./ciaosetup install on one machine of each architecture (once for Linux and once for Solaris in our example). This recompiles and installs a new engine and any architecture-dependent parts of the libraries for each architecture. The engines will have names such as ciaoengine.LINUXi86, ciaoengine.SolarisSparc, and so on.

  2. In multi-architecture environments it is even more important to make sure that users make the modifications to their startup scripts using <v>libroot</v>/ciao/DOTcshrc etc. The selection of the engine (and architecture-dependent parts of libraries) is done in these scripts by setting the environment variable CIAOARCH, using the ciao_get_arch command, which is installed automatically when installing Ciao. This will set CIAOARCH to, say, LINUXi86, SolarisSparc, respectively, and CIAOENGINE will be set to ciaoengine.CIAOARCH.

    However, note that this is not strictly necessary if running on only one architecture: if CIAOARCH is not set (i.e., undefined), the Ciao executables will look simply for ciaoengine, which is always a link to the latest engine installed in the libraries. But including the initialization files provided has the advantage of setting also paths for the manuals, etc.

Installation and compilation under Windows

There are two possibilities in order to install Ciao on Windows machines:

  • Installing from the Windows precompiled distribution. This is the easiest since it requires no compilation and is highly recommended. This is described in Installing Ciao from a Win32 binary distribution.

  • Installing the standard Ciao (Un*x) system source distribution and compiling it under Windows. This is somewhat more complex and currently requires the (freely available) Cygnus Win32 development libraries --described below.

In order to compile Ciao for Win32 environments you need to have the (public domain) Cygnus Win32 and development libraries installed in your system. Compilation should be performed preferably under Windows NT-type systems.

  • Thus, the first step, if Cygnus Win32 is not installed in your system, is to download it (from, e.g., http://www.cygnus.com/misc/gnu-win32) and install it. The compilation process also requires that the executables rm.exe, sh.exe, and uname.exe from the Cygnus distribution be copied under /bin prior to starting the process (if these executables are not available under /bin the compilation process will produce a number of errors and eventually stop prematurely).

  • Assuming all of the above is installed, type ./ciaosetup allwin32. This will compile both the engine and the Ciao libraries. In this process, system libraries that are normally linked dynamically under Un*x (i.e., those for which .so dynamically loadable files are generated) are linked statically into the engine (this is done instead of generating .dlls because of a limitation in the current version of the Cygnus Win32 environment). No actual installation is made at this point, i.e., this process leaves things in a similar state as if you had just downloaded and uncompressed the precompiled distribution. Thus, in order to complete the installation you should now:

  • Follow now the instructions in Installing Ciao from a Win32 binary distribution.

A further note regarding the executables generated by the Ciao compiler and top-level: the same considerations given in Installing Ciao from a Win32 binary distribution apply regarding .bat files, etc. However, in a system in which Cygnus Win32 is installed these executables can also be used in a very simple way. In fact, the executables can be run as in Un*x by simply typing their name at the bash shell command line without any associated .bat files. This only requires that the bash shell which comes with Cygnus Win32 be installed and accessible: simply, make sure that /bin/sh.exe exists.

Porting to currently unsupported operating systems and architectures

If you would like to port Ciao to a currently unsupported platform, there are several issues to take into account. The main one is to get the engine to compile in that platform, i.e., the C code under the engine directory. The procedure currently followed by Ciao to decide the various flags needed to compile is as follows:

  • The shell script $(CIAOSRC)/etc/ciao_get_arch is executed; it returns a string describing the operating system and the processor architecture (e.g., LINUXi86, SolarisSparc, SolarisAlpha, etc.). You should make sure it returns a correct (and meaningful) string for your setup. This string is used throughout the compilation to create several architecture-dependant flags.

  • Include in the file $(CIAOSRC)/config-sysdep.sh the definitions necessary for the platform. That file sets several flags regarding, for example, whether to use or not threads, which threads library to use, the optimization flags to use, the compiler, linker, and it also sets separately the architecture name (ARCHNAME variable) and the operating system (OSNAME).

  • Most times the porting problems happen in the use of locks and threads. You can either disable them, or have a look at the files $(CIAOSRC)/engine/locks.h and $(CIAOSRC)/engine/threads.h. If you know how to implement native (assembler) locks for your architecture, enable HAVE_NATIVE_SLOCKS for your architecture and add the definitions. Otherwise, if you have library-based locks, enable them. The mechanism in threads.h is similar.

Once a working engine is achieved, it should be possible to continue with the standard installation procedure, which will try to use a completely static version of the standalone compiler (ciaoc.sta in the ciaoc directory) to compile the interactive top-level (ciaosh) and a new version of the standalone compiler (ciaoc). These in turn should be able to compile the Ciao libraries. You may also need to look at some libraries (such as, for example, sockets) which contain C code. If you do succeed in porting to a platform that is currently unsupported please send any patches to <ciao@clip.dia.fi.upm.es>, and we will include them (with due credit, of course) in the next distribution.

Troubleshooting (nasty messages and nifty workarounds)

The following a list of common installation problems reported by users:

  • Problem: Compilation errors appear when trying a new installation/compilation after the previous one was aborted (e.g., because of errors).

    Possible reason and solution: It is a good idea to clean up any leftovers from the previous compilation using ./ciaosetup clean_engine before restarting the installation or compilation process.

  • Problem:

    During engine compilation, messages such as the following appear: tasks.c:102:PTHREAD_CANCEL_ASYNCHRONOUS undeclared (first use of this function).

    Possible reason and solution:

    Your (Linux?) system does not have (yet) the Posix threads library installed. You can upgrade to one which does have it, or download the library from

    http://pauillac.inria.fr/~xleroy/linuxthreads/index.html

    and install it, or disable the use of threads in Linux: for this, edit the SETTINGS file and specify USE_THREADS=no, which will avoid linking against thread libraries (it will disable the use of thread-related primitives as well). Clean the engine with ./ciaosetup clean_engine and restart compilation.

    If you have any alternative threads library available, you can tinker with engine/threads.h and the config-sysdep.sh file in order to get the task managing macros right for your system. Be sure to link the right library. If you succeed, we (<ciao@clip.dia.fi.upm.es>) will be happy of knowing about what you have done.

  • Problem:

    -lpthread: library not found (or similar)

    Possible reason and solution:

    Your (Linux?) system seems to have Posix threads installed, but there is no threads library in the system. In newer releases (e.g., RedHat 5.0), the Posix threads system calls have been included in glibc.so, so specifying -lpthread in config-sysdep.sh is not needed; remove it. ./ciaosetup clean_engine and restart installation.

    Alternatively, you may have made a custom installation of Posix threads in a non-standard location: be sure to include the flag -L/this/is/where/the/posix/libraries/are before -lpthread, and to update /etc/ld.so.conf (see man ldconfig).

  • Problem:

    Segmentation Violation (when starting the first executable)

    Possible reason and solution:

    This has been observed with certain older versions of gcc which generated erroneous code under full optimization. The best solution is to upgrade to a newer version of gcc. Alternatively, lowering the level of optimization (by editing the SETTINGS file in the main directory of the distribution) normally solves the problem, at the cost of reduced execution speed.

  • Problem: ciaoc: /home/clip/lib/ciao/ciao-X.Y/engine/ciaoengine: not found

    Possible reason and solution:

    • The system was not fully installed and the variable CIAOENGINE was not set.

    • The system was installed, the variable CIAOENGINE is set, but it is does not point to a valid ciaoengine.

    See the file LIBROOT/ciao/DOTcshrc for user settings for environment variables.

  • Problem:

    ERROR: File library(compiler) not found - aborting... (or any other library is not found)

    Possible reason and solution:

    • The system was not installed and the variable CIAOLIB was not set.

    • The system is installed and the variable CIAOLIB is wrong.

    See the file LIBROOT/ciao/DOTcshrc for user settings for environment variables.

  • Problem:

    ERROR: File <some_directory>/<some_file>.itf not found - aborting...

    Possible reason and solution:

    Can appear when compiling .pl files. The file to compile (<some_file>.pl) is not in the directory <some_directory>. You gave a wrong file name or you are in the wrong directory.

  • Problem:

    *ERROR*: /(write_option,1) is not a regular type (and similar ones)

    Possible reason and solution:

    This is not a problem, but rather the type checker catching some minor inconsistencies which may appear while compiling the libraries. Bug us to remove it, but ignore it for now.

  • Problem:

    WARNING: Predicate <some_predicate>/<N> undefined in module <some_module>

    Possible reason and solution:

    It can appear when the compiler is compiling Ciao library modules. If so, ignore it (we will fix it). If it appears when compiling user programs or modules, you may want to check your program for those undefined predicates.

  • Problem:

    make: Fatal error in reader: SHARED, line 12: Unexpected end of line seen

    Possible reason and solution:

    You are using standard Un*x make, not GNU's make implementation (gmake).

  • Problem:

    WARNINGs or ERRORs while compiling the Ciao libraries during installation.

    Possible reason and solution:

    It is possible that you will see some such errors while compiling the Ciao libraries during installation. This is specially the case if you are installing a Beta or Alpha release of Ciao. These releases (which have “odd” version numbers such as 1.5 or 2.1) are typically snapshots of the development directories, on which many developers are working simultaneously, which may include libraries which have typically not been tested yet as much as the “official” distributions (those with “even” version numbers such as 1.6 or 2.8). Thus, minor warnings may not have been eliminated yet or even errors can sneak in. These warnings and errors should not affect the overall operation of the system (e.g., if you do not use the affected library).

  • Problem:

    In Windows, many programs (including emacs and ciao) exit with error messages like:

    Doing vfork: resource temporarily unavailable

    Possible reason and solution:

    Cygwin needs a special memory layout to implement the fork semantics in Win32 (http://cygwin.com/ml/cygwin/2009-05/msg00413.html). A workaround this problem is using the rebaseall command, which relocates all Cygwin DLLs into a layout that avoids collisions:

    • 1. End all cygwin processes.
    • 2. Run /bin/rebaseall from c:\cygwin\bin\ash (probably as administrator)


Sections

Global Links

Indices

◄► 
Generated with LPdoc using Ciao