Constructors are public.

[cql-java-moved-to-github.git] / src / org / z3950 / zing / cql / CQLParser.java

diff --git a/src/org/z3950/zing/cql/CQLParser.java b/src/org/z3950/zing/cql/CQLParser.java
index 0ccd539..58e0326 100644 (file)
--- a/src/org/z3950/zing/cql/CQLParser.java
+++ b/src/org/z3950/zing/cql/CQLParser.java
@@ -1,4 +1,4 @@
-// $Id: CQLParser.java,v 1.34 2007-06-29 12:54:05 mike Exp $
+// $Id: CQLParser.java,v 1.39 2007-08-06 15:54:48 mike Exp $
 
 package org.z3950.zing.cql;
 import java.io.IOException;
@@ -12,15 +12,44 @@ import java.io.FileNotFoundException;
 /**
  * Compiles CQL strings into parse trees of CQLNode subtypes.
  *
- * @version    $Id: CQLParser.java,v 1.34 2007-06-29 12:54:05 mike Exp $
+ * @version    $Id: CQLParser.java,v 1.39 2007-08-06 15:54:48 mike Exp $
  * @see                <A href="http://zing.z3950.org/cql/index.html"
  *                     >http://zing.z3950.org/cql/index.html</A>
  */
 public class CQLParser {
     private CQLLexer lexer;
+    private int compat;        // When false, implement CQL 1.2
+    public static int V1POINT1 = 12368;
+    public static int V1POINT2 = 12369;
+    public static int V1POINT1SORT = 12370;
+
     static private boolean DEBUG = false;
     static private boolean LEXDEBUG = false;
 
+    /**
+     * The new parser implements a dialect of CQL specified by the
+     * <tt>compat</tt> argument:
+     * <ul>
+     *  <li>V1POINT1 - CQL version 1.1
+     *  </li>
+     *  <li>V1POINT2 - CQL version 1.2
+     *  </li>
+     *  <li>V1POINT1SORT - CQL version 1.1 but including
+     *         <tt>sortby</tt> as specified for CQL 1.2.
+     *  </li>
+     * </ul>
+     */
+    public CQLParser(int compat) {
+       this.compat = compat;
+    }
+
+    /**
+     * The new parser implements CQL 1.2
+     */
+    public CQLParser() {
+       this.compat = V1POINT2;
+    }
+
     private static void debug(String str) {
        if (DEBUG)
            System.err.println("PARSEDEBUG: " + str);
@@ -48,19 +77,53 @@ public class CQLParser {
 
        lexer.nextToken();
        debug("about to parseQuery()");
-       CQLNode root = parseQuery("srw.serverChoice", new CQLRelation("scr"));
+       CQLNode root = parseTopLevelPrefixes("cql.serverChoice",
+               new CQLRelation(compat == V1POINT2 ? "=" : "scr"));
        if (lexer.ttype != lexer.TT_EOF)
            throw new CQLParseException("junk after end: " + lexer.render());
 
        return root;
     }
 
+    private CQLNode parseTopLevelPrefixes(String index, CQLRelation relation)
+       throws CQLParseException, IOException {
+       debug("top-level prefix mapping");
+
+       if (lexer.ttype == '>') {
+           return parsePrefix(index, relation, true);
+       }
+
+       CQLNode node = parseQuery(index, relation);
+       if ((compat == V1POINT2 || compat == V1POINT1SORT) &&
+           lexer.ttype == lexer.TT_SORTBY) {
+           match(lexer.ttype);
+           debug("sortspec");
+
+           CQLSortNode sortnode = new CQLSortNode(node);
+           while (lexer.ttype != lexer.TT_EOF) {
+               String sortindex = matchSymbol("sort index");
+               ModifierSet ms = gatherModifiers(sortindex);
+               sortnode.addSortIndex(ms);
+           }
+
+           if (sortnode.keys.size() == 0) {
+               throw new CQLParseException("no sort keys");
+           }
+
+           node = sortnode;
+       }
+
+       return node;
+    }
+
     private CQLNode parseQuery(String index, CQLRelation relation)
        throws CQLParseException, IOException {
        debug("in parseQuery()");
 
        CQLNode term = parseTerm(index, relation);
-       while (lexer.ttype != lexer.TT_EOF && lexer.ttype != ')') {
+       while (lexer.ttype != lexer.TT_EOF &&
+              lexer.ttype != ')' &&
+              lexer.ttype != lexer.TT_SORTBY) {
            if (lexer.ttype == lexer.TT_AND ||
                lexer.ttype == lexer.TT_OR ||
                lexer.ttype == lexer.TT_NOT ||
@@ -124,8 +187,7 @@ public class CQLParser {
                match(')');
                return expr;
            } else if (lexer.ttype == '>') {
-               match('>');
-               return parsePrefix(index, relation);
+               return parsePrefix(index, relation, false);
            }
 
            debug("non-parenthesised term");
@@ -149,10 +211,12 @@ public class CQLParser {
        return node;
     }
 
-    private CQLNode parsePrefix(String index, CQLRelation relation)
+    private CQLNode parsePrefix(String index, CQLRelation relation,
+                               boolean topLevel)
        throws CQLParseException, IOException {
        debug("prefix mapping");
 
+       match('>');
        String name = null;
        String identifier = matchSymbol("prefix-name");
        if (lexer.ttype == '=') {
@@ -160,8 +224,11 @@ public class CQLParser {
            name = identifier;
            identifier = matchSymbol("prefix-identifer");
        }
-       CQLNode term = parseQuery(index, relation);
-       return new CQLPrefixNode(name, identifier, term);
+       CQLNode node = topLevel ?
+           parseTopLevelPrefixes(index, relation) :
+           parseQuery(index, relation);
+
+       return new CQLPrefixNode(name, identifier, node);
     }
 
     // Checks for a relation
@@ -173,7 +240,8 @@ public class CQLParser {
                lexer.ttype == '=' ||
                lexer.ttype == lexer.TT_LE ||
                lexer.ttype == lexer.TT_GE ||
-               lexer.ttype == lexer.TT_NE);
+               lexer.ttype == lexer.TT_NE ||
+               lexer.ttype == lexer.TT_EQEQ);
     }
 
     private void match(int token)
@@ -204,7 +272,8 @@ public class CQLParser {
            lexer.ttype == lexer.TT_AND ||
            lexer.ttype == lexer.TT_OR ||
            lexer.ttype == lexer.TT_NOT ||
-           lexer.ttype == lexer.TT_PROX) {
+           lexer.ttype == lexer.TT_PROX ||
+           lexer.ttype == lexer.TT_SORTBY) {
            String symbol = (lexer.ttype == lexer.TT_NUMBER) ?
                lexer.render() : lexer.sval;
            match(lexer.ttype);
@@ -263,6 +332,10 @@ public class CQLParser {
      * &lt;/triple&gt;
      * </PRE>
      * <P>
+     * @param -1
+     * CQL version 1.1 (default version 1.2)
+     * @param -d
+     * Debug mode: extra output written to stderr.
      * @param -c
      * Causes the output to be written in CQL rather than XCQL - that
      * is, a query equivalent to that which was input, is output.  In
@@ -280,6 +353,12 @@ public class CQLParser {
            argv.add(args[i]);
        }
 
+       int compat = V1POINT2;
+       if (argv.size() > 0 && argv.get(0).equals("-1")) {
+           compat = V1POINT1;
+           argv.remove(0);
+       }
+
        if (argv.size() > 0 && argv.get(0).equals("-d")) {
            DEBUG = true;
            argv.remove(0);
@@ -296,7 +375,8 @@ public class CQLParser {
        }
 
        if (argv.size() > 1) {
-           System.err.println("Usage: CQLParser [-d] [-c] [-p <pqf-properties> [<CQL-query>]");
+           System.err.println("Usage: CQLParser [-1] [-d] [-c] " +
+                              "[-p <pqf-properties> [<CQL-query>]");
            System.err.println("If unspecified, query is read from stdin");
            System.exit(1);
        }
@@ -316,7 +396,7 @@ public class CQLParser {
            cql = new String(bytes);
        }
 
-       CQLParser parser = new CQLParser();
+       CQLParser parser = new CQLParser(compat);
        CQLNode root = null;
        try {
            root = parser.parse(cql);