Changeset 8256 in josm for trunk

Timestamp:

2015-04-25T00:44:00+02:00 (10 years ago)

Author:

bastiK

Message:

mapcss: improve expression parsing
Now it respects operator precedence (C/C++ style) and allows
mix of plus and minus like this:

3 + 2 * 5 - 2 + 10

This is parsed as

(((3 + (2 * 5)) - 2) + 10)

Location:

trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss

Files:

• ExpressionFactory.java (modified) (1 diff)
• MapCSSParser.jj (modified) (3 diffs)

trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/ExpressionFactory.java

@@ -618 +618 @@
 
         /**
+         * Determines if the objects {@code a} and {@code b} are not equal.
+         * @param a First object
+         * @param b Second object
+         * @return {@code false} if objects are equal, {@code true} otherwise
+         * @see Object#equals(Object)
+         */
+        public static boolean not_equal(Object a, Object b) {
+            return !equal(a,b);
+        }
+        /**
          * Determines whether the JOSM search with {@code searchStr} applies to the object.
          * @param env the environment

trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/MapCSSParser.jj

@@ -10 +10 @@
 import java.io.InputStream;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
@@ -854 +856 @@
 }
 
-Expression expression():
-{
-    List<Expression> args = new ArrayList<Expression>();
+/**
+ * General expression.
+ * Separate production rule for each level of operator precedence (recursive descent).
+ */
+Expression expression() :
+{
+    Expression e;
+}
+{
+    e=conditional_expression()
+    {
+        return e;
+    }
+}
+
+Expression conditional_expression() :
+{
+    Expression e, e1, e2;
+    String op = null;
+}
+{
+    e=or_expression()
+    (
+        <QUESTION> w()
+        e1=conditional_expression()
+        <COLON> w()
+        e2=conditional_expression()
+        {
+            e = ExpressionFactory.createFunctionExpression("cond", Arrays.asList(e, e1, e2));
+        }
+    )?
+    {
+        return e;
+    }
+}
+
+Expression or_expression() :
+{
+    Expression e, e2;
+    String op = null;
+}
+{
+    e=and_expression()
+    (
+        <PIPE> <PIPE> w()
+        e2=and_expression()
+        {
+            e = ExpressionFactory.createFunctionExpression("or", Arrays.asList(e, e2));
+        }
+    )*
+    {
+        return e;
+    }
+}
+
+Expression and_expression() :
+{
+    Expression e, e2;
+    String op = null;
+}
+{
+    e=relational_expression()
+    (
+        <AMPERSAND> <AMPERSAND> w()
+        e2=relational_expression()
+        {
+            e = ExpressionFactory.createFunctionExpression("and", Arrays.asList(e, e2));
+        }
+    )*
+    {
+        return e;
+    }
+}
+
+Expression relational_expression() :
+{
+    Expression e, e2;
+    String op = null;
+}
+{
+    e=additive_expression()
+    (
+        (
+            <GREATER_EQUAL> { op = "greater_equal"; }
+            |
+            <LESS_EQUAL> { op = "less_equal"; }
+            |
+            <GREATER> { op = "greater"; }
+            |
+            <LESS> { op = "less"; }
+            |
+            <EQUAL> ( <EQUAL> )? { op = "equal"; }
+            |
+            <EXCLAMATION> <EQUAL> { op = "not_equal"; }
+        ) w()
+        e2=additive_expression()
+        {
+            e = ExpressionFactory.createFunctionExpression(op, Arrays.asList(e, e2));
+        }
+    )?
+    {
+        return e;
+    }
+}
+
+Expression additive_expression() :
+{
+    Expression e, e2;
+    String op = null;
+}
+{
+    e=multiplicative_expression()
+    (
+        ( <PLUS> { op = "plus"; } | <MINUS> { op = "minus"; } ) w()
+        e2=multiplicative_expression()
+        {
+            e = ExpressionFactory.createFunctionExpression(op, Arrays.asList(e, e2));
+        }
+    )*
+    {
+        return e;
+    }
+}
+
+Expression multiplicative_expression() :
+{
+    Expression e, e2;
+    String op = null;
+}
+{
+    e=unary_expression()
+    (
+        ( <STAR> { op = "times"; } | <SLASH> { op = "divided_by"; } ) w()
+        e2=unary_expression()
+        {
+            e = ExpressionFactory.createFunctionExpression(op, Arrays.asList(e, e2));
+        }
+    )*
+    {
+        return e;
+    }
+}
+
+Expression unary_expression() :
+{
     Expression e;
     String op = null;
@@ -862 +1006 @@
 {
     (
-        <EXCLAMATION> { op = "not"; } w() e=primary() { args.add(e); } w()
-    |
-        <MINUS> { op = "minus"; } w() e=primary() { args.add(e); } w()
-    |
-
-        (
-            e=primary() { args.add(e); } w()
-            (
-                    ( <PLUS> { op = "plus"; } w() e=primary() { args.add(e); } w() )+
-                |
-                    ( <STAR> { op = "times"; } w() e=primary() { args.add(e); } w() )+
-                |
-                    ( <MINUS> { op = "minus"; } w() e=primary() { args.add(e); } w() )+
-                |
-                    ( <SLASH> { op = "divided_by"; } w() e=primary() { args.add(e); } w() )+
-                |
-                    <GREATER_EQUAL> { op = "greater_equal"; } w() e=primary() { args.add(e); } w()
-                |
-                    <LESS_EQUAL> { op = "less_equal"; } w() e=primary() { args.add(e); } w()
-                |
-                    <GREATER> { op = "greater"; } w() e=primary() { args.add(e); } w()
-                |
-                    <EQUAL> ( <EQUAL> )? { op = "equal"; } w() e=primary() { args.add(e); } w()
-                |
-                    <LESS> { op = "less"; } w() e=primary() { args.add(e); } w()
-                |
-                    <AMPERSAND> <AMPERSAND> { op = "and"; } w() e=primary() { args.add(e); } w()
-                |
-                    <PIPE> <PIPE> { op = "or"; } w() e=primary() { args.add(e); } w()
-                |
-                    <QUESTION> { op = "cond"; } w() e=primary() { args.add(e); } w() <COLON> w() e=primary() { args.add(e); } w()
-            )?
-        )
-    )
+        <MINUS> { op = "minus"; } w()
+    |
+        <EXCLAMATION> { op = "not"; } w()
+    )?
+    e=primary() w()
     {
         if (op == null)
-            return args.get(0);
-        return ExpressionFactory.createFunctionExpression(op, args);
+            return e;
+        return ExpressionFactory.createFunctionExpression(op, Collections.singletonList(e));
     }
 }