Changeset 109

Timestamp:

09/11/07 14:37:45 (1 year ago)

Author:

Don Clugston

Message:

Syntax tree refactored, now works with functions.
Front-end joined to back end again.

Files:

• trunk/blade/Blade.d (modified) (5 diffs)
• trunk/blade/SyntaxTree.d (modified) (6 diffs)
• trunk/blade/SyntaxTreeDemo.d (added)

trunk/blade/Blade.d

@@ -49 +49 @@
-*/
-
-
+
+
-
-// General utilities.
@@ -911 +912 @@
-}
-
-
-
+GEN
+GEN
-     foreach (K; values) {
-        writefln("Param: ", K);
@@ -934 +935 @@
-}
-
+char [] makeSSE(AbstractSyntaxTree tree)
+{
+    char [] result = "SSEVECGEN!(" ~ wrapInQuotes(tree.expression) ~ ")(";
+    for (int i=0; i<tree.symbolTable.length;++i) {
+        if (i>0) result ~=",";
+        result ~= tree.symbolTable[i].value;
+    }
+    return result~ ");";
+}
+
+char [] SSEVEC(char [] expr)
+{
+    return "mixin(makeSSE(" ~ syntaxtreeof(expr) ~ "));";
+}        
+
-import std.stdio;
-
@@ -943 +959 @@
-    double[4] d0 = [17.0f, 28.25, 1, 56.2];
-
+
+    
-void main()
-{
@@ -958 +976 @@
-        r[i]= q[i]*2213.3L;
-    }
-
+
+
+
-    writefln("a=", a);
+   // writefln(qqq);
+//    writefln(qq);
-/*    
-//    VEC!("C+=(B*A)")( a, 2213.3, q);

trunk/blade/SyntaxTree.d

@@ -1 +1 @@
-// Written in the D programming language 1.0
-
+
+
+
-* Part of BLADE : Basic Linear Algebra D Expressions
+*
-* Author: Don Clugston
-* License: Public Domain
+*
+* THEORY:
+*  Nested mixins are used. The outermost one tricks the compiler into
+* converting the expression into a standard form with precedence and
+* associativity information. The inner mixin determines the type and value
+* of each symbol in the expression, by mixing in '.stringof' expressions.
+* The two levels of mixins are required because of some quirks in the behaviour
+* of stringof.
+*
+* BUGS:
+*  The following syntax is not supported:
+*       unary operators & !
+*       && and || operators
+*       Comparision operators and NCEG floating point operators
+*       ?:
+*       $ not really supported: a[$-1] should be replaced by a[a.length-1]
+*       cast
+*       new, delete, anonymous classes
+*       mixin, assert, and import expressions
+*       D 2.004 string literals.
+* QUIRKS:       
+*  Functions are typed as function pointers in the symbol table, unless they are
+*  used as properties, in which case they appear as function types.
+*  If the expression refers to a non-existent variable, a sensible error message
+*  will be printed, but it will be followed by a torrent of useless error messages.
+*   
-*/
-module SyntaxTree;
-
+public:
+
+/**
+ * Returns a string, which, when mixed in, lexes, parses, and semantically 
+ * analyses the given expression, then creates a struct literal of type
+ * AbstractSyntaxTree, containing a symbol table, and a syntax tree in a
+ * very simple placeholder format, which refers to the elements in the symbol table.
+ *
+ * Syntax trees are represented as placeholder expressions, with associativity
+ * and precedence indicated by parentheses.
+ *
+ 
+ * Typically, this function will be a code generator for a mixin.
+ */
+char [] syntaxtreeof(char [] expression)
+{
+    char [] expr=expression;
+    char [][] symbols = replaceSymbolsWithPlaceholders(expr);
+//    if (symbols.length> 25) return `static assert(0, "Too many symbols in expression.");`;
+    return `mixin(mixin_SymbolTable(` ~ wrapInQuotes(expression)~ `,` ~ mixin_getPrecedence(expr) ~ `))`;
+}
+
+
+/** The values of the A, B, C, ... placeholders
+*
+* Members:
+* type    the name of the type, as text
+* value   The value, as text. This will be either a symbol name, or a literal.
+*         Note that if it is a numeric or text literal, value[0] will be one of the characters
+*            0123456789"'-
+*/
+struct Symbol {
+    char [] type; // the name of the type, as text
+    char [] value; // the value, as text.
+}
+
+/** The result of semantic analysis of the original expression
+ *
+ */
+struct AbstractSyntaxTree {
+    char [] expression; /// syntax tree in Placeholder format, eg A+=(B*C)
+    Symbol[] symbolTable; /// The types and values of A,B,C,...
+}
+
+private:
-
-//  ==== LEXER ====
-
-private:
-
-/// Return true if text is a D keyword
@@ -52 +124 @@
-}
-
-
-
-/** Extract all terminal symbols(identifiers, type names, and literals)
+
+
+ *
- * Replace each identifier with a placeholder A, B, C, D, ...
- *
@@ -117 +189 @@
-}
-
-
-//  ==== SYNTAX PASS ====
-
-// The values of the A, B, C, ... placeholders
-struct Symbol {
-    char [] type; // the name of the type, as text
-    char [] value; // the value, as text
-    bool isConst; // is it a compile-time constant?
-}
-
-/** FOR MIXIN
- * Given an array of symbols, return a string to be mixed in, which will
- * generate the type and value associated with each symbol.
- * When mixed in, a Symbol[] array literal will be generated.
- */
-char[] mixin_SymbolTable(char [][] symbols)
-{
-    // Creates an array[2] of string literals, where [0] is the type, and [1] is the value
-    // This is passed to the toSymTable function which determines which entries are constants.
-    char [] result = "toSymTable([";
-    for(int i=0; i<symbols.length; ++i) {
-        if (i>0) result ~=",";
-        if (symbols[i][0]>='0' && symbols[i][0]<='9') {
-            result ~= "[typeof(" ~ symbols[i] ~ `).stringof, (` ~symbols[i] ~ `).stringof]`;
-        } else
-        result ~= "[typeof(" ~ symbols[i] ~ `).stringof, ` ~symbols[i] ~ `.stringof]`;
-    }
-    result ~="])";
-    return result;
-}
-
-/// Converts the input [type][value] array into a Symbol[] array.
-Symbol [] toSymTable(char [][2][] symboltable)
-{
-    Symbol [] symbolTable=[];
-    for (int i=0; i<symboltable.length; ++i) {
-        char c = symboltable[i][1][0];
-        bool isConst = ((c>='0' && c<='9')||c=='-'|| c=='"' || c=='\'');
-        symbolTable ~= Symbol(symboltable[i][0], symboltable[i][1], isConst);
-    }
-    return symbolTable;
-}
-
-
-/** Generate a syntax tree
@@ -175 +205 @@
-   ?:
-   $ not really supported: a[$-1] should be replaced by a[a.length-1]
-
+Comparison and 
-   cast
-   new, delete, anonymous classes
@@ -257 +287 @@
-char [] mixin_getPrecedence(char [] expr)
-{
-`"` ~ expr ~ `"`
+"`" ~ expr ~ "`"
-    char [] code = "typeof(";
-        for(int i=0; i<expr.length; ++i) {
@@ -275 +305 @@
-}
-
+//  ==== SEMANTIC PASS ====
+
+bool isFunc(int n, char [] expr)
+{
+    char c = n + 'A';
+    for (int i=0; i<expr.length-1; ++i) {
+        if ((expr[i]==c) && expr[i+1]=='(') return true;
+    }
+    return false;
+}
+
+public:
+/** FOR MIXIN
+ * Given a raw expression, and a processed expression (with placeholders, and 
+ * correct precedence), return a string to be mixed in, which will
+ * generate the type and value associated with each symbol.
+ * When mixed in, an AbstractSyntaxTree containing a Symbol[] array literal will be generated.
+ */
+char [] mixin_SymbolTable(char [] expression, char [] exprWithPlaceholders)
+{
+    char [] expr = expression;
+    char [][] symbols = replaceSymbolsWithPlaceholders(expr);
+    // Creates an array[2] of string literals, where [0] is the type, and [1] is the value
+    // This is passed to the toSymTable function which determines which entries are constants.
+    char [] result = `AbstractSyntaxTree("` ~ exprWithPlaceholders ~ `",[`;
+    for(int i=0; i<symbols.length; ++i) {
+        if (i>0) result ~=",";
+        if (isFunc(i, exprWithPlaceholders)) 
+            result ~= `Symbol(typeof(&` ~ symbols[i] ~ `).stringof,"` ~ symbols[i]~ `")`;
+        else if (symbols[i][0]>='0' && symbols[i][0]<='9') {
+            result ~= `Symbol(typeof(` ~ symbols[i] ~ `).stringof, (` ~symbols[i] ~ `).stringof)`;
+        } else
+        result ~= `Symbol(typeof(` ~ symbols[i] ~ `).stringof, ` ~symbols[i] ~ `.stringof)`;
+    }    
+    result ~="])";
+    return result;
+}
+
+public:
+char [] wrapInQuotes(char [] instr)
+{
+    char [] str=`"`;
+    foreach(char c; instr) {
+        if (c=='"') str~=`\"`;
+        else str~=c;        
+    }
+    return str~ `"`;
+}