Changeset 116

Show
Ignore:
Timestamp:
01/05/08 02:22:19 (1 year ago)
Author:
dan.lewis
Message:

Interpreter won't compile, but it's performing predictive lexical analysis of expressions, operators and operands. Next will be keyword statements.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/1.9/source/interpreter.d

    r115 r116  
    11 
    22private import 
     3    structure, 
    34    text, 
    45    value; 
    …… 
    89    uint line = 1; 
    910    char last = 0x03; 
    10     char* c = source[0]; 
     11    char* c = &source[0]; 
    1112    char* cMark; 
     13    uint parenCount = 0; 
    1214    Value v; 
    1315     
     16    void parseExpression() 
     17    { 
     18        Value[] buffer; 
     19        bool bFlag = false; 
     20         
     21        parseOptionalWS(); 
     22        parseUnaryExpression(); 
     23        if(v == UNDEFINED) { 
     24            // there's no contents in this expression? 
     25            v.s = MESSAGE_unexpected_token; 
     26            v.type = TYPE.ERROR; 
     27            throw v; 
     28        } 
     29        buffer ~= v; 
     30        v = UNDEFINED; 
     31        do { 
     32            // now we need to read however many combos of binaryOperator unaryExpression we get. 
     33            parseOptionalWS(); 
     34            parseBinaryOperator(); 
     35            if(v == UNDEFINED) // okay, we're done 
     36                break; 
     37            bFlag = true; 
     38            buffer ~= v; 
     39            v = UNDEFINED; 
     40            parseOptionalWS(); 
     41            parseUnaryExpression(); 
     42            if(v == UNDEFINED) { // we found an operator followed by something other than an operand. 
     43                v.s = MESSAGE_unexpected_token; 
     44                v.type = TYPE.ERROR; 
     45                return v; 
     46            } 
     47        } while(1); 
     48         
     49        // if we've got more than a unaryexpression 
     50        if(bFlag) { 
     51            v.a = buffer; 
     52            v.type = TYPE.EXPRESSION; 
     53            return; 
     54        } 
     55        // what unaryexpression returned 
     56        v = buffer[0]; 
     57    } 
     58     
     59    /* consumes whitespace, comments, and then stops.  Doesn't store anything in v. */ 
    1460    void parseOptionalWS() 
    1561    { 
    …… 
    5096        } 
    5197    } 
     98     
     99    /* consumes a number, string, array, object, (expression), or identifier if it's there and stores it in v.  */ 
    52100    void parseOperand() 
    53101    { 
    …… 
    60108            case '"': 
    61109                // String literal 
    62                 for(cMark = c++; c[0] != c[0]Mark; c++) { 
     110                for(cMark = c++; c[0] != cMark[0]; c++) { 
    63111                    if(c[0] == 0x03) { 
    64112                        v.s = MESSAGE_unterminated_string; 
    …… 
    75123            case '/': 
    76124                // RegExp literal 
    77                 for(cMark = c++; c[0] != c[0]Mark; c++) { 
     125                for(cMark = c++; c[0] != cMark[0]; c++) { 
    78126                    if(c[0] == 0x03) { 
    79127                        v.s = MESSAGE_bad_regexp; 
    …… 
    102150            case '-': 
    103151                // Number literal 
     152                // BUG: incomplete 
    104153                v.type = TYPE.DOUBLE; 
    105154                return; 
    106155            case '(': 
    107                 // Expression 
    108                 uint count = 0; 
    109                 for(cMark = c; c[0] != 0x03; c++) { 
    110                     if(c[0] == '(') 
    111                         count++; 
    112                     if(c[0] == ')') { 
    113                         if(--count == 0) { 
    114                             v.s = cMark[1..(c-1)]; 
    115                             v.type = TYPE.PARENS; 
    116                             return; 
    117                         } 
    118                     } 
    119                 } 
    120                 goto _unmatched_parens; 
     156                parenCount++; 
     157                parseExpression(); 
     158                if(*c != ')') { 
     159                    v.s = MESSAGE_unmatched_parenthesis; 
     160                    v.type = TYPE.ERROR; 
     161                    throw v; 
     162                } 
     163                return; 
    121164            case '[': 
    122                 // Array literal 
    123                 uint count = 0; 
    124                 for(cMark = c; c[0] != 0x03; c++) { 
    125                     if(c[0] == '[') 
    126                         count++; 
    127                     if(c[0] == ']') { 
    128                         if(--count == 0) { 
    129                             v.s = cMark[1..(c-1)]; 
    130                             v.type = TYPE.BRACKETS; 
    131                             return; 
    132                         } 
    133                     } 
    134                 } 
    135                 goto _unmatched_parens; 
     165                parenCount++; 
     166                parseArrayLiteral(); 
     167                if(*c != ']') { 
     168                    v.s = MESSAGE_unmatched_parenthesis; 
     169                    v.type = TYPE.ERROR; 
     170                    throw v; 
     171                } 
     172                return; 
    136173            case '{': 
    137                 // Object literal 
    138                 uint count = 0; 
    139                 for(cMark = c; c[0] != 0x03; c++) { 
    140                     if(c[0] == '{') 
    141                         count++; 
    142                     if(c[0] == '}') { 
    143                         if(--count == 0) { 
    144                             v.s = cMark[1..(c-1)]; 
    145                             v.type = TYPE.BRACES; 
    146                             return; 
    147                         } 
    148                     } 
    149                 } 
    150                 goto _unmatched_parens; 
     174                parenCount++; 
     175                parseObjectLiteral(); 
     176                if(*c != '}') { 
     177                    v.s = MESSAGE_unmatched_parenthesis; 
     178                    v.type = TYPE.ERROR; 
     179                    throw v; 
     180                } 
     181                return; 
    151182            default: 
    152183                // Identifier 
    …… 
    158189                    return; 
    159190                } 
    160  
    161                 // Shouldn't be here. 
    162                 goto _unexpected_token; 
    163191        } 
    164192    } 
    165     void parseBinaryOp() 
     193     
     194    /* consumes (!|++|--)operand(++|--) */ 
     195    void parseUnaryExpression() 
     196    { 
     197        Value[] buffer; 
     198        bool bFlag = false; 
     199         
     200        switch(c[0]) { 
     201            case '+': 
     202                if(c[1] == '+') { 
     203                    c+=2; 
     204                    bFlag = true; 
     205                    v.type = TYPE.INC; 
     206                    buffer ~= v; 
     207                } 
     208                break; 
     209            case '-': 
     210                if(c[1] == '-') { 
     211                    c+=2; 
     212                    bFlag = true; 
     213                    v.type = TYPE.DEC; 
     214                    buffer ~= v; 
     215                } 
     216                break; 
     217            case '!': 
     218                c++; 
     219                bFlag = true; 
     220                v.type = TYPE.NOT; 
     221                buffer ~= v; 
     222        } 
     223        parseOperand(); 
     224        buffer ~= v; 
     225        switch(c[0]) { 
     226            case '+': 
     227                if(c[1] == '+') { 
     228                    c+=2; 
     229                    bFlag = true; 
     230                    v.type = TYPE.INC; 
     231                    buffer ~= v; 
     232                } 
     233                break; 
     234            case '-': 
     235                if(c[1] == '-') { 
     236                    c+=2; 
     237                    bFlag = true; 
     238                    v.type = TYPE.DEC; 
     239                    buffer ~= v; 
     240                } 
     241        } 
     242        if(bFlag) { 
     243            v.a = buffer; 
     244            v.type = EXPRESSION; 
     245        } 
     246        // parseOperand was the last thing to affect v, so we're already straight. 
     247    } 
     248     
     249    /* consumes an operator if it's there and stores it in v.  */ 
     250    void parseBinaryOperator() 
    166251    { 
    167252        switch(c[0]) { 
    168253            case '+': 
     254                if(c[1] == '+') { 
     255                    c++; 
     256                    v.type = TYPE.INC; 
     257                    return; 
     258                } 
    169259                if(c[1] == '=') { 
    170260                    c++; 
    …… 
    175265                return; 
    176266            case '-':  
     267                if(c[1] == '-') { 
     268                    c++; 
     269                    v.type = TYPE.DEC; 
     270                    return; 
     271                } 
    177272                if(c[1] == '=') { 
    178273                    c++; 
    …… 
    206301                v.type = TYPE.MOD; 
    207302                return; 
    208             case '^': 
     303            case '~': 
    209304                if(c[1] == '=') { 
    210305                    c++; 
    …… 
    239334                } 
    240335                v.type = TYPE.OR; 
     336                return; 
     337            case '=': 
     338                if(c[1] == '=') { 
     339                    c++; 
     340                    v.type == TYPE.CMPE; 
     341                    return; 
     342                } 
     343                v.type = TYPE.MOV; 
     344                return; 
     345            case '!': 
     346                if(c[1] == '=') { 
     347                    c++; 
     348                    v.type = TYPE.CMPNE; 
     349                    return; 
     350                } 
     351                v.type = TYPE.NOT; 
    241352                return; 
    242353            case '<': 
    …… 
    284395                v.type = TYPE.CMPGT; 
    285396                return; 
    286             default: 
    287                 goto _unexpected_token; 
    288397        } 
    289398    } 

  • branches/1.9/source/value.d

    r115 r116  
    5656    EOF     = 0x10, 
    5757    WS      = 0x11, 
    58     PARENS = 0x12, 
    59     BRACKETS  = 0x13, 
    60     BRACES    = 0x14, 
     58    EXPRESSION = 0x12, 
     59    ARRAYLIT  = 0x13, 
     60    OBJECTLIT = 0x14, 
    6161    COMMA   = 0x15, 
    6262    DOT     = 0x16,