|
From: <uck...@us...> - 2016-11-19 23:52:25
|
Revision: 9242
http://sourceforge.net/p/vassalengine/svn/9242
Author: uckelman
Date: 2016-11-19 23:52:20 +0000 (Sat, 19 Nov 2016)
Log Message:
-----------
Use valueOf for creating all of the classes which wrap primitives. This
lets us take advantage of immutable object caching.
Modified Paths:
--------------
VASSAL-src/trunk/src/VASSAL/build/module/ToolbarMenu.java
VASSAL-src/trunk/src/bsh/BSHLiteral.java
VASSAL-src/trunk/src/bsh/BSHUnaryExpression.java
VASSAL-src/trunk/src/bsh/JJTParserState.java
VASSAL-src/trunk/src/bsh/Parser.java
VASSAL-src/trunk/src/bsh/Primitive.java
VASSAL-src/trunk/src/bsh/This.java
VASSAL-src/trunk/src/bsh/XThis.java
VASSAL-src/trunk/src/bsh/bsh.jjt
Modified: VASSAL-src/trunk/src/VASSAL/build/module/ToolbarMenu.java
===================================================================
--- VASSAL-src/trunk/src/VASSAL/build/module/ToolbarMenu.java 2016-11-07 17:28:27 UTC (rev 9241)
+++ VASSAL-src/trunk/src/VASSAL/build/module/ToolbarMenu.java 2016-11-19 23:52:20 UTC (rev 9242)
@@ -216,7 +216,7 @@
Object property = b.getClientProperty(MENU_PROPERTY);
b.addPropertyChangeListener(this);
b.setVisible(false);
- b.putClientProperty(HIDDEN_BY_TOOLBAR, new Boolean(true));
+ b.putClientProperty(HIDDEN_BY_TOOLBAR, Boolean.TRUE);
if (property instanceof JPopupMenu) {
// This button corresponds to another ToolbarMenu button.
Modified: VASSAL-src/trunk/src/bsh/BSHLiteral.java
===================================================================
--- VASSAL-src/trunk/src/bsh/BSHLiteral.java 2016-11-07 17:28:27 UTC (rev 9241)
+++ VASSAL-src/trunk/src/bsh/BSHLiteral.java 2016-11-19 23:52:20 UTC (rev 9242)
@@ -97,7 +97,7 @@
ch = getEscapeChar(ch);
}
- value = new Primitive(new Character(ch).charValue());
+ value = new Primitive(Character.valueOf(ch).charValue());
}
void stringSetup(String str)
Modified: VASSAL-src/trunk/src/bsh/BSHUnaryExpression.java
===================================================================
--- VASSAL-src/trunk/src/bsh/BSHUnaryExpression.java 2016-11-07 17:28:27 UTC (rev 9241)
+++ VASSAL-src/trunk/src/bsh/BSHUnaryExpression.java 2016-11-19 23:52:20 UTC (rev 9242)
@@ -101,7 +101,7 @@
Object operand = Primitive.promoteToInteger(val);
if ( operand instanceof Boolean )
- return new Boolean(
+ return Boolean.valueOf(
Primitive.booleanUnaryOperation((Boolean)operand, kind));
else
if ( operand instanceof Integer )
@@ -112,21 +112,21 @@
if(kind == INCR || kind == DECR)
{
if(operandType == Byte.TYPE)
- return new Byte((byte)result);
+ return Byte.valueOf((byte)result);
if(operandType == Short.TYPE)
- return new Short((short)result);
+ return Short.valueOf((short)result);
if(operandType == Character.TYPE)
- return new Character((char)result);
+ return Character.valueOf((char)result);
}
- return new Integer(result);
+ return Integer.valueOf(result);
}
else if(operand instanceof Long)
- return new Long(Primitive.longUnaryOperation((Long)operand, kind));
+ return Long.valueOf(Primitive.longUnaryOperation((Long)operand, kind));
else if(operand instanceof Float)
- return new Float(Primitive.floatUnaryOperation((Float)operand, kind));
+ return Float.valueOf(Primitive.floatUnaryOperation((Float)operand, kind));
else if(operand instanceof Double)
- return new Double(Primitive.doubleUnaryOperation((Double)operand, kind));
+ return Double.valueOf(Primitive.doubleUnaryOperation((Double)operand, kind));
else
throw new InterpreterError("An error occurred. Please call technical support.");
}
Modified: VASSAL-src/trunk/src/bsh/JJTParserState.java
===================================================================
--- VASSAL-src/trunk/src/bsh/JJTParserState.java 2016-11-07 17:28:27 UTC (rev 9241)
+++ VASSAL-src/trunk/src/bsh/JJTParserState.java 2016-11-19 23:52:20 UTC (rev 9242)
@@ -75,7 +75,7 @@
void openNodeScope(Node n) {
- marks.push(new Integer(mk));
+ marks.push(Integer.valueOf(mk));
mk = sp;
n.jjtOpen();
}
Modified: VASSAL-src/trunk/src/bsh/Parser.java
===================================================================
--- VASSAL-src/trunk/src/bsh/Parser.java 2016-11-07 17:28:27 UTC (rev 9241)
+++ VASSAL-src/trunk/src/bsh/Parser.java 2016-11-19 23:52:20 UTC (rev 9242)
@@ -2325,14 +2325,14 @@
if(ch == 'f' || ch == 'F')
{
literal = literal.substring(0,literal.length()-1);
- jjtn000.value = new Primitive( new Float( literal ).floatValue() );
+ jjtn000.value = new Primitive( Float.valueOf( literal ).floatValue() );
}
else
{
if(ch == 'd' || ch == 'D')
literal = literal.substring(0,literal.length()-1);
- jjtn000.value = new Primitive( new Double( literal ).doubleValue() );
+ jjtn000.value = new Primitive( Double.valueOf( literal ).doubleValue() );
}
break;
case CHARACTER_LITERAL:
Modified: VASSAL-src/trunk/src/bsh/Primitive.java
===================================================================
--- VASSAL-src/trunk/src/bsh/Primitive.java 2016-11-07 17:28:27 UTC (rev 9241)
+++ VASSAL-src/trunk/src/bsh/Primitive.java 2016-11-19 23:52:20 UTC (rev 9242)
@@ -132,14 +132,14 @@
this.value = value;
}
- public Primitive(boolean value) { this(new Boolean(value)); }
- public Primitive(byte value) { this(new Byte(value)); }
- public Primitive(short value) { this(new Short(value)); }
- public Primitive(char value) { this(new Character(value)); }
- public Primitive(int value) { this(new Integer(value)); }
- public Primitive(long value) { this(new Long(value)); }
- public Primitive(float value) { this(new Float(value)); }
- public Primitive(double value) { this(new Double(value)); }
+ public Primitive(boolean value) { this(Boolean.valueOf(value)); }
+ public Primitive(byte value) { this(Byte.valueOf(value)); }
+ public Primitive(short value) { this(Short.valueOf(value)); }
+ public Primitive(char value) { this(Character.valueOf(value)); }
+ public Primitive(int value) { this(Integer.valueOf(value)); }
+ public Primitive(long value) { this(Long.valueOf(value)); }
+ public Primitive(float value) { this(Float.valueOf(value)); }
+ public Primitive(double value) { this(Double.valueOf(value)); }
/**
Return the primitive value stored in its java.lang wrapper class
@@ -268,18 +268,18 @@
switch(kind)
{
case EQ:
- return new Boolean(lhs == rhs);
+ return Boolean.valueOf(lhs == rhs);
case NE:
- return new Boolean(lhs != rhs);
+ return Boolean.valueOf(lhs != rhs);
case BOOL_OR:
case BOOL_ORX:
- return new Boolean( lhs || rhs );
+ return Boolean.valueOf( lhs || rhs );
case BOOL_AND:
case BOOL_ANDX:
- return new Boolean( lhs && rhs );
+ return Boolean.valueOf( lhs && rhs );
default:
throw new InterpreterError("unimplemented binary operator");
@@ -297,65 +297,65 @@
// boolean
case LT:
case LTX:
- return new Boolean(lhs < rhs);
+ return Boolean.valueOf(lhs < rhs);
case GT:
case GTX:
- return new Boolean(lhs > rhs);
+ return Boolean.valueOf(lhs > rhs);
case EQ:
- return new Boolean(lhs == rhs);
+ return Boolean.valueOf(lhs == rhs);
case LE:
case LEX:
- return new Boolean(lhs <= rhs);
+ return Boolean.valueOf(lhs <= rhs);
case GE:
case GEX:
- return new Boolean(lhs >= rhs);
+ return Boolean.valueOf(lhs >= rhs);
case NE:
- return new Boolean(lhs != rhs);
+ return Boolean.valueOf(lhs != rhs);
// arithmetic
case PLUS:
- return new Long(lhs + rhs);
+ return Long.valueOf(lhs + rhs);
case MINUS:
- return new Long(lhs - rhs);
+ return Long.valueOf(lhs - rhs);
case STAR:
- return new Long(lhs * rhs);
+ return Long.valueOf(lhs * rhs);
case SLASH:
- return new Long(lhs / rhs);
+ return Long.valueOf(lhs / rhs);
case MOD:
- return new Long(lhs % rhs);
+ return Long.valueOf(lhs % rhs);
// bitwise
case LSHIFT:
case LSHIFTX:
- return new Long(lhs << rhs);
+ return Long.valueOf(lhs << rhs);
case RSIGNEDSHIFT:
case RSIGNEDSHIFTX:
- return new Long(lhs >> rhs);
+ return Long.valueOf(lhs >> rhs);
case RUNSIGNEDSHIFT:
case RUNSIGNEDSHIFTX:
- return new Long(lhs >>> rhs);
+ return Long.valueOf(lhs >>> rhs);
case BIT_AND:
case BIT_ANDX:
- return new Long(lhs & rhs);
+ return Long.valueOf(lhs & rhs);
case BIT_OR:
case BIT_ORX:
- return new Long(lhs | rhs);
+ return Long.valueOf(lhs | rhs);
case XOR:
- return new Long(lhs ^ rhs);
+ return Long.valueOf(lhs ^ rhs);
default:
throw new InterpreterError(
@@ -374,65 +374,65 @@
// boolean
case LT:
case LTX:
- return new Boolean(lhs < rhs);
+ return Boolean.valueOf(lhs < rhs);
case GT:
case GTX:
- return new Boolean(lhs > rhs);
+ return Boolean.valueOf(lhs > rhs);
case EQ:
- return new Boolean(lhs == rhs);
+ return Boolean.valueOf(lhs == rhs);
case LE:
case LEX:
- return new Boolean(lhs <= rhs);
+ return Boolean.valueOf(lhs <= rhs);
case GE:
case GEX:
- return new Boolean(lhs >= rhs);
+ return Boolean.valueOf(lhs >= rhs);
case NE:
- return new Boolean(lhs != rhs);
+ return Boolean.valueOf(lhs != rhs);
// arithmetic
case PLUS:
- return new Integer(lhs + rhs);
+ return Integer.valueOf(lhs + rhs);
case MINUS:
- return new Integer(lhs - rhs);
+ return Integer.valueOf(lhs - rhs);
case STAR:
- return new Integer(lhs * rhs);
+ return Integer.valueOf(lhs * rhs);
case SLASH:
- return new Integer(lhs / rhs);
+ return Integer.valueOf(lhs / rhs);
case MOD:
- return new Integer(lhs % rhs);
+ return Integer.valueOf(lhs % rhs);
// bitwise
case LSHIFT:
case LSHIFTX:
- return new Integer(lhs << rhs);
+ return Integer.valueOf(lhs << rhs);
case RSIGNEDSHIFT:
case RSIGNEDSHIFTX:
- return new Integer(lhs >> rhs);
+ return Integer.valueOf(lhs >> rhs);
case RUNSIGNEDSHIFT:
case RUNSIGNEDSHIFTX:
- return new Integer(lhs >>> rhs);
+ return Integer.valueOf(lhs >>> rhs);
case BIT_AND:
case BIT_ANDX:
- return new Integer(lhs & rhs);
+ return Integer.valueOf(lhs & rhs);
case BIT_OR:
case BIT_ORX:
- return new Integer(lhs | rhs);
+ return Integer.valueOf(lhs | rhs);
case XOR:
- return new Integer(lhs ^ rhs);
+ return Integer.valueOf(lhs ^ rhs);
default:
throw new InterpreterError(
@@ -448,31 +448,31 @@
// boolean
case LT:
case LTX:
- return new Boolean(lhs.compareTo(rhs) < 0);
+ return Boolean.valueOf(lhs.compareTo(rhs) < 0);
case GT:
case GTX:
- return new Boolean(lhs.compareTo(rhs) > 0);
+ return Boolean.valueOf(lhs.compareTo(rhs) > 0);
case EQ:
- return new Boolean(lhs.equals(rhs));
+ return Boolean.valueOf(lhs.equals(rhs));
case LE:
case LEX:
- return new Boolean(lhs.compareTo(rhs) <= 0);
+ return Boolean.valueOf(lhs.compareTo(rhs) <= 0);
case GE:
case GEX:
- return new Boolean(lhs.compareTo(rhs) >= 0);
+ return Boolean.valueOf(lhs.compareTo(rhs) >= 0);
case NE:
- return new Boolean(!lhs.equals(rhs));
+ return Boolean.valueOf(!lhs.equals(rhs));
case PLUS:
return lhs + rhs;
case MATCH:
- return new Boolean(Pattern.matches(rhs, lhs));
+ return Boolean.valueOf(Pattern.matches(rhs, lhs));
default:
throw new InterpreterError(
@@ -492,41 +492,41 @@
// boolean
case LT:
case LTX:
- return new Boolean(lhs < rhs);
+ return Boolean.valueOf(lhs < rhs);
case GT:
case GTX:
- return new Boolean(lhs > rhs);
+ return Boolean.valueOf(lhs > rhs);
case EQ:
- return new Boolean(lhs == rhs);
+ return Boolean.valueOf(lhs == rhs);
case LE:
case LEX:
- return new Boolean(lhs <= rhs);
+ return Boolean.valueOf(lhs <= rhs);
case GE:
case GEX:
- return new Boolean(lhs >= rhs);
+ return Boolean.valueOf(lhs >= rhs);
case NE:
- return new Boolean(lhs != rhs);
+ return Boolean.valueOf(lhs != rhs);
// arithmetic
case PLUS:
- return new Double(lhs + rhs);
+ return Double.valueOf(lhs + rhs);
case MINUS:
- return new Double(lhs - rhs);
+ return Double.valueOf(lhs - rhs);
case STAR:
- return new Double(lhs * rhs);
+ return Double.valueOf(lhs * rhs);
case SLASH:
- return new Double(lhs / rhs);
+ return Double.valueOf(lhs / rhs);
case MOD:
- return new Double(lhs % rhs);
+ return Double.valueOf(lhs % rhs);
// can't shift floating-point values
case LSHIFT:
@@ -554,41 +554,41 @@
// boolean
case LT:
case LTX:
- return new Boolean(lhs < rhs);
+ return Boolean.valueOf(lhs < rhs);
case GT:
case GTX:
- return new Boolean(lhs > rhs);
+ return Boolean.valueOf(lhs > rhs);
case EQ:
- return new Boolean(lhs == rhs);
+ return Boolean.valueOf(lhs == rhs);
case LE:
case LEX:
- return new Boolean(lhs <= rhs);
+ return Boolean.valueOf(lhs <= rhs);
case GE:
case GEX:
- return new Boolean(lhs >= rhs);
+ return Boolean.valueOf(lhs >= rhs);
case NE:
- return new Boolean(lhs != rhs);
+ return Boolean.valueOf(lhs != rhs);
// arithmetic
case PLUS:
- return new Float(lhs + rhs);
+ return Float.valueOf(lhs + rhs);
case MINUS:
- return new Float(lhs - rhs);
+ return Float.valueOf(lhs - rhs);
case STAR:
- return new Float(lhs * rhs);
+ return Float.valueOf(lhs * rhs);
case SLASH:
- return new Float(lhs / rhs);
+ return Float.valueOf(lhs / rhs);
case MOD:
- return new Float(lhs % rhs);
+ return Float.valueOf(lhs % rhs);
// can't shift floats
case LSHIFT:
@@ -611,9 +611,9 @@
static Object promoteToInteger(Object wrapper )
{
if(wrapper instanceof Character)
- return new Integer(((Character)wrapper).charValue());
+ return Integer.valueOf(((Character)wrapper).charValue());
else if((wrapper instanceof Byte) || (wrapper instanceof Short))
- return new Integer(((Number)wrapper).intValue());
+ return Integer.valueOf(((Number)wrapper).intValue());
return wrapper;
}
@@ -637,23 +637,23 @@
if((b = (lnum instanceof Double)) || (rnum instanceof Double))
{
if(b)
- rhs = new Double(rnum.doubleValue());
+ rhs = Double.valueOf(rnum.doubleValue());
else
- lhs = new Double(lnum.doubleValue());
+ lhs = Double.valueOf(lnum.doubleValue());
}
else if((b = (lnum instanceof Float)) || (rnum instanceof Float))
{
if(b)
- rhs = new Float(rnum.floatValue());
+ rhs = Float.valueOf(rnum.floatValue());
else
- lhs = new Float(lnum.floatValue());
+ lhs = Float.valueOf(lnum.floatValue());
}
else if((b = (lnum instanceof Long)) || (rnum instanceof Long))
{
if(b)
- rhs = new Long(rnum.longValue());
+ rhs = Long.valueOf(rnum.longValue());
else
- lhs = new Long(lnum.longValue());
+ lhs = Long.valueOf(lnum.longValue());
}
}
@@ -819,7 +819,7 @@
// Promote character to Number type for these purposes
if (value instanceof Character)
- value = new Integer(((Character)value).charValue());
+ value = Integer.valueOf(((Character)value).charValue());
if (value instanceof Number)
return (Number)value;
@@ -1117,7 +1117,7 @@
// first promote char to Number type to avoid duplicating code
if ( value instanceof Character )
- value = new Integer(((Character)value).charValue());
+ value = Integer.valueOf(((Character)value).charValue());
if ( !(value instanceof Number) )
throw new InterpreterError("bad type in cast");
@@ -1125,19 +1125,19 @@
Number number = (Number)value;
if (toType == Byte.TYPE)
- return new Byte(number.byteValue());
+ return Byte.valueOf(number.byteValue());
if (toType == Short.TYPE)
- return new Short(number.shortValue());
+ return Short.valueOf(number.shortValue());
if (toType == Character.TYPE)
- return new Character((char)number.intValue());
+ return Character.valueOf((char)number.intValue());
if (toType == Integer.TYPE)
- return new Integer(number.intValue());
+ return Integer.valueOf(number.intValue());
if (toType == Long.TYPE)
- return new Long(number.longValue());
+ return Long.valueOf(number.longValue());
if (toType == Float.TYPE)
- return new Float(number.floatValue());
+ return Float.valueOf(number.floatValue());
if (toType == Double.TYPE)
- return new Double(number.doubleValue());
+ return Double.valueOf(number.doubleValue());
throw new InterpreterError("error in wrapper cast");
}
Modified: VASSAL-src/trunk/src/bsh/This.java
===================================================================
--- VASSAL-src/trunk/src/bsh/This.java 2016-11-07 17:28:27 UTC (rev 9241)
+++ VASSAL-src/trunk/src/bsh/This.java 2016-11-19 23:52:20 UTC (rev 9242)
@@ -269,12 +269,12 @@
// a default hashCode()
if ( methodName.equals("hashCode" ) )
- return new Integer(this.hashCode());
+ return Integer.valueOf(this.hashCode());
// a default equals() testing for equality with the This reference
if ( methodName.equals("equals" ) ) {
Object obj = args[0];
- return new Boolean( this == obj );
+ return Boolean.valueOf( this == obj );
}
// Look for a default invoke() handler method in the namespace
Modified: VASSAL-src/trunk/src/bsh/XThis.java
===================================================================
--- VASSAL-src/trunk/src/bsh/XThis.java 2016-11-07 17:28:27 UTC (rev 9241)
+++ VASSAL-src/trunk/src/bsh/XThis.java 2016-11-19 23:52:20 UTC (rev 9242)
@@ -95,7 +95,7 @@
int hash = 21;
for(int i=0; i<ca.length; i++)
hash *= ca[i].hashCode() + 3;
- Object hashKey = new Integer(hash);
+ Object hashKey = Integer.valueOf(hash);
Object interf = interfaces.get( hashKey );
@@ -165,7 +165,7 @@
} catch ( UtilEvalError e ) {/*leave null*/ }
if ( methodName.equals("equals" ) && equalsMethod == null ) {
Object obj = args[0];
- return new Boolean( proxy == obj );
+ return Boolean.valueOf( proxy == obj );
}
/*
Modified: VASSAL-src/trunk/src/bsh/bsh.jjt
===================================================================
--- VASSAL-src/trunk/src/bsh/bsh.jjt 2016-11-07 17:28:27 UTC (rev 9241)
+++ VASSAL-src/trunk/src/bsh/bsh.jjt 2016-11-19 23:52:20 UTC (rev 9242)
@@ -1050,14 +1050,14 @@
if(ch == 'f' || ch == 'F')
{
literal = literal.substring(0,literal.length()-1);
- jjtThis.value = new Primitive( new Float( literal ).floatValue() );
+ jjtThis.value = new Primitive( Float.valueOf( literal ).floatValue() );
}
else
{
if(ch == 'd' || ch == 'D')
literal = literal.substring(0,literal.length()-1);
- jjtThis.value = new Primitive( new Double( literal ).doubleValue() );
+ jjtThis.value = new Primitive( Double.valueOf( literal ).doubleValue() );
}
}
|
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
------------------------------------------------------------------------------
_______________________________________________
vassalengine-svn mailing list
vas...@li...
https://lists.sourceforge.net/lists/listinfo/vassalengine-svn
|
