Пример #1
0
 internal static string Type(System.Type type, bool dropNamespaces = false)
 {
     string assemblyQualifiedName;
     Exception exception;
     if (type == null)
     {
         return string.Empty;
     }
     if (type.IsGenericType && !type.IsGenericTypeDefinition)
     {
         string str2 = Type(type.GetGenericTypeDefinition(), dropNamespaces);
         int num = str2.LastIndexOf('`');
         int length = str2.Length - (str2.Length - num);
         StringBuilder builder = new StringBuilder(str2, 0, length, 0x200);
         builder.Append('[');
         bool flag = true;
         foreach (System.Type type2 in type.GetGenericArguments())
         {
             if (!flag)
             {
                 builder.Append(',');
             }
             flag = false;
             builder.Append(Type(type2, dropNamespaces));
         }
         builder.Append(']');
         assemblyQualifiedName = builder.ToString();
     }
     else if (type.IsArray)
     {
         string str3 = Type(type.GetElementType(), dropNamespaces);
         StringBuilder builder2 = new StringBuilder(str3, str3.Length + 10);
         builder2.Append("[");
         for (int i = 0; i < (type.GetArrayRank() - 1); i++)
         {
             builder2.Append(",");
         }
         builder2.Append("]");
         assemblyQualifiedName = builder2.ToString();
     }
     else
     {
         assemblyQualifiedName = TypeAccelerators.FindBuiltinAccelerator(type) ?? (dropNamespaces ? type.Name : type.ToString());
     }
     if ((!type.IsGenericParameter && !type.ContainsGenericParameters) && (!dropNamespaces && (LanguagePrimitives.ConvertStringToType(assemblyQualifiedName, out exception) != type)))
     {
         assemblyQualifiedName = type.AssemblyQualifiedName;
     }
     return assemblyQualifiedName;
 }
 private static string ProcessArray(System.Type type, WsdlGenerator.XMLNamespace xns)
 {
     string wireQname = null;
     bool flag = false;
     System.Type elementType = type.GetElementType();
     string str2 = "ArrayOf";
     while (elementType.IsArray)
     {
         str2 = str2 + "ArrayOf";
         elementType = elementType.GetElementType();
     }
     wireQname = TypeName(elementType, true, xns);
     int index = wireQname.IndexOf(":");
     wireQname.Substring(0, index);
     string str3 = wireQname.Substring(index + 1);
     int arrayRank = type.GetArrayRank();
     string str4 = "";
     if (arrayRank > 1)
     {
         str4 = arrayRank.ToString(CultureInfo.InvariantCulture);
     }
     string name = (str2 + str3.Substring(0, 1).ToUpper(CultureInfo.InvariantCulture) + str3.Substring(1) + str4).Replace('+', 'N');
     if (xns.LookupArraySchemaType(name) == null)
     {
         WsdlGenerator.ArraySchemaType asType = new WsdlGenerator.ArraySchemaType(type, name, SchemaBlockType.ComplexContent, false);
         WsdlGenerator.Restriction particle = new WsdlGenerator.Restriction();
         WsdlGenerator.SchemaAttribute attribute = new WsdlGenerator.SchemaAttribute();
         if (flag)
         {
             attribute.AddArray(wireQname);
         }
         else
         {
             string str6 = type.Name;
             index = str6.IndexOf("[");
             attribute.AddArray(wireQname + str6.Substring(index));
         }
         particle.AddArray(attribute);
         asType.AddParticle(particle);
         xns.AddArraySchemaType(asType);
     }
     return (xns.Prefix + ":" + name);
 }
Пример #3
0
		private Type ImportImpl(System.Type type)
		{
			if (type.Assembly == typeof(IKVM.Reflection.Type).Assembly)
			{
				throw new ArgumentException("Did you really want to import " + type.FullName + "?");
			}
			if (type.HasElementType)
			{
				if (type.IsArray)
				{
					if (type.Name.EndsWith("[]"))
					{
						return Import(type.GetElementType()).MakeArrayType();
					}
					else
					{
						return Import(type.GetElementType()).MakeArrayType(type.GetArrayRank());
					}
				}
				else if (type.IsByRef)
				{
					return Import(type.GetElementType()).MakeByRefType();
				}
				else if (type.IsPointer)
				{
					return Import(type.GetElementType()).MakePointerType();
				}
				else
				{
					throw new InvalidOperationException();
				}
			}
			else if (type.IsGenericParameter)
			{
				if (type.DeclaringMethod != null)
				{
					throw new NotImplementedException();
				}
				else
				{
					return Import(type.DeclaringType).GetGenericArguments()[type.GenericParameterPosition];
				}
			}
			else if (type.IsGenericType && !type.IsGenericTypeDefinition)
			{
				System.Type[] args = type.GetGenericArguments();
				Type[] importedArgs = new Type[args.Length];
				for (int i = 0; i < args.Length; i++)
				{
					importedArgs[i] = Import(args[i]);
				}
				return Import(type.GetGenericTypeDefinition()).MakeGenericType(importedArgs);
			}
			else
			{
				return Import(type.Assembly).GetType(type.FullName);
			}
		}
 internal System.Type ToReferenceContext(System.Type type)
 {
     if (this.InReferenceContext(type))
     {
         return type;
     }
     if (type.IsArray)
     {
         return Microsoft.JScript.Convert.ToType(Microsoft.JScript.TypedArray.ToRankString(type.GetArrayRank()), this.ToReferenceContext(type.GetElementType()));
     }
     return this.JScriptReferenceModule.ResolveType(type.MetadataToken, null, null);
 }
