When there are methods in the api/abi, that take pointers to strings to
store them in the library, there are two methods to do so. Either they
are copying the string and leaving it intact, or they directly assign
the given pointer to some internal storage. While the former method, is
safer in terms of memory, as the user doesn't have to remember that he
can't use the string anymore, the latter can be more efficient, as there
is no extra strdup call, but the user is not allowed to change the
pointer, free it and also can't use the pointer, because it can't be
known whether it is already freed by the library. As it should be
decideable by the user, the library often implements both approaches,
where the method, that directly store pointers without creating a copy
contains the raw_ prefix.

The insert_attr_new methods were somewhat confusing in this regard, as
it is likely to be expected, that they were copying the string, while in
fact they did not. This is now fixed. The insert_attr_new methods copy
the strings, while the added insert_attr_raw_new methods preserve the
old behaviour of the insert_attr_new methods, thus allowing to let the
user choose, what is more appropriate.

Fixed some memory leak detected by valgrind.

The to_html method generates also the html for the attributes. Note,
that there is no escapeing of the quotes, the values are wrapped with. But
this is also somewhat consistent, as there is no syntax validation on
the tags either. (i.e. no '<' in side of a tag)

Two alternatives are provided: remove_attr and pop_attr. While the
former free's the Attr's data, the latter allocates a new Attr, to store
and return the data. Both functionality is provided by a single
(internal) static method.

This method needs to be used in places where freeing the src-pointer is
not possible, as it may be not allocated. If freeing is needed, it is
now in the responsibility of the caller. As it turns out this approach
is not even more useful, it is also less work, as it can be determined
from the fact, that adjusting the tests to the new behavior means
actually removing lines, that were previously working around the quirks,
that the old approach introduced.

Until now, the configure script just checked for check to be installed,
which is needed to compile the tests.
Now, configure provides a conditional (MISSING_CHECK) depending on its
presence for use by automake. If check is missing, the tests aren't
compiled. Instead a special script is executed to inform the user of the
problem and stops the testsuite. Note, that it was not possible to
directly stop the generation of the testsuite by injecting a rule to a
Makefile without relying on implementation details of automake.
See:
https://stackoverflow.com/questions/76376806/automake-how-to-portably-throw-an-error-and-aborting-the-target/76382437
To allow the script to issue messages to stderr, AM_TESTS_FD_REDIRECT is
used, because the parallel test harness redirects output of its tests to
logfiles. This isn't used for the serial test harness, because there is
no redirection to logfiles, but there AM_TESTS_FD_REDIRECT is also not
taken into account.
See:
https://www.gnu.org/software/automake/manual/html_node/Testsuite-Environment-Overrides.html
Additionaly configure also provides an argument to enforce both
behaviours. When specifying --enable-tests=no the tests are not compiled
regardless of the presence of check. If --enable-tests=yes, it is
assumed, that tests are really needed and the mandantory check for check
is performed thus providing the former behaviour. If not specified
--enable-tests default to auto, which results in the same behaviour as
--enable-tests=yes, if check is present, and like --enable-tests=no
otherwise.

The prepend_child and append_child methods were previously not tested.
They are now added to testing.

Hand in still missing tests.

added tests for getter

Sometimes it is interesting to know, whether to Attr are referring to
the same attribute. Note that it is not intended to provide a method for
the values, as that would be meaningless on its own and if it is used in
a more complex tasks, this is still possible with the current set of
methods, which is prefered as the complex task can then be implemented
on the outside completely.

A method to compare two Attr's for exact equality was added both to
internal and external methods.

Added the allocation part of the implementation of attributes. Also some
tests were improved.
The functions to add and remove attributes are not implemented, as well
as the generation of the html for the attributes. Thats why also test
can't really test the attributes as it is not possible to add
attributes.

When used with care, it is possible to bypass many strdup calls.

When used with care, it is possible to bypass many strdup calls.
To also save the instructions for the call, which are a lot of overhead
now, link time optimization is turned on. (-flto)

Sometimes a copy is useful.

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.