public static void GenerateClassMember(Behaviac.Design.VariableDef variable, StreamWriter stream, string indent, string var)
{
if (variable.ValueClass == Behaviac.Design.VariableDef.kConst)
{
Type type = variable.Value.GetType();
if (Plugin.IsArrayType(type) || Plugin.IsCustomClassType(type) || Plugin.IsStringType(type))
{
string nativeType = DataCppExporter.GetBasicGeneratedNativeType(variable.NativeType);
stream.WriteLine("{0}\t\t{1} {2};", indent, nativeType, var);
}
}
}
public static void PostGenerateCode(Behaviac.Design.MethodDef method, StringWriter stream, string indent, string typename, string var, string caller)
{
for (int i = 0; i < method.Params.Count; ++i)
{
if (!method.Params[i].NativeType.StartsWith("const ") && method.Params[i].NativeType.EndsWith("&"))
{
string param = (string.IsNullOrEmpty(var) ? caller : var) + "_p" + i;
string nativeType = DataCppExporter.GetBasicGeneratedNativeType(method.Params[i].NativeType);
ParameterCppExporter.PostGenerateCode(method.Params[i], stream, indent, nativeType, param, caller, method);
}
}
}
public static bool IsAgentPtr(string typeName)
{
if (DataCppExporter.IsPtr(typeName))
{
typeName = DataCppExporter.GetBasicGeneratedNativeType(typeName);
typeName = typeName.Replace("*", "");
typeName = typeName.Trim();
return(Plugin.IsAgentDerived(typeName, "Agent"));
}
return(false);
}
public static void GenerateClassMember(Behaviac.Design.MethodDef method, StreamWriter stream, string indent, string var)
{
for (int i = 0; i < method.Params.Count; ++i)
{
// const value
if (!method.Params[i].IsProperty && !method.Params[i].IsLocalVar)
{
string basicNativeType = DataCppExporter.GetBasicGeneratedNativeType(method.Params[i].NativeType);
string param = var + "_p" + i;
stream.WriteLine("{0}\t\t{1} {2};", indent, basicNativeType, param);
}
}
}
public static string GenerateCode(DefaultObject defaultObj, Behaviac.Design.MethodDef.Param param, StreamWriter stream, string indent, string typename, string var, string caller)
{
Behaviac.Design.ParInfo par = param.Value as Behaviac.Design.ParInfo;
if (par != null)
{
return(ParInfoCppExporter.GenerateCode(par, param.IsRef, stream, indent, typename, var, caller));
}
Behaviac.Design.VariableDef v = param.Value as Behaviac.Design.VariableDef;
if (v != null)
{
return(VariableCppExporter.GenerateCode(defaultObj, v, param.IsRef, stream, indent, typename, var, caller));
}
return(DataCppExporter.GenerateCode(param.Value, defaultObj, stream, indent, typename, var, caller));
}
public static void GenerateClassConstructor(DefaultObject defaultObj, Behaviac.Design.MethodDef method, StringWriter stream, string indent, string var)
{
for (int i = 0; i < method.Params.Count; ++i)
{
// const value
if (!method.Params[i].IsProperty && !method.Params[i].IsLocalVar)
{
object obj = method.Params[i].Value;
if (obj != null)
{
string param = var + "_p" + i;
Type type = obj.GetType();
if (Plugin.IsArrayType(type))
{
string nativeType = DataCppExporter.GetGeneratedNativeType(method.Params[i].NativeType);
int startIndex = nativeType.IndexOf('<');
int endIndex = nativeType.LastIndexOf('>');
string itemType = nativeType.Substring(startIndex + 1, endIndex - startIndex - 1);
ArrayCppExporter.GenerateCode(obj, defaultObj, stream, indent + "\t\t\t", itemType, param);
}
else if (Plugin.IsCustomClassType(type))
{
if (Plugin.IsRefType(type))
{
stream.WriteLine("{0}\t\t\t{1} = NULL;", indent, param);
}
else if (DesignerStruct.IsPureConstDatum(obj, method, method.Params[i].Name))
{
StructCppExporter.GenerateCode(obj, defaultObj, stream, indent + "\t\t\t", param, null, "");
}
}
else
{
string nativeType = DataCppExporter.GetBasicGeneratedNativeType(method.Params[i].NativeType);
string retStr = DataCppExporter.GenerateCode(obj, defaultObj, stream, string.Empty, nativeType, string.Empty, string.Empty);
stream.WriteLine("{0}\t\t\t{1} = {2};", indent, param, retStr);
}
}
}
}
}
public static void PostGenerateCode(Behaviac.Design.PropertyDef property, StreamWriter stream, string indent, string typename, string var, string caller, string setValue = null)
{
string[] name = property.Name.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (name.Length > 0)
{
string agentName = getGenerateAgentName(property, var, caller);
string prop = setValue;
if (setValue == null)
{
//string prop = string.Format("(({0}*){1})->{2}", property.ClassName, agentName, property.Name);
string propName = property.Name.Replace("::", "_");
string nativeType = DataCppExporter.GetGeneratedNativeType(property.NativeType);
prop = string.Format("(({0}*){1})->_Get_Property_<{2}PROPERTY_TYPE_{3}, {4} >()", property.ClassName, agentName, getNamespace(property.ClassName), propName, nativeType);
}
uint id = Behaviac.Design.CRC32.CalcCRC(name[name.Length - 1]);
stream.WriteLine("{0}BEHAVIAC_ASSERT(behaviac::MakeVariableId(\"{1}\") == {2}u);", indent, name[name.Length - 1], id);
stream.WriteLine("{0}{1}->SetVariable(\"{2}\", {3}, {4}u);", indent, agentName, name[name.Length - 1], prop, id);
}
}
public static string GetProperty(Behaviac.Design.PropertyDef property, MethodDef.Param arrayIndexElement, StreamWriter stream, string indent)
{
string retStr = string.Empty;
if (property != null)
{
string typename = DataCppExporter.GetGeneratedNativeType(property.NativeType);
if (property.IsArrayElement && !typename.StartsWith("behaviac::vector<"))
{
typename = string.Format("behaviac::vector<{0} >", typename);
}
string propBasicName = property.BasicName.Replace("[]", "");
uint id = Behaviac.Design.CRC32.CalcCRC(propBasicName);
retStr = string.Format("({0})pAgent->GetVariable<{0} >({1}u)", typename, id);
}
return(retStr);
}
public static void GenerateCode(object obj, StreamWriter stream, string indent, string var, object parent, string paramName)
{
Debug.Check(obj != null);
Type type = obj.GetType();
Debug.Check(Plugin.IsCustomClassType(type));
MethodDef method = parent as MethodDef;
IList <DesignerPropertyInfo> properties = DesignerProperty.GetDesignerProperties(type);
foreach (DesignerPropertyInfo property in properties)
{
if (!property.Attribute.HasFlags(DesignerProperty.DesignerFlags.NoSave))
{
object member = property.GetValue(obj);
if (property.Attribute is DesignerStruct)
{
GenerateCode(member, stream, indent, var + "." + property.Property.Name, parent, paramName);
}
else
{
bool bStructProperty = false;
if (method != null)
{
MethodDef.Param param = method.GetParam(paramName, property);
if (param != null)
{
bStructProperty = true;
ParameterCppExporter.GenerateCode(param, stream, indent, string.Empty, var + "." + property.Property.Name, string.Empty);
}
}
if (!bStructProperty)
{
DataCppExporter.GenerateCode(member, stream, indent, string.Empty, var + "." + property.Property.Name, string.Empty);
}
}
}
}
}
public static string GenerateCode(DefaultObject defaultObj, Behaviac.Design.PropertyDef property, MethodDef.Param arrayIndexElement, bool isRefParam, StreamWriter stream, string indent, string typename, string var, string caller)
{
if (property.IsPar || property.IsCustomized)
{
return(ParInfoCppExporter.GenerateCode(property, isRefParam, stream, indent, typename, var, caller));
}
string prop = GetProperty(defaultObj, property, arrayIndexElement, stream, indent, var, caller);
if (!string.IsNullOrEmpty(var))
{
if (string.IsNullOrEmpty(typename))
{
stream.WriteLine("{0}{1} = {2};", indent, var, prop);
}
else
{
stream.WriteLine("{0}{1} {2} = {3};", indent, DataCppExporter.GetGeneratedNativeType(property.NativeType), var, prop);
}
}
return(prop);
}
public static string GetProperty(DefaultObject defaultObj, Behaviac.Design.PropertyDef property, MethodDef.Param arrayIndexElement, StringWriter stream, string indent, string var, string caller)
{
string agentName = GetGenerateAgentName(property, var, caller);
if (property.Owner != Behaviac.Design.VariableDef.kSelf)
{
bool isGlobal = Plugin.IsInstanceName(property.Owner, null);
PropertyDef ownerProperty = null;
if (!isGlobal)
{
Debug.Check(defaultObj != null && defaultObj.Behavior != null && defaultObj.Behavior.AgentType != null);
if (defaultObj != null && defaultObj.Behavior != null)
{
ownerProperty = defaultObj.Behavior.AgentType.GetPropertyByName(property.Owner);
}
}
if (isGlobal || ownerProperty == null || ownerProperty.IsCustomized || ownerProperty.IsPar) // global or customized instance
{
stream.WriteLine("{0}Agent* {1} = Agent::GetInstance(pAgent, \"{2}\");", indent, agentName, property.Owner);
}
else // member instance
{
string propName = ownerProperty.Name.Replace("::", "_");
string nativeType = DataCppExporter.GetGeneratedNativeType(ownerProperty.Type);
string prop = string.Format("(({0}*)pAgent)->_Get_Property_<{1}PROPERTY_TYPE_{2}, {3} >()", ownerProperty.ClassName, getNamespace(ownerProperty.ClassName), propName, nativeType);
stream.WriteLine("{0}Agent* {1} = {2};", indent, agentName, prop);
}
stream.WriteLine("{0}BEHAVIAC_ASSERT({1});", indent, agentName);
}
return(getProperty(property, arrayIndexElement, agentName, stream, indent));
}
public static string GenerateCode(Behaviac.Design.MethodDef method, StreamWriter stream, string indent, string typename, string var, string caller)
{
string allParamTypes = string.Empty;
string allParams = string.Empty;
for (int i = 0; i < method.Params.Count; ++i)
{
string nativeType = DataCppExporter.GetGeneratedNativeType(method.Params[i].NativeType);
string basicNativeType = DataCppExporter.GetBasicGeneratedNativeType(nativeType);
string param = (string.IsNullOrEmpty(var) ? caller : var) + "_p" + i;
allParamTypes += ", " + nativeType;
if (method.Params[i].IsProperty || method.Params[i].IsLocalVar) // property
{
if ((method.Params[i].Property != null && method.Params[i].Property.IsCustomized) || method.Params[i].IsLocalVar)
{
ParameterCppExporter.GenerateCode(method.Params[i], stream, indent, basicNativeType, param, caller);
}
else
{
if (method.IsPublic)
{
param = ParameterCppExporter.GenerateCode(method.Params[i], stream, indent, basicNativeType, "", param);
}
else
{
ParameterCppExporter.GenerateCode(method.Params[i], stream, indent, basicNativeType, param, caller);
}
}
}
else // const value
{
object obj = method.Params[i].Value;
if (obj != null)
{
Type type = obj.GetType();
if (Plugin.IsCustomClassType(type) && !DesignerStruct.IsPureConstDatum(obj, method, method.Params[i].Name))
{
StructCppExporter.GenerateCode(obj, stream, indent, param, method, method.Params[i].Name);
}
}
}
if (basicNativeType == "System::Object")
{
param = "*(System::Object*)&" + param;
}
if (i > 0)
{
allParams += ", ";
}
allParams += param;
}
string agentName = "pAgent";
if (method.Owner != Behaviac.Design.VariableDef.kSelf)
{
agentName = "pAgent_" + caller;
stream.WriteLine("{0}Agent* {1} = Agent::GetInstance(pAgent, \"{2}\");", indent, agentName, method.Owner);
stream.WriteLine("{0}BEHAVIAC_ASSERT({1});", indent, agentName);
}
string nativeReturnType = DataCppExporter.GetGeneratedNativeType(method.NativeReturnType);
string retStr = "";
if (method.IsPublic)
{
if (method.IsStatic)
{
retStr = string.Format("{0}::{1}({2})", method.ClassName, method.BasicName, allParams);
}
else
{
retStr = string.Format("(({0}*){1})->{2}({3})", method.ClassName, agentName, method.BasicName, allParams);
}
}
else
{
retStr = string.Format("(({0}*){1})->_Execute_Method_<{2}METHOD_TYPE_{3}, {4}{5} >({6})", method.ClassName, agentName, getNamespace(method.ClassName), method.Name.Replace("::", "_"), nativeReturnType, allParamTypes, allParams);
}
if (!string.IsNullOrEmpty(var))
{
stream.WriteLine("{0}{1} {2} = {3};", indent, nativeReturnType, var, retStr);
}
return(retStr);
}
public static string GenerateCode(DefaultObject defaultObj, Behaviac.Design.MethodDef method, StringWriter stream, string indent, string typename, string var, string caller)
{
string allParamTypes = string.Empty;
string allParams = string.Empty;
for (int i = 0; i < method.Params.Count; ++i)
{
string nativeType = DataCppExporter.GetGeneratedNativeType(method.Params[i].NativeType);
string basicNativeType = DataCppExporter.GetBasicGeneratedNativeType(nativeType);
string param = (string.IsNullOrEmpty(var) ? caller : var) + "_p" + i;
allParamTypes += ", " + nativeType;
if (method.Params[i].IsProperty || method.Params[i].IsLocalVar) // property
{
VariableDef v = method.Params[i].Value as VariableDef;
if (v != null && v.ArrayIndexElement != null)
{
PropertyDef prop = method.Params[i].Property;
if (prop != null && prop.IsArrayElement)
{
string property = PropertyCppExporter.GetProperty(defaultObj, prop, v.ArrayIndexElement, stream, indent, param, caller);
string propName = prop.BasicName.Replace("[]", "");
ParameterCppExporter.GenerateCode(defaultObj, v.ArrayIndexElement, stream, indent, "int", param + "_index", param + caller);
param = string.Format("({0})[{1}_index]", property, param);
}
}
else
{
if ((method.Params[i].Property != null && method.Params[i].Property.IsCustomized) || method.Params[i].IsLocalVar)
{
ParameterCppExporter.GenerateCode(defaultObj, method.Params[i], stream, indent, basicNativeType, param, caller);
}
else
{
if (method.IsPublic)
{
param = ParameterCppExporter.GenerateCode(defaultObj, method.Params[i], stream, indent, basicNativeType, "", param);
}
else
{
ParameterCppExporter.GenerateCode(defaultObj, method.Params[i], stream, indent, basicNativeType, param, caller);
}
}
}
}
else // const value
{
object obj = method.Params[i].Value;
if (obj != null)
{
Type type = obj.GetType();
//if (Plugin.IsArrayType(type))
//{
// string nativeTypeStr = DataCppExporter.GetGeneratedNativeType(method.Params[i].NativeType);
// int startIndex = nativeTypeStr.IndexOf('<');
// int endIndex = nativeTypeStr.LastIndexOf('>');
// string itemType = nativeTypeStr.Substring(startIndex + 1, endIndex - startIndex - 1);
// ArrayCppExporter.GenerateCode(obj, stream, indent, itemType, param);
//}
//else
if (Plugin.IsCustomClassType(type) && !DesignerStruct.IsPureConstDatum(obj, method, method.Params[i].Name))
{
StructCppExporter.GenerateCode(obj, defaultObj, stream, indent, param, method, method.Params[i].Name);
}
}
}
if (basicNativeType == "System::Object")
{
param = "*(System::Object*)&" + param;
}
if (i > 0)
{
allParams += ", ";
}
allParams += param;
}
string agentName = "pAgent";
if (method.Owner != Behaviac.Design.VariableDef.kSelf)
{
agentName = "pAgent_" + caller;
bool isGlobal = Plugin.IsInstanceName(method.Owner, null);
PropertyDef ownerProperty = null;
if (!isGlobal)
{
Debug.Check(defaultObj != null && defaultObj.Behavior != null && defaultObj.Behavior.AgentType != null);
if (defaultObj != null && defaultObj.Behavior != null && defaultObj.Behavior.AgentType != null)
{
ownerProperty = defaultObj.Behavior.AgentType.GetPropertyByName(method.Owner);
}
}
if (isGlobal || ownerProperty == null || ownerProperty.IsCustomized || ownerProperty.IsPar) // global or customized instance
{
stream.WriteLine("{0}Agent* {1} = Agent::GetInstance(pAgent, \"{2}\");", indent, agentName, method.Owner);
}
else // member instance
{
string propName = ownerProperty.Name.Replace("::", "_");
string nativeType = DataCppExporter.GetGeneratedNativeType(ownerProperty.NativeType);
string prop = string.Format("(({0}*)pAgent)->_Get_Property_<{1}PROPERTY_TYPE_{2}, {3} >()", ownerProperty.ClassName, getNamespace(ownerProperty.ClassName), propName, nativeType);
stream.WriteLine("{0}Agent* {1} = {2};", indent, agentName, prop);
}
stream.WriteLine("{0}BEHAVIAC_ASSERT({1});", indent, agentName);
}
string nativeReturnType = DataCppExporter.GetGeneratedNativeType(method.NativeReturnType);
if (method.NativeReturnType.StartsWith("const "))
{
nativeReturnType = "const " + nativeReturnType;
}
string retStr = "";
if (method.IsPublic)
{
if (method.IsStatic)
{
retStr = string.Format("{0}::{1}({2})", method.ClassName, method.BasicName, allParams);
}
else
{
retStr = string.Format("(({0}*){1})->{2}({3})", method.ClassName, agentName, method.BasicName, allParams);
}
}
else
{
retStr = string.Format("(({0}*){1})->_Execute_Method_<{2}METHOD_TYPE_{3}, {4}{5} >({6})", method.ClassName, agentName, getNamespace(method.ClassName), method.Name.Replace("::", "_"), nativeReturnType, allParamTypes, allParams);
}
if (!string.IsNullOrEmpty(var))
{
stream.WriteLine("{0}{1} {2} = {3};", indent, nativeReturnType, var, retStr);
}
return(retStr);
}
public static void GenerateCode(object obj, DefaultObject defaultObj, StringWriter stream, string indent, string var, object parent, string paramName)
{
Debug.Check(obj != null);
if (obj != null)
{
Type type = obj.GetType();
Debug.Check(Plugin.IsCustomClassType(type));
MethodDef method = parent as MethodDef;
IList <DesignerPropertyInfo> properties = DesignerProperty.GetDesignerProperties(type);
foreach (DesignerPropertyInfo property in properties)
{
if (!property.Attribute.HasFlags(DesignerProperty.DesignerFlags.NoSave))
{
object member = property.GetValue(obj);
Type memberType = member.GetType();
if (Plugin.IsArrayType(memberType))
{
string memberNativeType = Plugin.GetNativeTypeName(memberType);
string nativeTypeStr = DataCppExporter.GetGeneratedNativeType(memberNativeType);
int startIndex = nativeTypeStr.IndexOf('<');
int endIndex = nativeTypeStr.LastIndexOf('>');
string itemType = nativeTypeStr.Substring(startIndex + 1, endIndex - startIndex - 1);
ArrayCppExporter.GenerateCode(member, defaultObj, stream, indent, itemType, var + "." + property.Property.Name);
}
else
{
if (property.Attribute is DesignerStruct)
{
GenerateCode(member, defaultObj, stream, indent, var + "." + property.Property.Name, parent, paramName);
}
else
{
bool bStructProperty = false;
if (method != null)
{
MethodDef.Param param = method.GetParam(paramName, property);
if (param != null)
{
bStructProperty = true;
ParameterCppExporter.GenerateCode(defaultObj, param, stream, indent, string.Empty, var + "." + property.Property.Name, string.Empty);
}
}
if (!bStructProperty)
{
DataCppExporter.GenerateCode(member, defaultObj, stream, indent, string.Empty, var + "." + property.Property.Name, string.Empty);
}
}
}
}
}
}
}
public static string GetPropertyNativeType(Behaviac.Design.PropertyDef property, MethodDef.Param arrayIndexElement)
{
string nativeType = DataCppExporter.GetGeneratedNativeType(property.NativeType);
return(nativeType);
}
public static bool IsPtr(string typeName)
{
typeName = DataCppExporter.GetBasicGeneratedNativeType(typeName);
return(typeName.EndsWith("*") && typeName != "char*" && typeName != "char *");
}
public static string GenerateCode(Behaviac.Design.PropertyDef property, bool isRefParam, StreamWriter stream, string indent, string typename, string var, string caller)
{
bool shouldDefineType = true;
if (string.IsNullOrEmpty(typename))
{
shouldDefineType = false;
typename = property.NativeType;
}
else if (typename == "System::Object")
{
typename = property.NativeType;
}
if (!typename.EndsWith("*") && Plugin.IsRefType(property.Type))
{
typename += "*";
}
bool isListType = (typename == "IList");
bool isString = (typename == "char*" || typename == "const char*");
if (isListType)
{
typename = property.NativeType;
}
typename = DataCppExporter.GetGeneratedNativeType(typename);
if (property.IsArrayElement && !typename.StartsWith("vector<") && !typename.StartsWith("behaviac::vector<"))
{
typename = string.Format("vector<{0} >", typename);
}
string varType = typename;
string propBasicName = property.BasicName.Replace("[]", "");
uint id = Behaviac.Design.CRC32.CalcCRC(propBasicName);
string retStr = string.Format("({0}&)pAgent->GetVariable<{1} >({2}u)", typename, varType, id);
if (isString)
{
retStr = string.Format("(char*)((behaviac::string&)pAgent->GetVariable<behaviac::string>({0}u)).c_str()", id);
}
if (!string.IsNullOrEmpty(var))
{
stream.WriteLine("{0}BEHAVIAC_ASSERT(behaviac::MakeVariableId(\"{1}\") == {2}u);", indent, propBasicName, id);
if (shouldDefineType || isRefParam)
{
if (isListType)
{
typename = string.Format("TList<{0} >", property.NativeType);
retStr = string.Format("&({0})", retStr);
}
else if (!isString)
{
typename = typename + "&";
}
stream.WriteLine("{0}{1} {2} = {3};", indent, typename, var, retStr);
}
else
{
stream.WriteLine("{0}{1} = {2};", indent, var, retStr);
}
}
return(retStr);
}
/// <summary>
/// Generate the native code for the given value object.
/// </summary>
/// <param name="obj">The given object.</param>
/// <param name="stream">The file stream for generating the codes.</param>
/// <param name="indent">The indent string when generating the line of codes.</param>
/// <param name="typename">The native type of the variable.</param>
/// <param name="var">The variable for the given object when generating the codes.</param>
/// <param name="caller">The caller for the method or the agent.</param>
/// <returns>Returns the string generated value.</returns>
public static string GenerateCode(object obj, StreamWriter stream, string indent, string typename, string var, string caller)
{
string retStr = string.Empty;
if (obj != null)
{
Type type = obj.GetType();
if (obj is Behaviac.Design.MethodDef)
{
Behaviac.Design.MethodDef method = obj as Behaviac.Design.MethodDef;
retStr = MethodCppExporter.GenerateCode(method, stream, indent, typename, var, caller);
}
else if (obj is Behaviac.Design.MethodDef.Param)
{
Behaviac.Design.MethodDef.Param param = obj as Behaviac.Design.MethodDef.Param;
retStr = ParameterCppExporter.GenerateCode(param, stream, indent, typename, var, caller);
}
else if (obj is Behaviac.Design.ParInfo)
{
Behaviac.Design.ParInfo par = obj as Behaviac.Design.ParInfo;
retStr = ParInfoCppExporter.GenerateCode(par, false, stream, indent, typename, var, caller);
}
else if (obj is Behaviac.Design.PropertyDef)
{
Behaviac.Design.PropertyDef property = obj as Behaviac.Design.PropertyDef;
retStr = PropertyCppExporter.GenerateCode(property, null, false, stream, indent, typename, var, caller);
}
else if (obj is Behaviac.Design.VariableDef)
{
Behaviac.Design.VariableDef variable = obj as Behaviac.Design.VariableDef;
retStr = VariableCppExporter.GenerateCode(variable, false, stream, indent, typename, var, caller);
}
else if (obj is Behaviac.Design.RightValueDef)
{
Behaviac.Design.RightValueDef rightValue = obj as Behaviac.Design.RightValueDef;
retStr = RightValueCppExporter.GenerateCode(rightValue, stream, indent, typename, var, caller);
}
// Array type
else if (Plugin.IsArrayType(type))
{
retStr = var;
if (!string.IsNullOrEmpty(typename))
{
stream.WriteLine("{0}{1} {2};", indent, DataCppExporter.GetBasicGeneratedNativeType(typename), var);
}
else
{
typename = DataCppExporter.GetGeneratedNativeType(type);
}
int startIndex = typename.IndexOf('<');
int endIndex = typename.LastIndexOf('>');
string itemType = typename.Substring(startIndex + 1, endIndex - startIndex - 1);
ArrayCppExporter.GenerateCode(obj, stream, indent, itemType, var);
}
// Struct type
else if (Plugin.IsCustomClassType(type))
{
retStr = var;
if (!string.IsNullOrEmpty(typename))
{
if (typename.EndsWith("*"))
{
stream.WriteLine("{0}{1} {2} = NULL;", indent, DataCppExporter.GetBasicGeneratedNativeType(typename), var);
}
else
{
stream.WriteLine("{0}{1} {2};", indent, DataCppExporter.GetBasicGeneratedNativeType(typename), var);
}
}
StructCppExporter.GenerateCode(obj, stream, indent, var, null, "");
}
// Other types
else
{
retStr = obj.ToString();
if (Plugin.IsStringType(type)) // string
{
retStr = string.Format("\"{0}\"", retStr);
if (typename.StartsWith("behaviac::wstring"))
{
retStr = string.Format("StringUtils::MBSToWCS({0})", retStr);
}
else
{
retStr = string.Format("(char*)({0})", retStr);
}
}
else if (Plugin.IsBooleanType(type)) // bool
{
retStr = retStr.ToLowerInvariant();
}
else if (Plugin.IsEnumType(type)) // enum
{
retStr = EnumCppExporter.GeneratedCode(obj);
}
else if (Plugin.IsFloatType(type)) // float
{
if (retStr.Contains(".") && !retStr.EndsWith("f") && !retStr.EndsWith("F"))
{
retStr = retStr + "f";
}
}
if (!string.IsNullOrEmpty(var))
{
if (string.IsNullOrEmpty(typename))
{
stream.WriteLine("{0}{1} = {2};", indent, var, retStr);
}
else
{
typename = DataCppExporter.GetGeneratedNativeType(typename);
stream.WriteLine("{0}{1} {2} = {3};", indent, typename, var, retStr);
}
}
}
}
return(retStr);
}
public static string GenerateCode(Behaviac.Design.MethodDef method, StreamWriter stream, string indent, string typename, string var, string caller)
{
string allParamTypes = string.Empty;
string allParams = string.Empty;
for (int i = 0; i < method.Params.Count; ++i)
{
string nativeType = DataCppExporter.GetGeneratedNativeType(method.Params[i].NativeType);
bool isPointRefType = nativeType.EndsWith("*&");
string basicNativeType = DataCppExporter.GetBasicGeneratedNativeType(nativeType);
string param = (string.IsNullOrEmpty(var) ? caller : var) + "_p" + i;
string paramBasicType = basicNativeType;
if (!isPointRefType && DataCppExporter.IsPtr(paramBasicType))
{
paramBasicType = paramBasicType.Replace("*", "");
paramBasicType = paramBasicType.Trim();
}
allParamTypes += ", " + paramBasicType;
if (method.Params[i].IsProperty) // property
{
param = ParameterCppExporter.GenerateCode(method.Params[i], stream, indent, basicNativeType, string.Empty, param);
if (!isPointRefType && DataCppExporter.IsPtr(basicNativeType))
{
param = "*" + param;
}
}
else
{
if (method.Params[i].IsPar) // par
{
ParameterCppExporter.GenerateCode(method.Params[i], stream, indent, basicNativeType, param, caller);
if (!isPointRefType && DataCppExporter.IsPtr(basicNativeType))
{
param = "*" + param;
}
}
else // const value
{
object obj = method.Params[i].Value;
if (obj != null)
{
Type type = obj.GetType();
if (Plugin.IsCustomClassType(type) && !DesignerStruct.IsPureConstDatum(obj, method, method.Params[i].Name))
{
StructCppExporter.GenerateCode(obj, stream, indent, param, method, method.Params[i].Name);
}
}
if (!isPointRefType && DataCppExporter.IsAgentPtr(basicNativeType))
{
param = "*" + param;
}
}
}
if (i > 0)
{
allParams += ", ";
}
allParams += param;
}
string agentName = "pAgent";
if (method.Owner != Behaviac.Design.VariableDef.kSelf)
{
agentName = "pAgent_" + caller;
stream.WriteLine("{0}Agent* {1} = Agent::GetInstance(\"{2}\", pAgent->GetContextId());", indent, agentName, method.Owner);
stream.WriteLine("{0}BEHAVIAC_ASSERT({1});", indent, agentName);
}
//string retStr = string.Format("(({0}*){1})->{2}({3})", method.ClassName, agentName, method.Name, allParams);
string nativeReturnType = DataCppExporter.GetGeneratedNativeType(method.NativeReturnType);
string retStr = string.Format("(({0}*){1})->_Execute_Method_<{2}METHOD_TYPE_{3}, {4}{5} >({6})", method.ClassName, agentName, getNamespace(method.ClassName), method.Name.Replace("::", "_"), nativeReturnType, allParamTypes, allParams);
if (!string.IsNullOrEmpty(var))
{
stream.WriteLine("{0}{1} {2} = {3};", indent, nativeReturnType, var, retStr);
}
return(retStr);
}
