/*
* NAME: node->float()
* DESCRIPTION: create a float node
*/
node *node_float(Float *flt)
{
node *n;
n = node_new(tk_line());
n->type = N_FLOAT;
n->flags = F_CONST;
n->mod = T_FLOAT;
NFLT_PUT(n, *flt);
return n;
}
/*
* NAME: optimize->binop()
* DESCRIPTION: optimize a binary operator expression
*/
static Uint opt_binop(node **m)
{
node *n, *t;
Uint d1, d2, d;
Float f1, f2;
n = *m;
if (n->type == N_ADD && n->r.right->type == N_ADD &&
n->l.left->mod == n->r.right->mod &&
(n->mod == T_STRING || (n->mod & T_REF) != 0)) {
/*
* a + (b + c) --> (a + b) + c
* the order in which these are added won't affect the final result
*/
t = n->l.left;
n->l.left = n->r.right;
n->r.right = n->l.left->r.right;
n->l.left->r.right = n->l.left->l.left;
n->l.left->l.left = t;
}
d1 = opt_expr(&n->l.left, FALSE);
d2 = opt_expr(&n->r.right, FALSE);
if (n->type == N_SUM) {
if (n->l.left->type == N_RANGE) {
d1 = max2(d1, 3);
} else if (n->l.left->type != N_SUM) {
d1++;
}
if (n->r.right->type == N_RANGE) {
d2 = max2(d2, 3);
} else {
d2++;
}
return d1 + d2;
}
if (n->type == N_ADD) {
if (n->r.right->type == N_STR &&
(n->l.left->type == N_ADD || n->l.left->type == N_SUM) &&
n->l.left->r.right->type == N_STR) {
/* (x + s1) + s2 */
node_tostr(n->r.right, str_add(n->l.left->r.right->l.string,
n->r.right->l.string));
n->l.left = n->l.left->l.left;
return d1;
}
if (n->l.left->mod == T_STRING || (n->l.left->mod & T_REF) != 0) {
/*
* see if the summand operator can be used
*/
switch (n->l.left->type) {
case N_ADD:
n->l.left->type = N_SUM;
d1 += 2; /* SUM_SIMPLE on both sides */
if (n->l.left->l.left->type == N_RANGE) {
d1++;
}
n->type = N_SUM;
if (n->r.right->type == N_RANGE) {
d2 = max2(d2, 3); /* at least 3 */
} else {
d2++; /* add SUM_SIMPLE */
}
return d1 + d2;
case N_FUNC:
if (n->l.left->r.number == kd_allocate ||
n->l.left->r.number == kd_allocate_int ||
n->l.left->r.number == kd_allocate_float) {
t = n->l.left->l.left->r.right;
if (t != (node *) NULL && t->type != N_PAIR &&
t->type != N_SPREAD && t->mod == T_INT) {
d1++; /* add SUM_ALLOCATE */
n->type = N_SUM;
if (n->r.right->type == N_RANGE) {
d2 = max2(d2, 3); /* at least 3 */
} else {
d2++; /* add SUM_SIMPLE */
}
return d1 + d2;
}
}
/* fall through */
default:
if (n->r.right->type != N_RANGE && n->r.right->type != N_AGGR) {
if (n->r.right->type != N_FUNC ||
(n->r.right->r.number != kd_allocate &&
n->r.right->r.number != kd_allocate_int &&
n->r.right->r.number != kd_allocate_float)) {
break;
}
t = n->r.right->l.left->r.right;
if (t == (node *) NULL || t->type == N_PAIR ||
t->type == N_SPREAD || t->mod != T_INT) {
break;
}
}
/* fall through */
case N_AGGR:
d1++; /* add SUM_SIMPLE */
n->type = N_SUM;
if (n->r.right->type == N_RANGE) {
d2 = max2(d2, 3); /* at least 3 */
} else {
d2++; /* add SUM_SIMPLE */
}
return d1 + d2;
case N_RANGE:
d1 = max2(d1, 3); /* at least 3 */
/* fall through */
case N_SUM:
n->type = N_SUM;
if (n->r.right->type == N_RANGE) {
d2 = max2(d2, 3); /* at least 3 */
} else {
d2++; /* add SUM_SIMPLE */
}
return d1 + d2;
}
}
}
if (n->l.left->flags & F_CONST) {
if (n->r.right->flags & F_CONST) {
/* c1 . c2 */
return opt_binconst(m);
}
switch (n->type) {
case N_ADD:
if (!T_ARITHMETIC(n->l.left->mod) || !T_ARITHMETIC(n->r.right->mod))
{
break;
}
/* fall through */
case N_ADD_INT:
case N_ADD_FLOAT:
case N_AND:
case N_AND_INT:
case N_EQ:
case N_EQ_INT:
case N_EQ_FLOAT:
case N_MULT:
case N_MULT_INT:
case N_MULT_FLOAT:
case N_NE:
case N_NE_INT:
case N_NE_FLOAT:
case N_OR:
case N_OR_INT:
case N_XOR:
case N_XOR_INT:
/* swap constant to the right */
t = n->l.left;
n->l.left = n->r.right;
n->r.right = t;
d = d1;
d1 = d2;
d2 = d;
break;
}
}
d = max2(d1, d2 + 1);
if ((n->r.right->type == N_INT && n->r.right->l.number == 0 &&
n->l.left->mod == T_INT) ||
(n->r.right->type == N_FLOAT && NFLT_ISZERO(n->r.right) &&
n->l.left->mod == T_FLOAT) ||
(n->r.right->type == nil_node && n->r.right->l.number == 0 &&
n->l.left->mod != T_MIXED && T_POINTER(n->l.left->mod))) {
/*
* int == 0, float == 0.0, ptr == nil
*/
switch (n->type) {
case N_EQ:
case N_EQ_INT:
case N_EQ_FLOAT:
*m = opt_not(n->l.left);
return d1;
case N_NE:
case N_NE_INT:
case N_NE_FLOAT:
*m = opt_tst(n->l.left);
return d1;
}
}
if (T_ARITHMETIC(n->mod) && n->mod == n->l.left->mod &&
n->mod == n->r.right->mod) {
if (n->r.right->flags & F_CONST) {
/* x . c */
if ((n->type == n->l.left->type ||
(n->mod == T_INT && n->l.left->mod == T_INT &&
n->type == n->l.left->type + 1)) &&
(n->l.left->r.right->flags & F_CONST)) {
/* (x . c1) . c2 */
switch (n->type) {
case N_ADD_FLOAT:
case N_SUB_FLOAT:
NFLT_GET(n->l.left->r.right, f1);
NFLT_GET(n->r.right, f2);
f1.add(f2);
NFLT_PUT(n->l.left->r.right, f1);
*m = n->l.left;
d = d1;
break;
case N_ADD_INT:
case N_SUB_INT:
case N_LSHIFT_INT:
case N_RSHIFT_INT:
n->l.left->r.right->l.number += n->r.right->l.number;
*m = n->l.left;
d = d1;
break;
case N_AND_INT:
n->l.left->r.right->l.number &= n->r.right->l.number;
*m = n->l.left;
d = d1;
break;
case N_DIV_FLOAT:
case N_MULT_FLOAT:
NFLT_GET(n->l.left->r.right, f1);
NFLT_GET(n->r.right, f2);
f1.mult(f2);
NFLT_PUT(n->l.left->r.right, f1);
*m = n->l.left;
d = d1;
break;
case N_DIV_INT:
case N_MULT_INT:
n->l.left->r.right->l.number *= n->r.right->l.number;
*m = n->l.left;
d = d1;
break;
case N_OR_INT:
n->l.left->r.right->l.number |= n->r.right->l.number;
*m = n->l.left;
d = d1;
break;
case N_XOR_INT:
n->l.left->r.right->l.number ^= n->r.right->l.number;
*m = n->l.left;
d = d1;
break;
}
} else {
switch (n->type) {
case N_ADD_FLOAT:
if (n->l.left->type == N_SUB_FLOAT) {
if (n->l.left->l.left->type == N_FLOAT) {
/* (c1 - x) + c2 */
NFLT_GET(n->l.left->l.left, f1);
NFLT_GET(n->r.right, f2);
f1.add(f2);
NFLT_PUT(n->l.left->l.left, f1);
*m = n->l.left;
return d1;
}
if (n->l.left->r.right->type == N_FLOAT) {
/* (x - c1) + c2 */
NFLT_GET(n->l.left->r.right, f1);
NFLT_GET(n->r.right, f2);
f1.sub(f2);
NFLT_PUT(n->l.left->r.right, f1);
*m = n->l.left;
d = d1;
}
}
break;
case N_ADD_INT:
if (n->l.left->type == N_SUB ||
n->l.left->type == N_SUB_INT) {
if (n->l.left->l.left->type == N_INT) {
/* (c1 - x) + c2 */
n->l.left->l.left->l.number += n->r.right->l.number;
*m = n->l.left;
return d1;
}
if (n->l.left->r.right->type == N_INT) {
/* (x - c1) + c2 */
n->l.left->r.right->l.number -=
n->r.right->l.number;
*m = n->l.left;
d = d1;
}
}
break;
case N_DIV_FLOAT:
if (n->l.left->type == N_MULT_FLOAT &&
n->l.left->r.right->type == N_FLOAT &&
!NFLT_ISZERO(n->r.right)) {
/* (x * c1) / c2 */
NFLT_GET(n->l.left->r.right, f1);
NFLT_GET(n->r.right, f2);
f1.div(f2);
NFLT_PUT(n->l.left->r.right, f1);
*m = n->l.left;
d = d1;
}
break;
case N_MULT_FLOAT:
if (n->l.left->type == N_DIV_FLOAT) {
if (n->l.left->l.left->type == N_FLOAT) {
/* (c1 / x) * c2 */
NFLT_GET(n->l.left->l.left, f1);
NFLT_GET(n->r.right, f2);
f1.mult(f2);
NFLT_PUT(n->l.left->l.left, f1);
*m = n->l.left;
return d1;
}
if (n->l.left->r.right->type == N_FLOAT &&
!NFLT_ISZERO(n->l.left->r.right)) {
/* (x / c1) * c2 */
NFLT_GET(n->r.right, f1);
NFLT_GET(n->l.left->r.right, f2);
f1.div(f2);
NFLT_PUT(n->r.right, f1);
n->l.left = n->l.left->l.left;
d = d1;
}
}
break;
case N_SUB_FLOAT:
if (n->l.left->type == N_ADD_FLOAT &&
n->l.left->r.right->type == N_FLOAT) {
/* (x + c1) - c2 */
NFLT_GET(n->l.left->r.right, f1);
NFLT_GET(n->r.right, f2);
f1.sub(f2);
NFLT_PUT(n->l.left->r.right, f1);
*m = n->l.left;
d = d1;
}
break;
case N_SUB_INT:
if (n->l.left->type == N_ADD_INT &&
n->l.left->r.right->type == N_INT) {
/* (x + c1) - c2 */
n->l.left->r.right->l.number -= n->r.right->l.number;
*m = n->l.left;
d = d1;
}
break;
}
}
} else if (n->l.left->flags & F_CONST) {
/* c . x */
switch (n->type) {
case N_SUB_FLOAT:
if (n->r.right->type == N_SUB_FLOAT) {
if (n->r.right->l.left->type == N_FLOAT) {
/* c1 - (c2 - x) */
NFLT_GET(n->l.left, f1);
NFLT_GET(n->r.right->l.left, f2);
f1.sub(f2);
n->type = N_ADD;
n->l.left = n->r.right->r.right;
n->r.right = n->r.right->l.left;
NFLT_PUT(n->r.right, f1);
d = d2;
} else if (n->r.right->r.right->type == N_FLOAT) {
/* c1 - (x - c2) */
NFLT_GET(n->l.left, f1);
NFLT_GET(n->r.right->r.right, f2);
f1.add(f2);
NFLT_PUT(n->l.left, f1);
n->r.right = n->r.right->l.left;
return d2 + 1;
}
} else if (n->r.right->type == N_ADD_FLOAT &&
n->r.right->r.right->type == N_FLOAT) {
/* c1 - (x + c2) */
NFLT_GET(n->l.left, f1);
NFLT_GET(n->r.right->r.right, f2);
f1.sub(f2);
NFLT_PUT(n->l.left, f1);
n->r.right = n->r.right->l.left;
return d2 + 1;
}
break;
case N_SUB_INT:
if ((n->r.right->type == N_SUB ||
n->r.right->type == N_SUB_INT)) {
if (n->r.right->l.left->type == N_INT) {
/* c1 - (c2 - x) */
n->r.right->l.left->l.number -= n->l.left->l.number;
n->type = n->r.right->type;
n->l.left = n->r.right->r.right;
n->r.right = n->r.right->l.left;
d = d2;
} else if (n->r.right->r.right->type == N_INT) {
/* c1 - (x - c2) */
n->l.left->l.number += n->r.right->r.right->l.number;
n->r.right->r.right = n->r.right->l.left;
n->r.right->l.left = n->l.left;
*m = n->r.right;
return d2 + 1;
}
} else if (n->r.right->type == N_ADD_INT &&
n->r.right->r.right->type == N_INT) {
/* c1 - (x + c2) */
n->l.left->l.number -= n->r.right->r.right->l.number;
n->r.right = n->r.right->l.left;
return d2 + 1;
}
break;
case N_DIV_FLOAT:
if (n->r.right->type == N_DIV_FLOAT) {
if (n->r.right->l.left->type == N_FLOAT &&
!NFLT_ISZERO(n->r.right->l.left)) {
/* c1 / (c2 / x) */
NFLT_GET(n->l.left, f1);
NFLT_GET(n->r.right->l.left, f2);
f1.div(f2);
n->type = N_MULT;
n->l.left = n->r.right->r.right;
n->r.right = n->r.right->l.left;
NFLT_PUT(n->r.right, f1);
d = d2;
} else if (n->r.right->r.right->type == N_FLOAT) {
/* c1 / (x / c2) */
NFLT_GET(n->l.left, f1);
NFLT_GET(n->r.right->r.right, f2);
f1.mult(f2);
NFLT_PUT(n->l.left, f1);
n->r.right = n->r.right->l.left;
return d2 + 1;
}
} else if (n->r.right->type == N_MULT_FLOAT &&
n->r.right->r.right->type == N_FLOAT &&
!NFLT_ISZERO(n->r.right->r.right)) {
/* c1 / (x * c2) */
NFLT_GET(n->l.left, f1);
NFLT_GET(n->r.right->r.right, f2);
f1.div(f2);
NFLT_PUT(n->l.left, f1);
n->r.right = n->r.right->l.left;
return d2 + 1;
}
break;
}
}
n = *m;
if (T_ARITHMETIC(n->l.left->mod) && (n->r.right->flags & F_CONST)) {
switch (n->type) {
case N_ADD:
case N_ADD_FLOAT:
case N_SUB:
case N_SUB_FLOAT:
if (NFLT_ISZERO(n->r.right)) {
*m = n->l.left;
d = d1;
}
break;
case N_ADD_INT:
case N_SUB_INT:
case N_LSHIFT_INT:
case N_RSHIFT_INT:
case N_XOR_INT:
if (n->r.right->l.number == 0) {
*m = n->l.left;
d = d1;
}
break;
case N_AND_INT:
if (n->r.right->l.number == 0) {
n->type = N_COMMA;
return opt_expr(m, FALSE);
}
if (n->r.right->l.number == -1) {
*m = n->l.left;
d = d1;
}
break;
case N_MULT:
case N_MULT_FLOAT:
if (NFLT_ISZERO(n->r.right)) {
n->type = N_COMMA;
return opt_expr(m, FALSE);
}
/* fall through */
case N_DIV:
case N_DIV_FLOAT:
if (NFLT_ISONE(n->r.right)) {
*m = n->l.left;
d = d1;
}
break;
case N_MULT_INT:
if (n->r.right->l.number == 0) {
n->type = N_COMMA;
return opt_expr(m, FALSE);
}
/* fall through */
case N_DIV_INT:
if (n->r.right->l.number == 1) {
*m = n->l.left;
d = d1;
}
break;
case N_MOD_INT:
if (n->r.right->l.number == 1) {
n->r.right->l.number = 0;
n->type = N_COMMA;
return opt_expr(m, FALSE);
}
break;
case N_OR_INT:
if (n->r.right->l.number == -1) {
n->type = N_COMMA;
return opt_expr(m, FALSE);
}
if (n->r.right->l.number == 0) {
*m = n->l.left;
d = d1;
}
break;
}
}
}
return d;
}
/*
* NAME: optimize->binconst()
* DESCRIPTION: optimize a binary operator constant expression
*/
static Uint opt_binconst(node **m)
{
node *n;
Float f1, f2;
bool flag;
n = *m;
if (n->l.left->type != n->r.right->type) {
if (n->type == N_EQ) {
node_toint(n, (Int) FALSE);
} else if (n->type == N_NE) {
node_toint(n, (Int) TRUE);
} else {
return 2; /* runtime error expected */
}
return 1;
}
switch (n->l.left->type) {
case N_INT:
switch (n->type) {
case N_ADD_INT:
n->l.left->l.number += n->r.right->l.number;
break;
case N_AND_INT:
n->l.left->l.number &= n->r.right->l.number;
break;
case N_DIV_INT:
if (n->r.right->l.number == 0) {
return 2; /* runtime error: division by 0 */
}
n->l.left->l.number /= n->r.right->l.number;
break;
case N_EQ_INT:
n->l.left->l.number = (n->l.left->l.number == n->r.right->l.number);
break;
case N_GE_INT:
n->l.left->l.number = (n->l.left->l.number >= n->r.right->l.number);
break;
case N_GT_INT:
n->l.left->l.number = (n->l.left->l.number > n->r.right->l.number);
break;
case N_LE_INT:
n->l.left->l.number = (n->l.left->l.number <= n->r.right->l.number);
break;
case N_LSHIFT_INT:
n->l.left->l.number <<= n->r.right->l.number;
break;
case N_LT_INT:
n->l.left->l.number = (n->l.left->l.number < n->r.right->l.number);
break;
case N_MOD_INT:
if (n->r.right->l.number == 0) {
return 2; /* runtime error: % 0 */
}
n->l.left->l.number %= n->r.right->l.number;
break;
case N_MULT_INT:
n->l.left->l.number *= n->r.right->l.number;
break;
case N_NE_INT:
n->l.left->l.number = (n->l.left->l.number != n->r.right->l.number);
break;
case N_OR_INT:
n->l.left->l.number |= n->r.right->l.number;
break;
case N_RSHIFT_INT:
n->l.left->l.number >>= n->r.right->l.number;
break;
case N_SUB_INT:
n->l.left->l.number -= n->r.right->l.number;
break;
case N_XOR_INT:
n->l.left->l.number ^= n->r.right->l.number;
break;
default:
return 2; /* runtime error expected */
}
*m = n->l.left;
(*m)->line = n->line;
return 1;
case N_FLOAT:
NFLT_GET(n->l.left, f1);
NFLT_GET(n->r.right, f2);
switch (n->type) {
case N_ADD:
case N_ADD_FLOAT:
f1.add(f2);
break;
case N_DIV:
case N_DIV_FLOAT:
if (NFLT_ISZERO(n->r.right)) {
return 2; /* runtime error: division by 0.0 */
}
f1.div(f2);
break;
case N_EQ:
case N_EQ_FLOAT:
node_toint(n->l.left, (Int) (f1.cmp(f2) == 0));
break;
case N_GE:
case N_GE_FLOAT:
node_toint(n->l.left, (Int) (f1.cmp(f2) >= 0));
break;
case N_GT:
case N_GT_FLOAT:
node_toint(n->l.left, (Int) (f1.cmp(f2) > 0));
break;
case N_LE:
case N_LE_FLOAT:
node_toint(n->l.left, (Int) (f1.cmp(f2) <= 0));
break;
case N_LT:
case N_LT_FLOAT:
node_toint(n->l.left, (Int) (f1.cmp(f2) < 0));
break;
case N_MULT:
case N_MULT_FLOAT:
f1.mult(f2);
break;
case N_NE:
case N_NE_FLOAT:
node_toint(n->l.left, (Int) (f1.cmp(f2) != 0));
break;
case N_SUB:
case N_SUB_FLOAT:
f1.sub(f2);
break;
default:
return 2; /* runtime error expected */
}
NFLT_PUT(n->l.left, f1);
*m = n->l.left;
(*m)->line = n->line;
return 1;
case N_STR:
switch (n->type) {
case N_ADD:
node_tostr(n, str_add(n->l.left->l.string, n->r.right->l.string));
return 1;
case N_EQ:
flag = (str_cmp(n->l.left->l.string, n->r.right->l.string) == 0);
break;
case N_GE:
flag = (str_cmp(n->l.left->l.string, n->r.right->l.string) >= 0);
break;
case N_GT:
flag = (str_cmp(n->l.left->l.string, n->r.right->l.string) > 0);
break;
case N_LE:
flag = (str_cmp(n->l.left->l.string, n->r.right->l.string) <= 0);
break;
case N_LT:
flag = (str_cmp(n->l.left->l.string, n->r.right->l.string) < 0);
break;
case N_NE:
flag = (str_cmp(n->l.left->l.string, n->r.right->l.string) != 0);
break;
default:
return 2; /* runtime error expected */
}
node_toint(n, (Int) flag);
return 1;
case N_NIL:
switch (n->type) {
case N_EQ:
flag = TRUE;
break;
case N_NE:
flag = FALSE;
break;
default:
return 2; /* runtime error expected */
}
node_toint(n, (Int) flag);
return 1;
}
return 2;
}
