public static Primitive unaryOperation(Primitive val, int kind) throws UtilEvalError { if (val == NULL) throw new UtilEvalError("illegal use of null object or 'null' literal"); if (val == VOID) throw new UtilEvalError("illegal use of undefined object or 'void' literal"); Class operandType = val.getType(); Object operand = promoteToInteger(val.getValue()); if (operand instanceof Boolean) return booleanUnaryOperation((Boolean) operand, kind) ? Primitive.TRUE : Primitive.FALSE; else if (operand instanceof Integer) { int result = intUnaryOperation((Integer) operand, kind); // ++ and -- must be cast back the original type if (kind == INCR || kind == DECR) { if (operandType == Byte.TYPE) return new Primitive((byte) result); if (operandType == Short.TYPE) return new Primitive((short) result); if (operandType == Character.TYPE) return new Primitive((char) result); } return new Primitive(result); } else if (operand instanceof Long) return new Primitive(longUnaryOperation((Long) operand, kind)); else if (operand instanceof Float) return new Primitive(floatUnaryOperation((Float) operand, kind)); else if (operand instanceof Double) return new Primitive(doubleUnaryOperation((Double) operand, kind)); else throw new InterpreterError("An error occurred. Please call technical support."); }
/** * DOCUMENT ME! * * @param callstack DOCUMENT ME! * @param interpreter DOCUMENT ME! * @param parameterNode DOCUMENT ME! * @return DOCUMENT ME! * @throws EvalError DOCUMENT ME! */ public Object filter(CallStack callstack, Interpreter interpreter, Node parameterNode) throws EvalError { int col = getColumn(); if (parameterNode instanceof BSHArguments) { Object[] keys = ((BSHArguments) parameterNode).getArguments(callstack, interpreter); for (int i = 0; i < keys.length; i++) { keys[i] = Primitive.unwrap(keys[i]); } Key key = null; if ((keys.length == 1) && (keys[0] == Dataset.ANY)) { key = Dataset.ANY; } else { key = new Key(keys); } Object value2 = new FilteredIndexField(this.indexView, key, col); interpreter.getRoot().setValue2(value2); return value2; } return null; }
/* Cast or check a cast of a primitive type to another type. Normally both types are primitive (e.g. numeric), but a null value (no type) may be cast to any type. <p/> @param toType is the target type of the cast. It is normally a java primitive TYPE, but in the case of a null cast can be any object type. @param fromType is the java primitive TYPE type of the primitive to be cast or null, to indicate that the fromValue was null or void. @param fromValue is, optionally, the value to be converted. If checkOnly is true fromValue must be null. If checkOnly is false, fromValue must be non-null (Primitive.NULL is of course valid). */ static Primitive castPrimitive( Class toType, Class fromType, Primitive fromValue, boolean checkOnly, int operation) throws UtilEvalError { /* Lots of preconditions checked here... Once things are running smoothly we might comment these out (That's what assertions are for). */ if (checkOnly && fromValue != null) throw new InterpreterError("bad cast param 1"); if (!checkOnly && fromValue == null) throw new InterpreterError("bad cast param 2"); if (fromType != null && !fromType.isPrimitive()) throw new InterpreterError("bad fromType:" + fromType); if (fromValue == Primitive.NULL && fromType != null) throw new InterpreterError("inconsistent args 1"); if (fromValue == Primitive.VOID && fromType != Void.TYPE) throw new InterpreterError("inconsistent args 2"); // can't cast void to anything if (fromType == Void.TYPE) if (checkOnly) return Types.INVALID_CAST; else throw Types.castError(Reflect.normalizeClassName(toType), "void value", operation); // unwrap Primitive fromValue to its wrapper value, etc. Object value = null; if (fromValue != null) value = fromValue.getValue(); if (toType.isPrimitive()) { // Trying to cast null to primitive type? if (fromType == null) if (checkOnly) return Types.INVALID_CAST; else throw Types.castError("primitive type:" + toType, "Null value", operation); // fall through } else { // Trying to cast primitive to an object type // Primitive.NULL can be cast to any object type if (fromType == null) return checkOnly ? Types.VALID_CAST : Primitive.NULL; if (checkOnly) return Types.INVALID_CAST; else throw Types.castError("object type:" + toType, "primitive value", operation); } // can only cast boolean to boolean if (fromType == Boolean.TYPE) { if (toType != Boolean.TYPE) if (checkOnly) return Types.INVALID_CAST; else throw Types.castError(toType, fromType, operation); return checkOnly ? Types.VALID_CAST : fromValue; } // Do numeric cast // Only allow legal Java assignment unless we're a CAST operation if (operation == Types.ASSIGNMENT && !Types.isJavaAssignable(toType, fromType)) { if (checkOnly) return Types.INVALID_CAST; else throw Types.castError(toType, fromType, operation); } return checkOnly ? Types.VALID_CAST : new Primitive(castWrapper(toType, value)); }