protected virtual bool GenerateParseTable()
{
MyArrayList Terminals = GetAllTerminals();
Terminals.Add(new RuleTerminal(m_EofTerminal, null));
MyArrayList StartTokens = GetDifStartTokens();
m_LL1ParseTabelle = new TopDownParseTabelle(Terminals, StartTokens);
bool dblEntry = false;
for (int i = 0; i < m_Rules.Count; i++)
{
BNFRule rl = (BNFRule)m_Rules[i];
RuleStart rs = rl.GetStart();
int len = rs.GetRuleConnect().FirstSet.Count;
for (int j = 0; j < len; j++)
{
RuleElement re = (RuleElement)rs.GetRuleConnect().FirstSet[j];
string colSign = re.GetToken();
string rowSign = rs.GetToken();
if (!m_LL1ParseTabelle.Add(colSign, rowSign, rs))
{
dblEntry = true;
}
}
if (!rl.EpsilonFree)
{
len = rs.GetRuleConnect().FollowSet.Count;
for (int j = 0; j < len; j++)
{
RuleElement re = (RuleElement)rs.GetRuleConnect().FollowSet[j];
string colSign = re.GetToken();
string rowSign = rs.GetToken();
if (!m_LL1ParseTabelle.Add(colSign, rowSign, rs))
{
dblEntry = true;
}
}
}
}
return(!dblEntry);
}
protected void ConnectAlternateStartRules()
{
MyArrayList StartTokens = GetDifStartTokens();
for (int i = 0; i < StartTokens.Count; i++)
{
RuleStart strt = (RuleStart)StartTokens[i];
MyArrayList OneTokenRules = GetStartRulesOneToken(strt.GetToken());
ConnectAlternateStartRules(OneTokenRules);
}
}
public RuleStart GetStartRule(string Token)
{
for (int i = 0; i < m_Rules.Count; i++)
{
BNFRule rl = (BNFRule)m_Rules[i];
RuleStart rs = rl.GetStart();
if (Token.Equals(rs.GetToken()))
{
return(rs);
}
}
return(null);
}
protected void GenerateAllFollowSets()
{
MyArrayList StartTokens = GetDifStartTokens();
bool changed = false;
do
{
changed = false;
for (int i = 0; i < StartTokens.Count; i++)
{
RuleStart rs = (RuleStart)StartTokens[i];
MyArrayList AllNonTerms = GetNonTermsFrom(rs.GetToken());
MyArrayList Follows = GenerateFollowList(AllNonTerms);
if (rs.GetToken().Equals(m_StartSign))
{
Follows.Add(new RuleTerminal(m_EofTerminal, null));
}
if (SetAllFollows(rs, Follows))
{
changed = true;
}
}
}while(changed);
}
private bool IsRuleLeftRekursiv(RuleStart rs)
{
RuleElement re = rs.GetNext();
if (re != null)
{
string StartToken = rs.GetToken();
string FirstToken = re.GetToken();
if (StartToken.Equals(FirstToken))
{
return(true);
}
}
return(false);
}
private RuleStart FindStartTokenList(MyArrayList StartTokens, RuleToken rlTkn)
{
RuleStart rlStrt = null;
for (int i = 0; i < StartTokens.Count; i++)
{
RuleStart rlStartTkn = (RuleStart)StartTokens[i];
if (rlTkn.GetToken().Equals(rlStartTkn.GetToken()))
{
rlStrt = rlStartTkn;
break;
}
}
return(rlStrt);
}
private void EleminateDirectLeftRecursion(RuleStart strt)
{
string ElemStartTkn = "";
if (strt != null)
{
ElemStartTkn = FindUnusedToken(strt.GetToken());
}
while (strt != null)
{
if (IsRuleLeftRekursiv(strt))
{
RuleElement re = strt.GetNext();
if (re != null)
{
strt.SetNext(re.GetNext());
re = GotoLastRule(strt);
re.SetNext(new RuleToken(ElemStartTkn, strt));
strt.SetToken(ElemStartTkn);
}
BNFRule bnfRl = new BNFRule(m_Rules.Count);
bnfRl.SetStart(ElemStartTkn);
bnfRl.GetStart().SetNext(new RuleEpsilon(bnfRl.GetStart()));
m_Rules.Add(bnfRl);
}
else
{
RuleElement re = strt.GetNext();
if (re != null)
{
re = GotoLastRule(strt);
re.SetNext(new RuleToken(ElemStartTkn, strt));
}
}
strt = strt.GetAlternate();
}
}
public string GetRuleString()
{
string res = Start.GetToken() + "->";
RuleElement iterator = Start.GetNext();
while (iterator != null)
{
if (iterator.IsTerminal())
{
res += "'" + iterator.GetToken() + "'";
}
else
{
res += iterator.GetToken();
}
iterator = iterator.GetNext();
if (iterator != null)
{
res += ",";
}
}
res += ".";
return(res);
}
