Quirks mode parsing

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

10 files changed, 282 insertions, 138 deletions

diff --git a/include/libcss/stylesheet.h b/include/libcss/stylesheet.h
index dd4bc81..3ce25d5 100644
--- a/include/libcss/stylesheet.h
+++ b/include/libcss/stylesheet.h
@@ -13,8 +13,8 @@
 
 css_error css_stylesheet_create(css_language_level level,
 		const char *charset, const char *url, const char *title,
-		css_origin origin, uint64_t media, lwc_context *dict,
-		css_allocator_fn alloc, void *alloc_pw, 
+		css_origin origin, uint64_t media, bool allow_quirks,
+		lwc_context *dict, css_allocator_fn alloc, void *alloc_pw, 
 		css_stylesheet **stylesheet);
 css_error css_stylesheet_destroy(css_stylesheet *sheet);
 
@@ -33,6 +33,8 @@ css_error css_stylesheet_get_url(css_stylesheet *sheet, const char **url);
 css_error css_stylesheet_get_title(css_stylesheet *sheet, const char **title);
 css_error css_stylesheet_get_origin(css_stylesheet *sheet, css_origin *origin);
 css_error css_stylesheet_get_media(css_stylesheet *sheet, uint64_t *media);
+css_error css_stylesheet_quirks_allowed(css_stylesheet *sheet, bool *allowed);
+css_error css_stylesheet_used_quirks(css_stylesheet *sheet, bool *quirks);
 
 css_error css_stylesheet_get_disabled(css_stylesheet *sheet, bool *disabled);
 css_error css_stylesheet_set_disabled(css_stylesheet *sheet, bool disabled);
diff --git a/src/parse/parse.c b/src/parse/parse.c
index 50bd362..a1b77b0 100644
--- a/src/parse/parse.c
+++ b/src/parse/parse.c
@@ -413,6 +413,17 @@ const char *css_parser_read_charset(css_parser *parser,
 	return parserutils_inputstream_read_charset(parser->stream, source);
 }
 
+/**
+ * Quirks permitted when parsing
+ *
+ * \param parser  Parser to query
+ * \return True if quirks permitted, false otherwise
+ */
+bool css_parser_quirks_permitted(css_parser *parser)
+{
+	return parser->quirks;
+}
+
 /******************************************************************************
  * Helper functions                                                           *
  ******************************************************************************/
diff --git a/src/parse/parse.h b/src/parse/parse.h
index bb6229f..3a460e6 100644
--- a/src/parse/parse.h
+++ b/src/parse/parse.h
@@ -71,6 +71,7 @@ css_error css_parser_completed(css_parser *parser);
 
 const char *css_parser_read_charset(css_parser *parser, 
 		css_charset_source *source);
+bool css_parser_quirks_permitted(css_parser *parser);
 
 #endif
 
