src/svgtiny.c

Bug Summary

File:	svgtiny.c
Warning:	line 954, column 4 Value stored to 'res' is never read
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name svgtiny.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/var/lib/jenkins/workspace/scan-build-libsvgtiny -fcoverage-compilation-dir=/var/lib/jenkins/workspace/scan-build-libsvgtiny -resource-dir /usr/lib/llvm-19/lib/clang/19 -D _BSD_SOURCE -D _DEFAULT_SOURCE -I /var/lib/jenkins/workspace/scan-build-libsvgtiny/include/ -I /var/lib/jenkins/workspace/scan-build-libsvgtiny/src -D _ALIGNED=__attribute__((aligned)) -D STMTEXPR=1 -D DEBUG -I /var/lib/jenkins/artifacts-x86_64-linux-gnu/include -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Og -Wwrite-strings -Wno-error -std=c99 -fconst-strings -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-display-progress -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /var/lib/jenkins/workspace/scan-build-libsvgtiny/clangScanBuildReports/2025-11-02-101011-3713021-1 -x c src/svgtiny.c
1/*
* This file is part of Libsvgtiny
* Licensed under the MIT License,
*                http://opensource.org/licenses/mit-license.php
* Copyright 2008-2009 James Bursa <james@semichrome.net>
* Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org>
* Copyright 2024 Vincent Sanders <vince@netsurf-browser.org>
*/

10#include <assert.h>
11#include <math.h>
12#include <setjmp.h>
13#include <stdbool.h>
14#include <stdio.h>
15#include <stdlib.h>
16#include <string.h>

18#include <dom/dom.h>
19#include <dom/bindings/xml/xmlparser.h>

21#include "svgtiny.h"
22#include "svgtiny_internal.h"


25/* circles are approximated with four bezier curves
*
* The optimal distance to the control points is the constant (4/3)*tan(pi/(2n))
* (where n is 4)
*/
30#define KAPPA0.5522847498 0.5522847498

32/* debug flag which enables printing of libdom parse messages to stderr */
33#undef PRINT_XML_PARSE_MSG

35#if (defined(_GNU_SOURCE) && !defined(__APPLE__) || defined(__amigaos4__) || defined(__HAIKU__) || (defined(_POSIX_C_SOURCE200809L) && ((_POSIX_C_SOURCE200809L - 0) >= 200809L)))
36#define HAVE_STRNDUP
37#else
38#undef HAVE_STRNDUP
39char *svgtiny_strndup(const char *s, size_t n);
40#define strndup svgtiny_strndup
41#endif

43static svgtiny_code parse_element(dom_element *element, struct svgtiny_parse_state *state);

45#ifndef HAVE_STRNDUP
46char *svgtiny_strndup(const char *s, size_t n)
47{
size_t len;
char *s2;

for (len = 0; len != n && s[len]; len++)
continue;

s2 = malloc(len + 1);
if (s2 == NULL((void*)0))
return NULL((void*)0);

memcpy(s2, s, len);
s2[len] = '\0';

return s2;
62}
63#endif


66/**
* Parse x, y, width, and height attributes, if present.
*/
69static void
70svgtiny_parse_position_attributes(dom_element *node,
		  struct svgtiny_parse_state state,
		  float *x, float *y,
		  float *width, float *height)
74{
struct svgtiny_parse_internal_operation styles[] = {
{
	/* x */
	state.interned_x,
	SVGTIOP_LENGTH,
	&state.viewport_width,
	x
},{
	/* y */
	state.interned_y,
	SVGTIOP_LENGTH,
	&state.viewport_height,
	y
},{
	/* width */
	state.interned_width,
	SVGTIOP_LENGTH,
	&state.viewport_width,
	width
},{
	/* height */
	state.interned_height,
	SVGTIOP_LENGTH,
	&state.viewport_height,
	height
},{
	NULL((void*)0), SVGTIOP_NONE, NULL((void*)0), NULL((void*)0)
},
};

*x = 0;
*y = 0;
*width = state.viewport_width;
*height = state.viewport_height;

svgtiny_parse_attributes(node, &state, styles);
111}


114/**
* Call this to ref the strings in a gradient state.
*/
117static void svgtiny_grad_string_ref(struct svgtiny_parse_state_gradient *grad)
118{
if (grad->gradient_x1 != NULL((void*)0)) {
dom_string_ref(grad->gradient_x1);
}
if (grad->gradient_y1 != NULL((void*)0)) {
dom_string_ref(grad->gradient_y1);
}
if (grad->gradient_x2 != NULL((void*)0)) {
dom_string_ref(grad->gradient_x2);
}
if (grad->gradient_y2 != NULL((void*)0)) {
dom_string_ref(grad->gradient_y2);
}
131}


134/**
* Call this to clean up the strings in a gradient state.
*/
137static void svgtiny_grad_string_cleanup(
struct svgtiny_parse_state_gradient *grad)
139{
if (grad->gradient_x1 != NULL((void*)0)) {
dom_string_unref(grad->gradient_x1);
grad->gradient_x1 = NULL((void*)0);
}
if (grad->gradient_y1 != NULL((void*)0)) {
dom_string_unref(grad->gradient_y1);
grad->gradient_y1 = NULL((void*)0);
}
if (grad->gradient_x2 != NULL((void*)0)) {
dom_string_unref(grad->gradient_x2);
grad->gradient_x2 = NULL((void*)0);
}
if (grad->gradient_y2 != NULL((void*)0)) {
dom_string_unref(grad->gradient_y2);
grad->gradient_y2 = NULL((void*)0);
}
156}


