As usual it should be also possible to bypass calls to strdup, while
also taking care.

The structure SH_Attr implements an HTML Attribute.

The function get_alloc_size was renamed to get_child_alloc_size as the
attributes will need another function.

Various remove methods were added, which are all implemented by an
static method, analog to the last commit.

The single method (formerly SH_NodeFragment_append_child) to add a child
at the end of the child list was replaced, by a bunch of methods to
insert a child at the beginning (SH_NodeFragment_prepend_child), at the
end (SH_NodeFragment_append_child), at a specific position
(SH_NodeFragment_insert_child) and directly before
(SH_NodeFragment_insert_child_before) or after another child
(SH_NodeFragment_insert_child_after). All these methods are implemented
by a single internal one (insert_child), as there isn't really much
difference in inserting one or the other way.
But this internal method doesn't check whether this insertion request is
actually doable, to save overhead as not every insertion method requires
this check. This is done by the respective method. However if the check
is not done correctly the internal method will attempt to write at not
allocated space, which will hopefully result in a segfault.

The child list is implemented as an array. To reduce the overhead to
realloc calls, the array is allocated in chunks of childs. The
calculation how many has to be allocated is done by another static
method and determined by the macro CHILD_CHUNK. This is set to 5, which
is just a guess. It should be somewhere around the average number of
childs per html element, to reduce unused overhead.

Also some predicates (SH_NodeFragment_is_parent,
SH_NodeFragment_is_ancestor) were added to check whether a relationship
exists between to nodes, thus whether they are linked through one or
multiple levels. These functions could replace the old ones
(SH_NodeFragment_is_child, SH_NodeFragment_is_descendant) semantically.
Furthermore they are more efficient as this is now possible to check
over the parent pointer. The internal insert method also uses these
methods to check whether the child node is actually a parent of the
parent node, which would result in errors later one.

The old test is now obsolete but remained, as it is not bad to test
more.

Removed some unnecessary type casts.
Added some forgotten calls to free.

Every fragment has a parent now, this is useful for both traversing the
tree and checking for cycles when a node is added, which would cause
problems, like freeing things twice or similar nice bugs. Both wouldn't
be possible otherwise. These features are not implemented yet.

The library provides a way to directly access the tag in a read-only
way, which saves an call to strdup. This is useful if only reading is
necessary , but needs special care by developers, as it is neither
allowed to modify it nor to free it. Disregarding this will lead to a
segfault in the best, and to silent data corruption and security bugs in
the worst case.

An array index should be of size_t instead of unsigned int.

Internal struct definitions shouldn't be exported by header files.

The validator was used to check that every created tag is validate.
However I now think that validation should take place at a later time,
so it is not mandatory.
Thus developing the validator is now discontinued.

The Validator saves the tags as an array. Now also another information
is added, which slots aren't used currently to spare expensive calls to
realloc. This led to a mere reimplementation of the functions. Tags
can't be deleted by now, but the adding function supports reusing empty
slots. Also the reading functions have to determine, whether a slot can
be read or is empty.
The tests were adjusted, but are buggy, so they should be rewritten in
the future.

Additionaly some annotations for splint were added.

Instead of the trivial structure SH_Error, SH_Status is used. The name
was chosen, because error/status is set independently whether an error
has occurred. Beside the error type, it also contains the associated
errno and an error message. The error message is also printed, when it
is set. Generating error messages with variadic arguments is now also
supported.
There are also macros to check for a set status.

The exception handling was removed for the *_free methods, because they
can't fail predictably during runtime.

Unfortunately the compiler reports, that inside the macro set_status
printf may be called with NULL [printf (NULL)], although, this is
explicitly debarred.

The make process was restructured to create a library. For this libtool
is used to provide both static and dynamic linking. Also header
inclusion guards were introduced, to prevent clients of the library to
include some single file without including others. The types were
exported with forward declarations for better abstraction. When
compiling the library, the macro LIB_SEFHT_COMPILATION is defined and
symbol declarations are exported fully. For compiling the tests this
macro is also defined, as the tests not only tests the API, but also the
internal state, because a lot of errors couldn't be detected otherwise.

The method SH_Text_print just prints the whole string to stdout.

The function SH_Text_get_length returns the length of the text. As the
text also supports being longer than SIZE_MAX, this method can fail on
runtime. If the text is longer then SIZE_MAX, the Text returns SIZE_MAX
and sets error to DOMAIN_ERROR. Note, that due to the implementation,
this is a non trivial function, so don't use it to exhaustively.

The function SH_Text_get_range returns a string begining at start and
ending at end. Note that end specifies the char, that is not returned
anymore. Thus the function implements something similar, as the pythonic
slice syntax (text[start:end]). In opposition to the behaviour there,
calling SH_Text_get_range with start > end is undefined behaviour. If
start == end, the empty string is returned.
If start is out of bounds, NULL is returned and an error is set. If end
is out of bounds, the existent part is returned. Also the length of the
returned string can be set (optionally) to the out parameter length.

