Exemple #1
0
        Java.Constants.MethodRef IByRefController.GetFieldByRefCtorMethodRef(InterType type)
        {
            JavaByRefType byRefType = new JavaByRefType(ByRefPlace.Field, JavaHelpers.InterTypeToJavaPrimitive(type));

            return(new Java.Constants.MethodRef(
                       TypeNameToJava(byRefType.ToString()),
                       ClassNames.JavaConstructorMethodName,
                       ClassNames.ByRef.FieldCtorDescriptor));
        }
Exemple #2
0
        string IByRefController.GetArrayByRefTypeName(InterType type)
        {
            JavaByRefType byRefType = new JavaByRefType(ByRefPlace.Array, JavaHelpers.InterTypeToJavaPrimitive(type));

            if (!byRefToGenerate.Contains(byRefType))
            {
                byRefToGenerate.Add(byRefType);
            }

            return(byRefType.ToString());
        }
Exemple #3
0
        Java.Constants.MethodRef IByRefController.GetByRefSetValueMethodRef(JavaPrimitiveType type)
        {
            JavaByRefType byRefType = new JavaByRefType(ByRefPlace.Unknown, type);
            string        descr     = "L" + TypeNameToJava(ClassNames.JavaObject) + ";";

            if (type != JavaPrimitiveType.Ref)
            {
                descr = JavaPrimitive2FieldChar[(int)type].ToString();
            }

            return(new Java.Constants.MethodRef(
                       TypeNameToJava(byRefType.ToString()),
                       ClassNames.ByRef.SetValueMethodName,
                       "(" + descr + ")V"));
        }
Exemple #4
0
        private string GetByRefTypeName(InterType byRefType)
        {
            while (byRefType.IsByRef)
            {
                byRefType = byRefType.ElementType;
            }

            JavaByRefType javaType = new JavaByRefType(ByRefPlace.Unknown, JavaHelpers.InterTypeToJavaPrimitive(byRefType));

            if (!byRefToGenerate.Contains(javaType))
            {
                byRefToGenerate.Add(javaType);
            }

            return(javaType.ToString());
        }
Exemple #5
0
        Java.Constants.MethodRef IByRefController.GetArrayByRefCtorMethodRef(InterType type)
        {
            JavaByRefType byRefType = new JavaByRefType(ByRefPlace.Array, JavaHelpers.InterTypeToJavaPrimitive(type));

            string typeDescr = "[L" + TypeNameToJava(ClassNames.JavaObject) + ";";

            if (byRefType.type != JavaPrimitiveType.Ref)
            {
                typeDescr = "[" + GetFieldDescriptor(type);
            }

            return(new Java.Constants.MethodRef(
                       TypeNameToJava(byRefType.ToString()),
                       ClassNames.JavaConstructorMethodName,
                       "(" + typeDescr + "I)V"));
        }
Exemple #6
0
        Java.Constants.MethodRef IByRefController.GetLocalByRefCtorMethodRef(InterType type)
        {
            JavaByRefType byRefType = new JavaByRefType(ByRefPlace.Local, JavaHelpers.InterTypeToJavaPrimitive(type));

            string descr = "L" + TypeNameToJava(ClassNames.JavaObject) + ";";

            if (byRefType.type != JavaPrimitiveType.Ref)
            {
                descr = JavaPrimitive2FieldChar[(int)byRefType.type].ToString();
            }

            return(new Java.Constants.MethodRef(
                       TypeNameToJava(byRefType.ToString()),
                       ClassNames.JavaConstructorMethodName,
                       "(" + descr + ")V"));
        }
Exemple #7
0
        InterType IResolver.Resolve(TypeReference typeRef, List <InterGenericArgument> genericArgs)
        {
            if (typeRef is RequiredModifierType)
            {
                typeRef = ((RequiredModifierType)typeRef).ElementType;
            }
            if (typeRef is OptionalModifierType)
            {
                typeRef = ((OptionalModifierType)typeRef).ElementType;
            }

            InterType primitive = null;

            switch (typeRef.MetadataType)
            {
            case MetadataType.Boolean: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.Bool]; break;

            case MetadataType.Byte: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.Byte]; break;

            case MetadataType.Char: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.Char]; break;

            case MetadataType.Double: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.Double]; break;

            case MetadataType.Int16: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.Int16]; break;

            case MetadataType.Int32: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.Int32]; break;

            case MetadataType.Int64: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.Int64]; break;

            case MetadataType.IntPtr: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.IntPtr]; break;

            case MetadataType.SByte: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.SByte]; break;

            case MetadataType.Single: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.Single]; break;

            case MetadataType.UInt16: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.UInt16]; break;

            case MetadataType.UInt32: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.UInt32]; break;

            case MetadataType.UInt64: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.UInt64]; break;

            case MetadataType.UIntPtr: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.UIntPtr]; break;

            case MetadataType.Void: primitive = InterType.PrimitiveTypes[(int)PrimitiveType.Void]; break;
            }

            if (primitive != null)
            {
                if (typesToCompile.Where(T => T.Fullname == primitive.Fullname).Count() == 0)
                {
                    typesToCompile.Add(primitive);
                }
                return(primitive);
            }

            if (!loadedModules.Contains(typeRef.Module))
            {
                loadedModules.Add(typeRef.Module);
            }

            InterType toReturn = null;
            InterType toAdd    = new InterType(typeRef, genericArgs, this, T =>
            {
                if (T.IsPrimitive)
                {
                    toReturn = T;
                    return(false);
                }

                toReturn = typesToCompile.Where(inter => inter.Fullname == T.Fullname).FirstOrDefault();
                if (toReturn != null)
                {
                    return(false);
                }
                else
                {
                    Messages.Verbose("Adding type {0} to compile...", T.ToString());
                    typesToCompile.Add(T);
                    toReturn = T;
                    return(true);
                }
            });

            if ((toReturn != null) && (toReturn.IsByRef))
            {
                JavaPrimitiveType jp   = JavaHelpers.InterTypeToJavaPrimitive(toReturn.ElementType);
                JavaByRefType     jbrt = new JavaByRefType(ByRefPlace.Unknown, jp);
                if (!byRefToGenerate.Contains(jbrt))
                {
                    byRefToGenerate.Add(jbrt);
                }
            }

            return(toReturn);
        }