src.org.python.compiler.ProxyCodeHelpers Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython Show documentation
Show all versions of jython Show documentation
Jython is an implementation of the high-level, dynamic, object-oriented
language Python written in 100% Pure Java, and seamlessly integrated with
the Java platform. It thus allows you to run Python on any Java platform.
package org.python.compiler;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Map.Entry;
import org.objectweb.asm.Type;
import org.python.core.Py;
import org.python.core.PyMethod;
import org.python.core.PyObject;
import org.python.core.PyProxy;
import org.python.core.PyReflectedFunction;
import org.python.util.Generic;
/*
* Various constants and methods for generating Proxy code
*/
public class ProxyCodeHelpers {
public static final int tBoolean=0;
public static final int tByte=1;
public static final int tShort=2;
public static final int tInteger=3;
public static final int tLong=4;
public static final int tFloat=5;
public static final int tDouble=6;
public static final int tCharacter=7;
public static final int tVoid=8;
public static final int tOther=9;
public static final int tNone=10;
public static Map, Integer> types = fillTypes();
public static Map, Integer> fillTypes() {
Map, Integer> typeMap = Generic.map();
typeMap.put(Boolean.TYPE, tBoolean);
typeMap.put(Byte.TYPE, tByte);
typeMap.put(Short.TYPE, tShort);
typeMap.put(Integer.TYPE, tInteger);
typeMap.put(Long.TYPE, tLong);
typeMap.put(Float.TYPE, tFloat);
typeMap.put(Double.TYPE, tDouble);
typeMap.put(Character.TYPE, tCharacter);
typeMap.put(Void.TYPE, tVoid);
return typeMap;
}
public static int getType(Class c) {
if (c == null) {
return tNone;
}
Object i = types.get(c);
if (i == null) {
return tOther;
} else {
return ((Integer)i);
}
}
/**
* Retrieves name from the PyObject in proxy if it's defined in
* Python. This is a specialized helper function for internal PyProxy use.
*/
public static PyObject findPython(PyProxy proxy, String name) {
PyObject o = proxy._getPyInstance();
if (o == null) {
proxy.__initProxy__(new Object[0]);
o = proxy._getPyInstance();
}
PyObject ret = o.__findattr__(name);
if (ret instanceof PyMethod) {
PyMethod meth = ((PyMethod)ret);
if (meth.__func__ instanceof PyReflectedFunction) {
PyReflectedFunction func = (PyReflectedFunction)meth.__func__;
if (func.nargs > 0 && proxy.getClass() == func.argslist[0].declaringClass) {
// This function is the default return for the proxy type if the Python instance
// hasn't returned something of its own from __findattr__, so do the standard
// Java call on this
return null;
}
}
}
Py.setSystemState(proxy._getPySystemState());
return ret;
}
public static String mapClass(Class c) {
String name = c.getName();
int index = name.indexOf(".");
if (index == -1) {
return name;
}
StringBuffer buf = new StringBuffer(name.length());
int last_index = 0;
while (index != -1) {
buf.append(name.substring(last_index, index));
buf.append("/");
last_index = index+1;
index = name.indexOf(".", last_index);
}
buf.append(name.substring(last_index, name.length()));
return buf.toString();
}
public static String mapType(Class type) {
if (type.isArray())
return "["+mapType(type.getComponentType());
switch (getType(type)) {
case tByte: return "B";
case tCharacter: return "C";
case tDouble: return "D";
case tFloat: return "F";
case tInteger: return "I";
case tLong: return "J";
case tShort: return "S";
case tBoolean: return "Z";
case tVoid: return "V";
default:
return "L"+mapClass(type)+";";
}
}
public static String makeSig(Class ret, Class... sig) {
String[] mapped = new String[sig.length];
for (int i = 0; i < mapped.length; i++) {
mapped[i] = mapType(sig[i]);
}
return makeSig(mapType(ret), mapped);
}
public static String makeSig(String returnType, String... parameterTypes) {
StringBuilder buf = new StringBuilder("(");
for (String param : parameterTypes) {
buf.append(param);
}
return buf.append(')').append(returnType).toString();
}
public static void doReturn(Code code, Class type) throws Exception {
switch (getType(type)) {
case tNone:
break;
case tCharacter:
case tBoolean:
case tByte:
case tShort:
case tInteger:
code.ireturn();
break;
case tLong:
code.lreturn();
break;
case tFloat:
code.freturn();
break;
case tDouble:
code.dreturn();
break;
case tVoid:
code.return_();
break;
default:
code.areturn();
break;
}
}
public static void doNullReturn(Code code, Class type) throws Exception {
switch (getType(type)) {
case tNone:
break;
case tCharacter:
case tBoolean:
case tByte:
case tShort:
case tInteger:
code.iconst_0();
code.ireturn();
break;
case tLong:
code.lconst_0();
code.lreturn();
break;
case tFloat:
code.fconst_0();
code.freturn();
break;
case tDouble:
code.dconst_0();
code.dreturn();
break;
case tVoid:
code.return_();
break;
default:
code.aconst_null();
code.areturn();
break;
}
}
public static String[] mapClasses(Class[] classes) {
String[] mapped = new String[classes.length];
for (int i = 0; i < mapped.length; i++) {
mapped[i] = mapClass(classes[i]);
}
return mapped;
}
public static String[] mapExceptions(Class[] classes) {
String[] exceptionTypes = new String[classes.length];
for (int i = 0; i < classes.length; i++) {
// Exceptions are represented by their internal names
exceptionTypes[i] = Type.getType(classes[i]).getInternalName();
}
return exceptionTypes;
}
public static class MethodDescr {
public final Class returnType;
public final String name;
public final Class[] parameters;
public final Class[] exceptions;
public final Map methodAnnotations;
public final Map[] parameterAnnotations;
public MethodDescr(Method m) {
this(m.getName(), m.getReturnType(), m.getParameterTypes(), m.getExceptionTypes(), null, null);
}
public MethodDescr(String name,
Class returnType,
Class[] parameters,
Class[] exceptions) {
this.name = name;
this.returnType = returnType;
this.parameters = parameters;
this.exceptions = exceptions;
this.methodAnnotations = null;
this.parameterAnnotations = null;
}
public MethodDescr(String name,
Class returnType,
Class[] parameters,
Class[] exceptions,
Map methodAnnotations,
Map[] parameterAnnotations) {
this.name = name;
this.returnType = returnType;
this.parameters = parameters;
this.exceptions = exceptions;
this.methodAnnotations = methodAnnotations;
this.parameterAnnotations = parameterAnnotations;
}
@Override
public int hashCode() {
return name.hashCode() + parameters.length;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof MethodDescr)) {
return false;
}
MethodDescr oDescr = (MethodDescr)obj;
if (!name.equals(oDescr.name) || parameters.length != oDescr.parameters.length) {
return false;
}
for (int i = 0; i < parameters.length; i++) {
if (!parameters[i].equals(oDescr.parameters[i])) {
return false;
}
}
return true;
}
}
public static class ConstructorDescr extends MethodDescr {
public ConstructorDescr(Constructor cons) {
this(cons.getParameterTypes(), cons.getExceptionTypes());
}
public ConstructorDescr(Class[] parameters, Class[] exceptions) {
super("", Void.TYPE, parameters, exceptions);
}
}
public static class AnnotationDescr {
public final Class annotation;
public final Map fields;
public AnnotationDescr(Classannotation) {
this.annotation = annotation;
this.fields = null;
}
public AnnotationDescr(Classannotation, Map fields) {
this.annotation = annotation;
this.fields = fields;
}
public boolean hasFields() {
if (fields == null) {
return false;
}
return true;
}
public String getName() {
return mapType(annotation);
}
public Map getFields() {
return fields;
}
@Override
public int hashCode() {
if (hasFields()) {
int hash = annotation.hashCode();
for (Entry field: fields.entrySet()) {
hash += field.getKey().hashCode() + field.getValue().hashCode();
}
return hash;
} else {
return annotation.hashCode();
}
}
}
}