obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 503 insertions, 0 deletions

diff --git a/libjava/classpath/gnu/javax/swing/text/html/css/CSSParser.java b/libjava/classpath/gnu/javax/swing/text/html/css/CSSParser.java
new file mode 100644
index 000000000..4be315e37
--- /dev/null
+++ b/libjava/classpath/gnu/javax/swing/text/html/css/CSSParser.java
@@ -0,0 +1,503 @@
+/* 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();
+      }
+  }
+
+}