From 7adaf92154adc7f3455769ca197f906e3d4cddaa Mon Sep 17 00:00:00 2001 From: John Mark Bell Date: Thu, 27 Nov 2008 12:14:07 +0000 Subject: css_string is now the same as a parserutils_dict_entry. This allows us to use dict entries directly as strings. iChange the way in which selectors are represented. This significantly reduces memory requirements -- reducing the approximate usage count (excludes the string dictionary, which is about 360k) of allzengarden.css from 4,535,400 bytes to 2,414,312 bytes on a 64bit platform. The string dictionary is now created and owned by the stylesheet object. The parser is just given access to this so that it can store strings in it. svn path=/trunk/libcss/; revision=5809 --- include/libcss/types.h | 10 +- src/lex/lex.c | 62 +++--- src/parse/css21.c | 62 +++--- src/parse/css21props.c | 520 ++++++++++++++++++++++++------------------------- src/parse/parse.c | 186 +++++++++--------- src/parse/parse.h | 4 +- src/stylesheet.c | 253 ++++++++++++++++++------ src/stylesheet.h | 36 ++-- src/utils/utils.h | 4 +- test/lex-auto.c | 8 +- test/lex.c | 30 +-- test/number.c | 2 +- test/parse.c | 16 +- 13 files changed, 676 insertions(+), 517 deletions(-) diff --git a/include/libcss/types.h b/include/libcss/types.h index 4cb8fbc..7bce679 100644 --- a/include/libcss/types.h +++ b/include/libcss/types.h @@ -12,6 +12,8 @@ #include #include +#include + /** Source of charset information, in order of importance * A client-dictated charset will override all others. * A document-specified charset will override autodetection or the default */ @@ -53,11 +55,11 @@ typedef enum css_origin { /** * String type + * + * \todo It might be better to define parserutils_string, and use that. + * (where parserutils_string is identical to parserutils_dict_entry) */ -typedef struct css_string { - uint8_t *ptr; /**< Pointer to data */ - size_t len; /**< Byte length of string */ -} css_string; +typedef parserutils_dict_entry css_string; typedef struct css_stylesheet css_stylesheet; diff --git a/src/lex/lex.c b/src/lex/lex.c index 7565b60..a649304 100644 --- a/src/lex/lex.c +++ b/src/lex/lex.c @@ -194,7 +194,7 @@ css_error css_lexer_create(parserutils_inputstream *input, lex->input = input; lex->bytesReadForToken = 0; lex->token.type = CSS_TOKEN_EOF; - lex->token.data.ptr = NULL; + lex->token.data.data = NULL; lex->token.data.len = 0; lex->escapeSeen = false; lex->unescapedTokenData = NULL; @@ -372,44 +372,44 @@ css_error emitToken(css_lexer *lexer, css_token_type type, /* Calculate token data start pointer. We have to do this here as * the inputstream's buffer may have moved under us. */ if (lexer->escapeSeen) { - t->data.ptr = lexer->unescapedTokenData->data; + t->data.data = lexer->unescapedTokenData->data; } else { size_t clen; - uintptr_t ptr = parserutils_inputstream_peek( + uintptr_t data = parserutils_inputstream_peek( lexer->input, 0, &clen); assert(type == CSS_TOKEN_EOF || - (ptr != PARSERUTILS_INPUTSTREAM_EOF && - ptr != PARSERUTILS_INPUTSTREAM_OOD)); + (data != PARSERUTILS_INPUTSTREAM_EOF && + data != PARSERUTILS_INPUTSTREAM_OOD)); - t->data.ptr = (type == CSS_TOKEN_EOF) ? NULL : (uint8_t *) ptr; + t->data.data = (type == CSS_TOKEN_EOF) ? NULL : (uint8_t *) data; } switch (type) { case CSS_TOKEN_ATKEYWORD: /* Strip the '@' from the front */ - t->data.ptr += 1; + t->data.data += 1; t->data.len -= 1; break; case CSS_TOKEN_STRING: /* Strip the leading quote */ - t->data.ptr += 1; + t->data.data += 1; t->data.len -= 1; /* Strip the trailing quote, iff it exists (may have hit EOF) */ - if (t->data.len > 0 && (t->data.ptr[t->data.len - 1] == '"' || - t->data.ptr[t->data.len - 1] == '\'')) { + if (t->data.len > 0 && (t->data.data[t->data.len - 1] == '"' || + t->data.data[t->data.len - 1] == '\'')) { t->data.len -= 1; } break; case CSS_TOKEN_INVALID_STRING: /* Strip the leading quote */ - t->data.ptr += 1; + t->data.data += 1; t->data.len -= 1; break; case CSS_TOKEN_HASH: /* Strip the '#' from the front */ - t->data.ptr += 1; + t->data.data += 1; t->data.len -= 1; break; case CSS_TOKEN_PERCENTAGE: @@ -421,18 +421,18 @@ css_error emitToken(css_lexer *lexer, css_token_type type, break; case CSS_TOKEN_URI: /* Strip the "url(" from the start */ - t->data.ptr += SLEN("url("); + t->data.data += SLEN("url("); t->data.len -= SLEN("url("); /* Strip any leading whitespace */ - while (isSpace(t->data.ptr[0])) { - t->data.ptr++; + while (isSpace(t->data.data[0])) { + t->data.data++; t->data.len--; } /* Strip any leading quote */ - if (t->data.ptr[0] == '"' || t->data.ptr[0] == '\'') { - t->data.ptr += 1; + if (t->data.data[0] == '"' || t->data.data[0] == '\'') { + t->data.data += 1; t->data.len -= 1; } @@ -441,24 +441,24 @@ css_error emitToken(css_lexer *lexer, css_token_type type, /* Strip any trailing whitespace */ while (t->data.len > 0 && - isSpace(t->data.ptr[t->data.len - 1])) { + isSpace(t->data.data[t->data.len - 1])) { t->data.len--; } /* Strip any trailing quote */ - if (t->data.len > 0 && (t->data.ptr[t->data.len - 1] == '"' || - t->data.ptr[t->data.len - 1] == '\'')) { + if (t->data.len > 0 && (t->data.data[t->data.len - 1] == '"' || + t->data.data[t->data.len - 1] == '\'')) { t->data.len -= 1; } break; case CSS_TOKEN_UNICODE_RANGE: /* Remove "U+" from the start */ - t->data.ptr += SLEN("U+"); + t->data.data += SLEN("U+"); t->data.len -= SLEN("U+"); break; case CSS_TOKEN_COMMENT: /* Strip the leading '/' and '*' */ - t->data.ptr += SLEN("/*"); + t->data.data += SLEN("/*"); t->data.len -= SLEN("/*"); /* Strip the trailing '*' and '/' */ @@ -1166,9 +1166,9 @@ start: /* Reset in preparation for the next token */ t->type = CSS_TOKEN_EOF; - t->data.ptr = NULL; + t->data.data = NULL; t->data.len = 0; - t->lower.ptr = NULL; + t->lower.data = NULL; t->lower.len = 0; t->col = lexer->currentCol; t->line = lexer->currentLine; @@ -1671,7 +1671,7 @@ css_error consumeDigits(css_lexer *lexer) css_error consumeEscape(css_lexer *lexer, bool nl) { - uintptr_t cptr, sptr; + uintptr_t cptr, sdata; uint8_t c; size_t clen, slen; css_error error; @@ -1709,17 +1709,17 @@ css_error consumeEscape(css_lexer *lexer, bool nl) * we must copy the characters we've read to the unescaped buffer */ if (!lexer->escapeSeen) { if (lexer->bytesReadForToken > 1) { - sptr = parserutils_inputstream_peek( + sdata = parserutils_inputstream_peek( lexer->input, 0, &slen); - assert(sptr != PARSERUTILS_INPUTSTREAM_EOF && - sptr != PARSERUTILS_INPUTSTREAM_OOD); + assert(sdata != PARSERUTILS_INPUTSTREAM_EOF && + sdata != PARSERUTILS_INPUTSTREAM_OOD); /* -1 to skip '\\' */ error = css_error_from_parserutils_error( parserutils_buffer_append( lexer->unescapedTokenData, - (const uint8_t *) sptr, + (const uint8_t *) sdata, lexer->bytesReadForToken - 1)); if (error != CSS_OK) return error; @@ -1932,7 +1932,7 @@ css_error consumeUnicode(css_lexer *lexer, uint32_t ucs) uint8_t c = 0; size_t clen; uint8_t utf8[6]; - uint8_t *utf8ptr = utf8; + uint8_t *utf8data = utf8; size_t utf8len = sizeof(utf8); size_t bytesReadInit = lexer->bytesReadForToken; int count; @@ -1968,7 +1968,7 @@ css_error consumeUnicode(css_lexer *lexer, uint32_t ucs) } /* Convert our UCS4 character to UTF-8 */ - error = parserutils_charset_utf8_from_ucs4(ucs, &utf8ptr, &utf8len); + error = parserutils_charset_utf8_from_ucs4(ucs, &utf8data, &utf8len); assert(error == PARSERUTILS_OK); /* Append it to the token data (unescaped buffer already set up) */ diff --git a/src/parse/css21.c b/src/parse/css21.c index 8f4fe0d..4303313 100644 --- a/src/parse/css21.c +++ b/src/parse/css21.c @@ -74,7 +74,7 @@ enum { /* Must be synchronised with above enum */ static struct { - const char *ptr; + const char *data; size_t len; } stringmap[LAST_KNOWN] = { { "charset", SLEN("charset") }, @@ -363,19 +363,19 @@ static inline css_error handleDeclaration(css_css21 *c, /* Selector list parsing */ static inline css_error parseClass(css_css21 *c, const parserutils_vector *vector, int *ctx, - css_selector **specific); + css_selector_detail **specific); static inline css_error parseAttrib(css_css21 *c, const parserutils_vector *vector, int *ctx, - css_selector **specific); + css_selector_detail **specific); static inline css_error parsePseudo(css_css21 *c, const parserutils_vector *vector, int *ctx, - css_selector **specific); + css_selector_detail **specific); static inline css_error parseSpecific(css_css21 *c, const parserutils_vector *vector, int *ctx, - css_selector *parent); + css_selector **parent); static inline css_error parseSelectorSpecifics(css_css21 *c, const parserutils_vector *vector, int *ctx, - css_selector *parent); + css_selector **parent); static inline css_error parseSimpleSelector(css_css21 *c, const parserutils_vector *vector, int *ctx, css_selector **result); @@ -436,7 +436,7 @@ css_error css_css21_create(css_stylesheet *sheet, css_parser *parser, /* Intern all known strings */ for (int i = 0; i < LAST_KNOWN; i++) { c->strings[i] = css_parser_dict_add(parser, - (const uint8_t *) stringmap[i].ptr, + (const uint8_t *) stringmap[i].data, stringmap[i].len); if (c->strings[i] == NULL) { parserutils_stack_destroy(c->context); @@ -645,7 +645,7 @@ css_error handleStartAtRule(css_css21 *c, const parserutils_vector *vector) * there is one */ assert(atkeyword != NULL && atkeyword->type == CSS_TOKEN_ATKEYWORD); - if (atkeyword->lower.ptr == c->strings[CHARSET]) { + if (atkeyword->lower.data == c->strings[CHARSET]) { if (c->state == BEFORE_CHARSET) { /* any0 = STRING */ if (ctx == 0) @@ -663,7 +663,7 @@ css_error handleStartAtRule(css_css21 *c, const parserutils_vector *vector) } else { return CSS_INVALID; } - } else if (atkeyword->lower.ptr == c->strings[IMPORT]) { + } else if (atkeyword->lower.data == c->strings[IMPORT]) { if (c->state != HAD_RULE) { /* any0 = (STRING | URI) ws * (IDENT ws (',' ws IDENT ws)* )? */ @@ -689,16 +689,16 @@ css_error handleStartAtRule(css_css21 *c, const parserutils_vector *vector) /** \todo these depend on nested block support, so we'll disable them * until we have such a thing. This means that we'll ignore the entire * at-rule until then */ - } else if (atkeyword->lower.ptr == c->strings[MEDIA]) { + } else if (atkeyword->lower.data == c->strings[MEDIA]) { /** \todo any0 = IDENT ws (',' ws IDENT ws)* */ - } else if (atkeyword->lower.ptr == c->strings[PAGE]) { + } else if (atkeyword->lower.data == c->strings[PAGE]) { /** \todo any0 = (':' IDENT)? ws */ #endif } else { return CSS_INVALID; } - entry.data = atkeyword->lower.ptr; + entry.data = atkeyword->lower.data; perror = parserutils_stack_push(c->context, (void *) &entry); if (perror != PARSERUTILS_OK) { @@ -816,7 +816,7 @@ css_error handleDeclaration(css_css21 *c, const parserutils_vector *vector) ******************************************************************************/ css_error parseClass(css_css21 *c, const parserutils_vector *vector, int *ctx, - css_selector **specific) + css_selector_detail **specific) { const css_token *token; @@ -829,12 +829,12 @@ css_error parseClass(css_css21 *c, const parserutils_vector *vector, int *ctx, if (token == NULL || token->type != CSS_TOKEN_IDENT) return CSS_INVALID; - return css_stylesheet_selector_create(c->sheet, + return css_stylesheet_selector_detail_create(c->sheet, CSS_SELECTOR_CLASS, &token->data, NULL, specific); } css_error parseAttrib(css_css21 *c, const parserutils_vector *vector, int *ctx, - css_selector **specific) + css_selector_detail **specific) { const css_token *token, *name, *value = NULL; css_selector_type type = CSS_SELECTOR_ATTRIBUTE; @@ -887,13 +887,13 @@ css_error parseAttrib(css_css21 *c, const parserutils_vector *vector, int *ctx, return CSS_INVALID; } - return css_stylesheet_selector_create(c->sheet, type, + return css_stylesheet_selector_detail_create(c->sheet, type, &name->data, value != NULL ? &value->data : NULL, specific); } css_error parsePseudo(css_css21 *c, const parserutils_vector *vector, int *ctx, - css_selector **specific) + css_selector_detail **specific) { const css_token *token, *name, *value = NULL; @@ -927,18 +927,18 @@ css_error parsePseudo(css_css21 *c, const parserutils_vector *vector, int *ctx, return CSS_INVALID; } - return css_stylesheet_selector_create(c->sheet, + return css_stylesheet_selector_detail_create(c->sheet, CSS_SELECTOR_PSEUDO, &name->data, value != NULL ? &value->data : NULL, specific); } css_error parseSpecific(css_css21 *c, const parserutils_vector *vector, int *ctx, - css_selector *parent) + css_selector **parent) { css_error error; const css_token *token; - css_selector *specific = NULL; + css_selector_detail *specific = NULL; /* specific -> [ HASH | class | attrib | pseudo ] */ @@ -947,7 +947,7 @@ css_error parseSpecific(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_HASH) { - error = css_stylesheet_selector_create(c->sheet, + error = css_stylesheet_selector_detail_create(c->sheet, CSS_SELECTOR_ID, &token->data, NULL, &specific); if (error != CSS_OK) return error; @@ -972,7 +972,7 @@ css_error parseSpecific(css_css21 *c, error = css_stylesheet_selector_append_specific(c->sheet, parent, specific); if (error != CSS_OK) { - css_stylesheet_selector_destroy(c->sheet, specific); + css_stylesheet_selector_detail_destroy(c->sheet, specific); return error; } @@ -981,7 +981,7 @@ css_error parseSpecific(css_css21 *c, css_error parseSelectorSpecifics(css_css21 *c, const parserutils_vector *vector, int *ctx, - css_selector *parent) + css_selector **parent) { css_error error; const css_token *token; @@ -1028,7 +1028,7 @@ css_error parseSimpleSelector(css_css21 *c, parserutils_vector_iterate(vector, ctx); } else { /* Universal selector */ - css_string name = { (uint8_t *) "*", 1 }; + static css_string name = { 1, (uint8_t *) "*" }; error = css_stylesheet_selector_create(c->sheet, CSS_SELECTOR_ELEMENT, &name, NULL, &selector); @@ -1036,16 +1036,22 @@ css_error parseSimpleSelector(css_css21 *c, return error; /* Ensure we have at least one specific selector */ - error = parseSpecific(c, vector, ctx, selector); + error = parseSpecific(c, vector, ctx, &selector); if (error != CSS_OK) { css_stylesheet_selector_destroy(c->sheet, selector); return error; } } + error = parseSelectorSpecifics(c, vector, ctx, &selector); + if (error != CSS_OK) { + css_stylesheet_selector_destroy(c->sheet, selector); + return error; + } + *result = selector; - return parseSelectorSpecifics(c, vector, ctx, selector); + return CSS_OK; } css_error parseCombinator(css_css21 *c, const parserutils_vector *vector, @@ -1219,7 +1225,7 @@ css_error parseProperty(css_css21 *c, const css_token *property, /* Find property index */ /** \todo improve on this linear search */ for (i = FIRST_PROP; i <= LAST_PROP; i++) { - if (property->lower.ptr == c->strings[i]) + if (property->lower.data == c->strings[i]) break; } if (i == LAST_PROP + 1) @@ -1279,7 +1285,7 @@ void consumeWhitespace(const parserutils_vector *vector, int *ctx) bool tokenIsChar(const css_token *token, uint8_t c) { return token != NULL && token->type == CSS_TOKEN_CHAR && - token->lower.len == 1 && token->lower.ptr[0] == c; + token->lower.len == 1 && token->lower.data[0] == c; } diff --git a/src/parse/css21props.c b/src/parse/css21props.c index fe0c405..43b0710 100644 --- a/src/parse/css21props.c +++ b/src/parse/css21props.c @@ -480,11 +480,11 @@ css_error parse_background_attachment(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[FIXED]) { + } else if (ident->lower.data == c->strings[FIXED]) { value = BACKGROUND_ATTACHMENT_FIXED; - } else if (ident->lower.ptr == c->strings[SCROLL]) { + } else if (ident->lower.data == c->strings[SCROLL]) { value = BACKGROUND_ATTACHMENT_SCROLL; } else return CSS_INVALID; @@ -520,11 +520,11 @@ css_error parse_background_color(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[TRANSPARENT]) { + token->lower.data == c->strings[TRANSPARENT]) { parserutils_vector_iterate(vector, ctx); value = BACKGROUND_COLOR_TRANSPARENT; } else { @@ -582,10 +582,10 @@ css_error parse_background_image(css_css21 *c, return error; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[NONE]) { + token->lower.data == c->strings[NONE]) { value = BACKGROUND_IMAGE_NONE; } else if (token->type == CSS_TOKEN_URI) { value = BACKGROUND_IMAGE_URI; @@ -607,7 +607,7 @@ css_error parse_background_image(css_css21 *c, memcpy((*result)->bytecode, &opv, sizeof(opv)); if ((flags & FLAG_INHERIT) == false && value == BACKGROUND_IMAGE_URI) { memcpy((uint8_t *) (*result)->bytecode + sizeof(opv), - &token->data.ptr, sizeof(uint8_t *)); + &token->data.data, sizeof(uint8_t *)); memcpy((uint8_t *) (*result)->bytecode + sizeof(opv) + sizeof(uint8_t *), &token->data.len, sizeof(size_t)); @@ -648,15 +648,15 @@ css_error parse_background_repeat(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[NO_REPEAT]) { + } else if (ident->lower.data == c->strings[NO_REPEAT]) { value = BACKGROUND_REPEAT_NO_REPEAT; - } else if (ident->lower.ptr == c->strings[REPEAT_X]) { + } else if (ident->lower.data == c->strings[REPEAT_X]) { value = BACKGROUND_REPEAT_REPEAT_X; - } else if (ident->lower.ptr == c->strings[REPEAT_Y]) { + } else if (ident->lower.data == c->strings[REPEAT_Y]) { value = BACKGROUND_REPEAT_REPEAT_Y; - } else if (ident->lower.ptr == c->strings[REPEAT]) { + } else if (ident->lower.data == c->strings[REPEAT]) { value = BACKGROUND_REPEAT_REPEAT; } else return CSS_INVALID; @@ -714,11 +714,11 @@ css_error parse_border_collapse(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[COLLAPSE]) { + } else if (ident->lower.data == c->strings[COLLAPSE]) { value = BORDER_COLLAPSE_COLLAPSE; - } else if (ident->lower.ptr == c->strings[SEPARATE]) { + } else if (ident->lower.data == c->strings[SEPARATE]) { value = BORDER_COLLAPSE_SEPARATE; } else return CSS_INVALID; @@ -831,11 +831,11 @@ css_error parse_bottom(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[AUTO]) { + token->lower.data == c->strings[AUTO]) { parserutils_vector_iterate(vector, ctx); value = BOTTOM_AUTO; } else { @@ -895,11 +895,11 @@ css_error parse_caption_side(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[TOP]) { + } else if (ident->lower.data == c->strings[TOP]) { value = CAPTION_SIDE_TOP; - } else if (ident->lower.ptr == c->strings[BOTTOM]) { + } else if (ident->lower.data == c->strings[BOTTOM]) { value = CAPTION_SIDE_BOTTOM; } else return CSS_INVALID; @@ -936,15 +936,15 @@ css_error parse_clear(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[RIGHT]) { + } else if (ident->lower.data == c->strings[RIGHT]) { value = CLEAR_RIGHT; - } else if (ident->lower.ptr == c->strings[LEFT]) { + } else if (ident->lower.data == c->strings[LEFT]) { value = CLEAR_LEFT; - } else if (ident->lower.ptr == c->strings[BOTH]) { + } else if (ident->lower.data == c->strings[BOTH]) { value = CLEAR_BOTH; - } else if (ident->lower.ptr == c->strings[NONE]) { + } else if (ident->lower.data == c->strings[NONE]) { value = CLEAR_NONE; } else return CSS_INVALID; @@ -993,7 +993,7 @@ css_error parse_color(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags |= FLAG_INHERIT; } else { @@ -1090,10 +1090,10 @@ css_error parse_cue_after(css_css21 *c, return error; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[NONE]) { + token->lower.data == c->strings[NONE]) { value = CUE_AFTER_NONE; } else if (token->type == CSS_TOKEN_URI) { value = CUE_AFTER_URI; @@ -1115,7 +1115,7 @@ css_error parse_cue_after(css_css21 *c, memcpy((*result)->bytecode, &opv, sizeof(opv)); if ((flags & FLAG_INHERIT) == false && value == CUE_AFTER_URI) { memcpy((uint8_t *) (*result)->bytecode + sizeof(opv), - &token->data.ptr, sizeof(uint8_t *)); + &token->data.data, sizeof(uint8_t *)); memcpy((uint8_t *) (*result)->bytecode + sizeof(opv) + sizeof(uint8_t *), &token->data.len, sizeof(size_t)); @@ -1146,10 +1146,10 @@ css_error parse_cue_before(css_css21 *c, return error; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[NONE]) { + token->lower.data == c->strings[NONE]) { value = CUE_BEFORE_NONE; } else if (token->type == CSS_TOKEN_URI) { value = CUE_BEFORE_URI; @@ -1171,7 +1171,7 @@ css_error parse_cue_before(css_css21 *c, memcpy((*result)->bytecode, &opv, sizeof(opv)); if ((flags & FLAG_INHERIT) == false && value == CUE_BEFORE_URI) { memcpy((uint8_t *) (*result)->bytecode + sizeof(opv), - &token->data.ptr, sizeof(uint8_t *)); + &token->data.data, sizeof(uint8_t *)); memcpy((uint8_t *) (*result)->bytecode + sizeof(opv) + sizeof(uint8_t *), &token->data.len, sizeof(size_t)); @@ -1212,11 +1212,11 @@ css_error parse_direction(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[LTR]) { + } else if (ident->lower.data == c->strings[LTR]) { value = DIRECTION_LTR; - } else if (ident->lower.ptr == c->strings[RTL]) { + } else if (ident->lower.data == c->strings[RTL]) { value = DIRECTION_RTL; } else return CSS_INVALID; @@ -1256,39 +1256,39 @@ css_error parse_display(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[INLINE]) { + } else if (ident->lower.data == c->strings[INLINE]) { value = DISPLAY_INLINE; - } else if (ident->lower.ptr == c->strings[BLOCK]) { + } else if (ident->lower.data == c->strings[BLOCK]) { value = DISPLAY_BLOCK; - } else if (ident->lower.ptr == c->strings[LIST_ITEM]) { + } else if (ident->lower.data == c->strings[LIST_ITEM]) { value = DISPLAY_LIST_ITEM; - } else if (ident->lower.ptr == c->strings[RUN_IN]) { + } else if (ident->lower.data == c->strings[RUN_IN]) { value = DISPLAY_RUN_IN; - } else if (ident->lower.ptr == c->strings[INLINE_BLOCK]) { + } else if (ident->lower.data == c->strings[INLINE_BLOCK]) { value = DISPLAY_INLINE_BLOCK; - } else if (ident->lower.ptr == c->strings[TABLE]) { + } else if (ident->lower.data == c->strings[TABLE]) { value = DISPLAY_TABLE; - } else if (ident->lower.ptr == c->strings[INLINE_TABLE]) { + } else if (ident->lower.data == c->strings[INLINE_TABLE]) { value = DISPLAY_INLINE_TABLE; - } else if (ident->lower.ptr == c->strings[TABLE_ROW_GROUP]) { + } else if (ident->lower.data == c->strings[TABLE_ROW_GROUP]) { value = DISPLAY_TABLE_ROW_GROUP; - } else if (ident->lower.ptr == c->strings[TABLE_HEADER_GROUP]) { + } else if (ident->lower.data == c->strings[TABLE_HEADER_GROUP]) { value = DISPLAY_TABLE_HEADER_GROUP; - } else if (ident->lower.ptr == c->strings[TABLE_FOOTER_GROUP]) { + } else if (ident->lower.data == c->strings[TABLE_FOOTER_GROUP]) { value = DISPLAY_TABLE_FOOTER_GROUP; - } else if (ident->lower.ptr == c->strings[TABLE_ROW]) { + } else if (ident->lower.data == c->strings[TABLE_ROW]) { value = DISPLAY_TABLE_ROW; - } else if (ident->lower.ptr == c->strings[TABLE_COLUMN_GROUP]) { + } else if (ident->lower.data == c->strings[TABLE_COLUMN_GROUP]) { value = DISPLAY_TABLE_COLUMN_GROUP; - } else if (ident->lower.ptr == c->strings[TABLE_COLUMN]) { + } else if (ident->lower.data == c->strings[TABLE_COLUMN]) { value = DISPLAY_TABLE_COLUMN; - } else if (ident->lower.ptr == c->strings[TABLE_CELL]) { + } else if (ident->lower.data == c->strings[TABLE_CELL]) { value = DISPLAY_TABLE_CELL; - } else if (ident->lower.ptr == c->strings[TABLE_CAPTION]) { + } else if (ident->lower.data == c->strings[TABLE_CAPTION]) { value = DISPLAY_TABLE_CAPTION; - } else if (ident->lower.ptr == c->strings[NONE]) { + } else if (ident->lower.data == c->strings[NONE]) { value = DISPLAY_NONE; } else return CSS_INVALID; @@ -1325,27 +1325,27 @@ css_error parse_elevation(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[BELOW]) { + token->lower.data == c->strings[BELOW]) { parserutils_vector_iterate(vector, ctx); value = ELEVATION_BELOW; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[LEVEL]) { + token->lower.data == c->strings[LEVEL]) { parserutils_vector_iterate(vector, ctx); value = ELEVATION_LEVEL; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[ABOVE]) { + token->lower.data == c->strings[ABOVE]) { parserutils_vector_iterate(vector, ctx); value = ELEVATION_ABOVE; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[HIGHER]) { + token->lower.data == c->strings[HIGHER]) { parserutils_vector_iterate(vector, ctx); value = ELEVATION_HIGHER; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[LOWER]) { + token->lower.data == c->strings[LOWER]) { parserutils_vector_iterate(vector, ctx); value = ELEVATION_LOWER; } else { @@ -1405,11 +1405,11 @@ css_error parse_empty_cells(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[SHOW]) { + } else if (ident->lower.data == c->strings[SHOW]) { value = EMPTY_CELLS_SHOW; - } else if (ident->lower.ptr == c->strings[HIDE]) { + } else if (ident->lower.data == c->strings[HIDE]) { value = EMPTY_CELLS_HIDE; } else return CSS_INVALID; @@ -1446,13 +1446,13 @@ css_error parse_float(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[LEFT]) { + } else if (ident->lower.data == c->strings[LEFT]) { value = FLOAT_LEFT; - } else if (ident->lower.ptr == c->strings[RIGHT]) { + } else if (ident->lower.data == c->strings[RIGHT]) { value = FLOAT_RIGHT; - } else if (ident->lower.ptr == c->strings[NONE]) { + } else if (ident->lower.data == c->strings[NONE]) { value = FLOAT_NONE; } else return CSS_INVALID; @@ -1504,43 +1504,43 @@ css_error parse_font_size(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[XX_SMALL]) { + token->lower.data == c->strings[XX_SMALL]) { parserutils_vector_iterate(vector, ctx); value = FONT_SIZE_XX_SMALL; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[X_SMALL]) { + token->lower.data == c->strings[X_SMALL]) { parserutils_vector_iterate(vector, ctx); value = FONT_SIZE_X_SMALL; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[SMALL]) { + token->lower.data == c->strings[SMALL]) { parserutils_vector_iterate(vector, ctx); value = FONT_SIZE_SMALL; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[MEDIUM]) { + token->lower.data == c->strings[MEDIUM]) { parserutils_vector_iterate(vector, ctx); value = FONT_SIZE_MEDIUM; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[LARGE]) { + token->lower.data == c->strings[LARGE]) { parserutils_vector_iterate(vector, ctx); value = FONT_SIZE_LARGE; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[X_LARGE]) { + token->lower.data == c->strings[X_LARGE]) { parserutils_vector_iterate(vector, ctx); value = FONT_SIZE_X_LARGE; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[XX_LARGE]) { + token->lower.data == c->strings[XX_LARGE]) { parserutils_vector_iterate(vector, ctx); value = FONT_SIZE_XX_LARGE; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[LARGER]) { + token->lower.data == c->strings[LARGER]) { parserutils_vector_iterate(vector, ctx); value = FONT_SIZE_LARGER; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[SMALLER]) { + token->lower.data == c->strings[SMALLER]) { parserutils_vector_iterate(vector, ctx); value = FONT_SIZE_SMALLER; } else { @@ -1600,13 +1600,13 @@ css_error parse_font_style(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[NORMAL]) { + } else if (ident->lower.data == c->strings[NORMAL]) { value = FONT_STYLE_NORMAL; - } else if (ident->lower.ptr == c->strings[ITALIC]) { + } else if (ident->lower.data == c->strings[ITALIC]) { value = FONT_STYLE_ITALIC; - } else if (ident->lower.ptr == c->strings[OBLIQUE]) { + } else if (ident->lower.data == c->strings[OBLIQUE]) { value = FONT_STYLE_OBLIQUE; } else return CSS_INVALID; @@ -1643,11 +1643,11 @@ css_error parse_font_variant(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[NORMAL]) { + } else if (ident->lower.data == c->strings[NORMAL]) { value = FONT_VARIANT_NORMAL; - } else if (ident->lower.ptr == c->strings[SMALL_CAPS]) { + } else if (ident->lower.data == c->strings[SMALL_CAPS]) { value = FONT_VARIANT_SMALL_CAPS; } else return CSS_INVALID; @@ -1686,7 +1686,7 @@ css_error parse_font_weight(css_css21 *c, if (error != CSS_OK) return error; - if (token->lower.ptr == c->strings[INHERIT]) { + if (token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { size_t consumed = 0; @@ -1707,13 +1707,13 @@ css_error parse_font_weight(css_css21 *c, case 900: value = FONT_WEIGHT_900; break; default: return CSS_INVALID; } - } else if (token->lower.ptr == c->strings[NORMAL]) { + } else if (token->lower.data == c->strings[NORMAL]) { value = FONT_WEIGHT_NORMAL; - } else if (token->lower.ptr == c->strings[BOLD]) { + } else if (token->lower.data == c->strings[BOLD]) { value = FONT_WEIGHT_BOLD; - } else if (token->lower.ptr == c->strings[BOLDER]) { + } else if (token->lower.data == c->strings[BOLDER]) { value = FONT_WEIGHT_BOLDER; - } else if (token->lower.ptr == c->strings[LIGHTER]) { + } else if (token->lower.data == c->strings[LIGHTER]) { value = FONT_WEIGHT_LIGHTER; } else return CSS_INVALID; @@ -1750,11 +1750,11 @@ css_error parse_height(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[AUTO]) { + token->lower.data == c->strings[AUTO]) { parserutils_vector_iterate(vector, ctx); value = HEIGHT_AUTO; } else { @@ -1814,11 +1814,11 @@ css_error parse_left(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[AUTO]) { + token->lower.data == c->strings[AUTO]) { parserutils_vector_iterate(vector, ctx); value = LEFT_AUTO; } else { @@ -1878,11 +1878,11 @@ css_error parse_letter_spacing(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[NORMAL]) { + token->lower.data == c->strings[NORMAL]) { parserutils_vector_iterate(vector, ctx); value = LETTER_SPACING_NORMAL; } else { @@ -1943,11 +1943,11 @@ css_error parse_line_height(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[NORMAL]) { + token->lower.data == c->strings[NORMAL]) { parserutils_vector_iterate(vector, ctx); value = LINE_HEIGHT_NORMAL; } else if (token->type == CSS_TOKEN_NUMBER) { @@ -2021,10 +2021,10 @@ css_error parse_list_style_image(css_css21 *c, return error; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[NONE]) { + token->lower.data == c->strings[NONE]) { value = LIST_STYLE_IMAGE_NONE; } else if (token->type == CSS_TOKEN_URI) { value = LIST_STYLE_IMAGE_URI; @@ -2046,7 +2046,7 @@ css_error parse_list_style_image(css_css21 *c, memcpy((*result)->bytecode, &opv, sizeof(opv)); if ((flags & FLAG_INHERIT) == false && value == LIST_STYLE_IMAGE_URI) { memcpy((uint8_t *) (*result)->bytecode + sizeof(opv), - &token->data.ptr, sizeof(uint8_t *)); + &token->data.data, sizeof(uint8_t *)); memcpy((uint8_t *) (*result)->bytecode + sizeof(opv) + sizeof(uint8_t *), &token->data.len, sizeof(size_t)); @@ -2074,11 +2074,11 @@ css_error parse_list_style_position(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[INSIDE]) { + } else if (ident->lower.data == c->strings[INSIDE]) { value = LIST_STYLE_POSITION_INSIDE; - } else if (ident->lower.ptr == c->strings[OUTSIDE]) { + } else if (ident->lower.data == c->strings[OUTSIDE]) { value = LIST_STYLE_POSITION_OUTSIDE; } else return CSS_INVALID; @@ -2119,37 +2119,37 @@ css_error parse_list_style_type(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[DISC]) { + } else if (ident->lower.data == c->strings[DISC]) { value = LIST_STYLE_TYPE_DISC; - } else if (ident->lower.ptr == c->strings[CIRCLE]) { + } else if (ident->lower.data == c->strings[CIRCLE]) { value = LIST_STYLE_TYPE_CIRCLE; - } else if (ident->lower.ptr == c->strings[SQUARE]) { + } else if (ident->lower.data == c->strings[SQUARE]) { value = LIST_STYLE_TYPE_SQUARE; - } else if (ident->lower.ptr == c->strings[DECIMAL]) { + } else if (ident->lower.data == c->strings[DECIMAL]) { value = LIST_STYLE_TYPE_DECIMAL; - } else if (ident->lower.ptr == c->strings[DECIMAL_LEADING_ZERO]) { + } else if (ident->lower.data == c->strings[DECIMAL_LEADING_ZERO]) { value = LIST_STYLE_TYPE_DECIMAL_LEADING_ZERO; - } else if (ident->lower.ptr == c->strings[LOWER_ROMAN]) { + } else if (ident->lower.data == c->strings[LOWER_ROMAN]) { value = LIST_STYLE_TYPE_LOWER_ROMAN; - } else if (ident->lower.ptr == c->strings[UPPER_ROMAN]) { + } else if (ident->lower.data == c->strings[UPPER_ROMAN]) { value = LIST_STYLE_TYPE_UPPER_ROMAN; - } else if (ident->lower.ptr == c->strings[LOWER_GREEK]) { + } else if (ident->lower.data == c->strings[LOWER_GREEK]) { value = LIST_STYLE_TYPE_LOWER_GREEK; - } else if (ident->lower.ptr == c->strings[LOWER_LATIN]) { + } else if (ident->lower.data == c->strings[LOWER_LATIN]) { value = LIST_STYLE_TYPE_LOWER_LATIN; - } else if (ident->lower.ptr == c->strings[UPPER_LATIN]) { + } else if (ident->lower.data == c->strings[UPPER_LATIN]) { value = LIST_STYLE_TYPE_UPPER_LATIN; - } else if (ident->lower.ptr == c->strings[ARMENIAN]) { + } else if (ident->lower.data == c->strings[ARMENIAN]) { value = LIST_STYLE_TYPE_ARMENIAN; - } else if (ident->lower.ptr == c->strings[GEORGIAN]) { + } else if (ident->lower.data == c->strings[GEORGIAN]) { value = LIST_STYLE_TYPE_GEORGIAN; - } else if (ident->lower.ptr == c->strings[LOWER_ALPHA]) { + } else if (ident->lower.data == c->strings[LOWER_ALPHA]) { value = LIST_STYLE_TYPE_LOWER_ALPHA; - } else if (ident->lower.ptr == c->strings[UPPER_ALPHA]) { + } else if (ident->lower.data == c->strings[UPPER_ALPHA]) { value = LIST_STYLE_TYPE_UPPER_ALPHA; - } else if (ident->lower.ptr == c->strings[NONE]) { + } else if (ident->lower.data == c->strings[NONE]) { value = LIST_STYLE_TYPE_NONE; } else return CSS_INVALID; @@ -2214,11 +2214,11 @@ css_error parse_max_height(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[NONE]) { + token->lower.data == c->strings[NONE]) { parserutils_vector_iterate(vector, ctx); value = MAX_HEIGHT_NONE; } else { @@ -2278,11 +2278,11 @@ css_error parse_max_width(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[NONE]) { + token->lower.data == c->strings[NONE]) { parserutils_vector_iterate(vector, ctx); value = MAX_WIDTH_NONE; } else { @@ -2342,7 +2342,7 @@ css_error parse_min_height(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else { @@ -2402,7 +2402,7 @@ css_error parse_min_width(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else { @@ -2465,7 +2465,7 @@ css_error parse_orphans(css_css21 *c, if (error != CSS_OK) return error; - if (token->lower.ptr == c->strings[INHERIT]) { + if (token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { size_t consumed = 0; @@ -2518,11 +2518,11 @@ css_error parse_outline_color(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INVERT]) { + token->lower.data == c->strings[INVERT]) { parserutils_vector_iterate(vector, ctx); value = OUTLINE_COLOR_INVERT; } else { @@ -2631,15 +2631,15 @@ css_error parse_overflow(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[VISIBLE]) { + } else if (ident->lower.data == c->strings[VISIBLE]) { value = OVERFLOW_VISIBLE; - } else if (ident->lower.ptr == c->strings[HIDDEN]) { + } else if (ident->lower.data == c->strings[HIDDEN]) { value = OVERFLOW_HIDDEN; - } else if (ident->lower.ptr == c->strings[SCROLL]) { + } else if (ident->lower.data == c->strings[SCROLL]) { value = OVERFLOW_SCROLL; - } else if (ident->lower.ptr == c->strings[AUTO]) { + } else if (ident->lower.data == c->strings[AUTO]) { value = OVERFLOW_AUTO; } else return CSS_INVALID; @@ -2704,17 +2704,17 @@ css_error parse_page_break_after(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[AUTO]) { + } else if (ident->lower.data == c->strings[AUTO]) { value = PAGE_BREAK_AFTER_AUTO; - } else if (ident->lower.ptr == c->strings[ALWAYS]) { + } else if (ident->lower.data == c->strings[ALWAYS]) { value = PAGE_BREAK_AFTER_ALWAYS; - } else if (ident->lower.ptr == c->strings[AVOID]) { + } else if (ident->lower.data == c->strings[AVOID]) { value = PAGE_BREAK_AFTER_AVOID; - } else if (ident->lower.ptr == c->strings[LEFT]) { + } else if (ident->lower.data == c->strings[LEFT]) { value = PAGE_BREAK_AFTER_LEFT; - } else if (ident->lower.ptr == c->strings[RIGHT]) { + } else if (ident->lower.data == c->strings[RIGHT]) { value = PAGE_BREAK_AFTER_RIGHT; } else return CSS_INVALID; @@ -2751,17 +2751,17 @@ css_error parse_page_break_before(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[AUTO]) { + } else if (ident->lower.data == c->strings[AUTO]) { value = PAGE_BREAK_BEFORE_AUTO; - } else if (ident->lower.ptr == c->strings[ALWAYS]) { + } else if (ident->lower.data == c->strings[ALWAYS]) { value = PAGE_BREAK_BEFORE_ALWAYS; - } else if (ident->lower.ptr == c->strings[AVOID]) { + } else if (ident->lower.data == c->strings[AVOID]) { value = PAGE_BREAK_BEFORE_AVOID; - } else if (ident->lower.ptr == c->strings[LEFT]) { + } else if (ident->lower.data == c->strings[LEFT]) { value = PAGE_BREAK_BEFORE_LEFT; - } else if (ident->lower.ptr == c->strings[RIGHT]) { + } else if (ident->lower.data == c->strings[RIGHT]) { value = PAGE_BREAK_BEFORE_RIGHT; } else return CSS_INVALID; @@ -2798,11 +2798,11 @@ css_error parse_page_break_inside(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[AUTO]) { + } else if (ident->lower.data == c->strings[AUTO]) { value = PAGE_BREAK_INSIDE_AUTO; - } else if (ident->lower.ptr == c->strings[AVOID]) { + } else if (ident->lower.data == c->strings[AVOID]) { value = PAGE_BREAK_INSIDE_AVOID; } else return CSS_INVALID; @@ -2839,7 +2839,7 @@ css_error parse_pause_after(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else { @@ -2899,7 +2899,7 @@ css_error parse_pause_before(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else { @@ -2962,7 +2962,7 @@ css_error parse_pitch_range(css_css21 *c, if (error != CSS_OK) return error; - if (token->lower.ptr == c->strings[INHERIT]) { + if (token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { size_t consumed = 0; @@ -3015,23 +3015,23 @@ css_error parse_pitch(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[X_LOW]) { + token->lower.data == c->strings[X_LOW]) { value = PITCH_X_LOW; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[LOW]) { + token->lower.data == c->strings[LOW]) { value = PITCH_LOW; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[MEDIUM]) { + token->lower.data == c->strings[MEDIUM]) { value = PITCH_MEDIUM; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[HIGH]) { + token->lower.data == c->strings[HIGH]) { value = PITCH_HIGH; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[X_HIGH]) { + token->lower.data == c->strings[X_HIGH]) { value = PITCH_X_HIGH; } else { error = parse_unit_specifier(c, vector, ctx, &length, &unit); @@ -3104,15 +3104,15 @@ css_error parse_position(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[STATIC]) { + } else if (ident->lower.data == c->strings[STATIC]) { value = POSITION_STATIC; - } else if (ident->lower.ptr == c->strings[RELATIVE]) { + } else if (ident->lower.data == c->strings[RELATIVE]) { value = POSITION_RELATIVE; - } else if (ident->lower.ptr == c->strings[ABSOLUTE]) { + } else if (ident->lower.data == c->strings[ABSOLUTE]) { value = POSITION_ABSOLUTE; - } else if (ident->lower.ptr == c->strings[FIXED]) { + } else if (ident->lower.data == c->strings[FIXED]) { value = POSITION_FIXED; } else return CSS_INVALID; @@ -3166,7 +3166,7 @@ css_error parse_richness(css_css21 *c, if (error != CSS_OK) return error; - if (token->lower.ptr == c->strings[INHERIT]) { + if (token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { size_t consumed = 0; @@ -3219,11 +3219,11 @@ css_error parse_right(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[AUTO]) { + token->lower.data == c->strings[AUTO]) { parserutils_vector_iterate(vector, ctx); value = RIGHT_AUTO; } else { @@ -3283,11 +3283,11 @@ css_error parse_speak_header(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[ONCE]) { + } else if (ident->lower.data == c->strings[ONCE]) { value = SPEAK_HEADER_ONCE; - } else if (ident->lower.ptr == c->strings[ALWAYS]) { + } else if (ident->lower.data == c->strings[ALWAYS]) { value = SPEAK_HEADER_ALWAYS; } else return CSS_INVALID; @@ -3324,11 +3324,11 @@ css_error parse_speak_numeral(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[DIGITS]) { + } else if (ident->lower.data == c->strings[DIGITS]) { value = SPEAK_NUMERAL_DIGITS; - } else if (ident->lower.ptr == c->strings[CONTINUOUS]) { + } else if (ident->lower.data == c->strings[CONTINUOUS]) { value = SPEAK_NUMERAL_CONTINUOUS; } else return CSS_INVALID; @@ -3365,11 +3365,11 @@ css_error parse_speak_punctuation(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[CODE]) { + } else if (ident->lower.data == c->strings[CODE]) { value = SPEAK_PUNCTUATION_CODE; - } else if (ident->lower.ptr == c->strings[NONE]) { + } else if (ident->lower.data == c->strings[NONE]) { value = SPEAK_PUNCTUATION_NONE; } else return CSS_INVALID; @@ -3406,13 +3406,13 @@ css_error parse_speak(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[NORMAL]) { + } else if (ident->lower.data == c->strings[NORMAL]) { value = SPEAK_NORMAL; - } else if (ident->lower.ptr == c->strings[NONE]) { + } else if (ident->lower.data == c->strings[NONE]) { value = SPEAK_NONE; - } else if (ident->lower.ptr == c->strings[SPELL_OUT]) { + } else if (ident->lower.data == c->strings[SPELL_OUT]) { value = SPEAK_SPELL_OUT; } else return CSS_INVALID; @@ -3455,28 +3455,28 @@ css_error parse_speech_rate(css_css21 *c, return error; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[X_SLOW]) { + token->lower.data == c->strings[X_SLOW]) { value = SPEECH_RATE_X_SLOW; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[SLOW]) { + token->lower.data == c->strings[SLOW]) { value = SPEECH_RATE_SLOW; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[MEDIUM]) { + token->lower.data == c->strings[MEDIUM]) { value = SPEECH_RATE_MEDIUM; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[FAST]) { + token->lower.data == c->strings[FAST]) { value = SPEECH_RATE_FAST; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[X_FAST]) { + token->lower.data == c->strings[X_FAST]) { value = SPEECH_RATE_X_FAST; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[FASTER]) { + token->lower.data == c->strings[FASTER]) { value = SPEECH_RATE_FASTER; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[SLOWER]) { + token->lower.data == c->strings[SLOWER]) { value = SPEECH_RATE_SLOWER; } else if (token->type == CSS_TOKEN_NUMBER) { size_t consumed = 0; @@ -3532,7 +3532,7 @@ css_error parse_stress(css_css21 *c, if (error != CSS_OK) return error; - if (token->lower.ptr == c->strings[INHERIT]) { + if (token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { size_t consumed = 0; @@ -3585,11 +3585,11 @@ css_error parse_table_layout(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[AUTO]) { + } else if (ident->lower.data == c->strings[AUTO]) { value = TABLE_LAYOUT_AUTO; - } else if (ident->lower.ptr == c->strings[FIXED]) { + } else if (ident->lower.data == c->strings[FIXED]) { value = TABLE_LAYOUT_FIXED; } else return CSS_INVALID; @@ -3626,15 +3626,15 @@ css_error parse_text_align(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[LEFT]) { + } else if (ident->lower.data == c->strings[LEFT]) { value = TEXT_ALIGN_LEFT; - } else if (ident->lower.ptr == c->strings[RIGHT]) { + } else if (ident->lower.data == c->strings[RIGHT]) { value = TEXT_ALIGN_RIGHT; - } else if (ident->lower.ptr == c->strings[CENTER]) { + } else if (ident->lower.data == c->strings[CENTER]) { value = TEXT_ALIGN_CENTER; - } else if (ident->lower.ptr == c->strings[JUSTIFY]) { + } else if (ident->lower.data == c->strings[JUSTIFY]) { value = TEXT_ALIGN_JUSTIFY; } else return CSS_INVALID; @@ -3685,7 +3685,7 @@ css_error parse_text_indent(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else { @@ -3745,15 +3745,15 @@ css_error parse_text_transform(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[CAPITALIZE]) { + } else if (ident->lower.data == c->strings[CAPITALIZE]) { value = TEXT_TRANSFORM_CAPITALIZE; - } else if (ident->lower.ptr == c->strings[UPPERCASE]) { + } else if (ident->lower.data == c->strings[UPPERCASE]) { value = TEXT_TRANSFORM_UPPERCASE; - } else if (ident->lower.ptr == c->strings[LOWERCASE]) { + } else if (ident->lower.data == c->strings[LOWERCASE]) { value = TEXT_TRANSFORM_LOWERCASE; - } else if (ident->lower.ptr == c->strings[NONE]) { + } else if (ident->lower.data == c->strings[NONE]) { value = TEXT_TRANSFORM_NONE; } else return CSS_INVALID; @@ -3790,11 +3790,11 @@ css_error parse_top(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[AUTO]) { + token->lower.data == c->strings[AUTO]) { parserutils_vector_iterate(vector, ctx); value = TOP_AUTO; } else { @@ -3854,13 +3854,13 @@ css_error parse_unicode_bidi(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[NORMAL]) { + } else if (ident->lower.data == c->strings[NORMAL]) { value = UNICODE_BIDI_NORMAL; - } else if (ident->lower.ptr == c->strings[EMBED]) { + } else if (ident->lower.data == c->strings[EMBED]) { value = UNICODE_BIDI_EMBED; - } else if (ident->lower.ptr == c->strings[BIDI_OVERRIDE]) { + } else if (ident->lower.data == c->strings[BIDI_OVERRIDE]) { value = UNICODE_BIDI_BIDI_OVERRIDE; } else return CSS_INVALID; @@ -3899,39 +3899,39 @@ css_error parse_vertical_align(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[BASELINE]) { + token->lower.data == c->strings[BASELINE]) { parserutils_vector_iterate(vector, ctx); value = VERTICAL_ALIGN_BASELINE; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[SUB]) { + token->lower.data == c->strings[SUB]) { parserutils_vector_iterate(vector, ctx); value = VERTICAL_ALIGN_SUB; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[SUPER]) { + token->lower.data == c->strings[SUPER]) { parserutils_vector_iterate(vector, ctx); value = VERTICAL_ALIGN_SUPER; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[TOP]) { + token->lower.data == c->strings[TOP]) { parserutils_vector_iterate(vector, ctx); value = VERTICAL_ALIGN_TOP; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[TEXT_TOP]) { + token->lower.data == c->strings[TEXT_TOP]) { parserutils_vector_iterate(vector, ctx); value = VERTICAL_ALIGN_TEXT_TOP; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[MIDDLE]) { + token->lower.data == c->strings[MIDDLE]) { parserutils_vector_iterate(vector, ctx); value = VERTICAL_ALIGN_MIDDLE; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[BOTTOM]) { + token->lower.data == c->strings[BOTTOM]) { parserutils_vector_iterate(vector, ctx); value = VERTICAL_ALIGN_BOTTOM; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[TEXT_BOTTOM]) { + token->lower.data == c->strings[TEXT_BOTTOM]) { parserutils_vector_iterate(vector, ctx); value = VERTICAL_ALIGN_TEXT_BOTTOM; } else { @@ -3991,13 +3991,13 @@ css_error parse_visibility(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[VISIBLE]) { + } else if (ident->lower.data == c->strings[VISIBLE]) { value = VISIBILITY_VISIBLE; - } else if (ident->lower.ptr == c->strings[HIDDEN]) { + } else if (ident->lower.data == c->strings[HIDDEN]) { value = VISIBILITY_HIDDEN; - } else if (ident->lower.ptr == c->strings[COLLAPSE]) { + } else if (ident->lower.data == c->strings[COLLAPSE]) { value = VISIBILITY_COLLAPSE; } else return CSS_INVALID; @@ -4050,31 +4050,31 @@ css_error parse_volume(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[SILENT]) { + token->lower.data == c->strings[SILENT]) { parserutils_vector_iterate(vector, ctx); value = VOLUME_SILENT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[X_SOFT]) { + token->lower.data == c->strings[X_SOFT]) { parserutils_vector_iterate(vector, ctx); value = VOLUME_X_SOFT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[SOFT]) { + token->lower.data == c->strings[SOFT]) { parserutils_vector_iterate(vector, ctx); value = VOLUME_SOFT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[MEDIUM]) { + token->lower.data == c->strings[MEDIUM]) { parserutils_vector_iterate(vector, ctx); value = VOLUME_MEDIUM; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[LOUD]) { + token->lower.data == c->strings[LOUD]) { parserutils_vector_iterate(vector, ctx); value = VOLUME_LOUD; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[X_LOUD]) { + token->lower.data == c->strings[X_LOUD]) { parserutils_vector_iterate(vector, ctx); value = VOLUME_X_LOUD; } else if (token->type == CSS_TOKEN_NUMBER) { @@ -4144,17 +4144,17 @@ css_error parse_white_space(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[NORMAL]) { + } else if (ident->lower.data == c->strings[NORMAL]) { value = WHITE_SPACE_NORMAL; - } else if (ident->lower.ptr == c->strings[PRE]) { + } else if (ident->lower.data == c->strings[PRE]) { value = WHITE_SPACE_PRE; - } else if (ident->lower.ptr == c->strings[NOWRAP]) { + } else if (ident->lower.data == c->strings[NOWRAP]) { value = WHITE_SPACE_NOWRAP; - } else if (ident->lower.ptr == c->strings[PRE_WRAP]) { + } else if (ident->lower.data == c->strings[PRE_WRAP]) { value = WHITE_SPACE_PRE_WRAP; - } else if (ident->lower.ptr == c->strings[PRE_LINE]) { + } else if (ident->lower.data == c->strings[PRE_LINE]) { value = WHITE_SPACE_PRE_LINE; } else return CSS_INVALID; @@ -4194,7 +4194,7 @@ css_error parse_widows(css_css21 *c, if (error != CSS_OK) return error; - if (token->lower.ptr == c->strings[INHERIT]) { + if (token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { size_t consumed = 0; @@ -4248,11 +4248,11 @@ css_error parse_width(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[AUTO]) { + token->lower.data == c->strings[AUTO]) { parserutils_vector_iterate(vector, ctx); value = WIDTH_AUTO; } else { @@ -4312,11 +4312,11 @@ css_error parse_word_spacing(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[NORMAL]) { + token->lower.data == c->strings[NORMAL]) { parserutils_vector_iterate(vector, ctx); value = WORD_SPACING_NORMAL; } else { @@ -4381,10 +4381,10 @@ css_error parse_z_index(css_css21 *c, return error; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[AUTO]) { + token->lower.data == c->strings[AUTO]) { value = Z_INDEX_AUTO; } else if (token->type == CSS_TOKEN_NUMBER) { size_t consumed = 0; @@ -4435,7 +4435,7 @@ css_error parse_important(css_css21 *c, if (token == NULL || token->type != CSS_TOKEN_IDENT) return CSS_INVALID; - if (token->lower.ptr == c->strings[IMPORTANT]) + if (token->lower.data == c->strings[IMPORTANT]) *result |= FLAG_IMPORTANT; } else if (token != NULL) return CSS_INVALID; @@ -4502,11 +4502,11 @@ css_error parse_border_side_color(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[TRANSPARENT]) { + token->lower.data == c->strings[TRANSPARENT]) { parserutils_vector_iterate(vector, ctx); value = BORDER_COLOR_TRANSPARENT; } else { @@ -4562,27 +4562,27 @@ css_error parse_border_side_style(css_css21 *c, if (error != CSS_OK) return error; - if (ident->lower.ptr == c->strings[INHERIT]) { + if (ident->lower.data == c->strings[INHERIT]) { flags |= FLAG_INHERIT; - } else if (ident->lower.ptr == c->strings[NONE]) { + } else if (ident->lower.data == c->strings[NONE]) { value = BORDER_STYLE_NONE; - } else if (ident->lower.ptr == c->strings[HIDDEN]) { + } else if (ident->lower.data == c->strings[HIDDEN]) { value = BORDER_STYLE_HIDDEN; - } else if (ident->lower.ptr == c->strings[DOTTED]) { + } else if (ident->lower.data == c->strings[DOTTED]) { value = BORDER_STYLE_DOTTED; - } else if (ident->lower.ptr == c->strings[DASHED]) { + } else if (ident->lower.data == c->strings[DASHED]) { value = BORDER_STYLE_DASHED; - } else if (ident->lower.ptr == c->strings[SOLID]) { + } else if (ident->lower.data == c->strings[SOLID]) { value = BORDER_STYLE_SOLID; - } else if (ident->lower.ptr == c->strings[DOUBLE]) { + } else if (ident->lower.data == c->strings[DOUBLE]) { value = BORDER_STYLE_DOUBLE; - } else if (ident->lower.ptr == c->strings[GROOVE]) { + } else if (ident->lower.data == c->strings[GROOVE]) { value = BORDER_STYLE_GROOVE; - } else if (ident->lower.ptr == c->strings[RIDGE]) { + } else if (ident->lower.data == c->strings[RIDGE]) { value = BORDER_STYLE_RIDGE; - } else if (ident->lower.ptr == c->strings[INSET]) { + } else if (ident->lower.data == c->strings[INSET]) { value = BORDER_STYLE_INSET; - } else if (ident->lower.ptr == c->strings[OUTSET]) { + } else if (ident->lower.data == c->strings[OUTSET]) { value = BORDER_STYLE_OUTSET; } else return CSS_INVALID; @@ -4619,19 +4619,19 @@ css_error parse_border_side_width(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[THIN]) { + token->lower.data == c->strings[THIN]) { parserutils_vector_iterate(vector, ctx); value = BORDER_WIDTH_THIN; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[MEDIUM]) { + token->lower.data == c->strings[MEDIUM]) { parserutils_vector_iterate(vector, ctx); value = BORDER_WIDTH_MEDIUM; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[THICK]) { + token->lower.data == c->strings[THICK]) { parserutils_vector_iterate(vector, ctx); value = BORDER_WIDTH_THICK; } else { @@ -4692,11 +4692,11 @@ css_error parse_margin_side(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[AUTO]) { + token->lower.data == c->strings[AUTO]) { parserutils_vector_iterate(vector, ctx); value = MARGIN_AUTO; } else { @@ -4756,7 +4756,7 @@ css_error parse_padding_side(css_css21 *c, return CSS_INVALID; if (token->type == CSS_TOKEN_IDENT && - token->lower.ptr == c->strings[INHERIT]) { + token->lower.data == c->strings[INHERIT]) { parserutils_vector_iterate(vector, ctx); flags = FLAG_INHERIT; } else { diff --git a/src/parse/parse.c b/src/parse/parse.c index f12ffe5..f461302 100644 --- a/src/parse/parse.c +++ b/src/parse/parse.c @@ -174,17 +174,19 @@ static css_error (*parseFuncs[])(css_parser *parser) = { /** * Create a CSS parser * - * \param charset Charset of data, if known, or NULL - * \param cs_source Source of charset information, or CSS_CHARSET_DEFAULT - * \param alloc Memory (de)allocation function - * \param pw Pointer to client-specific private data - * \param parser Pointer to location to receive parser instance + * \param charset Charset of data, if known, or NULL + * \param cs_source Source of charset information, or CSS_CHARSET_DEFAULT + * \param dictionary Dictionary in which to intern strings (not copied) + * \param alloc Memory (de)allocation function + * \param pw Pointer to client-specific private data + * \param parser Pointer to location to receive parser instance * \return CSS_OK on success, * CSS_BADPARM on bad parameters, * CSS_NOMEM on memory exhaustion */ css_error css_parser_create(const char *charset, css_charset_source cs_source, - css_alloc alloc, void *pw, css_parser **parser) + parserutils_dict *dictionary, css_alloc alloc, void *pw, + css_parser **parser) { css_parser *p; parser_state initial = { sStart, 0 }; @@ -223,21 +225,12 @@ css_error css_parser_create(const char *charset, css_charset_source cs_source, return css_error_from_parserutils_error(perror); } - perror = parserutils_dict_create((parserutils_alloc) alloc, pw, - &p->dictionary); - if (perror != PARSERUTILS_OK) { - parserutils_stack_destroy(p->states); - css_lexer_destroy(p->lexer); - parserutils_inputstream_destroy(p->stream); - alloc(p, 0, pw); - return css_error_from_parserutils_error(perror); - } + p->dictionary = dictionary; perror = parserutils_vector_create(sizeof(css_token), STACK_CHUNK, (parserutils_alloc) alloc, pw, &p->tokens); if (perror != PARSERUTILS_OK) { - parserutils_dict_destroy(p->dictionary); parserutils_stack_destroy(p->states); css_lexer_destroy(p->lexer); parserutils_inputstream_destroy(p->stream); @@ -261,7 +254,6 @@ css_error css_parser_create(const char *charset, css_charset_source cs_source, if (perror != PARSERUTILS_OK) { parserutils_stack_destroy(p->open_items); parserutils_vector_destroy(p->tokens); - parserutils_dict_destroy(p->dictionary); parserutils_stack_destroy(p->states); css_lexer_destroy(p->lexer); parserutils_inputstream_destroy(p->stream); @@ -298,8 +290,6 @@ css_error css_parser_destroy(css_parser *parser) parserutils_vector_destroy(parser->tokens); - parserutils_dict_destroy(parser->dictionary); - parserutils_stack_destroy(parser->states); css_lexer_destroy(parser->lexer); @@ -423,20 +413,20 @@ const char *css_parser_read_charset(css_parser *parser, * Add an entry to the parser dictionary * * \param parser The parser instance - * \param ptr Pointer to data + * \param data Pointer to data * \param len Length, in bytes, of data * \return Pointer to data in dictionary, or NULL on memory exhaustion */ -const uint8_t *css_parser_dict_add(css_parser *parser, const uint8_t *ptr, +const uint8_t *css_parser_dict_add(css_parser *parser, const uint8_t *data, size_t len) { const parserutils_dict_entry *interned; parserutils_error perror; - if (parser == NULL || ptr == NULL || len == 0) + if (parser == NULL || data == NULL || len == 0) return NULL; - perror = parserutils_dict_insert(parser->dictionary, ptr, len, + perror = parserutils_dict_insert(parser->dictionary, data, len, &interned); if (perror != PARSERUTILS_OK) return NULL; @@ -580,7 +570,7 @@ css_error getToken(css_parser *parser, const css_token **token) return error; if (t->type != CSS_TOKEN_S && - t->data.ptr != NULL && t->data.len > 0) { + t->data.data != NULL && t->data.len > 0) { /* Insert token text into the dictionary */ const parserutils_dict_entry *interned; uint8_t temp[t->data.len]; @@ -592,8 +582,8 @@ css_error getToken(css_parser *parser, const css_token **token) case CSS_TOKEN_HASH: case CSS_TOKEN_FUNCTION: for (size_t i = 0; i < t->data.len; i++) { - temp[i] = tolower(t->data.ptr[i]); - if (temp[i] != t->data.ptr[i]) + temp[i] = tolower(t->data.data[i]); + if (temp[i] != t->data.data[i]) lower = true; } break; @@ -614,30 +604,30 @@ css_error getToken(css_parser *parser, const css_token **token) perror); } - t->lower.ptr = interned->data; + t->lower.data = interned->data; t->lower.len = interned->len; perror = parserutils_dict_insert( parser->dictionary, - t->data.ptr, t->data.len, + t->data.data, t->data.len, &interned); } else { /* Otherwise, we're not interested in case */ perror = parserutils_dict_insert( parser->dictionary, - t->data.ptr, t->data.len, + t->data.data, t->data.len, &interned); - t->lower.ptr = interned->data; + t->lower.data = interned->data; t->lower.len = interned->len; } if (perror != PARSERUTILS_OK) return css_error_from_parserutils_error(perror); - t->data.ptr = interned->data; + t->data.data = interned->data; t->data.len = interned->len; } else if (t->type == CSS_TOKEN_S) { - t->data.ptr = t->lower.ptr = NULL; + t->data.data = t->lower.data = NULL; t->data.len = t->lower.len = 0; } @@ -863,7 +853,7 @@ css_error parseRuleset(css_parser *parser) * brace. We're going to assume that that won't happen, * however. */ if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1 && - token->lower.ptr[0] == '{') { + token->lower.data[0] == '{') { #if !defined(NDEBUG) && defined(DEBUG_EVENTS) printf("Begin ruleset\n"); #endif @@ -914,7 +904,7 @@ css_error parseRuleset(css_parser *parser) return error; if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 || - token->lower.ptr[0] != '{') { + token->lower.data[0] != '{') { /* This should never happen, as FOLLOW(selector) * contains only '{' */ assert(0 && "Expected {"); @@ -979,7 +969,7 @@ css_error parseRulesetEnd(css_parser *parser) return error; if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 || - token->lower.ptr[0] != '}') { + token->lower.data[0] != '}') { /* This should never happen, as FOLLOW(decl-list) * contains only '}' */ assert(0 && "Expected }"); @@ -1054,8 +1044,8 @@ css_error parseAtRule(css_parser *parser) /* Grammar ambiguity: any0 can be followed by '{',';',')',']'. * at-rule can only be followed by '{' and ';'. */ if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1) { - if (token->lower.ptr[0] == ')' || - token->lower.ptr[0] == ']') { + if (token->lower.data[0] == ')' || + token->lower.data[0] == ']') { parser_state to = { sAny0, Initial }; parser_state subsequent = { sAtRule, AfterAny }; @@ -1111,7 +1101,7 @@ css_error parseAtRuleEnd(css_parser *parser) assert(0 && "Expected { or ;"); } - if (token->lower.ptr[0] == '{') { + if (token->lower.data[0] == '{') { parser_state to = { sBlock, Initial }; parser_state subsequent = { sAtRuleEnd, AfterBlock }; @@ -1120,7 +1110,7 @@ css_error parseAtRuleEnd(css_parser *parser) return error; return transition(parser, to, subsequent); - } else if (token->lower.ptr[0] != ';') { + } else if (token->lower.data[0] != ';') { /* Again, should never happen */ assert(0 && "Expected ;"); } @@ -1173,7 +1163,7 @@ css_error parseBlock(css_parser *parser) parserutils_vector_clear(parser->tokens); if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 || - token->lower.ptr[0] != '{') { + token->lower.data[0] != '{') { /* This should never happen, as FIRST(block) == '{' */ assert(0 && "Expected {"); } @@ -1200,7 +1190,7 @@ css_error parseBlock(css_parser *parser) return error; if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 || - token->lower.ptr[0] != '}') { + token->lower.data[0] != '}') { /* This should never happen, as * FOLLOW(block-content) == '}' */ assert(0 && "Expected }"); @@ -1253,7 +1243,7 @@ css_error parseBlockContent(css_parser *parser) state->substate = WS; } else if (token->type == CSS_TOKEN_CHAR) { if (token->lower.len == 1 && - token->lower.ptr[0] == '{') { + token->lower.data[0] == '{') { /* Grammar ambiguity. Assume block */ parser_state to = { sBlock, Initial }; parser_state subsequent = @@ -1277,11 +1267,11 @@ css_error parseBlockContent(css_parser *parser) return transition(parser, to, subsequent); } else if (token->lower.len == 1 && - token->lower.ptr[0] == ';') { + token->lower.data[0] == ';') { /* Grammar ambiguity. Assume semi */ state->substate = WS; } else if (token->lower.len == 1 && - token->lower.ptr[0] == '}') { + token->lower.data[0] == '}') { /* Grammar ambiguity. Assume end */ error = pushBack(parser, token); if (error != CSS_OK) @@ -1390,7 +1380,7 @@ css_error parseDeclaration(css_parser *parser) return error; if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 || - token->lower.ptr[0] != ':') { + token->lower.data[0] != ':') { /* parse error -- expected : */ parser_state to = { sMalformedDecl, Initial }; @@ -1458,13 +1448,13 @@ css_error parseDeclList(css_parser *parser) assert(0 && "Expected ; or }"); } - if (token->lower.ptr[0] == '}') { + if (token->lower.data[0] == '}') { error = pushBack(parser, token); if (error != CSS_OK) return error; return done(parser); - } else if (token->lower.ptr[0] == ';') { + } else if (token->lower.data[0] == ';') { state->substate = WS; } else { /* Should never happen */ @@ -1504,8 +1494,8 @@ css_error parseDeclListEnd(css_parser *parser) if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 || - (token->lower.ptr[0] != ';' && - token->lower.ptr[0] != '}')) { + (token->lower.data[0] != ';' && + token->lower.data[0] != '}')) { parser_state to = { sDeclaration, Initial }; parser_state subsequent = { sDeclListEnd, AfterDeclaration }; @@ -1593,8 +1583,8 @@ css_error parseValue1(css_parser *parser) /* Grammar ambiguity -- assume ';' or '}' mark end */ if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1 && - (token->lower.ptr[0] == ';' || - token->lower.ptr[0] == '}')) { + (token->lower.data[0] == ';' || + token->lower.data[0] == '}')) { /* Parse error */ parser->parseError = true; @@ -1641,8 +1631,8 @@ css_error parseValue0(css_parser *parser) /* Grammar ambiguity -- assume ';' or '}' mark end */ if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1 && - (token->lower.ptr[0] == ';' || - token->lower.ptr[0] == '}')) { + (token->lower.data[0] == ';' || + token->lower.data[0] == '}')) { return done(parser); } @@ -1680,7 +1670,7 @@ css_error parseValue(css_parser *parser) state->substate = WS; } else if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1 && - token->lower.ptr[0] == '{') { + token->lower.data[0] == '{') { /* Grammar ambiguity. Assume block. */ parser_state to = { sBlock, Initial }; @@ -1741,10 +1731,10 @@ css_error parseAny0(css_parser *parser) * assume '{', ';', ')', ']' mark end */ if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1 && - (token->lower.ptr[0] == '{' || - token->lower.ptr[0] == ';' || - token->lower.ptr[0] == ')' || - token->lower.ptr[0] == ']')) { + (token->lower.data[0] == '{' || + token->lower.data[0] == ';' || + token->lower.data[0] == ')' || + token->lower.data[0] == ']')) { return done(parser); } @@ -1805,14 +1795,14 @@ css_error parseAny1(css_parser *parser) /* Grammar ambiguity: any0 can be followed by * '{', ';', ')', ']'. any1 can only be followed by '{'. */ if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1) { - if (token->lower.ptr[0] == ';' || - token->lower.ptr[0] == ')' || - token->lower.ptr[0] == ']') { + if (token->lower.data[0] == ';' || + token->lower.data[0] == ')' || + token->lower.data[0] == ']') { parser_state to = { sAny, Initial }; parser_state subsequent = { sAny1, AfterAny }; return transition(parser, to, subsequent); - } else if (token->lower.ptr[0] != '{') { + } else if (token->lower.data[0] != '{') { /* parse error */ parser->parseError = true; } @@ -1883,10 +1873,10 @@ css_error parseAny(css_parser *parser) state->substate = WS; } else if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1 && - (token->lower.ptr[0] == '(' || - token->lower.ptr[0] == '[')) { + (token->lower.data[0] == '(' || + token->lower.data[0] == '[')) { parser->match_char = - token->lower.ptr[0] == '(' ? ')' : ']'; + token->lower.data[0] == '(' ? ')' : ']'; state->substate = WS; } @@ -1919,7 +1909,7 @@ css_error parseAny(css_parser *parser) /* Match correct close bracket (grammar ambiguity) */ if (token->type == CSS_TOKEN_CHAR && token->lower.len == 1 && - token->lower.ptr[0] == parser->match_char) { + token->lower.data[0] == parser->match_char) { state->substate = WS2; goto ws2; } @@ -1963,13 +1953,13 @@ css_error parseMalformedDeclaration(css_parser *parser) if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 || - (token->lower.ptr[0] != '{' && - token->lower.ptr[0] != '}' && - token->lower.ptr[0] != '[' && - token->lower.ptr[0] != ']' && - token->lower.ptr[0] != '(' && - token->lower.ptr[0] != ')' && - token->lower.ptr[0] != ';')) + (token->lower.data[0] != '{' && + token->lower.data[0] != '}' && + token->lower.data[0] != '[' && + token->lower.data[0] != ']' && + token->lower.data[0] != '(' && + token->lower.data[0] != ')' && + token->lower.data[0] != ';')) continue; char want; @@ -1979,17 +1969,17 @@ css_error parseMalformedDeclaration(css_parser *parser) /* If the stack is empty, then we're done if we've got * either a ';' or '}' */ if (match == NULL) { - if (token->lower.ptr[0] == ';' || - token->lower.ptr[0] == '}') + if (token->lower.data[0] == ';' || + token->lower.data[0] == '}') break; } /* Regardless, if we've got a semicolon, ignore it */ - if (token->lower.ptr[0] == ';') + if (token->lower.data[0] == ';') continue; /* Get corresponding start tokens for end tokens */ - switch (token->lower.ptr[0]) { + switch (token->lower.data[0]) { case '}': want = '{'; break; @@ -2011,7 +2001,7 @@ css_error parseMalformedDeclaration(css_parser *parser) parser->open_items, NULL); } else if (want == 0) { parserutils_stack_push(parser->open_items, - &token->lower.ptr[0]); + &token->lower.data[0]); } } } @@ -2057,12 +2047,12 @@ css_error parseMalformedSelector(css_parser *parser) if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 || - (token->lower.ptr[0] != '{' && - token->lower.ptr[0] != '}' && - token->lower.ptr[0] != '[' && - token->lower.ptr[0] != ']' && - token->lower.ptr[0] != '(' && - token->lower.ptr[0] != ')')) + (token->lower.data[0] != '{' && + token->lower.data[0] != '}' && + token->lower.data[0] != '[' && + token->lower.data[0] != ']' && + token->lower.data[0] != '(' && + token->lower.data[0] != ')')) continue; char want; @@ -2070,7 +2060,7 @@ css_error parseMalformedSelector(css_parser *parser) parser->open_items); /* Get corresponding start tokens for end tokens */ - switch (token->lower.ptr[0]) { + switch (token->lower.data[0]) { case '}': want = '{'; break; @@ -2092,7 +2082,7 @@ css_error parseMalformedSelector(css_parser *parser) parser->open_items, NULL); } else if (want == 0) { parserutils_stack_push(parser->open_items, - &token->lower.ptr[0]); + &token->lower.data[0]); } /* If we encountered a '}', there was data on the stack @@ -2150,13 +2140,13 @@ css_error parseMalformedAtRule(css_parser *parser) if (token->type != CSS_TOKEN_CHAR || token->lower.len != 1 || - (token->lower.ptr[0] != '{' && - token->lower.ptr[0] != '}' && - token->lower.ptr[0] != '[' && - token->lower.ptr[0] != ']' && - token->lower.ptr[0] != '(' && - token->lower.ptr[0] != ')' && - token->lower.ptr[0] != ';')) + (token->lower.data[0] != '{' && + token->lower.data[0] != '}' && + token->lower.data[0] != '[' && + token->lower.data[0] != ']' && + token->lower.data[0] != '(' && + token->lower.data[0] != ')' && + token->lower.data[0] != ';')) continue; char want; @@ -2165,7 +2155,7 @@ css_error parseMalformedAtRule(css_parser *parser) /* If we have a semicolon, then we're either done or * need to ignore it */ - if (token->lower.ptr[0] == ';') { + if (token->lower.data[0] == ';') { if (match == NULL) break; else @@ -2173,7 +2163,7 @@ css_error parseMalformedAtRule(css_parser *parser) } /* Get corresponding start tokens for end tokens */ - switch (token->lower.ptr[0]) { + switch (token->lower.data[0]) { case '}': want = '{'; break; @@ -2195,7 +2185,7 @@ css_error parseMalformedAtRule(css_parser *parser) parser->open_items, NULL); } else if (want == 0) { parserutils_stack_push(parser->open_items, - &token->lower.ptr[0]); + &token->lower.data[0]); } /* If we encountered a '}', there was data on the stack @@ -2236,8 +2226,8 @@ static void tprinter(void *token) { css_token *t = token; - if (t->data.ptr) - printf("%d: %.*s", t->type, t->data.len, t->data.ptr); + if (t->data.data) + printf("%d: %.*s", t->type, t->data.len, t->data.data); else printf("%d", t->type); } diff --git a/src/parse/parse.h b/src/parse/parse.h index c2396cb..a948d56 100644 --- a/src/parse/parse.h +++ b/src/parse/parse.h @@ -8,6 +8,7 @@ #ifndef css_parse_parse_h_ #define css_parse_parse_h_ +#include #include #include @@ -56,7 +57,8 @@ typedef union css_parser_optparams { } css_parser_optparams; css_error css_parser_create(const char *charset, css_charset_source cs_source, - css_alloc alloc, void *pw, css_parser **parser); + parserutils_dict *dict, css_alloc alloc, void *pw, + css_parser **parser); css_error css_parser_destroy(css_parser *parser); css_error css_parser_setopt(css_parser *parser, css_parser_opttype type, diff --git a/src/stylesheet.c b/src/stylesheet.c index 0b1e2cd..7e634a9 100644 --- a/src/stylesheet.c +++ b/src/stylesheet.c @@ -10,6 +10,7 @@ #include "stylesheet.h" #include "bytecode/bytecode.h" #include "parse/css21.h" +#include "utils/parserutilserror.h" #include "utils/utils.h" /** @@ -36,6 +37,7 @@ css_error css_stylesheet_create(css_language_level level, css_import_handler import_callback, void *import_pw, css_alloc alloc, void *alloc_pw, css_stylesheet **stylesheet) { + parserutils_error perror; css_error error; css_stylesheet *sheet; size_t len; @@ -49,10 +51,18 @@ css_error css_stylesheet_create(css_language_level level, memset(sheet, 0, sizeof(css_stylesheet)); + perror = parserutils_dict_create((parserutils_alloc) alloc, alloc_pw, + &sheet->dictionary); + if (perror != PARSERUTILS_OK) { + alloc(sheet, 0, alloc_pw); + return css_error_from_parserutils_error(perror); + } + error = css_parser_create(charset, charset ? CSS_CHARSET_DICTATED : CSS_CHARSET_DEFAULT, - alloc, alloc_pw, &sheet->parser); + sheet->dictionary, alloc, alloc_pw, &sheet->parser); if (error != CSS_OK) { + parserutils_dict_destroy(sheet->dictionary); alloc(sheet, 0, alloc_pw); return error; } @@ -60,6 +70,7 @@ css_error css_stylesheet_create(css_language_level level, /* We only support CSS 2.1 */ if (level != CSS_LEVEL_21) { css_parser_destroy(sheet->parser); + parserutils_dict_destroy(sheet->dictionary); alloc(sheet, 0, alloc_pw); return CSS_INVALID; /** \todo better error */ } @@ -69,6 +80,7 @@ css_error css_stylesheet_create(css_language_level level, &sheet->parser_frontend); if (error != CSS_OK) { css_parser_destroy(sheet->parser); + parserutils_dict_destroy(sheet->dictionary); alloc(sheet, 0, alloc_pw); return error; } @@ -80,6 +92,7 @@ css_error css_stylesheet_create(css_language_level level, if (sheet->url == NULL) { css_css21_destroy(sheet->parser_frontend); css_parser_destroy(sheet->parser); + parserutils_dict_destroy(sheet->dictionary); alloc(sheet, 0, alloc_pw); return CSS_NOMEM; } @@ -89,9 +102,10 @@ css_error css_stylesheet_create(css_language_level level, len = strlen(title) + 1; sheet->title = alloc(NULL, len, alloc_pw); if (sheet->title == NULL) { + alloc(sheet->url, 0, alloc_pw); css_css21_destroy(sheet->parser_frontend); css_parser_destroy(sheet->parser); - alloc(sheet->url, 0, alloc_pw); + parserutils_dict_destroy(sheet->dictionary); alloc(sheet, 0, alloc_pw); return CSS_NOMEM; } @@ -123,6 +137,8 @@ css_error css_stylesheet_destroy(css_stylesheet *sheet) if (sheet == NULL) return CSS_BADPARM; + parserutils_dict_destroy(sheet->dictionary); + if (sheet->title != NULL) sheet->alloc(sheet->title, 0, sheet->pw); @@ -349,7 +365,9 @@ css_error css_stylesheet_selector_create(css_stylesheet *sheet, css_selector_type type, const css_string *name, const css_string *value, css_selector **selector) { + const css_string *iname, *ivalue; css_selector *sel; + parserutils_error perror; if (sheet == NULL || name == NULL || selector == NULL) return CSS_BADPARM; @@ -360,14 +378,33 @@ css_error css_stylesheet_selector_create(css_stylesheet *sheet, memset(sel, 0, sizeof(css_selector)); - sel->type = type; - sel->data.name = *name; + sel->data.type = type; + + /** \todo Given that this information is already guaranteed to be in + * the dictionary, it would be more efficient to pass a pointer to the + * dictionary entry around rather than re-discovering it here. The same + * applies for value, and in css_stylesheet_selector_detail_create() */ + perror = parserutils_dict_insert(sheet->dictionary, name->data, + name->len, &iname); + if (perror != PARSERUTILS_OK) { + sheet->alloc(sel, 0, sheet->pw); + return css_error_from_parserutils_error(perror); + } + sel->data.name = iname; + if (value != NULL) { - sel->data.value = *value; + perror = parserutils_dict_insert(sheet->dictionary, + value->data, value->len, &ivalue); + if (perror != PARSERUTILS_OK) { + sheet->alloc(sel, 0, sheet->pw); + return css_error_from_parserutils_error(perror); + } + sel->data.value = ivalue; } + /** \todo specificity */ sel->specificity = 0; - sel->combinator_type = CSS_COMBINATOR_NONE; + sel->data.comb = CSS_COMBINATOR_NONE; *selector = sel; @@ -394,33 +431,121 @@ css_error css_stylesheet_selector_destroy(css_stylesheet *sheet, return CSS_OK; } +/** + * Create a selector detail + * + * \param sheet The stylesheet context + * \param type The type of selector to create + * \param name Name of selector + * \param value Value of selector, or NULL + * \param detail Pointer to location to receive detail object + * \return CSS_OK on success, + * CSS_BADPARM on bad parameters, + * CSS_NOMEM on memory exhaustion + */ +css_error css_stylesheet_selector_detail_create(css_stylesheet *sheet, + css_selector_type type, const css_string *name, + const css_string *value, css_selector_detail **detail) +{ + parserutils_error perror; + const css_string *iname, *ivalue; + css_selector_detail *det; + + if (sheet == NULL || name == NULL || detail == NULL) + return CSS_BADPARM; + + det = sheet->alloc(NULL, sizeof(css_selector_detail), sheet->pw); + if (det == NULL) + return CSS_NOMEM; + + memset(det, 0, sizeof(css_selector_detail)); + + det->type = type; + + perror = parserutils_dict_insert(sheet->dictionary, name->data, + name->len, &iname); + if (perror != PARSERUTILS_OK) { + sheet->alloc(det, 0, sheet->pw); + return css_error_from_parserutils_error(perror); + } + det->name = iname; + + if (value != NULL) { + perror = parserutils_dict_insert(sheet->dictionary, + value->data, value->len, &ivalue); + if (perror != PARSERUTILS_OK) { + sheet->alloc(det, 0, sheet->pw); + return css_error_from_parserutils_error(perror); + } + det->value = ivalue; + } + + *detail = det; + + return CSS_OK; +} + +/** + * Destroy a selector detail + * + * \param sheet The stylesheet context + * \param detail The detail to destroy + * \return CSS_OK on success, appropriate error otherwise + */ +css_error css_stylesheet_selector_detail_destroy(css_stylesheet *sheet, + css_selector_detail *detail) +{ + if (sheet == NULL || detail == NULL) + return CSS_BADPARM; + + sheet->alloc(detail, 0, sheet->pw); + + return CSS_OK; +} + + /** * Append a selector to the specifics chain of another selector * * \param sheet The stylesheet context - * \param parent The parent selector - * \param specific The selector to append + * \param parent Pointer to pointer to the parent selector (updated on exit) + * \param specific The selector to append (destroyed) * \return CSS_OK on success, appropriate error otherwise. */ css_error css_stylesheet_selector_append_specific(css_stylesheet *sheet, - css_selector *parent, css_selector *specific) + css_selector **parent, css_selector_detail *detail) { - css_selector *s; + css_selector *temp; + css_selector_detail *d; + size_t num_details = 0; - if (sheet == NULL || parent == NULL || specific == NULL) + if (sheet == NULL || parent == NULL || + *parent == NULL || detail == NULL) return CSS_BADPARM; - /** \todo this may want optimising */ - for (s = parent->specifics; s != NULL && s->next != NULL; s = s->next) - /* do nothing */; - if (s == NULL) { - specific->prev = specific->next = NULL; - parent->specifics = specific; - } else { - s->next = specific; - specific->prev = s; - specific->next = NULL; - } + /** \todo this may want optimising -- counting blocks is O(n) + * In practice, however, n isn't likely to be large, so may be fine + */ + + /* Count current number of detail blocks */ + for (d = &(*parent)->data; d->next != 0; d++) + num_details++; + + /* Grow selector by one detail block */ + temp = sheet->alloc((*parent), sizeof(css_selector) + + (num_details + 1) * sizeof(css_selector_detail), + sheet->pw); + if (temp == NULL) + return CSS_NOMEM; + + /* Copy detail into empty block */ + (&temp->data)[num_details + 1] = *detail; + /* Flag that there's another block */ + (&temp->data)[num_details].next = 1; + + css_stylesheet_selector_detail_destroy(sheet, detail); + + (*parent) = temp; return CSS_OK; } @@ -451,7 +576,7 @@ css_error css_stylesheet_selector_combine(css_stylesheet *sheet, return CSS_INVALID; b->combinator = a; - b->combinator_type = type; + b->data.comb = type; return CSS_OK; } @@ -666,7 +791,9 @@ static void css_stylesheet_dump_selector_list(css_selector *list, FILE *target, size_t *size); static void css_stylesheet_dump_selector(css_selector *selector, FILE *target, size_t *size); -static void css_stylesheet_dump_string(css_string *string, FILE *target); +static void css_stylesheet_dump_selector_detail(css_selector_detail *detail, + FILE *target, size_t *size); +static void css_stylesheet_dump_string(const css_string *string, FILE *target); /** * Dump a stylesheet @@ -757,7 +884,7 @@ void css_stylesheet_dump_selector_list(css_selector *list, FILE *target, size); } - switch (list->combinator_type) { + switch (list->data.comb) { case CSS_COMBINATOR_NONE: break; case CSS_COMBINATOR_ANCESTOR: @@ -784,71 +911,87 @@ void css_stylesheet_dump_selector_list(css_selector *list, FILE *target, void css_stylesheet_dump_selector(css_selector *selector, FILE *target, size_t *size) { - css_selector *s; + css_selector_detail *d = &selector->data; + + *size += sizeof(css_selector) - sizeof(css_selector_detail); + + while (true) { + css_stylesheet_dump_selector_detail(d, target, size); - *size += sizeof(css_selector); + if (d->next == 0) + break; - switch (selector->type) { + d++; + } +} + +/** + * Dump a CSS selector detail + * + * \param detail The detail to dump + * \param target The file handle to output to + * \param size Pointer to current size of sheet, updated on exit + */ +void css_stylesheet_dump_selector_detail(css_selector_detail *detail, + FILE *target, size_t *size) +{ + + *size += sizeof(css_selector_detail); + + switch (detail->type) { case CSS_SELECTOR_ELEMENT: - if (selector->data.name.len == 1 && - selector->data.name.ptr[0] == '*' && - selector->specifics == NULL) { - css_stylesheet_dump_string(&selector->data.name, - target); - } else if (selector->data.name.len != 1 || - selector->data.name.ptr[0] != '*') { - css_stylesheet_dump_string(&selector->data.name, - target); + if (detail->name->len == 1 && detail->name->data[0] == '*' && + detail->next == 0) { + css_stylesheet_dump_string(detail->name, target); + } else if (detail->name->len != 1 || + detail->name->data[0] != '*') { + css_stylesheet_dump_string(detail->name, target); } break; case CSS_SELECTOR_CLASS: fprintf(target, "."); - css_stylesheet_dump_string(&selector->data.name, target); + css_stylesheet_dump_string(detail->name, target); break; case CSS_SELECTOR_ID: fprintf(target, "#"); - css_stylesheet_dump_string(&selector->data.name, target); + css_stylesheet_dump_string(detail->name, target); break; case CSS_SELECTOR_PSEUDO: fprintf(target, ":"); - css_stylesheet_dump_string(&selector->data.name, target); - if (selector->data.value.len > 0) { + css_stylesheet_dump_string(detail->name, target); + if (detail->value != NULL) { fprintf(target, "("); - css_stylesheet_dump_string(&selector->data.value, - target); + css_stylesheet_dump_string(detail->value, target); fprintf(target, ")"); } break; case CSS_SELECTOR_ATTRIBUTE: fprintf(target, "["); - css_stylesheet_dump_string(&selector->data.name, target); + css_stylesheet_dump_string(detail->name, target); fprintf(target, "]"); break; case CSS_SELECTOR_ATTRIBUTE_EQUAL: fprintf(target, "["); - css_stylesheet_dump_string(&selector->data.name, target); + css_stylesheet_dump_string(detail->name, target); fprintf(target, "=\""); - css_stylesheet_dump_string(&selector->data.value, target); + css_stylesheet_dump_string(detail->value, target); fprintf(target, "\"]"); break; case CSS_SELECTOR_ATTRIBUTE_DASHMATCH: fprintf(target, "["); - css_stylesheet_dump_string(&selector->data.name, target); + css_stylesheet_dump_string(detail->name, target); fprintf(target, "|=\""); - css_stylesheet_dump_string(&selector->data.value, target); + css_stylesheet_dump_string(detail->value, target); fprintf(target, "\"]"); break; case CSS_SELECTOR_ATTRIBUTE_INCLUDES: fprintf(target, "["); - css_stylesheet_dump_string(&selector->data.name, target); + css_stylesheet_dump_string(detail->name, target); fprintf(target, "~=\""); - css_stylesheet_dump_string(&selector->data.value, target); + css_stylesheet_dump_string(detail->value, target); fprintf(target, "\"]"); break; } - - for (s = selector->specifics; s != NULL; s = s->next) - css_stylesheet_dump_selector(s, target, size); } /** @@ -857,8 +1000,8 @@ void css_stylesheet_dump_selector(css_selector *selector, FILE *target, * \param string The string to dump * \param target The file handle to output to */ -void css_stylesheet_dump_string(css_string *string, FILE *target) +void css_stylesheet_dump_string(const css_string *string, FILE *target) { - fprintf(target, "%.*s", (int) string->len, string->ptr); + fprintf(target, "%.*s", (int) string->len, string->data); } diff --git a/src/stylesheet.h b/src/stylesheet.h index cedc3de..c5c2812 100644 --- a/src/stylesheet.h +++ b/src/stylesheet.h @@ -11,6 +11,8 @@ #include #include +#include + #include #include #include @@ -45,24 +47,24 @@ typedef enum css_combinator { CSS_COMBINATOR_SIBLING } css_combinator; -struct css_selector { - css_selector_type type; /**< Type of selector */ +typedef struct css_selector_detail { + const css_string *name; /**< Interned name */ + const css_string *value; /**< Interned value, or NULL */ - struct { - css_string name; - css_string value; - } data; /**< Selector data */ + uint32_t type : 4, /**< Type of selector */ + comb : 2, /**< Type of combinator */ + next : 1; /**< Another selector detail + * follows */ +} css_selector_detail; - uint32_t specificity; /**< Specificity of selector */ - css_selector *specifics; /**< Selector specifics */ - - css_combinator combinator_type; /**< Type of combinator */ +struct css_selector { css_selector *combinator; /**< Combining selector */ css_rule *rule; /**< Owning rule */ - css_selector *next; /**< Next selector in list */ - css_selector *prev; /**< Previous selector */ + uint32_t specificity; /**< Specificity of selector */ + + css_selector_detail data; /**< Selector data */ }; typedef enum css_rule_type { @@ -149,6 +151,8 @@ struct css_stylesheet { css_parser *parser; /**< Core parser for sheet */ void *parser_frontend; /**< Frontend parser */ + parserutils_dict *dictionary; /**< String dictionary */ + css_alloc alloc; /**< Allocation function */ void *pw; /**< Private word */ }; @@ -163,8 +167,14 @@ css_error css_stylesheet_selector_create(css_stylesheet *sheet, css_error css_stylesheet_selector_destroy(css_stylesheet *sheet, css_selector *selector); +css_error css_stylesheet_selector_detail_create(css_stylesheet *sheet, + css_selector_type type, const css_string *name, + const css_string *value, css_selector_detail **detail); +css_error css_stylesheet_selector_detail_destroy(css_stylesheet *sheet, + css_selector_detail *detail); + css_error css_stylesheet_selector_append_specific(css_stylesheet *sheet, - css_selector *parent, css_selector *specific); + css_selector **parent, css_selector_detail *specific); css_error css_stylesheet_selector_combine(css_stylesheet *sheet, css_combinator type, css_selector *a, css_selector *b); diff --git a/src/utils/utils.h b/src/utils/utils.h index 333a33f..a8848e3 100644 --- a/src/utils/utils.h +++ b/src/utils/utils.h @@ -43,7 +43,7 @@ static inline fixed number_from_css_string(const css_string *string, return 0; len = string->len; - ptr = string->ptr; + ptr = string->data; /* number = [+-]? ([0-9]+ | [0-9]* '.' [0-9]+) */ @@ -119,7 +119,7 @@ static inline fixed number_from_css_string(const css_string *string, intpart = (1 << 21) - 1; } - *consumed = ptr - string->ptr; + *consumed = ptr - string->data; return FMULI(((intpart << 10) | fracpart), sign); } diff --git a/test/lex-auto.c b/test/lex-auto.c index d336480..10f097c 100644 --- a/test/lex-auto.c +++ b/test/lex-auto.c @@ -41,11 +41,11 @@ static css_token_type string_to_type(const char *data, size_t len); static void run_test(const uint8_t *data, size_t len, exp_entry *exp, size_t explen); -static void *myrealloc(void *ptr, size_t len, void *pw) +static void *myrealloc(void *data, size_t len, void *pw) { UNUSED(pw); - return realloc(ptr, len); + return realloc(data, len); } int main(int argc, char **argv) @@ -302,11 +302,11 @@ void run_test(const uint8_t *data, size_t len, exp_entry *exp, size_t explen) assert(0 && "Text lengths differ"); } - if (strncmp((char *) tok->data.ptr, exp[e].text, + if (strncmp((char *) tok->data.data, exp[e].text, tok->data.len) != 0) { printf("%d: Got data '%.*s', Expected '%.*s'\n", testnum, - (int) tok->data.len, tok->data.ptr, + (int) tok->data.len, tok->data.data, (int) exp[e].textLen, exp[e].text); assert(0 && "Text differs"); } diff --git a/test/lex.c b/test/lex.c index 86c1c01..a95ba08 100644 --- a/test/lex.c +++ b/test/lex.c @@ -13,11 +13,11 @@ #include "testutils.h" -static void *myrealloc(void *ptr, size_t len, void *pw) +static void *myrealloc(void *data, size_t len, void *pw) { UNUSED(pw); - return realloc(ptr, len); + return realloc(data, len); } static void printToken(const css_token *token) @@ -30,42 +30,42 @@ static void printToken(const css_token *token) switch (token->type) { case CSS_TOKEN_IDENT: printf("IDENT(%.*s)", - (int) token->data.len, token->data.ptr); + (int) token->data.len, token->data.data); break; case CSS_TOKEN_ATKEYWORD: printf("ATKEYWORD(%.*s)", - (int) token->data.len, token->data.ptr); + (int) token->data.len, token->data.data); break; case CSS_TOKEN_STRING: printf("STRING(%.*s)", - (int) token->data.len, token->data.ptr); + (int) token->data.len, token->data.data); break; case CSS_TOKEN_INVALID_STRING: printf("INVALID(%.*s)", - (int) token->data.len, token->data.ptr); + (int) token->data.len, token->data.data); break; case CSS_TOKEN_HASH: printf("HASH(%.*s)", - (int) token->data.len, token->data.ptr); + (int) token->data.len, token->data.data); break; case CSS_TOKEN_NUMBER: printf("NUMBER(%.*s)", - (int) token->data.len, token->data.ptr); + (int) token->data.len, token->data.data); break; case CSS_TOKEN_PERCENTAGE: printf("PERCENTAGE(%.*s)", - (int) token->data.len, token->data.ptr); + (int) token->data.len, token->data.data); break; case CSS_TOKEN_DIMENSION: printf("DIMENSION(%.*s)", - (int) token->data.len, token->data.ptr); + (int) token->data.len, token->data.data); break; case CSS_TOKEN_URI: - printf("URI(%.*s)", (int) token->data.len, token->data.ptr); + printf("URI(%.*s)", (int) token->data.len, token->data.data); break; case CSS_TOKEN_UNICODE_RANGE: printf("UNICODE-RANGE(%.*s)", - (int) token->data.len, token->data.ptr); + (int) token->data.len, token->data.data); break; case CSS_TOKEN_CDO: printf("CDO"); @@ -77,11 +77,11 @@ static void printToken(const css_token *token) printf("S"); break; case CSS_TOKEN_COMMENT: - printf("COMMENT(%.*s)", (int) token->data.len, token->data.ptr); + printf("COMMENT(%.*s)", (int) token->data.len, token->data.data); break; case CSS_TOKEN_FUNCTION: printf("FUNCTION(%.*s)", - (int) token->data.len, token->data.ptr); + (int) token->data.len, token->data.data); break; case CSS_TOKEN_INCLUDES: printf("INCLUDES"); @@ -99,7 +99,7 @@ static void printToken(const css_token *token) printf("SUBSTRINGMATCH"); break; case CSS_TOKEN_CHAR: - printf("CHAR(%.*s)", (int) token->data.len, token->data.ptr); + printf("CHAR(%.*s)", (int) token->data.len, token->data.data); break; case CSS_TOKEN_EOF: printf("EOF"); diff --git a/test/number.c b/test/number.c index 7e793a2..8ef839e 100644 --- a/test/number.c +++ b/test/number.c @@ -107,7 +107,7 @@ bool handle_line(const char *data, size_t datalen, void *pw) void run_test(const uint8_t *data, size_t len, const char *exp, size_t explen) { - css_string in = { (uint8_t *) data, len }; + css_string in = { len, (uint8_t *) data }; size_t consumed; fixed result; char buf[256]; diff --git a/test/parse.c b/test/parse.c index 4ff9a6e..33dfe5f 100644 --- a/test/parse.c +++ b/test/parse.c @@ -24,11 +24,11 @@ static const char *event_names[] = { "DECLARATION" }; -static void *myrealloc(void *ptr, size_t len, void *pw) +static void *myrealloc(void *data, size_t len, void *pw) { UNUSED(pw); - return realloc(ptr, len); + return realloc(data, len); } static css_error event_handler(css_parser_event type, @@ -58,8 +58,8 @@ static css_error event_handler(css_parser_event type, printf("\n %d", token->type); - if (token->data.ptr != NULL) - printf(" %.*s", (int) token->data.len, token->data.ptr); + if (token->data.data != NULL) + printf(" %.*s", (int) token->data.len, token->data.data); } while (token != NULL); printf("\n"); @@ -71,6 +71,7 @@ static css_error event_handler(css_parser_event type, int main(int argc, char **argv) { css_parser_optparams params; + parserutils_dict *dict; css_parser *parser; FILE *fp; size_t len, origlen; @@ -86,7 +87,10 @@ int main(int argc, char **argv) /* Initialise library */ assert(css_initialise(argv[1], myrealloc, NULL) == CSS_OK); - assert(css_parser_create("UTF-8", CSS_CHARSET_DICTATED, + assert(parserutils_dict_create(myrealloc, NULL, &dict) == + PARSERUTILS_OK); + + assert(css_parser_create("UTF-8", CSS_CHARSET_DICTATED, dict, myrealloc, NULL, &parser) == CSS_OK); params.event_handler.handler = event_handler; @@ -128,6 +132,8 @@ int main(int argc, char **argv) css_parser_destroy(parser); + parserutils_dict_destroy(dict); + assert(css_finalise(myrealloc, NULL) == CSS_OK); printf("PASS\n"); -- cgit v1.2.3