/* * This file is part of LibCSS * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2017 The NetSurf Project */ /** Default values are 'initial value', unless the property is inherited, * in which case it is 'inherit'. */ static const css_computed_uncommon default_uncommon = { .i = { .bits = { (CSS_BORDER_SPACING_SET << 21) | ( CSS_OUTLINE_WIDTH_MEDIUM << 13) | ( CSS_COLUMN_RULE_WIDTH_MEDIUM << 5) | CSS_CURSOR_AUTO, (CSS_COLUMN_WIDTH_AUTO << 25) | (CSS_COLUMN_GAP_NORMAL << 18) | (CSS_LETTER_SPACING_NORMAL << 11) | (CSS_WORD_SPACING_NORMAL << 4) | CSS_BREAK_BEFORE_AUTO, (CSS_CLIP_AUTO << 6) | (CSS_COLUMN_RULE_STYLE_NONE << 2) | CSS_COLUMN_RULE_COLOR_CURRENT_COLOR, (CSS_BREAK_AFTER_AUTO << 28) | (CSS_BREAK_INSIDE_AUTO << 24) | (CSS_CONTENT_NORMAL << 22) | ( CSS_WRITING_MODE_HORIZONTAL_TB << 20) | (CSS_COLUMN_FILL_BALANCE << 18) | ( CSS_COLUMN_SPAN_NONE << 16) | ( CSS_COLUMN_COUNT_AUTO << 14) | ( CSS_OUTLINE_COLOR_INVERT << 12) | ( CSS_COUNTER_INCREMENT_NONE << 11) | ( CSS_COUNTER_RESET_NONE << 10) }, .border_spacing_a = 0, .border_spacing_b = 0, .clip_a = 0, .clip_b = 0, .clip_c = 0, .clip_d = 0, .column_count = 0, .column_gap = 0, .column_rule_color = 0, .column_rule_width = 0, .column_width = 0, .letter_spacing = 0, .outline_color = 0, .outline_width = 0, .word_spacing = 0 }, .content = NULL, .counter_increment = NULL, .counter_reset = NULL, .cursor = NULL, .next = NULL, .count = 0, .bin = UINT32_MAX }; #define ENSURE_UNCOMMON do { \ if (style->i.uncommon == NULL) { \ style->i.uncommon = malloc(sizeof( \ css_computed_uncommon)); \ if (style->i.uncommon == NULL) \ return CSS_NOMEM; \ \ memcpy(style->i.uncommon, &default_uncommon, sizeof( \ css_computed_uncommon)); \ } \ } while(0) \ #define BORDER_SPACING_INDEX 0 #define BORDER_SPACING_SHIFT 21 #define BORDER_SPACING_MASK 0xffe00000 static inline css_error set_border_spacing(css_computed_style *style, uint8_t type, css_fixed length_a, css_unit unit_a, css_fixed length_b, css_unit unit_b) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[BORDER_SPACING_INDEX]; /* 11bits: aaaaabbbbbt : unit_a | unit_b | type */ *bits = (*bits & ~BORDER_SPACING_MASK) | ((((uint32_t)type & 0x1) | ( unit_b << 1) | (unit_a << 6)) << BORDER_SPACING_SHIFT); style->i.uncommon->i.border_spacing_a = length_a; style->i.uncommon->i.border_spacing_b = length_b; return CSS_OK; } #undef BORDER_SPACING_INDEX #undef BORDER_SPACING_SHIFT #undef BORDER_SPACING_MASK #define BREAK_AFTER_INDEX 3 #define BREAK_AFTER_SHIFT 28 #define BREAK_AFTER_MASK 0xf0000000 static inline css_error set_break_after(css_computed_style *style, uint8_t type) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[BREAK_AFTER_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~BREAK_AFTER_MASK) | (((uint32_t)type & 0xf) << BREAK_AFTER_SHIFT); return CSS_OK; } #undef BREAK_AFTER_INDEX #undef BREAK_AFTER_SHIFT #undef BREAK_AFTER_MASK #define BREAK_BEFORE_INDEX 1 #define BREAK_BEFORE_SHIFT 0 #define BREAK_BEFORE_MASK 0xf static inline css_error set_break_before(css_computed_style *style, uint8_t type) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[BREAK_BEFORE_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~BREAK_BEFORE_MASK) | (((uint32_t)type & 0xf) << BREAK_BEFORE_SHIFT); return CSS_OK; } #undef BREAK_BEFORE_INDEX #undef BREAK_BEFORE_SHIFT #undef BREAK_BEFORE_MASK #define BREAK_INSIDE_INDEX 3 #define BREAK_INSIDE_SHIFT 24 #define BREAK_INSIDE_MASK 0xf000000 static inline css_error set_break_inside(css_computed_style *style, uint8_t type) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[BREAK_INSIDE_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~BREAK_INSIDE_MASK) | (((uint32_t)type & 0xf) << BREAK_INSIDE_SHIFT); return CSS_OK; } #undef BREAK_INSIDE_INDEX #undef BREAK_INSIDE_SHIFT #undef BREAK_INSIDE_MASK #define CLIP_INDEX 2 #define CLIP_SHIFT 6 #define CLIP_MASK 0xffffffc0 static inline css_error set_clip( css_computed_style *style, uint8_t type, css_computed_clip_rect *rect) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[CLIP_INDEX]; /* 26bits: tt tttr rrrr bbbb blll llTR BLyy: units: top | right | bottom | left opcodes: top | right | bottom | left | type */ *bits = (*bits & ~CLIP_MASK) | ((type & 0x3) << CLIP_SHIFT); if (type == CSS_CLIP_RECT) { *bits |= (((rect->top_auto ? 0x20 : 0) | (rect->right_auto ? 0x10 : 0) | (rect->bottom_auto ? 0x8 : 0) | (rect->left_auto ? 0x4 : 0)) << CLIP_SHIFT); *bits |= (((rect->tunit << 5) | rect->runit) << (CLIP_SHIFT + 16)); *bits |= (((rect->bunit << 5) | rect->lunit) << (CLIP_SHIFT + 6)); style->i.uncommon->i.clip_a = rect->top; style->i.uncommon->i.clip_b = rect->right; style->i.uncommon->i.clip_c = rect->bottom; style->i.uncommon->i.clip_d = rect->left; } return CSS_OK; } #undef CLIP_INDEX #undef CLIP_SHIFT #undef CLIP_MASK #define COLUMN_COUNT_INDEX 3 #define COLUMN_COUNT_SHIFT 14 #define COLUMN_COUNT_MASK 0xc000 static inline css_error set_column_count(css_computed_style *style, uint8_t type, int32_t integer) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[COLUMN_COUNT_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~COLUMN_COUNT_MASK) | (((uint32_t)type & 0x3) << COLUMN_COUNT_SHIFT); style->i.uncommon->i.column_count = integer; return CSS_OK; } #undef COLUMN_COUNT_INDEX #undef COLUMN_COUNT_SHIFT #undef COLUMN_COUNT_MASK #define COLUMN_FILL_INDEX 3 #define COLUMN_FILL_SHIFT 18 #define COLUMN_FILL_MASK 0xc0000 static inline css_error set_column_fill(css_computed_style *style, uint8_t type) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[COLUMN_FILL_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~COLUMN_FILL_MASK) | (((uint32_t)type & 0x3) << COLUMN_FILL_SHIFT); return CSS_OK; } #undef COLUMN_FILL_INDEX #undef COLUMN_FILL_SHIFT #undef COLUMN_FILL_MASK #define COLUMN_GAP_INDEX 1 #define COLUMN_GAP_SHIFT 18 #define COLUMN_GAP_MASK 0x1fc0000 static inline css_error set_column_gap(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[COLUMN_GAP_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~COLUMN_GAP_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << COLUMN_GAP_SHIFT); style->i.uncommon->i.column_gap = length; return CSS_OK; } #undef COLUMN_GAP_INDEX #undef COLUMN_GAP_SHIFT #undef COLUMN_GAP_MASK #define COLUMN_RULE_COLOR_INDEX 2 #define COLUMN_RULE_COLOR_SHIFT 0 #define COLUMN_RULE_COLOR_MASK 0x3 static inline css_error set_column_rule_color(css_computed_style *style, uint8_t type, css_color color) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[COLUMN_RULE_COLOR_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~COLUMN_RULE_COLOR_MASK) | (((uint32_t)type & 0x3) << COLUMN_RULE_COLOR_SHIFT); style->i.uncommon->i.column_rule_color = color; return CSS_OK; } #undef COLUMN_RULE_COLOR_INDEX #undef COLUMN_RULE_COLOR_SHIFT #undef COLUMN_RULE_COLOR_MASK #define COLUMN_RULE_STYLE_INDEX 2 #define COLUMN_RULE_STYLE_SHIFT 2 #define COLUMN_RULE_STYLE_MASK 0x3c static inline css_error set_column_rule_style(css_computed_style *style, uint8_t type) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[COLUMN_RULE_STYLE_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~COLUMN_RULE_STYLE_MASK) | (((uint32_t)type & 0xf) << COLUMN_RULE_STYLE_SHIFT); return CSS_OK; } #undef COLUMN_RULE_STYLE_INDEX #undef COLUMN_RULE_STYLE_SHIFT #undef COLUMN_RULE_STYLE_MASK #define COLUMN_RULE_WIDTH_INDEX 0 #define COLUMN_RULE_WIDTH_SHIFT 5 #define COLUMN_RULE_WIDTH_MASK 0x1fe0 static inline css_error set_column_rule_width(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[COLUMN_RULE_WIDTH_INDEX]; /* 8bits: uuuuuttt : unit | type */ *bits = (*bits & ~COLUMN_RULE_WIDTH_MASK) | ((((uint32_t)type & 0x7) | ( unit << 3)) << COLUMN_RULE_WIDTH_SHIFT); style->i.uncommon->i.column_rule_width = length; return CSS_OK; } #undef COLUMN_RULE_WIDTH_INDEX #undef COLUMN_RULE_WIDTH_SHIFT #undef COLUMN_RULE_WIDTH_MASK #define COLUMN_SPAN_INDEX 3 #define COLUMN_SPAN_SHIFT 16 #define COLUMN_SPAN_MASK 0x30000 static inline css_error set_column_span(css_computed_style *style, uint8_t type) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[COLUMN_SPAN_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~COLUMN_SPAN_MASK) | (((uint32_t)type & 0x3) << COLUMN_SPAN_SHIFT); return CSS_OK; } #undef COLUMN_SPAN_INDEX #undef COLUMN_SPAN_SHIFT #undef COLUMN_SPAN_MASK #define COLUMN_WIDTH_INDEX 1 #define COLUMN_WIDTH_SHIFT 25 #define COLUMN_WIDTH_MASK 0xfe000000 static inline css_error set_column_width(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[COLUMN_WIDTH_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~COLUMN_WIDTH_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << COLUMN_WIDTH_SHIFT); style->i.uncommon->i.column_width = length; return CSS_OK; } #undef COLUMN_WIDTH_INDEX #undef COLUMN_WIDTH_SHIFT #undef COLUMN_WIDTH_MASK #define CONTENT_INDEX 3 #define CONTENT_SHIFT 22 #define CONTENT_MASK 0xc00000 static inline css_error set_content( css_computed_style *style, uint8_t type, css_computed_content_item *content) { uint32_t *bits; css_computed_content_item *oldcontent; css_computed_content_item *c; ENSURE_UNCOMMON; /* 2bits: type */ bits = &style->i.uncommon->i.bits[CONTENT_INDEX]; oldcontent = style->i.uncommon->content; *bits = (*bits & ~CONTENT_MASK) | ((type & 0x3) << CONTENT_SHIFT); for (c = content; c != NULL && c->type != CSS_COMPUTED_CONTENT_NONE; c++) { switch (c->type) { case CSS_COMPUTED_CONTENT_STRING: c->data.string = lwc_string_ref(c->data.string); break; case CSS_COMPUTED_CONTENT_URI: c->data.uri = lwc_string_ref(c->data.uri); break; case CSS_COMPUTED_CONTENT_ATTR: c->data.attr = lwc_string_ref(c->data.attr); break; case CSS_COMPUTED_CONTENT_COUNTER: c->data.counter.name = lwc_string_ref(c->data.counter.name); break; case CSS_COMPUTED_CONTENT_COUNTERS: c->data.counters.name = lwc_string_ref(c->data.counters.name); c->data.counters.sep = lwc_string_ref(c->data.counters.sep); break; default: break; } } style->i.uncommon->content = content; /* Free existing array */ if (oldcontent != NULL) { for (c = oldcontent; c->type != CSS_COMPUTED_CONTENT_NONE; c++) { switch (c->type) { case CSS_COMPUTED_CONTENT_STRING: lwc_string_unref(c->data.string); break; case CSS_COMPUTED_CONTENT_URI: lwc_string_unref(c->data.uri); break; case CSS_COMPUTED_CONTENT_ATTR: lwc_string_unref(c->data.attr); break; case CSS_COMPUTED_CONTENT_COUNTER: lwc_string_unref(c->data.counter.name); break; case CSS_COMPUTED_CONTENT_COUNTERS: lwc_string_unref(c->data.counters.name); lwc_string_unref(c->data.counters.sep); break; default: break; } } if (oldcontent != content) free(oldcontent); } return CSS_OK; } #undef CONTENT_INDEX #undef CONTENT_SHIFT #undef CONTENT_MASK #define COUNTER_INCREMENT_INDEX 3 #define COUNTER_INCREMENT_SHIFT 11 #define COUNTER_INCREMENT_MASK 0x800 static inline css_error set_counter_increment(css_computed_style *style, uint8_t type, css_computed_counter *counter_arr) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[COUNTER_INCREMENT_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~COUNTER_INCREMENT_MASK) | (((uint32_t)type & 0x1) << COUNTER_INCREMENT_SHIFT); css_computed_counter *old_counter_arr = style->i.uncommon->counter_increment; css_computed_counter *c; for (c = counter_arr; c != NULL && c->name != NULL; c++) c->name = lwc_string_ref(c->name); style->i.uncommon->counter_increment = counter_arr; /* Free existing array */ if (old_counter_arr != NULL) { for (c = old_counter_arr; c->name != NULL; c++) lwc_string_unref(c->name); if (old_counter_arr != counter_arr) free(old_counter_arr); } return CSS_OK; } #undef COUNTER_INCREMENT_INDEX #undef COUNTER_INCREMENT_SHIFT #undef COUNTER_INCREMENT_MASK #define COUNTER_RESET_INDEX 3 #define COUNTER_RESET_SHIFT 10 #define COUNTER_RESET_MASK 0x400 static inline css_error set_counter_reset(css_computed_style *style, uint8_t type, css_computed_counter *counter_arr) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[COUNTER_RESET_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~COUNTER_RESET_MASK) | (((uint32_t)type & 0x1) << COUNTER_RESET_SHIFT); css_computed_counter *old_counter_arr = style->i.uncommon->counter_reset; css_computed_counter *c; for (c = counter_arr; c != NULL && c->name != NULL; c++) c->name = lwc_string_ref(c->name); style->i.uncommon->counter_reset = counter_arr; /* Free existing array */ if (old_counter_arr != NULL) { for (c = old_counter_arr; c->name != NULL; c++) lwc_string_unref(c->name); if (old_counter_arr != counter_arr) free(old_counter_arr); } return CSS_OK; } #undef COUNTER_RESET_INDEX #undef COUNTER_RESET_SHIFT #undef COUNTER_RESET_MASK #define CURSOR_INDEX 0 #define CURSOR_SHIFT 0 #define CURSOR_MASK 0x1f static inline css_error set_cursor(css_computed_style *style, uint8_t type, lwc_string **string_arr) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[CURSOR_INDEX]; /* 5bits: ttttt : type */ *bits = (*bits & ~CURSOR_MASK) | (((uint32_t)type & 0x1f) << CURSOR_SHIFT); lwc_string **old_string_arr = style->i.uncommon->cursor; lwc_string **s; for (s = string_arr; s != NULL && *s != NULL; s++) *s = lwc_string_ref(*s); style->i.uncommon->cursor = string_arr; /* Free existing array */ if (old_string_arr != NULL) { for (s = old_string_arr; *s != NULL; s++) lwc_string_unref(*s); if (old_string_arr != string_arr) free(old_string_arr); } return CSS_OK; } #undef CURSOR_INDEX #undef CURSOR_SHIFT #undef CURSOR_MASK #define LETTER_SPACING_INDEX 1 #define LETTER_SPACING_SHIFT 11 #define LETTER_SPACING_MASK 0x3f800 static inline css_error set_letter_spacing(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[LETTER_SPACING_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~LETTER_SPACING_MASK) | ((((uint32_t)type & 0x3) | ( unit << 2)) << LETTER_SPACING_SHIFT); style->i.uncommon->i.letter_spacing = length; return CSS_OK; } #undef LETTER_SPACING_INDEX #undef LETTER_SPACING_SHIFT #undef LETTER_SPACING_MASK #define OUTLINE_COLOR_INDEX 3 #define OUTLINE_COLOR_SHIFT 12 #define OUTLINE_COLOR_MASK 0x3000 static inline css_error set_outline_color(css_computed_style *style, uint8_t type, css_color color) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[OUTLINE_COLOR_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~OUTLINE_COLOR_MASK) | (((uint32_t)type & 0x3) << OUTLINE_COLOR_SHIFT); style->i.uncommon->i.outline_color = color; return CSS_OK; } #undef OUTLINE_COLOR_INDEX #undef OUTLINE_COLOR_SHIFT #undef OUTLINE_COLOR_MASK #define OUTLINE_WIDTH_INDEX 0 #define OUTLINE_WIDTH_SHIFT 13 #define OUTLINE_WIDTH_MASK 0x1fe000 static inline css_error set_outline_width(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[OUTLINE_WIDTH_INDEX]; /* 8bits: uuuuuttt : unit | type */ *bits = (*bits & ~OUTLINE_WIDTH_MASK) | ((((uint32_t)type & 0x7) | ( unit << 3)) << OUTLINE_WIDTH_SHIFT); style->i.uncommon->i.outline_width = length; return CSS_OK; } #undef OUTLINE_WIDTH_INDEX #undef OUTLINE_WIDTH_SHIFT #undef OUTLINE_WIDTH_MASK #define WORD_SPACING_INDEX 1 #define WORD_SPACING_SHIFT 4 #define WORD_SPACING_MASK 0x7f0 static inline css_error set_word_spacing(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[WORD_SPACING_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~WORD_SPACING_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << WORD_SPACING_SHIFT); style->i.uncommon->i.word_spacing = length; return CSS_OK; } #undef WORD_SPACING_INDEX #undef WORD_SPACING_SHIFT #undef WORD_SPACING_MASK #define WRITING_MODE_INDEX 3 #define WRITING_MODE_SHIFT 20 #define WRITING_MODE_MASK 0x300000 static inline css_error set_writing_mode(css_computed_style *style, uint8_t type) { uint32_t *bits; ENSURE_UNCOMMON; bits = &style->i.uncommon->i.bits[WRITING_MODE_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~WRITING_MODE_MASK) | (((uint32_t)type & 0x3) << WRITING_MODE_SHIFT); return CSS_OK; } #undef WRITING_MODE_INDEX #undef WRITING_MODE_SHIFT #undef WRITING_MODE_MASK static const css_computed_page default_page = { .bits = { (CSS_PAGE_BREAK_BEFORE_AUTO << 29) | (CSS_PAGE_BREAK_AFTER_AUTO << 26) | (CSS_PAGE_BREAK_INSIDE_AUTO << 24) | ( CSS_WIDOWS_SET << 23) | (CSS_ORPHANS_SET << 22) }, .orphans = 2, .widows = 2 }; #define ENSURE_PAGE do { \ if (style->page == NULL) { \ style->page = malloc(sizeof(css_computed_page)); \ if (style->page == NULL) \ return CSS_NOMEM; \ \ memcpy(style->page, &default_page, sizeof( \ css_computed_page)); \ } \ } while(0) \ #define ORPHANS_INDEX 0 #define ORPHANS_SHIFT 22 #define ORPHANS_MASK 0x400000 static inline css_error set_orphans(css_computed_style *style, uint8_t type, int32_t integer) { uint32_t *bits; ENSURE_PAGE; bits = &style->page->bits[ORPHANS_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~ORPHANS_MASK) | (((uint32_t)type & 0x1) << ORPHANS_SHIFT); style->page->orphans = integer; return CSS_OK; } #undef ORPHANS_INDEX #undef ORPHANS_SHIFT #undef ORPHANS_MASK #define PAGE_BREAK_AFTER_INDEX 0 #define PAGE_BREAK_AFTER_SHIFT 26 #define PAGE_BREAK_AFTER_MASK 0x1c000000 static inline css_error set_page_break_after(css_computed_style *style, uint8_t type) { uint32_t *bits; ENSURE_PAGE; bits = &style->page->bits[PAGE_BREAK_AFTER_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~PAGE_BREAK_AFTER_MASK) | (((uint32_t)type & 0x7) << PAGE_BREAK_AFTER_SHIFT); return CSS_OK; } #undef PAGE_BREAK_AFTER_INDEX #undef PAGE_BREAK_AFTER_SHIFT #undef PAGE_BREAK_AFTER_MASK #define PAGE_BREAK_BEFORE_INDEX 0 #define PAGE_BREAK_BEFORE_SHIFT 29 #define PAGE_BREAK_BEFORE_MASK 0xe0000000 static inline css_error set_page_break_before(css_computed_style *style, uint8_t type) { uint32_t *bits; ENSURE_PAGE; bits = &style->page->bits[PAGE_BREAK_BEFORE_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~PAGE_BREAK_BEFORE_MASK) | (((uint32_t)type & 0x7) << PAGE_BREAK_BEFORE_SHIFT); return CSS_OK; } #undef PAGE_BREAK_BEFORE_INDEX #undef PAGE_BREAK_BEFORE_SHIFT #undef PAGE_BREAK_BEFORE_MASK #define PAGE_BREAK_INSIDE_INDEX 0 #define PAGE_BREAK_INSIDE_SHIFT 24 #define PAGE_BREAK_INSIDE_MASK 0x3000000 static inline css_error set_page_break_inside(css_computed_style *style, uint8_t type) { uint32_t *bits; ENSURE_PAGE; bits = &style->page->bits[PAGE_BREAK_INSIDE_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~PAGE_BREAK_INSIDE_MASK) | (((uint32_t)type & 0x3) << PAGE_BREAK_INSIDE_SHIFT); return CSS_OK; } #undef PAGE_BREAK_INSIDE_INDEX #undef PAGE_BREAK_INSIDE_SHIFT #undef PAGE_BREAK_INSIDE_MASK #define WIDOWS_INDEX 0 #define WIDOWS_SHIFT 23 #define WIDOWS_MASK 0x800000 static inline css_error set_widows(css_computed_style *style, uint8_t type, int32_t integer) { uint32_t *bits; ENSURE_PAGE; bits = &style->page->bits[WIDOWS_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~WIDOWS_MASK) | (((uint32_t)type & 0x1) << WIDOWS_SHIFT); style->page->widows = integer; return CSS_OK; } #undef WIDOWS_INDEX #undef WIDOWS_SHIFT #undef WIDOWS_MASK #define ALIGN_CONTENT_INDEX 8 #define ALIGN_CONTENT_SHIFT 14 #define ALIGN_CONTENT_MASK 0x1c000 static inline css_error set_align_content(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[ALIGN_CONTENT_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~ALIGN_CONTENT_MASK) | (((uint32_t)type & 0x7) << ALIGN_CONTENT_SHIFT); return CSS_OK; } #undef ALIGN_CONTENT_INDEX #undef ALIGN_CONTENT_SHIFT #undef ALIGN_CONTENT_MASK #define ALIGN_ITEMS_INDEX 8 #define ALIGN_ITEMS_SHIFT 23 #define ALIGN_ITEMS_MASK 0x3800000 static inline css_error set_align_items(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[ALIGN_ITEMS_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~ALIGN_ITEMS_MASK) | (((uint32_t)type & 0x7) << ALIGN_ITEMS_SHIFT); return CSS_OK; } #undef ALIGN_ITEMS_INDEX #undef ALIGN_ITEMS_SHIFT #undef ALIGN_ITEMS_MASK #define ALIGN_SELF_INDEX 8 #define ALIGN_SELF_SHIFT 20 #define ALIGN_SELF_MASK 0x700000 static inline css_error set_align_self(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[ALIGN_SELF_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~ALIGN_SELF_MASK) | (((uint32_t)type & 0x7) << ALIGN_SELF_SHIFT); return CSS_OK; } #undef ALIGN_SELF_INDEX #undef ALIGN_SELF_SHIFT #undef ALIGN_SELF_MASK #define BACKGROUND_ATTACHMENT_INDEX 9 #define BACKGROUND_ATTACHMENT_SHIFT 6 #define BACKGROUND_ATTACHMENT_MASK 0xc0 static inline css_error set_background_attachment(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[BACKGROUND_ATTACHMENT_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~BACKGROUND_ATTACHMENT_MASK) | (((uint32_t)type & 0x3) << BACKGROUND_ATTACHMENT_SHIFT); return CSS_OK; } #undef BACKGROUND_ATTACHMENT_INDEX #undef BACKGROUND_ATTACHMENT_SHIFT #undef BACKGROUND_ATTACHMENT_MASK #define BACKGROUND_COLOR_INDEX 9 #define BACKGROUND_COLOR_SHIFT 14 #define BACKGROUND_COLOR_MASK 0xc000 static inline css_error set_background_color(css_computed_style *style, uint8_t type, css_color color) { uint32_t *bits; bits = &style->i.bits[BACKGROUND_COLOR_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~BACKGROUND_COLOR_MASK) | (((uint32_t)type & 0x3) << BACKGROUND_COLOR_SHIFT); style->i.background_color = color; return CSS_OK; } #undef BACKGROUND_COLOR_INDEX #undef BACKGROUND_COLOR_SHIFT #undef BACKGROUND_COLOR_MASK #define BACKGROUND_IMAGE_INDEX 10 #define BACKGROUND_IMAGE_SHIFT 25 #define BACKGROUND_IMAGE_MASK 0x2000000 static inline css_error set_background_image(css_computed_style *style, uint8_t type, lwc_string *string) { uint32_t *bits; bits = &style->i.bits[BACKGROUND_IMAGE_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~BACKGROUND_IMAGE_MASK) | (((uint32_t)type & 0x1) << BACKGROUND_IMAGE_SHIFT); lwc_string *old_string = style->i.background_image; if (string != NULL) { style->i.background_image = lwc_string_ref(string); } else { style->i.background_image = NULL; } if (old_string != NULL) lwc_string_unref(old_string); return CSS_OK; } #undef BACKGROUND_IMAGE_INDEX #undef BACKGROUND_IMAGE_SHIFT #undef BACKGROUND_IMAGE_MASK #define BACKGROUND_POSITION_INDEX 5 #define BACKGROUND_POSITION_SHIFT 21 #define BACKGROUND_POSITION_MASK 0xffe00000 static inline css_error set_background_position(css_computed_style *style, uint8_t type, css_fixed length_a, css_unit unit_a, css_fixed length_b, css_unit unit_b) { uint32_t *bits; bits = &style->i.bits[BACKGROUND_POSITION_INDEX]; /* 11bits: aaaaabbbbbt : unit_a | unit_b | type */ *bits = (*bits & ~BACKGROUND_POSITION_MASK) | ((((uint32_t)type & 0x1) | (unit_b << 1) | (unit_a << 6)) << BACKGROUND_POSITION_SHIFT); style->i.background_position_a = length_a; style->i.background_position_b = length_b; return CSS_OK; } #undef BACKGROUND_POSITION_INDEX #undef BACKGROUND_POSITION_SHIFT #undef BACKGROUND_POSITION_MASK #define BACKGROUND_REPEAT_INDEX 8 #define BACKGROUND_REPEAT_SHIFT 17 #define BACKGROUND_REPEAT_MASK 0xe0000 static inline css_error set_background_repeat(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[BACKGROUND_REPEAT_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~BACKGROUND_REPEAT_MASK) | (((uint32_t)type & 0x7) << BACKGROUND_REPEAT_SHIFT); return CSS_OK; } #undef BACKGROUND_REPEAT_INDEX #undef BACKGROUND_REPEAT_SHIFT #undef BACKGROUND_REPEAT_MASK #define BORDER_BOTTOM_COLOR_INDEX 9 #define BORDER_BOTTOM_COLOR_SHIFT 4 #define BORDER_BOTTOM_COLOR_MASK 0x30 static inline css_error set_border_bottom_color(css_computed_style *style, uint8_t type, css_color color) { uint32_t *bits; bits = &style->i.bits[BORDER_BOTTOM_COLOR_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~BORDER_BOTTOM_COLOR_MASK) | (((uint32_t)type & 0x3) << BORDER_BOTTOM_COLOR_SHIFT); style->i.border_bottom_color = color; return CSS_OK; } #undef BORDER_BOTTOM_COLOR_INDEX #undef BORDER_BOTTOM_COLOR_SHIFT #undef BORDER_BOTTOM_COLOR_MASK #define BORDER_BOTTOM_STYLE_INDEX 6 #define BORDER_BOTTOM_STYLE_SHIFT 6 #define BORDER_BOTTOM_STYLE_MASK 0x3c0 static inline css_error set_border_bottom_style(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[BORDER_BOTTOM_STYLE_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~BORDER_BOTTOM_STYLE_MASK) | (((uint32_t)type & 0xf) << BORDER_BOTTOM_STYLE_SHIFT); return CSS_OK; } #undef BORDER_BOTTOM_STYLE_INDEX #undef BORDER_BOTTOM_STYLE_SHIFT #undef BORDER_BOTTOM_STYLE_MASK #define BORDER_BOTTOM_WIDTH_INDEX 0 #define BORDER_BOTTOM_WIDTH_SHIFT 16 #define BORDER_BOTTOM_WIDTH_MASK 0xff0000 static inline css_error set_border_bottom_width(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[BORDER_BOTTOM_WIDTH_INDEX]; /* 8bits: uuuuuttt : unit | type */ *bits = (*bits & ~BORDER_BOTTOM_WIDTH_MASK) | ((((uint32_t)type & 0x7) | (unit << 3)) << BORDER_BOTTOM_WIDTH_SHIFT); style->i.border_bottom_width = length; return CSS_OK; } #undef BORDER_BOTTOM_WIDTH_INDEX #undef BORDER_BOTTOM_WIDTH_SHIFT #undef BORDER_BOTTOM_WIDTH_MASK #define BORDER_COLLAPSE_INDEX 9 #define BORDER_COLLAPSE_SHIFT 26 #define BORDER_COLLAPSE_MASK 0xc000000 static inline css_error set_border_collapse(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[BORDER_COLLAPSE_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~BORDER_COLLAPSE_MASK) | (((uint32_t)type & 0x3) << BORDER_COLLAPSE_SHIFT); return CSS_OK; } #undef BORDER_COLLAPSE_INDEX #undef BORDER_COLLAPSE_SHIFT #undef BORDER_COLLAPSE_MASK #define BORDER_LEFT_COLOR_INDEX 9 #define BORDER_LEFT_COLOR_SHIFT 24 #define BORDER_LEFT_COLOR_MASK 0x3000000 static inline css_error set_border_left_color(css_computed_style *style, uint8_t type, css_color color) { uint32_t *bits; bits = &style->i.bits[BORDER_LEFT_COLOR_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~BORDER_LEFT_COLOR_MASK) | (((uint32_t)type & 0x3) << BORDER_LEFT_COLOR_SHIFT); style->i.border_left_color = color; return CSS_OK; } #undef BORDER_LEFT_COLOR_INDEX #undef BORDER_LEFT_COLOR_SHIFT #undef BORDER_LEFT_COLOR_MASK #define BORDER_LEFT_STYLE_INDEX 4 #define BORDER_LEFT_STYLE_SHIFT 0 #define BORDER_LEFT_STYLE_MASK 0xf static inline css_error set_border_left_style(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[BORDER_LEFT_STYLE_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~BORDER_LEFT_STYLE_MASK) | (((uint32_t)type & 0xf) << BORDER_LEFT_STYLE_SHIFT); return CSS_OK; } #undef BORDER_LEFT_STYLE_INDEX #undef BORDER_LEFT_STYLE_SHIFT #undef BORDER_LEFT_STYLE_MASK #define BORDER_LEFT_WIDTH_INDEX 0 #define BORDER_LEFT_WIDTH_SHIFT 0 #define BORDER_LEFT_WIDTH_MASK 0xff static inline css_error set_border_left_width(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[BORDER_LEFT_WIDTH_INDEX]; /* 8bits: uuuuuttt : unit | type */ *bits = (*bits & ~BORDER_LEFT_WIDTH_MASK) | ((((uint32_t)type & 0x7) | ( unit << 3)) << BORDER_LEFT_WIDTH_SHIFT); style->i.border_left_width = length; return CSS_OK; } #undef BORDER_LEFT_WIDTH_INDEX #undef BORDER_LEFT_WIDTH_SHIFT #undef BORDER_LEFT_WIDTH_MASK #define BORDER_RIGHT_COLOR_INDEX 9 #define BORDER_RIGHT_COLOR_SHIFT 30 #define BORDER_RIGHT_COLOR_MASK 0xc0000000 static inline css_error set_border_right_color(css_computed_style *style, uint8_t type, css_color color) { uint32_t *bits; bits = &style->i.bits[BORDER_RIGHT_COLOR_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~BORDER_RIGHT_COLOR_MASK) | (((uint32_t)type & 0x3) << BORDER_RIGHT_COLOR_SHIFT); style->i.border_right_color = color; return CSS_OK; } #undef BORDER_RIGHT_COLOR_INDEX #undef BORDER_RIGHT_COLOR_SHIFT #undef BORDER_RIGHT_COLOR_MASK #define BORDER_RIGHT_STYLE_INDEX 6 #define BORDER_RIGHT_STYLE_SHIFT 14 #define BORDER_RIGHT_STYLE_MASK 0x3c000 static inline css_error set_border_right_style(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[BORDER_RIGHT_STYLE_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~BORDER_RIGHT_STYLE_MASK) | (((uint32_t)type & 0xf) << BORDER_RIGHT_STYLE_SHIFT); return CSS_OK; } #undef BORDER_RIGHT_STYLE_INDEX #undef BORDER_RIGHT_STYLE_SHIFT #undef BORDER_RIGHT_STYLE_MASK #define BORDER_RIGHT_WIDTH_INDEX 0 #define BORDER_RIGHT_WIDTH_SHIFT 8 #define BORDER_RIGHT_WIDTH_MASK 0xff00 static inline css_error set_border_right_width(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[BORDER_RIGHT_WIDTH_INDEX]; /* 8bits: uuuuuttt : unit | type */ *bits = (*bits & ~BORDER_RIGHT_WIDTH_MASK) | ((((uint32_t)type & 0x7) | (unit << 3)) << BORDER_RIGHT_WIDTH_SHIFT); style->i.border_right_width = length; return CSS_OK; } #undef BORDER_RIGHT_WIDTH_INDEX #undef BORDER_RIGHT_WIDTH_SHIFT #undef BORDER_RIGHT_WIDTH_MASK #define BORDER_TOP_COLOR_INDEX 8 #define BORDER_TOP_COLOR_SHIFT 0 #define BORDER_TOP_COLOR_MASK 0x3 static inline css_error set_border_top_color(css_computed_style *style, uint8_t type, css_color color) { uint32_t *bits; bits = &style->i.bits[BORDER_TOP_COLOR_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~BORDER_TOP_COLOR_MASK) | (((uint32_t)type & 0x3) << BORDER_TOP_COLOR_SHIFT); style->i.border_top_color = color; return CSS_OK; } #undef BORDER_TOP_COLOR_INDEX #undef BORDER_TOP_COLOR_SHIFT #undef BORDER_TOP_COLOR_MASK #define BORDER_TOP_STYLE_INDEX 6 #define BORDER_TOP_STYLE_SHIFT 10 #define BORDER_TOP_STYLE_MASK 0x3c00 static inline css_error set_border_top_style(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[BORDER_TOP_STYLE_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~BORDER_TOP_STYLE_MASK) | (((uint32_t)type & 0xf) << BORDER_TOP_STYLE_SHIFT); return CSS_OK; } #undef BORDER_TOP_STYLE_INDEX #undef BORDER_TOP_STYLE_SHIFT #undef BORDER_TOP_STYLE_MASK #define BORDER_TOP_WIDTH_INDEX 0 #define BORDER_TOP_WIDTH_SHIFT 24 #define BORDER_TOP_WIDTH_MASK 0xff000000 static inline css_error set_border_top_width(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[BORDER_TOP_WIDTH_INDEX]; /* 8bits: uuuuuttt : unit | type */ *bits = (*bits & ~BORDER_TOP_WIDTH_MASK) | ((((uint32_t)type & 0x7) | ( unit << 3)) << BORDER_TOP_WIDTH_SHIFT); style->i.border_top_width = length; return CSS_OK; } #undef BORDER_TOP_WIDTH_INDEX #undef BORDER_TOP_WIDTH_SHIFT #undef BORDER_TOP_WIDTH_MASK #define BOTTOM_INDEX 4 #define BOTTOM_SHIFT 11 #define BOTTOM_MASK 0x3f800 static inline css_error set_bottom(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[BOTTOM_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~BOTTOM_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << BOTTOM_SHIFT); style->i.bottom = length; return CSS_OK; } #undef BOTTOM_INDEX #undef BOTTOM_SHIFT #undef BOTTOM_MASK #define BOX_SIZING_INDEX 9 #define BOX_SIZING_SHIFT 12 #define BOX_SIZING_MASK 0x3000 static inline css_error set_box_sizing(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[BOX_SIZING_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~BOX_SIZING_MASK) | (((uint32_t)type & 0x3) << BOX_SIZING_SHIFT); return CSS_OK; } #undef BOX_SIZING_INDEX #undef BOX_SIZING_SHIFT #undef BOX_SIZING_MASK #define CAPTION_SIDE_INDEX 9 #define CAPTION_SIDE_SHIFT 20 #define CAPTION_SIDE_MASK 0x300000 static inline css_error set_caption_side(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[CAPTION_SIDE_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~CAPTION_SIDE_MASK) | (((uint32_t)type & 0x3) << CAPTION_SIDE_SHIFT); return CSS_OK; } #undef CAPTION_SIDE_INDEX #undef CAPTION_SIDE_SHIFT #undef CAPTION_SIDE_MASK #define CLEAR_INDEX 8 #define CLEAR_SHIFT 2 #define CLEAR_MASK 0x1c static inline css_error set_clear(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[CLEAR_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~CLEAR_MASK) | (((uint32_t)type & 0x7) << CLEAR_SHIFT); return CSS_OK; } #undef CLEAR_INDEX #undef CLEAR_SHIFT #undef CLEAR_MASK #define COLOR_INDEX 10 #define COLOR_SHIFT 24 #define COLOR_MASK 0x1000000 static inline css_error set_color(css_computed_style *style, uint8_t type, css_color color) { uint32_t *bits; bits = &style->i.bits[COLOR_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~COLOR_MASK) | (((uint32_t)type & 0x1) << COLOR_SHIFT); style->i.color = color; return CSS_OK; } #undef COLOR_INDEX #undef COLOR_SHIFT #undef COLOR_MASK #define DIRECTION_INDEX 9 #define DIRECTION_SHIFT 22 #define DIRECTION_MASK 0xc00000 static inline css_error set_direction(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[DIRECTION_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~DIRECTION_MASK) | (((uint32_t)type & 0x3) << DIRECTION_SHIFT); return CSS_OK; } #undef DIRECTION_INDEX #undef DIRECTION_SHIFT #undef DIRECTION_MASK #define DISPLAY_INDEX 6 #define DISPLAY_SHIFT 27 #define DISPLAY_MASK 0xf8000000 static inline css_error set_display(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[DISPLAY_INDEX]; /* 5bits: ttttt : type */ *bits = (*bits & ~DISPLAY_MASK) | (((uint32_t)type & 0x1f) << DISPLAY_SHIFT); return CSS_OK; } #undef DISPLAY_INDEX #undef DISPLAY_SHIFT #undef DISPLAY_MASK #define EMPTY_CELLS_INDEX 9 #define EMPTY_CELLS_SHIFT 18 #define EMPTY_CELLS_MASK 0xc0000 static inline css_error set_empty_cells(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[EMPTY_CELLS_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~EMPTY_CELLS_MASK) | (((uint32_t)type & 0x3) << EMPTY_CELLS_SHIFT); return CSS_OK; } #undef EMPTY_CELLS_INDEX #undef EMPTY_CELLS_SHIFT #undef EMPTY_CELLS_MASK #define FLEX_BASIS_INDEX 2 #define FLEX_BASIS_SHIFT 11 #define FLEX_BASIS_MASK 0x3f800 static inline css_error set_flex_basis(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[FLEX_BASIS_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~FLEX_BASIS_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << FLEX_BASIS_SHIFT); style->i.flex_basis = length; return CSS_OK; } #undef FLEX_BASIS_INDEX #undef FLEX_BASIS_SHIFT #undef FLEX_BASIS_MASK #define FLEX_DIRECTION_INDEX 8 #define FLEX_DIRECTION_SHIFT 11 #define FLEX_DIRECTION_MASK 0x3800 static inline css_error set_flex_direction(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[FLEX_DIRECTION_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~FLEX_DIRECTION_MASK) | (((uint32_t)type & 0x7) << FLEX_DIRECTION_SHIFT); return CSS_OK; } #undef FLEX_DIRECTION_INDEX #undef FLEX_DIRECTION_SHIFT #undef FLEX_DIRECTION_MASK #define FLEX_GROW_INDEX 10 #define FLEX_GROW_SHIFT 21 #define FLEX_GROW_MASK 0x200000 static inline css_error set_flex_grow(css_computed_style *style, uint8_t type, css_fixed fixed) { uint32_t *bits; bits = &style->i.bits[FLEX_GROW_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~FLEX_GROW_MASK) | (((uint32_t)type & 0x1) << FLEX_GROW_SHIFT); style->i.flex_grow = fixed; return CSS_OK; } #undef FLEX_GROW_INDEX #undef FLEX_GROW_SHIFT #undef FLEX_GROW_MASK #define FLEX_SHRINK_INDEX 10 #define FLEX_SHRINK_SHIFT 23 #define FLEX_SHRINK_MASK 0x800000 static inline css_error set_flex_shrink(css_computed_style *style, uint8_t type, css_fixed fixed) { uint32_t *bits; bits = &style->i.bits[FLEX_SHRINK_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~FLEX_SHRINK_MASK) | (((uint32_t)type & 0x1) << FLEX_SHRINK_SHIFT); style->i.flex_shrink = fixed; return CSS_OK; } #undef FLEX_SHRINK_INDEX #undef FLEX_SHRINK_SHIFT #undef FLEX_SHRINK_MASK #define FLEX_WRAP_INDEX 9 #define FLEX_WRAP_SHIFT 28 #define FLEX_WRAP_MASK 0x30000000 static inline css_error set_flex_wrap(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[FLEX_WRAP_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~FLEX_WRAP_MASK) | (((uint32_t)type & 0x3) << FLEX_WRAP_SHIFT); return CSS_OK; } #undef FLEX_WRAP_INDEX #undef FLEX_WRAP_SHIFT #undef FLEX_WRAP_MASK #define FLOAT_INDEX 9 #define FLOAT_SHIFT 8 #define FLOAT_MASK 0x300 static inline css_error set_float(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[FLOAT_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~FLOAT_MASK) | (((uint32_t)type & 0x3) << FLOAT_SHIFT); return CSS_OK; } #undef FLOAT_INDEX #undef FLOAT_SHIFT #undef FLOAT_MASK #define FONT_FAMILY_INDEX 8 #define FONT_FAMILY_SHIFT 26 #define FONT_FAMILY_MASK 0x1c000000 static inline css_error set_font_family(css_computed_style *style, uint8_t type, lwc_string **string_arr) { uint32_t *bits; bits = &style->i.bits[FONT_FAMILY_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~FONT_FAMILY_MASK) | (((uint32_t)type & 0x7) << FONT_FAMILY_SHIFT); lwc_string **old_string_arr = style->font_family; lwc_string **s; for (s = string_arr; s != NULL && *s != NULL; s++) *s = lwc_string_ref(*s); style->font_family = string_arr; /* Free existing array */ if (old_string_arr != NULL) { for (s = old_string_arr; *s != NULL; s++) lwc_string_unref(*s); if (old_string_arr != string_arr) free(old_string_arr); } return CSS_OK; } #undef FONT_FAMILY_INDEX #undef FONT_FAMILY_SHIFT #undef FONT_FAMILY_MASK #define FONT_SIZE_INDEX 5 #define FONT_SIZE_SHIFT 3 #define FONT_SIZE_MASK 0xff8 static inline css_error set_font_size(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[FONT_SIZE_INDEX]; /* 9bits: uuuuutttt : unit | type */ *bits = (*bits & ~FONT_SIZE_MASK) | ((((uint32_t)type & 0xf) | (unit << 4)) << FONT_SIZE_SHIFT); style->i.font_size = length; return CSS_OK; } #undef FONT_SIZE_INDEX #undef FONT_SIZE_SHIFT #undef FONT_SIZE_MASK #define FONT_STYLE_INDEX 7 #define FONT_STYLE_SHIFT 0 #define FONT_STYLE_MASK 0x3 static inline css_error set_font_style(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[FONT_STYLE_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~FONT_STYLE_MASK) | (((uint32_t)type & 0x3) << FONT_STYLE_SHIFT); return CSS_OK; } #undef FONT_STYLE_INDEX #undef FONT_STYLE_SHIFT #undef FONT_STYLE_MASK #define FONT_VARIANT_INDEX 9 #define FONT_VARIANT_SHIFT 10 #define FONT_VARIANT_MASK 0xc00 static inline css_error set_font_variant(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[FONT_VARIANT_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~FONT_VARIANT_MASK) | (((uint32_t)type & 0x3) << FONT_VARIANT_SHIFT); return CSS_OK; } #undef FONT_VARIANT_INDEX #undef FONT_VARIANT_SHIFT #undef FONT_VARIANT_MASK #define FONT_WEIGHT_INDEX 3 #define FONT_WEIGHT_SHIFT 0 #define FONT_WEIGHT_MASK 0xf static inline css_error set_font_weight(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[FONT_WEIGHT_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~FONT_WEIGHT_MASK) | (((uint32_t)type & 0xf) << FONT_WEIGHT_SHIFT); return CSS_OK; } #undef FONT_WEIGHT_INDEX #undef FONT_WEIGHT_SHIFT #undef FONT_WEIGHT_MASK #define HEIGHT_INDEX 4 #define HEIGHT_SHIFT 4 #define HEIGHT_MASK 0x7f0 static inline css_error set_height(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[HEIGHT_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~HEIGHT_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << HEIGHT_SHIFT); style->i.height = length; return CSS_OK; } #undef HEIGHT_INDEX #undef HEIGHT_SHIFT #undef HEIGHT_MASK #define JUSTIFY_CONTENT_INDEX 8 #define JUSTIFY_CONTENT_SHIFT 8 #define JUSTIFY_CONTENT_MASK 0x700 static inline css_error set_justify_content(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[JUSTIFY_CONTENT_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~JUSTIFY_CONTENT_MASK) | (((uint32_t)type & 0x7) << JUSTIFY_CONTENT_SHIFT); return CSS_OK; } #undef JUSTIFY_CONTENT_INDEX #undef JUSTIFY_CONTENT_SHIFT #undef JUSTIFY_CONTENT_MASK #define LEFT_INDEX 4 #define LEFT_SHIFT 25 #define LEFT_MASK 0xfe000000 static inline css_error set_left(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[LEFT_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~LEFT_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << LEFT_SHIFT); style->i.left = length; return CSS_OK; } #undef LEFT_INDEX #undef LEFT_SHIFT #undef LEFT_MASK #define LINE_HEIGHT_INDEX 1 #define LINE_HEIGHT_SHIFT 25 #define LINE_HEIGHT_MASK 0xfe000000 static inline css_error set_line_height(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[LINE_HEIGHT_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~LINE_HEIGHT_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << LINE_HEIGHT_SHIFT); style->i.line_height = length; return CSS_OK; } #undef LINE_HEIGHT_INDEX #undef LINE_HEIGHT_SHIFT #undef LINE_HEIGHT_MASK #define LIST_STYLE_IMAGE_INDEX 10 #define LIST_STYLE_IMAGE_SHIFT 26 #define LIST_STYLE_IMAGE_MASK 0x4000000 static inline css_error set_list_style_image(css_computed_style *style, uint8_t type, lwc_string *string) { uint32_t *bits; bits = &style->i.bits[LIST_STYLE_IMAGE_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~LIST_STYLE_IMAGE_MASK) | (((uint32_t)type & 0x1) << LIST_STYLE_IMAGE_SHIFT); lwc_string *old_string = style->i.list_style_image; if (string != NULL) { style->i.list_style_image = lwc_string_ref(string); } else { style->i.list_style_image = NULL; } if (old_string != NULL) lwc_string_unref(old_string); return CSS_OK; } #undef LIST_STYLE_IMAGE_INDEX #undef LIST_STYLE_IMAGE_SHIFT #undef LIST_STYLE_IMAGE_MASK #define LIST_STYLE_POSITION_INDEX 9 #define LIST_STYLE_POSITION_SHIFT 2 #define LIST_STYLE_POSITION_MASK 0xc static inline css_error set_list_style_position(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[LIST_STYLE_POSITION_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~LIST_STYLE_POSITION_MASK) | (((uint32_t)type & 0x3) << LIST_STYLE_POSITION_SHIFT); return CSS_OK; } #undef LIST_STYLE_POSITION_INDEX #undef LIST_STYLE_POSITION_SHIFT #undef LIST_STYLE_POSITION_MASK #define LIST_STYLE_TYPE_INDEX 6 #define LIST_STYLE_TYPE_SHIFT 18 #define LIST_STYLE_TYPE_MASK 0x3c0000 static inline css_error set_list_style_type(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[LIST_STYLE_TYPE_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~LIST_STYLE_TYPE_MASK) | (((uint32_t)type & 0xf) << LIST_STYLE_TYPE_SHIFT); return CSS_OK; } #undef LIST_STYLE_TYPE_INDEX #undef LIST_STYLE_TYPE_SHIFT #undef LIST_STYLE_TYPE_MASK #define MARGIN_BOTTOM_INDEX 3 #define MARGIN_BOTTOM_SHIFT 4 #define MARGIN_BOTTOM_MASK 0x7f0 static inline css_error set_margin_bottom(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[MARGIN_BOTTOM_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~MARGIN_BOTTOM_MASK) | ((((uint32_t)type & 0x3) | ( unit << 2)) << MARGIN_BOTTOM_SHIFT); style->i.margin_bottom = length; return CSS_OK; } #undef MARGIN_BOTTOM_INDEX #undef MARGIN_BOTTOM_SHIFT #undef MARGIN_BOTTOM_MASK #define MARGIN_LEFT_INDEX 1 #define MARGIN_LEFT_SHIFT 4 #define MARGIN_LEFT_MASK 0x7f0 static inline css_error set_margin_left(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[MARGIN_LEFT_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~MARGIN_LEFT_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << MARGIN_LEFT_SHIFT); style->i.margin_left = length; return CSS_OK; } #undef MARGIN_LEFT_INDEX #undef MARGIN_LEFT_SHIFT #undef MARGIN_LEFT_MASK #define MARGIN_RIGHT_INDEX 2 #define MARGIN_RIGHT_SHIFT 18 #define MARGIN_RIGHT_MASK 0x1fc0000 static inline css_error set_margin_right(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[MARGIN_RIGHT_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~MARGIN_RIGHT_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << MARGIN_RIGHT_SHIFT); style->i.margin_right = length; return CSS_OK; } #undef MARGIN_RIGHT_INDEX #undef MARGIN_RIGHT_SHIFT #undef MARGIN_RIGHT_MASK #define MARGIN_TOP_INDEX 3 #define MARGIN_TOP_SHIFT 18 #define MARGIN_TOP_MASK 0x1fc0000 static inline css_error set_margin_top(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[MARGIN_TOP_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~MARGIN_TOP_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << MARGIN_TOP_SHIFT); style->i.margin_top = length; return CSS_OK; } #undef MARGIN_TOP_INDEX #undef MARGIN_TOP_SHIFT #undef MARGIN_TOP_MASK #define MAX_HEIGHT_INDEX 2 #define MAX_HEIGHT_SHIFT 4 #define MAX_HEIGHT_MASK 0x7f0 static inline css_error set_max_height(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[MAX_HEIGHT_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~MAX_HEIGHT_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << MAX_HEIGHT_SHIFT); style->i.max_height = length; return CSS_OK; } #undef MAX_HEIGHT_INDEX #undef MAX_HEIGHT_SHIFT #undef MAX_HEIGHT_MASK #define MAX_WIDTH_INDEX 2 #define MAX_WIDTH_SHIFT 25 #define MAX_WIDTH_MASK 0xfe000000 static inline css_error set_max_width(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[MAX_WIDTH_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~MAX_WIDTH_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << MAX_WIDTH_SHIFT); style->i.max_width = length; return CSS_OK; } #undef MAX_WIDTH_INDEX #undef MAX_WIDTH_SHIFT #undef MAX_WIDTH_MASK #define MIN_HEIGHT_INDEX 3 #define MIN_HEIGHT_SHIFT 11 #define MIN_HEIGHT_MASK 0x3f800 static inline css_error set_min_height(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[MIN_HEIGHT_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~MIN_HEIGHT_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << MIN_HEIGHT_SHIFT); style->i.min_height = length; return CSS_OK; } #undef MIN_HEIGHT_INDEX #undef MIN_HEIGHT_SHIFT #undef MIN_HEIGHT_MASK #define MIN_WIDTH_INDEX 1 #define MIN_WIDTH_SHIFT 11 #define MIN_WIDTH_MASK 0x3f800 static inline css_error set_min_width(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[MIN_WIDTH_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~MIN_WIDTH_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << MIN_WIDTH_SHIFT); style->i.min_width = length; return CSS_OK; } #undef MIN_WIDTH_INDEX #undef MIN_WIDTH_SHIFT #undef MIN_WIDTH_MASK #define OPACITY_INDEX 10 #define OPACITY_SHIFT 22 #define OPACITY_MASK 0x400000 static inline css_error set_opacity(css_computed_style *style, uint8_t type, css_fixed fixed) { uint32_t *bits; bits = &style->i.bits[OPACITY_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~OPACITY_MASK) | (((uint32_t)type & 0x1) << OPACITY_SHIFT); style->i.opacity = fixed; return CSS_OK; } #undef OPACITY_INDEX #undef OPACITY_SHIFT #undef OPACITY_MASK #define ORDER_INDEX 10 #define ORDER_SHIFT 27 #define ORDER_MASK 0x8000000 static inline css_error set_order(css_computed_style *style, uint8_t type, int32_t integer) { uint32_t *bits; bits = &style->i.bits[ORDER_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~ORDER_MASK) | (((uint32_t)type & 0x1) << ORDER_SHIFT); style->i.order = integer; return CSS_OK; } #undef ORDER_INDEX #undef ORDER_SHIFT #undef ORDER_MASK #define OUTLINE_STYLE_INDEX 1 #define OUTLINE_STYLE_SHIFT 0 #define OUTLINE_STYLE_MASK 0xf static inline css_error set_outline_style(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[OUTLINE_STYLE_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~OUTLINE_STYLE_MASK) | (((uint32_t)type & 0xf) << OUTLINE_STYLE_SHIFT); return CSS_OK; } #undef OUTLINE_STYLE_INDEX #undef OUTLINE_STYLE_SHIFT #undef OUTLINE_STYLE_MASK #define OVERFLOW_X_INDEX 8 #define OVERFLOW_X_SHIFT 5 #define OVERFLOW_X_MASK 0xe0 static inline css_error set_overflow_x(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[OVERFLOW_X_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~OVERFLOW_X_MASK) | (((uint32_t)type & 0x7) << OVERFLOW_X_SHIFT); return CSS_OK; } #undef OVERFLOW_X_INDEX #undef OVERFLOW_X_SHIFT #undef OVERFLOW_X_MASK #define OVERFLOW_Y_INDEX 8 #define OVERFLOW_Y_SHIFT 29 #define OVERFLOW_Y_MASK 0xe0000000 static inline css_error set_overflow_y(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[OVERFLOW_Y_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~OVERFLOW_Y_MASK) | (((uint32_t)type & 0x7) << OVERFLOW_Y_SHIFT); return CSS_OK; } #undef OVERFLOW_Y_INDEX #undef OVERFLOW_Y_SHIFT #undef OVERFLOW_Y_MASK #define PADDING_BOTTOM_INDEX 7 #define PADDING_BOTTOM_SHIFT 20 #define PADDING_BOTTOM_MASK 0x3f00000 static inline css_error set_padding_bottom(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[PADDING_BOTTOM_INDEX]; /* 6bits: uuuuut : unit | type */ *bits = (*bits & ~PADDING_BOTTOM_MASK) | ((((uint32_t)type & 0x1) | ( unit << 1)) << PADDING_BOTTOM_SHIFT); style->i.padding_bottom = length; return CSS_OK; } #undef PADDING_BOTTOM_INDEX #undef PADDING_BOTTOM_SHIFT #undef PADDING_BOTTOM_MASK #define PADDING_LEFT_INDEX 7 #define PADDING_LEFT_SHIFT 26 #define PADDING_LEFT_MASK 0xfc000000 static inline css_error set_padding_left(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[PADDING_LEFT_INDEX]; /* 6bits: uuuuut : unit | type */ *bits = (*bits & ~PADDING_LEFT_MASK) | ((((uint32_t)type & 0x1) | (unit << 1)) << PADDING_LEFT_SHIFT); style->i.padding_left = length; return CSS_OK; } #undef PADDING_LEFT_INDEX #undef PADDING_LEFT_SHIFT #undef PADDING_LEFT_MASK #define PADDING_RIGHT_INDEX 7 #define PADDING_RIGHT_SHIFT 8 #define PADDING_RIGHT_MASK 0x3f00 static inline css_error set_padding_right(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[PADDING_RIGHT_INDEX]; /* 6bits: uuuuut : unit | type */ *bits = (*bits & ~PADDING_RIGHT_MASK) | ((((uint32_t)type & 0x1) | ( unit << 1)) << PADDING_RIGHT_SHIFT); style->i.padding_right = length; return CSS_OK; } #undef PADDING_RIGHT_INDEX #undef PADDING_RIGHT_SHIFT #undef PADDING_RIGHT_MASK #define PADDING_TOP_INDEX 7 #define PADDING_TOP_SHIFT 14 #define PADDING_TOP_MASK 0xfc000 static inline css_error set_padding_top(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[PADDING_TOP_INDEX]; /* 6bits: uuuuut : unit | type */ *bits = (*bits & ~PADDING_TOP_MASK) | ((((uint32_t)type & 0x1) | (unit << 1)) << PADDING_TOP_SHIFT); style->i.padding_top = length; return CSS_OK; } #undef PADDING_TOP_INDEX #undef PADDING_TOP_SHIFT #undef PADDING_TOP_MASK #define POSITION_INDEX 5 #define POSITION_SHIFT 0 #define POSITION_MASK 0x7 static inline css_error set_position(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[POSITION_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~POSITION_MASK) | (((uint32_t)type & 0x7) << POSITION_SHIFT); return CSS_OK; } #undef POSITION_INDEX #undef POSITION_SHIFT #undef POSITION_MASK #define QUOTES_INDEX 10 #define QUOTES_SHIFT 20 #define QUOTES_MASK 0x100000 static inline css_error set_quotes(css_computed_style *style, uint8_t type, lwc_string **string_arr) { uint32_t *bits; bits = &style->i.bits[QUOTES_INDEX]; /* 1bit: t : type */ *bits = (*bits & ~QUOTES_MASK) | (((uint32_t)type & 0x1) << QUOTES_SHIFT); lwc_string **old_string_arr = style->quotes; lwc_string **s; for (s = string_arr; s != NULL && *s != NULL; s++) *s = lwc_string_ref(*s); style->quotes = string_arr; /* Free existing array */ if (old_string_arr != NULL) { for (s = old_string_arr; *s != NULL; s++) lwc_string_unref(*s); if (old_string_arr != string_arr) free(old_string_arr); } return CSS_OK; } #undef QUOTES_INDEX #undef QUOTES_SHIFT #undef QUOTES_MASK #define RIGHT_INDEX 1 #define RIGHT_SHIFT 18 #define RIGHT_MASK 0x1fc0000 static inline css_error set_right(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[RIGHT_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~RIGHT_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << RIGHT_SHIFT); style->i.right = length; return CSS_OK; } #undef RIGHT_INDEX #undef RIGHT_SHIFT #undef RIGHT_MASK #define TABLE_LAYOUT_INDEX 9 #define TABLE_LAYOUT_SHIFT 0 #define TABLE_LAYOUT_MASK 0x3 static inline css_error set_table_layout(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[TABLE_LAYOUT_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~TABLE_LAYOUT_MASK) | (((uint32_t)type & 0x3) << TABLE_LAYOUT_SHIFT); return CSS_OK; } #undef TABLE_LAYOUT_INDEX #undef TABLE_LAYOUT_SHIFT #undef TABLE_LAYOUT_MASK #define TEXT_ALIGN_INDEX 2 #define TEXT_ALIGN_SHIFT 0 #define TEXT_ALIGN_MASK 0xf static inline css_error set_text_align(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[TEXT_ALIGN_INDEX]; /* 4bits: tttt : type */ *bits = (*bits & ~TEXT_ALIGN_MASK) | (((uint32_t)type & 0xf) << TEXT_ALIGN_SHIFT); return CSS_OK; } #undef TEXT_ALIGN_INDEX #undef TEXT_ALIGN_SHIFT #undef TEXT_ALIGN_MASK #define TEXT_DECORATION_INDEX 6 #define TEXT_DECORATION_SHIFT 22 #define TEXT_DECORATION_MASK 0x7c00000 static inline css_error set_text_decoration(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[TEXT_DECORATION_INDEX]; /* 5bits: ttttt : type */ *bits = (*bits & ~TEXT_DECORATION_MASK) | (((uint32_t)type & 0x1f) << TEXT_DECORATION_SHIFT); return CSS_OK; } #undef TEXT_DECORATION_INDEX #undef TEXT_DECORATION_SHIFT #undef TEXT_DECORATION_MASK #define TEXT_INDENT_INDEX 7 #define TEXT_INDENT_SHIFT 2 #define TEXT_INDENT_MASK 0xfc static inline css_error set_text_indent(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[TEXT_INDENT_INDEX]; /* 6bits: uuuuut : unit | type */ *bits = (*bits & ~TEXT_INDENT_MASK) | ((((uint32_t)type & 0x1) | (unit << 1)) << TEXT_INDENT_SHIFT); style->i.text_indent = length; return CSS_OK; } #undef TEXT_INDENT_INDEX #undef TEXT_INDENT_SHIFT #undef TEXT_INDENT_MASK #define TEXT_TRANSFORM_INDEX 6 #define TEXT_TRANSFORM_SHIFT 3 #define TEXT_TRANSFORM_MASK 0x38 static inline css_error set_text_transform(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[TEXT_TRANSFORM_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~TEXT_TRANSFORM_MASK) | (((uint32_t)type & 0x7) << TEXT_TRANSFORM_SHIFT); return CSS_OK; } #undef TEXT_TRANSFORM_INDEX #undef TEXT_TRANSFORM_SHIFT #undef TEXT_TRANSFORM_MASK #define TOP_INDEX 3 #define TOP_SHIFT 25 #define TOP_MASK 0xfe000000 static inline css_error set_top(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[TOP_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~TOP_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << TOP_SHIFT); style->i.top = length; return CSS_OK; } #undef TOP_INDEX #undef TOP_SHIFT #undef TOP_MASK #define UNICODE_BIDI_INDEX 9 #define UNICODE_BIDI_SHIFT 16 #define UNICODE_BIDI_MASK 0x30000 static inline css_error set_unicode_bidi(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[UNICODE_BIDI_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~UNICODE_BIDI_MASK) | (((uint32_t)type & 0x3) << UNICODE_BIDI_SHIFT); return CSS_OK; } #undef UNICODE_BIDI_INDEX #undef UNICODE_BIDI_SHIFT #undef UNICODE_BIDI_MASK #define VERTICAL_ALIGN_INDEX 5 #define VERTICAL_ALIGN_SHIFT 12 #define VERTICAL_ALIGN_MASK 0x1ff000 static inline css_error set_vertical_align(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[VERTICAL_ALIGN_INDEX]; /* 9bits: uuuuutttt : unit | type */ *bits = (*bits & ~VERTICAL_ALIGN_MASK) | ((((uint32_t)type & 0xf) | ( unit << 4)) << VERTICAL_ALIGN_SHIFT); style->i.vertical_align = length; return CSS_OK; } #undef VERTICAL_ALIGN_INDEX #undef VERTICAL_ALIGN_SHIFT #undef VERTICAL_ALIGN_MASK #define VISIBILITY_INDEX 10 #define VISIBILITY_SHIFT 28 #define VISIBILITY_MASK 0x30000000 static inline css_error set_visibility(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[VISIBILITY_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~VISIBILITY_MASK) | (((uint32_t)type & 0x3) << VISIBILITY_SHIFT); return CSS_OK; } #undef VISIBILITY_INDEX #undef VISIBILITY_SHIFT #undef VISIBILITY_MASK #define WHITE_SPACE_INDEX 6 #define WHITE_SPACE_SHIFT 0 #define WHITE_SPACE_MASK 0x7 static inline css_error set_white_space(css_computed_style *style, uint8_t type) { uint32_t *bits; bits = &style->i.bits[WHITE_SPACE_INDEX]; /* 3bits: ttt : type */ *bits = (*bits & ~WHITE_SPACE_MASK) | (((uint32_t)type & 0x7) << WHITE_SPACE_SHIFT); return CSS_OK; } #undef WHITE_SPACE_INDEX #undef WHITE_SPACE_SHIFT #undef WHITE_SPACE_MASK #define WIDTH_INDEX 4 #define WIDTH_SHIFT 18 #define WIDTH_MASK 0x1fc0000 static inline css_error set_width(css_computed_style *style, uint8_t type, css_fixed length, css_unit unit) { uint32_t *bits; bits = &style->i.bits[WIDTH_INDEX]; /* 7bits: uuuuutt : unit | type */ *bits = (*bits & ~WIDTH_MASK) | ((((uint32_t)type & 0x3) | (unit << 2)) << WIDTH_SHIFT); style->i.width = length; return CSS_OK; } #undef WIDTH_INDEX #undef WIDTH_SHIFT #undef WIDTH_MASK #define Z_INDEX_INDEX 10 #define Z_INDEX_SHIFT 30 #define Z_INDEX_MASK 0xc0000000 static inline css_error set_z_index(css_computed_style *style, uint8_t type, int32_t integer) { uint32_t *bits; bits = &style->i.bits[Z_INDEX_INDEX]; /* 2bits: tt : type */ *bits = (*bits & ~Z_INDEX_MASK) | (((uint32_t)type & 0x3) << Z_INDEX_SHIFT); style->i.z_index = integer; return CSS_OK; } #undef Z_INDEX_INDEX #undef Z_INDEX_SHIFT #undef Z_INDEX_MASK