CFFI, the Common Foreign Function Interface, purports to be a
portable foreign function interface for Common Lisp. The CFFI library
is composed of a Lisp-implementation-specific backend in the CFFI-SYS
package, and a portable frontend in the CFFI package.
The CFFI-SYS backend package defines a low-level interface to the
native FFI support in the Lisp implementation. It offers operators
for allocating and dereferencing foreign memory, calling foreign
functions, and loading shared libraries. The CFFI frontend provides
a declarative interface for defining foreign functions, structures,
typedefs, enumerated types, etc. It is implemented in portable ANSI
CL making use of the low-level operators exported by CFFI-SYS.
Log::Dispatch is a suite of OO modules for logging messages to multiple
outputs, each of which can have a minimum and maximum log level. It is
designed to be easily subclassed, both for creating a new dispatcher
object and particularly for creating new outputs.
It also allows both global (dispatcher level) and local (logging object)
message formatting callbacks which allows greater flexibility and should
reduce the need for subclassing.
Subclassing is only needed to send a message to a different output, not
to change the message format.
A program that takes as input a series of C source files and produces a
LaTeX or HTML document containing a cross reference of the
files/functions/variables in the program, including documentation taken
from suitably formatted source code comments.
The documentation is stored in the C source file in specially formatted
comments, making it simple to maintain. The cross referencing includes
lists of functions called, callers of each function, usage of global
variables, header file inclusion, macro definitions and type
definitions. Works for ANSI C, including a few gcc extensions.
Termbox is a library that provides a minimalistic API which allows the
programmer to write text-based user interfaces. The library is
crossplatform and has both terminal-based implementations on *nix
operating systems and a winapi console based implementation for
Windows operating systems. The basic idea is an abstraction of the
greatest common subset of features available on all major terminals
and other terminal-like APIs in a minimalistic fashion. Small API
means it is easy to implement, test, maintain and learn it, that's
what makes the termbox a distinct library in its area.
The (general | GNU) template generation tools are a set of scripts
for creating a whole set of sources, which may already be compiled
and installed by using the GNU development tools. Think of gtgt as
a program which is able to create an already compilable, very
sophisticated "hello world" program, written in C or C++ and
constituted by a main program, two internal modules (classes), one
static and one shared library. Using gitty-gitty you will get a
template of sources for the main cases you might meet, and which
you can also use as examples for automake, autoconf and so on.
C/C++ preprocessor defines and expands macros and processes '#if',
'#include' and some other directives.
MCPP is an alternative C/C++ preprocessor with the highest conformance.
It supports multiple standards: K&R, ISO C90, ISO C99, and ISO C++98.
MCPP is especially useful for debugging a source program which use
complicated macros and also useful for checking portability of a source.
Though mcpp could be built as a replacement of GCC's resident
preprocessor or as a stand-alone program without using library build of
mcpp, this package installs a program named 'mcpp' which links shared
library of libmcpp and behaves independent from GCC.
This driver uses a database table to store the cache for CHI.
The newest versions of MySQL and SQLite are known to work.
Other RDBMSes should work.
Why cache things in a database? Isn't the database what people are trying to
avoid with caches? This is often true, but a simple primary key lookup is
extremely fast in many databases and this provides a shared cache that can be
used when less reliable storage like memcached is not appropriate. Also, the
speed of simple lookups on MySQL when accessed over a local socket is very hard
to beat. DBI is fast.
The Carp routines are useful in your own modules because they act like die() or
warn(), but with a message which is more likely to be useful to a user of your
module. In the case of cluck, confess, and longmess that context is a summary of
every call in the call-stack. For a shorter message you can use carp or croak
which report the error as being from where your module was called. There is no
guarantee that that is where the error was, but it is a good educated guess.
AutoDia is a modular application that parses source code or data (if a
handler is available) and produces an XML document in Dia format,
essentially a Dia diagram auto creation package. The diagrams it creates
are standard UML diagrams showing dependencies, superclasses, packages,
classes and inheritances, as well as the methods, etc of each class.
AutoDia supports any language that a Handler has been written for -
currently this is C++, DBI, Java, PHP, Perl, Python, SQL and Torque (XML
DB schema).
Adding a handler is easy - read the DEVELOP file for details.
File::Slurp::Tree provides functions for slurping and emitting trees of files
and directories.
# an example of use in a test suite
use Test::More tests => 1;
use File::Slurp::Tree;
is_deeply( slurp_tree( "t/some_path" ), { foo => {}, bar => "sample\n" },
"some_path contains a directory called foo, and a file bar" );
The tree data structure is a hash of hashes. The keys of each hash are names of
directories or files. Directories have hash references as their value, files
have a scalar which holds the contents of the file.