css_string is now the same as a parserutils_dict_entry. This allows us to use dict entries directly as strings.

iChange the way in which selectors are represented. This significantly reduces memory requirements -- reducing the approximate usage count (excludes the string dictionary, which is about 360k) of allzengarden.css from 4,535,400 bytes to 2,414,312 bytes on a 64bit platform.

The string dictionary is now created and owned by the stylesheet object. The parser is just given access to this so that it can store strings in it.

svn path=/trunk/libcss/; revision=5809

4 files changed, 385 insertions, 387 deletions

diff --git a/src/parse/css21.c b/src/parse/css21.c
index 8f4fe0d..4303313 100644
--- a/src/parse/css21.c
+++ b/src/parse/css21.c
@@ -74,7 +74,7 @@ enum {
 
 /* Must be synchronised with above enum */
 static struct {
-	const char *ptr;
+	const char *data;
 	size_t len;
 } stringmap[LAST_KNOWN] = {
 	{ "charset", SLEN("charset") },
@@ -363,19 +363,19 @@ static inline css_error handleDeclaration(css_css21 *c,
 /* Selector list parsing */
 static inline css_error parseClass(css_css21 *c,
 		const parserutils_vector *vector, int *ctx,
-		css_selector **specific);
+		css_selector_detail **specific);
 static inline css_error parseAttrib(css_css21 *c, 
 		const parserutils_vector *vector, int *ctx,
-		css_selector **specific);
+		css_selector_detail **specific);
 static inline css_error parsePseudo(css_css21 *c,
 		const parserutils_vector *vector, int *ctx,
-		css_selector **specific);
+		css_selector_detail **specific);
 static inline css_error parseSpecific(css_css21 *c,
 		const parserutils_vector *vector, int *ctx,
-		css_selector *parent);
+		css_selector **parent);
 static inline css_error parseSelectorSpecifics(css_css21 *c,
 		const parserutils_vector *vector, int *ctx,
-		css_selector *parent);
+		css_selector **parent);
 static inline css_error parseSimpleSelector(css_css21 *c, 
 		const parserutils_vector *vector, int *ctx, 
 		css_selector **result);
