path: root/gnu/javax/swing/text/html/css/CSSParser.java

/* CSSParser.java -- A parser for CSS stylesheets
   Copyright (C) 2006 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath 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 the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package gnu.javax.swing.text.html.css;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;

/**
 * A parser for CSS stylesheets.
 *
 * This parser is based on the simple CSS grammar describe in
 *
 * http://www.w3.org/TR/CSS21/syndata.html .
 *
 * @author Roman Kennke (kennke@aicas.com)
 */
// TODO: Maybe use more restrictive grammar:
// http://www.w3.org/TR/CSS21/grammar.html#q1
public class CSSParser
{

  /**
   * The scanner used to read the input streams into more usable tokens.
   */
  private CSSScanner scanner;

  /**
   * The parser callback.
   */
  private CSSParserCallback callback;

  /**
   * One lookahead token.
   */
  private int lookahead;

  /**
   * The parse error.
   */
  private String error;

  /**
   * Creates a new CSSParser that parses the specified input.
   *
   * @param in the source to parse
   */
  public CSSParser(Reader in, CSSParserCallback cb)
  {
    scanner = new CSSScanner(in);
    callback = cb;
    lookahead = -1;
  }

  /**
   * Parses the input source specified in the constructor.
   *
   * @throws IOException if an IO or parse error occurs
   */
  public void parse()
    throws IOException
  {
    boolean success = parseStylesheet();
    if (! success)
      {
        throw new CSSParserException(error);
      }
  }

  /**
   * Parses a stylesheet.
   *
   * @return <code>true</code> if the stylesheet could be parsed successfully,
   *         <code>false</code> otherwise
   * 
   * @throws IOException if an IO or parse error occurs
   */
  private boolean parseStylesheet()
    throws IOException
  {
    int token = peekToken();
    while (token != CSSScanner.EOF && (token == CSSScanner.CDC
           || token == CSSScanner.CDO || token == CSSScanner.S
           || parseStatement()))
      {
        if (token == CSSScanner.CDC || token == CSSScanner.CDO
            || token == CSSScanner.S)
          readToken();
        token = peekToken();
      }
    // Last token must be EOF for valid stylesheets, I'd think.
    return token == CSSScanner.EOF;
  }

  /**
   * Parses a CSS statement.
   * @return <code>true</code> if the stylesheet could be parsed successfully,
   *         <code>false</code> otherwise
   * 
   * @throws IOException if an IO or parse error occurs
   */
  private boolean parseStatement()
    throws IOException
  {
    return parseRuleset() || parseAtRule();
  }

  /**
   * Parses a CSS rule set.
   *
   * @return <code>true</code> if the ruleset could be parsed successfully,
   *         <code>false</code> otherwise
   * 
   * @throws IOException if an IO or parse error occurs
   */
  private boolean parseRuleset()
    throws IOException
  {
    StringBuilder selector = new StringBuilder();
    parseSelector(selector);
    callback.startStatement(selector.toString());
    // Read any number of whitespace.
    int token;
    do
      {
        token = readToken();
      } while (token == CSSScanner.S);
    boolean ret = true;

    if (token == CSSScanner.CURLY_LEFT)
      {
        // Read any number of whitespace.
        do
          {
            token = readToken();
          } while (token == CSSScanner.S);
        lookahead = token;

        // Maybe read declaration.
        boolean decl = parseDeclaration();
        token = peekToken();
        while (token == CSSScanner.SEMICOLON)
          {
            readToken(); // Read the semicolon.
            // Read any number of whitespace.
            do
              {
                token = readToken();
              } while (token == CSSScanner.S);
            lookahead = token;

            // Maybe read declaration.
            parseDeclaration();
            token = peekToken();
          }
        if (token != CSSScanner.CURLY_RIGHT)
          {
            error = "Expected right curly brace";
            ret = false;
          }
        else
          {
            readToken();
            // Read any number of whitespace.
            do
              {
                token = readToken();
              } while (token == CSSScanner.S);
            lookahead = token;
            callback.endStatement();
          }
      }
    else
      {
        ret = false;
        error = "Expected left curly brace";
      }
    return ret;
  }

  /**
   * Parses a CSS declaration.
   *
   * @return <code>true</code> if the ruleset could be parsed successfully,
   *         <code>false</code> otherwise
   * 
   * @throws IOException if an IO or parse error occurs
   */
  private boolean parseDeclaration()
   throws IOException
  {
    // Maybe fetch one DELIM.
    int token = readToken();
    if (token == CSSScanner.DELIM)
      token = readToken();

    boolean ret = true;

    // Parse property
    String property = null;
    if (token == CSSScanner.IDENT)
      {
        property = new String(scanner.parseBuffer, 0, scanner.tokenEnd);
        // Read any number of whitespace.
        do
          {
            token = readToken();
          } while (token == CSSScanner.S);

        // Read ':'.
        if (token == CSSScanner.DELIM && scanner.parseBuffer[0] == ':')
          {
            // Read any number of whitespace.
            do
              {
                token = readToken();
              } while (token == CSSScanner.S);
            lookahead = token;

            StringBuilder value = new StringBuilder();
            if (parseValue(value))
              {
                callback.declaration(property, value.toString());
              }
            else
              {
                ret = false;
                error = "Error while reading the property value";
              }
          }
        else
          {
            ret = false;
            error = "Expected colon to separate property and value";
          }
          
      }
    else
      {
        lookahead = token;
        ret = false;
        error = "Expected IDENT token for property";
      }
    return ret;
  }

