src/svgtiny.c: deallocate stylesheets during finalisation

We allocate stylesheets in svgtiny_parse_style_element() and append
them to our global select_ctx, but the select_ctx retains only a const
reference to them and is not responsible for freeing their resources.
Instead, we have to do it during finalisation.

This is a little ugly because we have to de-const the sheet references
before we can destroy them. This relies on the non-local knowledge
that every sheet appended to the context does in fact originate in the
one function svgtiny_parse_style_element(). On the other hand, using
the context to keep track of these sheets saves us the trouble of
maintaining a duplicate array that would differ only in type
signature.

In summary:

  * The sheets are now removed from the context before destroying
    them. This avoids a potential issue where destroying the context
    itself (which we do afterwards) might try to access the sheets.

  * If we fail to obtain a pointer to a sheet, we stop processing that
    sheet. This should not happen, and if something extremely weird
    happens it can hide the problem, but that's still better than the
    segfault we'd get from trying to operate on an invalid pointer.

  * The sheets are removed/destroyed in reverse order, last-in
    first-out.

  * Extremely unlikely error paths call assert(). Production builds
    will still catch and propagate errors.

test/css: add some visually-verified test cases for our new features

It's helpful to have some test cases for our CSS handling, but
unfortunately, it's not all that easy to write them. How should we
compare the actual output to the expected output?

For now we settle for a visual comparison. You can render the test
diagrams using the example program examples/svgtiny_display_x11, and
also open them in another SVG viewer. Do they look the same? Great.
The test cases should be simple enough that _subtle_ visual mismatches
are not possible.

Automating this is not an impossible problem: for example, we could
render the parsed diagram to a bitmap image using cairo and then
compare it to what we get using librsvg which is also cairo-based. But
that has downsides too (like the portability of librsvg) that we don't
want to address right now.

src/svgtiny.c: use case-sensitive comparisons for SVG element names

SVG is XML and its element names are therefore case-sensitive. We
switch to case-sensitive comparisons to avoid rendering elements
(e.g. <RECT />) that other SVG clients (e.g. Firefox) will not.

examples/.gitignore: ignore the compiled example program

examples/svgtiny_display_x11.c: update build instructions

First, tell people to run "make" instead of giving them the full "gcc"
command-line. Then elaborate on how one can modify the build process
to use a development copy of libsvgtiny.

examples/GNUmakefile: add a GNUmakefile for the example program

This should simplify building it a bit, both against the system copy
and against a development repo. We use the name GNUmakefile (as
opposed to Makefile) to avoid interacting with the netsurf build
system.

src/svgtiny.c: remove parent == NULL hack

Now that we're providing some (unused!) default user-agent properties,
this code path is apparently no longer reached. Never look a gift
horse in the mouth, is an insane saying. But everything works great
without the NULL check, so let's remove it.

src/svgtiny_css.c: add some default user-agent properties after all

We tried to avoid populating ua_default_for_property() with any
default properties, but it looks like some are "required." Without
them, the style-composition process gets crashy while trying to set
initial values. Thanks to the libcss example program for the idea.

src/svgtiny.c: implement composition of parent styles

src/svgtiny*.{c,h}: move the libcss unit context into the parser state

This will make it easier to use the same unit context for style
composition that we do for style computation.

src/svgtiny_internal.h: add parent style to the parser state

This will come in handy when we want to compose the current (child)
node's styles with its parent's styles.

src/svgtiny{,_parse}.c: use a separate function for style application

We've been doing CSS in svgtiny_parse_paint_attributes(), because we
only support CSS paint attributes at the moment. But ultimately that
won't be right. Let's separate it out now into its own function,
svgtiny_parse_styles().

examples/svgtiny_display_x11.c: use opacity information

src/svgtiny.c: set shape opacities from the parser state

Record the "active" fill and stroke opacity from the parser state
in each shape that we create.

include/svgtiny.h: add fill_opacity and stroke_opacity to svgtiny_shape

We already have fields for the fill and stroke opacity in the parser
state, but we have no way to record those values in the shapes we're
creating as we parse. Here we make room to do that.

src/svgtiny.c: parse styles in svgtiny_parse_inline_style()

Now that the scaffolding is in place, we do the work to parse our two
supported CSS paint attributes, fill-opacity and stroke-opacity. This
amounts to,

  * Calling svgtiny_select_style(), which is just a wrapper around
    css_select_style()
  * Passing the result to css_computed_foo_opacity() to get the
    computed styles
  * Populating fill_opacity and stroke_opacity in the parser state
    if the corresponding styles exist

There's also a temporary hack to avoid crashing on the root node that
later goes away when we implement parent/child style composition.

test/decode_svg.c: handle svgtiny_LIBCSS_ERROR

This test program has a switch statement to handle errors, with one
case for each svgtiny_code. Now that svgtiny_LIBCSS_ERROR belongs to
that enum, we add it to the list of cases.

examples/svgtiny_display_x11.c: handle svgtiny_LIBCSS_ERROR

