[Up: Installation]
[Previous: Prerequisits] [Next: Installing MICO using Visual-C++]

#
Installing MICO under Unix

The MICO source release is shipped as a tar'ed and gzip'ed archive called

      mico-2.3.6.tar.gz

Unpack the archive using the following command:

      gzip -dc mico-2.3.6.tar.gz | tar xf -

You are left with a new directory `mico` containing the MICO sources. To save you the hassle of manually editing `Makefile`'s and such, MICO comes with a configuration script that checks your system for required programs and other configuration issues. The script, called `configure`, supports several important command line options:

`-help`
  Gives an overview of all supported command line options.
`-prefix=<install-directory>`
  With this options you tell configure where the MICO programs and libraries should be installed after compilation. This defaults to `/usr/local`.
`-enable-corba2-1`
  This option makes MICO compliant to the version 2.1 of the CORBA standard due to some backward incompatibilities with later releases of the standard.
`-disable-optimize`
  Do not use the `-O` option when compiling C/C++ files. It is now safe to use this option because only files that do not use exceptions are compiled using `-O`, which is why optimization is now turned on by default.
`-enable-debug`
  Use the `-g` option when compiling C/C++ files.
`-enable-repo`
  Use the `-frepo` flag when compiling C++ files. This works only with a patched g++ 2.7.2 and will greatly reduce the size of the binaries, at the cost of much slower compilation (this option instructs g++ to do some sort of template repository). You must use this option on HP-UX, otherwise you will get lots of error during linking.
`-disable-shared`
  Build the MICO library as a static library instead as a shared one. Shared libraries currently only work on ELF based systems (e.g., Linux, Solaris, Digital Unix, AIX, and HP-UX). If you do not use the `-disable-shared` option you have to make sure the directory where the MICO library resides is either by default searched for shared libraries by the dynamic linker (`/usr/lib` and `/lib` on most systems) or you have to include the directory in the environment variable that tells the dynamic linker where to search for additional shared libraries. This variable is called `LIBPATH` on AIX, `SHLIB_PATH` on HP-UX and `LD_LIBRARY_PATH` on all the other systems. To run the generated binaries before doing a `make install` you have to set this environment variable like this:

          # AIX
          export LIBPATH=<mico-path>/mico/orb:$LIBPATH
          # HP-UX
          export SHLIB_PATH=<mico-path>/mico/orb:$SHLIB_PATH
          # others
          export LD_LIBRARY_PATH=<mico-path>/mico/orb:$LD_LIBRARY_PATH
      %$

  where `<mico-path>` is the absolute path of the directory the MICO sources were unpacked in.
`-disable-dynamic`
  This option disables dynamic loading of CORBA objects into a running executable. For dynamic loading to work your system must either support `dlopen()` and friends or `shl_load()` and friends. See section 4.3.4 for details.
`-enable-final`
  Build a size optimized version of the MICO library. This will need lots of memory during compilation but will reduce the size of the resulting library a lot. Works with and without `-enable-shared`. Does not work on HP-UX.
`-disable-mini-stl`
  As mentioned before, MICO makes use of the Standard Template Library (STL). For environments that do not provide an STL implementation, MICO comes with its own slim STL (called MiniSTL), which is simply a subset of the standard STL sufficient to compile MICO. By default MICO will use MiniSTL. If you want to use the system supplied STL for some reason you have to use the option `-disable-mini-stl`. MiniSTL works well with g++ and greatly reduces compilation time and size of the binaries. Using MiniSTL one could try to compile MICO using a C++ compiler other than g++. But this still has not been tested and may therefore lead to problems.
`-disable-except`
  Disable exception handling. On some platforms (e.g., DEC alpha) g++ has very buggy exception handling support that inhibit the compilation of MICO with exception handling enabled. If this happens try turning off exception handling using this option.
`-with-qt=<qt-path>`
  Enable support for QT. `<qt-path>` is the directory where QT has been installed in.
`-with-gtk=<gtk-path>`
  Enable support for GTK. `<gtk-path>` is the directory where GTK has been installed in.
`-with-tcl=<tcl-path>`
  Enable support for TCL. `<tcl-path>` is the directory where TCL has been installed in.
`-with-ssl=<SSLeay-path>`
  Enable support for SSL. `<SSLeay-path>` is the directory where SSLeay has been installed in.

Now you should run `configure` with the proper command line options you need, e.g.:

      cd mico
      ./configure --with-qt=/usr/local/qt

Use `gmake` to start compilation and install the programs and libraries, possibly becoming root before installation:

      gmake
      gmake install

On some systems you have to take special actions after installing a shared library in order to tell the dynamic linker about the new library. For instance on Linux you have to run `ldconfig` as root:

      /sbin/ldconfig -v

[Previous: Prerequisits] [Next: Installing MICO using Visual-C++]
[Up: Installation]