Changeset 102

Show
Ignore:
Timestamp:
05/01/07 02:24:53 (1 year ago)
Author:
Don Clugston
Message:

Numerous small changes to Blade 0.2.
Added mixin form, which will become Blade 0.3

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/blade/Blade.d

    r101 r102  
    243243// of the types in the tuple. 
    244244 
    245 // Create a string representing the type A. 
    246245// Pure imaginary types are treated identically to pure reals, since they result in the 
    247246// same asm code. 
     247template fpTypeToString(A) 
     248{ 
     249    static if (is(A==real) || is(A==ireal)|| is(A==creal))  const char [] fpTypeToString="R"; 
     250    else static if (is(A==double) || is(A==idouble) || is(A==cdouble)) const char [] fpTypeToString="D"; 
     251    else static if (is(A==float) || is(A==ifloat) || is(A==cfloat))    const char [] fpTypeToString="F"; 
     252} 
     253 
     254// Create a string representing the type A. 
    248255template singleTypeToString(A) 
    249256{ 
    250          static if (is(A == real[])  || is(A == ireal[]))   const char [] singleTypeToString = "R"; 
    251     else static if (is(A == double[])|| is(A == idouble[])) const char [] singleTypeToString = "D"; 
    252     else static if (is(A == float[]) || is(A == ifloat[]))  const char [] singleTypeToString = "F"; 
    253     else static if (is(A == creal[]) || is(A == cdouble[]) || is(A==cfloat[])) const char [] singleTypeToString = "Z"; 
    254  
    255     else static if (is(A == real)    || is (A == ireal))   const char [] singleTypeToString = "r"; 
    256     else static if (is(A == double)  || is (A == idouble))   const char [] singleTypeToString = "d"; 
    257     else static if (is(A == float)   || is (A == ifloat))   const char [] singleTypeToString = "f"; 
    258     else static if (is(A : creal))                     const char [] singleTypeToString = "z"; 
    259     else const char [] singleTypeToString = "?"; 
     257   const char [] singleTypeToString = "S" ~ fpTypeToString!(A); // scalar 
     258
     259 
     260template singleTypeToString(A: A[]) 
     261
     262   static if (is(A:creal)) 
     263     const char [] singleTypeToString = "Z" ~ fpTypeToString!(A); // complex vector 
     264   else 
     265     const char [] singleTypeToString = "V" ~ fpTypeToString!(A); // vector 
    260266} 
    261267 
     
    264270template vectorTupleToString(X...) 
    265271{ 
    266 //    static if (X.length==1) const char [] vectorTupleToString = singleTypeToString!(X[0])~\0; 
    267 //    else  const char [] vectorTupleToString = singleTypeToString!(X[0]) ~ \0 ~ vectorTupleToString!(X[1..$]); 
    268     static if (X.length==1) const char [] vectorTupleToString = X[0].stringof ~\0; 
    269     else  const char [] vectorTupleToString = X[0].stringof ~ \0 ~ vectorTupleToString!(X[1..$]); 
     272    static if (X.length==1) const char [] vectorTupleToString = singleTypeToString!(X[0])~\0; 
     273    else  const char [] vectorTupleToString = singleTypeToString!(X[0]) ~ \0 ~ vectorTupleToString!(X[1..$]); 
     274//    static if (X.length==1) const char [] vectorTupleToString = X[0].stringof ~\0; 
     275//    else  const char [] vectorTupleToString = X[0].stringof ~ \0 ~ vectorTupleToString!(X[1..$]); 
    270276} 
    271277 
     
    280286        if (raw[i]=='\0') { 
    281287            char [] a; 
     288/* 
    282289            switch(raw[start..i]) { 
    283290                case (ifloat[]).stringof: 
     
    302309//                  a = "??" ~ raw[start..i]; break; 
    303310            } 
    304              s~=a; start=i+1; } 
     311             s~=a; 
     312*/ 
     313             s~=raw[start..i]; 
     314             start=i+1; } 
    305315    } 
    306316    return s; 
  • trunk/blade/BladeParse.d

    r101 r102  
    1818    return s; 
    1919} 
     20 
     21bool isDigit(char c) { return c>='0' && c<='9'; } 
     22bool isHexDigit(char c) { return c>='0' && c<='9' || c>='a' && c<='f' || c>='A' && c<='F'; } 
     23bool isAlpha(char c) { 
     24    return (c>='a' && c<='z') || (c>='A' && c<='Z'); 
     25} 
     26// Underscores allowed 
     27bool isUnderscoreDigit(char c) { return c=='_' || c>='0' && c<='9'; } 
     28bool isUnderscoreHexDigit(char c) { return c=='_' || c>='0' && c<='9' || c>='a' && c<='f' || c>='A' && c<='F'; } 
     29bool isUnderscoreAlpha(char c) { 
     30    return c=='_' || (c>='a' && c<='z') || (c>='A' && c<='Z'); 
     31} 
     32 
     33unittest { 
     34    assert(isHexDigit('9')); 
     35} 
     36 
     37// Extract a D identifier. Return the remainder of the string. 
     38char [] parseIdentifier(char [] s, out char [] rest) 
     39{ 
     40    int i=0; 
     41    if (!isUnderscoreAlpha(s[0])) { assert(0, "Identifier expected"); return "";} 
     42    while (i<s.length && (isUnderscoreAlpha(s[i])||isDigit(s[i]))) ++i; 
     43    char [] ident=s[0..i]; 
     44    while (i<s.length && s[i]==' ') ++i; // skip trailing spaces 
     45    rest = s[i..$]; 
     46    return ident; 
     47} 
     48 
     49char [] parseNumber(char [] s, out char[] rest) 
     50{ 
     51    int k=0; 
     52    while(k<s.length && isDigit(s[k])) ++k; 
     53    if (k<s.length-1 && s[k]=='.' && s[k+1]!='.') { 
     54        ++k; 
     55        while(k<s.length && isDigit(s[k])) ++k; 
     56        if (k<s.length && s[k]=='e') { ++k; 
     57            if (k<s.length && (s[k]=='+' || s[k]=='-')) ++k; 
     58            while(k<s.length && isDigit(s[k])) ++k; 
     59        } 
     60        if (k<s.length && (s[k]=='L' || s[k]=='f')) ++k; 
     61    } 
     62    char [] ident = s[0..k]; 
     63    int i=k; 
     64    while (i<s.length && s[i]==' ') ++i; // skip trailing spaces 
     65    rest = s[i..$]; 
     66    return ident; 
     67} 
     68 
     69char [] parseOperator(char [] s, out char [] rest) 
     70{ 
     71    int i=1; 
     72    if (s[0]=='+' || s[0]=='-' || s[0]=='*') { 
     73        if (s.length>1 && s[1]=='=') ++i; 
     74        int k=i; 
     75        while (k<s.length && s[k]==' ') ++k; // skip trailing spaces 
     76        rest = s[k..$]; 
     77        return s[0..i]; 
     78    } else { 
     79        assert(0, `Operator expected, not "` ~ s~ `"`); 
     80        return ""; 
     81    } 
     82} 
     83 
     84char [] parseQualifiedName(char [] s, out char[] rest) 
     85{ 
     86    char [] r; 
     87    char [] id = parseIdentifier(s, r); 
     88    while (r.length>0 && r[0]=='.') { 
     89        int i; 
     90        for (i=1; r[i]==' '; ++i) {} 
     91        id ~= "." ~ parseIdentifier(r[i..$], r); 
     92    } 
     93    rest=r; 
     94    return id; 
     95} 
     96 
    2097 
    2198// Some functions to grab information from the typestring. 
  • trunk/blade/CodegenX87.d

    r101 r102  
    2020} 
    2121 
     22int operatorLength(char [] s) 
     23{ 
     24    if (s[1]=='=') return 2; else return 1; 
     25} 
     26 
    2227// Converts an infix string into postfix. Also strips off the # symbols. 
    2328// Apply x87-specific optimisations during the conversion. 
     
    2833 
    2934    int x = exprLength(operations); 
     35    int y = x + 2; // end of the operator 
     36    if (operations[y]=='=') ++y; // Support +=, -=, *=, /=. 
    3037    char [] first = operations[0..x+1]; 
    31     char [] second = operations[x+2..$]; 
     38    char [] second = operations[y..$]; 
    3239    if (first[0]=='(') { 
    3340        first = makePostfixForX87(first[1..first.length-1], typelist); 
     
    3542    if (second[0]=='(') { 
    3643        second = makePostfixForX87(second[1..second.length-1], typelist); 
    37     } else if (second[0]=='#') second = operations[x+3..$]; 
     44    } else if (second[0]=='#') second = operations[y+1..$]; 
    3845 
    3946    // x87 OPTIMISATION #1 
     
    4855    if (operations[x+1]=='+') { 
    4956        if (second[second.length-1]=='*'&& first[first.length-1]!='*') { 
    50            return second ~ first ~ operations[x+1..x+2]; 
     57           return second ~ first ~ operations[x+1..y]; 
    5158        } 
    5259    } 
     
    6774           return second ~ first ~ "_"; 
    6875    } 
    69     return first ~ second ~ operations[x+1..x+2]; 
     76    return first ~ second ~ operations[x+1..y]; 
    7077} 
    7178 
     
    126133char [] operandSize(char [] typestr) 
    127134{ 
    128     switch(typestr) { 
    129         case "SR": 
    130         case "VR": return "real ptr "; 
    131         case "SD": 
    132         case "VD": return "double ptr "; 
    133         case "SF": 
    134         case "VF": return "float ptr "; 
    135     } 
    136 
    137  
    138 char [] opToX87(char op) 
    139 
    140     switch (op) { 
    141         case '*': 
    142         case '.': return "fmul"; 
    143         case '+': return "fadd"; 
    144         case '-': return "fsub"; 
    145         case '_': return "fsubr"; 
    146     } 
    147 
     135    switch(typestr[1]) { 
     136        case 'R': return "real ptr "; 
     137        case 'D': return "double ptr "; 
     138        case 'F': return "float ptr "; 
     139    } 
     140
     141 
     142char [][char] opToX87() { 
     143    return ['*':"fmul"[], '.': "fmul", '+': "fadd", '-': "fsub", '_': "fsubr"]; } 
     144 
    148145 
    149146static if (real.sizeof==10)      const char [] REALSIZE = "10"; 
     
    153150char [] vectorSize(char [] typestr) 
    154151{ 
    155     switch (typestr) { 
    156         case "VD": return "8"; 
    157         case "VF": return "4"; 
    158         case "VR": return REALSIZE; 
     152    switch (typestr[1]) { 
     153        case 'D': return "8"; 
     154        case 'F': return "4"; 
     155        case 'R': return REALSIZE; 
    159156    } 
    160157} 
     
    380377      if (isInstruction(operations[done])) { 
    381378            // Perform an arithemetic operation on the top two FPU stack items. 
    382             next = "  " ~ opToX87(operations[done]) ~ "p ST(1), ST;"\n; 
     379            next = "  " ~ opToX87[operations[done]] ~ "p ST(1), ST;"\n; 
    383380            mainbody ~= next; firstbody ~= next; 
    384381            ++done; 
     
    398395             // 80-bit vectors must be loaded onto the FPU stack first 
    399396            next = "  fld real ptr ["  ~ vectorRegister[vectorNum(typelist, operations[done])] ~ "];\n" 
    400                 ~ "  " ~ opToX87(operations[done+1]) ~ "p ST(1), ST;\n"; 
     397                ~ "  " ~ opToX87[operations[done+1]] ~ "p ST(1), ST;\n"; 
    401398         } else { 
    402             next = "  " ~ opToX87(operations[done+1]) ~ " " 
     399            next = "  " ~ opToX87[operations[done+1]] ~ " " 
    403400              ~ indexedVector(typelist, operations[done] ) ~ ";\n"; 
    404401        }