summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/lex/lex.c62
-rw-r--r--src/parse/css21.c62
-rw-r--r--src/parse/css21props.c520
-rw-r--r--src/parse/parse.c186
-rw-r--r--src/parse/parse.h4
-rw-r--r--src/stylesheet.c253
-rw-r--r--src/stylesheet.h36
-rw-r--r--src/utils/utils.h4
8 files changed, 639 insertions, 488 deletions
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 <parserutils/utils/dict.h>
#include <parserutils/utils/vector.h>
#include <libcss/errors.h>
@@ -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;
@@ -395,32 +432,120 @@ css_error css_stylesheet_selector_destroy(css_stylesheet *sheet,
}
/**
+ * 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 <inttypes.h>
#include <stdio.h>
+#include <parserutils/utils/dict.h>
+
#include <libcss/errors.h>
#include <libcss/functypes.h>
#include <libcss/stylesheet.h>
@@ -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);
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-27 15:34:19 +0000