001 /*****************************************************************************
002 * *
003 * This file is part of the BeanShell Java Scripting distribution. *
004 * Documentation and updates may be found at http://www.beanshell.org/ *
005 * *
006 * Sun Public License Notice: *
007 * *
008 * The contents of this file are subject to the Sun Public License Version *
009 * 1.0 (the "License"); you may not use this file except in compliance with *
010 * the License. A copy of the License is available at http://www.sun.com *
011 * *
012 * The Original Code is BeanShell. The Initial Developer of the Original *
013 * Code is Pat Niemeyer. Portions created by Pat Niemeyer are Copyright *
014 * (C) 2000. All Rights Reserved. *
015 * *
016 * GNU Public License Notice: *
017 * *
018 * Alternatively, the contents of this file may be used under the terms of *
019 * the GNU Lesser General Public License (the "LGPL"), in which case the *
020 * provisions of LGPL are applicable instead of those above. If you wish to *
021 * allow use of your version of this file only under the terms of the LGPL *
022 * and not to allow others to use your version of this file under the SPL, *
023 * indicate your decision by deleting the provisions above and replace *
024 * them with the notice and other provisions required by the LGPL. If you *
025 * do not delete the provisions above, a recipient may use your version of *
026 * this file under either the SPL or the LGPL. *
027 * *
028 * Patrick Niemeyer (pat@pat.net) *
029 * Author of Learning Java, O'Reilly & Associates *
030 * http://www.pat.net/~pat/ *
031 * *
032 *****************************************************************************/
033
034
035 package bsh;
036
037 import java.util.Hashtable;
038
039 /**
040 Wrapper for primitive types in Bsh. This is package public because it
041 is used in the implementation of some bsh commands.
042
043 See the note in LHS.java about wrapping objects.
044 */
045 /*
046 Note: this class is final because we may test == Primitive.class in places.
047 If we need to change that search for those tests.
048 */
049 public final class Primitive implements ParserConstants, java.io.Serializable
050 {
051 /*
052 static Hashtable primitiveToWrapper = new Hashtable();
053 static Hashtable wrapperToPrimitive = new Hashtable();
054 static {
055 primitiveToWrapper.put( Boolean.TYPE, Boolean.class );
056 primitiveToWrapper.put( Byte.TYPE, Byte.class );
057 primitiveToWrapper.put( Short.TYPE, Short.class );
058 primitiveToWrapper.put( Character.TYPE, Character.class );
059 primitiveToWrapper.put( Integer.TYPE, Integer.class );
060 primitiveToWrapper.put( Long.TYPE, Long.class );
061 primitiveToWrapper.put( Float.TYPE, Float.class );
062 primitiveToWrapper.put( Double.TYPE, Double.class );
063 wrapperToPrimitive.put( Boolean.class, Boolean.TYPE );
064 wrapperToPrimitive.put( Byte.class, Byte.TYPE );
065 wrapperToPrimitive.put( Short.class, Short.TYPE );
066 wrapperToPrimitive.put( Character.class, Character.TYPE );
067 wrapperToPrimitive.put( Integer.class, Integer.TYPE );
068 wrapperToPrimitive.put( Long.class, Long.TYPE );
069 wrapperToPrimitive.put( Float.class, Float.TYPE );
070 wrapperToPrimitive.put( Double.class, Double.TYPE );
071 }
072 */
073 static Hashtable wrapperMap = new Hashtable();
074 static {
075 wrapperMap.put( Boolean.TYPE, Boolean.class );
076 wrapperMap.put( Byte.TYPE, Byte.class );
077 wrapperMap.put( Short.TYPE, Short.class );
078 wrapperMap.put( Character.TYPE, Character.class );
079 wrapperMap.put( Integer.TYPE, Integer.class );
080 wrapperMap.put( Long.TYPE, Long.class );
081 wrapperMap.put( Float.TYPE, Float.class );
082 wrapperMap.put( Double.TYPE, Double.class );
083 wrapperMap.put( Boolean.class, Boolean.TYPE );
084 wrapperMap.put( Byte.class, Byte.TYPE );
085 wrapperMap.put( Short.class, Short.TYPE );
086 wrapperMap.put( Character.class, Character.TYPE );
087 wrapperMap.put( Integer.class, Integer.TYPE );
088 wrapperMap.put( Long.class, Long.TYPE );
089 wrapperMap.put( Float.class, Float.TYPE );
090 wrapperMap.put( Double.class, Double.TYPE );
091 }
092
093 /** The primitive value stored in its java.lang wrapper class */
094 private Object value;
095
096 private static class Special implements java.io.Serializable
097 {
098 private Special() { }
099
100 public static final Special NULL_VALUE = new Special();
101 public static final Special VOID_TYPE = new Special();
102 }
103
104 /*
105 NULL means "no value".
106 This ia a placeholder for primitive null value.
107 */
108 public static final Primitive NULL = new Primitive(Special.NULL_VALUE);
109
110 /**
111 VOID means "no type".
112 Strictly speaking, this makes no sense here. But for practical
113 reasons we'll consider the lack of a type to be a special value.
114 */
115 public static final Primitive VOID = new Primitive(Special.VOID_TYPE);
116
117 // private to prevent invocation with param that isn't a primitive-wrapper
118 public Primitive( Object value )
119 {
120 if ( value == null )
121 throw new InterpreterError(
122 "Use Primitve.NULL instead of Primitive(null)");
123
124 if ( value != Special.NULL_VALUE
125 && value != Special.VOID_TYPE &&
126 !isWrapperType( value.getClass() )
127 )
128 throw new InterpreterError( "Not a wrapper type: "+value);
129
130 this.value = value;
131 }
132
133 public Primitive(boolean value) { this(new Boolean(value)); }
134 public Primitive(byte value) { this(new Byte(value)); }
135 public Primitive(short value) { this(new Short(value)); }
136 public Primitive(char value) { this(new Character(value)); }
137 public Primitive(int value) { this(new Integer(value)); }
138 public Primitive(long value) { this(new Long(value)); }
139 public Primitive(float value) { this(new Float(value)); }
140 public Primitive(double value) { this(new Double(value)); }
141
142 /**
143 Return the primitive value stored in its java.lang wrapper class
144 */
145 public Object getValue()
146 {
147 if ( value == Special.NULL_VALUE )
148 return null;
149 else
150 if ( value == Special.VOID_TYPE )
151 throw new InterpreterError("attempt to unwrap void type");
152 else
153 return value;
154 }
155
156 public String toString()
157 {
158 if(value == Special.NULL_VALUE)
159 return "null";
160 else if(value == Special.VOID_TYPE)
161 return "void";
162 else
163 return value.toString();
164 }
165
166 /**
167 Get the corresponding Java primitive TYPE class for this Primitive.
168 @return the primitive TYPE class type of the value or Void.TYPE for
169 Primitive.VOID or null value for type of Primitive.NULL
170 */
171 public Class getType()
172 {
173 if ( this == Primitive.VOID )
174 return Void.TYPE;
175
176 // NULL return null as type... we currently use null type to indicate
177 // loose typing throughout bsh.
178 if ( this == Primitive.NULL )
179 return null;
180
181 return unboxType( value.getClass() );
182 }
183
184 /**
185 Perform a binary operation on two Primitives or wrapper types.
186 If both original args were Primitives return a Primitive result
187 else it was mixed (wrapper/primitive) return the wrapper type.
188 The exception is for boolean operations where we will return the
189 primitive type either way.
190 */
191 public static Object binaryOperation(
192 Object obj1, Object obj2, int kind)
193 throws UtilEvalError
194 {
195 // special primitive types
196 if ( obj1 == NULL || obj2 == NULL )
197 throw new UtilEvalError(
198 "Null value or 'null' literal in binary operation");
199 if ( obj1 == VOID || obj2 == VOID )
200 throw new UtilEvalError(
201 "Undefined variable, class, or 'void' literal in binary operation");
202
203 // keep track of the original types
204 Class lhsOrgType = obj1.getClass();
205 Class rhsOrgType = obj2.getClass();
206
207 // Unwrap primitives
208 if ( obj1 instanceof Primitive )
209 obj1 = ((Primitive)obj1).getValue();
210 if ( obj2 instanceof Primitive )
211 obj2 = ((Primitive)obj2).getValue();
212
213 Object[] operands = promotePrimitives(obj1, obj2);
214 Object lhs = operands[0];
215 Object rhs = operands[1];
216
217 if(lhs.getClass() != rhs.getClass())
218 throw new UtilEvalError("Type mismatch in operator. "
219 + lhs.getClass() + " cannot be used with " + rhs.getClass() );
220
221 Object result;
222 try {
223 result = binaryOperationImpl( lhs, rhs, kind );
224 } catch ( ArithmeticException e ) {
225 throw new UtilTargetError( "Arithemetic Exception in binary op", e);
226 }
227
228 // If both original args were Primitives return a Primitive result
229 // else it was mixed (wrapper/primitive) return the wrapper type
230 // Exception is for boolean result, return the primitive
231 if ( (lhsOrgType == Primitive.class && rhsOrgType == Primitive.class)
232 || result instanceof Boolean
233 )
234 return new Primitive( result );
235 else
236 return result;
237 }
238
239 static Object binaryOperationImpl( Object lhs, Object rhs, int kind )
240 throws UtilEvalError
241 {
242 if(lhs instanceof Boolean)
243 return booleanBinaryOperation((Boolean)lhs, (Boolean)rhs, kind);
244 else if(lhs instanceof Integer)
245 return intBinaryOperation( (Integer)lhs, (Integer)rhs, kind );
246 else if(lhs instanceof Long)
247 return longBinaryOperation((Long)lhs, (Long)rhs, kind);
248 else if(lhs instanceof Float)
249 return floatBinaryOperation((Float)lhs, (Float)rhs, kind);
250 else if(lhs instanceof Double)
251 return doubleBinaryOperation( (Double)lhs, (Double)rhs, kind);
252 else
253 throw new UtilEvalError("Invalid types in binary operator" );
254 }
255
256 static Boolean booleanBinaryOperation(Boolean B1, Boolean B2, int kind)
257 {
258 boolean lhs = B1.booleanValue();
259 boolean rhs = B2.booleanValue();
260
261 switch(kind)
262 {
263 case EQ:
264 return new Boolean(lhs == rhs);
265
266 case NE:
267 return new Boolean(lhs != rhs);
268
269 case BOOL_OR:
270 case BOOL_ORX:
271 return new Boolean( lhs || rhs );
272
273 case BOOL_AND:
274 case BOOL_ANDX:
275 return new Boolean( lhs && rhs );
276
277 default:
278 throw new InterpreterError("unimplemented binary operator");
279 }
280 }
281
282 // returns Object covering both Long and Boolean return types
283 static Object longBinaryOperation(Long L1, Long L2, int kind)
284 {
285 long lhs = L1.longValue();
286 long rhs = L2.longValue();
287
288 switch(kind)
289 {
290 // boolean
291 case LT:
292 case LTX:
293 return new Boolean(lhs < rhs);
294
295 case GT:
296 case GTX:
297 return new Boolean(lhs > rhs);
298
299 case EQ:
300 return new Boolean(lhs == rhs);
301
302 case LE:
303 case LEX:
304 return new Boolean(lhs <= rhs);
305
306 case GE:
307 case GEX:
308 return new Boolean(lhs >= rhs);
309
310 case NE:
311 return new Boolean(lhs != rhs);
312
313 // arithmetic
314 case PLUS:
315 return new Long(lhs + rhs);
316
317 case MINUS:
318 return new Long(lhs - rhs);
319
320 case STAR:
321 return new Long(lhs * rhs);
322
323 case SLASH:
324 return new Long(lhs / rhs);
325
326 case MOD:
327 return new Long(lhs % rhs);
328
329 // bitwise
330 case LSHIFT:
331 case LSHIFTX:
332 return new Long(lhs << rhs);
333
334 case RSIGNEDSHIFT:
335 case RSIGNEDSHIFTX:
336 return new Long(lhs >> rhs);
337
338 case RUNSIGNEDSHIFT:
339 case RUNSIGNEDSHIFTX:
340 return new Long(lhs >>> rhs);
341
342 case BIT_AND:
343 case BIT_ANDX:
344 return new Long(lhs & rhs);
345
346 case BIT_OR:
347 case BIT_ORX:
348 return new Long(lhs | rhs);
349
350 case XOR:
351 return new Long(lhs ^ rhs);
352
353 default:
354 throw new InterpreterError(
355 "Unimplemented binary long operator");
356 }
357 }
358
359 // returns Object covering both Integer and Boolean return types
360 static Object intBinaryOperation(Integer I1, Integer I2, int kind)
361 {
362 int lhs = I1.intValue();
363 int rhs = I2.intValue();
364
365 switch(kind)
366 {
367 // boolean
368 case LT:
369 case LTX:
370 return new Boolean(lhs < rhs);
371
372 case GT:
373 case GTX:
374 return new Boolean(lhs > rhs);
375
376 case EQ:
377 return new Boolean(lhs == rhs);
378
379 case LE:
380 case LEX:
381 return new Boolean(lhs <= rhs);
382
383 case GE:
384 case GEX:
385 return new Boolean(lhs >= rhs);
386
387 case NE:
388 return new Boolean(lhs != rhs);
389
390 // arithmetic
391 case PLUS:
392 return new Integer(lhs + rhs);
393
394 case MINUS:
395 return new Integer(lhs - rhs);
396
397 case STAR:
398 return new Integer(lhs * rhs);
399
400 case SLASH:
401 return new Integer(lhs / rhs);
402
403 case MOD:
404 return new Integer(lhs % rhs);
405
406 // bitwise
407 case LSHIFT:
408 case LSHIFTX:
409 return new Integer(lhs << rhs);
410
411 case RSIGNEDSHIFT:
412 case RSIGNEDSHIFTX:
413 return new Integer(lhs >> rhs);
414
415 case RUNSIGNEDSHIFT:
416 case RUNSIGNEDSHIFTX:
417 return new Integer(lhs >>> rhs);
418
419 case BIT_AND:
420 case BIT_ANDX:
421 return new Integer(lhs & rhs);
422
423 case BIT_OR:
424 case BIT_ORX:
425 return new Integer(lhs | rhs);
426
427 case XOR:
428 return new Integer(lhs ^ rhs);
429
430 default:
431 throw new InterpreterError(
432 "Unimplemented binary integer operator");
433 }
434 }
435
436 // returns Object covering both Double and Boolean return types
437 static Object doubleBinaryOperation(Double D1, Double D2, int kind)
438 throws UtilEvalError
439 {
440 double lhs = D1.doubleValue();
441 double rhs = D2.doubleValue();
442
443 switch(kind)
444 {
445 // boolean
446 case LT:
447 case LTX:
448 return new Boolean(lhs < rhs);
449
450 case GT:
451 case GTX:
452 return new Boolean(lhs > rhs);
453
454 case EQ:
455 return new Boolean(lhs == rhs);
456
457 case LE:
458 case LEX:
459 return new Boolean(lhs <= rhs);
460
461 case GE:
462 case GEX:
463 return new Boolean(lhs >= rhs);
464
465 case NE:
466 return new Boolean(lhs != rhs);
467
468 // arithmetic
469 case PLUS:
470 return new Double(lhs + rhs);
471
472 case MINUS:
473 return new Double(lhs - rhs);
474
475 case STAR:
476 return new Double(lhs * rhs);
477
478 case SLASH:
479 return new Double(lhs / rhs);
480
481 case MOD:
482 return new Double(lhs % rhs);
483
484 // can't shift floating-point values
485 case LSHIFT:
486 case LSHIFTX:
487 case RSIGNEDSHIFT:
488 case RSIGNEDSHIFTX:
489 case RUNSIGNEDSHIFT:
490 case RUNSIGNEDSHIFTX:
491 throw new UtilEvalError("Can't shift doubles");
492
493 default:
494 throw new InterpreterError(
495 "Unimplemented binary double operator");
496 }
497 }
498 // returns Object covering both Long and Boolean return types
499 static Object floatBinaryOperation(Float F1, Float F2, int kind)
500 throws UtilEvalError
501 {
502 float lhs = F1.floatValue();
503 float rhs = F2.floatValue();
504
505 switch(kind)
506 {
507 // boolean
508 case LT:
509 case LTX:
510 return new Boolean(lhs < rhs);
511
512 case GT:
513 case GTX:
514 return new Boolean(lhs > rhs);
515
516 case EQ:
517 return new Boolean(lhs == rhs);
518
519 case LE:
520 case LEX:
521 return new Boolean(lhs <= rhs);
522
523 case GE:
524 case GEX:
525 return new Boolean(lhs >= rhs);
526
527 case NE:
528 return new Boolean(lhs != rhs);
529
530 // arithmetic
531 case PLUS:
532 return new Float(lhs + rhs);
533
534 case MINUS:
535 return new Float(lhs - rhs);
536
537 case STAR:
538 return new Float(lhs * rhs);
539
540 case SLASH:
541 return new Float(lhs / rhs);
542
543 case MOD:
544 return new Float(lhs % rhs);
545
546 // can't shift floats
547 case LSHIFT:
548 case LSHIFTX:
549 case RSIGNEDSHIFT:
550 case RSIGNEDSHIFTX:
551 case RUNSIGNEDSHIFT:
552 case RUNSIGNEDSHIFTX:
553 throw new UtilEvalError("Can't shift floats ");
554
555 default:
556 throw new InterpreterError(
557 "Unimplemented binary float operator");
558 }
559 }
560
561 /**
562 Promote primitive wrapper type to to Integer wrapper type
563 */
564 static Object promoteToInteger(Object wrapper )
565 {
566 if(wrapper instanceof Character)
567 return new Integer(((Character)wrapper).charValue());
568 else if((wrapper instanceof Byte) || (wrapper instanceof Short))
569 return new Integer(((Number)wrapper).intValue());
570
571 return wrapper;
572 }
573
574 /**
575 Promote the pair of primitives to the maximum type of the two.
576 e.g. [int,long]->[long,long]
577 */
578 static Object[] promotePrimitives(Object lhs, Object rhs)
579 {
580 lhs = promoteToInteger(lhs);
581 rhs = promoteToInteger(rhs);
582
583 if((lhs instanceof Number) && (rhs instanceof Number))
584 {
585 Number lnum = (Number)lhs;
586 Number rnum = (Number)rhs;
587
588 boolean b;
589
590 if((b = (lnum instanceof Double)) || (rnum instanceof Double))
591 {
592 if(b)
593 rhs = new Double(rnum.doubleValue());
594 else
595 lhs = new Double(lnum.doubleValue());
596 }
597 else if((b = (lnum instanceof Float)) || (rnum instanceof Float))
598 {
599 if(b)
600 rhs = new Float(rnum.floatValue());
601 else
602 lhs = new Float(lnum.floatValue());
603 }
604 else if((b = (lnum instanceof Long)) || (rnum instanceof Long))
605 {
606 if(b)
607 rhs = new Long(rnum.longValue());
608 else
609 lhs = new Long(lnum.longValue());
610 }
611 }
612
613 return new Object[] { lhs, rhs };
614 }
615
616 public static Primitive unaryOperation(Primitive val, int kind)
617 throws UtilEvalError
618 {
619 if (val == NULL)
620 throw new UtilEvalError(
621 "illegal use of null object or 'null' literal");
622 if (val == VOID)
623 throw new UtilEvalError(
624 "illegal use of undefined object or 'void' literal");
625
626 Class operandType = val.getType();
627 Object operand = promoteToInteger(val.getValue());
628
629 if ( operand instanceof Boolean )
630 return new Primitive(booleanUnaryOperation((Boolean)operand, kind));
631 else if(operand instanceof Integer)
632 {
633 int result = intUnaryOperation((Integer)operand, kind);
634
635 // ++ and -- must be cast back the original type
636 if(kind == INCR || kind == DECR)
637 {
638 if(operandType == Byte.TYPE)
639 return new Primitive((byte)result);
640 if(operandType == Short.TYPE)
641 return new Primitive((short)result);
642 if(operandType == Character.TYPE)
643 return new Primitive((char)result);
644 }
645
646 return new Primitive(result);
647 }
648 else if(operand instanceof Long)
649 return new Primitive(longUnaryOperation((Long)operand, kind));
650 else if(operand instanceof Float)
651 return new Primitive(floatUnaryOperation((Float)operand, kind));
652 else if(operand instanceof Double)
653 return new Primitive(doubleUnaryOperation((Double)operand, kind));
654 else
655 throw new InterpreterError(
656 "An error occurred. Please call technical support.");
657 }
658
659 static boolean booleanUnaryOperation(Boolean B, int kind)
660 throws UtilEvalError
661 {
662 boolean operand = B.booleanValue();
663 switch(kind)
664 {
665 case BANG:
666 return !operand;
667 default:
668 throw new UtilEvalError("Operator inappropriate for boolean");
669 }
670 }
671
672 static int intUnaryOperation(Integer I, int kind)
673 {
674 int operand = I.intValue();
675
676 switch(kind)
677 {
678 case PLUS:
679 return operand;
680 case MINUS:
681 return -operand;
682 case TILDE:
683 return ~operand;
684 case INCR:
685 return operand + 1;
686 case DECR:
687 return operand - 1;
688 default:
689 throw new InterpreterError("bad integer unaryOperation");
690 }
691 }
692
693 static long longUnaryOperation(Long L, int kind)
694 {
695 long operand = L.longValue();
696
697 switch(kind)
698 {
699 case PLUS:
700 return operand;
701 case MINUS:
702 return -operand;
703 case TILDE:
704 return ~operand;
705 case INCR:
706 return operand + 1;
707 case DECR:
708 return operand - 1;
709 default:
710 throw new InterpreterError("bad long unaryOperation");
711 }
712 }
713
714 static float floatUnaryOperation(Float F, int kind)
715 {
716 float operand = F.floatValue();
717
718 switch(kind)
719 {
720 case PLUS:
721 return operand;
722 case MINUS:
723 return -operand;
724 default:
725 throw new InterpreterError("bad float unaryOperation");
726 }
727 }
728
729 static double doubleUnaryOperation(Double D, int kind)
730 {
731 double operand = D.doubleValue();
732
733 switch(kind)
734 {
735 case PLUS:
736 return operand;
737 case MINUS:
738 return -operand;
739 default:
740 throw new InterpreterError("bad double unaryOperation");
741 }
742 }
743
744 public int intValue() throws UtilEvalError
745 {
746 if(value instanceof Number)
747 return((Number)value).intValue();
748 else
749 throw new UtilEvalError("Primitive not a number");
750 }
751
752 public boolean booleanValue() throws UtilEvalError
753 {
754 if(value instanceof Boolean)
755 return((Boolean)value).booleanValue();
756 else
757 throw new UtilEvalError("Primitive not a boolean");
758 }
759
760 /**
761 Determine if this primitive is a numeric type.
762 i.e. not boolean, null, or void (but including char)
763 */
764 public boolean isNumber() {
765 return ( !(value instanceof Boolean)
766 && !(this == NULL) && !(this == VOID) );
767 }
768
769 public Number numberValue() throws UtilEvalError
770 {
771 Object value = this.value;
772
773 // Promote character to Number type for these purposes
774 if (value instanceof Character)
775 value = new Integer(((Character)value).charValue());
776
777 if (value instanceof Number)
778 return (Number)value;
779 else
780 throw new UtilEvalError("Primitive not a number");
781 }
782
783 /**
784 Primitives compare equal with other Primitives containing an equal
785 wrapped value.
786 */
787 public boolean equals( Object obj )
788 {
789 if ( obj instanceof Primitive )
790 return ((Primitive)obj).value.equals( this.value );
791 else
792 return false;
793 }
794
795 /**
796 The hash of the Primitive is tied to the hash of the wrapped value but
797 shifted so that they are not the same.
798 */
799 public int hashCode()
800 {
801 return this.value.hashCode() * 21; // arbitrary
802 }
803
804 /**
805 Unwrap primitive values and map voids to nulls.
806 Non Primitive types remain unchanged.
807
808 @param obj object type which may be bsh.Primitive
809 @return corresponding "normal" Java type, "unwrapping"
810 any bsh.Primitive types to their wrapper types.
811 */
812 public static Object unwrap( Object obj )
813 {
814 // map voids to nulls for the outside world
815 if (obj == Primitive.VOID)
816 return null;
817
818 // unwrap primitives
819 if (obj instanceof Primitive)
820 return((Primitive)obj).getValue();
821 else
822 return obj;
823 }
824
825 /*
826 Unwrap Primitive wrappers to their java.lang wrapper values.
827 e.g. Primitive(42) becomes Integer(42)
828 @see #unwrap( Object )
829 */
830 public static Object [] unwrap( Object[] args )
831 {
832 Object [] oa = new Object[ args.length ];
833 for(int i=0; i<args.length; i++)
834 oa[i] = unwrap( args[i] );
835 return oa;
836 }
837
838 /*
839 */
840 public static Object [] wrap( Object[] args, Class [] paramTypes )
841 {
842 if ( args == null )
843 return null;
844
845 Object [] oa = new Object[ args.length ];
846 for(int i=0; i<args.length; i++)
847 oa[i] = wrap( args[i], paramTypes[i] );
848 return oa;
849 }
850
851 /**
852 Wrap primitive values (as indicated by type param) and nulls in the
853 Primitive class. Values not primitive or null are left unchanged.
854 Primitive values are represented by their wrapped values in param value.
855 <p/>
856 The value null is mapped to Primitive.NULL.
857 Any value specified with type Void.TYPE is mapped to Primitive.VOID.
858 */
859 public static Object wrap(
860 Object value, Class type )
861 {
862 if ( type == Void.TYPE )
863 return Primitive.VOID;
864
865 if ( value == null )
866 return Primitive.NULL;
867
868 if ( type.isPrimitive() )
869 return new Primitive( value );
870
871 return value;
872 }
873
874
875 /**
876 Get the appropriate default value per JLS 4.5.4
877 */
878 public static Primitive getDefaultValue( Class type )
879 {
880 if ( type == null || !type.isPrimitive() )
881 return Primitive.NULL;
882 if ( type == Boolean.TYPE )
883 return new Primitive( false );
884
885 // non boolean primitive, get appropriate flavor of zero
886 try {
887 return new Primitive((int)0).castToType( type, Types.CAST );
888 } catch ( UtilEvalError e ) {
889 throw new InterpreterError( "bad cast" );
890 }
891 }
892
893 /**
894 Get the corresponding java.lang wrapper class for the primitive TYPE
895 class.
896 e.g. Integer.TYPE -> Integer.class
897 */
898 public static Class boxType( Class primitiveType )
899 {
900 Class c = (Class)wrapperMap.get( primitiveType );
901 if ( c != null )
902 return c;
903 throw new InterpreterError(
904 "Not a primitive type: "+ primitiveType );
905 }
906
907 /**
908 Get the corresponding primitive TYPE class for the java.lang wrapper
909 class type.
910 e.g. Integer.class -> Integer.TYPE
911 */
912 public static Class unboxType( Class wrapperType )
913 {
914 Class c = (Class)wrapperMap.get( wrapperType );
915 if ( c != null )
916 return c;
917 throw new InterpreterError(
918 "Not a primitive wrapper type: "+wrapperType );
919 }
920
921 /**
922 Cast this bsh.Primitive value to a new bsh.Primitive value
923 This is usually a numeric type cast. Other cases include:
924 A boolean can be cast to boolen
925 null can be cast to any object type and remains null
926 Attempting to cast a void causes an exception
927 @param toType is the java object or primitive TYPE class
928 */
929 public Primitive castToType( Class toType, int operation )
930 throws UtilEvalError
931 {
932 return castPrimitive(
933 toType, getType()/*fromType*/, this/*fromValue*/,
934 false/*checkOnly*/, operation );
935 }
936
937 /*
938 Cast or check a cast of a primitive type to another type.
939 Normally both types are primitive (e.g. numeric), but a null value
940 (no type) may be cast to any type.
941 <p/>
942
943 @param toType is the target type of the cast. It is normally a
944 java primitive TYPE, but in the case of a null cast can be any object
945 type.
946
947 @param fromType is the java primitive TYPE type of the primitive to be
948 cast or null, to indicate that the fromValue was null or void.
949
950 @param fromValue is, optionally, the value to be converted. If
951 checkOnly is true fromValue must be null. If checkOnly is false,
952 fromValue must be non-null (Primitive.NULL is of course valid).
953 */
954 static Primitive castPrimitive(
955 Class toType, Class fromType, Primitive fromValue,
956 boolean checkOnly, int operation )
957 throws UtilEvalError
958 {
959 /*
960 Lots of preconditions checked here...
961 Once things are running smoothly we might comment these out
962 (That's what assertions are for).
963 */
964 if ( checkOnly && fromValue != null )
965 throw new InterpreterError("bad cast param 1");
966 if ( !checkOnly && fromValue == null )
967 throw new InterpreterError("bad cast param 2");
968 if ( fromType != null && !fromType.isPrimitive() )
969 throw new InterpreterError("bad fromType:" +fromType);
970 if ( fromValue == Primitive.NULL && fromType != null )
971 throw new InterpreterError("inconsistent args 1");
972 if ( fromValue == Primitive.VOID && fromType != Void.TYPE )
973 throw new InterpreterError("inconsistent args 2");
974
975 // can't cast void to anything
976 if ( fromType == Void.TYPE )
977 if ( checkOnly )
978 return Types.INVALID_CAST;
979 else
980 throw Types.castError( Reflect.normalizeClassName(toType),
981 "void value", operation );
982
983 // unwrap Primitive fromValue to its wrapper value, etc.
984 Object value = null;
985 if ( fromValue != null )
986 value = fromValue.getValue();
987
988 if ( toType.isPrimitive() )
989 {
990 // Trying to cast null to primitive type?
991 if ( fromType == null )
992 if ( checkOnly )
993 return Types.INVALID_CAST;
994 else
995 throw Types.castError(
996 "primitive type:" + toType, "Null value", operation );
997
998 // fall through
999 } else
1000 {
1001 // Trying to cast primitive to an object type
1002 // Primitive.NULL can be cast to any object type
1003 if ( fromType == null )
1004 return checkOnly ? Types.VALID_CAST :
1005 Primitive.NULL;
1006
1007 if ( checkOnly )
1008 return Types.INVALID_CAST;
1009 else
1010 throw Types.castError(
1011 "object type:" + toType, "primitive value", operation);
1012 }
1013
1014 // can only cast boolean to boolean
1015 if ( fromType == Boolean.TYPE )
1016 {
1017 if ( toType != Boolean.TYPE )
1018 if ( checkOnly )
1019 return Types.INVALID_CAST;
1020 else
1021 throw Types.castError( toType, fromType, operation );
1022
1023 return checkOnly ? Types.VALID_CAST :
1024 fromValue;
1025 }
1026
1027 // Do numeric cast
1028
1029 // Only allow legal Java assignment unless we're a CAST operation
1030 if ( operation == Types.ASSIGNMENT
1031 && !Types.isJavaAssignable( toType, fromType )
1032 ) {
1033 if ( checkOnly )
1034 return Types.INVALID_CAST;
1035 else
1036 throw Types.castError( toType, fromType, operation );
1037 }
1038
1039 return checkOnly ? Types.VALID_CAST :
1040 new Primitive( castWrapper(toType, value) );
1041 }
1042
1043 public static boolean isWrapperType( Class type )
1044 {
1045 return wrapperMap.get( type ) != null && !type.isPrimitive();
1046 }
1047
1048 /**
1049 Cast a primitive value represented by its java.lang wrapper type to the
1050 specified java.lang wrapper type. e.g. Byte(5) to Integer(5) or
1051 Integer(5) to Byte(5)
1052 @param toType is the java TYPE type
1053 @param value is the value in java.lang wrapper.
1054 value may not be null.
1055 */
1056 static Object castWrapper(
1057 Class toType, Object value )
1058 {
1059 if ( !toType.isPrimitive() )
1060 throw new InterpreterError("invalid type in castWrapper: "+toType);
1061 if ( value == null )
1062 throw new InterpreterError("null value in castWrapper, guard");
1063 if ( value instanceof Boolean )
1064 {
1065 if ( toType != Boolean.TYPE )
1066 throw new InterpreterError("bad wrapper cast of boolean");
1067 else
1068 return value;
1069 }
1070
1071 // first promote char to Number type to avoid duplicating code
1072 if ( value instanceof Character )
1073 value = new Integer(((Character)value).charValue());
1074
1075 if ( !(value instanceof Number) )
1076 throw new InterpreterError("bad type in cast");
1077
1078 Number number = (Number)value;
1079
1080 if (toType == Byte.TYPE)
1081 return new Byte(number.byteValue());
1082 if (toType == Short.TYPE)
1083 return new Short(number.shortValue());
1084 if (toType == Character.TYPE)
1085 return new Character((char)number.intValue());
1086 if (toType == Integer.TYPE)
1087 return new Integer(number.intValue());
1088 if (toType == Long.TYPE)
1089 return new Long(number.longValue());
1090 if (toType == Float.TYPE)
1091 return new Float(number.floatValue());
1092 if (toType == Double.TYPE)
1093 return new Double(number.doubleValue());
1094
1095 throw new InterpreterError("error in wrapper cast");
1096 }
1097
1098 }