public static final Object[] ZERO_ARGS = {};

public static final Class<?>[] ZERO_TYPES = {};

static final String GET_PREFIX = "get";

static final String SET_PREFIX = "set";

static final String IS_PREFIX = "is";

private static final Map<String,String> ACCESSOR_NAMES = new WeakHashMap<>();

private static final Pattern DEFAULT_PACKAGE

= Pattern.compile("[^\\.]+|bsh\\..*");

private static final Pattern PACKAGE_ACCESS;

static {

String packageAccess = Security.getProperty("package.access");

if (null == packageAccess) packageAccess = "null";

String pattern = Stream.of(packageAccess.split(","))

.filter(s -> !s.isEmpty())

.collect(Collectors.joining("|", "(?:", ").*"));

PACKAGE_ACCESS = Pattern.compile(pattern);

}

/** Invoke method on arbitrary object instance. May be static (through the object

public static Object invokeObjectMethod(

Object object, String methodName, Object[] args,

Interpreter interpreter, CallStack callstack,

Node callerInfo) throws EvalError {

// Bsh scripted object

if (object instanceof This && !This.isExposedThisMethod(methodName))

return ((This) object).invokeMethod(

methodName, args, interpreter, callstack, callerInfo,

false/* declaredOnly */);

// Plain Java object, script engine exposed instance and find java method to invoke

BshClassManager bcm = interpreter.getClassManager();

// Flag primitive for overwrites, value/type exposure and recursion loop metigation.

boolean isPrimitive = object instanceof Primitive;

try { // The type exposed to script engine and used for method lookup

Class<?> type = object.getClass();

if (isPrimitive) { // Overwrite methods cosmetically deferred to bsh.Primitive

if (methodName.equals("equals")) return ((Primitive)object).equals(args[0]);

// NULL and VOID remain Primitive the rest are value/primitive type exposed

if (object != Primitive.NULL && object != Primitive.VOID) {

type = ((Primitive)object).getType();

object = Primitive.unwrap(object);

} // Cosmetic Void.TYPE returned while internal type remains bsh.Primitive

if (methodName.equals("getType") || methodName.equals("getClass"))

return (object == Primitive.VOID) ? ((Primitive)object).getType() : type;

} try { // Script engine exposed instance for method lookup and invocation here

Invocable method = resolveExpectedJavaMethod(

bcm, type, object, methodName, args, false);

NameSpace ns = getThisNS(object);

if (null != ns) ns.setNode(callerInfo);

return method.invoke(object, args); // script engine exposed instance call

} catch (ReflectError re) { // Void has overstayed its welcome round about here

if (object == Primitive.VOID) throw new EvalError("Attempt to invoke method: "

+ methodName + "() on undefined", callerInfo, callstack, re);

// Handle primitive method not found. Autoboxing or magic math method lookup.

// Errors gets rolled up, and not found is deferred back to exposed type.

if (isPrimitive && !interpreter.getStrictJava()) try { // mitigate recursion

if (!Types.isNumeric(object)) return invokeObjectMethod( // autobox type

object, methodName, args, interpreter, callstack, callerInfo);

return numericMathMethod( // find magic math method on all numeric types

object, type, methodName, args, interpreter, callstack, callerInfo);

} catch (TargetError te) { throw te; // method found but errored throw it up

} catch (EvalError ee) { /* not found deffered fall through to exposed type */ }

throw new EvalError( // Deferred/unhandled method not found on exposed type

"Error in method invocation: " + re.getMessage(), callerInfo, callstack, re);

} catch (InvocationTargetException e) {

throw targetErrorFromTargetException(e, methodName, callstack, callerInfo);

}

} catch (UtilEvalError e) {

throw e.toEvalError(callerInfo, callstack);

}

}