159/**
* Set the local externally-stored parts of a parse state.
* Call this in functions that made a new state on the stack.
* Doesn't make own copy of global state, such as the interned string list.
*/
164static void svgtiny_setup_state_local(struct svgtiny_parse_state *state)
165{
svgtiny_grad_string_ref(&(state->fill_grad));
svgtiny_grad_string_ref(&(state->stroke_grad));
168}


171/**
* Cleanup the local externally-stored parts of a parse state.
* Call this in functions that made a new state on the stack.
* Doesn't cleanup global state, such as the interned string list.
*/
176static void svgtiny_cleanup_state_local(struct svgtiny_parse_state *state)
177{
svgtiny_grad_string_cleanup(&(state->fill_grad));
svgtiny_grad_string_cleanup(&(state->stroke_grad));
180}


183static void ignore_msg(uint32_t severity, void *ctx, const char *msg, ...)
184{
185#ifdef PRINT_XML_PARSE_MSG
186#include <stdarg.h>
      va_list l;

      UNUSED(ctx)((void) (ctx));

      va_start(l, msg);

      fprintf(stderrstderr, "%"PRIu32"u"": ", severity);
      vfprintf(stderrstderr, msg, l);
      fprintf(stderrstderr, "\n");

va_end(l);
198#else
UNUSED(severity)((void) (severity));
UNUSED(ctx)((void) (ctx));
UNUSED(msg)((void) (msg));
202#endif
203}


206/**
* Parse paint attributes, if present.
*/
209static void
210svgtiny_parse_paint_attributes(dom_element *node,
	       struct svgtiny_parse_state *state)
212{
struct svgtiny_parse_internal_operation ops[] = {
{
	/* fill color */
	state->interned_fill,
	SVGTIOP_PAINT,
	&state->fill_grad,
	&state->fill
}, {
	/* stroke color */
	state->interned_stroke,
	SVGTIOP_PAINT,
	&state->stroke_grad,
	&state->stroke
}, {
	/* stroke width */
	state->interned_stroke_width,
	SVGTIOP_INTLENGTH,
	&state->viewport_width,
	&state->stroke_width
},{
	NULL((void*)0), SVGTIOP_NONE, NULL((void*)0), NULL((void*)0)
},
};

svgtiny_parse_attributes(node, state, ops);
svgtiny_parse_inline_style(node, state, ops);
239}


242/**
* Parse font attributes, if present.
*/
245static void
246svgtiny_parse_font_attributes(dom_element *node,
	      struct svgtiny_parse_state *state)
248{
/* TODO: Implement this, it never used to be */
UNUSED(node)((void) (node));
UNUSED(state)((void) (state));
252#ifdef WRITTEN_THIS_PROPERLY
const xmlAttr *attr;

UNUSED(state)((void) (state));

for (attr = node->properties; attr; attr = attr->next) {
if (strcmp((const char *) attr->name, "font-size") == 0) {
	/*if (css_parse_length(
	  (const char *) attr->children->content,
	  &state->style.font_size.value.length,
	  true, true)) {
	  state->style.font_size.size =
	  CSS_FONT_SIZE_LENGTH;
	  }*/
}
      }
268#endif
269}


272/**
* Parse transform attributes, if present.
*
* http://www.w3.org/TR/SVG11/coords#TransformAttribute
*/
277static void
278svgtiny_parse_transform_attributes(dom_element *node,
		   struct svgtiny_parse_state *state)
280{
dom_string *attr;
dom_exception exc;

exc = dom_element_get_attribute(node, state->interned_transform, &attr)dom_element_get_attribute( (dom_element *) (node), (state->
interned_transform), (&attr));
if (exc == DOM_NO_ERR && attr != NULL((void*)0)) {
svgtiny_parse_transform(dom_string_data(attr),
			dom_string_byte_length(attr),
			&state->ctm);

dom_string_unref(attr);
}
292}


295/**
* Add a path to the svgtiny_diagram.
*/
298static svgtiny_code
299svgtiny_add_path(float *p, unsigned int n, struct svgtiny_parse_state *state)
300{
struct svgtiny_shape *shape;
svgtiny_code res = svgtiny_OK;

if (state->fill == svgtiny_LINEAR_GRADIENT0x2000000) {
/* adds a shape to fill the path with a linear gradient */
res = svgtiny_gradient_add_fill_path(p, n, state);
}
if (res != svgtiny_OK) {
free(p);
return res;
}

if (state->stroke == svgtiny_LINEAR_GRADIENT0x2000000) {
/* adds a shape to stroke the path with a linear gradient */
res = svgtiny_gradient_add_stroke_path(p, n, state);
}
if (res != svgtiny_OK) {
free(p);
return res;
}

/* if stroke and fill are transparent do not add a shape */
if ((state->fill == svgtiny_TRANSPARENT0x1000000) &&
   (state->stroke == svgtiny_TRANSPARENT0x1000000)) {
free(p);
return res;
}

svgtiny_transform_path(p, n, state);

shape = svgtiny_add_shape(state);
if (shape == NULL((void*)0)) {
free(p);
return svgtiny_OUT_OF_MEMORY;
}
shape->path = p;
shape->path_length = n;
state->diagram->shape_count++;


return svgtiny_OK;
342}


