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.

While it should not be the case, that the Attr's internal method free's
the passed attribute, as some of the other internal methods pass
non-allocated pointers to it, the methods visible by the user should
indeed free things, where the ownership of every inner element is
already transfered. This was adjusted now. As some tests have taken
advantage of the fact, that while not to be changed, the old pointers
were still accessible, they had to be adjusted.

The demo program now uses some of the new functionality.

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)

The common code to cleanup in case of an error was bundled at the end of
the function. For people complaining about the use of goto: this is the
exact use case, where it is recommended!

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.

Hiding files, that are generated during build, shouldn't be a personal
choice, thus they should be added to the global .gitignore.
Note that in this project it is choosen, to not include generated files
into the version control system, but of course they must be always
included for distributions.

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