X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=expr.c;h=270c072c621c2618728a736d8fe3b7bd54798bff;hp=5474af8c36fa9cec7fd7506e5d230641d47f1462;hb=4205233c8397c581b4d27ab36ab81ec896ef3dd0;hpb=4ca28ba07da9f3848c2e3db0e2e9cbcaa787dd29 diff --git a/expr.c b/expr.c index 5474af8..270c072 100644 --- a/expr.c +++ b/expr.c @@ -1,7 +1,7 @@ // // RMAC - Reboot's Macro Assembler for all Atari computers // EXPR.C - Expression Analyzer -// Copyright (C) 199x Landon Dyer, 2011-2017 Reboot and Friends +// Copyright (C) 199x Landon Dyer, 2011-2020 Reboot and Friends // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986 // Source utilised with the kind permission of Landon Dyer // @@ -36,7 +36,7 @@ char itokcl[] = { CR_STREQ, CR_MACDEF, CR_DATE, CR_TIME, CR_ABSCOUNT, 0, - '!', '~', UNMINUS, 0, // UNARY + '!', '~', UNMINUS, UNLT, UNGT, 0, // UNARY '*', '/', '%', 0, // MULT '+', '-', 0, // ADD SHL, SHR, 0, // SHIFT @@ -49,6 +49,7 @@ char itokcl[] = { const char missym_error[] = "missing symbol"; const char str_error[] = "missing symbol or string"; +const char noflt_error[] = "operator not usable with float"; // Convert expression to postfix static PTR evalTokenBuffer; // Deposit tokens here (this is really a @@ -125,23 +126,24 @@ int expr0(void) // int expr1(void) { - TOKEN t; - SYM * sy; - char * p, * p2; + char * p; WORD w; - int j; int class = tokenClass[*tok]; - if (*tok == '-' || *tok == '+' || class == UNARY) + if (*tok == '-' || *tok == '+' || *tok == '<' || *tok == '>' || class == UNARY) { - t = *tok++; + TOKEN t = *tok++; if (expr2() != OK) return ERROR; if (t == '-') t = UNMINUS; + else if (t == '<') + t = UNLT; + else if (t == '>') + t = UNGT; // With leading + we don't have to deposit anything to the buffer // because there's no unary '+' nor we have to do anything about it @@ -153,8 +155,16 @@ int expr1(void) switch (*tok++) { case CR_ABSCOUNT: - *evalTokenBuffer.u32++ = CONST; - *evalTokenBuffer.u64++ = (uint64_t)sect[ABS].sloc; + if (cursect != ABS) + { + *evalTokenBuffer.u32++ = CONST; + *evalTokenBuffer.u64++ = sect[ABS].sloc; + } + else + { + *evalTokenBuffer.u32++ = CONST; + *evalTokenBuffer.u64++ = sloc; + } break; case CR_TIME: *evalTokenBuffer.u32++ = CONST; @@ -183,8 +193,9 @@ getsym: return error(missym_error); p = string[*tok++]; - j = (*p == '.' ? curenv : 0); - w = ((sy = lookup(p, LABEL, j)) != NULL && (sy->sattr & w) ? 1 : 0); + int j = (*p == '.' ? curenv : 0); + SYM * sy = lookup(p, LABEL, j); + w = ((sy != NULL) && (sy->sattr & w ? 1 : 0)); *evalTokenBuffer.u32++ = CONST; *evalTokenBuffer.u64++ = (uint64_t)w; break; @@ -201,7 +212,7 @@ getsym: if (*tok != SYMBOL && *tok != STRING) return error(str_error); - p2 = string[tok[1]]; + char * p2 = string[tok[1]]; tok += 2; w = (WORD)(!strcmp(p, p2)); @@ -222,9 +233,6 @@ getsym: // int expr2(void) { - char * p; - SYM * sy; - int j; PTR ptk; switch (*tok++) @@ -237,14 +245,15 @@ int expr2(void) break; case FCONST: ptk.u32 = tok; - *evalTokenBuffer.u32++ = CONST; + *evalTokenBuffer.u32++ = FCONST; *evalTokenBuffer.u64++ = *ptk.u64++; tok = ptk.u32; break; case SYMBOL: - p = string[*tok++]; - j = (*p == '.' ? curenv : 0); - sy = lookup(p, LABEL, j); + { + char * p = string[*tok++]; + int j = (*p == '.' ? curenv : 0); + SYM * sy = lookup(p, LABEL, j); if (sy == NULL) sy = NewSymbol(p, LABEL, j); @@ -264,6 +273,7 @@ int expr2(void) symbolPtr[symbolNum] = sy; symbolNum++; break; + } case STRING: *evalTokenBuffer.u32++ = CONST; *evalTokenBuffer.u64++ = str_value(string[*tok++]); @@ -494,10 +504,15 @@ thrown away right here. What the hell is it for? tok += 2; } + // Holy hell... This is likely due to the fact that LSR is mistakenly set as a SUNARY type... Need to fix this... !!! FIX !!! + else if (m6502) + { + *evalTokenBuffer.u32++ = *tok++; + } else { // Unknown type here... Alert the user!, - error("undefined RISC register in expression"); + error("undefined RISC register in expression [token=$%X]", *tok); // Prevent spurious error reporting... tok++; return ERROR; @@ -523,7 +538,7 @@ thrown away right here. What the hell is it for? // int evexpr(TOKEN * _tk, uint64_t * a_value, WORD * a_attr, SYM ** a_esym) { - WORD attr, attr2; + WORD attr; SYM * sy; uint64_t * sval = evstk; // (Empty) initial stack WORD * sattr = evattr; @@ -558,28 +573,28 @@ int evexpr(TOKEN * _tk, uint64_t * a_value, WORD * a_attr, SYM ** a_esym) } if (sy->sattr & DEFINED) - { *++sval = sy->svalue; // Push symbol's value - } else - { *++sval = 0; // 0 for undefined symbols - } *++sattr = (WORD)(sy->sattr & ~GLOBAL); // Push attribs sym_seg = (WORD)(sy->sattr & TDB); break; + case CONST: *++sval = *tk.u64++; //printf("evexpr(): CONST = %lX\n", *sval); *++sattr = ABS | DEFINED; // Push simple attribs break; + case FCONST: -//printf("evexpr(): FCONST = %i\n", *tk.u32); - *((double *)sval) = *((double *)tk.u32); - tk.u32 += 2; +//printf("evexpr(): FCONST = %lf\n", *tk.dp); + // Even though it's a double, we can treat it like a uint64_t since + // we're just moving the bits around. + *++sval = *tk.u64++; *++sattr = ABS | DEFINED | FLOAT; // Push simple attribs break; + case ACONST: //printf("evexpr(): ACONST = %i\n", *tk.u32); *++sval = *tk.u32++; // Push value @@ -597,36 +612,26 @@ int evexpr(TOKEN * _tk, uint64_t * a_value, WORD * a_attr, SYM ** a_esym) // // [1] + : Error // - : ABS + case '+': //printf("evexpr(): +\n"); --sval; // Pop value --sattr; // Pop attrib //printf("--> N+N: %i + %i = ", *sval, sval[1]); - // Extract float attributes from both terms and pack them - // into a single value - attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1); - attr2 = sattr[0] | sattr[1] & FLOAT; // Returns FLOAT if either of the two numbers are FLOAT + // Get FLOAT attribute, if any + attr = (sattr[0] | sattr[1]) & FLOAT; - if (attr == (FLOAT | (FLOAT >> 1))) + // Since adding an int to a fp value promotes it to a fp value, we + // don't care whether it's first or second; we cast to to a double + // regardless. + if (attr == FLOAT) { - // Float + Float - double * dst = (double *)sval; - double * src = (double *)(sval + 1); - *dst += *src; - } - else if (attr == FLOAT) - { - // Float + Int - double * dst = (double *)sval; - uint64_t * src = (uint64_t *)(sval + 1); - *dst += *src; - } - else if (attr == FLOAT >> 1) - { - // Int + Float - uint64_t * dst = (uint64_t *)sval; - double * src = (double *)(sval + 1); - *(double *)dst = *src + *dst; + PTR p; + p.u64 = sval; + double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64); + p.u64++; + double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64); + *(double *)sval = fpval1 + fpval2; } else { @@ -635,54 +640,43 @@ int evexpr(TOKEN * _tk, uint64_t * a_value, WORD * a_attr, SYM ** a_esym) //printf("%i\n", *sval); if (!(*sattr & TDB)) - *sattr = sattr[1] | attr2; + *sattr = sattr[1] | attr; else if (sattr[1] & TDB) return error(seg_error); break; + case '-': //printf("evexpr(): -\n"); --sval; // Pop value --sattr; // Pop attrib //printf("--> N-N: %i - %i = ", *sval, sval[1]); - // Extract float attributes from both terms and pack them - // into a single value - attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1); - attr2 = sattr[0] | sattr[1] & FLOAT; // Returns FLOAT if either of the two numbers are FLOAT + // Get FLOAT attribute, if any + attr = (sattr[0] | sattr[1]) & FLOAT; - if (attr == (FLOAT | (FLOAT >> 1))) - { - // Float - Float - double * dst = (double *)sval; - double * src = (double *)(sval + 1); - *dst -= *src; - } - else if (attr == FLOAT) + // Since subtracting an int to a fp value promotes it to a fp + // value, we don't care whether it's first or second; we cast to to + // a double regardless. + if (attr == FLOAT) { - // Float - Int - double * dst = (double *)sval; - uint64_t * src = (uint64_t *)(sval + 1); - *dst -= *src; - } - else if (attr == FLOAT >> 1) - { - // Int - Float - uint64_t * dst = (uint64_t *)sval; - double * src = (double *)(sval + 1); - *(double *)dst = *dst - *src; + PTR p; + p.u64 = sval; + double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64); + p.u64++; + double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64); + *(double *)sval = fpval1 - fpval2; } else { - *sval -= sval[1]; // Compute value + *sval -= sval[1]; } - //printf("%i\n", *sval); + *sattr |= attr; // Inherit FLOAT attribute attr = (WORD)(*sattr & TDB); #if 0 printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); #endif - *sattr |= attr2; // Inherit FLOAT attribute // If symbol1 is ABS, take attributes from symbol2 if (!attr) *sattr = sattr[1]; @@ -691,6 +685,7 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); *sattr &= ~TDB; break; + // Unary operators only work on ABS items case UNMINUS: //printf("evexpr(): UNMINUS\n"); @@ -699,16 +694,42 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if (*sattr & FLOAT) { - double *dst = (double *)sval; + double * dst = (double *)sval; *dst = -*dst; *sattr = ABS | DEFINED | FLOAT; // Expr becomes absolute } else { - *sval = -(int)*sval; + *sval = -(int64_t)*sval; *sattr = ABS | DEFINED; // Expr becomes absolute } + + break; + + case UNLT: // Unary < (get the low byte of a word) +//printf("evexpr(): UNLT\n"); + if (*sattr & TDB) + return error(seg_error); + + if (*sattr & FLOAT) + return error(noflt_error); + + *sval = (int64_t)((*sval) & 0x00FF); + *sattr = ABS | DEFINED; // Expr becomes absolute break; + + case UNGT: // Unary > (get the high byte of a word) +//printf("evexpr(): UNGT\n"); + if (*sattr & TDB) + return error(seg_error); + + if (*sattr & FLOAT) + return error(noflt_error); + + *sval = (int64_t)(((*sval) >> 8) & 0x00FF); + *sattr = ABS | DEFINED; // Expr becomes absolute + break; + case '!': //printf("evexpr(): !\n"); if (*sattr & TDB) @@ -720,6 +741,7 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); *sval = !*sval; *sattr = ABS | DEFINED; // Expr becomes absolute break; + case '~': //printf("evexpr(): ~\n"); if (*sattr & TDB) @@ -731,6 +753,7 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); *sval = ~*sval; *sattr = ABS | DEFINED; // Expr becomes absolute break; + // Comparison operators must have two values that // are in the same segment, but that's the only requirement. case LE: @@ -741,38 +764,28 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if ((*sattr & TDB) != (sattr[1] & TDB)) return error(seg_error); - // Extract float attributes from both terms and pack them - // into a single value - attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1); + // Get FLOAT attribute, if any + attr = (sattr[0] | sattr[1]) & FLOAT; - if (attr == (FLOAT | (FLOAT >> 1))) - { - // Float <= Float - double * dst = (double *)sval; - double * src = (double *)(sval + 1); - *sval = *dst <= *src; - } - else if (attr == FLOAT) - { - // Float <= Int - double * dst = (double *)sval; - uint64_t * src = (uint64_t *)(sval + 1); - *sval = *dst <= *src; - } - else if (attr == FLOAT >> 1) + // Cast any ints in the comparison to double, if there's at least + // one double in the comparison. + if (attr == FLOAT) { - // Int <= Float - uint64_t * dst = (uint64_t *)sval; - double * src = (double *)(sval + 1); - *sval = *dst <= *src; + PTR p; + p.u64 = sval; + double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64); + p.u64++; + double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64); + *sval = (fpval1 <= fpval2); } else { - *sval = *sval <= sval[1]; + *sval = (*sval <= sval[1]); } *sattr = ABS | DEFINED; break; + case GE: //printf("evexpr(): GE\n"); sattr--; @@ -781,39 +794,28 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if ((*sattr & TDB) != (sattr[1] & TDB)) return error(seg_error); - // Extract float attributes from both terms and pack them - // into a single value - attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1); + // Get FLOAT attribute, if any + attr = (sattr[0] | sattr[1]) & FLOAT; - if (attr == (FLOAT | (FLOAT >> 1))) - { - // Float >= Float - double * dst = (double *)sval; - double * src = (double *)(sval + 1); - *sval = *dst >= *src; - } - else if (attr == FLOAT) + // Cast any ints in the comparison to double, if there's at least + // one double in the comparison. + if (attr == FLOAT) { - // Float >= Int - double * dst = (double *)sval; - uint64_t * src = (uint64_t *)(sval + 1); - *sval = *dst >= *src; + PTR p; + p.u64 = sval; + double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64); + p.u64++; + double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64); + *sval = (fpval1 >= fpval2); } - else if (attr == FLOAT >> 1) - { - // Int >= Float - uint64_t * dst = (uint64_t *)sval; - double * src = (double *)(sval + 1); - *sval = *dst >= *src; - } - else if (attr == 0) + else { - *sval = *sval >= sval[1]; + *sval = (*sval >= sval[1]); } - else - *sattr = ABS | DEFINED; + *sattr = ABS | DEFINED; break; + case '>': //printf("evexpr(): >\n"); sattr--; @@ -822,39 +824,28 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if ((*sattr & TDB) != (sattr[1] & TDB)) return error(seg_error); - // Extract float attributes from both terms and pack them - // into a single value - attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1); + // Get FLOAT attribute, if any + attr = (sattr[0] | sattr[1]) & FLOAT; - if (attr == (FLOAT | (FLOAT >> 1))) - { - // Float > Float - double * dst = (double *)sval; - double * src = (double *)(sval + 1); - *sval = *dst > *src; - } - else if (attr == FLOAT) - { - // Float > Int - double * dst = (double *)sval; - uint64_t * src = (uint64_t *)(sval + 1); - *sval = *dst > *src; - } - else if (attr == FLOAT >> 1) + // Cast any ints in the comparison to double, if there's at least + // one double in the comparison. + if (attr == FLOAT) { - // Int > Float - uint64_t * dst = (uint64_t *)sval; - double * src = (double *)(sval + 1); - *sval = *dst > *src; + PTR p; + p.u64 = sval; + double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64); + p.u64++; + double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64); + *sval = (fpval1 > fpval2); } else { - *sval = *sval > sval[1]; + *sval = (*sval > sval[1]); } *sattr = ABS | DEFINED; - break; + case '<': //printf("evexpr(): <\n"); sattr--; @@ -863,39 +854,28 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if ((*sattr & TDB) != (sattr[1] & TDB)) return error(seg_error); - // Extract float attributes from both terms and pack them - // into a single value - attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1); + // Get FLOAT attribute, if any + attr = (sattr[0] | sattr[1]) & FLOAT; - if (attr == (FLOAT | (FLOAT >> 1))) + // Cast any ints in the comparison to double, if there's at least + // one double in the comparison. + if (attr == FLOAT) { - // Float < Float - double * dst = (double *)sval; - double * src = (double *)(sval + 1); - *sval = *dst < *src; - } - else if (attr == FLOAT) - { - // Float < Int - double * dst = (double *)sval; - uint64_t * src = (uint64_t *)(sval + 1); - *sval = *dst < *src; - } - else if (attr == FLOAT >> 1) - { - // Int < Float - uint64_t * dst = (uint64_t *)sval; - double * src = (double *)(sval + 1); - *sval = *dst < *src; + PTR p; + p.u64 = sval; + double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64); + p.u64++; + double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64); + *sval = (fpval1 < fpval2); } else { - *sval = *sval < sval[1]; + *sval = (*sval < sval[1]); } - *sattr = ABS | DEFINED; - + *sattr = ABS | DEFINED; // Expr forced to ABS break; + case NE: //printf("evexpr(): NE\n"); sattr--; @@ -904,33 +884,28 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if ((*sattr & TDB) != (sattr[1] & TDB)) return error(seg_error); - // Extract float attributes from both terms and pack them - // into a single value - attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1); + // Get FLOAT attribute, if any + attr = (sattr[0] | sattr[1]) & FLOAT; - if (attr == (FLOAT | (FLOAT >> 1))) - { - // Float <> Float - return error("comparison for equality with float types not allowed."); - } - else if (attr == FLOAT) - { - // Float <> Int - return error("comparison for equality with float types not allowed."); - } - else if (attr == FLOAT >> 1) + // Cast any ints in the comparison to double, if there's at least + // one double in the comparison. + if (attr == FLOAT) { - // Int != Float - return error("comparison for equality with float types not allowed."); + PTR p; + p.u64 = sval; + double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64); + p.u64++; + double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64); + *sval = (fpval1 != fpval2); } else { - *sval = *sval != sval[1]; + *sval = (*sval != sval[1]); } - *sattr = ABS | DEFINED; - + *sattr = ABS | DEFINED; // Expr forced to ABS break; + case '=': //printf("evexpr(): =\n"); sattr--; @@ -939,76 +914,59 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if ((*sattr & TDB) != (sattr[1] & TDB)) return error(seg_error); - // Extract float attributes from both terms and pack them - // into a single value - attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1); + // Get FLOAT attribute, if any + attr = (sattr[0] | sattr[1]) & FLOAT; - if (attr == (FLOAT | (FLOAT >> 1))) - { - // Float = Float - double * dst = (double *)sval; - double * src = (double *)(sval + 1); - *sval = *src == *dst; - } - else if (attr == FLOAT) - { - // Float = Int - return error("equality with float "); - } - else if (attr == FLOAT >> 1) + // Cast any ints in the comparison to double, if there's at least + // one double in the comparison. + if (attr == FLOAT) { - // Int == Float - uint64_t * dst = (uint64_t *)sval; - double * src = (double *)(sval + 1); - *sval = *src == *dst; + PTR p; + p.u64 = sval; + double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64); + p.u64++; + double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64); + *sval = (fpval1 == fpval2); } else { - *sval = *sval == sval[1]; + *sval = (*sval == sval[1]); } - *sattr = ABS | DEFINED; + *sattr = ABS | DEFINED; // Expr forced to ABS break; + // All other binary operators must have two ABS items to work with. // They all produce an ABS value. + // Shamus: Is this true? There's at least one counterexample of legit + // code where this assumption fails to produce correct code. default: //printf("evexpr(): default\n"); - // GH - Removed for v1.0.15 as part of the fix for indexed loads. - //if ((*sattr & (TEXT|DATA|BSS)) || (*--sattr & (TEXT|DATA|BSS))) - //error(seg_error); switch ((int)tk.u32[-1]) { case '*': sval--; - sattr--; // Pop attrib + sattr--; //printf("--> NxN: %i x %i = ", *sval, sval[1]); - // Extract float attributes from both terms and pack them - // into a single value - attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1); - attr2 = sattr[0] | sattr[1] & FLOAT; // Returns FLOAT if either of the two numbers are FLOAT + // Get FLOAT attribute, if any + attr = (sattr[0] | sattr[1]) & FLOAT; - if (attr == (FLOAT | (FLOAT >> 1))) - { - // Float * Float - double * dst = (double *)sval; - double * src = (double *)(sval + 1); - *dst *= *src; - } - else if (attr == FLOAT) - { - // Float * Int - double * dst = (double *)sval; - uint64_t * src = (uint64_t *)(sval + 1); - *dst *= *src; - } - else if (attr == FLOAT >> 1) + // Since multiplying an int to a fp value promotes it to a fp + // value, we don't care whether it's first or second; it will + // be cast to a double regardless. +/* +An open question here is do we promote ints to floats as signed or unsigned? It makes a difference if, say, the int is put in as -1 but is promoted to a double as $FFFFFFFFFFFFFFFF--you get very different results that way! For now, we promote as signed until proven detrimental otherwise. +*/ + if (attr == FLOAT) { - // Int * Float - uint64_t * dst = (uint64_t *)sval; - double * src = (double *)(sval + 1); - *(double *)dst = *src * *dst; + PTR p; + p.u64 = sval; + double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64); + p.u64++; + double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64); + *(double *)sval = fpval1 * fpval2; } else { @@ -1016,53 +974,28 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); } //printf("%i\n", *sval); - *sattr = ABS | DEFINED; // Expr becomes absolute - *sattr |= attr2; - +//no *sattr = ABS | DEFINED | attr; // Expr becomes absolute break; + case '/': sval--; - sattr--; // Pop attrib - - + sattr--; //printf("--> N/N: %i / %i = ", sval[0], sval[1]); - // Extract float attributes from both terms and pack them - // into a single value - attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1); - attr2 = sattr[0] | sattr[1] & FLOAT; // Returns FLOAT if either of the two numbers are FLOAT + // Get FLOAT attribute, if any + attr = (sattr[0] | sattr[1]) & FLOAT; - if (attr == (FLOAT | (FLOAT >> 1))) + if (attr == FLOAT) { - // Float / Float - double * dst = (double *)sval; - double * src = (double *)(sval + 1); + PTR p; + p.u64 = sval; + double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64); + p.u64++; + double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64); - if (*src == 0) + if (fpval2 == 0) return error("divide by zero"); - *dst = *dst / *src; - } - else if (attr == FLOAT) - { - // Float / Int - double * dst = (double *)sval; - uint64_t * src = (uint64_t *)(sval + 1); - - if (*src == 0) - return error("divide by zero"); - - *dst = *dst / *src; - } - else if (attr == FLOAT >> 1) - { - // Int / Float - uint64_t * dst=(uint64_t *)sval; - double * src=(double *)(sval + 1); - - if (*src == 0) - return error("divide by zero"); - - *(double *)dst = *dst / *src; + *(double *)sval = fpval1 / fpval2; } else { @@ -1077,15 +1010,14 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); // ints. *sval = (int32_t)sval[0] / (int32_t)sval[1]; } - - *sattr = ABS | DEFINED; // Expr becomes absolute - *sattr |= attr2; - //printf("%i\n", *sval); + +//no *sattr = ABS | DEFINED | attr; // Expr becomes absolute break; + case '%': sval--; - sattr--; // Pop attrib + sattr--; if ((*sattr | sattr[1]) & FLOAT) return error("floating point numbers not allowed with operator '%'."); @@ -1093,9 +1025,10 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if (sval[1] == 0) return error("mod (%) by zero"); - *sattr = ABS | DEFINED; // Expr becomes absolute *sval %= sval[1]; +//no *sattr = ABS | DEFINED; // Expr becomes absolute break; + case SHL: sval--; sattr--; // Pop attrib @@ -1103,9 +1036,10 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if ((*sattr | sattr[1]) & FLOAT) return error("floating point numbers not allowed with operator '<<'."); - *sattr = ABS | DEFINED; // Expr becomes absolute *sval <<= sval[1]; +//no *sattr = ABS | DEFINED; // Expr becomes absolute break; + case SHR: sval--; sattr--; // Pop attrib @@ -1113,9 +1047,10 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if ((*sattr | sattr[1]) & FLOAT) return error("floating point numbers not allowed with operator '>>'."); - *sattr = ABS | DEFINED; // Expr becomes absolute *sval >>= sval[1]; +//no *sattr = ABS | DEFINED; // Expr becomes absolute break; + case '&': sval--; sattr--; // Pop attrib @@ -1123,9 +1058,10 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if ((*sattr | sattr[1]) & FLOAT) return error("floating point numbers not allowed with operator '&'."); - *sattr = ABS | DEFINED; // Expr becomes absolute *sval &= sval[1]; +//no *sattr = ABS | DEFINED; // Expr becomes absolute break; + case '^': sval--; sattr--; // Pop attrib @@ -1133,21 +1069,24 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if ((*sattr | sattr[1]) & FLOAT) return error("floating point numbers not allowed with operator '^'."); - *sattr = ABS | DEFINED; // Expr becomes absolute *sval ^= sval[1]; +//no *sattr = ABS | DEFINED; // Expr becomes absolute break; + case '|': sval--; - sattr--; // Pop attrib + sattr--; if ((*sattr | sattr[1]) & FLOAT) return error("floating point numbers not allowed with operator '|'."); - *sattr = ABS | DEFINED; // Expr becomes absolute *sval |= sval[1]; +//no *sattr = ABS | DEFINED; // Expr becomes absolute break; + default: - interror(5); // Bad operator in expression stream + // Bad operator in expression stream (this should never happen!) + interror(5); } } } @@ -1158,14 +1097,34 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); if (a_esym != NULL) *a_esym = esym; - // sym_seg added in 1.0.16 to solve a problem with forward symbols in - // expressions where absolute values also existed. The absolutes were - // overiding the symbol segments and not being included :( - //*a_attr = *sattr | sym_seg; // Copy value + attrib - - *a_attr = *sattr; // Copy value + attrib + // Copy value + attrib into return variables *a_value = *sval; + *a_attr = *sattr; return OK; } + +// +// Count the # of tokens in the passed in expression +// N.B.: 64-bit constants count as two tokens each +// +uint16_t ExpressionLength(TOKEN * tk) +{ + uint16_t length; + + for(length=0; tk[length]!=ENDEXPR; length++) + { + // Add one to length for 2X tokens, two for 3X tokens + if (tk[length] == SYMBOL) + length++; + else if ((tk[length] == CONST) || (tk[length] == FCONST)) + length += 2; + } + + // Add 1 for ENDEXPR + length++; + + return length; +} +