555 lines
11 KiB
C
555 lines
11 KiB
C
/* C O N S T A N T E X P R E S S I O N H A N D L I N G */
|
|
|
|
#include "debug.h"
|
|
#include "target_sizes.h"
|
|
|
|
#include <em_arith.h>
|
|
#include <em_label.h>
|
|
#include <assert.h>
|
|
|
|
#include "idf.h"
|
|
#include "type.h"
|
|
#include "LLlex.h"
|
|
#include "node.h"
|
|
#include "Lpars.h"
|
|
#include "standards.h"
|
|
|
|
long mach_long_sign; /* sign bit of the machine long */
|
|
int mach_long_size; /* size of long on this machine == sizeof(long) */
|
|
long full_mask[MAXSIZE];/* full_mask[1] == 0xFF, full_mask[2] == 0xFFFF, .. */
|
|
arith max_int; /* maximum integer on target machine */
|
|
arith max_unsigned; /* maximum unsigned on target machine */
|
|
arith max_longint; /* maximum longint on target machine */
|
|
arith wrd_bits; /* number of bits in a word */
|
|
|
|
cstunary(expp)
|
|
register struct node *expp;
|
|
{
|
|
/* The unary operation in "expp" is performed on the constant
|
|
expression below it, and the result restored in expp.
|
|
*/
|
|
register arith o1 = expp->nd_right->nd_INT;
|
|
|
|
switch(expp->nd_symb) {
|
|
/* Should not get here
|
|
case '+':
|
|
break;
|
|
*/
|
|
|
|
case '-':
|
|
o1 = -o1;
|
|
if (expp->nd_type->tp_fund == T_INTORCARD) {
|
|
expp->nd_type = int_type;
|
|
}
|
|
break;
|
|
|
|
case NOT:
|
|
case '~':
|
|
o1 = !o1;
|
|
break;
|
|
|
|
default:
|
|
crash("(cstunary)");
|
|
}
|
|
|
|
expp->nd_class = Value;
|
|
expp->nd_token = expp->nd_right->nd_token;
|
|
expp->nd_INT = o1;
|
|
CutSize(expp);
|
|
FreeNode(expp->nd_right);
|
|
expp->nd_right = 0;
|
|
}
|
|
|
|
cstbin(expp)
|
|
register struct node *expp;
|
|
{
|
|
/* The binary operation in "expp" is performed on the constant
|
|
expressions below it, and the result restored in
|
|
expp.
|
|
*/
|
|
register arith o1 = expp->nd_left->nd_INT;
|
|
register arith o2 = expp->nd_right->nd_INT;
|
|
register int uns = expp->nd_type != int_type;
|
|
|
|
assert(expp->nd_class == Oper);
|
|
assert(expp->nd_left->nd_class == Value);
|
|
assert(expp->nd_right->nd_class == Value);
|
|
|
|
switch (expp->nd_symb) {
|
|
case '*':
|
|
o1 *= o2;
|
|
break;
|
|
|
|
case DIV:
|
|
if (o2 == 0) {
|
|
node_error(expp, "division by 0");
|
|
return;
|
|
}
|
|
if (uns) {
|
|
/* this is more of a problem than you might
|
|
think on C compilers which do not have
|
|
unsigned long.
|
|
*/
|
|
if (o2 & mach_long_sign) {/* o2 > max_long */
|
|
o1 = ! (o1 >= 0 || o1 < o2);
|
|
/* this is the unsigned test
|
|
o1 < o2 for o2 > max_long
|
|
*/
|
|
}
|
|
else { /* o2 <= max_long */
|
|
long half, bit, hdiv, hrem, rem;
|
|
|
|
half = (o1 >> 1) & ~mach_long_sign;
|
|
bit = o1 & 01;
|
|
/* now o1 == 2 * half + bit
|
|
and half <= max_long
|
|
and bit <= max_long
|
|
*/
|
|
hdiv = half / o2;
|
|
hrem = half % o2;
|
|
rem = 2 * hrem + bit;
|
|
o1 = 2 * hdiv + (rem < 0 || rem >= o2);
|
|
/* that is the unsigned compare
|
|
rem >= o2 for o2 <= max_long
|
|
*/
|
|
}
|
|
}
|
|
else
|
|
o1 /= o2;
|
|
break;
|
|
|
|
case MOD:
|
|
if (o2 == 0) {
|
|
node_error(expp, "modulo by 0");
|
|
return;
|
|
}
|
|
if (uns) {
|
|
if (o2 & mach_long_sign) {/* o2 > max_long */
|
|
o1 = (o1 >= 0 || o1 < o2) ? o1 : o1 - o2;
|
|
/* this is the unsigned test
|
|
o1 < o2 for o2 > max_long
|
|
*/
|
|
}
|
|
else { /* o2 <= max_long */
|
|
long half, bit, hrem, rem;
|
|
|
|
half = (o1 >> 1) & ~mach_long_sign;
|
|
bit = o1 & 01;
|
|
/* now o1 == 2 * half + bit
|
|
and half <= max_long
|
|
and bit <= max_long
|
|
*/
|
|
hrem = half % o2;
|
|
rem = 2 * hrem + bit;
|
|
o1 = (rem < 0 || rem >= o2) ? rem - o2 : rem;
|
|
}
|
|
}
|
|
else
|
|
o1 %= o2;
|
|
break;
|
|
|
|
case '+':
|
|
o1 += o2;
|
|
break;
|
|
|
|
case '-':
|
|
o1 -= o2;
|
|
if (expp->nd_type->tp_fund == T_INTORCARD) {
|
|
if (o1 < 0) expp->nd_type = int_type;
|
|
}
|
|
break;
|
|
|
|
case '<':
|
|
{ arith tmp = o1;
|
|
|
|
o1 = o2;
|
|
o2 = tmp;
|
|
}
|
|
/* Fall through */
|
|
|
|
case '>':
|
|
if (uns) {
|
|
o1 = (o1 & mach_long_sign ?
|
|
(o2 & mach_long_sign ? o1 > o2 : 1) :
|
|
(o2 & mach_long_sign ? 0 : o1 > o2)
|
|
);
|
|
}
|
|
else
|
|
o1 = (o1 > o2);
|
|
break;
|
|
|
|
case LESSEQUAL:
|
|
{ arith tmp = o1;
|
|
|
|
o1 = o2;
|
|
o2 = tmp;
|
|
}
|
|
/* Fall through */
|
|
|
|
case GREATEREQUAL:
|
|
if (uns) {
|
|
o1 = (o1 & mach_long_sign ?
|
|
(o2 & mach_long_sign ? o1 >= o2 : 1) :
|
|
(o2 & mach_long_sign ? 0 : o1 >= o2)
|
|
);
|
|
}
|
|
else
|
|
o1 = (o1 >= o2);
|
|
break;
|
|
|
|
case '=':
|
|
o1 = (o1 == o2);
|
|
break;
|
|
|
|
case '#':
|
|
o1 = (o1 != o2);
|
|
break;
|
|
|
|
case AND:
|
|
case '&':
|
|
o1 = (o1 && o2);
|
|
break;
|
|
|
|
case OR:
|
|
o1 = (o1 || o2);
|
|
break;
|
|
|
|
default:
|
|
crash("(cstbin)");
|
|
}
|
|
|
|
expp->nd_class = Value;
|
|
expp->nd_token = expp->nd_right->nd_token;
|
|
if (expp->nd_type == bool_type) expp->nd_symb = INTEGER;
|
|
expp->nd_INT = o1;
|
|
CutSize(expp);
|
|
FreeNode(expp->nd_left);
|
|
FreeNode(expp->nd_right);
|
|
expp->nd_left = expp->nd_right = 0;
|
|
}
|
|
|
|
cstset(expp)
|
|
register struct node *expp;
|
|
{
|
|
register arith *set1, *set2;
|
|
arith *resultset = 0;
|
|
register int setsize, j;
|
|
|
|
assert(expp->nd_right->nd_class == Set);
|
|
assert(expp->nd_symb == IN || expp->nd_left->nd_class == Set);
|
|
set2 = expp->nd_right->nd_set;
|
|
setsize = expp->nd_right->nd_type->tp_size / word_size;
|
|
|
|
if (expp->nd_symb == IN) {
|
|
arith i;
|
|
|
|
assert(expp->nd_left->nd_class == Value);
|
|
|
|
i = expp->nd_left->nd_INT;
|
|
expp->nd_class = Value;
|
|
expp->nd_INT = (i >= 0 && set2 != 0 &&
|
|
i < setsize * wrd_bits &&
|
|
(set2[i / wrd_bits] & (1 << (i % wrd_bits))));
|
|
if (set2) free((char *) set2);
|
|
}
|
|
else {
|
|
set1 = expp->nd_left->nd_set;
|
|
resultset = set1;
|
|
expp->nd_left->nd_set = 0;
|
|
switch(expp->nd_symb) {
|
|
case '+':
|
|
/* Set union
|
|
*/
|
|
if (!set1) {
|
|
resultset = set2;
|
|
expp->nd_right->nd_set = 0;
|
|
break;
|
|
}
|
|
if (set2) for (j = 0; j < setsize; j++) {
|
|
*set1++ |= *set2++;
|
|
}
|
|
break;
|
|
|
|
case '-':
|
|
/* Set difference
|
|
*/
|
|
if (!set1 || !set2) {
|
|
/* The set from which something is substracted
|
|
is already empty, or the set that is
|
|
substracted is empty. In either case, the
|
|
result set is set1.
|
|
*/
|
|
break;
|
|
}
|
|
for (j = 0; j < setsize; j++) {
|
|
*set1++ &= ~*set2++;
|
|
}
|
|
break;
|
|
|
|
case '*':
|
|
/* Set intersection
|
|
*/
|
|
if (!set1) {
|
|
/* set1 is empty, and so is the result set
|
|
*/
|
|
break;
|
|
}
|
|
if (!set2) {
|
|
/* set 2 is empty, so the result set must be
|
|
empty too.
|
|
*/
|
|
resultset = set2;
|
|
expp->nd_right->nd_set = 0;
|
|
break;
|
|
}
|
|
for (j = 0; j < setsize; j++) {
|
|
*set1++ &= *set2++;
|
|
}
|
|
break;
|
|
|
|
case '/':
|
|
/* Symmetric set difference
|
|
*/
|
|
if (!set1) {
|
|
resultset = set2;
|
|
expp->nd_right->nd_set = 0;
|
|
break;
|
|
}
|
|
if (set2) {
|
|
for (j = 0; j < setsize; j++) {
|
|
*set1++ ^= *set2++;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case GREATEREQUAL:
|
|
case LESSEQUAL:
|
|
case '=':
|
|
case '#':
|
|
/* Constant set comparisons
|
|
*/
|
|
expp->nd_left->nd_set = set1; /* may be disposed of */
|
|
for (j = 0; j < setsize; j++) {
|
|
switch(expp->nd_symb) {
|
|
case GREATEREQUAL:
|
|
if (!set2) {j = setsize; break; }
|
|
if (!set1) break;
|
|
if ((*set1 | *set2++) != *set1) break;
|
|
set1++;
|
|
continue;
|
|
case LESSEQUAL:
|
|
if (!set1) {j = setsize; break; }
|
|
if (!set2) break;
|
|
if ((*set2 | *set1++) != *set2) break;
|
|
set2++;
|
|
continue;
|
|
case '=':
|
|
case '#':
|
|
if (!set1 && !set2) {
|
|
j = setsize; break;
|
|
}
|
|
if (!set1 || !set2) break;
|
|
if (*set1++ != *set2++) break;
|
|
continue;
|
|
}
|
|
if (j < setsize) {
|
|
expp->nd_INT = expp->nd_symb == '#';
|
|
}
|
|
else {
|
|
expp->nd_INT = expp->nd_symb != '#';
|
|
}
|
|
break;
|
|
}
|
|
expp->nd_class = Value;
|
|
expp->nd_symb = INTEGER;
|
|
if (expp->nd_left->nd_set) {
|
|
free((char *) expp->nd_left->nd_set);
|
|
}
|
|
if (expp->nd_right->nd_set) {
|
|
free((char *) expp->nd_right->nd_set);
|
|
}
|
|
FreeNode(expp->nd_left);
|
|
FreeNode(expp->nd_right);
|
|
expp->nd_left = expp->nd_right = 0;
|
|
return;
|
|
default:
|
|
crash("(cstset)");
|
|
}
|
|
if (expp->nd_right->nd_set) {
|
|
free((char *) expp->nd_right->nd_set);
|
|
}
|
|
if (expp->nd_left->nd_set) {
|
|
free((char *) expp->nd_left->nd_set);
|
|
}
|
|
expp->nd_class = Set;
|
|
expp->nd_set = resultset;
|
|
}
|
|
FreeNode(expp->nd_left);
|
|
FreeNode(expp->nd_right);
|
|
expp->nd_left = expp->nd_right = 0;
|
|
}
|
|
|
|
cstcall(expp, call)
|
|
register struct node *expp;
|
|
{
|
|
/* a standard procedure call is found that can be evaluated
|
|
compile time, so do so.
|
|
*/
|
|
register struct node *expr = 0;
|
|
|
|
assert(expp->nd_class == Call);
|
|
|
|
if (expp->nd_right) {
|
|
expr = expp->nd_right->nd_left;
|
|
expp->nd_right->nd_left = 0;
|
|
FreeNode(expp->nd_right);
|
|
}
|
|
|
|
expp->nd_class = Value;
|
|
expp->nd_symb = INTEGER;
|
|
switch(call) {
|
|
case S_ABS:
|
|
if (expr->nd_INT < 0) expp->nd_INT = - expr->nd_INT;
|
|
else expp->nd_INT = expr->nd_INT;
|
|
CutSize(expp);
|
|
break;
|
|
|
|
case S_CAP:
|
|
if (expr->nd_INT >= 'a' && expr->nd_INT <= 'z') {
|
|
expp->nd_INT = expr->nd_INT + ('A' - 'a');
|
|
}
|
|
else expp->nd_INT = expr->nd_INT;
|
|
CutSize(expp);
|
|
break;
|
|
|
|
case S_CHR:
|
|
expp->nd_INT = expr->nd_INT;
|
|
CutSize(expp);
|
|
break;
|
|
|
|
case S_MAX:
|
|
if (expp->nd_type == int_type) {
|
|
expp->nd_INT = max_int;
|
|
}
|
|
else if (expp->nd_type == longint_type) {
|
|
expp->nd_INT = max_longint;
|
|
}
|
|
else if (expp->nd_type == card_type) {
|
|
expp->nd_INT = max_unsigned;
|
|
}
|
|
else if (expp->nd_type->tp_fund == T_SUBRANGE) {
|
|
expp->nd_INT = expp->nd_type->sub_ub;
|
|
}
|
|
else expp->nd_INT = expp->nd_type->enm_ncst - 1;
|
|
break;
|
|
|
|
case S_MIN:
|
|
if (expp->nd_type == int_type) {
|
|
expp->nd_INT = (-max_int) - 1;
|
|
}
|
|
else if (expp->nd_type == longint_type) {
|
|
expp->nd_INT = (-max_longint) - 1;
|
|
}
|
|
else if (expp->nd_type->tp_fund == T_SUBRANGE) {
|
|
expp->nd_INT = expp->nd_type->sub_lb;
|
|
}
|
|
else expp->nd_INT = 0;
|
|
break;
|
|
|
|
case S_ODD:
|
|
expp->nd_INT = (expr->nd_INT & 1);
|
|
break;
|
|
|
|
case S_ORD:
|
|
expp->nd_INT = expr->nd_INT;
|
|
CutSize(expp);
|
|
break;
|
|
|
|
case S_SIZE:
|
|
expp->nd_INT = WA(expr->nd_type->tp_size);
|
|
break;
|
|
|
|
case S_VAL:
|
|
expp->nd_INT = expr->nd_INT;
|
|
if ( /* Check overflow of subranges or enumerations */
|
|
( expp->nd_type->tp_fund == T_SUBRANGE
|
|
&&
|
|
( expp->nd_INT < expp->nd_type->sub_lb
|
|
|| expp->nd_INT > expp->nd_type->sub_ub
|
|
)
|
|
)
|
|
||
|
|
( expp->nd_type->tp_fund == T_ENUMERATION
|
|
&&
|
|
( expp->nd_INT < 0
|
|
|| expp->nd_INT >= expp->nd_type->enm_ncst
|
|
)
|
|
)
|
|
) node_warning(expp,"overflow in constant expression");
|
|
else CutSize(expp);
|
|
break;
|
|
|
|
default:
|
|
crash("(cstcall)");
|
|
}
|
|
FreeNode(expr);
|
|
FreeNode(expp->nd_left);
|
|
expp->nd_right = expp->nd_left = 0;
|
|
}
|
|
|
|
CutSize(expr)
|
|
register struct node *expr;
|
|
{
|
|
/* The constant value of the expression expr is made to
|
|
conform to the size of the type of the expression.
|
|
*/
|
|
register arith o1 = expr->nd_INT;
|
|
register struct type *tp = BaseType(expr->nd_type);
|
|
int uns;
|
|
int size = tp->tp_size;
|
|
|
|
assert(expr->nd_class == Value);
|
|
uns = (tp->tp_fund & (T_CARDINAL|T_CHAR));
|
|
if (uns) {
|
|
if (o1 & ~full_mask[size]) {
|
|
node_warning(expr,
|
|
"overflow in constant expression");
|
|
o1 &= full_mask[size];
|
|
}
|
|
}
|
|
else {
|
|
int nbits = (int) (mach_long_size - size) * 8;
|
|
long remainder = o1 & ~full_mask[size];
|
|
|
|
if (remainder != 0 && remainder != ~full_mask[size]) {
|
|
node_warning(expr, "overflow in constant expression");
|
|
o1 <<= nbits;
|
|
o1 >>= nbits;
|
|
}
|
|
}
|
|
expr->nd_INT = o1;
|
|
}
|
|
|
|
InitCst()
|
|
{
|
|
register int i = 0;
|
|
register arith bt = (arith)0;
|
|
|
|
while (!(bt < 0)) {
|
|
bt = (bt << 8) + 0377, i++;
|
|
if (i == MAXSIZE)
|
|
fatal("array full_mask too small for this machine");
|
|
full_mask[i] = bt;
|
|
}
|
|
mach_long_size = i;
|
|
mach_long_sign = 1 << (mach_long_size * 8 - 1);
|
|
if (long_size > mach_long_size) {
|
|
fatal("sizeof (long) insufficient on this machine");
|
|
}
|
|
|
|
max_int = full_mask[int_size] & ~(1 << (int_size * 8 - 1));
|
|
max_unsigned = full_mask[int_size];
|
|
max_longint = full_mask[long_size] & ~(1 << (long_size * 8 - 1));
|
|
wrd_bits = 8 * word_size;
|
|
}
|