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 (, libname.pc,, 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's,, 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,

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 
Debra Avtgis.


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
William Snyder
Last modified: Mon Nov 21 22:52:48 EST 2005