Aren/kolibrios
1
0
Fork 0
mirror of https://github.com/KolibriOS/kolibrios.git synced 2024-12-23 23:26:49 +03:00
Code Issues Packages Projects Releases Wiki Activity
038f3f8566
kolibrios/programs/network/netsurf/libcss/test/dump.h
Dmitry Pereverzev (SoUrcerer) 370da47fa0 Netsurf initial port (still needs native ui and cURL) 
git-svn-id: svn://kolibrios.org@3584 a494cfbc-eb01-0410-851d-a64ba20cac60
2013-06-01 17:14:14 +00:00

2703 lines
64 KiB
C
Raw Blame History

#ifndef test_dump_h_
#define test_dump_h_
#include <string.h>
#include <libcss/types.h>
#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",
"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",
};
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_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);
ADVANCE(sizeof(opv));
op = getOpcode(opv);
*((*ptr)++) = '|';
for (uint32_t 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_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_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;
}
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_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_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_OPACITY:
switch (value) {
case OPACITY_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_MIN_HEIGHT:
case CSS_PROP_MIN_WIDTH:
case CSS_PROP_PAUSE_AFTER:
case CSS_PROP_PAUSE_BEFORE:
case CSS_PROP_TEXT_INDENT:
assert(MIN_HEIGHT_SET ==
(enum op_min_height)
MIN_WIDTH_SET);
assert(MIN_HEIGHT_SET ==
(enum op_min_height)
PADDING_SET);
assert(MIN_HEIGHT_SET ==
(enum op_min_height)
PAUSE_AFTER_SET);
assert(MIN_HEIGHT_SET ==
(enum op_min_height)
PAUSE_BEFORE_SET);
assert(MIN_HEIGHT_SET ==
(enum op_min_height)
TEXT_INDENT_SET);
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;
}
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:
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_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) {
*ptr += sprintf(*ptr, "\n| src: ");
css_font_face_format 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
Reference in New Issue View Git Blame Copy Permalink