345/**
* return svgtiny_OK if source is an ancestor of target else svgtiny_LIBDOM_ERROR
*/
348static svgtiny_code is_ancestor_node(dom_node *source, dom_node *target)
349{
dom_node *parent;
dom_exception exc;

parent = dom_node_ref(target)dom_node_ref((dom_node *) (target));
while (parent != NULL((void*)0)) {
dom_node *next = NULL((void*)0);
if (parent == source) {
	dom_node_unref(parent)dom_node_unref((dom_node *) (parent));
	return svgtiny_OK;
}
exc = dom_node_get_parent_node(parent, &next)dom_node_get_parent_node( (dom_node *) (parent), (dom_node **
) (&next));
dom_node_unref(parent)dom_node_unref((dom_node *) (parent));
if (exc != DOM_NO_ERR) {
	break;
}

parent = next;
}
return svgtiny_LIBDOM_ERROR;
369}


372/**
* Parse a <path> element node.
*
* https://svgwg.org/svg2-draft/paths.html#PathElement
*/
377static svgtiny_code
378svgtiny_parse_path(dom_element *path, struct svgtiny_parse_state state)
379{
svgtiny_code res;
dom_string *path_d_str;
dom_exception exc;
float *p; /* path elemets */
unsigned int i;

svgtiny_setup_state_local(&state);

svgtiny_parse_paint_attributes(path, &state);
svgtiny_parse_transform_attributes(path, &state);

/* read d attribute */
exc = dom_element_get_attribute(path, state.interned_d, &path_d_str)dom_element_get_attribute( (dom_element *) (path), (state.interned_d
), (&path_d_str));
if (exc != DOM_NO_ERR) {
state.diagram->error_line = -1; /* path->line; */
state.diagram->error_message = "path: error retrieving d attribute";
svgtiny_cleanup_state_local(&state);
return svgtiny_SVG_ERROR;
}

if (path_d_str == NULL((void*)0)) {
state.diagram->error_line = -1; /* path->line; */
state.diagram->error_message = "path: missing d attribute";
svgtiny_cleanup_state_local(&state);
return svgtiny_SVG_ERROR;
}

res = svgtiny_parse_path_data(dom_string_data(path_d_str),
		      dom_string_byte_length(path_d_str),
		      &p,
                      &i);
if (res != svgtiny_OK) {
svgtiny_cleanup_state_local(&state);
return res;
}

if (i <= 4) {
/* insufficient segments in path treated as none */
if (i > 0) {
	free(p);
}
res = svgtiny_OK;
} else {
res = svgtiny_add_path(p, i, &state);
}

svgtiny_cleanup_state_local(&state);

return res;
429}


432/**
* Parse a <rect> element node.
*
* http://www.w3.org/TR/SVG11/shapes#RectElement
*/
437static svgtiny_code
438svgtiny_parse_rect(dom_element *rect, struct svgtiny_parse_state state)
439{
svgtiny_code err;
float x, y, width, height;
float *p;

svgtiny_setup_state_local(&state);

svgtiny_parse_position_attributes(rect, state,
			  &x, &y, &width, &height);
svgtiny_parse_paint_attributes(rect, &state);
svgtiny_parse_transform_attributes(rect, &state);

p = malloc(13 * sizeof p[0]);
if (!p) {
svgtiny_cleanup_state_local(&state);
return svgtiny_OUT_OF_MEMORY;
}

p[0] = svgtiny_PATH_MOVE;
p[1] = x;
p[2] = y;
p[3] = svgtiny_PATH_LINE;
p[4] = x + width;
p[5] = y;
p[6] = svgtiny_PATH_LINE;
p[7] = x + width;
p[8] = y + height;
p[9] = svgtiny_PATH_LINE;
p[10] = x;
p[11] = y + height;
p[12] = svgtiny_PATH_CLOSE;

err = svgtiny_add_path(p, 13, &state);

svgtiny_cleanup_state_local(&state);

return err;
476}


479/**
* Parse a <circle> element node.
*/
482static svgtiny_code
483svgtiny_parse_circle(dom_element *circle, struct svgtiny_parse_state state)
484{
svgtiny_code err;
float x = 0, y = 0, r = -1;
float *p;
struct svgtiny_parse_internal_operation ops[] = {
{
	state.interned_cx,
	SVGTIOP_LENGTH,
	&state.viewport_width,
	&x
}, {
	state.interned_cy,
	SVGTIOP_LENGTH,
	&state.viewport_height,
	&y
}, {
	state.interned_r,
	SVGTIOP_LENGTH,
	&state.viewport_width,
	&r
}, {
	NULL((void*)0), SVGTIOP_NONE, NULL((void*)0), NULL((void*)0)
},
};

svgtiny_setup_state_local(&state);

err = svgtiny_parse_attributes(circle, &state, ops);
if (err != svgtiny_OK) {
svgtiny_cleanup_state_local(&state);
return err;
}

svgtiny_parse_paint_attributes(circle, &state);
svgtiny_parse_transform_attributes(circle, &state);

if (r < 0) {
state.diagram->error_line = -1; /* circle->line; */
state.diagram->error_message = "circle: r missing or negative";
svgtiny_cleanup_state_local(&state);
return svgtiny_SVG_ERROR;
}
if (r == 0) {
svgtiny_cleanup_state_local(&state);
return svgtiny_OK;
}

p = malloc(32 * sizeof p[0]);
if (!p) {
svgtiny_cleanup_state_local(&state);
return svgtiny_OUT_OF_MEMORY;
}

p[0] = svgtiny_PATH_MOVE;
p[1] = x + r;
p[2] = y;
p[3] = svgtiny_PATH_BEZIER;
p[4] = x + r;
p[5] = y + r * KAPPA0.5522847498;
p[6] = x + r * KAPPA0.5522847498;
p[7] = y + r;
p[8] = x;
p[9] = y + r;
p[10] = svgtiny_PATH_BEZIER;
p[11] = x - r * KAPPA0.5522847498;
p[12] = y + r;
p[13] = x - r;
p[14] = y + r * KAPPA0.5522847498;
p[15] = x - r;
p[16] = y;
p[17] = svgtiny_PATH_BEZIER;
p[18] = x - r;
p[19] = y - r * KAPPA0.5522847498;
p[20] = x - r * KAPPA0.5522847498;
p[21] = y - r;
p[22] = x;
p[23] = y - r;
p[24] = svgtiny_PATH_BEZIER;
p[25] = x + r * KAPPA0.5522847498;
p[26] = y - r;
p[27] = x + r;
p[28] = y - r * KAPPA0.5522847498;
p[29] = x + r;
p[30] = y;
p[31] = svgtiny_PATH_CLOSE;

err = svgtiny_add_path(p, 32, &state);

svgtiny_cleanup_state_local(&state);

return err;
575}


