root/trunk/blade/SyntaxTreeDemo.d

// Create an abstract syntax tree
/**
BUGS: Doesn't support:
unary operators:  & !
&& and || operators
NCEG floating point operators
new, delete, anonymous classes
mixin, assert, and import expressions
*/

module blade.SyntaxTreeDemo;
import blade.SyntaxTree : syntaxtreeof, AbstractSyntaxTree, Symbol, AST;

// Display the syntax tree
char [] prettyTree(char [] syntaxtree)
{
    char [] output="";
    int depth=0;
    bool prevWasParen=false;
    for(int i=0; i<syntaxtree.length; ++i) {
        if (syntaxtree[i]=='(') {
            if (i>0 && syntaxtree[i-1]==')') { // it's an opCall
                output ~="\n";
                for (int k=0; k<depth; ++k) output~="  ";
                output~="()\n";             
            }
            depth++; prevWasParen=true;
        } else if (syntaxtree[i]==')') {
            depth--; 
            prevWasParen=true;
        }  else {
            if (syntaxtree[i]>='A' && syntaxtree[i]<='Z') {
                output ~="\n";
                for (int k=0; k<depth; ++k) output~="  "; 
                output~= "  " ~ syntaxtree[i];
                if (i<syntaxtree.length-1 && syntaxtree[i+1]=='(') output~='(';
                prevWasParen=true;
            } else {
              if (prevWasParen) {
                output ~="\n";
                for (int k=0; k<depth; ++k) output~="  "; 
              }
              output ~= syntaxtree[i]; prevWasParen=false;
            }
        }
    }
    return output;
}

char [] displayParseResult(AbstractSyntaxTree tree)
{
    char [] sym="  Rank\tCategory\tElement\tType\tValue\n";
    for (int i=0; i<tree.symbolTable.length; ++i) {
    Symbol q = tree.symbolTable[i];
        sym~=cast(char)('A'+i) ~ ": " ~ q.rank ~ \t;
        char c = q.value[0];
        if (tree.symbolTable[i].type=="") sym ~= "ERROR";
        else if ((c>='0' && c<='9')||c=='-') sym ~= "Numeric";
        else if (c=='"' || c=='\'') sym ~= "String";
        else if (tree.symbolTable[i].type[$-1]==')') sym ~= "Function";
        sym ~=\t ~ q.element;
        sym ~=\t ~ q.type ~ \t ~ q.value ~ \n;
    }
    return `Expression is: ` ~ tree.expression ~ \n ~ prettyTree(tree.expression) ~ \n ~ sym;   
}


char [] vec(char [] expression)
{
    return "pragma(msg, displayParseResult(" ~ syntaxtreeof(expression)~ "));";
}

int tr() { return 3; }

struct ags {
    int af[100];
}

const int butNotThis=6;

int func(int x, int youCanSeeThis = butNotThis ) { return 2; }

struct Blah(int Y) {
    char [] s;
    int k;
}

const QUAL = Blah!(7)("abc", 4);
import std.math;

void main()
{
    const double [9] s = [0.0, 3,4, 56,6585, 56,2.1, 465, 534];
    double fróg = 32;
    alias fróg fgf;    

    bool b;
    const int d = -2;
    const char ww='q';
    mixin(vec(`++fgf+ tr + s[5+d..s.length]*1.23e78/(45+fgf)~ww+x"30003132"c~"abc+fg*we+4"`));
    mixin(vec("b = ags.af[fróg*2..56] in s"));
    mixin(vec("func(d*35,d+  4)"));
    mixin(vec("QUAL^st"));
    mixin(vec("sin(3.45)"));
    
    static z = [3.4, 565, 31.3, 0];
    double [] a = new double[4];
    double [] dun = [17.0, 28.25, 1, 56.2];

    mixin(vec(" a   += dun*(25.5*3.01)-z"));
}