#ifndef test_dump_h_ #define test_dump_h_ #include #include #include "stylesheet.h" #include "bytecode/bytecode.h" #include "bytecode/opcodes.h" #include "select/font_face.h" #include "testutils.h" static void dump_sheet(css_stylesheet *sheet, char *buf, size_t *len); static void dump_rule_selector(css_rule_selector *s, char **buf, size_t *buflen, uint32_t depth); static void dump_rule_charset(css_rule_charset *s, char **buf, size_t *buflen); static void dump_rule_import(css_rule_import *s, char **buf, size_t *buflen); static void dump_rule_media(css_rule_media *s, char **buf, size_t *buflen); static void dump_rule_page(css_rule_page *s, char **buf, size_t *buflen); static void dump_rule_font_face(css_rule_font_face *s, char **buf, size_t *buflen); static void dump_selector_list(css_selector *list, char **ptr); static void dump_selector(css_selector *selector, char **ptr); static void dump_selector_detail(css_selector_detail *detail, char **ptr); static void dump_bytecode(css_style *style, char **ptr, uint32_t depth); static void dump_string(lwc_string *string, char **ptr); static void dump_font_face(css_font_face *font_face, char**ptr); void dump_sheet(css_stylesheet *sheet, char *buf, size_t *buflen) { css_rule *rule; for (rule = sheet->rule_list; rule != NULL; rule = rule->next) { switch (rule->type) { case CSS_RULE_SELECTOR: dump_rule_selector((css_rule_selector *) rule, &buf, buflen, 1); break; case CSS_RULE_CHARSET: dump_rule_charset((css_rule_charset *) rule, &buf, buflen); break; case CSS_RULE_IMPORT: dump_rule_import((css_rule_import *) rule, &buf, buflen); break; case CSS_RULE_MEDIA: dump_rule_media((css_rule_media *) rule, &buf, buflen); break; case CSS_RULE_PAGE: dump_rule_page((css_rule_page *) rule, &buf, buflen); break; case CSS_RULE_FONT_FACE: dump_rule_font_face((css_rule_font_face *) rule, &buf, buflen); break; default: { int written = sprintf(buf, "Unhandled rule type %d\n", rule->type); *buflen -= written; buf += written; } break; } } } void dump_rule_selector(css_rule_selector *s, char **buf, size_t *buflen, uint32_t depth) { uint32_t i; char *ptr = *buf; *ptr++ = '|'; for (i = 0; i < depth; i++) *ptr++ = ' '; /* Build selector string */ for (i = 0; i < s->base.items; i++) { dump_selector_list(s->selectors[i], &ptr); if (i != (uint32_t) (s->base.items - 1)) { memcpy(ptr, ", ", 2); ptr += 2; } } *ptr++ = '\n'; if (s->style != NULL) dump_bytecode(s->style, &ptr, depth + 1); *buflen -= ptr - *buf; *buf = ptr; } void dump_rule_charset(css_rule_charset *s, char **buf, size_t *buflen) { char *ptr = *buf; ptr += sprintf(ptr, "| @charset("); dump_string(s->encoding, &ptr); *ptr++ = ')'; *ptr++ = '\n'; *buflen -= ptr - *buf; *buf = ptr; } void dump_rule_import(css_rule_import *s, char **buf, size_t *buflen) { char *ptr = *buf; ptr += sprintf(ptr, "| @import url(\"%.*s\")", (int) lwc_string_length(s->url), lwc_string_data(s->url)); /** \todo media list */ *ptr++ = '\n'; *buflen -= ptr - *buf; *buf = ptr; } void dump_rule_media(css_rule_media *s, char **buf, size_t *buflen) { char *ptr = *buf; css_rule *rule; ptr += sprintf(ptr, "| @media "); /* \todo media list */ *ptr++ = '\n'; for (rule = s->first_child; rule != NULL; rule = rule->next) { size_t len = *buflen - (ptr - *buf); dump_rule_selector((css_rule_selector *) rule, &ptr, &len, 2); } *buflen -= ptr - *buf; *buf = ptr; } void dump_rule_page(css_rule_page *s, char **buf, size_t *buflen) { char *ptr = *buf; ptr += sprintf(ptr, "| @page "); if (s->selector != NULL) dump_selector_list(s->selector, &ptr); *ptr++ = '\n'; if (s->style != NULL) dump_bytecode(s->style, &ptr, 2); *buflen -= ptr - *buf; *buf = ptr; } void dump_rule_font_face(css_rule_font_face *s, char **buf, size_t *buflen) { char *ptr = *buf; ptr += sprintf(ptr, "| @font-face "); if (s->font_face != NULL) { dump_font_face(s->font_face, &ptr); } *ptr++ = '\n'; *buflen -= ptr - *buf; *buf = ptr; } void dump_selector_list(css_selector *list, char **ptr) { if (list->combinator != NULL) { dump_selector_list(list->combinator, ptr); } switch (list->data.comb) { case CSS_COMBINATOR_NONE: break; case CSS_COMBINATOR_ANCESTOR: (*ptr)[0] = ' '; *ptr += 1; break; case CSS_COMBINATOR_PARENT: memcpy(*ptr, " > ", 3); *ptr += 3; break; case CSS_COMBINATOR_SIBLING: memcpy(*ptr, " + ", 3); *ptr += 3; break; case CSS_COMBINATOR_GENERIC_SIBLING: memcpy(*ptr, " + ", 3); *ptr += 3; break; } dump_selector(list, ptr); } void dump_selector(css_selector *selector, char **ptr) { css_selector_detail *d = &selector->data; while (true) { dump_selector_detail(d, ptr); if (d->next == 0) break; d++; } } void dump_selector_detail(css_selector_detail *detail, char **ptr) { if (detail->negate) *ptr += sprintf(*ptr, ":not("); switch (detail->type) { case CSS_SELECTOR_ELEMENT: if (lwc_string_length(detail->qname.name) == 1 && lwc_string_data(detail->qname.name)[0] == '*' && detail->next == 0) { dump_string(detail->qname.name, ptr); } else if (lwc_string_length(detail->qname.name) != 1 || lwc_string_data(detail->qname.name)[0] != '*') { dump_string(detail->qname.name, ptr); } break; case CSS_SELECTOR_CLASS: **ptr = '.'; *ptr += 1; dump_string(detail->qname.name, ptr); break; case CSS_SELECTOR_ID: **ptr = '#'; *ptr += 1; dump_string(detail->qname.name, ptr); break; case CSS_SELECTOR_PSEUDO_CLASS: case CSS_SELECTOR_PSEUDO_ELEMENT: **ptr = ':'; *ptr += 1; dump_string(detail->qname.name, ptr); if (detail->value_type == CSS_SELECTOR_DETAIL_VALUE_STRING) { if (detail->value.string != NULL) { **ptr = '('; *ptr += 1; dump_string(detail->value.string, ptr); **ptr = ')'; *ptr += 1; } } else { *ptr += sprintf(*ptr, "(%dn+%d)", detail->value.nth.a, detail->value.nth.b); } break; case CSS_SELECTOR_ATTRIBUTE: **ptr = '['; *ptr += 1; dump_string(detail->qname.name, ptr); **ptr = ']'; *ptr += 1; break; case CSS_SELECTOR_ATTRIBUTE_EQUAL: **ptr = '['; *ptr += 1; dump_string(detail->qname.name, ptr); (*ptr)[0] = '='; (*ptr)[1] = '"'; *ptr += 2; dump_string(detail->value.string, ptr); (*ptr)[0] = '"'; (*ptr)[1] = ']'; *ptr += 2; break; case CSS_SELECTOR_ATTRIBUTE_DASHMATCH: **ptr = '['; *ptr += 1; dump_string(detail->qname.name, ptr); (*ptr)[0] = '|'; (*ptr)[1] = '='; (*ptr)[2] = '"'; *ptr += 3; dump_string(detail->value.string, ptr); (*ptr)[0] = '"'; (*ptr)[1] = ']'; *ptr += 2; break; case CSS_SELECTOR_ATTRIBUTE_INCLUDES: **ptr = '['; *ptr += 1; dump_string(detail->qname.name, ptr); (*ptr)[0] = '~'; (*ptr)[1] = '='; (*ptr)[2] = '"'; *ptr += 3; dump_string(detail->value.string, ptr); (*ptr)[0] = '"'; (*ptr)[1] = ']'; *ptr += 2; break; case CSS_SELECTOR_ATTRIBUTE_PREFIX: **ptr = '['; *ptr += 1; dump_string(detail->qname.name, ptr); (*ptr)[0] = '^'; (*ptr)[1] = '='; (*ptr)[2] = '"'; *ptr += 3; dump_string(detail->value.string, ptr); (*ptr)[0] = '"'; (*ptr)[1] = ']'; *ptr += 2; break; case CSS_SELECTOR_ATTRIBUTE_SUFFIX: **ptr = '['; *ptr += 1; dump_string(detail->qname.name, ptr); (*ptr)[0] = '$'; (*ptr)[1] = '='; (*ptr)[2] = '"'; *ptr += 3; dump_string(detail->value.string, ptr); (*ptr)[0] = '"'; (*ptr)[1] = ']'; *ptr += 2; break; case CSS_SELECTOR_ATTRIBUTE_SUBSTRING: **ptr = '['; *ptr += 1; dump_string(detail->qname.name, ptr); (*ptr)[0] = '*'; (*ptr)[1] = '='; (*ptr)[2] = '"'; *ptr += 3; dump_string(detail->value.string, ptr); (*ptr)[0] = '"'; (*ptr)[1] = ']'; *ptr += 2; break; } if (detail->negate) *ptr += sprintf(*ptr, ")"); } /** * Opcode names, indexed by opcode */ static const char *opcode_names[] = { "azimuth", "background-attachment", "background-color", "background-image", "background-position", "background-repeat", "border-collapse", "border-spacing", "border-top-color", "border-right-color", "border-bottom-color", "border-left-color", "border-top-style", "border-right-style", "border-bottom-style", "border-left-style", "border-top-width", "border-right-width", "border-bottom-width", "border-left-width", "bottom", "caption-side", "clear", "clip", "color", "content", "counter-increment", "counter-reset", "cue-after", "cue-before", "cursor", "direction", "display", "elevation", "empty-cells", "float", "font-family", "font-size", "font-style", "font-variant", "font-weight", "height", "left", "letter-spacing", "line-height", "list-style-image", "list-style-position", "list-style-type", "margin-top", "margin-right", "margin-bottom", "margin-left", "max-height", "max-width", "min-height", "min-width", "orphans", "outline-color", "outline-style", "outline-width", "overflow-x", "padding-top", "padding-right", "padding-bottom", "padding-left", "page-break-after", "page-break-before", "page-break-inside", "pause-after", "pause-before", "pitch-range", "pitch", "play-during", "position", "quotes", "richness", "right", "speak-header", "speak-numeral", "speak-punctuation", "speak", "speech-rate", "stress", "table-layout", "text-align", "text-decoration", "text-indent", "text-transform", "top", "unicode-bidi", "vertical-align", "visibility", "voice-family", "volume", "white-space", "widows", "width", "word-spacing", "z-index", "opacity", "break-after", "break-before", "break-inside", "column-count", "column-fill", "column-gap", "column-rule-color", "column-rule-style", "column-rule-width", "column-span", "column-width", "writing-mode", "overflow-y", "box-sizing", "align-content", "align-items", "align-self", "flex-basis", "flex-direction", "flex-grow", "flex-shrink", "flex-wrap", "justify-content", "order", }; static void dump_css_fixed(css_fixed f, char **ptr) { #define ABS(x) (uint32_t)((x) < 0 ? -(x) : (x)) uint32_t uintpart = FIXTOINT(ABS(f)); /* + 500 to ensure round to nearest (division will truncate) */ uint32_t fracpart = ((ABS(f) & 0x3ff) * 1000 + 500) / (1 << 10); #undef ABS size_t flen = 0; char tmp[20]; size_t tlen = 0; char *buf = *ptr; if (f < 0) { buf[0] = '-'; buf++; } do { tmp[tlen] = "0123456789"[uintpart % 10]; tlen++; uintpart /= 10; } while (tlen < 20 && uintpart != 0); while (tlen > 0) { buf[0] = tmp[--tlen]; buf++; } buf[0] = '.'; buf++; do { tmp[tlen] = "0123456789"[fracpart % 10]; tlen++; fracpart /= 10; } while (tlen < 20 && fracpart != 0); while (tlen > 0) { buf[0] = tmp[--tlen]; buf++; flen++; } while (flen < 3) { buf[0] = '0'; buf++; flen++; } buf[0] = '\0'; *ptr = buf; } static void dump_number(css_fixed val, char **ptr) { if (INTTOFIX(FIXTOINT(val)) == val) *ptr += sprintf(*ptr, "%d", FIXTOINT(val)); else dump_css_fixed(val, ptr); } static void dump_unit(css_fixed val, uint32_t unit, char **ptr) { dump_number(val, ptr); switch (unit) { case UNIT_PX: *ptr += sprintf(*ptr, "px"); break; case UNIT_EX: *ptr += sprintf(*ptr, "ex"); break; case UNIT_EM: *ptr += sprintf(*ptr, "em"); break; case UNIT_IN: *ptr += sprintf(*ptr, "in"); break; case UNIT_CM: *ptr += sprintf(*ptr, "cm"); break; case UNIT_MM: *ptr += sprintf(*ptr, "mm"); break; case UNIT_PT: *ptr += sprintf(*ptr, "pt"); break; case UNIT_PC: *ptr += sprintf(*ptr, "pc"); break; case UNIT_CAP: *ptr += sprintf(*ptr, "cap"); break; case UNIT_CH: *ptr += sprintf(*ptr, "ch"); break; case UNIT_IC: *ptr += sprintf(*ptr, "ic"); break; case UNIT_REM: *ptr += sprintf(*ptr, "rem"); break; case UNIT_LH: *ptr += sprintf(*ptr, "lh"); break; case UNIT_RLH: *ptr += sprintf(*ptr, "rlh"); break; case UNIT_VH: *ptr += sprintf(*ptr, "vh"); break; case UNIT_VW: *ptr += sprintf(*ptr, "vw"); break; case UNIT_VI: *ptr += sprintf(*ptr, "vi"); break; case UNIT_VB: *ptr += sprintf(*ptr, "vb"); break; case UNIT_VMIN: *ptr += sprintf(*ptr, "vmin"); break; case UNIT_VMAX: *ptr += sprintf(*ptr, "vmax"); break; case UNIT_Q: *ptr += sprintf(*ptr, "q"); break; case UNIT_PCT: *ptr += sprintf(*ptr, "%%"); break; case UNIT_DEG: *ptr += sprintf(*ptr, "deg"); break; case UNIT_GRAD: *ptr += sprintf(*ptr, "grad"); break; case UNIT_RAD: *ptr += sprintf(*ptr, "rad"); break; case UNIT_MS: *ptr += sprintf(*ptr, "ms"); break; case UNIT_S: *ptr += sprintf(*ptr, "s"); break; case UNIT_HZ: *ptr += sprintf(*ptr, "Hz"); break; case UNIT_KHZ: *ptr += sprintf(*ptr, "kHz"); break; } } static void dump_counter(lwc_string *name, uint32_t value, char **ptr) { *ptr += sprintf(*ptr, "counter(%.*s", (int) lwc_string_length(name), lwc_string_data(name)); value >>= CONTENT_COUNTER_STYLE_SHIFT; switch (value) { case LIST_STYLE_TYPE_DISC: *ptr += sprintf(*ptr, ", disc"); break; case LIST_STYLE_TYPE_CIRCLE: *ptr += sprintf(*ptr, ", circle"); break; case LIST_STYLE_TYPE_SQUARE: *ptr += sprintf(*ptr, ", square"); break; case LIST_STYLE_TYPE_DECIMAL: break; case LIST_STYLE_TYPE_DECIMAL_LEADING_ZERO: *ptr += sprintf(*ptr, ", decimal-leading-zero"); break; case LIST_STYLE_TYPE_LOWER_ROMAN: *ptr += sprintf(*ptr, ", lower-roman"); break; case LIST_STYLE_TYPE_UPPER_ROMAN: *ptr += sprintf(*ptr, ", upper-roman"); break; case LIST_STYLE_TYPE_LOWER_GREEK: *ptr += sprintf(*ptr, ", lower-greek"); break; case LIST_STYLE_TYPE_LOWER_LATIN: *ptr += sprintf(*ptr, ", lower-latin"); break; case LIST_STYLE_TYPE_UPPER_LATIN: *ptr += sprintf(*ptr, ", upper-latin"); break; case LIST_STYLE_TYPE_ARMENIAN: *ptr += sprintf(*ptr, ", armenian"); break; case LIST_STYLE_TYPE_GEORGIAN: *ptr += sprintf(*ptr, ", georgian"); break; case LIST_STYLE_TYPE_LOWER_ALPHA: *ptr += sprintf(*ptr, ", lower-alpha"); break; case LIST_STYLE_TYPE_UPPER_ALPHA: *ptr += sprintf(*ptr, ", upper-alpha"); break; case LIST_STYLE_TYPE_NONE: *ptr += sprintf(*ptr, ", none"); break; } *ptr += sprintf(*ptr, ")"); } static void dump_counters(lwc_string *name, lwc_string *separator, uint32_t value, char **ptr) { *ptr += sprintf(*ptr, "counter(%.*s, %.*s", (int) lwc_string_length(name), lwc_string_data(name), (int) lwc_string_length(separator), lwc_string_data(separator)); value >>= CONTENT_COUNTER_STYLE_SHIFT; switch (value) { case LIST_STYLE_TYPE_DISC: *ptr += sprintf(*ptr, ", disc"); break; case LIST_STYLE_TYPE_CIRCLE: *ptr += sprintf(*ptr, ", circle"); break; case LIST_STYLE_TYPE_SQUARE: *ptr += sprintf(*ptr, ", square"); break; case LIST_STYLE_TYPE_DECIMAL: break; case LIST_STYLE_TYPE_DECIMAL_LEADING_ZERO: *ptr += sprintf(*ptr, ", decimal-leading-zero"); break; case LIST_STYLE_TYPE_LOWER_ROMAN: *ptr += sprintf(*ptr, ", lower-roman"); break; case LIST_STYLE_TYPE_UPPER_ROMAN: *ptr += sprintf(*ptr, ", upper-roman"); break; case LIST_STYLE_TYPE_LOWER_GREEK: *ptr += sprintf(*ptr, ", lower-greek"); break; case LIST_STYLE_TYPE_LOWER_LATIN: *ptr += sprintf(*ptr, ", lower-latin"); break; case LIST_STYLE_TYPE_UPPER_LATIN: *ptr += sprintf(*ptr, ", upper-latin"); break; case LIST_STYLE_TYPE_ARMENIAN: *ptr += sprintf(*ptr, ", armenian"); break; case LIST_STYLE_TYPE_GEORGIAN: *ptr += sprintf(*ptr, ", georgian"); break; case LIST_STYLE_TYPE_LOWER_ALPHA: *ptr += sprintf(*ptr, ", lower-alpha"); break; case LIST_STYLE_TYPE_UPPER_ALPHA: *ptr += sprintf(*ptr, ", upper-alpha"); break; case LIST_STYLE_TYPE_NONE: *ptr += sprintf(*ptr, ", none"); break; } *ptr += sprintf(*ptr, ")"); } void dump_bytecode(css_style *style, char **ptr, uint32_t depth) { void *bytecode = style->bytecode; size_t length = (style->used * sizeof(css_code_t)); uint32_t offset = 0; #define ADVANCE(n) do { \ offset += (n); \ bytecode = ((uint8_t *) bytecode) + (n); \ } while(0) while (offset < length) { opcode_t op; uint32_t value; uint32_t opv = *((uint32_t *) bytecode); uint32_t i; ADVANCE(sizeof(opv)); op = getOpcode(opv); *((*ptr)++) = '|'; for (i = 0; i < depth; i++) *((*ptr)++) = ' '; *ptr += sprintf(*ptr, "%s: ", opcode_names[op]); if (isInherit(opv)) { *ptr += sprintf(*ptr, "inherit"); } else { value = getValue(opv); switch (op) { case CSS_PROP_ALIGN_CONTENT: switch (value) { case ALIGN_CONTENT_STRETCH: *ptr += sprintf(*ptr, "stretch"); break; case ALIGN_CONTENT_FLEX_START: *ptr += sprintf(*ptr, "flex-start"); break; case ALIGN_CONTENT_FLEX_END: *ptr += sprintf(*ptr, "flex-end"); break; case ALIGN_CONTENT_CENTER: *ptr += sprintf(*ptr, "center"); break; case ALIGN_CONTENT_SPACE_BETWEEN: *ptr += sprintf(*ptr, "space-between"); break; case ALIGN_CONTENT_SPACE_AROUND: *ptr += sprintf(*ptr, "space-around"); break; case ALIGN_CONTENT_SPACE_EVENLY: *ptr += sprintf(*ptr, "space-evenly"); break; } break; case CSS_PROP_ALIGN_ITEMS: switch (value) { case ALIGN_ITEMS_STRETCH: *ptr += sprintf(*ptr, "stretch"); break; case ALIGN_ITEMS_FLEX_START: *ptr += sprintf(*ptr, "flex-start"); break; case ALIGN_ITEMS_FLEX_END: *ptr += sprintf(*ptr, "flex-end"); break; case ALIGN_ITEMS_CENTER: *ptr += sprintf(*ptr, "center"); break; case ALIGN_ITEMS_BASELINE: *ptr += sprintf(*ptr, "baseline"); break; } break; case CSS_PROP_ALIGN_SELF: switch (value) { case ALIGN_SELF_STRETCH: *ptr += sprintf(*ptr, "stretch"); break; case ALIGN_SELF_FLEX_START: *ptr += sprintf(*ptr, "flex-start"); break; case ALIGN_SELF_FLEX_END: *ptr += sprintf(*ptr, "flex-end"); break; case ALIGN_SELF_CENTER: *ptr += sprintf(*ptr, "center"); break; case ALIGN_SELF_BASELINE: *ptr += sprintf(*ptr, "baseline"); break; case ALIGN_SELF_AUTO: *ptr += sprintf(*ptr, "auto"); break; } break; case CSS_PROP_AZIMUTH: switch (value & ~AZIMUTH_BEHIND) { case AZIMUTH_ANGLE: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case AZIMUTH_LEFTWARDS: *ptr += sprintf(*ptr, "leftwards"); break; case AZIMUTH_RIGHTWARDS: *ptr += sprintf(*ptr, "rightwards"); break; case AZIMUTH_LEFT_SIDE: *ptr += sprintf(*ptr, "left-side"); break; case AZIMUTH_FAR_LEFT: *ptr += sprintf(*ptr, "far-left"); break; case AZIMUTH_LEFT: *ptr += sprintf(*ptr, "left"); break; case AZIMUTH_CENTER_LEFT: *ptr += sprintf(*ptr, "center-left"); break; case AZIMUTH_CENTER: *ptr += sprintf(*ptr, "center"); break; case AZIMUTH_CENTER_RIGHT: *ptr += sprintf(*ptr, "center-right"); break; case AZIMUTH_RIGHT: *ptr += sprintf(*ptr, "right"); break; case AZIMUTH_FAR_RIGHT: *ptr += sprintf(*ptr, "far-right"); break; case AZIMUTH_RIGHT_SIDE: *ptr += sprintf(*ptr, "right-side"); break; } if (value & AZIMUTH_BEHIND) *ptr += sprintf(*ptr, " behind"); break; case CSS_PROP_BACKGROUND_ATTACHMENT: switch (value) { case BACKGROUND_ATTACHMENT_FIXED: *ptr += sprintf(*ptr, "fixed"); break; case BACKGROUND_ATTACHMENT_SCROLL: *ptr += sprintf(*ptr, "scroll"); break; } 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: case CSS_PROP_COLUMN_RULE_COLOR: assert(BACKGROUND_COLOR_TRANSPARENT == (enum op_background_color) BORDER_COLOR_TRANSPARENT); assert(BACKGROUND_COLOR_CURRENT_COLOR == (enum op_background_color) BORDER_COLOR_CURRENT_COLOR); assert(BACKGROUND_COLOR_SET == (enum op_background_color) BORDER_COLOR_SET); switch (value) { case BACKGROUND_COLOR_TRANSPARENT: *ptr += sprintf(*ptr, "transparent"); break; case BACKGROUND_COLOR_CURRENT_COLOR: *ptr += sprintf(*ptr, "currentColor"); break; case BACKGROUND_COLOR_SET: { uint32_t colour = *((uint32_t *) bytecode); ADVANCE(sizeof(colour)); *ptr += sprintf(*ptr, "#%08x", colour); } break; } 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_NONE == (enum op_background_image) CUE_AFTER_NONE); assert(BACKGROUND_IMAGE_URI == (enum op_background_image) CUE_AFTER_URI); assert(BACKGROUND_IMAGE_NONE == (enum op_background_image) CUE_BEFORE_NONE); assert(BACKGROUND_IMAGE_URI == (enum op_background_image) CUE_BEFORE_URI); assert(BACKGROUND_IMAGE_NONE == (enum op_background_image) LIST_STYLE_IMAGE_NONE); assert(BACKGROUND_IMAGE_URI == (enum op_background_image) LIST_STYLE_IMAGE_URI); switch (value) { case BACKGROUND_IMAGE_NONE: *ptr += sprintf(*ptr, "none"); break; case BACKGROUND_IMAGE_URI: { uint32_t snum = *((uint32_t *) bytecode); lwc_string *he; css__stylesheet_string_get(style->sheet, snum, &he); ADVANCE(sizeof(snum)); *ptr += sprintf(*ptr, "url('%.*s')", (int) lwc_string_length(he), lwc_string_data(he)); } break; } break; case CSS_PROP_BACKGROUND_POSITION: switch (value & 0xf0) { case BACKGROUND_POSITION_HORZ_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case BACKGROUND_POSITION_HORZ_CENTER: *ptr += sprintf(*ptr, "center"); break; case BACKGROUND_POSITION_HORZ_RIGHT: *ptr += sprintf(*ptr, "right"); break; case BACKGROUND_POSITION_HORZ_LEFT: *ptr += sprintf(*ptr, "left"); break; } *ptr += sprintf(*ptr, " "); switch (value & 0x0f) { case BACKGROUND_POSITION_VERT_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case BACKGROUND_POSITION_VERT_CENTER: *ptr += sprintf(*ptr, "center"); break; case BACKGROUND_POSITION_VERT_BOTTOM: *ptr += sprintf(*ptr, "bottom"); break; case BACKGROUND_POSITION_VERT_TOP: *ptr += sprintf(*ptr, "top"); break; } break; case CSS_PROP_BACKGROUND_REPEAT: switch (value) { case BACKGROUND_REPEAT_NO_REPEAT: *ptr += sprintf(*ptr, "no-repeat"); break; case BACKGROUND_REPEAT_REPEAT_X: *ptr += sprintf(*ptr, "repeat-x"); break; case BACKGROUND_REPEAT_REPEAT_Y: *ptr += sprintf(*ptr, "repeat-y"); break; case BACKGROUND_REPEAT_REPEAT: *ptr += sprintf(*ptr, "repeat"); break; } break; case CSS_PROP_BORDER_COLLAPSE: switch (value) { case BORDER_COLLAPSE_SEPARATE: *ptr += sprintf(*ptr, "separate"); break; case BORDER_COLLAPSE_COLLAPSE: *ptr += sprintf(*ptr, "collapse"); break; } break; case CSS_PROP_BORDER_SPACING: switch (value) { case BORDER_SPACING_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; } break; case CSS_PROP_BOX_SIZING: switch (value) { case BOX_SIZING_CONTENT_BOX: *ptr += sprintf(*ptr, "content-box"); break; case BOX_SIZING_BORDER_BOX: *ptr += sprintf(*ptr, "border-box"); break; } break; case CSS_PROP_BORDER_TOP_STYLE: case CSS_PROP_BORDER_RIGHT_STYLE: case CSS_PROP_BORDER_BOTTOM_STYLE: case CSS_PROP_BORDER_LEFT_STYLE: case CSS_PROP_COLUMN_RULE_STYLE: case CSS_PROP_OUTLINE_STYLE: assert(BORDER_STYLE_NONE == (enum op_border_style) OUTLINE_STYLE_NONE); assert(BORDER_STYLE_NONE == (enum op_border_style) COLUMN_RULE_STYLE_NONE); assert(BORDER_STYLE_HIDDEN == (enum op_border_style) OUTLINE_STYLE_HIDDEN); assert(BORDER_STYLE_HIDDEN == (enum op_border_style) COLUMN_RULE_STYLE_HIDDEN); assert(BORDER_STYLE_DOTTED == (enum op_border_style) OUTLINE_STYLE_DOTTED); assert(BORDER_STYLE_DOTTED == (enum op_border_style) COLUMN_RULE_STYLE_DOTTED); assert(BORDER_STYLE_DASHED == (enum op_border_style) OUTLINE_STYLE_DASHED); assert(BORDER_STYLE_DASHED == (enum op_border_style) COLUMN_RULE_STYLE_DASHED); assert(BORDER_STYLE_SOLID == (enum op_border_style) OUTLINE_STYLE_SOLID); assert(BORDER_STYLE_SOLID == (enum op_border_style) COLUMN_RULE_STYLE_SOLID); assert(BORDER_STYLE_DOUBLE == (enum op_border_style) OUTLINE_STYLE_DOUBLE); assert(BORDER_STYLE_DOUBLE == (enum op_border_style) COLUMN_RULE_STYLE_DOUBLE); assert(BORDER_STYLE_GROOVE == (enum op_border_style) OUTLINE_STYLE_GROOVE); assert(BORDER_STYLE_GROOVE == (enum op_border_style) COLUMN_RULE_STYLE_GROOVE); assert(BORDER_STYLE_RIDGE == (enum op_border_style) OUTLINE_STYLE_RIDGE); assert(BORDER_STYLE_RIDGE == (enum op_border_style) COLUMN_RULE_STYLE_RIDGE); assert(BORDER_STYLE_INSET == (enum op_border_style) OUTLINE_STYLE_INSET); assert(BORDER_STYLE_INSET == (enum op_border_style) COLUMN_RULE_STYLE_INSET); assert(BORDER_STYLE_OUTSET == (enum op_border_style) OUTLINE_STYLE_OUTSET); assert(BORDER_STYLE_OUTSET == (enum op_border_style) COLUMN_RULE_STYLE_OUTSET); switch (value) { case BORDER_STYLE_NONE: *ptr += sprintf(*ptr, "none"); break; case BORDER_STYLE_HIDDEN: *ptr += sprintf(*ptr, "hidden"); break; case BORDER_STYLE_DOTTED: *ptr += sprintf(*ptr, "dotted"); break; case BORDER_STYLE_DASHED: *ptr += sprintf(*ptr, "dashed"); break; case BORDER_STYLE_SOLID: *ptr += sprintf(*ptr, "solid"); break; case BORDER_STYLE_DOUBLE: *ptr += sprintf(*ptr, "double"); break; case BORDER_STYLE_GROOVE: *ptr += sprintf(*ptr, "groove"); break; case BORDER_STYLE_RIDGE: *ptr += sprintf(*ptr, "ridge"); break; case BORDER_STYLE_INSET: *ptr += sprintf(*ptr, "inset"); break; case BORDER_STYLE_OUTSET: *ptr += sprintf(*ptr, "outset"); break; } 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_COLUMN_RULE_WIDTH: case CSS_PROP_OUTLINE_WIDTH: assert(BORDER_WIDTH_SET == (enum op_border_width) OUTLINE_WIDTH_SET); assert(BORDER_WIDTH_THIN == (enum op_border_width) OUTLINE_WIDTH_THIN); assert(BORDER_WIDTH_MEDIUM == (enum op_border_width) OUTLINE_WIDTH_MEDIUM); assert(BORDER_WIDTH_THICK == (enum op_border_width) OUTLINE_WIDTH_THICK); switch (value) { case BORDER_WIDTH_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case BORDER_WIDTH_THIN: *ptr += sprintf(*ptr, "thin"); break; case BORDER_WIDTH_MEDIUM: *ptr += sprintf(*ptr, "medium"); break; case BORDER_WIDTH_THICK: *ptr += sprintf(*ptr, "thick"); break; } 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: case CSS_PROP_COLUMN_WIDTH: assert(BOTTOM_SET == (enum op_bottom) LEFT_SET); assert(BOTTOM_AUTO == (enum op_bottom) LEFT_AUTO); assert(BOTTOM_SET == (enum op_bottom) RIGHT_SET); assert(BOTTOM_AUTO == (enum op_bottom) RIGHT_AUTO); assert(BOTTOM_SET == (enum op_bottom) TOP_SET); assert(BOTTOM_AUTO == (enum op_bottom) TOP_AUTO); assert(BOTTOM_SET == (enum op_bottom) HEIGHT_SET); assert(BOTTOM_AUTO == (enum op_bottom) HEIGHT_AUTO); assert(BOTTOM_SET == (enum op_bottom) MARGIN_SET); assert(BOTTOM_AUTO == (enum op_bottom) MARGIN_AUTO); assert(BOTTOM_SET == (enum op_bottom) WIDTH_SET); assert(BOTTOM_AUTO == (enum op_bottom) WIDTH_AUTO); assert(BOTTOM_SET == (enum op_bottom) COLUMN_WIDTH_SET); assert(BOTTOM_AUTO == (enum op_bottom) COLUMN_WIDTH_AUTO); switch (value) { case BOTTOM_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case BOTTOM_AUTO: *ptr += sprintf(*ptr, "auto"); break; } break; case CSS_PROP_BREAK_AFTER: case CSS_PROP_BREAK_BEFORE: assert(BREAK_AFTER_AUTO == (enum op_break_after) BREAK_BEFORE_AUTO); assert(BREAK_AFTER_ALWAYS == (enum op_break_after) BREAK_BEFORE_ALWAYS); assert(BREAK_AFTER_AVOID == (enum op_break_after) BREAK_BEFORE_AVOID); assert(BREAK_AFTER_LEFT == (enum op_break_after) BREAK_BEFORE_LEFT); assert(BREAK_AFTER_RIGHT == (enum op_break_after) BREAK_BEFORE_RIGHT); assert(BREAK_AFTER_PAGE == (enum op_break_after) BREAK_BEFORE_PAGE); assert(BREAK_AFTER_COLUMN == (enum op_break_after) BREAK_BEFORE_COLUMN); assert(BREAK_AFTER_AVOID_PAGE == (enum op_break_after) BREAK_BEFORE_AVOID_PAGE); assert(BREAK_AFTER_AVOID_COLUMN == (enum op_break_after) BREAK_BEFORE_AVOID_COLUMN); switch (value) { case BREAK_AFTER_AUTO: *ptr += sprintf(*ptr, "auto"); break; case BREAK_AFTER_ALWAYS: *ptr += sprintf(*ptr, "always"); break; case BREAK_AFTER_AVOID: *ptr += sprintf(*ptr, "avoid"); break; case BREAK_AFTER_LEFT: *ptr += sprintf(*ptr, "left"); break; case BREAK_AFTER_RIGHT: *ptr += sprintf(*ptr, "right"); break; case BREAK_AFTER_PAGE: *ptr += sprintf(*ptr, "page"); break; case BREAK_AFTER_COLUMN: *ptr += sprintf(*ptr, "column"); break; case BREAK_AFTER_AVOID_PAGE: *ptr += sprintf(*ptr, "avoid-page"); break; case BREAK_AFTER_AVOID_COLUMN: *ptr += sprintf(*ptr, "avoid-column"); break; } break; case CSS_PROP_BREAK_INSIDE: switch (value) { case BREAK_INSIDE_AUTO: *ptr += sprintf(*ptr, "auto"); break; case BREAK_INSIDE_AVOID: *ptr += sprintf(*ptr, "avoid"); break; case BREAK_INSIDE_AVOID_PAGE: *ptr += sprintf(*ptr, "avoid-page"); break; case BREAK_INSIDE_AVOID_COLUMN: *ptr += sprintf(*ptr, "avoid-column"); break; } break; case CSS_PROP_CAPTION_SIDE: switch (value) { case CAPTION_SIDE_TOP: *ptr += sprintf(*ptr, "top"); break; case CAPTION_SIDE_BOTTOM: *ptr += sprintf(*ptr, "bottom"); break; } break; case CSS_PROP_CLEAR: switch (value) { case CLEAR_NONE: *ptr += sprintf(*ptr, "none"); break; case CLEAR_LEFT: *ptr += sprintf(*ptr, "left"); break; case CLEAR_RIGHT: *ptr += sprintf(*ptr, "right"); break; case CLEAR_BOTH: *ptr += sprintf(*ptr, "both"); break; } break; case CSS_PROP_CLIP: if ((value & CLIP_SHAPE_MASK) == CLIP_SHAPE_RECT) { *ptr += sprintf(*ptr, "rect("); if (value & CLIP_RECT_TOP_AUTO) { *ptr += sprintf(*ptr, "auto"); } else { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } *ptr += sprintf(*ptr, ", "); if (value & CLIP_RECT_RIGHT_AUTO) { *ptr += sprintf(*ptr, "auto"); } else { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } *ptr += sprintf(*ptr, ", "); if (value & CLIP_RECT_BOTTOM_AUTO) { *ptr += sprintf(*ptr, "auto"); } else { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } *ptr += sprintf(*ptr, ", "); if (value & CLIP_RECT_LEFT_AUTO) { *ptr += sprintf(*ptr, "auto"); } else { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } *ptr += sprintf(*ptr, ")"); } else *ptr += sprintf(*ptr, "auto"); break; case CSS_PROP_COLOR: switch (value) { case COLOR_TRANSPARENT: *ptr += sprintf(*ptr, "transparent"); break; case COLOR_CURRENT_COLOR: *ptr += sprintf(*ptr, "currentColor"); break; case COLOR_SET: { uint32_t colour = *((uint32_t *) bytecode); ADVANCE(sizeof(colour)); *ptr += sprintf(*ptr, "#%08x", colour); } break; } break; case CSS_PROP_COLUMN_COUNT: switch (value) { case COLUMN_COUNT_SET: { css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); dump_number(val, ptr); } break; case COLUMN_COUNT_AUTO: *ptr += sprintf(*ptr, "auto"); break; } break; case CSS_PROP_COLUMN_FILL: switch (value) { case COLUMN_FILL_BALANCE: *ptr += sprintf(*ptr, "balance"); break; case COLUMN_FILL_AUTO: *ptr += sprintf(*ptr, "auto"); break; } break; case CSS_PROP_COLUMN_GAP: switch (value) { case COLUMN_GAP_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case COLUMN_GAP_NORMAL: *ptr += sprintf(*ptr, "normal"); break; } break; case CSS_PROP_COLUMN_SPAN: switch (value) { case COLUMN_SPAN_NONE: *ptr += sprintf(*ptr, "none"); break; case COLUMN_SPAN_ALL: *ptr += sprintf(*ptr, "all"); break; } break; case CSS_PROP_CONTENT: if (value == CONTENT_NORMAL) { *ptr += sprintf(*ptr, "normal"); break; } else if (value == CONTENT_NONE) { *ptr += sprintf(*ptr, "none"); break; } while (value != CONTENT_NORMAL) { uint32_t snum = *((uint32_t *) bytecode); lwc_string *he; const char *end = ""; switch (value & 0xff) { case CONTENT_COUNTER: css__stylesheet_string_get(style->sheet, snum, &he); ADVANCE(sizeof(snum)); dump_counter(he, value, ptr); break; case CONTENT_COUNTERS: { lwc_string *sep; css__stylesheet_string_get(style->sheet, snum, &he); ADVANCE(sizeof(snum)); sep = *((lwc_string **) bytecode); ADVANCE(sizeof(sep)); dump_counters(he, sep, value, ptr); } break; case CONTENT_URI: case CONTENT_ATTR: case CONTENT_STRING: css__stylesheet_string_get(style->sheet, snum, &he); if (value == CONTENT_URI) *ptr += sprintf(*ptr, "url("); if (value == CONTENT_ATTR) *ptr += sprintf(*ptr, "attr("); if (value != CONTENT_STRING) end = ")"; ADVANCE(sizeof(snum)); *ptr += sprintf(*ptr, "'%.*s'%s", (int) lwc_string_length(he), lwc_string_data(he), end); break; case CONTENT_OPEN_QUOTE: *ptr += sprintf(*ptr, "open-quote"); break; case CONTENT_CLOSE_QUOTE: *ptr += sprintf(*ptr, "close-quote"); break; case CONTENT_NO_OPEN_QUOTE: *ptr += sprintf(*ptr, "no-open-quote"); break; case CONTENT_NO_CLOSE_QUOTE: *ptr += sprintf(*ptr, "no-close-quote"); break; } value = *((uint32_t *) bytecode); ADVANCE(sizeof(value)); if (value != CONTENT_NORMAL) *ptr += sprintf(*ptr, " "); } break; case CSS_PROP_COUNTER_INCREMENT: case CSS_PROP_COUNTER_RESET: assert(COUNTER_INCREMENT_NONE == (enum op_counter_increment) COUNTER_RESET_NONE); assert(COUNTER_INCREMENT_NAMED == (enum op_counter_increment) COUNTER_RESET_NAMED); switch (value) { case COUNTER_INCREMENT_NAMED: while (value != COUNTER_INCREMENT_NONE) { css_fixed val; uint32_t snum = *((uint32_t *) bytecode); lwc_string *he; css__stylesheet_string_get(style->sheet, snum, &he); ADVANCE(sizeof(snum)); *ptr += sprintf(*ptr, "%.*s ", (int)lwc_string_length(he), lwc_string_data(he)); val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); dump_number(val, ptr); value = *((uint32_t *) bytecode); ADVANCE(sizeof(value)); if (value != COUNTER_INCREMENT_NONE) *ptr += sprintf(*ptr, " "); } break; case COUNTER_INCREMENT_NONE: *ptr += sprintf(*ptr, "none"); break; } break; case CSS_PROP_CURSOR: while (value == CURSOR_URI) { uint32_t snum = *((uint32_t *) bytecode); lwc_string *he; css__stylesheet_string_get(style->sheet, snum, &he); ADVANCE(sizeof(snum)); *ptr += sprintf(*ptr, "url('%.*s'), ", (int) lwc_string_length(he), lwc_string_data(he)); value = *((uint32_t *) bytecode); ADVANCE(sizeof(value)); } switch (value) { case CURSOR_AUTO: *ptr += sprintf(*ptr, "auto"); break; case CURSOR_CROSSHAIR: *ptr += sprintf(*ptr, "crosshair"); break; case CURSOR_DEFAULT: *ptr += sprintf(*ptr, "default"); break; case CURSOR_POINTER: *ptr += sprintf(*ptr, "pointer"); break; case CURSOR_MOVE: *ptr += sprintf(*ptr, "move"); break; case CURSOR_E_RESIZE: *ptr += sprintf(*ptr, "e-resize"); break; case CURSOR_NE_RESIZE: *ptr += sprintf(*ptr, "ne-resize"); break; case CURSOR_NW_RESIZE: *ptr += sprintf(*ptr, "nw-resize"); break; case CURSOR_N_RESIZE: *ptr += sprintf(*ptr, "n-resize"); break; case CURSOR_SE_RESIZE: *ptr += sprintf(*ptr, "se-resize"); break; case CURSOR_SW_RESIZE: *ptr += sprintf(*ptr, "sw-resize"); break; case CURSOR_S_RESIZE: *ptr += sprintf(*ptr, "s-resize"); break; case CURSOR_W_RESIZE: *ptr += sprintf(*ptr, "w-resize"); break; case CURSOR_TEXT: *ptr += sprintf(*ptr, "text"); break; case CURSOR_WAIT: *ptr += sprintf(*ptr, "wait"); break; case CURSOR_HELP: *ptr += sprintf(*ptr, "help"); break; case CURSOR_PROGRESS: *ptr += sprintf(*ptr, "progress"); break; } break; case CSS_PROP_DIRECTION: switch (value) { case DIRECTION_LTR: *ptr += sprintf(*ptr, "ltr"); break; case DIRECTION_RTL: *ptr += sprintf(*ptr, "rtl"); break; } break; case CSS_PROP_DISPLAY: switch (value) { case DISPLAY_INLINE: *ptr += sprintf(*ptr, "inline"); break; case DISPLAY_BLOCK: *ptr += sprintf(*ptr, "block"); break; case DISPLAY_LIST_ITEM: *ptr += sprintf(*ptr, "list-item"); break; case DISPLAY_RUN_IN: *ptr += sprintf(*ptr, "run-in"); break; case DISPLAY_INLINE_BLOCK: *ptr += sprintf(*ptr, "inline-block"); break; case DISPLAY_TABLE: *ptr += sprintf(*ptr, "table"); break; case DISPLAY_INLINE_TABLE: *ptr += sprintf(*ptr, "inline-table"); break; case DISPLAY_TABLE_ROW_GROUP: *ptr += sprintf(*ptr, "table-row-group"); break; case DISPLAY_TABLE_HEADER_GROUP: *ptr += sprintf(*ptr, "table-header-group"); break; case DISPLAY_TABLE_FOOTER_GROUP: *ptr += sprintf(*ptr, "table-footer-group"); break; case DISPLAY_TABLE_ROW: *ptr += sprintf(*ptr, "table-row"); break; case DISPLAY_TABLE_COLUMN_GROUP: *ptr += sprintf(*ptr, "table-column-group"); break; case DISPLAY_TABLE_COLUMN: *ptr += sprintf(*ptr, "table-column"); break; case DISPLAY_TABLE_CELL: *ptr += sprintf(*ptr, "table-cell"); break; case DISPLAY_TABLE_CAPTION: *ptr += sprintf(*ptr, "table-caption"); break; case DISPLAY_NONE: *ptr += sprintf(*ptr, "none"); break; case DISPLAY_FLEX: *ptr += sprintf(*ptr, "flex"); break; case DISPLAY_INLINE_FLEX: *ptr += sprintf(*ptr, "inline-flex"); break; } break; case CSS_PROP_ELEVATION: switch (value) { case ELEVATION_ANGLE: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case ELEVATION_BELOW: *ptr += sprintf(*ptr, "below"); break; case ELEVATION_LEVEL: *ptr += sprintf(*ptr, "level"); break; case ELEVATION_ABOVE: *ptr += sprintf(*ptr, "above"); break; case ELEVATION_HIGHER: *ptr += sprintf(*ptr, "higher"); break; case ELEVATION_LOWER: *ptr += sprintf(*ptr, "lower"); break; } break; case CSS_PROP_EMPTY_CELLS: switch (value) { case EMPTY_CELLS_SHOW: *ptr += sprintf(*ptr, "show"); break; case EMPTY_CELLS_HIDE: *ptr += sprintf(*ptr, "hide"); break; } break; case CSS_PROP_FLEX_BASIS: switch (value) { case FLEX_BASIS_AUTO: *ptr += sprintf(*ptr, "auto"); break; case FLEX_BASIS_CONTENT: *ptr += sprintf(*ptr, "content"); break; case FLEX_BASIS_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; } break; case CSS_PROP_FLEX_DIRECTION: switch (value) { case FLEX_DIRECTION_ROW: *ptr += sprintf(*ptr, "row"); break; case FLEX_DIRECTION_COLUMN: *ptr += sprintf(*ptr, "column"); break; case FLEX_DIRECTION_ROW_REVERSE: *ptr += sprintf(*ptr, "row-reverse"); break; case FLEX_DIRECTION_COLUMN_REVERSE: *ptr += sprintf(*ptr, "column-reverse"); break; } break; case CSS_PROP_FLEX_GROW: switch (value) { case FLEX_GROW_SET: { css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); dump_number(val, ptr); } break; } break; case CSS_PROP_FLEX_SHRINK: switch (value) { case FLEX_SHRINK_SET: { css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); dump_number(val, ptr); } break; } break; case CSS_PROP_FLEX_WRAP: switch (value) { case FLEX_WRAP_NOWRAP: *ptr += sprintf(*ptr, "nowrap"); break; case FLEX_WRAP_WRAP: *ptr += sprintf(*ptr, "wrap"); break; case FLEX_WRAP_WRAP_REVERSE: *ptr += sprintf(*ptr, "wrap-reverse"); break; } break; case CSS_PROP_FLOAT: switch (value) { case FLOAT_LEFT: *ptr += sprintf(*ptr, "left"); break; case FLOAT_RIGHT: *ptr += sprintf(*ptr, "right"); break; case FLOAT_NONE: *ptr += sprintf(*ptr, "none"); break; } break; case CSS_PROP_FONT_FAMILY: while (value != FONT_FAMILY_END) { switch (value) { case FONT_FAMILY_STRING: case FONT_FAMILY_IDENT_LIST: { uint32_t snum = *((uint32_t *) bytecode); lwc_string *he; css__stylesheet_string_get(style->sheet, snum, &he); ADVANCE(sizeof(snum)); *ptr += sprintf(*ptr, "'%.*s'", (int) lwc_string_length(he), lwc_string_data(he)); } break; case FONT_FAMILY_SERIF: *ptr += sprintf(*ptr, "serif"); break; case FONT_FAMILY_SANS_SERIF: *ptr += sprintf(*ptr, "sans-serif"); break; case FONT_FAMILY_CURSIVE: *ptr += sprintf(*ptr, "cursive"); break; case FONT_FAMILY_FANTASY: *ptr += sprintf(*ptr, "fantasy"); break; case FONT_FAMILY_MONOSPACE: *ptr += sprintf(*ptr, "monospace"); break; } value = *((uint32_t *) bytecode); ADVANCE(sizeof(value)); if (value != FONT_FAMILY_END) *ptr += sprintf(*ptr, ", "); } break; case CSS_PROP_FONT_SIZE: switch (value) { case FONT_SIZE_DIMENSION: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case FONT_SIZE_XX_SMALL: *ptr += sprintf(*ptr, "xx-small"); break; case FONT_SIZE_X_SMALL: *ptr += sprintf(*ptr, "x-small"); break; case FONT_SIZE_SMALL: *ptr += sprintf(*ptr, "small"); break; case FONT_SIZE_MEDIUM: *ptr += sprintf(*ptr, "medium"); break; case FONT_SIZE_LARGE: *ptr += sprintf(*ptr, "large"); break; case FONT_SIZE_X_LARGE: *ptr += sprintf(*ptr, "x-large"); break; case FONT_SIZE_XX_LARGE: *ptr += sprintf(*ptr, "xx-large"); break; case FONT_SIZE_LARGER: *ptr += sprintf(*ptr, "larger"); break; case FONT_SIZE_SMALLER: *ptr += sprintf(*ptr, "smaller"); break; } break; case CSS_PROP_FONT_STYLE: switch (value) { case FONT_STYLE_NORMAL: *ptr += sprintf(*ptr, "normal"); break; case FONT_STYLE_ITALIC: *ptr += sprintf(*ptr, "italic"); break; case FONT_STYLE_OBLIQUE: *ptr += sprintf(*ptr, "oblique"); break; } break; case CSS_PROP_FONT_VARIANT: switch (value) { case FONT_VARIANT_NORMAL: *ptr += sprintf(*ptr, "normal"); break; case FONT_VARIANT_SMALL_CAPS: *ptr += sprintf(*ptr, "small-caps"); break; } break; case CSS_PROP_FONT_WEIGHT: switch (value) { case FONT_WEIGHT_NORMAL: *ptr += sprintf(*ptr, "normal"); break; case FONT_WEIGHT_BOLD: *ptr += sprintf(*ptr, "bold"); break; case FONT_WEIGHT_BOLDER: *ptr += sprintf(*ptr, "bolder"); break; case FONT_WEIGHT_LIGHTER: *ptr += sprintf(*ptr, "lighter"); break; case FONT_WEIGHT_100: *ptr += sprintf(*ptr, "100"); break; case FONT_WEIGHT_200: *ptr += sprintf(*ptr, "200"); break; case FONT_WEIGHT_300: *ptr += sprintf(*ptr, "300"); break; case FONT_WEIGHT_400: *ptr += sprintf(*ptr, "400"); break; case FONT_WEIGHT_500: *ptr += sprintf(*ptr, "500"); break; case FONT_WEIGHT_600: *ptr += sprintf(*ptr, "600"); break; case FONT_WEIGHT_700: *ptr += sprintf(*ptr, "700"); break; case FONT_WEIGHT_800: *ptr += sprintf(*ptr, "800"); break; case FONT_WEIGHT_900: *ptr += sprintf(*ptr, "900"); break; } break; case CSS_PROP_JUSTIFY_CONTENT: switch (value) { case JUSTIFY_CONTENT_FLEX_START: *ptr += sprintf(*ptr, "flex-start"); break; case JUSTIFY_CONTENT_FLEX_END: *ptr += sprintf(*ptr, "flex-end"); break; case JUSTIFY_CONTENT_CENTER: *ptr += sprintf(*ptr, "center"); break; case JUSTIFY_CONTENT_SPACE_BETWEEN: *ptr += sprintf(*ptr, "space-between"); break; case JUSTIFY_CONTENT_SPACE_AROUND: *ptr += sprintf(*ptr, "space-around"); break; case JUSTIFY_CONTENT_SPACE_EVENLY: *ptr += sprintf(*ptr, "space-evenly"); break; } break; case CSS_PROP_LETTER_SPACING: case CSS_PROP_WORD_SPACING: assert(LETTER_SPACING_SET == (enum op_letter_spacing) WORD_SPACING_SET); assert(LETTER_SPACING_NORMAL == (enum op_letter_spacing) WORD_SPACING_NORMAL); switch (value) { case LETTER_SPACING_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case LETTER_SPACING_NORMAL: *ptr += sprintf(*ptr, "normal"); break; } break; case CSS_PROP_LINE_HEIGHT: switch (value) { case LINE_HEIGHT_NUMBER: { css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); dump_number(val, ptr); } break; case LINE_HEIGHT_DIMENSION: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case LINE_HEIGHT_NORMAL: *ptr += sprintf(*ptr, "normal"); break; } break; case CSS_PROP_LIST_STYLE_POSITION: switch (value) { case LIST_STYLE_POSITION_INSIDE: *ptr += sprintf(*ptr, "inside"); break; case LIST_STYLE_POSITION_OUTSIDE: *ptr += sprintf(*ptr, "outside"); break; } break; case CSS_PROP_LIST_STYLE_TYPE: switch (value) { case LIST_STYLE_TYPE_DISC: *ptr += sprintf(*ptr, "disc"); break; case LIST_STYLE_TYPE_CIRCLE: *ptr += sprintf(*ptr, "circle"); break; case LIST_STYLE_TYPE_SQUARE: *ptr += sprintf(*ptr, "square"); break; case LIST_STYLE_TYPE_DECIMAL: *ptr += sprintf(*ptr, "decimal"); break; case LIST_STYLE_TYPE_DECIMAL_LEADING_ZERO: *ptr += sprintf(*ptr, "decimal-leading-zero"); break; case LIST_STYLE_TYPE_LOWER_ROMAN: *ptr += sprintf(*ptr, "lower-roman"); break; case LIST_STYLE_TYPE_UPPER_ROMAN: *ptr += sprintf(*ptr, "upper-roman"); break; case LIST_STYLE_TYPE_LOWER_GREEK: *ptr += sprintf(*ptr, "lower-greek"); break; case LIST_STYLE_TYPE_LOWER_LATIN: *ptr += sprintf(*ptr, "lower-latin"); break; case LIST_STYLE_TYPE_UPPER_LATIN: *ptr += sprintf(*ptr, "upper-latin"); break; case LIST_STYLE_TYPE_ARMENIAN: *ptr += sprintf(*ptr, "armenian"); break; case LIST_STYLE_TYPE_GEORGIAN: *ptr += sprintf(*ptr, "georgian"); break; case LIST_STYLE_TYPE_LOWER_ALPHA: *ptr += sprintf(*ptr, "lower-alpha"); break; case LIST_STYLE_TYPE_UPPER_ALPHA: *ptr += sprintf(*ptr, "upper-alpha"); break; case LIST_STYLE_TYPE_NONE: *ptr += sprintf(*ptr, "none"); break; } break; case CSS_PROP_MAX_HEIGHT: case CSS_PROP_MAX_WIDTH: assert(MAX_HEIGHT_SET == (enum op_max_height) MAX_WIDTH_SET); assert(MAX_HEIGHT_NONE == (enum op_max_height) MAX_WIDTH_NONE); switch (value) { case MAX_HEIGHT_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case MAX_HEIGHT_NONE: *ptr += sprintf(*ptr, "none"); break; } break; case CSS_PROP_MIN_HEIGHT: case CSS_PROP_MIN_WIDTH: assert(MIN_HEIGHT_SET == (enum op_min_height) MIN_WIDTH_SET); assert(MIN_HEIGHT_AUTO == (enum op_min_height) MIN_WIDTH_AUTO); switch (value) { case MIN_HEIGHT_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case MIN_HEIGHT_AUTO: *ptr += sprintf(*ptr, "auto"); break; } break; case CSS_PROP_OPACITY: switch (value) { case OPACITY_SET: { css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); dump_number(val, ptr); } break; } break; case CSS_PROP_ORDER: switch (value) { case ORDER_SET: { css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); dump_number(val, ptr); } break; } break; case CSS_PROP_PADDING_TOP: case CSS_PROP_PADDING_RIGHT: case CSS_PROP_PADDING_BOTTOM: case CSS_PROP_PADDING_LEFT: case CSS_PROP_PAUSE_AFTER: case CSS_PROP_PAUSE_BEFORE: case CSS_PROP_TEXT_INDENT: assert(TEXT_INDENT_SET == (enum op_text_indent) PADDING_SET); assert(TEXT_INDENT_SET == (enum op_text_indent) PAUSE_AFTER_SET); assert(TEXT_INDENT_SET == (enum op_text_indent) PAUSE_BEFORE_SET); switch (value) { case TEXT_INDENT_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; } 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 == (enum op_orphans) PITCH_RANGE_SET); assert(ORPHANS_SET == (enum op_orphans) RICHNESS_SET); assert(ORPHANS_SET == (enum op_orphans) STRESS_SET); assert(ORPHANS_SET == (enum op_orphans) WIDOWS_SET); switch (value) { case ORPHANS_SET: { css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); dump_number(val, ptr); } break; } break; case CSS_PROP_OUTLINE_COLOR: switch (value) { case OUTLINE_COLOR_TRANSPARENT: *ptr += sprintf(*ptr, "transparent"); break; case OUTLINE_COLOR_CURRENT_COLOR: *ptr += sprintf(*ptr, "currentColor"); break; case OUTLINE_COLOR_SET: { uint32_t colour = *((uint32_t *) bytecode); ADVANCE(sizeof(colour)); *ptr += sprintf(*ptr, "#%08x", colour); } break; case OUTLINE_COLOR_INVERT: *ptr += sprintf(*ptr, "invert"); break; } break; case CSS_PROP_OVERFLOW_X: case CSS_PROP_OVERFLOW_Y: switch (value) { case OVERFLOW_VISIBLE: *ptr += sprintf(*ptr, "visible"); break; case OVERFLOW_HIDDEN: *ptr += sprintf(*ptr, "hidden"); break; case OVERFLOW_SCROLL: *ptr += sprintf(*ptr, "scroll"); break; case OVERFLOW_AUTO: *ptr += sprintf(*ptr, "auto"); break; } break; case CSS_PROP_PAGE_BREAK_AFTER: case CSS_PROP_PAGE_BREAK_BEFORE: assert(PAGE_BREAK_AFTER_AUTO == (enum op_page_break_after) PAGE_BREAK_BEFORE_AUTO); assert(PAGE_BREAK_AFTER_ALWAYS == (enum op_page_break_after) PAGE_BREAK_BEFORE_ALWAYS); assert(PAGE_BREAK_AFTER_AVOID == (enum op_page_break_after) PAGE_BREAK_BEFORE_AVOID); assert(PAGE_BREAK_AFTER_LEFT == (enum op_page_break_after) PAGE_BREAK_BEFORE_LEFT); assert(PAGE_BREAK_AFTER_RIGHT == (enum op_page_break_after) PAGE_BREAK_BEFORE_RIGHT); switch (value) { case PAGE_BREAK_AFTER_AUTO: *ptr += sprintf(*ptr, "auto"); break; case PAGE_BREAK_AFTER_ALWAYS: *ptr += sprintf(*ptr, "always"); break; case PAGE_BREAK_AFTER_AVOID: *ptr += sprintf(*ptr, "avoid"); break; case PAGE_BREAK_AFTER_LEFT: *ptr += sprintf(*ptr, "left"); break; case PAGE_BREAK_AFTER_RIGHT: *ptr += sprintf(*ptr, "right"); break; } break; case CSS_PROP_PAGE_BREAK_INSIDE: switch (value) { case PAGE_BREAK_INSIDE_AUTO: *ptr += sprintf(*ptr, "auto"); break; case PAGE_BREAK_INSIDE_AVOID: *ptr += sprintf(*ptr, "avoid"); break; } break; case CSS_PROP_PITCH: switch (value) { case PITCH_FREQUENCY: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case PITCH_X_LOW: *ptr += sprintf(*ptr, "x-low"); break; case PITCH_LOW: *ptr += sprintf(*ptr, "low"); break; case PITCH_MEDIUM: *ptr += sprintf(*ptr, "medium"); break; case PITCH_HIGH: *ptr += sprintf(*ptr, "high"); break; case PITCH_X_HIGH: *ptr += sprintf(*ptr, "x-high"); break; } break; case CSS_PROP_PLAY_DURING: switch (value) { case PLAY_DURING_URI: { uint32_t snum = *((uint32_t *) bytecode); lwc_string *he; css__stylesheet_string_get(style->sheet, snum, &he); ADVANCE(sizeof(snum)); *ptr += sprintf(*ptr, "'%.*s'", (int) lwc_string_length(he), lwc_string_data(he)); } break; case PLAY_DURING_AUTO: *ptr += sprintf(*ptr, "auto"); break; case PLAY_DURING_NONE: *ptr += sprintf(*ptr, "none"); break; } if (value & PLAY_DURING_MIX) *ptr += sprintf(*ptr, " mix"); if (value & PLAY_DURING_REPEAT) *ptr += sprintf(*ptr, " repeat"); break; case CSS_PROP_POSITION: switch (value) { case POSITION_STATIC: *ptr += sprintf(*ptr, "static"); break; case POSITION_RELATIVE: *ptr += sprintf(*ptr, "relative"); break; case POSITION_ABSOLUTE: *ptr += sprintf(*ptr, "absolute"); break; case POSITION_FIXED: *ptr += sprintf(*ptr, "fixed"); break; } break; case CSS_PROP_QUOTES: switch (value) { case QUOTES_STRING: while (value != QUOTES_NONE) { uint32_t snum = *((uint32_t *) bytecode); lwc_string *he; css__stylesheet_string_get(style->sheet, snum, &he); ADVANCE(sizeof(snum)); *ptr += sprintf(*ptr, " '%.*s' ", (int) lwc_string_length(he), lwc_string_data(he)); css__stylesheet_string_get(style->sheet, snum, &he); ADVANCE(sizeof(he)); *ptr += sprintf(*ptr, " '%.*s' ", (int) lwc_string_length(he), lwc_string_data(he)); value = *((uint32_t *) bytecode); ADVANCE(sizeof(value)); } break; case QUOTES_NONE: *ptr += sprintf(*ptr, "none"); break; } break; case CSS_PROP_SPEAK_HEADER: switch (value) { case SPEAK_HEADER_ONCE: *ptr += sprintf(*ptr, "once"); break; case SPEAK_HEADER_ALWAYS: *ptr += sprintf(*ptr, "always"); break; } break; case CSS_PROP_SPEAK_NUMERAL: switch (value) { case SPEAK_NUMERAL_DIGITS: *ptr += sprintf(*ptr, "digits"); break; case SPEAK_NUMERAL_CONTINUOUS: *ptr += sprintf(*ptr, "continuous"); break; } break; case CSS_PROP_SPEAK_PUNCTUATION: switch (value) { case SPEAK_PUNCTUATION_CODE: *ptr += sprintf(*ptr, "code"); break; case SPEAK_PUNCTUATION_NONE: *ptr += sprintf(*ptr, "none"); break; } break; case CSS_PROP_SPEAK: switch (value) { case SPEAK_NORMAL: *ptr += sprintf(*ptr, "normal"); break; case SPEAK_NONE: *ptr += sprintf(*ptr, "none"); break; case SPEAK_SPELL_OUT: *ptr += sprintf(*ptr, "spell-out"); break; } break; case CSS_PROP_SPEECH_RATE: switch (value) { case SPEECH_RATE_SET: { css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); dump_number(val, ptr); } break; case SPEECH_RATE_X_SLOW: *ptr += sprintf(*ptr, "x-slow"); break; case SPEECH_RATE_SLOW: *ptr += sprintf(*ptr, "slow"); break; case SPEECH_RATE_MEDIUM: *ptr += sprintf(*ptr, "medium"); break; case SPEECH_RATE_FAST: *ptr += sprintf(*ptr, "fast"); break; case SPEECH_RATE_X_FAST: *ptr += sprintf(*ptr, "x-fast"); break; case SPEECH_RATE_FASTER: *ptr += sprintf(*ptr, "faster"); break; case SPEECH_RATE_SLOWER: *ptr += sprintf(*ptr, "slower"); break; } break; case CSS_PROP_TABLE_LAYOUT: switch (value) { case TABLE_LAYOUT_AUTO: *ptr += sprintf(*ptr, "auto"); break; case TABLE_LAYOUT_FIXED: *ptr += sprintf(*ptr, "fixed"); break; } break; case CSS_PROP_TEXT_ALIGN: switch (value) { case TEXT_ALIGN_LEFT: *ptr += sprintf(*ptr, "left"); break; case TEXT_ALIGN_RIGHT: *ptr += sprintf(*ptr, "right"); break; case TEXT_ALIGN_CENTER: *ptr += sprintf(*ptr, "center"); break; case TEXT_ALIGN_JUSTIFY: *ptr += sprintf(*ptr, "justify"); break; case TEXT_ALIGN_LIBCSS_LEFT: *ptr += sprintf(*ptr, "-libcss-left"); break; case TEXT_ALIGN_LIBCSS_CENTER: *ptr += sprintf(*ptr, "-libcss-center"); break; case TEXT_ALIGN_LIBCSS_RIGHT: *ptr += sprintf(*ptr, "-libcss-right"); break; } break; case CSS_PROP_TEXT_DECORATION: if (value == TEXT_DECORATION_NONE) *ptr += sprintf(*ptr, "none"); if (value & TEXT_DECORATION_UNDERLINE) *ptr += sprintf(*ptr, " underline"); if (value & TEXT_DECORATION_OVERLINE) *ptr += sprintf(*ptr, " overline"); if (value & TEXT_DECORATION_LINE_THROUGH) *ptr += sprintf(*ptr, " line-through"); if (value & TEXT_DECORATION_BLINK) *ptr += sprintf(*ptr, " blink"); break; case CSS_PROP_TEXT_TRANSFORM: switch (value) { case TEXT_TRANSFORM_CAPITALIZE: *ptr += sprintf(*ptr, "capitalize"); break; case TEXT_TRANSFORM_UPPERCASE: *ptr += sprintf(*ptr, "uppercase"); break; case TEXT_TRANSFORM_LOWERCASE: *ptr += sprintf(*ptr, "lowercase"); break; case TEXT_TRANSFORM_NONE: *ptr += sprintf(*ptr, "none"); break; } break; case CSS_PROP_UNICODE_BIDI: switch (value) { case UNICODE_BIDI_NORMAL: *ptr += sprintf(*ptr, "normal"); break; case UNICODE_BIDI_EMBED: *ptr += sprintf(*ptr, "embed"); break; case UNICODE_BIDI_BIDI_OVERRIDE: *ptr += sprintf(*ptr, "bidi-override"); break; } break; case CSS_PROP_VERTICAL_ALIGN: switch (value) { case VERTICAL_ALIGN_SET: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case VERTICAL_ALIGN_BASELINE: *ptr += sprintf(*ptr, "baseline"); break; case VERTICAL_ALIGN_SUB: *ptr += sprintf(*ptr, "sub"); break; case VERTICAL_ALIGN_SUPER: *ptr += sprintf(*ptr, "super"); break; case VERTICAL_ALIGN_TOP: *ptr += sprintf(*ptr, "top"); break; case VERTICAL_ALIGN_TEXT_TOP: *ptr += sprintf(*ptr, "text-top"); break; case VERTICAL_ALIGN_MIDDLE: *ptr += sprintf(*ptr, "middle"); break; case VERTICAL_ALIGN_BOTTOM: *ptr += sprintf(*ptr, "bottom"); break; case VERTICAL_ALIGN_TEXT_BOTTOM: *ptr += sprintf(*ptr, "text-bottom"); break; } break; case CSS_PROP_VISIBILITY: switch (value) { case VISIBILITY_VISIBLE: *ptr += sprintf(*ptr, "visible"); break; case VISIBILITY_HIDDEN: *ptr += sprintf(*ptr, "hidden"); break; case VISIBILITY_COLLAPSE: *ptr += sprintf(*ptr, "collapse"); break; } break; case CSS_PROP_VOICE_FAMILY: while (value != VOICE_FAMILY_END) { switch (value) { case VOICE_FAMILY_STRING: case VOICE_FAMILY_IDENT_LIST: { uint32_t snum = *((uint32_t *) bytecode); lwc_string *he; css__stylesheet_string_get(style->sheet, snum, &he); ADVANCE(sizeof(snum)); *ptr += sprintf(*ptr, "'%.*s'", (int) lwc_string_length(he), lwc_string_data(he)); } break; case VOICE_FAMILY_MALE: *ptr += sprintf(*ptr, "male"); break; case VOICE_FAMILY_FEMALE: *ptr += sprintf(*ptr, "female"); break; case VOICE_FAMILY_CHILD: *ptr += sprintf(*ptr, "child"); break; } value = *((uint32_t *) bytecode); ADVANCE(sizeof(value)); if (value != VOICE_FAMILY_END) *ptr += sprintf(*ptr, ", "); } break; case CSS_PROP_VOLUME: switch (value) { case VOLUME_NUMBER: { css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); dump_number(val, ptr); } break; case VOLUME_DIMENSION: { uint32_t unit; css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); unit = *((uint32_t *) bytecode); ADVANCE(sizeof(unit)); dump_unit(val, unit, ptr); } break; case VOLUME_SILENT: *ptr += sprintf(*ptr, "silent"); break; case VOLUME_X_SOFT: *ptr += sprintf(*ptr, "x-soft"); break; case VOLUME_SOFT: *ptr += sprintf(*ptr, "soft"); break; case VOLUME_MEDIUM: *ptr += sprintf(*ptr, "medium"); break; case VOLUME_LOUD: *ptr += sprintf(*ptr, "loud"); break; case VOLUME_X_LOUD: *ptr += sprintf(*ptr, "x-loud"); break; } break; case CSS_PROP_WHITE_SPACE: switch (value) { case WHITE_SPACE_NORMAL: *ptr += sprintf(*ptr, "normal"); break; case WHITE_SPACE_PRE: *ptr += sprintf(*ptr, "pre"); break; case WHITE_SPACE_NOWRAP: *ptr += sprintf(*ptr, "nowrap"); break; case WHITE_SPACE_PRE_WRAP: *ptr += sprintf(*ptr, "pre-wrap"); break; case WHITE_SPACE_PRE_LINE: *ptr += sprintf(*ptr, "pre-line"); break; } break; case CSS_PROP_WRITING_MODE: switch (value) { case WRITING_MODE_HORIZONTAL_TB: *ptr += sprintf(*ptr, "horizontal-tb"); break; case WRITING_MODE_VERTICAL_RL: *ptr += sprintf(*ptr, "vertical-rl"); break; case WRITING_MODE_VERTICAL_LR: *ptr += sprintf(*ptr, "vertical-lr"); break; } break; case CSS_PROP_Z_INDEX: switch (value) { case Z_INDEX_SET: { css_fixed val = *((css_fixed *) bytecode); ADVANCE(sizeof(val)); dump_number(val, ptr); } break; case Z_INDEX_AUTO: *ptr += sprintf(*ptr, "auto"); break; } break; default: *ptr += sprintf(*ptr, "Unknown opcode %x", op); return; } } if (isImportant(opv)) *ptr += sprintf(*ptr, " !important"); *ptr += sprintf(*ptr, "\n"); } #undef ADVANCE } void dump_string(lwc_string *string, char **ptr) { *ptr += sprintf(*ptr, "%.*s", (int) lwc_string_length(string), lwc_string_data(string)); } void dump_font_face(css_font_face *font_face, char **ptr) { uint8_t style, weight; if (font_face->font_family != NULL) { *(*ptr)++ = '\n'; *ptr += sprintf(*ptr, "| font-family: %.*s", (int) lwc_string_length(font_face->font_family), lwc_string_data(font_face->font_family)); } *ptr += sprintf(*ptr, "\n| font-style: "); style = css_font_face_font_style(font_face); switch (style) { case CSS_FONT_STYLE_INHERIT: *ptr += sprintf(*ptr, "unspecified"); break; case CSS_FONT_STYLE_NORMAL: *ptr += sprintf(*ptr, "normal"); break; case CSS_FONT_STYLE_ITALIC: *ptr += sprintf(*ptr, "italic"); break; case CSS_FONT_STYLE_OBLIQUE: *ptr += sprintf(*ptr, "oblique"); break; } *ptr += sprintf(*ptr, "\n| font-weight: "); weight = css_font_face_font_weight(font_face); switch (weight) { case CSS_FONT_WEIGHT_INHERIT: *ptr += sprintf(*ptr, "unspecified"); break; case CSS_FONT_WEIGHT_NORMAL: *ptr += sprintf(*ptr, "normal"); break; case CSS_FONT_WEIGHT_BOLD: *ptr += sprintf(*ptr, "bold"); break; case CSS_FONT_WEIGHT_100: *ptr += sprintf(*ptr, "100"); break; case CSS_FONT_WEIGHT_200: *ptr += sprintf(*ptr, "200"); break; case CSS_FONT_WEIGHT_300: *ptr += sprintf(*ptr, "300"); break; case CSS_FONT_WEIGHT_400: *ptr += sprintf(*ptr, "400"); break; case CSS_FONT_WEIGHT_500: *ptr += sprintf(*ptr, "500"); break; case CSS_FONT_WEIGHT_600: *ptr += sprintf(*ptr, "600"); break; case CSS_FONT_WEIGHT_700: *ptr += sprintf(*ptr, "700"); break; case CSS_FONT_WEIGHT_800: *ptr += sprintf(*ptr, "800"); break; case CSS_FONT_WEIGHT_900: *ptr += sprintf(*ptr, "900"); break; default: *ptr += sprintf(*ptr, "Unhandled weight %d\n", (int)weight); break; } if (font_face->srcs != NULL) { uint32_t i; css_font_face_src *srcs = font_face->srcs; for (i = 0; i < font_face->n_srcs; ++i) { css_font_face_format format; *ptr += sprintf(*ptr, "\n| src: "); format = css_font_face_src_format(&srcs[i]); *ptr += sprintf(*ptr, "\n| format: "); switch (format) { case CSS_FONT_FACE_FORMAT_UNSPECIFIED: *ptr += sprintf(*ptr, "unspecified"); break; case CSS_FONT_FACE_FORMAT_WOFF: *ptr += sprintf(*ptr, "WOFF"); break; case CSS_FONT_FACE_FORMAT_OPENTYPE: *ptr += sprintf(*ptr, "OTF"); break; case CSS_FONT_FACE_FORMAT_EMBEDDED_OPENTYPE: *ptr += sprintf(*ptr, "EOTF"); break; case CSS_FONT_FACE_FORMAT_SVG: *ptr += sprintf(*ptr, "SVG"); break; case CSS_FONT_FACE_FORMAT_UNKNOWN: *ptr += sprintf(*ptr, "unknown"); break; default: *ptr += sprintf(*ptr, "UNEXPECTED"); break; } if (srcs[i].location != NULL) { *ptr += sprintf(*ptr, "\n| location: "); switch (css_font_face_src_location_type( &srcs[i])) { case CSS_FONT_FACE_LOCATION_TYPE_LOCAL: *ptr += sprintf(*ptr, "local"); break; case CSS_FONT_FACE_LOCATION_TYPE_URI: *ptr += sprintf(*ptr, "url"); break; default: *ptr += sprintf(*ptr, "UNKNOWN"); break; } *ptr += sprintf(*ptr, "(%.*s)", (int) lwc_string_length( srcs[i].location), lwc_string_data(srcs[i].location)); } } } } #endif