578/**
* Parse an <ellipse> element node.
*/
581static svgtiny_code
582svgtiny_parse_ellipse(dom_element *ellipse, struct svgtiny_parse_state state)
583{
svgtiny_code err;
float x = 0, y = 0, rx = -1, ry = -1;
float *p;
struct svgtiny_parse_internal_operation ops[] = {
{
	state.interned_cx,
	SVGTIOP_LENGTH,
	&state.viewport_width,
	&x
}, {
	state.interned_cy,
	SVGTIOP_LENGTH,
	&state.viewport_height,
	&y
}, {
	state.interned_rx,
	SVGTIOP_LENGTH,
	&state.viewport_width,
	&rx
}, {
	state.interned_ry,
	SVGTIOP_LENGTH,
	&state.viewport_height,
	&ry
}, {
	NULL((void*)0), SVGTIOP_NONE, NULL((void*)0), NULL((void*)0)
},
};

svgtiny_setup_state_local(&state);

err = svgtiny_parse_attributes(ellipse, &state, ops);
if (err != svgtiny_OK) {
svgtiny_cleanup_state_local(&state);
return err;
}

svgtiny_parse_paint_attributes(ellipse, &state);
svgtiny_parse_transform_attributes(ellipse, &state);

if (rx < 0 || ry < 0) {
state.diagram->error_line = -1; /* ellipse->line; */
state.diagram->error_message = "ellipse: rx or ry missing "
	"or negative";
svgtiny_cleanup_state_local(&state);
return svgtiny_SVG_ERROR;
}
if (rx == 0 || ry == 0) {
svgtiny_cleanup_state_local(&state);
return svgtiny_OK;
}

p = malloc(32 * sizeof p[0]);
if (!p) {
svgtiny_cleanup_state_local(&state);
return svgtiny_OUT_OF_MEMORY;
}

p[0] = svgtiny_PATH_MOVE;
p[1] = x + rx;
p[2] = y;
p[3] = svgtiny_PATH_BEZIER;
p[4] = x + rx;
p[5] = y + ry * KAPPA0.5522847498;
p[6] = x + rx * KAPPA0.5522847498;
p[7] = y + ry;
p[8] = x;
p[9] = y + ry;
p[10] = svgtiny_PATH_BEZIER;
p[11] = x - rx * KAPPA0.5522847498;
p[12] = y + ry;
p[13] = x - rx;
p[14] = y + ry * KAPPA0.5522847498;
p[15] = x - rx;
p[16] = y;
p[17] = svgtiny_PATH_BEZIER;
p[18] = x - rx;
p[19] = y - ry * KAPPA0.5522847498;
p[20] = x - rx * KAPPA0.5522847498;
p[21] = y - ry;
p[22] = x;
p[23] = y - ry;
p[24] = svgtiny_PATH_BEZIER;
p[25] = x + rx * KAPPA0.5522847498;
p[26] = y - ry;
p[27] = x + rx;
p[28] = y - ry * KAPPA0.5522847498;
p[29] = x + rx;
p[30] = y;
p[31] = svgtiny_PATH_CLOSE;

err = svgtiny_add_path(p, 32, &state);

svgtiny_cleanup_state_local(&state);

return err;
680}


683/**
* Parse a <line> element node.
*/
686static svgtiny_code
687svgtiny_parse_line(dom_element *line, struct svgtiny_parse_state state)
688{
svgtiny_code err;
float x1 = 0, y1 = 0, x2 = 0, y2 = 0;
float *p;
struct svgtiny_parse_internal_operation ops[] = {
{
	state.interned_x1,
	SVGTIOP_LENGTH,
	&state.viewport_width,
	&x1
}, {
	state.interned_y1,
	SVGTIOP_LENGTH,
	&state.viewport_height,
	&y1
}, {
	state.interned_x2,
	SVGTIOP_LENGTH,
	&state.viewport_width,
	&x2
}, {
	state.interned_y2,
	SVGTIOP_LENGTH,
	&state.viewport_height,
	&y2
}, {
	NULL((void*)0), SVGTIOP_NONE, NULL((void*)0), NULL((void*)0)
},
};

svgtiny_setup_state_local(&state);

err = svgtiny_parse_attributes(line, &state, ops);
if (err != svgtiny_OK) {
svgtiny_cleanup_state_local(&state);
return err;
}

svgtiny_parse_paint_attributes(line, &state);
svgtiny_parse_transform_attributes(line, &state);

p = malloc(7 * sizeof p[0]);
if (!p) {
svgtiny_cleanup_state_local(&state);
return svgtiny_OUT_OF_MEMORY;
}

p[0] = svgtiny_PATH_MOVE;
p[1] = x1;
p[2] = y1;
p[3] = svgtiny_PATH_LINE;
p[4] = x2;
p[5] = y2;
p[6] = svgtiny_PATH_CLOSE;

err = svgtiny_add_path(p, 7, &state);

svgtiny_cleanup_state_local(&state);

return err;
748}