This example program has a switch statement to handle errors, with one
case for each svgtiny_code. Now that svgtiny_LIBCSS_ERROR belongs to
that enum, we add it to the list of cases.

src/svgtiny_internal.h: add fill/stroke_opacity to the parse state struct

src/svgtiny_internal.h: add svgtiny_select_style() to the header

We'll need a prototype in order to use that function in svgtiny.c.

src/svgtiny_css.c: add svgtiny_select_style() wrapper

Some boilerplate will be needed when we call css_select_style() during
parsing. In preparation for (avoiding) that, we factor it out into a
convenience function called svgtiny_select_style().

src/svgtiny_css.c: use our userdata handler in set_libcss_node_data()

This was a missing part of the implementation that had to wait until
our css_select_handler vtable was defined.

src/svgtiny_css.c: add user handler function

This function needs to be passed to dom_node_set_user_data() in
set_libcss_node_data(), but we couldn't implement it before our
css_select_handler was defined, because it passes the address of
that select handler to css_libcss_node_data_handler().

src/svgtiny_css.c: define a css_select_handler

We define a css_select_handler structure full of all of the select
handlers we've just implemented. This is the big piece of the puzzle
that we need before we can call css_select_style().

src/svgtiny_css.c: implement named_ancestor_node() select handler

src/svgtiny_css.c: implement node_presentational_hint() select handler

src/svgtiny_css.c: implement get_libcss_node_data() select handler

src/svgtiny_css.c: implement set_libcss_node_data() select handler

src/svgtiny_strings.h: intern a "userdata" key string

To implement libcss's select handler API, we need to implement two
functions that get/set "userdata" on a node. The corresponding libdom
API allows you to set arbitrary data in the form of key->value pairs;
so to identify THIS particular data, we need to use the same string
each time. For that reason we intern "_libcss_user_data" and call it
the "userdata_key".

src/svgtiny_css.c: implement node_is_visited() select handler

src/svgtiny_css.c: implement ua_default_for_property() select handler

src/svgtiny_css.c: implement node_is_lang() select handler

src/svgtiny_css.c: case-insensitivity for node_has_attribute_substring()

All of the CSS attribute selectors take a flag to make the comparison
case-insensitive. Libcss doesn't support that yet, but in the case of
node_has_attribute_substring(), factoring out the implementation and
letting it take an "insensitive" flag will be of use to us when we
implement the node_is_lang() select handler.

src/svgtiny_css.c: implement node_is_target() select handler

src/svgtiny_css.c: implement node_is_checked() select handler

src/svgtiny_css.c: implement node_is_disabled() select handler

src/svgtiny_css.c: implement node_is_enabled() select handler

src/svgtiny_css.c: implement node_is_focus() select handler

src/svgtiny_css.c: implement node_is_active() select handler

src/svgtiny_css.c: implement node_is_hover() select handler

src/svgtiny_css.c: implement node_is_link() select handler

src/svgtiny_css.c: implement node_is_empty() select handler

src/svgtiny_css.c: implement node_count_siblings() select handler

src/svgtiny_css.c: implement node_is_root() select handler

src/svgtiny_css.c: implement node_has_attribute_substring() select handler

src/svgtiny_css.c: implement node_has_attribute_suffix() select handler

src/svgtiny_css.c: implement node_has_attribute_prefix() select handler

src/svgtiny_css.c: implement node_has_attribute_includes() select handler

src/svgtiny_css.c: implement node_has_attribute_dashmatch() select handler

src/svgtiny_css.c: implement node_has_attribute_equal() select handler

src/svgtiny_css.c: implement node_has_attribute() select handler

src/svgtiny_css.c: implement node_has_id() select handler

src/svgtiny_css.c: implement node_has_class() select handler

src/svgtiny_css.c: implement node_has_name() select handler

src/svgtiny_strings.h: intern the universal selector string "*"

This is a prerequisite for implementing the node_has_name() select
handler.

src/svgtiny_css.c: implement sibling_node() select handler

src/svgtiny_css.c: implement parent_node() select handler

src/svgtiny_css.c: implement named_generic_sibling_node() select handler

src/svgtiny_css.c: implement named_sibling_node() select handler

src/svgtiny_css.c: implement named_parent_node() select handler

src/svgtiny_css.c: implement node_id() select handler

src/svgtiny_strings.h: intern "id" for libcss

As a prerequisite for implementing a libcss node_id() select handler,
we intern the string "id" that it will need access to.

src/svgtiny_css.c: implement node_classes() select handler

src/svgtiny_css.c: implement node_name() select handler

src/svgtiny{.c,_internal.h}: intern SVG's XML namespace URI

Intern the string "http://www.w3.org/2000/svg" in the parser state for
later use in libcss's node_name() select handler.

src/svgtiny_parse.c: add svgtiny_parse_style_inline() function

This function parses the contents of an inline style="..." attribute
into a libcss stylesheet, or NULL if anything went wrong.

