Changeset 144 for trunk/orca/op.c

Show
Ignore:
Timestamp:
05/11/06 14:23:03 (3 years ago)
Author:
krobillard
Message:

Native arguments are now kept on the stack until after the call and the
result is now always put into a1.

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • trunk/orca/op.c

    r98 r144  
    2828 
    2929 
    30 void orOpAdd( OValue* a ) 
    31 { 
    32     OValue* b = a + 1; 
    33     if( orIs(a, OT_INTEGER) ) 
    34     { 
    35         if( orIs(b, OT_INTEGER) ) 
    36         { 
    37             orResult( OT_INTEGER, orInt(a) + orInt(b) ); 
    38             return; 
    39         } 
    40         else if( orIs(b, OT_DECIMAL) ) 
    41         { 
    42             orResultDECIMAL( (double) orInt(a) + orDecimal(b) ); 
     30void orOpAdd( OValue* a1 ) 
     31{ 
     32    OValue* b = a1 + 1; 
     33    if( orIs(a1, OT_INTEGER) ) 
     34    { 
     35        if( orIs(b, OT_INTEGER) ) 
     36        { 
     37            orResult( OT_INTEGER, orInt(a1) + orInt(b) ); 
     38            return; 
     39        } 
     40        else if( orIs(b, OT_DECIMAL) ) 
     41        { 
     42            orResultDECIMAL( (double) orInt(a1) + orDecimal(b) ); 
    4343            return; 
    4444        } 
    … …  
    5252            for( i = 0; i < res->argc; i++ ) 
    5353            { 
    54                 tmp = orInt(a) + b->tuple[i]; 
     54                tmp = orInt(a1) + b->tuple[i]; 
    5555                res->tuple[i] = orToByteRange(tmp); 
    5656            }    
    … …  
    5959            return; 
    6060        } 
    61         a = b; 
    62     } 
    63     else if( orIs(a, OT_DECIMAL) ) 
    64     { 
    65         if( orIs(b, OT_INTEGER) ) 
    66         { 
    67             orResultDECIMAL( orDecimal(a) + (double) orInt(b) ); 
    68             return; 
    69         } 
    70         else if( orIs(b, OT_DECIMAL) ) 
    71         { 
    72             orResultDECIMAL( orDecimal(a) + orDecimal(b) ); 
     61        a1 = b; 
     62    } 
     63    else if( orIs(a1, OT_DECIMAL) ) 
     64    { 
     65        if( orIs(b, OT_INTEGER) ) 
     66        { 
     67            orResultDECIMAL( orDecimal(a1) + (double) orInt(b) ); 
     68            return; 
     69        } 
     70        else if( orIs(b, OT_DECIMAL) ) 
     71        { 
     72            orResultDECIMAL( orDecimal(a1) + orDecimal(b) ); 
    7373            return; 
    7474        } 
    … …  
    8383            for( i = 0; i < res->argc; i++ ) 
    8484            { 
    85                 tmp = (int) orDecimal(a) + b->tuple[i]; 
     85                tmp = (int) orDecimal(a1) + b->tuple[i]; 
    8686                res->tuple[i] = orToByteRange(tmp); 
    8787            }    
    … …  
    9191        } 
    9292#endif 
    93         a = b; 
    94     } 
    95     else if( orIs(a, OT_TUPLE) ) 
     93        a1 = b; 
     94    } 
     95    else if( orIs(a1, OT_TUPLE) ) 
    9696    { 
    9797        if( orIs(b, OT_TUPLE) ) 
    … …  
    100100            OValue* res; 
    101101             
    102             res = a; 
     102            res = a1; 
    103103             
    104             res->argc = a->argc > b->argc ? a->argc : b->argc; 
    105             for( i = 0; i < res->argc; i++ ) 
    106             { 
    107                 tmp = a->tuple[i] + b->tuple[i]; 
     104            res->argc = a1->argc > b->argc ? a1->argc : b->argc; 
     105            for( i = 0; i < res->argc; i++ ) 
     106            { 
     107                tmp = a1->tuple[i] + b->tuple[i]; 
    108108                res->tuple[i] = orToByteRange(tmp); 
    109109            } 
    … …  
    115115            OValue *res; 
    116116 
    117             res = a; 
    118  
    119             for( i = 0; i < res->argc; i++ ) 
    120             { 
    121                 tmp = a->tuple[i] + orInt(b); 
     117            res = a1; 
     118 
     119            for( i = 0; i < res->argc; i++ ) 
     120            { 
     121                tmp = a1->tuple[i] + orInt(b); 
    122122                res->tuple[i] = orToByteRange(tmp); 
    123123            }             
    … …  
    129129            OValue *res; 
    130130 
    131             res = a; 
    132  
    133             for( i = 0; i < res->argc; i++ ) 
    134             { 
    135                 tmp = a->tuple[i] + (int) orDecimal(b); 
     131            res = a1; 
     132 
     133            for( i = 0; i < res->argc; i++ ) 
     134            { 
     135                tmp = a1->tuple[i] + (int) orDecimal(b); 
    136136                res->tuple[i] = orToByteRange(tmp); 
    137137            }             
    138138            return; 
    139139        } 
    140         a = b; 
    141     } 
    142     else if( orIs(a, OT_TIME) ) 
     140        a1 = b; 
     141    } 
     142    else if( orIs(a1, OT_TIME) ) 
    143143    { 
    144144        if( orIs(b, OT_TIME) ) 
    145145        { 
    146             orSeconds(a) += orSeconds(b); 
    147             return; 
    148         } 
    149     } 
    150     orErrorOp( "+", a ); 
    151 } 
    152  
    153  
    154 void orOpSub( OValue* a ) 
    155 { 
    156     OValue* b = a + 1; 
    157     if( orIs(a, OT_INTEGER) ) 
    158     { 
    159         if( orIs(b, OT_INTEGER) ) 
    160         { 
    161             orResult( OT_INTEGER, orInt(a) - orInt(b) ); 
    162             return; 
    163         } 
    164         else if( orIs(b, OT_DECIMAL) ) 
    165         { 
    166             orResultDECIMAL( (double) orInt(a) - orDecimal(b) ); 
     146            orSeconds(a1) += orSeconds(b); 
     147            return; 
     148        } 
     149    } 
     150    orErrorOp( "+", a1 ); 
     151} 
     152 
     153 
     154void orOpSub( OValue* a1 ) 
     155{ 
     156    OValue* b = a1 + 1; 
     157    if( orIs(a1, OT_INTEGER) ) 
     158    { 
     159        if( orIs(b, OT_INTEGER) ) 
     160        { 
     161            orResult( OT_INTEGER, orInt(a1) - orInt(b) ); 
     162            return; 
     163        } 
     164        else if( orIs(b, OT_DECIMAL) ) 
     165        { 
     166            orResultDECIMAL( (double) orInt(a1) - orDecimal(b) ); 
    167167            return; 
    168168        } 
    … …  
    177177            for( i = 0; i < res->argc; i++ ) 
    178178            { 
    179                 tmp = orInt(a) - b->tuple[i]; 
     179                tmp = orInt(a1) - b->tuple[i]; 
    180180                res->tuple[i] = orToByteRange(tmp); 
    181181            }    
    … …  
    185185        } 
    186186#endif 
    187         a = b; 
    188     } 
    189     else if( orIs(a, OT_DECIMAL) ) 
    190     { 
    191         if( orIs(b, OT_INTEGER) ) 
    192         { 
    193             orResultDECIMAL( orDecimal(a) - (double) orInt(b) ); 
    194             return; 
    195         } 
    196         else if( orIs(b, OT_DECIMAL) ) 
    197         { 
    198             orResultDECIMAL( orDecimal(a) - orDecimal(b) ); 
     187        a1 = b; 
     188    } 
     189    else if( orIs(a1, OT_DECIMAL) ) 
     190    { 
     191        if( orIs(b, OT_INTEGER) ) 
     192        { 
     193            orResultDECIMAL( orDecimal(a1) - (double) orInt(b) ); 
     194            return; 
     195        } 
     196        else if( orIs(b, OT_DECIMAL) ) 
     197        { 
     198            orResultDECIMAL( orDecimal(a1) - orDecimal(b) ); 
    199199            return; 
    200200        } 
    … …  
    209209            for( i = 0; i < res->argc; i++ ) 
    210210            { 
    211                 tmp = (int) orDecimal(a) - b->tuple[i]; 
     211                tmp = (int) orDecimal(a1) - b->tuple[i]; 
    212212                res->tuple[i] = orToByteRange(tmp); 
    213213            }    
    … …  
    217217        } 
    218218#endif 
    219         a = b; 
    220     } 
    221     else if( orIs(a, OT_TUPLE) ) 
     219        a1 = b; 
     220    } 
     221    else if( orIs(a1, OT_TUPLE) ) 
    222222    { 
    223223        if( orIs(b, OT_TUPLE) ) 
    … …  
    226226            OValue* res; 
    227227             
    228             res = a; 
     228            res = a1; 
    229229             
    230             res->argc = a->argc > b->argc ? a->argc : b->argc; 
    231             for( i = 0; i < res->argc; i++ ) 
    232             { 
    233                 tmp = a->tuple[i] - b->tuple[i]; 
     230            res->argc = a1->argc > b->argc ? a1->argc : b->argc; 
     231            for( i = 0; i < res->argc; i++ ) 
     232            { 
     233                tmp = a1->tuple[i] - b->tuple[i]; 
    234234                res->tuple[i] = orToByteRange(tmp); 
    235235            } 
    … …  
    241241            OValue *res; 
    242242 
    243             res = a; 
    244  
    245             for( i = 0; i < res->argc; i++ ) 
    246             { 
    247                 tmp = a->tuple[i] - orInt(b); 
     243            res = a1; 
     244 
     245            for( i = 0; i < res->argc; i++ ) 
     246            { 
     247                tmp = a1->tuple[i] - orInt(b); 
    248248                res->tuple[i] = orToByteRange(tmp); 
    249249            }             
    … …  
    255255            OValue *res; 
    256256 
    257             res = a; 
    258  
    259             for( i = 0; i < res->argc; i++ ) 
    260             { 
    261                 tmp = a->tuple[i] - (int) orDecimal(b); 
     257            res = a1; 
     258 
     259            for( i = 0; i < res->argc; i++ ) 
     260            { 
     261                tmp = a1->tuple[i] - (int) orDecimal(b); 
    262262                res->tuple[i] = orToByteRange(tmp); 
    263263            }             
    264264            return; 
    265265        } 
    266         a = b; 
    267     } 
    268     else if( orIs(a, OT_TIME) ) 
     266        a1 = b; 
     267    } 
     268    else if( orIs(a1, OT_TIME) ) 
    269269    { 
    270270        if( orIs(b, OT_TIME) ) 
    271271        { 
    272             orSeconds(a) -= orSeconds(b); 
    273             return; 
    274         } 
    275     } 
    276     orErrorOp( "-", a ); 
    277 } 
    278  
    279  
    280 void orOpMul( OValue* a ) 
    281 { 
    282     OValue* b = a + 1; 
    283     if( orIs(a, OT_INTEGER) ) 
    284     { 
    285         if( orIs(b, OT_INTEGER) ) 
    286         { 
    287             orResult( OT_INTEGER, orInt(a) * orInt(b) ); 
    288             return; 
    289         } 
    290         else if( orIs(b, OT_DECIMAL) ) 
    291         { 
    292             orResultDECIMAL( (double) orInt(a) * orDecimal(b) ); 
     272            orSeconds(a1) -= orSeconds(b); 
     273            return; 
     274        } 
     275    } 
     276    orErrorOp( "-", a1 ); 
     277} 
     278 
     279 
     280void orOpMul( OValue* a1 ) 
     281{ 
     282    OValue* b = a1 + 1; 
     283    if( orIs(a1, OT_INTEGER) ) 
     284    { 
     285        if( orIs(b, OT_INTEGER) ) 
     286        { 
     287            orResult( OT_INTEGER, orInt(a1) * orInt(b) ); 
     288            return; 
     289        } 
     290        else if( orIs(b, OT_DECIMAL) ) 
     291        { 
     292            orResultDECIMAL( (double) orInt(a1) * orDecimal(b) ); 
    293293            return; 
    294294        } 
    … …  
    302302            for( i = 0; i < res->argc; i++ ) 
    303303            { 
    304                 tmp = orInt(a) * b->tuple[i]; 
     304                tmp = orInt(a1) * b->tuple[i]; 
    305305                res->tuple[i] = orToByteRange(tmp); 
    306306            }    
    … …  
    309309            return; 
    310310        } 
    311         a = b; 
    312     } 
    313     else if( orIs(a, OT_DECIMAL) ) 
    314     { 
    315         if( orIs(b, OT_INTEGER) ) 
    316         { 
    317             orResultDECIMAL( orDecimal(a) * (double) orInt(b) ); 
    318             return; 
    319         } 
    320         else if( orIs(b, OT_DECIMAL) ) 
    321         { 
    322             orResultDECIMAL( orDecimal(a) * orDecimal(b) ); 
     311        a1 = b; 
     312    } 
     313    else if( orIs(a1, OT_DECIMAL) ) 
     314    { 
     315        if( orIs(b, OT_INTEGER) ) 
     316        { 
     317            orResultDECIMAL( orDecimal(a1) * (double) orInt(b) ); 
     318            return; 
     319        } 
     320        else if( orIs(b, OT_DECIMAL) ) 
     321        { 
     322            orResultDECIMAL( orDecimal(a1) * orDecimal(b) ); 
    323323            return; 
    324324        } 
    … …  
    333333            for( i = 0; i < res->argc; i++ ) 
    334334            { 
    335                 tmp = (int) orDecimal(a) * b->tuple[i]; 
     335                tmp = (int) orDecimal(a1) * b->tuple[i]; 
    336336                res->tuple[i] = orToByteRange(tmp); 
    337337            }    
    … …  
    341341        } 
    342342#endif 
    343         a = b; 
    344     } 
    345     else if( orIs(a, OT_TUPLE) ) 
     343        a1 = b; 
     344    } 
     345    else if( orIs(a1, OT_TUPLE) ) 
    346346    { 
    347347        if( orIs(b, OT_TUPLE) ) 
    … …  
    350350            OValue* res; 
    351351             
    352             res = a; 
     352            res = a1; 
    353353             
    354             res->argc = a->argc > b->argc ? a->argc : b->argc; 
    355             for( i = 0; i < res->argc; i++ ) 
    356             { 
    357                 tmp = a->tuple[i] * b->tuple[i]; 
     354            res->argc = a1->argc > b->argc ? a1->argc : b->argc; 
     355            for( i = 0; i < res->argc; i++ ) 
     356            { 
     357                tmp = a1->tuple[i] * b->tuple[i]; 
    358358                res->tuple[i] = orToByteRange(tmp); 
    359359            } 
    … …  
    365365            OValue *res; 
    366366 
    367             res = a; 
    368  
    369             for( i = 0; i < res->argc; i++ ) 
    370             { 
    371                 tmp = a->tuple[i] * orInt(b); 
     367            res = a1; 
     368 
     369            for( i = 0; i < res->argc; i++ ) 
     370            { 
     371                tmp = a1->tuple[i] * orInt(b); 
    372372                res->tuple[i] = orToByteRange(tmp); 
    373373            }             
    … …  
    379379            OValue *res; 
    380380 
    381             res = a; 
    382  
    383             for( i = 0; i < res->argc; i++ ) 
    384             { 
    385                 tmp = a->tuple[i] * (int) orDecimal(b); 
     381            res = a1; 
     382 
     383            for( i = 0; i < res->argc; i++ ) 
     384            { 
     385                tmp = a1->tuple[i] * (int) orDecimal(b); 
    386386                res->tuple[i] = orToByteRange(tmp); 
    387387            }             
    388388            return; 
    389389        } 
    390         a = b; 
    391     } 
    392     orErrorOp( "*", a ); 
    393 } 
    394  
    395  
    396 void orOpDiv( OValue* a ) 
    397 { 
    398     OValue* b = a + 1; 
    399     if( orIs(a, OT_INTEGER) ) 
     390        a1 = b; 
     391    } 
     392    orErrorOp( "*", a1 ); 
     393} 
     394 
     395 
     396void orOpDiv( OValue* a1 ) 
     397{ 
     398    OValue* b = a1 + 1; 
     399    if( orIs(a1, OT_INTEGER) ) 
    400400    { 
    401401        if( orIs(b, OT_INTEGER) ) 
    … …  
    403403            if( orInt(b) == 0 ) 
    404404                goto div0; 
    405             orResult( OT_INTEGER, orInt(a) / orInt(b) ); 
     405            orResult( OT_INTEGER, orInt(a1) / orInt(b) ); 
    406406            return; 
    407407        } 
    … …  
    410410            if( orDecimal(b) == 0.0 ) 
    411411                goto div0; 
    412             orResultDECIMAL( (double) orInt(a) / orDecimal(b) ); 
     412            orResultDECIMAL( (double) orInt(a1) / orDecimal(b) ); 
    413413            return; 
    414414        } 
    … …  
    425425                if( b->tuple[i] == 0 ) 
    426426                    goto div0; 
    427                 tmp = orInt(a) / b->tuple[i]; 
     427                tmp = orInt(a1) / b->tuple[i]; 
    428428                res->tuple[i] = orToByteRange(tmp); 
    429429            }    
    … …  
    433433        } 
    434434#endif 
    435         a = b; 
    436     } 
    437     else if( orIs(a, OT_DECIMAL) ) 
     435        a1 = b; 
     436    } 
     437    else if( orIs(a1, OT_DECIMAL) ) 
    438438    { 
    439439        if( orIs(b, OT_INTEGER) ) 
    … …  
    441441            if( orInt(b) == 0 ) 
    442442                goto div0; 
    443             orResultDECIMAL( orDecimal(a) / (double) orInt(b) ); 
     443            orResultDECIMAL( orDecimal(a1) / (double) orInt(b) ); 
    444444            return; 
    445445        } 
    … …  
    448448            if( orDecimal(b) == 0.0 ) 
    449449                goto div0; 
    450             orResultDECIMAL( orDecimal(a) / orDecimal(b) ); 
     450            orResultDECIMAL( orDecimal(a1) / orDecimal(b) ); 
    451451            return; 
    452452        } 
    … …  
    463463                if( b->tuple[i] == 0 ) 
    464464                    goto div0; 
    465                 tmp = (int) orDecimal(a) / b->tuple[i]; 
     465                tmp = (int) orDecimal(a1) / b->tuple[i]; 
    466466                res->tuple[i] = orToByteRange(tmp); 
    467467            }    
    … …  
    471471        } 
    472472#endif 
    473         a = b; 
    474     } 
    475     else if( orIs(a, OT_TUPLE) ) 
     473        a1 = b; 
     474    } 
     475    else if( orIs(a1, OT_TUPLE) ) 
    476476    { 
    477477        if( orIs(b, OT_TUPLE) ) 
    … …  
    480480            OValue* res; 
    481481             
    482             res = a; 
     482            res = a1; 
    483483             
    484             res->argc = a->argc > b->argc ? a->argc : b->argc; 
     484            res->argc = a1->argc > b->argc ? a1->argc : b->argc; 
    485485            for( i = 0; i < res->argc; i++ ) 
    486486            { 
    487487                if( b->tuple[i] == 0 ) 
    488488                    goto div0; 
    489                 tmp = a->tuple[i] / b->tuple[i]; 
     489                tmp = a1->tuple[i] / b->tuple[i]; 
    490490                res->tuple[i] = orToByteRange(tmp); 
    491491            } 
    … …  
    497497            OValue *res; 
    498498 
    499             res = a; 
     499            res = a1; 
    500500 
    501501            for( i = 0; i < res->argc; i++ ) 
    … …  
    503503                if( orInt(b) == 0 ) 
    504504                    goto div0; 
    505                 tmp = a->tuple[i] / orInt(b); 
     505                tmp = a1->tuple[i] / orInt(b); 
    506506                res->tuple[i] = orToByteRange(tmp); 
    507507            }             
    … …  
    513513            OValue *res; 
    514514 
    515             res = a; 
     515            res = a1; 
    516516 
    517517            for( i = 0; i < res->argc; i++ ) 
    … …  
    519519                if( orDecimal(b) == 0 ) 
    520520                    goto div0; 
    521                 tmp = a->tuple[i] / (int) orDecimal(b); 
     521                tmp = a1->tuple[i] / (int) orDecimal(b); 
    522522                res->tuple[i] = orToByteRange(tmp); 
    523523            }             
    524524            return; 
    525525        } 
    526         a = b; 
    527     } 
    528     orErrorOp( "/", a ); 
     526        a1 = b; 
     527    } 
     528    orErrorOp( "/", a1 ); 
    529529    return; 
    530530 
    … …  
    609609 
    610610 
    611 void orOpGreater( OValue* a ) 
    612 { 
    613     OValue* b = a + 1; 
    614     switch( compareValue( a, b ) ) 
     611void orOpGreater( OValue* a1 ) 
     612{ 
     613    OValue* b = a1 + 1; 
     614    switch( compareValue( a1, b ) ) 
    615615    { 
    616616        case CMP_LESS: 
    … …  
    622622            break; 
    623623        case CMP_ERROR_B: 
    624             a = b; 
     624            a1 = b; 
    625625        case CMP_ERROR_A: 
    626             orErrorOp( ">", a ); 
     626            orErrorOp( ">", a1 ); 
    627627            break; 
    628628    } 
    … …  
    630630 
    631631 
    632 void orOpLess( OValue* a ) 
    633 { 
    634     OValue* b = a + 1; 
    635     switch( compareValue( a, b ) ) 
     632void orOpLess( OValue* a1 ) 
     633{ 
     634    OValue* b = a1 + 1; 
     635    switch( compareValue( a1, b ) ) 
    636636    { 
    637637        case CMP_LESS: 
    … …  
    643643            break; 
    644644        case CMP_ERROR_B: 
    645             a = b; 
     645            a1 = b; 
    646646        case CMP_ERROR_A: 
    647             orErrorOp( "<", a ); 
     647            orErrorOp( "<", a1 ); 
    648648            break; 
    649649    } 
    … …