Free structural software for linux

lx_lib handles memory allocations as structures, keeping important information such as the remaining allocated space and the length of the used string internal to each variable (or descriptor).
Much of it was initially inspired by Dan Bernsteins stralloc library, but the two are not compatible, nor has there ever been any intention to make them compatible.
Main features:
- strings need not be scanned to determine their length
- the amount of allocated string remaining is easily determined
- promotes more secure programming practices
- if used correctly, lx_lib can offer a significant speed increase over traditional methods
- easy-to-use methods for manipulating strings
- generic descriptor support for buffered i/o
- generic descriptors enable fast scanning of input for specific characters (e.g. a newline)
Enhancements:
- Bits of the lx_map() interface have been updated for use with the 20060228-1 release of libnaw.

Shotoku is designed to provide easy access to content repositories in which you can store data, revision content, bind metadata, and provide branching and merging strategies.
This means Shotoku can interface with repositories such as the Java Content Repository (JSR 170: JCR), Subversion, and file-system based repository implementations that aim to support basic revisioning mechanisms.
Main features:
- Three content managers: the first and default SVN-based, JCR-based and a local file system repository.
- Because a local working copy is present, data reading is very fast (SVN repository implementation).
- Data writing is reliable, because data is sent straight to the repository, without touching the working copy (SVN repository implementation).
- Shotoku can work in "embedded" mode in stand-alone applications, as well as a component in an application server.
- Shotoku allows you to "inject" content into any POJO using annotations (currently supported only in app server mode). POJOs which are Shotoku aware are automatically updated when a user updates a node in a Subversion repository Shotoku is configured to reference. Content can be anything and there are no structural requirements placed on the repository - even existing Subversion repositories can be referenced by Shotoku without modification.
- A simple search mechanism.
- Integeration with Apache Velocity - you can easily store templates in Shotoku to create higher level application features such as content and blog engines.
- Feeds component - automatic generation of rss, atom and rdf feeds/ podcasts, configured through a xml file, together with arbitrary feeds aggregation. You can see feeds already at work on JBoss Labs - just click the "Feeds" link in navigation or simply here.
- Blog component.
- A simple cache with "renewable" values - a value can be updated on regular intervals of time or when some of watched resources in a content manager change (see wiki for details).

PDL::Internals is a Perl module that contains a description of some aspects of the current internals.

Intro

This document explains various aspects of the current implementation of PDL. If you just want to use PDL for something, you definitely do not need to read this. Even if you want to interface your C routines to PDL or create new PDL::PP functions, you do not need to read this man page (though it may be informative). This document is primarily intended for people interested in debugging or changing the internals of PDL. To read this, a good understanding of the C language and programming and data structures in general is required, as well as some Perl understanding. If you read through this document and understand all of it and are able to point what any part of this document refers to in the PDL core sources and additionally struggle to understand PDL::PP, you will be awarded the title "PDL Guru" (of course, the current version of this document is so incomplete that this is next to impossible from just these notes).

Warning: If it seems that this document has gotten out of date, please inform the PDL porters email list (pdl-porters@jach.hawaii.edu). This may well happen.

Piddles

The pdl data object is generally an opaque scalar reference into a pdl structure in memory. Alternatively, it may be a hash reference with the PDL field containing the scalar reference (this makes overloading piddles easy, see PDL::Objects). You can easily find out at the Perl level which type of piddle you are dealing with. The example code below demonstrates how to do it:

# check if this a piddle
die "not a piddle" unless UNIVERSAL::isa($pdl, PDL);
# is it a scalar ref or a hash ref?
if (UNIVERSAL::isa($pdl, "HASH")) {
die "not a valid PDL" unless exists $pdl->{PDL} &&
UNIVERSAL::isa($pdl->{PDL},PDL);
print "This is a hash reference,",
" the PDL field contains the scalar refn";
} else {
print "This is a scalar ref that points to address $$pdl in memoryn";
}

The scalar reference points to the numeric address of a C structure of type pdl which is defined in pdl.h. The mapping between the object at the Perl level and the C structure containing the actual data and structural that makes up a piddle is done by the PDL typemap. The functions used in the PDL typemap are defined pretty much at the top of the file pdlcore.h. So what does the structure look like:

