Various changes which modify API and ABI:

- Remove client allocation function.
- Change node_classes callback not to yield array ownership to libcss.
- Node bloom filters now built by, during selection libcss.
- Added selection callbacks to get and set data on document nodes.

Test suite, example, and documentation updated to match.

6 files changed, 36 insertions, 68 deletions

diff --git a/src/parse/font_face.c b/src/parse/font_face.c
index 14a715d..8eab006 100644
--- a/src/parse/font_face.c
+++ b/src/parse/font_face.c
@@ -228,9 +228,8 @@ static css_error font_face_parse_src(css_language *c,
 		/* This will be inefficient if there are a lot of locations - 
 		 * probably not a problem in practice.
 		 */
-		new_srcs = c->alloc(srcs, 
-				(n_srcs + 1) * sizeof(css_font_face_src),
-				c->pw);
+		new_srcs = realloc(srcs, 
+				(n_srcs + 1) * sizeof(css_font_face_src));
 		if (new_srcs == NULL) {
 			error = CSS_NOMEM;
 			goto cleanup;
@@ -252,7 +251,7 @@ cleanup:
 	if (error != CSS_OK) {
 		*ctx = orig_ctx;
 		if (srcs != NULL) 
-			c->alloc(srcs, 0, c->pw);
+			free(srcs);
 	}
 
 	return error;
@@ -382,8 +381,7 @@ css_error css__parse_font_descriptor(css_language *c,
 	bool match;
 
 	if (font_face == NULL) {
-		error = css__font_face_create(c->sheet->alloc, 
-			     c->sheet->pw, &font_face);
+		error = css__font_face_create(&font_face);
 		if (error != CSS_OK) {
 			return error;
 		}
diff --git a/src/parse/language.c b/src/parse/language.c
index 7003f0b..5dac773 100644
--- a/src/parse/language.c
+++ b/src/parse/language.c
@@ -108,34 +108,30 @@ static css_error parseProperty(css_language *c,
  *
  * \param sheet	    The stylesheet object to parse for
  * \param parser    The core parser object to use
- * \param alloc	    Memory (de)allocation function
- * \param pw	    Pointer to client-specific private data
  * \param language  Pointer to location to receive parser object
  * \return CSS_OK on success,
  *	   CSS_BADPARM on bad parameters,
  *	   CSS_NOMEM on memory exhaustion
  */
 css_error css__language_create(css_stylesheet *sheet, css_parser *parser,
-		css_allocator_fn alloc, void *pw, void **language)
+		void **language)
 {
 	css_language *c;
 	css_parser_optparams params;
 	parserutils_error perror;
 	css_error error;
 
-	if (sheet == NULL || parser == NULL || alloc == NULL || 
-			language == NULL)
+	if (sheet == NULL || parser == NULL || language == NULL)
 		return CSS_BADPARM;
 
-	c = alloc(NULL, sizeof(css_language), pw);
+	c = malloc(sizeof(css_language));
 	if (c == NULL)
 		return CSS_NOMEM;
 
 	perror = parserutils_stack_create(sizeof(context_entry), 
-			STACK_CHUNK, (parserutils_alloc) alloc, pw, 
-			&c->context);
+			STACK_CHUNK, css_alloc, CSS_ALLOC_PW, &c->context);
 	if (perror != PARSERUTILS_OK) {
-		alloc(c, 0, pw);
+		free(c);
 		return css_error_from_parserutils_error(perror);
 	}
 
@@ -144,7 +140,7 @@ css_error css__language_create(css_stylesheet *sheet, css_parser *parser,
 	error = css__parser_setopt(parser, CSS_PARSER_EVENT_HANDLER, &params);
 	if (error != CSS_OK) {
 		parserutils_stack_destroy(c->context);
-		alloc(c, 0, pw);
+		free(c);
 		return error;
 	}
 
@@ -154,8 +150,6 @@ css_error css__language_create(css_stylesheet *sheet, css_parser *parser,
 	c->namespaces = NULL;
 	c->num_namespaces = 0;
 	c->strings = sheet->propstrings;
-	c->alloc = alloc;
-	c->pw = pw;
 
 	*language = c;
 
@@ -184,12 +178,12 @@ css_error css__language_destroy(css_language *language)
 			lwc_string_unref(language->namespaces[i].uri);
 		}
 
-		language->alloc(language->namespaces, 0, language->pw);
+		free(language->namespaces);
 	}
 
 	parserutils_stack_destroy(language->context);
 	
-	language->alloc(language, 0, language->pw);
+	free(language);
 
 	return CSS_OK;
 }
@@ -914,10 +908,9 @@ css_error addNamespace(css_language *c, lwc_string *prefix, lwc_string *uri)
 
 		if (idx == c->num_namespaces) {
 			/* Not found, create a new mapping */
-			css_namespace *ns = c->alloc(c->namespaces, 
+			css_namespace *ns = realloc(c->namespaces, 
 					sizeof(css_namespace) * 
-						(c->num_namespaces + 1), 
-					c->pw);
+						(c->num_namespaces + 1));
 
 			if (ns == NULL)
 				return CSS_NOMEM;
diff --git a/src/parse/language.h b/src/parse/language.h
index efbfaa1..f7c8536 100644
--- a/src/parse/language.h
+++ b/src/parse/language.h
@@ -48,13 +48,10 @@ typedef struct css_language {
 	lwc_string *default_namespace;	/**< Default namespace URI */
 	css_namespace *namespaces;	/**< Array of namespace mappings */
 	uint32_t num_namespaces;	/**< Number of namespace mappings */
-
-	css_allocator_fn alloc;		/**< Memory (de)allocation function */
-	void *pw;			/**< Client's private data */
 } css_language;
 
 css_error css__language_create(css_stylesheet *sheet, css_parser *parser,
-		css_allocator_fn alloc, void *pw, void **language);
+		void **language);
 css_error css__language_destroy(css_language *language);
 
 /******************************************************************************
diff --git a/src/parse/parse.c b/src/parse/parse.c
index d8281ae..b52e9f1 100644
--- a/src/parse/parse.c
+++ b/src/parse/parse.c
@@ -105,14 +105,10 @@ struct css_parser
 
 	css_parser_event_handler event;	/**< Client's event handler */
 	void *event_pw;			/**< Client data for event handler */
-
-	css_allocator_fn alloc;		/**< Memory (de)allocation function */
-	void *pw;			/**< Client-specific private data */
 };
 
 static css_error css__parser_create_internal(const char *charset, 
-		css_charset_source cs_source,
-		css_allocator_fn alloc, void *pw, parser_state initial, 
+		css_charset_source cs_source, parser_state initial, 
 		css_parser **parser);
 
 static css_error transition(css_parser *parser, parser_state to,
@@ -190,21 +186,18 @@ static css_error (*parseFuncs[])(css_parser *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
  * \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_allocator_fn alloc, void *pw, 
 		css_parser **parser)
 {
 	parser_state initial = { sStart, 0 };
 
 	return css__parser_create_internal(charset, cs_source,
-			alloc, pw, initial, parser);
+			initial, parser);
 }
 
 /**
@@ -212,21 +205,18 @@ css_error css__parser_create(const char *charset, css_charset_source cs_source,
  *
  * \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
  * \return CSS_OK on success,
  *         CSS_BADPARM on bad parameters,
  *         CSS_NOMEM on memory exhaustion
  */
 css_error css__parser_create_for_inline_style(const char *charset,
-		css_charset_source cs_source,
-		css_allocator_fn alloc, void *pw, css_parser **parser)
+		css_charset_source cs_source, css_parser **parser)
 {
 	parser_state initial = { sInlineStyle, 0 };
 
 	return css__parser_create_internal(charset, cs_source,
-			alloc, pw, initial, parser);
+			initial, parser);
 }
 
 /**
@@ -250,7 +240,7 @@ css_error css__parser_destroy(css_parser *parser)
 
 	parserutils_inputstream_destroy(parser->stream);
 
-	parser->alloc(parser, 0, parser->pw);
+	free(parser);
 
 	return CSS_OK;
 }
@@ -390,8 +380,6 @@ bool css__parser_quirks_permitted(css_parser *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 initial     The required initial state of the parser
  * \param parser      Pointer to location to receive parser instance
  * \return CSS_OK on success,
@@ -399,66 +387,63 @@ bool css__parser_quirks_permitted(css_parser *parser)
  *         CSS_NOMEM on memory exhaustion
  */
 css_error css__parser_create_internal(const char *charset, 
-		css_charset_source cs_source,
-		css_allocator_fn alloc, void *pw, parser_state initial, 
+		css_charset_source cs_source, parser_state initial, 
 		css_parser **parser)
 {
 	css_parser *p;
 	parserutils_error perror;
 	css_error error;
 
-	if (alloc == NULL || parser == NULL)
+	if (parser == NULL)
 		return CSS_BADPARM;
 
-	p = alloc(NULL, sizeof(css_parser), pw);
+	p = malloc(sizeof(css_parser));
 	if (p == NULL)
 		return CSS_NOMEM;
 
 	perror = parserutils_inputstream_create(charset, cs_source,
-			css__charset_extract, (parserutils_alloc) alloc, pw,
+			css__charset_extract, css_alloc, CSS_ALLOC_PW,
 			&p->stream);
 	if (perror != PARSERUTILS_OK) {
-		alloc(p, 0, pw);
+		free(p);
 		return css_error_from_parserutils_error(perror);
 	}
 
-	error = css__lexer_create(p->stream, alloc, pw, &p->lexer);
+	error = css__lexer_create(p->stream, &p->lexer);
 	if (error != CSS_OK) {
 		parserutils_inputstream_destroy(p->stream);
-		alloc(p, 0, pw);
+		free(p);
 		return error;
 	}
 
 	perror = parserutils_stack_create(sizeof(parser_state), 
-			STACK_CHUNK, (parserutils_alloc) alloc, pw,
+			STACK_CHUNK, css_alloc, CSS_ALLOC_PW,
 			&p->states);
 	if (perror != PARSERUTILS_OK) {
 		css__lexer_destroy(p->lexer);
 		parserutils_inputstream_destroy(p->stream);
-		alloc(p, 0, pw);
+		free(p);
 		return css_error_from_parserutils_error(perror);
 	}
 
 	perror = parserutils_vector_create(sizeof(css_token), 
-			STACK_CHUNK, (parserutils_alloc) alloc, pw,
-			&p->tokens);
+			STACK_CHUNK, css_alloc, CSS_ALLOC_PW, &p->tokens);
 	if (perror != PARSERUTILS_OK) {
 		parserutils_stack_destroy(p->states);
 		css__lexer_destroy(p->lexer);
 		parserutils_inputstream_destroy(p->stream);
-		alloc(p, 0, pw);
+		free(p);
 		return css_error_from_parserutils_error(perror);
 	}
 
 	perror = parserutils_stack_create(sizeof(char), 
-			STACK_CHUNK, (parserutils_alloc) alloc, pw,
-			&p->open_items);
+			STACK_CHUNK, css_alloc, CSS_ALLOC_PW, &p->open_items);
 	if (perror != PARSERUTILS_OK) {
 		parserutils_vector_destroy(p->tokens);
 		parserutils_stack_destroy(p->states);
 		css__lexer_destroy(p->lexer);
 		parserutils_inputstream_destroy(p->stream);
-		alloc(p, 0, pw);
+		free(p);
 		return css_error_from_parserutils_error(perror);
 	}
 