diff --git a/src/parse/properties.c b/src/parse/properties.c
index bd1a6a4..a4de6ef 100644
--- a/src/parse/properties.c
+++ b/src/parse/properties.c
@@ -315,10 +315,13 @@ static inline css_error parse_important(css_language *c,
 static inline css_error parse_colour_specifier(css_language *c,
 		const parserutils_vector *vector, int *ctx,
 		uint32_t *result);
+static inline css_error parse_hash_colour(lwc_string *data, uint32_t *result);
 static inline css_error parse_unit_specifier(css_language *c,
 		const parserutils_vector *vector, int *ctx,
 		uint32_t default_unit,
 		css_fixed *length, uint32_t *unit);
+static inline css_error parse_unit_keyword(const char *ptr, size_t len, 
+		css_unit *unit);
 
 static inline css_error parse_border_side_color(css_language *c,
 		const parserutils_vector *vector, int *ctx,
@@ -6569,6 +6572,7 @@ css_error parse_colour_specifier(css_language *c,
 {
 	const css_token *token;
 	uint8_t r = 0, g = 0, b = 0;
+	css_error error;
 
 	UNUSED(c);
 
@@ -6583,38 +6587,36 @@ css_error parse_colour_specifier(css_language *c,
 	token = parserutils_vector_iterate(vector, ctx);
 	if (token == NULL || (token->type != CSS_TOKEN_IDENT &&
 			token->type != CSS_TOKEN_HASH &&
-			token->type != CSS_TOKEN_FUNCTION))
-		return CSS_INVALID;
+			token->type != CSS_TOKEN_FUNCTION)) {
+		if (c->sheet->quirks_allowed == false ||
+				(token->type != CSS_TOKEN_NUMBER && 
+				token->type != CSS_TOKEN_DIMENSION))
+			return CSS_INVALID;
+	}
 
 	if (token->type == CSS_TOKEN_IDENT) {
 		/** \todo Parse colour names */
+
+		if (c->sheet->quirks_allowed) {
+			error = parse_hash_colour(token->idata, result);
+			if (error == CSS_OK)
+				c->sheet->quirks_used = true;
+			return error;
+		}
 	} else if (token->type == CSS_TOKEN_HASH) {
-		if (lwc_string_length(token->idata) == 3 &&
-				isHex(lwc_string_data(token->idata)[0]) &&
-				isHex(lwc_string_data(token->idata)[1]) &&
-				isHex(lwc_string_data(token->idata)[2])) {
-			r = charToHex(lwc_string_data(token->idata)[0]);
-			g = charToHex(lwc_string_data(token->idata)[1]);
-			b = charToHex(lwc_string_data(token->idata)[2]);
-
-			r |= (r << 4);
-			g |= (g << 4);
-			b |= (b << 4);
-		} else if (lwc_string_length(token->idata) == 6 &&
-				isHex(lwc_string_data(token->idata)[0]) &&
-				isHex(lwc_string_data(token->idata)[1]) &&
-				isHex(lwc_string_data(token->idata)[2]) &&
-				isHex(lwc_string_data(token->idata)[3]) &&
-				isHex(lwc_string_data(token->idata)[4]) &&
-				isHex(lwc_string_data(token->idata)[5])) {
-			r = (charToHex(lwc_string_data(token->idata)[0]) << 4);
-			r |= charToHex(lwc_string_data(token->idata)[1]);
-			g = (charToHex(lwc_string_data(token->idata)[2]) << 4);
-			g |= charToHex(lwc_string_data(token->idata)[3]);
-			b = (charToHex(lwc_string_data(token->idata)[4]) << 4);
-			b |= charToHex(lwc_string_data(token->idata)[5]);
-		} else
-			return CSS_INVALID;
+		return parse_hash_colour(token->idata, result);
+	} else if (c->sheet->quirks_allowed && 
+			token->type == CSS_TOKEN_NUMBER) {
+		error = parse_hash_colour(token->idata, result);
+		if (error == CSS_OK)
+			c->sheet->quirks_used = true;
+		return error;
+	} else if (c->sheet->quirks_allowed && 
+			token->type == CSS_TOKEN_DIMENSION) {
+		error = parse_hash_colour(token->idata, result);
+		if (error == CSS_OK)
+			c->sheet->quirks_used = true;
+		return error;
 	} else if (token->type == CSS_TOKEN_FUNCTION) {
 		if (token->ilower == c->strings[RGB]) {
 			css_token_type valid = CSS_TOKEN_NUMBER;
@@ -6684,6 +6686,38 @@ css_error parse_colour_specifier(css_language *c,
 	return CSS_OK;
 }
 
+css_error parse_hash_colour(lwc_string *data, uint32_t *result)
+{
+	uint8_t r = 0, g = 0, b = 0;
+	size_t len = lwc_string_length(data);
+	const char *input = lwc_string_data(data);
+
+	if (len == 3 &&	isHex(input[0]) && isHex(input[1]) &&
+			isHex(input[2])) {
+		r = charToHex(input[0]);
+		g = charToHex(input[1]);
+		b = charToHex(input[2]);
+
+		r |= (r << 4);
+		g |= (g << 4);
+		b |= (b << 4);
+	} else if (len == 6 && isHex(input[0]) && isHex(input[1]) &&
+			isHex(input[2]) && isHex(input[3]) &&
+			isHex(input[4]) && isHex(input[5])) {
+		r = (charToHex(input[0]) << 4);
+		r |= charToHex(input[1]);
+		g = (charToHex(input[2]) << 4);
+		g |= charToHex(input[3]);
+		b = (charToHex(input[4]) << 4);
+		b |= charToHex(input[5]);
+	} else
+		return CSS_INVALID;
+
+	*result = (r << 24) | (g << 16) | (b << 8);
+
+	return CSS_OK;
+}
+
 css_error parse_unit_specifier(css_language *c,
 		const parserutils_vector *vector, int *ctx,
 		uint32_t default_unit,
@@ -6692,6 +6726,7 @@ css_error parse_unit_specifier(css_language *c,
 	const css_token *token;
 	css_fixed num;
 	size_t consumed = 0;
+	css_error error;
 
 	UNUSED(c);
 
@@ -6706,73 +6741,48 @@ css_error parse_unit_specifier(css_language *c,
 	num = number_from_lwc_string(token->idata, false, &consumed);
 
 	if (token->type == CSS_TOKEN_DIMENSION) {
-		if (lwc_string_length(token->idata) - consumed == 4) {
-			if (strncasecmp((char *) lwc_string_data(token->idata) + consumed, 
-					"grad", 4) == 0)
-				*unit = UNIT_GRAD;
-			else
-				return CSS_INVALID;
-		} else if (lwc_string_length(token->idata) - consumed == 3) {
-			if (strncasecmp((char *) lwc_string_data(token->idata) + consumed,
-					"kHz", 3) == 0)
-				*unit = UNIT_KHZ;
-			else if (strncasecmp((char *) lwc_string_data(token->idata) + 
-					consumed, "deg", 3) == 0)
-				*unit = UNIT_DEG;
-			else if (strncasecmp((char *) lwc_string_data(token->idata) + 
-					consumed, "rad", 3) == 0)
-				*unit = UNIT_RAD;
-			else
-				return CSS_INVALID;
-		} else if (lwc_string_length(token->idata) - consumed == 2) {
-			if (strncasecmp((char *) lwc_string_data(token->idata) + consumed,
-					"Hz", 2) == 0)
-				*unit = UNIT_HZ;
-			else if (strncasecmp((char *) lwc_string_data(token->idata) + 
-					consumed, "ms", 2) == 0)
-				*unit = UNIT_MS;
-			else if (strncasecmp((char *) lwc_string_data(token->idata) + 
-					consumed, "px", 2) == 0)
-				*unit = UNIT_PX;
-			else if (strncasecmp((char *) lwc_string_data(token->idata) + 
-					consumed, "ex", 2) == 0)
-				*unit = UNIT_EX;
-			else if (strncasecmp((char *) lwc_string_data(token->idata) + 
-					consumed, "em", 2) == 0)
-				*unit = UNIT_EM;
-			else if (strncasecmp((char *) lwc_string_data(token->idata) + 
-					consumed, "in", 2) == 0)
-				*unit = UNIT_IN;
-			else if (strncasecmp((char *) lwc_string_data(token->idata) + 
-					consumed, "cm", 2) == 0)
-				*unit = UNIT_CM;
-			else if (strncasecmp((char *) lwc_string_data(token->idata) + 
-					consumed, "mm", 2) == 0)
-				*unit = UNIT_MM;
-			else if (strncasecmp((char *) lwc_string_data(token->idata) + 
-					consumed, "pt", 2) == 0)
-				*unit = UNIT_PT;
-			else if (strncasecmp((char *) lwc_string_data(token->idata) + 
-					consumed, "pc", 2) == 0)
-				*unit = UNIT_PC;
-			else
-				return CSS_INVALID;
-		} else if (lwc_string_length(token->idata) - consumed == 1) {
-			if (strncasecmp((char *) lwc_string_data(token->idata) + consumed,
-					"s", 1) == 0)
-				*unit = UNIT_S;
+		size_t len = lwc_string_length(token->idata);
+		const char *data = lwc_string_data(token->idata);
+
+		error = parse_unit_keyword(data + consumed, len - consumed, 
+				unit);
+		if (error != CSS_OK)
+			return error;
+	} else if (token->type == CSS_TOKEN_NUMBER) {
+		/* Non-zero values are permitted in quirks mode */
+		if (num != 0) {
+			if (c->sheet->quirks_allowed)
+				c->sheet->quirks_used = true;
 			else
 				return CSS_INVALID;
-		} else
-			return CSS_INVALID;
-	} else if (token->type == CSS_TOKEN_NUMBER) {
-		/** \todo In quirks mode, non-zero units should be 
-		 * treated as default_unit too */
-		/** \todo also, in quirks mode, we need to cater for dimensions
-		 * separated from their units by whitespace (e.g. "0 px") */
-		if (num != 0)
-			return CSS_INVALID;
+		}
+
 		*unit = default_unit;
+
+		if (c->sheet->quirks_allowed) {
+			/* Also, in quirks mode, we need to cater for 
+			 * dimensions separated from their units by whitespace
+			 * (e.g. "0 px")
+			 */
+			int temp_ctx = *ctx;
+			uint32_t temp_unit;
+
+			consumeWhitespace(vector, &temp_ctx);
+
+			token = parserutils_vector_iterate(vector, &temp_ctx);
+			if (token != NULL && token->type == CSS_TOKEN_IDENT) {
+				error = parse_unit_keyword(
+						lwc_string_data(token->idata),
+						lwc_string_length(token->idata),
+						&temp_unit);
+				if (error == CSS_OK) {
+					c->sheet->quirks_used = true;
+					*ctx = temp_ctx;
+					*unit = temp_unit;
+				}
+			}
+		}
+
 	} else {
 		if (consumed != lwc_string_length(token->idata))
 			return CSS_INVALID;
@@ -6784,6 +6794,56 @@ css_error parse_unit_specifier(css_language *c,
 	return CSS_OK;
 }
 
+css_error parse_unit_keyword(const char *ptr, size_t len, css_unit *unit)
+{
+	if (len == 4) {
+		if (strncasecmp(ptr, "grad", 4) == 0)
+			*unit = UNIT_GRAD;
+		else
+			return CSS_INVALID;
+	} else if (len == 3) {
+		if (strncasecmp(ptr, "kHz", 3) == 0)
+			*unit = UNIT_KHZ;
+		else if (strncasecmp(ptr, "deg", 3) == 0)
+			*unit = UNIT_DEG;
+		else if (strncasecmp(ptr, "rad", 3) == 0)
+			*unit = UNIT_RAD;
+		else
+			return CSS_INVALID;
+	} else if (len == 2) {
+		if (strncasecmp(ptr, "Hz", 2) == 0)
+			*unit = UNIT_HZ;
+		else if (strncasecmp(ptr, "ms", 2) == 0)
+			*unit = UNIT_MS;
+		else if (strncasecmp(ptr, "px", 2) == 0)
+			*unit = UNIT_PX;
+		else if (strncasecmp(ptr, "ex", 2) == 0)
+			*unit = UNIT_EX;
+		else if (strncasecmp(ptr, "em", 2) == 0)
+			*unit = UNIT_EM;
+		else if (strncasecmp(ptr, "in", 2) == 0)
+			*unit = UNIT_IN;
+		else if (strncasecmp(ptr, "cm", 2) == 0)
+			*unit = UNIT_CM;
+		else if (strncasecmp(ptr, "mm", 2) == 0)
+			*unit = UNIT_MM;
+		else if (strncasecmp(ptr, "pt", 2) == 0)
+			*unit = UNIT_PT;
+		else if (strncasecmp(ptr, "pc", 2) == 0)
+			*unit = UNIT_PC;
+		else
+			return CSS_INVALID;
+	} else if (len == 1) {
+		if (strncasecmp(ptr, "s", 1) == 0)
+			*unit = UNIT_S;
+		else
+			return CSS_INVALID;
+	} else
+		return CSS_INVALID;
+
+	return CSS_OK;
+}
+
 css_error parse_border_side_color(css_language *c,
 		const parserutils_vector *vector, int *ctx,
 		uint16_t op, css_style **result)
diff --git a/src/stylesheet.c b/src/stylesheet.c
index 0344e47..e6dd5d9 100644
--- a/src/stylesheet.c
+++ b/src/stylesheet.c
@@ -26,6 +26,8 @@ static css_error _remove_selectors(css_stylesheet *sheet, css_rule *rule);
  * \param title            Title of stylesheet
  * \param origin           Origin of stylesheet
  * \param media            Media stylesheet applies to
+ * \param allow_quirks     Permit quirky parsing of stylesheets
+ * \param dict             Dictionary in which to intern strings
  * \param alloc            Memory (de)allocation function
  * \param alloc_pw         Client private data for alloc
  * \param stylesheet       Pointer to location to receive stylesheet
@@ -35,10 +37,11 @@ static css_error _remove_selectors(css_stylesheet *sheet, css_rule *rule);
  */
 css_error css_stylesheet_create(css_language_level level,
 		const char *charset, const char *url, const char *title,
-		css_origin origin, uint64_t media, lwc_context *dict,
-		css_allocator_fn alloc, void *alloc_pw, 
+		css_origin origin, uint64_t media, bool allow_quirks,
+		lwc_context *dict, css_allocator_fn alloc, void *alloc_pw, 
 		css_stylesheet **stylesheet)
 {
+	css_parser_optparams params;
 	css_error error;
 	css_stylesheet *sheet;
 	size_t len;
@@ -62,6 +65,19 @@ css_error css_stylesheet_create(css_language_level level,
 		return error;
 	}
 
+	sheet->quirks_allowed = allow_quirks;
+	if (allow_quirks) {
+		params.quirks = true;
+
+		error = css_parser_setopt(sheet->parser, CSS_PARSER_QUIRKS,
+				&params);
+		if (error != CSS_OK) {
+			css_parser_destroy(sheet->parser);
+			alloc(sheet, 0, alloc_pw);
+			return error;
+		}
+	}
+
 	sheet->level = level;
 	error = css_language_create(sheet, sheet->parser, alloc, alloc_pw,
 			&sheet->parser_frontend);
@@ -399,6 +415,41 @@ css_error css_stylesheet_get_media(css_stylesheet *sheet, uint64_t *media)
 }
 
 /**
+ * Determine whether quirky parsing was permitted on a stylesheet
+ *
+ * \param sheet   The stylesheet to consider
+ * \param quirks  Pointer to location to receive quirkyness
+ * \return CSS_OK on success, appropriate error otherwise
+ */
+css_error css_stylesheet_quirks_allowed(css_stylesheet *sheet, bool *allowed)
+{
+	if (sheet == NULL || allowed == NULL)
+		return CSS_BADPARM;
+
+	*allowed = sheet->quirks_allowed;
+
+	return CSS_OK;
+}
+
+
+/**
+ * Determine whether quirky parsing was used on a stylesheet
+ *
+ * \param sheet   The stylesheet to consider
+ * \param quirks  Pointer to location to receive quirkyness
+ * \return CSS_OK on success, appropriate error otherwise
+ */
+css_error css_stylesheet_used_quirks(css_stylesheet *sheet, bool *quirks)
+{
+	if (sheet == NULL || quirks == NULL)
+		return CSS_BADPARM;
+
+	*quirks = sheet->quirks_used;
+
+	return CSS_OK;
+}
+
+/**
  * Get disabled status of a stylesheet
  *
  * \param sheet     The stylesheet to consider
diff --git a/src/stylesheet.h b/src/stylesheet.h
index 0a859f2..4cb890e 100644
--- a/src/stylesheet.h
+++ b/src/stylesheet.h
@@ -170,6 +170,9 @@ struct css_stylesheet {
 
 	lwc_context *dictionary;		/**< String dictionary */
 
+	bool quirks_allowed;			/**< Quirks permitted */
+	bool quirks_used;			/**< Quirks actually used */
+
 	css_allocator_fn alloc;			/**< Allocation function */
 	void *pw;				/**< Private word */
 };
diff --git a/test/css21.c b/test/css21.c
index 93200f5..b19fc2e 100644
--- a/test/css21.c
+++ b/test/css21.c
@@ -43,8 +43,8 @@ int main(int argc, char **argv)
 	for (int count = 0; count < ITERATIONS; count++) {
 
 		assert(css_stylesheet_create(CSS_LEVEL_21, "UTF-8", argv[2], 
-				NULL, CSS_ORIGIN_AUTHOR, CSS_MEDIA_ALL, ctx,
-				myrealloc, NULL, &sheet) == CSS_OK);
+				NULL, CSS_ORIGIN_AUTHOR, CSS_MEDIA_ALL, false,
+				ctx, myrealloc, NULL, &sheet) == CSS_OK);
 
 		fp = fopen(argv[2], "rb");
 		if (fp == NULL) {
@@ -92,13 +92,14 @@ int main(int argc, char **argv)
 				css_stylesheet *import;
 				char buf[lwc_string_length(url) + 1];
 
-				memcpy(buf, lwc_string_data(url), lwc_string_length(url));
+				memcpy(buf, lwc_string_data(url), 
+						lwc_string_length(url));
 				buf[lwc_string_length(url)] = '\0';
 
 				assert(css_stylesheet_create(CSS_LEVEL_21,
 					"UTF-8", buf, NULL, CSS_ORIGIN_AUTHOR,
-					media, ctx, myrealloc, NULL, &import) == 
-					CSS_OK);
+					media, false, ctx, myrealloc, NULL, 
+					&import) == CSS_OK);
 
 				assert(css_stylesheet_data_done(import) == 
 					CSS_OK);
diff --git a/test/parse-auto.c b/test/parse-auto.c
index 5ed0f55..1bb868b 100644
--- a/test/parse-auto.c
+++ b/test/parse-auto.c
@@ -312,7 +312,7 @@ void run_test(const uint8_t *data, size_t len, exp_entry *exp, size_t explen)
         lwc_context_ref(ctx);
         
 	assert(css_stylesheet_create(CSS_LEVEL_21, "UTF-8", "foo", NULL,
-			CSS_ORIGIN_AUTHOR, CSS_MEDIA_ALL, ctx,
+			CSS_ORIGIN_AUTHOR, CSS_MEDIA_ALL, false, ctx,
 			myrealloc, NULL, &sheet) == CSS_OK);
 
 	error = css_stylesheet_append_data(sheet, data, len);
@@ -336,12 +336,13 @@ void run_test(const uint8_t *data, size_t len, exp_entry *exp, size_t explen)
 			css_stylesheet *import;
 			char buf[lwc_string_length(url) + 1];
 
-			memcpy(buf, lwc_string_data(url), lwc_string_length(url));
+			memcpy(buf, lwc_string_data(url), 
+					lwc_string_length(url));
 			buf[lwc_string_length(url)] = '\0';
 
 			assert(css_stylesheet_create(CSS_LEVEL_21,
 				"UTF-8", buf, NULL, CSS_ORIGIN_AUTHOR,
-				media, ctx, myrealloc, NULL, &import) == 
+				media, false, ctx, myrealloc, NULL, &import) == 
 				CSS_OK);
 
 			assert(css_stylesheet_register_import(sheet,
@@ -443,8 +444,7 @@ void validate_rule_selector(css_rule_selector *s, exp_entry *e, int testnum)
 			}
 
 			if (j != e->stused) {
-				lwc_string **p =
-						(void *) ((uint8_t *) 
+				lwc_string **p = (void *) ((uint8_t *) 
 						s->style->bytecode + i);
 
 				if (lwc_string_length(*p) != 
@@ -452,8 +452,10 @@ void validate_rule_selector(css_rule_selector *s, exp_entry *e, int testnum)
 					memcmp(lwc_string_data(*p), 
 						e->stringtab[j].string,
 						lwc_string_length(*p)) != 0) {
-					printf("%d: Got string '%.*s'. Expected '%s'\n",
-						testnum, (int) lwc_string_length(*p), 
+					printf("%d: Got string '%.*s'. "
+						"Expected '%s'\n",
+						testnum, 
+						(int) lwc_string_length(*p), 
 						lwc_string_data(*p), 
 						e->stringtab[j].string);
 					assert(0 && "Strings differ");
@@ -496,7 +498,8 @@ void validate_rule_import(css_rule_import *s, exp_entry *e, int testnum)
         if (strncmp(lwc_string_data(s->url), e->name,
                     lwc_string_length(s->url)) != 0) {
 		printf("%d: Got URL '%.*s'. Expected '%s'\n",
-                       testnum, (int) lwc_string_length(s->url), lwc_string_data(s->url),
+			testnum, (int) lwc_string_length(s->url), 
+			lwc_string_data(s->url),
 		e->name);
 		assert(0 && "Mismatched URLs");
 	}
@@ -547,7 +550,8 @@ void dump_selector_detail(css_selector_detail *detail, char **ptr)
 {
 	switch (detail->type) {
 	case CSS_SELECTOR_ELEMENT:
-		if (lwc_string_length(detail->name) == 1 && lwc_string_data(detail->name)[0] == '*' &&
+		if (lwc_string_length(detail->name) == 1 && 
+				lwc_string_data(detail->name)[0] == '*' &&
 				detail->next == 0) {
 			dump_string(detail->name, ptr);
 		} else if (lwc_string_length(detail->name) != 1 ||
@@ -628,6 +632,7 @@ void dump_selector_detail(css_selector_detail *detail, char **ptr)
 
 void dump_string(lwc_string *string, char **ptr)
 {
-	*ptr += sprintf(*ptr, "%.*s", (int) lwc_string_length(string), lwc_string_data(string));
+	*ptr += sprintf(*ptr, "%.*s", (int) lwc_string_length(string), 
+			lwc_string_data(string));
 }
 
diff --git a/test/parse2-auto.c b/test/parse2-auto.c
index aedc46b..dd3c529 100644
--- a/test/parse2-auto.c
+++ b/test/parse2-auto.c
@@ -176,7 +176,7 @@ void run_test(const uint8_t *data, size_t len, const char *exp, size_t explen)
         lwc_context_ref(ctx);
         
 	assert(css_stylesheet_create(CSS_LEVEL_21, "UTF-8", "foo", NULL,
-			CSS_ORIGIN_AUTHOR, CSS_MEDIA_ALL, ctx,
+			CSS_ORIGIN_AUTHOR, CSS_MEDIA_ALL, false, ctx,
 			myrealloc, NULL, &sheet) == CSS_OK);
 
 	error = css_stylesheet_append_data(sheet, data, len);
diff --git a/test/select-auto.c b/test/select-auto.c
index a0f0966..a4e6158 100644
--- a/test/select-auto.c
+++ b/test/select-auto.c
@@ -441,7 +441,8 @@ void parse_sheet(line_ctx *ctx, const char *data, size_t len)
 
 	/** \todo How are we going to handle @import? */
 	assert(css_stylesheet_create(CSS_LEVEL_21, "UTF-8", "foo", "foo", 
-			origin, media, ctx->dict, myrealloc, NULL, &sheet) == CSS_OK);
+			origin, media, false, ctx->dict, myrealloc, NULL, 
+			&sheet) == CSS_OK);
 
 	/* Extend array of sheets and append new sheet to it */
 	temp = realloc(ctx->sheets, 
@@ -697,7 +698,7 @@ css_error named_ancestor_node(void *pw, void *n,
 	for (node = node->parent; node != NULL; node = node->parent) {
                 bool match;
 		assert(lwc_context_string_caseless_isequal(ctx->dict,
-                                                           name, node->name, &match) == lwc_error_ok);
+				name, node->name, &match) == lwc_error_ok);
                 if (match == true)
 			break;
 	}
@@ -718,8 +719,8 @@ css_error named_parent_node(void *pw, void *n,
 	if (node->parent != NULL) {
                 bool match;
                 assert(lwc_context_string_caseless_isequal(ctx->dict,
-                                                           name, node->parent->name,
-                                                           &match) == lwc_error_ok);
+				name, node->parent->name, &match) == 
+				lwc_error_ok);
                 if (match == true)
                         *parent = (void *) node->parent;
         }
@@ -738,8 +739,8 @@ css_error named_sibling_node(void *pw, void *n,
 	if (node->prev != NULL) {
                 bool match;
                 assert(lwc_context_string_caseless_isequal(ctx->dict,
-                                                           name, node->prev->name,
-                                                           &match) == lwc_error_ok);
+				name, node->prev->name, &match) == 
+				lwc_error_ok);
                 if (match == true)
                         *sibling = (void *) node->prev;
         }
@@ -779,8 +780,9 @@ css_error node_has_class(void *pw, void *n,
 
 	for (i = 0; i < node->n_attrs; i++) {
                 bool amatch;
-                assert(lwc_context_string_caseless_isequal(ctx->dict, node->attrs[i].name,
-                                                           ctx->attr_class, &amatch) == lwc_error_ok);
+                assert(lwc_context_string_caseless_isequal(ctx->dict, 
+				node->attrs[i].name, ctx->attr_class, 
+				&amatch) == lwc_error_ok);
                 if (amatch == true)
 			break;
 	}
@@ -804,8 +806,9 @@ css_error node_has_id(void *pw, void *n,
 
 	for (i = 0; i < node->n_attrs; i++) {
                 bool amatch;
-                assert(lwc_context_string_caseless_isequal(ctx->dict, node->attrs[i].name,
-                                                           ctx->attr_id, &amatch) == lwc_error_ok);
+		assert(lwc_context_string_caseless_isequal(ctx->dict, 
+				node->attrs[i].name, ctx->attr_id, &amatch) == 
+				lwc_error_ok);
                 if (amatch == true)
 			break;
 	}
@@ -829,8 +832,9 @@ css_error node_has_attribute(void *pw, void *n,
         
         *match = false;
 	for (i = 0; i < node->n_attrs; i++) {
-                assert(lwc_context_string_caseless_isequal(ctx->dict, node->attrs[i].name,
-                                                           name, match) == lwc_error_ok);
+                assert(lwc_context_string_caseless_isequal(ctx->dict, 
+				node->attrs[i].name, name, match) == 
+				lwc_error_ok);
                 if (*match == true)
                         break;
 	}
@@ -850,15 +854,17 @@ css_error node_has_attribute_equal(void *pw, void *n,
         *match = false;
         
 	for (i = 0; i < node->n_attrs; i++) {
-                assert(lwc_context_string_caseless_isequal(ctx->dict, node->attrs[i].name,
-                                                           name, match) == lwc_error_ok);
+                assert(lwc_context_string_caseless_isequal(ctx->dict, 
+				node->attrs[i].name, name, match) == 
+				lwc_error_ok);
                 if (*match == true)
                         break;
 	}
         
         if (*match == true) {
-                assert(lwc_context_string_caseless_isequal(ctx->dict, node->attrs[i].name,
-                                                           value, match) == lwc_error_ok);
+                assert(lwc_context_string_caseless_isequal(ctx->dict, 
+				node->attrs[i].name, value, match) == 
+				lwc_error_ok);
         }
         
 	return CSS_OK;
@@ -877,8 +883,9 @@ css_error node_has_attribute_includes(void *pw, void *n,
         *match = false;
         
 	for (i = 0; i < node->n_attrs; i++) {
-                assert(lwc_context_string_caseless_isequal(ctx->dict, node->attrs[i].name,
-                                                           name, match) == lwc_error_ok);
+                assert(lwc_context_string_caseless_isequal(ctx->dict, 
+				node->attrs[i].name, name, match) == 
+				lwc_error_ok);
                 if (*match == true)
                         break;
 	}
@@ -886,7 +893,8 @@ css_error node_has_attribute_includes(void *pw, void *n,
 	if (*match == true) {
 		const char *p;
 		const char *start = lwc_string_data(node->attrs[i].value);
-		const char *end = start + lwc_string_length(node->attrs[i].value);
+		const char *end = start + 
+				lwc_string_length(node->attrs[i].value);
                 
                 *match = false;
                 
@@ -894,8 +902,8 @@ css_error node_has_attribute_includes(void *pw, void *n,
 			if (*p == ' ') {
 				if ((size_t) (p - start) == vlen && 
 						strncasecmp(start,
-                                                            lwc_string_data(value), 
-                                                            vlen) == 0) {
+							lwc_string_data(value),
+							vlen) == 0) {
 					*match = true;
 					break;
 				}
@@ -921,8 +929,9 @@ css_error node_has_attribute_dashmatch(void *pw, void *n,
         *match = false;
         
 	for (i = 0; i < node->n_attrs; i++) {
-                assert(lwc_context_string_caseless_isequal(ctx->dict, node->attrs[i].name,
-                                                           name, match) == lwc_error_ok);
+                assert(lwc_context_string_caseless_isequal(ctx->dict, 
+				node->attrs[i].name, name, match) == 
+				lwc_error_ok);
                 if (*match == true)
                         break;
 	}
@@ -930,7 +939,8 @@ css_error node_has_attribute_dashmatch(void *pw, void *n,
 	if (*match == true) {
 		const char *p;
 		const char *start = lwc_string_data(node->attrs[i].value);
-		const char *end = start + lwc_string_length(node->attrs[i].value);
+		const char *end = start + 
+				lwc_string_length(node->attrs[i].value);
                 
                 *match = false;
                 
@@ -938,8 +948,8 @@ css_error node_has_attribute_dashmatch(void *pw, void *n,
 			if (*p == '-') {
 				if ((size_t) (p - start) == vlen && 
 						strncasecmp(start,
-                                                            lwc_string_data(value), 
-                                                            vlen) == 0) {
+							lwc_string_data(value), 
+							vlen) == 0) {
 					*match = true;
 					break;
 				}