/** Package scoped target error, extracted as a method, to prevent duplication.

static TargetError targetErrorFromTargetException(InvocationTargetException e,

String methodName, CallStack callstack, Node callerInfo) {

String msg = "Method Invocation " + methodName;

Throwable te = e.getCause();

// Try to squeltch the native code stack trace if the exception was caused by

// a reflective call back into the bsh interpreter (e.g. eval() or source()

boolean isNative = true;

if (te instanceof EvalError)

isNative = (te instanceof TargetError) && ((TargetError) te).inNativeCode();

return new TargetError(msg, te, callerInfo, callstack, isNative);

}

/** Determine which math class to call first, based on the floating point flag.

private static Object numericMathMethod(Object object, Class<?> type, String methodName,

Object[] args, Interpreter interpreter, CallStack callstack, Node callerInfo)

throws EvalError {

Class<?> mathType = Types.isFloatingpoint(object) ? BigDecimal.class : BigInteger.class;

try {

return invokeMathMethod(mathType,

object, type, methodName, args, interpreter, callstack, callerInfo);

} catch (TargetError te) { // method found but errored lets throw it back up

throw te.reThrow("Method found on " + mathType.getSimpleName() + " but with error");

} catch (EvalError ee) { // method not found try alternative math provider

return invokeMathMethod(

Types.isFloatingpoint(object) ? BigInteger.class : BigDecimal.class,

object, type, methodName, args, interpreter, callstack, callerInfo);

}

}

/** Cast object up to math type, and invoke the math method with the supplied

private static Object invokeMathMethod(Class<?> mathType, Object object, Class<?> returnType,

String methodName, Object[] args, Interpreter interpreter, CallStack callstack,

Node callerInfo) throws EvalError {

Object retrn = invokeObjectMethod(Primitive.castWrapper(mathType, object),

methodName, args, interpreter, callstack, callerInfo);

if (retrn instanceof Primitive && ((Primitive)retrn).getType() == mathType)

return Primitive.wrap(Primitive.castWrapper(returnType, retrn), returnType);

return retrn;

}

/**

public static Object invokeStaticMethod(

BshClassManager bcm, Class<?> clas, String methodName,

Object [] args, Node callerInfo )

throws ReflectError, UtilEvalError,

InvocationTargetException {

Interpreter.debug("invoke static Method");

NameSpace ns = getThisNS(clas);

if (null != ns)

ns.setNode(callerInfo);

Invocable method = resolveExpectedJavaMethod(

bcm, clas, null, methodName, args, true );

return method.invoke(null, args);

}

public static Object getStaticFieldValue(Class<?> clas, String fieldName)

throws UtilEvalError, ReflectError {

return getFieldValue( clas, null, fieldName, true/*onlystatic*/);

}

/**

public static Object getObjectFieldValue( Object object, String fieldName )

throws UtilEvalError, ReflectError {

if ( object instanceof This ) {

return ((This) object).namespace.getVariable( fieldName );

} else if( object == Primitive.NULL ) {

throw new UtilTargetError( new NullPointerException(

"Attempt to access field '" +fieldName+"' on null value" ) );

} else {

try {

return getFieldValue(

object.getClass(), object, fieldName, false/*onlystatic*/);

} catch ( ReflectError e ) {

// no field, try property access

if ( hasObjectPropertyGetter( object.getClass(), fieldName ) )

return getObjectProperty( object, fieldName );

else

throw e;

}

}

}

static LHS getLHSStaticField(Class<?> clas, String fieldName)

throws UtilEvalError, ReflectError {

try {

Invocable f = resolveExpectedJavaField(

clas, fieldName, true/*onlystatic*/);

return new LHS(f);

} catch ( ReflectError e ) {

NameSpace ns = getThisNS(clas);

if (isGeneratedClass(clas) && null != ns && ns.isClass) {

Variable var = ns.getVariableImpl(fieldName, true);

if ( null != var && (!var.hasModifier("private")

|| haveAccessibility()) )

return new LHS(ns, fieldName);

}

// not a field, try property access

if ( hasObjectPropertySetter( clas, fieldName ) )

return new LHS( clas, fieldName );

else

throw e;

}

}

