List of Packages

AIFAD is a machine learning tool for "Automated Induction of Functions
over Algebraic Datatypes".

From the ergo web site:
Ergo is an automatic theorem prover dedicated to program
verification. Ergo is based on CC(X) a congruence closure algorithm
parameterized by an equational theory X. Currently, CC(X) can be
instanciated by the empty equational theory and by the linear
arithmetics.

Big Brother allows you to keep an eye on your World Wide Web links. It is
essential for webmasters and authors who wish to make sure that the links
contained in their pages are up-to-date; a chore which quickly gets out of
hand without an automated tool! It is also invaluable to those who maintain
a large list of bookmarks, since it can easily be used to check bookmark
files. Big Brother is in the public domain. 

Camlmix is a generic preprocessor which converts text with embedded OCaml
into an OCaml program with embedded text. It produces text documents from
one or several templates. OCaml toplevel statements are inserted between ##
... ##, and OCaml string expressions between ##= ... ## 

CDuce is a programming language adapted to XML processing.
Main features:
- functional
- strong static typing + dynamic dispatch
- powerful XML types and patterns (regular expressions)

Note:
CDuce can take advantage of the pxp, expat, curl, and netclient library
if available.

The CEVE package is a parser for several package formats (currently APT and
RPM), which can output package metadata to several formats (currently
GraphML and SQL)

cmigrep is a utility to mine data from caml compiled interface files

From the coq web site:
Coq is a formal proof management system: a proof done with Coq is
mechanically checked by the machine. In particular, Coq allows:

    * to define functions or predicates,
    * to state mathematical theorems and software specifications,
    * to develop interactively formal proofs of these theorems,
    * to check these proofs by a relatively small certification "kernel".

Cppo is an OCaml-friendly implementation of cpp, the C preprocessor. 

From the ergo web site:
Ergo is an automatic theorem prover dedicated to program
verification. Ergo is based on CC(X) a congruence closure algorithm
parameterized by an equational theory X. Currently, CC(X) can be
instanciated by the empty equational theory and by the linear
arithmetics.

Felix Compiler 

Frama-C stands for FRAmework for Modular Analysis of C. It provides a generic
framework (based on the CIL library) for building static analyzers for
C programs. It features an annotation language, called ACSL, in which
it is possible possible to express the formal properties that the code under
analysis is expected to meet.
Current analyzers include:
- an abstract interpreter
- a code slicer
- an impact analysis tool

IMPORTANT NOTE for user upgrading from a previous version:
Starting from  Frama-C Beryllium 20090902 and why 2.21, Jessie plug-in is 
now provided directly by apps-why. There is no local why installation anymore.

GODIVA (standing for GODI Verpacken Assistant) is a tool for creating GODI
packages from simple specification files.  It rocks! 

Headache is a simple and lightweight tool for managing headers in
source code files.

HEVEA is a LaTeX to HTML translator.  The input language is a fairly
complete subset of LaTeX2e (old LaTeX style is also accepted) and the
output language is HTML that is (hopefully) correct with respect to
version 4.0 (transitional)

Exotic symbols are translated into symbols pertaining to the
symbol font of the HTML browser, using the FACE attribute of the FONT
tag. This allows the translation to HTML of quite a lot of the symbols
used in LaTeX.

HEVEA understands LaTeX macro definitions. Simple user style
files are understood with little or no modifications.
Furthermore, HEVEA customization is done by writing LaTeX code.

HEVEA is written in Objective Caml, as many lexers. It is quite fast
and flexible. Using HEVEA it is possible to translate large documents
such as manuals, books, etc. very quickly. All documents are
translated as one single HTML file. Then, the output file can be cut
into smaller files, using the companion program HACHA.

Ledit is a line editor, allowing to use control commands like in emacs
or in shells (bash, tcsh). To be used with interactive commands.

Nurpawiki is a personal information manager (PIM) application that
combines a wiki, a to-do list and a simple scheduler to help you get
organized. It aims to ease note taking and action planning. Actions
(to-dos) are always associated with notes or plans (wiki pages).

O'Browser is an OCaml virtual machine written in Javascript, to run 
OCaml program in browsers! It is independant from Eliom and Ocsigen's
server. You can use it with any Web server.

The ocamldsort command scans a set of Objective Caml source files (.ml  
and .mli files), sorts them according to their dependencies and prints  
the sorted files in order to link their corresponding .cmo files.

ocamlweb is a literate programming tool for Objective Caml

The invocation is

ocamlweb <options and files>

It creates a single LaTeX document with both documentation and code
(implementations and interfaces) extracted from the given files.
Documentation is inserted into ocaml files as comments and thus your
files will ever compile, no matter the fact you use ocamlweb or not.
See the manual for options.

Ocsigen is a programming framework providing a new way to create dynamic web
sites. Its goal is to offer an alternative to Apache/PHP, based on cutting-edge
technologies coming from research in programming languages. With Ocsigen, you
program in a concise and modular way, with a strong type system which helps you
to produce valid xhtml. The server handles sessions, URLs, and page parameters
automatically. 

pkglab is a matlab-like navigator for package distributions; the objects one
operates on are packages, sets of packages, dates and archives. It is possible
to explore these objects in many different ways (find out whether a package is
installable w.r.t. a certain archive, for example)

A simple and fun 2d planet simulation. 

Any SAT-Solver can tell you that each of the following formulae is unsatisfiable:
P1 /\ (P1 => P2) /\ ~P2
P1 /\ (P1 => P2) /\ (P2 => P3) /\ ~P3
P1 /\ (P1 => P2) /\ (P2 => P3) /\ (P3 => P4) /\ ~P4

RegSTAB can tell you directly that this is unsatisfiable for all n>=0:
P1 /\ (/\i=1..n Pi => Pi+1) /\ ~Pn+1  

IN ENGLISH:

Any SAT-Solver can tell you that each of the following formulae is unsatisfiable:
P1 and (P1 implies P2) and not P2
P1 and (P1 implies P2) and (P2 implies P3) and not P3
P1 and (P1 implies P2) and (P2 implies P3) and (P3 implies P4) implies not P4)

RegSTAB can tell you directly that this is unsatisfiable for all n>=0:
P1 and (for i from 1 to n: Pi implies Pi+1) and not Pn+1

