/**
* Parse !important
*
* \param c Parsing context
* \param vector Vector of tokens to process
* \param ctx Pointer to vector iteration context
* \param result Pointer to location to receive result
* \return CSS_OK on success,
* CSS_INVALID if "S* ! S* important" is not at the start of the vector
*
* Post condition: \a *ctx is updated with the next token to process
* If the input is invalid, then \a *ctx remains unchanged.
*/
css_error css__parse_important(css_language *c,
const parserutils_vector *vector, int *ctx,
uint8_t *result)
{
int orig_ctx = *ctx;
bool match = false;
const css_token *token;
consumeWhitespace(vector, ctx);
token = parserutils_vector_iterate(vector, ctx);
if (token != NULL && tokenIsChar(token, '!')) {
consumeWhitespace(vector, ctx);
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || token->type != CSS_TOKEN_IDENT) {
*ctx = orig_ctx;
return CSS_INVALID;
}
if (lwc_string_caseless_isequal(token->idata, c->strings[IMPORTANT],
&match) == lwc_error_ok && match) {
*result |= FLAG_IMPORTANT;
} else {
*ctx = orig_ctx;
return CSS_INVALID;
}
} else if (token != NULL) {
*ctx = orig_ctx;
return CSS_INVALID;
}
return CSS_OK;
}
/**
* Parse content
*
* \param c Parsing context
* \param vector Vector of tokens to process
* \param ctx Pointer to vector iteration context
* \param result Pointer to location to receive resulting style
* \return CSS_OK on success,
* CSS_NOMEM on memory exhaustion,
* CSS_INVALID if the input is not valid
*
* Post condition: \a *ctx is updated with the next token to process
* If the input is invalid, then \a *ctx remains unchanged.
*/
css_error css__parse_content(css_language *c,
const parserutils_vector *vector, int *ctx,
css_style *result)
{
int orig_ctx = *ctx;
css_error error;
const css_token *token;
bool match;
/* IDENT(normal, none, inherit) | [ ... ]+ */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL) {
*ctx = orig_ctx;
return CSS_INVALID;
}
if ((token->type == CSS_TOKEN_IDENT) &&
(lwc_string_caseless_isequal(token->idata,
c->strings[INHERIT],
&match) == lwc_error_ok && match)) {
error = css_stylesheet_style_inherit(result, CSS_PROP_CONTENT);
} else if ((token->type == CSS_TOKEN_IDENT) &&
(lwc_string_caseless_isequal(token->idata,
c->strings[NORMAL],
&match) == lwc_error_ok && match)) {
error = css__stylesheet_style_appendOPV(result, CSS_PROP_CONTENT, 0, CONTENT_NORMAL);
} else if ((token->type == CSS_TOKEN_IDENT) &&
(lwc_string_caseless_isequal(token->idata,
c->strings[NONE],
&match) == lwc_error_ok && match)) {
error = css__stylesheet_style_appendOPV(result, CSS_PROP_CONTENT, 0, CONTENT_NONE);
} else {
/* Macro to output the value marker, awkward because we need to check
* first to determine how the value is constructed.
*/
#define CSS_APPEND(CSSVAL) css__stylesheet_style_append(result, first?buildOPV(CSS_PROP_CONTENT, 0, CSSVAL):CSSVAL)
bool first = true;
int prev_ctx = orig_ctx;
/* [
* IDENT(open-quote, close-quote, no-open-quote,
* no-close-quote) |
* STRING |
* URI |
* FUNCTION(attr) IDENT ')' |
* FUNCTION(counter) IDENT IDENT? ')' |
* FUNCTION(counters) IDENT STRING IDENT? ')'
* ]+
*/
while (token != NULL) {
if ((token->type == CSS_TOKEN_IDENT) &&
(lwc_string_caseless_isequal(
token->idata, c->strings[OPEN_QUOTE],
&match) == lwc_error_ok && match)) {
error = CSS_APPEND(CONTENT_OPEN_QUOTE);
} else if (token->type == CSS_TOKEN_IDENT &&
(lwc_string_caseless_isequal(
token->idata, c->strings[CLOSE_QUOTE],
&match) == lwc_error_ok && match)) {
error = CSS_APPEND(CONTENT_CLOSE_QUOTE);
} else if (token->type == CSS_TOKEN_IDENT &&
(lwc_string_caseless_isequal(
token->idata, c->strings[NO_OPEN_QUOTE],
&match) == lwc_error_ok && match)) {
error = CSS_APPEND(CONTENT_NO_OPEN_QUOTE);
} else if (token->type == CSS_TOKEN_IDENT &&
(lwc_string_caseless_isequal(
token->idata, c->strings[NO_CLOSE_QUOTE],
&match) == lwc_error_ok && match)) {
error = CSS_APPEND(CONTENT_NO_CLOSE_QUOTE);
} else if (token->type == CSS_TOKEN_STRING) {
uint32_t snumber;
error = css__stylesheet_string_add(c->sheet, lwc_string_ref(token->idata), &snumber);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = CSS_APPEND(CONTENT_STRING);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = css__stylesheet_style_append(result, snumber);
} else if (token->type == CSS_TOKEN_URI) {
lwc_string *uri;
uint32_t uri_snumber;
error = c->sheet->resolve(c->sheet->resolve_pw,
c->sheet->url,
token->idata,
&uri);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = css__stylesheet_string_add(c->sheet,
uri,
&uri_snumber);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = CSS_APPEND(CONTENT_URI);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = css__stylesheet_style_append(result, uri_snumber);
} else if (token->type == CSS_TOKEN_FUNCTION &&
(lwc_string_caseless_isequal(
token->idata, c->strings[ATTR],
&match) == lwc_error_ok && match)) {
uint32_t snumber;
consumeWhitespace(vector, ctx);
/* Expect IDENT */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || token->type != CSS_TOKEN_IDENT) {
*ctx = orig_ctx;
return CSS_INVALID;
}
error = css__stylesheet_string_add(c->sheet, lwc_string_ref(token->idata), &snumber);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = CSS_APPEND(CONTENT_ATTR);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = css__stylesheet_style_append(result, snumber);
consumeWhitespace(vector, ctx);
/* Expect ')' */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || tokenIsChar(token, ')') == false) {
*ctx = orig_ctx;
return CSS_INVALID;
}
} else if (token->type == CSS_TOKEN_FUNCTION &&
(lwc_string_caseless_isequal(
token->idata, c->strings[COUNTER],
&match) == lwc_error_ok && match)) {
lwc_string *name;
uint32_t snumber;
uint32_t opv;
opv = CONTENT_COUNTER;
consumeWhitespace(vector, ctx);
/* Expect IDENT */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || token->type != CSS_TOKEN_IDENT) {
*ctx = orig_ctx;
return CSS_INVALID;
}
name = token->idata;
consumeWhitespace(vector, ctx);
/* Possible ',' */
token = parserutils_vector_peek(vector, *ctx);
if (token == NULL ||
(tokenIsChar(token, ',') == false &&
tokenIsChar(token, ')') == false)) {
*ctx = orig_ctx;
return CSS_INVALID;
}
if (tokenIsChar(token, ',')) {
uint16_t v;
parserutils_vector_iterate(vector, ctx);
consumeWhitespace(vector, ctx);
/* Expect IDENT */
token = parserutils_vector_peek(vector, *ctx);
if (token == NULL || token->type !=
CSS_TOKEN_IDENT) {
*ctx = orig_ctx;
return CSS_INVALID;
}
error = css__parse_list_style_type_value(c, token, &v);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
opv |= v << CONTENT_COUNTER_STYLE_SHIFT;
parserutils_vector_iterate(vector, ctx);
consumeWhitespace(vector, ctx);
} else {
opv |= LIST_STYLE_TYPE_DECIMAL <<
CONTENT_COUNTER_STYLE_SHIFT;
}
/* Expect ')' */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || tokenIsChar(token, ')') == false) {
*ctx = orig_ctx;
return CSS_INVALID;
}
error = css__stylesheet_string_add(c->sheet, lwc_string_ref(name), &snumber);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = CSS_APPEND(opv);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = css__stylesheet_style_append(result, snumber);
} else if (token->type == CSS_TOKEN_FUNCTION &&
(lwc_string_caseless_isequal(
token->idata, c->strings[COUNTERS],
&match) == lwc_error_ok && match)) {
lwc_string *name;
lwc_string *sep;
uint32_t name_snumber;
uint32_t sep_snumber;
uint32_t opv;
opv = CONTENT_COUNTERS;
consumeWhitespace(vector, ctx);
/* Expect IDENT */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || token->type != CSS_TOKEN_IDENT) {
*ctx = orig_ctx;
return CSS_INVALID;
}
name = token->idata;
consumeWhitespace(vector, ctx);
/* Expect ',' */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || tokenIsChar(token, ',') == false) {
*ctx = orig_ctx;
return CSS_INVALID;
}
consumeWhitespace(vector, ctx);
/* Expect STRING */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || token->type != CSS_TOKEN_STRING) {
*ctx = orig_ctx;
return CSS_INVALID;
}
sep = token->idata;
consumeWhitespace(vector, ctx);
/* Possible ',' */
token = parserutils_vector_peek(vector, *ctx);
if (token == NULL ||
(tokenIsChar(token, ',') == false &&
tokenIsChar(token, ')') == false)) {
*ctx = orig_ctx;
return CSS_INVALID;
}
if (tokenIsChar(token, ',')) {
uint16_t v;
parserutils_vector_iterate(vector, ctx);
consumeWhitespace(vector, ctx);
/* Expect IDENT */
token = parserutils_vector_peek(vector, *ctx);
if (token == NULL || token->type !=
CSS_TOKEN_IDENT) {
*ctx = orig_ctx;
return CSS_INVALID;
}
error = css__parse_list_style_type_value(c,
token, &v);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
opv |= v << CONTENT_COUNTERS_STYLE_SHIFT;
parserutils_vector_iterate(vector, ctx);
consumeWhitespace(vector, ctx);
} else {
opv |= LIST_STYLE_TYPE_DECIMAL <<
CONTENT_COUNTERS_STYLE_SHIFT;
}
/* Expect ')' */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || tokenIsChar(token, ')') == false) {
*ctx = orig_ctx;
return CSS_INVALID;
}
error = css__stylesheet_string_add(c->sheet, lwc_string_ref(name), &name_snumber);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = css__stylesheet_string_add(c->sheet, lwc_string_ref(sep), &sep_snumber);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = CSS_APPEND(opv);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = css__stylesheet_style_append(result, name_snumber);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
error = css__stylesheet_style_append(result, sep_snumber);
} else if (first) {
/* Invalid if this is the first iteration */
error = CSS_INVALID;
} else {
/* Give up, ensuring current token is reprocessed */
*ctx = prev_ctx;
error = CSS_OK;
break;
}
/* if there was an error bail */
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
first = false;
consumeWhitespace(vector, ctx);
prev_ctx = *ctx;
token = parserutils_vector_iterate(vector, ctx);
} /* while */
/* Write list terminator */
css__stylesheet_style_append(result, CONTENT_NORMAL);
}
if (error != CSS_OK)
*ctx = orig_ctx;
return error;
}
/**
* Parse a colour specifier
*
* \param c Parsing context
* \param vector Vector of tokens to process
* \param ctx Pointer to vector iteration context
* \param value Pointer to location to receive value
* \param result Pointer to location to receive result (AARRGGBB)
* \return CSS_OK on success,
* CSS_INVALID if the input is invalid
*
* Post condition: \a *ctx is updated with the next token to process
* If the input is invalid, then \a *ctx remains unchanged.
*/
css_error css__parse_colour_specifier(css_language *c,
const parserutils_vector *vector, int *ctx,
uint16_t *value, uint32_t *result)
{
int orig_ctx = *ctx;
const css_token *token;
bool match;
css_error error;
consumeWhitespace(vector, ctx);
/* IDENT(<colour name>) |
* HASH(rgb | rrggbb) |
* FUNCTION(rgb) [ [ NUMBER | PERCENTAGE ] ',' ] {3} ')'
* FUNCTION(rgba) [ [ NUMBER | PERCENTAGE ] ',' ] {4} ')'
* FUNCTION(hsl) ANGLE ',' PERCENTAGE ',' PERCENTAGE ')'
* FUNCTION(hsla) ANGLE ',' PERCENTAGE ',' PERCENTAGE ',' NUMBER ')'
*
* For quirks, NUMBER | DIMENSION | IDENT, too
* I.E. "123456" -> NUMBER, "1234f0" -> DIMENSION, "f00000" -> IDENT
*/
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || (token->type != CSS_TOKEN_IDENT &&
token->type != CSS_TOKEN_HASH &&
token->type != CSS_TOKEN_FUNCTION)) {
if (c->sheet->quirks_allowed == false ||
token == NULL ||
(token->type != CSS_TOKEN_NUMBER &&
token->type != CSS_TOKEN_DIMENSION))
goto invalid;
}
if (token->type == CSS_TOKEN_IDENT) {
if ((lwc_string_caseless_isequal(
token->idata, c->strings[TRANSPARENT],
&match) == lwc_error_ok && match)) {
*value = COLOR_TRANSPARENT;
*result = 0; /* black transparent */
return CSS_OK;
} else if ((lwc_string_caseless_isequal(
token->idata, c->strings[CURRENTCOLOR],
&match) == lwc_error_ok && match)) {
*value = COLOR_CURRENT_COLOR;
*result = 0;
return CSS_OK;
}
error = css__parse_named_colour(c, token->idata, result);
if (error != CSS_OK && c->sheet->quirks_allowed) {
error = css__parse_hash_colour(token->idata, result);
if (error == CSS_OK)
c->sheet->quirks_used = true;
}
if (error != CSS_OK)
goto invalid;
} else if (token->type == CSS_TOKEN_HASH) {
error = css__parse_hash_colour(token->idata, result);
if (error != CSS_OK)
goto invalid;
} else if (c->sheet->quirks_allowed &&
token->type == CSS_TOKEN_NUMBER) {
error = css__parse_hash_colour(token->idata, result);
if (error == CSS_OK)
c->sheet->quirks_used = true;
else
goto invalid;
} else if (c->sheet->quirks_allowed &&
token->type == CSS_TOKEN_DIMENSION) {
error = css__parse_hash_colour(token->idata, result);
if (error == CSS_OK)
c->sheet->quirks_used = true;
else
goto invalid;
} else if (token->type == CSS_TOKEN_FUNCTION) {
uint8_t r = 0, g = 0, b = 0, a = 0xff;
int colour_channels = 0;
if ((lwc_string_caseless_isequal(
token->idata, c->strings[RGB],
&match) == lwc_error_ok && match)) {
colour_channels = 3;
} else if ((lwc_string_caseless_isequal(
token->idata, c->strings[RGBA],
&match) == lwc_error_ok && match)) {
colour_channels = 4;
} if ((lwc_string_caseless_isequal(
token->idata, c->strings[HSL],
&match) == lwc_error_ok && match)) {
colour_channels = 5;
} else if ((lwc_string_caseless_isequal(
token->idata, c->strings[HSLA],
&match) == lwc_error_ok && match)) {
colour_channels = 6;
}
if (colour_channels == 3 || colour_channels == 4) {
int i;
css_token_type valid = CSS_TOKEN_NUMBER;
uint8_t *components[4] = { &r, &g, &b, &a };
for (i = 0; i < colour_channels; i++) {
uint8_t *component;
css_fixed num;
size_t consumed = 0;
int32_t intval;
bool int_only;
component = components[i];
consumeWhitespace(vector, ctx);
token = parserutils_vector_peek(vector, *ctx);
if (token == NULL || (token->type !=
CSS_TOKEN_NUMBER &&
token->type !=
CSS_TOKEN_PERCENTAGE))
goto invalid;
if (i == 0)
valid = token->type;
else if (i < 3 && token->type != valid)
goto invalid;
/* The alpha channel may be a float */
if (i < 3)
int_only = (valid == CSS_TOKEN_NUMBER);
else
int_only = false;
num = css__number_from_lwc_string(token->idata,
int_only, &consumed);
if (consumed != lwc_string_length(token->idata))
goto invalid;
if (valid == CSS_TOKEN_NUMBER) {
if (i == 3) {
/* alpha channel */
intval = FIXTOINT(
FMUL(num, F_255));
} else {
/* colour channels */
intval = FIXTOINT(num);
}
} else {
intval = FIXTOINT(
FDIV(FMUL(num, F_255), F_100));
}
if (intval > 255)
*component = 255;
else if (intval < 0)
*component = 0;
else
*component = intval;
parserutils_vector_iterate(vector, ctx);
consumeWhitespace(vector, ctx);
token = parserutils_vector_peek(vector, *ctx);
if (token == NULL)
goto invalid;
if (i != (colour_channels - 1) &&
tokenIsChar(token, ',')) {
parserutils_vector_iterate(vector, ctx);
} else if (i == (colour_channels - 1) &&
tokenIsChar(token, ')')) {
parserutils_vector_iterate(vector, ctx);
} else {
goto invalid;
}
}
} else if (colour_channels == 5 || colour_channels == 6) {
/* hue - saturation - lightness */
size_t consumed = 0;
css_fixed hue, sat, lit;
int32_t alpha = 255;
/* hue is a number without a unit representing an
* angle (0-360) degrees
*/
consumeWhitespace(vector, ctx);
token = parserutils_vector_iterate(vector, ctx);
if ((token == NULL) || (token->type != CSS_TOKEN_NUMBER))
goto invalid;
hue = css__number_from_lwc_string(token->idata, false, &consumed);
if (consumed != lwc_string_length(token->idata))
goto invalid; /* failed to consume the whole string as a number */
/* Normalise hue to the range [0, 360) */
while (hue < 0)
hue += F_360;
while (hue >= F_360)
hue -= F_360;
consumeWhitespace(vector, ctx);
token = parserutils_vector_iterate(vector, ctx);
if (!tokenIsChar(token, ','))
goto invalid;
/* saturation */
consumeWhitespace(vector, ctx);
token = parserutils_vector_iterate(vector, ctx);
if ((token == NULL) || (token->type != CSS_TOKEN_PERCENTAGE))
goto invalid;
sat = css__number_from_lwc_string(token->idata, false, &consumed);
if (consumed != lwc_string_length(token->idata))
goto invalid; /* failed to consume the whole string as a number */
/* Normalise saturation to the range [0, 100] */
if (sat < INTTOFIX(0))
sat = INTTOFIX(0);
else if (sat > INTTOFIX(100))
sat = INTTOFIX(100);
consumeWhitespace(vector, ctx);
token = parserutils_vector_iterate(vector, ctx);
if (!tokenIsChar(token, ','))
goto invalid;
/* lightness */
consumeWhitespace(vector, ctx);
token = parserutils_vector_iterate(vector, ctx);
if ((token == NULL) || (token->type != CSS_TOKEN_PERCENTAGE))
goto invalid;
lit = css__number_from_lwc_string(token->idata, false, &consumed);
if (consumed != lwc_string_length(token->idata))
goto invalid; /* failed to consume the whole string as a number */
/* Normalise lightness to the range [0, 100] */
if (lit < INTTOFIX(0))
lit = INTTOFIX(0);
else if (lit > INTTOFIX(100))
lit = INTTOFIX(100);
consumeWhitespace(vector, ctx);
token = parserutils_vector_iterate(vector, ctx);
if (colour_channels == 6) {
/* alpha */
if (!tokenIsChar(token, ','))
goto invalid;
consumeWhitespace(vector, ctx);
token = parserutils_vector_iterate(vector, ctx);
if ((token == NULL) || (token->type != CSS_TOKEN_NUMBER))
goto invalid;
alpha = css__number_from_lwc_string(token->idata, false, &consumed);
if (consumed != lwc_string_length(token->idata))
goto invalid; /* failed to consume the whole string as a number */
alpha = FIXTOINT(FMUL(alpha, F_255));
consumeWhitespace(vector, ctx);
token = parserutils_vector_iterate(vector, ctx);
}
if (!tokenIsChar(token, ')'))
goto invalid;
/* have a valid HSV entry, convert to RGB */
HSL_to_RGB(hue, sat, lit, &r, &g, &b);
/* apply alpha */
if (alpha > 255)
a = 255;
else if (alpha < 0)
a = 0;
else
a = alpha;
} else {
goto invalid;
}
*result = (a << 24) | (r << 16) | (g << 8) | b;
}
*value = COLOR_SET;
return CSS_OK;
invalid:
*ctx = orig_ctx;
return CSS_INVALID;
}
/**
* Parse a comma separated list, converting to bytecode
*
* \param c Parsing context
* \param vector Vector of tokens to process
* \param ctx Pointer to vector iteration context
* \param reserved Callback to determine if an identifier is reserved
* \param get_value Callback to retrieve bytecode value for a token
* \param style Pointer to output style
* \return CSS_OK on success,
* CSS_INVALID if the input is invalid
*
* Post condition: \a *ctx is updated with the next token to process
* If the input is invalid, then \a *ctx remains unchanged.
*/
css_error css__comma_list_to_style(css_language *c,
const parserutils_vector *vector, int *ctx,
bool (*reserved)(css_language *c, const css_token *ident),
css_code_t (*get_value)(css_language *c, const css_token *token, bool first),
css_style *result)
{
int orig_ctx = *ctx;
int prev_ctx = orig_ctx;
const css_token *token;
bool first = true;
css_error error = CSS_OK;
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL) {
*ctx = orig_ctx;
return CSS_INVALID;
}
while (token != NULL) {
if (token->type == CSS_TOKEN_IDENT) {
css_code_t value = get_value(c, token, first);
if (reserved(c, token) == false) {
lwc_string *str = NULL;
uint32_t snumber;
*ctx = prev_ctx;
error = css__ident_list_to_string(c, vector, ctx,
reserved, &str);
if (error != CSS_OK)
goto cleanup;
error = css__stylesheet_string_add(c->sheet,
str, &snumber);
if (error != CSS_OK)
goto cleanup;
error = css__stylesheet_style_append(result,
value);
if (error != CSS_OK)
goto cleanup;
error = css__stylesheet_style_append(result,
snumber);
if (error != CSS_OK)
goto cleanup;
} else {
error = css__stylesheet_style_append(result,
value);
if (error != CSS_OK)
goto cleanup;
}
} else if (token->type == CSS_TOKEN_STRING) {
css_code_t value = get_value(c, token, first);
uint32_t snumber;
error = css__stylesheet_string_add(c->sheet,
lwc_string_ref(token->idata), &snumber);
if (error != CSS_OK)
goto cleanup;
error = css__stylesheet_style_append(result, value);
if (error != CSS_OK)
goto cleanup;
error = css__stylesheet_style_append(result, snumber);
if (error != CSS_OK)
goto cleanup;
} else {
error = CSS_INVALID;
goto cleanup;
}
consumeWhitespace(vector, ctx);
token = parserutils_vector_peek(vector, *ctx);
if (token != NULL && tokenIsChar(token, ',')) {
parserutils_vector_iterate(vector, ctx);
consumeWhitespace(vector, ctx);
token = parserutils_vector_peek(vector, *ctx);
if (token == NULL || (token->type != CSS_TOKEN_IDENT &&
token->type != CSS_TOKEN_STRING)) {
error = CSS_INVALID;
goto cleanup;
}
} else {
break;
}
first = false;
prev_ctx = *ctx;
token = parserutils_vector_iterate(vector, ctx);
}
cleanup:
if (error != CSS_OK)
*ctx = orig_ctx;
return error;
}
/**
* Parse clip
*
* \param c Parsing context
* \param vector Vector of tokens to process
* \param ctx Pointer to vector iteration context
* \param result Pointer to location to receive resulting style
* \return CSS_OK on success,
* CSS_NOMEM on memory exhaustion,
* CSS_INVALID if the input is not valid
*
* Post condition: \a *ctx is updated with the next token to process
* If the input is invalid, then \a *ctx remains unchanged.
*/
css_error css__parse_clip(css_language *c,
const parserutils_vector *vector, int *ctx,
css_style *result)
{
int orig_ctx = *ctx;
css_error error;
const css_token *token;
int num_lengths = 0;
css_fixed length[4] = { 0 };
uint32_t unit[4] = { 0 };
bool match;
/* FUNCTION(rect) [ [ IDENT(auto) | length ] CHAR(,)? ]{3}
* [ IDENT(auto) | length ] CHAR{)} |
* IDENT(auto, inherit) */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL) {
*ctx = orig_ctx;
return CSS_INVALID;
}
if ((token->type == CSS_TOKEN_IDENT) &&
(lwc_string_caseless_isequal(
token->idata, c->strings[INHERIT],
&match) == lwc_error_ok && match)) {
error = css__stylesheet_style_appendOPV(result,
CSS_PROP_CLIP,
FLAG_INHERIT,
0);
} else if ((token->type == CSS_TOKEN_IDENT) &&
(lwc_string_caseless_isequal(
token->idata, c->strings[AUTO],
&match) == lwc_error_ok && match)) {
error = css__stylesheet_style_appendOPV(result,
CSS_PROP_CLIP,
0,
CLIP_AUTO);
} else if ((token->type == CSS_TOKEN_FUNCTION) &&
(lwc_string_caseless_isequal(
token->idata, c->strings[RECT],
&match) == lwc_error_ok && match)) {
int i;
uint16_t value = CLIP_SHAPE_RECT;
for (i = 0; i < 4; i++) {
consumeWhitespace(vector, ctx);
token = parserutils_vector_peek(vector, *ctx);
if (token == NULL) {
*ctx = orig_ctx;
return CSS_INVALID;
}
if (token->type == CSS_TOKEN_IDENT) {
/* Slightly magical way of generating the auto
* values. These are bits 3-6 of the value. */
if ((lwc_string_caseless_isequal(
token->idata, c->strings[AUTO],
&match) == lwc_error_ok &&
match))
value |= 1 << (i + 3);
else {
*ctx = orig_ctx;
return CSS_INVALID;
}
parserutils_vector_iterate(vector, ctx);
} else {
error = css__parse_unit_specifier(c, vector, ctx,
UNIT_PX,
&length[num_lengths],
&unit[num_lengths]);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
if (unit[num_lengths] & UNIT_ANGLE ||
unit[num_lengths] & UNIT_TIME ||
unit[num_lengths] & UNIT_FREQ ||
unit[num_lengths] & UNIT_PCT) {
*ctx = orig_ctx;
return CSS_INVALID;
}
num_lengths++;
}
consumeWhitespace(vector, ctx);
/* Consume optional comma after first 3 parameters */
if (i < 3) {
token = parserutils_vector_peek(vector, *ctx);
if (token == NULL) {
*ctx = orig_ctx;
return CSS_INVALID;
}
if (tokenIsChar(token, ','))
parserutils_vector_iterate(vector, ctx);
}
}
consumeWhitespace(vector, ctx);
/* Finally, consume closing parenthesis */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || tokenIsChar(token, ')') == false) {
*ctx = orig_ctx;
return CSS_INVALID;
}
/* output bytecode */
error = css__stylesheet_style_appendOPV(result,
CSS_PROP_CLIP,
0,
value);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
for (i = 0; i < num_lengths; i++) {
error = css__stylesheet_style_vappend(result,
2,
length[i],
unit[i]);
if (error != CSS_OK)
break;
}
} else {
error = CSS_INVALID;
}
if (error != CSS_OK) {
*ctx = orig_ctx;
}
return error;
}
/**
* Parse clip
*
* \param c Parsing context
* \param vector Vector of tokens to process
* \param ctx Pointer to vector iteration context
* \param result Pointer to location to receive resulting style
* \return CSS_OK on success,
* CSS_NOMEM on memory exhaustion,
* CSS_INVALID if the input is not valid
*
* Post condition: \a *ctx is updated with the next token to process
* If the input is invalid, then \a *ctx remains unchanged.
*/
css_error parse_clip(css_language *c,
const parserutils_vector *vector, int *ctx,
css_style **result)
{
int orig_ctx = *ctx;
css_error error;
const css_token *token;
uint8_t flags = 0;
uint16_t value = 0;
uint32_t opv;
int num_lengths = 0;
css_fixed length[4] = { 0 };
uint32_t unit[4] = { 0 };
uint32_t required_size;
bool match;
/* FUNCTION(rect) [ [ IDENT(auto) | length ] CHAR(,)? ]{3}
* [ IDENT(auto) | length ] CHAR{)} |
* IDENT(auto, inherit) */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL) {
*ctx = orig_ctx;
return CSS_INVALID;
}
if (token->type == CSS_TOKEN_IDENT &&
(lwc_string_caseless_isequal(
token->idata, c->strings[INHERIT],
&match) == lwc_error_ok && match)) {
flags = FLAG_INHERIT;
} else if (token->type == CSS_TOKEN_IDENT &&
(lwc_string_caseless_isequal(
token->idata, c->strings[AUTO],
&match) == lwc_error_ok && match)) {
value = CLIP_AUTO;
} else if (token->type == CSS_TOKEN_FUNCTION &&
(lwc_string_caseless_isequal(
token->idata, c->strings[RECT],
&match) == lwc_error_ok && match)) {
int i;
value = CLIP_SHAPE_RECT;
for (i = 0; i < 4; i++) {
consumeWhitespace(vector, ctx);
token = parserutils_vector_peek(vector, *ctx);
if (token == NULL) {
*ctx = orig_ctx;
return CSS_INVALID;
}
if (token->type == CSS_TOKEN_IDENT) {
/* Slightly magical way of generating the auto
* values. These are bits 3-6 of the value. */
if ((lwc_string_caseless_isequal(
token->idata, c->strings[AUTO],
&match) == lwc_error_ok &&
match))
value |= 1 << (i + 3);
else {
*ctx = orig_ctx;
return CSS_INVALID;
}
parserutils_vector_iterate(vector, ctx);
} else {
error = parse_unit_specifier(c, vector, ctx,
UNIT_PX,
&length[num_lengths],
&unit[num_lengths]);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
if (unit[num_lengths] & UNIT_ANGLE ||
unit[num_lengths] & UNIT_TIME ||
unit[num_lengths] & UNIT_FREQ ||
unit[num_lengths] & UNIT_PCT) {
*ctx = orig_ctx;
return CSS_INVALID;
}
num_lengths++;
}
consumeWhitespace(vector, ctx);
/* Consume optional comma after first 3 parameters */
if (i < 3) {
token = parserutils_vector_peek(vector, *ctx);
if (token == NULL) {
*ctx = orig_ctx;
return CSS_INVALID;
}
if (tokenIsChar(token, ','))
parserutils_vector_iterate(vector, ctx);
}
}
consumeWhitespace(vector, ctx);
/* Finally, consume closing parenthesis */
token = parserutils_vector_iterate(vector, ctx);
if (token == NULL || tokenIsChar(token, ')') == false) {
*ctx = orig_ctx;
return CSS_INVALID;
}
} else {
*ctx = orig_ctx;
return CSS_INVALID;
}
opv = buildOPV(CSS_PROP_CLIP, flags, value);
required_size = sizeof(opv);
if ((flags & FLAG_INHERIT) == false &&
(value & CLIP_SHAPE_MASK) == CLIP_SHAPE_RECT) {
required_size +=
num_lengths * (sizeof(length[0]) + sizeof(unit[0]));
}
/* Allocate result */
error = css_stylesheet_style_create(c->sheet, required_size, result);
if (error != CSS_OK) {
*ctx = orig_ctx;
return error;
}
/* Copy the bytecode to it */
memcpy((*result)->bytecode, &opv, sizeof(opv));
if ((flags & FLAG_INHERIT) == false &&
(value & CLIP_SHAPE_MASK) == CLIP_SHAPE_RECT) {
int i;
uint8_t *ptr = ((uint8_t *) (*result)->bytecode) + sizeof(opv);
for (i = 0; i < num_lengths; i++) {
memcpy(ptr, &length[i], sizeof(length[i]));
ptr += sizeof(length[i]);
memcpy(ptr, &unit[i], sizeof(unit[i]));
ptr += sizeof(unit[i]);
}
}
return CSS_OK;
}