/**

static LHS getLHSObjectField( Object object, String fieldName )

throws UtilEvalError, ReflectError {

if ( object instanceof This )

return new LHS( ((This)object).namespace, fieldName, false );

try {

Invocable f = resolveExpectedJavaField(

object.getClass(), fieldName, false/*staticOnly*/ );

return new LHS(object, f);

} catch ( ReflectError e ) {

NameSpace ns = getThisNS(object);

if (isGeneratedClass(object.getClass()) && null != ns && ns.isClass) {

Variable var = ns.getVariableImpl(fieldName, true);

if ( null != var && (!var.hasModifier("private")

|| haveAccessibility()) )

return new LHS(ns, fieldName);

}

// not a field, try property access

if ( hasObjectPropertySetter( object.getClass(), fieldName ) )

return new LHS( object, fieldName );

else

throw e;

}

}

private static Object getFieldValue(

Class<?> clas, Object object, String fieldName, boolean staticOnly)

throws UtilEvalError, ReflectError {

try {

Invocable f = resolveExpectedJavaField(clas, fieldName, staticOnly);

return f.invoke(object);

} catch ( ReflectError e ) {

NameSpace ns = getThisNS(clas);

if (isGeneratedClass(clas) && null != ns && ns.isClass)

if (staticOnly) {

Variable var = ns.getVariableImpl(fieldName, true);

Object val = Primitive.VOID;

if ( null != var && (!var.hasModifier("private")

|| haveAccessibility()) )

val = ns.unwrapVariable(var);

if (Primitive.VOID != val)

return val;

}

else if (null != (ns = getThisNS(object))) {

Variable var = ns.getVariableImpl(fieldName, true);

Object val = Primitive.VOID;

if ( null != var && (!var.hasModifier("private")

|| haveAccessibility()) )

val = ns.unwrapVariable(var);

if (Primitive.VOID != val)

return val;

}

throw e;

} catch(InvocationTargetException e) {

if (e.getCause() instanceof InterpreterError)

throw (InterpreterError)e.getCause();

if (e.getCause() instanceof UtilEvalError)

throw new UtilTargetError(e.getCause());

throw new ReflectError("Can't access field: "

+ fieldName, e.getCause());

}

}

