public LR_SyntaxTree ParseAll(SyntaxTreeBuilder pSyntaxTreeBuilder)
{
if (!pSyntaxTreeBuilder.TokenScanner.MoveNext())
{
return(null);
}
var kSyntaxTree = new LR_SyntaxTree();
var rootId = new ParseNode_Id(Rule_Start.NtName);
m_dicIdName2RuleOrToken[Rule_Start.NtName] = Rule_Start;
rootId.Init_PreCheckSet(this);
Rule_Start.parent = rootId;
pSyntaxTreeBuilder.SyntaxRule_Cur = kSyntaxTree.root = new SyntaxTreeNode_Rule(rootId);
pSyntaxTreeBuilder.ParseNode_Cur = Rule_Start.Parse(pSyntaxTreeBuilder);
pSyntaxTreeBuilder.SyntaxRule_Err = pSyntaxTreeBuilder.SyntaxRule_Cur;
pSyntaxTreeBuilder.ParseNode_Err = pSyntaxTreeBuilder.ParseNode_Cur;
while (pSyntaxTreeBuilder.ParseNode_Cur != null)
{
if (!ParseStep(pSyntaxTreeBuilder))
{
break;
}
}
return(kSyntaxTree);
}
public void Init()
{
RootID = new ParseNode_Id(Rule_Start.NtName);
m_dicIdName2RuleOrToken[Rule_Start.NtName] = Rule_Start;
RootID.Init_PreCheckSet(this);
Rule_Start.parent = RootID;
}
public void _AR_(ParseNode_Id id, ParseNode_Base rhs, SemanticFlags kSF = 0, bool bContextualKeyword = false, bool bAuto = false)
{
m_kParseRoot.AddRule(new ParseNode_Rule(id.Name, rhs)
{
semantics = kSF, contextualKeyword = bContextualKeyword, autoExclude = bAuto
});
}
public ParseNode_Id Clone()
{
var clone = new ParseNode_Id(Name)
{
LinkedTarget = LinkedTarget, FirstSet = FirstSet, FollowSet = FollowSet
};
var token = LinkedTarget as ParseNode_Token;
if (token != null)
{
clone.LinkedTarget = token.Clone();
clone.LinkedTarget.parent = this;
}
return(clone);
}
public SyntaxTreeNode_Rule(ParseNode_Id rule)
{
ParseNode = rule;
}
public SyntaxTreeNode_Rule AddNode(ParseNode_Id rule, SyntaxTreeBuilder pSyntaxTreeBuilder, out bool skipParsing)
{
skipParsing = false;
bool removedReusable = false;
if (NumValidNodes < nodes.Count)
{
var reusable = nodes[NumValidNodes] as SyntaxTreeNode_Rule;
if (reusable != null)
{
var firstLeaf = reusable.GetFirstLeaf(false);
if (reusable.ParseNode != rule)
{
if (firstLeaf == null || firstLeaf.token == null || firstLeaf.Line <= pSyntaxTreeBuilder.TokenScanner.CurrentLine)
{
reusable.Dispose();
removedReusable = true;
}
}
else
{
if (firstLeaf != null && firstLeaf.token != null && firstLeaf.Line > pSyntaxTreeBuilder.TokenScanner.CurrentLine)
{
// Ignore this node for now
}
else if (firstLeaf == null || firstLeaf.token != null && firstLeaf.m_sSyntaxError != null)
{
reusable.Dispose();
removedReusable = true;
}
else if (firstLeaf.token == pSyntaxTreeBuilder.TokenScanner.Current)
{
var lastLeaf = reusable.GetLastLeaf();
if (lastLeaf != null && !reusable.HasErrors())
{
if (lastLeaf.token != null)
{
((SyntaxTreeBuilder_CSharp)pSyntaxTreeBuilder).MoveAfterLeaf(lastLeaf);
skipParsing = true;
++NumValidNodes;
return(pSyntaxTreeBuilder.SyntaxRule_Cur);
}
}
else
{
reusable.Dispose();
removedReusable = true;
}
}
else if (reusable.NumValidNodes == 0)
{
++NumValidNodes;
reusable.m_sSyntaxError = null;
reusable.m_bMissing = false;
return(reusable);
}
else if (pSyntaxTreeBuilder.TokenScanner.Current != null && (firstLeaf.token == null || firstLeaf.Line <= pSyntaxTreeBuilder.TokenScanner.CurrentLine))
{
reusable.Dispose();
if (firstLeaf.token == null || firstLeaf.Line == pSyntaxTreeBuilder.TokenScanner.CurrentLine)
{
removedReusable = true;
}
else
{
nodes.RemoveAt(NumValidNodes);
for (var i = NumValidNodes; i < nodes.Count; ++i)
{
--nodes[i].m_iChildIndex;
}
return(AddNode(rule, pSyntaxTreeBuilder, out skipParsing));
}
}
}
}
}
var node = new SyntaxTreeNode_Rule(rule)
{
Parent = this, m_iChildIndex = NumValidNodes
};
if (NumValidNodes == nodes.Count)
{
nodes.Add(node);
++NumValidNodes;
}
else
{
if (removedReusable)
{
nodes[NumValidNodes] = node;
}
else
{
nodes.Insert(NumValidNodes, node);
}
++NumValidNodes;
}
if (NumValidNodes < nodes.Count && nodes[NumValidNodes].m_iChildIndex != NumValidNodes)
{
for (var i = NumValidNodes; i < nodes.Count; ++i)
{
nodes[i].m_iChildIndex = i;
}
}
return(node);
}
