Double inclusion accompanied with macro guards are a bit ugly in
comparison to a separate file.

As the access must be fast, the tags are sorted when inserted, so that
the search can take place in log-time.

Instead of having one function performing all the tests, they are split
into multiple functions. Also a bug was found.

While it was very clever, the complex data structure of the tag array
introduced in 'Validator: restructured internal data (a0c9bb25)' comes
with a lot of runtime overhead. It reduces the calls to free and
realloc, when a lot of tags are deleted and inserted subsequently, but
burdens each call with a loop over the linked list of free blocks.

This is even more important, as validator must be fast in checking, as
this is done everytime something is inserted into the DOM-tree, but has
not so tight requirements for registering new tags, as this is merely
done at startup time.

To test static functions, static haven't to be declared as empty.

When a newline is encountered in the text, a <br /> is inserted and for
wrap mode also a newline and an indent is inserted. Note that the indent
is still missing at the front where it can't be inserted yet as SH_Text
is still lacking basic functionality.

The copy_and_replace function replaces a single character with a string,
while copying. This may be replaced by an elaborate function as
manipulating a text normally means that manipulating is deferred until
needed, which this function contradicts to.

What the method does is merely squashing everything together as opposed
to performing a direct copy.

At the end of the pipeline a release is generated. A release
automatically adds a tag, which in turn would trigger the pipeline a
second time. This is prevented.

The marks are now allocated and the allocated, where appropriate.

A text_segment allocates memory in terms of chunks, this is now also
done, when created from a string, but this means that we can't rely on
strdup anymore, as it takes care of the allocation. Calling malloc
ourselves shouldn't be such an overhead as at least glibc's strdup
performs the exact same steps. Actually we should be spare a strlen call
now, so it should be more perfomant.

A mark will be used to point to a specific location inside of a text.
Currently it can't do anything and isn't even used.

While it would be preferable, it doesn't seam to be possible to abstract
over the internals of text_segment. That's why only some basic
functionality is moved, but whether more is to follow, is not known yet.

Adjusted error coding style, to current one.

changed year and corrected email address

Some adjustments suggested by autoupdate and autoscan were added.

The transition from a single fragment, which is a tree, to a polymorph
fragment implemented by a base class (Fragment) and a subclass for
storing the tree (NodeFragment) and another subclass for storing text
(TextFragment) is now considered complete.
What is still missing is the proper treatment of embed text. This should
be indented and breaked at 72/79/80. Also newlines and special chars
should be replaced on generation, maybe also giving some way of
preventing XSS. Regarding the NodeFragment there should be some
adjustments to further adjust the styling, which of course should also
be reflected by TextFragment. This should also include the generation of
self-closing tags. Furthermore the html generation should be based on a
single text object, to which is added to. This will later on also enable
to directly send generated parts over the network while still generating
some data.
But all this changes are to meant to change the behaviour of existing
classes, so the will be eventually implemented on seperate branches.

The html generation for both TextFragment and NodeFragment combined is
tested. As the encoding semantics of the TextFragments are neither
defined nor implemented, some tests are marked as XFAIL.

Some basic text functionality is now directly supported via wrapper
functions.

Note that wrapper functions aren't tested in unit tests.

While this method is neccessary to manipulate the content of a
TextFragment, the TextFragment should abstract the semantics of Text.
While simple wrapper functions for appending are to be added, methods
purely manipulating the text, i.e. relying on the text's contents, wont
get wrapper functions. Thus this method is still needed until a more
sophisticated approach is implemented.

There are seperate build, test and release stages. Also the resulting
package is uploaded. To do that a special script was written to get the
real name of the package, which autoconf inserts into the scripts on
configure-time.

The basic functionality to implement all abstract methods is added. This
means, that TextFragment can be instantiated, but it can't do anything
useful yet.

The tests are mostly split in a variant with error checking and a
variant without, as it is now common.

The function SH_Text_set_char allows to write a single character to a
position, that already exists in the text. Thus overwriting another
character. If the index is out of range, a value error is set and FALSE
is returned.

NodeFragment is virtually finished, but TextFragment is still missing,
as it depends on still not implemented functionality of SH_Text.