X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=src%2Fsvgtiny.c;h=efac78882da2185d0cfea1b13a880f994bc72d83;hb=1e71d0472529b96ac35e2e4425b66e29146a01c1;hp=79a87d70c8b41b77195f80ee0bf8699eaeaffc53;hpb=1e37287ed69ca5c9828cb156dd567d0f3b9fea20;p=libsvgtiny.git

diff --git a/src/svgtiny.c b/src/svgtiny.c
index 79a87d7..efac788 100644
--- a/src/svgtiny.c
+++ b/src/svgtiny.c
@@ -42,17 +42,85 @@ static svgtiny_code svgtiny_parse_poly(dom_element *poly,
 		struct svgtiny_parse_state state, bool polygon);
 static svgtiny_code svgtiny_parse_text(dom_element *text,
 		struct svgtiny_parse_state state);
-static void svgtiny_parse_position_attributes(const dom_element *node,
+static void svgtiny_parse_position_attributes(dom_element *node,
 		const struct svgtiny_parse_state state,
 		float *x, float *y, float *width, float *height);
-static void svgtiny_parse_paint_attributes(const dom_element *node,
+static void svgtiny_parse_paint_attributes(dom_element *node,
 		struct svgtiny_parse_state *state);
-static void svgtiny_parse_font_attributes(const dom_element *node,
+static void svgtiny_parse_font_attributes(dom_element *node,
 		struct svgtiny_parse_state *state);
 static void svgtiny_parse_transform_attributes(dom_element *node,
 		struct svgtiny_parse_state *state);
 static svgtiny_code svgtiny_add_path(float *p, unsigned int n,
 		struct svgtiny_parse_state *state);
+static void _svgtiny_parse_color(const char *s, svgtiny_colour *c,
+		struct svgtiny_parse_state_gradient *grad,
+		struct svgtiny_parse_state *state);
+
+/**
+ * Call this to ref the strings in a gradient state.
+ */
+static void svgtiny_grad_string_ref(struct svgtiny_parse_state_gradient *grad)
+{
+	if (grad->gradient_x1 != NULL) {
+		dom_string_ref(grad->gradient_x1);
+	}
+	if (grad->gradient_y1 != NULL) {
+		dom_string_ref(grad->gradient_y1);
+	}
+	if (grad->gradient_x2 != NULL) {
+		dom_string_ref(grad->gradient_x2);
+	}
+	if (grad->gradient_y2 != NULL) {
+		dom_string_ref(grad->gradient_y2);
+	}
+}
+
+/**
+ * Call this to clean up the strings in a gradient state.
+ */
+static void svgtiny_grad_string_cleanup(
+		struct svgtiny_parse_state_gradient *grad)
+{
+	if (grad->gradient_x1 != NULL) {
+		dom_string_unref(grad->gradient_x1);
+		grad->gradient_x1 = NULL;
+	}
+	if (grad->gradient_y1 != NULL) {
+		dom_string_unref(grad->gradient_y1);
+		grad->gradient_y1 = NULL;
+	}
+	if (grad->gradient_x2 != NULL) {
+		dom_string_unref(grad->gradient_x2);
+		grad->gradient_x2 = NULL;
+	}
+	if (grad->gradient_y2 != NULL) {
+		dom_string_unref(grad->gradient_y2);
+		grad->gradient_y2 = NULL;
+	}
+}
+
+/**
+ * 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.
+ */
+static void svgtiny_setup_state_local(struct svgtiny_parse_state *state)
+{
+	svgtiny_grad_string_ref(&(state->fill_grad));
+	svgtiny_grad_string_ref(&(state->stroke_grad));
+}
+
+/**
+ * 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.
+ */
+static void svgtiny_cleanup_state_local(struct svgtiny_parse_state *state)
+{
+	svgtiny_grad_string_cleanup(&(state->fill_grad));
+	svgtiny_grad_string_cleanup(&(state->stroke_grad));
+}
 
 
 /**
@@ -135,6 +203,12 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
 		dom_node_unref(document);
 		return svgtiny_LIBDOM_ERROR;
 	}
+        if (svg == NULL) {
+                /* no root svg element */
+                dom_node_unref(document);
+		return svgtiny_SVG_ERROR;
+        }
+
 	exc = dom_node_get_node_name(svg, &svg_name);
 	if (exc != DOM_NO_ERR) {
 		dom_node_unref(svg);
@@ -160,20 +234,21 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
 	dom_string_unref(svg_name);
 
 	/* get graphic dimensions */
+	memset(&state, 0, sizeof(state));
 	state.diagram = diagram;
 	state.document = document;
 	state.viewport_width = viewport_width;
 	state.viewport_height = viewport_height;
 
-#define SVGTINY_STRING_ACTION(s)					\
-	if (dom_string_create_interned((const uint8_t *) #s,		\
-				       strlen(#s), &state.interned_##s)	\
+#define SVGTINY_STRING_ACTION2(s,n)					\
+	if (dom_string_create_interned((const uint8_t *) #n,		\
+				       strlen(#n), &state.interned_##s)	\
 	    != DOM_NO_ERR) {						\
 		code = svgtiny_LIBDOM_ERROR;				\
 		goto cleanup;						\
 	}
 #include "svgtiny_strings.h"
-#undef SVGTINY_STRING_ACTION
+#undef SVGTINY_STRING_ACTION2
 
 	svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
 	diagram->width = width;
@@ -193,7 +268,6 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
 	state.fill = 0x000000;
 	state.stroke = svgtiny_TRANSPARENT;
 	state.stroke_width = 1;
-	state.linear_gradient_stop_count = 0;
 
 	/* parse tree */
 	code = svgtiny_parse_svg(svg, state);
@@ -202,11 +276,12 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
 	dom_node_unref(document);
 
 cleanup:
-#define SVGTINY_STRING_ACTION(s)				\
+	svgtiny_cleanup_state_local(&state);
+#define SVGTINY_STRING_ACTION2(s,n)			\
 	if (state.interned_##s != NULL)			\
 		dom_string_unref(state.interned_##s);
-//#include "svgtiny_strings.h"
-#undef SVGTINY_STRING_ACTION
+#include "svgtiny_strings.h"
+#undef SVGTINY_STRING_ACTION2
 	return code;
 }
 
@@ -223,6 +298,8 @@ svgtiny_code svgtiny_parse_svg(dom_element *svg,
 	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);
@@ -230,12 +307,13 @@ svgtiny_code svgtiny_parse_svg(dom_element *svg,
 	exc = dom_element_get_attribute(svg, state.interned_viewBox,
 					&view_box);
 	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
 	}
 
 	if (view_box) {
 		char *s = strndup(dom_string_data(view_box),
-				  dom_string_length(view_box));
+				  dom_string_byte_length(view_box));
 		float min_x, min_y, vwidth, vheight;
 		if (sscanf(s, "%f,%f,%f,%f",
 				&min_x, &min_y, &vwidth, &vheight) == 4 ||
@@ -252,8 +330,9 @@ svgtiny_code svgtiny_parse_svg(dom_element *svg,
 
 	svgtiny_parse_transform_attributes(svg, &state);
 
-	exc = dom_node_get_first_child(svg, &child);
+	exc = dom_node_get_first_child(svg, (dom_node **) (void *) &child);
 	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
 	}
 	while (child != NULL) {
@@ -271,6 +350,7 @@ svgtiny_code svgtiny_parse_svg(dom_element *svg,
 			exc = dom_node_get_node_name(child, &nodename);
 			if (exc != DOM_NO_ERR) {
 				dom_node_unref(child);
+				svgtiny_cleanup_state_local(&state);
 				return svgtiny_LIBDOM_ERROR;
 			}
 			if (dom_string_caseless_isequal(state.interned_svg,
@@ -310,16 +390,20 @@ svgtiny_code svgtiny_parse_svg(dom_element *svg,
 		}
 		if (code != svgtiny_OK) {
 			dom_node_unref(child);
+			svgtiny_cleanup_state_local(&state);
 			return code;
 		}
-		exc = dom_node_get_next_sibling(child, &next);
+		exc = dom_node_get_next_sibling(child,
+						(dom_node **) (void *) &next);
 		dom_node_unref(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;
 }
 
@@ -334,14 +418,19 @@ svgtiny_code svgtiny_parse_svg(dom_element *svg,
 svgtiny_code svgtiny_parse_path(dom_element *path,
 		struct svgtiny_parse_state state)
 {
+	svgtiny_code err;
 	dom_string *path_d_str;
 	dom_exception exc;
 	char *s, *path_d;
-	float *p;
+	float *p; /* path elemets */
+        unsigned int palloc; /* number of path elements allocated */
 	unsigned int i;
 	float last_x = 0, last_y = 0;
 	float last_cubic_x = 0, last_cubic_y = 0;
 	float last_quad_x = 0, last_quad_y = 0;
+	float subpath_first_x = 0, subpath_first_y = 0;
+
+	svgtiny_setup_state_local(&state);
 
 	svgtiny_parse_paint_attributes(path, &state);
 	svgtiny_parse_transform_attributes(path, &state);
@@ -351,25 +440,44 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 	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) {
 		state.diagram->error_line = -1; /* path->line; */
 		state.diagram->error_message = "path: missing d attribute";
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_SVG_ERROR;
 	}
 
-	s = path_d = strndup(dom_string_data(path_d_str),
-			     dom_string_length(path_d_str));
+        /* empty path is permitted it just disables the path */
+        palloc = dom_string_byte_length(path_d_str);
+        if (palloc == 0) {
+		svgtiny_cleanup_state_local(&state);
+		return svgtiny_OK;
+        }
+
+        /* local copy of the path data allowing in-place modification */
+	s = path_d = strndup(dom_string_data(path_d_str), palloc);
 	dom_string_unref(path_d_str);
 	if (s == NULL) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OUT_OF_MEMORY;
 	}
-	/* allocate space for path: it will never have more elements than d */
-	p = malloc(sizeof p[0] * strlen(s));
-	if (!p) {
+
+        /* ensure path element allocation is sensibly bounded */
+        if (palloc < 8) {
+            palloc = 8;
+        } else if (palloc > 64) {
+            palloc = palloc / 2;
+        }
+
+	/* allocate initial space for path elements */
+	p = malloc(sizeof p[0] * palloc);
+	if (p == NULL) {
 		free(path_d);
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OUT_OF_MEMORY;
 	}
 
@@ -384,6 +492,24 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 		float x, y, x1, y1, x2, y2, rx, ry, rotation, large_arc, sweep;
 		int n;
 
+                /* Ensure there is sufficient space for path elements */
+#define ALLOC_PATH_ELEMENTS(NUM_ELEMENTS)                               \
+                do {                                                    \
+                        if ((palloc - i) < NUM_ELEMENTS) {              \
+                                float *tp;                              \
+                                palloc = (palloc * 2) + (palloc / 2);   \
+                                tp = realloc(p, sizeof p[0] * palloc);  \
+                                if (tp == NULL) {                       \
+                                        free(p);                        \
+                                        free(path_d);                   \
+                                        svgtiny_cleanup_state_local(&state); \
+                                        return svgtiny_OUT_OF_MEMORY;   \
+                                }                                       \
+                                p = tp;                                 \
+                        }                                               \
+                } while(0)
+
+
 		/* moveto (M, m), lineto (L, l) (2 arguments) */
 		if (sscanf(s, " %1[MmLl] %f %f %n", command, &x, &y, &n) == 3) {
 			/*LOG(("moveto or lineto"));*/
@@ -392,11 +518,16 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 			else
 				plot_command = svgtiny_PATH_LINE;
 			do {
+                                ALLOC_PATH_ELEMENTS(3);
 				p[i++] = plot_command;
 				if ('a' <= *command) {
 					x += last_x;
 					y += last_y;
 				}
+				if (plot_command == svgtiny_PATH_MOVE) {
+					subpath_first_x = x;
+					subpath_first_y = y;
+				}
 				p[i++] = last_cubic_x = last_quad_x = last_x
 						= x;
 				p[i++] = last_cubic_y = last_quad_y = last_y
@@ -408,13 +539,19 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 		/* closepath (Z, z) (no arguments) */
 		} else if (sscanf(s, " %1[Zz] %n", command, &n) == 1) {
 			/*LOG(("closepath"));*/
+                        ALLOC_PATH_ELEMENTS(1);
+
 			p[i++] = svgtiny_PATH_CLOSE;
 			s += n;
+			last_cubic_x = last_quad_x = last_x = subpath_first_x;
+			last_cubic_y = last_quad_y = last_y = subpath_first_y;
 
 		/* horizontal lineto (H, h) (1 argument) */
 		} else if (sscanf(s, " %1[Hh] %f %n", command, &x, &n) == 2) {
 			/*LOG(("horizontal lineto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(3);
+
 				p[i++] = svgtiny_PATH_LINE;
 				if (*command == 'h')
 					x += last_x;
@@ -428,6 +565,8 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 		} else if (sscanf(s, " %1[Vv] %f %n", command, &y, &n) == 2) {
 			/*LOG(("vertical lineto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(3);
+
 				p[i++] = svgtiny_PATH_LINE;
 				if (*command == 'v')
 					y += last_y;
@@ -442,6 +581,8 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 				&x1, &y1, &x2, &y2, &x, &y, &n) == 7) {
 			/*LOG(("curveto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(7);
+
 				p[i++] = svgtiny_PATH_BEZIER;
 				if (*command == 'c') {
 					x1 += last_x;
@@ -466,6 +607,8 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 				&x2, &y2, &x, &y, &n) == 5) {
 			/*LOG(("shorthand/smooth curveto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(7);
+
 				p[i++] = svgtiny_PATH_BEZIER;
 				x1 = last_x + (last_x - last_cubic_x);
 				y1 = last_y + (last_y - last_cubic_y);
@@ -490,6 +633,8 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 				&x1, &y1, &x, &y, &n) == 5) {
 			/*LOG(("quadratic Bezier curveto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(7);
+
 				p[i++] = svgtiny_PATH_BEZIER;
 				last_quad_x = x1;
 				last_quad_y = y1;
@@ -515,6 +660,8 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 				&x, &y, &n) == 3) {
 			/*LOG(("shorthand/smooth quadratic Bezier curveto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(7);
+
 				p[i++] = svgtiny_PATH_BEZIER;
 				x1 = last_x + (last_x - last_quad_x);
 				y1 = last_y + (last_y - last_quad_y);
@@ -541,6 +688,8 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 				&rx, &ry, &rotation, &large_arc, &sweep,
 				&x, &y, &n) == 8) {
 			do {
+                                ALLOC_PATH_ELEMENTS(3);
+
 				p[i++] = svgtiny_PATH_LINE;
 				if (*command == 'a') {
 					x += last_x;
@@ -566,10 +715,28 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 	if (i <= 4) {
 		/* no real segments in path */
 		free(p);
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OK;
 	}
 
-	return svgtiny_add_path(p, i, &state);
+        /* resize path element array to not be over allocated */
+        if (palloc != i) {
+                float *tp;
+
+                /* try the resize, if it fails just continue to use the old
+                 * allocation
+                 */
+                tp = realloc(p, sizeof p[0] * i);
+                if (tp != NULL) {
+                        p = tp;
+                }
+        }
+
+	err = svgtiny_add_path(p, i, &state);
+
+	svgtiny_cleanup_state_local(&state);
+
+	return err;
 }
 
 
@@ -582,17 +749,22 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 svgtiny_code svgtiny_parse_rect(dom_element *rect,
 		struct svgtiny_parse_state state)
 {
+	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)
+	if (!p) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OUT_OF_MEMORY;
+	}
 
 	p[0] = svgtiny_PATH_MOVE;
 	p[1] = x;
@@ -608,7 +780,11 @@ svgtiny_code svgtiny_parse_rect(dom_element *rect,
 	p[11] = y + height;
 	p[12] = svgtiny_PATH_CLOSE;
 
-	return svgtiny_add_path(p, 13, &state);
+	err = svgtiny_add_path(p, 13, &state);
+
+	svgtiny_cleanup_state_local(&state);
+
+	return err;
 }
 
 
@@ -619,30 +795,39 @@ svgtiny_code svgtiny_parse_rect(dom_element *rect,
 svgtiny_code svgtiny_parse_circle(dom_element *circle,
 		struct svgtiny_parse_state state)
 {
+	svgtiny_code err;
 	float x = 0, y = 0, r = -1;
 	float *p;
 	dom_string *attr;
 	dom_exception exc;
 
+	svgtiny_setup_state_local(&state);
+
 	exc = dom_element_get_attribute(circle, state.interned_cx, &attr);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	if (attr != NULL) {
 		x = svgtiny_parse_length(attr, state.viewport_width, state);
 	}
 	dom_string_unref(attr);
 
 	exc = dom_element_get_attribute(circle, state.interned_cy, &attr);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	if (attr != NULL) {
 		y = svgtiny_parse_length(attr, state.viewport_height, state);
 	}
 	dom_string_unref(attr);
 
 	exc = dom_element_get_attribute(circle, state.interned_r, &attr);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	if (attr != NULL) {
 		r = svgtiny_parse_length(attr, state.viewport_width, state);
 	}
@@ -654,14 +839,19 @@ svgtiny_code svgtiny_parse_circle(dom_element *circle,
 	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)
+	if (r == 0) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OK;
+	}
 
 	p = malloc(32 * sizeof p[0]);
-	if (!p)
+	if (!p) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OUT_OF_MEMORY;
+	}
 
 	p[0] = svgtiny_PATH_MOVE;
 	p[1] = x + r;
@@ -695,8 +885,12 @@ svgtiny_code svgtiny_parse_circle(dom_element *circle,
 	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 svgtiny_add_path(p, 32, &state);
+	return err;
 }
 
 
@@ -707,38 +901,49 @@ svgtiny_code svgtiny_parse_circle(dom_element *circle,
 svgtiny_code svgtiny_parse_ellipse(dom_element *ellipse,
 		struct svgtiny_parse_state state)
 {
+	svgtiny_code err;
 	float x = 0, y = 0, rx = -1, ry = -1;
 	float *p;
 	dom_string *attr;
 	dom_exception exc;
 
+	svgtiny_setup_state_local(&state);
+
 	exc = dom_element_get_attribute(ellipse, state.interned_cx, &attr);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	if (attr != NULL) {
 		x = svgtiny_parse_length(attr, state.viewport_width, state);
 	}
 	dom_string_unref(attr);
 
 	exc = dom_element_get_attribute(ellipse, state.interned_cy, &attr);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	if (attr != NULL) {
 		y = svgtiny_parse_length(attr, state.viewport_height, state);
 	}
 	dom_string_unref(attr);
 
 	exc = dom_element_get_attribute(ellipse, state.interned_rx, &attr);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	if (attr != NULL) {
 		rx = svgtiny_parse_length(attr, state.viewport_width, state);
 	}
 	dom_string_unref(attr);
 
 	exc = dom_element_get_attribute(ellipse, state.interned_ry, &attr);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	if (attr != NULL) {
 		ry = svgtiny_parse_length(attr, state.viewport_width, state);
 	}
@@ -751,14 +956,19 @@ svgtiny_code svgtiny_parse_ellipse(dom_element *ellipse,
 		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)
+	if (rx == 0 || ry == 0) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OK;
+	}
 
 	p = malloc(32 * sizeof p[0]);
-	if (!p)
+	if (!p) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OUT_OF_MEMORY;
+	}
 
 	p[0] = svgtiny_PATH_MOVE;
 	p[1] = x + rx;
@@ -793,7 +1003,11 @@ svgtiny_code svgtiny_parse_ellipse(dom_element *ellipse,
 	p[30] = y;
 	p[31] = svgtiny_PATH_CLOSE;
 	
-	return svgtiny_add_path(p, 32, &state);
+	err = svgtiny_add_path(p, 32, &state);
+
+	svgtiny_cleanup_state_local(&state);
+
+	return err;
 }
 
 
@@ -804,38 +1018,49 @@ svgtiny_code svgtiny_parse_ellipse(dom_element *ellipse,
 svgtiny_code svgtiny_parse_line(dom_element *line,
 		struct svgtiny_parse_state state)
 {
+	svgtiny_code err;
 	float x1 = 0, y1 = 0, x2 = 0, y2 = 0;
 	float *p;
 	dom_string *attr;
 	dom_exception exc;
 
+	svgtiny_setup_state_local(&state);
+
 	exc = dom_element_get_attribute(line, state.interned_x1, &attr);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	if (attr != NULL) {
 		x1 = svgtiny_parse_length(attr, state.viewport_width, state);
 	}
 	dom_string_unref(attr);
 
 	exc = dom_element_get_attribute(line, state.interned_y1, &attr);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	if (attr != NULL) {
 		y1 = svgtiny_parse_length(attr, state.viewport_height, state);
 	}
 	dom_string_unref(attr);
 
 	exc = dom_element_get_attribute(line, state.interned_x2, &attr);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	if (attr != NULL) {
 		x2 = svgtiny_parse_length(attr, state.viewport_width, state);
 	}
 	dom_string_unref(attr);
 
 	exc = dom_element_get_attribute(line, state.interned_y2, &attr);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	if (attr != NULL) {
 		y2 = svgtiny_parse_length(attr, state.viewport_height, state);
 	}
@@ -845,8 +1070,10 @@ svgtiny_code svgtiny_parse_line(dom_element *line,
 	svgtiny_parse_transform_attributes(line, &state);
 
 	p = malloc(7 * sizeof p[0]);
-	if (!p)
+	if (!p) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OUT_OF_MEMORY;
+	}
 
 	p[0] = svgtiny_PATH_MOVE;
 	p[1] = x1;
@@ -856,7 +1083,11 @@ svgtiny_code svgtiny_parse_line(dom_element *line,
 	p[5] = y2;
 	p[6] = svgtiny_PATH_CLOSE;
 
-	return svgtiny_add_path(p, 7, &state);
+	err = svgtiny_add_path(p, 7, &state);
+
+	svgtiny_cleanup_state_local(&state);
+
+	return err;
 }
 
 
@@ -870,37 +1101,46 @@ svgtiny_code svgtiny_parse_line(dom_element *line,
 svgtiny_code svgtiny_parse_poly(dom_element *poly,
 		struct svgtiny_parse_state state, bool polygon)
 {
+	svgtiny_code err;
 	dom_string *points_str;
 	dom_exception exc;
 	char *s, *points;
 	float *p;
 	unsigned int i;
 
+	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,
 					&points_str);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
+	}
 	
 	if (points_str == NULL) {
 		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;
 	}
 
 	s = points = strndup(dom_string_data(points_str),
-			     dom_string_length(points_str));
+			     dom_string_byte_length(points_str));
 	dom_string_unref(points_str);
 	/* read points attribute */
-	if (s == NULL)
+	if (s == NULL) {
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OUT_OF_MEMORY;
+	}
 	/* allocate space for path: it will never have more elements than s */
 	p = malloc(sizeof p[0] * strlen(s));
 	if (!p) {
 		free(points);
+		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OUT_OF_MEMORY;
 	}
 
@@ -930,7 +1170,11 @@ svgtiny_code svgtiny_parse_poly(dom_element *poly,
 
 	free(points);
 
-	return svgtiny_add_path(p, i, &state);
+	err = svgtiny_add_path(p, i, &state);
+
+	svgtiny_cleanup_state_local(&state);
+
+	return err;
 }
 
 
@@ -946,6 +1190,8 @@ svgtiny_code svgtiny_parse_text(dom_element *text,
 	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);
@@ -960,8 +1206,10 @@ svgtiny_code svgtiny_parse_text(dom_element *text,
 	style.font_size.value.length.value *= state.ctm.a;*/
 	
         exc = dom_node_get_first_child(text, &child);
-	if (exc != DOM_NO_ERR)
+	if (exc != DOM_NO_ERR) {
 		return svgtiny_LIBDOM_ERROR;
+		svgtiny_cleanup_state_local(&state);
+	}
 	while (child != NULL) {
 		dom_node *next;
 		dom_node_type nodetype;
@@ -970,6 +1218,7 @@ svgtiny_code svgtiny_parse_text(dom_element *text,
 		exc = dom_node_get_node_type(child, &nodetype);
 		if (exc != DOM_NO_ERR) {
 			dom_node_unref(child);
+			svgtiny_cleanup_state_local(&state);
 			return svgtiny_LIBDOM_ERROR;
 		}
 		if (nodetype == DOM_ELEMENT_NODE) {
@@ -977,6 +1226,7 @@ svgtiny_code svgtiny_parse_text(dom_element *text,
 			exc = dom_node_get_node_name(child, &nodename);
 			if (exc != DOM_NO_ERR) {
 				dom_node_unref(child);
+				svgtiny_cleanup_state_local(&state);
 				return svgtiny_LIBDOM_ERROR;
 			}
 			if (dom_string_caseless_isequal(nodename,
@@ -989,16 +1239,22 @@ svgtiny_code svgtiny_parse_text(dom_element *text,
 			dom_string *content;
 			if (shape == NULL) {
 				dom_node_unref(child);
+				svgtiny_cleanup_state_local(&state);
 				return svgtiny_OUT_OF_MEMORY;
 			}
 			exc = dom_text_get_whole_text(child, &content);
 			if (exc != DOM_NO_ERR) {
 				dom_node_unref(child);
+				svgtiny_cleanup_state_local(&state);
 				return svgtiny_LIBDOM_ERROR;
 			}
-			shape->text = strndup(dom_string_data(content),
-					      dom_string_length(content));
-			dom_string_unref(content);
+			if (content != NULL) {
+				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++;
@@ -1006,15 +1262,20 @@ svgtiny_code svgtiny_parse_text(dom_element *text,
 
 		if (code != svgtiny_OK) {
 			dom_node_unref(child);
+			svgtiny_cleanup_state_local(&state);
 			return code;
 		}
 		exc = dom_node_get_next_sibling(child, &next);
 		dom_node_unref(child);
-		if (exc != DOM_NO_ERR)
+		if (exc != DOM_NO_ERR) {
+			svgtiny_cleanup_state_local(&state);
 			return svgtiny_LIBDOM_ERROR;
+		}
 		child = next;
 	}
 
+	svgtiny_cleanup_state_local(&state);
+
 	return svgtiny_OK;
 }
 
@@ -1023,32 +1284,42 @@ svgtiny_code svgtiny_parse_text(dom_element *text,
  * Parse x, y, width, and height attributes, if present.
  */
 
-void svgtiny_parse_position_attributes(const dom_element *node,
+void svgtiny_parse_position_attributes(dom_element *node,
 		const struct svgtiny_parse_state state,
 		float *x, float *y, float *width, float *height)
 {
-	xmlAttr *attr;
+	dom_string *attr;
+	dom_exception exc;
 
 	*x = 0;
 	*y = 0;
 	*width = state.viewport_width;
 	*height = state.viewport_height;
 
-	for (attr = node->properties; attr; attr = attr->next) {
-		const char *name = (const char *) attr->name;
-		const char *content = (const char *) attr->children->content;
-		if (strcmp(name, "x") == 0)
-			*x = svgtiny_parse_length(content,
-					state.viewport_width, state);
-		else if (strcmp(name, "y") == 0)
-			*y = svgtiny_parse_length(content,
-					state.viewport_height, state);
-		else if (strcmp(name, "width") == 0)
-			*width = svgtiny_parse_length(content,
-					state.viewport_width, state);
-		else if (strcmp(name, "height") == 0)
-			*height = svgtiny_parse_length(content,
-					state.viewport_height, state);
+	exc = dom_element_get_attribute(node, state.interned_x, &attr);
+	if (exc == DOM_NO_ERR && attr != NULL) {
+		*x = svgtiny_parse_length(attr, state.viewport_width, state);
+		dom_string_unref(attr);
+	}
+
+	exc = dom_element_get_attribute(node, state.interned_y, &attr);
+	if (exc == DOM_NO_ERR && attr != NULL) {
+		*y = svgtiny_parse_length(attr, state.viewport_height, state);
+		dom_string_unref(attr);
+	}
+
+	exc = dom_element_get_attribute(node, state.interned_width, &attr);
+	if (exc == DOM_NO_ERR && attr != NULL) {
+		*width = svgtiny_parse_length(attr, state.viewport_width,
+					      state);
+		dom_string_unref(attr);
+	}
+
+	exc = dom_element_get_attribute(node, state.interned_height, &attr);
+	if (exc == DOM_NO_ERR && attr != NULL) {
+		*height = svgtiny_parse_length(attr, state.viewport_height,
+					       state);
+		dom_string_unref(attr);
 	}
 }
 
@@ -1095,7 +1366,7 @@ static float _svgtiny_parse_length(const char *s, int viewport_size,
 float svgtiny_parse_length(dom_string *s, int viewport_size,
 			   const struct svgtiny_parse_state state)
 {
-	const char *ss = strndup(dom_string_data(s), dom_string_length(s));
+	char *ss = strndup(dom_string_data(s), dom_string_byte_length(s));
 	float ret = _svgtiny_parse_length(ss, viewport_size, state);
 	free(ss);
 	return ret;
@@ -1105,52 +1376,64 @@ float svgtiny_parse_length(dom_string *s, int viewport_size,
  * Parse paint attributes, if present.
  */
 
-void svgtiny_parse_paint_attributes(const dom_element *node,
+void svgtiny_parse_paint_attributes(dom_element *node,
 		struct svgtiny_parse_state *state)
 {
-	const xmlAttr *attr;
+	dom_string *attr;
+	dom_exception exc;
+	
+	exc = dom_element_get_attribute(node, state->interned_fill, &attr);
+	if (exc == DOM_NO_ERR && attr != NULL) {
+		svgtiny_parse_color(attr, &state->fill, &state->fill_grad, state);
+		dom_string_unref(attr);
+	}
 
-	for (attr = node->properties; attr; attr = attr->next) {
-		const char *name = (const char *) attr->name;
-		const char *content = (const char *) attr->children->content;
-		if (strcmp(name, "fill") == 0)
-			svgtiny_parse_color(content, &state->fill, state);
-		else if (strcmp(name, "stroke") == 0)
-			svgtiny_parse_color(content, &state->stroke, state);
-		else if (strcmp(name, "stroke-width") == 0)
-			state->stroke_width = svgtiny_parse_length(content,
-					state->viewport_width, *state);
-		else if (strcmp(name, "style") == 0) {
-			const char *style = (const char *)
-					attr->children->content;
-			const char *s;
-			char *value;
-			if ((s = strstr(style, "fill:"))) {
-				s += 5;
-				while (*s == ' ')
-					s++;
-				value = strndup(s, strcspn(s, "; "));
-				svgtiny_parse_color(value, &state->fill, state);
-				free(value);
-			}
-			if ((s = strstr(style, "stroke:"))) {
-				s += 7;
-				while (*s == ' ')
-					s++;
-				value = strndup(s, strcspn(s, "; "));
-				svgtiny_parse_color(value, &state->stroke, state);
-				free(value);
-			}
-			if ((s = strstr(style, "stroke-width:"))) {
-				s += 13;
-				while (*s == ' ')
-					s++;
-				value = strndup(s, strcspn(s, "; "));
-				state->stroke_width = svgtiny_parse_length(value,
+	exc = dom_element_get_attribute(node, state->interned_stroke, &attr);
+	if (exc == DOM_NO_ERR && attr != NULL) {
+		svgtiny_parse_color(attr, &state->stroke, &state->stroke_grad, state);
+		dom_string_unref(attr);
+	}
+
+	exc = dom_element_get_attribute(node, state->interned_stroke_width, &attr);
+	if (exc == DOM_NO_ERR && attr != NULL) {
+		state->stroke_width = svgtiny_parse_length(attr,
 						state->viewport_width, *state);
-				free(value);
-			}
+		dom_string_unref(attr);
+	}
+
+	exc = dom_element_get_attribute(node, state->interned_style, &attr);
+	if (exc == DOM_NO_ERR && attr != NULL) {
+		char *style = strndup(dom_string_data(attr),
+				      dom_string_byte_length(attr));
+		const char *s;
+		char *value;
+		if ((s = strstr(style, "fill:"))) {
+			s += 5;
+			while (*s == ' ')
+				s++;
+			value = strndup(s, strcspn(s, "; "));
+			_svgtiny_parse_color(value, &state->fill, &state->fill_grad, state);
+			free(value);
+		}
+		if ((s = strstr(style, "stroke:"))) {
+			s += 7;
+			while (*s == ' ')
+				s++;
+			value = strndup(s, strcspn(s, "; "));
+			_svgtiny_parse_color(value, &state->stroke, &state->stroke_grad, state);
+			free(value);
+		}
+		if ((s = strstr(style, "stroke-width:"))) {
+			s += 13;
+			while (*s == ' ')
+				s++;
+			value = strndup(s, strcspn(s, "; "));
+			state->stroke_width = _svgtiny_parse_length(value,
+						state->viewport_width, *state);
+			free(value);
 		}
+		free(style);
+		dom_string_unref(attr);
 	}
 }
 
@@ -1159,7 +1442,8 @@ void svgtiny_parse_paint_attributes(const dom_element *node,
  * Parse a colour.
  */
 
-void svgtiny_parse_color(const char *s, svgtiny_colour *c,
+static void _svgtiny_parse_color(const char *s, svgtiny_colour *c,
+		struct svgtiny_parse_state_gradient *grad,
 		struct svgtiny_parse_state *state)
 {
 	unsigned int r, g, b;
@@ -1191,21 +1475,21 @@ void svgtiny_parse_color(const char *s, svgtiny_colour *c,
 
 	} else if (5 < len && s[0] == 'u' && s[1] == 'r' && s[2] == 'l' &&
 			s[3] == '(') {
-		if (s[4] == '#') {
+		if (grad == NULL) {
+			*c = svgtiny_RGB(0, 0, 0);
+		} else if (s[4] == '#') {
 			id = strdup(s + 5);
 			if (!id)
 				return;
 			rparen = strchr(id, ')');
 			if (rparen)
 				*rparen = 0;
-			svgtiny_find_gradient(id, state);
+			svgtiny_find_gradient(id, grad, state);
 			free(id);
-			fprintf(stderr, "linear_gradient_stop_count %i\n",
-					state->linear_gradient_stop_count);
-			if (state->linear_gradient_stop_count == 0)
+			if (grad->linear_gradient_stop_count == 0)
 				*c = svgtiny_TRANSPARENT;
-			else if (state->linear_gradient_stop_count == 1)
-				*c = state->gradient_stop[0].color;
+			else if (grad->linear_gradient_stop_count == 1)
+				*c = grad->gradient_stop[0].color;
 			else
 				*c = svgtiny_LINEAR_GRADIENT;
 		}
@@ -1218,14 +1502,26 @@ void svgtiny_parse_color(const char *s, svgtiny_colour *c,
 	}
 }
 
+void svgtiny_parse_color(dom_string *s, svgtiny_colour *c,
+		struct svgtiny_parse_state_gradient *grad,
+		struct svgtiny_parse_state *state)
+{
+	dom_string_ref(s);
+	_svgtiny_parse_color(dom_string_data(s), c, grad, state);
+	dom_string_unref(s);
+}
 
 /**
  * Parse font attributes, if present.
  */
 
-void svgtiny_parse_font_attributes(const dom_element *node,
+void svgtiny_parse_font_attributes(dom_element *node,
 		struct svgtiny_parse_state *state)
 {
+	/* TODO: Implement this, it never used to be */
+	UNUSED(node);
+	UNUSED(state);
+#ifdef WRITTEN_THIS_PROPERLY
 	const xmlAttr *attr;
 
 	UNUSED(state);
@@ -1241,6 +1537,7 @@ void svgtiny_parse_font_attributes(const dom_element *node,
 			}*/
 		}
         }
+#endif
 }
 
 
@@ -1254,14 +1551,19 @@ void svgtiny_parse_transform_attributes(dom_element *node,
 		struct svgtiny_parse_state *state)
 {
 	char *transform;
-
-	/* parse transform */
-	transform = (char *) xmlGetProp(node, (const xmlChar *) "transform");
-	if (transform) {
+	dom_string *attr;
+	dom_exception exc;
+	
+	exc = dom_element_get_attribute(node, state->interned_transform,
+					&attr);
+	if (exc == DOM_NO_ERR && attr != NULL) {
+		transform = strndup(dom_string_data(attr),
+				    dom_string_byte_length(attr));
 		svgtiny_parse_transform(transform, &state->ctm.a, &state->ctm.b,
 				&state->ctm.c, &state->ctm.d,
 				&state->ctm.e, &state->ctm.f);
-		xmlFree(transform);
+		free(transform);
+		dom_string_unref(attr);
 	}
 }
 
@@ -1287,23 +1589,23 @@ void svgtiny_parse_transform(char *s, float *ma, float *mb,
 		a = d = 1;
 		b = c = 0;
 		e = f = 0;
-		if (sscanf(s, "matrix (%f %f %f %f %f %f) %n",
-					&a, &b, &c, &d, &e, &f, &n) == 6)
+		if ((sscanf(s, " matrix (%f %f %f %f %f %f ) %n",
+                            &a, &b, &c, &d, &e, &f, &n) == 6) && (n > 0))
 			;
-		else if (sscanf(s, "translate (%f %f) %n",
-					&e, &f, &n) == 2)
+		else if ((sscanf(s, " translate (%f %f ) %n",
+                                 &e, &f, &n) == 2) && (n > 0))
 			;
-		else if (sscanf(s, "translate (%f) %n",
-					&e, &n) == 1)
+		else if ((sscanf(s, " translate (%f ) %n",
+                                 &e, &n) == 1) && (n > 0))
 			;
-		else if (sscanf(s, "scale (%f %f) %n",
-					&a, &d, &n) == 2)
+		else if ((sscanf(s, " scale (%f %f ) %n",
+                                 &a, &d, &n) == 2) && (n > 0))
 			;
-		else if (sscanf(s, "scale (%f) %n",
-					&a, &n) == 1)
+		else if ((sscanf(s, " scale (%f ) %n",
+                                 &a, &n) == 1) && (n > 0))
 			d = a;
-		else if (sscanf(s, "rotate (%f %f %f) %n",
-					&angle, &x, &y, &n) == 3) {
+		else if ((sscanf(s, " rotate (%f %f %f ) %n",
+                                 &angle, &x, &y, &n) == 3) && (n > 0)) {
 			angle = angle / 180 * M_PI;
 			a = cos(angle);
 			b = sin(angle);
@@ -1311,19 +1613,19 @@ void svgtiny_parse_transform(char *s, float *ma, float *mb,
 			d = cos(angle);
 			e = -x * cos(angle) + y * sin(angle) + x;
 			f = -x * sin(angle) - y * cos(angle) + y;
-		} else if (sscanf(s, "rotate (%f) %n",
-					&angle, &n) == 1) {
+		} else if ((sscanf(s, " rotate (%f ) %n",
+                                   &angle, &n) == 1) && (n > 0)) {
 			angle = angle / 180 * M_PI;
 			a = cos(angle);
 			b = sin(angle);
 			c = -sin(angle);
 			d = cos(angle);
-		} else if (sscanf(s, "skewX (%f) %n",
-					&angle, &n) == 1) {
+		} else if ((sscanf(s, " skewX (%f ) %n",
+                                   &angle, &n) == 1) && (n > 0)) {
 			angle = angle / 180 * M_PI;
 			c = tan(angle);
-		} else if (sscanf(s, "skewY (%f) %n",
-					&angle, &n) == 1) {
+		} else if ((sscanf(s, " skewY (%f ) %n",
+                                   &angle, &n) == 1) && (n > 0)) {
 			angle = angle / 180 * M_PI;
 			b = tan(angle);
 		} else