Changeset 173

Timestamp:

01/11/08 02:38:02 (8 months ago)

Author:

Don Clugston

Message:

* Refactored SyntaxTree?.
* Scalar folding of min, max.
* Improved comments.

Files:

• trunk/blade/Blade.d (modified) (2 diffs)
• trunk/blade/BladeSimplify.d (modified) (6 diffs)
• trunk/blade/PostfixX86.d (modified) (2 diffs)
• trunk/blade/SyntaxTree.d (modified) (6 diffs)

trunk/blade/Blade.d

@@ -33 +33 @@
-*    Except: Addition inside a dot product or vector sum is treated as associative.
-*
-* BUGS:
-*  Need to create asserts for nested expressions as well as for the primary one.
-*
-* FUTURE DIRECTIONS (in order of expected implementation):
-* - trace()
@@ -56 +53 @@
-*       (passes pointers, not arrays).
-* 0.5 - Expression simplification step. Slicing support.
-
+, intrinsics: abs, sqrt, sum
-*/
-

trunk/blade/BladeSimplify.d

@@ -15 +15 @@
-*    - Use associativity of *: A*(B*C[]) == (A*B)*C[] (Not strictly true for
-*      floating point; results may differ by 1ulp, 
-
+*
-*      Note that floating point addition is not associative at all).
+*    - Remove unary minus where possible, eg A-(-B) => A+B, abs(-A) => abs(A).
+*    - Use associativity of * in intrinsics: 
+*         sum(A*V) => A*sum(V), abs(A*B) => abs(A)*abs(B)
-* (D) Expression standardisation 
-*    - Move multiplies to left: Convert A[]*B into B*A[] (assumes * is commutative,
-*      not valid for quaternions).
-*    - Convert C-A*B into C+(-A)*B whenever possible.
-*    - Remove unary minus where possible, eg convert A-(-B) into A+B.
-*
-* Author:
@@ -51 +53 @@
-bool isBladeIntrinsic(char [] str)
-{
-
+
+
-}
-
@@ -282 +285 @@
-    }
-    ReturnType onVisitFunction(This this_, char [] func, char [][] args) {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-    }
-    ReturnType onVisitPrefix(This this_, char [] op, char [] expr) {
@@ -465 +459 @@
-    }
-    ReturnType onVisitFunction(This this_, char [] func, char [][] args) {
+        ScalarFold left = doVisit(this_,args[0]);
-        switch(func) {
-        case "dot":
-            // dot(a*v1, c*v2) == (a*b)*dot(v1, v2)
-            // this is a scalar, but the dot is a nested expression
-            ScalarFold left = doVisit(this_,args[0]);
-            ScalarFold right = doVisit(this_, args[1]);
-            return ScalarFold("", combineMul(combineMul(left.multiplier, right.multiplier), "{" ~ func ~ "(" ~ wrapInParens(left.expr) ~ "," ~ wrapInParens(right.expr) ~ ")}"));
-        case "sum": 
-
-
+
-            return ScalarFold("", combineMul(left.multiplier, "{" ~ func ~ "(" ~ wrapInParens(left.expr) ~ ")}"));
-
-
-
+
+
+
+
+
+
+
-            return ScalarFold((left.expr!="" ? func ~ "(" ~ wrapInParens(left.expr) ~ ")" : ""), (left.multiplier.length>0 && left.multiplier!="-")? func ~ "(" ~ wrapInParens(left.multiplier) ~ ")":"");
-        case "sqrt":
-            // There's a reduction in precision if we use f(a*v)==f(a)*f(v); also
-            // a and b could both be negative.
-            ScalarFold left = doVisit(this_,args[0]);
-            return ScalarFold((left.expr!="" ? func ~ "(" ~ wrapInParens(left.expr) ~ ")" : ""), (left.multiplier.length>0)? func ~ "(" ~ wrapInParens(left.multiplier) ~ ")":"");
+        case "max":
+        case "min": // max(A*B) can't be simplified unless we know that they are not negative.
+            return ScalarFold("", "{" ~ func ~ "(" ~ combineMulWithCompound(left.expr, left.multiplier) ~ ")}"); 
+//            return ScalarFold("", "{" ~ func ~ "(@>"  ~ left.expr ~ "@" ~ left.multiplier ~ "<@)}"); 
-        default:
-            assert(0, "BLADE: Unsupported function");
@@ -583 +583 @@
-}
-
-
+ (unless it is trivial)
-char [] combineMulWithCompound(char [] left, char [] right)
-{
@@ -613 +613 @@
-    assert(foldScalars("abs((A*abs(B)))", "10")=="(abs(A))*{(abs((abs(B))))}");
-    assert(foldScalars("abs((-A))", "1")=="abs(A)");
-
+
+
+

trunk/blade/PostfixX86.d

@@ -13 +13 @@
-*  *+-/         ST(0)*ST(1), ST(0)+ST(1), ST(0)-ST(1), ST(0)/ST(1) and pop stack
-*  _            ST(1)-ST(0) and pop stack
-stack top
+ST(0)
-*  ,            duplicate stack top (so ,* means ST=ST*ST, ,+ means ST*=2)
-*  a            abs
-*  n            unary negation
+*  m            ST(0) = max(ST(0), ST(1))
+*  u            ST(1) = min(ST(0), ST(1))
+*  q            sqrt
-*
-*  NOT YET IMPLEMENTED:
-*  1            the literal one (used to initialize a product, for example)
-
-
+
+
+
-*/
-
@@ -57 +61 @@
-    }
-    ReturnType onVisitFunction(This this_, char [] func, char [][] args) {
+        char [] left = doVisit(this_,args[0]);
-        switch(func) {
-        case "dot":
-            char [] left = doVisit(this_,args[0]);
-            char [] right = doVisit(this_, args[1]);
-            if (left==right) return "0" ~ left ~ ",*+";
-            return "0" ~ left ~ right ~ "*+";
-
-
-
-
+
+
+
+
+
-        default:     assert(0, "BLADE ICE: Unsupported");
-        }

trunk/blade/SyntaxTree.d

@@ -18 +18 @@
-*
-* BUGS:
-
+ by mixin_getPrecedence()
-*       unary operators & !
-*       && and || operators
@@ -24 +24 @@
-*       ?:
-*       cast
-
+, functions and delegates
-*       mixin, assert, and import expressions
-*       D 2.004 string literals.
@@ -106 +106 @@
-
-//  ==== LEXER ====
-
-/** Return true if text is a non-value, non-type D keyword
- */
-bool isNonTypeKeyword(char [] text) {
-    char [][] keywords = [ 
-    // "byte", "bool", "cdouble", "cent", "cfloat", "cdouble", "creal", "char",
-    // "double", "dchar", "false", "float", "idouble", "ifloat", "int", "ireal", "long",
-    // "null", "real", "short", "true", "ubyte", "ucent", "uint", "ulong", "ushort",
-    // "wchar", "this", "super", "void"
-    "abstract", "alias", "align", "asm", "assert", "auto", "body", "break",
-    "case", "cast", "catch", "class", "const", "continue", "dchar", "debug",
-    "default", "delegate", "delete", "deprecated", "do", "else", "enum",
-    "export", "extern", "final", "finally", "for", "foreach", "foreach_reverse",
-    "function", "goto", "if", "import", "in", "inout", "interface", "invariant",
-    "is", "lazy", "macro", "mixin", "module", "new", "out", "override",
-    "package", "pragma", "private", "protected", "public", "ref", "return",
-    "scope", "static", "struct", "switch", "synchronized", "template", "throw",
-    "__traits", "try", "typedef", "typeid", "typeof", "union", "unittest",
-    "version", "volatile", "while", "with" ];
-    
-    foreach(char [] s; keywords) {
-        if (s==text) return true;
-    }
-    return false;
-}
-
-/** 
- * Extract all terminal symbols(identifiers, type names, and literals)
@@ -145 +119 @@
-    char [] code = "";
-    char [][] symbols = [];
-    char [] symbol = "";
-    expr ~= " "; // ensure that it ends.
-    char quote=0; // character which marks end of string literal, 0 if none
+    int startOfSymbol=0;
-    for(int i=0; i<expr.length; ++i) {
-        char c = expr[i];
-        // Deal with string literals
-        if (quote != 0) {
-
-
+
-            continue;
-        } else if (c == '"' || c == '`' || c == '\'') { // Is a string literal beginning?
-            symbol ~= c;
-            quote = c;
-            continue;
-        }
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        } else {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-    if (code[$-1]==' ') code=code[0..$-1]; // remove the " " we added.
@@ -306 +274 @@
- * Insert parentheses around each symbol, to enforce normal D precedence rules.
- * Returns: a string which, when mixed in, generates a parenthesised expression.
- *    
- *   Bugs:
- *    Doesn't support:
- *      unary operators & !
- *      && and || operators
- *      ?:
- *      Comparison and NCEG floating point operators
- *      cast
- *      new, delete, anonymous classes
- *      mixin, assert, and import expressions
- */
-char [] mixin_getPrecedence(char [] expr)
@@ -415 +373 @@
-    assert(mixin(mixin_getPrecedence("A([B,C])"))=="A(([B,C]))");    
-}
+/+   // NO LONGER USED
+/** Return true if text is a non-value, non-type D keyword
+ */
+bool isNonTypeKeyword(char [] text) {
+    char [][] keywords = [ 
+    "abstract", "alias", "align", "asm", "assert", "auto", "body", "break",
+    "case", "cast", "catch", "class", "const", "continue", "dchar", "debug",
+    "default", "delegate", "delete", "deprecated", "do", "else", "enum",
+    "export", "extern", "final", "finally", "for", "foreach", "foreach_reverse",
+    "function", "goto", "if", "import", "in", "inout", "interface", "invariant",
+    "is", "lazy", "macro", "mixin", "module", "new", "out", "override",
+    "package", "pragma", "private", "protected", "public", "ref", "return",
+    "scope", "static", "struct", "switch", "synchronized", "template", "throw",
+    "__traits", "try", "typedef", "typeid", "typeof", "union", "unittest",
+    "version", "volatile", "while", "with" ];
+    
+    foreach(char [] s; keywords) {
+        if (s==text) return true;
+    }
+    return false;
+}
++/