azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

enums for primitive types and fix stdlib.jar reading

Browse Source 
* PrimitiveType and JvmPrimitiveType enums

* roll up for-each-enum copy-paste lines into loop by enum values

* finish JetStandardLibrary.getPrimitiveArrayJetTypeByPrimitiveJetType for all primitive types
that fixes stdlib.jar loading
This commit is contained in:
Stepan Koltsov
2012-01-11 19:36:55 +04:00
parent 046a92ed7a
commit fbc7f60af1
11 changed files with 334 additions and 624 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java
+31 -157
View File
@@ -14,6 +14,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.JavaNamespaceDescriptor;
import org.jetbrains.jet.lang.resolve.java.JvmAbi;
import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lexer.JetTokens;
@@ -35,27 +36,11 @@ public class JetTypeMapper {
public static final Type TYPE_TYPEINFOPROJECTION = Type.getType(TypeInfoProjection.class);
public static final Type TYPE_JET_OBJECT = Type.getType(JetObject.class);
public static final Type TYPE_NOTHING = Type.getObjectType("jet/Nothing");
public static final Type JL_INTEGER_TYPE = Type.getObjectType("java/lang/Integer");
public static final Type JL_LONG_TYPE = Type.getObjectType("java/lang/Long");
public static final Type JL_SHORT_TYPE = Type.getObjectType("java/lang/Short");
public static final Type JL_BYTE_TYPE = Type.getObjectType("java/lang/Byte");
public static final Type JL_CHAR_TYPE = Type.getObjectType("java/lang/Character");
public static final Type JL_FLOAT_TYPE = Type.getObjectType("java/lang/Float");
public static final Type JL_DOUBLE_TYPE = Type.getObjectType("java/lang/Double");
public static final Type JL_BOOLEAN_TYPE = Type.getObjectType("java/lang/Boolean");
public static final Type JL_NUMBER_TYPE = Type.getObjectType("java/lang/Number");
public static final Type JL_STRING_BUILDER = Type.getObjectType("java/lang/StringBuilder");
public static final Type JL_STRING_TYPE = Type.getObjectType("java/lang/String");
private static final Type JL_COMPARABLE_TYPE = Type.getObjectType("java/lang/Comparable");
public static final Type ARRAY_INT_TYPE = Type.getType(int[].class);
public static final Type ARRAY_LONG_TYPE = Type.getType(long[].class);
public static final Type ARRAY_SHORT_TYPE = Type.getType(short[].class);
public static final Type ARRAY_BYTE_TYPE = Type.getType(byte[].class);
public static final Type ARRAY_CHAR_TYPE = Type.getType(char[].class);
public static final Type ARRAY_FLOAT_TYPE = Type.getType(float[].class);
public static final Type ARRAY_DOUBLE_TYPE = Type.getType(double[].class);
public static final Type ARRAY_BOOL_TYPE = Type.getType(boolean[].class);
public static final Type ARRAY_GENERIC_TYPE = Type.getType(Object[].class);
private final JetStandardLibrary standardLibrary;
@@ -77,14 +62,6 @@ public class JetTypeMapper {
public static final Type TYPE_SHARED_CHAR = Type.getObjectType("jet/runtime/SharedVar$Char");
public static final Type TYPE_SHARED_LONG = Type.getObjectType("jet/runtime/SharedVar$Long");
public static final Type TYPE_SHARED_BOOLEAN = Type.getObjectType("jet/runtime/SharedVar$Boolean");
public static final Type TYPE_BOOLEAN_ITERATOR = Type.getObjectType("jet/BooleanIterator");
public static final Type TYPE_CHAR_ITERATOR = Type.getObjectType("jet/CharIterator");
public static final Type TYPE_BYTE_ITERATOR = Type.getObjectType("jet/ByteIterator");
public static final Type TYPE_SHORT_ITERATOR = Type.getObjectType("jet/ShortIterator");
public static final Type TYPE_INT_ITERATOR = Type.getObjectType("jet/IntIterator");
public static final Type TYPE_LONG_ITERATOR = Type.getObjectType("jet/LongIterator");
public static final Type TYPE_FLOAT_ITERATOR = Type.getObjectType("jet/FloatIterator");
public static final Type TYPE_DOUBLE_ITERATOR = Type.getObjectType("jet/DoubleIterator");
public static final Type TYPE_FUNCTION0 = Type.getObjectType("jet/Function0");
public static final Type TYPE_FUNCTION1 = Type.getObjectType("jet/Function1");
@@ -107,28 +84,6 @@ public class JetTypeMapper {
return type.getSort() != Type.OBJECT && type.getSort() != Type.ARRAY;
}
public static Type getBoxedType(final Type type) {
switch (type.getSort()) {
case Type.BYTE:
return JL_BYTE_TYPE;
case Type.BOOLEAN:
return JL_BOOLEAN_TYPE;
case Type.SHORT:
return JL_SHORT_TYPE;
case Type.CHAR:
return JL_CHAR_TYPE;
case Type.INT:
return JL_INTEGER_TYPE;
case Type.FLOAT:
return JL_FLOAT_TYPE;
case Type.LONG:
return JL_LONG_TYPE;
case Type.DOUBLE:
return JL_DOUBLE_TYPE;
}
return type;
}
public static Type correctElementType(Type type) {
String internalName = type.getInternalName();
assert internalName.charAt(0) == '[';
@@ -378,56 +333,21 @@ public class JetTypeMapper {
}
public static Type unboxType(final Type type) {
if (type == JL_INTEGER_TYPE) {
return Type.INT_TYPE;
JvmPrimitiveType jvmPrimitiveType = JvmPrimitiveType.getByWrapperAsmType(type);
if (jvmPrimitiveType != null) {
return jvmPrimitiveType.getAsmType();
} else {
throw new UnsupportedOperationException("Unboxing: " + type);
}
else if (type == JL_BOOLEAN_TYPE) {
return Type.BOOLEAN_TYPE;
}
else if (type == JL_CHAR_TYPE) {
return Type.CHAR_TYPE;
}
else if (type == JL_SHORT_TYPE) {
return Type.SHORT_TYPE;
}
else if (type == JL_LONG_TYPE) {
return Type.LONG_TYPE;
}
else if (type == JL_BYTE_TYPE) {
return Type.BYTE_TYPE;
}
else if (type == JL_FLOAT_TYPE) {
return Type.FLOAT_TYPE;
}
else if (type == JL_DOUBLE_TYPE) {
return Type.DOUBLE_TYPE;
}
throw new UnsupportedOperationException("Unboxing: " + type);
}
public static Type boxType(Type asmType) {
switch (asmType.getSort()) {
case Type.VOID:
return Type.VOID_TYPE;
case Type.BYTE:
return JL_BYTE_TYPE;
case Type.BOOLEAN:
return JL_BOOLEAN_TYPE;
case Type.SHORT:
return JL_SHORT_TYPE;
case Type.CHAR:
return JL_CHAR_TYPE;
case Type.INT:
return JL_INTEGER_TYPE;
case Type.FLOAT:
return JL_FLOAT_TYPE;
case Type.LONG:
return JL_LONG_TYPE;
case Type.DOUBLE:
return JL_DOUBLE_TYPE;
JvmPrimitiveType jvmPrimitiveType = JvmPrimitiveType.getByAsmType(asmType);
if (jvmPrimitiveType != null) {
return jvmPrimitiveType.getWrapper().getAsmType();
} else {
return asmType;
}
return asmType;
}
public CallableMethod mapToCallableMethod(FunctionDescriptor functionDescriptor, boolean superCall, OwnerKind kind) {
@@ -802,85 +722,39 @@ public class JetTypeMapper {
private void initKnownTypeNames() {
knowTypeNames.put(JetStandardClasses.getAnyType(), "ANY_TYPE_INFO");
knowTypeNames.put(JetStandardClasses.getNullableAnyType(), "NULLABLE_ANY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getIntType(), "INT_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableIntType(), "NULLABLE_INT_TYPE_INFO");
knowTypeNames.put(standardLibrary.getLongType(), "LONG_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableLongType(), "NULLABLE_LONG_TYPE_INFO");
knowTypeNames.put(standardLibrary.getShortType(),"SHORT_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableShortType(),"NULLABLE_SHORT_TYPE_INFO");
knowTypeNames.put(standardLibrary.getByteType(),"BYTE_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableByteType(),"NULLABLE_BYTE_TYPE_INFO");
knowTypeNames.put(standardLibrary.getCharType(),"CHAR_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableCharType(),"NULLABLE_CHAR_TYPE_INFO");
knowTypeNames.put(standardLibrary.getFloatType(),"FLOAT_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableFloatType(),"NULLABLE_FLOAT_TYPE_INFO");
knowTypeNames.put(standardLibrary.getDoubleType(),"DOUBLE_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableDoubleType(),"NULLABLE_DOUBLE_TYPE_INFO");
knowTypeNames.put(standardLibrary.getBooleanType(),"BOOLEAN_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableBooleanType(),"NULLABLE_BOOLEAN_TYPE_INFO");
for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
knowTypeNames.put(standardLibrary.getPrimitiveJetType(primitiveType), jvmPrimitiveType.name() + "_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullablePrimitiveJetType(primitiveType), "NULLABLE_" + jvmPrimitiveType.name() + "_TYPE_INFO");
knowTypeNames.put(standardLibrary.getPrimitiveArrayJetType(primitiveType), jvmPrimitiveType.name() + "_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullablePrimitiveArrayJetType(primitiveType), jvmPrimitiveType.name() + "_ARRAY_TYPE_INFO");
}
knowTypeNames.put(standardLibrary.getStringType(),"STRING_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableStringType(),"NULLABLE_STRING_TYPE_INFO");
knowTypeNames.put(standardLibrary.getTuple0Type(),"TUPLE0_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableTuple0Type(),"NULLABLE_TUPLE0_TYPE_INFO");
knowTypeNames.put(standardLibrary.getIntArrayType(), "INT_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getLongArrayType(), "LONG_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getShortArrayType(),"SHORT_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getByteArrayType(),"BYTE_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getCharArrayType(),"CHAR_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getFloatArrayType(),"FLOAT_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getDoubleArrayType(),"DOUBLE_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getBooleanArrayType(),"BOOLEAN_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableIntArrayType(), "INT_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableLongArrayType(), "LONG_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableShortArrayType(),"SHORT_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableByteArrayType(),"BYTE_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableCharArrayType(),"CHAR_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableFloatArrayType(),"FLOAT_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableDoubleArrayType(),"DOUBLE_ARRAY_TYPE_INFO");
knowTypeNames.put(standardLibrary.getNullableBooleanArrayType(),"BOOLEAN_ARRAY_TYPE_INFO");
}
private void initKnownTypes() {
knowTypes.put(JetStandardClasses.getNothingType(), TYPE_NOTHING);
knowTypes.put(JetStandardClasses.getNullableNothingType(), TYPE_NOTHING);
knowTypes.put(standardLibrary.getIntType(), Type.INT_TYPE);
knowTypes.put(standardLibrary.getNullableIntType(), JL_INTEGER_TYPE);
knowTypes.put(standardLibrary.getLongType(), Type.LONG_TYPE);
knowTypes.put(standardLibrary.getNullableLongType(), JL_LONG_TYPE);
knowTypes.put(standardLibrary.getShortType(),Type.SHORT_TYPE);
knowTypes.put(standardLibrary.getNullableShortType(),JL_SHORT_TYPE);
knowTypes.put(standardLibrary.getByteType(),Type.BYTE_TYPE);
knowTypes.put(standardLibrary.getNullableByteType(),JL_BYTE_TYPE);
knowTypes.put(standardLibrary.getCharType(),Type.CHAR_TYPE);
knowTypes.put(standardLibrary.getNullableCharType(),JL_CHAR_TYPE);
knowTypes.put(standardLibrary.getFloatType(),Type.FLOAT_TYPE);
knowTypes.put(standardLibrary.getNullableFloatType(),JL_FLOAT_TYPE);
knowTypes.put(standardLibrary.getDoubleType(),Type.DOUBLE_TYPE);
knowTypes.put(standardLibrary.getNullableDoubleType(),JL_DOUBLE_TYPE);
knowTypes.put(standardLibrary.getBooleanType(),Type.BOOLEAN_TYPE);
knowTypes.put(standardLibrary.getNullableBooleanType(),JL_BOOLEAN_TYPE);
for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
knowTypes.put(standardLibrary.getPrimitiveJetType(primitiveType), jvmPrimitiveType.getAsmType());
knowTypes.put(standardLibrary.getNullablePrimitiveJetType(primitiveType), jvmPrimitiveType.getWrapper().getAsmType());
}
knowTypes.put(standardLibrary.getStringType(),JL_STRING_TYPE);
knowTypes.put(standardLibrary.getNullableStringType(),JL_STRING_TYPE);
knowTypes.put(standardLibrary.getIntArrayType(), ARRAY_INT_TYPE);
knowTypes.put(standardLibrary.getLongArrayType(), ARRAY_LONG_TYPE);
knowTypes.put(standardLibrary.getShortArrayType(),ARRAY_SHORT_TYPE);
knowTypes.put(standardLibrary.getByteArrayType(),ARRAY_BYTE_TYPE);
knowTypes.put(standardLibrary.getCharArrayType(),ARRAY_CHAR_TYPE);
knowTypes.put(standardLibrary.getFloatArrayType(),ARRAY_FLOAT_TYPE);
knowTypes.put(standardLibrary.getDoubleArrayType(),ARRAY_DOUBLE_TYPE);
knowTypes.put(standardLibrary.getBooleanArrayType(),ARRAY_BOOL_TYPE);
knowTypes.put(standardLibrary.getNullableIntArrayType(), ARRAY_INT_TYPE);
knowTypes.put(standardLibrary.getNullableLongArrayType(), ARRAY_LONG_TYPE);
knowTypes.put(standardLibrary.getNullableShortArrayType(),ARRAY_SHORT_TYPE);
knowTypes.put(standardLibrary.getNullableByteArrayType(),ARRAY_BYTE_TYPE);
knowTypes.put(standardLibrary.getNullableCharArrayType(),ARRAY_CHAR_TYPE);
knowTypes.put(standardLibrary.getNullableFloatArrayType(),ARRAY_FLOAT_TYPE);
knowTypes.put(standardLibrary.getNullableDoubleArrayType(),ARRAY_DOUBLE_TYPE);
knowTypes.put(standardLibrary.getNullableBooleanArrayType(),ARRAY_BOOL_TYPE);
for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
knowTypes.put(standardLibrary.getPrimitiveArrayJetType(primitiveType), jvmPrimitiveType.getAsmArrayType());
knowTypes.put(standardLibrary.getNullablePrimitiveArrayJetType(primitiveType), jvmPrimitiveType.getAsmArrayType());
}
}
public String isKnownTypeInfo(JetType jetType) {
compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java
+4 -3
View File
@@ -7,6 +7,7 @@ import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.resolve.calls.ResolvedCall;
import org.jetbrains.jet.lang.resolve.java.JvmAbi;
import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lexer.JetTokens;
@@ -36,7 +37,7 @@ public abstract class StackValue {
if (type == Type.VOID_TYPE) {
instructionAdapter.aconst(null);
} else {
Type boxed = JetTypeMapper.getBoxedType(type);
Type boxed = JetTypeMapper.boxType(type);
instructionAdapter.invokestatic(boxed.getInternalName(), "valueOf", "(" + type.getDescriptor() + ")" + boxed.getDescriptor());
}
}
@@ -209,10 +210,10 @@ public abstract class StackValue {
else if (this.type.getSort() == Type.OBJECT && type.getSort() <= Type.DOUBLE) {
if (this.type.equals(JetTypeMapper.TYPE_OBJECT)) {
if (type.getSort() == Type.BOOLEAN) {
v.checkcast(JetTypeMapper.JL_BOOLEAN_TYPE);
v.checkcast(JvmPrimitiveType.BOOLEAN.getWrapper().getAsmType());
}
else if (type.getSort() == Type.CHAR) {
v.checkcast(JetTypeMapper.JL_CHAR_TYPE);
v.checkcast(JvmPrimitiveType.CHAR.getWrapper().getAsmType());
}
else {
v.checkcast(JetTypeMapper.JL_NUMBER_TYPE);
compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java
+12 -34
View File
@@ -10,7 +10,9 @@ import org.jetbrains.jet.lang.psi.JetCallExpression;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
import org.jetbrains.jet.lang.types.JetStandardLibrary;
import org.jetbrains.jet.lang.types.PrimitiveType;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.InstructionAdapter;
@@ -31,40 +33,16 @@ public class ArrayIterator implements IntrinsicMethod {
codegen.generateTypeInfo(funDescriptor.getReturnType().getArguments().get(0).getType(), null);
v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([Ljava/lang/Object;Ljet/TypeInfo;)Ljet/Iterator;");
return StackValue.onStack(JetTypeMapper.TYPE_ITERATOR);
}
else if(containingDeclaration.equals(standardLibrary.getByteArrayClass())) {
v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([B)Ljet/ByteIterator;");
return StackValue.onStack(JetTypeMapper.TYPE_BYTE_ITERATOR);
}
else if(containingDeclaration.equals(standardLibrary.getShortArrayClass())) {
v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([S)Ljet/ShortIterator;");
return StackValue.onStack(JetTypeMapper.TYPE_SHORT_ITERATOR);
}
else if(containingDeclaration.equals(standardLibrary.getIntArrayClass())) {
v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([I)Ljet/IntIterator;");
return StackValue.onStack(JetTypeMapper.TYPE_INT_ITERATOR);
}
else if(containingDeclaration.equals(standardLibrary.getLongArrayClass())) {
v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([J)Ljet/LongIterator;");
return StackValue.onStack(JetTypeMapper.TYPE_LONG_ITERATOR);
}
else if(containingDeclaration.equals(standardLibrary.getFloatArrayClass())) {
v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([F)Ljet/FloatIterator;");
return StackValue.onStack(JetTypeMapper.TYPE_FLOAT_ITERATOR);
}
else if(containingDeclaration.equals(standardLibrary.getDoubleArrayClass())) {
v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([D)Ljet/DoubleIterator;");
return StackValue.onStack(JetTypeMapper.TYPE_DOUBLE_ITERATOR);
}
else if(containingDeclaration.equals(standardLibrary.getCharArrayClass())) {
v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([C)Ljet/CharIterator;");
return StackValue.onStack(JetTypeMapper.TYPE_CHAR_ITERATOR);
}
else if(containingDeclaration.equals(standardLibrary.getBooleanArrayClass())) {
v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([Z)Ljet/BooleanIterator;");
return StackValue.onStack(JetTypeMapper.TYPE_BOOLEAN_ITERATOR);
}
else {
} else {
for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
ClassDescriptor arrayClass = standardLibrary.getPrimitiveArrayClassDescriptor(primitiveType);
if (containingDeclaration.equals(arrayClass)) {
String methodSignature = "([" + jvmPrimitiveType.getJvmLetter() + ")" + jvmPrimitiveType.getIterator().getDescriptor();
v.invokestatic("jet/runtime/ArrayIterator", "iterator", methodSignature);
return StackValue.onStack(jvmPrimitiveType.getIterator().getAsmType());
}
}
throw new UnsupportedOperationException(containingDeclaration.toString());
}
}
compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
+16 -44
View File
@@ -9,9 +9,11 @@ import com.intellij.psi.PsiMethod;
import com.intellij.psi.search.DelegatingGlobalSearchScope;
import com.intellij.psi.search.ProjectScope;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.JetStandardClasses;
import org.jetbrains.jet.lang.types.JetStandardLibrary;
import org.jetbrains.jet.lang.types.PrimitiveType;
import org.jetbrains.jet.lang.types.TypeProjection;
import org.jetbrains.jet.plugin.JetFileType;
import org.objectweb.asm.Opcodes;
@@ -118,55 +120,25 @@ public class IntrinsicMethods {
}
private void declareArrayMethods() {
for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
declareArrayMethodsForPrimitive(jvmPrimitiveType);
}
declareIntrinsicProperty("Array", "size", ARRAY_SIZE);
declareIntrinsicProperty("ByteArray", "size", ARRAY_SIZE);
declareIntrinsicProperty("ShortArray", "size", ARRAY_SIZE);
declareIntrinsicProperty("IntArray", "size", ARRAY_SIZE);
declareIntrinsicProperty("LongArray", "size", ARRAY_SIZE);
declareIntrinsicProperty("FloatArray", "size", ARRAY_SIZE);
declareIntrinsicProperty("DoubleArray", "size", ARRAY_SIZE);
declareIntrinsicProperty("CharArray", "size", ARRAY_SIZE);
declareIntrinsicProperty("BooleanArray", "size", ARRAY_SIZE);
declareIntrinsicProperty("Array", "indices", ARRAY_INDICES);
declareIntrinsicProperty("ByteArray", "indices", ARRAY_INDICES);
declareIntrinsicProperty("ShortArray", "indices", ARRAY_INDICES);
declareIntrinsicProperty("IntArray", "indices", ARRAY_INDICES);
declareIntrinsicProperty("LongArray", "indices", ARRAY_INDICES);
declareIntrinsicProperty("FloatArray", "indices", ARRAY_INDICES);
declareIntrinsicProperty("DoubleArray", "indices", ARRAY_INDICES);
declareIntrinsicProperty("CharArray", "indices", ARRAY_INDICES);
declareIntrinsicProperty("BooleanArray", "indices", ARRAY_INDICES);
declareIntrinsicFunction("Array", "set", 2, ARRAY_SET);
declareIntrinsicFunction("ByteArray", "set", 2, ARRAY_SET);
declareIntrinsicFunction("ShortArray", "set", 2, ARRAY_SET);
declareIntrinsicFunction("IntArray", "set", 2, ARRAY_SET);
declareIntrinsicFunction("LongArray", "set", 2, ARRAY_SET);
declareIntrinsicFunction("FloatArray", "set", 2, ARRAY_SET);
declareIntrinsicFunction("DoubleArray", "set", 2, ARRAY_SET);
declareIntrinsicFunction("CharArray", "set", 2, ARRAY_SET);
declareIntrinsicFunction("BooleanArray", "set", 2, ARRAY_SET);
declareIntrinsicFunction("Array", "get", 1, ARRAY_GET);
declareIntrinsicFunction("ByteArray", "get", 1, ARRAY_GET);
declareIntrinsicFunction("ShortArray", "get", 1, ARRAY_GET);
declareIntrinsicFunction("IntArray", "get", 1, ARRAY_GET);
declareIntrinsicFunction("LongArray", "get", 1, ARRAY_GET);
declareIntrinsicFunction("FloatArray", "get", 1, ARRAY_GET);
declareIntrinsicFunction("DoubleArray", "get", 1, ARRAY_GET);
declareIntrinsicFunction("CharArray", "get", 1, ARRAY_GET);
declareIntrinsicFunction("BooleanArray", "get", 1, ARRAY_GET);
declareIterator(myStdLib.getArray());
declareIterator(myStdLib.getByteArrayClass());
declareIterator(myStdLib.getShortArrayClass());
declareIterator(myStdLib.getIntArrayClass());
declareIterator(myStdLib.getLongArrayClass());
declareIterator(myStdLib.getFloatArrayClass());
declareIterator(myStdLib.getDoubleArrayClass());
declareIterator(myStdLib.getCharArrayClass());
declareIterator(myStdLib.getBooleanArrayClass());
}
private void declareArrayMethodsForPrimitive(JvmPrimitiveType jvmPrimitiveType) {
PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
declareIntrinsicProperty(primitiveType.getArrayTypeName(), "size", ARRAY_SIZE);
declareIntrinsicProperty(primitiveType.getArrayTypeName(), "indices", ARRAY_INDICES);
declareIntrinsicFunction(primitiveType.getArrayTypeName(), "set", 2, ARRAY_SET);
declareIntrinsicFunction(primitiveType.getArrayTypeName(), "get", 1, ARRAY_GET);
declareIterator(myStdLib.getPrimitiveArrayClassDescriptor(primitiveType));
}
private void declareIterator(ClassDescriptor classDescriptor) {