Showing with 0 additions and 209 deletions.
  1. +0 −10 src/ctfe.h
  2. +0 −199 src/ctfeexpr.d
10 changes: 0 additions & 10 deletions src/ctfe.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -235,16 +235,6 @@ Expression *findKeyInAA(Loc loc, AssocArrayLiteralExp *ae, Expression *e2);
/// True if type is TypeInfo_Class
bool isTypeInfo_Class(Type *type);

/***********************************************
In-place integer operations
***********************************************/

/// e = OP e
void intUnary(TOK op, IntegerExp *e);

/// dest = e1 OP e2;
void intBinary(TOK op, IntegerExp *dest, Type *type, IntegerExp *e1, IntegerExp *e2);


/***********************************************
COW const-folding operations
Expand Down
199 changes: 0 additions & 199 deletions src/ctfeexpr.d
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1005,205 +1005,6 @@ extern (C++) Expression paintFloatInt(Expression fromVal, Type to)
return Target.paintAsType(fromVal, to);
}

/***********************************************
Primitive integer operations
***********************************************/
/** e = OP e
*/
extern (C++) void intUnary(TOK op, IntegerExp e)
{
switch (op)
{
case TOKneg:
e.setInteger(-e.getInteger());
break;
case TOKtilde:
e.setInteger(~e.getInteger());
break;
default:
assert(0);
}
}

/** dest = e1 OP e2;
*/
extern (C++) void intBinary(TOK op, IntegerExp dest, Type type, IntegerExp e1, IntegerExp e2)
{
dinteger_t result;
switch (op)
{
case TOKand:
result = e1.getInteger() & e2.getInteger();
break;
case TOKor:
result = e1.getInteger() | e2.getInteger();
break;
case TOKxor:
result = e1.getInteger() ^ e2.getInteger();
break;
case TOKadd:
result = e1.getInteger() + e2.getInteger();
break;
case TOKmin:
result = e1.getInteger() - e2.getInteger();
break;
case TOKmul:
result = e1.getInteger() * e2.getInteger();
break;
case TOKdiv:
{
sinteger_t n1 = e1.getInteger();
sinteger_t n2 = e2.getInteger();
if (n2 == 0)
{
e2.error("divide by 0");
result = 1;
}
else if (e1.type.isunsigned() || e2.type.isunsigned())
result = (cast(dinteger_t)n1) / (cast(dinteger_t)n2);
else
result = n1 / n2;
break;
}
case TOKmod:
{
sinteger_t n1 = e1.getInteger();
sinteger_t n2 = e2.getInteger();
if (n2 == 0)
{
e2.error("divide by 0");
n2 = 1;
}
if (n2 == -1 && !type.isunsigned())
{
// Check for int.min % -1
if (n1 == 0xFFFFFFFF80000000UL && type.toBasetype().ty != Tint64)
{
e2.error("integer overflow: int.min % -1");
n2 = 1;
}
else if (n1 == 0x8000000000000000L) // long.min % -1
{
e2.error("integer overflow: long.min % -1");
n2 = 1;
}
}
if (e1.type.isunsigned() || e2.type.isunsigned())
result = (cast(dinteger_t)n1) % (cast(dinteger_t)n2);
else
result = n1 % n2;
break;
}
case TOKpow:
{
dinteger_t n = e2.getInteger();
if (!e2.type.isunsigned() && cast(sinteger_t)n < 0)
{
e2.error("integer ^^ -integer: total loss of precision");
n = 1;
}
uinteger_t r = e1.getInteger();
result = 1;
while (n != 0)
{
if (n & 1)
result = result * r;
n >>= 1;
r = r * r;
}
break;
}
case TOKshl:
result = e1.getInteger() << e2.getInteger();
break;
case TOKshr:
{
dinteger_t value = e1.getInteger();
dinteger_t dcount = e2.getInteger();
assert(dcount <= 0xFFFFFFFF);
uint count = cast(uint)dcount;
switch (e1.type.toBasetype().ty)
{
case Tint8:
result = cast(d_int8)value >> count;
break;
case Tuns8:
case Tchar:
result = cast(d_uns8)value >> count;
break;
case Tint16:
result = cast(d_int16)value >> count;
break;
case Tuns16:
case Twchar:
result = cast(d_uns16)value >> count;
break;
case Tint32:
result = cast(d_int32)value >> count;
break;
case Tuns32:
case Tdchar:
result = cast(d_uns32)value >> count;
break;
case Tint64:
result = cast(d_int64)value >> count;
break;
case Tuns64:
result = cast(d_uns64)value >> count;
break;
default:
assert(0);
}
break;
}
case TOKushr:
{
dinteger_t value = e1.getInteger();
dinteger_t dcount = e2.getInteger();
assert(dcount <= 0xFFFFFFFF);
uint count = cast(uint)dcount;
switch (e1.type.toBasetype().ty)
{
case Tint8:
case Tuns8:
case Tchar:
// Possible only with >>>=. >>> always gets promoted to int.
result = (value & 0xFF) >> count;
break;
case Tint16:
case Tuns16:
case Twchar:
// Possible only with >>>=. >>> always gets promoted to int.
result = (value & 0xFFFF) >> count;
break;
case Tint32:
case Tuns32:
case Tdchar:
result = (value & 0xFFFFFFFF) >> count;
break;
case Tint64:
case Tuns64:
result = cast(d_uns64)value >> count;
break;
default:
assert(0);
}
break;
}
case TOKequal:
case TOKidentity:
result = (e1.getInteger() == e2.getInteger());
break;
case TOKnotequal:
case TOKnotidentity:
result = (e1.getInteger() != e2.getInteger());
break;
default:
assert(0);
}
dest.setInteger(result);
dest.type = type;
}

/******** Constant folding, with support for CTFE ***************************/
/// Return true if non-pointer expression e can be compared
Expand Down