751/**
* Parse a <polyline> or <polygon> element node.
*
* http://www.w3.org/TR/SVG11/shapes#PolylineElement
* http://www.w3.org/TR/SVG11/shapes#PolygonElement
*/
757static svgtiny_code
758svgtiny_parse_poly(dom_element *poly,
   struct svgtiny_parse_state state,
   bool_Bool polygon)
761{
svgtiny_code err;
dom_string *points_str;
dom_exception exc;
float *pointv;
unsigned int pointc;

svgtiny_setup_state_local(&state);

svgtiny_parse_paint_attributes(poly, &state);
svgtiny_parse_transform_attributes(poly, &state);

exc = dom_element_get_attribute(poly, state.interned_points,dom_element_get_attribute( (dom_element *) (poly), (state.interned_points
), (&points_str))
			&points_str)dom_element_get_attribute( (dom_element *) (poly), (state.interned_points
), (&points_str));
if (exc != DOM_NO_ERR) {
svgtiny_cleanup_state_local(&state);
return svgtiny_LIBDOM_ERROR;
}

if (points_str == NULL((void*)0)) {
state.diagram->error_line = -1; /* poly->line; */
state.diagram->error_message =
	"polyline/polygon: missing points attribute";
svgtiny_cleanup_state_local(&state);
return svgtiny_SVG_ERROR;
}

/* allocate space for path: it will never have more elements than bytes
* in the string.
*/
pointc = dom_string_byte_length(points_str);
pointv = malloc(sizeof pointv[0] * pointc);
if (pointv == NULL((void*)0)) {
svgtiny_cleanup_state_local(&state);
return svgtiny_OUT_OF_MEMORY;
}

err = svgtiny_parse_poly_points(dom_string_data(points_str),
			dom_string_byte_length(points_str),
			pointv,
			&pointc);
dom_string_unref(points_str);
if (err != svgtiny_OK) {
free(pointv);
state.diagram->error_line = -1; /* poly->line; */
state.diagram->error_message =
	"polyline/polygon: failed to parse points";
} else {
if (pointc > 0) {
	pointv[0] = svgtiny_PATH_MOVE;
}
if (polygon) {
	pointv[pointc++] = svgtiny_PATH_CLOSE;
}

err = svgtiny_add_path(pointv, pointc, &state);
}
svgtiny_cleanup_state_local(&state);

return err;
821}


824/**
* Parse a <text> or <tspan> element node.
*/
827static svgtiny_code
828svgtiny_parse_text(dom_element *text, struct svgtiny_parse_state state)
829{
float x, y, width, height;
float px, py;
dom_node *child;
dom_exception exc;

svgtiny_setup_state_local(&state);

svgtiny_parse_position_attributes(text, state,
			  &x, &y, &width, &height);
svgtiny_parse_font_attributes(text, &state);
svgtiny_parse_transform_attributes(text, &state);

px = state.ctm.a * x + state.ctm.c * y + state.ctm.e;
py = state.ctm.b * x + state.ctm.d * y + state.ctm.f;
844/*	state.ctm.e = px - state.origin_x; */
845/*	state.ctm.f = py - state.origin_y; */

/*struct css_style style = state.style;
 style.font_size.value.length.value *= state.ctm.a;*/

      exc = dom_node_get_first_child(text, &child)dom_node_get_first_child( (dom_node *) (text), (dom_node **) (
&child));
if (exc != DOM_NO_ERR) {
return svgtiny_LIBDOM_ERROR;
svgtiny_cleanup_state_local(&state);
}
while (child != NULL((void*)0)) {
dom_node *next;
dom_node_type nodetype;
svgtiny_code code = svgtiny_OK;

exc = dom_node_get_node_type(child, &nodetype)dom_node_get_node_type( (dom_node *) (child), (dom_node_type *
) (&nodetype));
if (exc != DOM_NO_ERR) {
	dom_node_unref(child)dom_node_unref((dom_node *) (child));
	svgtiny_cleanup_state_local(&state);
	return svgtiny_LIBDOM_ERROR;
}
if (nodetype == DOM_ELEMENT_NODE) {
	dom_string *nodename;
	exc = dom_node_get_node_name(child, &nodename)dom_node_get_node_name((dom_node *) (child), (&nodename));
	if (exc != DOM_NO_ERR) {
		dom_node_unref(child)dom_node_unref((dom_node *) (child));
		svgtiny_cleanup_state_local(&state);
		return svgtiny_LIBDOM_ERROR;
	}
	if (dom_string_caseless_isequal(nodename,
					state.interned_tspan))
		code = svgtiny_parse_text((dom_element *)child,
					  state);
	dom_string_unref(nodename);
} else if (nodetype == DOM_TEXT_NODE) {
	struct svgtiny_shape *shape = svgtiny_add_shape(&state);
	dom_string *content;
	if (shape == NULL((void*)0)) {
		dom_node_unref(child)dom_node_unref((dom_node *) (child));
		svgtiny_cleanup_state_local(&state);
		return svgtiny_OUT_OF_MEMORY;
	}
	exc = dom_text_get_whole_text(child, &content)dom_text_get_whole_text((dom_text *) (child), (&content));
	if (exc != DOM_NO_ERR) {
		dom_node_unref(child)dom_node_unref((dom_node *) (child));
		svgtiny_cleanup_state_local(&state);
		return svgtiny_LIBDOM_ERROR;
	}
	if (content != NULL((void*)0)) {
		shape->text = strndup(dom_string_data(content),
				      dom_string_byte_length(content));
		dom_string_unref(content);
	} else {
		shape->text = strdup("");
	}
	shape->text_x = px;
	shape->text_y = py;
	state.diagram->shape_count++;
}

if (code != svgtiny_OK) {
	dom_node_unref(child)dom_node_unref((dom_node *) (child));
	svgtiny_cleanup_state_local(&state);
	return code;
}
exc = dom_node_get_next_sibling(child, &next)dom_node_get_next_sibling( (dom_node *) (child), (dom_node **
) (&next));
dom_node_unref(child)dom_node_unref((dom_node *) (child));
if (exc != DOM_NO_ERR) {
	svgtiny_cleanup_state_local(&state);
	return svgtiny_LIBDOM_ERROR;
}
child = next;
}

svgtiny_cleanup_state_local(&state);

return svgtiny_OK;
922}


