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.

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)