Port libcss to new lpu API.

Make lexer, core parser, and css21 parser constructors&destructors return errors

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

10 files changed, 174 insertions, 144 deletions

diff --git a/src/lex/lex.c b/src/lex/lex.c
index 460cca0..29291cf 100644
--- a/src/lex/lex.c
+++ b/src/lex/lex.c
@@ -174,19 +174,22 @@ static inline bool isSpace(uint8_t c);
  * \param input  The inputstream to read from
  * \param alloc  Memory (de)allocation function
  * \param pw     Pointer to client-specific private data
- * \return Pointer to instance, or NULL on memory exhaustion
+ * \param lexer  Pointer to location to receive lexer instance
+ * \return CSS_OK on success,
+ *         CSS_BADPARM on bad parameters,
+ *         CSS_NOMEM on memory exhaustion
  */
-css_lexer *css_lexer_create(parserutils_inputstream *input, 
-		css_alloc alloc, void *pw)
+css_error css_lexer_create(parserutils_inputstream *input, 
+		css_alloc alloc, void *pw, css_lexer **lexer)
 {
 	css_lexer *lex;
 
-	if (input == NULL || alloc == NULL)
-		return NULL;
+	if (input == NULL || alloc == NULL || lexer == NULL)
+		return CSS_BADPARM;
 
 	lex = alloc(NULL, sizeof(css_lexer), pw);
 	if (lex == NULL)
-		return NULL;
+		return CSS_NOMEM;
 
 	lex->input = input;
 	lex->bytesReadForToken = 0;
@@ -203,23 +206,28 @@ css_lexer *css_lexer_create(parserutils_inputstream *input,
 	lex->alloc = alloc;
 	lex->pw = pw;
 
-	return lex;
+	*lexer = lex;
+
+	return CSS_OK;
 }
 
 /**
  * Destroy a lexer instance
  *
  * \param lexer  The instance to destroy
+ * \return CSS_OK on success, appropriate error otherwise
  */
-void css_lexer_destroy(css_lexer *lexer)
+css_error css_lexer_destroy(css_lexer *lexer)
 {
 	if (lexer == NULL)
-		return;
+		return CSS_BADPARM;
 
 	if (lexer->unescapedTokenData != NULL)
 		parserutils_buffer_destroy(lexer->unescapedTokenData);
 
 	lexer->alloc(lexer, 0, lexer->pw);
+
+	return CSS_OK;
 }
 
 /**
@@ -1689,10 +1697,11 @@ css_error consumeEscape(css_lexer *lexer, bool nl)
 
 	/* Create unescaped buffer, if it doesn't already exist */
 	if (lexer->unescapedTokenData == NULL) {
-		lexer->unescapedTokenData = 
-			parserutils_buffer_create(lexer->alloc, lexer->pw);
-		if (lexer->unescapedTokenData == NULL)
-			return CSS_NOMEM;
+		parserutils_error err =
+			parserutils_buffer_create(lexer->alloc, lexer->pw,
+			&lexer->unescapedTokenData);
+		if (err != PARSERUTILS_OK)
+			return css_error_from_parserutils_error(err);
 	}
 
 	/* If this is the first escaped character we've seen for this token,
diff --git a/src/lex/lex.h b/src/lex/lex.h
index 6bfba6d..5fed823 100644
--- a/src/lex/lex.h
+++ b/src/lex/lex.h
@@ -57,9 +57,9 @@ typedef struct css_token {
 	uint32_t line;
 } css_token;
 
-css_lexer *css_lexer_create(parserutils_inputstream *input, 
-		css_alloc alloc, void *pw);
-void css_lexer_destroy(css_lexer *lexer);
+css_error css_lexer_create(parserutils_inputstream *input, 
+		css_alloc alloc, void *pw, css_lexer **lexer);
+css_error css_lexer_destroy(css_lexer *lexer);
 
 css_error css_lexer_setopt(css_lexer *lexer, css_lexer_opttype type, 
 		css_lexer_optparams *params);
diff --git a/src/parse/css21.c b/src/parse/css21.c
index e3031b7..fa98897 100644
--- a/src/parse/css21.c
+++ b/src/parse/css21.c
@@ -337,72 +337,82 @@ static inline bool tokenIsChar(const css_token *token, uint8_t c);
  * \param parser  The core parser object to use
  * \param alloc   Memory (de)allocation function
  * \param pw      Pointer to client-specific private data
- * \return Pointer to parser object, or NULL on failure
+ * \param css21   Pointer to location to receive parser object
+ * \return CSS_OK on success,
+ *         CSS_BADPARM on bad parameters,
+ *         CSS_NOMEM on memory exhaustion
  */
-css_css21 *css_css21_create(css_stylesheet *sheet, css_parser *parser,
-		css_alloc alloc, void *pw)
+css_error css_css21_create(css_stylesheet *sheet, css_parser *parser,
+		css_alloc alloc, void *pw, void **css21)
 {
-	css_css21 *css21;
+	css_css21 *c;
 	css_parser_optparams params;
+	parserutils_error perror;
 	css_error error;
 
-	if (sheet == NULL || parser == NULL || alloc == NULL)
-		return NULL;
+	if (sheet == NULL || parser == NULL || alloc == NULL || css21 == NULL)
+		return CSS_BADPARM;
 
-	css21 = alloc(NULL, sizeof(css_css21), pw);
-	if (css21 == NULL)
-		return NULL;
+	c = alloc(NULL, sizeof(css_css21), pw);
+	if (c == NULL)
+		return CSS_NOMEM;
 
-	css21->context = parserutils_stack_create(sizeof(context_entry), 
-			STACK_CHUNK, (parserutils_alloc) alloc, pw);
-	if (css21->context == NULL) {
-		alloc(css21, 0, pw);
-		return NULL;
+	perror = parserutils_stack_create(sizeof(context_entry), 
+			STACK_CHUNK, (parserutils_alloc) alloc, pw, 
+			&c->context);
+	if (perror != PARSERUTILS_OK) {
+		alloc(c, 0, pw);
+		return css_error_from_parserutils_error(perror);
 	}
 
 	/* Intern all known strings */
 	for (int i = 0; i < LAST_KNOWN; i++) {
-		css21->strings[i] = css_parser_dict_add(parser,
+		c->strings[i] = css_parser_dict_add(parser,
 				(const uint8_t *) stringmap[i].ptr, 
 				stringmap[i].len);
-		if (css21->strings[i] == NULL) {
-			parserutils_stack_destroy(css21->context);
-			alloc(css21, 0, pw);
-			return NULL;
+		if (c->strings[i] == NULL) {
+			parserutils_stack_destroy(c->context);
+			alloc(c, 0, pw);
+			return CSS_NOMEM;
 		}
 	}
 
 	params.event_handler.handler = css21_handle_event;
-	params.event_handler.pw = css21;
+	params.event_handler.pw = c;
 	error = css_parser_setopt(parser, CSS_PARSER_EVENT_HANDLER, &params);
 	if (error != CSS_OK) {
-		parserutils_stack_destroy(css21->context);
-		alloc(css21, 0, pw);
-		return NULL;
+		parserutils_stack_destroy(c->context);
+		alloc(c, 0, pw);
+		return error;
 	}
 
-	css21->sheet = sheet;
-	css21->parser = parser;
-	css21->state = BEFORE_CHARSET;
-	css21->alloc = alloc;
-	css21->pw = pw;
+	c->sheet = sheet;
+	c->parser = parser;
+	c->state = BEFORE_CHARSET;
+	c->alloc = alloc;
+	c->pw = pw;
+
+	*css21 = c;
 
-	return css21;
+	return CSS_OK;
 }
 
 /**
  * Destroy a CSS 2.1 parser
  *
  * \param css21  The parser to destroy
+ * \return CSS_OK on success, appropriate error otherwise
  */
-void css_css21_destroy(css_css21 *css21)
+css_error css_css21_destroy(css_css21 *css21)
 {
 	if (css21 == NULL)
-		return;
+		return CSS_BADPARM;
 
 	parserutils_stack_destroy(css21->context);
 
 	css21->alloc(css21, 0, css21->pw);
+
+	return CSS_OK;
 }
 
 /**
diff --git a/src/parse/css21.h b/src/parse/css21.h
index c1b1fda..8951308 100644
--- a/src/parse/css21.h
+++ b/src/parse/css21.h
@@ -17,9 +17,9 @@
 
 typedef struct css_css21 css_css21;
 
-css_css21 *css_css21_create(css_stylesheet *sheet, css_parser *parser,
-		css_alloc alloc, void *pw);
-void css_css21_destroy(css_css21 *css21);
+css_error css_css21_create(css_stylesheet *sheet, css_parser *parser,
+		css_alloc alloc, void *pw, void **css21);
+css_error css_css21_destroy(css_css21 *css21);
 
 #endif
 
diff --git a/src/parse/parse.c b/src/parse/parse.c
index 4c3f3bc..3976c0c 100644
--- a/src/parse/parse.c
+++ b/src/parse/parse.c
@@ -178,110 +178,121 @@ static css_error (*parseFuncs[])(css_parser *parser) = {
  * \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
- * \return Pointer to parser instance, or NULL on memory exhaustion
+ * \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_parser *css_parser_create(const char *charset, css_charset_source cs_source,
-		css_alloc alloc, void *pw)
+css_error css_parser_create(const char *charset, css_charset_source cs_source,
+		css_alloc alloc, void *pw, css_parser **parser)
 {
-	css_parser *parser;
+	css_parser *p;
 	parser_state initial = { sStart, 0 };
 	parserutils_error perror;
+	css_error error;
 
-	if (alloc == NULL)
-		return NULL;
+	if (alloc == NULL || parser == NULL)
+		return CSS_BADPARM;
 
-	parser = alloc(NULL, sizeof(css_parser), pw);
-	if (parser == NULL)
-		return NULL;
+	p = alloc(NULL, sizeof(css_parser), pw);
+	if (p == NULL)
+		return CSS_NOMEM;
 
-	parser->stream = parserutils_inputstream_create(charset, cs_source,
-			css_charset_extract, (parserutils_alloc) alloc, pw);
-	if (parser->stream == NULL) {
-		alloc(parser, 0, pw);
-		return NULL;
+	perror = parserutils_inputstream_create(charset, cs_source,
+			css_charset_extract, (parserutils_alloc) alloc, pw,
+			&p->stream);
+	if (perror != PARSERUTILS_OK) {
+		alloc(p, 0, pw);
+		return css_error_from_parserutils_error(perror);
 	}
 
-	parser->lexer = css_lexer_create(parser->stream, alloc, pw);
-	if (parser->lexer == NULL) {
-		parserutils_inputstream_destroy(parser->stream);
-		alloc(parser, 0, pw);
-		return NULL;
+	error = css_lexer_create(p->stream, alloc, pw, &p->lexer);
+	if (error != CSS_OK) {
+		parserutils_inputstream_destroy(p->stream);
+		alloc(p, 0, pw);
+		return error;
 	}
 
-	parser->states = parserutils_stack_create(sizeof(parser_state), 
-			STACK_CHUNK, (parserutils_alloc) alloc, pw);
-	if (parser->states == NULL) {
-		css_lexer_destroy(parser->lexer);
-		parserutils_inputstream_destroy(parser->stream);
-		alloc(parser, 0, pw);
-		return NULL;
+	perror = parserutils_stack_create(sizeof(parser_state), 
+			STACK_CHUNK, (parserutils_alloc) alloc, pw,
+			&p->states);
+	if (perror != PARSERUTILS_OK) {
+		css_lexer_destroy(p->lexer);
+		parserutils_inputstream_destroy(p->stream);
+		alloc(p, 0, pw);
+		return css_error_from_parserutils_error(perror);
 	}
 
-	parser->dictionary = parserutils_dict_create(
-			(parserutils_alloc) alloc, pw);
-	if (parser->dictionary == NULL) {
-		parserutils_stack_destroy(parser->states);
-		css_lexer_destroy(parser->lexer);
-		parserutils_inputstream_destroy(parser->stream);
-		alloc(parser, 0, pw);
-		return NULL;
+	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);
 	}
 
-	parser->tokens = parserutils_vector_create(sizeof(css_token), 
-			STACK_CHUNK, (parserutils_alloc) alloc, pw);
-	if (parser->tokens == NULL) {
-		parserutils_dict_destroy(parser->dictionary);
-		parserutils_stack_destroy(parser->states);
-		css_lexer_destroy(parser->lexer);
-		parserutils_inputstream_destroy(parser->stream);
-		alloc(parser, 0, pw);
-		return NULL;
+	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);
+		alloc(p, 0, pw);
+		return css_error_from_parserutils_error(perror);
 	}
 
-	parser->open_items = parserutils_stack_create(sizeof(char), 
-			STACK_CHUNK, (parserutils_alloc) alloc, pw);
-	if (parser->open_items == NULL) {
-		parserutils_vector_destroy(parser->tokens);
-		parserutils_stack_destroy(parser->states);
-		css_lexer_destroy(parser->lexer);
-		parserutils_inputstream_destroy(parser->stream);
-		alloc(parser, 0, pw);
-		return NULL;
+	perror = parserutils_stack_create(sizeof(char), 
+			STACK_CHUNK, (parserutils_alloc) 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);
+		return css_error_from_parserutils_error(perror);
 	}
 
-	perror = parserutils_stack_push(parser->states, (void *) &initial);
+	perror = parserutils_stack_push(p->states, (void *) &initial);
 	if (perror != PARSERUTILS_OK) {
-		parserutils_stack_destroy(parser->open_items);
-		parserutils_vector_destroy(parser->tokens);
-		parserutils_dict_destroy(parser->dictionary);
-		parserutils_stack_destroy(parser->states);
-		css_lexer_destroy(parser->lexer);
-		parserutils_inputstream_destroy(parser->stream);
-		alloc(parser, 0, pw);
-		return NULL;
+		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);
+		alloc(p, 0, pw);
+		return css_error_from_parserutils_error(perror);
 	}
 
-	parser->quirks = false;
-	parser->pushback = NULL;
-	parser->parseError = false;
-	parser->match_char = 0;
-	parser->event = NULL;
-	parser->event_pw = NULL;
-	parser->alloc = alloc;
-	parser->pw = pw;
+	p->quirks = false;
+	p->pushback = NULL;
+	p->parseError = false;
+	p->match_char = 0;
+	p->event = NULL;
+	p->event_pw = NULL;
+	p->alloc = alloc;
+	p->pw = pw;
+
+	*parser = p;
 
-	return parser;
+	return CSS_OK;
 }
 
 /**
  * Destroy a CSS parser
  *
  * \param parser  The parser instance to destroy
+ * \return CSS_OK on success, appropriate error otherwise
  */
-void css_parser_destroy(css_parser *parser)
+css_error css_parser_destroy(css_parser *parser)
 {
 	if (parser == NULL)
-		return;
+		return CSS_BADPARM;
 
 	parserutils_stack_destroy(parser->open_items);
 
@@ -296,6 +307,8 @@ void css_parser_destroy(css_parser *parser)
 	parserutils_inputstream_destroy(parser->stream);
 
 	parser->alloc(parser, 0, parser->pw);
+
+	return CSS_OK;
 }
 
 /**
diff --git a/src/parse/parse.h b/src/parse/parse.h
index 29f5a0b..c2396cb 100644
--- a/src/parse/parse.h
+++ b/src/parse/parse.h
@@ -55,9 +55,9 @@ typedef union css_parser_optparams {
 	} event_handler;
 } css_parser_optparams;
 
-css_parser *css_parser_create(const char *charset, css_charset_source cs_source,
-		css_alloc alloc, void *pw);
-void css_parser_destroy(css_parser *parser);
+css_error css_parser_create(const char *charset, css_charset_source cs_source,
+		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,
 		css_parser_optparams *params);
diff --git a/src/stylesheet.c b/src/stylesheet.c
index 9be6d70..333a650 100644
--- a/src/stylesheet.c
+++ b/src/stylesheet.c
@@ -33,6 +33,7 @@ css_stylesheet *css_stylesheet_create(css_language_level level,
 		css_import_handler import_callback, void *import_pw,
 		css_alloc alloc, void *alloc_pw)
 {
+	css_error error;
 	css_stylesheet *sheet;
 	size_t len;
 
@@ -45,10 +46,10 @@ css_stylesheet *css_stylesheet_create(css_language_level level,
 
 	memset(sheet, 0, sizeof(css_stylesheet));
 
-	sheet->parser = css_parser_create(charset, 
+	error = css_parser_create(charset, 
 			charset ? CSS_CHARSET_DICTATED : CSS_CHARSET_DEFAULT,
-			alloc, alloc_pw);
-	if (sheet->parser == NULL) {
+			alloc, alloc_pw, &sheet->parser);
+	if (error != CSS_OK) {
 		alloc(sheet, 0, alloc_pw);
 		return NULL;
 	}
@@ -61,9 +62,9 @@ css_stylesheet *css_stylesheet_create(css_language_level level,
 	}
 
 	sheet->level = level;
-	sheet->parser_frontend = 
-			css_css21_create(sheet, sheet->parser, alloc, alloc_pw);
-	if (sheet->parser_frontend == NULL) {
+	error = css_css21_create(sheet, sheet->parser, alloc, alloc_pw,
+			&sheet->parser_frontend);
+	if (error != CSS_OK) {
 		css_parser_destroy(sheet->parser);
 		alloc(sheet, 0, alloc_pw);
 		return NULL;
diff --git a/test/lex-auto.c b/test/lex-auto.c
index 98d0871..d336480 100644
--- a/test/lex-auto.c
+++ b/test/lex-auto.c
@@ -271,12 +271,11 @@ void run_test(const uint8_t *data, size_t len, exp_entry *exp, size_t explen)
 	size_t e;
 	static int testnum;
 
-	input = parserutils_inputstream_create("UTF-8", CSS_CHARSET_DICTATED,
-			css_charset_extract, myrealloc, NULL);
-	assert(input != NULL);
+	assert(parserutils_inputstream_create("UTF-8", CSS_CHARSET_DICTATED,
+			css_charset_extract, myrealloc, NULL, &input) ==
+			PARSERUTILS_OK);
 
-	lexer = css_lexer_create(input, myrealloc, NULL);
-	assert(lexer != NULL);
+	assert(css_lexer_create(input, myrealloc, NULL, &lexer) == CSS_OK);
 
 	assert(parserutils_inputstream_append(input, data, len) == 
 			PARSERUTILS_OK);
diff --git a/test/lex.c b/test/lex.c
index cba2d8f..86c1c01 100644
--- a/test/lex.c
+++ b/test/lex.c
@@ -129,13 +129,12 @@ int main(int argc, char **argv)
 	/* Initialise library */
 	assert(css_initialise(argv[1], myrealloc, NULL) == CSS_OK);
 
-	stream = parserutils_inputstream_create("UTF-8", CSS_CHARSET_DICTATED,
+	assert(parserutils_inputstream_create("UTF-8", CSS_CHARSET_DICTATED,
 			css_charset_extract, 
-			(parserutils_alloc) myrealloc, NULL);
-	assert(stream != NULL);
+			(parserutils_alloc) myrealloc, NULL, &stream) == 
+			PARSERUTILS_OK);
 
-	lexer = css_lexer_create(stream, myrealloc, NULL);
-	assert(lexer != NULL);
+	assert(css_lexer_create(stream, myrealloc, NULL, &lexer) == CSS_OK);
 
 	fp = fopen(argv[2], "rb");
 	if (fp == NULL) {
diff --git a/test/parse.c b/test/parse.c
index 1752dc2..4ff9a6e 100644
--- a/test/parse.c
+++ b/test/parse.c
@@ -86,9 +86,8 @@ int main(int argc, char **argv)
 	/* Initialise library */
 	assert(css_initialise(argv[1], myrealloc, NULL) == CSS_OK);
 
-	parser = css_parser_create("UTF-8", CSS_CHARSET_DICTATED, 
-			myrealloc, NULL);
-	assert(parser != NULL);
+	assert(css_parser_create("UTF-8", CSS_CHARSET_DICTATED, 
+			myrealloc, NULL, &parser) == CSS_OK);
 
 	params.event_handler.handler = event_handler;
 	params.event_handler.pw = NULL;