925/**
* Parse a <use> element node.
*
* https://www.w3.org/TR/SVG2/struct.html#UseElement
*/
930static svgtiny_code
931svgtiny_parse_use(dom_element *use, struct svgtiny_parse_state state)
1
[debug] analyzing from svgtiny_parse_use→
932{
svgtiny_code res;
dom_element *ref; /* referenced element */

svgtiny_setup_state_local(&state);

res = svgtiny_parse_element_from_href(use, &state, &ref);
if (res != svgtiny_OK) {
svgtiny_cleanup_state_local(&state);
return res;
}

if (ref != NULL((void*)0)) {
/* found the reference */

/**
 * If the referenced element is a ancestor of the ‘use’ element,
 * then this is an invalid circular reference and the ‘use’
 * element is in error.
 */
res = is_ancestor_node((dom_node *)ref, (dom_node *)use);
if (res != svgtiny_OK) {
	res = parse_element(ref, &state);
2
←
Value stored to 'res' is never read
}
dom_node_unref(ref)dom_node_unref((dom_node *) (ref));
}

svgtiny_cleanup_state_local(&state);

return svgtiny_OK;
962}


965/**
* Parse a <svg> or <g> element node.
*/
968static svgtiny_code
969svgtiny_parse_svg(dom_element *svg, struct svgtiny_parse_state state)
970{
float x, y, width, height;
dom_string *view_box;
dom_element *child;
dom_exception exc;

svgtiny_setup_state_local(&state);

svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
svgtiny_parse_paint_attributes(svg, &state);
svgtiny_parse_font_attributes(svg, &state);

exc = dom_element_get_attribute(svg, state.interned_viewBox,dom_element_get_attribute( (dom_element *) (svg), (state.interned_viewBox
), (&view_box))
			&view_box)dom_element_get_attribute( (dom_element *) (svg), (state.interned_viewBox
), (&view_box));
if (exc != DOM_NO_ERR) {
svgtiny_cleanup_state_local(&state);
return svgtiny_LIBDOM_ERROR;
}

if (view_box) {
svgtiny_parse_viewbox(dom_string_data(view_box),
		      dom_string_byte_length(view_box),
		      state.viewport_width,
		      state.viewport_height,
		      &state.ctm);
dom_string_unref(view_box);
}

svgtiny_parse_transform_attributes(svg, &state);

exc = dom_node_get_first_child(svg, (dom_node **) (void *) &child)dom_node_get_first_child( (dom_node *) (svg), (dom_node **) (
(dom_node **) (void *) &child));
if (exc != DOM_NO_ERR) {
svgtiny_cleanup_state_local(&state);
return svgtiny_LIBDOM_ERROR;
}
while (child != NULL((void*)0)) {
dom_element *next;
dom_node_type nodetype;
svgtiny_code code = svgtiny_OK;

exc = dom_node_get_node_type(child, &nodetype)dom_node_get_node_type( (dom_node *) (child), (dom_node_type *
) (&nodetype));
if (exc != DOM_NO_ERR) {
	dom_node_unref(child)dom_node_unref((dom_node *) (child));
	return svgtiny_LIBDOM_ERROR;
}
if (nodetype == DOM_ELEMENT_NODE) {
	code = parse_element(child, &state);
}
if (code != svgtiny_OK) {
	dom_node_unref(child)dom_node_unref((dom_node *) (child));
	svgtiny_cleanup_state_local(&state);
	return code;
}
exc = dom_node_get_next_sibling(child,dom_node_get_next_sibling( (dom_node *) (child), (dom_node **
) ((dom_node **) (void *) &next))
				(dom_node **) (void *) &next)dom_node_get_next_sibling( (dom_node *) (child), (dom_node **
) ((dom_node **) (void *) &next));
dom_node_unref(child)dom_node_unref((dom_node *) (child));
if (exc != DOM_NO_ERR) {
	svgtiny_cleanup_state_local(&state);
	return svgtiny_LIBDOM_ERROR;
}
child = next;
}

svgtiny_cleanup_state_local(&state);
return svgtiny_OK;
1035}


