Subversion Repositories openrisc

/* 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.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.util.StringTokenizer;

/**

 * 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);

    StringTokenizer selSplitter =

      new StringTokenizer(selector.toString(), ",");

    Selector[] sels = new Selector[selSplitter.countTokens()];

    for (int i = 0; selSplitter.hasMoreTokens(); i++)

      {

        String sel = selSplitter.nextToken().trim();

        sels[i] = new Selector(sel);

      }

    callback.startStatement(sels);

    // 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().trim());

              }

            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.

    boolean success = parseAny(s);

    while (parseAny(s))

      ;

    return success;

  }

  /**

   * 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

      {

        InputStream in;

        if (args.length > 0)

          {

            File file = new File(args[0]);

            in = new FileInputStream(file);

          }

        else

          {

            String name = "/javax/swing/text/html/default.css";

            in = CSSScanner.class.getResourceAsStream(name);

          }

        BufferedInputStream bin = new BufferedInputStream(in);

        InputStreamReader r = new InputStreamReader(bin);

        CSSParserCallback cb = new CSSParserCallback()

        {

          public void startStatement(Selector[] selector)

          {

            System.out.print("startStatement: ");

            for (int i = 0; i < selector.length; i++)

              {

                System.out.print(selector[i]);

                if (i < selector.length - 1)

                  System.out.print(',');

                else

                  System.out.println();

              }

          }

          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();

      }

  }

}