Table of Contents
What is RPSL?
RPSL (Rapid Prototyping Shared Library) is a small set of bash scripts
and utility files that coordinate the GNU autotools and pkg-config for
both developing and distributing C/C++ projects. RPSL can support a single,
self-contained executable project as an autotools directory tree, but the
system of scripts and dependency support is designed to build a heirarchy of
An RPSL project, then, consists of a collection of libraries and one or more
executables. Each of these is a separate autotools tree and generates a
separate target. A principle is that the small library module is the unit of
sharing, reuse, versioning and maintenance. To this end, RPSL supports a
stand-alone autotools source tree that contains the dependency specifications,
build tools and the source for one library in a shallow directory tree.
Unlike a more general GNU autotools tree, such as the hello world example, RSPL
doesn't support multiple libraries or executable targets in one tree. With
RPSL there is exactly one library or executable target per tree and these
separate components of a larger project are connected by the compile and link
Each library or executable source directory tree has a specific form that must
be followed. Basically it has a top level with utility files, and a main source
level with headers and implementation files. An optional second level of
source subdirectories is available but only needed in special cases. With this
form, the developer only edits one short, ascii dependency file called
rpslParams, and the source files. RPSL bash scripts take care of the rest by
writing all needed inputs for a full autotools configure and make.
With this system, installs are done to a location specified by the developer
that does not assume root access. Under this location the targets are placed in
the traditional locations: usr/local/bin, user/local/include and usr/local/lib.
RPSL employs the pkg-config tool to make subsequent including and linking
RPSL either contains or supports all the key elements of software process such
as source code configuration management and versioning.
In summary, RPSL integrates the following components:
1) A set of bash scripts that coordinate and simplify the use of automake,
autoconf, libtool and pkg-config. Specifically, there are scripts that start
a new tree, add source skeletons, scan for source code and generate the
autotools input files (Makefile.am, libname.pc, configure.ac), and run
2) Support for an optional three-level development hierarchy: global site
libraries, project-specific libraries, and individual developer sandboxes.
Here, sandbox means a developer source and install tree that is separate from
the project tree where the source modules are connected as CVS sandboxes to
the project source module repository.
3) A single, user-edited ascii parameter file for each library and executable
module that defines inter-library dependencies.
4) Complete documentation with procedures for all operations such as starting
a library, specifying the dependencies and versions, adding source files,
defining compiler flags, updating the makefiles and installing targets.
Customization is available for each of the steps, but the default configuration
works well right out of the box and it is easy to get started.
Specifically, a library can be started, populated, built, and installed with
the following commands:
% rpslNewLibTree <mylibname> <namespace> (autotools directory structure)
% rpslNewClass <className> (starts a new C++ class file for editing)
% rpslSyncBuild (writes Makefile.am's, configure.ac, and bootstraps)
% runConfigure (calls configure with default install target locations)
% make (makes locally)
% make install (installs the library targets)
That's all there's to it!
RPSL comes with a complete html documentation package. An example of building
a simple library and executable module is given in the documentation. It takes
a short time to try out once a few environment variables and paths are set.
The GNU autotools offer significant capabilities for static and shared object
creation and versioning across a wide variety of Unix platforms. Because of
various reasons, however, they are not easy to use. RPSL automates the autotools
suite by the use of standardized directory tree structures and a source code file
Other build systems to consider for C++ include simple makefiles, Maven for Ant,
sCons, BJam, and any built into an IDE, such as Eclipse CDT managed make.
Other automation tools exist for autotools as well, for example, see
autotoolset. This mostly just generates the directory tree. Also look
through the software library at the free software foundation, www.gnu.org.
RPSL is compatible with any IDE that can work with autotools and make. For
example RPSL works as a build system for an Eclipse CDT C++ Standard Build
project. Users can call the RPSL scripts with a pull-down menu from the
Eclipse external command featre. RPSL is also compatible with source configuration
management tools such as CVS.
RPSL was written by William C. Snyder and used on several projects before
releasing as a GPL package in 2005. All of the documentation and scripts are
Copyright 1997-2005 William Snyder and released under the GNU Public License (GPL).
RPSL was made better by help and comments from Douglas Turner, Monica Burke and
My main reference was:
"GNU autoconf, automake, and libtool" by Gary V. Vaughan, Ben Elliston, Tom
Tromey, and Ian Lance Taylor. This is sometimes known as the "goat book."
The entire book is available for free on line: Goat Book.
I also used "Murray's Web Pages:"
Using Automake and Autoconf with C++
Building C/C++ libraries with Automake and Autoconf
And I used the web pages for the autotools, libtool, and pkg-config:
Table of Contents
Last modified: Mon Nov 21 22:52:48 EST 2005