/*
* @(#) $(JCGO)/jtrsrc/com/ivmaisoft/jcgo/ConstValue.java --
* a part of JCGO translator.
**
* Project: JCGO (http://www.ivmaisoft.com/jcgo/)
* Copyright (C) 2001-2012 Ivan Maidanski <ivmai@mail.ru>
* All rights reserved.
*/
/*
* This is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
**
* This software is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License (GPL) for more details.
**
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
**
* As a special exception, the copyright holders of this library give you
* permission to link this library with independent modules to produce an
* executable, regardless of the license terms of these independent
* modules, and to copy and distribute the resulting executable under
* terms of your choice, provided that you also meet, for each linked
* independent module, the terms and conditions of the license of that
* module. An independent module is a module which is not derived from
* or based on this library. If you modify this library, you may extend
* this exception to your version of the library, but you are not
* obligated to do so. If you do not wish to do so, delete this
* exception statement from your version.
*/
package com.ivmaisoft.jcgo;
/**
* This class represents exact value of a java constant expression.
*/
final class ConstValue {
private static final ConstValue LONG_ZERO = new ConstValue(0, 0);
private/* final */int low;
private/* final */int high;
private/* final */boolean isLong;
ConstValue(boolean boolValue) {
high = low = boolValue ? -1 : 0;
isLong = false;
}
ConstValue(int intValue) {
low = intValue;
high = intValue < 0 ? -1 : 0;
isLong = false;
}
ConstValue(int low, int high) {
this.low = low;
this.high = high;
this.isLong = true;
}
private ConstValue(int low, int high, boolean isLong) {
this.low = low;
this.high = high;
this.isLong = isLong;
}
ConstValue(String str) {
char ch;
boolean isLong = false;
if (str.length() > 0
&& ((ch = str.charAt(str.length() - 1)) == 'L' || ch == 'l')) {
str = str.substring(0, str.length() - 1);
isLong = true;
}
int radix = 10;
if (str.length() > 1 && str.charAt(0) == '0') {
radix = 8;
if (str.charAt(1) == 'x' || str.charAt(1) == 'X') {
radix = 16;
str = str.substring(2);
}
}
int len = str.length();
int low = 0;
int high = 0;
for (int i = 0; i < len; i++) {
ch = str.charAt(i);
int digit = radix;
if (ch >= '0' && ch <= '9') {
digit = ch - '0';
} else if (ch >= 'A' && ch <= 'Z') {
digit = ch - ('A' - 10);
} else if (ch >= 'a' && ch <= 'z') {
digit = ch - ('a' - 10);
}
if (digit >= radix)
break;
if (isLong) {
high = mulHigh(low, radix) + high * radix;
}
low = low * radix + digit;
if (low < digit && low >= 0) {
high++;
}
}
this.low = low;
this.high = isLong ? high : low < 0 ? -1 : 0;
this.isLong = isLong;
}
boolean isLong() {
return isLong;
}
boolean isNeg() {
return high < 0;
}
boolean isNonZero() {
return (low | high) != 0;
}
boolean isMinusOne() {
return (low & high) == -1;
}
int getIntValue() {
return low;
}
ConstValue castTo(int type) {
if (type == Type.BOOLEAN)
return this;
if (type == Type.BYTE)
return new ConstValue((byte) low);
if (type == Type.CHAR)
return new ConstValue((char) low);
if (type == Type.SHORT)
return new ConstValue((short) low);
if (type == Type.INT)
return isLong ? new ConstValue(low) : this;
if (type == Type.LONG)
return castToLong();
return null;
}
ConstValue neg() {
return isLong ? new ConstValue(-low, low != 0 ? ~high : -high)
: new ConstValue(-low);
}
ConstValue bitNot() {
return new ConstValue(~low, ~high, isLong);
}
ConstValue bitAnd(ConstValue value) {
return value != null ? new ConstValue(low & value.low, high
& value.high, isLong || value.isLong) : null;
}
ConstValue bitOr(ConstValue value) {
return value != null ? new ConstValue(low | value.low, high
| value.high, isLong || value.isLong) : null;
}
ConstValue bitXor(ConstValue value) {
return value != null ? new ConstValue(low ^ value.low, high
^ value.high, isLong || value.isLong) : null;
}
ConstValue isEqual(ConstValue value) {
return value != null ? new ConstValue(low == value.low
&& high == value.high) : null;
}
ConstValue isLessThan(ConstValue value) {
return value != null ? new ConstValue(high < value.high
|| (high == value.high && ((low ^ value.low) >= 0 ? low
- value.low : value.low) < 0)) : null;
}
ConstValue isLessOrEqual(ConstValue value) {
return value != null ? new ConstValue(high < value.high
|| (high == value.high && ((low ^ value.low) >= 0 ? value.low
- low : low) >= 0)) : null;
}
private ConstValue castToLong() {
return isLong ? this : new ConstValue(low, high);
}
private ConstValue plus(ConstValue value) {
if (value != null) {
int resLow = low + value.low;
if (!isLong && !value.isLong)
return new ConstValue(resLow);
int resHigh = high + value.high;
if (((resLow ^ low) >= 0 ? resLow - low : low) < 0) {
resHigh++;
}
value = new ConstValue(resLow, resHigh);
}
return value;
}
private ConstValue minus(ConstValue value) {
if (value != null) {
int resLow = low - value.low;
if (!isLong && !value.isLong)
return new ConstValue(resLow);
int resHigh = high - value.high;
if (((low ^ resLow) >= 0 ? low - resLow : resLow) < 0) {
resHigh--;
}
value = new ConstValue(resLow, resHigh);
}
return value;
}
private ConstValue times(ConstValue value) {
return value != null ? (isLong || value.isLong ? new ConstValue(low
* value.low, mulHigh(low, value.low) + low * value.high + high
* value.low) : new ConstValue(low * value.low)) : null;
}
private static int mulHigh(int valueA, int valueB) {
int highA = valueA >>> 16;
int highB = valueB >>> 16;
valueA &= 0xffff;
int lowB = valueB & 0xffff;
valueA = ((valueA * lowB) >>> 16) + valueA * highB;
lowB *= highA;
valueA += lowB;
highA = highA * highB + (valueA >>> 16);
if ((valueA ^ lowB) >= 0) {
lowB = valueA - lowB;
}
if (lowB < 0) {
highA += 0x10000;
}
return highA;
}
private ConstValue divide(ConstValue value) {
if (value != null) {
if (!isLong && !value.isLong)
return value.low != 0 ? new ConstValue(low / value.low) : null;
if (value.isNonZero()) {
ConstValue res = LONG_ZERO;
if (isNonZero()) {
ConstValue remainder = isNeg() ? castToLong().neg()
: castToLong();
ConstValue shiftedValue = value.isNeg() ? value
.castToLong().neg() : value.castToLong();
ConstValue one = new ConstValue(1, 0);
ConstValue shiftedOne = one;
while (!shiftedValue.isNeg()) {
shiftedValue = shiftedValue.shiftLeft(one);
shiftedOne = shiftedOne.shiftLeft(one);
}
do {
if (shiftedValue.isNeg() ? shiftedValue.isEqual(
remainder).isNonZero() : shiftedValue
.isLessOrEqual(remainder).isNonZero()
|| remainder.isNeg()) {
remainder = remainder.minus(shiftedValue);
res = res.plus(shiftedOne);
if (!remainder.isNonZero())
break;
}
shiftedOne = shiftedOne.fillShiftRight(one);
if (!shiftedOne.isNonZero())
break;
shiftedValue = shiftedValue.fillShiftRight(one);
} while (true);
if (isNeg() != value.isNeg()) {
res = res.neg();
}
}
return res;
}
}
return null;
}
private ConstValue mod(ConstValue value) {
ConstValue value2 = divide(value);
return value2 != null ? minus(value2.times(value)) : null;
}
private ConstValue shiftLeft(ConstValue value) {
return value != null ? (isLong ? ((value.low & 0x20) != 0 ? new ConstValue(
0, low << value.low) : new ConstValue(low << value.low,
((value.low & 0x1f) != 0 ? low >>> (-value.low) : 0)
| (high << value.low)))
: new ConstValue(low << value.low))
: null;
}
private ConstValue shiftRight(ConstValue value) {
return value != null ? (isLong ? ((value.low & 0x20) != 0 ? new ConstValue(
high >> value.low, high < 0 ? -1 : 0) : new ConstValue(
((value.low & 0x1f) != 0 ? high << (-value.low) : 0)
| (low >>> value.low), high >> value.low))
: new ConstValue(low >> value.low))
: null;
}
private ConstValue fillShiftRight(ConstValue value) {
return value != null ? (isLong ? ((value.low & 0x20) != 0 ? new ConstValue(
high >>> value.low, 0) : new ConstValue(
((value.low & 0x1f) != 0 ? high << (-value.low) : 0)
| (low >>> value.low), high >>> value.low))
: new ConstValue(low >>> value.low))
: null;
}
ConstValue comparisonOp(ConstValue value, int sym) {
if (value != null) {
if (sym == LexTerm.EQ)
return isEqual(value);
if (sym == LexTerm.NE)
return isEqual(value).bitNot();
if (sym == LexTerm.LT)
return isLessThan(value);
if (sym == LexTerm.LE)
return isLessOrEqual(value);
if (sym == LexTerm.GT)
return value.isLessThan(this);
if (sym == LexTerm.GE)
return value.isLessOrEqual(this);
}
return null;
}
ConstValue arithmeticOp(ConstValue value, int sym) {
if (value != null) {
if (sym == LexTerm.BITAND)
return bitAnd(value);
if (sym == LexTerm.BITOR)
return bitOr(value);
if (sym == LexTerm.XOR)
return bitXor(value);
if (sym == LexTerm.PLUS)
return plus(value);
if (sym == LexTerm.MINUS)
return minus(value);
if (sym == LexTerm.TIMES)
return times(value);
if (sym == LexTerm.DIVIDE)
return divide(value);
if (sym == LexTerm.MOD)
return mod(value);
if (sym == LexTerm.SHIFT_LEFT)
return shiftLeft(value);
if (sym == LexTerm.SHIFT_RIGHT)
return shiftRight(value);
if (sym == LexTerm.FILLSHIFT_RIGHT)
return fillShiftRight(value);
}
return null;
}
String outputBoolean() {
return LexTerm.outputBoolean(isNonZero());
}
String stringOutput() {
if (!isLong)
return low != 0 ? (low >= 0x1000000 || low <= -0x1000000 ? "(jint)0x"
+ Integer.toHexString(low) + "L"
: "(jint)" + Integer.toString(low)
+ (low >= 30000 || low <= -30000 ? "L" : ""))
: "0";
return "JLONG_C("
+ ((low < 0 ? high + 1 : high) != 0 || low >= 0x1000000
|| low <= -0x1000000 ? "0x"
+ (high != 0 ? Integer.toHexString(high)
+ toPaddedHex(low, false) : Integer
.toHexString(low)) : Integer.toString(low))
+ ")";
}
static String toPaddedHex(int intValue, boolean upperCase) {
char[] chars = new char[8];
int pos = 8;
while (pos-- > 0) {
chars[pos] = (char) (((intValue & 0xf) < 10 ? '0'
: upperCase ? 'A' - 10 : 'a' - 10) + (intValue & 0xf));
intValue >>>= 4;
}
return new String(chars);
}
}