Tart is a utility that can spread a distribution (i.e. a set of packages with
dependencies between them) over several media (CDs, DVDs, etc.) in such a way
that any package from the distribution is installable using only the medium it
is on, or earlier media.

Tdir stands for Translation Directory, it is a replication tool
designed to assist in creating a multi vendor distributed directory
service.

UMLMON is an advanced monitor for User Mode Linux

UMLMON is an advanced monitor for User Mode Linux.
This package contains only the web interface.

The Unison file synchronizer

Why is a software verification tool. Why aims at being a verification
conditions generator (VCG) back-end for other verification tools. It
provides a powerful input language including higher-order functions,
polymorphism, references, arrays and exceptions. It generates proof obligation
for proof assistants and automated theorem provers. Some of them (namely Coq
and zenon) are available as Godi packages as well. Other ones have to be 
installed by hand. You need at least one system installed for Why to be useful.

The front-end for Why currently includes Krakatoa (for Java programs) and
Caduceus (for C programs). Caduceus is included in the Why distribution itself.

Warning: Wyrd requires remind 03.0.24 or better! Wyrd is a curses frontend
to the remind calendar program. 

This package contains the zenon theorem prover. Zenon is a first-order
automated theorem prover with equality, based on a tableaux method.
Zenon is developed by Damien Doligez at INRIA. Its main strength is that
it can output a trace of its proofs in the form of a Coq script or a Coq
term. In other words, its results can be checked by the Coq
proof-assistant (or conversely, zenon can be seen as a powerful
first-order tactic for Coq). It is also the main prover of the Focal
system.

This is the version of CURL used by GODI.

This is the version of expat used by GODI.

GNU `dbm' is a library of functions implementing a hashed database
on a disk file.  The software was written by Philip A. Nelson.

This is the version of PCRE used by GODI.

Mk is Andrew Hume's reimplementation of make. Mk is recommended by Stu
Feldman, who created make. Mk has evolved through many systems from
Bell Labs. Mk does not try to do everything but instead provides small
but coherent set of features, including especially good integration
with the shell. We use it to build Quick C--, and we're very happy.

The C code for Mk is extracted from the Plan 9 source distribution and
comes with an Open Source License. Requirements for compilation are a
C compiler and Make. The documentation includes a PDF file about Mk,
and a Unix man page.

The goal of the Subversion project is to build a version control
system that is a compelling replacement for CVS in the open source
community.

This package only includes the client for the subversion network
protocol such that you can directly access the GODI repositories. Of
course, it is also possible that you use an subversion client coming
with your OS. Check that it has at least version 1.0, and that it
supports SSL.

To build this package, libz and libssl are required.

This package configures where the BDB library is found.

This package configures where the CURL library is found.

This package configures where the expat library is found.

This package configures where freetype2 library is found.

This package configures where the GDBM library is found.

This package configures where the gdk-pixbuf for gtk 1.x library is found.

This package configures where the gif or ungif library is found.

This package configures where the glade for gtk 1.x library is found.

This package configures where the glut library can be found.

This package configures where the gmp includes and libraries can be found.

This package configures where the gnome 1.x library is found.

This package configures where the jpeg library is found.

This package configures where the gtk 1.x library is found.

This package configures where the gtkgl for gtk 1.x library is found.

This package configures where the jpeg library is found.

This package configures where BLAS and LAPACK can be found for LACAML.

This package configures where the Mysql client libraries can be found.

This package configures where the ncurses library is found.

This package configures where the opengl libraries GL and GLU are found.

This package configures where the PCRE library is found.

This package configures where the png library is found.

This package configures where the POPT library is found.

This package configures where the PostgreSQL client library is found.

This package configures where the RPM library is found.

This package configures where the SDL library is found.
SDL (Simple Direct Layer) is a video/audio/input device
API especially designed to develop games.

URL: http://www.libsdl.org

This package configures where the tcl/tk libraries can be found.

This package configures where the tiff library is found.

This package configures where the unixodbc library is found.

This package configures where the X11 library can be found.

This package configures where the xpm library is found.

This package configures where the zlib library is found.

AlphaCaml is a tool that turns a so-called `binding specification' into an
Objective Caml compilation unit. This helps writers of interpreters,
compilers, or other programs-that-manipulate-programs deal with alpha-
conversion in a safe and concise style. 

This module allows you to use in-memory data structures which are
larger than available memory and so are kept in swap.  If you try this
in normal OCaml code, you'll find that the machine quickly descends
into thrashing as the garbage collector repeatedly iterates over
swapped memory structures.  This module lets you break that
limitation.  Of course the module doesn't work by magic :-) If your
program tries to access these large structures, they still need to be
swapped back in, but it is suitable for large, sparsely accessed
structures.

Secondly, this module allows you to share those structures between
processes.  In this mode, the structures are backed by a disk file,
and any process that has read/write access that disk file can map that
file in and see the structures.

This is an annex to the standard library. It contains many useful things.

A very simple library for producing colorful text (and other effects) on
ANSI-compatible terminals. 

A small module to display colors and allow cursor movements on ANSI
compliant terminals. 

Batteries Included serves the following purposes: * define a standard set
of libraries which may be   expected on every compliant installation of
OCaml * organize these libraries into a hierarchy of modules,   with one
source of documentation * define a standard set of language extensions
which   may be expected on every compliant installation of OCaml * provide
a consistent API for otherwise independent   libraries. 

Bin-prot is a library for automated conversion of OCaml-values to and
from an efficient binary protocol.

library and camlp4 extension for data-structures with bound variables

The ocaml-bitstring project adds Erlang-style bitstrings and matching over
 bitstrings as a syntax extension and library for OCaml.

(This project was formerly known as "bitmatch").

You can use this module to both parse and generate binary formats,
 files and protocols.

Bitstring handling is added as primitives to the language,
 making it exceptionally simple to use and very powerful. 

This library implements a caching service for storing arbitrary strings
that can be located by string keys. The caching service is reachable
over TCP. The cache can be distributed over several nodes. The cache
can be saved to disk in regular intervals.

A client module is included. Both synchronous and asynchronous access
methods are defined.

Cairo is a 2D graphics library with support for multiple output devices.

Currently supported output targets include:
 X, Quartz, Win32, image buffers, PostScript, PDF, and SVG file output.