@@ -436,7 +436,7 @@ css_error css_css21_create(css_stylesheet *sheet, css_parser *parser,
 	/* Intern all known strings */
 	for (int i = 0; i < LAST_KNOWN; i++) {
 		c->strings[i] = css_parser_dict_add(parser,
-				(const uint8_t *) stringmap[i].ptr, 
+				(const uint8_t *) stringmap[i].data, 
 				stringmap[i].len);
 		if (c->strings[i] == NULL) {
 			parserutils_stack_destroy(c->context);
@@ -645,7 +645,7 @@ css_error handleStartAtRule(css_css21 *c, const parserutils_vector *vector)
 	 * there is one */
 	assert(atkeyword != NULL && atkeyword->type == CSS_TOKEN_ATKEYWORD);
 
-	if (atkeyword->lower.ptr == c->strings[CHARSET]) {
+	if (atkeyword->lower.data == c->strings[CHARSET]) {
 		if (c->state == BEFORE_CHARSET) {
 			/* any0 = STRING */
 			if (ctx == 0)
@@ -663,7 +663,7 @@ css_error handleStartAtRule(css_css21 *c, const parserutils_vector *vector)
 		} else {
 			return CSS_INVALID;
 		}
-	} else if (atkeyword->lower.ptr == c->strings[IMPORT]) {
+	} else if (atkeyword->lower.data == c->strings[IMPORT]) {
 		if (c->state != HAD_RULE) {
 			/* any0 = (STRING | URI) ws 
 			 *        (IDENT ws (',' ws IDENT ws)* )? */
@@ -689,16 +689,16 @@ css_error handleStartAtRule(css_css21 *c, const parserutils_vector *vector)
 	/** \todo these depend on nested block support, so we'll disable them
 	 * until we have such a thing. This means that we'll ignore the entire
 	 * at-rule until then */
-	} else if (atkeyword->lower.ptr == c->strings[MEDIA]) {
+	} else if (atkeyword->lower.data == c->strings[MEDIA]) {
 		/** \todo any0 = IDENT ws (',' ws IDENT ws)* */
-	} else if (atkeyword->lower.ptr == c->strings[PAGE]) {
+	} else if (atkeyword->lower.data == c->strings[PAGE]) {
 		/** \todo any0 = (':' IDENT)? ws */
 #endif
 	} else {
 		return CSS_INVALID;
 	}
 
-	entry.data = atkeyword->lower.ptr;
+	entry.data = atkeyword->lower.data;
 
 	perror = parserutils_stack_push(c->context, (void *) &entry);
 	if (perror != PARSERUTILS_OK) {
@@ -816,7 +816,7 @@ css_error handleDeclaration(css_css21 *c, const parserutils_vector *vector)
  ******************************************************************************/
 
 css_error parseClass(css_css21 *c, const parserutils_vector *vector, int *ctx,
-		css_selector **specific)
+		css_selector_detail **specific)
 {
 	const css_token *token;
 
@@ -829,12 +829,12 @@ css_error parseClass(css_css21 *c, const parserutils_vector *vector, int *ctx,
 	if (token == NULL || token->type != CSS_TOKEN_IDENT)
 		return CSS_INVALID;
 
-	return css_stylesheet_selector_create(c->sheet, 
+	return css_stylesheet_selector_detail_create(c->sheet, 
 			CSS_SELECTOR_CLASS, &token->data, NULL, specific);
 }
 
 css_error parseAttrib(css_css21 *c, const parserutils_vector *vector, int *ctx,
-		css_selector **specific)
+		css_selector_detail **specific)
 {
 	const css_token *token, *name, *value = NULL;
 	css_selector_type type = CSS_SELECTOR_ATTRIBUTE;
@@ -887,13 +887,13 @@ css_error parseAttrib(css_css21 *c, const parserutils_vector *vector, int *ctx,
 			return CSS_INVALID;
 	}
 
-	return css_stylesheet_selector_create(c->sheet, type, 
+	return css_stylesheet_selector_detail_create(c->sheet, type, 
 			&name->data, value != NULL ? &value->data : NULL,
 			specific);
 }
 
 css_error parsePseudo(css_css21 *c, const parserutils_vector *vector, int *ctx,
-		css_selector **specific)
+		css_selector_detail **specific)
 {
 	const css_token *token, *name, *value = NULL;
 
@@ -927,18 +927,18 @@ css_error parsePseudo(css_css21 *c, const parserutils_vector *vector, int *ctx,
 			return CSS_INVALID;
 	}
 
-	return css_stylesheet_selector_create(c->sheet, 
+	return css_stylesheet_selector_detail_create(c->sheet, 
 			CSS_SELECTOR_PSEUDO, &name->data, 
 			value != NULL ? &value->data : NULL, specific);
 }
 
 css_error parseSpecific(css_css21 *c, 
 		const parserutils_vector *vector, int *ctx,
-		css_selector *parent)
+		css_selector **parent)
 {
 	css_error error;
 	const css_token *token;
-	css_selector *specific = NULL;
+	css_selector_detail *specific = NULL;
 
 	/* specific  -> [ HASH | class | attrib | pseudo ] */
 
@@ -947,7 +947,7 @@ css_error parseSpecific(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_HASH) {
-		error = css_stylesheet_selector_create(c->sheet,
+		error = css_stylesheet_selector_detail_create(c->sheet,
 				CSS_SELECTOR_ID, &token->data, NULL, &specific);
 		if (error != CSS_OK)
 			return error;
@@ -972,7 +972,7 @@ css_error parseSpecific(css_css21 *c,
 	error = css_stylesheet_selector_append_specific(c->sheet, parent, 
 			specific);
 	if (error != CSS_OK) {
-		css_stylesheet_selector_destroy(c->sheet, specific);
+		css_stylesheet_selector_detail_destroy(c->sheet, specific);
 		return error;
 	}
 
@@ -981,7 +981,7 @@ css_error parseSpecific(css_css21 *c,
 
 css_error parseSelectorSpecifics(css_css21 *c,
 		const parserutils_vector *vector, int *ctx,
-		css_selector *parent)
+		css_selector **parent)
 {
 	css_error error;
 	const css_token *token;
@@ -1028,7 +1028,7 @@ css_error parseSimpleSelector(css_css21 *c,
 		parserutils_vector_iterate(vector, ctx);
 	} else {
 		/* Universal selector */
-		css_string name = { (uint8_t *) "*", 1 };
+		static css_string name = { 1, (uint8_t *) "*" };
 
 		error = css_stylesheet_selector_create(c->sheet,
 				CSS_SELECTOR_ELEMENT, &name, NULL, &selector);
@@ -1036,16 +1036,22 @@ css_error parseSimpleSelector(css_css21 *c,
 			return error;
 
 		/* Ensure we have at least one specific selector */
-		error = parseSpecific(c, vector, ctx, selector);
+		error = parseSpecific(c, vector, ctx, &selector);
 		if (error != CSS_OK) {
 			css_stylesheet_selector_destroy(c->sheet, selector);
 			return error;
 		}
 	}
 
+	error = parseSelectorSpecifics(c, vector, ctx, &selector);
+	if (error != CSS_OK) {
+		css_stylesheet_selector_destroy(c->sheet, selector);
+		return error;
+	}
+
 	*result = selector;
 
-	return parseSelectorSpecifics(c, vector, ctx, selector);
+	return CSS_OK;
 }
 
 css_error parseCombinator(css_css21 *c, const parserutils_vector *vector,
@@ -1219,7 +1225,7 @@ css_error parseProperty(css_css21 *c, const css_token *property,
 	/* Find property index */
 	/** \todo improve on this linear search */
 	for (i = FIRST_PROP; i <= LAST_PROP; i++) {
-		if (property->lower.ptr == c->strings[i])
+		if (property->lower.data == c->strings[i])
 			break;
 	}
 	if (i == LAST_PROP + 1)
@@ -1279,7 +1285,7 @@ void consumeWhitespace(const parserutils_vector *vector, int *ctx)
 bool tokenIsChar(const css_token *token, uint8_t c)
 {
 	return token != NULL && token->type == CSS_TOKEN_CHAR && 
-			token->lower.len == 1 && token->lower.ptr[0] == c;
+			token->lower.len == 1 && token->lower.data[0] == c;
 }
 
 
diff --git a/src/parse/css21props.c b/src/parse/css21props.c
index fe0c405..43b0710 100644
--- a/src/parse/css21props.c
+++ b/src/parse/css21props.c
@@ -480,11 +480,11 @@ css_error parse_background_attachment(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[FIXED]) {
+	} else if (ident->lower.data == c->strings[FIXED]) {
 		value = BACKGROUND_ATTACHMENT_FIXED;
-	} else if (ident->lower.ptr == c->strings[SCROLL]) {
+	} else if (ident->lower.data == c->strings[SCROLL]) {
 		value = BACKGROUND_ATTACHMENT_SCROLL;
 	} else
 		return CSS_INVALID;
@@ -520,11 +520,11 @@ css_error parse_background_color(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[TRANSPARENT]) {
+			token->lower.data == c->strings[TRANSPARENT]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = BACKGROUND_COLOR_TRANSPARENT;
 	} else {
@@ -582,10 +582,10 @@ css_error parse_background_image(css_css21 *c,
 		return error;
 
 	if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[NONE]) {
+			token->lower.data == c->strings[NONE]) {
 		value = BACKGROUND_IMAGE_NONE;
 	} else if (token->type == CSS_TOKEN_URI) {
 		value = BACKGROUND_IMAGE_URI;
@@ -607,7 +607,7 @@ css_error parse_background_image(css_css21 *c,
 	memcpy((*result)->bytecode, &opv, sizeof(opv));
 	if ((flags & FLAG_INHERIT) == false && value == BACKGROUND_IMAGE_URI) {
 		memcpy((uint8_t *) (*result)->bytecode + sizeof(opv),
-				&token->data.ptr, sizeof(uint8_t *));
+				&token->data.data, sizeof(uint8_t *));
 		memcpy((uint8_t *) (*result)->bytecode + sizeof(opv) + 
 					sizeof(uint8_t *),
 				&token->data.len, sizeof(size_t));
@@ -648,15 +648,15 @@ css_error parse_background_repeat(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[NO_REPEAT]) {
+	} else if (ident->lower.data == c->strings[NO_REPEAT]) {
 		value = BACKGROUND_REPEAT_NO_REPEAT;
-	} else if (ident->lower.ptr == c->strings[REPEAT_X]) {
+	} else if (ident->lower.data == c->strings[REPEAT_X]) {
 		value = BACKGROUND_REPEAT_REPEAT_X;
-	} else if (ident->lower.ptr == c->strings[REPEAT_Y]) {
+	} else if (ident->lower.data == c->strings[REPEAT_Y]) {
 		value = BACKGROUND_REPEAT_REPEAT_Y;
-	} else if (ident->lower.ptr == c->strings[REPEAT]) {
+	} else if (ident->lower.data == c->strings[REPEAT]) {
 		value = BACKGROUND_REPEAT_REPEAT;
 	} else
 		return CSS_INVALID;
@@ -714,11 +714,11 @@ css_error parse_border_collapse(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[COLLAPSE]) {
+	} else if (ident->lower.data == c->strings[COLLAPSE]) {
 		value = BORDER_COLLAPSE_COLLAPSE;
-	} else if (ident->lower.ptr == c->strings[SEPARATE]) {
+	} else if (ident->lower.data == c->strings[SEPARATE]) {
 		value = BORDER_COLLAPSE_SEPARATE;
 	} else
 		return CSS_INVALID;
@@ -831,11 +831,11 @@ css_error parse_bottom(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[AUTO]) {
+			token->lower.data == c->strings[AUTO]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = BOTTOM_AUTO;
 	} else {
@@ -895,11 +895,11 @@ css_error parse_caption_side(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[TOP]) {
+	} else if (ident->lower.data == c->strings[TOP]) {
 		value = CAPTION_SIDE_TOP;
-	} else if (ident->lower.ptr == c->strings[BOTTOM]) {
+	} else if (ident->lower.data == c->strings[BOTTOM]) {
 		value = CAPTION_SIDE_BOTTOM;
 	} else
 		return CSS_INVALID;
@@ -936,15 +936,15 @@ css_error parse_clear(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[RIGHT]) {
+	} else if (ident->lower.data == c->strings[RIGHT]) {
 		value = CLEAR_RIGHT;
-	} else if (ident->lower.ptr == c->strings[LEFT]) {
+	} else if (ident->lower.data == c->strings[LEFT]) {
 		value = CLEAR_LEFT;
-	} else if (ident->lower.ptr == c->strings[BOTH]) {
+	} else if (ident->lower.data == c->strings[BOTH]) {
 		value = CLEAR_BOTH;
-	} else if (ident->lower.ptr == c->strings[NONE]) {
+	} else if (ident->lower.data == c->strings[NONE]) {
 		value = CLEAR_NONE;
 	} else
 		return CSS_INVALID;
@@ -993,7 +993,7 @@ css_error parse_color(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags |= FLAG_INHERIT;
 	} else {
@@ -1090,10 +1090,10 @@ css_error parse_cue_after(css_css21 *c,
 		return error;
 
 	if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[NONE]) {
+			token->lower.data == c->strings[NONE]) {
 		value = CUE_AFTER_NONE;
 	} else if (token->type == CSS_TOKEN_URI) {
 		value = CUE_AFTER_URI;
@@ -1115,7 +1115,7 @@ css_error parse_cue_after(css_css21 *c,
 	memcpy((*result)->bytecode, &opv, sizeof(opv));
 	if ((flags & FLAG_INHERIT) == false && value == CUE_AFTER_URI) {
 		memcpy((uint8_t *) (*result)->bytecode + sizeof(opv),
-				&token->data.ptr, sizeof(uint8_t *));
+				&token->data.data, sizeof(uint8_t *));
 		memcpy((uint8_t *) (*result)->bytecode + sizeof(opv) + 
 					sizeof(uint8_t *),
 				&token->data.len, sizeof(size_t));
@@ -1146,10 +1146,10 @@ css_error parse_cue_before(css_css21 *c,
 		return error;
 
 	if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[NONE]) {
+			token->lower.data == c->strings[NONE]) {
 		value = CUE_BEFORE_NONE;
 	} else if (token->type == CSS_TOKEN_URI) {
 		value = CUE_BEFORE_URI;
@@ -1171,7 +1171,7 @@ css_error parse_cue_before(css_css21 *c,
 	memcpy((*result)->bytecode, &opv, sizeof(opv));
 	if ((flags & FLAG_INHERIT) == false && value == CUE_BEFORE_URI) {
 		memcpy((uint8_t *) (*result)->bytecode + sizeof(opv),
-				&token->data.ptr, sizeof(uint8_t *));
+				&token->data.data, sizeof(uint8_t *));
 		memcpy((uint8_t *) (*result)->bytecode + sizeof(opv) + 
 					sizeof(uint8_t *),
 				&token->data.len, sizeof(size_t));
@@ -1212,11 +1212,11 @@ css_error parse_direction(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[LTR]) {
+	} else if (ident->lower.data == c->strings[LTR]) {
 		value = DIRECTION_LTR;
-	} else if (ident->lower.ptr == c->strings[RTL]) {
+	} else if (ident->lower.data == c->strings[RTL]) {
 		value = DIRECTION_RTL;
 	} else
 		return CSS_INVALID;
@@ -1256,39 +1256,39 @@ css_error parse_display(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[INLINE]) {
+	} else if (ident->lower.data == c->strings[INLINE]) {
 		value = DISPLAY_INLINE;
-	} else if (ident->lower.ptr == c->strings[BLOCK]) {
+	} else if (ident->lower.data == c->strings[BLOCK]) {
 		value = DISPLAY_BLOCK;
-	} else if (ident->lower.ptr == c->strings[LIST_ITEM]) {
+	} else if (ident->lower.data == c->strings[LIST_ITEM]) {
 		value = DISPLAY_LIST_ITEM;
-	} else if (ident->lower.ptr == c->strings[RUN_IN]) {
+	} else if (ident->lower.data == c->strings[RUN_IN]) {
 		value = DISPLAY_RUN_IN;
-	} else if (ident->lower.ptr == c->strings[INLINE_BLOCK]) {
+	} else if (ident->lower.data == c->strings[INLINE_BLOCK]) {
 		value = DISPLAY_INLINE_BLOCK;
-	} else if (ident->lower.ptr == c->strings[TABLE]) {
+	} else if (ident->lower.data == c->strings[TABLE]) {
 		value = DISPLAY_TABLE;
-	} else if (ident->lower.ptr == c->strings[INLINE_TABLE]) {
+	} else if (ident->lower.data == c->strings[INLINE_TABLE]) {
 		value = DISPLAY_INLINE_TABLE;
-	} else if (ident->lower.ptr == c->strings[TABLE_ROW_GROUP]) {
+	} else if (ident->lower.data == c->strings[TABLE_ROW_GROUP]) {
 		value = DISPLAY_TABLE_ROW_GROUP;
-	} else if (ident->lower.ptr == c->strings[TABLE_HEADER_GROUP]) {
+	} else if (ident->lower.data == c->strings[TABLE_HEADER_GROUP]) {
 		value = DISPLAY_TABLE_HEADER_GROUP;
-	} else if (ident->lower.ptr == c->strings[TABLE_FOOTER_GROUP]) {
+	} else if (ident->lower.data == c->strings[TABLE_FOOTER_GROUP]) {
 		value = DISPLAY_TABLE_FOOTER_GROUP;
-	} else if (ident->lower.ptr == c->strings[TABLE_ROW]) {
+	} else if (ident->lower.data == c->strings[TABLE_ROW]) {
 		value = DISPLAY_TABLE_ROW;
-	} else if (ident->lower.ptr == c->strings[TABLE_COLUMN_GROUP]) {
+	} else if (ident->lower.data == c->strings[TABLE_COLUMN_GROUP]) {
 		value = DISPLAY_TABLE_COLUMN_GROUP;
-	} else if (ident->lower.ptr == c->strings[TABLE_COLUMN]) {
+	} else if (ident->lower.data == c->strings[TABLE_COLUMN]) {
 		value = DISPLAY_TABLE_COLUMN;
-	} else if (ident->lower.ptr == c->strings[TABLE_CELL]) {
+	} else if (ident->lower.data == c->strings[TABLE_CELL]) {
 		value = DISPLAY_TABLE_CELL;
-	} else if (ident->lower.ptr == c->strings[TABLE_CAPTION]) {
+	} else if (ident->lower.data == c->strings[TABLE_CAPTION]) {
 		value = DISPLAY_TABLE_CAPTION;
-	} else if (ident->lower.ptr == c->strings[NONE]) {
+	} else if (ident->lower.data == c->strings[NONE]) {
 		value = DISPLAY_NONE;
 	} else
 		return CSS_INVALID;
@@ -1325,27 +1325,27 @@ css_error parse_elevation(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[BELOW]) {
+			token->lower.data == c->strings[BELOW]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = ELEVATION_BELOW;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[LEVEL]) {
+			token->lower.data == c->strings[LEVEL]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = ELEVATION_LEVEL;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[ABOVE]) {
+			token->lower.data == c->strings[ABOVE]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = ELEVATION_ABOVE;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[HIGHER]) {
+			token->lower.data == c->strings[HIGHER]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = ELEVATION_HIGHER;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[LOWER]) {
+			token->lower.data == c->strings[LOWER]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = ELEVATION_LOWER;
 	} else {
@@ -1405,11 +1405,11 @@ css_error parse_empty_cells(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[SHOW]) {
+	} else if (ident->lower.data == c->strings[SHOW]) {
 		value = EMPTY_CELLS_SHOW;
-	} else if (ident->lower.ptr == c->strings[HIDE]) {
+	} else if (ident->lower.data == c->strings[HIDE]) {
 		value = EMPTY_CELLS_HIDE;
 	} else
 		return CSS_INVALID;
@@ -1446,13 +1446,13 @@ css_error parse_float(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[LEFT]) {
+	} else if (ident->lower.data == c->strings[LEFT]) {
 		value = FLOAT_LEFT;
-	} else if (ident->lower.ptr == c->strings[RIGHT]) {
+	} else if (ident->lower.data == c->strings[RIGHT]) {
 		value = FLOAT_RIGHT;
-	} else if (ident->lower.ptr == c->strings[NONE]) {
+	} else if (ident->lower.data == c->strings[NONE]) {
 		value = FLOAT_NONE;
 	} else
 		return CSS_INVALID;
@@ -1504,43 +1504,43 @@ css_error parse_font_size(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[XX_SMALL]) {
+			token->lower.data == c->strings[XX_SMALL]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = FONT_SIZE_XX_SMALL;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[X_SMALL]) {
+			token->lower.data == c->strings[X_SMALL]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = FONT_SIZE_X_SMALL;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[SMALL]) {
+			token->lower.data == c->strings[SMALL]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = FONT_SIZE_SMALL;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[MEDIUM]) {
+			token->lower.data == c->strings[MEDIUM]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = FONT_SIZE_MEDIUM;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[LARGE]) {
+			token->lower.data == c->strings[LARGE]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = FONT_SIZE_LARGE;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[X_LARGE]) {
+			token->lower.data == c->strings[X_LARGE]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = FONT_SIZE_X_LARGE;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[XX_LARGE]) {
+			token->lower.data == c->strings[XX_LARGE]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = FONT_SIZE_XX_LARGE;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[LARGER]) {
+			token->lower.data == c->strings[LARGER]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = FONT_SIZE_LARGER;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[SMALLER]) {
+			token->lower.data == c->strings[SMALLER]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = FONT_SIZE_SMALLER;
 	} else {
@@ -1600,13 +1600,13 @@ css_error parse_font_style(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[NORMAL]) {
+	} else if (ident->lower.data == c->strings[NORMAL]) {
 		value = FONT_STYLE_NORMAL;
-	} else if (ident->lower.ptr == c->strings[ITALIC]) {
+	} else if (ident->lower.data == c->strings[ITALIC]) {
 		value = FONT_STYLE_ITALIC;
-	} else if (ident->lower.ptr == c->strings[OBLIQUE]) {
+	} else if (ident->lower.data == c->strings[OBLIQUE]) {
 		value = FONT_STYLE_OBLIQUE;
 	} else
 		return CSS_INVALID;
@@ -1643,11 +1643,11 @@ css_error parse_font_variant(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[NORMAL]) {
+	} else if (ident->lower.data == c->strings[NORMAL]) {
 		value = FONT_VARIANT_NORMAL;
-	} else if (ident->lower.ptr == c->strings[SMALL_CAPS]) {
+	} else if (ident->lower.data == c->strings[SMALL_CAPS]) {
 		value = FONT_VARIANT_SMALL_CAPS;
 	} else
 		return CSS_INVALID;
@@ -1686,7 +1686,7 @@ css_error parse_font_weight(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (token->lower.ptr == c->strings[INHERIT]) {
+	if (token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_NUMBER) {
 		size_t consumed = 0;
@@ -1707,13 +1707,13 @@ css_error parse_font_weight(css_css21 *c,
 		case 900: value = FONT_WEIGHT_900; break;
 		default: return CSS_INVALID;
 		}
-	} else if (token->lower.ptr == c->strings[NORMAL]) {
+	} else if (token->lower.data == c->strings[NORMAL]) {
 		value = FONT_WEIGHT_NORMAL;
-	} else if (token->lower.ptr == c->strings[BOLD]) {
+	} else if (token->lower.data == c->strings[BOLD]) {
 		value = FONT_WEIGHT_BOLD;
-	} else if (token->lower.ptr == c->strings[BOLDER]) {
+	} else if (token->lower.data == c->strings[BOLDER]) {
 		value = FONT_WEIGHT_BOLDER;
-	} else if (token->lower.ptr == c->strings[LIGHTER]) {
+	} else if (token->lower.data == c->strings[LIGHTER]) {
 		value = FONT_WEIGHT_LIGHTER;
 	} else
 		return CSS_INVALID;
@@ -1750,11 +1750,11 @@ css_error parse_height(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[AUTO]) {
+			token->lower.data == c->strings[AUTO]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = HEIGHT_AUTO;
 	} else {
@@ -1814,11 +1814,11 @@ css_error parse_left(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[AUTO]) {
+			token->lower.data == c->strings[AUTO]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = LEFT_AUTO;
 	} else {
@@ -1878,11 +1878,11 @@ css_error parse_letter_spacing(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[NORMAL]) {
+			token->lower.data == c->strings[NORMAL]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = LETTER_SPACING_NORMAL;
 	} else {
@@ -1943,11 +1943,11 @@ css_error parse_line_height(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[NORMAL]) {
+			token->lower.data == c->strings[NORMAL]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = LINE_HEIGHT_NORMAL;
 	} else if (token->type == CSS_TOKEN_NUMBER) {
@@ -2021,10 +2021,10 @@ css_error parse_list_style_image(css_css21 *c,
 		return error;
 
 	if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[NONE]) {
+			token->lower.data == c->strings[NONE]) {
 		value = LIST_STYLE_IMAGE_NONE;
 	} else if (token->type == CSS_TOKEN_URI) {
 		value = LIST_STYLE_IMAGE_URI;
@@ -2046,7 +2046,7 @@ css_error parse_list_style_image(css_css21 *c,
 	memcpy((*result)->bytecode, &opv, sizeof(opv));
 	if ((flags & FLAG_INHERIT) == false && value == LIST_STYLE_IMAGE_URI) {
 		memcpy((uint8_t *) (*result)->bytecode + sizeof(opv),
-				&token->data.ptr, sizeof(uint8_t *));
+				&token->data.data, sizeof(uint8_t *));
 		memcpy((uint8_t *) (*result)->bytecode + sizeof(opv) + 
 					sizeof(uint8_t *),
 				&token->data.len, sizeof(size_t));
@@ -2074,11 +2074,11 @@ css_error parse_list_style_position(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[INSIDE]) {
+	} else if (ident->lower.data == c->strings[INSIDE]) {
 		value = LIST_STYLE_POSITION_INSIDE;
-	} else if (ident->lower.ptr == c->strings[OUTSIDE]) {
+	} else if (ident->lower.data == c->strings[OUTSIDE]) {
 		value = LIST_STYLE_POSITION_OUTSIDE;
 	} else
 		return CSS_INVALID;
@@ -2119,37 +2119,37 @@ css_error parse_list_style_type(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[DISC]) {
+	} else if (ident->lower.data == c->strings[DISC]) {
 		value = LIST_STYLE_TYPE_DISC;
-	} else if (ident->lower.ptr == c->strings[CIRCLE]) {
+	} else if (ident->lower.data == c->strings[CIRCLE]) {
 		value = LIST_STYLE_TYPE_CIRCLE;
-	} else if (ident->lower.ptr == c->strings[SQUARE]) {
+	} else if (ident->lower.data == c->strings[SQUARE]) {
 		value = LIST_STYLE_TYPE_SQUARE;
-	} else if (ident->lower.ptr == c->strings[DECIMAL]) {
+	} else if (ident->lower.data == c->strings[DECIMAL]) {
 		value = LIST_STYLE_TYPE_DECIMAL;
-	} else if (ident->lower.ptr == c->strings[DECIMAL_LEADING_ZERO]) {
+	} else if (ident->lower.data == c->strings[DECIMAL_LEADING_ZERO]) {
 		value = LIST_STYLE_TYPE_DECIMAL_LEADING_ZERO;
-	} else if (ident->lower.ptr == c->strings[LOWER_ROMAN]) {
+	} else if (ident->lower.data == c->strings[LOWER_ROMAN]) {
 		value = LIST_STYLE_TYPE_LOWER_ROMAN;
-	} else if (ident->lower.ptr == c->strings[UPPER_ROMAN]) {
+	} else if (ident->lower.data == c->strings[UPPER_ROMAN]) {
 		value = LIST_STYLE_TYPE_UPPER_ROMAN;
-	} else if (ident->lower.ptr == c->strings[LOWER_GREEK]) {
+	} else if (ident->lower.data == c->strings[LOWER_GREEK]) {
 		value = LIST_STYLE_TYPE_LOWER_GREEK;
-	} else if (ident->lower.ptr == c->strings[LOWER_LATIN]) {
+	} else if (ident->lower.data == c->strings[LOWER_LATIN]) {
 		value = LIST_STYLE_TYPE_LOWER_LATIN;
-	} else if (ident->lower.ptr == c->strings[UPPER_LATIN]) {
+	} else if (ident->lower.data == c->strings[UPPER_LATIN]) {
 		value = LIST_STYLE_TYPE_UPPER_LATIN;
-	} else if (ident->lower.ptr == c->strings[ARMENIAN]) {
+	} else if (ident->lower.data == c->strings[ARMENIAN]) {
 		value = LIST_STYLE_TYPE_ARMENIAN;
-	} else if (ident->lower.ptr == c->strings[GEORGIAN]) {
+	} else if (ident->lower.data == c->strings[GEORGIAN]) {
 		value = LIST_STYLE_TYPE_GEORGIAN;
-	} else if (ident->lower.ptr == c->strings[LOWER_ALPHA]) {
+	} else if (ident->lower.data == c->strings[LOWER_ALPHA]) {
 		value = LIST_STYLE_TYPE_LOWER_ALPHA;
-	} else if (ident->lower.ptr == c->strings[UPPER_ALPHA]) {
+	} else if (ident->lower.data == c->strings[UPPER_ALPHA]) {
 		value = LIST_STYLE_TYPE_UPPER_ALPHA;
-	} else if (ident->lower.ptr == c->strings[NONE]) {
+	} else if (ident->lower.data == c->strings[NONE]) {
 		value = LIST_STYLE_TYPE_NONE;
 	} else
 		return CSS_INVALID;
@@ -2214,11 +2214,11 @@ css_error parse_max_height(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[NONE]) {
+			token->lower.data == c->strings[NONE]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = MAX_HEIGHT_NONE;
 	} else {
@@ -2278,11 +2278,11 @@ css_error parse_max_width(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[NONE]) {
+			token->lower.data == c->strings[NONE]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = MAX_WIDTH_NONE;
 	} else {
@@ -2342,7 +2342,7 @@ css_error parse_min_height(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else {
@@ -2402,7 +2402,7 @@ css_error parse_min_width(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else {
@@ -2465,7 +2465,7 @@ css_error parse_orphans(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (token->lower.ptr == c->strings[INHERIT]) {
+	if (token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_NUMBER) {
 		size_t consumed = 0;
@@ -2518,11 +2518,11 @@ css_error parse_outline_color(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INVERT]) {
+			token->lower.data == c->strings[INVERT]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = OUTLINE_COLOR_INVERT;
 	} else {
@@ -2631,15 +2631,15 @@ css_error parse_overflow(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[VISIBLE]) {
+	} else if (ident->lower.data == c->strings[VISIBLE]) {
 		value = OVERFLOW_VISIBLE;
-	} else if (ident->lower.ptr == c->strings[HIDDEN]) {
+	} else if (ident->lower.data == c->strings[HIDDEN]) {
 		value = OVERFLOW_HIDDEN;
-	} else if (ident->lower.ptr == c->strings[SCROLL]) {
+	} else if (ident->lower.data == c->strings[SCROLL]) {
 		value = OVERFLOW_SCROLL;
-	} else if (ident->lower.ptr == c->strings[AUTO]) {
+	} else if (ident->lower.data == c->strings[AUTO]) {
 		value = OVERFLOW_AUTO;
 	} else
 		return CSS_INVALID;
@@ -2704,17 +2704,17 @@ css_error parse_page_break_after(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[AUTO]) {
+	} else if (ident->lower.data == c->strings[AUTO]) {
 		value = PAGE_BREAK_AFTER_AUTO;
-	} else if (ident->lower.ptr == c->strings[ALWAYS]) {
+	} else if (ident->lower.data == c->strings[ALWAYS]) {
 		value = PAGE_BREAK_AFTER_ALWAYS;
-	} else if (ident->lower.ptr == c->strings[AVOID]) {
+	} else if (ident->lower.data == c->strings[AVOID]) {
 		value = PAGE_BREAK_AFTER_AVOID;
-	} else if (ident->lower.ptr == c->strings[LEFT]) {
+	} else if (ident->lower.data == c->strings[LEFT]) {
 		value = PAGE_BREAK_AFTER_LEFT;
-	} else if (ident->lower.ptr == c->strings[RIGHT]) {
+	} else if (ident->lower.data == c->strings[RIGHT]) {
 		value = PAGE_BREAK_AFTER_RIGHT;
 	} else
 		return CSS_INVALID;
@@ -2751,17 +2751,17 @@ css_error parse_page_break_before(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[AUTO]) {
+	} else if (ident->lower.data == c->strings[AUTO]) {
 		value = PAGE_BREAK_BEFORE_AUTO;
-	} else if (ident->lower.ptr == c->strings[ALWAYS]) {
+	} else if (ident->lower.data == c->strings[ALWAYS]) {
 		value = PAGE_BREAK_BEFORE_ALWAYS;
-	} else if (ident->lower.ptr == c->strings[AVOID]) {
+	} else if (ident->lower.data == c->strings[AVOID]) {
 		value = PAGE_BREAK_BEFORE_AVOID;
-	} else if (ident->lower.ptr == c->strings[LEFT]) {
+	} else if (ident->lower.data == c->strings[LEFT]) {
 		value = PAGE_BREAK_BEFORE_LEFT;
-	} else if (ident->lower.ptr == c->strings[RIGHT]) {
+	} else if (ident->lower.data == c->strings[RIGHT]) {
 		value = PAGE_BREAK_BEFORE_RIGHT;
 	} else
 		return CSS_INVALID;
@@ -2798,11 +2798,11 @@ css_error parse_page_break_inside(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[AUTO]) {
+	} else if (ident->lower.data == c->strings[AUTO]) {
 		value = PAGE_BREAK_INSIDE_AUTO;
-	} else if (ident->lower.ptr == c->strings[AVOID]) {
+	} else if (ident->lower.data == c->strings[AVOID]) {
 		value = PAGE_BREAK_INSIDE_AVOID;
 	} else
 		return CSS_INVALID;
@@ -2839,7 +2839,7 @@ css_error parse_pause_after(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else {
@@ -2899,7 +2899,7 @@ css_error parse_pause_before(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else {
@@ -2962,7 +2962,7 @@ css_error parse_pitch_range(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (token->lower.ptr == c->strings[INHERIT]) {
+	if (token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_NUMBER) {
 		size_t consumed = 0;
@@ -3015,23 +3015,23 @@ css_error parse_pitch(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[X_LOW]) {
+			token->lower.data == c->strings[X_LOW]) {
 		value = PITCH_X_LOW;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[LOW]) {
+			token->lower.data == c->strings[LOW]) {
 		value = PITCH_LOW;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[MEDIUM]) {
+			token->lower.data == c->strings[MEDIUM]) {
 		value = PITCH_MEDIUM;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[HIGH]) {
+			token->lower.data == c->strings[HIGH]) {
 		value = PITCH_HIGH;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[X_HIGH]) {
+			token->lower.data == c->strings[X_HIGH]) {
 		value = PITCH_X_HIGH;
 	} else {
 		error = parse_unit_specifier(c, vector, ctx, &length, &unit);
@@ -3104,15 +3104,15 @@ css_error parse_position(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[STATIC]) {
+	} else if (ident->lower.data == c->strings[STATIC]) {
 		value = POSITION_STATIC;
-	} else if (ident->lower.ptr == c->strings[RELATIVE]) {
+	} else if (ident->lower.data == c->strings[RELATIVE]) {
 		value = POSITION_RELATIVE;
-	} else if (ident->lower.ptr == c->strings[ABSOLUTE]) {
+	} else if (ident->lower.data == c->strings[ABSOLUTE]) {
 		value = POSITION_ABSOLUTE;
-	} else if (ident->lower.ptr == c->strings[FIXED]) {
+	} else if (ident->lower.data == c->strings[FIXED]) {
 		value = POSITION_FIXED;
 	} else
 		return CSS_INVALID;
@@ -3166,7 +3166,7 @@ css_error parse_richness(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (token->lower.ptr == c->strings[INHERIT]) {
+	if (token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_NUMBER) {
 		size_t consumed = 0;
@@ -3219,11 +3219,11 @@ css_error parse_right(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[AUTO]) {
+			token->lower.data == c->strings[AUTO]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = RIGHT_AUTO;
 	} else {
@@ -3283,11 +3283,11 @@ css_error parse_speak_header(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[ONCE]) {
+	} else if (ident->lower.data == c->strings[ONCE]) {
 		value = SPEAK_HEADER_ONCE;
-	} else if (ident->lower.ptr == c->strings[ALWAYS]) {
+	} else if (ident->lower.data == c->strings[ALWAYS]) {
 		value = SPEAK_HEADER_ALWAYS;
 	} else
 		return CSS_INVALID;
@@ -3324,11 +3324,11 @@ css_error parse_speak_numeral(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[DIGITS]) {
+	} else if (ident->lower.data == c->strings[DIGITS]) {
 		value = SPEAK_NUMERAL_DIGITS;
-	} else if (ident->lower.ptr == c->strings[CONTINUOUS]) {
+	} else if (ident->lower.data == c->strings[CONTINUOUS]) {
 		value = SPEAK_NUMERAL_CONTINUOUS;
 	} else
 		return CSS_INVALID;
@@ -3365,11 +3365,11 @@ css_error parse_speak_punctuation(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[CODE]) {
+	} else if (ident->lower.data == c->strings[CODE]) {
 		value = SPEAK_PUNCTUATION_CODE;
-	} else if (ident->lower.ptr == c->strings[NONE]) {
+	} else if (ident->lower.data == c->strings[NONE]) {
 		value = SPEAK_PUNCTUATION_NONE;
 	} else
 		return CSS_INVALID;
@@ -3406,13 +3406,13 @@ css_error parse_speak(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[NORMAL]) {
+	} else if (ident->lower.data == c->strings[NORMAL]) {
 		value = SPEAK_NORMAL;
-	} else if (ident->lower.ptr == c->strings[NONE]) {
+	} else if (ident->lower.data == c->strings[NONE]) {
 		value = SPEAK_NONE;
-	} else if (ident->lower.ptr == c->strings[SPELL_OUT]) {
+	} else if (ident->lower.data == c->strings[SPELL_OUT]) {
 		value = SPEAK_SPELL_OUT;
 	} else
 		return CSS_INVALID;
@@ -3455,28 +3455,28 @@ css_error parse_speech_rate(css_css21 *c,
 		return error;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[X_SLOW]) {
+			token->lower.data == c->strings[X_SLOW]) {
 		value = SPEECH_RATE_X_SLOW;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[SLOW]) {
+			token->lower.data == c->strings[SLOW]) {
 		value = SPEECH_RATE_SLOW;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[MEDIUM]) {
+			token->lower.data == c->strings[MEDIUM]) {
 		value = SPEECH_RATE_MEDIUM;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[FAST]) {
+			token->lower.data == c->strings[FAST]) {
 		value = SPEECH_RATE_FAST;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[X_FAST]) {
+			token->lower.data == c->strings[X_FAST]) {
 		value = SPEECH_RATE_X_FAST;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[FASTER]) {
+			token->lower.data == c->strings[FASTER]) {
 		value = SPEECH_RATE_FASTER;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[SLOWER]) {
+			token->lower.data == c->strings[SLOWER]) {
 		value = SPEECH_RATE_SLOWER;
 	} else if (token->type == CSS_TOKEN_NUMBER) {
 		size_t consumed = 0;
@@ -3532,7 +3532,7 @@ css_error parse_stress(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (token->lower.ptr == c->strings[INHERIT]) {
+	if (token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_NUMBER) {
 		size_t consumed = 0;
@@ -3585,11 +3585,11 @@ css_error parse_table_layout(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[AUTO]) {
+	} else if (ident->lower.data == c->strings[AUTO]) {
 		value = TABLE_LAYOUT_AUTO;
-	} else if (ident->lower.ptr == c->strings[FIXED]) {
+	} else if (ident->lower.data == c->strings[FIXED]) {
 		value = TABLE_LAYOUT_FIXED;
 	} else
 		return CSS_INVALID;
@@ -3626,15 +3626,15 @@ css_error parse_text_align(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[LEFT]) {
+	} else if (ident->lower.data == c->strings[LEFT]) {
 		value = TEXT_ALIGN_LEFT;
-	} else if (ident->lower.ptr == c->strings[RIGHT]) {
+	} else if (ident->lower.data == c->strings[RIGHT]) {
 		value = TEXT_ALIGN_RIGHT;
-	} else if (ident->lower.ptr == c->strings[CENTER]) {
+	} else if (ident->lower.data == c->strings[CENTER]) {
 		value = TEXT_ALIGN_CENTER;
-	} else if (ident->lower.ptr == c->strings[JUSTIFY]) {
+	} else if (ident->lower.data == c->strings[JUSTIFY]) {
 		value = TEXT_ALIGN_JUSTIFY;
 	} else
 		return CSS_INVALID;
@@ -3685,7 +3685,7 @@ css_error parse_text_indent(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else {
@@ -3745,15 +3745,15 @@ css_error parse_text_transform(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[CAPITALIZE]) {
+	} else if (ident->lower.data == c->strings[CAPITALIZE]) {
 		value = TEXT_TRANSFORM_CAPITALIZE;
-	} else if (ident->lower.ptr == c->strings[UPPERCASE]) {
+	} else if (ident->lower.data == c->strings[UPPERCASE]) {
 		value = TEXT_TRANSFORM_UPPERCASE;
-	} else if (ident->lower.ptr == c->strings[LOWERCASE]) {
+	} else if (ident->lower.data == c->strings[LOWERCASE]) {
 		value = TEXT_TRANSFORM_LOWERCASE;
-	} else if (ident->lower.ptr == c->strings[NONE]) {
+	} else if (ident->lower.data == c->strings[NONE]) {
 		value = TEXT_TRANSFORM_NONE;
 	} else
 		return CSS_INVALID;
@@ -3790,11 +3790,11 @@ css_error parse_top(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[AUTO]) {
+			token->lower.data == c->strings[AUTO]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = TOP_AUTO;
 	} else {
@@ -3854,13 +3854,13 @@ css_error parse_unicode_bidi(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[NORMAL]) {
+	} else if (ident->lower.data == c->strings[NORMAL]) {
 		value = UNICODE_BIDI_NORMAL;
-	} else if (ident->lower.ptr == c->strings[EMBED]) {
+	} else if (ident->lower.data == c->strings[EMBED]) {
 		value = UNICODE_BIDI_EMBED;
-	} else if (ident->lower.ptr == c->strings[BIDI_OVERRIDE]) {
+	} else if (ident->lower.data == c->strings[BIDI_OVERRIDE]) {
 		value = UNICODE_BIDI_BIDI_OVERRIDE;
 	} else
 		return CSS_INVALID;
@@ -3899,39 +3899,39 @@ css_error parse_vertical_align(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[BASELINE]) {
+			token->lower.data == c->strings[BASELINE]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VERTICAL_ALIGN_BASELINE;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[SUB]) {
+			token->lower.data == c->strings[SUB]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VERTICAL_ALIGN_SUB;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[SUPER]) {
+			token->lower.data == c->strings[SUPER]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VERTICAL_ALIGN_SUPER;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[TOP]) {
+			token->lower.data == c->strings[TOP]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VERTICAL_ALIGN_TOP;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[TEXT_TOP]) {
+			token->lower.data == c->strings[TEXT_TOP]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VERTICAL_ALIGN_TEXT_TOP;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[MIDDLE]) {
+			token->lower.data == c->strings[MIDDLE]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VERTICAL_ALIGN_MIDDLE;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[BOTTOM]) {
+			token->lower.data == c->strings[BOTTOM]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VERTICAL_ALIGN_BOTTOM;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[TEXT_BOTTOM]) {
+			token->lower.data == c->strings[TEXT_BOTTOM]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VERTICAL_ALIGN_TEXT_BOTTOM;
 	} else {
@@ -3991,13 +3991,13 @@ css_error parse_visibility(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[VISIBLE]) {
+	} else if (ident->lower.data == c->strings[VISIBLE]) {
 		value = VISIBILITY_VISIBLE;
-	} else if (ident->lower.ptr == c->strings[HIDDEN]) {
+	} else if (ident->lower.data == c->strings[HIDDEN]) {
 		value = VISIBILITY_HIDDEN;
-	} else if (ident->lower.ptr == c->strings[COLLAPSE]) {
+	} else if (ident->lower.data == c->strings[COLLAPSE]) {
 		value = VISIBILITY_COLLAPSE;
 	} else
 		return CSS_INVALID;
@@ -4050,31 +4050,31 @@ css_error parse_volume(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[SILENT]) {
+			token->lower.data == c->strings[SILENT]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VOLUME_SILENT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[X_SOFT]) {
+			token->lower.data == c->strings[X_SOFT]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VOLUME_X_SOFT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[SOFT]) {
+			token->lower.data == c->strings[SOFT]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VOLUME_SOFT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[MEDIUM]) {
+			token->lower.data == c->strings[MEDIUM]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VOLUME_MEDIUM;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[LOUD]) {
+			token->lower.data == c->strings[LOUD]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VOLUME_LOUD;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[X_LOUD]) {
+			token->lower.data == c->strings[X_LOUD]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = VOLUME_X_LOUD;
 	} else if (token->type == CSS_TOKEN_NUMBER) {
@@ -4144,17 +4144,17 @@ css_error parse_white_space(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[NORMAL]) {
+	} else if (ident->lower.data == c->strings[NORMAL]) {
 		value = WHITE_SPACE_NORMAL;
-	} else if (ident->lower.ptr == c->strings[PRE]) {
+	} else if (ident->lower.data == c->strings[PRE]) {
 		value = WHITE_SPACE_PRE;
-	} else if (ident->lower.ptr == c->strings[NOWRAP]) {
+	} else if (ident->lower.data == c->strings[NOWRAP]) {
 		value = WHITE_SPACE_NOWRAP;
-	} else if (ident->lower.ptr == c->strings[PRE_WRAP]) {
+	} else if (ident->lower.data == c->strings[PRE_WRAP]) {
 		value = WHITE_SPACE_PRE_WRAP;
-	} else if (ident->lower.ptr == c->strings[PRE_LINE]) {
+	} else if (ident->lower.data == c->strings[PRE_LINE]) {
 		value = WHITE_SPACE_PRE_LINE;
 	} else
 		return CSS_INVALID;
@@ -4194,7 +4194,7 @@ css_error parse_widows(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (token->lower.ptr == c->strings[INHERIT]) {
+	if (token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_NUMBER) {
 		size_t consumed = 0;
@@ -4248,11 +4248,11 @@ css_error parse_width(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[AUTO]) {
+			token->lower.data == c->strings[AUTO]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = WIDTH_AUTO;
 	} else {
@@ -4312,11 +4312,11 @@ css_error parse_word_spacing(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[NORMAL]) {
+			token->lower.data == c->strings[NORMAL]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = WORD_SPACING_NORMAL;
 	} else {
@@ -4381,10 +4381,10 @@ css_error parse_z_index(css_css21 *c,
 		return error;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[AUTO]) {
+			token->lower.data == c->strings[AUTO]) {
 		value = Z_INDEX_AUTO;
 	} else if (token->type == CSS_TOKEN_NUMBER) {
 		size_t consumed = 0;
@@ -4435,7 +4435,7 @@ css_error parse_important(css_css21 *c,
 		if (token == NULL || token->type != CSS_TOKEN_IDENT)
 			return CSS_INVALID;
 
-		if (token->lower.ptr == c->strings[IMPORTANT])
+		if (token->lower.data == c->strings[IMPORTANT])
 			*result |= FLAG_IMPORTANT;
 	} else if (token != NULL)
 		return CSS_INVALID;
@@ -4502,11 +4502,11 @@ css_error parse_border_side_color(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[TRANSPARENT]) {
+			token->lower.data == c->strings[TRANSPARENT]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = BORDER_COLOR_TRANSPARENT;
 	} else {
@@ -4562,27 +4562,27 @@ css_error parse_border_side_style(css_css21 *c,
 	if (error != CSS_OK)
 		return error;
 
-	if (ident->lower.ptr == c->strings[INHERIT]) {
+	if (ident->lower.data == c->strings[INHERIT]) {
 		flags |= FLAG_INHERIT;
-	} else if (ident->lower.ptr == c->strings[NONE]) {
+	} else if (ident->lower.data == c->strings[NONE]) {
 		value = BORDER_STYLE_NONE;
-	} else if (ident->lower.ptr == c->strings[HIDDEN]) {
+	} else if (ident->lower.data == c->strings[HIDDEN]) {
 		value = BORDER_STYLE_HIDDEN;
-	} else if (ident->lower.ptr == c->strings[DOTTED]) {
+	} else if (ident->lower.data == c->strings[DOTTED]) {
 		value = BORDER_STYLE_DOTTED;
-	} else if (ident->lower.ptr == c->strings[DASHED]) {
+	} else if (ident->lower.data == c->strings[DASHED]) {
 		value = BORDER_STYLE_DASHED;
-	} else if (ident->lower.ptr == c->strings[SOLID]) {
+	} else if (ident->lower.data == c->strings[SOLID]) {
 		value = BORDER_STYLE_SOLID;
-	} else if (ident->lower.ptr == c->strings[DOUBLE]) {
+	} else if (ident->lower.data == c->strings[DOUBLE]) {
 		value = BORDER_STYLE_DOUBLE;
-	} else if (ident->lower.ptr == c->strings[GROOVE]) {
+	} else if (ident->lower.data == c->strings[GROOVE]) {
 		value = BORDER_STYLE_GROOVE;
-	} else if (ident->lower.ptr == c->strings[RIDGE]) {
+	} else if (ident->lower.data == c->strings[RIDGE]) {
 		value = BORDER_STYLE_RIDGE;
-	} else if (ident->lower.ptr == c->strings[INSET]) {
+	} else if (ident->lower.data == c->strings[INSET]) {
 		value = BORDER_STYLE_INSET;
-	} else if (ident->lower.ptr == c->strings[OUTSET]) {
+	} else if (ident->lower.data == c->strings[OUTSET]) {
 		value = BORDER_STYLE_OUTSET;
 	} else
 		return CSS_INVALID;
@@ -4619,19 +4619,19 @@ css_error parse_border_side_width(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT && 
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags |= FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[THIN]) {
+			token->lower.data == c->strings[THIN]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = BORDER_WIDTH_THIN;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[MEDIUM]) {
+			token->lower.data == c->strings[MEDIUM]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = BORDER_WIDTH_MEDIUM;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[THICK]) {
+			token->lower.data == c->strings[THICK]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = BORDER_WIDTH_THICK;
 	} else {
@@ -4692,11 +4692,11 @@ css_error parse_margin_side(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[AUTO]) {
+			token->lower.data == c->strings[AUTO]) {
 		parserutils_vector_iterate(vector, ctx);
 		value = MARGIN_AUTO;
 	} else {
@@ -4756,7 +4756,7 @@ css_error parse_padding_side(css_css21 *c,
 		return CSS_INVALID;
 
 	if (token->type == CSS_TOKEN_IDENT &&
-			token->lower.ptr == c->strings[INHERIT]) {
+			token->lower.data == c->strings[INHERIT]) {
 		parserutils_vector_iterate(vector, ctx);
 		flags = FLAG_INHERIT;
 	} else {
diff --git a/src/parse/parse.c b/src/parse/parse.c
index f12ffe5..f461302 100644
--- a/src/parse/parse.c
+++ b/src/parse/parse.c
@@ -174,17 +174,19 @@ static css_error (*parseFuncs[])(css_parser *parser) = {
 /**
  * Create a CSS parser
  *
- * \param charset    Charset of data, if known, or NULL
- * \param cs_source  Source of charset information, or CSS_CHARSET_DEFAULT
- * \param alloc      Memory (de)allocation function
- * \param pw         Pointer to client-specific private data
- * \param parser     Pointer to location to receive parser instance
+ * \param charset     Charset of data, if known, or NULL
+ * \param cs_source   Source of charset information, or CSS_CHARSET_DEFAULT
+ * \param dictionary  Dictionary in which to intern strings (not copied)
+ * \param alloc       Memory (de)allocation function
+ * \param pw          Pointer to client-specific private data
+ * \param parser      Pointer to location to receive parser instance
  * \return CSS_OK on success,
  *         CSS_BADPARM on bad parameters,
  *         CSS_NOMEM on memory exhaustion
  */
 css_error css_parser_create(const char *charset, css_charset_source cs_source,
-		css_alloc alloc, void *pw, css_parser **parser)
+		parserutils_dict *dictionary, css_alloc alloc, void *pw, 
+		css_parser **parser)
 {
 	css_parser *p;
 	parser_state initial = { sStart, 0 };
@@ -223,21 +225,12 @@ css_error css_parser_create(const char *charset, css_charset_source cs_source,
 		return css_error_from_parserutils_error(perror);
 	}
 
-	perror = parserutils_dict_create((parserutils_alloc) alloc, pw,
-			&p->dictionary);
-	if (perror != PARSERUTILS_OK) {
-		parserutils_stack_destroy(p->states);
-		css_lexer_destroy(p->lexer);
-		parserutils_inputstream_destroy(p->stream);
-		alloc(p, 0, pw);
-		return css_error_from_parserutils_error(perror);
-	}
+	p->dictionary = dictionary;
 
 	perror = parserutils_vector_create(sizeof(css_token), 
 			STACK_CHUNK, (parserutils_alloc) alloc, pw,
 			&p->tokens);
 	if (perror != PARSERUTILS_OK) {
-		parserutils_dict_destroy(p->dictionary);
 		parserutils_stack_destroy(p->states);
 		css_lexer_destroy(p->lexer);
 		parserutils_inputstream_destroy(p->stream);
@@ -261,7 +254,6 @@ css_error css_parser_create(const char *charset, css_charset_source cs_source,
 	if (perror != PARSERUTILS_OK) {
 		parserutils_stack_destroy(p->open_items);
 		parserutils_vector_destroy(p->tokens);
-		parserutils_dict_destroy(p->dictionary);
 		parserutils_stack_destroy(p->states);
 		css_lexer_destroy(p->lexer);
 		parserutils_inputstream_destroy(p->stream);
@@ -298,8 +290,6 @@ css_error css_parser_destroy(css_parser *parser)
 
 	parserutils_vector_destroy(parser->tokens);
 
-	parserutils_dict_destroy(parser->dictionary);
-
 	parserutils_stack_destroy(parser->states);
 
 	css_lexer_destroy(parser->lexer);
@@ -423,20 +413,20 @@ const char *css_parser_read_charset(css_parser *parser,
  * Add an entry to the parser dictionary
  *
  * \param parser  The parser instance
- * \param ptr     Pointer to data
+ * \param data     Pointer to data
  * \param len     Length, in bytes, of data
  * \return Pointer to data in dictionary, or NULL on memory exhaustion
  */
-const uint8_t *css_parser_dict_add(css_parser *parser, const uint8_t *ptr,
+const uint8_t *css_parser_dict_add(css_parser *parser, const uint8_t *data,
 		size_t len)
 {
 	const parserutils_dict_entry *interned;
 	parserutils_error perror;
 
-	if (parser == NULL || ptr == NULL || len == 0)
+	if (parser == NULL || data == NULL || len == 0)
 		return NULL;
 
-	perror = parserutils_dict_insert(parser->dictionary, ptr, len, 
+	perror = parserutils_dict_insert(parser->dictionary, data, len, 
 			&interned);
 	if (perror != PARSERUTILS_OK)
 		return NULL;
@@ -580,7 +570,7 @@ css_error getToken(css_parser *parser, const css_token **token)
 			return error;
 
 		if (t->type != CSS_TOKEN_S &&
-				t->data.ptr != NULL && t->data.len > 0) {
+				t->data.data != NULL && t->data.len > 0) {
 			/* Insert token text into the dictionary */
 			const parserutils_dict_entry *interned;
 			uint8_t temp[t->data.len];
@@ -592,8 +582,8 @@ css_error getToken(css_parser *parser, const css_token **token)
 			case CSS_TOKEN_HASH:
 			case CSS_TOKEN_FUNCTION:
 				for (size_t i = 0; i < t->data.len; i++) {
-					temp[i] = tolower(t->data.ptr[i]);
-					if (temp[i] != t->data.ptr[i])
+					temp[i] = tolower(t->data.data[i]);
+					if (temp[i] != t->data.data[i])
 						lower = true;
 				}
 				break;
@@ -614,30 +604,30 @@ css_error getToken(css_parser *parser, const css_token **token)
 							perror);
 				}
 
-				t->lower.ptr = interned->data;
+				t->lower.data = interned->data;
 				t->lower.len = interned->len;
 
 				perror = parserutils_dict_insert(
 						parser->dictionary,
-						t->data.ptr, t->data.len,
+						t->data.data, t->data.len,
 						&interned);
 			} else {
 				/* Otherwise, we're not interested in case */
 				perror = parserutils_dict_insert(
 						parser->dictionary,
-						t->data.ptr, t->data.len, 
+						t->data.data, t->data.len, 
 						&interned);
 
-				t->lower.ptr = interned->data;
+				t->lower.data = interned->data;
 				t->lower.len = interned->len;
 			}
 			if (perror != PARSERUTILS_OK)
 				return css_error_from_parserutils_error(perror);
 
-			t->data.ptr = interned->data;
+			t->data.data = interned->data;
 			t->data.len = interned->len;
 		} else if (t->type == CSS_TOKEN_S) {
-			t->data.ptr = t->lower.ptr = NULL;
+			t->data.data = t->lower.data = NULL;
 			t->data.len = t->lower.len = 0;
 		}
 
@@ -863,7 +853,7 @@ css_error parseRuleset(css_parser *parser)
 		 * brace. We're going to assume that that won't happen, 
 		 * however. */
 		if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1 && 
-				token->lower.ptr[0] == '{') {
+				token->lower.data[0] == '{') {
 #if !defined(NDEBUG) && defined(DEBUG_EVENTS)
 			printf("Begin ruleset\n");
 #endif
@@ -914,7 +904,7 @@ css_error parseRuleset(css_parser *parser)
 			return error;
 
 		if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 ||
-				token->lower.ptr[0] != '{') {
+				token->lower.data[0] != '{') {
 			/* This should never happen, as FOLLOW(selector) 
 			 * contains only '{' */
 			assert(0 && "Expected {");
@@ -979,7 +969,7 @@ css_error parseRulesetEnd(css_parser *parser)
 			return error;
 
 		if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 ||
-				token->lower.ptr[0] != '}') {
+				token->lower.data[0] != '}') {
 			/* This should never happen, as FOLLOW(decl-list)
 			 * contains only '}' */
 			assert(0 && "Expected }");
@@ -1054,8 +1044,8 @@ css_error parseAtRule(css_parser *parser)
 		/* Grammar ambiguity: any0 can be followed by '{',';',')',']'. 
 		 * at-rule can only be followed by '{' and ';'. */
 		if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1) {
-			if (token->lower.ptr[0] == ')' ||
-					token->lower.ptr[0] == ']') {
+			if (token->lower.data[0] == ')' ||
+					token->lower.data[0] == ']') {
 				parser_state to = { sAny0, Initial };
 				parser_state subsequent = { sAtRule, AfterAny };
 
@@ -1111,7 +1101,7 @@ css_error parseAtRuleEnd(css_parser *parser)
 			assert(0 && "Expected { or ;");
 		}
 		
-		if (token->lower.ptr[0] == '{') {
+		if (token->lower.data[0] == '{') {
 			parser_state to = { sBlock, Initial };
 			parser_state subsequent = { sAtRuleEnd, AfterBlock };
 
@@ -1120,7 +1110,7 @@ css_error parseAtRuleEnd(css_parser *parser)
 				return error;
 
 			return transition(parser, to, subsequent);
-		} else if (token->lower.ptr[0] != ';') {
+		} else if (token->lower.data[0] != ';') {
 			/* Again, should never happen */
 			assert(0 && "Expected ;");
 		}
@@ -1173,7 +1163,7 @@ css_error parseBlock(css_parser *parser)
 		parserutils_vector_clear(parser->tokens);
 
 		if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 ||
-				token->lower.ptr[0] != '{') {
+				token->lower.data[0] != '{') {
 			/* This should never happen, as FIRST(block) == '{' */
 			assert(0 && "Expected {");
 		}
@@ -1200,7 +1190,7 @@ css_error parseBlock(css_parser *parser)
 			return error;
 
 		if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 ||
-				token->lower.ptr[0] != '}') {
+				token->lower.data[0] != '}') {
 			/* This should never happen, as 
 			 * FOLLOW(block-content) == '}' */
 			assert(0 && "Expected }");
@@ -1253,7 +1243,7 @@ css_error parseBlockContent(css_parser *parser)
 				state->substate = WS;
 			} else if (token->type == CSS_TOKEN_CHAR) {
 				if (token->lower.len == 1 && 
-						token->lower.ptr[0] == '{') {
+						token->lower.data[0] == '{') {
 					/* Grammar ambiguity. Assume block */
 					parser_state to = { sBlock, Initial };
 					parser_state subsequent = 
@@ -1277,11 +1267,11 @@ css_error parseBlockContent(css_parser *parser)
 					return transition(parser, to, 
 							subsequent);
 				} else if (token->lower.len == 1 &&
-						token->lower.ptr[0] == ';') {
+						token->lower.data[0] == ';') {
 					/* Grammar ambiguity. Assume semi */
 					state->substate = WS;
 				} else if (token->lower.len == 1 &&
-						token->lower.ptr[0] == '}') {
+						token->lower.data[0] == '}') {
 					/* Grammar ambiguity. Assume end */
 					error = pushBack(parser, token);
 					if (error != CSS_OK)
@@ -1390,7 +1380,7 @@ css_error parseDeclaration(css_parser *parser)
 			return error;
 
 		if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 ||
-				token->lower.ptr[0] != ':') {
+				token->lower.data[0] != ':') {
 			/* parse error -- expected : */
 			parser_state to = { sMalformedDecl, Initial };
 
@@ -1458,13 +1448,13 @@ css_error parseDeclList(css_parser *parser)
 			assert(0 && "Expected ; or  }");
 		}
 
-		if (token->lower.ptr[0] == '}') {
+		if (token->lower.data[0] == '}') {
 			error = pushBack(parser, token);
 			if (error != CSS_OK)
 				return error;
 
 			return done(parser);
-		} else if (token->lower.ptr[0] == ';') {
+		} else if (token->lower.data[0] == ';') {
 			state->substate = WS;
 		} else {
 			/* Should never happen */
@@ -1504,8 +1494,8 @@ css_error parseDeclListEnd(css_parser *parser)
 
 		if (token->type != CSS_TOKEN_CHAR || 
 				token->lower.len != 1 || 
-				(token->lower.ptr[0] != ';' &&
-				token->lower.ptr[0] != '}')) {
+				(token->lower.data[0] != ';' &&
+				token->lower.data[0] != '}')) {
 			parser_state to = { sDeclaration, Initial };
 			parser_state subsequent = 
 					{ sDeclListEnd, AfterDeclaration };
@@ -1593,8 +1583,8 @@ css_error parseValue1(css_parser *parser)
 		/* Grammar ambiguity -- assume ';' or '}' mark end */
 		if (token->type == CSS_TOKEN_CHAR && 
 				token->lower.len == 1 &&
-				(token->lower.ptr[0] == ';' ||
-				token->lower.ptr[0] == '}')) {
+				(token->lower.data[0] == ';' ||
+				token->lower.data[0] == '}')) {
 			/* Parse error */
 			parser->parseError = true;
 
@@ -1641,8 +1631,8 @@ css_error parseValue0(css_parser *parser)
 			/* Grammar ambiguity -- assume ';' or '}' mark end */
 			if (token->type == CSS_TOKEN_CHAR && 
 					token->lower.len == 1 &&
-					(token->lower.ptr[0] == ';' ||
-					token->lower.ptr[0] == '}')) {
+					(token->lower.data[0] == ';' ||
+					token->lower.data[0] == '}')) {
 				return done(parser);
 			}
 
@@ -1680,7 +1670,7 @@ css_error parseValue(css_parser *parser)
 			state->substate = WS;
 		} else if (token->type == CSS_TOKEN_CHAR && 
 				token->lower.len == 1 && 
-				token->lower.ptr[0] == '{') {
+				token->lower.data[0] == '{') {
 			/* Grammar ambiguity. Assume block. */
 			parser_state to = { sBlock, Initial };
 
@@ -1741,10 +1731,10 @@ css_error parseAny0(css_parser *parser)
 			 * assume '{', ';', ')', ']' mark end */
 			if (token->type == CSS_TOKEN_CHAR && 
 					token->lower.len == 1 &&
-					(token->lower.ptr[0] == '{' ||
-					token->lower.ptr[0] == ';' ||
-					token->lower.ptr[0] == ')' ||
-					token->lower.ptr[0] == ']')) {
+					(token->lower.data[0] == '{' ||
+					token->lower.data[0] == ';' ||
+					token->lower.data[0] == ')' ||
+					token->lower.data[0] == ']')) {
 				return done(parser);
 			}
 
@@ -1805,14 +1795,14 @@ css_error parseAny1(css_parser *parser)
 		/* Grammar ambiguity: any0 can be followed by 
 		 * '{', ';', ')', ']'. any1 can only be followed by '{'. */
 		if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1) {
-			if (token->lower.ptr[0] == ';' ||
-					token->lower.ptr[0] == ')' ||
-					token->lower.ptr[0] == ']') {
+			if (token->lower.data[0] == ';' ||
+					token->lower.data[0] == ')' ||
+					token->lower.data[0] == ']') {
 				parser_state to = { sAny, Initial };
 				parser_state subsequent = { sAny1, AfterAny };
 
 				return transition(parser, to, subsequent);
-			} else if (token->lower.ptr[0] != '{') {
+			} else if (token->lower.data[0] != '{') {
 				/* parse error */
 				parser->parseError = true;
 			}
@@ -1883,10 +1873,10 @@ css_error parseAny(css_parser *parser)
 			state->substate = WS;
 		} else if (token->type == CSS_TOKEN_CHAR && 
 				token->lower.len == 1 && 
-				(token->lower.ptr[0] == '(' || 
-				token->lower.ptr[0] == '[')) {
+				(token->lower.data[0] == '(' || 
+				token->lower.data[0] == '[')) {
 			parser->match_char = 
-					token->lower.ptr[0] == '(' ? ')' : ']';
+					token->lower.data[0] == '(' ? ')' : ']';
 			state->substate = WS;
 		} 
 
@@ -1919,7 +1909,7 @@ css_error parseAny(css_parser *parser)
 
 		/* Match correct close bracket (grammar ambiguity) */
 		if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1 &&
-				token->lower.ptr[0] == parser->match_char) {
+				token->lower.data[0] == parser->match_char) {
 			state->substate = WS2;
 			goto ws2;
 		}
@@ -1963,13 +1953,13 @@ css_error parseMalformedDeclaration(css_parser *parser)
 
 			if (token->type != CSS_TOKEN_CHAR || 
 					token->lower.len != 1 ||
-					(token->lower.ptr[0] != '{' &&
-					token->lower.ptr[0] != '}' &&
-					token->lower.ptr[0] != '[' &&
-					token->lower.ptr[0] != ']' &&
-					token->lower.ptr[0] != '(' &&
-					token->lower.ptr[0] != ')' &&
-					token->lower.ptr[0] != ';'))
+					(token->lower.data[0] != '{' &&
+					token->lower.data[0] != '}' &&
+					token->lower.data[0] != '[' &&
+					token->lower.data[0] != ']' &&
+					token->lower.data[0] != '(' &&
+					token->lower.data[0] != ')' &&
+					token->lower.data[0] != ';'))
 				continue;
 
 			char want;
@@ -1979,17 +1969,17 @@ css_error parseMalformedDeclaration(css_parser *parser)
 			/* If the stack is empty, then we're done if we've got
 			 * either a ';' or '}' */
 			if (match == NULL) {
-				if (token->lower.ptr[0] == ';' ||
-						token->lower.ptr[0] == '}')
+				if (token->lower.data[0] == ';' ||
+						token->lower.data[0] == '}')
 					break;
 			}
 
 			/* Regardless, if we've got a semicolon, ignore it */
-			if (token->lower.ptr[0] == ';')
+			if (token->lower.data[0] == ';')
 				continue;
 
 			/* Get corresponding start tokens for end tokens */
-			switch (token->lower.ptr[0]) {
+			switch (token->lower.data[0]) {
 			case '}':
 				want = '{';
 				break;
@@ -2011,7 +2001,7 @@ css_error parseMalformedDeclaration(css_parser *parser)
 					parser->open_items, NULL);
 			} else if (want == 0) {
 				parserutils_stack_push(parser->open_items, 
-						&token->lower.ptr[0]);
+						&token->lower.data[0]);
 			}
 		}
 	}
@@ -2057,12 +2047,12 @@ css_error parseMalformedSelector(css_parser *parser)
 
 			if (token->type != CSS_TOKEN_CHAR || 
 					token->lower.len != 1 ||
-					(token->lower.ptr[0] != '{' &&
-					token->lower.ptr[0] != '}' &&
-					token->lower.ptr[0] != '[' &&
-					token->lower.ptr[0] != ']' &&
-					token->lower.ptr[0] != '(' &&
-					token->lower.ptr[0] != ')'))
+					(token->lower.data[0] != '{' &&
+					token->lower.data[0] != '}' &&
+					token->lower.data[0] != '[' &&
+					token->lower.data[0] != ']' &&
+					token->lower.data[0] != '(' &&
+					token->lower.data[0] != ')'))
 				continue;
 
 			char want;
@@ -2070,7 +2060,7 @@ css_error parseMalformedSelector(css_parser *parser)
 					parser->open_items);
 
 			/* Get corresponding start tokens for end tokens */
-			switch (token->lower.ptr[0]) {
+			switch (token->lower.data[0]) {
 			case '}':
 				want = '{';
 				break;
@@ -2092,7 +2082,7 @@ css_error parseMalformedSelector(css_parser *parser)
 					parser->open_items, NULL);
 			} else if (want == 0) {
 				parserutils_stack_push(parser->open_items, 
-						&token->lower.ptr[0]);
+						&token->lower.data[0]);
 			}
 
 			/* If we encountered a '}', there was data on the stack
@@ -2150,13 +2140,13 @@ css_error parseMalformedAtRule(css_parser *parser)
 
 			if (token->type != CSS_TOKEN_CHAR || 
 					token->lower.len != 1 ||
-					(token->lower.ptr[0] != '{' &&
-					token->lower.ptr[0] != '}' &&
-					token->lower.ptr[0] != '[' &&
-					token->lower.ptr[0] != ']' &&
-					token->lower.ptr[0] != '(' &&
-					token->lower.ptr[0] != ')' &&
-					token->lower.ptr[0] != ';'))
+					(token->lower.data[0] != '{' &&
+					token->lower.data[0] != '}' &&
+					token->lower.data[0] != '[' &&
+					token->lower.data[0] != ']' &&
+					token->lower.data[0] != '(' &&
+					token->lower.data[0] != ')' &&
+					token->lower.data[0] != ';'))
 				continue;
 
 			char want;
@@ -2165,7 +2155,7 @@ css_error parseMalformedAtRule(css_parser *parser)
 
 			/* If we have a semicolon, then we're either done or
 			 * need to ignore it */
-			if (token->lower.ptr[0] == ';') {
+			if (token->lower.data[0] == ';') {
 				if (match == NULL)
 					break;
 				else
@@ -2173,7 +2163,7 @@ css_error parseMalformedAtRule(css_parser *parser)
 			}
 
 			/* Get corresponding start tokens for end tokens */
-			switch (token->lower.ptr[0]) {
+			switch (token->lower.data[0]) {
 			case '}':
 				want = '{';
 				break;
@@ -2195,7 +2185,7 @@ css_error parseMalformedAtRule(css_parser *parser)
 					parser->open_items, NULL);
 			} else if (want == 0) {
 				parserutils_stack_push(parser->open_items, 
-						&token->lower.ptr[0]);
+						&token->lower.data[0]);
 			}
 
 			/* If we encountered a '}', there was data on the stack
@@ -2236,8 +2226,8 @@ static void tprinter(void *token)
 {
 	css_token *t = token;
 
-	if (t->data.ptr)
-		printf("%d: %.*s", t->type, t->data.len, t->data.ptr);
+	if (t->data.data)
+		printf("%d: %.*s", t->type, t->data.len, t->data.data);
 	else
 		printf("%d", t->type);
 }
diff --git a/src/parse/parse.h b/src/parse/parse.h
index c2396cb..a948d56 100644
--- a/src/parse/parse.h
+++ b/src/parse/parse.h
@@ -8,6 +8,7 @@
 #ifndef css_parse_parse_h_
 #define css_parse_parse_h_
 
+#include <parserutils/utils/dict.h>
 #include <parserutils/utils/vector.h>
 
 #include <libcss/errors.h>
@@ -56,7 +57,8 @@ typedef union css_parser_optparams {
 } css_parser_optparams;
 
 css_error css_parser_create(const char *charset, css_charset_source cs_source,
-		css_alloc alloc, void *pw, css_parser **parser);
+		parserutils_dict *dict, css_alloc alloc, void *pw, 
+		css_parser **parser);
 css_error css_parser_destroy(css_parser *parser);
 
 css_error css_parser_setopt(css_parser *parser, css_parser_opttype type,