From 4ff509a419cf48774d31f27e11a59edef1fd52d2 Mon Sep 17 00:00:00 2001 From: John Mark Bell Date: Thu, 18 Jun 2009 20:07:47 +0000 Subject: Centralise !important handling. Document background-attachment parser and make it behave correctly. svn path=/trunk/libcss/; revision=7856 --- src/parse/Makefile | 2 +- src/parse/important.c | 415 ++++++++++++++++++++++++++++++++ src/parse/important.h | 20 ++ src/parse/language.c | 14 ++ src/parse/properties/aural.c | 79 ------ src/parse/properties/background.c | 47 ++-- src/parse/properties/border_outline.c | 24 -- src/parse/properties/display_sizing.c | 32 --- src/parse/properties/effects_stacking.c | 16 -- src/parse/properties/font.c | 27 --- src/parse/properties/generated_list.c | 45 ---- src/parse/properties/margin.c | 4 - src/parse/properties/padding.c | 4 - src/parse/properties/page.c | 20 -- src/parse/properties/positioning.c | 20 -- src/parse/properties/table.c | 12 - src/parse/properties/text.c | 40 --- src/parse/properties/ui.c | 8 - src/parse/properties/utils.c | 46 ---- src/parse/properties/utils.h | 3 - 20 files changed, 474 insertions(+), 404 deletions(-) create mode 100644 src/parse/important.c create mode 100644 src/parse/important.h diff --git a/src/parse/Makefile b/src/parse/Makefile index b75e8fa..a7548a8 100644 --- a/src/parse/Makefile +++ b/src/parse/Makefile @@ -1,4 +1,4 @@ # Sources -DIR_SOURCES := parse.c language.c propstrings.c +DIR_SOURCES := parse.c language.c important.c propstrings.c include build/makefiles/Makefile.subdir diff --git a/src/parse/important.c b/src/parse/important.c new file mode 100644 index 0000000..a32da0a --- /dev/null +++ b/src/parse/important.c @@ -0,0 +1,415 @@ +/* + * This file is part of LibCSS. + * Licensed under the MIT License, + * http://www.opensource.org/licenses/mit-license.php + * Copyright 2009 John-Mark Bell + */ + +#include + +#include "bytecode/bytecode.h" +#include "bytecode/opcodes.h" +#include "parse/important.h" + +/** + * 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 parse_important(css_language *c, + const parserutils_vector *vector, int *ctx, + uint8_t *result) +{ + int orig_ctx = *ctx; + 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 (token->ilower == c->strings[IMPORTANT]) { + *result |= FLAG_IMPORTANT; + } else { + *ctx = orig_ctx; + return CSS_INVALID; + } + } else if (token != NULL) { + *ctx = orig_ctx; + return CSS_INVALID; + } + + return CSS_OK; +} + +/** + * Make a style important + * + * \param style The style to modify + */ +void make_style_important(css_style *style) +{ + void *bytecode = style->bytecode; + size_t length = style->length; + uint32_t offset = 0; + +#define ADVANCE(n) do { \ + offset += (n); \ + bytecode = ((uint8_t *) bytecode) + (n); \ +} while(0) + + while (offset < length) { + opcode op; + uint8_t flags; + uint32_t value; + uint32_t opv = *((uint32_t *) bytecode); + + /* Extract opv components, setting important flag */ + op = getOpcode(opv); + flags = getFlags(opv) | FLAG_IMPORTANT; + value = getValue(opv); + + /* Write OPV back to bytecode */ + *((uint32_t *) bytecode) = buildOPV(op, flags, value); + + ADVANCE(sizeof(opv)); + + /* Advance past any property-specific data */ + if (isInherit(opv) == false) { + switch (op) { + case CSS_PROP_AZIMUTH: + if ((value & ~AZIMUTH_BEHIND) == + AZIMUTH_ANGLE) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + break; + case CSS_PROP_BORDER_TOP_COLOR: + case CSS_PROP_BORDER_RIGHT_COLOR: + case CSS_PROP_BORDER_BOTTOM_COLOR: + case CSS_PROP_BORDER_LEFT_COLOR: + case CSS_PROP_BACKGROUND_COLOR: + assert(BACKGROUND_COLOR_SET == + BORDER_COLOR_SET); + + if (value == BACKGROUND_COLOR_SET) { + ADVANCE(sizeof(uint32_t)); + } + break; + case CSS_PROP_BACKGROUND_IMAGE: + case CSS_PROP_CUE_AFTER: + case CSS_PROP_CUE_BEFORE: + case CSS_PROP_LIST_STYLE_IMAGE: + assert(BACKGROUND_IMAGE_URI == CUE_AFTER_URI); + assert(BACKGROUND_IMAGE_URI == CUE_BEFORE_URI); + assert(BACKGROUND_IMAGE_URI == + LIST_STYLE_IMAGE_URI); + + if (value == BACKGROUND_IMAGE_URI) { + ADVANCE(sizeof(lwc_string *)); + } + break; + case CSS_PROP_BACKGROUND_POSITION: + if ((value & 0xf0) == + BACKGROUND_POSITION_HORZ_SET) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + if ((value & 0x0f) == + BACKGROUND_POSITION_VERT_SET) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + break; + case CSS_PROP_BORDER_SPACING: + if (value == BORDER_SPACING_SET) { + ADVANCE(2 * sizeof(css_fixed) + + 2 * sizeof(uint32_t)); + } + break; + case CSS_PROP_BORDER_TOP_WIDTH: + case CSS_PROP_BORDER_RIGHT_WIDTH: + case CSS_PROP_BORDER_BOTTOM_WIDTH: + case CSS_PROP_BORDER_LEFT_WIDTH: + case CSS_PROP_OUTLINE_WIDTH: + assert(BORDER_WIDTH_SET == OUTLINE_WIDTH_SET); + + if (value == BORDER_WIDTH_SET) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + break; + case CSS_PROP_MARGIN_TOP: + case CSS_PROP_MARGIN_RIGHT: + case CSS_PROP_MARGIN_BOTTOM: + case CSS_PROP_MARGIN_LEFT: + case CSS_PROP_BOTTOM: + case CSS_PROP_LEFT: + case CSS_PROP_RIGHT: + case CSS_PROP_TOP: + case CSS_PROP_HEIGHT: + case CSS_PROP_WIDTH: + assert(BOTTOM_SET == LEFT_SET); + assert(BOTTOM_SET == RIGHT_SET); + assert(BOTTOM_SET == TOP_SET); + assert(BOTTOM_SET == HEIGHT_SET); + assert(BOTTOM_SET == MARGIN_SET); + assert(BOTTOM_SET == WIDTH_SET); + + if (value == BOTTOM_SET) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + break; + case CSS_PROP_CLIP: + if ((value & CLIP_SHAPE_MASK) == + CLIP_SHAPE_RECT) { + if ((value & CLIP_RECT_TOP_AUTO) == 0) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + if ((value & CLIP_RECT_RIGHT_AUTO) == + 0) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + if ((value & CLIP_RECT_BOTTOM_AUTO) == + 0) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + if ((value & CLIP_RECT_LEFT_AUTO) == + 0) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + } + break; + case CSS_PROP_COLOR: + if (value == COLOR_SET) { + ADVANCE(sizeof(uint32_t)); + } + break; + case CSS_PROP_CONTENT: + while (value != CONTENT_NORMAL && + value != CONTENT_NONE) { + switch (value & 0xff) { + case CONTENT_COUNTER: + case CONTENT_URI: + case CONTENT_ATTR: + case CONTENT_STRING: + ADVANCE(sizeof(lwc_string *)); + break; + case CONTENT_COUNTERS: + ADVANCE(2 * + sizeof(lwc_string *)); + break; + case CONTENT_OPEN_QUOTE: + case CONTENT_CLOSE_QUOTE: + case CONTENT_NO_OPEN_QUOTE: + case CONTENT_NO_CLOSE_QUOTE: + break; + } + + value = *((uint32_t *) bytecode); + ADVANCE(sizeof(value)); + } + break; + case CSS_PROP_COUNTER_INCREMENT: + case CSS_PROP_COUNTER_RESET: + assert(COUNTER_INCREMENT_NONE == + COUNTER_RESET_NONE); + + while (value != COUNTER_INCREMENT_NONE) { + ADVANCE(sizeof(lwc_string *) + + sizeof(css_fixed)); + + value = *((uint32_t *) bytecode); + ADVANCE(sizeof(value)); + } + break; + case CSS_PROP_CURSOR: + while (value == CURSOR_URI) { + ADVANCE(sizeof(lwc_string *)); + + value = *((uint32_t *) bytecode); + ADVANCE(sizeof(value)); + } + break; + case CSS_PROP_ELEVATION: + if (value == ELEVATION_ANGLE) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + break; + case CSS_PROP_FONT_FAMILY: + while (value != FONT_FAMILY_END) { + switch (value) { + case FONT_FAMILY_STRING: + case FONT_FAMILY_IDENT_LIST: + ADVANCE(sizeof(lwc_string *)); + break; + } + + value = *((uint32_t *) bytecode); + ADVANCE(sizeof(value)); + } + break; + case CSS_PROP_FONT_SIZE: + if (value == FONT_SIZE_DIMENSION) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + break; + case CSS_PROP_LETTER_SPACING: + case CSS_PROP_WORD_SPACING: + assert(LETTER_SPACING_SET == WORD_SPACING_SET); + + if (value == LETTER_SPACING_SET) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + break; + case CSS_PROP_LINE_HEIGHT: + switch (value) { + case LINE_HEIGHT_NUMBER: + ADVANCE(sizeof(css_fixed)); + break; + case LINE_HEIGHT_DIMENSION: + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + break; + } + break; + case CSS_PROP_MAX_HEIGHT: + case CSS_PROP_MAX_WIDTH: + assert(MAX_HEIGHT_SET == MAX_WIDTH_SET); + + if (value == MAX_HEIGHT_SET) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + break; + case CSS_PROP_PADDING_TOP: + case CSS_PROP_PADDING_RIGHT: + case CSS_PROP_PADDING_BOTTOM: + case CSS_PROP_PADDING_LEFT: + case CSS_PROP_MIN_HEIGHT: + case CSS_PROP_MIN_WIDTH: + case CSS_PROP_PAUSE_AFTER: + case CSS_PROP_PAUSE_BEFORE: + case CSS_PROP_TEXT_INDENT: + assert(MIN_HEIGHT_SET == MIN_WIDTH_SET); + assert(MIN_HEIGHT_SET == PADDING_SET); + assert(MIN_HEIGHT_SET == PAUSE_AFTER_SET); + assert(MIN_HEIGHT_SET == PAUSE_BEFORE_SET); + assert(MIN_HEIGHT_SET == TEXT_INDENT_SET); + + if (value == MIN_HEIGHT_SET) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + break; + case CSS_PROP_ORPHANS: + case CSS_PROP_PITCH_RANGE: + case CSS_PROP_RICHNESS: + case CSS_PROP_STRESS: + case CSS_PROP_WIDOWS: + assert(ORPHANS_SET == PITCH_RANGE_SET); + assert(ORPHANS_SET == RICHNESS_SET); + assert(ORPHANS_SET == STRESS_SET); + assert(ORPHANS_SET == WIDOWS_SET); + + if (value == ORPHANS_SET) { + ADVANCE(sizeof(css_fixed)); + } + break; + case CSS_PROP_OUTLINE_COLOR: + if (value == OUTLINE_COLOR_SET) { + ADVANCE(sizeof(uint32_t)); + } + break; + case CSS_PROP_PITCH: + if (value == PITCH_FREQUENCY) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + break; + case CSS_PROP_PLAY_DURING: + if (value == PLAY_DURING_URI) { + ADVANCE(sizeof(lwc_string *)); + } + break; + case CSS_PROP_QUOTES: + while (value != QUOTES_NONE) { + ADVANCE(2 * sizeof(lwc_string *)); + + value = *((uint32_t *) bytecode); + ADVANCE(sizeof(value)); + } + break; + case CSS_PROP_SPEECH_RATE: + if (value == SPEECH_RATE_SET) { + ADVANCE(sizeof(css_fixed)); + } + break; + case CSS_PROP_VERTICAL_ALIGN: + if (value == VERTICAL_ALIGN_SET) { + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + } + break; + case CSS_PROP_VOICE_FAMILY: + while (value != VOICE_FAMILY_END) { + switch (value) { + case VOICE_FAMILY_STRING: + case VOICE_FAMILY_IDENT_LIST: + ADVANCE(sizeof(lwc_string *)); + break; + } + + value = *((uint32_t *) bytecode); + ADVANCE(sizeof(value)); + } + break; + case CSS_PROP_VOLUME: + switch (value) { + case VOLUME_NUMBER: + ADVANCE(sizeof(css_fixed)); + break; + case VOLUME_DIMENSION: + ADVANCE(sizeof(css_fixed) + + sizeof(uint32_t)); + break; + } + break; + case CSS_PROP_Z_INDEX: + if (value == Z_INDEX_SET) { + ADVANCE(sizeof(css_fixed)); + } + break; + default: + break; + } + } + } + +#undef ADVANCE + +} + diff --git a/src/parse/important.h b/src/parse/important.h new file mode 100644 index 0000000..9faafef --- /dev/null +++ b/src/parse/important.h @@ -0,0 +1,20 @@ +/* + * This file is part of LibCSS. + * Licensed under the MIT License, + * http://www.opensource.org/licenses/mit-license.php + * Copyright 2009 John-Mark Bell + */ + +#ifndef css_parse_important_h_ +#define css_parse_important_h_ + +#include "stylesheet.h" +#include "parse/language.h" + +css_error parse_important(css_language *c, + const parserutils_vector *vector, int *ctx, + uint8_t *result); + +void make_style_important(css_style *style); + +#endif diff --git a/src/parse/language.c b/src/parse/language.c index 5097feb..37edad8 100644 --- a/src/parse/language.c +++ b/src/parse/language.c @@ -12,10 +12,12 @@ #include "stylesheet.h" #include "lex/lex.h" +#include "parse/important.h" #include "parse/language.h" #include "parse/parse.h" #include "parse/propstrings.h" #include "parse/properties/properties.h" +#include "parse/properties/utils.h" #include "utils/parserutilserror.h" #include "utils/utils.h" @@ -1025,6 +1027,7 @@ css_error parseProperty(css_language *c, const css_token *property, css_error error; css_prop_handler handler = NULL; int i = 0; + uint8_t flags = 0; css_style *style = NULL; /* Find property index */ @@ -1047,6 +1050,17 @@ css_error parseProperty(css_language *c, const css_token *property, assert (style != NULL); + /* Determine if this is important or not */ + error = parse_important(c, vector, ctx, &flags); + if (error != CSS_OK) { + css_stylesheet_style_destroy(c->sheet, style); + return error; + } + + /* If it's important, then mark the style appropriately */ + if (flags != 0) + make_style_important(style); + /* Append style to rule */ error = css_stylesheet_rule_append_style(c->sheet, rule, style); if (error != CSS_OK) { diff --git a/src/parse/properties/aural.c b/src/parse/properties/aural.c index c548ff1..20ac59f 100644 --- a/src/parse/properties/aural.c +++ b/src/parse/properties/aural.c @@ -147,10 +147,6 @@ css_error parse_azimuth(css_language *c, value = AZIMUTH_ANGLE; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_AZIMUTH, flags, value); required_size = sizeof(opv); @@ -191,10 +187,6 @@ css_error parse_cue_after(css_language *c, token->type != CSS_TOKEN_URI)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->type == CSS_TOKEN_IDENT && token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; @@ -246,10 +238,6 @@ css_error parse_cue_before(css_language *c, token->type != CSS_TOKEN_URI)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->type == CSS_TOKEN_IDENT && token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; @@ -350,10 +338,6 @@ css_error parse_elevation(css_language *c, value = ELEVATION_ANGLE; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_ELEVATION, flags, value); required_size = sizeof(opv); @@ -415,10 +399,6 @@ css_error parse_pause_after(css_language *c, value = PAUSE_AFTER_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_PAUSE_AFTER, flags, value); required_size = sizeof(opv); @@ -480,10 +460,6 @@ css_error parse_pause_before(css_language *c, value = PAUSE_BEFORE_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_PAUSE_BEFORE, flags, value); required_size = sizeof(opv); @@ -525,10 +501,6 @@ css_error parse_pitch_range(css_language *c, token->type != CSS_TOKEN_NUMBER)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { @@ -625,10 +597,6 @@ css_error parse_pitch(css_language *c, value = PITCH_FREQUENCY; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_PITCH, flags, value); required_size = sizeof(opv); @@ -709,10 +677,6 @@ css_error parse_play_during(css_language *c, } } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_PLAY_DURING, flags, value); required_size = sizeof(opv); @@ -755,10 +719,6 @@ css_error parse_richness(css_language *c, token->type != CSS_TOKEN_NUMBER)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { @@ -812,10 +772,6 @@ css_error parse_speak_header(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[ONCE]) { @@ -853,10 +809,6 @@ css_error parse_speak_numeral(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[DIGITS]) { @@ -894,10 +846,6 @@ css_error parse_speak_punctuation(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[CODE]) { @@ -935,10 +883,6 @@ css_error parse_speak(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[NORMAL]) { @@ -983,10 +927,6 @@ css_error parse_speech_rate(css_language *c, token->type != CSS_TOKEN_NUMBER)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->type == CSS_TOKEN_IDENT && token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; @@ -1065,10 +1005,6 @@ css_error parse_stress(css_language *c, token->type != CSS_TOKEN_NUMBER)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { @@ -1232,10 +1168,6 @@ css_error parse_voice_family(css_language *c, required_size += sizeof(opv); } - error = parse_important(c, vector, &temp_ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_VOICE_FAMILY, flags, value); /* Allocate result */ @@ -1435,13 +1367,6 @@ css_error parse_voice_family(css_language *c, ptr += sizeof(opv); } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) { - css_stylesheet_style_destroy(c->sheet, *result); - *result = NULL; - return error; - } - return CSS_OK; } @@ -1522,10 +1447,6 @@ css_error parse_volume(css_language *c, value = VOLUME_DIMENSION; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_VOLUME, flags, value); required_size = sizeof(opv); diff --git a/src/parse/properties/background.c b/src/parse/properties/background.c index 46ddf73..491b092 100644 --- a/src/parse/properties/background.c +++ b/src/parse/properties/background.c @@ -13,10 +13,25 @@ #include "parse/properties/properties.h" #include "parse/properties/utils.h" +/** + * Parse background-attachment + * + * \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 a valid background-attachment + * + * 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_background_attachment(css_language *c, const parserutils_vector *vector, int *ctx, css_style **result) { + int orig_ctx = *ctx; css_error error; const css_token *ident; uint8_t flags = 0; @@ -25,12 +40,10 @@ css_error parse_background_attachment(css_language *c, /* IDENT (fixed, scroll, inherit) */ ident = parserutils_vector_iterate(vector, ctx); - if (ident == NULL || ident->type != CSS_TOKEN_IDENT) + if (ident == NULL || ident->type != CSS_TOKEN_IDENT) { + *ctx = orig_ctx; return CSS_INVALID; - - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; + } if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; @@ -38,15 +51,19 @@ css_error parse_background_attachment(css_language *c, value = BACKGROUND_ATTACHMENT_FIXED; } else if (ident->ilower == c->strings[SCROLL]) { value = BACKGROUND_ATTACHMENT_SCROLL; - } else + } else { + *ctx = orig_ctx; return CSS_INVALID; + } opv = buildOPV(CSS_PROP_BACKGROUND_ATTACHMENT, flags, value); /* Allocate result */ error = css_stylesheet_style_create(c->sheet, sizeof(opv), result); - if (error != CSS_OK) + if (error != CSS_OK) { + *ctx = orig_ctx; return error; + } /* Copy the bytecode to it */ memcpy((*result)->bytecode, &opv, sizeof(opv)); @@ -87,10 +104,6 @@ css_error parse_background_color(css_language *c, value = BACKGROUND_COLOR_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_BACKGROUND_COLOR, flags, value); required_size = sizeof(opv); @@ -129,10 +142,6 @@ css_error parse_background_image(css_language *c, token->type != CSS_TOKEN_URI)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->type == CSS_TOKEN_IDENT && token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; @@ -283,10 +292,6 @@ css_error parse_background_position(css_language *c, } } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_BACKGROUND_POSITION, flags, value[0] | value[1]); required_size = sizeof(opv); @@ -337,10 +342,6 @@ css_error parse_background_repeat(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[NO_REPEAT]) { diff --git a/src/parse/properties/border_outline.c b/src/parse/properties/border_outline.c index 72b6b7b..8d31dc5 100644 --- a/src/parse/properties/border_outline.c +++ b/src/parse/properties/border_outline.c @@ -61,10 +61,6 @@ css_error parse_border_collapse(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[COLLAPSE]) { @@ -201,10 +197,6 @@ css_error parse_border_spacing(css_language *c, value = BORDER_SPACING_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_BORDER_SPACING, flags, value); required_size = sizeof(opv); @@ -290,10 +282,6 @@ css_error parse_outline_color(css_language *c, value = OUTLINE_COLOR_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_OUTLINE_COLOR, flags, value); required_size = sizeof(opv); @@ -382,10 +370,6 @@ css_error parse_border_side_color(css_language *c, value = BORDER_COLOR_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(op, flags, value); required_size = sizeof(opv); @@ -423,10 +407,6 @@ css_error parse_border_side_style(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[NONE]) { @@ -516,10 +496,6 @@ css_error parse_border_side_width(css_language *c, value = BORDER_WIDTH_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(op, flags, value); required_size = sizeof(opv); diff --git a/src/parse/properties/display_sizing.c b/src/parse/properties/display_sizing.c index 057b3a1..900e580 100644 --- a/src/parse/properties/display_sizing.c +++ b/src/parse/properties/display_sizing.c @@ -30,10 +30,6 @@ css_error parse_display(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[INLINE]) { @@ -126,10 +122,6 @@ css_error parse_height(css_language *c, value = HEIGHT_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_HEIGHT, flags, value); required_size = sizeof(opv); @@ -207,10 +199,6 @@ css_error parse_line_height(css_language *c, value = LINE_HEIGHT_DIMENSION; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_LINE_HEIGHT, flags, value); required_size = sizeof(opv); @@ -280,10 +268,6 @@ css_error parse_max_height(css_language *c, value = MAX_HEIGHT_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_MAX_HEIGHT, flags, value); required_size = sizeof(opv); @@ -349,10 +333,6 @@ css_error parse_max_width(css_language *c, value = MAX_WIDTH_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_MAX_WIDTH, flags, value); required_size = sizeof(opv); @@ -414,10 +394,6 @@ css_error parse_min_height(css_language *c, value = MIN_HEIGHT_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_MIN_HEIGHT, flags, value); required_size = sizeof(opv); @@ -479,10 +455,6 @@ css_error parse_min_width(css_language *c, value = MIN_WIDTH_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_MIN_WIDTH, flags, value); required_size = sizeof(opv); @@ -548,10 +520,6 @@ css_error parse_width(css_language *c, value = WIDTH_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_WIDTH, flags, value); required_size = sizeof(opv); diff --git a/src/parse/properties/effects_stacking.c b/src/parse/properties/effects_stacking.c index 9659f80..6bcd862 100644 --- a/src/parse/properties/effects_stacking.c +++ b/src/parse/properties/effects_stacking.c @@ -100,10 +100,6 @@ css_error parse_clip(css_language *c, return CSS_INVALID; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_CLIP, flags, value); required_size = sizeof(opv); @@ -151,10 +147,6 @@ css_error parse_overflow(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[VISIBLE]) { @@ -196,10 +188,6 @@ css_error parse_visibility(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[VISIBLE]) { @@ -242,10 +230,6 @@ css_error parse_z_index(css_language *c, token->type != CSS_TOKEN_NUMBER)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->type == CSS_TOKEN_IDENT && token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; diff --git a/src/parse/properties/font.c b/src/parse/properties/font.c index 1d1e37a..17cac76 100644 --- a/src/parse/properties/font.c +++ b/src/parse/properties/font.c @@ -154,10 +154,6 @@ css_error parse_font_family(css_language *c, required_size += sizeof(opv); } - error = parse_important(c, vector, &temp_ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_FONT_FAMILY, flags, value); /* Allocate result */ @@ -366,13 +362,6 @@ css_error parse_font_family(css_language *c, ptr += sizeof(opv); } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) { - css_stylesheet_style_destroy(c->sheet, *result); - *result = NULL; - return error; - } - return CSS_OK; } @@ -451,10 +440,6 @@ css_error parse_font_size(css_language *c, value = FONT_SIZE_DIMENSION; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_FONT_SIZE, flags, value); required_size = sizeof(opv); @@ -493,10 +478,6 @@ css_error parse_font_style(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[NORMAL]) { @@ -536,10 +517,6 @@ css_error parse_font_variant(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[NORMAL]) { @@ -579,10 +556,6 @@ css_error parse_font_weight(css_language *c, token->type != CSS_TOKEN_NUMBER)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { diff --git a/src/parse/properties/generated_list.c b/src/parse/properties/generated_list.c index 6c9c1c7..970da2a 100644 --- a/src/parse/properties/generated_list.c +++ b/src/parse/properties/generated_list.c @@ -69,10 +69,6 @@ css_error parse_content(css_language *c, required_size += len; } - error = parse_important(c, vector, &temp_ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_CONTENT, flags, value); /* Allocate result */ @@ -101,11 +97,6 @@ css_error parse_content(css_language *c, return error; } - /* Ensure we skip past !important */ - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - return CSS_OK; } @@ -185,10 +176,6 @@ css_error parse_counter_increment(css_language *c, required_size += sizeof(opv); } - error = parse_important(c, vector, &temp_ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_COUNTER_INCREMENT, flags, value); /* Allocate result */ @@ -270,10 +257,6 @@ css_error parse_counter_increment(css_language *c, ptr += sizeof(opv); } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - return CSS_OK; } @@ -353,10 +336,6 @@ css_error parse_counter_reset(css_language *c, required_size += sizeof(opv); } - error = parse_important(c, vector, &temp_ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_COUNTER_RESET, flags, value); /* Allocate result */ @@ -438,10 +417,6 @@ css_error parse_counter_reset(css_language *c, ptr += sizeof(opv); } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - return CSS_OK; } @@ -462,10 +437,6 @@ css_error parse_list_style_image(css_language *c, token->type != CSS_TOKEN_URI)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->type == CSS_TOKEN_IDENT && token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; @@ -515,10 +486,6 @@ css_error parse_list_style_position(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[INSIDE]) { @@ -560,10 +527,6 @@ css_error parse_list_style_type(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else { @@ -658,10 +621,6 @@ css_error parse_quotes(css_language *c, required_size += sizeof(opv); } - error = parse_important(c, vector, &temp_ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_QUOTES, flags, value); /* Allocate result */ @@ -736,10 +695,6 @@ css_error parse_quotes(css_language *c, ptr += sizeof(opv); } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - return CSS_OK; } diff --git a/src/parse/properties/margin.c b/src/parse/properties/margin.c index d719d3a..9cf0b83 100644 --- a/src/parse/properties/margin.c +++ b/src/parse/properties/margin.c @@ -83,10 +83,6 @@ css_error parse_margin_side(css_language *c, value = MARGIN_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(op, flags, value); required_size = sizeof(opv); diff --git a/src/parse/properties/padding.c b/src/parse/properties/padding.c index cf33f35..d2a5bc4 100644 --- a/src/parse/properties/padding.c +++ b/src/parse/properties/padding.c @@ -86,10 +86,6 @@ css_error parse_padding_side(css_language *c, value = PADDING_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(op, flags, value); required_size = sizeof(opv); diff --git a/src/parse/properties/page.c b/src/parse/properties/page.c index f997276..49031cf 100644 --- a/src/parse/properties/page.c +++ b/src/parse/properties/page.c @@ -30,10 +30,6 @@ css_error parse_orphans(css_language *c, token->type != CSS_TOKEN_NUMBER)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { @@ -87,10 +83,6 @@ css_error parse_page_break_after(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[AUTO]) { @@ -134,10 +126,6 @@ css_error parse_page_break_before(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[AUTO]) { @@ -181,10 +169,6 @@ css_error parse_page_break_inside(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[AUTO]) { @@ -225,10 +209,6 @@ css_error parse_widows(css_language *c, token->type != CSS_TOKEN_NUMBER)) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (token->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (token->type == CSS_TOKEN_NUMBER) { diff --git a/src/parse/properties/positioning.c b/src/parse/properties/positioning.c index 4882a45..c280f4b 100644 --- a/src/parse/properties/positioning.c +++ b/src/parse/properties/positioning.c @@ -59,10 +59,6 @@ css_error parse_position(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[STATIC]) { @@ -104,10 +100,6 @@ css_error parse_clear(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[RIGHT]) { @@ -149,10 +141,6 @@ css_error parse_float(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[LEFT]) { @@ -245,10 +233,6 @@ css_error parse_vertical_align(css_language *c, value = VERTICAL_ALIGN_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_VERTICAL_ALIGN, flags, value); required_size = sizeof(opv); @@ -310,10 +294,6 @@ css_error parse_side(css_language *c, value = BOTTOM_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(op, flags, value); required_size = sizeof(opv); diff --git a/src/parse/properties/table.c b/src/parse/properties/table.c index e1249f8..43a8a58 100644 --- a/src/parse/properties/table.c +++ b/src/parse/properties/table.c @@ -27,10 +27,6 @@ css_error parse_caption_side(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[TOP]) { @@ -68,10 +64,6 @@ css_error parse_empty_cells(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[SHOW]) { @@ -109,10 +101,6 @@ css_error parse_table_layout(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[AUTO]) { diff --git a/src/parse/properties/text.c b/src/parse/properties/text.c index 3e9dc72..0c2a4c3 100644 --- a/src/parse/properties/text.c +++ b/src/parse/properties/text.c @@ -41,10 +41,6 @@ css_error parse_color(css_language *c, value = COLOR_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_COLOR, flags, value); required_size = sizeof(opv); @@ -81,10 +77,6 @@ css_error parse_direction(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[LTR]) { @@ -146,10 +138,6 @@ css_error parse_letter_spacing(css_language *c, value = LETTER_SPACING_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_LETTER_SPACING, flags, value); required_size = sizeof(opv); @@ -188,10 +176,6 @@ css_error parse_text_align(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[LEFT]) { @@ -272,10 +256,6 @@ css_error parse_text_decoration(css_language *c, } } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_TEXT_DECORATION, flags, value); /* Allocate result */ @@ -323,10 +303,6 @@ css_error parse_text_indent(css_language *c, value = TEXT_INDENT_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_TEXT_INDENT, flags, value); required_size = sizeof(opv); @@ -365,10 +341,6 @@ css_error parse_text_transform(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[CAPITALIZE]) { @@ -410,10 +382,6 @@ css_error parse_unicode_bidi(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[NORMAL]) { @@ -453,10 +421,6 @@ css_error parse_white_space(css_language *c, if (ident == NULL || ident->type != CSS_TOKEN_IDENT) return CSS_INVALID; - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - if (ident->ilower == c->strings[INHERIT]) { flags |= FLAG_INHERIT; } else if (ident->ilower == c->strings[NORMAL]) { @@ -524,10 +488,6 @@ css_error parse_word_spacing(css_language *c, value = WORD_SPACING_SET; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_WORD_SPACING, flags, value); required_size = sizeof(opv); diff --git a/src/parse/properties/ui.c b/src/parse/properties/ui.c index 1a3d1d8..882c3b0 100644 --- a/src/parse/properties/ui.c +++ b/src/parse/properties/ui.c @@ -158,10 +158,6 @@ css_error parse_cursor(css_language *c, return CSS_INVALID; } - error = parse_important(c, vector, &temp_ctx, &flags); - if (error != CSS_OK) - return error; - opv = buildOPV(CSS_PROP_CURSOR, flags, value); /* Allocate result */ @@ -271,10 +267,6 @@ css_error parse_cursor(css_language *c, return CSS_INVALID; } - error = parse_important(c, vector, ctx, &flags); - if (error != CSS_OK) - return error; - return CSS_OK; } diff --git a/src/parse/properties/utils.c b/src/parse/properties/utils.c index b0a4c1b..bc1fd30 100644 --- a/src/parse/properties/utils.c +++ b/src/parse/properties/utils.c @@ -12,52 +12,6 @@ #include "bytecode/opcodes.h" #include "parse/properties/utils.h" -/** - * 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 parse_important(css_language *c, - const parserutils_vector *vector, int *ctx, - uint8_t *result) -{ - int orig_ctx = *ctx; - 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 (token->ilower == c->strings[IMPORTANT]) { - *result |= FLAG_IMPORTANT; - } else { - *ctx = orig_ctx; - return CSS_INVALID; - } - } else if (token != NULL) { - *ctx = orig_ctx; - return CSS_INVALID; - } - - return CSS_OK; -} - /** * Parse a colour specifier * diff --git a/src/parse/properties/utils.h b/src/parse/properties/utils.h index 923ffb5..c04a2aa 100644 --- a/src/parse/properties/utils.h +++ b/src/parse/properties/utils.h @@ -10,9 +10,6 @@ #include "parse/language.h" -css_error parse_important(css_language *c, - const parserutils_vector *vector, int *ctx, - uint8_t *result); css_error parse_colour_specifier(css_language *c, const parserutils_vector *vector, int *ctx, uint32_t *result); -- cgit v1.2.3