Complete bytecode dumping code.

Change a few opcode values to be more consistent (namely, bit 7 set generally implies that there's data to follow).

svn path=/trunk/libcss/; revision=6048

3 files changed, 1689 insertions, 60 deletions

diff --git a/docs/Bytecode b/docs/Bytecode
index 4f4dcf9..e4c9e26 100644
--- a/docs/Bytecode
+++ b/docs/Bytecode
@@ -199,8 +199,11 @@ Opcodes
 07 - border-spacing
 	<value> (14bits) :
 		bits 8-13: MBZ
-		bits 0-7 : 00000000 => two lengths follow,
-			   other    => Reserved for future expansion.	
+		bits 0-7 :
+			bit 7: set => two lengths follow
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion.
+			       		bits 0-6: MBZ
 
 08 - border-{top,right,bottom,left}-color
 	<value> (14bits) :
@@ -210,9 +213,11 @@ Opcodes
 			01 => right
 			10 => bottom
 			11 => left
-		bits 0-7  : 00000000 => colour follows,
-			    00000001 => transparent,
-			    other    => Reserved for future expansion.
+		bit 7 set => colour follows.
+			bits 0-6: MBZ
+		bit 7 clear => keyword colour:
+			bits 1-6: MBZ
+			bit 0   : clear => transparent, set => rffe.
 
 09 - border-{top,right,bottom,left}-style
 	<value> (14bits) :
@@ -309,8 +314,10 @@ Opcodes
 	<value> (14bits) :
 		bits 8-13: MBZ
 		bits 0-7: 
-			00000000 => colour follows,
-			other    => Reserved for future expansion.
+			bit 7: set => colour follows.
+					bits 0-6: MBZ.
+			       clear => Reserved for future expansion.
+			       		bits 0-6: MBZ.
 
 10 - content
 	<value> (14bits) :
@@ -510,9 +517,9 @@ Opcodes
 					  0000101 => monospace,
 					  other   => rffe.
 
-	If the value indicates that data follows, then there is a parameter 
-	list. Each item is preceded by a <value> word which declares the type 
-	of the next item. The list is terminated by a word with	all bits clear.
+	In all cases, there is a parameter list. Each item is preceded by a 
+	<value> word which declares the type of the next item. The list is 
+	terminated by a word with all bits clear.
 
 1c - font-size
 	<value> (14bits) :
@@ -679,22 +686,28 @@ Opcodes
 	<value> (14bits) :
 		bits 8-13: MBZ
 		bits 0-7 :
-			00000000 => length or percentage follows,
-			other    => Reserved for future expansion.
+			bit 7: set => length or percentage follows
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion
+			       		bits 0-6: MBZ
 
 2b - min-width
 	<value> (14bits) :
 		bits 8-13: MBZ
 		bits 0-7 :
-			00000000 => length or percentage follows,
-			other    => Reserved for future expansion.
+			bit 7: set => length or percentage follows
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion
+			       		bits 0-6: MBZ
 
 2c - orphans
 	<value> (14bits) :
 		bits 8-13: MBZ
 		bits 0-7 :
-			00000000 => integer follows,
-			other    => Reserved for future expansion.
+			bit 7: set => integer follows
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion
+			       		bits 0-6: MBZ
 
 2d - outline-color
 	<value> (14bits) :
@@ -750,9 +763,11 @@ Opcodes
 			01 => right,
 			10 => bottom,
 			11 => left
-		bits 0-7  :
-			00000000 => length or percentage follows,
-			other    => Reserved for future expansion.
+		bits 0-7 :
+			bit 7: set => length or percentage follows
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion
+			       		bits 0-6: MBZ
 
 32 - page-break-after
 	<value> (14bits) :
@@ -782,22 +797,28 @@ Opcodes
 	<value> (14bits) :
 		bits 8-13: MBZ
 		bits 0-7 :
-			00000000 => time or percentage follows,
-			other    => Reserved for future expansion.
+			bit 7: set => time or percentage follows
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion
+			       		bits 0-6: MBZ
 
 36 - pause-before
 	<value> (14bits) :
 		bits 8-13: MBZ
 		bits 0-7 :
-			00000000 => time or percentage follows,
-			other    => Reserved for future expansion.
+			bit 7: set => time or percentage follows
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion
+			       		bits 0-6: MBZ
 
 37 - pitch-range
 	<value> (14bits) :
 		bits 8-13: MBZ
 		bits 0-7 :
-			00000000 => number follows,
-			other    => Reserved for future expansion.
+			bit 7: set => number follows
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion
+			       		bits 0-6: MBZ
 
 38 - pitch
 	<value> (14bits) :
@@ -853,8 +874,10 @@ Opcodes
 	<value> (14bits) :
 		bits 8-13: MBZ
 		bits 0-7 :
-			00000000 => number follows,
-			other    => Reserved for future expansion.
+			bit 7: set => number follows
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion
+			       		bits 0-6: MBZ
 
 3d - right
 	<value> (14bits) :
@@ -911,8 +934,10 @@ Opcodes
 	<value> (14bits) :
 		bits 8-13: MBZ
 		bits 0-7 :
-			00000000 => number follows,
-			other    => Reserved for future expansion.
+			bit 7: set => number follows
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion
+			       		bits 0-6: MBZ
 
 44 - table-layout
 	<value> (14bits) :
@@ -945,8 +970,10 @@ Opcodes
 	<value> (14bits) :
 		bits 8-13: MBZ
 		bits 0-7 :
-			00000000 => length or percentage follows,
-			other    => Reserved for future expansion.
+			bit 7: set => length or percentage follows
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion
+			       		bits 0-6: MBZ
 
 48 - text-transform
 	<value> (14bits) :
@@ -1010,10 +1037,9 @@ Opcodes
 					  0000011 => child,
 					  other   => rffe.
 
-	If the value indicates that a string is present, then there is a 
-	parameter list. Each item is preceded by a <value> word which declares
-	the type of the next item. The list is terminated by a word with
-	all bits clear.
+	In all cases, there is a parameter list. Each item is preceded by a 
+	<value> word which declares the type of the next item. The list is 
+	terminated by a word with all bits clear.
 	
 4e - volume
 	<value> (14bits) :
@@ -1045,8 +1071,10 @@ Opcodes
 	<value> (14bits) :
 		bits 8-13: MBZ
 		bits 0-7 :
-			00000000 => integer follows,
-			other    => Reserved for future expansion.
+			bit 7: set => integer follows
+					bits 0-6: MBZ
+			       clear => Reserved for future expansion
+			       		bits 0-6: MBZ
 
 51 - width
 	<value> (14bits) :
diff --git a/src/bytecode/dump.c b/src/bytecode/dump.c
index 0cf54c8..1299164 100644
--- a/src/bytecode/dump.c
+++ b/src/bytecode/dump.c
@@ -5,8 +5,11 @@
  * Copyright 2008 John-Mark Bell <jmb@netsurf-browser.org>
  */
 
+#include <assert.h>
+
 #include "bytecode/bytecode.h"
 #include "bytecode/opcodes.h"
+#include "utils/fpmath.h"
 
 /**
  * Opcode names, indexed by opcode
@@ -20,9 +23,9 @@ static const char *opcode_names[] = {
 	"background-repeat",
 	"border-collapse",
 	"border-spacing",
-	"border-trbl-color",
-	"border-trbl-style",
-	"border-trbl-width",
+	"border-%s-color",
+	"border-%s-style",
+	"border-%s-width",
 	"bottom",
 	"caption-side",
 	"clear",
@@ -51,7 +54,7 @@ static const char *opcode_names[] = {
 	"list-style-image",
 	"list-style-position",
 	"list-style-type",
-	"margin-trbl",
+	"margin-%s",
 	"max-height",
 	"max-width",
 	"min-height",
@@ -61,7 +64,7 @@ static const char *opcode_names[] = {
 	"outline-style",
 	"outline-width",
 	"overflow",
-	"padding-trbl",
+	"padding-%s",
 	"page-break-after",
 	"page-break-before",
 	"page-break-inside",
@@ -99,6 +102,193 @@ static const char *opcode_names[] = {
 };
 
 /**
+ * Sides, indexed by SIDE_*
+ */
+static const char *sides[] = { "top", "right", "bottom", "left" };
+
+static void dump_number(FILE *fp, fixed val)
+{
+	if (INTTOFIX(FIXTOINT(val)) == val)
+		fprintf(fp, "%d", FIXTOINT(val));
+	else
+		fprintf(fp, "%f", FIXTOFLT(val));
+}
+
+static void dump_unit(FILE *fp, fixed val, uint32_t unit)
+{
+	dump_number(fp, val);
+
+	switch (unit) {
+	case UNIT_PX:
+		fprintf(fp, "px");
+		break;
+	case UNIT_EX:
+		fprintf(fp, "ex");
+		break;
+	case UNIT_EM:
+		fprintf(fp, "em");
+		break;
+	case UNIT_IN:
+		fprintf(fp, "in");
+		break;
+	case UNIT_CM:
+		fprintf(fp, "cm");
+		break;
+	case UNIT_MM:
+		fprintf(fp, "mm");
+		break;
+	case UNIT_PT:
+		fprintf(fp, "pt");
+		break;
+	case UNIT_PC:
+		fprintf(fp, "pc");
+		break;
+	case UNIT_PCT:
+		fprintf(fp, "%%");
+		break;
+	case UNIT_DEG:
+		fprintf(fp, "deg");
+		break;
+	case UNIT_GRAD:
+		fprintf(fp, "grad");
+		break;
+	case UNIT_RAD:
+		fprintf(fp, "rad");
+		break;
+	case UNIT_MS:
+		fprintf(fp, "ms");
+		break;
+	case UNIT_S:
+		fprintf(fp, "s");
+		break;
+	case UNIT_HZ:
+		fprintf(fp, "Hz");
+		break;
+	case UNIT_KHZ:
+		fprintf(fp, "kHz");
+		break;
+	}
+}
+
+static void dump_counter(FILE *fp, const parserutils_hash_entry *name, 
+		uint32_t value)
+{
+	fprintf(fp, "counter(%.*s", (int) name->len, (char *) name->data);
+
+	value >>= CONTENT_COUNTER_STYLE_SHIFT;
+
+	switch (value) {
+	case LIST_STYLE_TYPE_DISC:
+		fprintf(fp, ", disc");
+		break;
+	case LIST_STYLE_TYPE_CIRCLE:
+		fprintf(fp, ", circle");
+		break;
+	case LIST_STYLE_TYPE_SQUARE:
+		fprintf(fp, ", square");
+		break;
+	case LIST_STYLE_TYPE_DECIMAL:
+		break;
+	case LIST_STYLE_TYPE_DECIMAL_LEADING_ZERO:
+		fprintf(fp, ", decimal-leading-zero");
+		break;
+	case LIST_STYLE_TYPE_LOWER_ROMAN:
+		fprintf(fp, ", lower-roman");
+		break;
+	case LIST_STYLE_TYPE_UPPER_ROMAN:
+		fprintf(fp, ", upper-roman");
+		break;
+	case LIST_STYLE_TYPE_LOWER_GREEK:
+		fprintf(fp, ", lower-greek");
+		break;
+	case LIST_STYLE_TYPE_LOWER_LATIN:
+		fprintf(fp, ", lower-latin");
+		break;
+	case LIST_STYLE_TYPE_UPPER_LATIN:
+		fprintf(fp, ", upper-latin");
+		break;
+	case LIST_STYLE_TYPE_ARMENIAN:
+		fprintf(fp, ", armenian");
+		break;
+	case LIST_STYLE_TYPE_GEORGIAN:
+		fprintf(fp, ", georgian");
+		break;
+	case LIST_STYLE_TYPE_LOWER_ALPHA:
+		fprintf(fp, ", lower-alpha");
+		break;
+	case LIST_STYLE_TYPE_UPPER_ALPHA:
+		fprintf(fp, ", upper-alpha");
+		break;
+	case LIST_STYLE_TYPE_NONE:
+		fprintf(fp, ", none");
+		break;
+	}
+
+	fprintf(fp, ")");
+}
+
+static void dump_counters(FILE *fp, const parserutils_hash_entry *name, 
+		const parserutils_hash_entry *separator,
+		uint32_t value)
+{
+	fprintf(fp, "counter(%.*s, %.*s", 
+			(int) name->len, (char *) name->data,
+			(int) separator->len, (char *) separator->data);
+
+	value >>= CONTENT_COUNTER_STYLE_SHIFT;
+
+	switch (value) {
+	case LIST_STYLE_TYPE_DISC:
+		fprintf(fp, ", disc");
+		break;
+	case LIST_STYLE_TYPE_CIRCLE:
+		fprintf(fp, ", circle");
+		break;
+	case LIST_STYLE_TYPE_SQUARE:
+		fprintf(fp, ", square");
+		break;
+	case LIST_STYLE_TYPE_DECIMAL:
+		break;
+	case LIST_STYLE_TYPE_DECIMAL_LEADING_ZERO:
+		fprintf(fp, ", decimal-leading-zero");
+		break;
+	case LIST_STYLE_TYPE_LOWER_ROMAN:
+		fprintf(fp, ", lower-roman");
+		break;
+	case LIST_STYLE_TYPE_UPPER_ROMAN:
+		fprintf(fp, ", upper-roman");
+		break;
+	case LIST_STYLE_TYPE_LOWER_GREEK:
+		fprintf(fp, ", lower-greek");
+		break;
+	case LIST_STYLE_TYPE_LOWER_LATIN:
+		fprintf(fp, ", lower-latin");
+		break;
+	case LIST_STYLE_TYPE_UPPER_LATIN:
+		fprintf(fp, ", upper-latin");
+		break;
+	case LIST_STYLE_TYPE_ARMENIAN:
+		fprintf(fp, ", armenian");
+		break;
+	case LIST_STYLE_TYPE_GEORGIAN:
+		fprintf(fp, ", georgian");
+		break;
+	case LIST_STYLE_TYPE_LOWER_ALPHA:
+		fprintf(fp, ", lower-alpha");
+		break;
+	case LIST_STYLE_TYPE_UPPER_ALPHA:
+		fprintf(fp, ", upper-alpha");
+		break;
+	case LIST_STYLE_TYPE_NONE:
+		fprintf(fp, ", none");
+		break;
+	}
+
+	fprintf(fp, ")");
+}
+
+
+/**
  * Dump a CSS bytecode stream to the given file handle
  * 
  * \param bytecode  The stream to dump
@@ -117,14 +307,21 @@ void css_bytecode_dump(void *bytecode, uint32_t length, FILE *fp)
 	while (offset < length) {
 		opcode op;
 		uint8_t flags;
-		uint16_t value;
+		uint32_t value;
 		uint32_t opv = *((uint32_t *) bytecode);
 
 		ADVANCE(sizeof(opv));
 
 		op = getOpcode(opv);
 
-		fprintf(fp, "%s: ", opcode_names[op]);
+		if (op == OP_BORDER_TRBL_COLOR || op == OP_BORDER_TRBL_STYLE ||
+				op == OP_BORDER_TRBL_WIDTH ||
+				op == OP_MARGIN_TRBL || op == OP_PADDING_TRBL) {
+			const uint32_t side = (getValue(opv) & SIDE_LEFT) >> 8;
+			fprintf(fp, opcode_names[op], sides[side]);
+			fprintf(fp, ": ");
+		} else
+			fprintf(fp, "%s: ", opcode_names[op]);
 
 		flags = getFlags(opv);
 
@@ -134,6 +331,55 @@ void css_bytecode_dump(void *bytecode, uint32_t length, FILE *fp)
 			value = getValue(opv);
 
 			switch (op) {
+			case OP_AZIMUTH:
+				switch (value) {
+				case AZIMUTH_ANGLE:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case AZIMUTH_LEFTWARDS:
+					fprintf(fp, "leftwards");
+					break;
+				case AZIMUTH_RIGHTWARDS:
+					fprintf(fp, "rightwards");
+					break;
+				case AZIMUTH_LEFT_SIDE:
+					fprintf(fp, "left-side");
+					break;
+				case AZIMUTH_FAR_LEFT:
+					fprintf(fp, "far-left");
+					break;
+				case AZIMUTH_LEFT:
+					fprintf(fp, "left");
+					break;
+				case AZIMUTH_CENTER_LEFT:
+					fprintf(fp, "center-left");
+					break;
+				case AZIMUTH_CENTER:
+					fprintf(fp, "center");
+					break;
+				case AZIMUTH_CENTER_RIGHT:
+					fprintf(fp, "center-right");
+					break;
+				case AZIMUTH_RIGHT:
+					fprintf(fp, "right");
+					break;
+				case AZIMUTH_FAR_RIGHT:
+					fprintf(fp, "far-right");
+					break;
+				case AZIMUTH_RIGHT_SIDE:
+					fprintf(fp, "right-side");
+					break;
+				}
+				if (value & AZIMUTH_BEHIND)
+					fprintf(fp, " behind");
+				break;
 			case OP_BACKGROUND_ATTACHMENT:
 				switch (value) {
 				case BACKGROUND_ATTACHMENT_FIXED:
@@ -145,6 +391,12 @@ void css_bytecode_dump(void *bytecode, uint32_t length, FILE *fp)
 				}
 				break;
 			case OP_BACKGROUND_COLOR:
+			case OP_BORDER_TRBL_COLOR:
+				assert(BACKGROUND_COLOR_TRANSPARENT == 
+						BORDER_COLOR_TRANSPARENT);
+				assert(BACKGROUND_COLOR_SET ==
+						BORDER_COLOR_SET);
+
 				switch (value) {
 				case BACKGROUND_COLOR_TRANSPARENT:
 					fprintf(fp, "transparent");
@@ -160,6 +412,18 @@ void css_bytecode_dump(void *bytecode, uint32_t length, FILE *fp)
 				}
 				break;
 			case OP_BACKGROUND_IMAGE:
+			case OP_CUE_AFTER:
+			case OP_CUE_BEFORE:
+			case OP_LIST_STYLE_IMAGE:
+				assert(BACKGROUND_IMAGE_NONE == CUE_AFTER_NONE);
+				assert(BACKGROUND_IMAGE_URI == CUE_AFTER_URI);
+				assert(BACKGROUND_IMAGE_NONE == CUE_BEFORE_NONE);
+				assert(BACKGROUND_IMAGE_URI == CUE_BEFORE_URI);
+				assert(BACKGROUND_IMAGE_NONE ==
+						LIST_STYLE_IMAGE_NONE);
+				assert(BACKGROUND_IMAGE_URI ==
+						LIST_STYLE_IMAGE_URI);
+
 				switch (value) {
 				case BACKGROUND_IMAGE_NONE:
 					fprintf(fp, "none");
@@ -177,6 +441,51 @@ void css_bytecode_dump(void *bytecode, uint32_t length, FILE *fp)
 					break;
 				}
 				break;
+			case OP_BACKGROUND_POSITION:
+				switch (value & 0xf0) {
+				case BACKGROUND_POSITION_HORZ_SET:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case BACKGROUND_POSITION_HORZ_CENTER:
+					fprintf(fp, "center");
+					break;
+				case BACKGROUND_POSITION_HORZ_RIGHT:
+					fprintf(fp, "right");
+					break;
+				case BACKGROUND_POSITION_HORZ_LEFT:
+					fprintf(fp, "left");
+					break;
+				}
+				fprintf(fp, " ");
+				switch (value & 0x0f) {
+				case BACKGROUND_POSITION_VERT_SET:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case BACKGROUND_POSITION_VERT_CENTER:
+					fprintf(fp, "center");
+					break;
+				case BACKGROUND_POSITION_VERT_BOTTOM:
+					fprintf(fp, "bottom");
+					break;
+				case BACKGROUND_POSITION_VERT_TOP:
+					fprintf(fp, "top");
+					break;
+				}
+				break;
 			case OP_BACKGROUND_REPEAT:
 				switch (value) {
 				case BACKGROUND_REPEAT_NO_REPEAT:
@@ -193,6 +502,174 @@ void css_bytecode_dump(void *bytecode, uint32_t length, FILE *fp)
 					break;
 				}
 				break;
+			case OP_BORDER_COLLAPSE:
+				switch (value) {
+				case BORDER_COLLAPSE_SEPARATE:
+					fprintf(fp, "separate");
+					break;
+				case BORDER_COLLAPSE_COLLAPSE:
+					fprintf(fp, "collapse");
+					break;
+				}
+				break;
+			case OP_BORDER_SPACING:
+				switch (value) {
+				case BORDER_SPACING_SET:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+
+					val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					unit = *((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				}
+				break;
+			case OP_BORDER_TRBL_STYLE:
+			case OP_OUTLINE_STYLE:
+				assert(BORDER_STYLE_NONE == OUTLINE_STYLE_NONE);
+				assert(BORDER_STYLE_HIDDEN == 
+						OUTLINE_STYLE_HIDDEN);
+				assert(BORDER_STYLE_DOTTED ==
+						OUTLINE_STYLE_DOTTED);
+				assert(BORDER_STYLE_DASHED ==
+						OUTLINE_STYLE_DASHED);
+				assert(BORDER_STYLE_SOLID ==
+						OUTLINE_STYLE_SOLID);
+				assert(BORDER_STYLE_DOUBLE ==
+						OUTLINE_STYLE_DOUBLE);
+				assert(BORDER_STYLE_GROOVE ==
+						OUTLINE_STYLE_GROOVE);
+				assert(BORDER_STYLE_RIDGE ==
+						OUTLINE_STYLE_RIDGE);
+				assert(BORDER_STYLE_INSET ==
+						OUTLINE_STYLE_INSET);
+				assert(BORDER_STYLE_OUTSET ==
+						OUTLINE_STYLE_OUTSET);
+
+				switch (value) {
+				case BORDER_STYLE_NONE:
+					fprintf(fp, "none");
+					break;
+				case BORDER_STYLE_HIDDEN:
+					fprintf(fp, "hidden");
+					break;
+				case BORDER_STYLE_DOTTED:
+					fprintf(fp, "dotted");
+					break;
+				case BORDER_STYLE_DASHED:
+					fprintf(fp, "dashed");
+					break;
+				case BORDER_STYLE_SOLID:
+					fprintf(fp, "solid");
+					break;
+				case BORDER_STYLE_DOUBLE:
+					fprintf(fp, "double");
+					break;
+				case BORDER_STYLE_GROOVE:
+					fprintf(fp, "groove");
+					break;
+				case BORDER_STYLE_RIDGE:
+					fprintf(fp, "ridge");
+					break;
+				case BORDER_STYLE_INSET:
+					fprintf(fp, "inset");
+					break;
+				case BORDER_STYLE_OUTSET:
+					fprintf(fp, "outset");
+					break;
+				}
+				break;
+			case OP_BORDER_TRBL_WIDTH:
+			case OP_OUTLINE_WIDTH:
+				assert(BORDER_WIDTH_SET == OUTLINE_WIDTH_SET);
+				assert(BORDER_WIDTH_THIN == OUTLINE_WIDTH_THIN);
+				assert(BORDER_WIDTH_MEDIUM ==
+						OUTLINE_WIDTH_MEDIUM);
+				assert(BORDER_WIDTH_THICK ==
+						OUTLINE_WIDTH_THICK);
+
+				switch (value) {
+				case BORDER_WIDTH_SET:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case BORDER_WIDTH_THIN:
+					fprintf(fp, "thin");
+					break;
+				case BORDER_WIDTH_MEDIUM:
+					fprintf(fp, "medium");
+					break;
+				case BORDER_WIDTH_THICK:
+					fprintf(fp, "thick");
+					break;
+				}
+				break;
+			case OP_MARGIN_TRBL:
+				/* Clear side bits */
+				value &= ~SIDE_LEFT;
+				/* Fall through */
+			case OP_BOTTOM:
+			case OP_LEFT:
+			case OP_RIGHT:
+			case OP_TOP:
+			case OP_HEIGHT:
+			case OP_WIDTH:
+			case OP_Z_INDEX:
+				assert(BOTTOM_SET == LEFT_SET);
+				assert(BOTTOM_AUTO == LEFT_AUTO);
+				assert(BOTTOM_SET == RIGHT_SET);
+				assert(BOTTOM_AUTO == RIGHT_AUTO);
+				assert(BOTTOM_SET == TOP_SET);
+				assert(BOTTOM_AUTO == TOP_AUTO);
+				assert(BOTTOM_SET == HEIGHT_SET);
+				assert(BOTTOM_AUTO == HEIGHT_AUTO);
+				assert(BOTTOM_SET == MARGIN_SET);
+				assert(BOTTOM_AUTO == MARGIN_AUTO);
+				assert(BOTTOM_SET == WIDTH_SET);
+				assert(BOTTOM_AUTO == WIDTH_AUTO);
+				assert(BOTTOM_SET == Z_INDEX_SET);
+				assert(BOTTOM_AUTO == Z_INDEX_AUTO);
+
+				switch (value) {
+				case BOTTOM_SET:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case BOTTOM_AUTO:
+					fprintf(fp, "auto");
+					break;
+				}
+				break;
+			case OP_CAPTION_SIDE:
+				switch (value) {
+				case CAPTION_SIDE_TOP:
+					fprintf(fp, "top");
+					break;
+				case CAPTION_SIDE_BOTTOM:
+					fprintf(fp, "bottom");
+					break;
+				}
+				break;
 			case OP_CLEAR:
 				switch (value) {
 				case CLEAR_NONE:
@@ -209,9 +686,1132 @@ void css_bytecode_dump(void *bytecode, uint32_t length, FILE *fp)
 					break;
 				}
 				break;
+			case OP_CLIP:
+				if ((value & CLIP_SHAPE_MASK) == 
+						CLIP_SHAPE_RECT) {
+					fprintf(fp, "rect(");
+					if (value & CLIP_RECT_TOP_AUTO) {
+						fprintf(fp, "auto");
+					} else {
+						fixed val = 
+							*((fixed *) bytecode);
+						ADVANCE(sizeof(val));
+						uint32_t unit = 
+							*((uint32_t *) bytecode);
+						ADVANCE(sizeof(unit));
+						dump_unit(fp, val, unit);
+					}
+					fprintf(fp, ", ");
+					if (value & CLIP_RECT_RIGHT_AUTO) {
+						fprintf(fp, "auto");
+					} else {
+						fixed val = 
+							*((fixed *) bytecode);
+						ADVANCE(sizeof(val));
+						uint32_t unit = 
+							*((uint32_t *) bytecode);
+						ADVANCE(sizeof(unit));
+						dump_unit(fp, val, unit);
+					}
+					fprintf(fp, ", ");
+					if (value & CLIP_RECT_BOTTOM_AUTO) {
+						fprintf(fp, "auto");
+					} else {
+						fixed val = 
+							*((fixed *) bytecode);
+						ADVANCE(sizeof(val));
+						uint32_t unit = 
+							*((uint32_t *) bytecode);
+						ADVANCE(sizeof(unit));
+						dump_unit(fp, val, unit);
+					}
+					fprintf(fp, ", ");
+					if (value & CLIP_RECT_LEFT_AUTO) {
+						fprintf(fp, "auto");
+					} else {
+						fixed val = 
+							*((fixed *) bytecode);
+						ADVANCE(sizeof(val));
+						uint32_t unit = 
+							*((uint32_t *) bytecode);
+						ADVANCE(sizeof(unit));
+						dump_unit(fp, val, unit);
+					}
+					fprintf(fp, ")");
+				} else
+					fprintf(fp, "auto");
+				break;
+			case OP_COLOR:
+				switch (value) {
+				case COLOR_SET:
+				{
+					uint32_t colour = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(colour));
+					fprintf(fp, "#%08x", colour);
+				}	
+					break;
+				}
+				break;
+			case OP_CONTENT:
+				if (value == CONTENT_NORMAL) {
+					fprintf(fp, "normal");
+					break;
+				} else if (value == CONTENT_NONE) {
+					fprintf(fp, "none");
+					break;
+				}
+
+				while (value != CONTENT_NORMAL) {
+					parserutils_hash_entry *ptr = 
+						*((parserutils_hash_entry **) 
+						bytecode);
+					const char *end = "";
+
+					switch (value & 0xff) {
+					case CONTENT_COUNTER:
+						ADVANCE(sizeof(ptr));
+						dump_counter(fp, ptr, value);
+						break;
+					case CONTENT_COUNTERS:
+					{
+						parserutils_hash_entry *sep;
+
+						ADVANCE(sizeof(ptr));
+
+						sep = *((parserutils_hash_entry **) bytecode);
+						ADVANCE(sizeof(sep));
+
+						dump_counters(fp, ptr, sep,
+								value);
+					}
+						break;
+					case CONTENT_URI:
+					case CONTENT_ATTR:	
+					case CONTENT_STRING:
+						if (value == CONTENT_URI) 
+							fprintf(fp, "url(");
+						if (value == CONTENT_ATTR)
+							fprintf(fp, "attr(");
+						if (value != CONTENT_STRING)
+							end = ")";
+
+						ADVANCE(sizeof(ptr));
+
+						fprintf(fp, "'%.*s'%s",
+							(int) ptr->len,
+							(char *) ptr->data,
+							end);
+						break;
+					case CONTENT_OPEN_QUOTE:
+						fprintf(fp, "open-quote");
+						break;
+					case CONTENT_CLOSE_QUOTE:
+						fprintf(fp, "close-quote");
+						break;
+					case CONTENT_NO_OPEN_QUOTE:
+						fprintf(fp, "no-open-quote");
+						break;
+					case CONTENT_NO_CLOSE_QUOTE:
+						fprintf(fp, "no-close-quote");
+						break;
+					}
+
+					value = *((uint32_t *) bytecode);
+					ADVANCE(sizeof(value));
+
+					if (value != CONTENT_NORMAL)
+						fprintf(fp, " ");
+				}
+				break;
+			case OP_COUNTER_INCREMENT:
+			case OP_COUNTER_RESET:
+				assert(COUNTER_INCREMENT_NONE == 
+						COUNTER_RESET_NONE);
+				assert(COUNTER_INCREMENT_NAMED ==
+						COUNTER_RESET_NAMED);
+
+				switch (value) {
+				case COUNTER_INCREMENT_NAMED:
+					while (value != COUNTER_INCREMENT_NONE) {
+						parserutils_hash_entry *ptr = 
+						*((parserutils_hash_entry **) 
+						bytecode);
+						ADVANCE(sizeof(ptr));
+						fprintf(fp, " %.*s ", 
+							(int) ptr->len, 
+							(char *) ptr->data);
+						fixed val =
+							*((fixed *) bytecode);
+						ADVANCE(sizeof(val));
+						dump_number(fp, val);
+
+						value = *((uint32_t *) bytecode);
+						ADVANCE(sizeof(value));
+					}
+					break;
+				case COUNTER_INCREMENT_NONE:
+					fprintf(fp, "none");
+					break;
+				}
+				break;
+			case OP_CURSOR:
+				switch (value) {
+				case CURSOR_URI:
+				{
+					parserutils_hash_entry *ptr = 
+						*((parserutils_hash_entry **) 
+						bytecode);
+					ADVANCE(sizeof(ptr));
+					fprintf(fp, "url('%.*s')", 
+							(int) ptr->len, 
+							(char *) ptr->data);
+				}
+					break;
+				case CURSOR_AUTO:
+					fprintf(fp, "auto");
+					break;
+				case CURSOR_CROSSHAIR:
+					fprintf(fp, "crosshair");
+					break;
+				case CURSOR_DEFAULT:
+					fprintf(fp, "default");
+					break;
+				case CURSOR_POINTER:
+					fprintf(fp, "pointer");
+					break;
+				case CURSOR_MOVE:
+					fprintf(fp, "move");
+					break;
+				case CURSOR_E_RESIZE:
+					fprintf(fp, "e-resize");
+					break;
+				case CURSOR_NE_RESIZE:
+					fprintf(fp, "ne-resize");
+					break;
+				case CURSOR_NW_RESIZE:
+					fprintf(fp, "nw-resize");
+					break;
+				case CURSOR_N_RESIZE:
+					fprintf(fp, "n-resize");
+					break;
+				case CURSOR_SE_RESIZE:
+					fprintf(fp, "se-resize");
+					break;
+				case CURSOR_SW_RESIZE:
+					fprintf(fp, "sw-resize");
+					break;
+				case CURSOR_S_RESIZE:
+					fprintf(fp, "s-resize");
+					break;
+				case CURSOR_W_RESIZE:
+					fprintf(fp, "w-resize");
+					break;
+				case CURSOR_TEXT:
+					fprintf(fp, "text");
+					break;
+				case CURSOR_WAIT:
+					fprintf(fp, "wait");
+					break;
+				case CURSOR_HELP:
+					fprintf(fp, "help");
+					break;
+				case CURSOR_PROGRESS:
+					fprintf(fp, "progress");
+					break;
+				}
+				break;
+			case OP_DIRECTION:
+				switch (value) {
+				case DIRECTION_LTR:
+					fprintf(fp, "ltr");
+					break;
+				case DIRECTION_RTL:
+					fprintf(fp, "rtl");
+					break;
+				}
+				break;
+			case OP_DISPLAY:
+				switch (value) {
+				case DISPLAY_INLINE:
+					fprintf(fp, "inline");
+					break;
+				case DISPLAY_BLOCK:
+					fprintf(fp, "block");
+					break;
+				case DISPLAY_LIST_ITEM:
+					fprintf(fp, "list-item");
+					break;
+				case DISPLAY_RUN_IN:
+					fprintf(fp, "run-in");
+					break;
+				case DISPLAY_INLINE_BLOCK:
+					fprintf(fp, "inline-block");
+					break;
+				case DISPLAY_TABLE:
+					fprintf(fp, "table");
+					break;
+				case DISPLAY_INLINE_TABLE:
+					fprintf(fp, "inline-table");
+					break;
+				case DISPLAY_TABLE_ROW_GROUP:
+					fprintf(fp, "table-row-group");
+					break;
+				case DISPLAY_TABLE_HEADER_GROUP:
+					fprintf(fp, "table-header-group");
+					break;
+				case DISPLAY_TABLE_FOOTER_GROUP:
+					fprintf(fp, "table-footer-group");
+					break;
+				case DISPLAY_TABLE_ROW:
+					fprintf(fp, "table-row");
+					break;
+				case DISPLAY_TABLE_COLUMN_GROUP:
+					fprintf(fp, "table-column-group");
+					break;
+				case DISPLAY_TABLE_COLUMN:
+					fprintf(fp, "table-column");
+					break;
+				case DISPLAY_TABLE_CELL:
+					fprintf(fp, "table-cell");
+					break;
+				case DISPLAY_TABLE_CAPTION:
+					fprintf(fp, "table-caption");
+					break;
+				case DISPLAY_NONE:
+					fprintf(fp, "none");
+					break;
+				}
+				break;
+			case OP_ELEVATION:
+				switch (value) {
+				case ELEVATION_ANGLE:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case ELEVATION_BELOW:
+					fprintf(fp, "below");
+					break;
+				case ELEVATION_LEVEL:
+					fprintf(fp, "level");
+					break;
+				case ELEVATION_ABOVE:
+					fprintf(fp, "above");
+					break;
+				case ELEVATION_HIGHER:
+					fprintf(fp, "higher");
+					break;
+				case ELEVATION_LOWER:
+					fprintf(fp, "lower");
+					break;
+				}
+				break;
+			case OP_EMPTY_CELLS:
+				switch (value) {
+				case EMPTY_CELLS_SHOW:
+					fprintf(fp, "show");
+					break;
+				case EMPTY_CELLS_HIDE:
+					fprintf(fp, "hide");
+					break;
+				}
+				break;
+			case OP_FLOAT:
+				switch (value) {
+				case FLOAT_LEFT:
+					fprintf(fp, "left");
+					break;
+				case FLOAT_RIGHT:
+					fprintf(fp, "right");
+					break;
+				case FLOAT_NONE:
+					fprintf(fp, "none");
+					break;
+				}
+				break;
+			case OP_FONT_FAMILY:
+				while (value != FONT_FAMILY_END) {
+					switch (value) {
+					case FONT_FAMILY_STRING:
+					case FONT_FAMILY_IDENT_LIST:
+					{
+						parserutils_hash_entry *ptr = 
+						*((parserutils_hash_entry **) 
+						bytecode);
+						ADVANCE(sizeof(ptr));
+						fprintf(fp, "'%.*s'", 
+							(int) ptr->len, 
+							(char *) ptr->data);
+					}
+						break;
+					case FONT_FAMILY_SERIF:
+						fprintf(fp, "serif");
+						break;
+					case FONT_FAMILY_SANS_SERIF:
+						fprintf(fp, "sans-serif");
+						break;
+					case FONT_FAMILY_CURSIVE:
+						fprintf(fp, "cursive");
+						break;
+					case FONT_FAMILY_FANTASY:
+						fprintf(fp, "fantasy");
+						break;
+					case FONT_FAMILY_MONOSPACE:
+						fprintf(fp, "monospace");
+						break;
+					}
+
+					value = *((uint32_t *) bytecode);
+					ADVANCE(sizeof(value));
+
+					if (value != FONT_FAMILY_END)
+						fprintf(fp, ", ");
+				}
+				break;
+			case OP_FONT_SIZE:
+				switch (value) {
+				case FONT_SIZE_DIMENSION:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case FONT_SIZE_XX_SMALL:
+					fprintf(fp, "xx-small");
+					break;
+				case FONT_SIZE_X_SMALL:
+					fprintf(fp, "x-small");
+					break;
+				case FONT_SIZE_SMALL:
+					fprintf(fp, "small");
+					break;
+				case FONT_SIZE_MEDIUM:
+					fprintf(fp, "medium");
+					break;
+				case FONT_SIZE_LARGE:
+					fprintf(fp, "large");
+					break;
+				case FONT_SIZE_X_LARGE:
+					fprintf(fp, "x-large");
+					break;
+				case FONT_SIZE_XX_LARGE:
+					fprintf(fp, "xx-large");
+					break;
+				case FONT_SIZE_LARGER:
+					fprintf(fp, "larger");
+					break;
+				case FONT_SIZE_SMALLER:
+					fprintf(fp, "smaller");
+					break;
+				}
+				break;
+			case OP_FONT_STYLE:
+				switch (value) {
+				case FONT_STYLE_NORMAL:
+					fprintf(fp, "normal");
+					break;
+				case FONT_STYLE_ITALIC:
+					fprintf(fp, "italic");
+					break;
+				case FONT_STYLE_OBLIQUE:
+					fprintf(fp, "oblique");
+					break;
+				}
+				break;
+			case OP_FONT_VARIANT:
+				switch (value) {
+				case FONT_VARIANT_NORMAL:
+					fprintf(fp, "normal");
+					break;
+				case FONT_VARIANT_SMALL_CAPS:
+					fprintf(fp, "small-caps");
+					break;
+				}
+				break;
+			case OP_FONT_WEIGHT:
+				switch (value) {
+				case FONT_WEIGHT_NORMAL:
+					fprintf(fp, "normal");
+					break;
+				case FONT_WEIGHT_BOLD:
+					fprintf(fp, "bold");
+					break;
+				case FONT_WEIGHT_BOLDER:
+					fprintf(fp, "bolder");
+					break;
+				case FONT_WEIGHT_LIGHTER:
+					fprintf(fp, "lighter");
+					break;
+				case FONT_WEIGHT_100:
+					fprintf(fp, "100");
+					break;
+				case FONT_WEIGHT_200:
+					fprintf(fp, "200");
+					break;
+				case FONT_WEIGHT_300:
+					fprintf(fp, "300");
+					break;
+				case FONT_WEIGHT_400:
+					fprintf(fp, "400");
+					break;
+				case FONT_WEIGHT_500:
+					fprintf(fp, "500");
+					break;
+				case FONT_WEIGHT_600:
+					fprintf(fp, "600");
+					break;
+				case FONT_WEIGHT_700:
+					fprintf(fp, "700");
+					break;
+				case FONT_WEIGHT_800:
+					fprintf(fp, "800");
+					break;
+				case FONT_WEIGHT_900:
+					fprintf(fp, "900");
+					break;
+				}
+				break;
+			case OP_LETTER_SPACING:
+			case OP_WORD_SPACING:
+				assert(LETTER_SPACING_SET == WORD_SPACING_SET);
+				assert(LETTER_SPACING_NORMAL ==
+						WORD_SPACING_NORMAL);
+
+				switch (value) {
+				case LETTER_SPACING_SET:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case LETTER_SPACING_NORMAL:
+					fprintf(fp, "normal");
+					break;
+				}
+				break;
+			case OP_LINE_HEIGHT:
+				switch (value) {
+				case LINE_HEIGHT_NUMBER:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					dump_number(fp, val);
+				}
+					break;
+				case LINE_HEIGHT_DIMENSION:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case LINE_HEIGHT_NORMAL:
+					fprintf(fp, "normal");
+					break;
+				}
+				break;
+			case OP_LIST_STYLE_POSITION:
+				switch (value) {
+				case LIST_STYLE_POSITION_INSIDE:
+					fprintf(fp, "inside");
+					break;
+				case LIST_STYLE_POSITION_OUTSIDE:
+					fprintf(fp, "outside");
+					break;
+				}
+				break;
+			case OP_LIST_STYLE_TYPE:
+				switch (value) {
+				case LIST_STYLE_TYPE_DISC:
+					fprintf(fp, "disc");
+					break;
+				case LIST_STYLE_TYPE_CIRCLE:
+					fprintf(fp, "circle");
+					break;
+				case LIST_STYLE_TYPE_SQUARE:
+					fprintf(fp, "square");
+					break;
+				case LIST_STYLE_TYPE_DECIMAL:
+					fprintf(fp, "decimal");
+					break;
+				case LIST_STYLE_TYPE_DECIMAL_LEADING_ZERO:
+					fprintf(fp, "decimal-leading-zero");
+					break;
+				case LIST_STYLE_TYPE_LOWER_ROMAN:
+					fprintf(fp, "lower-roman");
+					break;
+				case LIST_STYLE_TYPE_UPPER_ROMAN:
+					fprintf(fp, "upper-roman");
+					break;
+				case LIST_STYLE_TYPE_LOWER_GREEK:
+					fprintf(fp, "lower-greek");
+					break;
+				case LIST_STYLE_TYPE_LOWER_LATIN:
+					fprintf(fp, "lower-latin");
+					break;
+				case LIST_STYLE_TYPE_UPPER_LATIN:
+					fprintf(fp, "upper-latin");
+					break;
+				case LIST_STYLE_TYPE_ARMENIAN:
+					fprintf(fp, "armenian");
+					break;
+				case LIST_STYLE_TYPE_GEORGIAN:
+					fprintf(fp, "georgian");
+					break;
+				case LIST_STYLE_TYPE_LOWER_ALPHA:
+					fprintf(fp, "lower-alpha");
+					break;
+				case LIST_STYLE_TYPE_UPPER_ALPHA:
+					fprintf(fp, "upper-alpha");
+					break;
+				case LIST_STYLE_TYPE_NONE:
+					fprintf(fp, "none");
+					break;
+				}
+				break;
+			case OP_MAX_HEIGHT:
+			case OP_MAX_WIDTH:
+				assert(MAX_HEIGHT_SET == MAX_WIDTH_SET);
+				assert(MAX_HEIGHT_NONE == MAX_WIDTH_NONE);
+
+				switch (value) {
+				case MAX_HEIGHT_SET:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case MAX_HEIGHT_NONE:
+					fprintf(fp, "none");
+					break;
+				}
+				break;
+			case OP_PADDING_TRBL:
+				/* Clear side bits */
+				value &= ~SIDE_LEFT;
+				/* Fall through */
+			case OP_MIN_HEIGHT:
+			case OP_MIN_WIDTH:
+			case OP_PAUSE_AFTER:
+			case OP_PAUSE_BEFORE:
+			case OP_TEXT_INDENT:
+				assert(MIN_HEIGHT_SET == MIN_WIDTH_SET);
+				assert(MIN_HEIGHT_SET == PADDING_SET);
+				assert(MIN_HEIGHT_SET == PAUSE_AFTER_SET);
+				assert(MIN_HEIGHT_SET == PAUSE_BEFORE_SET);
+				assert(MIN_HEIGHT_SET == TEXT_INDENT_SET);
+
+				switch (value) {
+				case MIN_HEIGHT_SET:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				}
+				break;
+			case OP_ORPHANS:
+			case OP_PITCH_RANGE:
+			case OP_RICHNESS:
+			case OP_STRESS:
+			case OP_WIDOWS:
+				assert(ORPHANS_SET == PITCH_RANGE_SET);
+				assert(ORPHANS_SET == RICHNESS_SET);
+				assert(ORPHANS_SET == STRESS_SET);
+				assert(ORPHANS_SET == WIDOWS_SET);
+
+				switch (value) {
+				case ORPHANS_SET:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					dump_number(fp, val);
+				}
+					break;
+				}
+				break;
+			case OP_OUTLINE_COLOR:
+				switch (value) {
+				case OUTLINE_COLOR_SET:
+				{
+					uint32_t colour = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(colour));
+					fprintf(fp, "#%08x", colour);
+				}
+					break;
+				case OUTLINE_COLOR_INVERT:
+					fprintf(fp, "invert");
+					break;
+				}
+				break;
+			case OP_OVERFLOW:
+				switch (value) {
+				case OVERFLOW_VISIBLE:
+					fprintf(fp, "visible");
+					break;
+				case OVERFLOW_HIDDEN:
+					fprintf(fp, "hidden");
+					break;
+				case OVERFLOW_SCROLL:
+					fprintf(fp, "scroll");
+					break;
+				case OVERFLOW_AUTO:
+					fprintf(fp, "auto");
+					break;
+				}
+				break;
+			case OP_PAGE_BREAK_AFTER:
+			case OP_PAGE_BREAK_BEFORE:
+				assert(PAGE_BREAK_AFTER_AUTO == 
+						PAGE_BREAK_BEFORE_AUTO);
+				assert(PAGE_BREAK_AFTER_ALWAYS ==
+						PAGE_BREAK_BEFORE_ALWAYS);
+				assert(PAGE_BREAK_AFTER_AVOID ==
+						PAGE_BREAK_BEFORE_AVOID);
+				assert(PAGE_BREAK_AFTER_LEFT ==
+						PAGE_BREAK_BEFORE_LEFT);
+				assert(PAGE_BREAK_AFTER_RIGHT ==
+						PAGE_BREAK_BEFORE_RIGHT);
+
+				switch (value) {
+				case PAGE_BREAK_AFTER_AUTO:
+					fprintf(fp, "auto");
+					break;
+				case PAGE_BREAK_AFTER_ALWAYS:
+					fprintf(fp, "always");
+					break;
+				case PAGE_BREAK_AFTER_AVOID:
+					fprintf(fp, "avoid");
+					break;
+				case PAGE_BREAK_AFTER_LEFT:
+					fprintf(fp, "left");
+					break;
+				case PAGE_BREAK_AFTER_RIGHT:
+					fprintf(fp, "right");
+					break;
+				}
+				break;
+			case OP_PAGE_BREAK_INSIDE:
+				switch (value) {
+				case PAGE_BREAK_INSIDE_AUTO:
+					fprintf(fp, "auto");
+					break;
+				case PAGE_BREAK_INSIDE_AVOID:
+					fprintf(fp, "avoid");
+					break;
+				}
+				break;
+			case OP_PITCH:
+				switch (value) {
+				case PITCH_FREQUENCY:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case PITCH_X_LOW:
+					fprintf(fp, "x-low");
+					break;
+				case PITCH_LOW:
+					fprintf(fp, "low");
+					break;
+				case PITCH_MEDIUM:
+					fprintf(fp, "medium");
+					break;
+				case PITCH_HIGH:
+					fprintf(fp, "high");
+					break;
+				case PITCH_X_HIGH:
+					fprintf(fp, "x-high");
+					break;
+				}
+				break;
+			case OP_PLAY_DURING:
+				switch (value) {
+				case PLAY_DURING_URI:
+				{
+					parserutils_hash_entry *ptr = 
+						*((parserutils_hash_entry **) 
+						bytecode);
+					ADVANCE(sizeof(ptr));
+					fprintf(fp, "'%.*s'", 
+						(int) ptr->len, 
+						(char *) ptr->data);
+				}
+					break;
+				case PLAY_DURING_AUTO:
+					fprintf(fp, "auto");
+					break;
+				case PLAY_DURING_NONE:
+					fprintf(fp, "none");
+					break;
+				}
+
+				if (value & PLAY_DURING_MIX)
+					fprintf(fp, " mix");
+				if (value & PLAY_DURING_REPEAT)
+					fprintf(fp, " repeat");
+				break;
+			case OP_POSITION:
+				switch (value) {
+				case POSITION_STATIC:
+					fprintf(fp, "static");
+					break;
+				case POSITION_RELATIVE:
+					fprintf(fp, "relative");
+					break;
+				case POSITION_ABSOLUTE:
+					fprintf(fp, "absolute");
+					break;
+				case POSITION_FIXED:
+					fprintf(fp, "fixed");
+					break;
+				}
+				break;
+			case OP_QUOTES:
+				switch (value) {
+				case QUOTES_STRING:
+					while (value != QUOTES_NONE) {
+						parserutils_hash_entry *ptr = 
+						*((parserutils_hash_entry **) 
+						bytecode);
+						ADVANCE(sizeof(ptr));
+						fprintf(fp, " '%.*s' ", 
+							(int) ptr->len, 
+							(char *) ptr->data);
+
+						ptr = 
+						*((parserutils_hash_entry **) 
+						bytecode);
+						ADVANCE(sizeof(ptr));
+						fprintf(fp, " '%.*s' ", 
+							(int) ptr->len, 
+							(char *) ptr->data);
+
+						value = *((uint32_t *) bytecode);
+						ADVANCE(sizeof(value));
+					}
+					break;
+				case QUOTES_NONE:
+					fprintf(fp, "none");
+					break;
+				}
+				break;
+			case OP_SPEAK_HEADER:
+				switch (value) {
+				case SPEAK_HEADER_ONCE:
+					fprintf(fp, "once");
+					break;
+				case SPEAK_HEADER_ALWAYS:
+					fprintf(fp, "always");
+					break;
+				}
+				break;
+			case OP_SPEAK_NUMERAL:
+				switch (value) {
+				case SPEAK_NUMERAL_DIGITS:
+					fprintf(fp, "digits");
+					break;
+				case SPEAK_NUMERAL_CONTINUOUS:
+					fprintf(fp, "continuous");
+					break;
+				}
+				break;
+			case OP_SPEAK_PUNCTUATION:
+				switch (value) {
+				case SPEAK_PUNCTUATION_CODE:
+					fprintf(fp, "code");
+					break;
+				case SPEAK_PUNCTUATION_NONE:
+					fprintf(fp, "none");
+					break;
+				}
+				break;
+			case OP_SPEAK:
+				switch (value) {
+				case SPEAK_NORMAL:
+					fprintf(fp, "normal");
+					break;
+				case SPEAK_NONE:
+					fprintf(fp, "none");
+					break;
+				case SPEAK_SPELL_OUT:
+					fprintf(fp, "spell-out");
+					break;
+				}
+				break;
+			case OP_SPEECH_RATE:
+				switch (value) {
+				case SPEECH_RATE_SET:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					dump_number(fp, val);
+				}
+					break;
+				case SPEECH_RATE_X_SLOW:
+					fprintf(fp, "x-slow");
+					break;
+				case SPEECH_RATE_SLOW:
+					fprintf(fp, "slow");
+					break;
+				case SPEECH_RATE_FAST:
+					fprintf(fp, "fast");
+					break;
+				case SPEECH_RATE_X_FAST:
+					fprintf(fp, "x-fast");
+					break;
+				case SPEECH_RATE_FASTER:
+					fprintf(fp, "faster");
+					break;
+				case SPEECH_RATE_SLOWER:
+					fprintf(fp, "slower");
+					break;
+				}
+				break;
+			case OP_TABLE_LAYOUT:
+				switch (value) {
+				case TABLE_LAYOUT_AUTO:
+					fprintf(fp, "auto");
+					break;
+				case TABLE_LAYOUT_FIXED:
+					fprintf(fp, "fixed");
+					break;
+				}
+				break;
+			case OP_TEXT_ALIGN:
+				switch (value) {
+				case TEXT_ALIGN_LEFT:
+					fprintf(fp, "left");
+					break;
+				case TEXT_ALIGN_RIGHT:
+					fprintf(fp, "right");
+					break;
+				case TEXT_ALIGN_CENTER:
+					fprintf(fp, "center");
+					break;
+				case TEXT_ALIGN_JUSTIFY:
+					fprintf(fp, "justify");
+					break;
+				}
+				break;
+			case OP_TEXT_DECORATION:
+				if (value == TEXT_DECORATION_NONE)
+					fprintf(fp, "none");
+
+				if (value & TEXT_DECORATION_UNDERLINE)
+					fprintf(fp, " underline");
+				if (value & TEXT_DECORATION_OVERLINE)
+					fprintf(fp, " overline");
+				if (value & TEXT_DECORATION_LINE_THROUGH)
+					fprintf(fp, " line-through");
+				if (value & TEXT_DECORATION_BLINK)
+					fprintf(fp, " blink");
+				break;
+			case OP_TEXT_TRANSFORM:
+				switch (value) {
+				case TEXT_TRANSFORM_CAPITALIZE:
+					fprintf(fp, "capitalize");
+					break;
+				case TEXT_TRANSFORM_UPPERCASE:
+					fprintf(fp, "uppercase");
+					break;
+				case TEXT_TRANSFORM_LOWERCASE:
+					fprintf(fp, "lowercase");
+					break;
+				case TEXT_TRANSFORM_NONE:
+					fprintf(fp, "none");
+					break;
+				}
+				break;
+			case OP_UNICODE_BIDI:
+				switch (value) {
+				case UNICODE_BIDI_NORMAL:
+					fprintf(fp, "normal");
+					break;
+				case UNICODE_BIDI_EMBED:
+					fprintf(fp, "embed");
+					break;
+				case UNICODE_BIDI_BIDI_OVERRIDE:
+					fprintf(fp, "bidi-override");
+					break;
+				}
+				break;
+			case OP_VERTICAL_ALIGN:
+				switch (value) {
+				case VERTICAL_ALIGN_SET:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case VERTICAL_ALIGN_BASELINE:
+					fprintf(fp, "baseline");
+					break;
+				case VERTICAL_ALIGN_SUB:
+					fprintf(fp, "sub");
+					break;
+				case VERTICAL_ALIGN_SUPER:
+					fprintf(fp, "super");
+					break;
+				case VERTICAL_ALIGN_TOP:
+					fprintf(fp, "top");
+					break;
+				case VERTICAL_ALIGN_TEXT_TOP:
+					fprintf(fp, "text-top");
+					break;
+				case VERTICAL_ALIGN_MIDDLE:
+					fprintf(fp, "middle");
+					break;
+				case VERTICAL_ALIGN_BOTTOM:
+					fprintf(fp, "bottom");
+					break;
+				case VERTICAL_ALIGN_TEXT_BOTTOM:
+					fprintf(fp, "text-bottom");
+					break;
+				}
+				break;
+			case OP_VISIBILITY:
+				switch (value) {
+				case VISIBILITY_VISIBLE:
+					fprintf(fp, "visible");
+					break;
+				case VISIBILITY_HIDDEN:
+					fprintf(fp, "hidden");
+					break;
+				case VISIBILITY_COLLAPSE:
+					fprintf(fp, "collapse");
+					break;
+				}
+				break;
+			case OP_VOICE_FAMILY:
+				while (value != VOICE_FAMILY_END) {
+					switch (value) {
+					case VOICE_FAMILY_STRING:
+					case VOICE_FAMILY_IDENT_LIST:
+					{
+						parserutils_hash_entry *ptr = 
+						*((parserutils_hash_entry **) 
+						bytecode);
+						ADVANCE(sizeof(ptr));
+						fprintf(fp, "'%.*s'", 
+							(int) ptr->len, 
+							(char *) ptr->data);
+					}
+						break;
+					case VOICE_FAMILY_MALE:
+						fprintf(fp, "male");
+						break;
+					case VOICE_FAMILY_FEMALE:
+						fprintf(fp, "female");
+						break;
+					case VOICE_FAMILY_CHILD:
+						fprintf(fp, "child");
+						break;
+					}
+
+					value = *((uint32_t *) bytecode);
+					ADVANCE(sizeof(value));
+
+					if (value != VOICE_FAMILY_END)
+						fprintf(fp, ", ");
+				}
+				break;
+			case OP_VOLUME:
+				switch (value) {
+				case VOLUME_NUMBER:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					dump_number(fp, val);
+				}
+					break;
+				case VOLUME_DIMENSION:
+				{
+					fixed val = *((fixed *) bytecode);
+					ADVANCE(sizeof(val));
+					uint32_t unit = 
+						*((uint32_t *) bytecode);
+					ADVANCE(sizeof(unit));
+					dump_unit(fp, val, unit);
+				}
+					break;
+				case VOLUME_SILENT:
+					fprintf(fp, "silent");
+					break;
+				case VOLUME_X_SOFT:
+					fprintf(fp, "x-soft");
+					break;
+				case VOLUME_SOFT:
+					fprintf(fp, "soft");
+					break;
+				case VOLUME_MEDIUM:
+					fprintf(fp, "medium");
+					break;
+				case VOLUME_LOUD:
+					fprintf(fp, "loud");
+					break;
+				case VOLUME_X_LOUD:
+					fprintf(fp, "x-loud");
+					break;
+				}
+				break;
+			case OP_WHITE_SPACE:
+				switch (value) {
+				case WHITE_SPACE_NORMAL:
+					fprintf(fp, "normal");
+					break;
+				case WHITE_SPACE_PRE:
+					fprintf(fp, "pre");
+					break;
+				case WHITE_SPACE_NOWRAP:
+					fprintf(fp, "nowrap");
+					break;
+				case WHITE_SPACE_PRE_WRAP:
+					fprintf(fp, "pre-wrap");
+					break;
+				case WHITE_SPACE_PRE_LINE:
+					fprintf(fp, "pre-line");
+					break;
+				}
+				break;
 			default:
 				fprintf(fp, "Unknown opcode %x", op);
