/// <summary>
/// Expression -> <ExpressionOr> <Expression> | <ExpressionOr> | <epsilon>;
/// </summary>
/// <param name="WordInfo"></param>
/// <returns></returns>
private ResultItem Analysis_Expression(NFAGenerator_Lexer.WordInfo[] WordInfo)
{
var startnode = new NFANode {
Edge = new NFAEdge[0]
};
var curnode = startnode;
while (true)
{
if (CurIndex >= WordInfo.Length)
{
break;
}
var r = Analysis_ExpressionOr(WordInfo);
curnode.Edge = new NFAEdge[1] {
new NFAEdge {
Epsilon = true, NextNode = r.StartNode
}
};
curnode = r.EndNode;
if (CurIndex < WordInfo.Length && WordInfo[CurIndex].Type == NFAGenerator_Lexer.WordType.RightBrace)
{
break;
}
}
return(new ResultItem {
StartNode = startnode, EndNode = curnode
});
}
/// <summary>
/// ExpressionStar -> <ExpressionChar> <Star> | <ExpressionChar>
/// </summary>
/// <param name="WordInfo"></param>
/// <returns></returns>
private ResultItem Analysis_ExpressionStar(NFAGenerator_Lexer.WordInfo[] WordInfo)
{
var r = Analysis_ExpressionChar(WordInfo);
if (CurIndex < WordInfo.Length && WordInfo[CurIndex].Type == NFAGenerator_Lexer.WordType.Star)
{
var endnode = new NFANode {
Edge = new NFAEdge[0]
};
var startnode = new NFANode {
Edge = new NFAEdge[2] {
new NFAEdge {
Epsilon = true, NextNode = r.StartNode
}, new NFAEdge {
Epsilon = true, NextNode = endnode
}
}
};
r.EndNode.Edge = new NFAEdge[1] {
new NFAEdge {
Epsilon = true, NextNode = startnode
}
};
CurIndex++;
return(new ResultItem {
StartNode = startnode, EndNode = endnode
});
}
return(r);
}
/// <summary>
/// ExpressionPart -> <ExpressionStar> <ExpressionPart> | <ExpressionStar>
/// </summary>
/// <param name="WordInfo"></param>
/// <returns></returns>
private ResultItem Analysis_ExpressionPart(NFAGenerator_Lexer.WordInfo[] WordInfo)
{
var startnode = new NFANode {
Edge = new NFAEdge[0]
};
var curnode = startnode;
var empty = true;
while (true)
{
var beginindex = CurIndex;
try
{
var r = Analysis_ExpressionStar(WordInfo);
curnode.Edge = new NFAEdge[1] {
new NFAEdge {
Epsilon = true, NextNode = r.StartNode
}
};
curnode = r.EndNode;
empty = false;
}
catch (NFAParserAnalysisException ex)
{
CurIndex = beginindex;
break;
}
if (CurIndex < WordInfo.Length && WordInfo[CurIndex].Type == NFAGenerator_Lexer.WordType.RightBrace)
{
break;
}
}
if (empty)
{
if (CurIndex >= WordInfo.Length)
{
GenerateError("期望表达式但遇到了文本结束标记");
}
else
{
GenerateError("期望表达式", ((char)WordInfo[CurIndex].AdditionInfo) + "");
}
}
return(new ResultItem {
StartNode = startnode, EndNode = curnode
});
}
/// <summary>
/// ExpressionOr -> <ExpressionPart> <Or> <ExpressionOr> | <ExpressionPart>;
/// </summary>
/// <param name="WordInfo"></param>
/// <returns></returns>
private ResultItem Analysis_ExpressionOr(NFAGenerator_Lexer.WordInfo[] WordInfo)
{
var rlist = new List <ResultItem>();
while (true)
{
var r = Analysis_ExpressionPart(WordInfo);
rlist.Add(r);
if (CurIndex >= WordInfo.Length || WordInfo[CurIndex].Type != NFAGenerator_Lexer.WordType.Or)
{
break;
}
if (CurIndex < WordInfo.Length && WordInfo[CurIndex].Type == NFAGenerator_Lexer.WordType.RightBrace)
{
break;
}
CurIndex++;
}
if (rlist.Count == 0)
{
GenerateError("表达式选择列表为空");
}
var beginnode = new NFANode();
var endnode = new NFANode {
Edge = new NFAEdge[0]
};
var beginlist = new List <NFAEdge>();
foreach (var item in rlist)
{
beginlist.Add(new NFAEdge {
Epsilon = true, NextNode = item.StartNode
});
item.EndNode.Edge = new NFAEdge[1] {
new NFAEdge {
Epsilon = true, NextNode = endnode
}
};
}
beginnode.Edge = beginlist.ToArray();
return(new ResultItem {
StartNode = beginnode, EndNode = endnode
});
}
/// <summary>
/// ExpressionChar -> "(" <Expression> ")" | <Char>
/// </summary>
/// <param name="WordInfo"></param>
/// <returns></returns>
private ResultItem Analysis_ExpressionChar(NFAGenerator_Lexer.WordInfo[] WordInfo)
{
if (CurIndex >= WordInfo.Length)
{
GenerateError("期望字符或表达式但遇到了文本结束标记");
}
switch (WordInfo[CurIndex].Type)
{
case NFAGenerator_Lexer.WordType.LeftBrace:
var beginindex = CurIndex;
CurIndex++;
var r = Analysis_Expression(WordInfo);
if (CurIndex >= WordInfo.Length || WordInfo[CurIndex].Type != NFAGenerator_Lexer.WordType.RightBrace)
{
CurIndex = beginindex;
GenerateError("该左括号无对应右括号", "(");
}
CurIndex++;
return(r);
case NFAGenerator_Lexer.WordType.Char:
var node = new NFANode {
Edge = new NFAEdge[1] {
new NFAEdge {
Condition = (char)WordInfo[CurIndex].AdditionInfo, Epsilon = false, NextNode = new NFANode {
Edge = new NFAEdge[0]
}
}
}
};
CurIndex++;
return(new ResultItem {
StartNode = node, EndNode = node.Edge[0].NextNode
});
default:
GenerateError("无效的词，期望\"(\"或字符", ((char)WordInfo[CurIndex].AdditionInfo) + "");
break;
}
//Here is unreachable
return(new ResultItem());
}
private static void DFS(NFANode CurNode)
{
var curname = StateNameMap[CurNode];
foreach (var item in CurNode.Edge)
{
if (!StateNameMap.ContainsKey(item.NextNode))
{
var newname = "Q" + (NewStateID++);
StateNameMap.Add(item.NextNode, newname);
VertexList.Add(newname);
EdgeList.Add(new string[3] {
curname, newname, item.Epsilon ? "" : item.Condition + ""
});
DFS(item.NextNode);
}
else
{
EdgeList.Add(new string[3] {
curname, StateNameMap[item.NextNode], item.Epsilon ? "" : item.Condition + ""
});
}
}
}