@@ -469,7 +454,7 @@ css_error css__parser_create_internal(const char *charset,
 		parserutils_stack_destroy(p->states);
 		css__lexer_destroy(p->lexer);
 		parserutils_inputstream_destroy(p->stream);
-		alloc(p, 0, pw);
+		free(p);
 		return css_error_from_parserutils_error(perror);
 	}
 
@@ -480,8 +465,6 @@ css_error css__parser_create_internal(const char *charset,
 	p->event = NULL;
 	p->last_was_ws = false;
 	p->event_pw = NULL;
-	p->alloc = alloc;
-	p->pw = pw;
 
 	*parser = p;
 
diff --git a/src/parse/parse.h b/src/parse/parse.h
index e9dbe64..6b95acb 100644
--- a/src/parse/parse.h
+++ b/src/parse/parse.h
@@ -58,11 +58,9 @@ typedef union css_parser_optparams {
 } css_parser_optparams;
 
 css_error css__parser_create(const char *charset, css_charset_source cs_source,
-		css_allocator_fn alloc, void *pw, 
 		css_parser **parser);
 css_error css__parser_create_for_inline_style(const char *charset, 
-		css_charset_source cs_source,
-		css_allocator_fn alloc, void *pw, css_parser **parser);
+		css_charset_source cs_source, css_parser **parser);
 css_error css__parser_destroy(css_parser *parser);
 
 css_error css__parser_setopt(css_parser *parser, css_parser_opttype type,
diff --git a/src/parse/properties/utils.c b/src/parse/properties/utils.c
index e018599..4e43c8c 100644
--- a/src/parse/properties/utils.c
+++ b/src/parse/properties/utils.c
@@ -1118,8 +1118,7 @@ css_error css__ident_list_to_string(css_language *c,
 	lwc_string *interned;
 	lwc_error lerror;
 
-	perror = parserutils_buffer_create((parserutils_alloc) c->alloc, 
-			c->pw, &buffer);
+	perror = parserutils_buffer_create(css_alloc, CSS_ALLOC_PW, &buffer);
 	if (perror != PARSERUTILS_OK)
 		return css_error_from_parserutils_error(perror);