Experimental backends include OpenGL (through glitz), XCB, BeOS, OS/2,
 and DirectFB.

The cairo API provides operations similar to the drawing operators
 of PostScript and PDF.

Operations in cairo including stroking and filling cubic Bézier splines,
 transforming and compositing translucent images,
 and antialiased text rendering.

All drawing operations can be transformed by any affine transformation
 (scale, rotation, shear, etc.)

Cairo is free software and is available to be redistributed
 and/or modified under the terms of
 either the GNU Lesser General Public License (LGPL) version 2.1
 or the Mozilla Public License (MPL) version 1.1 at your option.

see, http://cairographics.org/

N.B. automake suite is required to compile this package

The Calendar library is a library providing a set of operations over dates
and times. 

Caml2html provides a command-line executable which converts a set of OCaml
source files into a HTML document with colored syntax. A library is also
provided for building web-page generators that would color OCaml code
appropriately. 

Camlidl is a stub code generator for Objective Caml.  It generates
stub code for interfacing Caml with C from an IDL description of the C
functions.  Thus, Camlidl automates the most tedious task in
interfacing C libraries with Caml programs.  It can also be used to
interface Caml programs with other languages, as long as those
languages have a well-defined C interface.

In addition, Camlidl provides basic support for COM interfaces and
components under MS Windows.  It supports both using COM components
(usually written in C++ or C) from Caml programs, and packaging Caml
objects as COM components that can then be used from C++ or C.

CamlImages is an image processing library, which provides

    * Basic functions for image processing and loading/saving various
    image file formats (hence providing a translation facility from
    format to format),
    * An interface with the Caml graphics library allows to display
    images in the Graphics module screen and to mix them with Caml
    drawings, 
    * A freetype interface, integrated into the library: you can draw
    texts into images using any truetype fonts.  

In addition, the library can handle huge images that cannot be (or can
hardly be) stored into the main memory (the library then automatically
creates swap files and escapes them to reduce the memory usage). 

The original reference manual and the tutorial for Camlp4. This refers 
to the Camlp4 version shipped until O'Caml 3.09 (which is still 
separately available as "Camlp5"). The Camlp4 version in 3.10 was 
rewritten from scratch. However, many of the interfaces and concepts 
described in this manual are still applicable.

An "appendix" to this manual is available in godi-gallium-docs, which is 
a copy of the wiki at http://brion.inria.fr/gallium, and these docs 
somehow describe the changes in the rewritten Camlp4.

This package provides the camlp5 pre-processor and pretty-printer. camlp5 is
compatible with the camlp4 implementation that was built in ocaml versions
prior 3.10, so that it is possible to use it to compile apps that rely on the
old behavior of camlp4

CamlTemplate can be used to generate web pages, scripts, SQL queries, XML
documents and other sorts of text. 

Camomile provides Unicode character type, UTF-8, UTF-16, UTF-32 strings,
conversion to/from about 200 encodings, collation and locale-sensitive case
mappings, and more 

CFG is a purely functional library for manipulating context-free grammars.

 CIL (C Intermediate Language) is a high-level representation along
with a set of tools that permit easy analysis and source-to-source
transformation of C programs.

godi-core-mk is the "make" framework of GODI, one of the core components.

The tools to create, add, remove, and list the binary packages
(.tgz files).

This is a support library to write scripts for GODI in O'Caml.
Currently, these scripts are used for conf-foo packages.

This is a binding to the unix crypt function in the standard C library

This library implements Blowfish, DES, and Triple-DES.
 

The Cryptokit library for Objective Caml provides a variety of
cryptographic primitives that can be used to implement cryptographic
protocols in security-sensitive applications. The primitives provided
include:

    * Symmetric-key cryptography: AES, DES, Triple-DES, ARCfour, in ECB,
      CBC, CFB and OFB modes. 

    * Public-key cryptography: RSA encryption and signature;
      Diffie-Hellman key agreement.

    * Hash functions and MACs: SHA-1, MD5, and MACs based on AES and
      DES.

    * Random number generation.

    * Encodings and compression: base 64, hexadecimal, Zlib compression. 

Additional ciphers and hashes can easily be used in conjunction with the
library. In particular, basic mechanisms such as chaining modes, output
buffering, and padding are provided by generic classes that can easily
be composed with user-provided ciphers. More generally, the library
promotes a "Lego"-like style of constructing and composing
transformations over character streams.

This library works under Unix and Windows.

O'Caml bindings for libcurl

Dose2 is a library for distribution analysis.

Dum is a library for inspecting the runtime representation of arbitrary
Objective Caml values. Shared or cyclic data are detected and labelled.
This guarantees that printing would always terminate. This makes it
possible to print values such as closures, objects or exceptions in depth
and without risk. 

dypgen is a GLR parser generator for Objective Caml, it is able to generate self-extensible parsers (also called adaptive parsers). Dypgen is also able to generate extensible lexers for the parsers it produces.

The main features of dypgen are:

    * dypgen is a GLR parser. This means it can handle ambiguous grammars and outputs the list of all possible parse trees. Even for non ambiguous grammars, GLR parsing allows to define the grammar in a more natural way. It is possible to extract a definition suitable for the documentation directly from the parser source file.

    * Ambiguities can be removed by introducing priorities and relations between them. This gives a very natural way to express a grammar (the examples in the documentation illustrate this).

    * Grammars are self-extensible, i.e. an action can add new rules to the current grammar. Moreover, the modifications can be local. The new grammar is valid only for a well delimited section of the parsed input.

    * dypgen provides management of local and global immutable data. The user actions can access it and return it modified. These mechanisms adress the problem posed by global mutable data with GLR parsing and let the user controls the scope of the data. Modifications of local data are preserved when traveling from right to left in a rule or when going down in the parse tree. Modifications of global data are preserved across the complete traversal of the parse tree. These data may be used for instance to do type-checking at parsing time in an elegant and acceptable way. The local data may contain the environment that associates a type to each variable while the global data would contain the substitution over types that is usually produced by unification.

    * Pattern matching for symbols in right-hand sides of rules is possible. In particular this allows guarded reductions and to bind names to the arguments of actions.

    * dypgen allows early actions, that are semantic actions performed before the end of a rule.

    * It is possible to use dypgen as the lexer generator too. In this case regular expressions that match characters strings are allowed in the right-hand side of grammar rules and it is possible to extend the lexer by introducing such rules.

    * The operators *, + and ? of regular expressions are available for non terminals and nested rules too. 

