diff options
33 files changed, 482 insertions, 342 deletions
diff --git a/include/parserutils/charset/codec.h b/include/parserutils/charset/codec.h index 9bf2ce7..d79740b 100644 --- a/include/parserutils/charset/codec.h +++ b/include/parserutils/charset/codec.h @@ -84,10 +84,12 @@ typedef union parserutils_charset_codec_optparams { /* Create a charset codec */ -parserutils_charset_codec *parserutils_charset_codec_create(const char *charset, - parserutils_alloc alloc, void *pw); +parserutils_error parserutils_charset_codec_create(const char *charset, + parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec); /* Destroy a charset codec */ -void parserutils_charset_codec_destroy(parserutils_charset_codec *codec); +parserutils_error parserutils_charset_codec_destroy( + parserutils_charset_codec *codec); /* Configure a charset codec */ parserutils_error parserutils_charset_codec_setopt( diff --git a/include/parserutils/errors.h b/include/parserutils/errors.h index 09c715c..632d334 100644 --- a/include/parserutils/errors.h +++ b/include/parserutils/errors.h @@ -18,6 +18,7 @@ typedef enum parserutils_error { PARSERUTILS_INVALID = 3, PARSERUTILS_FILENOTFOUND = 4, PARSERUTILS_NEEDDATA = 5, + PARSERUTILS_BADENCODING = 6, } parserutils_error; /* Convert a parserutils error value to a string */ diff --git a/include/parserutils/input/inputstream.h b/include/parserutils/input/inputstream.h index 3bf51aa..bf1911d 100644 --- a/include/parserutils/input/inputstream.h +++ b/include/parserutils/input/inputstream.h @@ -46,11 +46,13 @@ typedef struct parserutils_inputstream #define PARSERUTILS_INPUTSTREAM_OOD (0xFFFFFFFEU) /* Create an input stream */ -parserutils_inputstream *parserutils_inputstream_create(const char *enc, +parserutils_error parserutils_inputstream_create(const char *enc, uint32_t encsrc, parserutils_charset_detect_func csdetect, - parserutils_alloc alloc, void *pw); + parserutils_alloc alloc, void *pw, + parserutils_inputstream **stream); /* Destroy an input stream */ -void parserutils_inputstream_destroy(parserutils_inputstream *stream); +parserutils_error parserutils_inputstream_destroy( + parserutils_inputstream *stream); /* Append data to an input stream */ parserutils_error parserutils_inputstream_append( diff --git a/include/parserutils/utils/buffer.h b/include/parserutils/utils/buffer.h index 96053a3..c988564 100644 --- a/include/parserutils/utils/buffer.h +++ b/include/parserutils/utils/buffer.h @@ -22,9 +22,9 @@ struct parserutils_buffer }; typedef struct parserutils_buffer parserutils_buffer; -parserutils_buffer *parserutils_buffer_create(parserutils_alloc alloc, - void *pw); -void parserutils_buffer_destroy(parserutils_buffer *buffer); +parserutils_error parserutils_buffer_create(parserutils_alloc alloc, + void *pw, parserutils_buffer **buffer); +parserutils_error parserutils_buffer_destroy(parserutils_buffer *buffer); parserutils_error parserutils_buffer_append(parserutils_buffer *buffer, const uint8_t *data, size_t len); diff --git a/include/parserutils/utils/stack.h b/include/parserutils/utils/stack.h index e9fad5a..26262eb 100644 --- a/include/parserutils/utils/stack.h +++ b/include/parserutils/utils/stack.h @@ -16,9 +16,9 @@ struct parserutils_stack; typedef struct parserutils_stack parserutils_stack; -parserutils_stack *parserutils_stack_create(size_t item_size, size_t chunk_size, - parserutils_alloc alloc, void *pw); -void parserutils_stack_destroy(parserutils_stack *stack); +parserutils_error parserutils_stack_create(size_t item_size, size_t chunk_size, + parserutils_alloc alloc, void *pw, parserutils_stack **stack); +parserutils_error parserutils_stack_destroy(parserutils_stack *stack); parserutils_error parserutils_stack_push(parserutils_stack *stack, void *item); parserutils_error parserutils_stack_pop(parserutils_stack *stack, void *item); diff --git a/include/parserutils/utils/vector.h b/include/parserutils/utils/vector.h index 6bfd0fe..77340bc 100644 --- a/include/parserutils/utils/vector.h +++ b/include/parserutils/utils/vector.h @@ -16,9 +16,10 @@ struct parserutils_vector; typedef struct parserutils_vector parserutils_vector; -parserutils_vector *parserutils_vector_create(size_t item_size, - size_t chunk_size, parserutils_alloc alloc, void *pw); -void parserutils_vector_destroy(parserutils_vector *vector); +parserutils_error parserutils_vector_create(size_t item_size, + size_t chunk_size, parserutils_alloc alloc, void *pw, + parserutils_vector **vector); +parserutils_error parserutils_vector_destroy(parserutils_vector *vector); parserutils_error parserutils_vector_append(parserutils_vector *vector, void *item); diff --git a/src/charset/codec.c b/src/charset/codec.c index 1dc436d..ea1fc7e 100644 --- a/src/charset/codec.c +++ b/src/charset/codec.c @@ -31,23 +31,29 @@ static parserutils_charset_handler *handler_table[] = { * \param charset Target charset * \param alloc Memory (de)allocation function * \param pw Pointer to client-specific private data (may be NULL) - * \return Pointer to codec instance, or NULL on failure + * \param codec Pointer to location to receive codec instance + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters, + * PARSERUTILS_NOMEM on memory exhaustion, + * PARSERUTILS_BADENCODING on unsupported charset */ -parserutils_charset_codec *parserutils_charset_codec_create(const char *charset, - parserutils_alloc alloc, void *pw) +parserutils_error parserutils_charset_codec_create(const char *charset, + parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec) { - parserutils_charset_codec *codec; + parserutils_charset_codec *c; parserutils_charset_handler **handler; const parserutils_charset_aliases_canon * canon; + parserutils_error error; - if (charset == NULL || alloc == NULL) - return NULL; + if (charset == NULL || alloc == NULL || codec == NULL) + return PARSERUTILS_BADPARM; /* Canonicalise parserutils_charset name. */ canon = parserutils_charset_alias_canonicalise(charset, strlen(charset)); if (canon == NULL) - return NULL; + return PARSERUTILS_BADENCODING; /* Search for handler class */ for (handler = handler_table; *handler != NULL; handler++) { @@ -57,37 +63,43 @@ parserutils_charset_codec *parserutils_charset_codec_create(const char *charset, /* None found */ if ((*handler) == NULL) - return NULL; + return PARSERUTILS_BADENCODING; /* Instantiate class */ - codec = (*handler)->create(canon->name, alloc, pw); - if (codec == NULL) - return NULL; + error = (*handler)->create(canon->name, alloc, pw, &c); + if (error != PARSERUTILS_OK) + return error; /* and initialise it */ - codec->mibenum = canon->mib_enum; + c->mibenum = canon->mib_enum; + + c->errormode = PARSERUTILS_CHARSET_CODEC_ERROR_LOOSE; - codec->errormode = PARSERUTILS_CHARSET_CODEC_ERROR_LOOSE; + c->alloc = alloc; + c->alloc_pw = pw; - codec->alloc = alloc; - codec->alloc_pw = pw; + *codec = c; - return codec; + return PARSERUTILS_OK; } /** * Destroy a charset codec * * \param codec The codec to destroy + * \return PARSERUTILS_OK on success, appropriate error otherwise */ -void parserutils_charset_codec_destroy(parserutils_charset_codec *codec) +parserutils_error parserutils_charset_codec_destroy( + parserutils_charset_codec *codec) { if (codec == NULL) - return; + return PARSERUTILS_BADPARM; codec->handler.destroy(codec); codec->alloc(codec, 0, codec->alloc_pw); + + return PARSERUTILS_OK; } /** diff --git a/src/charset/codecs/codec_8859.c b/src/charset/codecs/codec_8859.c index 1b8fd37..c04eb87 100644 --- a/src/charset/codecs/codec_8859.c +++ b/src/charset/codecs/codec_8859.c @@ -66,9 +66,11 @@ typedef struct charset_8859_codec { } charset_8859_codec; static bool charset_8859_codec_handles_charset(const char *charset); -static parserutils_charset_codec *charset_8859_codec_create(const char *charset, - parserutils_alloc alloc, void *pw); -static void charset_8859_codec_destroy (parserutils_charset_codec *codec); +static parserutils_error charset_8859_codec_create(const char *charset, + parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec); +static parserutils_error charset_8859_codec_destroy( + parserutils_charset_codec *codec); static parserutils_error charset_8859_codec_encode( parserutils_charset_codec *codec, const uint8_t **source, size_t *sourcelen, @@ -125,12 +127,16 @@ bool charset_8859_codec_handles_charset(const char *charset) * \param charset The charset to read from / write to * \param alloc Memory (de)allocation function * \param pw Pointer to client-specific private data (may be NULL) - * \return Pointer to codec, or NULL on failure + * \param codec Pointer to location to receive codec + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters, + * PARSERUTILS_NOMEM on memory exhausion */ -parserutils_charset_codec *charset_8859_codec_create(const char *charset, - parserutils_alloc alloc, void *pw) +parserutils_error charset_8859_codec_create(const char *charset, + parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec) { - charset_8859_codec *codec; + charset_8859_codec *c; uint16_t match = parserutils_charset_mibenum_from_name( charset, strlen(charset)); uint32_t *table = NULL; @@ -144,35 +150,40 @@ parserutils_charset_codec *charset_8859_codec_create(const char *charset, assert(table != NULL); - codec = alloc(NULL, sizeof(charset_8859_codec), pw); - if (codec == NULL) - return NULL; + c = alloc(NULL, sizeof(charset_8859_codec), pw); + if (c == NULL) + return PARSERUTILS_NOMEM; - codec->table = table; + c->table = table; - codec->read_buf[0] = 0; - codec->read_len = 0; + c->read_buf[0] = 0; + c->read_len = 0; - codec->write_buf[0] = 0; - codec->write_len = 0; + c->write_buf[0] = 0; + c->write_len = 0; /* Finally, populate vtable */ - codec->base.handler.destroy = charset_8859_codec_destroy; - codec->base.handler.encode = charset_8859_codec_encode; - codec->base.handler.decode = charset_8859_codec_decode; - codec->base.handler.reset = charset_8859_codec_reset; + c->base.handler.destroy = charset_8859_codec_destroy; + c->base.handler.encode = charset_8859_codec_encode; + c->base.handler.decode = charset_8859_codec_decode; + c->base.handler.reset = charset_8859_codec_reset; + + *codec = (parserutils_charset_codec *) c; - return (parserutils_charset_codec *) codec; + return PARSERUTILS_OK; } /** * Destroy an ISO-8859-n codec * * \param codec The codec to destroy + * \return PARSERUTILS_OK on success, appropriate error otherwise */ -void charset_8859_codec_destroy (parserutils_charset_codec *codec) +parserutils_error charset_8859_codec_destroy (parserutils_charset_codec *codec) { UNUSED(codec); + + return PARSERUTILS_OK; } /** diff --git a/src/charset/codecs/codec_ascii.c b/src/charset/codecs/codec_ascii.c index bce5191..944d354 100644 --- a/src/charset/codecs/codec_ascii.c +++ b/src/charset/codecs/codec_ascii.c @@ -39,9 +39,11 @@ typedef struct charset_ascii_codec { } charset_ascii_codec; static bool charset_ascii_codec_handles_charset(const char *charset); -static parserutils_charset_codec *charset_ascii_codec_create( - const char *charset, parserutils_alloc alloc, void *pw); -static void charset_ascii_codec_destroy (parserutils_charset_codec *codec); +static parserutils_error charset_ascii_codec_create( + const char *charset, parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec); +static parserutils_error charset_ascii_codec_destroy( + parserutils_charset_codec *codec); static parserutils_error charset_ascii_codec_encode( parserutils_charset_codec *codec, const uint8_t **source, size_t *sourcelen, @@ -93,42 +95,51 @@ bool charset_ascii_codec_handles_charset(const char *charset) * \param charset The charset to read from / write to * \param alloc Memory (de)allocation function * \param pw Pointer to client-specific private data (may be NULL) - * \return Pointer to codec, or NULL on failure + * \param codec Pointer to location to receive codec + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters, + * PARSERUTILS_NOMEM on memory exhausion */ -parserutils_charset_codec *charset_ascii_codec_create(const char *charset, - parserutils_alloc alloc, void *pw) +parserutils_error charset_ascii_codec_create(const char *charset, + parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec) { - charset_ascii_codec *codec; + charset_ascii_codec *c; UNUSED(charset); - codec = alloc(NULL, sizeof(charset_ascii_codec), pw); - if (codec == NULL) - return NULL; + c = alloc(NULL, sizeof(charset_ascii_codec), pw); + if (c == NULL) + return PARSERUTILS_NOMEM; - codec->read_buf[0] = 0; - codec->read_len = 0; + c->read_buf[0] = 0; + c->read_len = 0; - codec->write_buf[0] = 0; - codec->write_len = 0; + c->write_buf[0] = 0; + c->write_len = 0; /* Finally, populate vtable */ - codec->base.handler.destroy = charset_ascii_codec_destroy; - codec->base.handler.encode = charset_ascii_codec_encode; - codec->base.handler.decode = charset_ascii_codec_decode; - codec->base.handler.reset = charset_ascii_codec_reset; + c->base.handler.destroy = charset_ascii_codec_destroy; + c->base.handler.encode = charset_ascii_codec_encode; + c->base.handler.decode = charset_ascii_codec_decode; + c->base.handler.reset = charset_ascii_codec_reset; + + *codec = (parserutils_charset_codec *) c; - return (parserutils_charset_codec *) codec; + return PARSERUTILS_OK; } /** * Destroy a US-ASCII codec * * \param codec The codec to destroy + * \return PARSERUTILS_OK on success, appropriate error otherwise */ -void charset_ascii_codec_destroy (parserutils_charset_codec *codec) +parserutils_error charset_ascii_codec_destroy (parserutils_charset_codec *codec) { UNUSED(codec); + + return PARSERUTILS_OK; } /** diff --git a/src/charset/codecs/codec_ext8.c b/src/charset/codecs/codec_ext8.c index 8678890..1f12fea 100644 --- a/src/charset/codecs/codec_ext8.c +++ b/src/charset/codecs/codec_ext8.c @@ -60,9 +60,11 @@ typedef struct charset_ext8_codec { } charset_ext8_codec; static bool charset_ext8_codec_handles_charset(const char *charset); -static parserutils_charset_codec *charset_ext8_codec_create(const char *charset, - parserutils_alloc alloc, void *pw); -static void charset_ext8_codec_destroy (parserutils_charset_codec *codec); +static parserutils_error charset_ext8_codec_create(const char *charset, + parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec); +static parserutils_error charset_ext8_codec_destroy( + parserutils_charset_codec *codec); static parserutils_error charset_ext8_codec_encode( parserutils_charset_codec *codec, const uint8_t **source, size_t *sourcelen, @@ -119,12 +121,16 @@ bool charset_ext8_codec_handles_charset(const char *charset) * \param charset The charset to read from / write to * \param alloc Memory (de)allocation function * \param pw Pointer to client-specific private data (may be NULL) - * \return Pointer to codec, or NULL on failure + * \param codec Pointer to location to receive codec + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters, + * PARSERUTILS_NOMEM on memory exhausion */ -parserutils_charset_codec *charset_ext8_codec_create(const char *charset, - parserutils_alloc alloc, void *pw) +parserutils_error charset_ext8_codec_create(const char *charset, + parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec) { - charset_ext8_codec *codec; + charset_ext8_codec *c; uint16_t match = parserutils_charset_mibenum_from_name( charset, strlen(charset)); uint32_t *table = NULL; @@ -138,35 +144,40 @@ parserutils_charset_codec *charset_ext8_codec_create(const char *charset, assert(table != NULL); - codec = alloc(NULL, sizeof(charset_ext8_codec), pw); - if (codec == NULL) - return NULL; + c = alloc(NULL, sizeof(charset_ext8_codec), pw); + if (c == NULL) + return PARSERUTILS_NOMEM; - codec->table = table; + c->table = table; - codec->read_buf[0] = 0; - codec->read_len = 0; + c->read_buf[0] = 0; + c->read_len = 0; - codec->write_buf[0] = 0; - codec->write_len = 0; + c->write_buf[0] = 0; + c->write_len = 0; /* Finally, populate vtable */ - codec->base.handler.destroy = charset_ext8_codec_destroy; - codec->base.handler.encode = charset_ext8_codec_encode; - codec->base.handler.decode = charset_ext8_codec_decode; - codec->base.handler.reset = charset_ext8_codec_reset; + c->base.handler.destroy = charset_ext8_codec_destroy; + c->base.handler.encode = charset_ext8_codec_encode; + c->base.handler.decode = charset_ext8_codec_decode; + c->base.handler.reset = charset_ext8_codec_reset; + + *codec = (parserutils_charset_codec *) c; - return (parserutils_charset_codec *) codec; + return PARSERUTILS_OK; } /** * Destroy an extended 8bit codec * * \param codec The codec to destroy + * \return PARSERUTILS_OK on success, appropriate error otherwise */ -void charset_ext8_codec_destroy (parserutils_charset_codec *codec) +parserutils_error charset_ext8_codec_destroy (parserutils_charset_codec *codec) { UNUSED(codec); + + return PARSERUTILS_OK; } /** diff --git a/src/charset/codecs/codec_impl.h b/src/charset/codecs/codec_impl.h index 9183594..09f622c 100644 --- a/src/charset/codecs/codec_impl.h +++ b/src/charset/codecs/codec_impl.h @@ -25,7 +25,7 @@ struct parserutils_charset_codec { void *alloc_pw; /**< private word */ struct { - void (*destroy)(parserutils_charset_codec *codec); + parserutils_error (*destroy)(parserutils_charset_codec *codec); parserutils_error (*encode)(parserutils_charset_codec *codec, const uint8_t **source, size_t *sourcelen, uint8_t **dest, size_t *destlen); @@ -41,8 +41,9 @@ struct parserutils_charset_codec { */ typedef struct parserutils_charset_handler { bool (*handles_charset)(const char *charset); - parserutils_charset_codec *(*create)(const char *charset, - parserutils_alloc alloc, void *pw); + parserutils_error (*create)(const char *charset, + parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec); } parserutils_charset_handler; #endif diff --git a/src/charset/codecs/codec_utf16.c b/src/charset/codecs/codec_utf16.c index e17c217..c2a91ed 100644 --- a/src/charset/codecs/codec_utf16.c +++ b/src/charset/codecs/codec_utf16.c @@ -45,9 +45,11 @@ typedef struct charset_utf16_codec { } charset_utf16_codec; static bool charset_utf16_codec_handles_charset(const char *charset); -static parserutils_charset_codec *charset_utf16_codec_create( - const char *charset, parserutils_alloc alloc, void *pw); -static void charset_utf16_codec_destroy (parserutils_charset_codec *codec); +static parserutils_error charset_utf16_codec_create( + const char *charset, parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec); +static parserutils_error charset_utf16_codec_destroy( + parserutils_charset_codec *codec); static parserutils_error charset_utf16_codec_encode( parserutils_charset_codec *codec, const uint8_t **source, size_t *sourcelen, @@ -85,45 +87,54 @@ bool charset_utf16_codec_handles_charset(const char *charset) * \param charset The charset to read from / write to * \param alloc Memory (de)allocation function * \param pw Pointer to client-specific private data (may be NULL) - * \return Pointer to codec, or NULL on failure + * \param codec Pointer to location to receive codec + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters, + * PARSERUTILS_NOMEM on memory exhausion */ -parserutils_charset_codec *charset_utf16_codec_create(const char *charset, - parserutils_alloc alloc, void *pw) +parserutils_error charset_utf16_codec_create(const char *charset, + parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec) { - charset_utf16_codec *codec; + charset_utf16_codec *c; UNUSED(charset); - codec = alloc(NULL, sizeof(charset_utf16_codec), pw); - if (codec == NULL) - return NULL; + c = alloc(NULL, sizeof(charset_utf16_codec), pw); + if (c == NULL) + return PARSERUTILS_NOMEM; - codec->inval_buf[0] = '\0'; - codec->inval_len = 0; + c->inval_buf[0] = '\0'; + c->inval_len = 0; - codec->read_buf[0] = 0; - codec->read_len = 0; + c->read_buf[0] = 0; + c->read_len = 0; - codec->write_buf[0] = 0; - codec->write_len = 0; + c->write_buf[0] = 0; + c->write_len = 0; /* Finally, populate vtable */ - codec->base.handler.destroy = charset_utf16_codec_destroy; - codec->base.handler.encode = charset_utf16_codec_encode; - codec->base.handler.decode = charset_utf16_codec_decode; - codec->base.handler.reset = charset_utf16_codec_reset; + c->base.handler.destroy = charset_utf16_codec_destroy; + c->base.handler.encode = charset_utf16_codec_encode; + c->base.handler.decode = charset_utf16_codec_decode; + c->base.handler.reset = charset_utf16_codec_reset; - return (parserutils_charset_codec *) codec; + *codec = (parserutils_charset_codec *) c; + + return PARSERUTILS_OK; } /** * Destroy a UTF-16 codec * * \param codec The codec to destroy + * \return PARSERUTILS_OK on success, appropriate error otherwise */ -void charset_utf16_codec_destroy (parserutils_charset_codec *codec) +parserutils_error charset_utf16_codec_destroy (parserutils_charset_codec *codec) { UNUSED(codec); + + return PARSERUTILS_OK; } /** diff --git a/src/charset/codecs/codec_utf8.c b/src/charset/codecs/codec_utf8.c index 24eb3e4..f39b8bb 100644 --- a/src/charset/codecs/codec_utf8.c +++ b/src/charset/codecs/codec_utf8.c @@ -45,9 +45,11 @@ typedef struct charset_utf8_codec { } charset_utf8_codec; static bool charset_utf8_codec_handles_charset(const char *charset); -static parserutils_charset_codec *charset_utf8_codec_create(const char *charset, - parserutils_alloc alloc, void *pw); -static void charset_utf8_codec_destroy (parserutils_charset_codec *codec); +static parserutils_error charset_utf8_codec_create(const char *charset, + parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec); +static parserutils_error charset_utf8_codec_destroy( + parserutils_charset_codec *codec); static parserutils_error charset_utf8_codec_encode( parserutils_charset_codec *codec, const uint8_t **source, size_t *sourcelen, @@ -86,45 +88,54 @@ bool charset_utf8_codec_handles_charset(const char *charset) * \param charset The charset to read from / write to * \param alloc Memory (de)allocation function * \param pw Pointer to client-specific private data (may be NULL) - * \return Pointer to codec, or NULL on failure + * \param codec Pointer to location to receive codec + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters, + * PARSERUTILS_NOMEM on memory exhausion */ -parserutils_charset_codec *charset_utf8_codec_create(const char *charset, - parserutils_alloc alloc, void *pw) +parserutils_error charset_utf8_codec_create(const char *charset, + parserutils_alloc alloc, void *pw, + parserutils_charset_codec **codec) { - charset_utf8_codec *codec; + charset_utf8_codec *c; UNUSED(charset); - codec = alloc(NULL, sizeof(charset_utf8_codec), pw); - if (codec == NULL) - return NULL; + c = alloc(NULL, sizeof(charset_utf8_codec), pw); + if (c == NULL) + return PARSERUTILS_NOMEM; - codec->inval_buf[0] = '\0'; - codec->inval_len = 0; + c->inval_buf[0] = '\0'; + c->inval_len = 0; - codec->read_buf[0] = 0; - codec->read_len = 0; + c->read_buf[0] = 0; + c->read_len = 0; - codec->write_buf[0] = 0; - codec->write_len = 0; + c->write_buf[0] = 0; + c->write_len = 0; /* Finally, populate vtable */ - codec->base.handler.destroy = charset_utf8_codec_destroy; - codec->base.handler.encode = charset_utf8_codec_encode; - codec->base.handler.decode = charset_utf8_codec_decode; - codec->base.handler.reset = charset_utf8_codec_reset; + c->base.handler.destroy = charset_utf8_codec_destroy; + c->base.handler.encode = charset_utf8_codec_encode; + c->base.handler.decode = charset_utf8_codec_decode; + c->base.handler.reset = charset_utf8_codec_reset; - return (parserutils_charset_codec *) codec; + *codec = (parserutils_charset_codec *) c; + + return PARSERUTILS_OK; } /** * Destroy a UTF-8 codec * * \param codec The codec to destroy + * \return PARSERUTILS_OK on success, appropriate error otherwise */ -void charset_utf8_codec_destroy (parserutils_charset_codec *codec) +parserutils_error charset_utf8_codec_destroy (parserutils_charset_codec *codec) { UNUSED(codec); + + return PARSERUTILS_OK; } /** diff --git a/src/input/filter.c b/src/input/filter.c index 337fc78..716fbf6 100644 --- a/src/input/filter.c +++ b/src/input/filter.c @@ -54,65 +54,74 @@ static parserutils_error filter_set_encoding(parserutils_filter *input, * \param int_enc Desired encoding of document * \param alloc Function used to (de)allocate data * \param pw Pointer to client-specific private data (may be NULL) - * \return Pointer to filter instance, or NULL on failure + * \param filter Pointer to location to receive filter instance + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters, + * PARSERUTILS_NOMEM on memory exhausion, + * PARSERUTILS_BADENCODING if the encoding is unsupported */ -parserutils_filter *parserutils_filter_create(const char *int_enc, - parserutils_alloc alloc, void *pw) +parserutils_error parserutils_filter_create(const char *int_enc, + parserutils_alloc alloc, void *pw, parserutils_filter **filter) { - parserutils_filter *filter; + parserutils_filter *f; + parserutils_error error; - if (int_enc == NULL || alloc == NULL) - return NULL; + if (int_enc == NULL || alloc == NULL || filter == NULL) + return PARSERUTILS_BADPARM; - filter = alloc(NULL, sizeof(*filter), pw); - if (!filter) - return NULL; + f = alloc(NULL, sizeof(parserutils_filter), pw); + if (f == NULL) + return PARSERUTILS_NOMEM; #ifdef WITH_ICONV_FILTER - filter->cd = (iconv_t) -1; - filter->int_enc = parserutils_charset_mibenum_from_name( + f->cd = (iconv_t) -1; + f->int_enc = parserutils_charset_mibenum_from_name( int_enc, strlen(int_enc)); - if (filter->int_enc == 0) { - alloc(filter, 0, pw); - return NULL; + if (f->int_enc == 0) { + alloc(f, 0, pw); + return PARSERUTILS_BADENCODING; } #else - filter->leftover = false; - filter->pivot_left = NULL; - filter->pivot_len = 0; + f->leftover = false; + f->pivot_left = NULL; + f->pivot_len = 0; #endif - filter->alloc = alloc; - filter->pw = pw; + f->alloc = alloc; + f->pw = pw; - if (filter_set_defaults(filter) != PARSERUTILS_OK) { - filter->alloc(filter, 0, pw); - return NULL; + error = filter_set_defaults(f); + if (error != PARSERUTILS_OK) { + f->alloc(f, 0, pw); + return error; } #ifndef WITH_ICONV_FILTER - filter->write_codec = - parserutils_charset_codec_create(int_enc, alloc, pw); - if (filter->write_codec == NULL) { - if (filter->read_codec != NULL) - parserutils_charset_codec_destroy(filter->read_codec); - filter->alloc(filter, 0, pw); - return NULL; + error = parserutils_charset_codec_create(int_enc, alloc, pw, + &f->write_codec); + if (error != PARSERUTILS_OK) { + if (f->read_codec != NULL) + parserutils_charset_codec_destroy(f->read_codec); + f->alloc(f, 0, pw); + return error; } #endif - return filter; + *filter = f; + + return PARSERUTILS_OK; } /** * Destroy an input filter * * \param input Pointer to filter instance + * \return PARSERUTILS_OK on success, appropriate error otherwise */ -void parserutils_filter_destroy(parserutils_filter *input) +parserutils_error parserutils_filter_destroy(parserutils_filter *input) { if (input == NULL) - return; + return PARSERUTILS_BADPARM; #ifdef WITH_ICONV_FILTER if (input->cd != (iconv_t) -1) @@ -127,7 +136,7 @@ void parserutils_filter_destroy(parserutils_filter *input) input->alloc(input, 0, input->pw); - return; + return PARSERUTILS_OK; } /** @@ -354,6 +363,7 @@ parserutils_error filter_set_defaults(parserutils_filter *input) parserutils_error filter_set_encoding(parserutils_filter *input, const char *enc) { + parserutils_error error; const char *old_enc; uint16_t mibenum; @@ -384,10 +394,10 @@ parserutils_error filter_set_encoding(parserutils_filter *input, if (input->read_codec != NULL) parserutils_charset_codec_destroy(input->read_codec); - input->read_codec = parserutils_charset_codec_create(enc, input->alloc, - input->pw); - if (input->read_codec == NULL) - return PARSERUTILS_NOMEM; + error = parserutils_charset_codec_create(enc, input->alloc, + input->pw, &input->read_codec); + if (error != PARSERUTILS_OK) + return error; #endif input->settings.encoding = mibenum; diff --git a/src/input/filter.h b/src/input/filter.h index 96941a6..0d72b92 100644 --- a/src/input/filter.h +++ b/src/input/filter.h @@ -35,10 +35,10 @@ typedef union parserutils_filter_optparams { /* Create an input filter */ -parserutils_filter *parserutils_filter_create(const char *int_enc, - parserutils_alloc alloc, void *pw); +parserutils_error parserutils_filter_create(const char *int_enc, + parserutils_alloc alloc, void *pw, parserutils_filter **filter); /* Destroy an input filter */ -void parserutils_filter_destroy(parserutils_filter *input); +parserutils_error parserutils_filter_destroy(parserutils_filter *input); /* Configure an input filter */ parserutils_error parserutils_filter_setopt(parserutils_filter *input, diff --git a/src/input/inputstream.c b/src/input/inputstream.c index 5631331..a4859be 100644 --- a/src/input/inputstream.c +++ b/src/input/inputstream.c @@ -51,104 +51,115 @@ static inline parserutils_error parserutils_inputstream_strip_bom( * \param csdetect Charset detection function, or NULL * \param alloc Memory (de)allocation function * \param pw Pointer to client-specific private data (may be NULL) - * \return Pointer to stream instance, or NULL on failure + * \param stream Pointer to location to receive stream instance + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters, + * PARSERUTILS_NOMEM on memory exhaustion, + * PARSERUTILS_BADENCODING on unsupported encoding * * The value 0 is defined as being the lowest priority encoding source * (i.e. the default fallback encoding). Beyond this, no further * interpretation is made upon the encoding source. */ -parserutils_inputstream *parserutils_inputstream_create(const char *enc, +parserutils_error parserutils_inputstream_create(const char *enc, uint32_t encsrc, parserutils_charset_detect_func csdetect, - parserutils_alloc alloc, void *pw) + parserutils_alloc alloc, void *pw, + parserutils_inputstream **stream) { - parserutils_inputstream_private *stream; + parserutils_inputstream_private *s; + parserutils_error error; - if (alloc == NULL) - return NULL; + if (alloc == NULL || stream == NULL) + return PARSERUTILS_BADPARM; - stream = alloc(NULL, sizeof(parserutils_inputstream_private), pw); - if (stream == NULL) - return NULL; + s = alloc(NULL, sizeof(parserutils_inputstream_private), pw); + if (s == NULL) + return PARSERUTILS_NOMEM; - stream->raw = parserutils_buffer_create(alloc, pw); - if (stream->raw == NULL) { - alloc(stream, 0, pw); - return NULL; + error = parserutils_buffer_create(alloc, pw, &s->raw); + if (error != PARSERUTILS_OK) { + alloc(s, 0, pw); + return error; } - stream->public.utf8 = parserutils_buffer_create(alloc, pw); - if (stream->public.utf8 == NULL) { - parserutils_buffer_destroy(stream->raw); - alloc(stream, 0, pw); - return NULL; + error = parserutils_buffer_create(alloc, pw, &s->public.utf8); + if (error != PARSERUTILS_OK) { + parserutils_buffer_destroy(s->raw); + alloc(s, 0, pw); + return error; } - stream->public.cursor = 0; - stream->public.had_eof = false; - stream->done_first_chunk = false; - - stream->input = parserutils_filter_create("UTF-8", alloc, pw); - if (stream->input == NULL) { - parserutils_buffer_destroy(stream->public.utf8); - parserutils_buffer_destroy(stream->raw); - alloc(stream, 0, pw); - return NULL; + s->public.cursor = 0; + s->public.had_eof = false; + s->done_first_chunk = false; + + error = parserutils_filter_create("UTF-8", alloc, pw, &s->input); + if (error != PARSERUTILS_OK) { + parserutils_buffer_destroy(s->public.utf8); + parserutils_buffer_destroy(s->raw); + alloc(s, 0, pw); + return error; } if (enc != NULL) { - parserutils_error error; parserutils_filter_optparams params; - stream->mibenum = + s->mibenum = parserutils_charset_mibenum_from_name(enc, strlen(enc)); - if (stream->mibenum != 0) { + if (s->mibenum != 0) { params.encoding.name = enc; - error = parserutils_filter_setopt(stream->input, + error = parserutils_filter_setopt(s->input, PARSERUTILS_FILTER_SET_ENCODING, ¶ms); if (error != PARSERUTILS_OK && error != PARSERUTILS_INVALID) { - parserutils_filter_destroy(stream->input); - parserutils_buffer_destroy(stream->public.utf8); - parserutils_buffer_destroy(stream->raw); - alloc(stream, 0, pw); - return NULL; + parserutils_filter_destroy(s->input); + parserutils_buffer_destroy(s->public.utf8); + parserutils_buffer_destroy(s->raw); + alloc(s, 0, pw); + return error; } - stream->encsrc = encsrc; + s->encsrc = encsrc; } } else { - stream->mibenum = 0; - stream->encsrc = 0; + s->mibenum = 0; + s->encsrc = 0; } - stream->csdetect = csdetect; + s->csdetect = csdetect; + + s->alloc = alloc; + s->pw = pw; - stream->alloc = alloc; - stream->pw = pw; + *stream = (parserutils_inputstream *) s; - return (parserutils_inputstream *) stream; + return PARSERUTILS_OK; } /** * Destroy an input stream * * \param stream Input stream to destroy + * \return PARSERUTILS_OK on success, appropriate error otherwise */ -void parserutils_inputstream_destroy(parserutils_inputstream *stream) +parserutils_error parserutils_inputstream_destroy( + parserutils_inputstream *stream) { parserutils_inputstream_private *s = (parserutils_inputstream_private *) stream; if (stream == NULL) - return; + return PARSERUTILS_BADPARM; parserutils_filter_destroy(s->input); parserutils_buffer_destroy(s->public.utf8); parserutils_buffer_destroy(s->raw); s->alloc(s, 0, s->pw); + + return PARSERUTILS_OK; } /** diff --git a/src/utils/buffer.c b/src/utils/buffer.c index 3c28e16..a7ee7f4 100644 --- a/src/utils/buffer.c +++ b/src/utils/buffer.c @@ -14,45 +14,57 @@ /** * Create a memory buffer * - * \param alloc Memory (de)allocation function - * \param pw Pointer to client-specific private data - * \return Pointer to memory buffer, or NULL on memory exhaustion + * \param alloc Memory (de)allocation function + * \param pw Pointer to client-specific private data + * \param buffer Pointer to location to receive memory buffer + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters, + * PARSERUTILS_NOMEM on memory exhausion */ -parserutils_buffer *parserutils_buffer_create(parserutils_alloc alloc, void *pw) +parserutils_error parserutils_buffer_create(parserutils_alloc alloc, void *pw, + parserutils_buffer **buffer) { - parserutils_buffer *buffer = - alloc(NULL, sizeof(parserutils_buffer), pw); + parserutils_buffer *b; - if (buffer == NULL) - return NULL; + if (alloc == NULL || buffer == NULL) + return PARSERUTILS_BADPARM; + + b = alloc(NULL, sizeof(parserutils_buffer), pw); + if (b == NULL) + return PARSERUTILS_NOMEM; - buffer->data = alloc(NULL, DEFAULT_SIZE, pw); - if (buffer->data == NULL) { - alloc(buffer, 0, pw); - return NULL; + b->data = alloc(NULL, DEFAULT_SIZE, pw); + if (b->data == NULL) { + alloc(b, 0, pw); + return PARSERUTILS_NOMEM; } - buffer->length = 0; - buffer->allocated = DEFAULT_SIZE; + b->length = 0; + b->allocated = DEFAULT_SIZE; + + b->alloc = alloc; + b->pw = pw; - buffer->alloc = alloc; - buffer->pw = pw; + *buffer = b; - return buffer; + return PARSERUTILS_OK; } /** * Destroy a memory buffer * * \param buffer The buffer to destroy + * \return PARSERUTILS_OK on success, appropriate error otherwise */ -void parserutils_buffer_destroy(parserutils_buffer *buffer) +parserutils_error parserutils_buffer_destroy(parserutils_buffer *buffer) { if (buffer == NULL) - return; + return PARSERUTILS_BADPARM; buffer->alloc(buffer->data, 0, buffer->pw); buffer->alloc(buffer, 0, buffer->pw); + + return PARSERUTILS_OK; } /** diff --git a/src/utils/dict.c b/src/utils/dict.c index 17b94a5..8b519ba 100644 --- a/src/utils/dict.c +++ b/src/utils/dict.c @@ -104,10 +104,10 @@ parserutils_error parserutils_dict_insert(parserutils_dict *dict, return PARSERUTILS_OK; } } else { - dict->table[index] = parserutils_rbtree_create(dict_cmp, - dict->alloc, dict->pw); - if (dict->table[index] == NULL) - return PARSERUTILS_NOMEM; + error = parserutils_rbtree_create(dict_cmp, + dict->alloc, dict->pw, &dict->table[index]); + if (error != PARSERUTILS_OK) + return error; } entry = dict->alloc(NULL, sizeof(parserutils_dict_entry) + len, diff --git a/src/utils/errors.c b/src/utils/errors.c index 353cda1..93e098d 100644 --- a/src/utils/errors.c +++ b/src/utils/errors.c @@ -38,6 +38,9 @@ const char *parserutils_error_to_string(parserutils_error error) case PARSERUTILS_NEEDDATA: result = "Insufficient data"; break; + case PARSERUTILS_BADENCODING: + result = "Unsupported encoding"; + break; } return result; @@ -64,6 +67,8 @@ parserutils_error parserutils_error_from_string(const char *str, size_t len) return PARSERUTILS_FILENOTFOUND; } else if (strncmp(str, "PARSERUTILS_NEEDDATA", len) == 0) { return PARSERUTILS_NEEDDATA; + } else if (strncmp(str, "PARSERUTILS_BADENCODING", len) == 0) { + return PARSERUTILS_BADENCODING; } return PARSERUTILS_OK; diff --git a/src/utils/rbtree.c b/src/utils/rbtree.c index 9bf1087..4f2b64b 100644 --- a/src/utils/rbtree.c +++ b/src/utils/rbtree.c @@ -92,26 +92,31 @@ static inline void dump_tree(rbnode *node, parserutils_rbtree_print print, * \param cmp Comparator routine for keys * \param alloc Memory (de)allocation function * \param pw Pointer to client-specific private data - * \return Pointer to tree instance, or NULL on memory exhaustion + * \param tree Pointer to location to receive tree instance + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters, + * PARSERUTILS_NOMEM on memory exhaustion */ -parserutils_rbtree *parserutils_rbtree_create(parserutils_rbtree_cmp cmp, - parserutils_alloc alloc, void *pw) +parserutils_error parserutils_rbtree_create(parserutils_rbtree_cmp cmp, + parserutils_alloc alloc, void *pw, parserutils_rbtree **tree) { - parserutils_rbtree *tree; + parserutils_rbtree *t; - if (cmp == NULL || alloc == NULL) - return NULL; + if (cmp == NULL || alloc == NULL || tree == NULL) + return PARSERUTILS_BADPARM; - tree = alloc(NULL, sizeof(parserutils_rbtree), pw); - if (tree == NULL) - return NULL; + t = alloc(NULL, sizeof(parserutils_rbtree), pw); + if (t == NULL) + return PARSERUTILS_NOMEM; + + t->root = NULL; + t->cmp = cmp; + t->alloc = alloc; + t->pw = pw; - tree->root = NULL; - tree->cmp = cmp; - tree->alloc = alloc; - tree->pw = pw; + *tree = t; - return tree; + return PARSERUTILS_OK; } /** @@ -120,12 +125,13 @@ parserutils_rbtree *parserutils_rbtree_create(parserutils_rbtree_cmp cmp, * \param tree The tree to destroy * \param destructor Routine to be called with key/value pairs to destroy * \param pw Pointer to client-specific private data + * \return PARSERUTILS_OK on success, appropriate error otherwise */ -void parserutils_rbtree_destroy(parserutils_rbtree *tree, +parserutils_error parserutils_rbtree_destroy(parserutils_rbtree *tree, parserutils_rbtree_del destructor, void *pw) { if (tree == NULL) - return; + return PARSERUTILS_BADPARM; while (tree->root != NULL) { #ifndef USE_DELETEMAX @@ -142,6 +148,8 @@ void parserutils_rbtree_destroy(parserutils_rbtree *tree, } tree->alloc(tree, 0, tree->pw); + + return PARSERUTILS_OK; } /** diff --git a/src/utils/rbtree.h b/src/utils/rbtree.h index 0225c92..074d390 100644 --- a/src/utils/rbtree.h +++ b/src/utils/rbtree.h @@ -19,9 +19,9 @@ typedef void (*parserutils_rbtree_del)(void *key, void *value, void *pw); typedef void (*parserutils_rbtree_print)(const void *key, const void *value, int depth); -parserutils_rbtree *parserutils_rbtree_create(parserutils_rbtree_cmp cmp, - parserutils_alloc alloc, void *pw); -void parserutils_rbtree_destroy(parserutils_rbtree *tree, +parserutils_error parserutils_rbtree_create(parserutils_rbtree_cmp cmp, + parserutils_alloc alloc, void *pw, parserutils_rbtree **tree); +parserutils_error parserutils_rbtree_destroy(parserutils_rbtree *tree, parserutils_rbtree_del destructor, void *pw); parserutils_error parserutils_rbtree_insert(parserutils_rbtree *tree, diff --git a/src/utils/stack.c b/src/utils/stack.c index 2751ec4..cee43ee 100644 --- a/src/utils/stack.c +++ b/src/utils/stack.c @@ -32,49 +32,57 @@ struct parserutils_stack * \param chunk_size Number of stack slots in a chunk * \param alloc Memory (de)allocation function * \param pw Pointer to client-specific private data - * \return Pointer to stack instance, or NULL on memory exhaustion + * \param stack Pointer to location to receive stack instance + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters + * PARSERUTILS_NOMEM on memory exhaustion */ -parserutils_stack *parserutils_stack_create(size_t item_size, size_t chunk_size, - parserutils_alloc alloc, void *pw) +parserutils_error parserutils_stack_create(size_t item_size, size_t chunk_size, + parserutils_alloc alloc, void *pw, parserutils_stack **stack) { - parserutils_stack *stack; + parserutils_stack *s; - if (item_size == 0 || chunk_size == 0 || alloc == NULL) - return NULL; + if (item_size == 0 || chunk_size == 0 || alloc == NULL || stack == NULL) + return PARSERUTILS_BADPARM; - stack = alloc(NULL, sizeof(parserutils_stack), pw); - if (stack == NULL) - return NULL; + s = alloc(NULL, sizeof(parserutils_stack), pw); + if (s == NULL) + return PARSERUTILS_NOMEM; - stack->items = alloc(NULL, item_size * chunk_size, pw); - if (stack->items == NULL) { - alloc(stack, 0, pw); - return NULL; + s->items = alloc(NULL, item_size * chunk_size, pw); + if (s->items == NULL) { + alloc(s, 0, pw); + return PARSERUTILS_NOMEM; } - stack->item_size = item_size; - stack->chunk_size = chunk_size; - stack->items_allocated = chunk_size; - stack->current_item = -1; + s->item_size = item_size; + s->chunk_size = chunk_size; + s->items_allocated = chunk_size; + s->current_item = -1; + + s->alloc = alloc; + s->pw = pw; - stack->alloc = alloc; - stack->pw = pw; + *stack = s; - return stack; + return PARSERUTILS_OK; } /** * Destroy a stack instance * * \param stack The stack to destroy + * \return PARSERUTILS_OK on success, appropriate error otherwise. */ -void parserutils_stack_destroy(parserutils_stack *stack) +parserutils_error parserutils_stack_destroy(parserutils_stack *stack) { if (stack == NULL) - return; + return PARSERUTILS_BADPARM; stack->alloc(stack->items, 0, stack->pw); stack->alloc(stack, 0, stack->pw); + + return PARSERUTILS_OK; } /** diff --git a/src/utils/vector.c b/src/utils/vector.c index 1ffa8a3..f99b773 100644 --- a/src/utils/vector.c +++ b/src/utils/vector.c @@ -32,49 +32,59 @@ struct parserutils_vector * \param chunk_size Number of vector slots in a chunk * \param alloc Memory (de)allocation function * \param pw Pointer to client-specific private data - * \return Pointer to vector instance, or NULL on memory exhaustion + * \param vector Pointer to location to receive vector instance + * \return PARSERUTILS_OK on success, + * PARSERUTILS_BADPARM on bad parameters, + * PARSERUTILS_NOMEM on memory exhaustion */ -parserutils_vector *parserutils_vector_create(size_t item_size, - size_t chunk_size, parserutils_alloc alloc, void *pw) +parserutils_error parserutils_vector_create(size_t item_size, + size_t chunk_size, parserutils_alloc alloc, void *pw, + parserutils_vector **vector) { - parserutils_vector *vector; + parserutils_vector *v; - if (item_size == 0 || chunk_size == 0 || alloc == NULL) - return NULL; + if (item_size == 0 || chunk_size == 0 || alloc == NULL || + vector == NULL) + return PARSERUTILS_BADPARM; - vector = alloc(NULL, sizeof(parserutils_vector), pw); - if (vector == NULL) - return NULL; + v = alloc(NULL, sizeof(parserutils_vector), pw); + if (v == NULL) + return PARSERUTILS_NOMEM; - vector->items = alloc(NULL, item_size * chunk_size, pw); - if (vector->items == NULL) { - alloc(vector, 0, pw); - return NULL; + v->items = alloc(NULL, item_size * chunk_size, pw); + if (v->items == NULL) { + alloc(v, 0, pw); + return PARSERUTILS_NOMEM; } - vector->item_size = item_size; - vector->chunk_size = chunk_size; - vector->items_allocated = chunk_size; - vector->current_item = -1; + v->item_size = item_size; + v->chunk_size = chunk_size; + v->items_allocated = chunk_size; + v->current_item = -1; + + v->alloc = alloc; + v->pw = pw; - vector->alloc = alloc; - vector->pw = pw; + *vector = v; - return vector; + return PARSERUTILS_OK; } /** * Destroy a vector instance * * \param vector The vector to destroy + * \return PARSERUTILS_OK on success, appropriate error otherwise. */ -void parserutils_vector_destroy(parserutils_vector *vector) +parserutils_error parserutils_vector_destroy(parserutils_vector *vector) { if (vector == NULL) - return; + return PARSERUTILS_BADPARM; vector->alloc(vector->items, 0, vector->pw); vector->alloc(vector, 0, vector->pw); + + return PARSERUTILS_OK; } /** diff --git a/test/cscodec-8859.c b/test/cscodec-8859.c index 6378cd4..75ce20e 100644 --- a/test/cscodec-8859.c +++ b/test/cscodec-8859.c @@ -40,6 +40,7 @@ static void *myrealloc(void *ptr, size_t len, void *pw) int main(int argc, char **argv) { + parserutils_charset_codec *codec; line_ctx ctx; if (argc != 3) { @@ -51,7 +52,7 @@ int main(int argc, char **argv) PARSERUTILS_OK); assert(parserutils_charset_codec_create("NATS-SEFI-ADD", - myrealloc, NULL) == NULL); + myrealloc, NULL, &codec) == PARSERUTILS_BADENCODING); ctx.buflen = parse_filesize(argv[2]); if (ctx.buflen == 0) @@ -178,9 +179,9 @@ bool handle_line(const char *data, size_t datalen, void *pw) memcpy(enc_name, enc, end - enc); enc_name[end - enc] = 0; - ctx->codec = parserutils_charset_codec_create(enc_name, - myrealloc, NULL); - assert(ctx->codec != NULL); + assert(parserutils_charset_codec_create(enc_name, + myrealloc, NULL, &ctx->codec) == + PARSERUTILS_OK); ctx->hadenc = true; } diff --git a/test/cscodec-ext8.c b/test/cscodec-ext8.c index 6378cd4..75ce20e 100644 --- a/test/cscodec-ext8.c +++ b/test/cscodec-ext8.c @@ -40,6 +40,7 @@ static void *myrealloc(void *ptr, size_t len, void *pw) int main(int argc, char **argv) { + parserutils_charset_codec *codec; line_ctx ctx; if (argc != 3) { @@ -51,7 +52,7 @@ int main(int argc, char **argv) PARSERUTILS_OK); assert(parserutils_charset_codec_create("NATS-SEFI-ADD", - myrealloc, NULL) == NULL); + myrealloc, NULL, &codec) == PARSERUTILS_BADENCODING); ctx.buflen = parse_filesize(argv[2]); if (ctx.buflen == 0) @@ -178,9 +179,9 @@ bool handle_line(const char *data, size_t datalen, void *pw) memcpy(enc_name, enc, end - enc); enc_name[end - enc] = 0; - ctx->codec = parserutils_charset_codec_create(enc_name, - myrealloc, NULL); - assert(ctx->codec != NULL); + assert(parserutils_charset_codec_create(enc_name, + myrealloc, NULL, &ctx->codec) == + PARSERUTILS_OK); ctx->hadenc = true; } diff --git a/test/cscodec-utf16.c b/test/cscodec-utf16.c index 25ebb8c..d61fd64 100644 --- a/test/cscodec-utf16.c +++ b/test/cscodec-utf16.c @@ -43,6 +43,7 @@ static void *myrealloc(void *ptr, size_t len, void *pw) int main(int argc, char **argv) { + parserutils_charset_codec *codec; line_ctx ctx; if (argc != 3) { @@ -54,10 +55,10 @@ int main(int argc, char **argv) PARSERUTILS_OK); assert(parserutils_charset_codec_create("NATS-SEFI-ADD", - myrealloc, NULL) == NULL); + myrealloc, NULL, &codec) == PARSERUTILS_BADENCODING); - ctx.codec = parserutils_charset_codec_create("UTF-16", myrealloc, NULL); - assert(ctx.codec != NULL); + assert(parserutils_charset_codec_create("UTF-16", myrealloc, NULL, + &ctx.codec) == PARSERUTILS_OK); ctx.buflen = parse_filesize(argv[2]); if (ctx.buflen == 0) diff --git a/test/cscodec-utf8.c b/test/cscodec-utf8.c index 5d0580b..85d0443 100644 --- a/test/cscodec-utf8.c +++ b/test/cscodec-utf8.c @@ -38,6 +38,7 @@ static void *myrealloc(void *ptr, size_t len, void *pw) int main(int argc, char **argv) { + parserutils_charset_codec *codec; line_ctx ctx; if (argc != 3) { @@ -49,10 +50,10 @@ int main(int argc, char **argv) PARSERUTILS_OK); assert(parserutils_charset_codec_create("NATS-SEFI-ADD", - myrealloc, NULL) == NULL); + myrealloc, NULL, &codec) == PARSERUTILS_BADENCODING); - ctx.codec = parserutils_charset_codec_create("UTF-8", myrealloc, NULL); - assert(ctx.codec != NULL); + assert(parserutils_charset_codec_create("UTF-8", myrealloc, NULL, + &ctx.codec) == PARSERUTILS_OK); ctx.buflen = parse_filesize(argv[2]); if (ctx.buflen == 0) diff --git a/test/filter.c b/test/filter.c index ff4d1e7..044a772 100644 --- a/test/filter.c +++ b/test/filter.c @@ -37,8 +37,8 @@ int main(int argc, char **argv) PARSERUTILS_OK); /* Create input filter */ - input = parserutils_filter_create("UTF-8", myrealloc, NULL); - assert(input); + assert(parserutils_filter_create("UTF-8", myrealloc, NULL, &input) == + PARSERUTILS_OK); /* Convert filter to UTF-8 encoding */ params.encoding.name = "UTF-8"; diff --git a/test/inputstream.c b/test/inputstream.c index 5e4f134..33b163b 100644 --- a/test/inputstream.c +++ b/test/inputstream.c @@ -40,9 +40,8 @@ int main(int argc, char **argv) assert(parserutils_initialise(argv[1], myrealloc, NULL) == PARSERUTILS_OK); - stream = parserutils_inputstream_create("UTF-8", 1, NULL, - myrealloc, NULL); - assert(stream != NULL); + assert(parserutils_inputstream_create("UTF-8", 1, NULL, + myrealloc, NULL, &stream) == PARSERUTILS_OK); fp = fopen(argv[2], "rb"); if (fp == NULL) { diff --git a/test/rbtree.c b/test/rbtree.c index a28bcfb..ac27964 100644 --- a/test/rbtree.c +++ b/test/rbtree.c @@ -25,8 +25,8 @@ int main(int argc, char **argv) UNUSED(argc); UNUSED(argv); - tree = parserutils_rbtree_create(mycmp, myrealloc, NULL); - assert(tree != NULL); + assert(parserutils_rbtree_create(mycmp, myrealloc, NULL, &tree) == + PARSERUTILS_OK); #define N 40000 #define G 307 diff --git a/test/regression/cscodec-segv.c b/test/regression/cscodec-segv.c index 5802fdf..0cf9f69 100644 --- a/test/regression/cscodec-segv.c +++ b/test/regression/cscodec-segv.c @@ -24,8 +24,8 @@ int main(int argc, char **argv) assert(parserutils_charset_initialise(argv[1], myrealloc, NULL) == PARSERUTILS_OK); - codec = parserutils_charset_codec_create("UTF-8", myrealloc, NULL); - assert(codec != NULL); + assert(parserutils_charset_codec_create("UTF-8", myrealloc, NULL, + &codec) == PARSERUTILS_OK); parserutils_charset_codec_destroy(codec); diff --git a/test/regression/filter-segv.c b/test/regression/filter-segv.c index 761caab..a884b6d 100644 --- a/test/regression/filter-segv.c +++ b/test/regression/filter-segv.c @@ -26,8 +26,8 @@ int main(int argc, char **argv) assert(parserutils_initialise(argv[1], myrealloc, NULL) == PARSERUTILS_OK); - input = parserutils_filter_create("UTF-8", myrealloc, NULL); - assert(input); + assert(parserutils_filter_create("UTF-8", myrealloc, NULL, &input) == + PARSERUTILS_OK); parserutils_filter_destroy(input); diff --git a/test/regression/stream-nomem.c b/test/regression/stream-nomem.c index f62b392..004a807 100644 --- a/test/regression/stream-nomem.c +++ b/test/regression/stream-nomem.c @@ -52,9 +52,8 @@ int main(int argc, char **argv) assert(parserutils_initialise(argv[1], myrealloc, NULL) == PARSERUTILS_OK); - stream = parserutils_inputstream_create("UTF-8", 0, - NULL, myrealloc, NULL); - assert(stream != NULL); + assert(parserutils_inputstream_create("UTF-8", 0, + NULL, myrealloc, NULL, &stream) == PARSERUTILS_OK); assert(parserutils_inputstream_append(stream, input_buffer, BUFFER_SIZE) == PARSERUTILS_OK); |