public EocConstantInfo GetEocConstantInfo(EmnuConstantExpression expr)
{
var dataTypeInfo = Libs[expr.LibraryId].DataType[expr.StructId];
var memberInfo = dataTypeInfo.Member[expr.MemberId];
EocConstantInfo result;
try
{
result = EocLibs[expr.LibraryId].Enum[dataTypeInfo.Name][memberInfo.Name];
}
catch (Exception)
{
result = new EocConstantInfo()
{
Value = memberInfo.Default
};
if (result.Value is long longValue)
{
if ((int)longValue == longValue)
{
result.Value = (int)longValue;
}
}
result.DataType = EocDataTypes.GetConstValueType(result.Value);
}
return(result);
}
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 EocConstantInfo GetEocConstantInfo(int libraryId, int id)
{
switch (libraryId)
{
case -2:
return(GetEocConstantInfo(id));
default:
var name = Libs[libraryId].Constant[id].Name;
EocConstantInfo result;
try
{
result = EocLibs[libraryId].Constant[name];
}
catch (Exception)
{
result = new EocConstantInfo()
{
Value = Libs[libraryId].Constant[id].Value
};
if (result.Value is long longValue)
{
if ((int)longValue == longValue)
{
result.Value = (int)longValue;
}
}
result.DataType = EocDataTypes.GetConstValueType(result.Value);
}
return(result);
}
}
internal void DefineVariable(CodeWriter writer, string[] modifiers, EocVariableInfo variable, bool initAtOnce = true)
{
writer.NewLine();
if (modifiers != null)
{
foreach (var item in modifiers)
{
writer.Write(item);
writer.Write(" ");
}
}
writer.Write(variable.DataType.ToString());
writer.Write(" ");
writer.Write(variable.CppName.Split(new string[] { "::" }, StringSplitOptions.None).LastOrDefault());
if (initAtOnce)
{
var initParameter = EocDataTypes.GetInitParameter(variable.DataType, variable.UBound);
if (!string.IsNullOrWhiteSpace(initParameter))
{
writer.Write("(");
writer.Write(initParameter);
writer.Write(")");
}
}
writer.Write(";");
}
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 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 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 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()
});
}
internal void InitMembersInConstructor(CodeWriter writer, IEnumerable <EocVariableInfo> collection)
{
bool first = true;
foreach (var item in collection)
{
if (first)
{
first = false;
}
else
{
writer.Write(", ");
}
writer.Write(item.CppName);
writer.Write("(");
writer.Write(EocDataTypes.GetInitParameter(item.DataType, item.UBound));
writer.Write(")");
}
}
public EocObjectClass(ProjectConverter p, ClassInfo rawInfo) : base(p, rawInfo)
{
RawName = "raw_" + Name;
RawCppName = $"{P.TypeNamespace}::eoc_internal::{RawName}";
if (rawInfo.BaseClass == 0 || rawInfo.BaseClass == -1)
{
BaseClassName = BaseClassCppName = BaseClassRawName = BaseClassRawCppName = null;
}
else
{
BaseClassName = P.GetUserDefinedName_SimpleCppName(rawInfo.BaseClass);
BaseClassCppName = EocDataTypes.Translate(P, rawInfo.BaseClass).ToString();
BaseClassRawName = $"raw_{BaseClassName}";
BaseClassRawCppName = $"{P.TypeNamespace}::eoc_internal::{BaseClassRawName}";
}
MemberInfoMap = RawInfo.Variables.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()
});
}
private static EocCmdInfo InferEocCmdInfo(ProjectConverter P, MethodInfo rawInfo, StatementBlock rawStatementBlock)
{
var autoParam = new HashSet <int>();
for (int i = 0; i < rawStatementBlock.Count;)
{
if (rawStatementBlock[i] is ExpressionStatement exprStat)
{
var callExpr = exprStat.Expression;
if (callExpr != null && callExpr.LibraryId == P.EocHelperLibId)
{
var cmdName = P.IdToNameMap.GetLibCmdName(callExpr.LibraryId, callExpr.MethodId);
switch (cmdName)
{
case "EOC标记_自适应参数":
if (callExpr.ParamList.FirstOrDefault() is VariableExpression varExpr)
{
autoParam.Add(varExpr.Id);
}
rawStatementBlock.RemoveAt(i);
continue;
}
}
}
i++;
}
var name = P.GetUserDefinedName_SimpleCppName(rawInfo.Id);
string cppName;
if (EplSystemId.GetType(P.MethodIdToClassMap[rawInfo.Id].Id) == EplSystemId.Type_Class)
{
cppName = name;
}
else
{
cppName = $"{P.CmdNamespace}::{name}";
}
return(new EocCmdInfo()
{
ReturnDataType = rawInfo.ReturnDataType == 0 ? null : EocDataTypes.Translate(P, rawInfo.ReturnDataType),
CppName = cppName,
Parameters = rawInfo.Parameters.Select((x) =>
{
CppTypeName dataType;
if (autoParam.Contains(x.Id))
{
dataType = x.ArrayParameter ? EocDataTypes.ArrayOf(EocDataTypes.Auto) : EocDataTypes.Auto;
}
else
{
dataType = EocDataTypes.Translate(P, x.DataType, x.ArrayParameter);
}
if (dataType == EocDataTypes.Any && !x.ByRef)
{
//考虑到可空、参考（非基本类型强制参考、基本类型非参考）等问题，实现起来过于麻烦，暂时搁置
throw new NotImplementedException("暂不支持非参考自适应参数，请勾选 参考 或 贡献代码实现相应功能");
}
return new EocParameterInfo()
{
ByRef = x.ByRef || x.ArrayParameter || (!EocDataTypes.IsValueType(dataType) && dataType != EocDataTypes.Any),
Optional = x.OptionalParameter,
VarArgs = false,
DataType = dataType,
CppName = P.GetUserDefinedName_SimpleCppName(x.Id)
};
}).ToList()
});
}