Software Map

GNU/Liberty Basic Compiler Collection (GLBCC) is a suite of tools that allow Liberty Basic source code to be compiled directly to executable programs. It leverages greatly off of the GNU Compiler Collection, which allows it to run both on Windows and Linux, while also having the ability to generate both Linux and Windows executables on Linux via the Mingw cross compiler. The suite also includes a frontend program that has both a GUI and CLI to provide a simple environment to compile Liberty Basic code.

xcb-proto contains descriptions of the X Window
System core protocol and selected extensions in an
XML-based data format. They are used by the X C
Binding (XCB) library to generate much of its
code, but you can also use these descriptions for
other purposes, such as decoding the X protocol or
building X Window System bindings for other languages.

This package can be used to emulate class namespaces under PHP 5. It parses PHP code to extract namespace definition statements. The code is rewritten to emulate the namespace support in a way similar to the Java language supports namespaces. This package implements new commands named package and import. The package command defines the package to which a class belongs. The import command indicates that the package should be imported for use in the PHP script on which the import command is used.

pilot-template will generate the skeleton code,
Makefiles, icons, etc. for programming for the
Palm Pilot using open source tools. This version
was modified to work with PalmOS SDK 5.x.

CGI::Application::Generator provides a means by
which a CGI::Application-based module can be
created from code, as opposed to being written by
hand. This module is intended to create the shell
of an application module, based on the
specification you provide. It will not output a
completely functional application without
additional coding. It will, however, create the
structural parts of your application common to all
CGI::Application-based modules. This module is
intended to ease the creation of new
CGI::Application modules and to encourage
standardization of CGI::Application coding styles.

The Abacus Formula Compiler (AFC) compiles
computations defined in spreadsheet files directly
to Java byte code. Users can thus customize an
application using Excel or OpenOffice Calc. AFC
compiles against your own Java interfaces to
obtain input values and compute output values (it
essentially generates strategy implementations for
you), and supports internal computations with
either double or BigDecimal (for financial
applications).

Freefactor is a Java refactoring framework. It
consists of a tool-independent refactoring system
and an interface to allow it to be integrated with
other tools. Currently, a prototype Java-based
tool is provided as well as bindings for Emacs.

Cameleon a Framework for developing reliable
database applications in a technology independent
and predominantly editorial way. User interfaces
may be easily exchanged from Swing to HTML and
vice versa, and databases may be exchanged in the
same manner. The Swing variant framework is
established. The HTML user interface is under
construction but can be reviewed on the project
Webpage ("Test sample application"). Cameleon's
target users are programmers who manage midrange
data volumes (from thousands to millions of
database records) and who prefer simplicity and
availability rather than animation. Business
features such as security management and parameter
administration are supported in the framework. The
framework allows web developement without any
knowledge of JSP, HTML, Servlets etc. Data input
elements (and groups of them) may be used in Java
Server Pages.

MySqueaks is a PHP class that allows you to create
MySQL statements with the flexibility of OOP and
throws in a simple database interface as well.
This means that you can create PHP objects to
represent your database tables and use the various
methods provided to select, update, or delete
data. This also means that instead of having to
write out a very long SQL query, you can simply
convert the representation into a series of
"steps", which can be easier to understand and debug.