Import ossp-ex-1.0.6 as wip/ossp-ex.

OSSP ex is a small ISO-C++ style exception handling library for use in the ISO-C
language. It allows you to use the paradigm of throwing and catching exceptions
in order to reduce the amount of error handling code without making your program
less robust.

This is achieved by directly transferring exceptional return codes (and the
program control flow) from the location where the exception is raised (throw
point) to the location where it is handled (catch point) -- usually from a
deeply nested sub-routine to a parent routine. All intermediate routines no
longer have to make sure that the exceptional return codes from sub-routines are
correctly passed back to the parent.

The OSSP ex facility also provides advanced exception handling features like
shielded and deferred exceptions. Additionally, OSSP ex allows you to choose the
used underlying machine context switching facility and optionally support multi-
threading environments by allowing you to store the exception catching stack in
a thread-safe way.
Import ossp-l2-0.9.13 as wip/ossp-l2.

OSSP l2 is a C library providing a very flexible and sophisticated Unix logging
facility. It is based on the model of arbitrary number of channels, stacked
together in a top-down data flow tree structure with filtering channels in
internal nodes and output channels on the leave nodes.

Channel trees can be either constructed manually through lower-level API
functions or all at once with a single API function controlled by a compact
syntactical description of the channel tree. For generating log messages a
printf-style formatting engine is provided which can be extended through
callback functions. The data flow inside the channel tree is controlled by
(eight fixed and nine custom) logging message severity levels which are assigned
to each individual channel.

Channels are implemented by channel handlers which can be even customer supplied
for creating own channels which seamlessly integrate into the framework. For
convenience reasons, OSSP l2 already ships with pre-implemented filtering (noop,
filter, prefix, buffer) and output (null, fd, file, pipe, socket, syslog, smtp)
channels which already cover mostly all use cases of logging.
Import ossp-sa-1.2.6 as wip/ossp-sa.

OSSP sa is an abstraction library for the Unix socket application programming
interface (API) featuring stream and datagram oriented communication over Unix
Domain and Internet Domain (TCP and UDP) sockets. It provides the following key
features: address abstraction (local, IPv4, and IPv6), type abstraction, I/O
timeouts, I/O stream buffering and convenience I/O functions.
Import ossp-val-0.9.4 as wip/ossp-val.

OSSP val is a flexible name to value mapping library for C variables. It is a
companion library to OSSP var. It allows one to access C variables through name
strings, although the C language does neither provide such a dedicated facility
nor an evaluation construct (which could be used to implement such a facility
easily).

In general, this is used for accessing C variables without having to know the
actual symbol/address/reference. The typical use cases are in combination with
flexible configuration parsing and supporting loosly-coupled DSO-based module
architectures.
Import ossp-var-1.1.3 as wip/ossp-var.

OSSP var is a flexible, full-featured and fast variable construct expansion
library. It supports a configurable variable construct syntax very similar to
the style found in many scripting languages (like @name, ${name}, , etc.) and
provides both simple scalar (${name}) and array (${name[index]}) expansion, plus
optionally one or more post-operations on the expanded value (${name:op:op...}).

The supported post-operations are length determination, case conversion,
defaults, postive and negative alternatives, sub-strings, regular expression
based substitutions, character translations, and padding. Additionally, a meta-
onstruct plus arithmetic expressions for index and range calculations allow
(even nested) iterations over array variable expansions
(..[..${name[#+1]}..]..). The actual variable value lookup is performed through
a callback function, so OSSP var can expand arbitrary values.