Here is an example of a parser for a small calculator which enforces the usual precedences between operators:

%start main
%relation pi<pt<pp
%layout [' ' '\t']

%parser

main: expr "\n" { $1 }

expr:
  | ['0'-'9']+      { int_of_string $1 } pi
  | "-" expr(=pi)            { -$2 }     pi
  | "(" expr ")"             { $2 }      pi
  | expr(<=pp) "+" expr(<pp) { $1 + $3 } pp
  | expr(<=pp) "-" expr(<pp) { $1 - $3 } pp
  | expr(<=pt) "*" expr(<pt) { $1 * $3 } pt
  | expr(<=pt) "/" expr(<pt) { $1 / $3 } pt

This module offers a simplified interface to the Format module of the
standard library. Input data must be converted into a tree using 3 kinds of
nodes: atoms, lists and labelled nodes. Each node is bound to its own
formatting parameters and a single function call produces the formatted
output. 

OCaml bindings for the expat XML parser

ExtLib is a project aiming at providing a complete - yet small -
standard library for the OCaml programming langage. The purpose of
this library is to add new functions to OCaml Standard Library
modules, to modify some functions in order to get better performances
or more safety (tail-recursive) but also to provide new modules which
should be useful for the average OCaml programmer.

FaCiLe is a constraint programming library on integer and integer set finite
domains written in OCaml. It offers all usual facilities to create and
manipulate finite domain variables, arithmetic expressions and constraints
(possibly non-linear), built-in global constraints (difference, cardinality,
sorting etc.) and search and optimization goals. FaCiLe allows as well to build
easily user-defined constraints and goals (including recursive ones), making
pervasive use of OCaml higher-order functionals to provide a simple and flexible
interface for the user. As FaCiLe is an OCaml library and not "yet another
language", the user benefits from type inference and strong typing discipline,
high level of abstraction, modules and objects system, as well as native code
compilation efficiency, garbage collection and replay debugger, all features of
OCaml (among many others) that allow to prototype and experiment quickly:
modeling, data processing and interface are implemented with the same powerful
and efficient language.

Online documentation at:
http://www.recherche.enac.fr/opti/facile/index.html.en

OCaml interface to FFTW version 2. FFTW, the "Fastest Fourier Transform in
the West" is a C subroutine library for computing the Discrete Fourier
Transform (DFT) in one or more dimensions. For more information about FFTW,
visit http://www.fftw.org/ 

This is the findlib package manager for O'Caml:

The "findlib" library provides a scheme to manage reusable software
components (packages), and includes tools that support this
scheme. Packages are collections of OCaml modules for which
metainformation can be stored. The packages are kept in the filesystem
hierarchy, but with strict directory structure. The library contains
functions to look the directory up that stores a package, to query
metainformation about a package, and to retrieve dependency
information about multiple packages. There is also a tool that allows
the user to enter queries on the command-line. In order to simplify
compilation and linkage, there are new frontends of the various OCaml
compilers that can directly deal with packages.

Together with the packages metainformation is stored. This includes a
version string, the archives the package consists of, and additional
linker options. Packages can also be dependent on other
packages. There is a query which finds out all predecessors of a list
of packages and sorts them topologically. The new compiler frontends
do this implicitly.

Metainformation can be conditional, i.e. depend on a set of
predicates. This is mainly used to be able to react on certain
properties of the environment, such as if the bytecode or the native
compiler is invoked, if the application is multi-threaded, and a few
more. If the new compiler frontends are used, most predicates are
found out automatically.

There is special support for scripts. A new directive, "#require",
loads packages into scripts. Of course, this works only with newly
created toploops which include the "findlib" library.

This CGI allows you to browse through the interfaces of all
packages, provided there are .mli files.

Note: flexdll is only available for Windows platforms!

Under Windows, DLL (Dynamically-Linked Libraries) are generally used
to improve code modularity and sharing. A DLL can be loaded
automatically when the program is loaded (if it requires the DLL). The
program can also explicitly request Windows to load a DLL at any
moment during runtime, using the LoadLibrary function from the Win32
API.

This naturally suggests to use DLLs as a plugin mechanism. For
instance, a web server could load extensions modules stored in DLLs at
runtime. But Windows does not really make it easy to implement plugins
that way. The reason is that when you try to create a DLL from a set
of object files, the linker needs to resolve all the symbols, which
leads to the very problem solved by FlexDLL:

Windows DLL cannot refer to symbols defined in the main application or
in previously loaded DLLs.

Some usual solutions exist, but they are not very flexible. A notable
exception is the edll library (its homepage also describes the usual
solutions), which follows a rather drastic approach; indeed, edll
implements a new dynamic linker which can directly load object files
(without creating a Windows DLL).

FlexDLL is another solution to the same problem. Contrary to edll, it
relies on the native static and dynamic linkers. Also, it works both
with the Microsoft environment (MS linker, Visual Studio compilers)
and with Cygwin (GNU linker and compilers, in Cygwin or MinGW
mode). Actually, FlexDLL implements mostly the usual dlopen POSIX API,
without trying to be fully conformant though (e.g. it does not respect
the official priority ordering for symbol resolution). This should
make it easy to port applications developped for Unix.

FrontC is an OCAML library providing a C parser and lexer. The result
is a syntactic tree easy to process with usual OCAML tree management.

It provides support for ANSI C syntax, old-C K&R style syntax and the
standard GNU CC attributes.

It provides also a C pretty printer as an example of use.