-				break;
+				return;
 			}
 		}
 
diff --git a/src/bytecode/opcodes.h b/src/bytecode/opcodes.h
index 64b9d26..3de9fc1 100644
--- a/src/bytecode/opcodes.h
+++ b/src/bytecode/opcodes.h
@@ -75,12 +75,12 @@ enum op_border_collapse {
 };
 
 enum op_border_spacing {
-	BORDER_SPACING_SET		= 0x0000,
+	BORDER_SPACING_SET		= 0x0080,
 };
 
 enum op_border_color {
-	BORDER_COLOR_SET		= 0x0000,
-	BORDER_COLOR_TRANSPARENT	= 0x0001,
+	BORDER_COLOR_SET		= 0x0080,
+	BORDER_COLOR_TRANSPARENT	= 0x0000,
 };
 
 enum op_border_style {
@@ -122,6 +122,7 @@ enum op_clear {
 };
 
 enum op_clip {
+	CLIP_SHAPE_MASK			= 0x0087,
 	CLIP_SHAPE_RECT			= 0x0080,
 
 	CLIP_RECT_TOP_AUTO		= 0x0008,
@@ -133,7 +134,7 @@ enum op_clip {
 };
 
 enum op_color {
-	COLOR_SET			= 0x0000,
+	COLOR_SET			= 0x0080,
 };
 
 enum op_content {
@@ -361,15 +362,15 @@ enum op_max_width {
 };
 
 enum op_min_height {
-	MIN_HEIGHT_SET			= 0x0000,
+	MIN_HEIGHT_SET			= 0x0080,
 };
 
 enum op_min_width {
-	MIN_WIDTH_SET			= 0x0000,
+	MIN_WIDTH_SET			= 0x0080,
 };
 
 enum op_orphans {
-	ORPHANS_SET			= 0x0000,
+	ORPHANS_SET			= 0x0080,
 };
 
 enum op_outline_color {
@@ -405,7 +406,7 @@ enum op_overflow {
 };
 
 enum op_padding {
-	PADDING_SET			= 0x0000,
+	PADDING_SET			= 0x0080,
 };
 
 enum op_page_break_after {
@@ -430,15 +431,15 @@ enum op_page_break_inside {
 };
 
 enum op_pause_after {
-	PAUSE_AFTER_SET			= 0x0000,
+	PAUSE_AFTER_SET			= 0x0080,
 };
 
 enum op_pause_before {
-	PAUSE_BEFORE_SET		= 0x0000,
+	PAUSE_BEFORE_SET		= 0x0080,
 };
 
 enum op_pitch_range {
-	PITCH_RANGE_SET			= 0x0000,
+	PITCH_RANGE_SET			= 0x0080,
 };
 
 enum op_pitch {
@@ -474,7 +475,7 @@ enum op_quotes {
 };
 
 enum op_richness {
-	RICHNESS_SET			= 0x0000,
+	RICHNESS_SET			= 0x0080,
 };
 
 enum op_right {
@@ -517,7 +518,7 @@ enum op_speech_rate {
 };
 
 enum op_stress {
-	STRESS_SET			= 0x0000,
+	STRESS_SET			= 0x0080,
 };
 
 enum op_table_layout {
@@ -542,7 +543,7 @@ enum op_text_decoration {
 };
 
 enum op_text_indent {
-	TEXT_INDENT_SET			= 0x0000,
+	TEXT_INDENT_SET			= 0x0080,
 };
 
 enum op_text_transform {
@@ -615,7 +616,7 @@ enum op_white_space {
 };
 
 enum op_widows {
-	WIDOWS_SET			= 0x0000,
+	WIDOWS_SET			= 0x0080,
 };
 
 enum op_width {