public static ProtoCore.Type GetProtoCoreType(Type type, CLRDLLModule module)
{
ProtoCore.Type protoCoreType;
if (mTypeMaps.TryGetValue(type, out protoCoreType))
{
return(protoCoreType);
}
if (type == typeof(object) || !CLRObjectMarshler.IsMarshaledAsNativeType(type))
{
if (type.IsEnum)
{
protoCoreType = CLRModuleType.GetInstance(type, module, string.Empty).ProtoCoreType;
}
else
{
protoCoreType = CLRModuleType.GetInstance(type, null, string.Empty).ProtoCoreType;
}
}
else
{
protoCoreType = CLRObjectMarshler.GetProtoCoreType(type);
}
lock (mTypeMaps)
{
mTypeMaps[type] = protoCoreType;
}
return(protoCoreType);
}
public override CodeBlockNode ImportCodeBlock(string typeName, string alias, CodeBlockNode refNode)
{
Type[] types = GetTypes(typeName);
Type exttype = typeof(IExtensionApplication);
#if PARALLEL
System.Threading.Tasks.Parallel.ForEach(types, type =>
{
//For now there is no support for generic type.
if (!type.IsGenericType && type.IsPublic && !exttype.IsAssignableFrom(type) && CLRModuleType.IsBrowsable(type))
{
CLRModuleType importedType = CLRModuleType.GetInstance(type, this, alias);
}
});
#else
foreach (var type in types)
{
//For now there is no support for generic type.
if (!type.IsGenericType && type.IsPublic && !exttype.IsAssignableFrom(type) && CLRModuleType.IsBrowsable(type))
{
CLRModuleType importedType = CLRModuleType.GetInstance(type, this, alias);
Type[] nestedTypes = type.GetNestedTypes();
if (null != nestedTypes && nestedTypes.Length > 0)
{
foreach (var item in nestedTypes)
{
importedType = CLRModuleType.GetInstance(item, this, string.Empty);
}
}
}
}
#endif
CodeBlockNode node = new CodeBlockNode();
//Get all the types available on this module.
//TODO: need to optimize for performance.
List <CLRModuleType> moduleTypes = CLRModuleType.GetTypes((CLRModuleType mtype) => { return(mtype.Module == this); });
foreach (var item in moduleTypes)
{
node.Body.Add(item.ClassNode);
mTypes[item.ClassName] = item; //update Type dictionary.
}
//Also add all the available empty class nodes.
List <CLRModuleType> emptyTypes = CLRModuleType.GetEmptyTypes();
foreach (var item in emptyTypes)
{
item.EnsureDisposeMethod(this);
node.Body.Add(item.ClassNode);
}
string ffidump = Environment.GetEnvironmentVariable("FFIDUMP");
if (string.Compare(ffidump, "1") == 0)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
foreach (var item in node.Body)
{
sb.Append(item.ToString());
sb.AppendLine();
}
using (System.IO.FileStream fs = new System.IO.FileStream(string.Format("{0}.ds", this.Name), System.IO.FileMode.Create))
{
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(sb.ToString());
fs.Write(bytes, 0, bytes.Length);
}
}
return(node);
}
private ClassDeclNode ParseSystemType(Type type, string alias)
{
Validity.Assert(IsBrowsable(type), "Non browsable type is being imported!!");
string classname = alias;
if (classname == null | classname == string.Empty)
{
classname = CLRObjectMarshler.GetTypeName(type);
}
ProtoCore.AST.AssociativeAST.ClassDeclNode classnode = CreateEmptyClassNode(classname);
classnode.ExternLibName = Module.Name;
classnode.className = classname;
classnode.Name = type.Name;
Type baseType = GetBaseType(type);
if (baseType != null && !CLRObjectMarshler.IsMarshaledAsNativeType(baseType))
{
string baseTypeName = CLRObjectMarshler.GetTypeName(baseType);
classnode.superClass = new List <string>();
classnode.superClass.Add(baseTypeName);
//Make sure that base class is imported properly.
CLRModuleType.GetInstance(baseType, Module, string.Empty);
}
ConstructorInfo[] ctors = type.GetConstructors();
foreach (var c in ctors)
{
if (c.IsPublic && !c.IsGenericMethod && IsBrowsable(c))
{
ConstructorDefinitionNode node = ParseConstructor(c, type);
classnode.funclist.Add(node);
RegisterFunctionPointer(node.Name, c, node.ReturnType);
}
}
BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static;
bool isDerivedClass = classnode.superClass != null;
if (isDerivedClass) //has base class
{
flags |= BindingFlags.DeclaredOnly; //for derived class, parse only class declared methods.
}
bool isDisposable = typeof(IDisposable).IsAssignableFrom(type);
MethodInfo[] methods = type.GetMethods(flags);
bool hasDisposeMethod = false;
foreach (var m in methods)
{
if (!IsBrowsable(m))
{
continue;
}
//Don't include overriden methods or generic methods
if (m.IsPublic && !m.IsGenericMethod && (m == m.GetBaseDefinition() || (m.GetBaseDefinition().DeclaringType == baseType && baseType == typeof(Object))))
{
AssociativeNode node = ParseAndRegisterFunctionPointer(isDisposable, ref hasDisposeMethod, m);
classnode.funclist.Add(node);
}
else if (!hasDisposeMethod && isDisposable && baseType == typeof(Object) && isDisposeMethod(m))
{
AssociativeNode node = ParseAndRegisterFunctionPointer(isDisposable, ref hasDisposeMethod, m);
classnode.funclist.Add(node);
}
}
if (!hasDisposeMethod && !isDisposable)
{
AssociativeNode node = ParseAndRegisterFunctionPointer(true, ref hasDisposeMethod, mDisposeMethod);
classnode.funclist.Add(node);
}
FieldInfo[] fields = type.GetFields();
foreach (var f in fields)
{
if (!IsBrowsable(f))
{
continue;
}
VarDeclNode variable = ParseFieldDeclaration(f);
if (null == variable)
{
continue;
}
classnode.varlist.Add(variable);
FunctionDefinitionNode func = ParseFieldAccessor(f);
if (null != func)
{
RegisterFunctionPointer(func.Name, f, func.ReturnType);
}
}
PropertyInfo[] properties = type.GetProperties(flags);
foreach (var p in properties)
{
AssociativeNode node = ParseProperty(p);
if (null != node)
{
classnode.varlist.Add(node);
}
}
return(classnode);
}
private ClassDeclNode ParseSystemType(Type type, string alias)
{
Validity.Assert(!SupressesImport(type), "Supressed type is being imported!!");
string classname = alias;
if (classname == null | classname == string.Empty)
{
classname = CLRObjectMarshler.GetTypeName(type);
}
ProtoCore.AST.AssociativeAST.ClassDeclNode classnode = CreateEmptyClassNode(classname);
classnode.ExternLibName = Module.Name;
classnode.className = classname;
classnode.Name = type.Name;
Type baseType = GetBaseType(type);
if (baseType != null && !CLRObjectMarshler.IsMarshaledAsNativeType(baseType))
{
string baseTypeName = CLRObjectMarshler.GetTypeName(baseType);
classnode.superClass = new List <string>();
classnode.superClass.Add(baseTypeName);
//Make sure that base class is imported properly.
CLRModuleType.GetInstance(baseType, Module, string.Empty);
}
// There is no static class in runtime. static class is simply
// marked as sealed and abstract.
bool isStaticClass = type.IsSealed && type.IsAbstract;
if (!isStaticClass)
{
// If all methods are static, it doesn't make sense to expose
// constructor.
ConstructorInfo[] ctors = type.GetConstructors();
foreach (var c in ctors)
{
if (c.IsPublic && !c.IsGenericMethod && !SupressesImport(c))
{
ConstructorDefinitionNode node = ParseConstructor(c, type);
classnode.funclist.Add(node);
List <ProtoCore.Type> argTypes = GetArgumentTypes(node);
RegisterFunctionPointer(node.Name, c, argTypes, node.ReturnType);
}
}
}
BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static;
bool isDerivedClass = (classnode.superClass != null) && classnode.superClass.Count > 0;
if (isDerivedClass) //has base class
{
flags |= BindingFlags.DeclaredOnly; //for derived class, parse only class declared methods.
}
bool isDisposable = typeof(IDisposable).IsAssignableFrom(type);
MethodInfo[] methods = type.GetMethods(flags);
bool hasDisposeMethod = false;
foreach (var m in methods)
{
if (SupressesImport(m))
{
continue;
}
if (isStaticClass && m.GetBaseDefinition().DeclaringType == baseType && baseType == typeof(object))
{
continue;
}
//Don't include overriden methods or generic methods
if (m.IsPublic && !m.IsGenericMethod && m == m.GetBaseDefinition())
{
AssociativeNode node = ParseAndRegisterFunctionPointer(isDisposable, ref hasDisposeMethod, m);
classnode.funclist.Add(node);
}
else if (!hasDisposeMethod && isDisposable && baseType == typeof(Object) && isDisposeMethod(m))
{
AssociativeNode node = ParseAndRegisterFunctionPointer(isDisposable, ref hasDisposeMethod, m);
classnode.funclist.Add(node);
}
}
if (!hasDisposeMethod && !isDisposable)
{
AssociativeNode node = ParseAndRegisterFunctionPointer(true, ref hasDisposeMethod, mDisposeMethod);
classnode.funclist.Add(node);
}
FieldInfo[] fields = type.GetFields();
foreach (var f in fields)
{
if (SupressesImport(f))
{
continue;
}
//Supress if defined in super-type
if (isDerivedClass)
{
FieldInfo[] supertypeFields = baseType.GetFields();
if (supertypeFields.Any(superF => superF.Name == f.Name))
{
continue;
}
}
VarDeclNode variable = ParseFieldDeclaration(f);
if (null == variable)
{
continue;
}
classnode.varlist.Add(variable);
FunctionDefinitionNode func = ParseFieldAccessor(f);
if (null != func)
{
RegisterFunctionPointer(func.Name, f, null, func.ReturnType);
}
}
PropertyInfo[] properties = type.GetProperties(flags);
foreach (var p in properties)
{
AssociativeNode node = ParseProperty(p);
if (null != node)
{
classnode.varlist.Add(node);
}
}
FFIClassAttributes cattrs = new FFIClassAttributes(type);
classnode.ClassAttributes = cattrs;
SetTypeAttributes(type, cattrs);
return(classnode);
}