This is a dump of the Gallium wiki at http://brion.inria.fr/gallium/index.php.
It mainly contains docs about camlp4 (in the version since O'Caml 3.10),
and about ocamlbuild.

Parsing of command line arguments with a syntax à la GNU getopt.

Gaussian process regression in OCaml.

The Hweak module, containing a weak hasthable where binding disappear
if the key or the value is collected.  The Weak_memo module,
containing a class that may help to recover the true type of an
upcasted object.  

Hydro is an independent implementation of ICE, the object-oriented RPC
protocol by ZeroC, for the O'Caml programming language. This is an
early, not yet complete release, but the code is already stable and
usable. For the restrictions of this release, see below.

Hydro (like ICE) allows you to bridge language barriers by letting
components written in different programming languages communicate with
each other. ZeroC's ICE product currently includes implementations for
C++, Java, C#, Python, Ruby, VB, and PHP.  Hydro adds support for
O'Caml. The ICE protocol is rich enough to make the representation of
the data to communicate easy and convenient to use, and adopts an
object-oriented type system. ZeroC sees ICE as a superior successor to
CORBA.

Hydro includes a runtime, and a generator called hydrogen. The runtime
is fully asynchronous, based on Ocamlnet's event queues. The generator
is used to create a thin layer on top of the runtime that maps
abstract Hydro types to specific O'Caml types.  The Hydro engine
therefore appears to the programmer as if it was typed using the input
IDL file. Unlike the generators shipped by ZeroC, hydrogen does not
create marshalling code -- we see this as the task of the runtime and
not of the language mapping layer. Because of this design decision we
have high confidence in the correctness of the generator.

Although we want Hydro to be an implementation whose protocol is fully
compatible with ICE and that can process all its IDL files, we take
some freedom to deviate from what is described in ZeroC's "ICE
manual". ICE was designed with mainstream object-oriented languages in
mind, and therefore lacks many of the advanced constructs available in
O'Caml (variants, for example).  Conversely, ICE includes constructs
such as hierarchical exceptions and downcasts which do not exist in
O'Caml (and for good reason!).  To deal with the "impedance mismatch,"
we implemented emulations for these concepts.  On the other hand,
O'Caml offers advanced features which ought to be exploited by a good
implementation.  For example, in O'Caml, asynchronous networking code
is quite natural, so we have chosen to make this the default style. So
while Hydro is quite straightforward, the O'Caml programmer should not
expect a design which is a perfect one-to-one translation of what
ZeroC describes.

This is a small library for reading .ini format config files

Jane Street Core library

Jane Street Fieldslib preprocessor for generating record functions

JSON (JavaScript Object Notation) is a lightweight data-interchange
format. It is easy for humans to read and write. It is easy for
machines to parse and generate. It is based on a subset of the
JavaScript Programming Language, Standard ECMA-262 3rd Edition -
December 1999. JSON is a text format that is completely language
independent but uses conventions that are familiar to programmers of
the C-family of languages, including C, C++, C#, Java, JavaScript,
Perl, Python, and many others. These properties make JSON an ideal
data-interchange language.

This is a Camlp4 syntax extension that reads special type definitions
representing the structure of JSON data (http://json.org/) and produces
conversion functions between those types and generic JSON data of type
Json_type.t. Type Json_type.t is defined by the json-wheel library which
provides parsing and printing functions for the JSON format. 

From http://www.json.org/: "JSON (JavaScript Object Notation) is a
lightweight data-interchange format. It is easy for humans to read and
write. It is easy for machines to parse and generate. It is based on a
subset of the JavaScript Programming Language, Standard ECMA-262 3rd
Edition - December 1999." This implementation follows RFC 4627. We use
key/value lists to represent JSON objects, and lists to represent JSON
arrays. The library also provides pretty-printing and optional support for
C-style comments. 

A type-safe binding for openGL, with labltk and lablgtk support.

Note Cygwin: Although they compile, the Togl bindings (and lablgl)
do not work. The Glut bindings (and lablglut) are functional, however.

Note OS X: Togl works only if labltk was linked against the X11 version
of tcl/tk, not the Aqua version. As the latter is currently not automatically
found, it is quite likely you get the right one.

A full-fledge interface for GTK

A full-fledge interface for GTK2.
Includes support for GtkGLarea, libglade2, librsvg2, gnomecanvas2...

Note about version numbers:

The GODI package prefers the date-based version string (e.g. 20040319)
over the release-based version string (e.g. 2.2.0). The former scheme
is applicable to both development and stable versions. Here is a table
how they map to each other:

20081220 = 2.12.0
20080226 = 2.10.1
20070927 = 2.10.0
20051028 = 2.6.0
20040716 = 2.4.0
20031010 = 2.2.0

This packages provides bindings for the gtksourceview library
(http://gtksourceview.sourceforge.net/), an extension to the gtk text widget
that allows syntax highlighting for a variety of programming languages.
Note that you need to have gtksourceview installed before installing the
package.

LACAML is a linear algebra library interfacing LAPACK, BLAS and some custom
C-functions for high-performance numerical computations on bigarrays.

Lua-ML is an interpreter for version 2.5 of the Lua  programming language.

Note that you need the Perl interpreter to build this package!

Lwt (the abbreviation stands for Light-Weight Threading) is a cooperative
threading library for Ocaml. 

Contains:
- The GODI User's Guide

Menhir compiles LR(1) grammar specifications down to Objective Caml code.
It accepts legacy ocamlyacc grammar specifications, with a few caveats. It
is superior to ocamlyacc in several ways. For instance, it offers a library
of standard parameterized definitions, including options, sequences, and
lists, and allows users to define their own parameterized nonterminal
symbols. It accepts LR(1) grammars, as opposed to only LALR(1) grammars,
and attempts to explain conflicts in a readable way. See the reference
manual for a more detailed overview of Menhir. 

Micmatch is a Camlp4-based syntax extension of OCaml which extends the
match-with construct with regexps for quick and simple text manipulation.
The syntax of the regexps is an extension of the syntax of OCamllex
regexps, which are easy to learn and OCaml-friendly. Micmatch_pcre takes
advantage of most of the advanced features of the PCRE library, including
laziness, possessiveness, and lookahead and lookbehind assertions. The
compilation of regexps is performed internally and once only. If the
program is compiled successfully, then your regexps are valid, as well as
the named captures, otherwise the preprocessor reports the error
accurately. 

Mikmatch/Micmatch is a Camlp4-based syntax extension of OCaml which extends
the match-with construct with regexps for quick and simple text
manipulation. The syntax of the regexps is an extension of the syntax of
OCamllex regexps, which are easy to learn and OCaml-friendly. Mikmatch_pcre
takes advantage of most of the advanced features of the PCRE library,
including laziness, possessiveness, and lookahead and lookbehind
assertions. The compilation of regexps is performed internally and once
only. If the program is compiled successfully, then your regexps are valid,
as well as the named captures, otherwise the preprocessor reports the error
accurately. Mikmatch with a K is for the new Camlp4 while Micmatch with a C
is for Camlp5. 

From a module for function composition to an implementation of "rm -rf",
missinglib is full of goodies. 

GMP (GNU MP) is an extended precision computation library (integers, rationals, floats). I did the interface with O'Caml. It's used easily and transparently. 

This program is free software.

Mlpost is an Objective Caml interface to Metapost.

(texlive-metapost and texlive-context are required)

This is the core of the Objective Caml language environment.
It contains the runtime environment, the compilers, and the
core libraries unix, str, bigarray, nums, dbm, threads.

The thread model can be either "bthr" (bytecode threads) or
"pthr" (POSIX threads), depending on the configuration.

The dbm library is always linked against GDBM (the real GDBM,
not the compatibility NDBM layer).

The graphics library can be found in pkg godi-ocaml-graphics,
and the labltk library can be found in pkg godi-ocaml-labltk.

This package does not install the Emacs mode distributed
with OCaml.

ABOUT OBJECTIVE CAML:

Citing the homepage:

"Caml is a programming language, easy to learn, easy to use, and yet
amazingly powerful. -- It is developed and distributed by INRIA (the
main French research institute for computer science), since 1984. It
is freely available for Unix, PC or Macintosh. -- There exist two
flavors of Caml: Caml Light and Objective Caml. Caml Light is merely a
subset of Objective Caml, especially designed for teaching and
learning the art of programming.  In addition to the Caml Light's core
language, Objective Caml features a powerful modules system, full
support to object-oriented paradigm, and an optimizing compiler."

"Objective Caml is the latest implementation of the Caml dialect of ML."

"Objective Caml is an implementation of the Caml dialect of ML extended
with class-based objects and a powerful module system in the style of
SML's. It continues the Caml Light effort in many ways (separate
compilation, low memory requirements, fast turnaround through bytecode
interpretation), but also significantly departs from Caml Light on
other points (objects, the module calculus, and a high-performance
native-code compiler).

Objective Caml continues an earlier implementation of Caml plus
modules, known as Caml Special Light. The only difference between
Objective Caml and Caml Special Light is the addition of objects."

"Objective Caml is a general purpose programming language that
combines functional, imperative, and object-oriented programming. The
language is statically typed; its type system ensures the correct
evaluation of programs. Types are automatically inferred. The language
offers powerful constructions such as user-definable data-types, the
ability to define functions by pattern-matching, and an exception
mechanism. Programming in the large is facilitated by a full-fledge
class-based object-oriented layer and an expressive module system."

------------------------------

Informal runtime dependencies:
- The C compiler is needed (same as at build time), and the tools
  required by the C compiler (assembler, linker).
- Maybe objcopy is needed.

This is a meta package; install it to get all components
of the official O'Caml distribution at once.

This library can write CSV files, including all extensions used by Excel -
eg. quotes, newlines, 8 bit characters in fields, "O etc.

This package contains the NDBM library of Objective Caml.
It is linked with the GDBM C library.

Le but de ocaml-fileutils est de fournir un ensemble de fonction OCaml afin de
permettre la manipulation de fichier directement en OCaml.

The goal of ocaml-fileutils is to provide a set of ocaml functions in order to
allow manipulation of files directly in ocaml.

This package contains the graphics library of Objective Caml.

From the manual:

"The graphics library provides a set of portable drawing
primitives. Drawing takes place in a separate window that is created
when open_graph is called. ... Unix: This library is implemented under
the X11 windows system."

------------------------------

Informal runtime dependencies:

- The X11 client libraries must be installed.

OCaml HTTP is a simple OCaml library for creating HTTP daemons, it is largely
inspired to the Perl's HTTP:: modules family.

This package contains the labltk and camltk libraries of Objective Caml.
Furthermore, ocamlbrowser is included.

From the manual:

"The labltk library provides access to the Tcl/Tk GUI from Objective
Caml programs. This interface is generated in an automated way, and
you should refer to Tcl/Tk books and man pages for detailed
information on the behavior of the numerous functions. We also suggest
to use ocamlbrowser to see the types of the various functions, that
are the best documentation for the library itself. ... Unix: The
labltk library is available for any system with Tcl/Tk installed,
starting from Tcl 7.5/Tk 4.1 up to Tcl/Tk 8.3. Beware that some beta
versions may have compatibility problems."

For this version of OCaml the labltk library includes full support
for the older camltk interface (by a compatibility layer).

About ocamlbrowser:

"... OCamlBrowser, a source and compiled interface browser, written
using LablTk. This is a useful companion to the programmer.

Its functions are:

    * navigation through Objective Caml's modules (using compiled interfaces).
    * source editing, type-checking, and browsing.
    * integrated Objective Caml shell, running as a subprocess."

------------------------------

Informal runtime dependencies:

- It is required that the X11 client libraries are installed.
- It is required that the tcl/tk libraries are installed.

The reference manual of Objective Caml, HTML-formatted

Bindings for interacting with MySQL databases from ocaml.

This package contains the already configured but not yet
compiled sources of the Objective Caml system.

This is a binding to OpenSSL for Ocaml, it allows to use both client and server side secure sockets.

OCaml-Text is a library for dealing with ``text'', i.e. sequence of 
unicode characters, in a convenient way. 

It supports:

  - character encoding/decoding using iconv
  - manipulation of text as UTF-8 encoded strings
  - localised text functions such as compare, upper, ...
  - human readable regular expression inside patterns

In order to be the compatible with other ocaml library without pain,
OCaml-Text choose to use only regular strings for dealing with text.

* Requirement

OCaml-Text needs ocaml >= 3.11 and libiconv. It require also pcre
bindings for ocaml to have regular expression support.

XML-RPC library for clients and servers. Stubs are generated from
.idl files.

This is an OCAML binding to the Berkely DB library.

The ocamlbuild users' manual by Berke Durak and Nicolas Poillard

Ocamldap is a toolkit for querying, and creating LDAP directory
services. It also contains useful modules for dealing with the data
once you get it.

ocamldbi is a database independent layer for Objective CAML (OCaml)
patterned upon Perl DBI.

Copyright (C) 2003 Merjis Ltd. (http://www.merjis.com/)

The GODI version of ocamldbi supports drivers for: PostgreSQL, MySQL,
and generic access via ODBC.

ocamldbi is distributed under the GNU Library General Public License
(see file COPYING.LIB for terms and conditions).

ocamldbi was mainly written by Richard W.M. Jones
(rich@annexia.org). See file AUTHORS for other contributors.

OCamlDuce is a modified OCaml compiler with built-in support for XML
types and patterns from CDuce.

OcamlGraph is a graph library for Objective Caml.

The GNU Scientific Library (GSL) is a numerical library for C and C++ (and
now OCaml) programmers.  The library provides a wide range of mathematical
routines such as random number generators, special functions and
least-squares fitting. 

This is Markus Mottl's OCamlMakefile, a generic Makefile for GNU make
one can include into one's own Makefile.

ocamlnet-2 distributes the following libararies:

- netstring: a library of string processing functions related to Internet
  protocols (formerly known as "netstring" and distributed separately):
  MIME encoding/decoding, Date/time parsing, Character encoding
  conversion, HTML parsing and printing, URL parsing and printing,
  OO-representation of channels, and a lot more.

- cgi or netcgi1: implementations for classic CGI, for FastCGI and AJP (Jakarta
  connector)

- netcgi2: Revised CGI implementation, also with support for FastCGI,
  AJP, SCGI

- netcgi2-plex: Standalone FastCGI/AJP/SCGI servers

- equeue: a generic implementation of queues of events of any
  type, and a specific implementation of queues of file descriptor
  events.

- shell: event-queue compatible invocation of external commands

- netclient: an HTTP, a Telnet, and an incomplete FTP client

- nethttpd: a HTTP server

- netplex: a generic server framework

- netshm: shared memory for IPC

- rpc: a SunRPC implementation

- rpc-generator: the generator for rpc

- rpc-xti: (for System V platforms only:) add-on to connect to local
  XTI-based rpc services

- pop: a simple POP 3 client

- smtp: an SMTP client

This package is the Glib/gtk1 extension of ocamlnet.

This package is the Glib/gtk2 extension of ocamlnet.

This package is the SSL extension of ocamlnet.

This package is the Tcl extension of ocamlnet.

O'Caml bindings for ODBC. This package is pre-configured for the
unixodbc library (ocamlodbc supports some direct database drivers
as well, but I have only chosen the unixodbc driver because of its
flexibility).

In order to connect to a database, you need not only the unixodbc
library but also an ODBC driver, and an ODBC configuration
(odbcinst.ini and odbc.ini). See http://www.unixodbc.org for
documentation.

Notes for package developers: ocamlodbc supports several database
systems directly, i.e. without unixodbc. When somebody wants to
make this code available for GODI, this should be done as a separate
package. For instance, a package directly connecting to a
MySQL database system could be named ocamlodbc-mysql. Please avoid
name conflicts, especially the .so stub library should have a
different name. It is ok that it is impossible to load two different
ocamlodbc instances into the same executable (because of symbol
conflicts on the C level).

ocamlscript compiles scripts into native code for optimal speed and ease of
use. 

O'Caml bindings for SDL, the Simple Direct Layer. This is an API
to write games. It provides access to video, audio, and input
devices like joysticks.

Scheme interpreter written by OCaml. It can be used as an extension
language for an OCaml application.

OMake is a build system designed for scalability and portability. It uses a
syntax similar to make utilities you may have used, but it features many
additional enhancements, including the following.

  - Support for projects spanning several directories or directory hierarchies.
  - Fast, reliable, automated, scriptable dependency analysis using MD5 digests,
    with full support for incremental builds.
  - Fully scriptable, includes a library that providing support for standard
    tasks in C, C++, OCaml, and LaTeX projects, or a mixture thereof.

    Often, a configuration file is as simple as a single line

    .DEFAULT: $(OCamlProgram prog, foo bar baz)

    which states that the program "prog" is built from the files foo.ml,
    bar.ml, and baz.ml. This one line will also invoke the default standard
    library scripts for discovering implicit dependencies in OCaml files
  - Full native support for rules that build several files at once.
  - Portability: omake provides a uniform interface on Linux/Unix (including
    64-bit architectures), Win32, Cygwin, Mac OS X, and other platforms that are
    supported by OCaml.
  - Built-in functions that provide the most common features of programs like
    grep, sed, find, and awk. These are especially useful on Win32.
  - Active filesystem monitoring, where the build automatically restarts
    whenever you modify a source file. This can be very useful during the
    edit/compile cycle.
  - A built-in command-interpreter osh that can be used interactively.

OMake preserves the style of syntax and rule definitions used in
Makefiles, making it easy to port your project to OMake. There is no need
to code in Perl (cons), or Python (scons). However, there are a few things
to keep in mind:

 1. Indentation is significant, but tabs are not required.
 2. The OMake language is functional: functions are first-class and there are no
    side-effects apart from I/O.
 3. Scoping is dynamic.

OMake is licensed under a mixture of the GNU GPL license (OMake engine
itself) and the MIT-like license (default configuration files).

To try it out, run the command "omake --install" in a project directory,
and modify the generated OMakefile.

OMake 0.9.8.5 is an alpha release.  While we have made an effort to ensure
that it is bug-free, it is possible some functions may not behave as you
would expect.  Please report any comments and/or bugs to the mailing
list omake@metaprl.org

===== Oni =====

Oni is an assortment of Objective Caml libraries of general interest and also
specifically for developing new Internet application layer protocols. (Formerly
known as OCaml NAE on sourceforge.net)

Highlighted features include:

- Functional streams and stream processors (extended).
- Functional bootstrapped skew-binomial heap.
- Functional red-black binary tree (associative array).
- Functional sets based on red-black binary tree.
- Functional real-time catenable deque.
- Functional LL(x) parsing using state-exception monad.
- Functional lazy deterministic finite automaton (DFA).
- Functional lexical analyzer (using lazy DFA and monadic parser).
- Functional substring list manipulation (message buffer chains).
- Gregorian calendar date manipulation.
- Standard time manipulation.
- System time in Temps Atomique International (TAI).
- Unicode transcoding.
- Universal resource identifier (URI) manipulation.
- Extended socket interface (supports more options, and UDP w/multicast).
- I/O event multiplexing (with Unix.select).

The distribution builds with OMake and includes the following subpackages:

  oni.cf    - Core foundation [included by default]
  oni.nx    - Extended socket interface
  oni.iom   - I/O event multiplexing

--j h woodyatt <jhw@conjury.org>
  San Francisco, CA

From the Ott website:

Ott is a tool for writing definitions of programming languages and
calculi. It takes as input a definition of a language syntax and
semantics, in a concise and readable ASCII notation that is close to
what one would write in informal mathematics. It generates LaTeX to
build a typeset version of the definition, and Coq, HOL, and Isabelle
versions of the definition. Additionally, it can be run as a filter,
taking a LaTeX/Coq/Isabelle/HOL source file with embedded (symbolic)
terms of the defined language, parsing them and replacing them by
target-system terms. For a simple example, here is an Ott source file
for an untyped call-by-value lambda calculus (test10.ott), and the
generated LaTeX (compiled to pdf) and (compiled to ps), Coq, Isabelle,
and HOL definitions.

Most simply, the tool can be used to aid completely informal LaTeX
mathematics. Here it permits the definition, and terms within proofs
and exposition, to be written in a clear, editable, ASCII notation,
without LaTeX noise. It generates good-quality typeset output. By
parsing (and so sort-checking) this input, it quickly catches a range
of simple errors, e.g. inconsistent use of judgement forms or
metavariable naming conventions.

That same input can be used to generate formal definitions, for Coq,
HOL, and Isabelle. It should thereby enable a smooth transition
between use of informal and formal mathematics. Additionally, the tool
can automatically generate definitions of functions for free
variables, single and multiple substitutions, subgrammar checks
(e.g. for value subgrammars), and binding auxiliary functions. (At
present only a fully concrete representation of binding is supported,
without quotienting by alpha equivalence.)

OUnit is a unit test framework for OCaml by Maas-Maarten 
Zeeman <mmzeeman@xs4all.nl>. 

OUnit is based on HUnit, a unit testing framework for Haskell.

Online documentation is available at:
http://www.xs4all.nl/~mmzeeman/ocaml/ounit-doc/OUnit.html

This is a small library for generating English pronounceable, but
reasonably secure passwords.

OCaml bindings for "Perl compatible regular expressions"

Pomap is a purely functional library for manipulating partially ordered maps.

This libraries allows an OCaml program to query a PostgreSQL database
backend.

THIS IS THE DEPRECATED VERSION PROVIDED BY ALAIN FRISCH! Well, there
is still software needing it...

This library allows an OCaml program to query a PostgreSQL database
backend.

This is the version maintained by Markus Mottl.

PXP is a validating parser for XML-1.0 which has been written entirely in
Objective Caml.

PXP means "Polymorphic XML parser" and emphasizes its most useful property:
that the API is polymorphic and can be configured such that different objects
are used to store different types of elements.

RE is a regular expression library for OCaml.  It is still under
development, but is already rather usable.

The following styles of regular expressions are supported:
- Perl-style regular expressions (module Re_perl);
- Posix extended regular expressions (module Re_posix);
- Emacs-style regular expressions (module Re_emacs);
- Shell-style file globbing (module Re_glob).

It is also possible to build regular expressions by combining simpler
regular expressions (module Re)

The most notable missing features are back-references and
look-ahead/look-behind assertions.

The matches are performed by lazily building a DFA (deterministic
finite automata) from the regular expression.  As a consequence,
matching takes linear time in the length of the matched string.

The compilation of patterns is slower than with libraries using
back-tracking, such as PCRE.  But, once a large enough part of the
DFA is built, matching is extremely fast.

React is an OCaml module for functional reactive programming (FRP). It
provides support to program with time varying values : applicative
events and signals. React doesn't define any primitive event or
signal, this lets the client chooses the concrete timeline.

Res is a library for resizable arrays, strings, and generally contiguous
datastructures.

Scheme interpreter written by OCaml. It can be used for an extension
language for an OCaml application. 

Sexplib is a library for automated conversion of OCaml-values to and from
S-expressions.  This is the version for OCaml 3.10 and later.

This library allows an OCaml program to query SQLite3 databases.

This is the version maintained by Markus Mottl.

This is a syslog client implementation

godi-tools currently only contains godi_console, the package
management utility.

Tophide hides toplevel values whose name starts with an underscore. This is
useful for some Camlp4 syntax extensions that produce lots of global
identifiers that should remain hidden. 

The type-conv mini library factors out functionality needed by different
preprocessors that generate code from type specifications, because this
functionality cannot be duplicated without losing the ability to use
these preprocessors simultaneously.

ulex is a lexer generator implemented as an OCaml syntax extension,
and with support for Unicode encodings.

WDialog is an advanced system to create dialog-centric web applications.

Feature list:

    * Separation of the user interface (UI) definition from the
      backend program, improving the structure of the application and
      enabling advanced software engineering processes

    * The UI definition is contained in an XML file, and it describes
      the whole UI from the overall dialog structure to the style of
      the individual HTML element

    * The dialogs have built-in persistency for session state. The
      HTML form elements can be tied to dialog variables reflecting
      their current state

    * A powerful template system manages the combination of individual
      HTML fragments to whole pages

    * The dialogs behave like GUI widgets. They visualize the state of
      the session, and user clicks are treated like events that are
      handled by programmable callback methods

    * The callbacks are written in a real programming language
      (Objective Caml, or Perl), making it possible to formulate all
      algorithms and to use all system resources

    * The application can run as CGI as well as application server

    * The WDialog toolkit itself does not require any database as
      backend store

    * WDialog preprocesses all web inputs, and ensures that minimum
      security standards are fulfilled

--

Note: This GODI package omits the Perl bindings.

The reference manual of WDialog, HTML-formatted

XML Light is a minimal XML parser & printer for OCaml. It provides
functions to parse an XML document into an OCaml data structure, work with
it, and print it back to an XML document. 

String functions for O'Caml

This is a camlp4 extension that expands brace expansions like a shell
does. 

This library provides easy access to compressed files in ZIP and GZIP
format, as well as to Java JAR files.  It provides functions for reading
from and writing to compressed files in these formats.