001: /*
002: * ProGuard -- shrinking, optimization, obfuscation, and preverification
003: * of Java bytecode.
004: *
005: * Copyright (c) 2002-2007 Eric Lafortune (eric@graphics.cornell.edu)
006: *
007: * This program is free software; you can redistribute it and/or modify it
008: * under the terms of the GNU General Public License as published by the Free
009: * Software Foundation; either version 2 of the License, or (at your option)
010: * any later version.
011: *
012: * This program is distributed in the hope that it will be useful, but WITHOUT
013: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
014: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
015: * more details.
016: *
017: * You should have received a copy of the GNU General Public License along
018: * with this program; if not, write to the Free Software Foundation, Inc.,
019: * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020: */
021: package proguard.evaluation.value;
022:
023: import proguard.classfile.ClassConstants;
024:
025: /**
026: * This class represents a partially evaluated double value.
027: *
028: * @author Eric Lafortune
029: */
030: public class DoubleValue extends Category2Value {
031: /**
032: * Returns the specific double value, if applicable.
033: */
034: public double value() {
035: return 0.0;
036: }
037:
038: // Basic binary methods.
039:
040: /**
041: * Returns the generalization of this DoubleValue and the given other
042: * DoubleValue.
043: */
044: public DoubleValue generalize(DoubleValue other) {
045: return this ;
046: }
047:
048: /**
049: * Returns the sum of this DoubleValue and the given DoubleValue.
050: */
051: public DoubleValue add(DoubleValue other) {
052: return this ;
053: }
054:
055: /**
056: * Returns the difference of this DoubleValue and the given DoubleValue.
057: */
058: public DoubleValue subtract(DoubleValue other) {
059: return this ;
060: }
061:
062: /**
063: * Returns the difference of the given DoubleValue and this DoubleValue.
064: */
065: public DoubleValue subtractFrom(DoubleValue other) {
066: return this ;
067: }
068:
069: /**
070: * Returns the product of this DoubleValue and the given DoubleValue.
071: */
072: public DoubleValue multiply(DoubleValue other) {
073: return this ;
074: }
075:
076: /**
077: * Returns the quotient of this DoubleValue and the given DoubleValue.
078: */
079: public DoubleValue divide(DoubleValue other) {
080: return this ;
081: }
082:
083: /**
084: * Returns the quotient of the given DoubleValue and this DoubleValue.
085: */
086: public DoubleValue divideOf(DoubleValue other) {
087: return this ;
088: }
089:
090: /**
091: * Returns the remainder of this DoubleValue divided by the given DoubleValue.
092: */
093: public DoubleValue remainder(DoubleValue other) {
094: return this ;
095: }
096:
097: /**
098: * Returns the remainder of the given DoubleValue divided by this DoubleValue.
099: */
100: public DoubleValue remainderOf(DoubleValue other) {
101: return this ;
102: }
103:
104: /**
105: * Returns an IntegerValue with value -1, 0, or 1, if this DoubleValue is
106: * less than, equal to, or greater than the given DoubleValue, respectively.
107: */
108: public IntegerValue compare(DoubleValue other,
109: ValueFactory valueFactory) {
110: return valueFactory.createIntegerValue();
111: }
112:
113: // Derived binary methods.
114:
115: /**
116: * Returns an IntegerValue with value 1, 0, or -1, if this DoubleValue is
117: * less than, equal to, or greater than the given DoubleValue, respectively.
118: */
119: public final IntegerValue compareReverse(DoubleValue other,
120: ValueFactory valueFactory) {
121: return compare(other, valueFactory).negate();
122: }
123:
124: // Basic unary methods.
125:
126: /**
127: * Returns the negated value of this DoubleValue.
128: */
129: public DoubleValue negate() {
130: return this ;
131: }
132:
133: /**
134: * Converts this DoubleValue to an IntegerValue.
135: */
136: public IntegerValue convertToInteger(ValueFactory valueFactory) {
137: return valueFactory.createIntegerValue();
138: }
139:
140: /**
141: * Converts this DoubleValue to a LongValue.
142: */
143: public LongValue convertToLong(ValueFactory valueFactory) {
144: return valueFactory.createLongValue();
145: }
146:
147: /**
148: * Converts this DoubleValue to a FloatValue.
149: */
150: public FloatValue convertToFloat(ValueFactory valueFactory) {
151: return valueFactory.createFloatValue();
152: }
153:
154: // Similar binary methods, but this time with more specific arguments.
155:
156: /**
157: * Returns the generalization of this DoubleValue and the given other
158: * SpecificDoubleValue.
159: */
160: public DoubleValue generalize(SpecificDoubleValue other) {
161: return this ;
162: }
163:
164: /**
165: * Returns the sum of this DoubleValue and the given SpecificDoubleValue.
166: */
167: public DoubleValue add(SpecificDoubleValue other) {
168: return this ;
169: }
170:
171: /**
172: * Returns the difference of this DoubleValue and the given SpecificDoubleValue.
173: */
174: public DoubleValue subtract(SpecificDoubleValue other) {
175: return this ;
176: }
177:
178: /**
179: * Returns the difference of the given SpecificDoubleValue and this DoubleValue.
180: */
181: public DoubleValue subtractFrom(SpecificDoubleValue other) {
182: return this ;
183: }
184:
185: /**
186: * Returns the product of this DoubleValue and the given SpecificDoubleValue.
187: */
188: public DoubleValue multiply(SpecificDoubleValue other) {
189: return this ;
190: }
191:
192: /**
193: * Returns the quotient of this DoubleValue and the given SpecificDoubleValue.
194: */
195: public DoubleValue divide(SpecificDoubleValue other) {
196: return this ;
197: }
198:
199: /**
200: * Returns the quotient of the given SpecificDoubleValue and this
201: * DoubleValue.
202: */
203: public DoubleValue divideOf(SpecificDoubleValue other) {
204: return this ;
205: }
206:
207: /**
208: * Returns the remainder of this DoubleValue divided by the given
209: * SpecificDoubleValue.
210: */
211: public DoubleValue remainder(SpecificDoubleValue other) {
212: return this ;
213: }
214:
215: /**
216: * Returns the remainder of the given SpecificDoubleValue and this
217: * DoubleValue.
218: */
219: public DoubleValue remainderOf(SpecificDoubleValue other) {
220: return this ;
221: }
222:
223: /**
224: * Returns an IntegerValue with value -1, 0, or 1, if this DoubleValue is
225: * less than, equal to, or greater than the given SpecificDoubleValue,
226: * respectively.
227: */
228: public IntegerValue compare(SpecificDoubleValue other,
229: ValueFactory valueFactory) {
230: return valueFactory.createIntegerValue();
231: }
232:
233: // Derived binary methods.
234:
235: /**
236: * Returns an IntegerValue with value 1, 0, or -1, if this DoubleValue is
237: * less than, equal to, or greater than the given SpecificDoubleValue,
238: * respectively.
239: */
240: public final IntegerValue compareReverse(SpecificDoubleValue other,
241: ValueFactory valueFactory) {
242: return compare(other, valueFactory).negate();
243: }
244:
245: // Implementations for Value.
246:
247: public final DoubleValue doubleValue() {
248: return this ;
249: }
250:
251: public final Value generalize(Value other) {
252: return this .generalize(other.doubleValue());
253: }
254:
255: public final int computationalType() {
256: return TYPE_DOUBLE;
257: }
258:
259: public final String internalType() {
260: return String.valueOf(ClassConstants.INTERNAL_TYPE_DOUBLE);
261: }
262:
263: // Implementations for Object.
264:
265: public boolean equals(Object object) {
266: return object != null && this .getClass() == object.getClass();
267: }
268:
269: public int hashCode() {
270: return this .getClass().hashCode();
271: }
272:
273: public String toString() {
274: return "d";
275: }
276: }
|