1038static svgtiny_code
1039parse_element(dom_element *element, struct svgtiny_parse_state *state)
1040{
dom_exception exc;
dom_string *nodename;
svgtiny_code code = svgtiny_OK;;

exc = dom_node_get_node_name(element, &nodename)dom_node_get_node_name((dom_node *) (element), (&nodename
));
if (exc != DOM_NO_ERR) {
return svgtiny_LIBDOM_ERROR;
}

if (dom_string_caseless_isequal(state->interned_svg, nodename)) {
code = svgtiny_parse_svg(element, *state);
} else if (dom_string_caseless_isequal(state->interned_g, nodename)) {
code = svgtiny_parse_svg(element, *state);
} else if (dom_string_caseless_isequal(state->interned_a, nodename)) {
code = svgtiny_parse_svg(element, *state);
} else if (dom_string_caseless_isequal(state->interned_path, nodename)) {
code = svgtiny_parse_path(element, *state);
} else if (dom_string_caseless_isequal(state->interned_rect, nodename)) {
code = svgtiny_parse_rect(element, *state);
} else if (dom_string_caseless_isequal(state->interned_circle, nodename)) {
code = svgtiny_parse_circle(element, *state);
} else if (dom_string_caseless_isequal(state->interned_ellipse, nodename)) {
code = svgtiny_parse_ellipse(element, *state);
} else if (dom_string_caseless_isequal(state->interned_line, nodename)) {
code = svgtiny_parse_line(element, *state);
} else if (dom_string_caseless_isequal(state->interned_polyline, nodename)) {
code = svgtiny_parse_poly(element, *state, false0);
} else if (dom_string_caseless_isequal(state->interned_polygon, nodename)) {
code = svgtiny_parse_poly(element, *state, true1);
} else if (dom_string_caseless_isequal(state->interned_text, nodename)) {
code = svgtiny_parse_text(element, *state);
} else if (dom_string_caseless_isequal(state->interned_use, nodename)) {
code = svgtiny_parse_use(element, *state);
}
dom_string_unref(nodename);
return code;
1077}


1080static svgtiny_code
1081initialise_parse_state(struct svgtiny_parse_state *state,
       struct svgtiny_diagram *diagram,
       dom_document *document,
       dom_element *svg,
       int viewport_width,
       int viewport_height)