struct pdl {
unsigned long magicno; /* Always stores PDL_MAGICNO as a sanity check */
/* This is first so most pointer accesses to wrong type are caught */
int state; /* Whats in this pdl */

pdl_trans *trans; /* Opaque pointer to internals of transformation from
parent */

pdl_vaffine *vafftrans;

void* sv; /* (optional) pointer back to original sv.
ALWAYS check for non-null before use.
We cannot inc refcnt on this one or wed
never get destroyed */

void *datasv; /* Pointer to SV containing data. Refcnt inced */
void *data; /* Null: no data alloced for this one */
int nvals; /* How many values allocated */
int datatype;
PDL_Long *dims; /* Array of data dimensions */
PDL_Long *dimincs; /* Array of data default increments */
short ndims; /* Number of data dimensions */

unsigned char *threadids; /* Starting index of the thread index set n */
unsigned char nthreadids;

pdl *progenitor; /* Im in a mutated family. make_physical_now must
copy me to the new generation. */
pdl *future_me; /* Im the "then" pdl and this is my "now" (or more modern
version, anyway */

pdl_children children;

short living_for; /* perl side not referenced; delete me when */

PDL_Long def_dims[PDL_NDIMS]; /* Preallocated space for efficiency */
PDL_Long def_dimincs[PDL_NDIMS]; /* Preallocated space for efficiency */
unsigned char def_threadids[PDL_NTHREADIDS];

struct pdl_magic *magic;

void *hdrsv; /* "header", settable from outside */
};

This is quite a structure for just storing some data in - what is going on?

MKDoc::XML::Stripper is a Perl module to remove unwanted XML / XHTML tags and attributes.

SYNOPSIS

use MKDoc::XML::Stripper;

my $stripper = new MKDoc::XML::Stripper;
$stripper->allow (qw /p class id/);

my $ugly = < p class="para" style="color:red" >Hello, < strong >World< /strong >!< /p >;
my $neat = $stripper->process_data ($ugly);
print $neat;
Should print:
< p class="para" >Hello, World!< /p >

MKDoc::XML::Stripper is a class which lets you specify a set of tags and attributes which you want to allow, and then cheekily strip any XML of unwanted tags and attributes.

In MKDoc, this is used so that editors use structural XHTML rather than presentational tags, i.e. strip anything which looks like a tag, a style attribute or other tags which would break separation of structure from content.

TMHarvest provides a tool which harvests topicmaps from structured datasources.
The TMHarvest library is based on TM4J and provides a convenient way to automatically generate topic maps from different data sources. A rules files with embedded templates (written in XML) defines from which data sources topic map constructs should be taken into account, as well how new or existent topics should be associated.
Main features:
- TMHarvest creates topic maps from existing data sources. Currently it supports the following source-types: SQL-Databases, CSV-Files, XPath-Queries. In addition it is possible to integrate custom model-providers, written in Java. See for details.
- The harvesting is driven by a model-file. The model may be processed as often as you like. Since the data sources are queried at processing time, it is possible to build topic paps periodically in order to reflect changing content.
- The model-file has a modular setup. The resulting topic map is populated step by step from distinct templateActions. The static parts of the topic map (the structural parts, for example the topics that define the ontology of the topic map) may be merged from static files and therefore seperated from the actual harvest.
Pros and Cons
The process which creates the topic map is serialized in the model-file. Once the process is defined, it runs as often as you like. This enables the creation of topic maps, that are refreshed periodically in an automated way.
Working with the templates leads to a certain interactive experience. Shaping the model, letting TMHarvest run, revisiting the results, reshape the model... let you converge the final form
The fact that the model-file must be written by hand, excludes many users, which lack the necessary technical affinity. The development of graphical interfaces or wizards would be really helpful.

gmuck assists you in producing valid (X)HTML by checking CGI scripts, XSL stylesheets, templates, normal HTML files or [you name it] and reporting errors that it finds. The project is not a replacement for real validation tools, but is handy in quick checks and in situations where validation of the actual markup is troublesome.

gmuck assists you in producing valid (X)HTML by checking CGI scripts, XSL stylesheets, templates, normal HTML files or [you name it] and reporting errors that it finds.

It is not a replacement for real validation tools, but is handy in quick checks and in situations where validation of the actual generated markup is troublesome.

gmuck is a line-oriented tool. Because of that, its structural checking capabilities are limited, but it makes an attempt to report syntactical errors as well as provides some lint-like features.

There gmuck distribution consists of the "HTML::GMUCK" module and the "gmuck" command line interface to it.

See the gmuck(1) and HTML::GMUCK(3) manual pages (or before installation, "perldoc bin/gmuck.pod" and "perldoc lib/HTML/GMUCK.pod" in the dir where you unpacked gmuck), and ChangeLog, TODO and BUGS files for more information.

gmuck is short for Generated MarkUp ChecKer, or Generated MUCK if you like. Hmph, thats actually ambiguous, see above for a better explanation. But gmuck sounds cool

SPindent (Server Page Indenter) is a JSP/PHP structural validator and indenter. It performs structural compatibility check of inner HTML generated from "parallel" branches of process flow statements such as if/else.

It allows for those HTML branches to have different entry and exit HTML stack points, as far as the branches are compatible.

This allows for verification and proper indentation of handy workarounds, as well as rusty pyramids. It is based on MixedCC (Mixed Compiler Compiler).