public static void DefineStructMarshaler(ProjectConverter P, CodeWriter writer, EocStruct[] collection)
{
//In e::system
var map = collection.ToDictionary(x => x.RawInfo.Id);
var graph = new AdjacencyGraph <EocStruct, IEdge <EocStruct> >();
foreach (var item in collection)
{
var hasDependentItem = false;
foreach (var member in item.RawInfo.Member)
{
if (EplSystemId.GetType(member.DataType) == EplSystemId.Type_Struct &&
map.TryGetValue(member.DataType, out var memberType))
{
graph.AddVerticesAndEdge(new Edge <EocStruct>(memberType, item));
hasDependentItem = true;
}
}
if (!hasDependentItem)
{
graph.AddVertex(item);
}
}
foreach (var item in graph.TopologicalSort())
{
item.DefineStructMarshaler(writer);
}
}
public CodeConverter(ProjectConverter projectConverter, EocClass classItem, MethodInfo methodItem)
{
this.P = projectConverter;
this.Name = P.GetUserDefinedName_SimpleCppName(methodItem.Id);
this.ClassItem = classItem;
this.MethodItem = methodItem;
this.RawStatementBlock = CodeDataParser.ParseStatementBlock(methodItem.CodeData.ExpressionData, methodItem.CodeData.Encoding);
this.Info = InferEocCmdInfo(P, methodItem, RawStatementBlock);
this.TemplatedMethod = Info.Parameters.Find(x => x.DataType == EocDataTypes.Auto) != null;
this.IsClassMember = classItem is EocObjectClass;
this.ParamMap = new SortedDictionary <int, EocParameterInfo>();
for (int i = 0; i < Info.Parameters.Count; i++)
{
this.ParamMap.Add(methodItem.Parameters[i].Id, Info.Parameters[i]);
}
this.LocalMap = methodItem.Variables.ToSortedDictionary(x => x.Id, x => new EocLocalVariableInfo()
{
CppName = P.GetUserDefinedName_SimpleCppName(x.Id),
DataType = EocDataTypes.Translate(P, x.DataType, x.UBound),
UBound = x.UBound.ToList()
});
if (IsClassMember)
{
this.RefId = $"{ClassItem.CppName}|{Info.CppName}";
}
else
{
this.RefId = Info.CppName;
}
}
public static int NormalizeDataTypeId(ProjectConverter P, int dataType)
{
if (dataType == 0)
{
return(EplSystemId.DataType_Int);
}
if (EplSystemId.IsLibDataType(dataType) && dataType != P.DataTypeId_IntPtr)
{
EplSystemId.DecomposeLibDataTypeId(dataType, out var libId, out var typeId);
try
{
if (P.Libs[libId].DataType[typeId].IsEnum)
{
return(EplSystemId.DataType_Int);
}
}
catch (Exception)
{
}
try
{
if (P.EocLibs[libId].Enum.ContainsKey(P.Libs[libId].DataType[typeId].Name))
{
return(EplSystemId.DataType_Int);
}
}
catch (Exception)
{
}
}
return(dataType);
}
public static EocDll Translate(ProjectConverter P, DllDeclareInfo rawInfo)
{
var libraryName = rawInfo.LibraryName;
var entryPoint = rawInfo.EntryPoint;
if (string.IsNullOrEmpty(entryPoint))
{
entryPoint = P.IdToNameMap.GetUserDefinedName(rawInfo.Id);
}
var name = P.GetUserDefinedName_SimpleCppName(rawInfo.Id);
var info = new EocCmdInfo()
{
ReturnDataType = rawInfo.ReturnDataType == 0 ? null : EocDataTypes.Translate(P, rawInfo.ReturnDataType),
CppName = $"{P.DllNamespace}::{name}",
Parameters = rawInfo.Parameters.Select((x) =>
{
var dataType = EocDataTypes.Translate(P, x.DataType, x.ArrayParameter);
return(new EocParameterInfo()
{
ByRef = x.ByRef || x.ArrayParameter || !EocDataTypes.IsValueType(dataType),
Optional = false,
VarArgs = false,
DataType = dataType,
CppName = P.GetUserDefinedName_SimpleCppName(x.Id)
});
}).ToList()
};
return(new EocDll(P, name, info, libraryName, entryPoint));
}
public EocGlobalVariable(ProjectConverter p, GlobalVariableInfo rawInfo)
{
P = p ?? throw new ArgumentNullException(nameof(p));
RawInfo = rawInfo ?? throw new ArgumentNullException(nameof(rawInfo));
Name = P.GetUserDefinedName_SimpleCppName(RawInfo.Id);
CppName = $"{P.GlobalNamespace}::{Name}";
}
public EocDllExport(ProjectConverter p, string name, EocCmdInfo info, string exportId)
{
P = p ?? throw new ArgumentNullException(nameof(p));
Name = name ?? throw new ArgumentNullException(nameof(name));
Info = info ?? throw new ArgumentNullException(nameof(info));
ExportId = exportId ?? Name;
}
public static void DefineName(ProjectConverter P, CodeWriter writer, EocObjectClass[] collection)
{
//In e::user::type
foreach (var item in collection)
{
item.DefineName(writer);
}
}
public static void DefineName(ProjectConverter P, CodeWriter writer, SortedDictionary <int, EocObjectClass> map)
{
//In e::user::type
foreach (var item in map.Values)
{
item.DefineName(writer);
}
}
public static void DefineRawStructInfo(ProjectConverter P, CodeWriter writer, EocStruct[] collection)
{
//In e::user::type::eoc_internal
foreach (var item in collection)
{
item.DefineRawStructInfo(writer);
}
}
public static void DefineRawStructInfo(ProjectConverter P, CodeWriter writer, SortedDictionary <int, EocStruct> map)
{
//In e::user::type::eoc_internal
foreach (var item in map.Values)
{
item.DefineRawStructInfo(writer);
}
}
public static void MakeDef(ProjectConverter P, StreamWriter writer, EocDllExport[] dllExports)
{
writer.WriteLine("EXPORTS");
foreach (var item in dllExports)
{
item.MakeDefItem(P, writer);
}
}
public static void MakeDef(ProjectConverter P, StreamWriter writer, SortedDictionary <int, EocDllExport> map)
{
writer.WriteLine("EXPORTS");
foreach (var item in map.Values)
{
item.MakeDefItem(P, writer);
}
}
public static void Implement(ProjectConverter P, CodeWriter writer, SortedDictionary <int, EocDll> map)
{
writer.Write("#include \"dll.h\"");
writer.NewLine();
writer.Write("#include <e/system/dll_core.h>");
writer.NewLine();
writer.Write("#include <e/system/methodptr_caller.h>");
using (writer.NewNamespace(P.DllNamespace))
{
var moduleMap = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
var funcMap = new Dictionary <Tuple <string, string>, string>();
var eocDlls = map.Values.ToList();
for (int i = 0, j = 0, k = 0; i < eocDlls.Count; i++)
{
var item = eocDlls[i];
if (!moduleMap.TryGetValue(item.LibraryName, out var dllIdInCpp))
{
dllIdInCpp = (j++).ToString();
moduleMap.Add(item.LibraryName, dllIdInCpp);
}
var dllEntryPointPair = new Tuple <string, string>(dllIdInCpp, item.EntryPoint);
if (!funcMap.ContainsKey(dllEntryPointPair))
{
funcMap.Add(dllEntryPointPair, (k++).ToString());
}
}
using (writer.NewNamespace("eoc_module"))
{
foreach (var item in moduleMap)
{
writer.NewLine();
writer.Write($"eoc_DefineMoudleLoader({item.Value}, \"{item.Key}\");");
}
}
using (writer.NewNamespace("eoc_func"))
{
foreach (var item in funcMap)
{
var entryPointExpr = item.Key.Item2;
if (entryPointExpr.StartsWith("#"))
{
entryPointExpr = $"reinterpret_cast<const char *>({Convert.ToInt32(entryPointExpr.Substring(1))})";
}
else
{
entryPointExpr = $"\"{entryPointExpr}\"";
}
writer.NewLine();
writer.Write($"eoc_DefineFuncPtrGetter({item.Value}, {P.DllNamespace}::eoc_module::GetMoudleHandle_{item.Key.Item1}(), {entryPointExpr});");
}
}
foreach (var item in eocDlls)
{
item.ImplementItem(writer, moduleMap, funcMap);
}
}
}
public EocStruct(ProjectConverter p, StructInfo rawInfo)
{
P = p ?? throw new ArgumentNullException(nameof(p));
RawInfo = rawInfo ?? throw new ArgumentNullException(nameof(rawInfo));
Name = P.GetUserDefinedName_SimpleCppName(RawInfo.Id);
RawName = "raw_" + Name;
RawCppName = $"{P.TypeNamespace}::eoc_internal::{RawName}";
CppName = P.GetCppTypeName(rawInfo.Id).ToString();
}
public static EocGlobalVariable Translate(ProjectConverter P, GlobalVariableInfo x)
{
return new EocGlobalVariable(P, new EocVariableInfo()
{
CppName = $"{P.GlobalNamespace}::{P.GetUserDefinedName_SimpleCppName(x.Id)}",
DataType = EocDataTypes.Translate(P, x.DataType, x.UBound),
UBound = x.UBound.ToList()
});
}
public EocDll(ProjectConverter p, string name, EocCmdInfo info, string libraryName, string entryPoint)
{
P = p ?? throw new ArgumentNullException(nameof(p));
Name = name ?? throw new ArgumentNullException(nameof(name));
Info = info ?? throw new ArgumentNullException(nameof(info));
LibraryName = libraryName ?? throw new ArgumentNullException(nameof(libraryName));
EntryPoint = entryPoint ?? throw new ArgumentNullException(nameof(EntryPoint));
}
public EocStaticClass(ProjectConverter p, ClassInfo rawInfo) : base(p, rawInfo)
{
MemberInfoMap = RawInfo.Variables.ToSortedDictionary(x => x.Id, x => new EocMemberInfo()
{
CppName = $"{this.CppName}::{P.GetUserDefinedName_SimpleCppName(x.Id)}",
DataType = EocDataTypes.Translate(P, x.DataType, x.UBound),
UBound = x.UBound.ToList(),
Static = true
});
}
public static void Implement(ProjectConverter P, CodeWriter writer, EocGlobalVariable[] collection)
{
writer.Write("#include \"global.h\"");
using (writer.NewNamespace(P.GlobalNamespace))
{
foreach (var item in collection)
{
item.ImplementItem(writer);
}
}
}
public static EocDll Translate(ProjectConverter P, DllDeclareInfo dllDeclare)
{
var libraryName = dllDeclare.LibraryName;
var entryPoint = dllDeclare.EntryPoint;
if (string.IsNullOrEmpty(entryPoint))
{
entryPoint = P.IdToNameMap.GetUserDefinedName(dllDeclare.Id);
}
return(new EocDll(P, P.GetUserDefinedName_SimpleCppName(dllDeclare.Id), P.GetEocCmdInfo(dllDeclare), libraryName, entryPoint));
}
public static void Implement(ProjectConverter P, CodeWriter writer, SortedDictionary<int, EocGlobalVariable> map)
{
writer.Write("#include \"global.h\"");
using (writer.NewNamespace(P.GlobalNamespace))
{
foreach (var item in map.Values)
{
item.ImplementItem(writer);
}
}
}
public static void Implement(ProjectConverter P, CodeWriter writer, EocConstant[] eocDlls)
{
writer.Write("#include \"constant.h\"");
using (writer.NewNamespace(P.ConstantNamespace))
{
foreach (var item in eocDlls)
{
item.ImplementItem(writer);
}
}
}
public static void Define(ProjectConverter P, CodeWriter writer, EocGlobalVariable[] collection)
{
writer.Write("#pragma once");
writer.NewLine();
writer.Write("#include \"type.h\"");
using (writer.NewNamespace(P.GlobalNamespace))
{
foreach (var item in collection)
{
item.DefineItem(writer);
}
}
}
public static void Implement(ProjectConverter P, CodeWriter writer, EocDllExport[] dllExports)
{
writer.Write("#include \"stdafx.h\"");
writer.NewLine();
writer.Write("extern \"C\"");
using (writer.NewBlock())
{
foreach (var item in dllExports)
{
item.ImplementItem(P, writer);
}
}
}
public static void Define(ProjectConverter P, CodeWriter writer, EocDll[] eocDlls)
{
writer.Write("#pragma once");
writer.NewLine();
writer.Write("#include \"type.h\"");
using (writer.NewNamespace(P.DllNamespace))
{
foreach (var item in eocDlls)
{
item.DefineItem(writer);
}
}
}
public static void Define(ProjectConverter P, CodeWriter writer, SortedDictionary<int, EocGlobalVariable> map)
{
writer.Write("#pragma once");
writer.NewLine();
writer.Write("#include \"type.h\"");
using (writer.NewNamespace(P.GlobalNamespace))
{
foreach (var item in map.Values)
{
item.DefineItem(writer);
}
}
}
public static void Define(ProjectConverter P, CodeWriter writer, EocConstant[] eocDlls)
{
writer.Write("#pragma once");
writer.NewLine();
writer.Write("#include <e/system/basic_type.h>");
using (writer.NewNamespace(P.ConstantNamespace))
{
foreach (var item in eocDlls)
{
item.DefineItem(writer);
}
}
}
public static void Define(ProjectConverter P, CodeWriter writer, SortedDictionary <int, EocConstant> map)
{
writer.Write("#pragma once");
writer.NewLine();
writer.Write("#include <e/system/basic_type.h>");
using (writer.NewNamespace(P.ConstantNamespace))
{
foreach (var item in map.Values)
{
item.DefineItem(writer);
}
}
}
public static void Implement(ProjectConverter P, CodeWriter writer, SortedDictionary <int, EocDllExport> map)
{
writer.Write("#include \"stdafx.h\"");
writer.NewLine();
writer.Write("extern \"C\"");
using (writer.NewBlock())
{
foreach (var item in map.Values)
{
item.ImplementItem(P, writer);
}
}
}
public EocStruct(ProjectConverter p, StructInfo rawInfo)
{
P = p ?? throw new ArgumentNullException(nameof(p));
RawInfo = rawInfo ?? throw new ArgumentNullException(nameof(rawInfo));
Name = P.GetUserDefinedName_SimpleCppName(RawInfo.Id);
RawName = "raw_" + Name;
RawCppName = $"{P.TypeNamespace}::eoc_internal::{RawName}";
CppName = EocDataTypes.Translate(P, rawInfo.Id).ToString();
MemberInfoMap = RawInfo.Member.ToSortedDictionary(x => x.Id, x => new EocMemberInfo()
{
CppName = P.GetUserDefinedName_SimpleCppName(x.Id),
DataType = EocDataTypes.Translate(P, x.DataType, x.UBound),
UBound = x.UBound.ToList()
});
}
public EocClass(ProjectConverter p, ClassInfo rawInfo)
{
P = p ?? throw new ArgumentNullException(nameof(p));
RawInfo = rawInfo ?? throw new ArgumentNullException(nameof(rawInfo));
Name = P.GetUserDefinedName_SimpleCppName(RawInfo.Id);
if (EplSystemId.GetType(rawInfo.Id) == EplSystemId.Type_Class)
{
CppName = $"{P.TypeNamespace}::{Name}";
}
else
{
CppName = $"{P.CmdNamespace}::{Name}";
}
Method = RawInfo.Method.Select(x => P.MethodIdMap[x]).Select(x => new CodeConverter(P, this, x)).ToList();
}