We use the new function in svgtiny_parse_paint_attributes() to parse
an inline sheet... and then (for now) do nothing with it. We are able
to parse the inline style="..." attributes right now but more
scaffolding is needed before we can utilize css_select_style().

src/svgtiny.c: use svgtiny_create_stylesheet() to parse <style>

The new function handles all of the boilerplate parameter creation
that was originally done in svgtiny_parse_style_element().

src/svgtiny_internal.h: add svgtiny_create_stylesheet() prototype

Needed to let src/svgtiny.c know about the new function.

src/svgtiny_css.c: new function svgtiny_create_stylesheet()

We add a function to handle the creation of a new stylesheet with the
default set of parameters. This is in preparation for parsing the
inline styles, which a priori would involve copy/pasting a lot of

  params.foo = bar;

lines from svgtiny_parse_style_element(). The goal is to factor the
common bits out of both the <style> and style= implementations.

src/svgtiny.c: add svgtiny_parse_style_element() function and use it

The new function parses the contents of a <style> element. We add a
call to it in svgtiny_preparse_styles() where previously a placeholder
was left.

src/Makefile: add the new svgtiny_css.c to the list of sources

src/svgtiny_css.c: new file with new svgtiny_resolve_url() function

Define a stub relative-URL resolver that assumes all URLs are absolute
and returns them unmodified. Some method of doing this is required by
libcss. At the moment, libcss does not support any SVG properties that
take url() values, so not much is lost.

Makefile: drop -pedantic from CFLAGS

With -pedantic enabled, -Werror causes build failures when we try to
call lwc_string_ref(). For example,

  src/svgtiny_css.c:120:9: error: use of GNU statement expression
  extension from macro expansion [-Werror,
  -Wgnu-statement-expression-from-macro-expansion]
  120 |         *abs = lwc_string_ref(rel);

will happen in the very next commit.

src/svgtiny.c: add impotent svgtiny_preparse_styles() function

We declare and add the svgtiny_preparse_styles() function that will be
used to make a first pass through the SVG document and parse all of
the <style> elements. At the moment it is only half implemented:
once we find a <style> element, we do nothing with it. A separate
function will be used to parse a <style> once we have it.

src/svgtiny.c: initialise/finalise the libcss context

Before we begin parsing, we have to initialize our new css_select_ctx
by calling css_select_ctx_create(). Later, when parsing is complete,
we css_select_ctx_destroy() it.

include/svgtiny.h: add new error constant svgtiny_LIBCSS_ERROR

Analogous to svgtiny_LIBDOM_ERROR, we add svgtiny_LIBCSS_ERROR to
indicate an error related to CSS.

src/svgtiny_strings.h: add "media" to the list of strings

The "media" attribute is arguably the only meaningful attribute a
<style> element has within an SVG document. Here we intern the string
"media" in preparation for parsing <style>. Libcss can at least store
the media information even if we decide not to use it.

src/svgtiny_internal.h: add CSS context to parser state

Add a css_select_ctx pointer to the svgtiny_parse_state that is
threaded through each phase of SVG parsing. This will allow us to
populate the context with any <style> sheets we find; later, we can
consult those stylesheets while constructing our svgtiny_diagram (the
abstract representation into which we parse an SVG).

README: mention that libcss is required

Makefile: build against libcss

The first step towards adding libcss support is to build against
libcss. For now that means getting its "cflags" and "libs" from
pkg-config and putting them into CFLAGS and LDFLAGS.

src/svgtiny.c: remove old misleading libcss comments

There were a few comments in this file suggesting some future libcss
integration. However, now that we are beginning that integration (much
later), it is probably best to start with a clean slate. So, we remove
those comments.

src/svgtiny_internal.h: removed commented libcss stub

This files once thought about declaring,

  /*struct css_style style;*/

as a member of the svgtiny_parse_state struct. We delete that comment
now so that we can begin libcss integration with a clean slate.

src/svgtiny_gradient.c: be more careful with float -> int assignment

Assigning the value of a float to an unsigned int is undefined
behavior unless the value is guaranteed to fit. We run afoul of this
in compute_grad_points(), where the number of steps is computed using
a floating point calculation.

On a RISC-V / musl system, the end result is that we wind up with
steps = the maximum value of an unsigned int, when really this should
be an error case resulting in steps = 1. The test suite catches this.

Update AFL test corpus

in addition provides near complete coverage when used as unit test vectors

Update test dir to add fuzzer configuration

Implement use element

improve svg parse initialisation/finalisation

refactor path parse

fixup named colour lookup

fixup paint parse

Improve gradient parsing and generation

Improve attribute parsing with operation tables

Reimplement style processing

Reimplement parsing of viewbox

fixup tests that used non existant viewport attribute

Improve number parse API

Reimplement color parsing

Reimplement transform processing

remove use of sscanf and string duplication in transform processing

Cleanup length parsing

remove the incorrect use of atof and use an API that does not require the string to be copied to terminate with a null

Rework poly point parsing

Change parsing of poly points to use a specific number parser insteads of sscanf

Extend polyline tests