Пример #5
0
        private static Hashtable typeMap; //contains weak references

        /// <summary>
        /// Gets a TypeNode instance corresponding to the given System.Type instance.
        /// </summary>
        /// <param name="type">A runtime type.</param>
        /// <returns>A TypeNode instance.</returns>
        public static TypeNode GetTypeNode(System.Type type)
        {
            if(type == null)
                return null;
            Hashtable typeMap = TypeNode.typeMap;
            if(typeMap == null)
                TypeNode.typeMap = typeMap = Hashtable.Synchronized(new Hashtable());
            TypeNode result = null;
            WeakReference wr = (WeakReference)typeMap[type];
            if(wr != null)
            {
                result = wr.Target as TypeNode;
                if(result == Class.DoesNotExist)
                    return null;
                if(result != null)
                    return result;
            }

            if(type.IsGenericType && !type.IsGenericTypeDefinition)
            {
                try
                {
                    TypeNode template = TypeNode.GetTypeNode(type.GetGenericTypeDefinition());
                    if(template == null)
                        return null;
                    TypeNodeList templateArguments = new TypeNodeList();
                    foreach(Type arg in type.GetGenericArguments())
                        templateArguments.Add(TypeNode.GetTypeNode(arg));
                    return template.GetGenericTemplateInstance(template.DeclaringModule, templateArguments);
                }
                catch
                {
                    //TODO: log error
                    return null;
                }
            }
            if(type.IsGenericParameter)
            {
                try
                {
                    int parIndx = type.GenericParameterPosition;
                    System.Reflection.MethodInfo mi = type.DeclaringMethod as System.Reflection.MethodInfo;
                    if(mi != null)
                    {
                        Method m = Method.GetMethod(mi);
                        if(m == null)
                            return null;
                        if(m.TemplateParameters != null && m.TemplateParameters.Count > parIndx)
                            return m.TemplateParameters[parIndx];
                    }
                    else
                    {
                        System.Type ti = type.DeclaringType;
                        TypeNode t = TypeNode.GetTypeNode(ti);
                        if(t == null)
                            return null;
                        if(t.TemplateParameters != null && t.TemplateParameters.Count > parIndx)
                            return t.TemplateParameters[parIndx];
                    }
                    return null;
                }
                catch
                {
                    //TODO: log error
                    return null;
                }
            }

            if(type.HasElementType)
            {
                TypeNode elemType = TypeNode.GetTypeNode(type.GetElementType());
                if(elemType == null)
                    return null;
                if(type.IsArray)
                    result = elemType.GetArrayType(type.GetArrayRank());
                else if(type.IsByRef)
                    result = elemType.GetReferenceType();
                else if(type.IsPointer)
                    result = elemType.GetPointerType();
                else
                {
                    Debug.Assert(false);
                    result = null;
                }
            }
            else if(type.DeclaringType != null)
            {
                TypeNode dType = TypeNode.GetTypeNode(type.DeclaringType);
                if(dType == null)
                    return null;
                result = dType.GetNestedType(Identifier.For(type.Name));
            }
            else
            {
                AssemblyNode assem = AssemblyNode.GetAssembly(type.Assembly);
                if(assem != null)
                {
                    result = assem.GetType(Identifier.For(type.Namespace), Identifier.For(type.Name));
                }
            }
            if(result == null)
                typeMap[type] = new WeakReference(Class.DoesNotExist);
            else
                typeMap[type] = new WeakReference(result);
            return result;
        }
Пример #6
0
 // Create an array node given an existing CLR array type
 public ArrayTypeSig(System.Type tArray, ISemanticResolver s)    
 {
     Debug.Assert(tArray != null);
     
     m_filerange = null;
     m_cDimension = tArray.GetArrayRank();        
     Debug.Assert(m_cDimension == 1, "@todo - only 1d arrays currently implemented");
     
     m_ArrayTypeRec = s.ResolveCLRTypeToBlueType(tArray).AsArrayType;
     m_sigBase = null; // left as null.
 }
 private void GetTypeParts(System.Type type, out System.Type baseType, out ParameterData[] parameterDataArray, out int[] arrayRanks)
 {
     baseType = null;
     parameterDataArray = null;
     arrayRanks = null;
     if (type.IsArray)
     {
         ArrayList list = new ArrayList();
         this.GetTypeParts(type.GetElementType(), out baseType, out parameterDataArray, out arrayRanks);
         if (arrayRanks != null)
         {
             list.AddRange(arrayRanks);
         }
         list.Add(type.GetArrayRank());
         arrayRanks = (int[]) list.ToArray(typeof(int));
     }
     else if (type.IsGenericType)
     {
         System.Type underlyingSystemType = null;
         System.Type type3 = null;
         if (type.ContainsGenericParameters)
         {
             type3 = null;
             underlyingSystemType = type.UnderlyingSystemType;
         }
         else
         {
             type3 = type;
             underlyingSystemType = type.GetGenericTypeDefinition().UnderlyingSystemType;
         }
         ArrayList list2 = new ArrayList();
         for (int i = 0; i < underlyingSystemType.GetGenericArguments().Length; i++)
         {
             ParameterData data = new ParameterData {
                 ParameterType = underlyingSystemType.GetGenericArguments()[i]
             };
             if (type3 != null)
             {
                 data.Type = type.GetGenericArguments()[i];
             }
             list2.Add(data);
         }
         parameterDataArray = (ParameterData[]) list2.ToArray(typeof(ParameterData));
         baseType = underlyingSystemType;
     }
     else
     {
         baseType = type;
     }
 }