Renamed sass -> theme-compiler for consistency (#9299)

63 files changed, 17739 insertions, 0 deletions

diff --git a/theme-compiler/src/com/vaadin/sass/SassCompiler.java b/theme-compiler/src/com/vaadin/sass/SassCompiler.java
new file mode 100644
index 0000000000..555797066b
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/SassCompiler.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class SassCompiler {
+
+    public static void main(String[] args) throws Exception {
+        String input = null;
+        String output = null;
+        if (args.length == 0) {
+            System.out
+                    .println("usage: SassCompile <scss file to compile> <css file to write>");
+            return;
+        } else if (args.length == 1) {
+            input = args[0];
+        } else {
+            input = args[0];
+            output = args[1];
+        }
+
+        // ScssStylesheet.setStylesheetResolvers(new VaadinResolver());
+
+        ScssStylesheet scss = ScssStylesheet.get(input);
+        scss.compile();
+        if (output == null) {
+            System.out.println(scss.toString());
+        } else {
+            writeFile(output, scss.toString());
+        }
+    }
+
+    public static void writeFile(String filename, String output)
+            throws IOException {
+        File file = new File(filename);
+        FileWriter writer = new FileWriter(file);
+        writer.write(output);
+        writer.close();
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/ScssServlet.java b/theme-compiler/src/com/vaadin/sass/ScssServlet.java
new file mode 100644
index 0000000000..a345ca1583
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/ScssServlet.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+public class ScssServlet extends HttpServlet {
+    @Override
+    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
+            throws ServletException, IOException {
+        String cssPath = req.getRequestURI();
+        if (cssPath.endsWith(".css")) {
+            File cssFile = new File(cssPath);
+            if (cssFile.exists()) {
+
+            } else {
+                String scssPath = cssPath.replace(".css", ".scss");
+                File scssFile = new File(scssPath);
+                if (scssFile.exists()) {
+                    ScssStylesheet scss = ScssStylesheet.get(cssPath);
+                    try {
+                        scss.compile();
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                    resp.setContentType("text/css");
+                    OutputStream fout = resp.getOutputStream();
+                    OutputStream bos = new BufferedOutputStream(fout);
+                    OutputStreamWriter outputwriter = new OutputStreamWriter(
+                            bos);
+                    outputwriter.write(scss.toString());
+                }
+
+            }
+        }
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/ScssStylesheet.java b/theme-compiler/src/com/vaadin/sass/ScssStylesheet.java
new file mode 100644
index 0000000000..b38cab82a0
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/ScssStylesheet.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.w3c.css.sac.CSSException;
+import org.w3c.css.sac.InputSource;
+
+import com.vaadin.sass.handler.SCSSDocumentHandler;
+import com.vaadin.sass.handler.SCSSDocumentHandlerImpl;
+import com.vaadin.sass.parser.Parser;
+import com.vaadin.sass.resolver.ScssStylesheetResolver;
+import com.vaadin.sass.resolver.VaadinResolver;
+import com.vaadin.sass.tree.Node;
+import com.vaadin.sass.visitor.BlockVisitor;
+import com.vaadin.sass.visitor.ControlVisitor;
+import com.vaadin.sass.visitor.ExtendVisitor;
+import com.vaadin.sass.visitor.ImportVisitor;
+import com.vaadin.sass.visitor.MixinVisitor;
+import com.vaadin.sass.visitor.NestPropertiesVisitor;
+import com.vaadin.sass.visitor.ParentSelectorVisitor;
+import com.vaadin.sass.visitor.VariableVisitor;
+import com.vaadin.sass.visitor.Visitor;
+
+public class ScssStylesheet extends Node {
+
+    private static final long serialVersionUID = 3849790204404961608L;
+
+    /**
+     * Read in a file SCSS and parse it into a ScssStylesheet
+     * 
+     * @param file
+     * @throws IOException
+     */
+    public ScssStylesheet() {
+        super();
+    }
+
+    /**
+     * Main entry point for the SASS compiler. Takes in a file and builds upp a
+     * ScssStylesheet tree out of it. Calling compile() on it will transform
+     * SASS into CSS. Calling toString() will print out the SCSS/CSS.
+     * 
+     * @param file
+     * @return
+     * @throws CSSException
+     * @throws IOException
+     */
+    public static ScssStylesheet get(String identifier) throws CSSException,
+            IOException {
+        File file = new File(identifier);
+        file = file.getCanonicalFile();
+
+        SCSSDocumentHandler handler = new SCSSDocumentHandlerImpl();
+        ScssStylesheet stylesheet = handler.getStyleSheet();
+
+        InputSource source = stylesheet.resolveStylesheet(identifier);
+        if (source == null) {
+            return null;
+        }
+
+        Parser parser = new Parser();
+        parser.setDocumentHandler(handler);
+        parser.parseStyleSheet(source);
+
+        return stylesheet;
+    }
+
+    private static ScssStylesheetResolver[] resolvers = null;
+
+    public static void setStylesheetResolvers(
+            ScssStylesheetResolver... styleSheetResolvers) {
+        resolvers = Arrays.copyOf(styleSheetResolvers,
+                styleSheetResolvers.length);
+    }
+
+    public InputSource resolveStylesheet(String identifier) {
+        if (resolvers == null) {
+            setStylesheetResolvers(new VaadinResolver());
+        }
+
+        for (ScssStylesheetResolver resolver : resolvers) {
+            InputSource source = resolver.resolve(identifier);
+            if (source != null) {
+                File f = new File(source.getURI());
+                setFileName(f.getParent());
+                return source;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Applies all the visitors and compiles SCSS into Css.
+     * 
+     * @throws Exception
+     */
+    public void compile() throws Exception {
+        List<Visitor> visitors = new ArrayList<Visitor>();
+        visitors.add(new ImportVisitor());
+        visitors.add(new MixinVisitor());
+        visitors.add(new VariableVisitor());
+        visitors.add(new ParentSelectorVisitor());
+        visitors.add(new BlockVisitor());
+        visitors.add(new NestPropertiesVisitor());
+        visitors.add(new ExtendVisitor());
+        visitors.add(new ControlVisitor());
+        ArrayList<Node> children2 = children;
+        for (Visitor visitor : visitors) {
+            visitor.traverse(this);
+        }
+    }
+
+    /**
+     * Prints out the current state of the node tree. Will return SCSS before
+     * compile and CSS after.
+     * 
+     * For now this is an own method with it's own implementation that most node
+     * types will implement themselves.
+     */
+    @Override
+    public String toString() {
+        StringBuilder string = new StringBuilder("");
+        if (children.size() > 0) {
+            string.append(children.get(0).toString());
+        }
+        String delimeter = "\n\n";
+        if (children.size() > 1) {
+            for (int i = 1; i < children.size(); i++) {
+                String childString = children.get(i).toString();
+                if (childString != null) {
+                    string.append(delimeter).append(childString);
+                }
+            }
+        }
+        String output = string.toString();
+        return output;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/handler/SCSSDocumentHandler.java b/theme-compiler/src/com/vaadin/sass/handler/SCSSDocumentHandler.java
new file mode 100644
index 0000000000..c489a6a4a7
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/handler/SCSSDocumentHandler.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.handler;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.w3c.css.sac.DocumentHandler;
+import org.w3c.css.sac.LexicalUnit;
+import org.w3c.css.sac.SACMediaList;
+import org.w3c.css.sac.SelectorList;
+
+import com.vaadin.sass.ScssStylesheet;
+import com.vaadin.sass.tree.ForNode;
+import com.vaadin.sass.tree.IfNode;
+import com.vaadin.sass.tree.MixinDefNode;
+import com.vaadin.sass.tree.VariableNode;
+import com.vaadin.sass.tree.WhileNode;
+import com.vaadin.sass.tree.controldirective.EachDefNode;
+
+public interface SCSSDocumentHandler extends DocumentHandler {
+    ScssStylesheet getStyleSheet();
+
+    void variable(String name, LexicalUnit value, boolean guarded);
+
+    void startMixinDirective(String name, Collection<VariableNode> args);
+
+    void endMixinDirective(String name, Collection<VariableNode> args);
+
+    MixinDefNode mixinDirective(String name, String args, String body);
+
+    void debugDirective();
+
+    ForNode forDirective(String var, String from, String to, boolean exclusive,
+            String body);
+
+    WhileNode whileDirective(String condition, String body);
+
+    IfNode ifDirective();
+
+    void extendDirective(SelectorList list);
+
+    void startNestedProperties(String name);
+
+    void endNestedProperties(String name);
+
+    void includeDirective(String name, Collection<LexicalUnit> args);
+
+    void importStyle(String uri, SACMediaList media, boolean isURL);
+
+    void property(String name, LexicalUnit value, boolean important,
+            String comment);
+
+    EachDefNode startEachDirective(String variable, ArrayList<String> list);
+
+    void endEachDirective();
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/handler/SCSSDocumentHandlerImpl.java b/theme-compiler/src/com/vaadin/sass/handler/SCSSDocumentHandlerImpl.java
new file mode 100644
index 0000000000..0ed8b8d0f2
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/handler/SCSSDocumentHandlerImpl.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.handler;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+
+import org.w3c.css.sac.CSSException;
+import org.w3c.css.sac.InputSource;
+import org.w3c.css.sac.LexicalUnit;
+import org.w3c.css.sac.SACMediaList;
+import org.w3c.css.sac.SelectorList;
+
+import com.vaadin.sass.ScssStylesheet;
+import com.vaadin.sass.tree.BlockNode;
+import com.vaadin.sass.tree.CommentNode;
+import com.vaadin.sass.tree.ExtendNode;
+import com.vaadin.sass.tree.ForNode;
+import com.vaadin.sass.tree.IfNode;
+import com.vaadin.sass.tree.ImportNode;
+import com.vaadin.sass.tree.MediaNode;
+import com.vaadin.sass.tree.MixinDefNode;
+import com.vaadin.sass.tree.MixinNode;
+import com.vaadin.sass.tree.NestPropertiesNode;
+import com.vaadin.sass.tree.Node;
+import com.vaadin.sass.tree.RuleNode;
+import com.vaadin.sass.tree.VariableNode;
+import com.vaadin.sass.tree.WhileNode;
+import com.vaadin.sass.tree.controldirective.EachDefNode;
+
+public class SCSSDocumentHandlerImpl implements SCSSDocumentHandler {
+
+    private final ScssStylesheet styleSheet;
+    Stack<Node> nodeStack = new Stack<Node>();
+    private Map<String, Stack<LexicalUnit>> variableMap;
+
+    public SCSSDocumentHandlerImpl() {
+        this(new ScssStylesheet());
+        variableMap = new HashMap<String, Stack<LexicalUnit>>();
+    }
+
+    public SCSSDocumentHandlerImpl(ScssStylesheet styleSheet) {
+        this.styleSheet = styleSheet;
+        nodeStack.push(styleSheet);
+    }
+
+    public void addVariable(String varName, LexicalUnit value) {
+        if (variableMap.get(varName) == null) {
+            variableMap.put(varName, new Stack<LexicalUnit>());
+        }
+        Stack<LexicalUnit> valueStack = variableMap.get(varName);
+        valueStack.push(value);
+    }
+
+    public void removeVaraible(String varName) {
+        Stack<LexicalUnit> valueStack = variableMap.get(varName);
+        if (valueStack != null && !valueStack.isEmpty()) {
+            valueStack.pop();
+        }
+    }
+
+    public LexicalUnit getVariable(String varName) {
+        Stack<LexicalUnit> valueStack = variableMap.get(varName);
+        if (valueStack != null && !valueStack.isEmpty()) {
+            return valueStack.peek();
+        }
+        return null;
+    }
+
+    @Override
+    public ScssStylesheet getStyleSheet() {
+        return styleSheet;
+    }
+
+    @Override
+    public void startDocument(InputSource source) throws CSSException {
+        nodeStack.push(styleSheet);
+        // System.out.println("startDocument(InputSource source): "
+        // + source.getURI());
+    }
+
+    @Override
+    public void endDocument(InputSource source) throws CSSException {
+        // System.out.println("endDocument(InputSource source): "
+        // + source.getURI());
+    }
+
+    @Override
+    public void variable(String name, LexicalUnit value, boolean guarded) {
+        VariableNode node = new VariableNode(name, value, guarded);
+        nodeStack.peek().appendChild(node);
+    }
+
+    @Override
+    public void debugDirective() {
+    }
+
+    @Override
+    public ForNode forDirective(String var, String from, String to,
+            boolean exclusive, String body) {
+        ForNode node = new ForNode(var, from, to, exclusive, body);
+        System.out.println(node);
+        return node;
+    }
+
+    @Override
+    public EachDefNode startEachDirective(String var, ArrayList<String> list) {
+        EachDefNode node = new EachDefNode(var, list);
+        nodeStack.peek().appendChild(node);
+        nodeStack.push(node);
+        return node;
+    }
+
+    @Override
+    public void endEachDirective() {
+        nodeStack.pop();
+    }
+
+    @Override
+    public WhileNode whileDirective(String condition, String body) {
+        WhileNode node = new WhileNode(condition, body);
+        System.out.println(node);
+        return node;
+    }
+
+    @Override
+    public IfNode ifDirective() {
+        return new IfNode();
+    }
+
+    @Override
+    public void comment(String text) throws CSSException {
+        CommentNode node = new CommentNode(text);
+        nodeStack.peek().appendChild(node);
+    }
+
+    @Override
+    public void ignorableAtRule(String atRule) throws CSSException {
+        System.out.println("ignorableAtRule(String atRule): " + atRule);
+    }
+
+    @Override
+    public void namespaceDeclaration(String prefix, String uri)
+            throws CSSException {
+        System.out.println("namespaceDeclaration(String prefix, String uri): "
+                + prefix + ", " + uri);
+    }
+
+    @Override
+    public void importStyle(String uri, SACMediaList media,
+            String defaultNamespaceURI) throws CSSException {
+    }
+
+    @Override
+    public void startMedia(SACMediaList media) throws CSSException {
+        MediaNode node = new MediaNode(media);
+        nodeStack.peek().appendChild(node);
+        nodeStack.push(node);
+    }
+
+    @Override
+    public void endMedia(SACMediaList media) throws CSSException {
+        nodeStack.pop();
+    }
+
+    @Override
+    public void startPage(String name, String pseudo_page) throws CSSException {
+        System.out.println("startPage(String name, String pseudo_page): "
+                + name + ", " + pseudo_page);
+    }
+
+    @Override
+    public void endPage(String name, String pseudo_page) throws CSSException {
+        System.out.println("endPage(String name, String pseudo_page): " + name
+                + ", " + pseudo_page);
+    }
+
+    @Override
+    public void startFontFace() throws CSSException {
+        System.out.println("startFontFace()");
+    }
+
+    @Override
+    public void endFontFace() throws CSSException {
+        System.out.println("endFontFace()");
+    }
+
+    @Override
+    public void startSelector(SelectorList selectors) throws CSSException {
+        BlockNode node = new BlockNode(selectors);
+        nodeStack.peek().appendChild(node);
+        nodeStack.push(node);
+    }
+
+    @Override
+    public void endSelector(SelectorList selectors) throws CSSException {
+        nodeStack.pop();
+    }
+
+    @Override
+    public void property(String name, LexicalUnit value, boolean important)
+            throws CSSException {
+        property(name, value, important, null);
+    }
+
+    public void property(String name, LexicalUnit value, boolean important,
+            String comment) {
+        RuleNode node = new RuleNode(name, value, important, comment);
+        nodeStack.peek().appendChild(node);
+    }
+
+    @Override
+    public void extendDirective(SelectorList list) {
+        ExtendNode node = new ExtendNode(list);
+        nodeStack.peek().appendChild(node);
+    }
+
+    @Override
+    public MixinDefNode mixinDirective(String name, String args, String body) {
+        MixinDefNode node = new MixinDefNode(name, args, body);
+        return node;
+    }
+
+    @Override
+    public void startNestedProperties(String name) {
+        NestPropertiesNode node = new NestPropertiesNode(name);
+        nodeStack.peek().appendChild(node);
+        nodeStack.push(node);
+    }
+
+    @Override
+    public void endNestedProperties(String name) {
+        nodeStack.pop();
+    }
+
+    @Override
+    public void startMixinDirective(String name, Collection<VariableNode> args) {
+        MixinDefNode node = new MixinDefNode(name.trim(), args);
+        nodeStack.peek().appendChild(node);
+        nodeStack.push(node);
+    }
+
+    @Override
+    public void endMixinDirective(String name, Collection<VariableNode> args) {
+        nodeStack.pop();
+    }
+
+    @Override
+    public void includeDirective(String name, Collection<LexicalUnit> args) {
+        MixinNode node = new MixinNode(name, args);
+        nodeStack.peek().appendChild(node);
+    }
+
+    @Override
+    public void importStyle(String uri, SACMediaList media, boolean isURL) {
+        ImportNode node = new ImportNode(uri, media, isURL);
+        nodeStack.peek().appendChild(node);
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/CharStream.java b/theme-compiler/src/com/vaadin/sass/parser/CharStream.java
new file mode 100644
index 0000000000..004e3eb8fd
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/CharStream.java
@@ -0,0 +1,115 @@
+/* Generated By:JavaCC: Do not edit this line. CharStream.java Version 5.0 */
+/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
+package com.vaadin.sass.parser;
+
+/**
+ * This interface describes a character stream that maintains line and
+ * column number positions of the characters.  It also has the capability
+ * to backup the stream to some extent.  An implementation of this
+ * interface is used in the TokenManager implementation generated by
+ * JavaCCParser.
+ *
+ * All the methods except backup can be implemented in any fashion. backup
+ * needs to be implemented correctly for the correct operation of the lexer.
+ * Rest of the methods are all used to get information like line number,
+ * column number and the String that constitutes a token and are not used
+ * by the lexer. Hence their implementation won't affect the generated lexer's
+ * operation.
+ */
+
+public
+interface CharStream {
+
+  /**
+   * Returns the next character from the selected input.  The method
+   * of selecting the input is the responsibility of the class
+   * implementing this interface.  Can throw any java.io.IOException.
+   */
+  char readChar() throws java.io.IOException;
+
+  @Deprecated
+  /**
+   * Returns the column position of the character last read.
+   * @deprecated
+   * @see #getEndColumn
+   */
+  int getColumn();
+
+  @Deprecated
+  /**
+   * Returns the line number of the character last read.
+   * @deprecated
+   * @see #getEndLine
+   */
+  int getLine();
+
+  /**
+   * Returns the column number of the last character for current token (being
+   * matched after the last call to BeginTOken).
+   */
+  int getEndColumn();
+
+  /**
+   * Returns the line number of the last character for current token (being
+   * matched after the last call to BeginTOken).
+   */
+  int getEndLine();
+
+  /**
+   * Returns the column number of the first character for current token (being
+   * matched after the last call to BeginTOken).
+   */
+  int getBeginColumn();
+
+  /**
+   * Returns the line number of the first character for current token (being
+   * matched after the last call to BeginTOken).
+   */
+  int getBeginLine();
+
+  /**
+   * Backs up the input stream by amount steps. Lexer calls this method if it
+   * had already read some characters, but could not use them to match a
+   * (longer) token. So, they will be used again as the prefix of the next
+   * token and it is the implemetation's responsibility to do this right.
+   */
+  void backup(int amount);
+
+  /**
+   * Returns the next character that marks the beginning of the next token.
+   * All characters must remain in the buffer between two successive calls
+   * to this method to implement backup correctly.
+   */
+  char BeginToken() throws java.io.IOException;
+
+  /**
+   * Returns a string made up of characters from the marked token beginning
+   * to the current buffer position. Implementations have the choice of returning
+   * anything that they want to. For example, for efficiency, one might decide
+   * to just return null, which is a valid implementation.
+   */
+  String GetImage();
+
+  /**
+   * Returns an array of characters that make up the suffix of length 'len' for
+   * the currently matched token. This is used to build up the matched string
+   * for use in actions in the case of MORE. A simple and inefficient
+   * implementation of this is as follows :
+   *
+   *   {
+   *      String t = GetImage();
+   *      return t.substring(t.length() - len, t.length()).toCharArray();
+   *   }
+   */
+  char[] GetSuffix(int len);
+
+  /**
+   * The lexer calls this function to indicate that it is done with the stream
+   * and hence implementations can free any resources held by this class.
+   * Again, the body of this function can be just empty and it will not
+   * affect the lexer's operation.
+   */
+  void Done();
+
+}
+/* JavaCC - OriginalChecksum=28e31651bf0ffe57018eaaa3310c55ac (do not edit this line) */
diff --git a/theme-compiler/src/com/vaadin/sass/parser/Generic_CharStream.java b/theme-compiler/src/com/vaadin/sass/parser/Generic_CharStream.java
new file mode 100644
index 0000000000..fd9c8a7c03
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/Generic_CharStream.java
@@ -0,0 +1,355 @@
+/* Generated By:JavaCC: Do not edit this line. Generic_CharStream.java Version 0.7pre6 */
+package com.vaadin.sass.parser;
+
+/**
+ * An implementation of interface CharStream, where the stream is assumed to
+ * contain only ASCII characters (without unicode processing).
+ */
+
+public final class Generic_CharStream implements CharStream
+{
+  public static final boolean staticFlag = false;
+  int bufsize;
+  int available;
+  int tokenBegin;
+  public int bufpos = -1;
+  private int bufline[];
+  private int bufcolumn[];
+
+  private int column = 0;
+  private int line = 1;
+
+  private boolean prevCharIsCR = false;
+  private boolean prevCharIsLF = false;
+
+  private java.io.Reader reader;
+
+  private char[] buffer;
+  private int maxNextCharInd = 0;
+  private int inBuf = 0;
+
+  private final void ExpandBuff(boolean wrapAround)
+  {
+     char[] newbuffer = new char[bufsize + 2048];
+     int newbufline[] = new int[bufsize + 2048];
+     int newbufcolumn[] = new int[bufsize + 2048];
+
+     try
+     {
+        if (wrapAround)
+        {
+           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
+           System.arraycopy(buffer, 0, newbuffer,
+                                             bufsize - tokenBegin, bufpos);
+           buffer = newbuffer;
+
+           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
+           System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
+           bufline = newbufline;
+
+           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
+           System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
+           bufcolumn = newbufcolumn;
+
+           maxNextCharInd = (bufpos += (bufsize - tokenBegin));
+        }
+        else
+        {
+           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
+           buffer = newbuffer;
+
+           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
+           bufline = newbufline;
+
+           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
+           bufcolumn = newbufcolumn;
+
+           maxNextCharInd = (bufpos -= tokenBegin);
+        }
+     }
+     catch (Throwable t)
+     {
+        throw new Error(t.getMessage());
+     }
+
+
+     bufsize += 2048;
+     available = bufsize;
+     tokenBegin = 0;
+  }
+
+  private final void FillBuff() throws java.io.IOException
+  {
+     if (maxNextCharInd == available)
+     {
+        if (available == bufsize)
+        {
+           if (tokenBegin > 2048)
+           {
+              bufpos = maxNextCharInd = 0;
+              available = tokenBegin;
+           }
+           else if (tokenBegin < 0)
+              bufpos = maxNextCharInd = 0;
+           else
+              ExpandBuff(false);
+        }
+        else if (available > tokenBegin)
+           available = bufsize;
+        else if ((tokenBegin - available) < 2048)
+           ExpandBuff(true);
+        else
+           available = tokenBegin;
+     }
+
+     int i;
+     try {
+        if ((i = reader.read(buffer, maxNextCharInd,
+                                    available - maxNextCharInd)) == -1)
+        {
+           reader.close();
+           throw new java.io.IOException();
+        }
+        else
+           maxNextCharInd += i;
+        return;
+     }
+     catch(java.io.IOException e) {
+        --bufpos;
+        backup(0);
+        if (tokenBegin == -1)
+           tokenBegin = bufpos;
+        throw e;
+     }
+  }
+
+  public final char BeginToken() throws java.io.IOException
+  {
+     tokenBegin = -1;
+     char c = readChar();
+     tokenBegin = bufpos;
+
+     return c;
+  }
+
+  private final void UpdateLineColumn(char c)
+  {
+     column++;
+
+     if (prevCharIsLF)
+     {
+        prevCharIsLF = false;
+        line += (column = 1);
+     }
+     else if (prevCharIsCR)
+     {
+        prevCharIsCR = false;
+        if (c == '\n')
+        {
+           prevCharIsLF = true;
+        }
+        else
+           line += (column = 1);
+     }
+
+     switch (c)
+     {
+        case '\r' :
+           prevCharIsCR = true;
+           break;
+        case '\n' :
+           prevCharIsLF = true;
+           break;
+        case '\t' :
+           column--;
+           column += (8 - (column & 07));
+           break;
+        default :
+           break;
+     }
+
+     bufline[bufpos] = line;
+     bufcolumn[bufpos] = column;
+  }
+
+  public final char readChar() throws java.io.IOException
+  {
+     if (inBuf > 0)
+     {
+        --inBuf;
+        return (char)((char)0xff & buffer[(bufpos == bufsize - 1) ? (bufpos = 0) : ++bufpos]);
+     }
+
+     if (++bufpos >= maxNextCharInd)
+        FillBuff();
+
+     char c = (char)((char)0xff & buffer[bufpos]);
+
+     UpdateLineColumn(c);
+     return (c);
+  }
+
+  /**
+   * @deprecated 
+   * @see #getEndColumn
+   */
+
+  public final int getColumn() {
+     return bufcolumn[bufpos];
+  }
+
+  /**
+   * @deprecated 
+   * @see #getEndLine
+   */
+
+  public final int getLine() {
+     return bufline[bufpos];
+  }
+
+  public final int getEndColumn() {
+     return bufcolumn[bufpos];
+  }
+
+  public final int getEndLine() {
+     return bufline[bufpos];
+  }
+
+  public final int getBeginColumn() {
+     return bufcolumn[tokenBegin];
+  }
+
+  public final int getBeginLine() {
+     return bufline[tokenBegin];
+  }
+
+  public final void backup(int amount) {
+
+    inBuf += amount;
+    if ((bufpos -= amount) < 0)
+       bufpos += bufsize;
+  }
+
+  public Generic_CharStream(java.io.Reader dstream, int startline,
+			    int startcolumn, int buffersize)
+  {
+    reader = dstream;
+    line = startline;
+    column = startcolumn - 1;
+
+    available = bufsize = buffersize;
+    buffer = new char[buffersize];
+    bufline = new int[buffersize];
+    bufcolumn = new int[buffersize];
+  }
+
+  public Generic_CharStream(java.io.Reader dstream, int startline,
+			    int startcolumn)
+  {
+     this(dstream, startline, startcolumn, 4096);
+  }
+  public void ReInit(java.io.Reader dstream, int startline,
+  int startcolumn, int buffersize)
+  {
+    reader = dstream;
+    line = startline;
+    column = startcolumn - 1;
+
+    if (buffer == null || buffersize != buffer.length)
+    {
+      available = bufsize = buffersize;
+      buffer = new char[buffersize];
+      bufline = new int[buffersize];
+      bufcolumn = new int[buffersize];
+    }
+    prevCharIsLF = prevCharIsCR = false;
+    tokenBegin = inBuf = maxNextCharInd = 0;
+    bufpos = -1;
+  }
+
+  public void ReInit(java.io.Reader dstream, int startline,
+                                                           int startcolumn)
+  {
+     ReInit(dstream, startline, startcolumn, 4096);
+  }
+
+  public final String GetImage()
+  {
+     if (bufpos >= tokenBegin)
+        return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
+     else
+        return new String(buffer, tokenBegin, bufsize - tokenBegin) +
+                              new String(buffer, 0, bufpos + 1);
+  }
+
+  public final char[] GetSuffix(int len)
+  {
+     char[] ret = new char[len];
+
+     if ((bufpos + 1) >= len)
+        System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
+     else
+     {
+        System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
+                                                          len - bufpos - 1);
+        System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
+     }
+     return ret;
+  }
+
+  public void Done()
+  {
+     buffer = null;
+     bufline = null;
+     bufcolumn = null;
+  }
+
+  /**
+   * Method to adjust line and column numbers for the start of a token.<BR>
+   */
+  public void adjustBeginLineColumn(int newLine, int newCol)
+  {
+     int start = tokenBegin;
+     int len;
+
+     if (bufpos >= tokenBegin)
+     {
+        len = bufpos - tokenBegin + inBuf + 1;
+     }
+     else
+     {
+        len = bufsize - tokenBegin + bufpos + 1 + inBuf;
+     }
+
+     int i = 0, j = 0, k = 0;
+     int nextColDiff = 0, columnDiff = 0;
+
+     while (i < len &&
+            bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
+     {
+        bufline[j] = newLine;
+        nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
+        bufcolumn[j] = newCol + columnDiff;
+        columnDiff = nextColDiff;
+        i++;
+     } 
+
+     if (i < len)
+     {
+        bufline[j] = newLine++;
+        bufcolumn[j] = newCol + columnDiff;
+
+        while (i++ < len)
+        {
+           if (bufline[j = start % bufsize] != bufline[++start % bufsize])
+              bufline[j] = newLine++;
+           else
+              bufline[j] = newLine;
+        }
+     }
+
+     line = bufline[j];
+     column = bufcolumn[j];
+  }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/JumpException.java b/theme-compiler/src/com/vaadin/sass/parser/JumpException.java
new file mode 100644
index 0000000000..4d0f5923e9
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/JumpException.java
@@ -0,0 +1,24 @@
+/*
+ * (c) COPYRIGHT 1999 World Wide Web Consortium
+ * (Massachusetts Institute of Technology, Institut National de Recherche
+ *  en Informatique et en Automatique, Keio University).
+ * All Rights Reserved. http://www.w3.org/Consortium/Legal/
+ *
+ * $Id: JumpException.java,v 1.1 1999/06/09 15:21:33 plehegar Exp $
+ */
+package com.vaadin.sass.parser;
+
+/**
+ * @version $Revision: 1.1 $
+ * @author Philippe Le Hegaret
+ */
+public class JumpException extends RuntimeException {
+    private static final long serialVersionUID = -2010286909393046205L;
+
+    /**
+     * Creates a new JumpException
+     */
+    public JumpException() {
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/LexicalUnitImpl.java b/theme-compiler/src/com/vaadin/sass/parser/LexicalUnitImpl.java
new file mode 100644
index 0000000000..a6b03a864c
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/LexicalUnitImpl.java
@@ -0,0 +1,582 @@
+/*
+ * Copyright (c) 1999 World Wide Web Consortium
+ * (Massachusetts Institute of Technology, Institut National de Recherche
+ *  en Informatique et en Automatique, Keio University).
+ * All Rights Reserved. http://www.w3.org/Consortium/Legal/
+ *
+ * $Id: LexicalUnitImpl.java,v 1.3 2000/02/15 02:08:19 plehegar Exp $
+ */
+package com.vaadin.sass.parser;
+
+import java.io.Serializable;
+
+import org.w3c.css.sac.LexicalUnit;
+
+import com.vaadin.sass.util.ColorUtil;
+
+/**
+ * @version $Revision: 1.3 $
+ * @author Philippe Le Hegaret
+ */
+public class LexicalUnitImpl implements LexicalUnit, SCSSLexicalUnit,
+        Serializable {
+    private static final long serialVersionUID = -6649833716809789399L;
+
+    LexicalUnit prev;
+    LexicalUnit next;
+
+    short type;
+    int line;
+    int column;
+
+    int i;
+    float f;
+    short dimension;
+    String sdimension;
+    String s;
+    String fname;
+    LexicalUnitImpl params;
+
+    LexicalUnitImpl(short type, int line, int column, LexicalUnitImpl p) {
+        if (p != null) {
+            prev = p;
+            p.next = this;
+        }
+        this.line = line;
+        this.column = column - 1;
+        this.type = type;
+    }
+
+    LexicalUnitImpl(int line, int column, LexicalUnitImpl previous, int i) {
+        this(SAC_INTEGER, line, column, previous);
+        this.i = i;
+    }
+
+    LexicalUnitImpl(int line, int column, LexicalUnitImpl previous,
+            short dimension, String sdimension, float f) {
+        this(dimension, line, column, previous);
+        this.f = f;
+        this.dimension = dimension;
+        this.sdimension = sdimension;
+    }
+
+    LexicalUnitImpl(int line, int column, LexicalUnitImpl previous, short type,
+            String s) {
+        this(type, line, column, previous);
+        this.s = s;
+    }
+
+    LexicalUnitImpl(short type, int line, int column, LexicalUnitImpl previous,
+            String fname, LexicalUnitImpl params) {
+        this(type, line, column, previous);
+        this.fname = fname;
+        this.params = params;
+    }
+
+    public int getLineNumber() {
+        return line;
+    }
+
+    public int getColumnNumber() {
+        return column;
+    }
+
+    @Override
+    public short getLexicalUnitType() {
+        return type;
+    }
+
+    @Override
+    public LexicalUnit getNextLexicalUnit() {
+        return next;
+    }
+
+    public void setNextLexicalUnit(LexicalUnit n) {
+        next = n;
+    }
+
+    @Override
+    public LexicalUnit getPreviousLexicalUnit() {
+        return prev;
+    }
+
+    @Override
+    public int getIntegerValue() {
+        return i;
+    }
+
+    void setIntegerValue(int i) {
+        this.i = i;
+    }
+
+    @Override
+    public float getFloatValue() {
+        return f;
+    }
+
+    public void setFloatValue(float f) {
+        this.f = f;
+    }
+
+    @Override
+    public String getDimensionUnitText() {
+        switch (type) {
+        case SAC_PERCENTAGE:
+            return "%";
+        case SAC_EM:
+            return "em";
+        case SAC_EX:
+            return "ex";
+        case SAC_PIXEL:
+            return "px";
+        case SAC_CENTIMETER:
+            return "cm";
+        case SAC_MILLIMETER:
+            return "mm";
+        case SAC_INCH:
+            return "in";
+        case SAC_POINT:
+            return "pt";
+        case SAC_PICA:
+            return "pc";
+        case SAC_DEGREE:
+            return "deg";
+        case SAC_RADIAN:
+            return "rad";
+        case SAC_GRADIAN:
+            return "grad";
+        case SAC_MILLISECOND:
+            return "ms";
+        case SAC_SECOND:
+            return "s";
+        case SAC_HERTZ:
+            return "Hz";
+        case SAC_KILOHERTZ:
+            return "kHz";
+        case SAC_DIMENSION:
+            return sdimension;
+        default:
+            throw new IllegalStateException("invalid dimension " + type);
+        }
+    }
+
+    @Override
+    public String getStringValue() {
+        return s;
+    }
+
+    public void setStringValue(String str) {
+        s = str;
+    }
+
+    @Override
+    public String getFunctionName() {
+        return fname;
+    }
+
+    @Override
+    public LexicalUnitImpl getParameters() {
+        return params;
+    }
+
+    @Override
+    public LexicalUnitImpl getSubValues() {
+        return params;
+    }
+
+    @Override
+    public String toString() {
+        short type = getLexicalUnitType();
+        String text = null;
+        switch (type) {
+        case SCSS_VARIABLE:
+            text = "$" + s;
+            break;
+        case LexicalUnit.SAC_OPERATOR_COMMA:
+            text = ",";
+            break;
+        case LexicalUnit.SAC_OPERATOR_PLUS:
+            text = "+";
+            break;
+        case LexicalUnit.SAC_OPERATOR_MINUS:
+            text = "-";
+            break;
+        case LexicalUnit.SAC_OPERATOR_MULTIPLY:
+            text = "*";
+            break;
+        case LexicalUnit.SAC_OPERATOR_SLASH:
+            text = "/";
+            break;
+        case LexicalUnit.SAC_OPERATOR_MOD:
+            text = "%";
+            break;
+        case LexicalUnit.SAC_OPERATOR_EXP:
+            text = "^";
+            break;
+        case LexicalUnit.SAC_OPERATOR_LT:
+            text = "<";
+            break;
+        case LexicalUnit.SAC_OPERATOR_GT:
+            text = ">";
+            break;
+        case LexicalUnit.SAC_OPERATOR_LE:
+            text = "<=";
+            break;
+        case LexicalUnit.SAC_OPERATOR_GE:
+            text = "=>";
+            break;
+        case LexicalUnit.SAC_OPERATOR_TILDE:
+            text = "~";
+            break;
+        case LexicalUnit.SAC_INHERIT:
+            text = "inherit";
+            break;
+        case LexicalUnit.SAC_INTEGER:
+            text = Integer.toString(getIntegerValue(), 10);
+            break;
+        case LexicalUnit.SAC_REAL:
+            text = getFloatValue() + "";
+            break;
+        case LexicalUnit.SAC_EM:
+        case LexicalUnit.SAC_EX:
+        case LexicalUnit.SAC_PIXEL:
+        case LexicalUnit.SAC_INCH:
+        case LexicalUnit.SAC_CENTIMETER:
+        case LexicalUnit.SAC_MILLIMETER:
+        case LexicalUnit.SAC_POINT:
+        case LexicalUnit.SAC_PICA:
+        case LexicalUnit.SAC_PERCENTAGE:
+        case LexicalUnit.SAC_DEGREE:
+        case LexicalUnit.SAC_GRADIAN:
+        case LexicalUnit.SAC_RADIAN:
+        case LexicalUnit.SAC_MILLISECOND:
+        case LexicalUnit.SAC_SECOND:
+        case LexicalUnit.SAC_HERTZ:
+        case LexicalUnit.SAC_KILOHERTZ:
+        case LexicalUnit.SAC_DIMENSION:
+            float f = getFloatValue();
+            int i = (int) f;
+            if ((i) == f) {
+                text = i + getDimensionUnitText();
+            } else {
+                text = f + getDimensionUnitText();
+            }
+            break;
+        case LexicalUnit.SAC_URI:
+            text = "url(" + getStringValue() + ")";
+            break;
+        case LexicalUnit.SAC_RGBCOLOR:
+        case LexicalUnit.SAC_COUNTER_FUNCTION:
+        case LexicalUnit.SAC_COUNTERS_FUNCTION:
+        case LexicalUnit.SAC_RECT_FUNCTION:
+        case LexicalUnit.SAC_FUNCTION:
+            String funcName = getFunctionName();
+            LexicalUnitImpl firstParam = getParameters();
+            if ("round".equals(funcName)) {
+                firstParam
+                        .setFloatValue(Math.round(firstParam.getFloatValue()));
+                text = firstParam.toString();
+            } else if ("ceil".equals(funcName)) {
+                firstParam.setFloatValue((float) Math.ceil(firstParam
+                        .getFloatValue()));
+                text = firstParam.toString();
+            } else if ("floor".equals(funcName)) {
+                firstParam.setFloatValue((float) Math.floor(firstParam
+                        .getFloatValue()));
+                text = firstParam.toString();
+            } else if ("abs".equals(funcName)) {
+                firstParam.setFloatValue(Math.abs(firstParam.getFloatValue()));
+                text = firstParam.toString();
+            } else if ("darken".equals(funcName)) {
+                LexicalUnitImpl dark = ColorUtil.darken(this);
+                text = dark.toString();
+            } else if ("lighten".equals(funcName)) {
+                text = ColorUtil.lighten(this).toString();
+            } else {
+                text = getFunctionName() + "(" + getParameters() + ")";
+            }
+            break;
+        case LexicalUnit.SAC_IDENT:
+            text = getStringValue();
+            break;
+        case LexicalUnit.SAC_STRING_VALUE:
+            // @@SEEME. not exact
+            text = "\"" + getStringValue() + "\"";
+            break;
+        case LexicalUnit.SAC_ATTR:
+            text = "attr(" + getStringValue() + ")";
+            break;
+        case LexicalUnit.SAC_UNICODERANGE:
+            text = "@@TODO";
+            break;
+        case LexicalUnit.SAC_SUB_EXPRESSION:
+            text = getSubValues().toString();
+            break;
+        default:
+            text = "@unknown";
+            break;
+        }
+        if (getNextLexicalUnit() != null) {
+            if (getNextLexicalUnit().getLexicalUnitType() == SAC_OPERATOR_COMMA) {
+                return text + getNextLexicalUnit();
+            }
+            return text + ' ' + getNextLexicalUnit();
+        } else {
+            return text;
+        }
+    }
+
+    @Override
+    public LexicalUnitImpl divide(LexicalUnitImpl denominator) {
+        setFloatValue(getFloatValue() / denominator.getIntegerValue());
+        return this;
+    }
+
+    @Override
+    public LexicalUnitImpl add(LexicalUnitImpl another) {
+        setFloatValue(getFloatValue() + another.getFloatValue());
+        return this;
+    }
+
+    @Override
+    public LexicalUnitImpl minus(LexicalUnitImpl another) {
+        setFloatValue(getFloatValue() - another.getFloatValue());
+        return this;
+    }
+
+    @Override
+    public LexicalUnitImpl multiply(LexicalUnitImpl another) {
+        setFloatValue(getFloatValue() * another.getIntegerValue());
+        return this;
+    }
+
+    public void replaceValue(LexicalUnitImpl another) {
+        type = another.getLexicalUnitType();
+        i = another.getIntegerValue();
+        f = another.getFloatValue();
+        dimension = another.getDimension();
+        sdimension = another.getSdimension();
+        s = another.getStringValue();
+        fname = another.getFunctionName();
+        params = another.getParameters();
+        prev = another.getPreviousLexicalUnit();
+        LexicalUnit finalNextInAnother = another;
+        while (finalNextInAnother.getNextLexicalUnit() != null) {
+            finalNextInAnother = finalNextInAnother.getNextLexicalUnit();
+        }
+        ((LexicalUnitImpl) finalNextInAnother).setNextLexicalUnit(next);
+        next = another.next;
+    }
+
+    public short getDimension() {
+        return dimension;
+    }
+
+    public String getSdimension() {
+        return sdimension;
+    }
+
+    // here some useful function for creation
+    public static LexicalUnitImpl createVariable(int line, int column,
+            LexicalUnitImpl previous, String name) {
+        return new LexicalUnitImpl(line, column, previous, SCSS_VARIABLE, name);
+    }
+
+    public static LexicalUnitImpl createNumber(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        int i = (int) v;
+        if (v == i) {
+            return new LexicalUnitImpl(line, column, previous, i);
+        } else {
+            return new LexicalUnitImpl(line, column, previous, SAC_REAL, "", v);
+        }
+    }
+
+    public static LexicalUnitImpl createInteger(int line, int column,
+            LexicalUnitImpl previous, int i) {
+        return new LexicalUnitImpl(line, column, previous, i);
+    }
+
+    public static LexicalUnitImpl createPercentage(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_PERCENTAGE,
+                null, v);
+    }
+
+    static LexicalUnitImpl createEMS(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_EM, null, v);
+    }
+
+    static LexicalUnitImpl createEXS(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_EX, null, v);
+    }
+
+    static LexicalUnitImpl createPX(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_PIXEL, null, v);
+    }
+
+    static LexicalUnitImpl createCM(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_CENTIMETER,
+                null, v);
+    }
+
+    static LexicalUnitImpl createMM(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_MILLIMETER,
+                null, v);
+    }
+
+    static LexicalUnitImpl createIN(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_INCH, null, v);
+    }
+
+    static LexicalUnitImpl createPT(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_POINT, null, v);
+    }
+
+    static LexicalUnitImpl createPC(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_PICA, null, v);
+    }
+
+    static LexicalUnitImpl createDEG(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_DEGREE, null, v);
+    }
+
+    static LexicalUnitImpl createRAD(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_RADIAN, null, v);
+    }
+
+    static LexicalUnitImpl createGRAD(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        return new LexicalUnitImpl(line, column, previous, SAC_GRADIAN, null, v);
+    }
+
+    static LexicalUnitImpl createMS(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        if (v < 0) {
+            throw new ParseException("Time values may not be negative");
+        }
+        return new LexicalUnitImpl(line, column, previous, SAC_MILLISECOND,
+                null, v);
+    }
+
+    static LexicalUnitImpl createS(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        if (v < 0) {
+            throw new ParseException("Time values may not be negative");
+        }
+        return new LexicalUnitImpl(line, column, previous, SAC_SECOND, null, v);
+    }
+
+    static LexicalUnitImpl createHZ(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        if (v < 0) {
+            throw new ParseException("Frequency values may not be negative");
+        }
+        return new LexicalUnitImpl(line, column, previous, SAC_HERTZ, null, v);
+    }
+
+    static LexicalUnitImpl createKHZ(int line, int column,
+            LexicalUnitImpl previous, float v) {
+        if (v < 0) {
+            throw new ParseException("Frequency values may not be negative");
+        }
+        return new LexicalUnitImpl(line, column, previous, SAC_KILOHERTZ, null,
+                v);
+    }
+
+    static LexicalUnitImpl createDimen(int line, int column,
+            LexicalUnitImpl previous, float v, String s) {
+        return new LexicalUnitImpl(line, column, previous, SAC_DIMENSION, s, v);
+    }
+
+    static LexicalUnitImpl createInherit(int line, int column,
+            LexicalUnitImpl previous) {
+        return new LexicalUnitImpl(line, column, previous, SAC_INHERIT,
+                "inherit");
+    }
+
+    public static LexicalUnitImpl createIdent(int line, int column,
+            LexicalUnitImpl previous, String s) {
+        return new LexicalUnitImpl(line, column, previous, SAC_IDENT, s);
+    }
+
+    static LexicalUnitImpl createString(int line, int column,
+            LexicalUnitImpl previous, String s) {
+        return new LexicalUnitImpl(line, column, previous, SAC_STRING_VALUE, s);
+    }
+
+    static LexicalUnitImpl createURL(int line, int column,
+            LexicalUnitImpl previous, String s) {
+        return new LexicalUnitImpl(line, column, previous, SAC_URI, s);
+    }
+
+    static LexicalUnitImpl createAttr(int line, int column,
+            LexicalUnitImpl previous, String s) {
+        return new LexicalUnitImpl(line, column, previous, SAC_ATTR, s);
+    }
+
+    static LexicalUnitImpl createCounter(int line, int column,
+            LexicalUnitImpl previous, LexicalUnit params) {
+        return new LexicalUnitImpl(SAC_COUNTER_FUNCTION, line, column,
+                previous, "counter", (LexicalUnitImpl) params);
+    }
+
+    public static LexicalUnitImpl createCounters(int line, int column,
+            LexicalUnitImpl previous, LexicalUnit params) {
+        return new LexicalUnitImpl(SAC_COUNTERS_FUNCTION, line, column,
+                previous, "counters", (LexicalUnitImpl) params);
+    }
+
+    public static LexicalUnitImpl createRGBColor(int line, int column,
+            LexicalUnitImpl previous, LexicalUnit params) {
+        return new LexicalUnitImpl(SAC_RGBCOLOR, line, column, previous, "rgb",
+                (LexicalUnitImpl) params);
+    }
+
+    public static LexicalUnitImpl createRect(int line, int column,
+            LexicalUnitImpl previous, LexicalUnit params) {
+        return new LexicalUnitImpl(SAC_RECT_FUNCTION, line, column, previous,
+                "rect", (LexicalUnitImpl) params);
+    }
+
+    public static LexicalUnitImpl createFunction(int line, int column,
+            LexicalUnitImpl previous, String fname, LexicalUnit params) {
+        return new LexicalUnitImpl(SAC_FUNCTION, line, column, previous, fname,
+                (LexicalUnitImpl) params);
+    }
+
+    public static LexicalUnitImpl createUnicodeRange(int line, int column,
+            LexicalUnit previous, LexicalUnit params) {
+        // @@ return new LexicalUnitImpl(line, column, previous, null,
+        // SAC_UNICODERANGE, params);
+        return null;
+    }
+
+    public static LexicalUnitImpl createComma(int line, int column,
+            LexicalUnitImpl previous) {
+        return new LexicalUnitImpl(SAC_OPERATOR_COMMA, line, column, previous);
+    }
+
+    public static LexicalUnitImpl createSlash(int line, int column,
+            LexicalUnitImpl previous) {
+        return new LexicalUnitImpl(SAC_OPERATOR_SLASH, line, column, previous);
+    }
+
+    @Override
+    public LexicalUnitImpl clone() {
+        LexicalUnitImpl cloned = new LexicalUnitImpl(type, line, column,
+                (LexicalUnitImpl) prev);
+        cloned.replaceValue(this);
+        return cloned;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/LocatorImpl.java b/theme-compiler/src/com/vaadin/sass/parser/LocatorImpl.java
new file mode 100644
index 0000000000..d481459f17
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/LocatorImpl.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 1999 World Wide Web Consortium
+ * (Massachusetts Institute of Technology, Institut National de Recherche
+ *  en Informatique et en Automatique, Keio University).
+ * All Rights Reserved. http://www.w3.org/Consortium/Legal/
+ *
+ * $Id: LocatorImpl.java,v 1.2 2000/02/14 16:59:06 plehegar Exp $
+ */
+package com.vaadin.sass.parser;
+
+import org.w3c.css.sac.Locator;
+
+/**
+ * @version $Revision: 1.2 $
+ * @author Philippe Le Hegaret
+ */
+public class LocatorImpl implements Locator {
+
+    // W3C DEBUG mode
+    private static boolean W3CDebug;
+    static {
+        try {
+            W3CDebug = (Boolean.getBoolean("debug")
+                    || Boolean
+                            .getBoolean("org.w3c.flute.parser.LocatorImpl.debug")
+                    || Boolean.getBoolean("org.w3c.flute.parser.debug")
+                    || Boolean.getBoolean("org.w3c.flute.debug")
+                    || Boolean.getBoolean("org.w3c.debug") || Boolean
+                    .getBoolean("org.debug"));
+        } catch (Exception e) {
+            // nothing
+        }
+    }
+
+    String uri;
+    int line;
+    int column;
+
+    public String getURI() {
+        return uri;
+    }
+
+    public int getLineNumber() {
+        return line;
+    }
+
+    public int getColumnNumber() {
+        return column;
+    }
+
+    /**
+     * Creates a new LocatorImpl
+     */
+    public LocatorImpl(Parser p) {
+        if (W3CDebug) {
+            System.err.println("LocatorImpl::newLocator(" + p + ");");
+        }
+        uri = p.source.getURI();
+        line = p.token.beginLine;
+        column = p.token.beginColumn;
+    }
+
+    /**
+     * Reinitializes a LocatorImpl
+     */
+    public LocatorImpl(Parser p, Token tok) {
+        if (W3CDebug) {
+            System.err.println("LocatorImpl::newLocator(" + p + ", " + tok
+                    + ");");
+        }
+        uri = p.source.getURI();
+        line = tok.beginLine;
+        column = tok.beginColumn;
+    }
+
+    /**
+     * Reinitializes a LocatorImpl
+     */
+    public LocatorImpl(Parser p, int line, int column) {
+        if (W3CDebug) {
+            System.err.println("LocatorImpl::newLocator(" + p + ", " + line
+                    + ", " + column + ");");
+        }
+        uri = p.source.getURI();
+        this.line = line;
+        this.column = column;
+    }
+
+    /**
+     * Reinitializes a LocatorImpl
+     */
+    public LocatorImpl reInit(Parser p) {
+        if (W3CDebug) {
+            System.err.println("LocatorImpl::reInit(" + p + ");");
+        }
+        uri = p.source.getURI();
+        line = p.token.beginLine;
+        column = p.token.beginColumn;
+        return this;
+    }
+
+    /**
+     * Reinitializes a LocatorImpl
+     */
+    public LocatorImpl reInit(Parser p, Token tok) {
+        if (W3CDebug) {
+            System.err.println("LocatorImpl::reInit(" + p + ", " + tok + ");");
+        }
+        uri = p.source.getURI();
+        line = tok.beginLine;
+        column = tok.beginColumn;
+        return this;
+    }
+
+    /**
+     * Reinitializes a LocatorImpl
+     */
+    public LocatorImpl reInit(Parser p, int line, int column) {
+        if (W3CDebug) {
+            System.err.println("LocatorImpl::reInit(" + p + ", " + line + ", "
+                    + column + ");");
+        }
+        uri = p.source.getURI();
+        this.line = line;
+        this.column = column;
+        return this;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/MediaListImpl.java b/theme-compiler/src/com/vaadin/sass/parser/MediaListImpl.java
new file mode 100644
index 0000000000..042e385cb3
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/MediaListImpl.java
@@ -0,0 +1,79 @@
+/*
+ * (c) COPYRIGHT 1999 World Wide Web Consortium
+ * (Massachusetts Institute of Technology, Institut National de Recherche
+ *  en Informatique et en Automatique, Keio University).
+ * All Rights Reserved. http://www.w3.org/Consortium/Legal/
+ *
+ * $Id: MediaListImpl.java,v 1.4 2000/04/26 13:40:19 plehegar Exp $
+ */
+package com.vaadin.sass.parser;
+
+import org.w3c.css.sac.SACMediaList;
+
+/**
+ * @version $Revision: 1.4 $
+ * @author Philippe Le Hegaret
+ */
+public class MediaListImpl implements SACMediaList {
+
+    String[] array = new String[10];
+    int current;
+
+    @Override
+    public int getLength() {
+        return current;
+    }
+
+    @Override
+    public String item(int index) {
+        if ((index < 0) || (index >= current)) {
+            return null;
+        }
+        return array[index];
+    }
+
+    void addItem(String medium) {
+        if (medium.equals("all")) {
+            array[0] = "all";
+            current = 1;
+            return;
+        }
+        for (int i = 0; i < current; i++) {
+            if (medium.equals(array[i])) {
+                return;
+            }
+        }
+        if (current == array.length) {
+            String[] old = array;
+            array = new String[current + current];
+            System.arraycopy(old, 0, array, 0, current);
+        }
+        array[current++] = medium;
+    }
+
+    /**
+     * Returns a string representation of this object.
+     */
+    @Override
+    public String toString() {
+        switch (current) {
+        case 0:
+            return "";
+        case 1:
+            return array[0];
+        default:
+            boolean not_done = true;
+            int i = 0;
+            StringBuffer buf = new StringBuffer(50);
+            do {
+                buf.append(array[i++]);
+                if (i == current) {
+                    not_done = false;
+                } else {
+                    buf.append(", ");
+                }
+            } while (not_done);
+            return buf.toString();
+        }
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/ParseException.java b/theme-compiler/src/com/vaadin/sass/parser/ParseException.java
new file mode 100644
index 0000000000..482e5d3b3f
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/ParseException.java
@@ -0,0 +1,188 @@
+/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 0.7pre6 */
+package com.vaadin.sass.parser;
+
+import org.w3c.css.sac.CSSException;
+
+/**
+ * This exception is thrown when parse errors are encountered. You can
+ * explicitly create objects of this exception type by calling the method
+ * generateParseException in the generated parser.
+ * 
+ * You can modify this class to customize your error reporting mechanisms so
+ * long as you retain the public fields.
+ */
+public class ParseException extends CSSException {
+    private static final long serialVersionUID = -8556588037264585977L;
+
+    /**
+     * This constructor is used by the method "generateParseException" in the
+     * generated parser. Calling this constructor generates a new object of this
+     * type with the fields "currentToken", "expectedTokenSequences", and
+     * "tokenImage" set. The boolean flag "specialConstructor" is also set to
+     * true to indicate that this constructor was used to create this object.
+     * This constructor calls its super class with the empty string to force the
+     * "toString" method of parent class "Throwable" to print the error message
+     * in the form: ParseException: <result of getMessage>
+     */
+    public ParseException(Token currentTokenVal,
+            int[][] expectedTokenSequencesVal, String[] tokenImageVal) {
+        super("");
+        specialConstructor = true;
+        currentToken = currentTokenVal;
+        expectedTokenSequences = expectedTokenSequencesVal;
+        tokenImage = tokenImageVal;
+    }
+
+    /**
+     * The following constructors are for use by you for whatever purpose you
+     * can think of. Constructing the exception in this manner makes the
+     * exception behave in the normal way - i.e., as documented in the class
+     * "Throwable". The fields "errorToken", "expectedTokenSequences", and
+     * "tokenImage" do not contain relevant information. The JavaCC generated
+     * code does not use these constructors.
+     */
+
+    public ParseException() {
+        super();
+        specialConstructor = false;
+    }
+
+    public ParseException(String message) {
+        super(message);
+        specialConstructor = false;
+    }
+
+    /**
+     * This variable determines which constructor was used to create this object
+     * and thereby affects the semantics of the "getMessage" method (see below).
+     */
+    protected boolean specialConstructor;
+
+    /**
+     * This is the last token that has been consumed successfully. If this
+     * object has been created due to a parse error, the token followng this
+     * token will (therefore) be the first error token.
+     */
+    public Token currentToken;
+
+    /**
+     * Each entry in this array is an array of integers. Each array of integers
+     * represents a sequence of tokens (by their ordinal values) that is
+     * expected at this point of the parse.
+     */
+    public int[][] expectedTokenSequences;
+
+    /**
+     * This is a reference to the "tokenImage" array of the generated parser
+     * within which the parse error occurred. This array is defined in the
+     * generated ...Constants interface.
+     */
+    public String[] tokenImage;
+
+    /**
+     * This method has the standard behavior when this object has been created
+     * using the standard constructors. Otherwise, it uses "currentToken" and
+     * "expectedTokenSequences" to generate a parse error message and returns
+     * it. If this object has been created due to a parse error, and you do not
+     * catch it (it gets thrown from the parser), then this method is called
+     * during the printing of the final stack trace, and hence the correct error
+     * message gets displayed.
+     */
+    @Override
+    public String getMessage() {
+        if (!specialConstructor) {
+            return super.getMessage();
+        }
+        String expected = "";
+        int maxSize = 0;
+        for (int i = 0; i < expectedTokenSequences.length; i++) {
+            if (maxSize < expectedTokenSequences[i].length) {
+                maxSize = expectedTokenSequences[i].length;
+            }
+            for (int j = 0; j < expectedTokenSequences[i].length; j++) {
+                expected += tokenImage[expectedTokenSequences[i][j]] + " ";
+            }
+            if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
+                expected += "...";
+            }
+            expected += eol + "    ";
+        }
+        String retval = "Encountered \"";
+        Token tok = currentToken.next;
+        for (int i = 0; i < maxSize; i++) {
+            if (i != 0) {
+                retval += " ";
+            }
+            if (tok.kind == 0) {
+                retval += tokenImage[0];
+                break;
+            }
+            retval += add_escapes(tok.image);
+            tok = tok.next;
+        }
+        retval += "\" at line " + currentToken.next.beginLine + ", column "
+                + currentToken.next.beginColumn + "." + eol;
+        if (expectedTokenSequences.length == 1) {
+            retval += "Was expecting:" + eol + "    ";
+        } else {
+            retval += "Was expecting one of:" + eol + "    ";
+        }
+        retval += expected;
+        return retval;
+    }
+
+    /**
+     * The end of line string for this machine.
+     */
+    protected String eol = System.getProperty("line.separator", "\n");
+
+    /**
+     * Used to convert raw characters to their escaped version when these raw
+     * version cannot be used as part of an ASCII string literal.
+     */
+    protected String add_escapes(String str) {
+        StringBuffer retval = new StringBuffer();
+        char ch;
+        for (int i = 0; i < str.length(); i++) {
+            switch (str.charAt(i)) {
+            case 0:
+                continue;
+            case '\b':
+                retval.append("\\b");
+                continue;
+            case '\t':
+                retval.append("\\t");
+                continue;
+            case '\n':
+                retval.append("\\n");
+                continue;
+            case '\f':
+                retval.append("\\f");
+                continue;
+            case '\r':
+                retval.append("\\r");
+                continue;
+            case '\"':
+                retval.append("\\\"");
+                continue;
+            case '\'':
+                retval.append("\\\'");
+                continue;
+            case '\\':
+                retval.append("\\\\");
+                continue;
+            default:
+                if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
+                    String s = "0000" + Integer.toString(ch, 16);
+                    retval.append("\\u"
+                            + s.substring(s.length() - 4, s.length()));
+                } else {
+                    retval.append(ch);
+                }
+                continue;
+            }
+        }
+        return retval.toString();
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/Parser.java b/theme-compiler/src/com/vaadin/sass/parser/Parser.java
new file mode 100644
index 0000000000..68e0aa7231
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/Parser.java
@@ -0,0 +1,5253 @@
+/* Generated By:JavaCC: Do not edit this line. Parser.java */
+package com.vaadin.sass.parser;
+
+import java.io.*;
+import java.net.*;
+import java.util.ArrayList;
+import java.util.Locale;
+import java.util.Map;
+
+import org.w3c.css.sac.ConditionFactory;
+import org.w3c.css.sac.Condition;
+import org.w3c.css.sac.SelectorFactory;
+import org.w3c.css.sac.SelectorList;
+import org.w3c.css.sac.Selector;
+import org.w3c.css.sac.SimpleSelector;
+import org.w3c.css.sac.DocumentHandler;
+import org.w3c.css.sac.InputSource;
+import org.w3c.css.sac.ErrorHandler;
+import org.w3c.css.sac.CSSException;
+import org.w3c.css.sac.CSSParseException;
+import org.w3c.css.sac.Locator;
+import org.w3c.css.sac.LexicalUnit;
+
+import org.w3c.flute.parser.selectors.SelectorFactoryImpl;
+import org.w3c.flute.parser.selectors.ConditionFactoryImpl;
+
+import org.w3c.flute.util.Encoding;
+
+import com.vaadin.sass.handler.*;
+
+import com.vaadin.sass.tree.*;
+
+/**
+ * A CSS2 parser
+ *
+ * @author Philippe Le H�garet
+ * @version $Revision: 1.15 $
+ */
+public class Parser implements org.w3c.css.sac.Parser, ParserConstants {
+
+    // replaces all \t, \n, etc with this StringBuffer.
+    static final StringBuilder SPACE = new StringBuilder(" ");
+
+    // the document handler for the parser
+    protected SCSSDocumentHandlerImpl documentHandler;
+    // the error handler for the parser
+    protected ErrorHandler errorHandler;
+    // the input source for the parser
+    protected InputSource source;
+
+    protected ConditionFactory conditionFactory;
+    protected SelectorFactory selectorFactory;
+
+    // temporary place holder for pseudo-element ...
+    private String pseudoElt;
+
+    /**
+     * Creates a new Parser
+     */
+    public Parser() {
+        this((CharStream) null);
+    }
+
+    /**
+     * @@TODO
+     * @exception CSSException Not yet implemented
+     */
+    public void setLocale(Locale locale) throws CSSException {
+        throw new CSSException(CSSException.SAC_NOT_SUPPORTED_ERR);
+    }
+
+    /**
+     * Set the document handler for this parser
+     */
+    public void setDocumentHandler(DocumentHandler handler) {
+        this.documentHandler = (SCSSDocumentHandlerImpl) handler;
+    }
+
+    public void setSelectorFactory(SelectorFactory selectorFactory) {
+        this.selectorFactory = selectorFactory;
+    }
+
+    public void setConditionFactory(ConditionFactory conditionFactory) {
+        this.conditionFactory = conditionFactory;
+    }
+
+    /**
+     * Set the error handler for this parser
+     */
+    public void setErrorHandler(ErrorHandler error) {
+        this.errorHandler = error;
+    }
+
+    /**
+     * Main parse methods
+     *
+     * @param source the source of the style sheet.
+     * @exception IOException the source can't be parsed.
+     * @exception CSSException the source is not CSS valid.
+     */
+    public void parseStyleSheet(InputSource source)
+            throws CSSException, IOException {
+        this.source = source;
+        ReInit(getCharStreamWithLurk(source));
+        if (selectorFactory == null) {
+            selectorFactory = new SelectorFactoryImpl();
+        }
+        if (conditionFactory == null) {
+            conditionFactory = new ConditionFactoryImpl();
+        }
+
+        parserUnit();
+    }
+
+    /**
+     * Convenient method for URIs.
+     *
+     * @param systemId the fully resolved URI of the style sheet.
+     * @exception IOException the source can't be parsed.
+     * @exception CSSException the source is not CSS valid.
+     */
+    public void parseStyleSheet(String systemId)
+            throws CSSException, IOException {
+        parseStyleSheet(new InputSource(systemId));
+    }
+
+    /**
+     * This method parses only one rule (style rule or at-rule, except @charset).
+     *
+     * @param source the source of the rule.
+     * @exception IOException the source can't be parsed.
+     * @exception CSSException the source is not CSS valid.
+     */
+    public void parseRule(InputSource source)
+            throws CSSException, IOException {
+        this.source = source;
+        ReInit(getCharStreamWithLurk(source));
+
+        if (selectorFactory == null) {
+            selectorFactory = new SelectorFactoryImpl();
+        }
+        if (conditionFactory == null) {
+            conditionFactory = new ConditionFactoryImpl();
+        }
+        _parseRule();
+    }
+
+    /**
+     * This method parses a style declaration (including the surrounding curly
+     * braces).
+     *
+     * @param source the source of the style declaration.
+     * @exception IOException the source can't be parsed.
+     * @exception CSSException the source is not CSS valid.
+     */
+    public void parseStyleDeclaration(InputSource source)
+            throws CSSException, IOException {
+        this.source = source;
+        ReInit(getCharStreamWithLurk(source));
+
+        if (selectorFactory == null) {
+            selectorFactory = new SelectorFactoryImpl();
+        }
+        if (conditionFactory == null) {
+            conditionFactory = new ConditionFactoryImpl();
+        }
+        _parseDeclarationBlock();
+    }
+
+    /**
+     * This methods returns "http://www.w3.org/TR/REC-CSS2".
+     * @return the string "http://www.w3.org/TR/REC-CSS2".
+     */
+    public String getParserVersion() {
+        return "http://www.w3.org/TR/REC-CSS2";
+    }
+
+    /**
+     * Parse methods used by DOM Level 2 implementation.
+     */
+    public void parseImportRule(InputSource source)
+            throws CSSException, IOException {
+        this.source = source;
+        ReInit(getCharStreamWithLurk(source));
+
+        if (selectorFactory == null) {
+            selectorFactory = new SelectorFactoryImpl();
+        }
+        if (conditionFactory == null) {
+            conditionFactory = new ConditionFactoryImpl();
+        }
+        _parseImportRule();
+    }
+
+    public void parseMediaRule(InputSource source)
+            throws CSSException, IOException {
+        this.source = source;
+        ReInit(getCharStreamWithLurk(source));
+
+        if (selectorFactory == null) {
+            selectorFactory = new SelectorFactoryImpl();
+        }
+        if (conditionFactory == null) {
+            conditionFactory = new ConditionFactoryImpl();
+        }
+        _parseMediaRule();
+    }
+
+    public SelectorList parseSelectors(InputSource source)
+            throws CSSException, IOException {
+        this.source = source;
+        ReInit(getCharStreamWithLurk(source));
+
+        if (selectorFactory == null) {
+            selectorFactory = new SelectorFactoryImpl();
+        }
+        if (conditionFactory == null) {
+            conditionFactory = new ConditionFactoryImpl();
+        }
+        return _parseSelectors();
+    }
+
+    public LexicalUnit parsePropertyValue(InputSource source)
+            throws CSSException, IOException {
+        this.source = source;
+        ReInit(getCharStreamWithLurk(source));
+
+        return expr();
+    }
+
+    public boolean parsePriority(InputSource source)
+            throws CSSException, IOException {
+        this.source = source;
+        ReInit(getCharStreamWithLurk(source));
+
+        return prio();
+    }
+
+    /**
+     * Convert the source into a Reader. Used only by DOM Level 2 parser methods.
+     */
+    private Reader getReader(InputSource source) throws IOException {
+        if (source.getCharacterStream() != null) {
+            return source.getCharacterStream();
+        } else if (source.getByteStream() != null) {
+            // My DOM level 2 implementation doesn't use this case.
+            if (source.getEncoding() == null) {
+                // unknown encoding, use ASCII as default.
+                return new InputStreamReader(source.getByteStream(), "ASCII");
+            } else {
+                return new InputStreamReader(source.getByteStream(),
+                                             source.getEncoding());
+            }
+        } else {
+            // systemId
+            // @@TODO
+            throw new CSSException("not yet implemented");
+        }
+    }
+
+    /**
+     * Convert the source into a CharStream with encoding informations.
+     * The encoding can be found in the InputSource or in the CSS document.
+     * Since this method marks the reader and make a reset after looking for
+     * the charset declaration, you'll find the charset declaration into the
+     * stream.  
+     */
+    private CharStream getCharStreamWithLurk(InputSource source)
+            throws CSSException, IOException {
+        if (source.getCharacterStream() != null) {
+            // all encoding are supposed to be resolved by the user
+            // return the reader
+            return new Generic_CharStream(source.getCharacterStream(), 1, 1);
+        } else if (source.getByteStream() == null) {
+            // @@CONTINUE ME. see also getReader() with systemId
+            try {
+                source.setByteStream(new URL(source.getURI()).openStream());
+            } catch (Exception e) {
+                try {
+                    source.setByteStream(new FileInputStream(source.getURI()));
+                } catch (IOException ex) {
+                    throw new CSSException("invalid url ?");
+                }
+            }
+        }
+        String encoding = "ASCII";
+        InputStream input = source.getByteStream();
+        char c = ' ';
+
+        if (!input.markSupported()) {
+            input = new BufferedInputStream(input);
+            source.setByteStream(input);
+        }
+        input.mark(100);
+        c = (char) input.read();
+
+        if (c == '@') {
+            // hum, is it a charset ?
+            int size   = 100;
+            byte[] buf = new byte[size];
+            input.read(buf, 0, 7);
+            String keyword = new String(buf, 0, 7);
+            if (keyword.equals("charset")) {
+                // Yes, this is the charset declaration !
+
+                // here I don't use the right declaration : white space are ' '.
+                while ((c = (char) input.read()) == ' ') {
+                    // find the first quote
+                }
+                char endChar = c;
+                int i = 0;
+
+                if ((endChar != '"') && (endChar != '\u005c'')) {
+                    // hum this is not a quote.
+                    throw new CSSException("invalid charset declaration");
+                }
+
+                while ((c = (char) input.read()) != endChar) {
+                    buf[i++] = (byte) c;
+                    if (i == size) {
+                        byte[] old = buf;
+                        buf = new byte[size + 100];
+                        System.arraycopy(old, 0, buf, 0, size);
+                        size += 100;
+                    }
+                }
+                while ((c = (char) input.read()) == ' ') {
+                    // find the next relevant character
+                }
+                if (c != ';') {
+                    // no semi colon at the end ?
+                    throw new CSSException("invalid charset declaration: "
+                                           + "missing semi colon");
+                }
+                encoding = new String(buf, 0, i);
+                if (source.getEncoding() != null) {
+                    // compare the two encoding informations.
+                    // For example, I don't accept to have ASCII and after UTF-8.
+                    // Is it really good ? That is the question.
+                    if (!encoding.equals(source.getEncoding())) {
+                        throw new CSSException("invalid encoding information.");
+                    }
+                }
+            } // else no charset declaration available
+        }
+        // ok set the real encoding of this source.
+        source.setEncoding(encoding);
+        // set the real reader of this source.
+        source.setCharacterStream(new InputStreamReader(source.getByteStream(),
+                                             Encoding.getJavaEncoding(encoding)));
+        // reset the stream (leave the charset declaration in the stream).
+        input.reset();
+
+        return new Generic_CharStream(source.getCharacterStream(), 1, 1);
+    }
+
+    private LocatorImpl currentLocator;
+    private Locator getLocator() {
+        if (currentLocator == null) {
+            currentLocator = new LocatorImpl(this);
+            return currentLocator;
+        }
+        return currentLocator.reInit(this);
+    }
+    private LocatorImpl getLocator(Token save) {
+        if (currentLocator == null) {
+            currentLocator = new LocatorImpl(this, save);
+            return currentLocator;
+        }
+        return currentLocator.reInit(this, save);
+    }
+
+    private void reportError(Locator l, Exception e) {
+        if (errorHandler != null) {
+            if (e instanceof ParseException) {
+                // construct a clean error message.
+                ParseException pe = (ParseException) e;
+                if (pe.specialConstructor) {
+                    StringBuffer errorM = new StringBuffer();
+                    if (pe.currentToken != null) {
+                        errorM.append("encountered \u005c"")
+                            .append(pe.currentToken.next);
+                    }
+                    errorM.append('"');
+                    if (pe.expectedTokenSequences.length != 0) {
+                        errorM.append(". Was expecting one of: ");
+                        for (int i = 0; i < pe.expectedTokenSequences.length; i++) {
+                            for (int j = 0; j < pe.expectedTokenSequences[i].length; j++) {
+                                int kind = pe.expectedTokenSequences[i][j];
+                                if (kind != S) {
+                                    errorM.append(pe.tokenImage[kind]);
+                                    errorM.append(' ');
+                                }
+                            }
+                        }
+                    }
+                    errorHandler.error(new CSSParseException(errorM.toString(),
+                                                             l, e));
+                } else {
+                    errorHandler.error(new CSSParseException(e.getMessage(),
+                                                             l, e));
+                }
+            } else if (e == null) {
+                errorHandler.error(new CSSParseException("error", l, null));
+            } else {
+                errorHandler.error(new CSSParseException(e.getMessage(), l, e));
+            }
+        }
+    }
+
+    private void reportWarningSkipText(Locator l, String text) {
+        if (errorHandler != null && text  != null) {
+            errorHandler.warning(new CSSParseException("Skipping: " + text, l));
+        }
+    }
+
+/*
+ * The grammar of CSS2
+ */
+
+/**
+ * The main entry for the parser.
+ *
+ * @exception ParseException exception during the parse
+ */
+  final public void parserUnit() throws ParseException {
+    try {
+          documentHandler.startDocument(source);
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case CHARSET_SYM:
+        charset();
+        break;
+      default:
+        jj_la1[0] = jj_gen;
+        ;
+      }
+      label_1:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+        case CDO:
+        case CDC:
+        case ATKEYWORD:
+          ;
+          break;
+        default:
+          jj_la1[1] = jj_gen;
+          break label_1;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          jj_consume_token(S);
+          comments();
+          break;
+        case CDO:
+        case CDC:
+        case ATKEYWORD:
+          ignoreStatement();
+          break;
+        default:
+          jj_la1[2] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      label_2:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case IMPORT_SYM:
+          ;
+          break;
+        default:
+          jj_la1[3] = jj_gen;
+          break label_2;
+        }
+        importDeclaration();
+        label_3:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case CDO:
+          case CDC:
+          case ATKEYWORD:
+            ;
+            break;
+          default:
+            jj_la1[4] = jj_gen;
+            break label_3;
+          }
+          ignoreStatement();
+          label_4:
+          while (true) {
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case S:
+              ;
+              break;
+            default:
+              jj_la1[5] = jj_gen;
+              break label_4;
+            }
+            jj_consume_token(S);
+          }
+        }
+      }
+      afterImportDeclaration();
+      jj_consume_token(0);
+    } finally {
+        documentHandler.endDocument(source);
+    }
+  }
+
+  final public void charset() throws ParseException {
+  Token n;
+    try {
+      jj_consume_token(CHARSET_SYM);
+      label_5:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[6] = jj_gen;
+          break label_5;
+        }
+        jj_consume_token(S);
+      }
+      n = jj_consume_token(STRING);
+      label_6:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[7] = jj_gen;
+          break label_6;
+        }
+        jj_consume_token(S);
+      }
+      jj_consume_token(SEMICOLON);
+    } catch (ParseException e) {
+        reportError(getLocator(e.currentToken.next), e);
+        skipStatement();
+        // reportWarningSkipText(getLocator(), skipStatement());
+
+    } catch (Exception e) {
+        reportError(getLocator(), e);
+        skipStatement();
+        // reportWarningSkipText(getLocator(), skipStatement());
+
+    }
+  }
+
+  final public void afterImportDeclaration() throws ParseException {
+ String ret;
+ Locator l;
+    label_7:
+    while (true) {
+      ;
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case VARIABLE:
+        variable();
+        break;
+      case MIXIN_SYM:
+        mixinDirective();
+        break;
+      case EACH_SYM:
+        eachDirective();
+        break;
+      case INCLUDE_SYM:
+        includeDirective();
+        break;
+      case LBRACKET:
+      case ANY:
+      case PARENT:
+      case DOT:
+      case COLON:
+      case EACH_VAR:
+      case IDENT:
+      case HASH:
+        styleRule();
+        break;
+      case MEDIA_SYM:
+        media();
+        break;
+      case PAGE_SYM:
+        page();
+        break;
+      case FONT_FACE_SYM:
+        fontFace();
+        break;
+      default:
+        jj_la1[8] = jj_gen;
+          l = getLocator();
+        ret = skipStatement();
+          if ((ret == null) || (ret.length() == 0)) {
+              {if (true) return;}
+          }
+          reportWarningSkipText(l, ret);
+          if (ret.charAt(0) == '@') {
+              documentHandler.ignorableAtRule(ret);
+          }
+      }
+      label_8:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case CDO:
+        case CDC:
+        case ATKEYWORD:
+          ;
+          break;
+        default:
+          jj_la1[9] = jj_gen;
+          break label_8;
+        }
+        ignoreStatement();
+        label_9:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case S:
+            ;
+            break;
+          default:
+            jj_la1[10] = jj_gen;
+            break label_9;
+          }
+          jj_consume_token(S);
+        }
+      }
+    }
+  }
+
+  final public void ignoreStatement() throws ParseException {
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case CDO:
+      jj_consume_token(CDO);
+      break;
+    case CDC:
+      jj_consume_token(CDC);
+      break;
+    case ATKEYWORD:
+      atRuleDeclaration();
+      break;
+    default:
+      jj_la1[11] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+  }
+
+/**
+ * The import statement
+ *
+ * @exception ParseException exception during the parse
+ */
+  final public void importDeclaration() throws ParseException {
+ Token n;
+ String uri;
+ MediaListImpl ml = new MediaListImpl();
+ boolean isURL = false;
+    try {
+      jj_consume_token(IMPORT_SYM);
+      label_10:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[12] = jj_gen;
+          break label_10;
+        }
+        jj_consume_token(S);
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case STRING:
+        n = jj_consume_token(STRING);
+                               uri = convertStringIndex(n.image, 1,
+                                                        n.image.length() -1);
+        break;
+      case URL:
+        n = jj_consume_token(URL);
+               isURL=true;
+               uri = n.image.substring(4, n.image.length()-1).trim();
+               if ((uri.charAt(0) == '"')
+                   || (uri.charAt(0) == '\u005c'')) {
+                   uri = uri.substring(1, uri.length()-1);
+               }
+        break;
+      default:
+        jj_la1[13] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      label_11:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[14] = jj_gen;
+          break label_11;
+        }
+        jj_consume_token(S);
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENT:
+        mediaStatement(ml);
+        break;
+      default:
+        jj_la1[15] = jj_gen;
+        ;
+      }
+      jj_consume_token(SEMICOLON);
+      label_12:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[16] = jj_gen;
+          break label_12;
+        }
+        jj_consume_token(S);
+      }
+               if (ml.getLength() == 0) {
+                   // see section 6.3 of the CSS2 recommandation.
+                   ml.addItem("all");
+               }
+               documentHandler.importStyle(uri, ml, isURL);
+    } catch (ParseException e) {
+     reportError(getLocator(), e);
+     skipStatement();
+     // reportWarningSkipText(getLocator(), skipStatement());
+
+    }
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public void media() throws ParseException {
+    boolean start = false;
+    String ret;
+    MediaListImpl ml = new MediaListImpl();
+    try {
+      jj_consume_token(MEDIA_SYM);
+      label_13:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[17] = jj_gen;
+          break label_13;
+        }
+        jj_consume_token(S);
+      }
+      mediaStatement(ml);
+     start = true; documentHandler.startMedia(ml);
+      jj_consume_token(LBRACE);
+      label_14:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[18] = jj_gen;
+          break label_14;
+        }
+        jj_consume_token(S);
+      }
+      label_15:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case CDO:
+        case LBRACE:
+        case DASHMATCH:
+        case INCLUDES:
+        case PLUS:
+        case MINUS:
+        case COMMA:
+        case SEMICOLON:
+        case PRECEDES:
+        case LBRACKET:
+        case ANY:
+        case PARENT:
+        case DOT:
+        case COLON:
+        case EACH_VAR:
+        case NONASCII:
+        case STRING:
+        case IDENT:
+        case NUMBER:
+        case URL:
+        case PERCENTAGE:
+        case HASH:
+        case IMPORT_SYM:
+        case MEDIA_SYM:
+        case CHARSET_SYM:
+        case PAGE_SYM:
+        case FONT_FACE_SYM:
+        case ATKEYWORD:
+        case IMPORTANT_SYM:
+        case UNICODERANGE:
+        case FUNCTION:
+        case UNKNOWN:
+          ;
+          break;
+        default:
+          jj_la1[19] = jj_gen;
+          break label_15;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case LBRACKET:
+        case ANY:
+        case PARENT:
+        case DOT:
+        case COLON:
+        case EACH_VAR:
+        case IDENT:
+        case HASH:
+          styleRule();
+          break;
+        case CDO:
+        case LBRACE:
+        case DASHMATCH:
+        case INCLUDES:
+        case PLUS:
+        case MINUS:
+        case COMMA:
+        case SEMICOLON:
+        case PRECEDES:
+        case NONASCII:
+        case STRING:
+        case NUMBER:
+        case URL:
+        case PERCENTAGE:
+        case IMPORT_SYM:
+        case MEDIA_SYM:
+        case CHARSET_SYM:
+        case PAGE_SYM:
+        case FONT_FACE_SYM:
+        case ATKEYWORD:
+        case IMPORTANT_SYM:
+        case UNICODERANGE:
+        case FUNCTION:
+        case UNKNOWN:
+          skipUnknownRule();
+          break;
+        default:
+          jj_la1[20] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      jj_consume_token(RBRACE);
+      label_16:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[21] = jj_gen;
+          break label_16;
+        }
+        jj_consume_token(S);
+      }
+    } catch (ParseException e) {
+     reportError(getLocator(), e);
+     skipStatement();
+     // reportWarningSkipText(getLocator(), skipStatement());
+
+    } finally {
+     if (start) {
+         documentHandler.endMedia(ml);
+     }
+    }
+  }
+
+  final public void mediaStatement(MediaListImpl ml) throws ParseException {
+    String m;
+    m = medium();
+    label_17:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case COMMA:
+        ;
+        break;
+      default:
+        jj_la1[22] = jj_gen;
+        break label_17;
+      }
+      jj_consume_token(COMMA);
+      label_18:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[23] = jj_gen;
+          break label_18;
+        }
+        jj_consume_token(S);
+      }
+                                   ml.addItem(m);
+      m = medium();
+    }
+     ml.addItem(m);
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public String medium() throws ParseException {
+ Token n;
+    n = jj_consume_token(IDENT);
+    label_19:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[24] = jj_gen;
+        break label_19;
+      }
+      jj_consume_token(S);
+    }
+                         {if (true) return convertIdent(n.image);}
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public void page() throws ParseException {
+ boolean start = false;
+ Token n = null;
+ String page = null;
+ String pseudo = null;
+    try {
+      jj_consume_token(PAGE_SYM);
+      label_20:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[25] = jj_gen;
+          break label_20;
+        }
+        jj_consume_token(S);
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENT:
+        n = jj_consume_token(IDENT);
+        label_21:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case S:
+            ;
+            break;
+          default:
+            jj_la1[26] = jj_gen;
+            break label_21;
+          }
+          jj_consume_token(S);
+        }
+        break;
+      default:
+        jj_la1[27] = jj_gen;
+        ;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case COLON:
+        pseudo = pseudo_page();
+        break;
+      default:
+        jj_la1[28] = jj_gen;
+        ;
+      }
+          if (n != null) {
+              page = convertIdent(n.image);
+          }
+      jj_consume_token(LBRACE);
+      label_22:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[29] = jj_gen;
+          break label_22;
+        }
+        jj_consume_token(S);
+      }
+          start = true;
+          documentHandler.startPage(page, pseudo);
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENT:
+        declaration();
+        break;
+      default:
+        jj_la1[30] = jj_gen;
+        ;
+      }
+      label_23:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case SEMICOLON:
+          ;
+          break;
+        default:
+          jj_la1[31] = jj_gen;
+          break label_23;
+        }
+        jj_consume_token(SEMICOLON);
+        label_24:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case S:
+            ;
+            break;
+          default:
+            jj_la1[32] = jj_gen;
+            break label_24;
+          }
+          jj_consume_token(S);
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case IDENT:
+          declaration();
+          break;
+        default:
+          jj_la1[33] = jj_gen;
+          ;
+        }
+      }
+      jj_consume_token(RBRACE);
+      label_25:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[34] = jj_gen;
+          break label_25;
+        }
+        jj_consume_token(S);
+      }
+    } catch (ParseException e) {
+     if (errorHandler != null) {
+         LocatorImpl li = new LocatorImpl(this,
+                                          e.currentToken.next.beginLine,
+                                          e.currentToken.next.beginColumn-1);
+         reportError(li, e);
+         skipStatement();
+         // reportWarningSkipText(li, skipStatement());
+     } else {
+         skipStatement();
+     }
+    } finally {
+     if (start) {
+         documentHandler.endPage(page, pseudo);
+     }
+    }
+  }
+
+  final public String pseudo_page() throws ParseException {
+  Token n;
+    jj_consume_token(COLON);
+    n = jj_consume_token(IDENT);
+    label_26:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[35] = jj_gen;
+        break label_26;
+      }
+      jj_consume_token(S);
+    }
+                             {if (true) return convertIdent(n.image);}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public void fontFace() throws ParseException {
+    boolean start = false;
+    try {
+      jj_consume_token(FONT_FACE_SYM);
+      label_27:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[36] = jj_gen;
+          break label_27;
+        }
+        jj_consume_token(S);
+      }
+      jj_consume_token(LBRACE);
+      label_28:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[37] = jj_gen;
+          break label_28;
+        }
+        jj_consume_token(S);
+      }
+        start = true; documentHandler.startFontFace();
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENT:
+        declaration();
+        break;
+      default:
+        jj_la1[38] = jj_gen;
+        ;
+      }
+      label_29:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case SEMICOLON:
+          ;
+          break;
+        default:
+          jj_la1[39] = jj_gen;
+          break label_29;
+        }
+        jj_consume_token(SEMICOLON);
+        label_30:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case S:
+            ;
+            break;
+          default:
+            jj_la1[40] = jj_gen;
+            break label_30;
+          }
+          jj_consume_token(S);
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case IDENT:
+          declaration();
+          break;
+        default:
+          jj_la1[41] = jj_gen;
+          ;
+        }
+      }
+      jj_consume_token(RBRACE);
+      label_31:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[42] = jj_gen;
+          break label_31;
+        }
+        jj_consume_token(S);
+      }
+    } catch (ParseException e) {
+     reportError(getLocator(), e);
+     skipStatement();
+     // reportWarningSkipText(getLocator(), skipStatement());
+
+    } finally {
+     if (start) {
+         documentHandler.endFontFace();
+     }
+    }
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public void atRuleDeclaration() throws ParseException {
+ Token n;
+ String ret;
+    n = jj_consume_token(ATKEYWORD);
+        ret=skipStatement();
+        reportWarningSkipText(getLocator(), ret);
+        if ((ret != null) && (ret.charAt(0) == '@')) {
+            documentHandler.ignorableAtRule(ret);
+        }
+  }
+
+  final public void skipUnknownRule() throws ParseException {
+  Token n;
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case ATKEYWORD:
+      n = jj_consume_token(ATKEYWORD);
+      break;
+    case CDO:
+      n = jj_consume_token(CDO);
+      break;
+    case CHARSET_SYM:
+      n = jj_consume_token(CHARSET_SYM);
+      break;
+    case COMMA:
+      n = jj_consume_token(COMMA);
+      break;
+    case DASHMATCH:
+      n = jj_consume_token(DASHMATCH);
+      break;
+    case FONT_FACE_SYM:
+      n = jj_consume_token(FONT_FACE_SYM);
+      break;
+    case FUNCTION:
+      n = jj_consume_token(FUNCTION);
+      break;
+    case IMPORTANT_SYM:
+      n = jj_consume_token(IMPORTANT_SYM);
+      break;
+    case IMPORT_SYM:
+      n = jj_consume_token(IMPORT_SYM);
+      break;
+    case INCLUDES:
+      n = jj_consume_token(INCLUDES);
+      break;
+    case LBRACE:
+      n = jj_consume_token(LBRACE);
+      break;
+    case MEDIA_SYM:
+      n = jj_consume_token(MEDIA_SYM);
+      break;
+    case NONASCII:
+      n = jj_consume_token(NONASCII);
+      break;
+    case NUMBER:
+      n = jj_consume_token(NUMBER);
+      break;
+    case PAGE_SYM:
+      n = jj_consume_token(PAGE_SYM);
+      break;
+    case PERCENTAGE:
+      n = jj_consume_token(PERCENTAGE);
+      break;
+    case STRING:
+      n = jj_consume_token(STRING);
+      break;
+    case UNICODERANGE:
+      n = jj_consume_token(UNICODERANGE);
+      break;
+    case URL:
+      n = jj_consume_token(URL);
+      break;
+    case SEMICOLON:
+      n = jj_consume_token(SEMICOLON);
+      break;
+    case PLUS:
+      n = jj_consume_token(PLUS);
+      break;
+    case PRECEDES:
+      n = jj_consume_token(PRECEDES);
+      break;
+    case MINUS:
+      n = jj_consume_token(MINUS);
+      break;
+    case UNKNOWN:
+      n = jj_consume_token(UNKNOWN);
+      break;
+    default:
+      jj_la1[43] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+     String ret;
+     Locator loc = getLocator();
+     ret=skipStatement();
+     reportWarningSkipText(loc, ret);
+     if ((ret != null) && (n.image.charAt(0) == '@')) {
+         documentHandler.ignorableAtRule(ret);
+     }
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public char combinator() throws ParseException {
+char connector = ' ';
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case PLUS:
+      jj_consume_token(PLUS);
+      label_32:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[44] = jj_gen;
+          break label_32;
+        }
+        jj_consume_token(S);
+      }
+                   {if (true) return '+';}
+      break;
+    case PRECEDES:
+      jj_consume_token(PRECEDES);
+      label_33:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[45] = jj_gen;
+          break label_33;
+        }
+        jj_consume_token(S);
+      }
+                     {if (true) return '>';}
+      break;
+    case S:
+      jj_consume_token(S);
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case PLUS:
+      case PRECEDES:
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case PLUS:
+          jj_consume_token(PLUS);
+                 connector = '+';
+          break;
+        case PRECEDES:
+          jj_consume_token(PRECEDES);
+                   connector = '>';
+          break;
+        default:
+          jj_la1[46] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        label_34:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case S:
+            ;
+            break;
+          default:
+            jj_la1[47] = jj_gen;
+            break label_34;
+          }
+          jj_consume_token(S);
+        }
+        break;
+      default:
+        jj_la1[48] = jj_gen;
+        ;
+      }
+               {if (true) return connector;}
+      break;
+    default:
+      jj_la1[49] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public String property() throws ParseException {
+ Token n;
+    n = jj_consume_token(IDENT);
+    label_35:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[50] = jj_gen;
+        break label_35;
+      }
+      jj_consume_token(S);
+    }
+                                 {if (true) return convertIdent(n.image);}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public String variableName() throws ParseException {
+ Token n;
+    n = jj_consume_token(VARIABLE);
+    label_36:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[51] = jj_gen;
+        break label_36;
+      }
+      jj_consume_token(S);
+    }
+                         {if (true) return convertIdent(n.image.substring(1));}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public String functionName() throws ParseException {
+ Token n;
+    n = jj_consume_token(FUNCTION);
+    label_37:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[52] = jj_gen;
+        break label_37;
+      }
+      jj_consume_token(S);
+    }
+                           {if (true) return convertIdent(n.image.substring(0, n.image.length()-1));}
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public void styleRule() throws ParseException {
+    boolean start = false;
+    SelectorList l = null;
+    Token save;
+    Locator loc;
+    try {
+      l = selectorList();
+                        save = token;
+      jj_consume_token(LBRACE);
+      label_38:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[53] = jj_gen;
+          break label_38;
+        }
+        jj_consume_token(S);
+      }
+         start = true;
+         documentHandler.startSelector(l);
+      label_39:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case LBRACKET:
+        case ANY:
+        case PARENT:
+        case DOT:
+        case COLON:
+        case EACH_VAR:
+        case INCLUDE_SYM:
+        case EACH_SYM:
+        case EXTEND_SYM:
+        case IDENT:
+        case VARIABLE:
+        case HASH:
+        case MEDIA_SYM:
+          ;
+          break;
+        default:
+          jj_la1[54] = jj_gen;
+          break label_39;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case INCLUDE_SYM:
+          includeDirective();
+          break;
+        case MEDIA_SYM:
+          media();
+          break;
+        case EXTEND_SYM:
+          extendDirective();
+          break;
+        case EACH_SYM:
+          eachDirective();
+          break;
+        case VARIABLE:
+          variable();
+          break;
+        default:
+          jj_la1[55] = jj_gen;
+          if (jj_2_1(3)) {
+            declarationOrNestedProperties();
+          } else {
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case LBRACKET:
+            case ANY:
+            case PARENT:
+            case DOT:
+            case COLON:
+            case EACH_VAR:
+            case IDENT:
+            case HASH:
+              styleRule();
+              break;
+            default:
+              jj_la1[56] = jj_gen;
+              jj_consume_token(-1);
+              throw new ParseException();
+            }
+          }
+        }
+      }
+      jj_consume_token(RBRACE);
+      label_40:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[57] = jj_gen;
+          break label_40;
+        }
+        jj_consume_token(S);
+      }
+    } catch (ThrowedParseException e) {
+     if (errorHandler != null) {
+         LocatorImpl li = new LocatorImpl(this,
+                                          e.e.currentToken.next.beginLine,
+                                          e.e.currentToken.next.beginColumn-1);
+         reportError(li, e.e);
+     }
+    } catch (ParseException e) {
+     reportError(getLocator(), e);
+     skipStatement();
+     // reportWarningSkipText(getLocator(), skipStatement());
+
+    } catch (TokenMgrError e) {
+     reportWarningSkipText(getLocator(), skipStatement());
+    } finally {
+     if (start) {
+         documentHandler.endSelector(l);
+     }
+    }
+  }
+
+  final public SelectorList selectorList() throws ParseException {
+    SelectorListImpl selectors = new SelectorListImpl();
+    Selector selector;
+    selector = selector();
+    label_41:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case COMMA:
+        ;
+        break;
+      default:
+        jj_la1[58] = jj_gen;
+        break label_41;
+      }
+      jj_consume_token(COMMA);
+      label_42:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[59] = jj_gen;
+          break label_42;
+        }
+        jj_consume_token(S);
+      }
+                                        selectors.addSelector(selector);
+      selector = selector();
+    }
+    selectors.addSelector(selector);
+    {if (true) return selectors;}
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public Selector selector() throws ParseException {
+    Selector selector;
+    char    comb;
+    try {
+      selector = simple_selector(null, ' ');
+      label_43:
+      while (true) {
+        if (jj_2_2(2)) {
+          ;
+        } else {
+          break label_43;
+        }
+        comb = combinator();
+        selector = simple_selector(selector, comb);
+      }
+      label_44:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[60] = jj_gen;
+          break label_44;
+        }
+        jj_consume_token(S);
+      }
+       {if (true) return selector;}
+    } catch (ParseException e) {
+     /*
+     Token t = getToken(1);
+     StringBuffer s = new StringBuffer();
+     s.append(getToken(0).image);
+     while ((t.kind != COMMA) && (t.kind != SEMICOLON) 
+	    && (t.kind != LBRACE) && (t.kind != EOF)) {
+	 s.append(t.image);
+	 getNextToken();
+	 t = getToken(1);
+     }
+     reportWarningSkipText(getLocator(), s.toString());
+     */
+     Token t = getToken(1);
+     while ((t.kind != COMMA) && (t.kind != SEMICOLON)
+            && (t.kind != LBRACE) && (t.kind != EOF)) {
+         getNextToken();
+         t = getToken(1);
+     }
+
+     {if (true) throw new ThrowedParseException(e);}
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public Selector simple_selector(Selector selector, char comb) throws ParseException {
+    SimpleSelector simple_current = null;
+    Condition cond = null;
+
+    pseudoElt = null;
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case ANY:
+    case PARENT:
+    case EACH_VAR:
+    case IDENT:
+      simple_current = element_name();
+      label_45:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case LBRACKET:
+        case DOT:
+        case COLON:
+        case HASH:
+          ;
+          break;
+        default:
+          jj_la1[61] = jj_gen;
+          break label_45;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case HASH:
+          cond = hash(cond);
+          break;
+        case DOT:
+          cond = _class(cond);
+          break;
+        case LBRACKET:
+          cond = attrib(cond);
+          break;
+        case COLON:
+          cond = pseudo(cond);
+          break;
+        default:
+          jj_la1[62] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      break;
+    case HASH:
+      cond = hash(cond);
+      label_46:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case LBRACKET:
+        case DOT:
+        case COLON:
+          ;
+          break;
+        default:
+          jj_la1[63] = jj_gen;
+          break label_46;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case DOT:
+          cond = _class(cond);
+          break;
+        case LBRACKET:
+          cond = attrib(cond);
+          break;
+        case COLON:
+          cond = pseudo(cond);
+          break;
+        default:
+          jj_la1[64] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      break;
+    case DOT:
+      cond = _class(cond);
+      label_47:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case LBRACKET:
+        case DOT:
+        case COLON:
+        case HASH:
+          ;
+          break;
+        default:
+          jj_la1[65] = jj_gen;
+          break label_47;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case HASH:
+          cond = hash(cond);
+          break;
+        case DOT:
+          cond = _class(cond);
+          break;
+        case LBRACKET:
+          cond = attrib(cond);
+          break;
+        case COLON:
+          cond = pseudo(cond);
+          break;
+        default:
+          jj_la1[66] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      break;
+    case COLON:
+      cond = pseudo(cond);
+      label_48:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case LBRACKET:
+        case DOT:
+        case COLON:
+        case HASH:
+          ;
+          break;
+        default:
+          jj_la1[67] = jj_gen;
+          break label_48;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case HASH:
+          cond = hash(cond);
+          break;
+        case DOT:
+          cond = _class(cond);
+          break;
+        case LBRACKET:
+          cond = attrib(cond);
+          break;
+        case COLON:
+          cond = pseudo(cond);
+          break;
+        default:
+          jj_la1[68] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      break;
+    case LBRACKET:
+      cond = attrib(cond);
+      label_49:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case LBRACKET:
+        case DOT:
+        case COLON:
+        case HASH:
+          ;
+          break;
+        default:
+          jj_la1[69] = jj_gen;
+          break label_49;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case HASH:
+          cond = hash(cond);
+          break;
+        case DOT:
+          cond = _class(cond);
+          break;
+        case LBRACKET:
+          cond = attrib(cond);
+          break;
+        case COLON:
+          cond = pseudo(cond);
+          break;
+        default:
+          jj_la1[70] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      break;
+    default:
+      jj_la1[71] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+            if (simple_current == null) {
+                simple_current = selectorFactory.createElementSelector(null, null);
+            }
+            if (cond != null) {
+                simple_current = selectorFactory.createConditionalSelector(simple_current,
+                                                                    cond);
+            }
+            if (selector != null) {
+                switch (comb) {
+                case ' ':
+                    selector = selectorFactory.createDescendantSelector(selector,
+                                                                       simple_current);
+                    break;
+                case '+':
+                    selector =
+                        selectorFactory.createDirectAdjacentSelector((short) 1,
+                                                                     selector,
+                                                                     simple_current);
+                    break;
+                case '>':
+                    selector = selectorFactory.createChildSelector(selector,
+                                                                  simple_current);
+                    break;
+                default:
+                    {if (true) throw new ParseException("invalid state. send a bug report");}
+                }
+            } else {
+                selector= simple_current;
+            }
+            if (pseudoElt != null) {
+                selector = selectorFactory.createChildSelector(selector,
+                             selectorFactory.createPseudoElementSelector(null, pseudoElt));
+            }
+            {if (true) return selector;}
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public Condition _class(Condition pred) throws ParseException {
+ Token t;
+String s = "";
+Condition c;
+    jj_consume_token(DOT);
+    label_50:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENT:
+        t = jj_consume_token(IDENT);
+                   s += t.image;
+        break;
+      case EACH_VAR:
+        t = jj_consume_token(EACH_VAR);
+                                                     s += t.image;
+        break;
+      default:
+        jj_la1[72] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case EACH_VAR:
+      case IDENT:
+        ;
+        break;
+      default:
+        jj_la1[73] = jj_gen;
+        break label_50;
+      }
+    }
+          c = conditionFactory.createClassCondition(null, s);
+          if (pred == null) {
+              {if (true) return c;}
+          } else {
+              {if (true) return conditionFactory.createAndCondition(pred, c);}
+          }
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public SimpleSelector element_name() throws ParseException {
+ Token t; String s = "";
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case EACH_VAR:
+    case IDENT:
+      label_51:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case IDENT:
+          t = jj_consume_token(IDENT);
+                 s += t.image;
+          break;
+        case EACH_VAR:
+          t = jj_consume_token(EACH_VAR);
+                                                   s += t.image;
+          break;
+        default:
+          jj_la1[74] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case EACH_VAR:
+        case IDENT:
+          ;
+          break;
+        default:
+          jj_la1[75] = jj_gen;
+          break label_51;
+        }
+      }
+      {if (true) return selectorFactory.createElementSelector(null, s);}
+      break;
+    case ANY:
+      jj_consume_token(ANY);
+      {if (true) return selectorFactory.createElementSelector(null, "*");}
+      break;
+    case PARENT:
+      jj_consume_token(PARENT);
+      {if (true) return selectorFactory.createElementSelector(null, "&");}
+      break;
+    default:
+      jj_la1[76] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public Condition attrib(Condition pred) throws ParseException {
+    int cases = 0;
+    Token att = null;
+    Token val = null;
+    String attValue = null;
+    jj_consume_token(LBRACKET);
+    label_52:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[77] = jj_gen;
+        break label_52;
+      }
+      jj_consume_token(S);
+    }
+    att = jj_consume_token(IDENT);
+    label_53:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[78] = jj_gen;
+        break label_53;
+      }
+      jj_consume_token(S);
+    }
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case DASHMATCH:
+    case INCLUDES:
+    case EQ:
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case EQ:
+        jj_consume_token(EQ);
+                          cases = 1;
+        break;
+      case INCLUDES:
+        jj_consume_token(INCLUDES);
+                          cases = 2;
+        break;
+      case DASHMATCH:
+        jj_consume_token(DASHMATCH);
+                          cases = 3;
+        break;
+      default:
+        jj_la1[79] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      label_54:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[80] = jj_gen;
+          break label_54;
+        }
+        jj_consume_token(S);
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENT:
+        val = jj_consume_token(IDENT);
+                        attValue = val.image;
+        break;
+      case STRING:
+        val = jj_consume_token(STRING);
+                           attValue = convertStringIndex(val.image, 1,
+                                                         val.image.length() -1);
+        break;
+      default:
+        jj_la1[81] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      label_55:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[82] = jj_gen;
+          break label_55;
+        }
+        jj_consume_token(S);
+      }
+      break;
+    default:
+      jj_la1[83] = jj_gen;
+      ;
+    }
+    jj_consume_token(RBRACKET);
+      String name = convertIdent(att.image);
+      Condition c;
+      switch (cases) {
+          case 0:
+          c = conditionFactory.createAttributeCondition(name, null, false, null);
+          break;
+          case 1:
+          c = conditionFactory.createAttributeCondition(name, null, false,
+                                                        attValue);
+          break;
+          case 2:
+          c = conditionFactory.createOneOfAttributeCondition(name, null, false,
+                                                             attValue);
+          break;
+          case 3:
+          c = conditionFactory.createBeginHyphenAttributeCondition(name, null,
+                                                                   false,
+                                                                   attValue);
+          break;
+          default:
+          // never reached.
+          c = null;
+      }
+      if (pred == null) {
+          {if (true) return c;}
+      } else {
+          {if (true) return conditionFactory.createAndCondition(pred, c);}
+      }
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public Condition pseudo(Condition pred) throws ParseException {
+ Token n;
+Token language;
+boolean isPseudoElement = false;
+    jj_consume_token(COLON);
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case COLON:
+      jj_consume_token(COLON);
+             isPseudoElement=true;
+      break;
+    default:
+      jj_la1[84] = jj_gen;
+      ;
+    }
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case IDENT:
+      n = jj_consume_token(IDENT);
+            String s = convertIdent(n.image);
+            if (isPseudoElement) {
+                if (pseudoElt != null) {
+                    {if (true) throw new CSSParseException("duplicate pseudo element definition "
+                                                + s, getLocator());}
+                } else {
+                    pseudoElt = s;
+                    {if (true) return pred;}
+                }
+            } else {
+                Condition c =
+                conditionFactory.createPseudoClassCondition(null, s);
+                if (pred == null) {
+                    {if (true) return c;}
+                } else {
+                    {if (true) return conditionFactory.createAndCondition(pred, c);}
+                }
+            }
+      break;
+    case FUNCTION:
+      n = jj_consume_token(FUNCTION);
+      label_56:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[85] = jj_gen;
+          break label_56;
+        }
+        jj_consume_token(S);
+      }
+      language = jj_consume_token(IDENT);
+      label_57:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[86] = jj_gen;
+          break label_57;
+        }
+        jj_consume_token(S);
+      }
+      jj_consume_token(RPARAN);
+                  String f = convertIdent(n.image);
+                  if (f.equals("lang(")) {
+                      Condition d =
+              conditionFactory.createLangCondition(convertIdent(language.image));
+                      if (pred == null) {
+                          {if (true) return d;}
+                      } else {
+                          {if (true) return conditionFactory.createAndCondition(pred, d);}
+                      }
+                  } else {
+                      {if (true) throw new CSSParseException("invalid pseudo function name "
+                                                  + f, getLocator());}
+                  }
+      break;
+    default:
+      jj_la1[87] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public Condition hash(Condition pred) throws ParseException {
+ Token n;
+    n = jj_consume_token(HASH);
+      Condition d =
+          conditionFactory.createIdCondition(n.image.substring(1));
+      if (pred == null) {
+          {if (true) return d;}
+      } else {
+          {if (true) return conditionFactory.createAndCondition(pred, d);}
+      }
+    throw new Error("Missing return statement in function");
+  }
+
+  final public void variable() throws ParseException {
+        String name;
+        LexicalUnit exp = null;
+        boolean guarded = false;
+        String raw;
+    try {
+      name = variableName();
+      jj_consume_token(COLON);
+      label_58:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[88] = jj_gen;
+          break label_58;
+        }
+        jj_consume_token(S);
+      }
+      exp = expr();
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case GUARDED_SYM:
+        guarded = guarded();
+        break;
+      default:
+        jj_la1[89] = jj_gen;
+        ;
+      }
+      label_59:
+      while (true) {
+        jj_consume_token(SEMICOLON);
+        label_60:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case S:
+            ;
+            break;
+          default:
+            jj_la1[90] = jj_gen;
+            break label_60;
+          }
+          jj_consume_token(S);
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case SEMICOLON:
+          ;
+          break;
+        default:
+          jj_la1[91] = jj_gen;
+          break label_59;
+        }
+      }
+                    documentHandler.variable(name, exp, guarded);
+    } catch (JumpException e) {
+            skipAfterExpression();
+    } catch (NumberFormatException e) {
+            if (errorHandler != null) {
+                errorHandler.error(new CSSParseException("Invalid number "
+                                                  + e.getMessage(),
+                                                  getLocator(),
+                                                  e));
+            }
+            reportWarningSkipText(getLocator(), skipAfterExpression());
+    } catch (ParseException e) {
+            if (errorHandler != null) {
+                if (e.currentToken != null) {
+                        LocatorImpl li = new LocatorImpl(this,
+                                                      e.currentToken.next.beginLine,
+                                                      e.currentToken.next.beginColumn-1);
+                        reportError(li, e);
+                } else {
+                        reportError(getLocator(), e);
+            }
+                skipAfterExpression();
+            } else {
+                skipAfterExpression();
+            }
+    }
+  }
+
+  final public void eachDirective() throws ParseException {
+  Token var;
+  ArrayList<String> list;
+    jj_consume_token(EACH_SYM);
+    label_61:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[92] = jj_gen;
+        break label_61;
+      }
+      jj_consume_token(S);
+    }
+    var = jj_consume_token(VARIABLE);
+    label_62:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[93] = jj_gen;
+        break label_62;
+      }
+      jj_consume_token(S);
+    }
+    jj_consume_token(EACH_IN);
+    label_63:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[94] = jj_gen;
+        break label_63;
+      }
+      jj_consume_token(S);
+    }
+    list = stringList();
+    jj_consume_token(LBRACE);
+    label_64:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[95] = jj_gen;
+        break label_64;
+      }
+      jj_consume_token(S);
+    }
+    documentHandler.startEachDirective(var.image, list);
+    label_65:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case LBRACKET:
+      case ANY:
+      case PARENT:
+      case DOT:
+      case COLON:
+      case EACH_VAR:
+      case INCLUDE_SYM:
+      case EXTEND_SYM:
+      case IDENT:
+      case VARIABLE:
+      case HASH:
+      case MEDIA_SYM:
+        ;
+        break;
+      default:
+        jj_la1[96] = jj_gen;
+        break label_65;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case INCLUDE_SYM:
+        includeDirective();
+        break;
+      case MEDIA_SYM:
+        media();
+        break;
+      case EXTEND_SYM:
+        extendDirective();
+        break;
+      case VARIABLE:
+        variable();
+        break;
+      default:
+        jj_la1[97] = jj_gen;
+        if (jj_2_3(3)) {
+          declarationOrNestedProperties();
+        } else {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case LBRACKET:
+          case ANY:
+          case PARENT:
+          case DOT:
+          case COLON:
+          case EACH_VAR:
+          case IDENT:
+          case HASH:
+            styleRule();
+            break;
+          default:
+            jj_la1[98] = jj_gen;
+            jj_consume_token(-1);
+            throw new ParseException();
+          }
+        }
+      }
+    }
+    jj_consume_token(RBRACE);
+    label_66:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[99] = jj_gen;
+        break label_66;
+      }
+      jj_consume_token(S);
+    }
+    documentHandler.endEachDirective();
+  }
+
+  final public ArrayList<String > stringList() throws ParseException {
+        ArrayList<String > strings = new ArrayList<String >();
+        Token input;
+    input = jj_consume_token(IDENT);
+    label_67:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[100] = jj_gen;
+        break label_67;
+      }
+      jj_consume_token(S);
+    }
+          strings.add(input.image);
+    label_68:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case COMMA:
+        ;
+        break;
+      default:
+        jj_la1[101] = jj_gen;
+        break label_68;
+      }
+      jj_consume_token(COMMA);
+      label_69:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[102] = jj_gen;
+          break label_69;
+        }
+        jj_consume_token(S);
+      }
+      input = jj_consume_token(IDENT);
+                                               strings.add(input.image);
+      label_70:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[103] = jj_gen;
+          break label_70;
+        }
+        jj_consume_token(S);
+      }
+    }
+          {if (true) return strings;}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public void mixinDirective() throws ParseException {
+    String name;
+    ArrayList<VariableNode> args = null;
+    String body;
+    jj_consume_token(MIXIN_SYM);
+    label_71:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[104] = jj_gen;
+        break label_71;
+      }
+      jj_consume_token(S);
+    }
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case IDENT:
+      name = property();
+      break;
+    case FUNCTION:
+      name = functionName();
+      args = arglist();
+      jj_consume_token(RPARAN);
+      label_72:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[105] = jj_gen;
+          break label_72;
+        }
+        jj_consume_token(S);
+      }
+      break;
+    default:
+      jj_la1[106] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+    jj_consume_token(LBRACE);
+    label_73:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[107] = jj_gen;
+        break label_73;
+      }
+      jj_consume_token(S);
+    }
+     documentHandler.startMixinDirective(name, args);
+    label_74:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case LBRACKET:
+      case ANY:
+      case PARENT:
+      case DOT:
+      case COLON:
+      case EACH_VAR:
+      case INCLUDE_SYM:
+      case EXTEND_SYM:
+      case IDENT:
+      case VARIABLE:
+      case HASH:
+      case MEDIA_SYM:
+        ;
+        break;
+      default:
+        jj_la1[108] = jj_gen;
+        break label_74;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case INCLUDE_SYM:
+        includeDirective();
+        break;
+      case MEDIA_SYM:
+        media();
+        break;
+      case EXTEND_SYM:
+        extendDirective();
+        break;
+      case VARIABLE:
+        variable();
+        break;
+      default:
+        jj_la1[109] = jj_gen;
+        if (jj_2_4(3)) {
+          declarationOrNestedProperties();
+        } else {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case LBRACKET:
+          case ANY:
+          case PARENT:
+          case DOT:
+          case COLON:
+          case EACH_VAR:
+          case IDENT:
+          case HASH:
+            styleRule();
+            break;
+          default:
+            jj_la1[110] = jj_gen;
+            jj_consume_token(-1);
+            throw new ParseException();
+          }
+        }
+      }
+    }
+    jj_consume_token(RBRACE);
+    label_75:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[111] = jj_gen;
+        break label_75;
+      }
+      jj_consume_token(S);
+    }
+     documentHandler.endMixinDirective(name, args);
+  }
+
+  final public ArrayList<VariableNode> arglist() throws ParseException {
+    ArrayList<VariableNode> args = new ArrayList<VariableNode>();
+    VariableNode arg;
+    arg = mixinArg();
+    label_76:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case COMMA:
+        ;
+        break;
+      default:
+        jj_la1[112] = jj_gen;
+        break label_76;
+      }
+      jj_consume_token(COMMA);
+      label_77:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[113] = jj_gen;
+          break label_77;
+        }
+        jj_consume_token(S);
+      }
+                                      args.add(arg);
+      arg = mixinArg();
+    }
+      args.add(arg);
+        {if (true) return args;}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public VariableNode mixinArg() throws ParseException {
+    String name;
+    LexicalUnit value = null;
+    name = variableName();
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case COLON:
+      jj_consume_token(COLON);
+      label_78:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[114] = jj_gen;
+          break label_78;
+        }
+        jj_consume_token(S);
+      }
+      value = term(null);
+      break;
+    default:
+      jj_la1[115] = jj_gen;
+      ;
+    }
+        VariableNode arg = new VariableNode(name, value, false);
+        {if (true) return arg;}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public ArrayList<LexicalUnit> argValuelist() throws ParseException {
+    ArrayList<LexicalUnit> args = new ArrayList<LexicalUnit>();
+    LexicalUnit argValue;
+    argValue = term(null);
+                           args.add(argValue);
+    label_79:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case COMMA:
+        ;
+        break;
+      default:
+        jj_la1[116] = jj_gen;
+        break label_79;
+      }
+      jj_consume_token(COMMA);
+      label_80:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[117] = jj_gen;
+          break label_80;
+        }
+        jj_consume_token(S);
+      }
+      argValue = term(null);
+       args.add(argValue);
+    }
+     {if (true) return args;}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public void includeDirective() throws ParseException {
+    String name;
+    ArrayList<LexicalUnit> args=null;
+    jj_consume_token(INCLUDE_SYM);
+    label_81:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[118] = jj_gen;
+        break label_81;
+      }
+      jj_consume_token(S);
+    }
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case IDENT:
+      name = property();
+      break;
+    case FUNCTION:
+      name = functionName();
+      args = argValuelist();
+      jj_consume_token(RPARAN);
+      break;
+    default:
+      jj_la1[119] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+    label_82:
+    while (true) {
+      jj_consume_token(SEMICOLON);
+      label_83:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[120] = jj_gen;
+          break label_83;
+        }
+        jj_consume_token(S);
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case SEMICOLON:
+        ;
+        break;
+      default:
+        jj_la1[121] = jj_gen;
+        break label_82;
+      }
+    }
+            documentHandler.includeDirective(name, args);
+  }
+
+  final public Node functionDirective() throws ParseException {
+    String name;
+    String args = null;
+    String body;
+    int[] stops = {RPARAN};
+    name = functionName();
+    args = skipStatementUntilRightParan();
+    jj_consume_token(RPARAN);
+    label_84:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[122] = jj_gen;
+        break label_84;
+      }
+      jj_consume_token(S);
+    }
+    body = skipStatement();
+        {if (true) return null;}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public Node returnDirective() throws ParseException {
+    String raw;
+    raw = skipStatement();
+         {if (true) return null;}
+    throw new Error("Missing return statement in function");
+  }
+
+  void debugDirective() throws ParseException {
+  }
+
+  void warnDirective() throws ParseException {
+  }
+
+  final public Node forDirective() throws ParseException {
+    String var;
+    String from;
+    String to;
+    boolean exclusive;
+    String body;
+    Token tok;
+    var = variableName();
+        int[] toThrough = {TO, THROUGH};
+        from = skipStatementUntil(toThrough);
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case TO:
+      tok = jj_consume_token(TO);
+                 exclusive = true;
+      break;
+    case THROUGH:
+      tok = jj_consume_token(THROUGH);
+                       exclusive = false;
+      break;
+    default:
+      jj_la1[123] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+    to = skipStatementUntilLeftBrace();
+    label_85:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[124] = jj_gen;
+        break label_85;
+      }
+      jj_consume_token(S);
+    }
+    body = skipStatement();
+     {if (true) return documentHandler.forDirective(var, from, to, exclusive, body);}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public Node whileDirective() throws ParseException {
+    String condition;
+    String body;
+    condition = skipStatementUntilLeftBrace();
+    body = skipStatement();
+        {if (true) return documentHandler.whileDirective(condition, body);}
+    throw new Error("Missing return statement in function");
+  }
+
+  Node ifDirective() throws ParseException {
+    return documentHandler.ifDirective();
+  }
+
+  void elseDirective() throws ParseException {
+  }
+
+  final public void extendDirective() throws ParseException {
+ SelectorList list;
+    jj_consume_token(EXTEND_SYM);
+    label_86:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[125] = jj_gen;
+        break label_86;
+      }
+      jj_consume_token(S);
+    }
+    list = selectorList();
+    label_87:
+    while (true) {
+      jj_consume_token(SEMICOLON);
+      label_88:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[126] = jj_gen;
+          break label_88;
+        }
+        jj_consume_token(S);
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case SEMICOLON:
+        ;
+        break;
+      default:
+        jj_la1[127] = jj_gen;
+        break label_87;
+      }
+    }
+     documentHandler.extendDirective(list);
+  }
+
+  Node importDirective() throws ParseException {
+    return null;
+  }
+
+  Node charsetDirective() throws ParseException {
+    return null;
+  }
+
+  Node mozDocumentDirective() throws ParseException {
+    return null;
+  }
+
+  Node supportsDirective() throws ParseException {
+    return null;
+  }
+
+  final public void nestedProperties() throws ParseException {
+ String name;
+LexicalUnit exp;
+    name = property();
+    jj_consume_token(COLON);
+    label_89:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[128] = jj_gen;
+        break label_89;
+      }
+      jj_consume_token(S);
+    }
+    jj_consume_token(LBRACE);
+    label_90:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[129] = jj_gen;
+        break label_90;
+      }
+      jj_consume_token(S);
+    }
+      documentHandler.startNestedProperties(name);
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case IDENT:
+      declaration();
+      break;
+    default:
+      jj_la1[130] = jj_gen;
+      ;
+    }
+    label_91:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case SEMICOLON:
+        ;
+        break;
+      default:
+        jj_la1[131] = jj_gen;
+        break label_91;
+      }
+      jj_consume_token(SEMICOLON);
+      label_92:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[132] = jj_gen;
+          break label_92;
+        }
+        jj_consume_token(S);
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENT:
+        declaration();
+        break;
+      default:
+        jj_la1[133] = jj_gen;
+        ;
+      }
+    }
+    jj_consume_token(RBRACE);
+      documentHandler.endNestedProperties(name);
+    label_93:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[134] = jj_gen;
+        break label_93;
+      }
+      jj_consume_token(S);
+    }
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public void declarationOrNestedProperties() throws ParseException {
+  boolean important = false;
+  String name;
+  LexicalUnit exp;
+  Token save;
+  String comment = null;
+    try {
+      name = property();
+       save = token;
+      jj_consume_token(COLON);
+      label_94:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[135] = jj_gen;
+          break label_94;
+        }
+        jj_consume_token(S);
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case PLUS:
+      case MINUS:
+      case STRING:
+      case IDENT:
+      case NUMBER:
+      case URL:
+      case VARIABLE:
+      case PERCENTAGE:
+      case PT:
+      case MM:
+      case CM:
+      case PC:
+      case IN:
+      case PX:
+      case EMS:
+      case EXS:
+      case DEG:
+      case RAD:
+      case GRAD:
+      case MS:
+      case SECOND:
+      case HZ:
+      case KHZ:
+      case DIMEN:
+      case HASH:
+      case UNICODERANGE:
+      case FUNCTION:
+        exp = expr();
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case IMPORTANT_SYM:
+          important = prio();
+          break;
+        default:
+          jj_la1[136] = jj_gen;
+          ;
+        }
+         Token next = getToken(1);
+         if(next.kind == SEMICOLON || next.kind == RBRACE){
+             while(next.kind == SEMICOLON){
+                 skipStatement();
+                 next = getToken(1);
+             }
+             if(token.specialToken!=null){
+                 documentHandler.property(name, exp, important, token.specialToken.image);
+             }else{
+                 documentHandler.property(name, exp, important, null);
+             }
+         }
+        break;
+      case LBRACE:
+        jj_consume_token(LBRACE);
+        label_95:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case S:
+            ;
+            break;
+          default:
+            jj_la1[137] = jj_gen;
+            break label_95;
+          }
+          jj_consume_token(S);
+        }
+         documentHandler.startNestedProperties(name);
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case IDENT:
+          declaration();
+          break;
+        default:
+          jj_la1[138] = jj_gen;
+          ;
+        }
+        label_96:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case SEMICOLON:
+            ;
+            break;
+          default:
+            jj_la1[139] = jj_gen;
+            break label_96;
+          }
+          jj_consume_token(SEMICOLON);
+          label_97:
+          while (true) {
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case S:
+              ;
+              break;
+            default:
+              jj_la1[140] = jj_gen;
+              break label_97;
+            }
+            jj_consume_token(S);
+          }
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case IDENT:
+            declaration();
+            break;
+          default:
+            jj_la1[141] = jj_gen;
+            ;
+          }
+        }
+        jj_consume_token(RBRACE);
+        label_98:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case S:
+            ;
+            break;
+          default:
+            jj_la1[142] = jj_gen;
+            break label_98;
+          }
+          jj_consume_token(S);
+        }
+         documentHandler.endNestedProperties(name);
+        break;
+      default:
+        jj_la1[143] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } catch (JumpException e) {
+     skipAfterExpression();
+     // reportWarningSkipText(getLocator(), skipAfterExpression());
+
+    } catch (NumberFormatException e) {
+     if (errorHandler != null) {
+         errorHandler.error(new CSSParseException("Invalid number "
+                                                  + e.getMessage(),
+                                                  getLocator(),
+                                                  e));
+     }
+     reportWarningSkipText(getLocator(), skipAfterExpression());
+    } catch (ParseException e) {
+     if (errorHandler != null) {
+         if (e.currentToken != null) {
+             LocatorImpl li = new LocatorImpl(this,
+                                              e.currentToken.next.beginLine,
+                                              e.currentToken.next.beginColumn-1);
+             reportError(li, e);
+         } else {
+             reportError(getLocator(), e);
+         }
+         skipAfterExpression();
+         /*
+         LocatorImpl loc = (LocatorImpl) getLocator();
+         loc.column--;
+         reportWarningSkipText(loc, skipAfterExpression());
+         */
+     } else {
+         skipAfterExpression();
+     }
+    }
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public void declaration() throws ParseException {
+  boolean important = false;
+  String name;
+  LexicalUnit exp;
+  Token save;
+    try {
+      name = property();
+       save = token;
+      jj_consume_token(COLON);
+      label_99:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[144] = jj_gen;
+          break label_99;
+        }
+        jj_consume_token(S);
+      }
+      exp = expr();
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IMPORTANT_SYM:
+        important = prio();
+        break;
+      default:
+        jj_la1[145] = jj_gen;
+        ;
+      }
+         documentHandler.property(name, exp, important);
+    } catch (JumpException e) {
+     skipAfterExpression();
+     // reportWarningSkipText(getLocator(), skipAfterExpression());
+
+    } catch (NumberFormatException e) {
+     if (errorHandler != null) {
+         errorHandler.error(new CSSParseException("Invalid number "
+                                                  + e.getMessage(),
+                                                  getLocator(),
+                                                  e));
+     }
+     reportWarningSkipText(getLocator(), skipAfterExpression());
+    } catch (ParseException e) {
+     if (errorHandler != null) {
+         if (e.currentToken != null) {
+             LocatorImpl li = new LocatorImpl(this,
+                                              e.currentToken.next.beginLine,
+                                              e.currentToken.next.beginColumn-1);
+             reportError(li, e);
+         } else {
+             reportError(getLocator(), e);
+         }
+         skipAfterExpression();
+         /*
+	 LocatorImpl loc = (LocatorImpl) getLocator();
+	 loc.column--;
+	 reportWarningSkipText(loc, skipAfterExpression());
+	 */
+     } else {
+         skipAfterExpression();
+     }
+    }
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public boolean prio() throws ParseException {
+    jj_consume_token(IMPORTANT_SYM);
+    label_100:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[146] = jj_gen;
+        break label_100;
+      }
+      jj_consume_token(S);
+    }
+                             {if (true) return true;}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public boolean guarded() throws ParseException {
+    jj_consume_token(GUARDED_SYM);
+    label_101:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[147] = jj_gen;
+        break label_101;
+      }
+      jj_consume_token(S);
+    }
+                          {if (true) return true;}
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public LexicalUnitImpl operator(LexicalUnitImpl prev) throws ParseException {
+ Token n;
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case DIV:
+      n = jj_consume_token(DIV);
+      label_102:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[148] = jj_gen;
+          break label_102;
+        }
+        jj_consume_token(S);
+      }
+                 {if (true) return LexicalUnitImpl.createSlash(n.beginLine,
+                                                       n.beginColumn,
+                                                       prev);}
+      break;
+    case COMMA:
+      n = jj_consume_token(COMMA);
+      label_103:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[149] = jj_gen;
+          break label_103;
+        }
+        jj_consume_token(S);
+      }
+                   {if (true) return LexicalUnitImpl.createComma(n.beginLine,
+                                                         n.beginColumn,
+                                                         prev);}
+      break;
+    default:
+      jj_la1[150] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public LexicalUnit expr() throws ParseException {
+    LexicalUnitImpl first, res;
+    char op;
+    first = term(null);
+                      res = first;
+    label_104:
+    while (true) {
+      if (jj_2_5(2)) {
+        ;
+      } else {
+        break label_104;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case COMMA:
+      case DIV:
+        res = operator(res);
+        break;
+      default:
+        jj_la1[151] = jj_gen;
+        ;
+      }
+      res = term(res);
+    }
+    {if (true) return first;}
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public char unaryOperator() throws ParseException {
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case MINUS:
+      jj_consume_token(MINUS);
+        {if (true) return '-';}
+      break;
+    case PLUS:
+      jj_consume_token(PLUS);
+        {if (true) return '+';}
+      break;
+    default:
+      jj_la1[152] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public LexicalUnitImpl term(LexicalUnitImpl prev) throws ParseException {
+  LexicalUnitImpl result = null;
+  Token n = null;
+  char op = ' ';
+  String varName;
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case PLUS:
+    case MINUS:
+    case STRING:
+    case IDENT:
+    case NUMBER:
+    case URL:
+    case PERCENTAGE:
+    case PT:
+    case MM:
+    case CM:
+    case PC:
+    case IN:
+    case PX:
+    case EMS:
+    case EXS:
+    case DEG:
+    case RAD:
+    case GRAD:
+    case MS:
+    case SECOND:
+    case HZ:
+    case KHZ:
+    case DIMEN:
+    case HASH:
+    case UNICODERANGE:
+    case FUNCTION:
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case PLUS:
+      case MINUS:
+      case NUMBER:
+      case PERCENTAGE:
+      case PT:
+      case MM:
+      case CM:
+      case PC:
+      case IN:
+      case PX:
+      case EMS:
+      case EXS:
+      case DEG:
+      case RAD:
+      case GRAD:
+      case MS:
+      case SECOND:
+      case HZ:
+      case KHZ:
+      case DIMEN:
+      case FUNCTION:
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case PLUS:
+        case MINUS:
+          op = unaryOperator();
+          break;
+        default:
+          jj_la1[153] = jj_gen;
+          ;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case NUMBER:
+          n = jj_consume_token(NUMBER);
+          result = LexicalUnitImpl.createNumber(n.beginLine, n.beginColumn,
+                                                prev, number(op, n, 0));
+          break;
+        case PERCENTAGE:
+          n = jj_consume_token(PERCENTAGE);
+          result = LexicalUnitImpl.createPercentage(n.beginLine, n.beginColumn,
+                                                    prev, number(op, n, 1));
+          break;
+        case PT:
+          n = jj_consume_token(PT);
+          result = LexicalUnitImpl.createPT(n.beginLine, n.beginColumn,
+                                            prev, number(op, n, 2));
+          break;
+        case CM:
+          n = jj_consume_token(CM);
+          result = LexicalUnitImpl.createCM(n.beginLine, n.beginColumn,
+                                            prev, number(op, n, 2));
+          break;
+        case MM:
+          n = jj_consume_token(MM);
+          result = LexicalUnitImpl.createMM(n.beginLine, n.beginColumn,
+                                            prev, number(op, n, 2));
+          break;
+        case PC:
+          n = jj_consume_token(PC);
+          result = LexicalUnitImpl.createPC(n.beginLine, n.beginColumn,
+                                            prev, number(op, n, 2));
+          break;
+        case IN:
+          n = jj_consume_token(IN);
+          result = LexicalUnitImpl.createIN(n.beginLine, n.beginColumn,
+                                            prev, number(op, n, 2));
+          break;
+        case PX:
+          n = jj_consume_token(PX);
+          result = LexicalUnitImpl.createPX(n.beginLine, n.beginColumn,
+                                            prev, number(op, n, 2));
+          break;
+        case EMS:
+          n = jj_consume_token(EMS);
+          result = LexicalUnitImpl.createEMS(n.beginLine, n.beginColumn,
+                                             prev, number(op, n, 2));
+          break;
+        case EXS:
+          n = jj_consume_token(EXS);
+          result = LexicalUnitImpl.createEXS(n.beginLine, n.beginColumn,
+                                             prev, number(op, n, 2));
+          break;
+        case DEG:
+          n = jj_consume_token(DEG);
+          result = LexicalUnitImpl.createDEG(n.beginLine, n.beginColumn,
+                                             prev, number(op, n, 3));
+          break;
+        case RAD:
+          n = jj_consume_token(RAD);
+          result = LexicalUnitImpl.createRAD(n.beginLine, n.beginColumn,
+                                             prev, number(op, n, 3));
+          break;
+        case GRAD:
+          n = jj_consume_token(GRAD);
+          result = LexicalUnitImpl.createGRAD(n.beginLine, n.beginColumn,
+                                              prev, number(op, n, 3));
+          break;
+        case SECOND:
+          n = jj_consume_token(SECOND);
+          result = LexicalUnitImpl.createS(n.beginLine, n.beginColumn,
+                                           prev, number(op, n, 1));
+          break;
+        case MS:
+          n = jj_consume_token(MS);
+          result = LexicalUnitImpl.createMS(n.beginLine, n.beginColumn,
+                                            prev, number(op, n, 2));
+          break;
+        case HZ:
+          n = jj_consume_token(HZ);
+          result = LexicalUnitImpl.createHZ(n.beginLine, n.beginColumn,
+                                            prev, number(op, n, 2));
+          break;
+        case KHZ:
+          n = jj_consume_token(KHZ);
+          result = LexicalUnitImpl.createKHZ(n.beginLine, n.beginColumn,
+                                             prev, number(op, n, 3));
+          break;
+        case DIMEN:
+          n = jj_consume_token(DIMEN);
+            String s = n.image;
+            int i = 0;
+            while (i < s.length()
+                   && (Character.isDigit(s.charAt(i)) || (s.charAt(i) == '.'))) {
+                i++;
+            }
+            result = LexicalUnitImpl.createDimen(n.beginLine, n.beginColumn, prev,
+                                                 Float.valueOf(s.substring(0, i)).floatValue(),
+                                                 s.substring(i));
+          break;
+        case FUNCTION:
+          result = function(op, prev);
+          break;
+        default:
+          jj_la1[154] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        break;
+      case STRING:
+      case IDENT:
+      case URL:
+      case HASH:
+      case UNICODERANGE:
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case STRING:
+          n = jj_consume_token(STRING);
+          result =
+          LexicalUnitImpl.createString(n.beginLine, n.beginColumn, prev,
+                                       convertStringIndex(n.image, 1,
+                                                          n.image.length() -1));
+          break;
+        case IDENT:
+          n = jj_consume_token(IDENT);
+        String s = convertIdent(n.image);
+        if ("inherit".equals(s)) {
+            result = LexicalUnitImpl.createInherit(n.beginLine, n.beginColumn,
+                                               prev);
+        } else {
+            result = LexicalUnitImpl.createIdent(n.beginLine, n.beginColumn,
+                                               prev, convertIdent(n.image));
+        }
+
+          /* /
+         Auto correction code used in the CSS Validator but must not
+          be used by a conformant CSS2 parser.
+	 * Common error :
+	 * H1 {
+	 *   color : black
+	 *   background : white
+	 * }
+	 *
+	Token t = getToken(1);
+	Token semicolon = new Token();
+	semicolon.kind = SEMICOLON;
+	semicolon.image = ";";
+	if (t.kind == COLON) {
+	    // @@SEEME. (generate a warning?)
+	    // @@SEEME if expression is a single ident, 
+	       generate an error ?
+	    rejectToken(semicolon);
+	    
+	    result = prev;
+	}
+	/ */
+
+          break;
+        case HASH:
+          result = hexcolor(prev);
+          break;
+        case URL:
+          result = url(prev);
+          break;
+        case UNICODERANGE:
+          result = unicode(prev);
+          break;
+        default:
+          jj_la1[155] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        break;
+      default:
+        jj_la1[156] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      label_105:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[157] = jj_gen;
+          break label_105;
+        }
+        jj_consume_token(S);
+      }
+      break;
+    case VARIABLE:
+      varName = variableName();
+          result = LexicalUnitImpl.createVariable(token.beginLine, token.beginColumn,
+                 prev, varName);
+      break;
+    default:
+      jj_la1[158] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+          {if (true) return result;}
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * Handle all CSS2 functions.
+ * @exception ParseException exception during the parse
+ */
+  final public LexicalUnitImpl function(char operator, LexicalUnitImpl prev) throws ParseException {
+ Token n;
+ LexicalUnit params = null;
+    n = jj_consume_token(FUNCTION);
+    label_106:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[159] = jj_gen;
+        break label_106;
+      }
+      jj_consume_token(S);
+    }
+        String fname = convertIdent(n.image);
+        if("alpha(".equals(fname)){
+            String body = skipStatementUntilSemiColon();
+            {if (true) return LexicalUnitImpl.createIdent(n.beginLine, n.beginColumn,
+                 null, "alpha("+body);}
+        }
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case PLUS:
+    case MINUS:
+    case STRING:
+    case IDENT:
+    case NUMBER:
+    case URL:
+    case VARIABLE:
+    case PERCENTAGE:
+    case PT:
+    case MM:
+    case CM:
+    case PC:
+    case IN:
+    case PX:
+    case EMS:
+    case EXS:
+    case DEG:
+    case RAD:
+    case GRAD:
+    case MS:
+    case SECOND:
+    case HZ:
+    case KHZ:
+    case DIMEN:
+    case HASH:
+    case UNICODERANGE:
+    case FUNCTION:
+      params = expr();
+      break;
+    default:
+      jj_la1[160] = jj_gen;
+      ;
+    }
+    jj_consume_token(RPARAN);
+        if (operator != ' ') {
+            {if (true) throw new CSSParseException("invalid operator before a function.",
+                                        getLocator());}
+        }
+        String f = convertIdent(n.image);
+        LexicalUnitImpl l = (LexicalUnitImpl) params;
+        boolean loop = true;
+        if ("rgb(".equals(f)) {
+            // this is a RGB declaration (e.g. rgb(255, 50%, 0) )
+            int i = 0;
+            while (loop && l != null && i < 5) {
+                switch (i) {
+                    case 0:
+                    case 2:
+                    case 4:
+                        if ((l.getLexicalUnitType() != LexicalUnit.SAC_INTEGER)
+                            && (l.getLexicalUnitType() != LexicalUnit.SAC_PERCENTAGE)) {
+                            loop = false;
+                        }
+                        break;
+                    case 1:
+                    case 3:
+                        if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) {
+                            loop = false;
+                        }
+                        break;
+                    default:
+                        {if (true) throw new ParseException("implementation error");}
+                }
+                if (loop) {
+                    l = (LexicalUnitImpl) l.getNextLexicalUnit();
+                    i ++;
+                }
+            }
+            if ((i == 5) && loop && (l == null)) {
+                {if (true) return LexicalUnitImpl.createRGBColor(n.beginLine,
+                                                      n.beginColumn,
+                                                      prev, params);}
+            } else {
+                if (errorHandler != null) {
+                    String errorText;
+                    Locator loc;
+                    if (i < 5) {
+                        if (params == null) {
+                            loc = new LocatorImpl(this, n.beginLine,
+                                                  n.beginColumn-1);
+                            errorText = "not enough parameters.";
+                        } else if (l == null) {
+                            loc = new LocatorImpl(this, n.beginLine,
+                                                  n.beginColumn-1);
+                            errorText = "not enough parameters: "
+                                + params.toString();
+                        } else {
+                            loc = new LocatorImpl(this, l.getLineNumber(),
+                                                  l.getColumnNumber());
+                            errorText = "invalid parameter: "
+                                + l.toString();
+                        }
+                    } else {
+                        loc = new LocatorImpl(this, l.getLineNumber(),
+                                              l.getColumnNumber());
+                        errorText = "too many parameters: "
+                            + l.toString();
+                    }
+                    errorHandler.error(new CSSParseException(errorText, loc));
+                }
+
+                {if (true) throw new JumpException();}
+            }
+        } else if ("counter".equals(f)) {
+            int i = 0;
+            while (loop && l != null && i < 3) {
+                switch (i) {
+                    case 0:
+                    case 2:
+                        if (l.getLexicalUnitType() != LexicalUnit.SAC_IDENT) {
+                            loop = false;
+                        }
+                        break;
+                    case 1:
+                        if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) {
+                            loop = false;
+                        }
+                        break;
+                    default:
+                        {if (true) throw new ParseException("implementation error");}
+                }
+                l = (LexicalUnitImpl) l.getNextLexicalUnit();
+                i ++;
+            }
+            if (((i == 1) || (i == 3)) && loop && (l == null)) {
+                {if (true) return LexicalUnitImpl.createCounter(n.beginLine, n.beginColumn,
+                                                     prev, params);}
+            }
+
+        } else if ("counters(".equals(f)) {
+
+            int i = 0;
+            while (loop && l != null && i < 5) {
+                switch (i) {
+                    case 0:
+                    case 4:
+                        if (l.getLexicalUnitType() != LexicalUnit.SAC_IDENT) {
+                            loop = false;
+                        }
+                        break;
+                    case 2:
+                        if (l.getLexicalUnitType() != LexicalUnit.SAC_STRING_VALUE) {
+                            loop = false;
+                        }
+                        break;
+                    case 1:
+                    case 3:
+                        if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) {
+                            loop = false;
+                        }
+                        break;
+                    default:
+                        {if (true) throw new ParseException("implementation error");}
+                }
+                l = (LexicalUnitImpl) l.getNextLexicalUnit();
+                i ++;
+            }
+            if (((i == 3) || (i == 5)) && loop && (l == null)) {
+                {if (true) return LexicalUnitImpl.createCounters(n.beginLine, n.beginColumn,
+                                                      prev, params);}
+            }
+        } else if ("attr(".equals(f)) {
+            if ((l != null)
+                && (l.getNextLexicalUnit() == null)
+                && (l.getLexicalUnitType() == LexicalUnit.SAC_IDENT)) {
+                {if (true) return LexicalUnitImpl.createAttr(l.getLineNumber(),
+                                                  l.getColumnNumber(),
+                                                  prev, l.getStringValue());}
+            }
+        } else if ("rect(".equals(f)) {
+            int i = 0;
+            while (loop && l != null && i < 7) {
+                switch (i) {
+                    case 0:
+                    case 2:
+                    case 4:
+                    case 6:
+                        switch (l.getLexicalUnitType()) {
+                        case LexicalUnit.SAC_INTEGER:
+                            if (l.getIntegerValue() != 0) {
+                                loop = false;
+                            }
+                            break;
+                        case LexicalUnit.SAC_IDENT:
+                            if (!l.getStringValue().equals("auto")) {
+                                loop = false;
+                            }
+                            break;
+                        case LexicalUnit.SAC_EM:
+                        case LexicalUnit.SAC_EX:
+                        case LexicalUnit.SAC_PIXEL:
+                        case LexicalUnit.SAC_CENTIMETER:
+                        case LexicalUnit.SAC_MILLIMETER:
+                        case LexicalUnit.SAC_INCH:
+                        case LexicalUnit.SAC_POINT:
+                        case LexicalUnit.SAC_PICA:
+                            // nothing
+                            break;
+                        default:
+                            loop = false;
+                        }
+                        break;
+                    case 1:
+                    case 3:
+                    case 5:
+                        if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) {
+                            loop = false;
+                        }
+                        break;
+                    default:
+                        {if (true) throw new ParseException("implementation error");}
+                }
+                l = (LexicalUnitImpl) l.getNextLexicalUnit();
+                i ++;
+            }
+            if ((i == 7) && loop && (l == null)) {
+                {if (true) return LexicalUnitImpl.createRect(n.beginLine, n.beginColumn,
+                                                  prev, params);}
+            }
+        }
+        {if (true) return LexicalUnitImpl.createFunction(n.beginLine, n.beginColumn, prev,
+                                              f.substring(0,
+                                                        f.length() -1),
+                                              params);}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public LexicalUnitImpl unicode(LexicalUnitImpl prev) throws ParseException {
+  Token n;
+    n = jj_consume_token(UNICODERANGE);
+     LexicalUnitImpl params = null;
+     String s = n.image.substring(2);
+     int index = s.indexOf('-');
+     if (index == -1) {
+         params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn,
+                                                params, Integer.parseInt(s, 16));
+     } else {
+         String s1 = s.substring(0, index);
+         String s2 = s.substring(index);
+
+         params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn,
+                                                params, Integer.parseInt(s1, 16));
+         params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn,
+                                                params, Integer.parseInt(s2, 16));
+     }
+
+     {if (true) return LexicalUnitImpl.createUnicodeRange(n.beginLine, n.beginColumn,
+                                               prev, params);}
+    throw new Error("Missing return statement in function");
+  }
+
+  final public LexicalUnitImpl url(LexicalUnitImpl prev) throws ParseException {
+  Token n;
+    n = jj_consume_token(URL);
+   String urlname = n.image.substring(4, n.image.length()-1).trim();
+   if (urlname.charAt(0) == '"'
+       || urlname.charAt(0) == '\u005c'') {
+       urlname = urlname.substring(1, urlname.length()-1);
+   }
+   {if (true) return LexicalUnitImpl.createURL(n.beginLine, n.beginColumn, prev, urlname);}
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * @exception ParseException exception during the parse
+ */
+  final public LexicalUnitImpl hexcolor(LexicalUnitImpl prev) throws ParseException {
+ Token n;
+    n = jj_consume_token(HASH);
+     int r;
+     LexicalUnitImpl first, params = null;
+     String s = n.image.substring(1);
+
+     if(s.length()!=3 && s.length()!=6) {
+         first = null;
+         {if (true) throw new CSSParseException("invalid hexadecimal notation for RGB: " + s,
+                                     getLocator());}
+     }
+     {if (true) return LexicalUnitImpl.createIdent(n.beginLine, n.beginColumn,
+             prev, n.image);}
+    throw new Error("Missing return statement in function");
+  }
+
+  float number(char operator, Token n, int lengthUnit) throws ParseException {
+    String image  = n.image;
+    float f = 0;
+
+    if (lengthUnit != 0) {
+        image = image.substring(0, image.length() - lengthUnit);
+    }
+    f = Float.valueOf(image).floatValue();
+    return (operator == '-')? -f: f;
+  }
+
+  String skipStatementUntilSemiColon() throws ParseException {
+    int[] semicolon = {SEMICOLON};
+    return skipStatementUntil(semicolon);
+  }
+
+  String skipStatementUntilLeftBrace() throws ParseException {
+    int[] lBrace = {LBRACE};
+    return skipStatementUntil(lBrace);
+  }
+
+  String skipStatementUntilRightParan() throws ParseException {
+    int[] rParan = {RPARAN};
+    return skipStatementUntil(rParan);
+  }
+
+  String skipStatementUntil(int[] symbols) throws ParseException {
+    StringBuffer s = new StringBuffer();
+    boolean stop = false;
+    Token tok;
+    while(!stop){
+        tok = getToken(1);
+        if(tok.kind == EOF) {
+            return null;
+        }
+        for(int sym : symbols){
+            if(tok.kind == sym){
+                stop = true;
+                break;
+            }
+        }
+        if(!stop){
+            if (tok.image != null) {
+                s.append(tok.image);
+            }
+            getNextToken();
+        }
+    }
+    return s.toString().trim();
+  }
+
+  String skipStatement() throws ParseException {
+    StringBuffer s = new StringBuffer();
+    Token tok = getToken(0);
+    if (tok.image != null) {
+        s.append(tok.image);
+    }
+    while (true) {
+        tok = getToken(1);
+        if (tok.kind == EOF) {
+            return null;
+        }
+        s.append(tok.image);
+        if (tok.kind == LBRACE) {
+            getNextToken();
+            s.append(skip_to_matching_brace());
+            getNextToken();
+            tok = getToken(1);
+            break;
+        } else if (tok.kind == RBRACE) {
+            getNextToken();
+            tok = getToken(1);
+            break;
+        } else if (tok.kind == SEMICOLON) {
+            getNextToken();
+            tok = getToken(1);
+            break;
+        }
+        getNextToken();
+    }
+
+    // skip white space
+    while (true) {
+        if (tok.kind != S) {
+            break;
+        }
+        tok = getNextToken();
+        tok = getToken(1);
+    }
+
+    return s.toString().trim();
+  }
+
+  String skip_to_matching_brace() throws ParseException {
+    StringBuffer s = new StringBuffer();
+    Token tok;
+    int nesting = 1;
+    while (true) {
+        tok = getToken(1);
+        if (tok.kind == EOF) {
+            break;
+        }
+        s.append(tok.image);
+        if (tok.kind == LBRACE) {
+            nesting++;
+        } else if (tok.kind == RBRACE) {
+            nesting--;
+            if (nesting == 0) {
+                break;
+            }
+        }
+        getNextToken();
+    }
+    return s.toString();
+  }
+
+  String convertStringIndex(String s, int start, int len) throws ParseException {
+    StringBuffer buf = new StringBuffer(len);
+    int index = start;
+
+    while (index < len) {
+        char c = s.charAt(index);
+        if (c == '\u005c\u005c') {
+            if (++index < len) {
+                c = s.charAt(index);
+                switch (c) {
+                case '0': case '1': case '2': case '3': case '4':
+                case '5': case '6': case '7': case '8': case '9':
+                case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+                case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+                    int numValue = Character.digit(c, 16);
+                    int count = 0;
+                    int p = 16;
+
+                    while (index + 1 < len && count < 6) {
+                        c = s.charAt(index+1);
+
+                        if (Character.digit(c, 16) != -1) {
+                            numValue = (numValue * 16) + Character.digit(c, 16);
+                            p *= 16;
+                            index++;
+                        } else {
+                            if (c == ' ') {
+                                // skip the latest white space
+                                index++;
+                            }
+                            break;
+                        }
+                    }
+                    buf.append((char) numValue);
+                    break;
+                case '\u005cn':
+                case '\u005cf':
+                    break;
+                case '\u005cr':
+                    if (index + 1 < len) {
+                        if (s.charAt(index + 1) == '\u005cn') {
+                            index ++;
+                        }
+                    }
+                    break;
+                default:
+                    buf.append(c);
+                }
+            } else {
+                throw new CSSParseException("invalid string " + s, getLocator());
+            }
+        } else {
+            buf.append(c);
+        }
+        index++;
+    }
+
+    return buf.toString();
+  }
+
+  String convertIdent(String s) throws ParseException {
+    return convertStringIndex(s, 0, s.length());
+  }
+
+  String convertString(String s) throws ParseException {
+    return convertStringIndex(s, 0, s.length());
+  }
+
+  void comments() throws ParseException {
+    if (token.specialToken != null){
+        Token tmp_t = token.specialToken;
+        while (tmp_t.specialToken != null) tmp_t = tmp_t.specialToken;
+        while (tmp_t != null) {
+            documentHandler.comment(tmp_t.image);
+            tmp_t = tmp_t.next;
+        }
+    }
+  }
+
+  void rejectToken(Token t) throws ParseException {
+    Token fakeToken = new Token();
+    t.next = token;
+    fakeToken.next = t;
+    token = fakeToken;
+  }
+
+  String skipAfterExpression() throws ParseException {
+    Token t = getToken(1);
+    StringBuffer s = new StringBuffer();
+    s.append(getToken(0).image);
+
+    while ((t.kind != RBRACE) && (t.kind != SEMICOLON) && (t.kind != EOF)) {
+        s.append(t.image);
+        getNextToken();
+        t = getToken(1);
+    }
+
+    return s.toString();
+  }
+
+/**
+ * The following functions are useful for a DOM CSS implementation only and are
+ * not part of the general CSS2 parser.
+ */
+  final public void _parseRule() throws ParseException {
+ String ret = null;
+    label_107:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[161] = jj_gen;
+        break label_107;
+      }
+      jj_consume_token(S);
+    }
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case IMPORT_SYM:
+      importDeclaration();
+      break;
+    case LBRACKET:
+    case ANY:
+    case PARENT:
+    case DOT:
+    case COLON:
+    case EACH_VAR:
+    case IDENT:
+    case HASH:
+      styleRule();
+      break;
+    case MEDIA_SYM:
+      media();
+      break;
+    case PAGE_SYM:
+      page();
+      break;
+    case FONT_FACE_SYM:
+      fontFace();
+      break;
+    default:
+      jj_la1[162] = jj_gen;
+      ret = skipStatement();
+                    if ((ret == null) || (ret.length() == 0)) {
+                        {if (true) return;}
+                    }
+                    if (ret.charAt(0) == '@') {
+                        documentHandler.ignorableAtRule(ret);
+                    } else {
+                        {if (true) throw new CSSParseException("unrecognize rule: " + ret,
+                                                    getLocator());}
+                    }
+    }
+  }
+
+  final public void _parseImportRule() throws ParseException {
+    label_108:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[163] = jj_gen;
+        break label_108;
+      }
+      jj_consume_token(S);
+    }
+    importDeclaration();
+  }
+
+  final public void _parseMediaRule() throws ParseException {
+    label_109:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[164] = jj_gen;
+        break label_109;
+      }
+      jj_consume_token(S);
+    }
+    media();
+  }
+
+  final public void _parseDeclarationBlock() throws ParseException {
+    label_110:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case S:
+        ;
+        break;
+      default:
+        jj_la1[165] = jj_gen;
+        break label_110;
+      }
+      jj_consume_token(S);
+    }
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case IDENT:
+      declaration();
+      break;
+    default:
+      jj_la1[166] = jj_gen;
+      ;
+    }
+    label_111:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case SEMICOLON:
+        ;
+        break;
+      default:
+        jj_la1[167] = jj_gen;
+        break label_111;
+      }
+      jj_consume_token(SEMICOLON);
+      label_112:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[168] = jj_gen;
+          break label_112;
+        }
+        jj_consume_token(S);
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENT:
+        declaration();
+        break;
+      default:
+        jj_la1[169] = jj_gen;
+        ;
+      }
+    }
+  }
+
+  final public SelectorList _parseSelectors() throws ParseException {
+  SelectorList p = null;
+    try {
+      label_113:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case S:
+          ;
+          break;
+        default:
+          jj_la1[170] = jj_gen;
+          break label_113;
+        }
+        jj_consume_token(S);
+      }
+      p = selectorList();
+          {if (true) return p;}
+    } catch (ThrowedParseException e) {
+        {if (true) throw (ParseException) e.e.fillInStackTrace();}
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+  private boolean jj_2_1(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_1(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(0, xla); }
+  }
+
+  private boolean jj_2_2(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_2(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(1, xla); }
+  }
+
+  private boolean jj_2_3(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_3(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(2, xla); }
+  }
+
+  private boolean jj_2_4(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_4(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(3, xla); }
+  }
+
+  private boolean jj_2_5(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_5(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(4, xla); }
+  }
+
+  private boolean jj_3R_180() {
+    if (jj_scan_token(UNICODERANGE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_185() {
+    if (jj_3R_133()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_177() {
+    if (jj_scan_token(FUNCTION)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_scan_token(1)) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_185()) jj_scanpos = xsp;
+    if (jj_scan_token(RPARAN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_132() {
+    if (jj_3R_144()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_129() {
+    if (jj_3R_139()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_174() {
+    if (jj_3R_180()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_128() {
+    if (jj_3R_138()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_173() {
+    if (jj_3R_179()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_172() {
+    if (jj_3R_178()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_127() {
+    if (jj_3R_137()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_126() {
+    if (jj_3R_136()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_125() {
+    if (jj_3R_135()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_136() {
+    if (jj_scan_token(HASH)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_116() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_125()) {
+    jj_scanpos = xsp;
+    if (jj_3R_126()) {
+    jj_scanpos = xsp;
+    if (jj_3R_127()) {
+    jj_scanpos = xsp;
+    if (jj_3R_128()) {
+    jj_scanpos = xsp;
+    if (jj_3R_129()) return true;
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3_1() {
+    if (jj_3R_114()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_171() {
+    if (jj_scan_token(IDENT)) return true;
+    return false;
+  }
+
+  private boolean jj_3_4() {
+    if (jj_3R_114()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_170() {
+    if (jj_scan_token(STRING)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_169() {
+    if (jj_3R_177()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_143() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_170()) {
+    jj_scanpos = xsp;
+    if (jj_3R_171()) {
+    jj_scanpos = xsp;
+    if (jj_3R_172()) {
+    jj_scanpos = xsp;
+    if (jj_3R_173()) {
+    jj_scanpos = xsp;
+    if (jj_3R_174()) return true;
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3_2() {
+    if (jj_3R_115()) return true;
+    if (jj_3R_116()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_138() {
+    if (jj_scan_token(COLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_168() {
+    if (jj_scan_token(DIMEN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_167() {
+    if (jj_scan_token(KHZ)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_166() {
+    if (jj_scan_token(HZ)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_165() {
+    if (jj_scan_token(MS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_164() {
+    if (jj_scan_token(SECOND)) return true;
+    return false;
+  }
+
+  private boolean jj_3_3() {
+    if (jj_3R_114()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_163() {
+    if (jj_scan_token(GRAD)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_162() {
+    if (jj_scan_token(RAD)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_121() {
+    if (jj_scan_token(LBRACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_161() {
+    if (jj_scan_token(DEG)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_160() {
+    if (jj_scan_token(EXS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_159() {
+    if (jj_scan_token(EMS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_158() {
+    if (jj_scan_token(PX)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_157() {
+    if (jj_scan_token(IN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_120() {
+    if (jj_3R_133()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_156() {
+    if (jj_scan_token(PC)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_155() {
+    if (jj_scan_token(MM)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_182() {
+    if (jj_scan_token(EACH_VAR)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_154() {
+    if (jj_scan_token(CM)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_114() {
+    if (jj_3R_119()) return true;
+    if (jj_scan_token(COLON)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_scan_token(1)) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_120()) {
+    jj_scanpos = xsp;
+    if (jj_3R_121()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_153() {
+    if (jj_scan_token(PT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_152() {
+    if (jj_scan_token(PERCENTAGE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_150() {
+    if (jj_3R_176()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_139() {
+    if (jj_scan_token(LBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_151() {
+    if (jj_scan_token(NUMBER)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_142() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_150()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_151()) {
+    jj_scanpos = xsp;
+    if (jj_3R_152()) {
+    jj_scanpos = xsp;
+    if (jj_3R_153()) {
+    jj_scanpos = xsp;
+    if (jj_3R_154()) {
+    jj_scanpos = xsp;
+    if (jj_3R_155()) {
+    jj_scanpos = xsp;
+    if (jj_3R_156()) {
+    jj_scanpos = xsp;
+    if (jj_3R_157()) {
+    jj_scanpos = xsp;
+    if (jj_3R_158()) {
+    jj_scanpos = xsp;
+    if (jj_3R_159()) {
+    jj_scanpos = xsp;
+    if (jj_3R_160()) {
+    jj_scanpos = xsp;
+    if (jj_3R_161()) {
+    jj_scanpos = xsp;
+    if (jj_3R_162()) {
+    jj_scanpos = xsp;
+    if (jj_3R_163()) {
+    jj_scanpos = xsp;
+    if (jj_3R_164()) {
+    jj_scanpos = xsp;
+    if (jj_3R_165()) {
+    jj_scanpos = xsp;
+    if (jj_3R_166()) {
+    jj_scanpos = xsp;
+    if (jj_3R_167()) {
+    jj_scanpos = xsp;
+    if (jj_3R_168()) {
+    jj_scanpos = xsp;
+    if (jj_3R_169()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_131() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_142()) {
+    jj_scanpos = xsp;
+    if (jj_3R_143()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_scan_token(1)) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_118() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_131()) {
+    jj_scanpos = xsp;
+    if (jj_3R_132()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_149() {
+    if (jj_scan_token(PARENT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_148() {
+    if (jj_scan_token(ANY)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_117() {
+    if (jj_3R_130()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_178() {
+    if (jj_scan_token(HASH)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_119() {
+    if (jj_scan_token(IDENT)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_scan_token(1)) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_144() {
+    if (jj_scan_token(VARIABLE)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_scan_token(1)) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_181() {
+    if (jj_scan_token(IDENT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_175() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_181()) {
+    jj_scanpos = xsp;
+    if (jj_3R_182()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_184() {
+    if (jj_scan_token(PLUS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_135() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_147()) {
+    jj_scanpos = xsp;
+    if (jj_3R_148()) {
+    jj_scanpos = xsp;
+    if (jj_3R_149()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_147() {
+    Token xsp;
+    if (jj_3R_175()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_175()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_183() {
+    if (jj_scan_token(MINUS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_176() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_183()) {
+    jj_scanpos = xsp;
+    if (jj_3R_184()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_146() {
+    if (jj_scan_token(PRECEDES)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_145() {
+    if (jj_scan_token(PLUS)) return true;
+    return false;
+  }
+
+  private boolean jj_3_5() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_117()) jj_scanpos = xsp;
+    if (jj_3R_118()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_134() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_145()) {
+    jj_scanpos = xsp;
+    if (jj_3R_146()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_179() {
+    if (jj_scan_token(URL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_133() {
+    if (jj_3R_118()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_123() {
+    if (jj_scan_token(PRECEDES)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_scan_token(1)) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_115() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_122()) {
+    jj_scanpos = xsp;
+    if (jj_3R_123()) {
+    jj_scanpos = xsp;
+    if (jj_3R_124()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_122() {
+    if (jj_scan_token(PLUS)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_scan_token(1)) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_124() {
+    if (jj_scan_token(S)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_134()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_137() {
+    if (jj_scan_token(DOT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_141() {
+    if (jj_scan_token(COMMA)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_scan_token(1)) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_140() {
+    if (jj_scan_token(DIV)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_scan_token(1)) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_130() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_140()) {
+    jj_scanpos = xsp;
+    if (jj_3R_141()) return true;
+    }
+    return false;
+  }
+
+  /** Generated Token Manager. */
+  public ParserTokenManager token_source;
+  /** Current token. */
+  public Token token;
+  /** Next token. */
+  public Token jj_nt;
+  private int jj_ntk;
+  private Token jj_scanpos, jj_lastpos;
+  private int jj_la;
+  private int jj_gen;
+  final private int[] jj_la1 = new int[171];
+  static private int[] jj_la1_0;
+  static private int[] jj_la1_1;
+  static private int[] jj_la1_2;
+  static private int[] jj_la1_3;
+  static {
+      jj_la1_init_0();
+      jj_la1_init_1();
+      jj_la1_init_2();
+      jj_la1_init_3();
+   }
+   private static void jj_la1_init_0() {
+      jj_la1_0 = new int[] {0x0,0xc02,0xc02,0x0,0xc00,0x2,0x2,0x2,0xce800000,0xc00,0x2,0xc00,0x2,0x0,0x2,0x0,0x2,0x2,0x2,0xcebed400,0xcebed400,0x2,0x80000,0x2,0x2,0x2,0x2,0x0,0x40000000,0x2,0x0,0x100000,0x2,0x0,0x2,0x2,0x2,0x2,0x0,0x100000,0x2,0x0,0x2,0x3ed400,0x2,0x2,0x220000,0x2,0x220000,0x220002,0x2,0x2,0x2,0x2,0xce800000,0x0,0xce800000,0x2,0x80000,0x2,0x2,0x48800000,0x48800000,0x48800000,0x48800000,0x48800000,0x48800000,0x48800000,0x48800000,0x48800000,0x48800000,0xce800000,0x80000000,0x80000000,0x80000000,0x80000000,0x86000000,0x2,0x2,0x1c000,0x2,0x0,0x2,0x1c000,0x40000000,0x2,0x2,0x0,0x2,0x0,0x2,0x100000,0x2,0x2,0x2,0x2,0xce800000,0x0,0xce800000,0x2,0x2,0x80000,0x2,0x2,0x2,0x2,0x0,0x2,0xce800000,0x0,0xce800000,0x2,0x80000,0x2,0x2,0x40000000,0x80000,0x2,0x2,0x0,0x2,0x100000,0x2,0x0,0x2,0x2,0x2,0x100000,0x2,0x2,0x0,0x100000,0x2,0x0,0x2,0x2,0x0,0x2,0x0,0x100000,0x2,0x0,0x2,0x61000,0x2,0x0,0x2,0x2,0x2,0x2,0x480000,0x480000,0x60000,0x60000,0x0,0x0,0x60000,0x2,0x60000,0x2,0x60000,0x2,0xce800000,0x2,0x2,0x2,0x0,0x100000,0x2,0x0,0x2,};
+   }
+   private static void jj_la1_init_1() {
+      jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10083000,0x0,0x0,0x0,0x0,0x88000000,0x0,0x10000000,0x0,0x0,0x0,0xb8000001,0xb8000001,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x10000000,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x10000000,0x0,0xa8000001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10882000,0x882000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x10000000,0x10000000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x18000000,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x10802000,0x802000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x10802000,0x802000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x10000000,0x0,0xb8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x98000000,0xb8000000,0x0,0xb8000000,0x0,0xb8000000,0x0,0x10000000,0x0,0x0,0x0,0x10000000,0x0,0x0,0x10000000,0x0,};
+   }
+   private static void jj_la1_init_2() {
+      jj_la1_2 = new int[] {0x200000,0x1000000,0x1000000,0x80000,0x1000000,0x0,0x0,0x0,0xd40001,0x1000000,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3fc0002,0x3fc0002,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f80002,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x140001,0x100001,0x40000,0x0,0x0,0x0,0x0,0x40000,0x40000,0x0,0x0,0x40000,0x40000,0x40000,0x40000,0x40000,0x40000,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x140001,0x100001,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x140001,0x100001,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x7ffff,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3fffe,0x40000,0x7fffe,0x0,0x7ffff,0x0,0x7ffff,0x0,0xdc0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+   }
+   private static void jj_la1_init_3() {
+      jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x38,0x38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x8,0x18,0x0,0x18,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+   }
+  final private JJCalls[] jj_2_rtns = new JJCalls[5];
+  private boolean jj_rescan = false;
+  private int jj_gc = 0;
+
+  /** Constructor with user supplied CharStream. */
+  public Parser(CharStream stream) {
+    token_source = new ParserTokenManager(stream);
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 171; i++) jj_la1[i] = -1;
+    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  /** Reinitialise. */
+  public void ReInit(CharStream stream) {
+    token_source.ReInit(stream);
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 171; i++) jj_la1[i] = -1;
+    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  /** Constructor with generated Token Manager. */
+  public Parser(ParserTokenManager tm) {
+    token_source = tm;
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 171; i++) jj_la1[i] = -1;
+    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  /** Reinitialise. */
+  public void ReInit(ParserTokenManager tm) {
+    token_source = tm;
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 171; i++) jj_la1[i] = -1;
+    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  private Token jj_consume_token(int kind) throws ParseException {
+    Token oldToken;
+    if ((oldToken = token).next != null) token = token.next;
+    else token = token.next = token_source.getNextToken();
+    jj_ntk = -1;
+    if (token.kind == kind) {
+      jj_gen++;
+      if (++jj_gc > 100) {
+        jj_gc = 0;
+        for (int i = 0; i < jj_2_rtns.length; i++) {
+          JJCalls c = jj_2_rtns[i];
+          while (c != null) {
+            if (c.gen < jj_gen) c.first = null;
+            c = c.next;
+          }
+        }
+      }
+      return token;
+    }
+    token = oldToken;
+    jj_kind = kind;
+    throw generateParseException();
+  }
+
+  static private final class LookaheadSuccess extends java.lang.Error { }
+  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
+  private boolean jj_scan_token(int kind) {
+    if (jj_scanpos == jj_lastpos) {
+      jj_la--;
+      if (jj_scanpos.next == null) {
+        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
+      } else {
+        jj_lastpos = jj_scanpos = jj_scanpos.next;
+      }
+    } else {
+      jj_scanpos = jj_scanpos.next;
+    }
+    if (jj_rescan) {
+      int i = 0; Token tok = token;
+      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
+      if (tok != null) jj_add_error_token(kind, i);
+    }
+    if (jj_scanpos.kind != kind) return true;
+    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
+    return false;
+  }
+
+
+/** Get the next Token. */
+  final public Token getNextToken() {
+    if (token.next != null) token = token.next;
+    else token = token.next = token_source.getNextToken();
+    jj_ntk = -1;
+    jj_gen++;
+    return token;
+  }
+
+/** Get the specific Token. */
+  final public Token getToken(int index) {
+    Token t = token;
+    for (int i = 0; i < index; i++) {
+      if (t.next != null) t = t.next;
+      else t = t.next = token_source.getNextToken();
+    }
+    return t;
+  }
+
+  private int jj_ntk() {
+    if ((jj_nt=token.next) == null)
+      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
+    else
+      return (jj_ntk = jj_nt.kind);
+  }
+
+  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
+  private int[] jj_expentry;
+  private int jj_kind = -1;
+  private int[] jj_lasttokens = new int[100];
+  private int jj_endpos;
+
+  private void jj_add_error_token(int kind, int pos) {
+    if (pos >= 100) return;
+    if (pos == jj_endpos + 1) {
+      jj_lasttokens[jj_endpos++] = kind;
+    } else if (jj_endpos != 0) {
+      jj_expentry = new int[jj_endpos];
+      for (int i = 0; i < jj_endpos; i++) {
+        jj_expentry[i] = jj_lasttokens[i];
+      }
+      jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
+        int[] oldentry = (int[])(it.next());
+        if (oldentry.length == jj_expentry.length) {
+          for (int i = 0; i < jj_expentry.length; i++) {
+            if (oldentry[i] != jj_expentry[i]) {
+              continue jj_entries_loop;
+            }
+          }
+          jj_expentries.add(jj_expentry);
+          break jj_entries_loop;
+        }
+      }
+      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
+    }
+  }
+
+  /** Generate ParseException. */
+  public ParseException generateParseException() {
+    jj_expentries.clear();
+    boolean[] la1tokens = new boolean[102];
+    if (jj_kind >= 0) {
+      la1tokens[jj_kind] = true;
+      jj_kind = -1;
+    }
+    for (int i = 0; i < 171; i++) {
+      if (jj_la1[i] == jj_gen) {
+        for (int j = 0; j < 32; j++) {
+          if ((jj_la1_0[i] & (1<<j)) != 0) {
+            la1tokens[j] = true;
+          }
+          if ((jj_la1_1[i] & (1<<j)) != 0) {
+            la1tokens[32+j] = true;
+          }
+          if ((jj_la1_2[i] & (1<<j)) != 0) {
+            la1tokens[64+j] = true;
+          }
+          if ((jj_la1_3[i] & (1<<j)) != 0) {
+            la1tokens[96+j] = true;
+          }
+        }
+      }
+    }
+    for (int i = 0; i < 102; i++) {
+      if (la1tokens[i]) {
+        jj_expentry = new int[1];
+        jj_expentry[0] = i;
+        jj_expentries.add(jj_expentry);
+      }
+    }
+    jj_endpos = 0;
+    jj_rescan_token();
+    jj_add_error_token(0, 0);
+    int[][] exptokseq = new int[jj_expentries.size()][];
+    for (int i = 0; i < jj_expentries.size(); i++) {
+      exptokseq[i] = jj_expentries.get(i);
+    }
+    return new ParseException(token, exptokseq, tokenImage);
+  }
+
+  /** Enable tracing. */
+  final public void enable_tracing() {
+  }
+
+  /** Disable tracing. */
+  final public void disable_tracing() {
+  }
+
+  private void jj_rescan_token() {
+    jj_rescan = true;
+    for (int i = 0; i < 5; i++) {
+    try {
+      JJCalls p = jj_2_rtns[i];
+      do {
+        if (p.gen > jj_gen) {
+          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
+          switch (i) {
+            case 0: jj_3_1(); break;
+            case 1: jj_3_2(); break;
+            case 2: jj_3_3(); break;
+            case 3: jj_3_4(); break;
+            case 4: jj_3_5(); break;
+          }
+        }
+        p = p.next;
+      } while (p != null);
+      } catch(LookaheadSuccess ls) { }
+    }
+    jj_rescan = false;
+  }
+
+  private void jj_save(int index, int xla) {
+    JJCalls p = jj_2_rtns[index];
+    while (p.gen > jj_gen) {
+      if (p.next == null) { p = p.next = new JJCalls(); break; }
+      p = p.next;
+    }
+    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
+  }
+
+  static final class JJCalls {
+    int gen;
+    Token first;
+    int arg;
+    JJCalls next;
+  }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/Parser.jj b/theme-compiler/src/com/vaadin/sass/parser/Parser.jj
new file mode 100644
index 0000000000..717094a763
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/Parser.jj
@@ -0,0 +1,2463 @@
+/* -*-java-extended-*-
+ * Copyright (c) 1999 World Wide Web Consortium
+ * (Massachusetts Institute of Technology, Institut National de Recherche
+ *  en Informatique et en Automatique, Keio University).
+ * All Rights Reserved. http://www.w3.org/Consortium/Legal/
+ *
+ * $Id: Parser.jj,v 1.15 2000/10/27 21:09:37 plehegar Exp $
+ */
+
+options {
+    IGNORE_CASE  = true;
+    STATIC = false;
+    USER_CHAR_STREAM = true;
+    /* DEBUG_TOKEN_MANAGER = true;
+       DEBUG_PARSER = true; */
+}
+
+PARSER_BEGIN(Parser)
+
+package com.vaadin.sass.parser;
+
+import java.io.*;
+import java.net.*;
+import java.util.ArrayList;
+import java.util.Locale;
+import java.util.Map;
+
+import org.w3c.css.sac.ConditionFactory;
+import org.w3c.css.sac.Condition;
+import org.w3c.css.sac.SelectorFactory;
+import org.w3c.css.sac.SelectorList;
+import org.w3c.css.sac.Selector;
+import org.w3c.css.sac.SimpleSelector;
+import org.w3c.css.sac.DocumentHandler;
+import org.w3c.css.sac.InputSource;
+import org.w3c.css.sac.ErrorHandler;
+import org.w3c.css.sac.CSSException;
+import org.w3c.css.sac.CSSParseException;
+import org.w3c.css.sac.Locator;
+import org.w3c.css.sac.LexicalUnit;
+
+import org.w3c.flute.parser.selectors.SelectorFactoryImpl;
+import org.w3c.flute.parser.selectors.ConditionFactoryImpl;
+
+import org.w3c.flute.util.Encoding;
+
+import com.vaadin.sass.handler.*;
+
+import com.vaadin.sass.tree.*;
+
+/**
+ * A CSS2 parser
+ *
+ * @author Philippe Le H�garet
+ * @version $Revision: 1.15 $
+ */
+public class Parser implements org.w3c.css.sac.Parser {
+
+    // replaces all \t, \n, etc with this StringBuffer.
+    static final StringBuilder SPACE = new StringBuilder(" ");
+
+    // the document handler for the parser
+    protected SCSSDocumentHandlerImpl documentHandler;
+    // the error handler for the parser
+    protected ErrorHandler errorHandler;
+    // the input source for the parser
+    protected InputSource source;
+
+    protected ConditionFactory conditionFactory;
+    protected SelectorFactory selectorFactory;
+
+    // temporary place holder for pseudo-element ...
+    private String pseudoElt;
+    
+    /**
+     * Creates a new Parser
+     */
+    public Parser() {
+	this((CharStream) null);
+    }
+
+    /**
+     * @@TODO
+     * @exception CSSException Not yet implemented
+     */    
+    public void setLocale(Locale locale) throws CSSException {
+	throw new CSSException(CSSException.SAC_NOT_SUPPORTED_ERR);
+    }
+
+    /**
+     * Set the document handler for this parser
+     */    
+    public void setDocumentHandler(DocumentHandler handler) {
+	this.documentHandler = (SCSSDocumentHandlerImpl) handler;
+    }
+
+    public void setSelectorFactory(SelectorFactory selectorFactory) {
+	this.selectorFactory = selectorFactory;
+    }
+
+    public void setConditionFactory(ConditionFactory conditionFactory) {
+	this.conditionFactory = conditionFactory;
+    }
+
+    /**
+     * Set the error handler for this parser
+     */    
+    public void setErrorHandler(ErrorHandler error) {
+	this.errorHandler = error;
+    }
+    
+    /**
+     * Main parse methods
+     *
+     * @param source the source of the style sheet.
+     * @exception IOException the source can't be parsed.
+     * @exception CSSException the source is not CSS valid.
+     */
+    public void parseStyleSheet(InputSource source) 
+	    throws CSSException, IOException {
+	this.source = source;
+	ReInit(getCharStreamWithLurk(source));
+	if (selectorFactory == null) {
+	    selectorFactory = new SelectorFactoryImpl();
+	}
+	if (conditionFactory == null) {
+	    conditionFactory = new ConditionFactoryImpl();
+	}
+
+	parserUnit();
+    }
+
+    /**
+     * Convenient method for URIs.
+     *
+     * @param systemId the fully resolved URI of the style sheet.
+     * @exception IOException the source can't be parsed.
+     * @exception CSSException the source is not CSS valid.
+     */    
+    public void parseStyleSheet(String systemId) 
+	    throws CSSException, IOException {
+	parseStyleSheet(new InputSource(systemId));
+    }
+
+    /**
+     * This method parses only one rule (style rule or at-rule, except @charset).
+     *
+     * @param source the source of the rule.
+     * @exception IOException the source can't be parsed.
+     * @exception CSSException the source is not CSS valid.
+     */    
+    public void parseRule(InputSource source) 
+	    throws CSSException, IOException {
+	this.source = source;
+	ReInit(getCharStreamWithLurk(source));
+
+	if (selectorFactory == null) {
+	    selectorFactory = new SelectorFactoryImpl();
+	}
+	if (conditionFactory == null) {
+	    conditionFactory = new ConditionFactoryImpl();
+	}
+	_parseRule();
+    }
+
+    /**
+     * This method parses a style declaration (including the surrounding curly
+     * braces).
+     *
+     * @param source the source of the style declaration.
+     * @exception IOException the source can't be parsed.
+     * @exception CSSException the source is not CSS valid.
+     */
+    public void parseStyleDeclaration(InputSource source) 
+	    throws CSSException, IOException {
+	this.source = source;
+	ReInit(getCharStreamWithLurk(source));
+
+	if (selectorFactory == null) {
+	    selectorFactory = new SelectorFactoryImpl();
+	}
+	if (conditionFactory == null) {
+	    conditionFactory = new ConditionFactoryImpl();
+	}
+	_parseDeclarationBlock();
+    }
+
+    /**
+     * This methods returns "http://www.w3.org/TR/REC-CSS2".
+     * @return the string "http://www.w3.org/TR/REC-CSS2".
+     */    
+    public String getParserVersion() {
+	return "http://www.w3.org/TR/REC-CSS2";
+    }
+
+    /**
+     * Parse methods used by DOM Level 2 implementation.
+     */    
+    public void parseImportRule(InputSource source) 
+	    throws CSSException, IOException {
+	this.source = source;
+	ReInit(getCharStreamWithLurk(source));
+
+	if (selectorFactory == null) {
+	    selectorFactory = new SelectorFactoryImpl();
+	}
+	if (conditionFactory == null) {
+	    conditionFactory = new ConditionFactoryImpl();
+	}
+	_parseImportRule();
+    }
+
+    public void parseMediaRule(InputSource source) 
+	    throws CSSException, IOException {
+	this.source = source;
+	ReInit(getCharStreamWithLurk(source));
+
+	if (selectorFactory == null) {
+	    selectorFactory = new SelectorFactoryImpl();
+	}
+	if (conditionFactory == null) {
+	    conditionFactory = new ConditionFactoryImpl();
+	}
+	_parseMediaRule();
+    }
+
+    public SelectorList parseSelectors(InputSource source) 
+	    throws CSSException, IOException {
+	this.source = source;
+	ReInit(getCharStreamWithLurk(source));
+
+	if (selectorFactory == null) {
+	    selectorFactory = new SelectorFactoryImpl();
+	}
+	if (conditionFactory == null) {
+	    conditionFactory = new ConditionFactoryImpl();
+	}
+	return _parseSelectors();
+    }
+
+    public LexicalUnit parsePropertyValue(InputSource source) 
+	    throws CSSException, IOException {
+	this.source = source;
+	ReInit(getCharStreamWithLurk(source));
+
+	return expr();
+    }
+
+    public boolean parsePriority(InputSource source) 
+	    throws CSSException, IOException {
+	this.source = source;
+	ReInit(getCharStreamWithLurk(source));
+
+	return prio();
+    }
+
+    /**
+     * Convert the source into a Reader. Used only by DOM Level 2 parser methods.
+     */    
+    private Reader getReader(InputSource source) throws IOException {
+	if (source.getCharacterStream() != null) {
+	    return source.getCharacterStream();
+	} else if (source.getByteStream() != null) {
+	    // My DOM level 2 implementation doesn't use this case.
+	    if (source.getEncoding() == null) {
+		// unknown encoding, use ASCII as default.
+		return new InputStreamReader(source.getByteStream(), "ASCII");
+	    } else {
+		return new InputStreamReader(source.getByteStream(), 
+					     source.getEncoding());
+	    }
+	} else {
+	    // systemId
+	    // @@TODO
+	    throw new CSSException("not yet implemented");
+	}
+    }
+
+    /**
+     * Convert the source into a CharStream with encoding informations.
+     * The encoding can be found in the InputSource or in the CSS document.
+     * Since this method marks the reader and make a reset after looking for
+     * the charset declaration, you'll find the charset declaration into the
+     * stream.  
+     */
+    private CharStream getCharStreamWithLurk(InputSource source)
+	    throws CSSException, IOException {
+	if (source.getCharacterStream() != null) {
+	    // all encoding are supposed to be resolved by the user
+	    // return the reader
+	    return new Generic_CharStream(source.getCharacterStream(), 1, 1);
+	} else if (source.getByteStream() == null) {
+	    // @@CONTINUE ME. see also getReader() with systemId
+	    try {
+		source.setByteStream(new URL(source.getURI()).openStream());
+	    } catch (Exception e) {
+		try {
+		    source.setByteStream(new FileInputStream(source.getURI()));
+		} catch (IOException ex) {
+		    throw new CSSException("invalid url ?");
+		}
+	    }
+	}
+	String encoding = "ASCII";
+	InputStream input = source.getByteStream();
+	char c = ' ';
+
+	if (!input.markSupported()) {
+	    input = new BufferedInputStream(input);
+	    source.setByteStream(input);
+	}
+	input.mark(100);
+	c = (char) input.read();
+
+	if (c == '@') {
+	    // hum, is it a charset ?
+	    int size   = 100;
+	    byte[] buf = new byte[size];
+	    input.read(buf, 0, 7);
+	    String keyword = new String(buf, 0, 7);
+	    if (keyword.equals("charset")) {
+		// Yes, this is the charset declaration !
+
+		// here I don't use the right declaration : white space are ' '.
+		while ((c = (char) input.read()) == ' ') {
+		    // find the first quote
+		}
+		char endChar = c;
+		int i = 0;
+
+		if ((endChar != '"') && (endChar != '\'')) {
+		    // hum this is not a quote.
+		    throw new CSSException("invalid charset declaration");
+		}
+
+		while ((c = (char) input.read()) != endChar) {
+		    buf[i++] = (byte) c;
+		    if (i == size) {
+			byte[] old = buf;
+			buf = new byte[size + 100];
+			System.arraycopy(old, 0, buf, 0, size);
+			size += 100;
+		    }
+		}
+		while ((c = (char) input.read()) == ' ') {
+		    // find the next relevant character
+		}
+		if (c != ';') {
+		    // no semi colon at the end ?
+		    throw new CSSException("invalid charset declaration: "
+					   + "missing semi colon");
+		}
+		encoding = new String(buf, 0, i);
+		if (source.getEncoding() != null) {
+		    // compare the two encoding informations.
+		    // For example, I don't accept to have ASCII and after UTF-8.
+		    // Is it really good ? That is the question.
+		    if (!encoding.equals(source.getEncoding())) {
+			throw new CSSException("invalid encoding information.");
+		    }
+		}
+	    } // else no charset declaration available
+	}
+	// ok set the real encoding of this source.
+	source.setEncoding(encoding);
+	// set the real reader of this source.
+	source.setCharacterStream(new InputStreamReader(source.getByteStream(),
+                                             Encoding.getJavaEncoding(encoding)));
+	// reset the stream (leave the charset declaration in the stream).
+	input.reset();
+
+	return new Generic_CharStream(source.getCharacterStream(), 1, 1);
+    }
+
+    private LocatorImpl currentLocator;
+    private Locator getLocator() {
+	if (currentLocator == null) {
+	    currentLocator = new LocatorImpl(this);
+	    return currentLocator;
+	}
+	return currentLocator.reInit(this);
+    }
+    private LocatorImpl getLocator(Token save) {
+	if (currentLocator == null) {
+	    currentLocator = new LocatorImpl(this, save);
+	    return currentLocator;
+	}
+	return currentLocator.reInit(this, save);
+    }
+
+    private void reportError(Locator l, Exception e) {
+	if (errorHandler != null) {
+	    if (e instanceof ParseException) {
+		// construct a clean error message.
+		ParseException pe = (ParseException) e;
+		if (pe.specialConstructor) {
+		    StringBuffer errorM = new StringBuffer();
+		    if (pe.currentToken != null) {
+			errorM.append("encountered \"")
+			    .append(pe.currentToken.next);
+		    }
+		    errorM.append('"');
+		    if (pe.expectedTokenSequences.length != 0) {
+			errorM.append(". Was expecting one of: ");
+			for (int i = 0; i < pe.expectedTokenSequences.length; i++) {
+			    for (int j = 0; j < pe.expectedTokenSequences[i].length; j++) {
+				int kind = pe.expectedTokenSequences[i][j];
+				if (kind != S) {
+				    errorM.append(pe.tokenImage[kind]);
+				    errorM.append(' ');
+				}
+			    }
+			}
+		    }
+		    errorHandler.error(new CSSParseException(errorM.toString(), 
+							     l, e));
+		} else {
+		    errorHandler.error(new CSSParseException(e.getMessage(), 
+							     l, e));
+		}
+	    } else if (e == null) {
+		errorHandler.error(new CSSParseException("error", l, null));
+	    } else {
+		errorHandler.error(new CSSParseException(e.getMessage(), l, e));
+	    }
+	}
+    }
+
+    private void reportWarningSkipText(Locator l, String text) {
+	if (errorHandler != null && text  != null) {
+	    errorHandler.warning(new CSSParseException("Skipping: " + text, l));
+	}
+    }
+}
+
+PARSER_END(Parser)
+
+/*
+ * The tokenizer 
+ */
+
+<DEFAULT>
+TOKEN :
+{
+    < S : ( [ " ", "\t" , "\n" , "\r", "\f" ] )+ > 
+	{ image = Parser.SPACE; }
+}
+   
+<DEFAULT>
+MORE :
+{
+  "//" : IN_SINGLE_LINE_COMMENT
+}
+
+<IN_SINGLE_LINE_COMMENT>
+MORE :
+{
+    < ~["\n","\r"] > : IN_SINGLE_LINE_COMMENT
+}
+
+<IN_SINGLE_LINE_COMMENT>
+SKIP :
+{
+    < "\n"|"\r"|"\r\n" > : DEFAULT
+}
+
+<DEFAULT>
+MORE :
+{
+  <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
+|
+  "/*" : IN_MULTI_LINE_COMMENT
+}
+<IN_FORMAL_COMMENT>
+SPECIAL_TOKEN :
+{
+  <FORMAL_COMMENT: "*/" > : DEFAULT
+}
+
+<IN_MULTI_LINE_COMMENT>
+SKIP :
+{
+  <MULTI_LINE_COMMENT: "*/" > : DEFAULT
+}
+
+<IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
+MORE :
+{
+  < ~[] >
+}
+
+<DEFAULT>
+TOKEN :
+{
+  < CDO : "<!--" >
+  | < CDC : "-->" >
+  | < LBRACE : "{" >
+  | < RBRACE : "}">
+  | < DASHMATCH : "|=" >
+  | < INCLUDES  : "~=" >
+  | < EQ        : "=" >
+  | < PLUS      : "+" >
+  | < MINUS     : "-" >
+  | < COMMA     : "," >
+  | < SEMICOLON : ";" >
+  | < PRECEDES  : ">" >
+  | < DIV       : "/" >
+  | < LBRACKET  : "[" >
+  | < RBRACKET  : "]" >
+  | < ANY       : "*" >
+  | < PARENT    : "&" >
+  | < DOT       : "." >
+  | < LPARAN    : "(" >
+  | < RPARAN    : ")">
+}
+
+<DEFAULT>
+TOKEN :
+{
+  < COLON     : ":" >
+}
+
+< DEFAULT >
+TOKEN :
+{
+	< EACH_VAR : "#{"< VARIABLE > "}">
+}
+
+<DEFAULT>
+TOKEN : /* basic tokens */
+{ 
+    < NONASCII    : ["\200"-"\377"] >
+  | < #H          : ["0"-"9", "a"-"f"] >
+  | < #UNICODE    : "\\" <H> ( <H> )? /* I can't say {1,6} */
+                         ( <H> )? ( <H> )?
+                         ( <H> )? ( <H> )? 
+                    ( [ " ", "\t" , "\n" , "\r", "\f" ] )? >
+  | < #ESCAPE     : <UNICODE> | ( "\\" [ " "-"~","\200"-"\377" ] ) >
+  | < #NMSTART    : ("-")?[ "a"-"z"] | <NONASCII> | <ESCAPE> >
+  | < #NMCHAR	  : ["a"-"z", "0"-"9", "-", "_"] | <NONASCII> | <ESCAPE> >
+  | < #STRINGCHAR : [ "\t"," ","!","#","$","%","&","("-"~" ] 
+                    | "\\\n" | "\\\r\n" | "\\\r" | "\\\f" 
+                    | <NONASCII> | <ESCAPE> >
+  | < #D          : ["0"-"9"] >
+  | < #NAME       : ( <NMCHAR> )+ >
+}
+
+
+<DEFAULT>
+TOKEN :
+{
+    <TO         : "to">
+    |<THROUGH   : "through">
+    |<EACH_IN        : "in">
+}
+
+/* DERECTIVES */
+<DEFAULT>
+TOKEN :
+{
+    <MIXIN_SYM          : "@mixin">
+  | <INCLUDE_SYM        : "@include">
+  | <FUNCTION_SYM       : "@function">
+  | <RETURN_SYM         : "@return">
+  | <DEBUG_SYM          : "@debug">
+  | <WARN_SYM           : "@warn">
+  | <FOR_SYM            : "@for">
+  | <EACH_SYM           : "@each">
+  | <WHILE_SYM          : "@while">
+  | <IF_SYM             : "@if">
+  | <ELSE_SYM           : "@else">
+  | <EXTEND_SYM         : "@extend">
+  | <MOZ_DOCUMENT_SYM   : "@-moz-document">
+  | <SUPPORTS_SYM       : "@supports">
+}
+
+<DEFAULT>
+TOKEN:
+{
+        < GUARDED_SYM : "!" ( <S> )? "default">
+}
+
+<DEFAULT>
+TOKEN :
+{
+  < STRING      : ( "\"" ( <STRINGCHAR> | "'" )* "\"" ) | 
+                  ( "'" ( <STRINGCHAR> | "\"" )* "'" ) >
+  | < IDENT         : <NMSTART> ( <NMCHAR> )* >
+  | < NUMBER	  : ( <D> )+ | ( <D> )* "." ( <D> )+ > 
+  | < #_URL       : [ "!","#","$","%","&","*"-"~" ] | <NONASCII> | <ESCAPE> >
+  | < URL         : "url(" ( <S> )*
+                    ( <STRING> | ( <_URL> )* ) ( <S> )* ")" >            
+}
+
+<DEFAULT>
+TOKEN:
+{
+	< VARIABLE : "$" <IDENT>>
+}
+
+<DEFAULT>
+TOKEN :
+{
+   < PERCENTAGE : <NUMBER> "%" >
+ | < PT : <NUMBER> "pt" >
+ | < MM : <NUMBER> "mm" >
+ | < CM : <NUMBER> "cm" >
+ | < PC : <NUMBER> "pc" >
+ | < IN : <NUMBER> "in" >
+ | < PX : <NUMBER> "px" >
+ | < EMS : <NUMBER> "em" >
+ | < EXS : <NUMBER> "ex" >
+ | < DEG : <NUMBER> "deg" >
+ | < RAD : <NUMBER> "rad" >
+ | < GRAD : <NUMBER> "grad" >
+ | < MS : <NUMBER> "ms" >
+ | < SECOND  : <NUMBER> "s" >
+ | < HZ : <NUMBER> "Hz" >
+ | < KHZ : <NUMBER> "kHz" >
+ | < DIMEN  : <NUMBER> <IDENT> >
+}
+
+<DEFAULT>
+TOKEN :
+{
+  < HASH : "#" <NAME> >
+}
+
+/* RESERVED ATRULE WORDS */
+<DEFAULT>
+TOKEN : 
+{
+    < IMPORT_SYM   : "@import">
+  | < MEDIA_SYM    : "@media" >
+  | < CHARSET_SYM  : "@charset" >
+  | < PAGE_SYM     : "@page"  >
+  | < FONT_FACE_SYM: "@font-face" >
+  | < ATKEYWORD    : "@" <IDENT> >
+}
+
+<DEFAULT>
+TOKEN :
+{
+ < IMPORTANT_SYM : "!" ( <S> )? "important" >
+}
+
+<DEFAULT>
+TOKEN :
+{
+    < #RANGE0 : <H> <H> <H> <H>  <H> >
+    | < #RANGE1 : <H> <H> <H> <H> <H> ( "?" )? >
+    | < #RANGE2 : <H> <H> <H> <H> ( "?" )? ( "?" )? >
+    | < #RANGE3 : <H> <H> <H> ( "?" )? ( "?" )? ( "?" )? >
+    | < #RANGE4 : <H> <H> ( "?" )? ( "?" )? ( "?" )? ( "?" )? >
+    | < #RANGE5 : <H> ( "?" )? ( "?" )? ( "?" )? ( "?" )? ( "?" )? >
+    | < #RANGE6 : "?" ( "?" )? ( "?" )? ( "?" )? ( "?" )? ( "?" )? >
+    | < #RANGE  : <RANGE0> | <RANGE1> | <RANGE2> 
+                  | <RANGE3> | <RANGE4> | <RANGE5> | <RANGE6> >
+    | < #UNI    : <H> ( <H> )? ( <H> )? ( <H> )? ( <H> )? ( <H> )? >
+    | < UNICODERANGE : "U+" <RANGE>
+                        | "U+" <UNI> "-" <UNI> >
+}
+
+<DEFAULT>
+TOKEN :
+{
+ < FUNCTION : <IDENT>(< S >)* "(" >
+}
+
+<DEFAULT, IN_MULTI_LINE_COMMENT>
+TOKEN :
+{ /* avoid token manager error */
+    < UNKNOWN : ~[] >
+}
+
+/*
+ * The grammar of CSS2
+ */
+
+/**
+ * The main entry for the parser.
+ *
+ * @exception ParseException exception during the parse
+ */
+void parserUnit() :
+{}
+{
+    try {
+	{ documentHandler.startDocument(source); }
+	( charset() )?
+	( <S> comments()
+	 | ignoreStatement() )*
+	( importDeclaration() ( ignoreStatement() ( <S> )* )* )*
+	afterImportDeclaration()
+	<EOF>
+    } finally {
+	documentHandler.endDocument(source);
+    }
+}
+
+void charset() :
+{ Token n; }
+{  
+    try {
+	<CHARSET_SYM> ( <S> )* n=<STRING> ( <S> )* ";"
+    } catch (ParseException e) {
+        reportError(getLocator(e.currentToken.next), e);
+	skipStatement();
+	// reportWarningSkipText(getLocator(), skipStatement());
+    } catch (Exception e) {
+        reportError(getLocator(), e);
+	skipStatement();
+	// reportWarningSkipText(getLocator(), skipStatement());
+    }
+}
+
+void afterImportDeclaration() :
+{String ret; 
+ Locator l;
+}
+{
+  ( 
+     ( variable() | mixinDirective()|eachDirective() | includeDirective() | styleRule() | media()| page() | fontFace() 
+      | { l = getLocator(); } ret=skipStatement() 
+      {
+	  if ((ret == null) || (ret.length() == 0)) {
+	      return; 
+	  }
+	  reportWarningSkipText(l, ret);
+	  if (ret.charAt(0) == '@') {
+	      documentHandler.ignorableAtRule(ret);
+	  }
+      }
+      )
+    ( ignoreStatement() ( <S> )* )* )*
+}
+
+void ignoreStatement() :
+{}
+{
+   <CDO> | <CDC> | atRuleDeclaration()
+}
+
+/**
+ * The import statement
+ *
+ * @exception ParseException exception during the parse
+ */
+void importDeclaration() :
+{Token n;
+ String uri;
+ MediaListImpl ml = new MediaListImpl();
+ boolean isURL = false;
+}
+{
+ try {
+  <IMPORT_SYM> 
+       ( <S> )* ( n=<STRING> { uri = convertStringIndex(n.image, 1, 
+							n.image.length() -1); }
+		  | n=<URL> 
+	   {
+	       isURL=true;	      
+	       uri = n.image.substring(4, n.image.length()-1).trim();
+	       if ((uri.charAt(0) == '"')
+		   || (uri.charAt(0) == '\'')) {
+		   uri = uri.substring(1, uri.length()-1);
+	       }
+	   }
+		  )
+       ( <S> )* ( mediaStatement(ml) )? ";"
+       ( <S> )*
+	   {
+	       if (ml.getLength() == 0) {
+		   // see section 6.3 of the CSS2 recommandation.
+		   ml.addItem("all");
+	       }
+	       documentHandler.importStyle(uri, ml, isURL);
+	   }
+ } catch (ParseException e) {
+     reportError(getLocator(), e);
+     skipStatement();
+     // reportWarningSkipText(getLocator(), skipStatement());
+ }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+void media() :
+{ 
+    boolean start = false;
+    String ret;
+    MediaListImpl ml = new MediaListImpl(); 
+}
+{
+ try {
+  <MEDIA_SYM> ( <S> )*
+   mediaStatement(ml)
+   { start = true; documentHandler.startMedia(ml); }
+   <LBRACE> ( <S> )* ( styleRule() | skipUnknownRule() )* <RBRACE> ( <S> )*
+ } catch (ParseException e) {
+     reportError(getLocator(), e);
+     skipStatement();
+     // reportWarningSkipText(getLocator(), skipStatement());
+ } finally {
+     if (start) {
+	 documentHandler.endMedia(ml);
+     }
+ }
+}
+
+void mediaStatement(MediaListImpl ml) :
+{ 
+    String m;
+}
+{
+   m=medium() ( <COMMA> ( <S> )* { ml.addItem(m); } m=medium() )* 
+   { ml.addItem(m); }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+String medium() : /* tv, projection, screen, ... */
+{Token n;}
+{
+    n=<IDENT> ( <S> )* { return convertIdent(n.image); }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+void page() :
+{
+ boolean start = false;
+ Token n = null;
+ String page = null;
+ String pseudo = null;
+}
+{
+ try {
+  <PAGE_SYM> ( <S> )* ( n=<IDENT> ( <S> )* )?
+  ( pseudo=pseudo_page() )? 
+      {
+	  if (n != null) {
+	      page = convertIdent(n.image);
+	  }
+      }
+  <LBRACE> (<S>)* 
+      {
+	  start = true;
+	  documentHandler.startPage(page, pseudo);
+      }
+     ( declaration() )? ( ";" ( <S> )* ( declaration() )? )* 
+     <RBRACE> (<S>)*
+ } catch (ParseException e) {
+     if (errorHandler != null) {
+	 LocatorImpl li = new LocatorImpl(this,
+					  e.currentToken.next.beginLine,
+					  e.currentToken.next.beginColumn-1);
+	 reportError(li, e);
+	 skipStatement();
+	 // reportWarningSkipText(li, skipStatement());
+     } else {
+	 skipStatement();
+     }
+ } finally {
+     if (start) {
+	 documentHandler.endPage(page, pseudo);
+     }
+ }
+}
+
+String pseudo_page() :
+{ Token n; }
+{
+    ":" n=<IDENT> ( <S> )* { return convertIdent(n.image); }
+}
+
+void fontFace() :
+{
+    boolean start = false;
+}
+{
+ try {
+  <FONT_FACE_SYM> ( <S> )* 
+     <LBRACE> (<S>)* 
+      { start = true; documentHandler.startFontFace(); }
+     ( declaration() )? ( ";" ( <S> )* ( declaration() )? )* 
+     <RBRACE> (<S>)*
+ } catch (ParseException e) {
+     reportError(getLocator(), e);
+     skipStatement();
+     // reportWarningSkipText(getLocator(), skipStatement());
+ } finally {
+     if (start) {
+	 documentHandler.endFontFace();
+     }
+ }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+void atRuleDeclaration() :
+{Token n;
+ String ret; 
+}
+{
+ n=<ATKEYWORD>
+    {
+	ret=skipStatement();
+	reportWarningSkipText(getLocator(), ret);
+	if ((ret != null) && (ret.charAt(0) == '@')) {
+	    documentHandler.ignorableAtRule(ret);
+	}
+    }
+}
+
+void skipUnknownRule() :
+{ Token n;}
+{
+ ( n=<ATKEYWORD>
+| n=<CDO>
+| n=<CHARSET_SYM>
+| n=<COMMA>
+| n=<DASHMATCH>
+| n=<FONT_FACE_SYM>
+| n=<FUNCTION>
+| n=<IMPORTANT_SYM>
+| n=<IMPORT_SYM>
+| n=<INCLUDES>
+| n=<LBRACE>
+| n=<MEDIA_SYM>
+| n=<NONASCII>
+| n=<NUMBER>
+| n=<PAGE_SYM>
+| n=<PERCENTAGE>
+| n=<STRING>
+| n=<UNICODERANGE>
+| n=<URL>
+| n=";"
+| n="+"
+| n=">"
+| n="-"
+| n=<UNKNOWN>
+   ) {
+     String ret;
+     Locator loc = getLocator();
+     ret=skipStatement();
+     reportWarningSkipText(loc, ret);
+     if ((ret != null) && (n.image.charAt(0) == '@')) {
+	 documentHandler.ignorableAtRule(ret);
+     }
+ }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+char combinator() :
+{
+char connector = ' ';
+}
+{
+    "+" ( <S> )* { return '+'; }
+    | ">" ( <S> )* { return '>'; }
+| <S>  ( ( "+" { connector = '+'; } 
+           | ">" { connector = '>'; } )
+ ( <S> )* )? { return connector; }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+String property() :
+{Token n;
+}
+{
+	    n=<IDENT> ( <S> )* { return convertIdent(n.image); }
+}
+
+String variableName() :
+{Token n;}
+{
+    n=<VARIABLE> (<S>)* {return convertIdent(n.image.substring(1));}
+}
+
+String functionName() :
+{Token n;}
+{
+    n=<FUNCTION> ( <S> )* {return convertIdent(n.image.substring(0, n.image.length()-1));}
+}
+/**
+ * @exception ParseException exception during the parse
+ */
+void styleRule() :
+{
+    boolean start = false;
+    SelectorList l = null;
+    Token save;
+    Locator loc;
+}
+{
+ try {
+     l=selectorList() { save = token; } <LBRACE> (<S>)*
+     {
+	 start = true;
+	 documentHandler.startSelector(l);
+     }
+     ( includeDirective() | media() | extendDirective()| eachDirective() | variable() | LOOKAHEAD(3) declarationOrNestedProperties() | styleRule())*
+     <RBRACE> (<S>)*
+ } catch (ThrowedParseException e) {
+     if (errorHandler != null) {
+	 LocatorImpl li = new LocatorImpl(this,
+					  e.e.currentToken.next.beginLine,
+					  e.e.currentToken.next.beginColumn-1);
+	 reportError(li, e.e);
+     }
+ } catch (ParseException e) {
+     reportError(getLocator(), e);
+     skipStatement();
+     // reportWarningSkipText(getLocator(), skipStatement());
+ } catch (TokenMgrError e) {
+     reportWarningSkipText(getLocator(), skipStatement());
+ } finally {
+     if (start) {
+	 documentHandler.endSelector(l);
+     }
+ }
+}
+
+SelectorList selectorList() :
+{
+    SelectorListImpl selectors = new SelectorListImpl();
+    Selector selector;
+}
+{
+ selector=selector() ( <COMMA> (<S>)* { selectors.addSelector(selector); } 
+                       selector=selector() )* 
+  { selectors.addSelector(selector); 
+    return selectors;
+  }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+Selector selector() :
+{   
+    Selector selector;
+    char    comb;
+}
+{
+ try {
+   selector=simple_selector(null, ' ') 
+       ( LOOKAHEAD(2) comb=combinator() 
+	 selector=simple_selector(selector, comb) )* (<S>)*
+   {
+       return selector; 
+   }
+ } catch (ParseException e) {
+     /*
+     Token t = getToken(1);
+     StringBuffer s = new StringBuffer();
+     s.append(getToken(0).image);
+     while ((t.kind != COMMA) && (t.kind != SEMICOLON) 
+	    && (t.kind != LBRACE) && (t.kind != EOF)) {
+	 s.append(t.image);
+	 getNextToken();
+	 t = getToken(1);
+     }
+     reportWarningSkipText(getLocator(), s.toString());
+     */
+     Token t = getToken(1);
+     while ((t.kind != COMMA) && (t.kind != SEMICOLON) 
+	    && (t.kind != LBRACE) && (t.kind != EOF)) {
+	 getNextToken();
+	 t = getToken(1);
+     }
+
+     throw new ThrowedParseException(e);
+  }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+Selector simple_selector(Selector selector, char comb) :
+{
+    SimpleSelector simple_current = null;
+    Condition cond = null;
+
+    pseudoElt = null;
+}
+{
+    ( simple_current=element_name() 
+	( cond=hash(cond) | cond=_class(cond) 
+	  | cond=attrib(cond) | cond=pseudo(cond) )*
+      | cond=hash(cond) ( cond=_class(cond) 
+			  | cond=attrib(cond) | cond=pseudo(cond) )*
+      | cond=_class(cond) ( cond=hash(cond) | cond=_class(cond) 
+		       | cond=attrib(cond) | cond=pseudo(cond) )*
+      | cond=pseudo(cond) ( cond=hash(cond) | cond=_class(cond) 
+		       | cond=attrib(cond) | cond=pseudo(cond) )*
+      | cond=attrib(cond) ( cond=hash(cond) | cond=_class(cond) 
+			    | cond=attrib(cond) | cond=pseudo(cond) )*
+      )
+	{
+	    if (simple_current == null) {
+		simple_current = selectorFactory.createElementSelector(null, null);
+	    }
+	    if (cond != null) {
+		simple_current = selectorFactory.createConditionalSelector(simple_current, 
+								    cond);
+	    }
+	    if (selector != null) {
+		switch (comb) {
+		case ' ':
+		    selector = selectorFactory.createDescendantSelector(selector, 
+								       simple_current);
+		    break;
+		case '+':
+		    selector = 
+			selectorFactory.createDirectAdjacentSelector((short) 1,
+								     selector, 
+								     simple_current);
+		    break;
+		case '>':
+		    selector = selectorFactory.createChildSelector(selector, 
+								  simple_current);
+		    break;
+		default:
+		    throw new ParseException("invalid state. send a bug report");
+		}
+	    } else {
+		selector= simple_current;
+	    }
+	    if (pseudoElt != null) {
+		selector = selectorFactory.createChildSelector(selector, 
+                             selectorFactory.createPseudoElementSelector(null, pseudoElt));
+	    }
+	    return selector;
+	}
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+Condition _class(Condition pred) :
+{Token t;
+String s = "";
+Condition c;
+}
+{
+  "." (t = <IDENT>{s += t.image; }|t = < EACH_VAR >{ s += t.image; })+
+      { 
+	  c = conditionFactory.createClassCondition(null, s);
+	  if (pred == null) {
+	      return c;
+	  } else {
+	      return conditionFactory.createAndCondition(pred, c);
+	  }
+      }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+SimpleSelector element_name() :
+{Token t; String s = "";}
+{
+    (t = <IDENT>{s += t.image; }|t = < EACH_VAR >{ s += t.image; })+
+    { 
+      return selectorFactory.createElementSelector(null, s); 
+    }
+      | "*"
+    { return selectorFactory.createElementSelector(null, "*"); }
+      | "&"
+    { return selectorFactory.createElementSelector(null, "&"); }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+Condition attrib(Condition pred) :
+{
+    int cases = 0;
+    Token att = null;
+    Token val = null;
+    String attValue = null;
+}
+{
+  "[" ( <S> )* att=<IDENT> ( <S> )*
+      ( ( "="           { cases = 1; }
+	  | <INCLUDES>  { cases = 2; }	  
+	  | <DASHMATCH> { cases = 3; } ) ( <S> )* 
+	( val=<IDENT> { attValue = val.image; }
+	  | val=<STRING> { attValue = convertStringIndex(val.image, 1, 
+							 val.image.length() -1);}
+	)
+	( <S> )* )?
+  "]"
+  {
+      String name = convertIdent(att.image);
+      Condition c;
+      switch (cases) {
+	  case 0:
+	  c = conditionFactory.createAttributeCondition(name, null, false, null);
+	  break;
+	  case 1:
+	  c = conditionFactory.createAttributeCondition(name, null, false, 
+							attValue);
+	  break;
+	  case 2:
+	  c = conditionFactory.createOneOfAttributeCondition(name, null, false, 
+							     attValue);
+	  break;
+	  case 3:
+	  c = conditionFactory.createBeginHyphenAttributeCondition(name, null, 
+								   false, 
+								   attValue);
+	  break;
+	  default:
+	  // never reached.
+	  c = null;
+      }
+      if (pred == null) {
+	  return c;
+      } else {
+	  return conditionFactory.createAndCondition(pred, c);
+      }
+  }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+Condition pseudo(Condition pred) :
+{Token n;
+Token language;
+boolean isPseudoElement = false;
+}
+{
+    ":" (":"{isPseudoElement=true;})?( n=<IDENT>
+	{
+	    String s = convertIdent(n.image);
+	    if (isPseudoElement) {
+		if (pseudoElt != null) {
+		    throw new CSSParseException("duplicate pseudo element definition " 
+						+ s, getLocator());
+		} else {
+		    pseudoElt = s;
+		    return pred;
+		}
+	    } else {
+		Condition c = 
+		conditionFactory.createPseudoClassCondition(null, s);
+		if (pred == null) {
+		    return c;
+		} else {
+		    return conditionFactory.createAndCondition(pred, c);
+		}
+	    }
+	}
+	  | ( n=<FUNCTION> ( <S> )* language=<IDENT> ( <S> )* ")" 
+	      {
+		  String f = convertIdent(n.image);
+		  if (f.equals("lang(")) {
+		      Condition d = 
+	      conditionFactory.createLangCondition(convertIdent(language.image));
+		      if (pred == null) {
+			  return d;
+		      } else {
+			  return conditionFactory.createAndCondition(pred, d);
+		      }
+		  } else {
+		      throw new CSSParseException("invalid pseudo function name " 
+						  + f, getLocator());
+		  }
+	      }
+	      )
+	  )
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+Condition hash(Condition pred) :
+{Token n; }
+{
+  n=<HASH>
+  {
+      Condition d = 
+	  conditionFactory.createIdCondition(n.image.substring(1));
+      if (pred == null) {
+	  return d;
+      } else {
+	  return conditionFactory.createAndCondition(pred, d);
+      }
+  }
+}
+
+void variable() :
+{
+	String name;
+	LexicalUnit exp = null;
+	boolean guarded = false;
+	String raw;
+}
+{
+	try{
+		name = variableName()
+		":" ( <S> )* exp=expr() ( guarded=guarded() )?(";"(<S>)*)+
+		//raw=skipStatementUntilSemiColon()
+		{
+		    documentHandler.variable(name, exp, guarded);
+		}
+	}catch (JumpException e) {
+	    skipAfterExpression();
+	} catch (NumberFormatException e) {
+	    if (errorHandler != null) {
+		errorHandler.error(new CSSParseException("Invalid number " 
+						  + e.getMessage(),
+						  getLocator(), 
+						  e));
+	    }
+	    reportWarningSkipText(getLocator(), skipAfterExpression());
+	 } catch (ParseException e) {
+	    if (errorHandler != null) {
+	    	if (e.currentToken != null) {
+	    		LocatorImpl li = new LocatorImpl(this,
+						      e.currentToken.next.beginLine,
+						      e.currentToken.next.beginColumn-1);
+	    		reportError(li, e);
+	    	} else {
+	    		reportError(getLocator(), e);
+	    }
+		skipAfterExpression();
+	    } else {
+		skipAfterExpression();
+	    }
+	}
+}
+
+void eachDirective() :
+{
+  Token var;
+  ArrayList<String> list;
+}
+{
+  < EACH_SYM >
+  (< S >)*
+  var = < VARIABLE > (< S >)* < EACH_IN > (< S >)*
+  list = stringList()
+  < LBRACE >(< S >)*
+  { documentHandler.startEachDirective(var.image, list);}
+  ( includeDirective() | media() | extendDirective()| variable() | LOOKAHEAD(3) declarationOrNestedProperties() | styleRule())*	  
+  < RBRACE >(< S >)*
+  { documentHandler.endEachDirective();}
+}
+
+ArrayList<String > stringList():
+{
+	ArrayList<String > strings = new ArrayList<String >();
+	Token input;	
+}
+{
+	(input = < IDENT > (< S >)*) 
+	{ strings.add(input.image); }
+	
+	(< COMMA >(< S >)* input = < IDENT > { strings.add(input.image); } (< S >)*)*
+	{ return strings; }
+	  
+}
+
+void mixinDirective() :
+{
+    String name;
+    ArrayList<VariableNode> args = null;
+    String body;
+}
+{
+    <MIXIN_SYM>
+    (<S>)*
+    (name = property()
+    |(name = functionName() 
+      args = arglist()) <RPARAN> (<S>)*) <LBRACE> (<S>)*
+    {documentHandler.startMixinDirective(name, args);}
+    ( includeDirective() | media()| extendDirective()| variable() | LOOKAHEAD(3) declarationOrNestedProperties() | styleRule())*
+    //(includeDirective() | media() | LOOKAHEAD(declaration()) declaration()";"(<S>)* | styleRule())*
+    <RBRACE>(<S>)*
+    {documentHandler.endMixinDirective(name, args);}
+}
+
+ArrayList<VariableNode> arglist() :
+{
+    ArrayList<VariableNode> args = new ArrayList<VariableNode>();
+    VariableNode arg;
+}
+{
+    arg=mixinArg() ( <COMMA> (<S>)* { args.add(arg); } 
+        arg=mixinArg() )* 
+    { args.add(arg); 
+        return args;
+    }
+}
+
+VariableNode mixinArg() :
+{
+    String name;
+    LexicalUnit value = null;
+}
+{
+    name=variableName() (":" (<S>)* value=term(null) )?
+    {
+        VariableNode arg = new VariableNode(name, value, false);
+        return arg;
+    }
+}
+
+ArrayList<LexicalUnit> argValuelist() :
+{
+    ArrayList<LexicalUnit> args = new ArrayList<LexicalUnit>();
+    LexicalUnit argValue;
+}
+{
+    argValue= term(null) { args.add(argValue); }
+    ( <COMMA> (<S>)* argValue = term(null)
+      {args.add(argValue);}
+    )* 
+    {return args;}
+}
+
+void includeDirective() :
+{
+    String name;
+    ArrayList<LexicalUnit> args=null;
+}
+{
+    <INCLUDE_SYM>
+    (<S>)*
+    (name = property()
+         |(name = functionName() 
+           args = argValuelist()) <RPARAN>)(";"(<S>)*)+
+           {documentHandler.includeDirective(name, args);}
+}
+
+Node functionDirective() :
+{
+    String name;
+    String args = null;
+    String body;
+    int[] stops = {RPARAN};
+}
+{
+    (name=functionName() args = skipStatementUntilRightParan() <RPARAN>)
+    (<S>)*
+    body = skipStatement()   
+    {
+        return null;
+    }
+}
+
+Node returnDirective() :
+{
+    String raw;
+}
+{
+	raw = skipStatement()
+	{return null;}
+}
+
+JAVACODE
+void debugDirective(){
+}
+
+JAVACODE
+void warnDirective(){
+}
+
+Node forDirective() :
+{
+    String var;
+    String from;
+    String to;
+    boolean exclusive;
+    String body;
+    Token tok;
+}
+{
+    var = variableName()
+    {
+        int[] toThrough = {TO, THROUGH};
+        from = skipStatementUntil(toThrough);
+    }
+    (tok = <TO> {exclusive = true;}
+    | tok = <THROUGH> {exclusive = false;})
+    to = skipStatementUntilLeftBrace()
+    (<S>)*
+    body = skipStatement()
+    {return documentHandler.forDirective(var, from, to, exclusive, body);}
+}
+
+Node whileDirective() :
+{
+    String condition;
+    String body;
+}
+{
+    condition = skipStatementUntilLeftBrace()
+    body = skipStatement()
+    {   return documentHandler.whileDirective(condition, body);}
+}
+
+JAVACODE
+Node ifDirective(){
+    return documentHandler.ifDirective();
+}
+
+JAVACODE
+void elseDirective(){
+   // throw new ParseException("Invalid CSS: @else must come after @if");
+}
+
+void extendDirective() : 
+{SelectorList list;}
+{
+    <EXTEND_SYM>
+    (<S>)*
+    list = selectorList()
+    (";"(<S>)*)+
+    {documentHandler.extendDirective(list);}
+}
+
+JAVACODE
+Node importDirective(){
+    return null;
+}
+
+JAVACODE
+Node charsetDirective(){
+    return null;
+}
+
+JAVACODE
+Node mozDocumentDirective(){
+    return null;
+}
+
+JAVACODE
+Node supportsDirective(){
+    return null;
+}
+
+
+void nestedProperties():
+{String name;
+LexicalUnit exp;}
+{
+    name=property()
+    ":" ( <S> )* 
+    <LBRACE> (<S>)*
+    {
+      documentHandler.startNestedProperties(name);
+    }
+    ( declaration() )? ( ";" ( <S> )* ( declaration() )? )*
+    <RBRACE>
+    {
+      documentHandler.endNestedProperties(name);
+    }
+    (<S>)*
+}
+/**
+ * @exception ParseException exception during the parse
+ */
+void declarationOrNestedProperties() :
+{ boolean important = false;
+  String name;
+  LexicalUnit exp;
+  Token save;
+  String comment = null;
+}
+{
+ try {
+     name=property()
+     { save = token; }
+     ":" ( <S> )* 
+     (exp=expr() ( important=prio() )?
+     {
+         Token next = getToken(1);
+         if(next.kind == SEMICOLON || next.kind == RBRACE){
+             while(next.kind == SEMICOLON){
+                 skipStatement();
+                 next = getToken(1);
+             }
+             if(token.specialToken!=null){
+                 documentHandler.property(name, exp, important, token.specialToken.image);
+             }else{
+                 documentHandler.property(name, exp, important, null);
+             }
+         }
+     }
+     |<LBRACE> (<S>)*
+     {
+         documentHandler.startNestedProperties(name);
+     }
+     ( declaration() )? ( ";" ( <S> )* ( declaration() )? )*
+     <RBRACE>(<S>)*
+     {
+         documentHandler.endNestedProperties(name);
+     }
+     )
+     
+ } catch (JumpException e) {
+     skipAfterExpression();
+     // reportWarningSkipText(getLocator(), skipAfterExpression());
+ } catch (NumberFormatException e) {
+     if (errorHandler != null) {
+         errorHandler.error(new CSSParseException("Invalid number " 
+                                                  + e.getMessage(),
+                                                  getLocator(), 
+                                                  e));
+     }
+     reportWarningSkipText(getLocator(), skipAfterExpression());
+ } catch (ParseException e) {
+     if (errorHandler != null) {
+         if (e.currentToken != null) {
+             LocatorImpl li = new LocatorImpl(this,
+                                              e.currentToken.next.beginLine,
+                                              e.currentToken.next.beginColumn-1);
+             reportError(li, e);
+         } else {
+             reportError(getLocator(), e);
+         }
+         skipAfterExpression();
+         /*
+         LocatorImpl loc = (LocatorImpl) getLocator();
+         loc.column--;
+         reportWarningSkipText(loc, skipAfterExpression());
+         */
+     } else {
+         skipAfterExpression();
+     }
+ }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+void declaration() :
+{ boolean important = false;
+  String name;
+  LexicalUnit exp;
+  Token save;
+}
+{
+ try {
+     name=property()
+     { save = token; }
+     ":" ( <S> )* exp=expr() ( important=prio() )?
+     {
+	 documentHandler.property(name, exp, important);
+     }
+ } catch (JumpException e) {
+     skipAfterExpression();
+     // reportWarningSkipText(getLocator(), skipAfterExpression());
+ } catch (NumberFormatException e) {
+     if (errorHandler != null) {
+	 errorHandler.error(new CSSParseException("Invalid number " 
+						  + e.getMessage(),
+						  getLocator(), 
+						  e));
+     }
+     reportWarningSkipText(getLocator(), skipAfterExpression());
+ } catch (ParseException e) {
+     if (errorHandler != null) {
+	 if (e.currentToken != null) {
+	     LocatorImpl li = new LocatorImpl(this,
+					      e.currentToken.next.beginLine,
+					      e.currentToken.next.beginColumn-1);
+	     reportError(li, e);
+	 } else {
+	     reportError(getLocator(), e);
+	 }
+	 skipAfterExpression();
+	 /*
+	 LocatorImpl loc = (LocatorImpl) getLocator();
+	 loc.column--;
+	 reportWarningSkipText(loc, skipAfterExpression());
+	 */
+     } else {
+	 skipAfterExpression();
+     }
+ }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+boolean prio() :
+{}
+{
+  <IMPORTANT_SYM> ( <S> )* { return true; }
+}
+
+boolean guarded() :
+{}
+{
+    <GUARDED_SYM> (<S>)* {return true;}
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+LexicalUnitImpl operator(LexicalUnitImpl prev) :
+{Token n;}
+{
+n="/" ( <S> )* { return LexicalUnitImpl.createSlash(n.beginLine, 
+						       n.beginColumn,
+						       prev); }
+| n="," ( <S> )* { return LexicalUnitImpl.createComma(n.beginLine, 
+							 n.beginColumn,
+							 prev); }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+LexicalUnit expr() :
+{
+    LexicalUnitImpl first, res;
+    char op;
+}
+{
+    first=term(null){ res = first; }
+    ( LOOKAHEAD(2) ( res=operator(res) )? res=term(res))*
+  { return first; }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+char unaryOperator() :
+{}
+{
+  "-" { return '-'; }
+| "+" { return '+'; }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+LexicalUnitImpl term(LexicalUnitImpl prev) :
+{ LexicalUnitImpl result = null;
+  Token n = null;
+  char op = ' ';
+  String varName;
+}
+{
+  (( ( ( op=unaryOperator() )?
+    (
+      n=<NUMBER>
+	{ result = LexicalUnitImpl.createNumber(n.beginLine, n.beginColumn,
+						prev, number(op, n, 0)); }
+    | n=<PERCENTAGE>
+	{ result = LexicalUnitImpl.createPercentage(n.beginLine, n.beginColumn,
+						    prev, number(op, n, 1)); }
+    | n=<PT>
+	{ result = LexicalUnitImpl.createPT(n.beginLine, n.beginColumn,
+					    prev, number(op, n, 2)); }
+    | n=<CM>
+	{ result = LexicalUnitImpl.createCM(n.beginLine, n.beginColumn,
+					    prev, number(op, n, 2)); }
+    | n=<MM>
+	{ result = LexicalUnitImpl.createMM(n.beginLine, n.beginColumn,
+					    prev, number(op, n, 2)); }
+    | n=<PC>
+	{ result = LexicalUnitImpl.createPC(n.beginLine, n.beginColumn,
+					    prev, number(op, n, 2)); }
+    | n=<IN>
+	{ result = LexicalUnitImpl.createIN(n.beginLine, n.beginColumn,
+					    prev, number(op, n, 2)); }
+    | n=<PX>
+	{ result = LexicalUnitImpl.createPX(n.beginLine, n.beginColumn,
+					    prev, number(op, n, 2)); }
+    | n=<EMS>
+	{ result = LexicalUnitImpl.createEMS(n.beginLine, n.beginColumn,
+					     prev, number(op, n, 2)); }
+    | n=<EXS>
+	{ result = LexicalUnitImpl.createEXS(n.beginLine, n.beginColumn,
+					     prev, number(op, n, 2)); }
+    | n=<DEG>
+	{ result = LexicalUnitImpl.createDEG(n.beginLine, n.beginColumn,
+					     prev, number(op, n, 3)); }
+    | n=<RAD>
+	{ result = LexicalUnitImpl.createRAD(n.beginLine, n.beginColumn,
+					     prev, number(op, n, 3)); }
+    | n=<GRAD>
+	{ result = LexicalUnitImpl.createGRAD(n.beginLine, n.beginColumn,
+					      prev, number(op, n, 3)); }
+    | n=<SECOND>
+	{ result = LexicalUnitImpl.createS(n.beginLine, n.beginColumn,
+					   prev, number(op, n, 1)); }
+    | n=<MS>
+	{ result = LexicalUnitImpl.createMS(n.beginLine, n.beginColumn,
+					    prev, number(op, n, 2)); }
+    | n=<HZ>
+	{ result = LexicalUnitImpl.createHZ(n.beginLine, n.beginColumn,
+					    prev, number(op, n, 2)); }
+    | n=<KHZ>
+	{ result = LexicalUnitImpl.createKHZ(n.beginLine, n.beginColumn,
+					     prev, number(op, n, 3)); }
+    | n=<DIMEN>
+	{
+	    String s = n.image;
+	    int i = 0;
+	    while (i < s.length() 
+		   && (Character.isDigit(s.charAt(i)) || (s.charAt(i) == '.'))) {
+		i++;
+	    }
+	    result = LexicalUnitImpl.createDimen(n.beginLine, n.beginColumn, prev, 
+						 Float.valueOf(s.substring(0, i)).floatValue(),
+						 s.substring(i));
+	}
+    | result=function(op, prev) ) )
+  | ( n=<STRING>
+	{ result =
+	  LexicalUnitImpl.createString(n.beginLine, n.beginColumn, prev,
+				       convertStringIndex(n.image, 1, 
+							  n.image.length() -1));}
+       | n=<IDENT> 
+      { String s = convertIdent(n.image);
+	if ("inherit".equals(s)) {
+	    result = LexicalUnitImpl.createInherit(n.beginLine, n.beginColumn,
+					       prev);
+	} else {
+	    result = LexicalUnitImpl.createIdent(n.beginLine, n.beginColumn,
+					       prev, convertIdent(n.image));
+	}
+
+	  /* /
+         Auto correction code used in the CSS Validator but must not
+          be used by a conformant CSS2 parser.
+	 * Common error :
+	 * H1 {
+	 *   color : black
+	 *   background : white
+	 * }
+	 *
+	Token t = getToken(1);
+	Token semicolon = new Token();
+	semicolon.kind = SEMICOLON;
+	semicolon.image = ";";
+	if (t.kind == COLON) {
+	    // @@SEEME. (generate a warning?)
+	    // @@SEEME if expression is a single ident, 
+	       generate an error ?
+	    rejectToken(semicolon);
+	    
+	    result = prev;
+	}
+	/ */
+    }
+	| result=hexcolor(prev)	
+        | result=url(prev)
+	| result=unicode(prev)
+         ) ) ( <S> )*
+        | varName = variableName()
+         {result = LexicalUnitImpl.createVariable(token.beginLine, token.beginColumn,
+                 prev, varName);})
+      {
+	  return result;
+      }
+}
+
+/**
+ * Handle all CSS2 functions.
+ * @exception ParseException exception during the parse
+ */
+LexicalUnitImpl function(char operator, LexicalUnitImpl prev) :
+{Token n;
+ LexicalUnit params = null;
+}
+{
+    n=<FUNCTION> ( <S> )*  
+    {
+        String fname = convertIdent(n.image);
+        if("alpha(".equals(fname)){
+            String body = skipStatementUntilSemiColon();
+            return LexicalUnitImpl.createIdent(n.beginLine, n.beginColumn,
+                 null, "alpha("+body);
+        }
+    }
+    ( params=expr() )? ")"
+    {
+        if (operator != ' ') {
+	    throw new CSSParseException("invalid operator before a function.", 
+					getLocator());
+	}
+	String f = convertIdent(n.image);
+        LexicalUnitImpl l = (LexicalUnitImpl) params;
+	boolean loop = true;
+	if ("rgb(".equals(f)) {
+	    // this is a RGB declaration (e.g. rgb(255, 50%, 0) )
+	    int i = 0;
+	    while (loop && l != null && i < 5) {
+		switch (i) {
+		    case 0:
+		    case 2:
+		    case 4:
+			if ((l.getLexicalUnitType() != LexicalUnit.SAC_INTEGER)
+			    && (l.getLexicalUnitType() != LexicalUnit.SAC_PERCENTAGE)) {
+			    loop = false;
+			}
+			break;
+		    case 1:
+		    case 3:
+			if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) {
+			    loop = false;
+			}
+			break;
+		    default:
+                        throw new ParseException("implementation error");
+		}
+		if (loop) {
+		    l = (LexicalUnitImpl) l.getNextLexicalUnit();
+		    i ++;
+		}
+	    }
+	    if ((i == 5) && loop && (l == null)) {
+		return LexicalUnitImpl.createRGBColor(n.beginLine,
+						      n.beginColumn,
+						      prev, params);
+	    } else {
+		if (errorHandler != null) {
+		    String errorText;
+		    Locator loc;
+		    if (i < 5) {
+			if (params == null) {
+			    loc = new LocatorImpl(this, n.beginLine,
+						  n.beginColumn-1);
+			    errorText = "not enough parameters.";
+			} else if (l == null) {
+			    loc = new LocatorImpl(this, n.beginLine,
+						  n.beginColumn-1);
+			    errorText = "not enough parameters: " 
+				+ params.toString();
+			} else {
+			    loc = new LocatorImpl(this, l.getLineNumber(),
+						  l.getColumnNumber());
+			    errorText = "invalid parameter: "
+				+ l.toString();
+			}
+		    } else {
+			loc = new LocatorImpl(this, l.getLineNumber(),
+					      l.getColumnNumber());
+			errorText = "too many parameters: "
+			    + l.toString();
+		    }
+		    errorHandler.error(new CSSParseException(errorText, loc));
+		}
+
+		throw new JumpException();
+	    }
+	} else if ("counter".equals(f)) {
+	    int i = 0;
+	    while (loop && l != null && i < 3) {
+		switch (i) {
+		    case 0:
+		    case 2:
+			if (l.getLexicalUnitType() != LexicalUnit.SAC_IDENT) {
+			    loop = false;
+			}
+			break;
+		    case 1:
+			if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) {
+			    loop = false;
+			}
+			break;
+		    default:
+                        throw new ParseException("implementation error");
+		}
+		l = (LexicalUnitImpl) l.getNextLexicalUnit();
+		i ++;
+	    }
+	    if (((i == 1) || (i == 3)) && loop && (l == null)) {
+		return LexicalUnitImpl.createCounter(n.beginLine, n.beginColumn,
+						     prev, params);
+	    }
+
+	} else if ("counters(".equals(f)) {
+	    
+	    int i = 0;
+	    while (loop && l != null && i < 5) {
+		switch (i) {
+		    case 0:
+		    case 4:
+			if (l.getLexicalUnitType() != LexicalUnit.SAC_IDENT) {
+			    loop = false;
+			}
+			break;
+		    case 2:
+			if (l.getLexicalUnitType() != LexicalUnit.SAC_STRING_VALUE) {
+			    loop = false;
+			}
+			break;
+		    case 1:
+		    case 3:
+			if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) {
+			    loop = false;
+			}
+			break;
+		    default:
+                        throw new ParseException("implementation error");
+		}
+		l = (LexicalUnitImpl) l.getNextLexicalUnit();
+		i ++;
+	    }
+	    if (((i == 3) || (i == 5)) && loop && (l == null)) {
+		return LexicalUnitImpl.createCounters(n.beginLine, n.beginColumn,
+						      prev, params);
+	    }
+	} else if ("attr(".equals(f)) {
+	    if ((l != null)
+		&& (l.getNextLexicalUnit() == null)
+		&& (l.getLexicalUnitType() == LexicalUnit.SAC_IDENT)) {
+                return LexicalUnitImpl.createAttr(l.getLineNumber(), 
+						  l.getColumnNumber(),
+						  prev, l.getStringValue());
+	    }
+	} else if ("rect(".equals(f)) {
+	    int i = 0;
+	    while (loop && l != null && i < 7) {
+		switch (i) {
+		    case 0:
+		    case 2:
+		    case 4:
+		    case 6:
+			switch (l.getLexicalUnitType()) {
+			case LexicalUnit.SAC_INTEGER:
+			    if (l.getIntegerValue() != 0) {
+				loop = false;
+			    }
+			    break;
+			case LexicalUnit.SAC_IDENT:
+			    if (!l.getStringValue().equals("auto")) {
+				loop = false;
+			    }
+			    break;
+			case LexicalUnit.SAC_EM:
+			case LexicalUnit.SAC_EX:
+			case LexicalUnit.SAC_PIXEL:
+			case LexicalUnit.SAC_CENTIMETER:
+			case LexicalUnit.SAC_MILLIMETER:
+			case LexicalUnit.SAC_INCH:
+			case LexicalUnit.SAC_POINT:
+			case LexicalUnit.SAC_PICA:
+			    // nothing
+			    break;
+			default:
+			    loop = false;
+			}
+			break;
+		    case 1:
+		    case 3:
+		    case 5:
+			if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) {
+			    loop = false;
+			}
+			break;
+		    default:
+                        throw new ParseException("implementation error");
+		}
+		l = (LexicalUnitImpl) l.getNextLexicalUnit();
+		i ++;
+	    }
+	    if ((i == 7) && loop && (l == null)) {
+		return LexicalUnitImpl.createRect(n.beginLine, n.beginColumn,
+						  prev, params);
+	    }
+	} 
+	return LexicalUnitImpl.createFunction(n.beginLine, n.beginColumn, prev, 
+					      f.substring(0, 
+							f.length() -1),
+					      params);
+    }
+}
+
+LexicalUnitImpl unicode(LexicalUnitImpl prev) :
+{ Token n;
+}
+{
+  n=<UNICODERANGE>
+ {
+     LexicalUnitImpl params = null;
+     String s = n.image.substring(2);
+     int index = s.indexOf('-');
+     if (index == -1) {
+	 params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn,
+						params, Integer.parseInt(s, 16));
+     } else {
+	 String s1 = s.substring(0, index);
+	 String s2 = s.substring(index);
+
+	 params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn,
+						params, Integer.parseInt(s1, 16));
+	 params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn,
+						params, Integer.parseInt(s2, 16));
+     }
+
+     return LexicalUnitImpl.createUnicodeRange(n.beginLine, n.beginColumn,
+					       prev, params);
+ }
+}
+
+LexicalUnitImpl url(LexicalUnitImpl prev) :
+{ Token n;
+}
+{
+  n=<URL>
+ {
+   String urlname = n.image.substring(4, n.image.length()-1).trim();
+   if (urlname.charAt(0) == '"'
+       || urlname.charAt(0) == '\'') {
+       urlname = urlname.substring(1, urlname.length()-1);
+   }
+   return LexicalUnitImpl.createURL(n.beginLine, n.beginColumn, prev, urlname); 
+ }
+}
+
+/**
+ * @exception ParseException exception during the parse
+ */
+LexicalUnitImpl hexcolor(LexicalUnitImpl prev) :
+{Token n; 
+}
+{
+ n=<HASH>
+ { 
+     int r;
+     LexicalUnitImpl first, params = null;
+     String s = n.image.substring(1);
+     
+     if(s.length()!=3 && s.length()!=6) {
+	 first = null;
+	 throw new CSSParseException("invalid hexadecimal notation for RGB: " + s, 
+				     getLocator());
+     }
+     return LexicalUnitImpl.createIdent(n.beginLine, n.beginColumn,
+             prev, n.image);
+ }
+}
+
+JAVACODE
+float number(char operator, Token n, int lengthUnit) {
+    String image  = n.image;
+    float f = 0;
+
+    if (lengthUnit != 0) {
+	image = image.substring(0, image.length() - lengthUnit);
+    }
+    f = Float.valueOf(image).floatValue();
+    return (operator == '-')? -f: f;
+}
+
+JAVACODE
+String skipStatementUntilSemiColon(){
+    int[] semicolon = {SEMICOLON};
+    return skipStatementUntil(semicolon);
+}
+
+JAVACODE
+String skipStatementUntilLeftBrace(){
+    int[] lBrace = {LBRACE};
+    return skipStatementUntil(lBrace);
+}
+
+JAVACODE
+String skipStatementUntilRightParan(){
+    int[] rParan = {RPARAN};
+    return skipStatementUntil(rParan);
+}
+
+JAVACODE
+String skipStatementUntil(int[] symbols){
+    StringBuffer s = new StringBuffer();
+    boolean stop = false;
+    Token tok;
+    while(!stop){
+        tok = getToken(1);
+        if(tok.kind == EOF) {
+            return null;
+        }
+        for(int sym : symbols){
+            if(tok.kind == sym){
+                stop = true;
+                break;
+            }
+        }
+        if(!stop){
+            if (tok.image != null) {
+                s.append(tok.image);
+            }
+            getNextToken();
+        }
+    }
+    return s.toString().trim();
+}
+
+
+JAVACODE
+String skipStatement() {
+    StringBuffer s = new StringBuffer();
+    Token tok = getToken(0);
+    if (tok.image != null) {
+        s.append(tok.image);    
+    }
+    while (true) {
+        tok = getToken(1);
+        if (tok.kind == EOF) {
+            return null;
+        } 
+        s.append(tok.image);
+        if (tok.kind == LBRACE) {
+            getNextToken();
+            s.append(skip_to_matching_brace());
+            getNextToken();
+            tok = getToken(1);
+            break;
+        } else if (tok.kind == RBRACE) {
+            getNextToken();
+            tok = getToken(1);
+            break;
+        } else if (tok.kind == SEMICOLON) {
+            getNextToken();
+            tok = getToken(1);
+            break;
+        }
+        getNextToken();
+    }
+    
+    // skip white space
+    while (true) {
+        if (tok.kind != S) {
+            break;
+        }
+        tok = getNextToken();
+        tok = getToken(1);
+    }
+
+    return s.toString().trim();
+}
+
+JAVACODE
+String skip_to_matching_brace() {
+    StringBuffer s = new StringBuffer();
+    Token tok;
+    int nesting = 1;
+    while (true) {
+        tok = getToken(1);
+        if (tok.kind == EOF) {
+            break;
+        }
+        s.append(tok.image);
+        if (tok.kind == LBRACE) {
+            nesting++;
+        } else if (tok.kind == RBRACE) {
+            nesting--;
+            if (nesting == 0) {
+                break;
+            }
+        }
+        getNextToken();
+    }
+    return s.toString();
+}
+
+/*
+ * Here I handle all CSS2 unicode character stuffs.
+ * I convert all \XXXXXX character into a single character.
+ * Don't forget that the parser has recognize the token before.
+ * (So IDENT won't contain newline and stuffs like this).
+ */
+JAVACODE
+String convertStringIndex(String s, int start, int len) {
+    StringBuffer buf = new StringBuffer(len);
+    int index = start;
+
+    while (index < len) {
+	char c = s.charAt(index);
+	if (c == '\\') {
+	    if (++index < len) {
+		c = s.charAt(index);
+		switch (c) {
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+		case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+		case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+		    int numValue = Character.digit(c, 16);
+		    int count = 0;
+		    int p = 16;
+
+		    while (index + 1 < len && count < 6) {
+			c = s.charAt(index+1);
+
+			if (Character.digit(c, 16) != -1) {
+			    numValue = (numValue * 16) + Character.digit(c, 16);
+			    p *= 16;
+			    index++;
+			} else {
+			    if (c == ' ') {
+				// skip the latest white space
+				index++;
+			    }
+			    break;
+			}
+		    }
+		    buf.append((char) numValue);
+		    break;
+		case '\n':
+		case '\f':
+		    break;
+		case '\r':
+		    if (index + 1 < len) {
+			if (s.charAt(index + 1) == '\n') {
+			    index ++;
+			}
+		    }
+		    break;
+		default:
+		    buf.append(c);
+		}
+	    } else {
+		throw new CSSParseException("invalid string " + s, getLocator());
+	    }
+	} else {
+	    buf.append(c);
+	}
+	index++;
+    }
+
+    return buf.toString();
+}
+
+JAVACODE
+String convertIdent(String s) {
+    return convertStringIndex(s, 0, s.length());
+}
+
+JAVACODE
+String convertString(String s) {
+    return convertStringIndex(s, 0, s.length());
+}
+
+JAVACODE
+void comments(){
+    if (token.specialToken != null){
+        Token tmp_t = token.specialToken;
+        while (tmp_t.specialToken != null) tmp_t = tmp_t.specialToken;
+        while (tmp_t != null) {
+            documentHandler.comment(tmp_t.image);
+            tmp_t = tmp_t.next;
+        }
+    }
+} 
+
+/*
+ * @@HACK
+ * I can't insert a token into the tokens flow.
+ * It's jj_consume_token implementation dependant! :-(
+ */
+JAVACODE
+void rejectToken(Token t) {
+    Token fakeToken = new Token();
+    t.next = token;
+    fakeToken.next = t;
+    token = fakeToken;
+}
+
+/**
+ * skip after an expression
+ */
+JAVACODE
+String skipAfterExpression() {
+    Token t = getToken(1);
+    StringBuffer s = new StringBuffer();
+    s.append(getToken(0).image);
+    
+    while ((t.kind != RBRACE) && (t.kind != SEMICOLON) && (t.kind != EOF)) {
+	s.append(t.image);
+	getNextToken();
+	t = getToken(1);
+    }
+    
+    return s.toString();
+}
+
+/**
+ * The following functions are useful for a DOM CSS implementation only and are
+ * not part of the general CSS2 parser.
+ */
+
+void _parseRule() :
+{String ret = null;
+}
+{
+	( <S> )*
+	   ( importDeclaration() | styleRule() | media() | page() 
+	     | fontFace() | ret=skipStatement() 
+		{
+		    if ((ret == null) || (ret.length() == 0)) {
+			return; 
+		    }
+		    if (ret.charAt(0) == '@') {
+			documentHandler.ignorableAtRule(ret);
+		    } else {
+			throw new CSSParseException("unrecognize rule: " + ret,
+						    getLocator());
+		    }
+		}
+	  )
+}
+
+void _parseImportRule() :
+{
+}
+{
+    ( <S> )* importDeclaration()
+}
+
+void _parseMediaRule() :
+{
+}
+{
+    ( <S> )* media()
+}
+
+void _parseDeclarationBlock() :
+{
+}
+{
+    ( <S> )* 
+	( declaration() )? ( ";" ( <S> )* ( declaration() )? )* 
+ }
+
+SelectorList _parseSelectors() :
+{ SelectorList p = null; 
+}
+{
+    try {
+	( <S> )* p = selectorList()
+	{ return p; }
+    } catch (ThrowedParseException e) {
+	throw (ParseException) e.e.fillInStackTrace();
+    }
+}
+
+/*
+ * Local Variables:
+ * compile-command: javacc Parser.jj & javac Parser.java
+ * End:
+ */
diff --git a/theme-compiler/src/com/vaadin/sass/parser/ParserConstants.java b/theme-compiler/src/com/vaadin/sass/parser/ParserConstants.java
new file mode 100644
index 0000000000..41fb8ca030
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/ParserConstants.java
@@ -0,0 +1,319 @@
+/* Generated By:JavaCC: Do not edit this line. ParserConstants.java */
+package com.vaadin.sass.parser;
+
+
+/**
+ * Token literal values and constants.
+ * Generated by org.javacc.parser.OtherFilesGen#start()
+ */
+public interface ParserConstants {
+
+  /** End of File. */
+  int EOF = 0;
+  /** RegularExpression Id. */
+  int S = 1;
+  /** RegularExpression Id. */
+  int FORMAL_COMMENT = 7;
+  /** RegularExpression Id. */
+  int MULTI_LINE_COMMENT = 8;
+  /** RegularExpression Id. */
+  int CDO = 10;
+  /** RegularExpression Id. */
+  int CDC = 11;
+  /** RegularExpression Id. */
+  int LBRACE = 12;
+  /** RegularExpression Id. */
+  int RBRACE = 13;
+  /** RegularExpression Id. */
+  int DASHMATCH = 14;
+  /** RegularExpression Id. */
+  int INCLUDES = 15;
+  /** RegularExpression Id. */
+  int EQ = 16;
+  /** RegularExpression Id. */
+  int PLUS = 17;
+  /** RegularExpression Id. */
+  int MINUS = 18;
+  /** RegularExpression Id. */
+  int COMMA = 19;
+  /** RegularExpression Id. */
+  int SEMICOLON = 20;
+  /** RegularExpression Id. */
+  int PRECEDES = 21;
+  /** RegularExpression Id. */
+  int DIV = 22;
+  /** RegularExpression Id. */
+  int LBRACKET = 23;
+  /** RegularExpression Id. */
+  int RBRACKET = 24;
+  /** RegularExpression Id. */
+  int ANY = 25;
+  /** RegularExpression Id. */
+  int PARENT = 26;
+  /** RegularExpression Id. */
+  int DOT = 27;
+  /** RegularExpression Id. */
+  int LPARAN = 28;
+  /** RegularExpression Id. */
+  int RPARAN = 29;
+  /** RegularExpression Id. */
+  int COLON = 30;
+  /** RegularExpression Id. */
+  int EACH_VAR = 31;
+  /** RegularExpression Id. */
+  int NONASCII = 32;
+  /** RegularExpression Id. */
+  int H = 33;
+  /** RegularExpression Id. */
+  int UNICODE = 34;
+  /** RegularExpression Id. */
+  int ESCAPE = 35;
+  /** RegularExpression Id. */
+  int NMSTART = 36;
+  /** RegularExpression Id. */
+  int NMCHAR = 37;
+  /** RegularExpression Id. */
+  int STRINGCHAR = 38;
+  /** RegularExpression Id. */
+  int D = 39;
+  /** RegularExpression Id. */
+  int NAME = 40;
+  /** RegularExpression Id. */
+  int TO = 41;
+  /** RegularExpression Id. */
+  int THROUGH = 42;
+  /** RegularExpression Id. */
+  int EACH_IN = 43;
+  /** RegularExpression Id. */
+  int MIXIN_SYM = 44;
+  /** RegularExpression Id. */
+  int INCLUDE_SYM = 45;
+  /** RegularExpression Id. */
+  int FUNCTION_SYM = 46;
+  /** RegularExpression Id. */
+  int RETURN_SYM = 47;
+  /** RegularExpression Id. */
+  int DEBUG_SYM = 48;
+  /** RegularExpression Id. */
+  int WARN_SYM = 49;
+  /** RegularExpression Id. */
+  int FOR_SYM = 50;
+  /** RegularExpression Id. */
+  int EACH_SYM = 51;
+  /** RegularExpression Id. */
+  int WHILE_SYM = 52;
+  /** RegularExpression Id. */
+  int IF_SYM = 53;
+  /** RegularExpression Id. */
+  int ELSE_SYM = 54;
+  /** RegularExpression Id. */
+  int EXTEND_SYM = 55;
+  /** RegularExpression Id. */
+  int MOZ_DOCUMENT_SYM = 56;
+  /** RegularExpression Id. */
+  int SUPPORTS_SYM = 57;
+  /** RegularExpression Id. */
+  int GUARDED_SYM = 58;
+  /** RegularExpression Id. */
+  int STRING = 59;
+  /** RegularExpression Id. */
+  int IDENT = 60;
+  /** RegularExpression Id. */
+  int NUMBER = 61;
+  /** RegularExpression Id. */
+  int _URL = 62;
+  /** RegularExpression Id. */
+  int URL = 63;
+  /** RegularExpression Id. */
+  int VARIABLE = 64;
+  /** RegularExpression Id. */
+  int PERCENTAGE = 65;
+  /** RegularExpression Id. */
+  int PT = 66;
+  /** RegularExpression Id. */
+  int MM = 67;
+  /** RegularExpression Id. */
+  int CM = 68;
+  /** RegularExpression Id. */
+  int PC = 69;
+  /** RegularExpression Id. */
+  int IN = 70;
+  /** RegularExpression Id. */
+  int PX = 71;
+  /** RegularExpression Id. */
+  int EMS = 72;
+  /** RegularExpression Id. */
+  int EXS = 73;
+  /** RegularExpression Id. */
+  int DEG = 74;
+  /** RegularExpression Id. */
+  int RAD = 75;
+  /** RegularExpression Id. */
+  int GRAD = 76;
+  /** RegularExpression Id. */
+  int MS = 77;
+  /** RegularExpression Id. */
+  int SECOND = 78;
+  /** RegularExpression Id. */
+  int HZ = 79;
+  /** RegularExpression Id. */
+  int KHZ = 80;
+  /** RegularExpression Id. */
+  int DIMEN = 81;
+  /** RegularExpression Id. */
+  int HASH = 82;
+  /** RegularExpression Id. */
+  int IMPORT_SYM = 83;
+  /** RegularExpression Id. */
+  int MEDIA_SYM = 84;
+  /** RegularExpression Id. */
+  int CHARSET_SYM = 85;
+  /** RegularExpression Id. */
+  int PAGE_SYM = 86;
+  /** RegularExpression Id. */
+  int FONT_FACE_SYM = 87;
+  /** RegularExpression Id. */
+  int ATKEYWORD = 88;
+  /** RegularExpression Id. */
+  int IMPORTANT_SYM = 89;
+  /** RegularExpression Id. */
+  int RANGE0 = 90;
+  /** RegularExpression Id. */
+  int RANGE1 = 91;
+  /** RegularExpression Id. */
+  int RANGE2 = 92;
+  /** RegularExpression Id. */
+  int RANGE3 = 93;
+  /** RegularExpression Id. */
+  int RANGE4 = 94;
+  /** RegularExpression Id. */
+  int RANGE5 = 95;
+  /** RegularExpression Id. */
+  int RANGE6 = 96;
+  /** RegularExpression Id. */
+  int RANGE = 97;
+  /** RegularExpression Id. */
+  int UNI = 98;
+  /** RegularExpression Id. */
+  int UNICODERANGE = 99;
+  /** RegularExpression Id. */
+  int FUNCTION = 100;
+  /** RegularExpression Id. */
+  int UNKNOWN = 101;
+
+  /** Lexical state. */
+  int DEFAULT = 0;
+  /** Lexical state. */
+  int IN_SINGLE_LINE_COMMENT = 1;
+  /** Lexical state. */
+  int IN_FORMAL_COMMENT = 2;
+  /** Lexical state. */
+  int IN_MULTI_LINE_COMMENT = 3;
+
+  /** Literal token values. */
+  String[] tokenImage = {
+    "<EOF>",
+    "<S>",
+    "\"//\"",
+    "<token of kind 3>",
+    "<token of kind 4>",
+    "<token of kind 5>",
+    "\"/*\"",
+    "\"*/\"",
+    "\"*/\"",
+    "<token of kind 9>",
+    "\"<!--\"",
+    "\"-->\"",
+    "\"{\"",
+    "\"}\"",
+    "\"|=\"",
+    "\"~=\"",
+    "\"=\"",
+    "\"+\"",
+    "\"-\"",
+    "\",\"",
+    "\";\"",
+    "\">\"",
+    "\"/\"",
+    "\"[\"",
+    "\"]\"",
+    "\"*\"",
+    "\"&\"",
+    "\".\"",
+    "\"(\"",
+    "\")\"",
+    "\":\"",
+    "<EACH_VAR>",
+    "<NONASCII>",
+    "<H>",
+    "<UNICODE>",
+    "<ESCAPE>",
+    "<NMSTART>",
+    "<NMCHAR>",
+    "<STRINGCHAR>",
+    "<D>",
+    "<NAME>",
+    "\"to\"",
+    "\"through\"",
+    "\"in\"",
+    "\"@mixin\"",
+    "\"@include\"",
+    "\"@function\"",
+    "\"@return\"",
+    "\"@debug\"",
+    "\"@warn\"",
+    "\"@for\"",
+    "\"@each\"",
+    "\"@while\"",
+    "\"@if\"",
+    "\"@else\"",
+    "\"@extend\"",
+    "\"@-moz-document\"",
+    "\"@supports\"",
+    "<GUARDED_SYM>",
+    "<STRING>",
+    "<IDENT>",
+    "<NUMBER>",
+    "<_URL>",
+    "<URL>",
+    "<VARIABLE>",
+    "<PERCENTAGE>",
+    "<PT>",
+    "<MM>",
+    "<CM>",
+    "<PC>",
+    "<IN>",
+    "<PX>",
+    "<EMS>",
+    "<EXS>",
+    "<DEG>",
+    "<RAD>",
+    "<GRAD>",
+    "<MS>",
+    "<SECOND>",
+    "<HZ>",
+    "<KHZ>",
+    "<DIMEN>",
+    "<HASH>",
+    "\"@import\"",
+    "\"@media\"",
+    "\"@charset\"",
+    "\"@page\"",
+    "\"@font-face\"",
+    "<ATKEYWORD>",
+    "<IMPORTANT_SYM>",
+    "<RANGE0>",
+    "<RANGE1>",
+    "<RANGE2>",
+    "<RANGE3>",
+    "<RANGE4>",
+    "<RANGE5>",
+    "<RANGE6>",
+    "<RANGE>",
+    "<UNI>",
+    "<UNICODERANGE>",
+    "<FUNCTION>",
+    "<UNKNOWN>",
+  };
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/ParserTokenManager.java b/theme-compiler/src/com/vaadin/sass/parser/ParserTokenManager.java
new file mode 100644
index 0000000000..7c176f2262
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/ParserTokenManager.java
@@ -0,0 +1,4330 @@
+/* Generated By:JavaCC: Do not edit this line. ParserTokenManager.java */
+package com.vaadin.sass.parser;
+import java.io.*;
+import java.net.*;
+import java.util.ArrayList;
+import java.util.Locale;
+import java.util.Map;
+import org.w3c.css.sac.ConditionFactory;
+import org.w3c.css.sac.Condition;
+import org.w3c.css.sac.SelectorFactory;
+import org.w3c.css.sac.SelectorList;
+import org.w3c.css.sac.Selector;
+import org.w3c.css.sac.SimpleSelector;
+import org.w3c.css.sac.DocumentHandler;
+import org.w3c.css.sac.InputSource;
+import org.w3c.css.sac.ErrorHandler;
+import org.w3c.css.sac.CSSException;
+import org.w3c.css.sac.CSSParseException;
+import org.w3c.css.sac.Locator;
+import org.w3c.css.sac.LexicalUnit;
+import org.w3c.flute.parser.selectors.SelectorFactoryImpl;
+import org.w3c.flute.parser.selectors.ConditionFactoryImpl;
+import org.w3c.flute.util.Encoding;
+import com.vaadin.sass.handler.*;
+import com.vaadin.sass.tree.*;
+
+/** Token Manager. */
+public class ParserTokenManager implements ParserConstants
+{
+
+  /** Debug output. */
+  public  java.io.PrintStream debugStream = System.out;
+  /** Set debug output. */
+  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
+private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x8000000L) != 0L)
+            return 400;
+         if ((active0 & 0x40800L) != 0L)
+            return 159;
+         if ((active0 & 0x3fff00000000000L) != 0L || (active1 & 0xf80000L) != 0L)
+            return 96;
+         if ((active0 & 0x400044L) != 0L)
+            return 3;
+         if ((active0 & 0xe0000000000L) != 0L)
+         {
+            jjmatchedKind = 60;
+            return 401;
+         }
+         return -1;
+      case 1:
+         if ((active0 & 0x100000000000000L) != 0L)
+            return 97;
+         if ((active0 & 0x40000000000L) != 0L)
+         {
+            jjmatchedKind = 60;
+            jjmatchedPos = 1;
+            return 401;
+         }
+         if ((active0 & 0xa0000000000L) != 0L)
+            return 401;
+         if ((active0 & 0x40L) != 0L)
+            return 1;
+         if ((active0 & 0x2fff00000000000L) != 0L || (active1 & 0xf80000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 1;
+            return 402;
+         }
+         return -1;
+      case 2:
+         if ((active0 & 0x20000000000000L) != 0L)
+            return 402;
+         if ((active0 & 0x3dff00000000000L) != 0L || (active1 & 0xf80000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 2;
+            return 402;
+         }
+         if ((active0 & 0x40000000000L) != 0L)
+         {
+            jjmatchedKind = 60;
+            jjmatchedPos = 2;
+            return 401;
+         }
+         return -1;
+      case 3:
+         if ((active0 & 0x4000000000000L) != 0L)
+            return 402;
+         if ((active0 & 0x3dbf00000000000L) != 0L || (active1 & 0xf80000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 3;
+            return 402;
+         }
+         if ((active0 & 0x40000000000L) != 0L)
+         {
+            jjmatchedKind = 60;
+            jjmatchedPos = 3;
+            return 401;
+         }
+         return -1;
+      case 4:
+         if ((active0 & 0x4a000000000000L) != 0L || (active1 & 0x400000L) != 0L)
+            return 402;
+         if ((active0 & 0x391f00000000000L) != 0L || (active1 & 0xb80000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 4;
+            return 402;
+         }
+         if ((active0 & 0x40000000000L) != 0L)
+         {
+            jjmatchedKind = 60;
+            jjmatchedPos = 4;
+            return 401;
+         }
+         return -1;
+      case 5:
+         if ((active0 & 0x11100000000000L) != 0L || (active1 & 0x100000L) != 0L)
+            return 402;
+         if ((active0 & 0x40000000000L) != 0L)
+         {
+            jjmatchedKind = 60;
+            jjmatchedPos = 5;
+            return 401;
+         }
+         if ((active0 & 0x380e00000000000L) != 0L || (active1 & 0xa80000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 5;
+            return 402;
+         }
+         return -1;
+      case 6:
+         if ((active0 & 0x80800000000000L) != 0L || (active1 & 0x80000L) != 0L)
+            return 402;
+         if ((active0 & 0x300600000000000L) != 0L || (active1 & 0xa00000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 6;
+            return 402;
+         }
+         if ((active0 & 0x40000000000L) != 0L)
+            return 401;
+         return -1;
+      case 7:
+         if ((active0 & 0x200000000000L) != 0L || (active1 & 0x200000L) != 0L)
+            return 402;
+         if ((active0 & 0x300400000000000L) != 0L || (active1 & 0x800000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 7;
+            return 402;
+         }
+         return -1;
+      case 8:
+         if ((active0 & 0x200400000000000L) != 0L)
+            return 402;
+         if ((active0 & 0x100000000000000L) != 0L || (active1 & 0x800000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 8;
+            return 402;
+         }
+         return -1;
+      case 9:
+         if ((active1 & 0x800000L) != 0L)
+            return 402;
+         if ((active0 & 0x100000000000000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 9;
+            return 402;
+         }
+         return -1;
+      case 10:
+         if ((active0 & 0x100000000000000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 10;
+            return 402;
+         }
+         return -1;
+      case 11:
+         if ((active0 & 0x100000000000000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 11;
+            return 402;
+         }
+         return -1;
+      case 12:
+         if ((active0 & 0x100000000000000L) != 0L)
+         {
+            jjmatchedKind = 88;
+            jjmatchedPos = 12;
+            return 402;
+         }
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_0(int pos, long active0, long active1)
+{
+   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
+}
+private int jjStopAtPos(int pos, int kind)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   return pos + 1;
+}
+private int jjMoveStringLiteralDfa0_0()
+{
+   switch(curChar)
+   {
+      case 38:
+         return jjStopAtPos(0, 26);
+      case 40:
+         return jjStopAtPos(0, 28);
+      case 41:
+         return jjStopAtPos(0, 29);
+      case 42:
+         return jjStopAtPos(0, 25);
+      case 43:
+         return jjStopAtPos(0, 17);
+      case 44:
+         return jjStopAtPos(0, 19);
+      case 45:
+         jjmatchedKind = 18;
+         return jjMoveStringLiteralDfa1_0(0x800L, 0x0L);
+      case 46:
+         return jjStartNfaWithStates_0(0, 27, 400);
+      case 47:
+         jjmatchedKind = 22;
+         return jjMoveStringLiteralDfa1_0(0x44L, 0x0L);
+      case 58:
+         return jjStopAtPos(0, 30);
+      case 59:
+         return jjStopAtPos(0, 20);
+      case 60:
+         return jjMoveStringLiteralDfa1_0(0x400L, 0x0L);
+      case 61:
+         return jjStopAtPos(0, 16);
+      case 62:
+         return jjStopAtPos(0, 21);
+      case 64:
+         return jjMoveStringLiteralDfa1_0(0x3fff00000000000L, 0xf80000L);
+      case 91:
+         return jjStopAtPos(0, 23);
+      case 93:
+         return jjStopAtPos(0, 24);
+      case 73:
+      case 105:
+         return jjMoveStringLiteralDfa1_0(0x80000000000L, 0x0L);
+      case 84:
+      case 116:
+         return jjMoveStringLiteralDfa1_0(0x60000000000L, 0x0L);
+      case 123:
+         return jjStopAtPos(0, 12);
+      case 124:
+         return jjMoveStringLiteralDfa1_0(0x4000L, 0x0L);
+      case 125:
+         return jjStopAtPos(0, 13);
+      case 126:
+         return jjMoveStringLiteralDfa1_0(0x8000L, 0x0L);
+      default :
+         return jjMoveNfa_0(4, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_0(long active0, long active1)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(0, active0, active1);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 33:
+         return jjMoveStringLiteralDfa2_0(active0, 0x400L, active1, 0L);
+      case 42:
+         if ((active0 & 0x40L) != 0L)
+            return jjStartNfaWithStates_0(1, 6, 1);
+         break;
+      case 45:
+         return jjMoveStringLiteralDfa2_0(active0, 0x100000000000800L, active1, 0L);
+      case 47:
+         if ((active0 & 0x4L) != 0L)
+            return jjStopAtPos(1, 2);
+         break;
+      case 61:
+         if ((active0 & 0x4000L) != 0L)
+            return jjStopAtPos(1, 14);
+         else if ((active0 & 0x8000L) != 0L)
+            return jjStopAtPos(1, 15);
+         break;
+      case 67:
+      case 99:
+         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x200000L);
+      case 68:
+      case 100:
+         return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000L, active1, 0L);
+      case 69:
+      case 101:
+         return jjMoveStringLiteralDfa2_0(active0, 0xc8000000000000L, active1, 0L);
+      case 70:
+      case 102:
+         return jjMoveStringLiteralDfa2_0(active0, 0x4400000000000L, active1, 0x800000L);
+      case 72:
+      case 104:
+         return jjMoveStringLiteralDfa2_0(active0, 0x40000000000L, active1, 0L);
+      case 73:
+      case 105:
+         return jjMoveStringLiteralDfa2_0(active0, 0x20200000000000L, active1, 0x80000L);
+      case 77:
+      case 109:
+         return jjMoveStringLiteralDfa2_0(active0, 0x100000000000L, active1, 0x100000L);
+      case 78:
+      case 110:
+         if ((active0 & 0x80000000000L) != 0L)
+            return jjStartNfaWithStates_0(1, 43, 401);
+         break;
+      case 79:
+      case 111:
+         if ((active0 & 0x20000000000L) != 0L)
+            return jjStartNfaWithStates_0(1, 41, 401);
+         break;
+      case 80:
+      case 112:
+         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x400000L);
+      case 82:
+      case 114:
+         return jjMoveStringLiteralDfa2_0(active0, 0x800000000000L, active1, 0L);
+      case 83:
+      case 115:
+         return jjMoveStringLiteralDfa2_0(active0, 0x200000000000000L, active1, 0L);
+      case 87:
+      case 119:
+         return jjMoveStringLiteralDfa2_0(active0, 0x12000000000000L, active1, 0L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(0, active0, active1);
+}
+private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
+{
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(0, old0, old1);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(1, active0, active1);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 45:
+         return jjMoveStringLiteralDfa3_0(active0, 0x400L, active1, 0L);
+      case 62:
+         if ((active0 & 0x800L) != 0L)
+            return jjStopAtPos(2, 11);
+         break;
+      case 65:
+      case 97:
+         return jjMoveStringLiteralDfa3_0(active0, 0xa000000000000L, active1, 0x400000L);
+      case 69:
+      case 101:
+         return jjMoveStringLiteralDfa3_0(active0, 0x1800000000000L, active1, 0x100000L);
+      case 70:
+      case 102:
+         if ((active0 & 0x20000000000000L) != 0L)
+            return jjStartNfaWithStates_0(2, 53, 402);
+         break;
+      case 72:
+      case 104:
+         return jjMoveStringLiteralDfa3_0(active0, 0x10000000000000L, active1, 0x200000L);
+      case 73:
+      case 105:
+         return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0L);
+      case 76:
+      case 108:
+         return jjMoveStringLiteralDfa3_0(active0, 0x40000000000000L, active1, 0L);
+      case 77:
+      case 109:
+         return jjMoveStringLiteralDfa3_0(active0, 0x100000000000000L, active1, 0x80000L);
+      case 78:
+      case 110:
+         return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L, active1, 0L);
+      case 79:
+      case 111:
+         return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000L, active1, 0x800000L);
+      case 82:
+      case 114:
+         return jjMoveStringLiteralDfa3_0(active0, 0x40000000000L, active1, 0L);
+      case 85:
+      case 117:
+         return jjMoveStringLiteralDfa3_0(active0, 0x200400000000000L, active1, 0L);
+      case 88:
+      case 120:
+         return jjMoveStringLiteralDfa3_0(active0, 0x80000000000000L, active1, 0L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(1, active0, active1);
+}
+private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
+{
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(1, old0, old1);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(2, active0, active1);
+      return 3;
+   }
+   switch(curChar)
+   {
+      case 45:
+         if ((active0 & 0x400L) != 0L)
+            return jjStopAtPos(3, 10);
+         break;
+      case 65:
+      case 97:
+         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x200000L);
+      case 66:
+      case 98:
+         return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);
+      case 67:
+      case 99:
+         return jjMoveStringLiteralDfa4_0(active0, 0x8200000000000L, active1, 0L);
+      case 68:
+      case 100:
+         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x100000L);
+      case 71:
+      case 103:
+         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x400000L);
+      case 73:
+      case 105:
+         return jjMoveStringLiteralDfa4_0(active0, 0x10000000000000L, active1, 0L);
+      case 78:
+      case 110:
+         return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0x800000L);
+      case 79:
+      case 111:
+         return jjMoveStringLiteralDfa4_0(active0, 0x100040000000000L, active1, 0L);
+      case 80:
+      case 112:
+         return jjMoveStringLiteralDfa4_0(active0, 0x200000000000000L, active1, 0x80000L);
+      case 82:
+      case 114:
+         if ((active0 & 0x4000000000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 50, 402);
+         return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L);
+      case 83:
+      case 115:
+         return jjMoveStringLiteralDfa4_0(active0, 0x40000000000000L, active1, 0L);
+      case 84:
+      case 116:
+         return jjMoveStringLiteralDfa4_0(active0, 0x80800000000000L, active1, 0L);
+      case 88:
+      case 120:
+         return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(2, active0, active1);
+}
+private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
+{
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(2, old0, old1);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(3, active0, active1);
+      return 4;
+   }
+   switch(curChar)
+   {
+      case 67:
+      case 99:
+         return jjMoveStringLiteralDfa5_0(active0, 0x400000000000L, active1, 0L);
+      case 69:
+      case 101:
+         if ((active0 & 0x40000000000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 54, 402);
+         else if ((active1 & 0x400000L) != 0L)
+            return jjStartNfaWithStates_0(4, 86, 402);
+         return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L, active1, 0L);
+      case 72:
+      case 104:
+         if ((active0 & 0x8000000000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 51, 402);
+         break;
+      case 73:
+      case 105:
+         return jjMoveStringLiteralDfa5_0(active0, 0x100000000000L, active1, 0x100000L);
+      case 76:
+      case 108:
+         return jjMoveStringLiteralDfa5_0(active0, 0x10200000000000L, active1, 0L);
+      case 78:
+      case 110:
+         if ((active0 & 0x2000000000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 49, 402);
+         break;
+      case 79:
+      case 111:
+         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x80000L);
+      case 80:
+      case 112:
+         return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0L);
+      case 82:
+      case 114:
+         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x200000L);
+      case 84:
+      case 116:
+         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x800000L);
+      case 85:
+      case 117:
+         return jjMoveStringLiteralDfa5_0(active0, 0x1840000000000L, active1, 0L);
+      case 90:
+      case 122:
+         return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(3, active0, active1);
+}
+private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
+{
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(3, old0, old1);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(4, active0, active1);
+      return 5;
+   }
+   switch(curChar)
+   {
+      case 45:
+         return jjMoveStringLiteralDfa6_0(active0, 0x100000000000000L, active1, 0x800000L);
+      case 65:
+      case 97:
+         if ((active1 & 0x100000L) != 0L)
+            return jjStartNfaWithStates_0(5, 84, 402);
+         break;
+      case 69:
+      case 101:
+         if ((active0 & 0x10000000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 52, 402);
+         break;
+      case 71:
+      case 103:
+         if ((active0 & 0x1000000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 48, 402);
+         return jjMoveStringLiteralDfa6_0(active0, 0x40000000000L, active1, 0L);
+      case 78:
+      case 110:
+         if ((active0 & 0x100000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 44, 402);
+         return jjMoveStringLiteralDfa6_0(active0, 0x80000000000000L, active1, 0L);
+      case 79:
+      case 111:
+         return jjMoveStringLiteralDfa6_0(active0, 0x200000000000000L, active1, 0L);
+      case 82:
+      case 114:
+         return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L, active1, 0x80000L);
+      case 83:
+      case 115:
+         return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x200000L);
+      case 84:
+      case 116:
+         return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L);
+      case 85:
+      case 117:
+         return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L, active1, 0L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(4, active0, active1);
+}
+private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
+{
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(4, old0, old1);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(5, active0, active1);
+      return 6;
+   }
+   switch(curChar)
+   {
+      case 68:
+      case 100:
+         if ((active0 & 0x80000000000000L) != 0L)
+            return jjStartNfaWithStates_0(6, 55, 402);
+         return jjMoveStringLiteralDfa7_0(active0, 0x100200000000000L, active1, 0L);
+      case 69:
+      case 101:
+         return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x200000L);
+      case 70:
+      case 102:
+         return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x800000L);
+      case 72:
+      case 104:
+         if ((active0 & 0x40000000000L) != 0L)
+            return jjStartNfaWithStates_0(6, 42, 401);
+         break;
+      case 73:
+      case 105:
+         return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L, active1, 0L);
+      case 78:
+      case 110:
+         if ((active0 & 0x800000000000L) != 0L)
+            return jjStartNfaWithStates_0(6, 47, 402);
+         break;
+      case 82:
+      case 114:
+         return jjMoveStringLiteralDfa7_0(active0, 0x200000000000000L, active1, 0L);
+      case 84:
+      case 116:
+         if ((active1 & 0x80000L) != 0L)
+            return jjStartNfaWithStates_0(6, 83, 402);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(5, active0, active1);
+}
+private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1)
+{
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(5, old0, old1);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(6, active0, active1);
+      return 7;
+   }
+   switch(curChar)
+   {
+      case 65:
+      case 97:
+         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x800000L);
+      case 69:
+      case 101:
+         if ((active0 & 0x200000000000L) != 0L)
+            return jjStartNfaWithStates_0(7, 45, 402);
+         break;
+      case 79:
+      case 111:
+         return jjMoveStringLiteralDfa8_0(active0, 0x100400000000000L, active1, 0L);
+      case 84:
+      case 116:
+         if ((active1 & 0x200000L) != 0L)
+            return jjStartNfaWithStates_0(7, 85, 402);
+         return jjMoveStringLiteralDfa8_0(active0, 0x200000000000000L, active1, 0L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(6, active0, active1);
+}
+private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1)
+{
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(6, old0, old1);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(7, active0, active1);
+      return 8;
+   }
+   switch(curChar)
+   {
+      case 67:
+      case 99:
+         return jjMoveStringLiteralDfa9_0(active0, 0x100000000000000L, active1, 0x800000L);
+      case 78:
+      case 110:
+         if ((active0 & 0x400000000000L) != 0L)
+            return jjStartNfaWithStates_0(8, 46, 402);
+         break;
+      case 83:
+      case 115:
+         if ((active0 & 0x200000000000000L) != 0L)
+            return jjStartNfaWithStates_0(8, 57, 402);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(7, active0, active1);
+}
+private int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1)
+{
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(7, old0, old1);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(8, active0, active1);
+      return 9;
+   }
+   switch(curChar)
+   {
+      case 69:
+      case 101:
+         if ((active1 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_0(9, 87, 402);
+         break;
+      case 85:
+      case 117:
+         return jjMoveStringLiteralDfa10_0(active0, 0x100000000000000L, active1, 0L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(8, active0, active1);
+}
+private int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1)
+{
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(8, old0, old1);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(9, active0, 0L);
+      return 10;
+   }
+   switch(curChar)
+   {
+      case 77:
+      case 109:
+         return jjMoveStringLiteralDfa11_0(active0, 0x100000000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(9, active0, 0L);
+}
+private int jjMoveStringLiteralDfa11_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(9, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(10, active0, 0L);
+      return 11;
+   }
+   switch(curChar)
+   {
+      case 69:
+      case 101:
+         return jjMoveStringLiteralDfa12_0(active0, 0x100000000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(10, active0, 0L);
+}
+private int jjMoveStringLiteralDfa12_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(10, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(11, active0, 0L);
+      return 12;
+   }
+   switch(curChar)
+   {
+      case 78:
+      case 110:
+         return jjMoveStringLiteralDfa13_0(active0, 0x100000000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(11, active0, 0L);
+}
+private int jjMoveStringLiteralDfa13_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(11, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(12, active0, 0L);
+      return 13;
+   }
+   switch(curChar)
+   {
+      case 84:
+      case 116:
+         if ((active0 & 0x100000000000000L) != 0L)
+            return jjStartNfaWithStates_0(13, 56, 402);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(12, active0, 0L);
+}
+private int jjStartNfaWithStates_0(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_0(state, pos + 1);
+}
+static final long[] jjbitVec0 = {
+   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+private int jjMoveNfa_0(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 400;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 400:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(0, 4);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(211, 214);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(208, 210);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(206, 207);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(203, 205);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(198, 202);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(194, 197);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(190, 193);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(187, 189);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(184, 186);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(181, 183);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(178, 180);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(175, 177);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(172, 174);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(169, 171);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(166, 168);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(164, 165);
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 61)
+                        kind = 61;
+                     jjCheckNAdd(163);
+                  }
+                  break;
+               case 96:
+                  if (curChar == 45)
+                     jjstateSet[jjnewStateCnt++] = 97;
+                  break;
+               case 402:
+               case 98:
+                  if ((0x3ff200000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddTwoStates(98, 99);
+                  break;
+               case 401:
+                  if ((0x3ff200000000000L & l) != 0L)
+                     jjCheckNAddStates(5, 8);
+                  else if ((0x100003600L & l) != 0L)
+                     jjCheckNAddTwoStates(128, 129);
+                  else if (curChar == 40)
+                  {
+                     if (kind > 100)
+                        kind = 100;
+                  }
+                  if ((0x3ff200000000000L & l) != 0L)
+                  {
+                     if (kind > 60)
+                        kind = 60;
+                     jjCheckNAddTwoStates(117, 118);
+                  }
+                  break;
+               case 4:
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 61)
+                        kind = 61;
+                     jjCheckNAddStates(9, 82);
+                  }
+                  else if ((0x100003600L & l) != 0L)
+                  {
+                     if (kind > 1)
+                        kind = 1;
+                     jjCheckNAdd(0);
+                  }
+                  else if (curChar == 46)
+                     jjCheckNAddStates(83, 100);
+                  else if (curChar == 45)
+                     jjAddStates(101, 102);
+                  else if (curChar == 33)
+                     jjCheckNAddStates(103, 106);
+                  else if (curChar == 35)
+                     jjCheckNAddTwoStates(85, 86);
+                  else if (curChar == 36)
+                     jjCheckNAddStates(107, 110);
+                  else if (curChar == 39)
+                     jjCheckNAddStates(111, 114);
+                  else if (curChar == 34)
+                     jjCheckNAddStates(115, 118);
+                  else if (curChar == 47)
+                     jjstateSet[jjnewStateCnt++] = 3;
+                  if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 5;
+                  break;
+               case 0:
+                  if ((0x100003600L & l) == 0L)
+                     break;
+                  if (kind > 1)
+                     kind = 1;
+                  jjCheckNAdd(0);
+                  break;
+               case 1:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 2:
+                  if ((0xffff7fffffffffffL & l) != 0L && kind > 5)
+                     kind = 5;
+                  break;
+               case 3:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 6:
+                  if (curChar == 36)
+                     jjCheckNAddStates(119, 122);
+                  break;
+               case 7:
+                  if (curChar == 45)
+                     jjCheckNAdd(8);
+                  break;
+               case 9:
+                  if ((0x3ff200000000000L & l) != 0L)
+                     jjCheckNAddStates(123, 125);
+                  break;
+               case 12:
+                  if ((0xffffffff00000000L & l) != 0L)
+                     jjCheckNAddStates(123, 125);
+                  break;
+               case 13:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(126, 130);
+                  break;
+               case 14:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddStates(123, 125);
+                  break;
+               case 15:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(131, 138);
+                  break;
+               case 16:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(139, 142);
+                  break;
+               case 17:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(143, 147);
+                  break;
+               case 18:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(148, 153);
+                  break;
+               case 19:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(154, 160);
+                  break;
+               case 22:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(161, 165);
+                  break;
+               case 23:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(166, 173);
+                  break;
+               case 24:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(174, 177);
+                  break;
+               case 25:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(178, 182);
+                  break;
+               case 26:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(183, 188);
+                  break;
+               case 27:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(189, 195);
+                  break;
+               case 28:
+                  if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 5;
+                  break;
+               case 29:
+                  if (curChar == 34)
+                     jjCheckNAddStates(115, 118);
+                  break;
+               case 30:
+                  if ((0xfffffffb00000200L & l) != 0L)
+                     jjCheckNAddStates(115, 118);
+                  break;
+               case 31:
+                  if (curChar == 34 && kind > 59)
+                     kind = 59;
+                  break;
+               case 33:
+                  if (curChar == 12)
+                     jjCheckNAddStates(115, 118);
+                  break;
+               case 35:
+                  if ((0xffffffff00000000L & l) != 0L)
+                     jjCheckNAddStates(115, 118);
+                  break;
+               case 36:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(196, 201);
+                  break;
+               case 37:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddStates(115, 118);
+                  break;
+               case 38:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(202, 210);
+                  break;
+               case 39:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(211, 215);
+                  break;
+               case 40:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(216, 221);
+                  break;
+               case 41:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(222, 228);
+                  break;
+               case 42:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(229, 236);
+                  break;
+               case 43:
+                  if (curChar == 13)
+                     jjCheckNAddStates(115, 118);
+                  break;
+               case 44:
+                  if (curChar == 10)
+                     jjCheckNAddStates(115, 118);
+                  break;
+               case 45:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 44;
+                  break;
+               case 46:
+                  if (curChar == 39)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 47:
+                  if ((0xffffff7f00000200L & l) != 0L)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 48:
+                  if (curChar == 39 && kind > 59)
+                     kind = 59;
+                  break;
+               case 50:
+                  if (curChar == 12)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 52:
+                  if ((0xffffffff00000000L & l) != 0L)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 53:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(237, 242);
+                  break;
+               case 54:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 55:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(243, 251);
+                  break;
+               case 56:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(252, 256);
+                  break;
+               case 57:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(257, 262);
+                  break;
+               case 58:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(263, 269);
+                  break;
+               case 59:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(270, 277);
+                  break;
+               case 60:
+                  if (curChar == 13)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 61:
+                  if (curChar == 10)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 62:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 61;
+                  break;
+               case 63:
+                  if (curChar == 36)
+                     jjCheckNAddStates(107, 110);
+                  break;
+               case 64:
+                  if (curChar == 45)
+                     jjCheckNAdd(65);
+                  break;
+               case 66:
+                  if ((0x3ff200000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 68:
+                  if ((0xffffffff00000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 69:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(278, 281);
+                  break;
+               case 70:
+                  if ((0x100003600L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 71:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(282, 288);
+                  break;
+               case 72:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(289, 291);
+                  break;
+               case 73:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(292, 295);
+                  break;
+               case 74:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(296, 300);
+                  break;
+               case 75:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(301, 306);
+                  break;
+               case 78:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(307, 310);
+                  break;
+               case 79:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(311, 317);
+                  break;
+               case 80:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(318, 320);
+                  break;
+               case 81:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(321, 324);
+                  break;
+               case 82:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(325, 329);
+                  break;
+               case 83:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(330, 335);
+                  break;
+               case 84:
+                  if (curChar == 35)
+                     jjCheckNAddTwoStates(85, 86);
+                  break;
+               case 85:
+                  if ((0x3ff200000000000L & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddTwoStates(85, 86);
+                  break;
+               case 87:
+                  if ((0xffffffff00000000L & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddTwoStates(85, 86);
+                  break;
+               case 88:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(336, 339);
+                  break;
+               case 89:
+                  if ((0x100003600L & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddTwoStates(85, 86);
+                  break;
+               case 90:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(340, 346);
+                  break;
+               case 91:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(347, 349);
+                  break;
+               case 92:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(350, 353);
+                  break;
+               case 93:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(354, 358);
+                  break;
+               case 94:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(359, 364);
+                  break;
+               case 100:
+                  if ((0xffffffff00000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddTwoStates(98, 99);
+                  break;
+               case 101:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(365, 368);
+                  break;
+               case 102:
+                  if ((0x100003600L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddTwoStates(98, 99);
+                  break;
+               case 103:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(369, 375);
+                  break;
+               case 104:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(376, 378);
+                  break;
+               case 105:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(379, 382);
+                  break;
+               case 106:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(383, 387);
+                  break;
+               case 107:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(388, 393);
+                  break;
+               case 110:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(394, 397);
+                  break;
+               case 111:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(398, 404);
+                  break;
+               case 112:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(405, 407);
+                  break;
+               case 113:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(408, 411);
+                  break;
+               case 114:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(412, 416);
+                  break;
+               case 115:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(417, 422);
+                  break;
+               case 117:
+                  if ((0x3ff200000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddTwoStates(117, 118);
+                  break;
+               case 119:
+                  if ((0xffffffff00000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddTwoStates(117, 118);
+                  break;
+               case 120:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(423, 426);
+                  break;
+               case 121:
+                  if ((0x100003600L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddTwoStates(117, 118);
+                  break;
+               case 122:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(427, 433);
+                  break;
+               case 123:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(434, 436);
+                  break;
+               case 124:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(437, 440);
+                  break;
+               case 125:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(441, 445);
+                  break;
+               case 126:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(446, 451);
+                  break;
+               case 127:
+                  if ((0x3ff200000000000L & l) != 0L)
+                     jjCheckNAddStates(5, 8);
+                  break;
+               case 128:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddTwoStates(128, 129);
+                  break;
+               case 129:
+                  if (curChar == 40 && kind > 100)
+                     kind = 100;
+                  break;
+               case 131:
+                  if ((0xffffffff00000000L & l) != 0L)
+                     jjCheckNAddStates(5, 8);
+                  break;
+               case 132:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(452, 456);
+                  break;
+               case 133:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddStates(5, 8);
+                  break;
+               case 134:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(457, 464);
+                  break;
+               case 135:
+               case 341:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(465, 468);
+                  break;
+               case 136:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(469, 473);
+                  break;
+               case 137:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(474, 479);
+                  break;
+               case 138:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(480, 486);
+                  break;
+               case 139:
+                  if (curChar == 33)
+                     jjCheckNAddStates(103, 106);
+                  break;
+               case 140:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddTwoStates(140, 147);
+                  break;
+               case 148:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddTwoStates(148, 157);
+                  break;
+               case 158:
+                  if (curChar == 45)
+                     jjAddStates(101, 102);
+                  break;
+               case 162:
+                  if (curChar == 46)
+                     jjCheckNAddStates(83, 100);
+                  break;
+               case 163:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 61)
+                     kind = 61;
+                  jjCheckNAdd(163);
+                  break;
+               case 164:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(164, 165);
+                  break;
+               case 165:
+                  if (curChar == 37 && kind > 65)
+                     kind = 65;
+                  break;
+               case 166:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(166, 168);
+                  break;
+               case 169:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(169, 171);
+                  break;
+               case 172:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(172, 174);
+                  break;
+               case 175:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(175, 177);
+                  break;
+               case 178:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(178, 180);
+                  break;
+               case 181:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(181, 183);
+                  break;
+               case 184:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(184, 186);
+                  break;
+               case 187:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(187, 189);
+                  break;
+               case 190:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(190, 193);
+                  break;
+               case 194:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(194, 197);
+                  break;
+               case 198:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(198, 202);
+                  break;
+               case 203:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(203, 205);
+                  break;
+               case 206:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(206, 207);
+                  break;
+               case 208:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(208, 210);
+                  break;
+               case 211:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(211, 214);
+                  break;
+               case 215:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(0, 4);
+                  break;
+               case 216:
+                  if (curChar == 45)
+                     jjCheckNAdd(217);
+                  break;
+               case 218:
+                  if ((0x3ff200000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddTwoStates(218, 219);
+                  break;
+               case 220:
+                  if ((0xffffffff00000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddTwoStates(218, 219);
+                  break;
+               case 221:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(487, 490);
+                  break;
+               case 222:
+                  if ((0x100003600L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddTwoStates(218, 219);
+                  break;
+               case 223:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(491, 497);
+                  break;
+               case 224:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(498, 500);
+                  break;
+               case 225:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(501, 504);
+                  break;
+               case 226:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(505, 509);
+                  break;
+               case 227:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(510, 515);
+                  break;
+               case 230:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(516, 519);
+                  break;
+               case 231:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(520, 526);
+                  break;
+               case 232:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(527, 529);
+                  break;
+               case 233:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(530, 533);
+                  break;
+               case 234:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(534, 538);
+                  break;
+               case 235:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(539, 544);
+                  break;
+               case 237:
+                  if (curChar == 40)
+                     jjCheckNAddStates(545, 550);
+                  break;
+               case 238:
+                  if ((0xfffffc7a00000000L & l) != 0L)
+                     jjCheckNAddStates(551, 554);
+                  break;
+               case 239:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddTwoStates(239, 240);
+                  break;
+               case 240:
+                  if (curChar == 41 && kind > 63)
+                     kind = 63;
+                  break;
+               case 242:
+                  if ((0xffffffff00000000L & l) != 0L)
+                     jjCheckNAddStates(551, 554);
+                  break;
+               case 243:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(555, 559);
+                  break;
+               case 244:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddStates(551, 554);
+                  break;
+               case 245:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(560, 567);
+                  break;
+               case 246:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(568, 571);
+                  break;
+               case 247:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(572, 576);
+                  break;
+               case 248:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(577, 582);
+                  break;
+               case 249:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(583, 589);
+                  break;
+               case 250:
+                  if (curChar == 39)
+                     jjCheckNAddStates(590, 593);
+                  break;
+               case 251:
+                  if ((0xffffff7f00000200L & l) != 0L)
+                     jjCheckNAddStates(590, 593);
+                  break;
+               case 252:
+                  if (curChar == 39)
+                     jjCheckNAddTwoStates(239, 240);
+                  break;
+               case 254:
+                  if (curChar == 12)
+                     jjCheckNAddStates(590, 593);
+                  break;
+               case 256:
+                  if ((0xffffffff00000000L & l) != 0L)
+                     jjCheckNAddStates(590, 593);
+                  break;
+               case 257:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(594, 599);
+                  break;
+               case 258:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddStates(590, 593);
+                  break;
+               case 259:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(600, 608);
+                  break;
+               case 260:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(609, 613);
+                  break;
+               case 261:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(614, 619);
+                  break;
+               case 262:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(620, 626);
+                  break;
+               case 263:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(627, 634);
+                  break;
+               case 264:
+                  if (curChar == 13)
+                     jjCheckNAddStates(590, 593);
+                  break;
+               case 265:
+                  if (curChar == 10)
+                     jjCheckNAddStates(590, 593);
+                  break;
+               case 266:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 265;
+                  break;
+               case 267:
+                  if (curChar == 34)
+                     jjCheckNAddStates(635, 638);
+                  break;
+               case 268:
+                  if ((0xfffffffb00000200L & l) != 0L)
+                     jjCheckNAddStates(635, 638);
+                  break;
+               case 269:
+                  if (curChar == 34)
+                     jjCheckNAddTwoStates(239, 240);
+                  break;
+               case 271:
+                  if (curChar == 12)
+                     jjCheckNAddStates(635, 638);
+                  break;
+               case 273:
+                  if ((0xffffffff00000000L & l) != 0L)
+                     jjCheckNAddStates(635, 638);
+                  break;
+               case 274:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(639, 644);
+                  break;
+               case 275:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddStates(635, 638);
+                  break;
+               case 276:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(645, 653);
+                  break;
+               case 277:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(654, 658);
+                  break;
+               case 278:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(659, 664);
+                  break;
+               case 279:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(665, 671);
+                  break;
+               case 280:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(672, 679);
+                  break;
+               case 281:
+                  if (curChar == 13)
+                     jjCheckNAddStates(635, 638);
+                  break;
+               case 282:
+                  if (curChar == 10)
+                     jjCheckNAddStates(635, 638);
+                  break;
+               case 283:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 282;
+                  break;
+               case 284:
+                  if ((0x100003600L & l) != 0L)
+                     jjCheckNAddStates(680, 686);
+                  break;
+               case 287:
+                  if (curChar == 43)
+                     jjAddStates(687, 688);
+                  break;
+               case 288:
+                  if (curChar != 63)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjstateSet[jjnewStateCnt++] = 289;
+                  break;
+               case 289:
+                  if (curChar != 63)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddStates(689, 692);
+                  break;
+               case 290:
+                  if (curChar == 63 && kind > 99)
+                     kind = 99;
+                  break;
+               case 291:
+               case 306:
+               case 310:
+               case 313:
+               case 316:
+                  if (curChar != 63)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAdd(290);
+                  break;
+               case 292:
+                  if (curChar != 63)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddTwoStates(290, 291);
+                  break;
+               case 293:
+                  if (curChar != 63)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddStates(693, 695);
+                  break;
+               case 294:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjAddStates(696, 701);
+                  break;
+               case 295:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 296;
+                  break;
+               case 296:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 297;
+                  break;
+               case 297:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAdd(298);
+                  break;
+               case 298:
+                  if ((0x3ff000000000000L & l) != 0L && kind > 99)
+                     kind = 99;
+                  break;
+               case 299:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 300;
+                  break;
+               case 300:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 301;
+                  break;
+               case 301:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 302;
+                  break;
+               case 302:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAdd(290);
+                  break;
+               case 303:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 304;
+                  break;
+               case 304:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 305;
+                  break;
+               case 305:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjstateSet[jjnewStateCnt++] = 306;
+                  break;
+               case 307:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 308;
+                  break;
+               case 308:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjstateSet[jjnewStateCnt++] = 309;
+                  break;
+               case 309:
+                  if (curChar != 63)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddTwoStates(290, 310);
+                  break;
+               case 311:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjstateSet[jjnewStateCnt++] = 312;
+                  break;
+               case 312:
+                  if (curChar != 63)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddStates(702, 704);
+                  break;
+               case 314:
+                  if (curChar != 63)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddTwoStates(290, 313);
+                  break;
+               case 315:
+                  if (curChar != 63)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddStates(705, 708);
+                  break;
+               case 317:
+                  if (curChar != 63)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddTwoStates(290, 316);
+                  break;
+               case 318:
+                  if (curChar != 63)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddStates(709, 711);
+                  break;
+               case 319:
+                  if (curChar == 43)
+                     jjstateSet[jjnewStateCnt++] = 320;
+                  break;
+               case 320:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(321, 327);
+                  break;
+               case 321:
+                  if (curChar == 45)
+                     jjstateSet[jjnewStateCnt++] = 322;
+                  break;
+               case 322:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjstateSet[jjnewStateCnt++] = 323;
+                  break;
+               case 323:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddStates(712, 715);
+                  break;
+               case 324:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAdd(298);
+                  break;
+               case 325:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddTwoStates(298, 324);
+                  break;
+               case 326:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddStates(716, 718);
+                  break;
+               case 327:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(719, 723);
+                  break;
+               case 328:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAdd(321);
+                  break;
+               case 329:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(328, 321);
+                  break;
+               case 330:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(724, 726);
+                  break;
+               case 331:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(727, 730);
+                  break;
+               case 333:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(731, 734);
+                  break;
+               case 334:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(735, 741);
+                  break;
+               case 335:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(742, 744);
+                  break;
+               case 336:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(745, 748);
+                  break;
+               case 337:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(749, 753);
+                  break;
+               case 338:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(754, 759);
+                  break;
+               case 339:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(760, 764);
+                  break;
+               case 340:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(765, 772);
+                  break;
+               case 342:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(773, 777);
+                  break;
+               case 343:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(778, 783);
+                  break;
+               case 344:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(784, 790);
+                  break;
+               case 345:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 61)
+                     kind = 61;
+                  jjCheckNAddStates(9, 82);
+                  break;
+               case 346:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 61)
+                     kind = 61;
+                  jjCheckNAdd(346);
+                  break;
+               case 347:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(347, 348);
+                  break;
+               case 348:
+                  if (curChar == 46)
+                     jjCheckNAdd(163);
+                  break;
+               case 349:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(349, 165);
+                  break;
+               case 350:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(350, 351);
+                  break;
+               case 351:
+                  if (curChar == 46)
+                     jjCheckNAdd(164);
+                  break;
+               case 352:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(352, 168);
+                  break;
+               case 353:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(353, 354);
+                  break;
+               case 354:
+                  if (curChar == 46)
+                     jjCheckNAdd(166);
+                  break;
+               case 355:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(355, 171);
+                  break;
+               case 356:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(356, 357);
+                  break;
+               case 357:
+                  if (curChar == 46)
+                     jjCheckNAdd(169);
+                  break;
+               case 358:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(358, 174);
+                  break;
+               case 359:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(359, 360);
+                  break;
+               case 360:
+                  if (curChar == 46)
+                     jjCheckNAdd(172);
+                  break;
+               case 361:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(361, 177);
+                  break;
+               case 362:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(362, 363);
+                  break;
+               case 363:
+                  if (curChar == 46)
+                     jjCheckNAdd(175);
+                  break;
+               case 364:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(364, 180);
+                  break;
+               case 365:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(365, 366);
+                  break;
+               case 366:
+                  if (curChar == 46)
+                     jjCheckNAdd(178);
+                  break;
+               case 367:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(367, 183);
+                  break;
+               case 368:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(368, 369);
+                  break;
+               case 369:
+                  if (curChar == 46)
+                     jjCheckNAdd(181);
+                  break;
+               case 370:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(370, 186);
+                  break;
+               case 371:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(371, 372);
+                  break;
+               case 372:
+                  if (curChar == 46)
+                     jjCheckNAdd(184);
+                  break;
+               case 373:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(373, 189);
+                  break;
+               case 374:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(374, 375);
+                  break;
+               case 375:
+                  if (curChar == 46)
+                     jjCheckNAdd(187);
+                  break;
+               case 376:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(376, 193);
+                  break;
+               case 377:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(377, 378);
+                  break;
+               case 378:
+                  if (curChar == 46)
+                     jjCheckNAdd(190);
+                  break;
+               case 379:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(379, 197);
+                  break;
+               case 380:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(380, 381);
+                  break;
+               case 381:
+                  if (curChar == 46)
+                     jjCheckNAdd(194);
+                  break;
+               case 382:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(382, 202);
+                  break;
+               case 383:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(383, 384);
+                  break;
+               case 384:
+                  if (curChar == 46)
+                     jjCheckNAdd(198);
+                  break;
+               case 385:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(385, 205);
+                  break;
+               case 386:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(386, 387);
+                  break;
+               case 387:
+                  if (curChar == 46)
+                     jjCheckNAdd(203);
+                  break;
+               case 388:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(388, 207);
+                  break;
+               case 389:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(389, 390);
+                  break;
+               case 390:
+                  if (curChar == 46)
+                     jjCheckNAdd(206);
+                  break;
+               case 391:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(391, 210);
+                  break;
+               case 392:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(392, 393);
+                  break;
+               case 393:
+                  if (curChar == 46)
+                     jjCheckNAdd(208);
+                  break;
+               case 394:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(394, 214);
+                  break;
+               case 395:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(395, 396);
+                  break;
+               case 396:
+                  if (curChar == 46)
+                     jjCheckNAdd(211);
+                  break;
+               case 397:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(791, 795);
+                  break;
+               case 398:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(398, 399);
+                  break;
+               case 399:
+                  if (curChar == 46)
+                     jjCheckNAdd(215);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 96:
+                  if ((0x7fffffe07fffffeL & l) != 0L)
+                  {
+                     if (kind > 88)
+                        kind = 88;
+                     jjCheckNAddTwoStates(98, 99);
+                  }
+                  else if (curChar == 92)
+                     jjCheckNAddTwoStates(100, 110);
+                  break;
+               case 159:
+                  if ((0x7fffffe07fffffeL & l) != 0L)
+                     jjCheckNAddStates(5, 8);
+                  if ((0x7fffffe07fffffeL & l) != 0L)
+                  {
+                     if (kind > 60)
+                        kind = 60;
+                     jjCheckNAddTwoStates(117, 118);
+                  }
+                  break;
+               case 402:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 88)
+                        kind = 88;
+                     jjCheckNAddTwoStates(98, 99);
+                  }
+                  else if (curChar == 92)
+                     jjCheckNAddTwoStates(100, 101);
+                  break;
+               case 401:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                     jjCheckNAddStates(5, 8);
+                  else if (curChar == 92)
+                     jjCheckNAddTwoStates(119, 120);
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 60)
+                        kind = 60;
+                     jjCheckNAddTwoStates(117, 118);
+                  }
+                  else if (curChar == 92)
+                     jjCheckNAddTwoStates(131, 132);
+                  break;
+               case 4:
+                  if ((0x7fffffe07fffffeL & l) != 0L)
+                  {
+                     if (kind > 60)
+                        kind = 60;
+                     jjCheckNAddStates(796, 801);
+                  }
+                  else if (curChar == 92)
+                     jjCheckNAddStates(802, 805);
+                  else if (curChar == 64)
+                     jjAddStates(806, 809);
+                  if ((0x20000000200000L & l) != 0L)
+                     jjAddStates(810, 812);
+                  break;
+               case 2:
+                  if (kind > 5)
+                     kind = 5;
+                  break;
+               case 5:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 6;
+                  break;
+               case 8:
+                  if ((0x7fffffe07fffffeL & l) != 0L)
+                     jjCheckNAddStates(123, 125);
+                  break;
+               case 9:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                     jjCheckNAddStates(123, 125);
+                  break;
+               case 10:
+                  if (curChar == 125 && kind > 31)
+                     kind = 31;
+                  break;
+               case 11:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(12, 13);
+                  break;
+               case 12:
+                  if ((0x7fffffffffffffffL & l) != 0L)
+                     jjCheckNAddStates(123, 125);
+                  break;
+               case 13:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(126, 130);
+                  break;
+               case 15:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(131, 138);
+                  break;
+               case 16:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(139, 142);
+                  break;
+               case 17:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(143, 147);
+                  break;
+               case 18:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(148, 153);
+                  break;
+               case 19:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(154, 160);
+                  break;
+               case 21:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(12, 22);
+                  break;
+               case 22:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(161, 165);
+                  break;
+               case 23:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(166, 173);
+                  break;
+               case 24:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(174, 177);
+                  break;
+               case 25:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(178, 182);
+                  break;
+               case 26:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(183, 188);
+                  break;
+               case 27:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(189, 195);
+                  break;
+               case 30:
+               case 35:
+                  if ((0x7fffffffffffffffL & l) != 0L)
+                     jjCheckNAddStates(115, 118);
+                  break;
+               case 32:
+                  if (curChar == 92)
+                     jjAddStates(813, 816);
+                  break;
+               case 34:
+                  if (curChar == 92)
+                     jjAddStates(817, 818);
+                  break;
+               case 36:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(196, 201);
+                  break;
+               case 38:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(202, 210);
+                  break;
+               case 39:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(211, 215);
+                  break;
+               case 40:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(216, 221);
+                  break;
+               case 41:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(222, 228);
+                  break;
+               case 42:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(229, 236);
+                  break;
+               case 47:
+               case 52:
+                  if ((0x7fffffffffffffffL & l) != 0L)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 49:
+                  if (curChar == 92)
+                     jjAddStates(819, 822);
+                  break;
+               case 51:
+                  if (curChar == 92)
+                     jjAddStates(823, 824);
+                  break;
+               case 53:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(237, 242);
+                  break;
+               case 55:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(243, 251);
+                  break;
+               case 56:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(252, 256);
+                  break;
+               case 57:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(257, 262);
+                  break;
+               case 58:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(263, 269);
+                  break;
+               case 59:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(270, 277);
+                  break;
+               case 65:
+                  if ((0x7fffffe07fffffeL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 66:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 67:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(68, 69);
+                  break;
+               case 68:
+                  if ((0x7fffffffffffffffL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 69:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(278, 281);
+                  break;
+               case 71:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(282, 288);
+                  break;
+               case 72:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(289, 291);
+                  break;
+               case 73:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(292, 295);
+                  break;
+               case 74:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(296, 300);
+                  break;
+               case 75:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(301, 306);
+                  break;
+               case 77:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(68, 78);
+                  break;
+               case 78:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(307, 310);
+                  break;
+               case 79:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(311, 317);
+                  break;
+               case 80:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(318, 320);
+                  break;
+               case 81:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(321, 324);
+                  break;
+               case 82:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(325, 329);
+                  break;
+               case 83:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddStates(330, 335);
+                  break;
+               case 85:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddTwoStates(85, 86);
+                  break;
+               case 86:
+                  if (curChar == 92)
+                     jjAddStates(825, 826);
+                  break;
+               case 87:
+                  if ((0x7fffffffffffffffL & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddTwoStates(85, 86);
+                  break;
+               case 88:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(336, 339);
+                  break;
+               case 90:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(340, 346);
+                  break;
+               case 91:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(347, 349);
+                  break;
+               case 92:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(350, 353);
+                  break;
+               case 93:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(354, 358);
+                  break;
+               case 94:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddStates(359, 364);
+                  break;
+               case 95:
+                  if (curChar == 64)
+                     jjAddStates(806, 809);
+                  break;
+               case 97:
+                  if ((0x7fffffe07fffffeL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddTwoStates(98, 99);
+                  break;
+               case 98:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddTwoStates(98, 99);
+                  break;
+               case 99:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(100, 101);
+                  break;
+               case 100:
+                  if ((0x7fffffffffffffffL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddTwoStates(98, 99);
+                  break;
+               case 101:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(365, 368);
+                  break;
+               case 103:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(369, 375);
+                  break;
+               case 104:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(376, 378);
+                  break;
+               case 105:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(379, 382);
+                  break;
+               case 106:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(383, 387);
+                  break;
+               case 107:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(388, 393);
+                  break;
+               case 109:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(100, 110);
+                  break;
+               case 110:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(394, 397);
+                  break;
+               case 111:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(398, 404);
+                  break;
+               case 112:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(405, 407);
+                  break;
+               case 113:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(408, 411);
+                  break;
+               case 114:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(412, 416);
+                  break;
+               case 115:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddStates(417, 422);
+                  break;
+               case 117:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddTwoStates(117, 118);
+                  break;
+               case 118:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(119, 120);
+                  break;
+               case 119:
+                  if ((0x7fffffffffffffffL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddTwoStates(117, 118);
+                  break;
+               case 120:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(423, 426);
+                  break;
+               case 122:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(427, 433);
+                  break;
+               case 123:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(434, 436);
+                  break;
+               case 124:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(437, 440);
+                  break;
+               case 125:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(441, 445);
+                  break;
+               case 126:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(446, 451);
+                  break;
+               case 127:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                     jjCheckNAddStates(5, 8);
+                  break;
+               case 130:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(131, 132);
+                  break;
+               case 131:
+                  if ((0x7fffffffffffffffL & l) != 0L)
+                     jjCheckNAddStates(5, 8);
+                  break;
+               case 132:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(452, 456);
+                  break;
+               case 134:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(457, 464);
+                  break;
+               case 135:
+               case 341:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(465, 468);
+                  break;
+               case 136:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(469, 473);
+                  break;
+               case 137:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(474, 479);
+                  break;
+               case 138:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(480, 486);
+                  break;
+               case 141:
+                  if ((0x10000000100000L & l) != 0L && kind > 58)
+                     kind = 58;
+                  break;
+               case 142:
+                  if ((0x100000001000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 141;
+                  break;
+               case 143:
+                  if ((0x20000000200000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 142;
+                  break;
+               case 144:
+                  if ((0x200000002L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 143;
+                  break;
+               case 145:
+                  if ((0x4000000040L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 144;
+                  break;
+               case 146:
+                  if ((0x2000000020L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 145;
+                  break;
+               case 147:
+                  if ((0x1000000010L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 146;
+                  break;
+               case 149:
+                  if ((0x10000000100000L & l) != 0L && kind > 89)
+                     kind = 89;
+                  break;
+               case 150:
+                  if ((0x400000004000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 149;
+                  break;
+               case 151:
+                  if ((0x200000002L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 150;
+                  break;
+               case 152:
+                  if ((0x10000000100000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 151;
+                  break;
+               case 153:
+                  if ((0x4000000040000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 152;
+                  break;
+               case 154:
+                  if ((0x800000008000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 153;
+                  break;
+               case 155:
+                  if ((0x1000000010000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 154;
+                  break;
+               case 156:
+                  if ((0x200000002000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 155;
+                  break;
+               case 157:
+                  if ((0x20000000200L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 156;
+                  break;
+               case 160:
+                  if ((0x7fffffe07fffffeL & l) != 0L)
+                     jjCheckNAddStates(5, 8);
+                  break;
+               case 161:
+                  if ((0x7fffffe07fffffeL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(796, 801);
+                  break;
+               case 167:
+                  if ((0x10000000100000L & l) != 0L && kind > 66)
+                     kind = 66;
+                  break;
+               case 168:
+                  if ((0x1000000010000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 167;
+                  break;
+               case 170:
+                  if ((0x200000002000L & l) != 0L && kind > 67)
+                     kind = 67;
+                  break;
+               case 171:
+                  if ((0x200000002000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 170;
+                  break;
+               case 173:
+                  if ((0x200000002000L & l) != 0L && kind > 68)
+                     kind = 68;
+                  break;
+               case 174:
+                  if ((0x800000008L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 173;
+                  break;
+               case 176:
+                  if ((0x800000008L & l) != 0L && kind > 69)
+                     kind = 69;
+                  break;
+               case 177:
+                  if ((0x1000000010000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 176;
+                  break;
+               case 179:
+                  if ((0x400000004000L & l) != 0L && kind > 70)
+                     kind = 70;
+                  break;
+               case 180:
+                  if ((0x20000000200L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 179;
+                  break;
+               case 182:
+                  if ((0x100000001000000L & l) != 0L && kind > 71)
+                     kind = 71;
+                  break;
+               case 183:
+                  if ((0x1000000010000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 182;
+                  break;
+               case 185:
+                  if ((0x200000002000L & l) != 0L && kind > 72)
+                     kind = 72;
+                  break;
+               case 186:
+                  if ((0x2000000020L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 185;
+                  break;
+               case 188:
+                  if ((0x100000001000000L & l) != 0L && kind > 73)
+                     kind = 73;
+                  break;
+               case 189:
+                  if ((0x2000000020L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 188;
+                  break;
+               case 191:
+                  if ((0x8000000080L & l) != 0L && kind > 74)
+                     kind = 74;
+                  break;
+               case 192:
+                  if ((0x2000000020L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 191;
+                  break;
+               case 193:
+                  if ((0x1000000010L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 192;
+                  break;
+               case 195:
+                  if ((0x1000000010L & l) != 0L && kind > 75)
+                     kind = 75;
+                  break;
+               case 196:
+                  if ((0x200000002L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 195;
+                  break;
+               case 197:
+                  if ((0x4000000040000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 196;
+                  break;
+               case 199:
+                  if ((0x1000000010L & l) != 0L && kind > 76)
+                     kind = 76;
+                  break;
+               case 200:
+                  if ((0x200000002L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 199;
+                  break;
+               case 201:
+                  if ((0x4000000040000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 200;
+                  break;
+               case 202:
+                  if ((0x8000000080L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 201;
+                  break;
+               case 204:
+                  if ((0x8000000080000L & l) != 0L && kind > 77)
+                     kind = 77;
+                  break;
+               case 205:
+                  if ((0x200000002000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 204;
+                  break;
+               case 207:
+                  if ((0x8000000080000L & l) != 0L && kind > 78)
+                     kind = 78;
+                  break;
+               case 209:
+                  if ((0x400000004000000L & l) != 0L && kind > 79)
+                     kind = 79;
+                  break;
+               case 210:
+                  if ((0x10000000100L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 209;
+                  break;
+               case 212:
+                  if ((0x400000004000000L & l) != 0L && kind > 80)
+                     kind = 80;
+                  break;
+               case 213:
+                  if ((0x10000000100L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 212;
+                  break;
+               case 214:
+                  if ((0x80000000800L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 213;
+                  break;
+               case 217:
+                  if ((0x7fffffe07fffffeL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddTwoStates(218, 219);
+                  break;
+               case 218:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddTwoStates(218, 219);
+                  break;
+               case 219:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(220, 221);
+                  break;
+               case 220:
+                  if ((0x7fffffffffffffffL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddTwoStates(218, 219);
+                  break;
+               case 221:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(487, 490);
+                  break;
+               case 223:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(491, 497);
+                  break;
+               case 224:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(498, 500);
+                  break;
+               case 225:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(501, 504);
+                  break;
+               case 226:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(505, 509);
+                  break;
+               case 227:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(510, 515);
+                  break;
+               case 229:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(220, 230);
+                  break;
+               case 230:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(516, 519);
+                  break;
+               case 231:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(520, 526);
+                  break;
+               case 232:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(527, 529);
+                  break;
+               case 233:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(530, 533);
+                  break;
+               case 234:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(534, 538);
+                  break;
+               case 235:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddStates(539, 544);
+                  break;
+               case 236:
+                  if ((0x20000000200000L & l) != 0L)
+                     jjAddStates(810, 812);
+                  break;
+               case 238:
+               case 242:
+                  if ((0x7fffffffffffffffL & l) != 0L)
+                     jjCheckNAddStates(551, 554);
+                  break;
+               case 241:
+                  if (curChar == 92)
+                     jjAddStates(827, 828);
+                  break;
+               case 243:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(555, 559);
+                  break;
+               case 245:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(560, 567);
+                  break;
+               case 246:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(568, 571);
+                  break;
+               case 247:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(572, 576);
+                  break;
+               case 248:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(577, 582);
+                  break;
+               case 249:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(583, 589);
+                  break;
+               case 251:
+               case 256:
+                  if ((0x7fffffffffffffffL & l) != 0L)
+                     jjCheckNAddStates(590, 593);
+                  break;
+               case 253:
+                  if (curChar == 92)
+                     jjAddStates(829, 832);
+                  break;
+               case 255:
+                  if (curChar == 92)
+                     jjAddStates(833, 834);
+                  break;
+               case 257:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(594, 599);
+                  break;
+               case 259:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(600, 608);
+                  break;
+               case 260:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(609, 613);
+                  break;
+               case 261:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(614, 619);
+                  break;
+               case 262:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(620, 626);
+                  break;
+               case 263:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(627, 634);
+                  break;
+               case 268:
+               case 273:
+                  if ((0x7fffffffffffffffL & l) != 0L)
+                     jjCheckNAddStates(635, 638);
+                  break;
+               case 270:
+                  if (curChar == 92)
+                     jjAddStates(835, 838);
+                  break;
+               case 272:
+                  if (curChar == 92)
+                     jjAddStates(839, 840);
+                  break;
+               case 274:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(639, 644);
+                  break;
+               case 276:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(645, 653);
+                  break;
+               case 277:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(654, 658);
+                  break;
+               case 278:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(659, 664);
+                  break;
+               case 279:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(665, 671);
+                  break;
+               case 280:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(672, 679);
+                  break;
+               case 285:
+                  if ((0x100000001000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 237;
+                  break;
+               case 286:
+                  if ((0x4000000040000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 285;
+                  break;
+               case 294:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjAddStates(696, 701);
+                  break;
+               case 295:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 296;
+                  break;
+               case 296:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 297;
+                  break;
+               case 297:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAdd(298);
+                  break;
+               case 298:
+                  if ((0x7e0000007eL & l) != 0L && kind > 99)
+                     kind = 99;
+                  break;
+               case 299:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 300;
+                  break;
+               case 300:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 301;
+                  break;
+               case 301:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 302;
+                  break;
+               case 302:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjstateSet[jjnewStateCnt++] = 290;
+                  break;
+               case 303:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 304;
+                  break;
+               case 304:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 305;
+                  break;
+               case 305:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjstateSet[jjnewStateCnt++] = 306;
+                  break;
+               case 307:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 308;
+                  break;
+               case 308:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjstateSet[jjnewStateCnt++] = 309;
+                  break;
+               case 311:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjstateSet[jjnewStateCnt++] = 312;
+                  break;
+               case 320:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddTwoStates(321, 327);
+                  break;
+               case 322:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjstateSet[jjnewStateCnt++] = 323;
+                  break;
+               case 323:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddStates(712, 715);
+                  break;
+               case 324:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAdd(298);
+                  break;
+               case 325:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddTwoStates(298, 324);
+                  break;
+               case 326:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 99)
+                     kind = 99;
+                  jjCheckNAddStates(716, 718);
+                  break;
+               case 327:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(719, 723);
+                  break;
+               case 328:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAdd(321);
+                  break;
+               case 329:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddTwoStates(328, 321);
+                  break;
+               case 330:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(724, 726);
+                  break;
+               case 331:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(727, 730);
+                  break;
+               case 332:
+                  if (curChar == 92)
+                     jjCheckNAddStates(802, 805);
+                  break;
+               case 333:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(731, 734);
+                  break;
+               case 334:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(735, 741);
+                  break;
+               case 335:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(742, 744);
+                  break;
+               case 336:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(745, 748);
+                  break;
+               case 337:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(749, 753);
+                  break;
+               case 338:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddStates(754, 759);
+                  break;
+               case 339:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(760, 764);
+                  break;
+               case 340:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(765, 772);
+                  break;
+               case 342:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(773, 777);
+                  break;
+               case 343:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(778, 783);
+                  break;
+               case 344:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(784, 790);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 96:
+               case 100:
+                  if ((jjbitVec0[i2] & l2) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddTwoStates(98, 99);
+                  break;
+               case 402:
+               case 98:
+                  if ((jjbitVec0[i2] & l2) == 0L)
+                     break;
+                  if (kind > 88)
+                     kind = 88;
+                  jjCheckNAddTwoStates(98, 99);
+                  break;
+               case 401:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                  {
+                     if (kind > 60)
+                        kind = 60;
+                     jjCheckNAddTwoStates(117, 118);
+                  }
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjCheckNAddStates(5, 8);
+                  break;
+               case 4:
+                  if ((jjbitVec0[i2] & l2) == 0L)
+                     break;
+                  if (kind > 32)
+                     kind = 32;
+                  jjCheckNAddStates(796, 801);
+                  break;
+               case 2:
+                  if ((jjbitVec0[i2] & l2) != 0L && kind > 5)
+                     kind = 5;
+                  break;
+               case 9:
+               case 12:
+               case 20:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjCheckNAddStates(123, 125);
+                  break;
+               case 30:
+               case 35:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjCheckNAddStates(115, 118);
+                  break;
+               case 47:
+               case 52:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 66:
+               case 68:
+               case 76:
+                  if ((jjbitVec0[i2] & l2) == 0L)
+                     break;
+                  if (kind > 64)
+                     kind = 64;
+                  jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 85:
+               case 87:
+                  if ((jjbitVec0[i2] & l2) == 0L)
+                     break;
+                  if (kind > 82)
+                     kind = 82;
+                  jjCheckNAddTwoStates(85, 86);
+                  break;
+               case 117:
+               case 119:
+                  if ((jjbitVec0[i2] & l2) == 0L)
+                     break;
+                  if (kind > 60)
+                     kind = 60;
+                  jjCheckNAddTwoStates(117, 118);
+                  break;
+               case 127:
+               case 131:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjCheckNAddStates(5, 8);
+                  break;
+               case 218:
+               case 220:
+               case 228:
+                  if ((jjbitVec0[i2] & l2) == 0L)
+                     break;
+                  if (kind > 81)
+                     kind = 81;
+                  jjCheckNAddTwoStates(218, 219);
+                  break;
+               case 238:
+               case 242:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjCheckNAddStates(551, 554);
+                  break;
+               case 251:
+               case 256:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjCheckNAddStates(590, 593);
+                  break;
+               case 268:
+               case 273:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjCheckNAddStates(635, 638);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 400 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private int jjMoveStringLiteralDfa0_3()
+{
+   switch(curChar)
+   {
+      case 42:
+         return jjMoveStringLiteralDfa1_3(0x100L);
+      default :
+         return 1;
+   }
+}
+private int jjMoveStringLiteralDfa1_3(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 47:
+         if ((active0 & 0x100L) != 0L)
+            return jjStopAtPos(1, 8);
+         break;
+      default :
+         return 2;
+   }
+   return 2;
+}
+private int jjMoveStringLiteralDfa0_1()
+{
+   return jjMoveNfa_1(0, 0);
+}
+private int jjMoveNfa_1(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 4;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 0:
+                  if ((0xffffffffffffdbffL & l) != 0L)
+                  {
+                     if (kind > 3)
+                        kind = 3;
+                  }
+                  else if ((0x2400L & l) != 0L)
+                  {
+                     if (kind > 4)
+                        kind = 4;
+                  }
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 1:
+                  if ((0x2400L & l) != 0L && kind > 4)
+                     kind = 4;
+                  break;
+               case 2:
+                  if (curChar == 10 && kind > 4)
+                     kind = 4;
+                  break;
+               case 3:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 0:
+                  kind = 3;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 0:
+                  if ((jjbitVec0[i2] & l2) != 0L && kind > 3)
+                     kind = 3;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private int jjMoveStringLiteralDfa0_2()
+{
+   switch(curChar)
+   {
+      case 42:
+         return jjMoveStringLiteralDfa1_2(0x80L);
+      default :
+         return 1;
+   }
+}
+private int jjMoveStringLiteralDfa1_2(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 47:
+         if ((active0 & 0x80L) != 0L)
+            return jjStopAtPos(1, 7);
+         break;
+      default :
+         return 2;
+   }
+   return 2;
+}
+static final int[] jjnextStates = {
+   215, 216, 217, 228, 229, 127, 128, 129, 130, 346, 347, 348, 349, 350, 351, 165, 
+   352, 353, 354, 168, 355, 356, 357, 171, 358, 359, 360, 174, 361, 362, 363, 177, 
+   364, 365, 366, 180, 367, 368, 369, 183, 370, 371, 372, 186, 373, 374, 375, 189, 
+   376, 377, 378, 193, 379, 380, 381, 197, 382, 383, 384, 202, 385, 386, 387, 205, 
+   388, 389, 390, 207, 391, 392, 393, 210, 394, 395, 396, 214, 397, 398, 399, 216, 
+   217, 228, 229, 163, 164, 166, 169, 172, 175, 178, 181, 184, 187, 190, 194, 198, 
+   203, 206, 208, 211, 215, 159, 160, 140, 147, 148, 157, 64, 65, 76, 77, 47, 
+   48, 49, 51, 30, 31, 32, 34, 7, 8, 20, 21, 9, 10, 11, 9, 14, 
+   10, 11, 15, 9, 16, 14, 10, 11, 17, 18, 19, 9, 14, 10, 11, 9, 
+   16, 14, 10, 11, 9, 16, 14, 10, 11, 17, 9, 16, 14, 10, 11, 17, 
+   18, 14, 9, 10, 11, 23, 24, 14, 9, 10, 11, 25, 26, 27, 14, 9, 
+   10, 11, 24, 14, 9, 10, 11, 24, 14, 9, 10, 11, 25, 24, 14, 9, 
+   10, 11, 25, 26, 30, 37, 31, 32, 34, 38, 30, 39, 37, 31, 32, 34, 
+   40, 41, 42, 30, 37, 31, 32, 34, 30, 39, 37, 31, 32, 34, 30, 39, 
+   37, 31, 32, 34, 40, 30, 39, 37, 31, 32, 34, 40, 41, 47, 54, 48, 
+   49, 51, 55, 47, 56, 54, 48, 49, 51, 57, 58, 59, 47, 54, 48, 49, 
+   51, 47, 56, 54, 48, 49, 51, 47, 56, 54, 48, 49, 51, 57, 47, 56, 
+   54, 48, 49, 51, 57, 58, 66, 70, 67, 71, 66, 72, 70, 67, 73, 74, 
+   75, 66, 70, 67, 66, 72, 70, 67, 66, 72, 70, 67, 73, 66, 72, 70, 
+   67, 73, 74, 70, 66, 67, 79, 80, 70, 66, 67, 81, 82, 83, 70, 66, 
+   67, 80, 70, 66, 67, 80, 70, 66, 67, 81, 80, 70, 66, 67, 81, 82, 
+   85, 89, 86, 90, 85, 91, 89, 86, 92, 93, 94, 85, 89, 86, 85, 91, 
+   89, 86, 85, 91, 89, 86, 92, 85, 91, 89, 86, 92, 93, 98, 102, 99, 
+   103, 98, 104, 102, 99, 105, 106, 107, 98, 102, 99, 98, 104, 102, 99, 98, 
+   104, 102, 99, 105, 98, 104, 102, 99, 105, 106, 102, 98, 99, 111, 112, 102, 
+   98, 99, 113, 114, 115, 102, 98, 99, 112, 102, 98, 99, 112, 102, 98, 99, 
+   113, 112, 102, 98, 99, 113, 114, 117, 121, 118, 122, 117, 123, 121, 118, 124, 
+   125, 126, 117, 121, 118, 117, 123, 121, 118, 117, 123, 121, 118, 124, 117, 123, 
+   121, 118, 124, 125, 127, 129, 130, 133, 134, 127, 135, 129, 130, 133, 136, 137, 
+   138, 127, 129, 130, 133, 127, 135, 129, 130, 133, 127, 135, 129, 130, 133, 136, 
+   127, 135, 129, 130, 133, 136, 137, 218, 222, 219, 223, 218, 224, 222, 219, 225, 
+   226, 227, 218, 222, 219, 218, 224, 222, 219, 218, 224, 222, 219, 225, 218, 224, 
+   222, 219, 225, 226, 222, 218, 219, 231, 232, 222, 218, 219, 233, 234, 235, 222, 
+   218, 219, 232, 222, 218, 219, 232, 222, 218, 219, 233, 232, 222, 218, 219, 233, 
+   234, 238, 250, 267, 240, 241, 284, 238, 239, 240, 241, 238, 240, 241, 244, 245, 
+   238, 246, 240, 241, 244, 247, 248, 249, 238, 240, 241, 244, 238, 246, 240, 241, 
+   244, 238, 246, 240, 241, 244, 247, 238, 246, 240, 241, 244, 247, 248, 251, 252, 
+   253, 255, 251, 258, 252, 253, 255, 259, 251, 260, 258, 252, 253, 255, 261, 262, 
+   263, 251, 258, 252, 253, 255, 251, 260, 258, 252, 253, 255, 251, 260, 258, 252, 
+   253, 255, 261, 251, 260, 258, 252, 253, 255, 261, 262, 268, 269, 270, 272, 268, 
+   275, 269, 270, 272, 276, 268, 277, 275, 269, 270, 272, 278, 279, 280, 268, 275, 
+   269, 270, 272, 268, 277, 275, 269, 270, 272, 268, 277, 275, 269, 270, 272, 278, 
+   268, 277, 275, 269, 270, 272, 278, 279, 238, 250, 267, 239, 240, 241, 284, 288, 
+   294, 290, 291, 292, 293, 290, 291, 292, 295, 299, 303, 307, 311, 315, 290, 313, 
+   314, 290, 316, 317, 318, 290, 316, 317, 298, 324, 325, 326, 298, 324, 325, 328, 
+   321, 329, 330, 331, 328, 321, 329, 328, 321, 329, 330, 121, 117, 118, 334, 335, 
+   121, 117, 118, 336, 337, 338, 121, 117, 118, 335, 121, 117, 118, 335, 121, 117, 
+   118, 336, 335, 121, 117, 118, 336, 337, 127, 129, 130, 133, 340, 341, 127, 129, 
+   130, 133, 342, 343, 344, 341, 127, 129, 130, 133, 341, 127, 129, 130, 133, 342, 
+   341, 127, 129, 130, 133, 342, 343, 397, 216, 217, 228, 229, 117, 127, 128, 129, 
+   130, 118, 119, 333, 131, 339, 96, 97, 108, 109, 286, 287, 319, 33, 43, 45, 
+   44, 35, 36, 50, 60, 62, 61, 52, 53, 87, 88, 242, 243, 254, 264, 266, 
+   265, 256, 257, 271, 281, 283, 282, 273, 274, 
+};
+
+/** Token literal values. */
+public static final String[] jjstrLiteralImages = {
+"", null, null, null, null, null, null, null, null, null, "\74\41\55\55", 
+"\55\55\76", "\173", "\175", "\174\75", "\176\75", "\75", "\53", "\55", "\54", "\73", 
+"\76", "\57", "\133", "\135", "\52", "\46", "\56", "\50", "\51", "\72", null, null, 
+null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, null, null, null, null, null, null, null, null, null, null, null, null, };
+
+/** Lexer state names. */
+public static final String[] lexStateNames = {
+   "DEFAULT",
+   "IN_SINGLE_LINE_COMMENT",
+   "IN_FORMAL_COMMENT",
+   "IN_MULTI_LINE_COMMENT",
+};
+
+/** Lex State array. */
+public static final int[] jjnewLexState = {
+   -1, -1, 1, -1, 0, 2, 3, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+   -1, -1, 
+};
+static final long[] jjtoToken = {
+   0xbffffe01fffffc03L, 0x3803ffffffL, 
+};
+static final long[] jjtoSkip = {
+   0x190L, 0x0L, 
+};
+static final long[] jjtoSpecial = {
+   0x80L, 0x0L, 
+};
+static final long[] jjtoMore = {
+   0x26cL, 0x0L, 
+};
+protected CharStream input_stream;
+private final int[] jjrounds = new int[400];
+private final int[] jjstateSet = new int[800];
+private final StringBuilder jjimage = new StringBuilder();
+private StringBuilder image = jjimage;
+private int jjimageLen;
+private int lengthOfMatch;
+protected char curChar;
+/** Constructor. */
+public ParserTokenManager(CharStream stream){
+   input_stream = stream;
+}
+
+/** Constructor. */
+public ParserTokenManager(CharStream stream, int lexState){
+   this(stream);
+   SwitchTo(lexState);
+}
+
+/** Reinitialise parser. */
+public void ReInit(CharStream stream)
+{
+   jjmatchedPos = jjnewStateCnt = 0;
+   curLexState = defaultLexState;
+   input_stream = stream;
+   ReInitRounds();
+}
+private void ReInitRounds()
+{
+   int i;
+   jjround = 0x80000001;
+   for (i = 400; i-- > 0;)
+      jjrounds[i] = 0x80000000;
+}
+
+/** Reinitialise parser. */
+public void ReInit(CharStream stream, int lexState)
+{
+   ReInit(stream);
+   SwitchTo(lexState);
+}
+
+/** Switch to specified lex state. */
+public void SwitchTo(int lexState)
+{
+   if (lexState >= 4 || lexState < 0)
+      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
+   else
+      curLexState = lexState;
+}
+
+protected Token jjFillToken()
+{
+   final Token t;
+   final String curTokenImage;
+   final int beginLine;
+   final int endLine;
+   final int beginColumn;
+   final int endColumn;
+   String im = jjstrLiteralImages[jjmatchedKind];
+   curTokenImage = (im == null) ? input_stream.GetImage() : im;
+   beginLine = input_stream.getBeginLine();
+   beginColumn = input_stream.getBeginColumn();
+   endLine = input_stream.getEndLine();
+   endColumn = input_stream.getEndColumn();
+   t = Token.newToken(jjmatchedKind, curTokenImage);
+
+   t.beginLine = beginLine;
+   t.endLine = endLine;
+   t.beginColumn = beginColumn;
+   t.endColumn = endColumn;
+
+   return t;
+}
+
+int curLexState = 0;
+int defaultLexState = 0;
+int jjnewStateCnt;
+int jjround;
+int jjmatchedPos;
+int jjmatchedKind;
+
+/** Get the next Token. */
+public Token getNextToken() 
+{
+  Token specialToken = null;
+  Token matchedToken;
+  int curPos = 0;
+
+  EOFLoop :
+  for (;;)
+  {
+   try
+   {
+      curChar = input_stream.BeginToken();
+   }
+   catch(java.io.IOException e)
+   {
+      jjmatchedKind = 0;
+      matchedToken = jjFillToken();
+      matchedToken.specialToken = specialToken;
+      return matchedToken;
+   }
+   image = jjimage;
+   image.setLength(0);
+   jjimageLen = 0;
+
+   for (;;)
+   {
+     switch(curLexState)
+     {
+       case 0:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_0();
+         if (jjmatchedPos == 0 && jjmatchedKind > 101)
+         {
+            jjmatchedKind = 101;
+         }
+         break;
+       case 1:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_1();
+         break;
+       case 2:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_2();
+         if (jjmatchedPos == 0 && jjmatchedKind > 9)
+         {
+            jjmatchedKind = 9;
+         }
+         break;
+       case 3:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_3();
+         if (jjmatchedPos == 0 && jjmatchedKind > 9)
+         {
+            jjmatchedKind = 9;
+         }
+         break;
+     }
+     if (jjmatchedKind != 0x7fffffff)
+     {
+        if (jjmatchedPos + 1 < curPos)
+           input_stream.backup(curPos - jjmatchedPos - 1);
+        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+        {
+           matchedToken = jjFillToken();
+           matchedToken.specialToken = specialToken;
+           TokenLexicalActions(matchedToken);
+       if (jjnewLexState[jjmatchedKind] != -1)
+         curLexState = jjnewLexState[jjmatchedKind];
+           return matchedToken;
+        }
+        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+        {
+           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+           {
+              matchedToken = jjFillToken();
+              if (specialToken == null)
+                 specialToken = matchedToken;
+              else
+              {
+                 matchedToken.specialToken = specialToken;
+                 specialToken = (specialToken.next = matchedToken);
+              }
+              SkipLexicalActions(matchedToken);
+           }
+           else
+              SkipLexicalActions(null);
+         if (jjnewLexState[jjmatchedKind] != -1)
+           curLexState = jjnewLexState[jjmatchedKind];
+           continue EOFLoop;
+        }
+        MoreLexicalActions();
+      if (jjnewLexState[jjmatchedKind] != -1)
+        curLexState = jjnewLexState[jjmatchedKind];
+        curPos = 0;
+        jjmatchedKind = 0x7fffffff;
+        try {
+           curChar = input_stream.readChar();
+           continue;
+        }
+        catch (java.io.IOException e1) { }
+     }
+     int error_line = input_stream.getEndLine();
+     int error_column = input_stream.getEndColumn();
+     String error_after = null;
+     boolean EOFSeen = false;
+     try { input_stream.readChar(); input_stream.backup(1); }
+     catch (java.io.IOException e1) {
+        EOFSeen = true;
+        error_after = curPos <= 1 ? "" : input_stream.GetImage();
+        if (curChar == '\n' || curChar == '\r') {
+           error_line++;
+           error_column = 0;
+        }
+        else
+           error_column++;
+     }
+     if (!EOFSeen) {
+        input_stream.backup(1);
+        error_after = curPos <= 1 ? "" : input_stream.GetImage();
+     }
+     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
+   }
+  }
+}
+
+void SkipLexicalActions(Token matchedToken)
+{
+   switch(jjmatchedKind)
+   {
+      default :
+         break;
+   }
+}
+void MoreLexicalActions()
+{
+   jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
+   switch(jjmatchedKind)
+   {
+      case 5 :
+         image.append(input_stream.GetSuffix(jjimageLen));
+         jjimageLen = 0;
+                   input_stream.backup(1);
+         break;
+      default :
+         break;
+   }
+}
+void TokenLexicalActions(Token matchedToken)
+{
+   switch(jjmatchedKind)
+   {
+      case 1 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+          image = Parser.SPACE;
+         break;
+      default :
+         break;
+   }
+}
+private void jjCheckNAdd(int state)
+{
+   if (jjrounds[state] != jjround)
+   {
+      jjstateSet[jjnewStateCnt++] = state;
+      jjrounds[state] = jjround;
+   }
+}
+private void jjAddStates(int start, int end)
+{
+   do {
+      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
+   } while (start++ != end);
+}
+private void jjCheckNAddTwoStates(int state1, int state2)
+{
+   jjCheckNAdd(state1);
+   jjCheckNAdd(state2);
+}
+
+private void jjCheckNAddStates(int start, int end)
+{
+   do {
+      jjCheckNAdd(jjnextStates[start]);
+   } while (start++ != end);
+}
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/SCSSLexicalUnit.java b/theme-compiler/src/com/vaadin/sass/parser/SCSSLexicalUnit.java
new file mode 100644
index 0000000000..8c2fa4018d
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/SCSSLexicalUnit.java
@@ -0,0 +1,16 @@
+package com.vaadin.sass.parser;
+
+import org.w3c.css.sac.LexicalUnit;
+
+public interface SCSSLexicalUnit extends LexicalUnit {
+    static final short SCSS_VARIABLE = 100;
+
+    LexicalUnitImpl divide(LexicalUnitImpl denominator);
+
+    LexicalUnitImpl add(LexicalUnitImpl another);
+
+    LexicalUnitImpl minus(LexicalUnitImpl another);
+
+    LexicalUnitImpl multiply(LexicalUnitImpl another);
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/SelectorListImpl.java b/theme-compiler/src/com/vaadin/sass/parser/SelectorListImpl.java
new file mode 100644
index 0000000000..634fe57647
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/SelectorListImpl.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 1999 World Wide Web Consortium,
+ * (Massachusetts Institute of Technology, Institut National de
+ * Recherche en Informatique et en Automatique, Keio University). All
+ * Rights Reserved. This program is distributed under the W3C's Software
+ * Intellectual Property License. This program is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
+ *
+ * $Id: SelectorListImpl.java,v 1.1 2000/08/07 01:16:21 plehegar Exp $
+ */
+package com.vaadin.sass.parser;
+
+import org.w3c.css.sac.Selector;
+import org.w3c.css.sac.SelectorList;
+
+/**
+ * @version $Revision: 1.1 $
+ * @author Philippe Le Hegaret
+ */
+public class SelectorListImpl implements SelectorList {
+
+    Selector[] selectors = new Selector[5];
+    int current;
+
+    @Override
+    public Selector item(int index) {
+        if ((index < 0) || (index >= current)) {
+            return null;
+        }
+        return selectors[index];
+    }
+
+    public Selector itemSelector(int index) {
+        if ((index < 0) || (index >= current)) {
+            return null;
+        }
+        return selectors[index];
+    }
+
+    @Override
+    public int getLength() {
+        return current;
+    }
+
+    public void addSelector(Selector selector) {
+        if (current == selectors.length) {
+            Selector[] old = selectors;
+            selectors = new Selector[old.length + old.length];
+            System.arraycopy(old, 0, selectors, 0, old.length);
+        }
+        selectors[current++] = selector;
+    }
+
+    public void replaceSelector(int index, Selector selector) {
+        if ((index >= 0) && (index < current)) {
+            selectors[index] = selector;
+        }
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/Selectors.java b/theme-compiler/src/com/vaadin/sass/parser/Selectors.java
new file mode 100644
index 0000000000..bec8d66294
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/Selectors.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 1999 World Wide Web Consortium,
+ * (Massachusetts Institute of Technology, Institut National de
+ * Recherche en Informatique et en Automatique, Keio University). All
+ * Rights Reserved. This program is distributed under the W3C's Software
+ * Intellectual Property License. This program is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
+ *
+ * $Id: Selectors.java,v 1.1 2000/02/14 16:58:31 plehegar Exp $
+ */
+package com.vaadin.sass.parser;
+
+import org.w3c.css.sac.SelectorList;
+import org.w3c.css.sac.Selector;
+
+/**
+ * @version $Revision: 1.1 $
+ * @author  Philippe Le Hegaret
+ */
+class Selectors implements SelectorList {
+
+    Selector[] selectors = new Selector[5];
+    int      current;
+
+    public Selector item(int index) {
+	if ((index < 0) || (index >= current)) {
+	    return null;
+	}
+	return selectors[index];
+    }
+
+    public Selector itemSelector(int index) {
+	if ((index < 0) || (index >= current)) {
+	    return null;
+	}
+	return selectors[index];
+    }
+
+    public int getLength() {
+	return current;
+    }
+
+    void addSelector(Selector selector) {
+	if (current == selectors.length) {
+	    Selector[] old = selectors;
+	    selectors = new Selector[old.length + old.length];
+	    System.arraycopy(old, 0, selectors, 0, old.length);
+	}
+	selectors[current++] = selector;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/ThrowedParseException.java b/theme-compiler/src/com/vaadin/sass/parser/ThrowedParseException.java
new file mode 100644
index 0000000000..5c1a9e8f33
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/ThrowedParseException.java
@@ -0,0 +1,26 @@
+/*
+ * (c) COPYRIGHT 1999 World Wide Web Consortium
+ * (Massachusetts Institute of Technology, Institut National de Recherche
+ *  en Informatique et en Automatique, Keio University).
+ * All Rights Reserved. http://www.w3.org/Consortium/Legal/
+ *
+ * $Id: ThrowedParseException.java,v 1.1 1999/06/09 15:21:33 plehegar Exp $
+ */
+package com.vaadin.sass.parser;
+
+/**
+ * @version $Revision: 1.1 $
+ * @author Philippe Le Hegaret
+ */
+class ThrowedParseException extends RuntimeException {
+    private static final long serialVersionUID = -7926371344505913546L;
+
+    ParseException e;
+
+    /**
+     * Creates a new ThrowedParseException
+     */
+    ThrowedParseException(ParseException e) {
+        this.e = e;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/parser/Token.java b/theme-compiler/src/com/vaadin/sass/parser/Token.java
new file mode 100644
index 0000000000..554b97896e
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/Token.java
@@ -0,0 +1,131 @@
+/* Generated By:JavaCC: Do not edit this line. Token.java Version 5.0 */
+/* JavaCCOptions:TOKEN_EXTENDS=,KEEP_LINE_COL=null,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
+package com.vaadin.sass.parser;
+
+/**
+ * Describes the input token stream.
+ */
+
+public class Token implements java.io.Serializable {
+
+  /**
+   * The version identifier for this Serializable class.
+   * Increment only if the <i>serialized</i> form of the
+   * class changes.
+   */
+  private static final long serialVersionUID = 1L;
+
+  /**
+   * An integer that describes the kind of this token.  This numbering
+   * system is determined by JavaCCParser, and a table of these numbers is
+   * stored in the file ...Constants.java.
+   */
+  public int kind;
+
+  /** The line number of the first character of this Token. */
+  public int beginLine;
+  /** The column number of the first character of this Token. */
+  public int beginColumn;
+  /** The line number of the last character of this Token. */
+  public int endLine;
+  /** The column number of the last character of this Token. */
+  public int endColumn;
+
+  /**
+   * The string image of the token.
+   */
+  public String image;
+
+  /**
+   * A reference to the next regular (non-special) token from the input
+   * stream.  If this is the last token from the input stream, or if the
+   * token manager has not read tokens beyond this one, this field is
+   * set to null.  This is true only if this token is also a regular
+   * token.  Otherwise, see below for a description of the contents of
+   * this field.
+   */
+  public Token next;
+
+  /**
+   * This field is used to access special tokens that occur prior to this
+   * token, but after the immediately preceding regular (non-special) token.
+   * If there are no such special tokens, this field is set to null.
+   * When there are more than one such special token, this field refers
+   * to the last of these special tokens, which in turn refers to the next
+   * previous special token through its specialToken field, and so on
+   * until the first special token (whose specialToken field is null).
+   * The next fields of special tokens refer to other special tokens that
+   * immediately follow it (without an intervening regular token).  If there
+   * is no such token, this field is null.
+   */
+  public Token specialToken;
+
+  /**
+   * An optional attribute value of the Token.
+   * Tokens which are not used as syntactic sugar will often contain
+   * meaningful values that will be used later on by the compiler or
+   * interpreter. This attribute value is often different from the image.
+   * Any subclass of Token that actually wants to return a non-null value can
+   * override this method as appropriate.
+   */
+  public Object getValue() {
+    return null;
+  }
+
+  /**
+   * No-argument constructor
+   */
+  public Token() {}
+
+  /**
+   * Constructs a new token for the specified Image.
+   */
+  public Token(int kind)
+  {
+    this(kind, null);
+  }
+
+  /**
+   * Constructs a new token for the specified Image and Kind.
+   */
+  public Token(int kind, String image)
+  {
+    this.kind = kind;
+    this.image = image;
+  }
+
+  /**
+   * Returns the image.
+   */
+  public String toString()
+  {
+    return image;
+  }
+
+  /**
+   * Returns a new Token object, by default. However, if you want, you
+   * can create and return subclass objects based on the value of ofKind.
+   * Simply add the cases to the switch for all those special cases.
+   * For example, if you have a subclass of Token called IDToken that
+   * you want to create if ofKind is ID, simply add something like :
+   *
+   *    case MyParserConstants.ID : return new IDToken(ofKind, image);
+   *
+   * to the following switch statement. Then you can cast matchedToken
+   * variable to the appropriate type and use sit in your lexical actions.
+   */
+  public static Token newToken(int ofKind, String image)
+  {
+    switch(ofKind)
+    {
+      default : return new Token(ofKind, image);
+    }
+  }
+
+  public static Token newToken(int ofKind)
+  {
+    return newToken(ofKind, null);
+  }
+
+}
+/* JavaCC - OriginalChecksum=fd921a11cd37e391729b9460c71d3ad6 (do not edit this line) */
diff --git a/theme-compiler/src/com/vaadin/sass/parser/TokenMgrError.java b/theme-compiler/src/com/vaadin/sass/parser/TokenMgrError.java
new file mode 100644
index 0000000000..311bf0d9b3
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/parser/TokenMgrError.java
@@ -0,0 +1,147 @@
+/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 5.0 */
+/* JavaCCOptions: */
+package com.vaadin.sass.parser;
+
+/** Token Manager Error. */
+public class TokenMgrError extends Error
+{
+
+  /**
+   * The version identifier for this Serializable class.
+   * Increment only if the <i>serialized</i> form of the
+   * class changes.
+   */
+  private static final long serialVersionUID = 1L;
+
+  /*
+   * Ordinals for various reasons why an Error of this type can be thrown.
+   */
+
+  /**
+   * Lexical error occurred.
+   */
+  static final int LEXICAL_ERROR = 0;
+
+  /**
+   * An attempt was made to create a second instance of a static token manager.
+   */
+  static final int STATIC_LEXER_ERROR = 1;
+
+  /**
+   * Tried to change to an invalid lexical state.
+   */
+  static final int INVALID_LEXICAL_STATE = 2;
+
+  /**
+   * Detected (and bailed out of) an infinite loop in the token manager.
+   */
+  static final int LOOP_DETECTED = 3;
+
+  /**
+   * Indicates the reason why the exception is thrown. It will have
+   * one of the above 4 values.
+   */
+  int errorCode;
+
+  /**
+   * Replaces unprintable characters by their escaped (or unicode escaped)
+   * equivalents in the given string
+   */
+  protected static final String addEscapes(String str) {
+    StringBuffer retval = new StringBuffer();
+    char ch;
+    for (int i = 0; i < str.length(); i++) {
+      switch (str.charAt(i))
+      {
+        case 0 :
+          continue;
+        case '\b':
+          retval.append("\\b");
+          continue;
+        case '\t':
+          retval.append("\\t");
+          continue;
+        case '\n':
+          retval.append("\\n");
+          continue;
+        case '\f':
+          retval.append("\\f");
+          continue;
+        case '\r':
+          retval.append("\\r");
+          continue;
+        case '\"':
+          retval.append("\\\"");
+          continue;
+        case '\'':
+          retval.append("\\\'");
+          continue;
+        case '\\':
+          retval.append("\\\\");
+          continue;
+        default:
+          if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
+            String s = "0000" + Integer.toString(ch, 16);
+            retval.append("\\u" + s.substring(s.length() - 4, s.length()));
+          } else {
+            retval.append(ch);
+          }
+          continue;
+      }
+    }
+    return retval.toString();
+  }
+
+  /**
+   * Returns a detailed message for the Error when it is thrown by the
+   * token manager to indicate a lexical error.
+   * Parameters :
+   *    EOFSeen     : indicates if EOF caused the lexical error
+   *    curLexState : lexical state in which this error occurred
+   *    errorLine   : line number when the error occurred
+   *    errorColumn : column number when the error occurred
+   *    errorAfter  : prefix that was seen before this error occurred
+   *    curchar     : the offending character
+   * Note: You can customize the lexical error message by modifying this method.
+   */
+  protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) {
+    return("Lexical error at line " +
+          errorLine + ", column " +
+          errorColumn + ".  Encountered: " +
+          (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") +
+          "after : \"" + addEscapes(errorAfter) + "\"");
+  }
+
+  /**
+   * You can also modify the body of this method to customize your error messages.
+   * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
+   * of end-users concern, so you can return something like :
+   *
+   *     "Internal Error : Please file a bug report .... "
+   *
+   * from this method for such cases in the release version of your parser.
+   */
+  public String getMessage() {
+    return super.getMessage();
+  }
+
+  /*
+   * Constructors of various flavors follow.
+   */
+
+  /** No arg constructor. */
+  public TokenMgrError() {
+  }
+
+  /** Constructor with message and reason. */
+  public TokenMgrError(String message, int reason) {
+    super(message);
+    errorCode = reason;
+  }
+
+  /** Full Constructor. */
+  public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) {
+    this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason);
+  }
+}
+/* JavaCC - OriginalChecksum=7d5524d89510a94f7c2ac022e99c24c3 (do not edit this line) */
diff --git a/theme-compiler/src/com/vaadin/sass/resolver/ClassloaderResolver.java b/theme-compiler/src/com/vaadin/sass/resolver/ClassloaderResolver.java
new file mode 100644
index 0000000000..84ac6dc530
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/resolver/ClassloaderResolver.java
@@ -0,0 +1,39 @@
+package com.vaadin.sass.resolver;
+
+import java.io.InputStream;
+
+import org.w3c.css.sac.InputSource;
+
+public class ClassloaderResolver implements ScssStylesheetResolver {
+
+    @Override
+    public InputSource resolve(String identifier) {
+        // identifier should not have .scss, fileName should
+        String ext = ".scss";
+        if (identifier.endsWith(".css")) {
+            ext = ".css";
+        }
+        String fileName = identifier;
+        if (identifier.endsWith(ext)) {
+            identifier = identifier.substring(0,
+                    identifier.length() - ext.length());
+        } else {
+            fileName = fileName + ext;
+        }
+
+        // Can the classloader find it?
+        InputStream is = getClass().getClassLoader().getResourceAsStream(
+                fileName);
+        if (is != null) {
+            InputSource source = new InputSource();
+            source.setByteStream(is);
+            source.setURI(fileName);
+            return source;
+
+        } else {
+            return null;
+        }
+
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/resolver/FilesystemResolver.java b/theme-compiler/src/com/vaadin/sass/resolver/FilesystemResolver.java
new file mode 100644
index 0000000000..2c6b92430f
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/resolver/FilesystemResolver.java
@@ -0,0 +1,40 @@
+package com.vaadin.sass.resolver;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+
+import org.w3c.css.sac.InputSource;
+
+public class FilesystemResolver implements ScssStylesheetResolver {
+
+    @Override
+    public InputSource resolve(String identifier) {
+        // identifier should not have .scss, fileName should
+        String ext = ".scss";
+        if (identifier.endsWith(".css")) {
+            ext = ".css";
+        }
+        String fileName = identifier;
+        if (identifier.endsWith(ext)) {
+            identifier = identifier.substring(0,
+                    identifier.length() - ext.length());
+        } else {
+            fileName = fileName + ext;
+        }
+
+        try {
+            InputStream is = new FileInputStream(fileName);
+            InputSource source = new InputSource();
+            source.setByteStream(is);
+            source.setURI(fileName);
+            return source;
+
+        } catch (FileNotFoundException e) {
+            // not found, try something else
+            return null;
+        }
+
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/resolver/ScssStylesheetResolver.java b/theme-compiler/src/com/vaadin/sass/resolver/ScssStylesheetResolver.java
new file mode 100644
index 0000000000..c3b0e75979
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/resolver/ScssStylesheetResolver.java
@@ -0,0 +1,19 @@
+package com.vaadin.sass.resolver;
+
+import org.w3c.css.sac.InputSource;
+
+public interface ScssStylesheetResolver {
+    /**
+     * Called with the "identifier" of a stylesheet that the resolver should try
+     * to find. The identifier is basically a filename, like "runo.scss" or
+     * "addon/styles.scss", but might exclude ".scss". The resolver must
+     * {@link InputSource#setURI(String)} to the final location where the
+     * stylesheet was found, e.g "runo.scss" might result in a URI like
+     * "VAADIN/themes/runo/runo.scss".
+     * 
+     * @param identifier
+     *            used fo find stylesheet
+     * @return InputSource for stylesheet (with URI set) or null if not found
+     */
+    public InputSource resolve(String identifier);
+}
\ No newline at end of file
diff --git a/theme-compiler/src/com/vaadin/sass/resolver/VaadinResolver.java b/theme-compiler/src/com/vaadin/sass/resolver/VaadinResolver.java
new file mode 100644
index 0000000000..93fdf6bfec
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/resolver/VaadinResolver.java
@@ -0,0 +1,46 @@
+package com.vaadin.sass.resolver;
+
+import org.w3c.css.sac.InputSource;
+
+public class VaadinResolver implements ScssStylesheetResolver {
+
+    @Override
+    public InputSource resolve(String identifier) {
+        String ext = ".scss";
+        if (identifier.endsWith(".css")) {
+            ext = ".css";
+        }
+
+        // 'normalize' identifier to use in themeFile
+        String fileName = identifier;
+        if (identifier.endsWith(ext)) {
+            identifier = identifier.substring(0,
+                    identifier.length() - ext.length());
+        }
+        // also look here
+        String themeFile = "VAADIN/themes/" + identifier + "/" + fileName;
+
+        // first plain file
+        ScssStylesheetResolver resolver = new FilesystemResolver();
+        InputSource source = resolver.resolve(fileName);
+
+        if (source == null) {
+            // then file in theme
+            source = resolver.resolve(themeFile);
+        }
+
+        if (source == null) {
+            // then plain via classloader
+            resolver = new ClassloaderResolver();
+            source = resolver.resolve(identifier);
+
+        }
+        if (source == null) {
+            // then try theme via classloader
+            source = resolver.resolve(themeFile);
+        }
+
+        return source;
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/selector/CompositeSelector.java b/theme-compiler/src/com/vaadin/sass/selector/CompositeSelector.java
new file mode 100644
index 0000000000..f187cf8f6b
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/selector/CompositeSelector.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.selector;
+
+import org.w3c.css.sac.Selector;
+
+public class CompositeSelector implements Selector {
+    public static final short SCSS_COMPOSITE_SELECTOR = 100;
+    private Selector first;
+    private Selector second;
+
+    public CompositeSelector(Selector first, Selector second) {
+        this.first = first;
+        this.second = second;
+    }
+
+    public Selector getFirst() {
+        return first;
+    }
+
+    public Selector getSecond() {
+        return second;
+    }
+
+    @Override
+    public short getSelectorType() {
+        return SCSS_COMPOSITE_SELECTOR;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/selector/SelectorUtil.java b/theme-compiler/src/com/vaadin/sass/selector/SelectorUtil.java
new file mode 100644
index 0000000000..d93f37c175
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/selector/SelectorUtil.java
@@ -0,0 +1,308 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.selector;
+
+import org.w3c.css.sac.CombinatorCondition;
+import org.w3c.css.sac.Condition;
+import org.w3c.css.sac.ConditionFactory;
+import org.w3c.css.sac.ConditionalSelector;
+import org.w3c.css.sac.DescendantSelector;
+import org.w3c.css.sac.ElementSelector;
+import org.w3c.css.sac.Selector;
+import org.w3c.css.sac.SelectorFactory;
+import org.w3c.css.sac.SelectorList;
+import org.w3c.css.sac.SiblingSelector;
+import org.w3c.css.sac.SimpleSelector;
+import org.w3c.flute.parser.selectors.AndConditionImpl;
+import org.w3c.flute.parser.selectors.AttributeConditionImpl;
+import org.w3c.flute.parser.selectors.ClassConditionImpl;
+import org.w3c.flute.parser.selectors.ConditionFactoryImpl;
+import org.w3c.flute.parser.selectors.DirectAdjacentSelectorImpl;
+import org.w3c.flute.parser.selectors.ElementSelectorImpl;
+import org.w3c.flute.parser.selectors.IdConditionImpl;
+import org.w3c.flute.parser.selectors.PseudoClassConditionImpl;
+import org.w3c.flute.parser.selectors.PseudoElementSelectorImpl;
+import org.w3c.flute.parser.selectors.SelectorFactoryImpl;
+
+import com.vaadin.sass.parser.SelectorListImpl;
+
+public class SelectorUtil {
+
+    public static String toString(CompositeSelector compositeSelector) {
+        StringBuilder builder = new StringBuilder();
+        if (compositeSelector != null) {
+            if (compositeSelector.getFirst() != null) {
+                builder.append(toString(compositeSelector.getFirst())).append(
+                        " ");
+            }
+            if (compositeSelector.getSecond() != null) {
+                builder.append(toString(compositeSelector.getSecond()));
+            }
+        }
+        return builder.toString();
+    }
+
+    public static String toString(SelectorList selectorList) {
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int i = 0; i < selectorList.getLength(); i++) {
+            String selectorString = toString(selectorList.item(i));
+            stringBuilder.append(selectorString);
+            if (selectorList.getLength() > i + 1) {
+                stringBuilder.append(", ");
+            }
+        }
+        return stringBuilder.toString();
+    }
+
+    public static String toString(Selector selector) {
+        if (selector == null) {
+            return "";
+        }
+        if (selector.getSelectorType() == Selector.SAC_CONDITIONAL_SELECTOR) {
+            StringBuilder stringBuilder = new StringBuilder();
+            ConditionalSelector conditionalSelector = (ConditionalSelector) selector;
+            String simpleSelectorString = toString(conditionalSelector
+                    .getSimpleSelector());
+            if (simpleSelectorString != null) {
+                stringBuilder.append(simpleSelectorString);
+            }
+            String conditionString = getConditionString(conditionalSelector
+                    .getCondition());
+            stringBuilder.append(conditionString);
+            return stringBuilder.toString();
+        } else if (selector.getSelectorType() == Selector.SAC_DESCENDANT_SELECTOR) {
+            return getDecendantSelectorString((DescendantSelector) selector,
+                    " ");
+        } else if (selector.getSelectorType() == Selector.SAC_CHILD_SELECTOR) {
+            DescendantSelector childSelector = (DescendantSelector) selector;
+            String seperator = " > ";
+            if (childSelector.getSimpleSelector() instanceof PseudoElementSelectorImpl) {
+                seperator = "::";
+            }
+            return getDecendantSelectorString((DescendantSelector) selector,
+                    seperator);
+        } else if (selector.getSelectorType() == Selector.SAC_ELEMENT_NODE_SELECTOR) {
+            ElementSelectorImpl elementSelector = (ElementSelectorImpl) selector;
+            return elementSelector.getLocalName() == null ? ""
+                    : elementSelector.getLocalName();
+        } else if (selector.getSelectorType() == Selector.SAC_DIRECT_ADJACENT_SELECTOR) {
+            DirectAdjacentSelectorImpl directAdjacentSelector = (DirectAdjacentSelectorImpl) selector;
+            StringBuilder stringBuilder = new StringBuilder();
+            stringBuilder
+                    .append(toString(directAdjacentSelector.getSelector()));
+            stringBuilder.append(" + ");
+            stringBuilder.append(toString(directAdjacentSelector
+                    .getSiblingSelector()));
+            return stringBuilder.toString();
+        } else if (selector.getSelectorType() == Selector.SAC_PSEUDO_ELEMENT_SELECTOR) {
+            PseudoElementSelectorImpl pseudoElementSelectorImpl = (PseudoElementSelectorImpl) selector;
+            return pseudoElementSelectorImpl.getLocalName();
+        } else if (selector.getSelectorType() == CompositeSelector.SCSS_COMPOSITE_SELECTOR) {
+            return toString((CompositeSelector) selector);
+        } else {
+            System.out.println("SU !Unknown selector type, type: "
+                    + selector.getSelectorType() + ", " + selector.toString());
+        }
+        return "";
+    }
+
+    private static String getDecendantSelectorString(
+            DescendantSelector selector, String separator) {
+        StringBuilder stringBuilder = new StringBuilder();
+        String ancestor = toString(selector.getAncestorSelector());
+        String simpleSelector = toString(selector.getSimpleSelector());
+        stringBuilder.append(ancestor);
+        stringBuilder.append(separator);
+        stringBuilder.append(simpleSelector);
+        return stringBuilder.toString();
+    }
+
+    private static String getConditionString(Condition condition) {
+        short conditionType = condition.getConditionType();
+        if (conditionType == Condition.SAC_CLASS_CONDITION) {
+            ClassConditionImpl classCondition = (ClassConditionImpl) condition;
+            return "." + classCondition.getValue();
+        } else if (conditionType == Condition.SAC_ID_CONDITION) {
+            IdConditionImpl idCondition = (IdConditionImpl) condition;
+            return "#" + idCondition.getValue();
+        } else if (conditionType == Condition.SAC_AND_CONDITION) {
+            AndConditionImpl andCondition = (AndConditionImpl) condition;
+            return getConditionString(andCondition.getFirstCondition())
+                    + getConditionString(andCondition.getSecondCondition());
+        } else if (conditionType == Condition.SAC_ATTRIBUTE_CONDITION) {
+            AttributeConditionImpl attributeCondition = (AttributeConditionImpl) condition;
+            StringBuilder string = new StringBuilder();
+            string.append('[');
+            string.append(attributeCondition.getLocalName());
+            String value = attributeCondition.getValue();
+            if ("true".equals(value) || "false".equals(value)) {
+                string.append("=").append(value).append(']');
+            } else {
+                string.append("=\"");
+                string.append(attributeCondition.getValue());
+                string.append("\"]");
+            }
+            return string.toString();
+        } else if (conditionType == Condition.SAC_PSEUDO_CLASS_CONDITION) {
+            PseudoClassConditionImpl pseudoClassCondition = (PseudoClassConditionImpl) condition;
+            return ":" + pseudoClassCondition.getValue();
+        } else {
+            System.out.println("CU !condition type not identified, type: "
+                    + conditionType + ", " + condition.toString());
+            return "";
+        }
+    }
+
+    public static boolean hasParentSelector(SelectorList selectorList) {
+        String selectorString = toString(selectorList);
+        return selectorString.contains("&");
+    }
+
+    public static SelectorList createNewSelectorListFromAnOldOneWithSomPartReplaced(
+            SelectorList oldList, String toBeReplacedSelectorName,
+            SelectorList candidateSelectorList) throws Exception {
+        if (candidateSelectorList.getLength() != 1) {
+            throw new Exception("Candidate selector should not be a list");
+        }
+        if (!(candidateSelectorList.item(0) instanceof SimpleSelector)) {
+            throw new Exception(
+                    "Candidate selector should only be a SimpleSelector");
+        }
+        SelectorListImpl newSelectorList = new SelectorListImpl();
+        SimpleSelector candidateSelector = (SimpleSelector) candidateSelectorList
+                .item(0);
+        for (int i = 0; i < oldList.getLength(); i++) {
+            Selector selector = oldList.item(i);
+            newSelectorList.addSelector(createSelectorWithSomePartReplaced(
+                    selector, toBeReplacedSelectorName, candidateSelector));
+        }
+        return newSelectorList;
+    }
+
+    private static Selector createSelectorWithSomePartReplaced(
+            Selector selector, String toBeReplacedSelectorName,
+            SimpleSelector candidateSelector) {
+        if (!toString(selector).contains(toBeReplacedSelectorName)) {
+            return selector;
+        }
+        SelectorFactory factory = new SelectorFactoryImpl();
+        if (selector instanceof SimpleSelector) {
+            return createSimpleSelectorWithSomePartReplaced(
+                    (SimpleSelector) selector, toBeReplacedSelectorName,
+                    candidateSelector);
+        } else if (selector instanceof DescendantSelector) {
+            DescendantSelector descendantSelector = (DescendantSelector) selector;
+            Selector ancestor = descendantSelector.getAncestorSelector();
+            SimpleSelector simpleSelector = descendantSelector
+                    .getSimpleSelector();
+            return factory.createDescendantSelector(
+                    createSelectorWithSomePartReplaced(ancestor,
+                            toBeReplacedSelectorName, candidateSelector),
+                    createSimpleSelectorWithSomePartReplaced(simpleSelector,
+                            toBeReplacedSelectorName, candidateSelector));
+        } else if (selector instanceof DirectAdjacentSelectorImpl) {
+            SiblingSelector siblingSelector = (SiblingSelector) selector;
+            Selector ancestor = siblingSelector.getSelector();
+            SimpleSelector simpleSelector = siblingSelector
+                    .getSiblingSelector();
+            return factory.createDirectAdjacentSelector(
+                    Selector.SAC_DIRECT_ADJACENT_SELECTOR, ancestor,
+                    simpleSelector);
+        } else if (selector instanceof CompositeSelector) {
+            CompositeSelector compositeSelector = (CompositeSelector) selector;
+            Selector first = compositeSelector.getFirst();
+            Selector second = compositeSelector.getSecond();
+            return new CompositeSelector(createSelectorWithSomePartReplaced(
+                    first, toBeReplacedSelectorName, candidateSelector),
+                    createSelectorWithSomePartReplaced(second,
+                            toBeReplacedSelectorName, candidateSelector));
+        }
+        return null;
+    }
+
+    private static SimpleSelector createSimpleSelectorWithSomePartReplaced(
+            SimpleSelector simpleSelector, String toBeReplacedSelectorName,
+            SimpleSelector candidateSelector) {
+        if (simpleSelector == null
+                || !toString(simpleSelector).contains(toBeReplacedSelectorName)) {
+            return simpleSelector;
+        }
+        if (simpleSelector instanceof ElementSelector
+                && candidateSelector instanceof ElementSelector) {
+            return candidateSelector;
+        }
+        if (simpleSelector instanceof ConditionalSelector) {
+            return createConditionSelectorWithSomePartReplaced(
+                    (ConditionalSelector) simpleSelector,
+                    toBeReplacedSelectorName, candidateSelector);
+        }
+        return simpleSelector;
+    }
+
+    private static ConditionalSelector createConditionSelectorWithSomePartReplaced(
+            ConditionalSelector oldConditionSelector,
+            String toBeReplacedSelectorName, SimpleSelector candidateSelector) {
+        if (oldConditionSelector == null
+                || !toString(oldConditionSelector).contains(
+                        toBeReplacedSelectorName)) {
+            return oldConditionSelector;
+        }
+        SelectorFactory selectorFactory = new SelectorFactoryImpl();
+        if (candidateSelector instanceof ElementSelector) {
+            return selectorFactory.createConditionalSelector(candidateSelector,
+                    oldConditionSelector.getCondition());
+        }
+        if (candidateSelector instanceof ConditionalSelector) {
+            // TODO some cases not covered.
+            ConditionalSelector candidateConditionSelector = (ConditionalSelector) candidateSelector;
+            Condition newCondition = createConditionWithSomePartReplaced(
+                    oldConditionSelector.getCondition(),
+                    toBeReplacedSelectorName,
+                    candidateConditionSelector.getCondition());
+            return selectorFactory.createConditionalSelector(
+                    oldConditionSelector.getSimpleSelector(), newCondition);
+        }
+        return oldConditionSelector;
+    }
+
+    private static Condition createConditionWithSomePartReplaced(
+            Condition oldCondition, String toBeReplaced, Condition candidate) {
+        if (oldCondition == null
+                || !getConditionString(oldCondition).contains(toBeReplaced)) {
+            return oldCondition;
+        }
+        if (oldCondition.getConditionType() == Condition.SAC_AND_CONDITION) {
+            ConditionFactory conditionFactory = new ConditionFactoryImpl();
+            CombinatorCondition oldCombinatorCondition = (CombinatorCondition) oldCondition;
+            Condition newFirstCondition = createConditionWithSomePartReplaced(
+                    oldCombinatorCondition.getFirstCondition(), toBeReplaced,
+                    candidate);
+            Condition newSecondCondition = createConditionWithSomePartReplaced(
+                    oldCombinatorCondition.getSecondCondition(), toBeReplaced,
+                    candidate);
+            return conditionFactory.createAndCondition(newFirstCondition,
+                    newSecondCondition);
+        } else {
+            return candidate;
+        }
+    }
+
+    public static boolean equals(Selector one, Selector another) {
+        return one == null ? another == null : toString(one).equals(
+                toString(another));
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/BlockNode.java b/theme-compiler/src/com/vaadin/sass/tree/BlockNode.java
new file mode 100644
index 0000000000..e255b2a3e5
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/BlockNode.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+import org.w3c.css.sac.SelectorList;
+
+import com.vaadin.sass.parser.SelectorListImpl;
+import com.vaadin.sass.selector.SelectorUtil;
+import com.vaadin.sass.util.Clonable;
+import com.vaadin.sass.util.DeepCopy;
+
+public class BlockNode extends Node implements Clonable {
+
+    private static final long serialVersionUID = 5742962631468325048L;
+
+    SelectorList selectorList;
+
+    public BlockNode(SelectorList selectorList) {
+        this.selectorList = selectorList;
+    }
+
+    public SelectorList getSelectorList() {
+        return selectorList;
+    }
+
+    public void setSelectorList(SelectorList selectorList) {
+        this.selectorList = selectorList;
+    }
+
+    public String toString(boolean indent) {
+        StringBuilder string = new StringBuilder();
+        string.append(SelectorUtil.toString(selectorList));
+        string.append(" {\n");
+        for (Node child : children) {
+            if (indent) {
+                string.append("\t");
+            }
+            string.append("\t" + child.toString() + "\n");
+        }
+        if (indent) {
+            string.append("\t");
+        }
+        string.append("}");
+        return string.toString();
+    }
+
+    @Override
+    public String toString() {
+        return toString(false);
+    }
+
+    @Override
+    public Object clone() throws CloneNotSupportedException {
+
+        SelectorListImpl clonedSelectorList = null;
+
+        if (selectorList != null) {
+            clonedSelectorList = new SelectorListImpl();
+            for (int i = 0; i < selectorList.getLength(); i++) {
+                clonedSelectorList.addSelector(selectorList.item(i));
+            }
+        }
+        final BlockNode clone = new BlockNode(clonedSelectorList);
+        for (Node child : getChildren()) {
+            clone.getChildren().add((Node) DeepCopy.copy(child));
+        }
+        return clone;
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/CommentNode.java b/theme-compiler/src/com/vaadin/sass/tree/CommentNode.java
new file mode 100644
index 0000000000..5fb438bb08
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/CommentNode.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+public class CommentNode extends Node {
+    private String comment;
+
+    public CommentNode(String comment) {
+        this.comment = comment;
+    }
+
+    public String getComment() {
+        return comment;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
+    @Override
+    public String toString() {
+        return comment;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/ExtendNode.java b/theme-compiler/src/com/vaadin/sass/tree/ExtendNode.java
new file mode 100644
index 0000000000..65ecb254bb
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/ExtendNode.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+import org.w3c.css.sac.SelectorList;
+
+public class ExtendNode extends Node {
+    private static final long serialVersionUID = 3301805078983796878L;
+
+    SelectorList list;
+
+    public ExtendNode(SelectorList list) {
+        super();
+        this.list = list;
+    }
+
+    public SelectorList getList() {
+        return list;
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/ForNode.java b/theme-compiler/src/com/vaadin/sass/tree/ForNode.java
new file mode 100644
index 0000000000..7c0239aa60
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/ForNode.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+public class ForNode extends Node {
+    private static final long serialVersionUID = -1159180539216623335L;
+
+    String var;
+    String from;
+    String to;
+    boolean exclusive;
+    String body;
+
+    public ForNode(String var, String from, String to, boolean exclusive,
+            String body) {
+        super();
+        this.var = var;
+        this.from = from;
+        this.to = to;
+        this.exclusive = exclusive;
+        this.body = body;
+    }
+
+    @Override
+    public String toString() {
+        return "For Node: " + "{variable: " + var + ", from:" + from + ", to: "
+                + to + ", exclusive: " + exclusive + ", body" + body;
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/FunctionNode.java b/theme-compiler/src/com/vaadin/sass/tree/FunctionNode.java
new file mode 100644
index 0000000000..90b5458235
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/FunctionNode.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+public class FunctionNode extends Node {
+    private static final long serialVersionUID = -5383104165955523923L;
+
+    private String name;
+    private String args;
+    private String body;
+
+    public FunctionNode(String name) {
+        super();
+        this.name = name;
+    }
+
+    public FunctionNode(String name, String args, String body) {
+        this.name = name;
+        this.args = args;
+        this.body = body;
+    }
+
+    @Override
+    public String toString() {
+        return "Function Node: {name: " + name + ", args: " + args + ", body: "
+                + body + "}";
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/IfNode.java b/theme-compiler/src/com/vaadin/sass/tree/IfNode.java
new file mode 100644
index 0000000000..e425538104
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/IfNode.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+public class IfNode extends Node {
+    private static final long serialVersionUID = 1561250630856748066L;
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/ImportNode.java b/theme-compiler/src/com/vaadin/sass/tree/ImportNode.java
new file mode 100644
index 0000000000..ac070d6ffc
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/ImportNode.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+import org.w3c.css.sac.SACMediaList;
+
+public class ImportNode extends Node {
+    private static final long serialVersionUID = 5671255892282668438L;
+
+    private String uri;
+    private SACMediaList ml;
+    private boolean isURL;
+
+    public ImportNode(String uri, SACMediaList ml, boolean isURL) {
+        super();
+        this.uri = uri;
+        this.ml = ml;
+        this.isURL = isURL;
+    }
+
+    public boolean isPureCssImport() {
+        return (isURL || uri.endsWith(".css") || uri.startsWith("http://") || hasMediaQueries());
+    }
+
+    private boolean hasMediaQueries() {
+        return (ml != null && ml.getLength() >= 1 && !"all".equals(ml.item(0)));
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder("@import ");
+        if (isURL) {
+            builder.append("url(").append(uri).append(")");
+        } else {
+            builder.append("\"").append(uri).append("\"");
+        }
+        if (hasMediaQueries()) {
+            for (int i = 0; i < ml.getLength(); i++) {
+                builder.append(" ").append(ml.item(i));
+            }
+        }
+        builder.append(";");
+        return builder.toString();
+    }
+
+    public String getUri() {
+        return uri;
+    }
+
+    public void setUri(String uri) {
+        this.uri = uri;
+    }
+
+    public SACMediaList getMl() {
+        return ml;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/MediaNode.java b/theme-compiler/src/com/vaadin/sass/tree/MediaNode.java
new file mode 100644
index 0000000000..00a7442a24
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/MediaNode.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+import org.w3c.css.sac.SACMediaList;
+
+public class MediaNode extends Node {
+    private static final long serialVersionUID = 2502097081457509523L;
+
+    SACMediaList media;
+
+    public MediaNode(SACMediaList media) {
+        super();
+        this.media = media;
+    }
+
+    public SACMediaList getMedia() {
+        return media;
+    }
+
+    public void setMedia(SACMediaList media) {
+        this.media = media;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder("@media ");
+        if (media != null) {
+            for (int i = 0; i < media.getLength(); i++) {
+                builder.append(media.item(i));
+            }
+        }
+        builder.append(" {\n");
+        for (Node child : children) {
+            if (child instanceof BlockNode) {
+                builder.append("\t" + ((BlockNode) child).toString(true) + "\n");
+            } else {
+                builder.append("\t" + child.toString() + "\n");
+            }
+
+        }
+        builder.append("}");
+        return builder.toString();
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/MixinDefNode.java b/theme-compiler/src/com/vaadin/sass/tree/MixinDefNode.java
new file mode 100644
index 0000000000..b888d01971
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/MixinDefNode.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class MixinDefNode extends Node {
+    private static final long serialVersionUID = 5469294053247343948L;
+
+    private String name;
+    private ArrayList<VariableNode> arglist;
+    private String args;
+    private String body;
+
+    public MixinDefNode(String name, Collection<VariableNode> args) {
+        super();
+        this.name = name;
+        arglist = new ArrayList<VariableNode>();
+        if (args != null && !args.isEmpty()) {
+            arglist.addAll(args);
+        }
+    }
+
+    public MixinDefNode(String name, String args, String body) {
+        this.name = name;
+        this.args = args;
+        this.body = body;
+    }
+
+    @Override
+    public String toString() {
+        return "Mixin Definition Node: {name: " + name + ", args: " + args
+                + ", body: " + body + "}";
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public ArrayList<VariableNode> getArglist() {
+        return arglist;
+    }
+
+    public void setArglist(ArrayList<VariableNode> arglist) {
+        this.arglist = arglist;
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/MixinNode.java b/theme-compiler/src/com/vaadin/sass/tree/MixinNode.java
new file mode 100644
index 0000000000..0267b88e2d
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/MixinNode.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.w3c.css.sac.LexicalUnit;
+
+public class MixinNode extends Node {
+    private static final long serialVersionUID = 4725008226813110658L;
+
+    private String name;
+    private ArrayList<LexicalUnit> arglist;
+
+    public MixinNode(String name, Collection<LexicalUnit> args) {
+        super();
+        this.name = name;
+        arglist = new ArrayList<LexicalUnit>();
+        if (args != null && !args.isEmpty()) {
+            arglist.addAll(args);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "name: " + name + " args: " + arglist;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public ArrayList<LexicalUnit> getArglist() {
+        return arglist;
+    }
+
+    public void setArglist(ArrayList<LexicalUnit> arglist) {
+        this.arglist = arglist;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/NestPropertiesNode.java b/theme-compiler/src/com/vaadin/sass/tree/NestPropertiesNode.java
new file mode 100644
index 0000000000..306a73ba87
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/NestPropertiesNode.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class NestPropertiesNode extends Node {
+    private static final long serialVersionUID = 3671253315690598308L;
+
+    public NestPropertiesNode(String name) {
+        super();
+        this.name = name;
+    }
+
+    private String name;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Collection<RuleNode> unNesting() {
+        List<RuleNode> result = new ArrayList<RuleNode>();
+        for (Node child : children) {
+            result.add(createNewRuleNodeFromChild((RuleNode) child));
+        }
+        return result;
+    }
+
+    public RuleNode createNewRuleNodeFromChild(RuleNode child) {
+        StringBuilder builder = new StringBuilder(name);
+        builder.append("-").append(child.getVariable());
+        RuleNode newRuleNode = new RuleNode(builder.toString(),
+                child.getValue(), child.isImportant(), null);
+        return newRuleNode;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/Node.java b/theme-compiler/src/com/vaadin/sass/tree/Node.java
new file mode 100644
index 0000000000..817327502b
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/Node.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public abstract class Node implements Serializable {
+    private static final long serialVersionUID = 5914711715839294816L;
+
+    protected ArrayList<Node> children;
+    private String fileName;
+
+    protected String rawString;
+    protected List<String> variables;
+
+    public Node() {
+        children = new ArrayList<Node>();
+        variables = new ArrayList<String>();
+    }
+
+    public Node(String raw) {
+        this();
+        rawString = raw;
+    }
+
+    public void appendAll(Collection<Node> nodes) {
+        if (nodes != null && !nodes.isEmpty()) {
+            children.addAll(nodes);
+        }
+    }
+
+    public void appendChild(Node node) {
+        if (node != null) {
+            children.add(node);
+        }
+    }
+
+    public void appendChild(Node node, Node after) {
+        if (node != null) {
+            int index = children.indexOf(after);
+            if (index != -1) {
+                children.add(index + 1, node);
+            } else {
+                throw new NullPointerException("after-node was not found");
+            }
+        }
+    }
+
+    public void removeChild(Node node) {
+        if (node != null) {
+            children.remove(node);
+        }
+    }
+
+    public ArrayList<Node> getChildren() {
+        return children;
+    }
+
+    public void setChildren(ArrayList<Node> children) {
+        this.children = children;
+    }
+
+    public boolean hasChildren() {
+        return !children.isEmpty();
+    }
+
+    public void setFileName(String fileName) {
+        this.fileName = fileName;
+    }
+
+    public String getFileName() {
+        return fileName;
+    }
+
+    @Override
+    public String toString() {
+        return "";
+    }
+
+    public String getRawString() {
+        return rawString;
+    }
+
+    public void addVariable(String var) {
+        variables.add(var);
+    }
+
+    public void removeVariable(String var) {
+        variables.remove(var);
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/RuleNode.java b/theme-compiler/src/com/vaadin/sass/tree/RuleNode.java
new file mode 100644
index 0000000000..3b51468e1d
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/RuleNode.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+import org.w3c.css.sac.LexicalUnit;
+
+public class RuleNode extends Node {
+    private static final long serialVersionUID = 6653493127869037022L;
+
+    String variable;
+    LexicalUnit value;
+    String comment;
+    private boolean important;
+
+    public RuleNode(String variable, LexicalUnit value, boolean important,
+            String comment) {
+        this.variable = variable;
+        this.value = value;
+        this.important = important;
+        this.comment = comment;
+    }
+
+    public String getVariable() {
+        return variable;
+    }
+
+    public void setVariable(String variable) {
+        this.variable = variable;
+    }
+
+    public LexicalUnit getValue() {
+        return value;
+    }
+
+    public void setValue(LexicalUnit value) {
+        this.value = value;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        builder.append(variable).append(": ").append(value.toString());
+        builder.append(important ? " !important;" : ";");
+        if (comment != null) {
+            builder.append(comment);
+        }
+        return builder.toString();
+    }
+
+    public boolean isImportant() {
+        return important;
+    }
+
+    public void setImportant(boolean important) {
+        this.important = important;
+    }
+
+    public String getComment() {
+        return comment;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/SimpleNode.java b/theme-compiler/src/com/vaadin/sass/tree/SimpleNode.java
new file mode 100644
index 0000000000..39a5d17b48
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/SimpleNode.java
@@ -0,0 +1,24 @@
+package com.vaadin.sass.tree;
+
+/**
+ * A simple BlockNode where input text equals output. <b>Note : </b> ignores any
+ * possible children so only use it when you are sure no child nodes will be
+ * applied.
+ * 
+ * @author Sebastian Nyholm @ Vaadin Ltd
+ * 
+ */
+public class SimpleNode extends Node {
+
+    private final String text;
+
+    public SimpleNode(String text) {
+        this.text = text;
+
+    }
+
+    @Override
+    public String toString() {
+        return text;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/VariableNode.java b/theme-compiler/src/com/vaadin/sass/tree/VariableNode.java
new file mode 100644
index 0000000000..db014ae616
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/VariableNode.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+import org.w3c.css.sac.LexicalUnit;
+
+public class VariableNode extends Node {
+    private static final long serialVersionUID = 7003372557547748734L;
+
+    private String name;
+    private LexicalUnit expr;
+    private boolean guarded;
+
+    public VariableNode(String name, LexicalUnit expr, boolean guarded) {
+        super();
+        this.name = name;
+        this.expr = expr;
+        this.guarded = guarded;
+    }
+
+    public VariableNode(String name, String raw) {
+        super(raw);
+        this.name = name;
+    }
+
+    public LexicalUnit getExpr() {
+        return expr;
+    }
+
+    public void setExpr(LexicalUnit expr) {
+        this.expr = expr;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public boolean isGuarded() {
+        return guarded;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder("$");
+        builder.append(name).append(": ").append(expr);
+        return builder.toString();
+    }
+
+    public void setGuarded(boolean guarded) {
+        this.guarded = guarded;
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/WhileNode.java b/theme-compiler/src/com/vaadin/sass/tree/WhileNode.java
new file mode 100644
index 0000000000..465fec061d
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/WhileNode.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree;
+
+public class WhileNode extends Node {
+    private static final long serialVersionUID = 7593896018196027279L;
+
+    private String condition;
+    private String body;
+
+    public WhileNode(String condition, String body) {
+        this.condition = condition;
+        this.body = body;
+    }
+
+    @Override
+    public String toString() {
+        return "While Node: { condition: " + condition + ", body:" + body + "}";
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/controldirective/ControlChildNode.java b/theme-compiler/src/com/vaadin/sass/tree/controldirective/ControlChildNode.java
new file mode 100644
index 0000000000..a6df1e744b
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/controldirective/ControlChildNode.java
@@ -0,0 +1,6 @@
+package com.vaadin.sass.tree.controldirective;
+
+
+public interface ControlChildNode extends ControlNode {
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/controldirective/ControlDefNode.java b/theme-compiler/src/com/vaadin/sass/tree/controldirective/ControlDefNode.java
new file mode 100644
index 0000000000..4ead42eb0a
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/controldirective/ControlDefNode.java
@@ -0,0 +1,6 @@
+package com.vaadin.sass.tree.controldirective;
+
+
+public interface ControlDefNode extends ControlNode {
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/controldirective/ControlNode.java b/theme-compiler/src/com/vaadin/sass/tree/controldirective/ControlNode.java
new file mode 100644
index 0000000000..453593d4d2
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/controldirective/ControlNode.java
@@ -0,0 +1,5 @@
+package com.vaadin.sass.tree.controldirective;
+
+public interface ControlNode {
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/tree/controldirective/EachDefNode.java b/theme-compiler/src/com/vaadin/sass/tree/controldirective/EachDefNode.java
new file mode 100644
index 0000000000..1dfa5892d9
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/tree/controldirective/EachDefNode.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.tree.controldirective;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.vaadin.sass.tree.Node;
+
+public class EachDefNode extends Node implements ControlDefNode {
+    private static final long serialVersionUID = 7943948981204906221L;
+
+    private String var;
+    private ArrayList<String> list;
+
+    public EachDefNode(String var, ArrayList<String> list) {
+        super();
+        this.var = var;
+        this.list = list;
+    }
+
+    public List<String> getVariables() {
+        return list;
+    }
+
+    public String getVariableName() {
+        return var;
+    }
+
+    @Override
+    public String toString() {
+        return "Each Definition Node: {variable : " + var + ", "
+                + "children : " + list.size() + "}";
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/util/Clonable.java b/theme-compiler/src/com/vaadin/sass/util/Clonable.java
new file mode 100644
index 0000000000..639f158fb0
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/util/Clonable.java
@@ -0,0 +1,7 @@
+package com.vaadin.sass.util;
+
+public interface Clonable {
+
+    public Object clone() throws CloneNotSupportedException;
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/util/ColorUtil.java b/theme-compiler/src/com/vaadin/sass/util/ColorUtil.java
new file mode 100644
index 0000000000..25e29ff9a2
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/util/ColorUtil.java
@@ -0,0 +1,315 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.util;
+
+import org.w3c.css.sac.LexicalUnit;
+
+import com.vaadin.sass.parser.LexicalUnitImpl;
+
+public class ColorUtil {
+    public static LexicalUnitImpl hexColorToHsl(LexicalUnitImpl hexColor) {
+        String s = hexColor.getStringValue().substring(1);
+        int r = 0, g = 0, b = 0;
+        if (s.length() == 3) {
+            String sh = s.substring(0, 1);
+            r = Integer.parseInt(sh + sh, 16);
+            sh = s.substring(1, 2);
+            g = Integer.parseInt(sh + sh, 16);
+            sh = s.substring(2, 3);
+            b = Integer.parseInt(sh + sh, 16);
+        } else if (s.length() == 6) {
+            r = Integer.parseInt(s.substring(0, 2), 16);
+            g = Integer.parseInt(s.substring(2, 4), 16);
+            b = Integer.parseInt(s.substring(4, 6), 16);
+        }
+        int hsl[] = calculateHsl(r, g, b);
+
+        LexicalUnitImpl hslParams = createHslParameters(hsl[0], hsl[1], hsl[2],
+                hexColor.getLineNumber(), hexColor.getColumnNumber(),
+                (LexicalUnitImpl) hexColor.getPreviousLexicalUnit());
+
+        return LexicalUnitImpl.createFunction(hexColor.getLineNumber(),
+                hexColor.getColumnNumber(),
+                (LexicalUnitImpl) hexColor.getPreviousLexicalUnit(), "hsl",
+                hslParams);
+    }
+
+    public static LexicalUnitImpl hslToHexColor(LexicalUnitImpl hsl, int lengh) {
+        int[] rgb = calculateRgb(hsl);
+        StringBuilder builder = new StringBuilder("#");
+        for (int i = 0; i < 3; i++) {
+            String color = Integer.toHexString(rgb[i]);
+            if (lengh == 6) {
+                if (color.length() == 1) {
+                    color = "0" + color;
+                }
+            }
+            if (lengh == 3) {
+                color = color.substring(0, 1);
+            }
+            builder.append(color);
+        }
+        return LexicalUnitImpl.createIdent(hsl.getLineNumber(),
+                hsl.getColumnNumber(),
+                (LexicalUnitImpl) hsl.getPreviousLexicalUnit(),
+                builder.toString());
+    }
+
+    private static int[] calculateRgb(LexicalUnitImpl hsl) {
+        LexicalUnitImpl hslParam = hsl.getParameters();
+        LexicalUnitImpl hue = null;
+        LexicalUnitImpl saturation = null;
+        LexicalUnitImpl lightness = null;
+        int i = 0;
+        while (i < 5) {
+            switch (i) {
+            case 0:
+                hue = hslParam;
+                break;
+            case 2:
+                saturation = hslParam;
+                break;
+            case 4:
+                lightness = hslParam;
+                break;
+            case 1:
+            case 3:
+                break;
+            }
+            hslParam = (LexicalUnitImpl) hslParam.getNextLexicalUnit();
+            i++;
+        }
+        float h = ((hue.getIntegerValue() % 360) + 360) % 360 / 360f;
+        float s = saturation.getFloatValue() / 100;
+        float l = lightness.getFloatValue() / 100;
+        float m2, m1;
+        int[] rgb = new int[3];
+        m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
+        m1 = l * 2 - m2;
+        rgb[0] = Math.round(hueToRgb(m1, m2, h + 1f / 3) * 255);
+        rgb[1] = Math.round(hueToRgb(m1, m2, h) * 255);
+        rgb[2] = Math.round(hueToRgb(m1, m2, h - 1f / 3) * 255);
+        return rgb;
+    }
+
+    public static LexicalUnitImpl rgbToHsl(LexicalUnitImpl rgb) {
+        LexicalUnitImpl rgbParam = rgb.getParameters();
+        LexicalUnitImpl red = null;
+        LexicalUnitImpl green = null;
+        LexicalUnitImpl blue = null;
+        int i = 0;
+        while (i < 5) {
+            switch (i) {
+            case 0:
+                red = rgbParam;
+                break;
+            case 2:
+                green = rgbParam;
+                break;
+            case 4:
+                blue = rgbParam;
+                break;
+            case 1:
+            case 3:
+                break;
+            }
+            rgbParam = (LexicalUnitImpl) rgbParam.getNextLexicalUnit();
+            i++;
+        }
+
+        int hsl[] = calculateHsl(red.getIntegerValue(),
+                green.getIntegerValue(), blue.getIntegerValue());
+
+        rgbParam = rgb.getParameters();
+
+        LexicalUnitImpl hslParams = createHslParameters(hsl[0], hsl[1], hsl[2],
+                rgbParam.getLineNumber(), rgbParam.getColumnNumber(),
+                (LexicalUnitImpl) rgbParam.getPreviousLexicalUnit());
+
+        return LexicalUnitImpl.createFunction(rgb.getLineNumber(),
+                rgb.getColumnNumber(),
+                (LexicalUnitImpl) rgb.getPreviousLexicalUnit(), "hsl",
+                hslParams);
+    }
+
+    private static int[] calculateHsl(int red, int green, int blue) {
+        int[] hsl = new int[3];
+
+        float r = red / 255f;
+        float g = green / 255f;
+        float b = blue / 255f;
+
+        float max = Math.max(Math.max(r, g), b);
+        float min = Math.min(Math.min(r, g), b);
+        float d = max - min;
+
+        float h = 0f, s = 0f, l = 0f;
+
+        if (max == min) {
+            h = 0;
+        }
+        if (max == r) {
+            h = 60 * (g - b) / d;
+        } else if (max == g) {
+            h = 60 * (b - r) / d + 120;
+        } else if (max == b) {
+            h = 60 * (r - g) / d + 240;
+        }
+
+        l = (max + min) / 2f;
+
+        if (max == min) {
+            s = 0;
+        } else if (l < 0.5) {
+            s = d / (2 * l);
+        } else {
+            s = d / (2 - 2 * l);
+        }
+
+        hsl[0] = Math.round(h % 360);
+        hsl[1] = Math.round(s * 100);
+        hsl[2] = Math.round(l * 100);
+
+        return hsl;
+    }
+
+    public static LexicalUnitImpl hslToRgb(LexicalUnitImpl hsl) {
+        int[] rgb = calculateRgb(hsl);
+        LexicalUnitImpl hslParam = hsl.getParameters();
+        LexicalUnitImpl rgbParams = createRgbParameters(rgb[0], rgb[1], rgb[2],
+                hslParam.getLineNumber(), hslParam.getColumnNumber(),
+                (LexicalUnitImpl) hslParam.getPreviousLexicalUnit());
+
+        return LexicalUnitImpl.createFunction(hsl.getLineNumber(),
+                hsl.getColumnNumber(),
+                (LexicalUnitImpl) hsl.getPreviousLexicalUnit(), "rgb",
+                rgbParams);
+    }
+
+    private static float hueToRgb(float m1, float m2, float h) {
+        if (h < 0) {
+            h = h + 1;
+        }
+        if (h > 1) {
+            h = h - 1;
+        }
+        if (h * 6 < 1) {
+            return m1 + (m2 - m1) * h * 6;
+        }
+        if (h * 2 < 1) {
+            return m2;
+        }
+        if (h * 3 < 2) {
+            return m1 + (m2 - m1) * (2f / 3 - h) * 6;
+        }
+        return m1;
+    }
+
+    private static LexicalUnitImpl createRgbParameters(int r, int g, int b,
+            int ln, int cn, LexicalUnitImpl prev) {
+        LexicalUnitImpl red = LexicalUnitImpl.createInteger(ln, cn, prev, r);
+        LexicalUnitImpl firstComma = LexicalUnitImpl.createComma(ln, cn, red);
+        LexicalUnitImpl green = LexicalUnitImpl.createInteger(ln, cn,
+                firstComma, g);
+        LexicalUnitImpl secondComma = LexicalUnitImpl
+                .createComma(ln, cn, green);
+        LexicalUnitImpl.createInteger(ln, cn, secondComma, b);
+        return red;
+    }
+
+    private static LexicalUnitImpl createHslParameters(int h, int s, int l,
+            int ln, int cn, LexicalUnitImpl prev) {
+        LexicalUnitImpl hue = LexicalUnitImpl.createInteger(ln, cn, prev, h);
+        LexicalUnitImpl firstComma = LexicalUnitImpl.createComma(ln, cn, hue);
+        LexicalUnitImpl saturation = LexicalUnitImpl.createPercentage(ln, cn,
+                firstComma, s);
+        LexicalUnitImpl secondComma = LexicalUnitImpl.createComma(ln, cn,
+                saturation);
+        LexicalUnitImpl.createPercentage(ln, cn, secondComma, l);
+        return hue;
+    }
+
+    public static LexicalUnitImpl darken(LexicalUnitImpl darkenFunc) {
+        LexicalUnitImpl color = darkenFunc.getParameters();
+        float amount = getAmountValue(color);
+        LexicalUnitImpl pre = (LexicalUnitImpl) darkenFunc
+                .getPreviousLexicalUnit();
+
+        return adjust(color, amount, ColorOperation.Darken, pre);
+    }
+
+    private static LexicalUnitImpl adjust(LexicalUnitImpl color,
+            float amountByPercent, ColorOperation op, LexicalUnitImpl pre) {
+        if (color.getLexicalUnitType() == LexicalUnit.SAC_FUNCTION) {
+            LexicalUnit funcParam = color.getParameters();
+            if ("hsl".equals(color.getFunctionName())) {
+                LexicalUnit lightness = funcParam;
+                for (int index = 0; index < 4; index++) {
+                    lightness = lightness.getNextLexicalUnit();
+                }
+                float newValue = 0f;
+                if (op == ColorOperation.Darken) {
+                    newValue = lightness.getFloatValue() - amountByPercent;
+                    newValue = newValue < 0 ? 0 : newValue;
+                } else if (op == ColorOperation.Lighten) {
+                    newValue = lightness.getFloatValue() + amountByPercent;
+                    newValue = newValue > 100 ? 100 : newValue;
+                }
+                ((LexicalUnitImpl) lightness).setFloatValue(newValue);
+                return LexicalUnitImpl.createFunction(color.getLineNumber(),
+                        color.getColumnNumber(), pre, color.getFunctionName(),
+                        funcParam);
+            }
+
+        } else if (color.getLexicalUnitType() == LexicalUnit.SAC_IDENT) {
+            if (color.getStringValue().startsWith("#")) {
+                return hslToHexColor(
+                        adjust(hexColorToHsl(color), amountByPercent, op, pre),
+                        color.getStringValue().substring(1).length());
+            }
+        } else if (color.getLexicalUnitType() == LexicalUnit.SAC_RGBCOLOR) {
+            LexicalUnitImpl hsl = rgbToHsl(color);
+            LexicalUnitImpl hslAfterDarken = adjust(hsl, amountByPercent, op,
+                    pre);
+            return hslToRgb(hslAfterDarken);
+        }
+        return color;
+    }
+
+    public static LexicalUnitImpl lighten(LexicalUnitImpl lightenFunc) {
+        LexicalUnitImpl color = lightenFunc.getParameters();
+        float amount = getAmountValue(color);
+        LexicalUnitImpl pre = (LexicalUnitImpl) lightenFunc
+                .getPreviousLexicalUnit();
+
+        return adjust(color, amount, ColorOperation.Lighten, pre);
+    }
+
+    private static float getAmountValue(LexicalUnitImpl color) {
+        LexicalUnit next = color.getNextLexicalUnit();
+        float amount = 10f;
+        if (next != null && next.getNextLexicalUnit() != null) {
+            next = next.getNextLexicalUnit();
+            amount = next.getFloatValue();
+        }
+        return amount;
+    }
+
+    enum ColorOperation {
+        Darken, Lighten
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/util/DeepCopy.java b/theme-compiler/src/com/vaadin/sass/util/DeepCopy.java
new file mode 100644
index 0000000000..5d4e43c477
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/util/DeepCopy.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.util;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/**
+ * Utility for making deep copies (vs. clone()'s shallow copies) of objects.
+ * Objects are first serialized and then deserialized. Error checking is fairly
+ * minimal in this implementation. If an object is encountered that cannot be
+ * serialized (or that references an object that cannot be serialized) an error
+ * is printed to System.err and null is returned. Depending on your specific
+ * application, it might make more sense to have copy(...) re-throw the
+ * exception.
+ */
+public class DeepCopy {
+
+    /**
+     * Returns a copy of the object, or null if the object cannot be serialized.
+     */
+    public static Object copy(Object orig) {
+
+        Object obj = null;
+        if (!(orig instanceof Clonable)) {
+            try {
+                // Write the object out to a byte array
+                FastByteArrayOutputStream fbos = new FastByteArrayOutputStream();
+                ObjectOutputStream out = new ObjectOutputStream(fbos);
+                out.writeObject(orig);
+                out.flush();
+                out.close();
+
+                // Retrieve an input stream from the byte array and read
+                // a copy of the object back in.
+                ObjectInputStream in = new ObjectInputStream(
+                        fbos.getInputStream());
+                obj = in.readObject();
+                in.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            } catch (ClassNotFoundException cnfe) {
+                cnfe.printStackTrace();
+            }
+            return obj;
+        } else {
+            try {
+                obj = ((Clonable) orig).clone();
+            } catch (ClassCastException e2) {
+                // Can't clone, return obj as null
+            } catch (CloneNotSupportedException e2) {
+                // Can't clone, return obj as null
+            }
+            return obj;
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/theme-compiler/src/com/vaadin/sass/util/FastByteArrayInputStream.java b/theme-compiler/src/com/vaadin/sass/util/FastByteArrayInputStream.java
new file mode 100644
index 0000000000..1b3d0ea0f7
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/util/FastByteArrayInputStream.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.util;
+
+import java.io.InputStream;
+
+/**
+ * ByteArrayInputStream implementation that does not synchronize methods.
+ */
+public class FastByteArrayInputStream extends InputStream {
+    /**
+     * Our byte buffer
+     */
+    protected byte[] buf = null;
+
+    /**
+     * Number of bytes that we can read from the buffer
+     */
+    protected int count = 0;
+
+    /**
+     * Number of bytes that have been read from the buffer
+     */
+    protected int pos = 0;
+
+    public FastByteArrayInputStream(byte[] buf, int count) {
+        this.buf = buf;
+        this.count = count;
+    }
+
+    @Override
+    public final int available() {
+        return count - pos;
+    }
+
+    @Override
+    public final int read() {
+        return (pos < count) ? (buf[pos++] & 0xff) : -1;
+    }
+
+    @Override
+    public final int read(byte[] b, int off, int len) {
+        if (pos >= count) {
+            return -1;
+        }
+
+        if ((pos + len) > count) {
+            len = (count - pos);
+        }
+
+        System.arraycopy(buf, pos, b, off, len);
+        pos += len;
+        return len;
+    }
+
+    @Override
+    public final long skip(long n) {
+        if ((pos + n) > count) {
+            n = count - pos;
+        }
+        if (n < 0) {
+            return 0;
+        }
+        pos += n;
+        return n;
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/util/FastByteArrayOutputStream.java b/theme-compiler/src/com/vaadin/sass/util/FastByteArrayOutputStream.java
new file mode 100644
index 0000000000..24b386686f
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/util/FastByteArrayOutputStream.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.util;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * ByteArrayOutputStream implementation that doesn't synchronize methods and
+ * doesn't copy the data on toByteArray().
+ */
+public class FastByteArrayOutputStream extends OutputStream {
+    /**
+     * Buffer and size
+     */
+    protected byte[] buf = null;
+    protected int size = 0;
+
+    /**
+     * Constructs a stream with buffer capacity size 5K
+     */
+    public FastByteArrayOutputStream() {
+        this(5 * 1024);
+    }
+
+    /**
+     * Constructs a stream with the given initial size
+     */
+    public FastByteArrayOutputStream(int initSize) {
+        size = 0;
+        buf = new byte[initSize];
+    }
+
+    /**
+     * Ensures that we have a large enough buffer for the given size.
+     */
+    private void verifyBufferSize(int sz) {
+        if (sz > buf.length) {
+            byte[] old = buf;
+            buf = new byte[Math.max(sz, 2 * buf.length)];
+            System.arraycopy(old, 0, buf, 0, old.length);
+            old = null;
+        }
+    }
+
+    public int getSize() {
+        return size;
+    }
+
+    /**
+     * Returns the byte array containing the written data. Note that this array
+     * will almost always be larger than the amount of data actually written.
+     */
+    public byte[] getByteArray() {
+        return buf;
+    }
+
+    @Override
+    public final void write(byte b[]) {
+        verifyBufferSize(size + b.length);
+        System.arraycopy(b, 0, buf, size, b.length);
+        size += b.length;
+    }
+
+    @Override
+    public final void write(byte b[], int off, int len) {
+        verifyBufferSize(size + len);
+        System.arraycopy(b, off, buf, size, len);
+        size += len;
+    }
+
+    @Override
+    public final void write(int b) {
+        verifyBufferSize(size + 1);
+        buf[size++] = (byte) b;
+    }
+
+    public void reset() {
+        size = 0;
+    }
+
+    /**
+     * Returns a ByteArrayInputStream for reading back the written data
+     */
+    public InputStream getInputStream() {
+        return new FastByteArrayInputStream(buf, size);
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/util/StringUtil.java b/theme-compiler/src/com/vaadin/sass/util/StringUtil.java
new file mode 100644
index 0000000000..bd39f1d41a
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/util/StringUtil.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class StringUtil {
+    private static final String FOLDER_SEPARATOR = "/"; // folder separator
+
+    private static final String WINDOWS_FOLDER_SEPARATOR = "\\"; // Windows
+                                                                 // folder
+                                                                 // separator
+
+    private static final String TOP_PATH = ".."; // top folder
+
+    private static final String CURRENT_PATH = "."; // current folder
+
+    public static String cleanPath(String path) {
+        String pathToUse = replace(path, WINDOWS_FOLDER_SEPARATOR,
+                FOLDER_SEPARATOR);
+        String[] pathArray = delimitedListToStringArray(pathToUse,
+                FOLDER_SEPARATOR);
+        List pathElements = new LinkedList();
+        int tops = 0;
+        for (int i = pathArray.length - 1; i >= 0; i--) {
+            if (CURRENT_PATH.equals(pathArray[i])) {
+                // do nothing
+            } else if (TOP_PATH.equals(pathArray[i])) {
+                tops++;
+            } else {
+                if (tops > 0) {
+                    tops--;
+                } else {
+                    pathElements.add(0, pathArray[i]);
+                }
+            }
+        }
+        for (int i = 0; i < tops; i++) {
+            pathElements.add(0, TOP_PATH);
+        }
+        return collectionToDelimitedString(pathElements, FOLDER_SEPARATOR);
+    }
+
+    public static String replace(String inString, String oldPattern,
+            String newPattern) {
+        if (inString == null) {
+            return null;
+        }
+        if (oldPattern == null || newPattern == null) {
+            return inString;
+        }
+
+        StringBuffer sbuf = new StringBuffer();
+        // output StringBuffer we'll build up
+        int pos = 0; // our position in the old string
+        int index = inString.indexOf(oldPattern);
+        // the index of an occurrence we've found, or -1
+        int patLen = oldPattern.length();
+        while (index >= 0) {
+            sbuf.append(inString.substring(pos, index));
+            sbuf.append(newPattern);
+            pos = index + patLen;
+            index = inString.indexOf(oldPattern, pos);
+        }
+        sbuf.append(inString.substring(pos));
+
+        // remember to append any characters to the right of a match
+        return sbuf.toString();
+    }
+
+    public static String[] delimitedListToStringArray(String str,
+            String delimiter) {
+        if (str == null) {
+            return new String[0];
+        }
+        if (delimiter == null) {
+            return new String[] { str };
+        }
+
+        List result = new ArrayList();
+        int pos = 0;
+        int delPos = 0;
+        while ((delPos = str.indexOf(delimiter, pos)) != -1) {
+            result.add(str.substring(pos, delPos));
+            pos = delPos + delimiter.length();
+        }
+        if (str.length() > 0 && pos <= str.length()) {
+            // Add rest of String, but not in case of empty input.
+            result.add(str.substring(pos));
+        }
+
+        return (String[]) result.toArray(new String[result.size()]);
+    }
+
+    public static String collectionToDelimitedString(Collection coll,
+            String delim, String prefix, String suffix) {
+        if (coll == null) {
+            return "";
+        }
+
+        StringBuffer sb = new StringBuffer();
+        Iterator it = coll.iterator();
+        int i = 0;
+        while (it.hasNext()) {
+            if (i > 0) {
+                sb.append(delim);
+            }
+            sb.append(prefix).append(it.next()).append(suffix);
+            i++;
+        }
+        return sb.toString();
+    }
+
+    public static String collectionToDelimitedString(Collection coll,
+            String delim) {
+        return collectionToDelimitedString(coll, delim, "", "");
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/visitor/BlockVisitor.java b/theme-compiler/src/com/vaadin/sass/visitor/BlockVisitor.java
new file mode 100644
index 0000000000..6d2489e494
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/visitor/BlockVisitor.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.visitor;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.w3c.css.sac.Selector;
+import org.w3c.css.sac.SelectorList;
+
+import com.vaadin.sass.parser.SelectorListImpl;
+import com.vaadin.sass.selector.CompositeSelector;
+import com.vaadin.sass.tree.BlockNode;
+import com.vaadin.sass.tree.Node;
+
+public class BlockVisitor implements Visitor {
+
+    @Override
+    public void traverse(Node node) {
+        traverse(null, node);
+    }
+
+    private void traverse(Node parent, Node node) {
+        Node after = node;
+        Set<Node> toBeDeleted = new HashSet<Node>();
+        for (int pos = 0; pos < node.getChildren().size(); pos++) {
+            Node child = node.getChildren().get(pos);
+
+            traverse(node, child);
+
+            if (child instanceof BlockNode && node instanceof BlockNode
+                    && parent != null) {
+                combineParentSelectorListToChild(node, child);
+                toBeDeleted.add(child);
+                parent.appendChild(child, after);
+                after = child;
+            }
+        }
+        for (Node child : toBeDeleted) {
+            node.removeChild(child);
+        }
+    }
+
+    private void combineParentSelectorListToChild(Node parent, Node child) {
+        if (parent instanceof BlockNode && child instanceof BlockNode) {
+            SelectorListImpl newList = new SelectorListImpl();
+            SelectorList parentSelectors = ((BlockNode) parent)
+                    .getSelectorList();
+            SelectorList childSelectors = ((BlockNode) child).getSelectorList();
+            for (int i = 0; i < parentSelectors.getLength(); i++) {
+                Selector parentSelector = parentSelectors.item(i);
+                for (int j = 0; j < childSelectors.getLength(); j++) {
+                    Selector childSelector = childSelectors.item(j);
+                    newList.addSelector(new CompositeSelector(parentSelector,
+                            childSelector));
+                }
+
+            }
+            ((BlockNode) child).setSelectorList(newList);
+        }
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/visitor/ControlVisitor.java b/theme-compiler/src/com/vaadin/sass/visitor/ControlVisitor.java
new file mode 100644
index 0000000000..cc736b307f
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/visitor/ControlVisitor.java
@@ -0,0 +1,57 @@
+package com.vaadin.sass.visitor;
+
+import java.util.HashSet;
+import java.util.regex.Pattern;
+
+import com.vaadin.sass.tree.BlockNode;
+import com.vaadin.sass.tree.Node;
+import com.vaadin.sass.tree.SimpleNode;
+import com.vaadin.sass.tree.controldirective.ControlDefNode;
+import com.vaadin.sass.tree.controldirective.EachDefNode;
+
+public class ControlVisitor implements Visitor {
+
+    HashSet<Node> controlDefs = new HashSet<Node>();
+    private Node rootNode;
+
+    @Override
+    public void traverse(Node node) throws Exception {
+        this.rootNode = node;
+        for (Node child : node.getChildren()) {
+            if (child instanceof ControlDefNode) {
+                controlDefs.add(child);
+            }
+        }
+
+        replaceControlNodes();
+
+    }
+
+    private void replaceControlNodes() {
+        for (final Node defNode : controlDefs) {
+            if (defNode instanceof EachDefNode) {
+                replaceEachDefNode((EachDefNode) defNode);
+            }
+
+        }
+    }
+
+    private void replaceEachDefNode(EachDefNode defNode) {
+        for (final Node child : defNode.getChildren()) {
+            if (child instanceof BlockNode) {
+                for (final String variable : defNode.getVariables()) {
+
+                    String output = child.toString();
+                    output = output.replaceAll(
+                            Pattern.quote("#{" + defNode.getVariableName()
+                                    + "}"), variable);
+                    SimpleNode simple = new SimpleNode(output);
+
+                    rootNode.appendChild(simple, defNode);
+                }
+            }
+        }
+        rootNode.removeChild(defNode);
+    }
+
+}
diff --git a/theme-compiler/src/com/vaadin/sass/visitor/ExtendVisitor.java b/theme-compiler/src/com/vaadin/sass/visitor/ExtendVisitor.java
new file mode 100644
index 0000000000..605c7930c3
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/visitor/ExtendVisitor.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.visitor;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.w3c.css.sac.SelectorList;
+
+import com.vaadin.sass.parser.SelectorListImpl;
+import com.vaadin.sass.selector.SelectorUtil;
+import com.vaadin.sass.tree.BlockNode;
+import com.vaadin.sass.tree.ExtendNode;
+import com.vaadin.sass.tree.Node;
+
+public class ExtendVisitor implements Visitor {
+    private Map<String, List<SelectorList>> extendsMap = new HashMap<String, List<SelectorList>>();
+
+    @Override
+    public void traverse(Node node) throws Exception {
+        buildExtendsMap(node);
+        modifyTree(node);
+    }
+
+    private void modifyTree(Node node) throws Exception {
+        for (Node child : node.getChildren()) {
+            if (child instanceof BlockNode) {
+                BlockNode blockNode = (BlockNode) child;
+                String selectorString = SelectorUtil.toString(blockNode
+                        .getSelectorList());
+                if (extendsMap.get(selectorString) != null) {
+                    for (SelectorList sList : extendsMap.get(selectorString)) {
+                        SelectorList newList = SelectorUtil
+                                .createNewSelectorListFromAnOldOneWithSomPartReplaced(
+                                        blockNode.getSelectorList(),
+                                        selectorString, sList);
+                        addAdditionalSelectorListToBlockNode(blockNode, newList);
+                    }
+                } else {
+                    for (Entry<String, List<SelectorList>> entry : extendsMap
+                            .entrySet()) {
+                        if (selectorString.contains(entry.getKey())) {
+                            for (SelectorList sList : entry.getValue()) {
+                                SelectorList newList = SelectorUtil
+                                        .createNewSelectorListFromAnOldOneWithSomPartReplaced(
+                                                blockNode.getSelectorList(),
+                                                entry.getKey(), sList);
+                                addAdditionalSelectorListToBlockNode(blockNode,
+                                        newList);
+                            }
+                        }
+                    }
+                }
+            } else {
+                buildExtendsMap(child);
+            }
+        }
+
+    }
+
+    private void buildExtendsMap(Node node) {
+        if (node instanceof BlockNode) {
+            BlockNode blockNode = (BlockNode) node;
+            for (Node child : new ArrayList<Node>(node.getChildren())) {
+                if (child instanceof ExtendNode) {
+                    ExtendNode extendNode = (ExtendNode) child;
+                    String extendedString = SelectorUtil.toString(extendNode
+                            .getList());
+                    if (extendsMap.get(extendedString) == null) {
+                        extendsMap.put(extendedString,
+                                new ArrayList<SelectorList>());
+                    }
+                    extendsMap.get(extendedString).add(
+                            blockNode.getSelectorList());
+                    node.removeChild(child);
+                } else {
+                    buildExtendsMap(child);
+                }
+            }
+        } else {
+            for (Node child : node.getChildren()) {
+                buildExtendsMap(child);
+            }
+        }
+
+    }
+
+    private void addAdditionalSelectorListToBlockNode(BlockNode blockNode,
+            SelectorList list) {
+        if (list != null) {
+            for (int i = 0; i < list.getLength(); i++) {
+                ((SelectorListImpl) blockNode.getSelectorList())
+                        .addSelector(list.item(i));
+            }
+        }
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/visitor/ImportVisitor.java b/theme-compiler/src/com/vaadin/sass/visitor/ImportVisitor.java
new file mode 100644
index 0000000000..bda040be39
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/visitor/ImportVisitor.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.visitor;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import org.w3c.css.sac.CSSException;
+import org.w3c.css.sac.LexicalUnit;
+
+import com.vaadin.sass.ScssStylesheet;
+import com.vaadin.sass.parser.LexicalUnitImpl;
+import com.vaadin.sass.tree.ImportNode;
+import com.vaadin.sass.tree.Node;
+import com.vaadin.sass.tree.RuleNode;
+import com.vaadin.sass.util.StringUtil;
+
+public class ImportVisitor implements Visitor {
+
+    @Override
+    public void traverse(Node node) {
+        for (Node child : new ArrayList<Node>(node.getChildren())) {
+            if (child instanceof ImportNode) {
+                ImportNode importNode = (ImportNode) child;
+                if (!importNode.isPureCssImport()) {
+
+                    try {
+
+                        StringBuilder filePathBuilder = new StringBuilder(
+                                node.getFileName());
+                        filePathBuilder.append(File.separatorChar).append(
+                                importNode.getUri());
+                        if (!filePathBuilder.toString().endsWith(".scss")) {
+                            filePathBuilder.append(".scss");
+                        }
+
+                        ScssStylesheet imported = ScssStylesheet
+                                .get(filePathBuilder.toString());
+                        if (imported == null) {
+                            imported = ScssStylesheet.get(importNode.getUri());
+                        }
+                        if (imported == null) {
+                            throw new FileNotFoundException(importNode.getUri()
+                                    + " (parent: " + node.getFileName() + ")");
+                        }
+
+                        traverse(imported);
+                        String prefix = getUrlPrefix(importNode.getUri());
+                        if (prefix != null) {
+                            updateUrlInImportedSheet(imported, prefix);
+                        }
+                        Node pre = importNode;
+                        for (Node importedChild : imported.getChildren()) {
+                            node.appendChild(importedChild, pre);
+                            pre = importedChild;
+                        }
+                        node.removeChild(importNode);
+                    } catch (CSSException e) {
+                        e.printStackTrace();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+
+    private String getUrlPrefix(String url) {
+        if (url == null) {
+            return null;
+        }
+        int pos = url.lastIndexOf('/');
+        if (pos == -1) {
+            return null;
+        }
+        return url.substring(0, pos + 1);
+    }
+
+    private void updateUrlInImportedSheet(Node node, String prefix) {
+        for (Node child : node.getChildren()) {
+            if (child instanceof RuleNode) {
+                LexicalUnit value = ((RuleNode) child).getValue();
+                while (value != null) {
+                    if (value.getLexicalUnitType() == LexicalUnit.SAC_URI) {
+                        String path = value.getStringValue();
+                        if (!path.startsWith("/") && !path.contains(":")) {
+                            path = prefix + path;
+                            path = StringUtil.cleanPath(path);
+                            ((LexicalUnitImpl) value).setStringValue(path);
+                        }
+                    }
+                    value = value.getNextLexicalUnit();
+                }
+
+            }
+            updateUrlInImportedSheet(child, prefix);
+        }
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/visitor/MixinVisitor.java b/theme-compiler/src/com/vaadin/sass/visitor/MixinVisitor.java
new file mode 100644
index 0000000000..d6008526b4
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/visitor/MixinVisitor.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.visitor;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.vaadin.sass.tree.MixinDefNode;
+import com.vaadin.sass.tree.MixinNode;
+import com.vaadin.sass.tree.Node;
+import com.vaadin.sass.tree.VariableNode;
+import com.vaadin.sass.util.DeepCopy;
+
+public class MixinVisitor implements Visitor {
+    Map<String, MixinDefNode> mixinDefs = new HashMap<String, MixinDefNode>();
+
+    @Override
+    public void traverse(Node node) throws Exception {
+        // create mixin map.
+        for (Node child : node.getChildren()) {
+            if (child instanceof MixinDefNode) {
+                mixinDefs.put(((MixinDefNode) child).getName(),
+                        (MixinDefNode) child);
+            }
+        }
+
+        replaceMixins(node);
+
+        // delete MixinDefNode
+        for (Node child : new ArrayList<Node>(node.getChildren())) {
+            if (child instanceof MixinDefNode) {
+                node.removeChild(child);
+            }
+        }
+
+    }
+
+    private void replaceMixins(Node node) throws Exception {
+        for (Node child : new ArrayList<Node>(node.getChildren())) {
+            replaceMixins(child);
+            if (child instanceof MixinNode) {
+                MixinNode mixinNode = (MixinNode) child;
+                MixinDefNode mixinDef = mixinDefs.get(mixinNode.getName());
+                if (mixinDef == null) {
+                    throw new Exception("Mixin Definition: "
+                            + mixinNode.getName() + " not found");
+                }
+                replaceMixinNode(node, mixinNode, mixinDef);
+            }
+        }
+    }
+
+    private void replaceMixinNode(Node current, MixinNode mixinNode,
+            MixinDefNode mixinDef) {
+        Node pre = mixinNode;
+        if (mixinDef.getArglist().isEmpty()) {
+            for (Node child : mixinDef.getChildren()) {
+                current.appendChild(child, pre);
+                pre = child;
+            }
+        } else {
+            for (int i = 0; i < mixinDef.getArglist().size(); i++) {
+                VariableNode arg = (VariableNode) DeepCopy.copy(mixinDef
+                        .getArglist().get(i));
+                if (i < mixinNode.getArglist().size()) {
+                    arg.setExpr(mixinNode.getArglist().get(i));
+                }
+                current.appendChild(arg, pre);
+                pre = arg;
+            }
+            for (Node child : mixinDef.getChildren()) {
+                Node clonedChild = (Node) DeepCopy.copy(child);
+                current.appendChild(clonedChild, pre);
+                pre = clonedChild;
+            }
+        }
+        current.removeChild(mixinNode);
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/visitor/NestPropertiesVisitor.java b/theme-compiler/src/com/vaadin/sass/visitor/NestPropertiesVisitor.java
new file mode 100644
index 0000000000..82fbef42ef
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/visitor/NestPropertiesVisitor.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.visitor;
+
+import java.util.ArrayList;
+
+import com.vaadin.sass.tree.NestPropertiesNode;
+import com.vaadin.sass.tree.Node;
+import com.vaadin.sass.tree.RuleNode;
+
+public class NestPropertiesVisitor implements Visitor {
+
+    @Override
+    public void traverse(Node node) {
+        for (Node child : new ArrayList<Node>(node.getChildren())) {
+            if (child instanceof NestPropertiesNode) {
+                Node previous = child;
+                for (RuleNode unNested : ((NestPropertiesNode) child)
+                        .unNesting()) {
+                    node.appendChild(unNested, previous);
+                    previous = unNested;
+                    node.removeChild(child);
+                }
+            } else {
+                traverse(child);
+            }
+        }
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/visitor/ParentSelectorVisitor.java b/theme-compiler/src/com/vaadin/sass/visitor/ParentSelectorVisitor.java
new file mode 100644
index 0000000000..f24d7ae09d
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/visitor/ParentSelectorVisitor.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.visitor;
+
+import java.util.ArrayList;
+
+import org.w3c.css.sac.SelectorList;
+
+import com.vaadin.sass.selector.SelectorUtil;
+import com.vaadin.sass.tree.BlockNode;
+import com.vaadin.sass.tree.Node;
+
+public class ParentSelectorVisitor implements Visitor {
+
+    @Override
+    public void traverse(Node node) throws Exception {
+        for (Node child : new ArrayList<Node>(node.getChildren())) {
+            if (child instanceof BlockNode) {
+                traverse(node, (BlockNode) child);
+            }
+        }
+    }
+
+    private void traverse(Node parent, BlockNode block) throws Exception {
+        Node pre = block;
+        for (Node child : new ArrayList<Node>(block.getChildren())) {
+            if (child instanceof BlockNode) {
+                BlockNode blockChild = (BlockNode) child;
+                traverse(block, blockChild);
+                if (SelectorUtil
+                        .hasParentSelector(blockChild.getSelectorList())) {
+                    parent.appendChild(child, pre);
+                    pre = child;
+                    block.removeChild(child);
+                    SelectorList newSelectorList = SelectorUtil
+                            .createNewSelectorListFromAnOldOneWithSomPartReplaced(
+                                    blockChild.getSelectorList(), "&",
+                                    block.getSelectorList());
+                    blockChild.setSelectorList(newSelectorList);
+                }
+            }
+        }
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/visitor/VariableVisitor.java b/theme-compiler/src/com/vaadin/sass/visitor/VariableVisitor.java
new file mode 100644
index 0000000000..7fa62bd20f
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/visitor/VariableVisitor.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.visitor;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.w3c.css.sac.LexicalUnit;
+
+import com.vaadin.sass.parser.LexicalUnitImpl;
+import com.vaadin.sass.parser.SCSSLexicalUnit;
+import com.vaadin.sass.tree.Node;
+import com.vaadin.sass.tree.RuleNode;
+import com.vaadin.sass.tree.VariableNode;
+
+public class VariableVisitor implements Visitor {
+
+    @Override
+    public void traverse(Node node) {
+        Map<String, LexicalUnitImpl> variables = new HashMap<String, LexicalUnitImpl>();
+        traverse(node, variables);
+    }
+
+    private void traverse(Node node, Map<String, LexicalUnitImpl> variables) {
+        if (node instanceof RuleNode) {
+            LexicalUnit value = ((RuleNode) node).getValue();
+            while (updateValue(value, variables)) {
+                ;
+            }
+        } else {
+            Set<Node> toBeDeleted = new HashSet<Node>();
+            for (Node child : node.getChildren()) {
+                if (child instanceof VariableNode) {
+                    VariableNode varChild = (VariableNode) child;
+                    if (!varChild.isGuarded() || varChild.isGuarded()
+                            && variables.get(varChild.getName()) == null) {
+                        variables.put(((VariableNode) child).getName(),
+                                (LexicalUnitImpl) ((VariableNode) child)
+                                        .getExpr());
+                    }
+                    toBeDeleted.add(child);
+                } else {
+                    traverse(child, new HashMap<String, LexicalUnitImpl>(
+                            variables));
+                }
+            }
+            for (Node child : toBeDeleted) {
+                node.removeChild(child);
+            }
+        }
+    }
+
+    private boolean updateValue(LexicalUnit value,
+            Map<String, LexicalUnitImpl> variables) {
+        boolean onceMore = false;
+        if (value == null) {
+            return false;
+        }
+        if (value.getLexicalUnitType() == SCSSLexicalUnit.SCSS_VARIABLE) {
+            LexicalUnitImpl variableValue = variables.get(value
+                    .getStringValue());
+            if (variableValue != null) {
+                LexicalUnitImpl variableValueCloned = variableValue.clone();
+                if (variableValueCloned != null) {
+                    LexicalUnitImpl lexVal = (LexicalUnitImpl) value;
+                    lexVal.replaceValue(variableValueCloned);
+                    onceMore = true;
+                }
+            }
+        } else if (value.getLexicalUnitType() == SCSSLexicalUnit.SAC_FUNCTION) {
+            LexicalUnit params = value.getParameters();
+            updateValue(params, variables);
+        }
+        LexicalUnit next = value.getNextLexicalUnit();
+        updateValue(next, variables);
+        return onceMore;
+    }
+}
diff --git a/theme-compiler/src/com/vaadin/sass/visitor/Visitor.java b/theme-compiler/src/com/vaadin/sass/visitor/Visitor.java
new file mode 100644
index 0000000000..046cb7c0d1
--- /dev/null
+++ b/theme-compiler/src/com/vaadin/sass/visitor/Visitor.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2011 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.sass.visitor;
+
+import com.vaadin.sass.tree.Node;
+
+public interface Visitor {
+
+    public void traverse(Node node) throws Exception;
+}