merge

1 files changed, 1476 insertions, 0 deletions

diff --git a/src/cssparser.cc b/src/cssparser.cc
new file mode 100644
index 00000000..00ba7428
--- /dev/null
+++ b/src/cssparser.cc
@@ -0,0 +1,1476 @@
+/*
+ * File: cssparser.cc
+ *
+ * Copyright 2004 Sebastian Geerken <sgeerken@dillo.org>
+ * Copyright 2008-2009 Johannes Hofmann <Johannes.Hofmann@gmx.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ */
+
+/*
+ * This file is heavily based on the CSS parser of dillo-0.8.0-css-3 -
+ * a dillo1 based CSS prototype written by Sebastian Geerken.
+ */
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "msg.h"
+#include "colors.h"
+#include "html_common.hh"
+#include "css.hh"
+#include "cssparser.hh"
+
+using namespace dw::core::style;
+
+#define DEBUG_MSG(A, B, ...) _MSG(B, __VA_ARGS__)
+#define MSG_CSS(A, ...) MSG(A, __VA_ARGS__)
+#define DEBUG_TOKEN_LEVEL   0
+#define DEBUG_PARSE_LEVEL   0
+#define DEBUG_CREATE_LEVEL  0
+
+#define DEBUG_LEVEL 10
+
+/* The last three ones are never parsed. */
+#define CSS_NUM_INTERNAL_PROPERTIES 3
+#define CSS_NUM_PARSED_PROPERTIES \
+   (CSS_PROPERTY_LAST - CSS_NUM_INTERNAL_PROPERTIES)
+
+
+typedef struct {
+   const char *symbol;
+   const CssValueType type[3];
+   const char *const *enum_symbols;
+} CssPropertyInfo;
+
+static const char *const Css_border_style_enum_vals[] = {
+   "none", "hidden", "dotted", "dashed", "solid", "double", "groove",
+   "ridge", "inset", "outset", NULL
+};
+
+static const char *const Css_border_width_enum_vals[] = {
+   "thin", "medium", "thick", NULL
+};
+
+static const char *const Css_cursor_enum_vals[] = {
+   "crosshair", "default", "pointer", "move", "e-resize", "ne-resize",
+   "nw-resize", "n-resize", "se-resize", "sw-resize", "s-resize",
+   "w-resize", "text", "wait", "help", NULL
+};
+
+static const char *const Css_display_enum_vals[] = {
+   "block", "inline", "list-item", "none", "table", "table-row-group",
+   "table-header-group", "table-footer-group", "table-row",
+   "table-cell", NULL
+};
+
+static const char *const Css_font_size_enum_vals[] = {
+   "large", "larger", "medium", "small", "smaller", "xx-large", "xx-small",
+   "x-large", "x-small", NULL
+};
+
+static const char *const Css_font_style_enum_vals[] = {
+   "normal", "italic", "oblique", NULL
+};
+
+static const char *const Css_font_weight_enum_vals[] = {
+   "bold", "bolder", "light", "lighter", "normal", NULL
+};
+
+static const char *const Css_letter_spacing_enum_vals[] = {
+   "normal", NULL
+};
+
+static const char *const Css_list_style_position_enum_vals[] = {
+   "inside", "outside", NULL
+};
+
+static const char *const Css_line_height_enum_vals[] = {
+   "normal", NULL
+};
+
+static const char *const Css_list_style_type_enum_vals[] = {
+   "disc", "circle", "square", "decimal", "decimal-leading-zero",
+   "lower-roman", "upper-roman", "lower-greek", "lower-alpha",
+   "lower-latin", "upper-alpha", "upper-latin", "hebrew", "armenian",
+   "georgian", "cjk-ideographic", "hiragana", "katakana", "hiragana-iroha",
+   "katakana-iroha", "none", NULL
+};
+
+static const char *const Css_text_align_enum_vals[] = {
+   "left", "right", "center", "justify", "string", NULL
+};
+
+static const char *const Css_text_decoration_enum_vals[] = {
+   "underline", "overline", "line-through", "blink", NULL
+};
+
+static const char *const Css_vertical_align_vals[] = {
+   "top", "bottom", "middle", "baseline", "sub", "super", "text-top",
+   "text-bottom", NULL
+};
+
+static const char *const Css_white_space_vals[] = {
+   "normal", "pre", "nowrap", "pre-wrap", "pre-line", NULL
+};
+
+static const char *const Css_word_spacing_enum_vals[] = {
+   "normal", NULL
+};
+
+const CssPropertyInfo Css_property_info[CSS_PROPERTY_LAST] = {
+   {"background-attachment", {CSS_TYPE_UNUSED}, NULL},
+   {"background-color", {CSS_TYPE_COLOR, CSS_TYPE_UNUSED}, NULL},
+   {"background-image", {CSS_TYPE_UNUSED}, NULL},
+   {"background-position", {CSS_TYPE_UNUSED}, NULL},
+   {"background-repeat", {CSS_TYPE_UNUSED}, NULL},
+   {"border-bottom-color", {CSS_TYPE_COLOR, CSS_TYPE_UNUSED}, NULL},
+   {"border-bottom-style", {CSS_TYPE_ENUM, CSS_TYPE_UNUSED},
+    Css_border_style_enum_vals},
+   {"border-bottom-width", {CSS_TYPE_ENUM, CSS_TYPE_LENGTH, CSS_TYPE_UNUSED},
+    Css_border_width_enum_vals},
+   {"border-collapse", {CSS_TYPE_UNUSED}, NULL},
+   {"border-left-color", {CSS_TYPE_COLOR, CSS_TYPE_UNUSED}, NULL},
+   {"border-left-style", {CSS_TYPE_ENUM, CSS_TYPE_UNUSED},
+    Css_border_style_enum_vals},
+   {"border-left-width", {CSS_TYPE_ENUM, CSS_TYPE_LENGTH, CSS_TYPE_UNUSED},
+    Css_border_width_enum_vals},
+   {"border-right-color", {CSS_TYPE_COLOR, CSS_TYPE_UNUSED}, NULL},
+   {"border-right-style", {CSS_TYPE_ENUM, CSS_TYPE_UNUSED},
+    Css_border_style_enum_vals},
+   {"border-rigth-width", {CSS_TYPE_ENUM, CSS_TYPE_LENGTH, CSS_TYPE_UNUSED},
+    Css_border_width_enum_vals},
+   {"border-spacing", {CSS_TYPE_LENGTH, CSS_TYPE_UNUSED}, NULL},
+   {"border-top-color", {CSS_TYPE_COLOR, CSS_TYPE_UNUSED}, NULL},
+   {"border-top-style", {CSS_TYPE_ENUM, CSS_TYPE_UNUSED},
+    Css_border_style_enum_vals},
+   {"border-top-width", {CSS_TYPE_ENUM, CSS_TYPE_LENGTH, CSS_TYPE_UNUSED},
+    Css_border_width_enum_vals},
+   {"bottom", {CSS_TYPE_UNUSED}, NULL},
+   {"caption-side", {CSS_TYPE_UNUSED}, NULL},
+   {"clear", {CSS_TYPE_UNUSED}, NULL},
+   {"clip", {CSS_TYPE_UNUSED}, NULL},
+   {"color", {CSS_TYPE_COLOR, CSS_TYPE_UNUSED}, NULL},
+   {"content", {CSS_TYPE_STRING, CSS_TYPE_UNUSED}, NULL},
+   {"counter-increment", {CSS_TYPE_UNUSED}, NULL},
+   {"counter-reset", {CSS_TYPE_UNUSED}, NULL},
+   {"cursor", {CSS_TYPE_ENUM, CSS_TYPE_UNUSED}, Css_cursor_enum_vals},
+   {"direction", {CSS_TYPE_UNUSED}, NULL},
+   {"display", {CSS_TYPE_ENUM, CSS_TYPE_UNUSED}, Css_display_enum_vals},
+   {"empty-cells", {CSS_TYPE_UNUSED}, NULL},
+   {"float", {CSS_TYPE_UNUSED}, NULL},
+   {"font-family", {CSS_TYPE_SYMBOL, CSS_TYPE_UNUSED}, NULL},
+   {"font-size", {CSS_TYPE_ENUM, CSS_TYPE_LENGTH_PERCENTAGE, CSS_TYPE_UNUSED},
+    Css_font_size_enum_vals},
+   {"font-size-adjust", {CSS_TYPE_UNUSED}, NULL},
+   {"font-stretch", {CSS_TYPE_UNUSED}, NULL},
+   {"font-style", {CSS_TYPE_ENUM, CSS_TYPE_UNUSED}, Css_font_style_enum_vals},
+   {"font-variant", {CSS_TYPE_UNUSED}, NULL},
+   {"font-weight", {CSS_TYPE_ENUM, CSS_TYPE_FONT_WEIGHT, CSS_TYPE_UNUSED},
+    Css_font_weight_enum_vals},
+   {"height", {CSS_TYPE_LENGTH_PERCENTAGE, CSS_TYPE_UNUSED}, NULL},
+   {"left", {CSS_TYPE_UNUSED}, NULL},
+   {"letter-spacing", {CSS_TYPE_ENUM, CSS_TYPE_SIGNED_LENGTH, CSS_TYPE_UNUSED},
+    Css_letter_spacing_enum_vals},
+   {"line-height",
+    {CSS_TYPE_ENUM, CSS_TYPE_LENGTH_PERCENTAGE_NUMBER, CSS_TYPE_UNUSED},
+    Css_line_height_enum_vals},
+   {"list-style-image", {CSS_TYPE_UNUSED}, NULL},
+   {"list-style-position", {CSS_TYPE_ENUM, CSS_TYPE_UNUSED},
+    Css_list_style_position_enum_vals},
+   {"list-style-type", {CSS_TYPE_ENUM, CSS_TYPE_UNUSED},
+    Css_list_style_type_enum_vals},
+   {"margin-bottom", {CSS_TYPE_SIGNED_LENGTH, CSS_TYPE_UNUSED}, NULL},
+   {"margin-left", {CSS_TYPE_SIGNED_LENGTH, CSS_TYPE_UNUSED}, NULL},
+   {"margin-right", {CSS_TYPE_SIGNED_LENGTH, CSS_TYPE_UNUSED}, NULL},
+   {"margin-top", {CSS_TYPE_SIGNED_LENGTH, CSS_TYPE_UNUSED}, NULL},
+   {"marker-offset", {CSS_TYPE_UNUSED}, NULL},
+   {"marks", {CSS_TYPE_UNUSED}, NULL},
+   {"max-height", {CSS_TYPE_UNUSED}, NULL},
+   {"max-width", {CSS_TYPE_UNUSED}, NULL},
+   {"min-height", {CSS_TYPE_UNUSED}, NULL},
+   {"min-width", {CSS_TYPE_UNUSED}, NULL},
+   {"outline-color", {CSS_TYPE_UNUSED}, NULL},
+   {"outline-style", {CSS_TYPE_UNUSED}, NULL},
+   {"outline-width", {CSS_TYPE_UNUSED}, NULL},
+   {"overflow", {CSS_TYPE_UNUSED}, NULL},
+   {"padding-bottom", {CSS_TYPE_LENGTH, CSS_TYPE_UNUSED}, NULL},
+   {"padding-left", {CSS_TYPE_LENGTH, CSS_TYPE_UNUSED}, NULL},
+   {"padding-right", {CSS_TYPE_LENGTH, CSS_TYPE_UNUSED}, NULL},
+   {"padding-top", {CSS_TYPE_LENGTH, CSS_TYPE_UNUSED}, NULL},
+   {"position", {CSS_TYPE_UNUSED}, NULL},
+   {"quotes", {CSS_TYPE_UNUSED}, NULL},
+   {"right", {CSS_TYPE_UNUSED}, NULL},
+   {"text-align", {CSS_TYPE_ENUM, CSS_TYPE_UNUSED}, Css_text_align_enum_vals},
+   {"text-decoration", {CSS_TYPE_MULTI_ENUM, CSS_TYPE_UNUSED},
+    Css_text_decoration_enum_vals},
+   {"text-indent", {CSS_TYPE_UNUSED}, NULL},
+   {"text-shadow", {CSS_TYPE_UNUSED}, NULL},
+   {"text-transform", {CSS_TYPE_UNUSED}, NULL},
+   {"top", {CSS_TYPE_UNUSED}, NULL},
+   {"unicode-bidi", {CSS_TYPE_UNUSED}, NULL},
+   {"vertical-align",{CSS_TYPE_ENUM, CSS_TYPE_UNUSED},Css_vertical_align_vals},
+   {"visibility", {CSS_TYPE_UNUSED}, NULL},
+   {"white-space", {CSS_TYPE_ENUM, CSS_TYPE_UNUSED}, Css_white_space_vals},
+   {"width", {CSS_TYPE_LENGTH_PERCENTAGE, CSS_TYPE_UNUSED}, NULL},
+   {"word-spacing", {CSS_TYPE_ENUM, CSS_TYPE_SIGNED_LENGTH, CSS_TYPE_UNUSED},
+    Css_word_spacing_enum_vals},
+   {"z-index", {CSS_TYPE_UNUSED}, NULL},
+
+   /* These are extensions, for internal used, and never parsed. */
+   {"x-link", {CSS_TYPE_INTEGER, CSS_TYPE_UNUSED}, NULL},
+   {"x-colspan", {CSS_TYPE_INTEGER, CSS_TYPE_UNUSED}, NULL},
+   {"x-rowspan", {CSS_TYPE_INTEGER, CSS_TYPE_UNUSED}, NULL},
+   {"last", {CSS_TYPE_UNUSED}, NULL},
+};
+
+typedef struct {
+   const char *symbol;
+   enum {
+      CSS_SHORTHAND_MULTIPLE,   /* [ p1 || p2 || ...], the property pi is
+                                 * determined  by the type */
+      CSS_SHORTHAND_DIRECTIONS, /* <t>{1,4} */
+      CSS_SHORTHAND_BORDER,     /* special, used for 'border' */
+      CSS_SHORTHAND_FONT,       /* special, used for 'font' */
+   } type;
+   const CssPropertyName * properties;/* CSS_SHORTHAND_MULTIPLE:
+                                       *   must be terminated by -1
+                                       * CSS_SHORTHAND_DIRECTIONS:
+                                       *   must have length 4
+                                       * CSS_SHORTHAND_BORDERS:
+                                       *   must have length 12
+                                       * CSS_SHORTHAND_FONT:
+                                       *   unused */
+} CssShorthandInfo;
+
+const CssPropertyName Css_background_properties[] = {
+   CSS_PROPERTY_BACKGROUND_COLOR,
+   CSS_PROPERTY_BACKGROUND_IMAGE,
+   CSS_PROPERTY_BACKGROUND_REPEAT,
+   CSS_PROPERTY_BACKGROUND_ATTACHMENT,
+   CSS_PROPERTY_BACKGROUND_POSITION,
+   (CssPropertyName) - 1
+};
+
+const CssPropertyName Css_border_bottom_properties[] = {
+   CSS_PROPERTY_BORDER_BOTTOM_WIDTH,
+   CSS_PROPERTY_BORDER_BOTTOM_STYLE,
+   CSS_PROPERTY_BORDER_BOTTOM_COLOR,
+   (CssPropertyName) - 1
+};
+
+const CssPropertyName Css_border_color_properties[4] = {
+   CSS_PROPERTY_BORDER_TOP_COLOR,
+   CSS_PROPERTY_BORDER_BOTTOM_COLOR,
+   CSS_PROPERTY_BORDER_LEFT_COLOR,
+   CSS_PROPERTY_BORDER_RIGHT_COLOR
+};
+
+const CssPropertyName Css_border_left_properties[] = {
+   CSS_PROPERTY_BORDER_LEFT_WIDTH,
+   CSS_PROPERTY_BORDER_LEFT_STYLE,
+   CSS_PROPERTY_BORDER_LEFT_COLOR,
+   (CssPropertyName) - 1
+};
+
+const CssPropertyName Css_border_right_properties[] = {
+   CSS_PROPERTY_BORDER_RIGHT_WIDTH,
+   CSS_PROPERTY_BORDER_RIGHT_STYLE,
+   CSS_PROPERTY_BORDER_RIGHT_COLOR,
+   (CssPropertyName) - 1
+};
+
+const CssPropertyName Css_border_style_properties[] = {
+   CSS_PROPERTY_BORDER_TOP_STYLE,
+   CSS_PROPERTY_BORDER_BOTTOM_STYLE,
+   CSS_PROPERTY_BORDER_LEFT_STYLE,
+   CSS_PROPERTY_BORDER_RIGHT_STYLE
+};
+
+const CssPropertyName Css_border_top_properties[] = {
+   CSS_PROPERTY_BORDER_TOP_WIDTH,
+   CSS_PROPERTY_BORDER_TOP_STYLE,
+   CSS_PROPERTY_BORDER_TOP_COLOR,
+   (CssPropertyName) - 1
+};
+
+const CssPropertyName Css_border_width_properties[] = {
+   CSS_PROPERTY_BORDER_TOP_WIDTH,
+   CSS_PROPERTY_BORDER_BOTTOM_WIDTH,
+   CSS_PROPERTY_BORDER_LEFT_WIDTH,
+   CSS_PROPERTY_BORDER_RIGHT_WIDTH
+};
+
+const CssPropertyName Css_list_style_properties[] = {
+   CSS_PROPERTY_LIST_STYLE_TYPE,
+   CSS_PROPERTY_LIST_STYLE_POSITION,
+   CSS_PROPERTY_LIST_STYLE_IMAGE,
+   (CssPropertyName) - 1
+};
+
+const CssPropertyName Css_margin_properties[] = {
+   CSS_PROPERTY_MARGIN_TOP,
+   CSS_PROPERTY_MARGIN_BOTTOM,
+   CSS_PROPERTY_MARGIN_LEFT,
+   CSS_PROPERTY_MARGIN_RIGHT
+};
+
+const CssPropertyName Css_outline_properties[] = {
+   CSS_PROPERTY_OUTLINE_COLOR,
+   CSS_PROPERTY_OUTLINE_STYLE,
+   CSS_PROPERTY_OUTLINE_WIDTH,
+   (CssPropertyName) - 1
+};
+
+const CssPropertyName Css_padding_properties[] = {
+   CSS_PROPERTY_PADDING_TOP,
+   CSS_PROPERTY_PADDING_BOTTOM,
+   CSS_PROPERTY_PADDING_LEFT,
+   CSS_PROPERTY_PADDING_RIGHT
+};
+
+const CssPropertyName Css_border_properties[] = {
+   CSS_PROPERTY_BORDER_TOP_WIDTH,
+   CSS_PROPERTY_BORDER_TOP_STYLE,
+   CSS_PROPERTY_BORDER_TOP_COLOR,
+   CSS_PROPERTY_BORDER_BOTTOM_WIDTH,
+   CSS_PROPERTY_BORDER_BOTTOM_STYLE,
+   CSS_PROPERTY_BORDER_BOTTOM_COLOR,
+   CSS_PROPERTY_BORDER_LEFT_WIDTH,
+   CSS_PROPERTY_BORDER_LEFT_STYLE,
+   CSS_PROPERTY_BORDER_LEFT_COLOR,
+   CSS_PROPERTY_BORDER_RIGHT_WIDTH,
+   CSS_PROPERTY_BORDER_RIGHT_STYLE,
+   CSS_PROPERTY_BORDER_RIGHT_COLOR
+};
+
+const CssPropertyName Css_font_properties[] = {
+   CSS_PROPERTY_FONT_SIZE,
+   CSS_PROPERTY_FONT_STYLE,
+   CSS_PROPERTY_FONT_VARIANT,
+   CSS_PROPERTY_FONT_WEIGHT,
+   CSS_PROPERTY_FONT_FAMILY,
+   (CssPropertyName) - 1
+};
+
+static const CssShorthandInfo Css_shorthand_info[] = {
+   {"background", CssShorthandInfo::CSS_SHORTHAND_MULTIPLE,
+    Css_background_properties},
+   {"border", CssShorthandInfo::CSS_SHORTHAND_BORDER,
+    Css_border_properties},
+   {"border-bottom", CssShorthandInfo::CSS_SHORTHAND_MULTIPLE,
+    Css_border_bottom_properties},
+   {"border-color", CssShorthandInfo::CSS_SHORTHAND_DIRECTIONS,
+    Css_border_color_properties},
+   {"border-left", CssShorthandInfo::CSS_SHORTHAND_MULTIPLE,
+    Css_border_left_properties},
+   {"border-right", CssShorthandInfo::CSS_SHORTHAND_MULTIPLE,
+    Css_border_right_properties},
+   {"border-style", CssShorthandInfo::CSS_SHORTHAND_DIRECTIONS,
+    Css_border_style_properties},
+   {"border-top", CssShorthandInfo::CSS_SHORTHAND_MULTIPLE,
+    Css_border_top_properties},
+   {"border-width", CssShorthandInfo::CSS_SHORTHAND_DIRECTIONS,
+    Css_border_width_properties},
+   {"font", CssShorthandInfo::CSS_SHORTHAND_FONT,
+    Css_font_properties},
+   {"list-style", CssShorthandInfo::CSS_SHORTHAND_MULTIPLE,
+    Css_list_style_properties},
+   {"margin", CssShorthandInfo::CSS_SHORTHAND_DIRECTIONS,
+    Css_margin_properties},
+   {"outline", CssShorthandInfo::CSS_SHORTHAND_MULTIPLE,
+    Css_outline_properties},
+   {"padding", CssShorthandInfo::CSS_SHORTHAND_DIRECTIONS,
+    Css_padding_properties},
+};
+
+#define CSS_SHORTHAND_NUM \
+   (sizeof(Css_shorthand_info) / sizeof(CssShorthandInfo))
+
+/* ----------------------------------------------------------------------
+ *    Parsing
+ * ---------------------------------------------------------------------- */
+
+CssParser::CssParser(CssContext *context, CssOrigin origin,
+                     const char *buf, int buflen)
+{
+   this->context = context;
+   this->origin = origin;
+   this->buf = buf;
+   this->buflen = buflen;
+   this->bufptr = 0;
+   this->spaceSeparated = false;
+   this->withinBlock = false;
+
+   nextToken ();
+}
+
+/*
+ * Gets the next character from the buffer, or EOF.
+ */
+int CssParser::getChar()
+{
+   int c;
+
+   if (bufptr >= buflen)
+      c = EOF;
+   else
+      c = buf[bufptr];
+
+   /* The buffer pointer is increased in any case, so that ungetChar works
+    * correctly at the end of the buffer. */
+   bufptr++;
+   return c;
+}
+
+/*
+ * Undoes the last getChar().
+ */
+void CssParser::ungetChar()
+{
+   bufptr--;
+}
+
+/*
+ * Skip string str if it is found in the input buffer.
+ * If not wind back. The first char is passed as parameter c
+ * to avoid unnecessary getChar() / ungetChar() calls.
+ */
+inline bool CssParser::skipString(int c, const char *str)
+{
+   int n = 0;
+
+   while (str[n]) {
+      if (str[n] != c) {
+         while (n--)
+            ungetChar();
+         return false;
+      }
+      c = getChar();
+      n++;
+   }
+
+   return true;
+}
+
+void CssParser::nextToken()
+{
+   int c, c1, d, j;
+   char hexbuf[5];
+   int i = 0;
+
+   ttype = CSS_TK_CHAR; /* init */
+   spaceSeparated = false;
+
+   while (true) {
+      c = getChar();
+      if (isspace(c)) {                    // ignore whitespace
+         spaceSeparated = true;
+      } else if (skipString(c, "/*")) {    // ignore comments
+         do {
+            c = getChar();
+         } while (c != EOF && ! skipString(c, "*/"));
+      } else if (skipString(c, "<!--")) {  // ignore XML comment markers
+      } else if (skipString(c, "-->")) {
+      } else {
+         break;
+      }
+   }
+
+   // handle negative numbers
+   if (c == '-') {
+      if (i < maxStrLen - 1)
+         tval[i++] = c;
+      c = getChar();
+   }
+
+   if (isdigit(c)) {
+      ttype = CSS_TK_DECINT;
+      do {
+         if (i < maxStrLen - 1) {
+            tval[i++] = c;
+         }
+         /* else silently truncated */
+         c = getChar();
+      } while (isdigit(c));
+      if (c != '.')
+         ungetChar();
+
+      /* ...but keep going to see whether it's really a float */
+   }
+
+   if (c == '.') {
+      c = getChar();
+      if (isdigit(c)) {
+         ttype = CSS_TK_FLOAT;
+         if (i < maxStrLen - 1)
+            tval[i++] = '.';
+         do {
+            if (i < maxStrLen - 1)
+               tval[i++] = c;
+            /* else silently truncated */
+            c = getChar();
+         } while (isdigit(c));
+
+         ungetChar();
+         tval[i] = 0;
+         DEBUG_MSG(DEBUG_TOKEN_LEVEL, "token number %s\n", tval);
+         return;
+      } else {
+         ungetChar();
+         if (ttype == CSS_TK_DECINT) {
+            ungetChar();
+         } else {
+            c = '.';
+         }
+      }
+   }
+
+   if (ttype == CSS_TK_DECINT) {
+      tval[i] = 0;
+      DEBUG_MSG(DEBUG_TOKEN_LEVEL, "token number %s\n", tval);
+      return;
+   }
+
+   if (i) {
+      ungetChar(); /* ungetChar '-' */
+      i--;
+      c = getChar();
+   }
+
+   if (isalpha(c) || c == '_' || c == '-') {
+      ttype = CSS_TK_SYMBOL;
+
+      tval[0] = c;
+      i = 1;
+      c = getChar();
+      while (isalnum(c) || c == '_' || c == '-') {
+         if (i < maxStrLen - 1) {
+            tval[i] = c;
+            i++;
+         }                      /* else silently truncated */
+         c = getChar();
+      }
+      tval[i] = 0;
+      ungetChar();
+      DEBUG_MSG(DEBUG_TOKEN_LEVEL, "token symbol '%s'\n", tval);
+      return;
+   }
+
+   if (c == '"' || c == '\'') {
+      c1 = c;
+      ttype = CSS_TK_STRING;
+
+      i = 0;
+      c = getChar();
+
+      while (c != EOF && c != c1) {
+         if (c == '\\') {
+            d = getChar();
+            if (isxdigit(d)) {
+               /* Read hex Unicode char. (Actually, strings are yet only 8
+                * bit.) */
+               hexbuf[0] = d;
+               j = 1;
+               d = getChar();
+               while (j < 4 && isxdigit(d)) {
+                  hexbuf[j] = d;
+                  j++;
+                  d = getChar();
+               }
+               hexbuf[j] = 0;
+               ungetChar();
+               c = strtol(hexbuf, NULL, 16);
+            } else {
+               /* Take character literally. */
+               c = d;
+            }
+         }
+
+         if (i < maxStrLen - 1) {
+            tval[i] = c;
+            i++;
+         }                      /* else silently truncated */
+         c = getChar();
+      }
+      tval[i] = 0;
+      /* No ungetChar(). */
+      DEBUG_MSG(DEBUG_TOKEN_LEVEL, "token string '%s'\n", tval);
+      return;
+   }
+
+   /*
+    * Within blocks, '#' starts a color, outside, it is used in selectors.
+    */
+   if (c == '#' && withinBlock) {
+      ttype = CSS_TK_COLOR;
+
+      tval[0] = c;
+      i = 1;
+      c = getChar();
+      while (isxdigit(c)) {
+         if (i < maxStrLen - 1) {
+            tval[i] = c;
+            i++;
+         }                      /* else silently truncated */
+         c = getChar();
+      }
+      tval[i] = 0;
+      ungetChar();
+      DEBUG_MSG(DEBUG_TOKEN_LEVEL, "token color '%s'\n", tval);
+      return;
+   }
+
+   if (c == EOF) {
+      DEBUG_MSG(DEBUG_TOKEN_LEVEL, "token %s\n", "EOF");
+      ttype = CSS_TK_END;
+      return;
+   }
+
+   ttype = CSS_TK_CHAR;
+   tval[0] = c;
+   tval[1] = 0;
+   DEBUG_MSG(DEBUG_TOKEN_LEVEL, "token char '%c'\n", c);
+}
+
+
+bool CssParser::tokenMatchesProperty(CssPropertyName prop, CssValueType *type)
+{
+   int i, err = 1;
+   CssValueType savedType = *type;
+
+   for (int j = 0; Css_property_info[prop].type[j] != CSS_TYPE_UNUSED; j++) {
+      *type = Css_property_info[prop].type[j];
+
+      switch (Css_property_info[prop].type[j]) {
+
+      case CSS_TYPE_ENUM:
+         if (ttype == CSS_TK_SYMBOL) {
+            for (i = 0; Css_property_info[prop].enum_symbols[i]; i++)
+               if (dStrcasecmp(tval,
+                     Css_property_info[prop].enum_symbols[i]) == 0)
+                  return true;
+         }
+         break;
+
+      case CSS_TYPE_MULTI_ENUM:
+         if (ttype == CSS_TK_SYMBOL) {
+            if (dStrcasecmp(tval, "none") == 0)
+                  return true;
+            else {
+               for (i = 0; Css_property_info[prop].enum_symbols[i]; i++) {
+                  if (dStrcasecmp(tval,
+                        Css_property_info[prop].enum_symbols[i]) == 0)
+                     return true;
+               }
+            }
+         }
+         break;
+
+      case CSS_TYPE_LENGTH_PERCENTAGE:
+      case CSS_TYPE_LENGTH_PERCENTAGE_NUMBER:
+      case CSS_TYPE_LENGTH:
+         if  (tval[0] == '-')
+            return false;
+         // Fall Through
+      case CSS_TYPE_SIGNED_LENGTH:
+         if (ttype == CSS_TK_DECINT ||
+             ttype == CSS_TK_FLOAT ||
+             (ttype == CSS_TK_SYMBOL && dStrcasecmp(tval, "auto") == 0))
+            return true;
+         break;
+
+      case CSS_TYPE_COLOR:
+         if ((ttype == CSS_TK_COLOR ||
+              ttype == CSS_TK_SYMBOL) &&
+            (dStrcasecmp(tval, "rgb") == 0 ||
+             a_Color_parse(tval, -1, &err) != -1))
+            return true;
+         break;
+
+      case CSS_TYPE_STRING:
+         if (ttype == CSS_TK_STRING)
+            return true;
+         break;
+
+      case CSS_TYPE_SYMBOL:
+         if (ttype == CSS_TK_SYMBOL ||
+             ttype == CSS_TK_STRING)
+            return true;
+         break;
+
+      case CSS_TYPE_FONT_WEIGHT:
+         if (ttype == CSS_TK_DECINT) {
+            i = strtol(tval, NULL, 10);
+            if (i >= 100 && i <= 900)
+               return true;
+         }
+         break;
+
+      case CSS_TYPE_UNUSED:
+      case CSS_TYPE_INTEGER:
+         /* Not used for parser values. */
+      default:
+         assert(false);
+         break;
+      }
+   }
+
+   *type = savedType;
+   return false;
+}
+
+bool CssParser::parseRgbColorComponent(int32_t *cc, int *percentage) {
+   if (ttype != CSS_TK_DECINT) {
+      MSG_CSS("expected integer not found in %s color\n", "rgb");
+      return false;
+   }
+
+   *cc = strtol(tval, NULL, 10);
+
+   nextToken();
+   if (ttype == CSS_TK_CHAR && tval[0] == '%') {
+      if (*percentage == 0) {
+         MSG_CSS("'%s' unexpected in rgb color\n", "%");
+         return false;
+      }
+      *percentage = 1;
+      *cc = *cc * 255 / 100;
+      nextToken();
+   } else {
+      if (*percentage == 1) {
+         MSG_CSS("expected '%s' not found in rgb color\n", "%");
+         return false;
+      }
+      *percentage = 0;
+   }
+
+   if (*cc > 255)
+      *cc = 255;
+   if (*cc < 0)
+      *cc = 0;
+
+   return true;
+}
+
+bool CssParser::parseRgbColor(int32_t *c) {
+   int32_t cc;
+   int percentage = -1;
+
+   *c = 0;
+
+   if (ttype != CSS_TK_CHAR || tval[0] != '(') {
+      MSG_CSS("expected '%s' not found in rgb color\n", "(");
+      return false;
+   }
+   nextToken();
+
+   if (!parseRgbColorComponent(&cc, &percentage))
+      return false;
+   *c |= cc << 16;
+
+   if (ttype != CSS_TK_CHAR || tval[0] != ',') {
+      MSG_CSS("expected '%s' not found in rgb color\n", ",");
+      return false;
+   }
+   nextToken();
+
+   if (!parseRgbColorComponent(&cc, &percentage))
+      return false;
+   *c |= cc << 8;
+
+   if (ttype != CSS_TK_CHAR || tval[0] != ',') {
+      MSG_CSS("expected '%s' not found in rgb color\n", ",");
+      return false;
+   }
+   nextToken();
+
+   if (!parseRgbColorComponent(&cc, &percentage))
+      return false;
+   *c |= cc;
+
+   if (ttype != CSS_TK_CHAR || tval[0] != ')') {
+      MSG_CSS("expected '%s' not found in rgb color\n", ")");
+      return false;
+   }
+
+   return true;
+}
+
+bool CssParser::parseValue(CssPropertyName prop,
+                           CssValueType type,
+                           CssPropertyValue * val)
+{
+   CssLengthType lentype;
+   bool found, ret = false;
+   float fval;
+   int i, ival, err = 1;
+   Dstr *dstr;
+
+   switch (type) {
+   case CSS_TYPE_ENUM:
+      if (ttype == CSS_TK_SYMBOL) {
+         for (i = 0; Css_property_info[prop].enum_symbols[i]; i++)
+            if (dStrcasecmp(tval,
+                            Css_property_info[prop].enum_symbols[i]) == 0) {
+               val->intVal = i;
+               ret = true;
+               break;
+            }
+         nextToken();
+      }
+      break;
+
+   case CSS_TYPE_MULTI_ENUM:
+      val->intVal = 0;
+      ret = true;
+
+      while (ttype == CSS_TK_SYMBOL) {
+         if (dStrcasecmp(tval, "none") != 0) {
+            for (i = 0, found = false;
+                 !found && Css_property_info[prop].enum_symbols[i]; i++) {
+               if (dStrcasecmp(tval,
+                               Css_property_info[prop].enum_symbols[i]) == 0)
+                  val->intVal |= (1 << i);
+            }
+         }
+         nextToken();
+      }
+      break;
+
+   case CSS_TYPE_LENGTH_PERCENTAGE:
+   case CSS_TYPE_LENGTH_PERCENTAGE_NUMBER:
+   case CSS_TYPE_LENGTH:
+   case CSS_TYPE_SIGNED_LENGTH:
+      if (ttype == CSS_TK_DECINT || ttype == CSS_TK_FLOAT) {
+         fval = atof(tval);
+         lentype = CSS_LENGTH_TYPE_NONE;
+
+         nextToken();
+         if (!spaceSeparated && ttype == CSS_TK_SYMBOL) {
+            ret = true;
+
+            if (dStrcasecmp(tval, "px") == 0) {
+               lentype = CSS_LENGTH_TYPE_PX;
+               nextToken();
+            } else if (dStrcasecmp(tval, "mm") == 0) {
+               lentype = CSS_LENGTH_TYPE_MM;
+               nextToken();
+            } else if (dStrcasecmp(tval, "cm") == 0) {
+               lentype = CSS_LENGTH_TYPE_MM;
+               fval *= 10;
+               nextToken();
+            } else if (dStrcasecmp(tval, "in") == 0) {
+               lentype = CSS_LENGTH_TYPE_MM;
+               fval *= 25.4;
+               nextToken();
+            } else if (dStrcasecmp(tval, "pt") == 0) {
+               lentype = CSS_LENGTH_TYPE_MM;
+               fval *= (25.4 / 72);
+               nextToken();
+            } else if (dStrcasecmp(tval, "pc") == 0) {
+               lentype = CSS_LENGTH_TYPE_MM;
+               fval *= (25.4 / 6);
+               nextToken();
+            } else if (dStrcasecmp(tval, "em") == 0) {
+               lentype = CSS_LENGTH_TYPE_EM;
+               nextToken();
+            } else if (dStrcasecmp(tval, "ex") == 0) {
+               lentype = CSS_LENGTH_TYPE_EX;
+               nextToken();
+            } else {
+               ret = false;
+            }
+         } else if (!spaceSeparated &&
+                    (type == CSS_TYPE_LENGTH_PERCENTAGE ||
+                     type == CSS_TYPE_LENGTH_PERCENTAGE_NUMBER) &&
+                    ttype == CSS_TK_CHAR &&
+                    tval[0] == '%') {
+            fval /= 100;
+            lentype = CSS_LENGTH_TYPE_PERCENTAGE;
+            ret = true;
+            nextToken();
+         }
+
+         /* Allow numbers without unit only for 0 or
+          * CSS_TYPE_LENGTH_PERCENTAGE_NUMBER
+          */
+         if (lentype == CSS_LENGTH_TYPE_NONE &&
+            (type == CSS_TYPE_LENGTH_PERCENTAGE_NUMBER || fval == 0.0))
+            ret = true;
+
+         val->intVal = CSS_CREATE_LENGTH(fval, lentype);
+      } else if (ttype == CSS_TK_SYMBOL && dStrcasecmp(tval, "auto") == 0) {
+         ret = true;
+         val->intVal = CSS_LENGTH_TYPE_AUTO;
+         nextToken();
+      }
+      break;
+
+   case CSS_TYPE_COLOR:
+      if (ttype == CSS_TK_COLOR) {
+         val->intVal = a_Color_parse(tval, -1, &err);
+         if (err)
+            MSG_CSS("color is not in \"%s\" format\n", "#RRGGBB");
+         else
+            ret = true;
+         nextToken();
+      } else if (ttype == CSS_TK_SYMBOL) {
+         if (dStrcasecmp(tval, "rgb") == 0) {
+            nextToken();
+            if (parseRgbColor(&val->intVal))
+               ret = true;
+            else
+               MSG_CSS("Failed to parse %s color\n", "rgb(r,g,b)");
+         } else {
+            val->intVal = a_Color_parse(tval, -1, &err);
+            if (err)
+               MSG_CSS("color is not in \"%s\" format\n", "#RRGGBB");
+            else
+               ret = true;
+         }
+         nextToken();
+      }
+      break;
+
+   case CSS_TYPE_STRING:
+      if (ttype == CSS_TK_STRING) {
+         val->strVal = dStrdup(tval);
+         ret = true;
+         nextToken();
+      }
+      break;
+
+   case CSS_TYPE_SYMBOL:
+      /* Read comma separated list of font family names */
+      dstr = dStr_new("");
+      while (ttype == CSS_TK_SYMBOL || ttype == CSS_TK_STRING ||
+             (ttype == CSS_TK_CHAR && tval[0] == ',')) {
+         if (spaceSeparated)
+            dStr_append_c(dstr, ' ');
+         dStr_append(dstr, tval);
+         ret = true;
+         nextToken();
+      }
+
+      if (ret) {
+         val->strVal = dStrstrip(dstr->str);
+         dStr_free(dstr, 0);
+      } else {
+         dStr_free(dstr, 1);
+      }
+      break;
+
+   case CSS_TYPE_FONT_WEIGHT:
+      ival = 0;
+      if (ttype == CSS_TK_DECINT) {
+         ival = strtol(tval, NULL, 10);
+         if (ival < 100 || ival > 900)
+            /* invalid */
+            ival = 0;
+      }
+
+      if (ival != 0) {
+         val->intVal = ival;
+         ret = true;
+         nextToken();
+      }
+      break;
+
+   case CSS_TYPE_UNUSED:
+      /* nothing */
+      break;
+
+   case CSS_TYPE_INTEGER:
+      /* Not used for parser values. */
+   default:
+      assert(false);            /* not reached */
+   }
+
+   return ret;
+}
+
+bool CssParser::parseWeight()
+{
+   if (ttype == CSS_TK_CHAR && tval[0] == '!') {
+      nextToken();
+      if (ttype == CSS_TK_SYMBOL &&
+          dStrcasecmp(tval, "important") == 0) {
+         nextToken();
+         return true;
+      }
+   }
+
+   return false;
+}
+
+/*
+ * bsearch(3) compare function for searching properties
+ */
+static int Css_property_info_cmp(const void *a, const void *b)
+{
+   return dStrcasecmp(((CssPropertyInfo *) a)->symbol,
+                      ((CssPropertyInfo *) b)->symbol);
+}
+
+
+/*
+ * bsearch(3) compare function for searching shorthands
+ */
+static int Css_shorthand_info_cmp(const void *a, const void *b)
+{
+   return dStrcasecmp(((CssShorthandInfo *) a)->symbol,
+                      ((CssShorthandInfo *) b)->symbol);
+}
+
+void CssParser::parseDeclaration(CssPropertyList * props,
+                                 CssPropertyList * importantProps)
+{
+   CssPropertyInfo pi = {NULL, {CSS_TYPE_UNUSED}, NULL}, *pip;
+   CssShorthandInfo si, *sip;
+   CssValueType type = CSS_TYPE_UNUSED;
+
+   CssPropertyName prop;
+   CssPropertyValue val, dir_vals[4];
+   CssValueType  dir_types[4];
+   bool found, weight;
+   int sh_index, i, j, n;
+   int dir_set[4][4] = {
+      /* 1 value  */ {0, 0, 0, 0},
+      /* 2 values */ {0, 0, 1, 1},
+      /* 3 values */ {0, 2, 1, 1},
+      /* 4 values */ {0, 2, 3, 1}
+   };
+
+   if (ttype == CSS_TK_SYMBOL) {
+      pi.symbol = tval;
+      pip =
+          (CssPropertyInfo *) bsearch(&pi, Css_property_info,
+                                      CSS_NUM_PARSED_PROPERTIES,
+                                      sizeof(CssPropertyInfo),
+                                      Css_property_info_cmp);
+      if (pip) {
+         prop = (CssPropertyName) (pip - Css_property_info);
+         nextToken();
+         if (ttype == CSS_TK_CHAR && tval[0] == ':') {
+            nextToken();
+            if (tokenMatchesProperty (prop, &type) &&
+                parseValue(prop, type, &val)) {
+               weight = parseWeight();
+               if (weight && importantProps)
+                  importantProps->set(prop, type, val);
+               else
+                  props->set(prop, type, val);
+            }
+         }
+      } else {
+         /* Try shorthands. */
+         si.symbol = tval;
+         sip =
+             (CssShorthandInfo *) bsearch(&pi, Css_shorthand_info,
+                                          CSS_SHORTHAND_NUM,
+                                          sizeof(CssShorthandInfo),
+                                          Css_shorthand_info_cmp);
+         if (sip) {
+            sh_index = sip - Css_shorthand_info;
+            nextToken();
+            if (ttype == CSS_TK_CHAR && tval[0] == ':') {
+               nextToken();
+
+               switch (Css_shorthand_info[sh_index].type) {
+
+               case CssShorthandInfo::CSS_SHORTHAND_FONT:
+                  /* \todo Implement details. */
+               case CssShorthandInfo::CSS_SHORTHAND_MULTIPLE:
+                  do {
+                     for (found = false, i = 0;
+                          !found &&
+                          Css_shorthand_info[sh_index].properties[i] != -1;
+                          i++)
+                        if (tokenMatchesProperty(Css_shorthand_info[sh_index].
+                                                 properties[i], &type)) {
+                           found = true;
+                           DEBUG_MSG(DEBUG_PARSE_LEVEL,
+                                     "will assign to '%s'\n",
+                                     Css_property_info
+                                     [Css_shorthand_info[sh_index]
+                                      .properties[i]].symbol);
+                           if (parseValue(Css_shorthand_info[sh_index]
+                                          .properties[i], type, &val)) {
+                              weight = parseWeight();
+                              if (weight && importantProps)
+                                 importantProps->
+                                     set(Css_shorthand_info[sh_index].
+                                         properties[i], type, val);
+                              else
+                                 props->set(Css_shorthand_info[sh_index].
+                                            properties[i], type, val);
+                           }
+                        }
+                  } while (found);
+                  break;
+
+               case CssShorthandInfo::CSS_SHORTHAND_DIRECTIONS:
+                  n = 0;
+                  while (n < 4) {
+                     if (tokenMatchesProperty(Css_shorthand_info[sh_index].
+                                              properties[0], &type) &&
+                         parseValue(Css_shorthand_info[sh_index]
+                                    .properties[0], type, &val)) {
+                        dir_vals[n] = val;
+                        dir_types[n] = type;
+                        n++;
+                     } else
+                        break;
+                  }
+
+                  weight = parseWeight();
+                  if (n > 0) {
+                     for (i = 0; i < 4; i++)
+                        if (weight && importantProps)
+                           importantProps->set(Css_shorthand_info[sh_index]
+                                               .properties[i],
+                                               dir_types[dir_set[n - 1][i]],
+                                               dir_vals[dir_set[n - 1][i]]);
+                        else
+                           props->set(Css_shorthand_info[sh_index]
+                                      .properties[i],
+                                      dir_types[dir_set[n - 1][i]],
+                                      dir_vals[dir_set[n - 1][i]]);
+                  } else
+                     MSG_CSS("no values for shorthand property '%s'\n",
+                             Css_shorthand_info[sh_index].symbol);
+
+                  break;
+
+               case CssShorthandInfo::CSS_SHORTHAND_BORDER:
+                  do {
+                     for (found = false, i = 0;
+                          !found && i < 3;
+                          i++)
+                        if (tokenMatchesProperty(Css_shorthand_info[sh_index].
+                                                 properties[i], &type)) {
+                           found = true;
+                           if (parseValue(Css_shorthand_info[sh_index]
+                                          .properties[i], type, &val)) {
+                              weight = parseWeight();
+                              for (j = 0; j < 4; j++)
+                                 if (weight && importantProps)
+                                    importantProps->
+                                       set(Css_shorthand_info[sh_index].
+                                          properties[j * 3 + i], type, val);
+                                 else
+                                    props->set(Css_shorthand_info[sh_index].
+                                       properties[j * 3 + i], type, val);
+                           }
+                        }
+                  } while (found);
+                  break;
+               }
+            }
+         }
+      }
+   }
+
+   /* Skip all tokens until the expected end. */
+   while (!(ttype == CSS_TK_END ||
+            (ttype == CSS_TK_CHAR &&
+             (tval[0] == ';' || tval[0] == '}'))))
+      nextToken();
+
+   if (ttype == CSS_TK_CHAR && tval[0] == ';')
+      nextToken();
+}
+
+bool CssParser::parseSimpleSelector(CssSimpleSelector *selector)
+{
+   CssSimpleSelector::SelectType selectType;
+
+   if (ttype == CSS_TK_SYMBOL) {
+      selector->setElement (a_Html_tag_index(tval));
+      nextToken();
+      if (spaceSeparated)
+         return true;
+   } else if (ttype == CSS_TK_CHAR && tval[0] == '*') {
+      selector->setElement (CssSimpleSelector::ELEMENT_ANY);
+      nextToken();
+      if (spaceSeparated)
+         return true;
+   } else if (ttype == CSS_TK_CHAR &&
+              (tval[0] == '#' ||
+               tval[0] == '.' ||
+               tval[0] == ':')) {
+      // nothing to be done in this case
+   } else {
+      return false;
+   }
+
+   do {
+      selectType = CssSimpleSelector::SELECT_NONE;
+      if (ttype == CSS_TK_CHAR) {
+         switch (tval[0]) {
+         case '#':
+            selectType = CssSimpleSelector::SELECT_ID;
+            break;
+         case '.':
+            selectType = CssSimpleSelector::SELECT_CLASS;
+            break;
+         case ':':
+            selectType = CssSimpleSelector::SELECT_PSEUDO_CLASS;
+            if (selector->getPseudoClass ())
+               // pseudo class has been set already.
+               // As dillo currently only supports :link and :visisted, a
+               // selector with more than one pseudo class will never match.
+               // By returning false, the whole CssRule will be dropped.
+               // \todo adapt this when supporting :hover, :active...
+               return false;
+            break;
+         }
+      }
+
+      if (selectType != CssSimpleSelector::SELECT_NONE) {
+         nextToken();
+         if (spaceSeparated)
+            return true;
+
+         if (ttype == CSS_TK_SYMBOL) {
+            selector->setSelect (selectType, tval);
+            nextToken();
+         } else {
+            return false; // don't accept classes or id's starting with integer
+         }
+         if (spaceSeparated)
+            return true;
+      }
+   } while (selectType != CssSimpleSelector::SELECT_NONE);
+
+   DEBUG_MSG(DEBUG_PARSE_LEVEL, "end of simple selector (%s, %s, %s, %d)\n",
+      selector->id, selector->klass,
+      selector->pseudo, selector->element);
+
+   return true;
+}
+
+CssSelector *CssParser::parseSelector()
+{
+   CssSelector *selector = new CssSelector ();
+
+   while (true) {
+      if (! parseSimpleSelector (selector->top ())) {
+         delete selector;
+         selector = NULL;
+         break;
+      }
+
+      if (ttype == CSS_TK_CHAR &&
+         (tval[0] == ',' || tval[0] == '{')) {
+         break;
+      } else if (ttype == CSS_TK_CHAR && tval[0] == '>') {
+         selector->addSimpleSelector (CssSelector::CHILD);
+         nextToken();
+      } else if (ttype != CSS_TK_END && spaceSeparated) {
+         selector->addSimpleSelector (CssSelector::DESCENDANT);
+      } else {
+         delete selector;
+         selector = NULL;
+         break;
+      }
+   }
+
+   while (ttype != CSS_TK_END &&
+          (ttype != CSS_TK_CHAR ||
+           (tval[0] != ',' && tval[0] != '{')))
+         nextToken();
+
+   return selector;
+}
+
+void CssParser::parseRuleset()
+{
+   lout::misc::SimpleVector < CssSelector * >*list;
+   CssPropertyList *props, *importantProps;
+   CssSelector *selector;
+
+   list = new lout::misc::SimpleVector < CssSelector * >(1);
+
+   while (true) {
+      selector = parseSelector();
+
+      if (selector) {
+         selector->ref();
+         list->increase();
+         list->set(list->size() - 1, selector);
+      }
+
+      // \todo dump whole ruleset in case of parse error as required by CSS 2.1
+      //       however make sure we don't dump it if only dillo fails to parse
+      //       valid CSS.
+
+      if (ttype == CSS_TK_CHAR && tval[0] == ',')
+         /* To read the next token. */
+         nextToken();
+      else
+         /* No more selectors. */
+         break;
+   }
+
+   DEBUG_MSG(DEBUG_PARSE_LEVEL, "end of %s\n", "selectors");
+
+   props = new CssPropertyList(true);
+   props->ref();
+   importantProps = new CssPropertyList(true);
+   importantProps->ref();
+
+   /* Read block. ('{' has already been read.) */
+   if (ttype != CSS_TK_END) {
+      withinBlock = true;
+      nextToken();
+      do
+         parseDeclaration(props, importantProps);
+      while (!(ttype == CSS_TK_END ||
+               (ttype == CSS_TK_CHAR && tval[0] == '}')));
+      withinBlock = false;
+   }
+
+   for (int i = 0; i < list->size(); i++) {
+      CssSelector *s = list->get(i);
+
+      if (origin == CSS_ORIGIN_USER_AGENT) {
+         context->addRule(s, props, CSS_PRIMARY_USER_AGENT);
+      } else if (origin == CSS_ORIGIN_USER) {
+         context->addRule(s, props, CSS_PRIMARY_USER);
+         context->addRule(s, importantProps, CSS_PRIMARY_USER_IMPORTANT);
+      } else if (origin == CSS_ORIGIN_AUTHOR) {
+         context->addRule(s, props, CSS_PRIMARY_AUTHOR);
+         context->addRule(s, importantProps, CSS_PRIMARY_AUTHOR_IMPORTANT);
+      }
+
+      s->unref();
+   }
+
+   props->unref();
+   importantProps->unref();
+
+   delete list;
+
+   if (ttype == CSS_TK_CHAR && tval[0] == '}')
+      nextToken();
+}
+
+char * CssParser::parseUrl()
+{
+   Dstr *urlStr = NULL;
+
+   if (ttype != CSS_TK_SYMBOL ||
+      dStrcasecmp(tval, "url") != 0)
+      return NULL;
+
+   nextToken();
+
+   if (ttype != CSS_TK_CHAR || tval[0] != '(')
+      return NULL;
+
+   nextToken();
+
+   if (ttype == CSS_TK_STRING) {
+      urlStr = dStr_new(tval);
+      nextToken();
+   } else {
+      urlStr = dStr_new("");
+      while (ttype != CSS_TK_END &&
+             (ttype != CSS_TK_CHAR || tval[0] != ')')) {
+         dStr_append(urlStr, tval);
+         nextToken();
+      }
+   }
+
+   if (ttype != CSS_TK_CHAR || tval[0] != ')') {
+      dStr_free(urlStr, 1);
+      urlStr = NULL;
+   }
+
+   if (urlStr) {
+      char *url = urlStr->str;
+      dStr_free(urlStr, 0);
+      return url;
+   } else {
+      return NULL;
+   }
+}
+
+void CssParser::parseImport(DilloHtml *html, DilloUrl *baseUrl)
+{
+   char *urlStr = NULL;
+
+   if (html != NULL &&
+      ttype == CSS_TK_SYMBOL &&
+      dStrcasecmp(tval, "import") == 0) {
+      nextToken();
+
+      if (ttype == CSS_TK_SYMBOL &&
+         dStrcasecmp(tval, "url") == 0)
+         urlStr = parseUrl();
+      else if (ttype == CSS_TK_STRING)
+         urlStr = dStrdup (tval);
+
+      /* Skip all tokens until the expected end. */
+      while (!(ttype == CSS_TK_END ||
+            (ttype == CSS_TK_CHAR && (tval[0] == ';'))))
+         nextToken();
+
+      nextToken();
+
+      if (urlStr) {
+         MSG("CssParser::parseImport(): @import %s\n", urlStr);
+         DilloUrl *url = a_Html_url_new (html, urlStr, a_Url_str(baseUrl),
+                                         baseUrl ? 1 : 0);
+         a_Html_load_stylesheet(html, url);
+         a_Url_free(url);
+         dFree (urlStr);
+      }
+   }
+}
+
+const char * CssParser::propertyNameString(CssPropertyName name)
+{
+   return Css_property_info[name].symbol;
+}
+
+void CssParser::parse(DilloHtml *html, DilloUrl *url, CssContext * context,
+                      const char *buf,
+                      int buflen, CssOrigin origin)
+{
+   CssParser parser (context, origin, buf, buflen);
+
+   while (parser.ttype == CSS_TK_CHAR && parser.tval[0] == '@') {
+      parser.nextToken();
+      parser.parseImport(html, url);
+   }
+
+   while (parser.ttype != CSS_TK_END)
+      parser.parseRuleset();
+}
+
+CssPropertyList *CssParser::parseDeclarationBlock(const char *buf, int buflen)
+{
+   CssPropertyList *props = new CssPropertyList (true);
+   CssParser parser (NULL, CSS_ORIGIN_AUTHOR, buf, buflen);
+
+   parser.withinBlock = true;
+
+   do
+      parser.parseDeclaration(props, NULL);
+   while (!(parser.ttype == CSS_TK_END ||
+         (parser.ttype == CSS_TK_CHAR && parser.tval[0] == '}')));
+
+   if (props->size () == 0) {
+      delete props;
+      props = NULL;
+   }
+
+   return props;
+}