1087{
float x, y, width, height;

memset(state, 0, sizeof(*state));

state->diagram = diagram;
state->document = document;

1095#define SVGTINY_STRING_ACTION2(s,n)					\
if (dom_string_create_interned((const uint8_t *) #n,		\
		       strlen(#n),			\
		       &state->interned_##s)		\
   != DOM_NO_ERR) {						\
return svgtiny_LIBDOM_ERROR;				\
}
1102#include "svgtiny_strings.h"
1103#undef SVGTINY_STRING_ACTION2

/* get graphic dimensions */
state->viewport_width = viewport_width;
state->viewport_height = viewport_height;
svgtiny_parse_position_attributes(svg, *state, &x, &y, &width, &height);
diagram->width = width;
diagram->height = height;

/* set up parsing state */
state->viewport_width = width;
state->viewport_height = height;
state->ctm.a = 1; /*(float) viewport_width / (float) width;*/
state->ctm.b = 0;
state->ctm.c = 0;
state->ctm.d = 1; /*(float) viewport_height / (float) height;*/
state->ctm.e = 0; /*x;*/
state->ctm.f = 0; /*y;*/
/*state->style = css_base_style;
 state->style.font_size.value.length.value = option_font_size * 0.1;*/
state->fill = 0x000000;
state->stroke = svgtiny_TRANSPARENT0x1000000;
state->stroke_width = 1;
return svgtiny_OK;
1127}


1130static svgtiny_code finalise_parse_state(struct svgtiny_parse_state *state)
1131{
svgtiny_cleanup_state_local(state);

1134#define SVGTINY_STRING_ACTION2(s,n)				\
if (state->interned_##s != NULL((void*)0))			\
dom_string_unref(state->interned_##s);
1137#include "svgtiny_strings.h"
1138#undef SVGTINY_STRING_ACTION2
return svgtiny_OK;
1140}


1143static svgtiny_code get_svg_element(dom_document *document, dom_element **svg)
1144{
dom_exception exc;
dom_string *svg_name;
lwc_string *svg_name_lwc;

/* find root <svg> element */
exc = dom_document_get_document_element(document, svg)dom_document_get_document_element((dom_document *) (document)
, (struct dom_element **) (svg));
if (exc != DOM_NO_ERR) {
return svgtiny_LIBDOM_ERROR;
}
      if (svg == NULL((void*)0)) {
              /* no root element */
return svgtiny_SVG_ERROR;
      }

/* ensure root element is <svg> */
exc = dom_node_get_node_name(*svg, &svg_name)dom_node_get_node_name((dom_node *) (*svg), (&svg_name));
if (exc != DOM_NO_ERR) {
dom_node_unref(*svg)dom_node_unref((dom_node *) (*svg));
return svgtiny_LIBDOM_ERROR;
}
if (lwc_intern_string("svg", 3 /* SLEN("svg") */,
	      &svg_name_lwc) != lwc_error_ok) {
dom_string_unref(svg_name);
dom_node_unref(*svg)dom_node_unref((dom_node *) (*svg));
return svgtiny_LIBDOM_ERROR;
}
if (!dom_string_caseless_lwc_isequal(svg_name, svg_name_lwc)) {
lwc_string_unref(svg_name_lwc){ lwc_string *__lwc_s = (svg_name_lwc); ((__lwc_s != ((void*)
0)) ? (void) (0) : __assert_fail ("__lwc_s != NULL", "src/svgtiny.c"
, 1172, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
dom_string_unref(svg_name);
dom_node_unref(*svg)dom_node_unref((dom_node *) (*svg));
return svgtiny_NOT_SVG;
}

lwc_string_unref(svg_name_lwc){ lwc_string *__lwc_s = (svg_name_lwc); ((__lwc_s != ((void*)
0)) ? (void) (0) : __assert_fail ("__lwc_s != NULL", "src/svgtiny.c"
, 1178, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
dom_string_unref(svg_name);

return svgtiny_OK;
1182}


1185static svgtiny_code
1186svg_document_from_buffer(uint8_t *buffer, size_t size, dom_document **document)
1187{
dom_xml_parser *parser;
dom_xml_error err;

parser = dom_xml_parser_create(NULL((void*)0), NULL((void*)0), ignore_msg, NULL((void*)0), document);

if (parser == NULL((void*)0))
return svgtiny_LIBDOM_ERROR;

err = dom_xml_parser_parse_chunk(parser, buffer, size);
if (err != DOM_XML_OK) {
dom_node_unref(*document)dom_node_unref((dom_node *) (*document));
dom_xml_parser_destroy(parser);
return svgtiny_LIBDOM_ERROR;
}

err = dom_xml_parser_completed(parser);
if (err != DOM_XML_OK) {
dom_node_unref(*document)dom_node_unref((dom_node *) (*document));
dom_xml_parser_destroy(parser);
return svgtiny_LIBDOM_ERROR;
}

/* We're done parsing, drop the parser.
* We now own the document entirely.
*/
dom_xml_parser_destroy(parser);

return svgtiny_OK;
1216}


1219/**
* Add a svgtiny_shape to the svgtiny_diagram.
*
* library internal interface
*/
1224struct svgtiny_shape *svgtiny_add_shape(struct svgtiny_parse_state *state)
1225{
struct svgtiny_shape *shape;

shape = realloc(state->diagram->shape,
	(state->diagram->shape_count + 1) *
	sizeof (state->diagram->shape[0]));
if (shape != NULL((void*)0)) {
state->diagram->shape = shape;

shape += state->diagram->shape_count;
shape->path = 0;
shape->path_length = 0;
shape->text = 0;
shape->fill = state->fill;
shape->stroke = state->stroke;
shape->stroke_width = lroundf((float) state->stroke_width *
			      (state->ctm.a + state->ctm.d) / 2.0);
if (0 < state->stroke_width && shape->stroke_width == 0)
	shape->stroke_width = 1;
}
return shape;
1246}


1249/**
* Apply the current transformation matrix to a path.
*
* library internal interface
*/
1254void
1255svgtiny_transform_path(float *p,
       unsigned int n,
       struct svgtiny_parse_state *state)
1258{
unsigned int j;

for (j = 0; j != n; ) {
unsigned int points = 0;
unsigned int k;
switch ((int) p[j]) {
case svgtiny_PATH_MOVE:
case svgtiny_PATH_LINE:
	points = 1;
	break;
case svgtiny_PATH_CLOSE:
	points = 0;
	break;
case svgtiny_PATH_BEZIER:
	points = 3;
	break;
default:
	assert(0)((0) ? (void) (0) : __assert_fail ("0", "src/svgtiny.c", 1276
, __extension__ __PRETTY_FUNCTION__));
}
j++;
for (k = 0; k != points; k++) {
	float x0 = p[j], y0 = p[j + 1];
	float x = state->ctm.a * x0 + state->ctm.c * y0 +
		state->ctm.e;
	float y = state->ctm.b * x0 + state->ctm.d * y0 +
		state->ctm.f;
	p[j] = x;
	p[j + 1] = y;
	j += 2;
}
}
1290}


1293/**
* Create a new svgtiny_diagram structure.
*/
1296struct svgtiny_diagram *svgtiny_create(void)
1297{
struct svgtiny_diagram *diagram;

diagram = calloc(1, sizeof(*diagram));

return diagram;
1303}


1306/**
* Parse a block of memory into a svgtiny_diagram.
*/
1309svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
	   const char *buffer, size_t size, const char *url,
	   int viewport_width, int viewport_height)
1312{
dom_document *document;
dom_element *svg;
struct svgtiny_parse_state state;
svgtiny_code code;

assert(diagram)((diagram) ? (void) (0) : __assert_fail ("diagram", "src/svgtiny.c"
, 1318, __extension__ __PRETTY_FUNCTION__));
assert(buffer)((buffer) ? (void) (0) : __assert_fail ("buffer", "src/svgtiny.c"
, 1319, __extension__ __PRETTY_FUNCTION__));
assert(url)((url) ? (void) (0) : __assert_fail ("url", "src/svgtiny.c", 1320
, __extension__ __PRETTY_FUNCTION__));

UNUSED(url)((void) (url));

code = svg_document_from_buffer((uint8_t *)buffer, size, &document);
if (code == svgtiny_OK) {
code = get_svg_element(document, &svg);
if (code == svgtiny_OK) {
	code = initialise_parse_state(&state,
				      diagram,
				      document,
				      svg,
				      viewport_width,
				      viewport_height);
	if (code == svgtiny_OK) {
		code = svgtiny_parse_svg(svg, state);
	}

	finalise_parse_state(&state);

	dom_node_unref(svg)dom_node_unref((dom_node *) (svg));
}
dom_node_unref(document)dom_node_unref((dom_node *) (document));
}

return code;
1346}


1349/**
* Free all memory used by a diagram.
*/
1352void svgtiny_free(struct svgtiny_diagram *svg)
1353{
unsigned int i;
assert(svg)((svg) ? (void) (0) : __assert_fail ("svg", "src/svgtiny.c", 1355
, __extension__ __PRETTY_FUNCTION__));

for (i = 0; i != svg->shape_count; i++) {
free(svg->shape[i].path);
free(svg->shape[i].text);
}

free(svg->shape);

free(svg);
1365}