/*

protected static Invocable resolveJavaField(

Class<?> clas, String fieldName, boolean staticOnly )

throws UtilEvalError {

try {

return resolveExpectedJavaField( clas, fieldName, staticOnly );

} catch ( ReflectError e ) {

return null;

}

}

/**

/*

protected static Invocable resolveExpectedJavaField(

Class<?> clas, String fieldName, boolean staticOnly)

throws UtilEvalError, ReflectError {

Invocable field = BshClassManager.memberCache

.get(clas).findField(fieldName);

if (null == field)

throw new ReflectError("No such field: "

+ fieldName + " for class: " + clas.getName());

if ( staticOnly && !field.isStatic() )

throw new UtilEvalError(

"Can't reach instance field: " + fieldName

+ " from static context: " + clas.getName() );

return field;

}

/**

protected static Invocable resolveExpectedJavaMethod(

BshClassManager bcm, Class<?> clas, Object object,

String name, Object[] args, boolean staticOnly )

throws ReflectError, UtilEvalError {

if ( object == Primitive.NULL )

throw new UtilTargetError( new NullPointerException(

"Attempt to invoke method " +name+" on null value" ) );

Class<?>[] types = Types.getTypes(args);

Invocable method = resolveJavaMethod( clas, name, types, staticOnly );

if ( null != bcm && bcm.getStrictJava()

&& method != null && method.getDeclaringClass().isInterface()

&& method.getDeclaringClass() != clas

&& Modifier.isStatic(method.getModifiers()))

// static interface methods are class only

method = null;

if ( method == null )

throw new ReflectError(

( staticOnly ? "Static method " : "Method " )

+ StringUtil.methodString(name, types) +

" not found in class'" + clas.getName() + "'");

return method;

}

/**

protected static Invocable resolveJavaMethod(

Class<?> clas, String name, Class<?>[] types,

boolean staticOnly ) throws UtilEvalError {

if ( clas == null )

throw new InterpreterError("null class");

Invocable method = BshClassManager.memberCache

.get(clas).findMethod(name, types);

Interpreter.debug("resolved java method: ", method, " on class: ", clas);

checkFoundStaticMethod( method, staticOnly, clas );

return method;

}

/** Find a static method member of baseClass, for the given name.

static BshMethod staticMethodImport(Class<?> baseClass, String methodName) {

Invocable method = BshClassManager.memberCache.get(baseClass)

.findStaticMethod(methodName);

if (null != method)

return new BshMethod(method, null);

return null;

}

/**

static Object constructObject( Class<?> clas, Object[] args )

throws ReflectError, InvocationTargetException {

return constructObject(clas, null, args);

}

static Object constructObject( Class<?> clas, Object object, Object[] args )

throws ReflectError, InvocationTargetException {

if ( null == clas )

return Primitive.NULL;

if ( clas.isInterface() )

throw new ReflectError(

"Can't create instance of an interface: "+clas);

Class<?>[] types = Types.getTypes(args);

if (clas.isMemberClass() && !isStatic(clas) && null != object)

types = Stream.concat(Stream.of(object.getClass()),

Stream.of(types)).toArray(Class[]::new);

Interpreter.debug("Looking for most specific constructor: ", clas);

Invocable con = BshClassManager.memberCache.get(clas)

.findMethod(clas.getName(), types);

if ( con == null || (args.length != con.getParameterCount()

&& !con.isVarArgs() && !con.isInnerClass()))

throw cantFindConstructor( clas, types );

try {

return con.invoke( object, args );

} catch(InvocationTargetException e) {

if (e.getCause().getCause() instanceof IllegalAccessException)

throw new ReflectError(

"We don't have permission to create an instance. "

+ e.getCause().getCause().getMessage()

+ " Use setAccessibility(true) to enable access.",

e.getCause().getCause());

throw e;

}

}

/**

public static BshMethod findMostSpecificBshMethod(

Class<?>[] idealMatch, List<BshMethod> methods ) {

Interpreter.debug("find most specific BshMethod for: "+

Arrays.toString(idealMatch));

int match = findMostSpecificBshMethodIndex( idealMatch, methods );

return match == -1 ? null : methods.get(match);

}

/**

public static int findMostSpecificBshMethodIndex(Class<?>[] idealMatch,

List<BshMethod> methods) {

for (int i=0; i<methods.size(); i++)

Interpreter.debug(" "+i+":"+methods.get(i).toString()+" "+methods.get(i).getClass().getName());

/*

List<Class<?>[]> candidateSigs = new ArrayList<>();

// array to remap the index in the new list

ArrayList<Integer> remap = new ArrayList<>();

int i=0;

for( BshMethod m : methods ) {

Class<?>[] parameterTypes = m.getParameterTypes();

if (idealMatch.length == parameterTypes.length) {

remap.add(i);

candidateSigs.add( parameterTypes );

}

i++;

}

Class<?>[][] sigs = candidateSigs.toArray(new Class[candidateSigs.size()][]);

int match = findMostSpecificSignature( idealMatch, sigs );

if (match >= 0) {

match = remap.get(match);

Interpreter.debug(" remap: "+remap);

Interpreter.debug(" match:"+match);

return match;

}

/*

candidateSigs.clear();

remap.clear();

i=0;

for( BshMethod m : methods ) {

Class<?>[] parameterTypes = m.getParameterTypes();

if (m.isVarArgs()

&& idealMatch.length >= parameterTypes.length-1 ) {

Class<?>[] candidateSig = new Class[idealMatch.length];

System.arraycopy(parameterTypes, 0, candidateSig, 0,

parameterTypes.length-1);

Class<?> arrayCompType = parameterTypes[parameterTypes.length-1].getComponentType();

Arrays.fill(candidateSig, parameterTypes.length-1,

idealMatch.length, arrayCompType);

remap.add(i);

candidateSigs.add( candidateSig );

}

i++;

}

sigs = candidateSigs.toArray(new Class[candidateSigs.size()][]);

match = findMostSpecificSignature( idealMatch, sigs);

if (match >= 0) {

match = remap.get(match);

Interpreter.debug(" remap (varargs): "+Arrays.toString(remap.toArray(new Integer[0])));

Interpreter.debug(" match (varargs):"+match);

}

return match;

}

/**

public static Invocable findMostSpecificInvocable(

Class<?>[] idealMatch, List<Invocable> methods ) {

Interpreter.debug("find most specific Invocable for: "+

Arrays.toString(idealMatch));

int match = findMostSpecificInvocableIndex( idealMatch, methods );

return match == -1 ? null : methods.get(match);

}

/**

public static int findMostSpecificInvocableIndex(Class<?>[] idealMatch,

List<Invocable> methods) {

for (int i=0; i<methods.size(); i++)

Interpreter.debug(" "+i+"="+methods.get(i).toString());

/*

List<Class<?>[]> candidateSigs = new ArrayList<>();

// array to remap the index in the new list

ArrayList<Integer> remap = new ArrayList<>();

int i=0;

for( Invocable method : methods ) {

Class<?>[] parameterTypes = method.getParameterTypes();

if (idealMatch.length == parameterTypes.length) {

remap.add(i);

candidateSigs.add( parameterTypes );

}

i++;

}

Class<?>[][] sigs = candidateSigs.toArray(new Class[candidateSigs.size()][]);

int match = findMostSpecificSignature( idealMatch, sigs );

if (match >= 0) {

match = remap.get(match);

Interpreter.debug(" remap="+Arrays.toString(remap.toArray(new Integer[0])));

Interpreter.debug(" match="+match);

return match;

}

/*

candidateSigs.clear();

remap.clear();

i=0;

for( Invocable method : methods ) {

Class<?>[] parameterTypes = method.getParameterTypes();

if (method.isVarArgs()

&& idealMatch.length >= parameterTypes.length-1 ) {

Class<?>[] candidateSig = new Class[idealMatch.length];

System.arraycopy(parameterTypes, 0, candidateSig, 0,

parameterTypes.length-1);

Arrays.fill(candidateSig, parameterTypes.length-1,

idealMatch.length, method.getVarArgsComponentType());

remap.add(i);

candidateSigs.add( candidateSig );

}

i++;

}

sigs = candidateSigs.toArray(new Class[candidateSigs.size()][]);

match = findMostSpecificSignature( idealMatch, sigs);

/*

if (match >= 0)

match = remap.get(match);

Interpreter.debug(" remap (varargs) ="+Arrays.toString(remap.toArray(new Integer[0])));

Interpreter.debug(" match (varargs) ="+match);

return match;

}

/**

/*

static int findMostSpecificSignature(

Class<?>[] idealMatch, Class<?>[][] candidates ) {

for ( int round = Types.FIRST_ROUND_ASSIGNABLE;

round <= Types.LAST_ROUND_ASSIGNABLE; round++ ) {

Class<?>[] bestMatch = null;

int bestMatchIndex = -1;

for (int i=0; i < candidates.length; i++) {

Class<?>[] targetMatch = candidates[i];

if (null != bestMatch && Types

.areSignaturesEqual(targetMatch, bestMatch))

// overridden keep first

continue;

// If idealMatch fits targetMatch and this is the first match

// or targetMatch is more specific than the best match, make it

// the new best match.

if ( Types.isSignatureAssignable(

idealMatch, targetMatch, round )

&& ( bestMatch == null

|| Types.areSignaturesEqual(idealMatch, targetMatch)

|| ( Types.isSignatureAssignable(targetMatch, bestMatch,

Types.JAVA_BASE_ASSIGNABLE)

&& !Types.areSignaturesEqual(idealMatch, bestMatch)))) {

bestMatch = targetMatch;

bestMatchIndex = i;

}

}

if ( bestMatch != null )

return bestMatchIndex;

}

return -1;

}

static String accessorName( String prefix, String propName ) {

if (!ACCESSOR_NAMES.containsKey(propName)) {

char[] ch = propName.toCharArray();

ch[0] = Character.toUpperCase(ch[0]);

ACCESSOR_NAMES.put(propName, new String(ch));

}

return prefix + ACCESSOR_NAMES.get(propName);

}

public static boolean hasObjectPropertyGetter(

Class<?> clas, String propName ) {

if ( Types.isPropertyType(clas) )

return true;

return BshClassManager.memberCache

.get(clas).hasMember(propName)

&& null != BshClassManager.memberCache

.get(clas).findGetter(propName);

}

public static boolean hasObjectPropertySetter(

Class<?> clas, String propName ) {

if ( Types.isPropertyType(clas) )

return true;

return BshClassManager.memberCache

.get(clas).hasMember(propName)

&& null != BshClassManager.memberCache

.get(clas).findSetter(propName);

}

@SuppressWarnings("rawtypes")

public static Object getObjectProperty(Object obj, String propName) {

if (Types.isPropertyTypeEntry(obj)) switch (propName) {

case "key":

return ((Entry) obj).getKey();

case "val": case "value":

return ((Entry) obj).getValue();

}

return getObjectProperty(obj, (Object) propName);

}

@SuppressWarnings("rawtypes")

public static Object getObjectProperty(Object obj, Object propName) {

if ( Types.isPropertyTypeMap(obj) ) {

Map map = (Map) obj;

if (map.containsKey(propName))

return map.get(propName);

return Primitive.VOID;

}

if ( Types.isPropertyTypeEntry(obj) ) {

Entry entre = (Entry) obj;

if (propName.equals(entre.getKey()))

return entre.getValue();

return Primitive.VOID;

}

Class<?> cls = obj.getClass();

if ( Types.isPropertyTypeEntryList(cls) ) {

Entry entre = getEntryForKey(propName, (Entry[]) obj);

if ( null != entre )

return entre.getValue();

return Primitive.VOID;

}

if ( obj instanceof Class )

cls = (Class) obj;

Invocable getter = BshClassManager.memberCache.get(cls)

.findGetter(propName.toString());

if ( null == getter ) {

Interpreter.debug("property getter not found");

return Primitive.VOID;

}

try {

return getter.invoke(obj);

} catch(InvocationTargetException e) {

Interpreter.debug("Property accessor threw exception");

return Primitive.VOID;

}

}

@SuppressWarnings("rawtypes")

public static Entry getEntryForKey(Object key, Entry[] entries) {

for ( Entry ntre : entries )

if ( key.equals(ntre.getKey()) )

return ntre;

return null;

}

@SuppressWarnings({"rawtypes", "unchecked"})

public static Object setObjectProperty(

Object obj, String propName, Object value) {

if (Types.isPropertyTypeEntry(obj)) switch(propName) {

case "val": case "value":

return ((Entry) obj).setValue(value);

}

return setObjectProperty(obj, (Object) propName, value);

}

@SuppressWarnings({"rawtypes", "unchecked"})

public static Object setObjectProperty(

Object obj, Object propName, Object value) {

if ( Types.isPropertyTypeMap(obj) )

return ((Map) obj).put(propName, Primitive.unwrap(value));

if ( Types.isPropertyTypeEntry(obj) ) {

Entry entre = (Entry) obj;

if ( propName.equals(entre.getKey()) )

return entre.setValue(Primitive.unwrap(value));

throw new ReflectError("No such property setter: " + propName

+ " for type: " + StringUtil.typeString(obj));

}

Class<?> cls = obj.getClass();

if ( Types.isPropertyTypeEntryList(cls) )

return getEntryForKey(propName, (Entry[]) obj)

.setValue(Primitive.unwrap(value));

if ( obj instanceof Class )

cls = (Class) obj;

Invocable setter = BshClassManager.memberCache.get(cls)

.findSetter(propName.toString());

if ( null == setter )

throw new ReflectError("No such property setter: " + propName

+ " for type: " + StringUtil.typeString(cls));

try {

return setter.invoke(obj, new Object[] { Primitive.unwrap(value) });

} catch(InvocationTargetException e) {

throw new ReflectError("Property accessor threw exception: "

+ e.getCause(), e.getCause());

}

}

/**

public static Object invokeCompiledCommand(

Class<?> commandClass, Object [] args, Interpreter interpreter,

CallStack callstack, Node callerInfo )

throws UtilEvalError

{

// add interpereter and namespace to args list

Object[] invokeArgs = new Object[args.length + 2];

invokeArgs[0] = interpreter;

invokeArgs[1] = callstack;

System.arraycopy( args, 0, invokeArgs, 2, args.length );

BshClassManager bcm = interpreter.getClassManager();

try {

return invokeStaticMethod(

bcm, commandClass, "invoke", invokeArgs, callerInfo );

} catch ( InvocationTargetException e ) {

throw new UtilEvalError(

"Error in compiled command: " + e.getCause(), e );

} catch ( ReflectError e ) {

throw new UtilEvalError("Error invoking compiled command: " + e, e );

}

}

static void logInvokeMethod(String msg, Invocable method, List<Object> params) {

if (Interpreter.DEBUG.get()) {

logInvokeMethod(msg, method, params.toArray());

}

}

static void logInvokeMethod(String msg, Invocable method, Object[] args) {

if (Interpreter.DEBUG.get()) {

Interpreter.debug(msg, method, " with args:");

for (int i = 0; i < args.length; i++) {

final Object arg = args[i];

Interpreter.debug("args[", i, "] = ", arg, " type = ", (arg == null ? "<unknown>" : arg.getClass()));

}

}

}

private static void checkFoundStaticMethod(

Invocable method, boolean staticOnly, Class<?> clas )

throws UtilEvalError

{

// We're looking for a static method but found an instance method

if ( method != null && staticOnly && !method.isStatic() )

throw new UtilEvalError(

"Cannot reach instance method: "

+ StringUtil.methodString(

method.getName(), method.getParameterTypes() )

+ " from static context: "+ clas.getName() );

}

private static ReflectError cantFindConstructor(

Class<?> clas, Class<?>[] types )

{

if ( types.length == 0 )

return new ReflectError(

"Can't find default constructor for: "+clas);

else

return new ReflectError(

"Can't find constructor: "

+ StringUtil.methodString( clas.getName(), types )

+" in class: "+ clas.getName() );

}

/*

public static boolean isGeneratedClass(Class<?> type) {

return null != type && type != GeneratedClass.class

&& GeneratedClass.class.isAssignableFrom(type);

}

/**

public static This getClassStaticThis(Class<?> clas, String className) {

try {

return (This) getStaticFieldValue(clas, BSHSTATIC + className);

} catch (Exception e) {

throw new InterpreterError("Unable to get class static space: " + e, e);

}

}

/**

public static This getClassInstanceThis(Object instance, String className) {

try {

Object o = getObjectFieldValue(instance, BSHTHIS + className);

return (This) Primitive.unwrap(o); // unwrap Primitive.Null to null

} catch (Exception e) {

throw new InterpreterError("Generated class: Error getting This " + e, e);

}

}