  /**
   * Parses a property value.
   *
   * @param s the string builder to read the value into
   *
   * @return <code>true</code> if the ruleset could be parsed successfully,
   *         <code>false</code> otherwise
   * 
   * @throws IOException if an IO or parse error occurs
   */
  private boolean parseValue(StringBuilder s)
    throws IOException
  {
    // FIXME: Handle block and ATKEYWORD.
    return parseAny(s);
  }

  /**
   * Parses a selector.
   *
   * @param sel the string buffer to put the selector into
   *
   * @return <code>true</code> if the ruleset could be parsed successfully,
   *         <code>false</code> otherwise
   * 
   * @throws IOException if an IO or parse error occurs
   */
  private boolean parseSelector(StringBuilder sel)
    throws IOException
  {
    // At least one any needs to be parsed.
    boolean ret = parseAny(sel);
    if (ret)
      {
        while (parseAny(sel));
      }
    return ret;
  }

  /**
   * Parses the any rule. If s is not null, then the contents of the
   * tokens is appended verbatim.
   *
   * @param s the string builder to append to
   *
   * @return <code>true</code> if the ruleset could be parsed successfully,
   *         <code>false</code> otherwise
   * 
   * @throws IOException if an IO or parse error occurs
   */
  private boolean parseAny(StringBuilder s)
    throws IOException
  {
    int token = peekToken();
    boolean ret = false;
    if (token == CSSScanner.IDENT || token == CSSScanner.NUMBER
        || token == CSSScanner.PERCENTAGE || token == CSSScanner.DIMENSION
        || token == CSSScanner.STRING || token == CSSScanner.DELIM
        || token == CSSScanner.URI || token == CSSScanner.HASH
        || token == CSSScanner.UNICODE_RANGE || token == CSSScanner.INCLUDES
        || token == CSSScanner.DASHMATCH)
      {
        if (s != null)
          s.append(scanner.parseBuffer, 0, scanner.tokenEnd);
        readToken();
        ret = true;
      }
    else if (token == CSSScanner.FUNCTION)
      System.err.println("Implement parseAny for FUNCTION");
    else if (token == CSSScanner.PAREN_LEFT)
      System.err.println("Implement parseAny for (");
    else if (token == CSSScanner.BRACE_LEFT)
      System.err.println("Implement parseAny for [");

    // Parse any following whitespace too.
    token = peekToken();
    while (token == CSSScanner.S)
      {
        if (s != null)
          s.append(scanner.parseBuffer, 0, scanner.tokenEnd);
        readToken();
        token = peekToken();
      }
    return ret;
  }

  /**
   * Parses a CSS at-rule.
   *
   * @return <code>true</code> if the at-rule could be parsed successfully,
   *         <code>false</code> otherwise
   * 
   * @throws IOException if an IO or parse error occurs
   */
  private boolean parseAtRule()
    throws IOException
  {
    // FIXME: Implement.
    return false;
  }

  /**
   * Reads the next token, and skips the comments.
   *
   * @return the next non-comment token
   */
  private int readToken()
    throws IOException
  {
    int token;
    if (lookahead == -1)
      {
        do
          {
            token = scanner.nextToken();
          } while (token == CSSScanner.COMMENT);
      }
    else
      {
        token = lookahead;
        lookahead = -1;
      }
    return token;
  }

  /**
   * Returns the next token to be read, without really reading it. The next
   * call to readToken() will return the same token again.
   *
   * @return the next token to be read, without really reading it
   */
  private int peekToken()
    throws IOException
  {
    int token;
    if (lookahead == -1)
      {
        do
          {
            token = scanner.nextToken();
          } while (token == CSSScanner.COMMENT);
        lookahead = token;
      }
    else
      token = lookahead;
    return token;
  }

  /**
   * For testing, we read in the default.css in javax/swing/text/html
   *
   * @param args
   */
  public static void main(String[] args)
  {
    try
      {
        String name = "/javax/swing/text/html/default.css";
        InputStream in = CSSScanner.class.getResourceAsStream(name);
        BufferedInputStream bin = new BufferedInputStream(in);
        InputStreamReader r = new InputStreamReader(bin);
        CSSParserCallback cb = new CSSParserCallback()
        {
          public void startStatement(String selector)
          {
            System.out.println("startStatement: " + selector);
          }
          public void endStatement()
          {
            System.out.println("endStatement");
          }
          public void declaration(String property, String value)
          {
            System.out.println("declaration: " + property + ", " + value);
          }
        };
        CSSParser p = new CSSParser(r, cb);
        p.parse();
      }
    catch (IOException ex)
      {
        ex.printStackTrace();
      }
  }

}