The function SH_Text_get_string returns a substring of text beginning at
index and of length offset. If index is out of bounds, NULL is returned
and an error is set. If offset is out of bounds, the existent part is
returned. Also the length of the returned string can be set (optionally)
to the out parameter length.
If the original behaviour of SH_Text_get_string is achieved,
SH_Text_get_string (text, length, error) has to be changed to
SH_Text_get_string (text, 0, SIZE_MAX, length, error). The only
difference will be that the function won't fail, when the text is longer
than SIZE_MAX, because it is told to stop there. A text that is longer
than SIZE_MAX is not possible to be returned, but that wasn't possible
at anytime. Also I don't think handling char[] longer than SIZE_MAX is
possible with the standard C library. Those in this case the text can
only be returned in parts (By now only possible till 2*SIZE_MAX-1 with
calling SH_Text_get_string (text, SIZE_MAX, SIZE_MAX, length, error))
or has to be manipulated using the appropiate SH_Text methods, which are
not implemented yet.

The method SH_Text_get_char returns a single character by a given index.
If the index is out of range, NULL is returned and error->type is set to
VALUE_ERROR.

The (intern) implementation of SH_Text was changed from an array of
char, to a single linked list of arrays of char. This allows an easier
implementation of (further) text manipulation.
The API hasn't changed much, but SH_Text_join can't yield an error
anymore, so it now doesn't support passing an error and returns nothing.

The source has been adapted to splint, which still tells about some
errors, but they are all checked to be false-positives.

A method was added, that returns the generated text.

The constructor SH_Text_new_from_string accepts a string, with that the
text is initialized. This can replace the so far needed two calls
SH_Text_new and SH_Text_append_string.

When writing the test, it was neccessary to simulate an overflow.
Thereby a bug was detected regarding another overflow test. The bug was,
that when SIZE_MAX % CHUNK_SIZE == 0 (which is normally true, if 2^n is
taken as the value for CHUNK_SIZE) there can't be an overflow, so the
test for an overflow fails. Actually there wasn't a neccesity to check
for an overflow, as this could easily be bypassed by just allocating the
requested size instead of the next chunk size, if this would be greater
then SIZE_MAX.

Sometimes a copy is needed.

This renaming is neccessary, as the future Fragmment will be the base
class to all Fragment types.

When the wrap mode is used, after each tag a newline is started. Also the
html is indented, which can be configured by the parameters indent_base,
indent_base, indent_char. The parameter indent_base specifies the width
the first tag should be indented with, while indent_step specifies the
increment of the indent when switching to a child tag. The character,
that is used for indenting is taken from indent_char. (It could also be
a string longer than a single character).
This aguments can't be set by the user, but are hardcoded (by now).

Fragment can be copied, either recursive (copying also all childs) or
nonrecursive (ignoring the childs, thus the copy has always no childs).
Adding the same element twice in the tree (graph) isn't possible, as
this leads to problems e.g. double free or similars.

The methods
- SH_Fragment_get_child (by index)
- SH_Fragment_is_child (non recursive) and
- SH_Fragment_is_descendant (recursive)
were added.

A Fragment can contain childs. When building the html, the childs html
is generated where appropiate.

SH_Text_append_string can be used to append a string to the text,
SH_Text_append_text can be used to append another text to the text.
SH_Text_join is a wrapper for SH_Text_append_text, but also frees the
second text, thus joining the texts to a single one.

A Fragment can output it's html. If there is an error the method aborts
and returns NULL.

Changing sefht_validator_test so that no memory leaks occur.

The space a Text has for saving the string is allocated in chunks. To
request additional space SH_Text_enlarge is called. If the requestad
size fits inside the already allocated space or is even smaller than the
current size, nothing is done. Otherwise a multiple of chunk size is
allocated beeing equal or greater than the requested size. The chunk
size can be changed by changing the macro CHUNK_SIZE in src/text.h. The
default is 64.
This adjustment is done automatically when a string is added.

Check in tests whether error really was written, by setting it to
undefined before each call.

This is a data type to deal with frequently appending to a string.

When a tag is made known to the Validator, which it already knows, the
old id is returned and nothing is added.
As this has to be checked by iterating over all known tags, a new helper
function is written for both SH_Validator_check_tag and
SH_Validator_register_tag: SH_Validator_get_tag.

Because we want also to test this function, we have to include
validator.c in the test file and override the static keyword by an empty
macro. It isn't possible any more to check for correct overflowdetection
by setting the index to UINT_MAX, because it will be iterated over all
data, thus raising an SIGSEGV when doing so. This is solved by filling
garbage unil UINT_MAX is really reached. As there would be an timeout
and it would fill RAM with around 40 GB of garbage, UINT_MAX is
overriden prior to inclusion of validator.c .