/// <summary>
/// 计算文法的所有单个的结点的FIRST
/// </summary>
/// <param name="grammar"></param>
/// <param name="nullableDict"></param>
/// <returns></returns>
private static void GetFirstCollection4Node(
this RegulationList grammar,
out FIRSTCollection firstCollection,
Dictionary <TreeNodeType, bool> nullableDict = null)
{
// 初始化FIRST
firstCollection = new FIRSTCollection();
// 初始化非叶结点的FIRST
foreach (var item in grammar.GetAllTreeNodeNonLeaveTypes())
{
if (nullableDict[item])
{
firstCollection.TryInsert(new FIRST(item, TreeNodeType.NullNode));
}
else
{
firstCollection.TryInsert(new FIRST(item));
}
}
// 初始化叶结点的FIRST（叶结点的FIRST实际上已经完工）
foreach (var item in grammar.GetAllTreeNodeLeaveTypes())
{
firstCollection.TryInsert(new FIRST(item, item));
}
bool changed = false;
do
{
changed = false;
foreach (var regulation in grammar)
{
FIRST first = FindFirst(firstCollection, regulation.Left);
int rightPartCount = regulation.RightPart.Count();
for (int checkCount = 0; checkCount < rightPartCount; checkCount++)
{
// 如果前面checkCount个结点都可为null，
// 就说明RightPart[checkCount]的FIRST是此regulation.Left的FIRST的一部分。
if (Nullable(regulation.RightPart, 0, checkCount, nullableDict))
{
FIRST refFirst = FindFirst(firstCollection, regulation.RightNode(checkCount));
if (refFirst == null)
{
throw new Exception("algorithm error!");
}
if (refFirst != first)
{
foreach (var value in refFirst.Values)
{
if (value != TreeNodeType.NullNode)
{
changed = first.TryInsert(value) || changed;
}
}
}
}
}
}
} while (changed);
}
private static string GetUniqueString(HashCache cache)
{
FIRST obj = cache as FIRST;
return(obj.Dump());
//StringBuilder builder = new StringBuilder();
//{
// builder.Append("FIRST( ");
// int count = obj.target.Count;
// for (int i = 0; i < count; i++)
// {
// builder.Append(obj.target[i].Nickname);
// if (i + 1 < count)
// { builder.Append(" "); }
// }
// if (count == 0)
// { builder.Append("ε "); }
// builder.Append(" ) = ");
//}
//{
// builder.Append("【 ");
// int count = obj.values.Count;
// for (int i = 0; i < count; i++)
// {
// builder.Append(obj.values[i].Nickname);
// if (i + 1 < count)
// { builder.Append(" "); }
// }
// builder.Append(" 】");
//}
//return builder.ToString();
}
/// <summary>
/// 计算文法的各个RightPart的FIRST集
/// </summary>
/// <param name="grammar"></param>
/// <param name="nullableDict"></param>
/// <param name="firstList4Node"></param>
/// <returns></returns>
private static void GetFirstCollection4Regulation(
this RegulationList grammar,
out FIRSTCollection firstCollection,
Dictionary <TreeNodeType, bool> nullableDict = null, FIRSTCollection firstList4Node = null)
{
// 初始化FIRST集
firstCollection = new FIRSTCollection();
foreach (var regulation in grammar)
{
firstCollection.TryInsert(new FIRST(regulation.RightPart));
}
bool changed = false;
do
{
changed = false;
foreach (var first in firstCollection)
{
int count = first.Target.Count();
for (int i = 0; i < count; i++)
{
// 如果前i个结点都可为null，就说明下一个结点（first.Target[i]）的FIRST是此RightPart的FIRST的一部分
if (Nullable(first.Target, 0, i, nullableDict))
{
// 找到下一个结点的FIRST
FIRST refFirst = FindFirst(firstList4Node, first.GetNode(i));
foreach (var value in refFirst.Values)
{
if (value != TreeNodeType.NullNode)
{
changed = first.TryInsert(value) || changed;
}
}
}
}
{
// 如果RightPart的全部结点都可为null，就说明此RightPart的FIRST包含"null"结点。
if (Nullable(first.Target, 0, first.Target.Count(), nullableDict))
{
changed = first.TryInsert(TreeNodeType.NullNode) || changed;
}
}
}
} while (changed);
}
/// <summary>
/// LR(1)的Closure操作。
/// 补全一个状态。
/// </summary>
/// <param name="grammar"></param>
/// <param name="state"></param>
/// <returns></returns>
static SmallerLR1State Closure(this RegulationList grammar, SmallerLR1State state,
Dictionary <TreeNodeType, bool> nullableDict = null, FIRSTCollection firstCollection = null)
{
if (nullableDict == null)
{
grammar.GetNullableDict(out nullableDict);
}
if (firstCollection == null)
{
grammar.GetFirstCollection(out firstCollection, nullableDict);
}
Queue <LR1Item> queue = new Queue <LR1Item>();
foreach (var item in state)
{
queue.Enqueue(item);
}
while (queue.Count > 0)
{
LR1Item item = queue.Dequeue();
TreeNodeType node = item.GetNodeNext2Dot();
if (node == null || node.IsLeave)
{
continue;
}
List <TreeNodeType> betaZ = item.GetBetaZ();
FIRST first = grammar.GetFirst(firstCollection, nullableDict, betaZ);
List <Regulation> regulations = grammar.GetRegulations(node);
foreach (var regulation in regulations)
{
foreach (var value in first.Values)
{
LR1Item newItem = new LR1Item(regulation, 0, value);
if (state.TryInsert(newItem))
{
queue.Enqueue(newItem);
}
}
}
}
return(state);
}
/// <summary>
/// 根据文法和已经计算的所有结点的FIRST集，计算任意一个结点串的FIRST。
/// </summary>
/// <param name="grammar"></param>
/// <param name="firstList4Node"></param>
/// <param name="target"></param>
/// <returns></returns>
private static FIRST GetFirst(this RegulationList grammar, FIRSTCollection firstList4Node, Dictionary <TreeNodeType, bool> nullableDict, List <TreeNodeType> target)
{
// 初始化FIRST集
FIRST first = new FIRST(target);
bool changed = false;
do
{
changed = false;
int count = first.Target.Count();
for (int checkCount = 0; checkCount < count; checkCount++)
{
// 如果前i个结点都可为null，就说明下一个结点（first.Target[i]）的FIRST是此RightPart的FIRST的一部分
if (Nullable(first.Target, 0, checkCount, nullableDict))
{
// 找到下一个结点的FIRST
FIRST refFirst = FindFirst(firstList4Node, first.GetNode(checkCount));
foreach (var value in refFirst.Values)
{
if (value != TreeNodeType.NullNode)
{
changed = first.TryInsert(value) || changed;
}
}
}
}
{
// 如果RightPart的全部结点都可为null，就说明此RightPart的FIRST包含"null"结点。
if (Nullable(first.Target, 0, first.Target.Count(), nullableDict))
{
//throw new Exception("如果是在LR1分析器生成工具的设计时走到此处，说明代码有问题。");
if (!first.Values.Contains(TreeNodeType.NullNode))
{
changed = first.TryInsert(TreeNodeType.NullNode) || changed;
}
}
}
} while (changed);
return(first);
}
/// <summary>
/// 计算文法的FOLLOW集
/// </summary>
/// <param name="grammar"></param>
/// <param name="nullableDict"></param>
/// <param name="firstList4Node"></param>
/// <returns></returns>
private static void DoGetFollowList(
this RegulationList grammar,
out FOLLOWCollection followCollection,
Dictionary <TreeNodeType, bool> nullableDict, FIRSTCollection firstList4Node)
{
// 初始化Follow list
followCollection = new FOLLOWCollection();
foreach (var item in grammar.GetAllTreeNodeNonLeaveTypes())
{
followCollection.TryInsert(new FOLLOW(item));
}
// 迭代到不动点
bool changed = false;
do
{
changed = false;
foreach (var regulation in grammar)
{
int count = regulation.RightPart.Count();
for (int index = 0; index < count; index++)
{
// 准备为target添加follow元素
TreeNodeType target = regulation.RightNode(index);
if (target.IsLeave)
{
continue;
} // 叶结点没有follow
FOLLOW follow = FindFollow(followCollection, target); // 找到follow对象
for (int checkCount = 0; checkCount < count - (index + 1); checkCount++)
{
if (Nullable(regulation.RightPart, index + 1, checkCount, nullableDict))
{
// nullable之后的FIRST是target的follow的一部分
FIRST first = FindFirst(
firstList4Node, regulation.RightNode(index + 1 + checkCount));
foreach (var value in first.Values)
{
if (value != TreeNodeType.NullNode)
{
changed = follow.TryInsert(value) || changed;
}
}
}
}
{
// 如果target之后的全部结点都是nullable，说明此regulation.Left的folow也是target的一部分。
if (Nullable(regulation.RightPart, index + 1, count - (index + 1), nullableDict))
{
// 找到此regulation.Left的folow
FOLLOW refFollow = FindFollow(followCollection, regulation.Left);
if (refFollow != follow)
{
foreach (var item in refFollow.Values)
{
changed = follow.TryInsert(item) || changed;
}
}
}
}
}
}
} while (changed);
}