diff options
author | Michael Drake <Michael Drake tlsa@netsurf-browser.org> | 2019-05-04 14:54:04 +0100 |
---|---|---|
committer | Michael Drake <Michael Drake tlsa@netsurf-browser.org> | 2019-05-04 14:54:04 +0100 |
commit | ace5978891ce0c2e1700945a296881fc62109701 (patch) | |
tree | cbc8d71fb5116b7d65b9b607b71335ecc61c6af2 /src/parse | |
parent | 4591e4851068ab16afdecbaef5eccacc71344ffa (diff) | |
parent | 44feffba4ab7178cca1dbdb4e218d6a93861f804 (diff) | |
download | libcss-ace5978891ce0c2e1700945a296881fc62109701.tar.gz libcss-ace5978891ce0c2e1700945a296881fc62109701.tar.bz2 |
Merge branch 'tlsa/jmb/mq2'
Diffstat (limited to 'src/parse')
-rw-r--r-- | src/parse/Makefile | 2 | ||||
-rw-r--r-- | src/parse/language.c | 112 | ||||
-rw-r--r-- | src/parse/mq.c | 1150 | ||||
-rw-r--r-- | src/parse/mq.h | 100 | ||||
-rw-r--r-- | src/parse/parse.c | 204 | ||||
-rw-r--r-- | src/parse/parse.h | 2 | ||||
-rw-r--r-- | src/parse/properties/utils.c | 8 | ||||
-rw-r--r-- | src/parse/propstrings.c | 4 | ||||
-rw-r--r-- | src/parse/propstrings.h | 2 |
9 files changed, 1413 insertions, 171 deletions
diff --git a/src/parse/Makefile b/src/parse/Makefile index 99f55d0..6d11096 100644 --- a/src/parse/Makefile +++ b/src/parse/Makefile @@ -1,4 +1,4 @@ # Sources -DIR_SOURCES := parse.c language.c important.c propstrings.c font_face.c +DIR_SOURCES := parse.c language.c important.c propstrings.c font_face.c mq.c include $(NSBUILD)/Makefile.subdir diff --git a/src/parse/language.c b/src/parse/language.c index 9af2547..54fac9a 100644 --- a/src/parse/language.c +++ b/src/parse/language.c @@ -15,6 +15,7 @@ #include "parse/font_face.h" #include "parse/important.h" #include "parse/language.h" +#include "parse/mq.h" #include "parse/parse.h" #include "parse/propstrings.h" #include "parse/properties/properties.h" @@ -53,9 +54,6 @@ static css_error handleDeclaration(css_language *c, const parserutils_vector *vector); /* At-rule parsing */ -static css_error parseMediaList(css_language *c, - const parserutils_vector *vector, int *ctx, - uint64_t *media); static css_error addNamespace(css_language *c, lwc_string *prefix, lwc_string *uri); static css_error lookupNamespace(css_language *c, @@ -416,10 +414,9 @@ css_error handleStartAtRule(css_language *c, const parserutils_vector *vector) match) { if (c->state <= IMPORT_PERMITTED) { lwc_string *url; - uint64_t media = 0; + css_mq_query *media = NULL; - /* any0 = (STRING | URI) ws - * (IDENT ws (',' ws IDENT ws)* )? */ + /* any0 = (STRING | URI) ws (media query)? */ const css_token *uri = parserutils_vector_iterate(vector, &ctx); if (uri == NULL || (uri->type != CSS_TOKEN_STRING && @@ -429,15 +426,18 @@ css_error handleStartAtRule(css_language *c, const parserutils_vector *vector) consumeWhitespace(vector, &ctx); /* Parse media list */ - error = parseMediaList(c, vector, &ctx, &media); + error = css__mq_parse_media_list( + c->strings, vector, &ctx, &media); if (error != CSS_OK) return error; /* Create rule */ error = css__stylesheet_rule_create(c->sheet, CSS_RULE_IMPORT, &rule); - if (error != CSS_OK) + if (error != CSS_OK) { + css__mq_query_destroy(media); return error; + } /* Resolve import URI */ error = c->sheet->resolve(c->sheet->resolve_pw, @@ -445,6 +445,7 @@ css_error handleStartAtRule(css_language *c, const parserutils_vector *vector) uri->idata, &url); if (error != CSS_OK) { css__stylesheet_rule_destroy(c->sheet, rule); + css__mq_query_destroy(media); return error; } @@ -454,13 +455,14 @@ css_error handleStartAtRule(css_language *c, const parserutils_vector *vector) if (error != CSS_OK) { lwc_string_unref(url); css__stylesheet_rule_destroy(c->sheet, rule); + css__mq_query_destroy(media); return error; } /* Inform client of need for import */ if (c->sheet->import != NULL) { error = c->sheet->import(c->sheet->import_pw, - c->sheet, url, media); + c->sheet, url); if (error != CSS_OK) { lwc_string_unref(url); css__stylesheet_rule_destroy(c->sheet, @@ -527,22 +529,25 @@ css_error handleStartAtRule(css_language *c, const parserutils_vector *vector) } } else if (lwc_string_caseless_isequal(atkeyword->idata, c->strings[MEDIA], &match) == lwc_error_ok && match) { - uint64_t media = 0; + css_mq_query *media = NULL; - /* any0 = IDENT ws (',' ws IDENT ws)* */ - - error = parseMediaList(c, vector, &ctx, &media); + /* any0 = media query */ + error = css__mq_parse_media_list( + c->strings, vector, &ctx, &media); if (error != CSS_OK) return error; error = css__stylesheet_rule_create(c->sheet, CSS_RULE_MEDIA, &rule); - if (error != CSS_OK) + if (error != CSS_OK) { + css__mq_query_destroy(media); return error; + } error = css__stylesheet_rule_set_media(c->sheet, rule, media); if (error != CSS_OK) { css__stylesheet_rule_destroy(c->sheet, rule); + css__mq_query_destroy(media); return error; } @@ -795,85 +800,6 @@ css_error handleDeclaration(css_language *c, const parserutils_vector *vector) * At-rule parsing functions * ******************************************************************************/ -css_error parseMediaList(css_language *c, - const parserutils_vector *vector, int *ctx, - uint64_t *media) -{ - uint64_t ret = 0; - bool match = false; - const css_token *token; - - token = parserutils_vector_iterate(vector, ctx); - - while (token != NULL) { - if (token->type != CSS_TOKEN_IDENT) - return CSS_INVALID; - - if (lwc_string_caseless_isequal(token->idata, c->strings[AURAL], - &match) == lwc_error_ok && match) { - ret |= CSS_MEDIA_AURAL; - } else if (lwc_string_caseless_isequal( - token->idata, c->strings[BRAILLE], - &match) == lwc_error_ok && match) { - ret |= CSS_MEDIA_BRAILLE; - } else if (lwc_string_caseless_isequal( - token->idata, c->strings[EMBOSSED], - &match) == lwc_error_ok && match) { - ret |= CSS_MEDIA_EMBOSSED; - } else if (lwc_string_caseless_isequal( - token->idata, c->strings[HANDHELD], - &match) == lwc_error_ok && match) { - ret |= CSS_MEDIA_HANDHELD; - } else if (lwc_string_caseless_isequal( - token->idata, c->strings[PRINT], - &match) == lwc_error_ok && match) { - ret |= CSS_MEDIA_PRINT; - } else if (lwc_string_caseless_isequal( - token->idata, c->strings[PROJECTION], - &match) == lwc_error_ok && match) { - ret |= CSS_MEDIA_PROJECTION; - } else if (lwc_string_caseless_isequal( - token->idata, c->strings[SCREEN], - &match) == lwc_error_ok && match) { - ret |= CSS_MEDIA_SCREEN; - } else if (lwc_string_caseless_isequal( - token->idata, c->strings[SPEECH], - &match) == lwc_error_ok && match) { - ret |= CSS_MEDIA_SPEECH; - } else if (lwc_string_caseless_isequal( - token->idata, c->strings[TTY], - &match) == lwc_error_ok && match) { - ret |= CSS_MEDIA_TTY; - } else if (lwc_string_caseless_isequal( - token->idata, c->strings[TV], - &match) == lwc_error_ok && match) { - ret |= CSS_MEDIA_TV; - } else if (lwc_string_caseless_isequal( - token->idata, c->strings[ALL], - &match) == lwc_error_ok && match) { - ret |= CSS_MEDIA_ALL; - } else - return CSS_INVALID; - - consumeWhitespace(vector, ctx); - - token = parserutils_vector_iterate(vector, ctx); - if (token != NULL && tokenIsChar(token, ',') == false) - return CSS_INVALID; - - consumeWhitespace(vector, ctx); - } - - /* If, after parsing the media list, we still have no media, - * then it must be ALL. */ - if (ret == 0) - ret = CSS_MEDIA_ALL; - - *media = ret; - - return CSS_OK; -} - /** * Add a namespace mapping * diff --git a/src/parse/mq.c b/src/parse/mq.c new file mode 100644 index 0000000..cb9345d --- /dev/null +++ b/src/parse/mq.c @@ -0,0 +1,1150 @@ +/* + * This file is part of LibCSS. + * Licensed under the MIT License, + * http://www.opensource.org/licenses/mit-license.php + * Copyright 2016 John-Mark Bell <jmb@netsurf-browser.org> + */ + +/* https://drafts.csswg.org/mediaqueries/ */ + +#include <string.h> + +#include <libcss/fpmath.h> + +#include "stylesheet.h" +#include "bytecode/bytecode.h" +#include "parse/mq.h" +#include "parse/properties/utils.h" +#include "utils/utils.h" + +static void css__mq_value_destroy(css_mq_value *value) +{ + assert(value != NULL); + + if (value->type == CSS_MQ_VALUE_TYPE_IDENT) { + lwc_string_unref(value->data.ident); + } +} + +static void css__mq_feature_destroy(css_mq_feature *feature) +{ + if (feature != NULL) { + lwc_string_unref(feature->name); + css__mq_value_destroy(&feature->value); + css__mq_value_destroy(&feature->value2); + free(feature); + } +} + +static void css__mq_cond_or_feature_destroy( + css_mq_cond_or_feature *cond_or_feature); + +static void css__mq_cond_parts_destroy(css_mq_cond_parts *cond_parts) +{ + if (cond_parts != NULL) { + for (uint32_t i = 0; i < cond_parts->nparts; i++) { + css__mq_cond_or_feature_destroy(cond_parts->parts[i]); + } + free(cond_parts->parts); + free(cond_parts); + } +} + +static void css__mq_cond_destroy(css_mq_cond *cond) +{ + if (cond != NULL) { + css__mq_cond_parts_destroy(cond->parts); + free(cond); + } +} + +static void css__mq_cond_or_feature_destroy( + css_mq_cond_or_feature *cond_or_feature) +{ + if (cond_or_feature != NULL) { + switch (cond_or_feature->type) { + case CSS_MQ_FEATURE: + css__mq_feature_destroy(cond_or_feature->data.feat); + break; + case CSS_MQ_COND: + css__mq_cond_destroy(cond_or_feature->data.cond); + break; + } + free(cond_or_feature); + } +} + +void css__mq_query_destroy(css_mq_query *media) +{ + while (media != NULL) { + css_mq_query *next = media->next; + + css__mq_cond_destroy(media->cond); + free(media); + + media = next; + } +} + +static css_error mq_parse_condition(lwc_string **strings, + const parserutils_vector *vector, int *ctx, + bool permit_or, css_mq_cond **cond); + +static css_error mq_parse_ratio( + const parserutils_vector *vector, int *ctx, + const css_token *numerator, css_fixed *ratio) +{ + const css_token *token; + css_fixed num, den; + size_t num_len, den_len; + + /* NUMBER ws* '/' ws* NUMBER */ + + /* numerator, ws* already consumed */ + + token = parserutils_vector_iterate(vector, ctx); + if (token == NULL || tokenIsChar(token, '/') == false) { + return CSS_INVALID; + } + + consumeWhitespace(vector, ctx); + + token = parserutils_vector_iterate(vector, ctx); + if (token == NULL || token->type != CSS_TOKEN_NUMBER) { + return CSS_INVALID; + } + + num = css__number_from_lwc_string(numerator->idata, true, &num_len); + den = css__number_from_lwc_string(token->idata, true, &den_len); + + *ratio = css_divide_fixed(num, den); + + return CSS_OK; +} + +static css_error mq_create_feature( + lwc_string *name, + css_mq_feature **feature) +{ + css_mq_feature *f; + + f = malloc(sizeof(*f)); + if (f == NULL) { + return CSS_NOMEM; + } + + memset(f, 0, sizeof(*f)); + + f->name = lwc_string_ref(name); + + *feature = f; + + return CSS_OK; +} + +static css_error mq_populate_value(css_mq_value *value, + const css_token *token) +{ + if (token->type == CSS_TOKEN_NUMBER) { + size_t num_len; + value->type = CSS_MQ_VALUE_TYPE_NUM; + value->data.num_or_ratio = css__number_from_lwc_string( + token->idata, false, &num_len); + } else if (token->type == CSS_TOKEN_DIMENSION) { + size_t len = lwc_string_length(token->idata); + const char *data = lwc_string_data(token->idata); + uint32_t unit = UNIT_PX; + size_t consumed; + css_error error; + + value->type = CSS_MQ_VALUE_TYPE_DIM; + value->data.dim.len = css__number_from_lwc_string( + token->idata, false, &consumed); + error = css__parse_unit_keyword(data + consumed, len - consumed, + &unit); + if (error != CSS_OK) { + return error; + } + value->data.dim.unit = unit; + } else if (token->type == CSS_TOKEN_IDENT) { + value->type = CSS_MQ_VALUE_TYPE_IDENT; + value->data.ident = lwc_string_ref(token->idata); + } + + return CSS_OK; +} + +static css_error mq_parse_op(const css_token *token, + css_mq_feature_op *op) +{ + size_t len; + const char *data; + + if (token == NULL || token->type != CSS_TOKEN_CHAR) + return CSS_INVALID; + + len = lwc_string_length(token->idata); + data = lwc_string_data(token->idata); + + if (len == 2) { + if (strncasecmp(data, "<=", 2) == 0) + *op = CSS_MQ_FEATURE_OP_LTE; + else if (strncasecmp(data, ">=", 2) == 0) + *op = CSS_MQ_FEATURE_OP_GTE; + else + return CSS_INVALID; + } else if (len == 1) { + if (*data == '<') + *op = CSS_MQ_FEATURE_OP_LT; + else if (*data == '=') + *op = CSS_MQ_FEATURE_OP_EQ; + else if (*data == '>') + *op = CSS_MQ_FEATURE_OP_GT; + else + return CSS_INVALID; + } else { + return CSS_INVALID; + } + + return CSS_OK; +} + +static css_error mq_parse_range(lwc_string **strings, + const parserutils_vector *vector, int *ctx, + const css_token *name_or_value, + css_mq_feature **feature) +{ + const css_token *token, *value_or_name, *name = NULL, *value2 = NULL; + css_mq_feature *result; + css_mq_feature_op op, op2; + css_fixed ratio, ratio2; + bool name_first = false, value_is_ratio = false, value2_is_ratio = false, match; + css_error error; + + /* <mf-range> = <mf-name> [ '<' | '>' ]? '='? <mf-value> + * | <mf-value> [ '<' | '>' ]? '='? <mf-name> + * | <mf-value> '<' '='? <mf-name> '<' '='? <mf-value> + * | <mf-value> '>' '='? <mf-name> '>' '='? <mf-value> + */ + + if (name_or_value == NULL || (name_or_value->type != CSS_TOKEN_NUMBER && + name_or_value->type != CSS_TOKEN_DIMENSION && + name_or_value->type != CSS_TOKEN_IDENT)) { + return CSS_INVALID; + } + + consumeWhitespace(vector, ctx); + + /* Name-or-value */ + if (name_or_value->type == CSS_TOKEN_NUMBER && + tokenIsChar(parserutils_vector_peek(vector, *ctx), '/')) { + /* ratio */ + error = mq_parse_ratio(vector, ctx, name_or_value, &ratio); + if (error != CSS_OK) { + return error; + } + + consumeWhitespace(vector, ctx); + + value_is_ratio = true; + } else if (name_or_value->type == CSS_TOKEN_IDENT && + lwc_string_caseless_isequal(name_or_value->idata, + strings[INFINITE], &match) == lwc_error_ok && + match == false) { + /* The only ident permitted for mf-value is 'infinite', thus must have name */ + name = name_or_value; + name_first = true; + } + + /* Op */ + token = parserutils_vector_iterate(vector, ctx); + error = mq_parse_op(token, &op); + if (error != CSS_OK) { + return error; + } + + consumeWhitespace(vector, ctx); + + /* Value-or-name */ + value_or_name = parserutils_vector_iterate(vector, ctx); + if (value_or_name == NULL || (value_or_name->type != CSS_TOKEN_NUMBER && + value_or_name->type != CSS_TOKEN_DIMENSION && + value_or_name->type != CSS_TOKEN_IDENT)) { + return CSS_INVALID; + } + + if (name == NULL) { + if (value_or_name->type != CSS_TOKEN_IDENT) { + return CSS_INVALID; + } else { + name = value_or_name; + } + } + + consumeWhitespace(vector, ctx); + + if (value_or_name->type == CSS_TOKEN_NUMBER && + tokenIsChar(parserutils_vector_peek(vector, *ctx), '/')) { + /* ratio */ + error = mq_parse_ratio(vector, ctx, token, &ratio); + if (error != CSS_OK) { + return error; + } + + consumeWhitespace(vector, ctx); + + value_is_ratio = true; + } + + token = parserutils_vector_peek(vector, *ctx); + if (name_first == false && token != NULL && tokenIsChar(token, ')') == false) { + /* Op2 */ + token = parserutils_vector_iterate(vector, ctx); + error = mq_parse_op(token, &op2); + if (error != CSS_OK) { + return error; + } + + consumeWhitespace(vector, ctx); + + /* Validate operators: must both be LT(E) or GT(E) */ + if (op == CSS_MQ_FEATURE_OP_LT || op == CSS_MQ_FEATURE_OP_LTE) { + if (op2 != CSS_MQ_FEATURE_OP_LT && op2 != CSS_MQ_FEATURE_OP_LTE) { + return CSS_INVALID; + } + } else if (op == CSS_MQ_FEATURE_OP_GT || op == CSS_MQ_FEATURE_OP_GTE) { + if (op2 != CSS_MQ_FEATURE_OP_GT && op2 != CSS_MQ_FEATURE_OP_GTE) { + return CSS_INVALID; + } + } else { + return CSS_INVALID; + } + + /* Value2 */ + value2 = parserutils_vector_iterate(vector, ctx); + if (value2 == NULL || (value2->type != CSS_TOKEN_NUMBER && + value2->type != CSS_TOKEN_DIMENSION && + value2->type != CSS_TOKEN_IDENT)) { + return CSS_INVALID; + } + + consumeWhitespace(vector, ctx); + + if (value_or_name->type == CSS_TOKEN_NUMBER && + tokenIsChar(parserutils_vector_peek(vector, *ctx), '/')) { + /* ratio */ + error = mq_parse_ratio(vector, ctx, token, &ratio2); + if (error != CSS_OK) { + return error; + } + + consumeWhitespace(vector, ctx); + + value2_is_ratio = true; + } + } + + error = mq_create_feature(name->idata, &result); + if (error != CSS_OK) { + return error; + } + if (name_first) { + /* Invert operator */ + if (op == CSS_MQ_FEATURE_OP_LT) { + op = CSS_MQ_FEATURE_OP_GTE; + } else if (op == CSS_MQ_FEATURE_OP_LTE) { + op = CSS_MQ_FEATURE_OP_GT; + } else if (op == CSS_MQ_FEATURE_OP_GT) { + op = CSS_MQ_FEATURE_OP_LTE; + } else if (op == CSS_MQ_FEATURE_OP_GTE) { + op = CSS_MQ_FEATURE_OP_LT; + } + } + result->op = op; + if (value_is_ratio) { + result->value.type = CSS_MQ_VALUE_TYPE_RATIO; + result->value.data.num_or_ratio = ratio; + } else { + /* num/dim/ident */ + error = mq_populate_value(&result->value, token); + if (error != CSS_OK) { + free(result); + return error; + } + } + if (value2 != NULL) { + result->op2 = op2; + if (value2_is_ratio) { + result->value2.type = CSS_MQ_VALUE_TYPE_RATIO; + result->value2.data.num_or_ratio = ratio; + } else { + /* num/dim/ident */ + error = mq_populate_value(&result->value2, token); + if (error != CSS_OK) { + css__mq_feature_destroy(result); + return error; + } + } + } + + *feature = result; + + return CSS_OK; +} + +static css_error mq_parse_media_feature(lwc_string **strings, + const parserutils_vector *vector, int *ctx, + css_mq_feature **feature) +{ + const css_token *name_or_value, *token; + css_mq_feature *result; + css_error error; + + /* <media-feature> = ( [ <mf-plain> | <mf-boolean> | <mf-range> ] ) + * <mf-plain> = <mf-name> : <mf-value> + * <mf-boolean> = <mf-name> + * <mf-name> = <ident> + * <mf-value> = <number> | <dimension> | <ident> | <ratio> + */ + + /* ( already consumed */ + + consumeWhitespace(vector, ctx); + + name_or_value = parserutils_vector_iterate(vector, ctx); + if (name_or_value == NULL) + return CSS_INVALID; + + if (name_or_value->type == CSS_TOKEN_IDENT) { + consumeWhitespace(vector, ctx); + + token = parserutils_vector_peek(vector, *ctx); + if (tokenIsChar(token, ')')) { + /* mf-boolean */ + error = mq_create_feature(name_or_value->idata, &result); + if (error != CSS_OK) { + return error; + } + + result->op = CSS_MQ_FEATURE_OP_BOOL; + } else if (tokenIsChar(token, ':')) { + /* mf-plain */ + parserutils_vector_iterate(vector, ctx); + + consumeWhitespace(vector, ctx); + + token = parserutils_vector_iterate(vector, ctx); + if (token == NULL || (token->type != CSS_TOKEN_NUMBER && + token->type != CSS_TOKEN_DIMENSION && + token->type != CSS_TOKEN_IDENT)) { + return CSS_INVALID; + } + + consumeWhitespace(vector, ctx); + + error = mq_create_feature(name_or_value->idata, &result); + if (error != CSS_OK) { + return error; + } + result->op = CSS_MQ_FEATURE_OP_EQ; + + if (token->type == CSS_TOKEN_NUMBER && + tokenIsChar(parserutils_vector_peek(vector, *ctx), '/')) { + /* ratio */ + css_fixed ratio; + + error = mq_parse_ratio(vector, ctx, token, &ratio); + if (error != CSS_OK) { + free(result); + return error; + } + + result->value.type = CSS_MQ_VALUE_TYPE_RATIO; + result->value.data.num_or_ratio = ratio; + } else { + /* num/dim/ident */ + error = mq_populate_value(&result->value, token); + if (error != CSS_OK) { + free(result); + return error; + } + } + + consumeWhitespace(vector, ctx); + } else { + /* mf-range */ + error = mq_parse_range(strings, vector, ctx, + name_or_value, &result); + if (error != CSS_OK) { + return error; + } + + consumeWhitespace(vector, ctx); + } + } else { + /* mf-range */ + error = mq_parse_range(strings, vector, ctx, + name_or_value, &result); + if (error != CSS_OK) { + return error; + } + + consumeWhitespace(vector, ctx); + } + + token = parserutils_vector_iterate(vector, ctx); + if (tokenIsChar(token, ')') == false) { + css__mq_feature_destroy(result); + return CSS_INVALID; + } + + *feature = result; + + return CSS_OK; +} + +/* + * Consume any value + * + * CSS Syntax Module Level 3: 8.2 + */ +static css_error mq_parse_consume_any_value(lwc_string **strings, + const parserutils_vector *vector, int *ctx, + bool until, const char until_char) +{ + const css_token *token; + css_error error; + + while (true) { + consumeWhitespace(vector, ctx); + + token = parserutils_vector_iterate(vector, ctx); + if (token == NULL) { + return CSS_INVALID; + } + + switch (token->type) { + case CSS_TOKEN_INVALID_STRING: + return CSS_INVALID; + + case CSS_TOKEN_CHAR: + if (until && tokenIsChar(token, until_char)) { + /* Found matching close bracket */ + return CSS_OK; + + } else if (tokenIsChar(token, ')') || + tokenIsChar(token, ']') || + tokenIsChar(token, '}')) { + /* Non-matching close bracket */ + return CSS_INVALID; + } + if (tokenIsChar(token, '(')) { + /* Need to consume until matching bracket. */ + error = mq_parse_consume_any_value(strings, + vector, ctx, true, ')'); + if (error != CSS_OK) { + return error; + } + } else if (tokenIsChar(token, '[')) { + /* Need to consume until matching bracket. */ + error = mq_parse_consume_any_value(strings, + vector, ctx, true, ']'); + if (error != CSS_OK) { + return error; + } + } else if (tokenIsChar(token, '{')) { + /* Need to consume until matching bracket. */ + error = mq_parse_consume_any_value(strings, + vector, ctx, true, '}'); + if (error != CSS_OK) { + return error; + } + } + break; + + default: + break; + } + } + + return CSS_OK; +} + +static css_error mq_parse_general_enclosed(lwc_string **strings, + const parserutils_vector *vector, int *ctx) +{ + const css_token *token; + css_error error; + + /* <general-enclosed> = [ <function-token> <any-value> ) ] + * | ( <ident> <any-value> ) + */ + + token = parserutils_vector_iterate(vector, ctx); + if (token == NULL) { + return CSS_INVALID; + } + + switch (token->type) { + case CSS_TOKEN_FUNCTION: + error = mq_parse_consume_any_value(strings, vector, ctx, + true, ')'); + if (error != CSS_OK) { + return error; + } + + token = parserutils_vector_peek(vector, *ctx); + if (!tokenIsChar(token, ')')) { + return CSS_INVALID; + } + break; + + case CSS_TOKEN_IDENT: + error = mq_parse_consume_any_value(strings, vector, ctx, + false, '\0'); + if (error != CSS_OK) { + return error; + } + break; + + default: + return CSS_INVALID; + } + + return CSS_OK; +} + +static css_error mq_parse_media_in_parens(lwc_string **strings, + const parserutils_vector *vector, int *ctx, + css_mq_cond_or_feature **cond_or_feature) +{ + const css_token *token; + bool match; + int old_ctx; + css_mq_cond_or_feature *result = NULL; + css_error error = CSS_OK; + + /* <media-in-parens> = ( <media-condition> ) | <media-feature> | <general-enclosed> + */ + + //LPAREN -> condition-or-feature + // "not" or LPAREN -> condition + // IDENT | NUMBER | DIMENSION | RATIO -> feature + + token = parserutils_vector_iterate(vector, ctx); + if (token == NULL || tokenIsChar(token, '(') == false) { + return CSS_INVALID; + } + + consumeWhitespace(vector, ctx); + + token = parserutils_vector_peek(vector, *ctx); + if (token == NULL) { + return CSS_INVALID; + } + + old_ctx = *ctx; + + if (tokenIsChar(token, '(') || (token->type == CSS_TOKEN_IDENT && + lwc_string_caseless_isequal(token->idata, + strings[NOT], &match) == lwc_error_ok && + match)) { + css_mq_cond *cond; + error = mq_parse_condition(strings, vector, ctx, true, &cond); + if (error == CSS_OK) { + token = parserutils_vector_iterate(vector, ctx); + if (tokenIsChar(token, ')') == false) { + return CSS_INVALID; + } + + result = malloc(sizeof(*result)); + if (result == NULL) { + css__mq_cond_destroy(cond); + return CSS_NOMEM; + } + memset(result, 0, sizeof(*result)); + result->type = CSS_MQ_COND; + result->data.cond = cond; + *cond_or_feature = result; + return CSS_OK; + } + } else if (token->type == CSS_TOKEN_IDENT || + token->type == CSS_TOKEN_NUMBER || + token->type == CSS_TOKEN_DIMENSION) { + css_mq_feature *feature; + error = mq_parse_media_feature(strings, vector, ctx, &feature); + if (error == CSS_OK) { + result = malloc(sizeof(*result)); + if (result == NULL) { + css__mq_feature_destroy(feature); + return CSS_NOMEM; + } + memset(result, 0, sizeof(*result)); + result->type = CSS_MQ_FEATURE; + result->data.feat = feature; + *cond_or_feature = result; + return CSS_OK; + } + } + + *ctx = old_ctx; + error = mq_parse_general_enclosed(strings, vector, ctx); + + return error; +} + +static css_error mq_parse_condition(lwc_string **strings, + const parserutils_vector *vector, int *ctx, + bool permit_or, css_mq_cond **cond) +{ + const css_token *token; + bool match = false; + int op = 0; /* Will be AND | OR once we've had one */ + css_mq_cond_or_feature *cond_or_feature, **parts; + css_mq_cond *result; + css_error error; + + /* <media-condition> = <media-not> | <media-in-parens> [ <media-and>* | <media-or>* ] + * <media-condition-without-or> = <media-not> | <media-in-parens> <media-and>* + * <media-not> = not <media-in-parens> + * <media-and> = and <media-in-parens> + * <media-or> = or <media-in-parens> + */ + + token = parserutils_vector_peek(vector, *ctx); + if (token == NULL || + (tokenIsChar(token, '(') == false && + token->type != CSS_TOKEN_IDENT && + lwc_string_caseless_isequal(token->idata, + strings[NOT], &match) != lwc_error_ok && + match == false)) { + return CSS_INVALID; + } + + result = malloc(sizeof(*result)); + if (result == NULL) { + return CSS_NOMEM; + } + memset(result, 0, sizeof(*result)); + result->parts = malloc(sizeof(*result->parts)); + if (result->parts == NULL) { + free(result); + return CSS_NOMEM; + } + memset(result->parts, 0, sizeof(*result->parts)); + + if (tokenIsChar(token, '(') == false) { + /* Must be "not" */ + parserutils_vector_iterate(vector, ctx); + consumeWhitespace(vector, ctx); + + error = mq_parse_media_in_parens(strings, + vector, ctx, &cond_or_feature); + if (error != CSS_OK) { + css__mq_cond_destroy(result); + return CSS_INVALID; + } + + result->negate = 1; + result->parts->nparts = 1; + result->parts->parts = malloc(sizeof(*result->parts->parts)); + if (result->parts->parts == NULL) { + css__mq_cond_or_feature_destroy(cond_or_feature); + css__mq_cond_destroy(result); + return CSS_NOMEM; + } + result->parts->parts[0] = cond_or_feature; + + *cond = result; + + return CSS_OK; + } + + /* FOLLOW(media-condition) := RPAREN | COMMA | EOF */ + while (token != NULL && tokenIsChar(token, ')') == false && + tokenIsChar(token, ',') == false) { + error = mq_parse_media_in_parens(strings, vector, ctx, + &cond_or_feature); + if (error != CSS_OK) { + css__mq_cond_destroy(result); + return CSS_INVALID; + } + + parts = realloc(result->parts->parts, + (result->parts->nparts+1)*sizeof(*result->parts->parts)); + if (parts == NULL) { + css__mq_cond_or_feature_destroy(cond_or_feature); + css__mq_cond_destroy(result); + return CSS_NOMEM; + } + parts[result->parts->nparts] = cond_or_feature; + result->parts->parts = parts; + result->parts->nparts++; + + consumeWhitespace(vector, ctx); + + token = parserutils_vector_peek(vector, *ctx); + if (token != NULL && tokenIsChar(token, ')') == false && + tokenIsChar(token, ',') == false) { + if (token->type != CSS_TOKEN_IDENT) { + css__mq_cond_destroy(result); + return CSS_INVALID; + } else if (lwc_string_caseless_isequal(token->idata, + strings[AND], &match) == lwc_error_ok && + match) { + if (op != 0 && op != AND) { + css__mq_cond_destroy(result); + return CSS_INVALID; + } + op = AND; + } else if (lwc_string_caseless_isequal(token->idata, + strings[OR], &match) == lwc_error_ok && + match) { + if (permit_or == false || (op != 0 && op != OR)) { + css__mq_cond_destroy(result); + return CSS_INVALID; + } + op = OR; + } else { + /* Neither AND nor OR */ + css__mq_cond_destroy(result); + return CSS_INVALID; + } + + parserutils_vector_iterate(vector, ctx); + consumeWhitespace(vector, ctx); + } + } + + if (op == OR) { + result->op = 1; + } + + *cond = result; + + return CSS_OK; +} + +/** + * Parse a media query type. + */ +static uint64_t mq_parse_type(lwc_string **strings, lwc_string *type) +{ + bool match; + + if (type == NULL) { + return CSS_MEDIA_ALL; + } else if (lwc_string_caseless_isequal( + type, strings[AURAL], + &match) == lwc_error_ok && match) { + return CSS_MEDIA_AURAL; + } else if (lwc_string_caseless_isequal( + type, strings[BRAILLE], + &match) == lwc_error_ok && match) { + return CSS_MEDIA_BRAILLE; + } else if (lwc_string_caseless_isequal( + type, strings[EMBOSSED], + &match) == lwc_error_ok && match) { + return CSS_MEDIA_EMBOSSED; + } else if (lwc_string_caseless_isequal( + type, strings[HANDHELD], + &match) == lwc_error_ok && match) { + return CSS_MEDIA_HANDHELD; + } else if (lwc_string_caseless_isequal( + type, strings[PRINT], + &match) == lwc_error_ok && match) { + return CSS_MEDIA_PRINT; + } else if (lwc_string_caseless_isequal( + type, strings[PROJECTION], + &match) == lwc_error_ok && match) { + return CSS_MEDIA_PROJECTION; + } else if (lwc_string_caseless_isequal( + type, strings[SCREEN], + &match) == lwc_error_ok && match) { + return CSS_MEDIA_SCREEN; + } else if (lwc_string_caseless_isequal( + type, strings[SPEECH], + &match) == lwc_error_ok && match) { + return CSS_MEDIA_SPEECH; + } else if (lwc_string_caseless_isequal( + type, strings[TTY], + &match) == lwc_error_ok && match) { + return CSS_MEDIA_TTY; + } else if (lwc_string_caseless_isequal( + type, strings[TV], + &match) == lwc_error_ok && match) { + return CSS_MEDIA_TV; + } else if (lwc_string_caseless_isequal( + type, strings[ALL], + &match) == lwc_error_ok && match) { + return CSS_MEDIA_ALL; + } + + return 0; +} + +static css_error mq_parse_media_query(lwc_string **strings, + const parserutils_vector *vector, int *ctx, + css_mq_query **query) +{ + const css_token *token; + bool match, is_condition = false; + css_mq_query *result; + css_error error; + + /* <media-query> = <media-condition> + * | [ not | only ]? <media-type> [ and <media-condition-without-or> ]? + * <media-type> = <ident> (except "not", "and", "or", "only") + */ + + // LPAREN -> media-condition + // not LPAREN -> media-condition + + consumeWhitespace(vector, ctx); + + token = parserutils_vector_peek(vector, *ctx); + if (tokenIsChar(token, '(')) { + is_condition = true; + } else if (token->type == CSS_TOKEN_IDENT && + lwc_string_caseless_isequal(token->idata, + strings[NOT], &match) == lwc_error_ok && + match) { + int old_ctx = *ctx; + + parserutils_vector_iterate(vector, ctx); + consumeWhitespace(vector, ctx); + + token = parserutils_vector_peek(vector, *ctx); + if (tokenIsChar(token, '(')) { + is_condition = true; + } + + *ctx = old_ctx; + } + + result = malloc(sizeof(*result)); + if (result == NULL) { + return CSS_NOMEM; + } + memset(result, 0, sizeof(*result)); + + if (is_condition) { + /* media-condition */ + error = mq_parse_condition(strings, vector, ctx, true, + &result->cond); + if (error != CSS_OK) { + free(result); + return error; + } + + *query = result; + return CSS_OK; + } + + token = parserutils_vector_iterate(vector, ctx); + if (token == NULL || token->type != CSS_TOKEN_IDENT) { + free(result); + return CSS_INVALID; + } + + if (lwc_string_caseless_isequal(token->idata, + strings[NOT], &match) == lwc_error_ok && match) { + result->negate_type = 1; + consumeWhitespace(vector, ctx); + token = parserutils_vector_iterate(vector, ctx); + } else if (lwc_string_caseless_isequal(token->idata, + strings[ONLY], &match) == lwc_error_ok && match) { + consumeWhitespace(vector, ctx); + token = parserutils_vector_iterate(vector, ctx); + } + + if (token == NULL || token->type != CSS_TOKEN_IDENT) { + free(result); + return CSS_INVALID; + } + + result->type = mq_parse_type(strings, token->idata); + + consumeWhitespace(vector, ctx); + + token = parserutils_vector_iterate(vector, ctx); + if (token != NULL) { + if (token->type != CSS_TOKEN_IDENT || + lwc_string_caseless_isequal(token->idata, + strings[AND], &match) != lwc_error_ok || + match == false) { + free(result); + return CSS_INVALID; + } + + consumeWhitespace(vector, ctx); + + error = mq_parse_condition(strings, vector, ctx, false, + &result->cond); + if (error != CSS_OK) { + free(result); + return error; + } + } + + *query = result; + return CSS_OK; +} + +css_error css__mq_parse_media_list(lwc_string **strings, + const parserutils_vector *vector, int *ctx, + css_mq_query **media) +{ + css_mq_query *result = NULL, *last = NULL; + const css_token *token; + css_error error; + + /* <media-query-list> = <media-query> [ COMMA <media-query> ]* */ + + /* if {[(, push }]) to stack + * if func, push ) to stack + * on error, scan forward until stack is empty (or EOF), popping matching tokens off stack + * if stack is empty, the next input token must be comma or EOF + * if comma, consume, and start again from the next input token + */ + + token = parserutils_vector_peek(vector, *ctx); + while (token != NULL) { + css_mq_query *query; + + error = mq_parse_media_query(strings, vector, ctx, &query); + if (error != CSS_OK) { + /* TODO: error recovery (see above) */ + css__mq_query_destroy(result); + return error; + } else { + if (result == NULL) { + result = last = query; + } else { + assert(last != NULL); + last->next = query; + last = query; + } + } + + consumeWhitespace(vector, ctx); + + token = parserutils_vector_iterate(vector, ctx); + if (token != NULL && tokenIsChar(token, ',') == false) { + /* Give up */ + break; + } + } + + *media = result; + + return CSS_OK; +} + +typedef struct css_mq_parse_ctx { + lwc_string **strings; + css_mq_query *media; +} css_mq_parse_ctx; + +static css_error css_parse_media_query_handle_event( + css_parser_event type, + const parserutils_vector *tokens, + void *pw) +{ + int idx = 0; + css_error err; + css_mq_query *media; + const css_token *tok; + css_mq_parse_ctx *ctx = pw; + lwc_string **strings = ctx->strings; + + UNUSED(type); + + /* Skip @media */ + tok = parserutils_vector_iterate(tokens, &idx); + assert(tok->type == CSS_TOKEN_ATKEYWORD); + UNUSED(tok); + + /* Skip whitespace */ + tok = parserutils_vector_iterate(tokens, &idx); + assert(tok->type == CSS_TOKEN_S); + UNUSED(tok); + + err = css__mq_parse_media_list(strings, tokens, &idx, &media); + if (err != CSS_OK) { + return CSS_OK; + } + + ctx->media = media; + return CSS_OK; +} + +css_error css_parse_media_query(lwc_string **strings, + const uint8_t *mq, size_t len, + css_mq_query **media_out) +{ + css_error err; + css_parser *parser; + css_mq_parse_ctx ctx = { + .strings = strings, + }; + css_parser_optparams params_quirks = { + .quirks = false, + }; + css_parser_optparams params_handler = { + .event_handler = { + .handler = css_parse_media_query_handle_event, + .pw = &ctx, + }, + }; + + if (mq == NULL || len == 0) { + return CSS_BADPARM; + } + + err = css__parser_create_for_media_query(NULL, + CSS_CHARSET_DEFAULT, &parser); + if (err != CSS_OK) { + return err; + } + + err = css__parser_setopt(parser, CSS_PARSER_QUIRKS, + ¶ms_quirks); + if (err != CSS_OK) { + css__parser_destroy(parser); + return err; + } + + err = css__parser_setopt(parser, CSS_PARSER_EVENT_HANDLER, + ¶ms_handler); + if (err != CSS_OK) { + css__parser_destroy(parser); + return err; + } + + err = css__parser_parse_chunk(parser, + (const uint8_t *)"@media ", + strlen("@media ")); + if (err != CSS_OK && err != CSS_NEEDDATA) { + css__parser_destroy(parser); + return err; + } + + err = css__parser_parse_chunk(parser, mq, len); + if (err != CSS_OK && err != CSS_NEEDDATA) { + css__parser_destroy(parser); + return err; + } + + err = css__parser_completed(parser); + if (err != CSS_OK) { + css__parser_destroy(parser); + return err; + } + + css__parser_destroy(parser); + + *media_out = ctx.media; + return CSS_OK; +} + diff --git a/src/parse/mq.h b/src/parse/mq.h new file mode 100644 index 0000000..0e2f845 --- /dev/null +++ b/src/parse/mq.h @@ -0,0 +1,100 @@ +/* + * This file is part of LibCSS. + * Licensed under the MIT License, + * http://www.opensource.org/licenses/mit-license.php + * Copyright 2016 John-Mark Bell <jmb@netsurf-browser.org> + */ + +#ifndef css_parse_mq_h_ +#define css_parse_mq_h_ + +#include <parserutils/utils/vector.h> +#include "parse/language.h" + +typedef struct { + enum { + CSS_MQ_VALUE_TYPE_NUM, + CSS_MQ_VALUE_TYPE_DIM, + CSS_MQ_VALUE_TYPE_IDENT, + CSS_MQ_VALUE_TYPE_RATIO + } type; + union { + css_fixed num_or_ratio; /* Where ratio is the result of a/b */ + struct { + css_fixed len; + uint32_t unit; + } dim; + lwc_string *ident; + } data; +} css_mq_value; + +/* + * "name : value" is encoded as "name = value" + * "name" is encoded by setting the operator to "bool" + * "value op name" is encoded verbatim (with op2 set to "unused") + * "name op value" inverts the operator to encode (i.e < becomes >=) (and sets op2 to "unused") + * "value op name op value" is encoded using op2 and value2 + */ +typedef enum { + CSS_MQ_FEATURE_OP_BOOL, /* op only */ + CSS_MQ_FEATURE_OP_UNUSED = CSS_MQ_FEATURE_OP_BOOL, /* op2 only */ + + CSS_MQ_FEATURE_OP_LT, + CSS_MQ_FEATURE_OP_LTE, + CSS_MQ_FEATURE_OP_EQ, /* op only */ + CSS_MQ_FEATURE_OP_GTE, + CSS_MQ_FEATURE_OP_GT +} css_mq_feature_op; + +typedef struct { + lwc_string *name; + css_mq_feature_op op; + css_mq_feature_op op2; + css_mq_value value; + css_mq_value value2; +} css_mq_feature; + +typedef struct css_mq_cond_or_feature css_mq_cond_or_feature; + +typedef struct { + uint32_t nparts; + css_mq_cond_or_feature **parts; +} css_mq_cond_parts; + +typedef struct { + uint32_t negate : 1, /* set if "not" */ + op : 1; /* clear if "and", set if "or" */ + css_mq_cond_parts *parts; +} css_mq_cond; + +struct css_mq_cond_or_feature { + enum { + CSS_MQ_FEATURE, + CSS_MQ_COND + } type; + union { + css_mq_cond *cond; + css_mq_feature *feat; + } data; +}; + +typedef struct css_mq_query { + struct css_mq_query *next; + + uint32_t negate_type : 1; /* set if "not type" */ + uint64_t type; /* or NULL */ + + css_mq_cond *cond; +} css_mq_query; + +css_error css_parse_media_query(lwc_string **strings, + const uint8_t *mq, size_t len, + css_mq_query **media_out); + +css_error css__mq_parse_media_list(lwc_string **strings, + const parserutils_vector *vector, int *ctx, + css_mq_query **media); + +void css__mq_query_destroy(css_mq_query *media); + +#endif diff --git a/src/parse/parse.c b/src/parse/parse.c index 4cc1c98..cbd8b56 100644 --- a/src/parse/parse.c +++ b/src/parse/parse.c @@ -67,7 +67,8 @@ enum { sMalformedAtRule = 22, sInlineStyle = 23, sISBody0 = 24, - sISBody = 25 + sISBody = 25, + sMediaQuery = 26, }; /** @@ -99,8 +100,6 @@ struct css_parser bool parseError; /**< A parse error has occurred */ parserutils_stack *open_items; /**< Stack of open brackets */ - uint8_t match_char; /**< Close bracket type for parseAny */ - bool last_was_ws; /**< Last token was whitespace */ css_parser_event_handler event; /**< Client's event handler */ @@ -146,8 +145,9 @@ static css_error parseMalformedAtRule(css_parser *parser); static css_error parseInlineStyle(css_parser *parser); static css_error parseISBody0(css_parser *parser); static css_error parseISBody(css_parser *parser); +static css_error parseMediaQuery(css_parser *parser); -static void unref_interned_strings_in_tokens(css_parser *parser); +static void discard_tokens(css_parser *parser); /** * Dispatch table for parsing, indexed by major state number @@ -178,7 +178,8 @@ static css_error (*parseFuncs[])(css_parser *parser) = { parseMalformedAtRule, parseInlineStyle, parseISBody0, - parseISBody + parseISBody, + parseMediaQuery, }; /** @@ -220,6 +221,25 @@ css_error css__parser_create_for_inline_style(const char *charset, } /** + * Create a CSS parser for a media query + * + * \param charset Charset of data, if known, or NULL + * \param cs_source Source of charset information, or CSS_CHARSET_DEFAULT + * \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_for_media_query(const char *charset, + css_charset_source cs_source, css_parser **parser) +{ + parser_state initial = { sMediaQuery, 0 }; + + return css__parser_create_internal(charset, cs_source, + initial, parser); +} + +/** * Destroy a CSS parser * * \param parser The parser instance to destroy @@ -459,7 +479,6 @@ css_error css__parser_create_internal(const char *charset, p->quirks = false; p->pushback = NULL; p->parseError = false; - p->match_char = 0; p->event = NULL; p->last_was_ws = false; p->event_pw = NULL; @@ -746,8 +765,7 @@ css_error parseStart(css_parser *parser) parser->event_pw); } - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); return done(parser); } @@ -778,8 +796,7 @@ css_error parseStylesheet(css_parser *parser) if (error != CSS_OK) return error; - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); return done(parser); case CSS_TOKEN_CDO: @@ -849,8 +866,7 @@ css_error parseRuleset(css_parser *parser) switch (state->substate) { case Initial: - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); error = getToken(parser, &token); if (error != CSS_OK) @@ -890,17 +906,6 @@ css_error parseRuleset(css_parser *parser) } break; case Brace: -#if !defined(NDEBUG) && defined(DEBUG_EVENTS) - printf("Begin ruleset\n"); - parserutils_vector_dump(parser->tokens, __func__, tprinter); -#endif - if (parser->parseError == false && parser->event != NULL) { - if (parser->event(CSS_PARSER_START_RULESET, - parser->tokens, parser->event_pw) == - CSS_INVALID) - parser->parseError = true; - } - if (parser->parseError == true) { parser_state to = { sMalformedSelector, Initial }; @@ -911,22 +916,40 @@ css_error parseRuleset(css_parser *parser) if (error != CSS_OK) return error; - if (token->type == CSS_TOKEN_EOF) { + if (token->type != CSS_TOKEN_CHAR || + lwc_string_length(token->idata) != 1 || + lwc_string_data(token->idata)[0] != '{') { + /* FOLLOW(selector) contains only '{', but we may + * also have seen EOF, which is a parse error. */ error = pushBack(parser, token); if (error != CSS_OK) return error; + parser->parseError = true; return done(parser); } - if (token->type != CSS_TOKEN_CHAR || - lwc_string_length(token->idata) != 1 || - lwc_string_data(token->idata)[0] != '{') { - /* This should never happen, as FOLLOW(selector) - * contains only '{' */ - assert(0 && "Expected {"); + /* We don't want to emit the brace, so push it back */ + error = pushBack(parser, token); + if (error != CSS_OK) + return error; + +#if !defined(NDEBUG) && defined(DEBUG_EVENTS) + printf("Begin ruleset\n"); + parserutils_vector_dump(parser->tokens, __func__, tprinter); +#endif + if (parser->parseError == false && parser->event != NULL) { + if (parser->event(CSS_PARSER_START_RULESET, + parser->tokens, parser->event_pw) == + CSS_INVALID) + parser->parseError = true; } + /* Re-read the brace */ + error = getToken(parser, &token); + if (error != CSS_OK) + return error; + state->substate = WS; /* Fall through */ case WS: @@ -1041,8 +1064,7 @@ css_error parseAtRule(css_parser *parser) switch (state->substate) { case Initial: - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); error = getToken(parser, &token); if (error != CSS_OK) @@ -1212,8 +1234,7 @@ css_error parseBlock(css_parser *parser) assert(0 && "Expected {"); } - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); state->substate = WS; /* Fall through */ @@ -1269,8 +1290,7 @@ css_error parseBlock(css_parser *parser) parser->event(CSS_PARSER_END_BLOCK, NULL, parser->event_pw); } - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); return done(parser); } @@ -1322,10 +1342,7 @@ css_error parseBlockContent(css_parser *parser) parser->event_pw); } - unref_interned_strings_in_tokens( - parser); - parserutils_vector_clear( - parser->tokens); + discard_tokens(parser); return transition(parser, to, subsequent); @@ -1353,10 +1370,7 @@ css_error parseBlockContent(css_parser *parser) if (error != CSS_OK) return error; - unref_interned_strings_in_tokens( - parser); - parserutils_vector_clear( - parser->tokens); + discard_tokens(parser); state->substate = WS; } else if (lwc_string_length( @@ -1379,10 +1393,7 @@ css_error parseBlockContent(css_parser *parser) parser->event_pw); } - unref_interned_strings_in_tokens( - parser); - parserutils_vector_clear( - parser->tokens); + discard_tokens(parser); return done(parser); } @@ -1401,8 +1412,7 @@ css_error parseBlockContent(css_parser *parser) parser->event_pw); } - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); return done(parser); } @@ -1445,8 +1455,7 @@ css_error parseSelector(css_parser *parser) parser_state to = { sAny1, Initial }; parser_state subsequent = { sSelector, AfterAny1 }; - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); return transition(parser, to, subsequent); } @@ -1472,8 +1481,7 @@ css_error parseDeclaration(css_parser *parser) parser_state to = { sProperty, Initial }; parser_state subsequent = { sDeclaration, Colon }; - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); return transition(parser, to, subsequent); } @@ -1945,6 +1953,9 @@ css_error parseAny1(css_parser *parser) if (error != CSS_OK) return error; + if (token->type == CSS_TOKEN_EOF) + return done(parser); + /* Grammar ambiguity: any0 can be followed by * '{', ';', ')', ']'. any1 can only be followed by '{'. */ if (token->type == CSS_TOKEN_CHAR && @@ -2025,18 +2036,19 @@ css_error parseAny(css_parser *parser) } if (token->type == CSS_TOKEN_FUNCTION) { - parser->match_char = ')'; + parserutils_stack_push(parser->open_items, &")"[0]); state->substate = WS; } else if (token->type == CSS_TOKEN_CHAR && lwc_string_length(token->idata) == 1 && (lwc_string_data(token->idata)[0] == '(' || lwc_string_data(token->idata)[0] == '[')) { - parser->match_char = lwc_string_data( - token->idata)[0] == '(' ? ')' : ']'; + parserutils_stack_push(parser->open_items, + &(lwc_string_data( + token->idata)[0] == '(' ? ")" : "]")[0]); state->substate = WS; + } else { + state->substate = WS2; } - - state->substate = WS2; /* Fall through */ case WS: case WS2: @@ -2063,11 +2075,24 @@ css_error parseAny(css_parser *parser) if (error != CSS_OK) return error; + if (token->type == CSS_TOKEN_EOF) { + error = pushBack(parser, token); + if (error != CSS_OK) + return error; + + /* parse error */ + parser->parseError = true; + + return done(parser); + } + /* Match correct close bracket (grammar ambiguity) */ if (token->type == CSS_TOKEN_CHAR && lwc_string_length(token->idata) == 1 && lwc_string_data(token->idata)[0] == - parser->match_char) { + ((uint8_t *) parserutils_stack_get_current( + parser->open_items))[0]) { + parserutils_stack_pop(parser->open_items, NULL); state->substate = WS2; goto ws2; } @@ -2174,8 +2199,7 @@ css_error parseMalformedDeclaration(css_parser *parser) return error; /* Discard the tokens we've read */ - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); return done(parser); } @@ -2270,8 +2294,7 @@ css_error parseMalformedSelector(css_parser *parser) return error; /* Discard the tokens we've read */ - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); return done(parser); } @@ -2379,8 +2402,7 @@ css_error parseMalformedAtRule(css_parser *parser) return error; /* Discard the tokens we've read */ - unref_interned_strings_in_tokens(parser); - parserutils_vector_clear(parser->tokens); + discard_tokens(parser); return done(parser); } @@ -2425,7 +2447,7 @@ css_error parseInlineStyle(css_parser *parser) } case AfterISBody0: /* Clean up any remaining tokens */ - unref_interned_strings_in_tokens(parser); + discard_tokens(parser); /* Emit remaining fake events to end the parse */ if (parser->event != NULL) { @@ -2571,22 +2593,48 @@ css_error parseISBody(css_parser *parser) return done(parser); } +css_error parseMediaQuery(css_parser *parser) +{ + enum { Initial = 0, AfterAtRule = 1 }; + parser_state *state = parserutils_stack_get_current(parser->states); + + /* media-query = at-rule */ + + switch (state->substate) { + case Initial: + { + parser_state to = { sAtRule, Initial }; + parser_state subsequent = { sMediaQuery, AfterAtRule }; + + return transition(parser, to, subsequent); + } + case AfterAtRule: + /* Clean up any remaining tokens */ + discard_tokens(parser); + break; + } + + return done(parser); +} + /** - * Iterate the token vector and unref any interned strings in the tokens. + * Discard the contents of the token vector * * \param parser The parser whose tokens we are cleaning up. */ -void unref_interned_strings_in_tokens(css_parser *parser) +void discard_tokens(css_parser *parser) { - int32_t ctx = 0; - const css_token *tok; + int32_t ctx = 0; + const css_token *tok; - while ((tok = parserutils_vector_iterate( + while ((tok = parserutils_vector_iterate( parser->tokens, &ctx)) != NULL) { - if (tok->idata != NULL) { - lwc_string_unref(tok->idata); + if (tok->idata != NULL) { + lwc_string_unref(tok->idata); } - } + } + + parserutils_vector_clear(parser->tokens); } #ifndef NDEBUG @@ -2604,7 +2652,11 @@ static void tprinter(void *token) { css_token *t = token; - if (t->data.data) + if (t->idata) { + printf("%d: %.*s", t->type, + (int) lwc_string_length(t->idata), + lwc_string_data(t->idata)); + } else if (t->data.data) printf("%d: %.*s", t->type, (int) t->data.len, t->data.data); else printf("%d", t->type); diff --git a/src/parse/parse.h b/src/parse/parse.h index 833aa51..e65f055 100644 --- a/src/parse/parse.h +++ b/src/parse/parse.h @@ -61,6 +61,8 @@ css_error css__parser_create(const char *charset, css_charset_source cs_source, css_parser **parser); css_error css__parser_create_for_inline_style(const char *charset, css_charset_source cs_source, css_parser **parser); +css_error css__parser_create_for_media_query(const char *charset, + css_charset_source cs_source, 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/parse/properties/utils.c b/src/parse/properties/utils.c index 7abef24..0e49853 100644 --- a/src/parse/properties/utils.c +++ b/src/parse/properties/utils.c @@ -1007,6 +1007,12 @@ css_error css__parse_unit_keyword(const char *ptr, size_t len, uint32_t *unit) if (len == 4) { if (strncasecmp(ptr, "grad", 4) == 0) *unit = UNIT_GRAD; + else if (strncasecmp(ptr, "turn", 4) == 0) + *unit = UNIT_TURN; + else if (strncasecmp(ptr, "dppx", 4) == 0) + *unit = UNIT_DPPX; + else if (strncasecmp(ptr, "dpcm", 4) == 0) + *unit = UNIT_DPCM; else if (strncasecmp(ptr, "vmin", 4) == 0) *unit = UNIT_VMIN; else if (strncasecmp(ptr, "vmax", 4) == 0) @@ -1026,6 +1032,8 @@ css_error css__parse_unit_keyword(const char *ptr, size_t len, uint32_t *unit) *unit = UNIT_REM; else if (strncasecmp(ptr, "rlh", 3) == 0) *unit = UNIT_RLH; + else if (strncasecmp(ptr, "dpi", 3) == 0) + *unit = UNIT_DPI; else return CSS_INVALID; } else if (len == 2) { diff --git a/src/parse/propstrings.c b/src/parse/propstrings.c index bfd2965..3c9401b 100644 --- a/src/parse/propstrings.c +++ b/src/parse/propstrings.c @@ -439,6 +439,10 @@ const stringmap_entry stringmap[LAST_KNOWN] = { { "column-reverse", SLEN("column-reverse") }, { "wrap", SLEN("wrap") }, { "wrap-reverse", SLEN("wrap-reverse") }, + { "and", SLEN("and") }, + { "or", SLEN("or") }, + { "only", SLEN("only") }, + { "infinite", SLEN("infinite") }, { "aliceblue", SLEN("aliceblue") }, { "antiquewhite", SLEN("antiquewhite") }, diff --git a/src/parse/propstrings.h b/src/parse/propstrings.h index 67eaa5f..24b681b 100644 --- a/src/parse/propstrings.h +++ b/src/parse/propstrings.h @@ -101,7 +101,7 @@ enum { AVOID_PAGE, AVOID_COLUMN, BALANCE, HORIZONTAL_TB, VERTICAL_RL, VERTICAL_LR, CONTENT_BOX, BORDER_BOX, STRETCH, INLINE_FLEX, FLEX_START, FLEX_END, SPACE_BETWEEN, SPACE_AROUND, SPACE_EVENLY, ROW, ROW_REVERSE, - COLUMN_REVERSE, WRAP_STRING, WRAP_REVERSE, + COLUMN_REVERSE, WRAP_STRING, WRAP_REVERSE, AND, OR, ONLY, INFINITE, /* Named colours */ FIRST_COLOUR, |