//============================================================
// <T>在Map表中查找类型对应的全名。</T>
//
// @param filenode 从文件中提取的待查找节点
// @param type 类型
// @return 查找到的全名
//============================================================
public string LookInMap(FFileNode filenode, string type)
{
string fullClassString = string.Empty;
string key = filenode.ClassStr;
if (_classesMap.Contains(key))
{
FArray <string> value = _classesMap[key];
if (_classesMap.Contains(key) && value.Length == 1)
{
fullClassString = value[0].ToString();
if (fullClassString != string.Empty)
{
return(fullClassString + "." + type);
}
else
{
return(type);
}
}
if (_classesMap.Contains(key) && value.Length > 1)
{
fullClassString = GetCorrectNamespace(filenode.Impotrs, value);
if (fullClassString != string.Empty)
{
return(fullClassString + "." + type);
}
else
{
return(type);
}
}
}
return(type);
}
//============================================================
// <T>扫描字符串中的逗号，并在符合条件的逗号后面加上$符号。</T>
//
// @param commastr 需要扫描逗号的字符串
// @return 扫面并修改之后的字符串
//============================================================
public string ScanComma(string commastr)
{
char[] c = commastr.ToCharArray();
FArray <char> charArr = new FArray <char>();
int left = 0, right = 0;
for (int n = 0; n < c.Length; n++)
{
if (c[n] == '<')
{
left++;
}
if (c[n] == '>')
{
right++;
}
if (c[n] == ',' && left == right)
{
charArr.Add('$');
}
charArr.Add(c[n]);
}
char[] cs = charArr.ToArray();
string str = new string(cs);
return(str);
}
//============================================================
// <T>构造函数</T>
//============================================================
public FCsClass()
{
_accessLevel = string.Empty;
_className = string.Empty;
_annotates = new FStrings();
_method = new FArray <FCsMethod>();
}
//============================================================
// <T>构造方法</T>
//============================================================
public FCsMethod()
{
_methodName = string.Empty;
_methodType = string.Empty;
_annotates = new FStrings();
_parameter = new FArray <FCsParameter>();
}
static Offset <FArray> Serialise(FlatBufferBuilder b, IHasFloatArray float_a)
{
var v_offset = FArray.CreateArrayVectorBlock(b, float_a.ObservationArray);
//var v_offset = CustomFlatBufferImplementation.CreateFloatVector(b, float_a.ObservationArray);
var ranges_vector = new VectorOffset();
FArray.StartRangesVector(b, float_a.ObservationSpace.Length);
foreach (var tra in float_a.ObservationSpace)
{
FRange.CreateFRange(b,
tra.DecimalGranularity,
tra.Max,
tra.Min,
tra.NormalisedBool);
}
ranges_vector = b.EndVector();
FArray.StartFArray(b);
FArray.AddArray(b, v_offset);
FArray.AddRanges(b, ranges_vector);
return(FArray.EndFArray(b));
}
//============================================================
// <T>构造函数</T>
//============================================================
public FCsSpace(FStrings strLine, int beginLine, int endLine)
{
_spaceStr = strLine;
_startIndex = beginLine;
_endIndex = endLine;
_spaceName = string.Empty;
_class = new FArray <FCsClass> ( );
}
public static FObject NewArray(FArray array)
{
var o = new FObject {
Type = FObjectType.Array, PTR = VirtualMachine.Heap.Add(array)
};
;
return(o);
}
static Offset <FArray> build_array(FlatBufferBuilder b, IHasArray camera)
{
var v_offset = FArray.CreateArrayVector(b, camera.ObservationArray);
//FArray.StartRangesVector(b,);
FArray.StartFArray(b);
FArray.AddArray(b, v_offset);
//FArray.AddRanges(b,);
return(FArray.EndFArray(b));
}
//============================================================
// <T>构造方法</T>
//============================================================
public FCsMethod(FStrings strlines, int beginIndex, int endIndex)
{
_methodName = string.Empty;
_methodType = string.Empty;
_annotates = new FStrings();
_parameter = new FArray <FCsParameter>();
_strLine = strlines;
_beginIndex = beginIndex;
_endIndex = endIndex;
}
//============================================================
// <T>构造函数</T>
//============================================================R
public FCsClass(FStrings strLine, int startIndex, int endIndex)
{
_accessLevel = string.Empty;
_className = string.Empty;
_annotates = new FStrings();
_method = new FArray <FCsMethod>();
_strLine = strLine;
_startIndex = startIndex;
_endIndex = endIndex;
}
//============================================================
// <T> 取得在FArray<FCppClass>中class的索引号。</T>
//
// @param cppClasses 被查找的Array
// @param cppClass 需要查找的Node
// @return 若是存在则返回索引号，否则返回-1;
//============================================================
public int ExistNo(FArray <FCppClass> cppClasses, FCppClass cppClass)
{
for (int n = 0; n < cppClasses.Length; n++)
{
if (cppClasses[n].ClassName == cppClass.ClassName)
{
return(n);
}
}
return(-1);
}
//============================================================
// <T>向类索引Map表中加入节点 。</T>
//
// @param node 需要加入的节点信息
//============================================================
public void AddNode(FMapNode node)
{
if (_classesMap.Contains(node.ClassStr))
{
_classesMap[node.ClassStr].Add(node.ArrayStr);
}
else
{
FArray <string> arrNode = new FArray <string>();
arrNode.Add(node.ArrayStr);
_classesMap.Set(node.ClassStr, arrNode);
}
}
//============================================================
// <T>获得正确的命名空间</T>
//
// @param type 类型列表
// @param node 待查找节点
//============================================================
public string GetCorrectNamespace(FArray <string> type, FArray <string> node)
{
for (int n = 0; n < type.Length; n++)
{
for (int i = 0; i < node.Length; i++)
{
if (type[n].ToString().Trim() == node[i].ToString().Trim())
{
return(type[n].ToString().Trim());
}
}
}
return(string.Empty);
}
//============================================================
// <T>向MAP表里面加入节点。</T>
//
// @param node 需要加工的节点
// @param dotHFilePath H文件的路径
//============================================================
public void AddNode(FMapNode node, string dotHFilePath)
{
if (_classesMap.Names.Contains(node.FileDotH))
{
_classesMap[node.FileDotH].Add(node.ClassStr);
}
else
{
FArray <string> arrNode = new FArray <string>();
arrNode.Add(dotHFilePath);
arrNode.Add(node.ClassStr);
_classesMap.Set(node.FileDotH, arrNode);
}
}
/****************************************************************
* Arrays Node
***************************************************************/
public Node ArrayDeclaration()
{
Expect(TokenCategory.PARENTHESIS_OPEN);
var arr = new FArray();
arr.Add(Expression());
while (CurrentToken == TokenCategory.COMMA)
{
Expect(TokenCategory.COMMA);
arr.Add(Expression());
}
Expect(TokenCategory.PARENTHESIS_CLOSE);
return(arr);
}
//============================================================
// <T>将被选择的文件解析为类对象数组，并解析出代码在编译器外的警告或者错误。</T>
//
// @param indextable 从.h文件中解析出来的类与头文件对应的MAP表
// @param putPath XML文档的输出路径
// @param swPrint StringWriter对象用来输出警告或者错误。
// @param fileCpp 当前解析的文件
// @param relativePath 被选择解析的文件夹路径
//============================================================
public void ParserFileCpp(FileInfo fileCpp, FCppClassesIndexTable indextable, string outPath, string relativePath, StreamWriter swPrint)
{
FStrings strLines = FCppParser.GetLines(fileCpp.FullName);
string strClass = string.Empty;
FArray <FCppClass> classArr = new FArray <FCppClass>();
int start, end = CheckParaAnnotate(strLines, 0, out start);
for (int n = 0; n < strLines.Count; n++)
{
if (IsInInterregional(n, start, end))
{
continue;
}
if (FCppMethod.IsMethodInCpp(strLines, n))
{
FCppMethod method = new FCppMethod(strLines, n, GetPairNum(strLines, n));
string classStr = GetClassInCpp(strLines, n);
strClass = classStr;
FFileNode node = MakeNode(strLines, GetClassInCpp(strLines, n));
string fileHpath = indextable.LookInMap(node);
if (fileHpath == "")
{
continue;
}
FCppClass cppClass = ParserFileH(fileHpath, classStr);
int index = ExistNo(classArr, cppClass);
if (index != -1)
{
classArr.Get(index).Method.Add(method);
}
else
{
cppClass.Method.Add(method);
classArr.Add(cppClass);
}
}
}
ProduceXMLFile(classArr, outPath, swPrint, fileCpp, relativePath);
if (strLines[strLines.Count - 1].Trim() != "")
{
string errID = "CPP07CL06E" + strLines.Count.ToString() + "L";
string path = fileCpp.FullName.Substring(relativePath.Length);
string error = "[错误][" + errID.PadRight(16) + "][" + path + "(" + strLines.Count.ToString().PadRight(5) + ")]";
swPrint.WriteLine(error);
}
}
public FArray <string> GetUsing(FStrings strLines)
{
FArray <string> usings = new FArray <string>();
for (int n = 0; n < strLines.Count; n++)
{
string strTemp = strLines[n].ToString().Trim();
if (strTemp.Contains("using") && strTemp.Contains("MO"))
{
string usinginfo = strTemp.Substring(6).Trim();
usings.Add(usinginfo);
}
if (!strTemp.Contains("using"))
{
return(usings);
}
}
return(usings);
}
//============================================================
// <T>在MAP表中查找对应值。</T>
//
// @param filenode 在文件中生成的查找节点。
// @return 查找到的值
//============================================================
public string LookInMap(FFileNode filenode)
{
FArray <string> heads = new FArray <string>();
heads = filenode.HeadHS;
string classstr = filenode.ClassStr;
foreach (string head in heads)
{
if (_classesMap.Contains(head))
{
if (_classesMap[head].Contains(classstr))
{
return(_classesMap[head][0].Trim());
}
}
}
return(string.Empty);
}
//============================================================
//<T>将类所继承的接口作为子节点连接到类的节点下面</T>
// @param interface 接口的字符串组
// @param nodeClass 要连接的父节点，也就是类的节点
//============================================================
public void MakeInterfaceNode(FArray <string> interfaces, FXmlNode nodeClass, FClassesIndexTable indextable)
{
if (interfaces == null || interfaces.Length < 1)
{
return;
}
FXmlNode nodeInterface = new FXmlNode("Inherts");
foreach (string str in interfaces)
{
FXmlNode inhert = new FXmlNode("Inhert");
string inhertstr = str.Trim();
FFileNode type = new FFileNode(inhertstr, GetUsing(_strLine));
inhertstr = indextable.LookInMap(type, inhertstr);
inhert.Set("name", inhertstr.Trim());
nodeInterface.Push(inhert);
}
nodeClass.Push(nodeInterface);
}
public FArray <string> GetImport(FStrings strLines)
{
FArray <string> imports = new FArray <string>();
for (int n = 0; n < strLines.Count; n++)
{
string strTemp = strLines[n].ToString().Trim();
if (strTemp.Contains("import") && strTemp.Contains("MO"))
{
string usinginfo = strTemp.Substring(6).Trim();
imports.Add(usinginfo);
}
if (!strTemp.Contains(" class "))
{
return(imports);
}
}
return(imports);
}
//============================================================
// <T>将一组提取出来的类对象解析成XML文档，并解析出代码在编译器外的警告或者错误。</T>
//
// @param classArr 一组类对象
// @param putPath XML文档的输出路径
// @param swPrint StringWriter对象用来输出警告或者错误。
// @param file 当前解析的文件
// @param relativePath 被选择解析的文件夹路径
//============================================================
public void ProduceXMLFile(FArray <FCppClass> classArr, string outPath, StreamWriter swPrint, FileInfo file, string relativePath)
{
for (int n = 0; n < classArr.Length; n++)
{
if (classArr[n] != null)
{
FXmlDocument doc = new FXmlDocument();
FXmlNode config = doc.Root;
FXmlNode node = classArr[n].XMLMaker(swPrint, file, relativePath);
config.Push(node);
FXmlNode methods = new FXmlNode("Methods");
node.Push(methods);
for (int i = 0; i < classArr[n].Method.Length; i++)
{
classArr[n].Method[i].ParserMethod(methods, swPrint, file, relativePath);
}
doc.SaveFile(@outPath + "\\" + classArr[n].ClassName + ".xml");
}
}
}
public FArray <string> GetInclude(FStrings strLines)
{
FArray <string> includes = new FArray <string>();
for (int n = 0; n < strLines.Count; n++)
{
string strTemp = strLines[n].Trim();
if (strTemp.Contains("include") && strTemp.Contains("\""))
{
int start = strTemp.IndexOf("\"") + 1;
int end = strTemp.LastIndexOf("\"");
string temp = strTemp.Substring(start, end - start);
includes.Add(temp);
}
if (!strTemp.Contains("#") && strTemp != "")
{
return(includes);
}
}
return(includes);
}
//============================================================
// <T>构造函数</T>
//============================================================
public FCsSpace( )
{
_spaceName = string.Empty;
_class = new FArray <FCsClass> ( );
}
//============================================================
// <T>构造方法</T>
//============================================================
public FFileNode()
{
_headHs = new FArray <string>();
_class = string.Empty;
}
//============================================================
// <T>构造方法，带参数的</T>
//
// @param classstr 类名
// @param headhs 文件中提取的所包含的头文件名数组
//============================================================
public FFileNode(string classstr, FArray <string> headhs)
{
this._headHs = headhs;
this._class = classstr;
}
private static void LoadArrayFunctions()
{
functions["insert"] = new FBuiltin
{
// Arity count is not including caller object (array in this case)
Arity = 2, CallObjectTypes = { FObjectType.Array },
Invokable = (fi, ins) =>
{
ins[0].Array().Insert(ins[1].I64, ins[2]);
return(ins[0]);
},
ArgumentTypes = { FObjectType.Array, FObjectType.Int, FObjectType.Any }
};
functions["count"] = new FBuiltin
{
Arity = 0, CallObjectTypes = { FObjectType.Array, FObjectType.String },
Invokable = (fi, ins) => FObject.NewI64(ins[0].Array().Length),
};
functions["remove"] = new FBuiltin
{
Arity = 1, CallObjectTypes = { FObjectType.Array },
Invokable = (fi, ins) =>
{
ins[0].Array().Remove(ins[1].I64);
return(ins[0]);
},
ArgumentTypes = { FObjectType.Int }
};
functions["mutate"] = new FBuiltin
{
Arity = 1, CallObjectTypes = { FObjectType.Array },
Invokable = (fi, ins) =>
{
var oArr = ins[0].Array();
var func = ins[1].Function();
var nArr = new FArray(oArr.Length);
for (int i = 0; i < oArr.Length; i++)
{
nArr.Push(fi.Invoke(func, new[] { oArr.Get(i) }));
}
return(FObject.NewArray(nArr));
},
ArgumentTypes = { FObjectType.Function }
};
functions["filter"] = new FBuiltin
{
Arity = 1,
CallObjectTypes = { FObjectType.Array },
Invokable = (fi, ins) =>
{
var oArr = ins[0].Array();
var func = ins[1].Function();
var nArr = new FArray(oArr.Length);
for (int i = 0; i < oArr.Length; i++)
{
if (fi.Invoke(func, new[] { oArr.Get(i) }).True())
{
nArr.Push(oArr.Get(i));
}
}
return(FObject.NewArray(nArr));
},
ArgumentTypes = { FObjectType.Function }
};
functions["foreach"] = new FBuiltin
{
Arity = 1,
CallObjectTypes = { FObjectType.Array },
Invokable = (fi, ins) =>
{
var oArr = ins[0].Array();
var func = ins[1].Function();
for (int i = 0; i < oArr.Length; i++)
{
fi.Invoke(func, new[] { oArr.Get(i) });
}
return(FObject.Nil);
},
ArgumentTypes = { FObjectType.Function }
};
}
//============================================================
// <T>构造方法。</T>
//
// @param classStr 类名
// @using 文件中所包含的包名
//============================================================
public FFileNode(string classStr, FArray <string> usings)
{
this._classStr = classStr;
this._import = usings;
}
//============================================================
// <T>构造方法。</T>
//
//============================================================
public FFileNode()
{
_import = new FArray <string>();
_classStr = string.Empty;
}
//============================================================
// <T>生成查找是的MAP节点</T>
//
// @param strLines 文件解析出的字符串行数组
// @param classStr 解析出的类字符串
// @return 返回生成的节点
//============================================================
public FFileNode MakeNode(FStrings strLines, string classStr)
{
FArray <string> includes = GetInclude(strLines);
return(new FFileNode(classStr, includes));
}
//============================================================
// <T>构造方法。</T>
//============================================================
public FFileNode()
{
_usings = new FArray <string>();
_classStr = string.Empty;
}
