public static string ParseVerlaufArray2String(MyArrayList parseList) { string parseverlaufStr = ""; if (parseList != null) { for (int i = 0; i < parseList.Count; i++) { MyArrayList actStack = (MyArrayList)parseList[i]; if (actStack != null) { for (int j = 0; j < actStack.Count; j++) { RuleElement rl = (RuleElement)actStack[j]; if (rl.IsTerminal()) { parseverlaufStr += "'" + rl.GetToken() + "'"; } else { parseverlaufStr += rl.GetToken(); } parseverlaufStr += " "; } } parseverlaufStr += "\n"; } } return(parseverlaufStr); }
private bool FirstClosureFromRule(MyArrayList Huelle, string Token, MyArrayList FirstSet) { bool bChanged = false; MyArrayList TkRules = base.GetStartRulesOneToken(Token); if (TkRules != null && Huelle != null) { for (int i = 0; i < TkRules.Count; i++) { RuleStart rs = (RuleStart)TkRules[i]; int RuleNr = rs.GetRuleConnect().Index; int HuelPos = RuleInsideHuelle(Huelle, RuleNr, 1); if (HuelPos < 0) { LR1Element LrElm = new LR1Element(rs.GetRuleConnect().Index, m_HuellenCounter, m_LRMECnter++); LrElm.FirstSet = FirstSet; Huelle.Add(LrElm); bChanged = true; } else { LR1Element LrElm = (LR1Element)Huelle[HuelPos]; int FrstSize = LrElm.FirstSet.Count; LrElm.FirstSet = ParseHelper.UnionSet(LrElm.FirstSet, FirstSet); if (FrstSize != LrElm.FirstSet.Count) { bChanged = true; } } } } return(bChanged); }
private MyArrayList GenerateFollowList(MyArrayList NonTerms) { MyArrayList Follows = new MyArrayList(); for (int i = 0; i < NonTerms.Count; i++) { RuleElement re = (RuleElement)NonTerms[i]; RuleStart rs = re.GetBegin(); BNFRule rl = rs.GetRuleConnect(); RuleElement nextRe = re.GetNext(); if (nextRe == null) { Follows = ParseHelper.UnionSet(Follows, rl.FollowSet); } else { if (nextRe.IsTerminal()) { Follows.Add(nextRe); } else { RuleToken rt = (RuleToken)nextRe; MyArrayList AllFirstSet = BetaTotalRuleFirstSet(rt); Follows = ParseHelper.UnionSet(Follows, AllFirstSet); if (!BetaTotalRuleEpsFree(rt)) { Follows = ParseHelper.UnionSet(Follows, rl.FollowSet); } } } } return(Follows); }
protected MyArrayList BetaTotalRuleFirstSet(RuleElement re) { MyArrayList BetaFirst = new MyArrayList(); while (re != null) { if (re.IsTerminal()) { BetaFirst.Add(re); return(BetaFirst); } else { if (re.GetToken().Length > 0) { RuleToken rt = (RuleToken)re; if (rt != null) { RuleStart conStr = GoToFirstStartRule(rt.GetConnected()); MyArrayList FirstSet = TotalRuleFirstSet(conStr); BetaFirst = ParseHelper.UnionSet(BetaFirst, FirstSet); if (TotalRuleEpsFree(rt.GetConnected())) { return(BetaFirst); } } } } re = re.GetNext(); } return(BetaFirst); }
public TopDownParser(TopDownParseTabelle pt, RuleStart rs, string EOFSign) { m_pt = pt; m_rs = rs; m_ParseVerlaufArray = new MyArrayList(); m_EofSign = EOFSign; }
protected void GenerateAllFirstSets() { bool bChanged = true; while (bChanged) { bChanged = false; for (int i = 0; i < m_Rules.Count; i++) { MyArrayList FirstSet = new MyArrayList(); BNFRule bnfRl = (BNFRule)m_Rules[i]; RuleStart strt = bnfRl.GetStart(); if (strt != null) { RuleElement re = strt.GetNext(); FirstSet = BetaTotalRuleFirstSet(re); } int FrstSize = 0; if (strt.GetRuleConnect().FirstSet != null) { FrstSize = strt.GetRuleConnect().FirstSet.Count; } strt.GetRuleConnect().FirstSet = ParseHelper.UnionSet(strt.GetRuleConnect().FirstSet, FirstSet); FrstSize = strt.GetRuleConnect().FirstSet.Count - FrstSize; if (FrstSize != 0) { bChanged = true; } } } }
protected int GetHuellenNr(MyArrayList Huelle) { if (Huelle != null && Huelle.Count > 0) { LRElement lrm = (LRElement)Huelle[0]; return(lrm.HuellenNr); } return(-1); }
public SLR1ParseTable(MyArrayList Rules, string StartSign) : base(Rules, StartSign) { m_StartSign = FindUnusedToken(m_StartSign); BNFRule bnfRl = new BNFRule(m_Rules.Count); bnfRl.SetStart(m_StartSign); bnfRl.GetStart().SetNext(new RuleToken(StartSign, bnfRl.GetStart())); m_Rules.Add(bnfRl); }
public void AddCol() { for (int i = 0; i < m_rows; i++) { MyArrayList colArr = (MyArrayList)m_Tabelle[i]; colArr.Add(new object()); } m_cols++; }
public void AddArray(MyArrayList ArrCont) { if (ArrCont != null) { for (int i = 0; i < ArrCont.Count; i++) { Add(ArrCont[i]); } } }
private MyArrayList GetAllFollows() { MyArrayList Terminals = new MyArrayList(); for (int i = 0; i < m_Rules.Count; i++) { BNFRule rl = (BNFRule)m_Rules[i]; Terminals = ParseHelper.UnionSet(Terminals, rl.FollowSet); } return(Terminals); }
public bool Init() { if (m_pt != null) { m_ParseVarlauf = ""; m_ps = new ButtomUpParseStack(); m_ParseVerlaufArray = new MyArrayList(); return(true); } return(false); }
public void AddRow() { MyArrayList OneRow = new MyArrayList(); for (int j = 0; j < m_cols; j++) { OneRow.Add(new object()); } m_Tabelle.Add(OneRow); m_rows++; }
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); } }
protected MyArrayList GetAllTerminals() { MyArrayList Terminals = new MyArrayList(); for (int i = 0; i < m_Rules.Count; i++) { BNFRule rl = (BNFRule)m_Rules[i]; Terminals = ParseHelper.UnionSet(Terminals, rl.GetAllTerminals()); } return(Terminals); }
private MyArrayList GetNonTermsFrom(string NonTerm) { MyArrayList AllNonTerms = null; for (int i = 0; i < m_Rules.Count; i++) { BNFRule rule = (BNFRule)m_Rules[i]; MyArrayList NonTrms = rule.FindToken(NonTerm); AllNonTerms = ParseHelper.AddList(AllNonTerms, NonTrms); } return(AllNonTerms); }
private MyArrayList TotalRuleFollowSet(RuleStart rs) { MyArrayList res = new MyArrayList(); rs = GoToFirstStartRule(rs); while (rs != null) { res = ParseHelper.UnionSet(res, rs.GetRuleConnect().FollowSet); rs = rs.GetAlternate(); } return(res); }
protected void ConnectTokens() { MyArrayList StartTokens = GetDifStartTokens(); for (int i = 0; i < m_Rules.Count; i++) { BNFRule rule = (BNFRule)m_Rules[i]; RuleStart strt = rule.GetStart(); MyArrayList AllTkns = strt.GetAllTokens(); ConnectToken2Start(StartTokens, AllTkns); } }
public object Get(int col, int row) { if (row >= 0 && row < m_Tabelle.Count) { MyArrayList colArr = (MyArrayList)m_Tabelle[row]; if (col >= 0 && col < colArr.Count) { return(colArr[col]); } } return(null); }
private void ConnectToken2Start(MyArrayList StartTokens, MyArrayList AllRuleTokens) { for (int i = 0; i < AllRuleTokens.Count; i++) { RuleToken rlTkn = (RuleToken)AllRuleTokens[i]; RuleStart rlStartTkn = FindStartTokenList(StartTokens, rlTkn); if (rlStartTkn != null) { rlStartTkn = GoToFirstStartRule(rlStartTkn); rlTkn.SetConnected(rlStartTkn); } } }
/// <summary> /// /// </summary> /// <param name="re"></param> /// <param name="Nodes"></param> public ASTElement(RuleElement re, MyArrayList Nodes) { m_re = re; m_Root = null; m_NodeList = new MyArrayList(); if (Nodes != null) { for (int i = 0; i < Nodes.Count; i++) { m_NodeList.Add(Nodes[i]); } } }
public void Push(RuleStart Transition) { MyArrayList TransRules = Rules2Array(Transition); for (int i = 0; i < TransRules.Count; i++) { RuleElement re = (RuleElement)TransRules[TransRules.Count - i - 1]; m_Stack.Push(re); re = (RuleElement)TransRules[i]; ASTElement astElm = m_ActRoot.AddNode(re); m_TreeStack.Push(astElm); } }
protected virtual MyArrayList GenerateFirstSet(RuleStart rs) { MyArrayList res = new MyArrayList(); RuleElement re = null; if (rs != null) { re = rs.GetNext(); } else { return(null); } while (re != null) { if (re.GetToken().Equals("")) { re = re.GetNext(); } else { if (re.IsTerminal()) { res.Add(re); return(res); } else { RuleToken rt = (RuleToken)re; RuleStart conStr = GoToFirstStartRule(rt.GetConnected()); MyArrayList res2 = null; while (conStr != null) { res2 = GenerateFirstSet(conStr); res = ParseHelper.UnionSet(res, res2); conStr = conStr.GetAlternate(); } if (TotalRuleEpsFree(rt.GetConnected())) { return(res); } else { re = re.GetNext(); } } } } return(res); }
public static MyArrayList ConcatList(MyArrayList Lst1, MyArrayList Lst2) { MyArrayList ConcatList = new MyArrayList(); for (int i = 0; i < Lst1.Count; i++) { ConcatList.Add(Lst1[i]); } for (int i = 0; i < Lst2.Count; i++) { ConcatList.Add(Lst2[i]); } return(ConcatList); }
private MyArrayList CopyHuellen(MyArrayList arrOld) { MyArrayList newHuellen = new MyArrayList(); if (arrOld != null) { for (int i = 0; i < arrOld.Count; i++) { MyArrayList Huelle = (MyArrayList)arrOld[i]; newHuellen.Add(CopyHuelle(Huelle)); } } return(newHuellen); }
protected MyArrayList GetStartRulesOneToken(string Token) { MyArrayList StartRuleList = new MyArrayList(); for (int i = 0; i < m_Rules.Count; i++) { BNFRule rule = (BNFRule)m_Rules[i]; if (Token.Equals(rule.GetStart().GetToken())) { StartRuleList.Add(rule.GetStart()); } } return(StartRuleList); }
public static bool IsRuleInTokenList(MyArrayList RuleList, RuleElement re2) { if (RuleList != null) { for (int i = 0; i < RuleList.Count; i++) { RuleElement re1 = (RuleElement)RuleList[i]; if (re1.GetToken().Equals(re2.GetToken())) { return(true); } } } return(false); }
public static bool IsTokenInTokenList(MyArrayList TokenLst, RuleElement Token) { if (TokenLst != null) { for (int i = 0; i < TokenLst.Count; i++) { RuleElement re = (RuleElement)TokenLst[i]; if (Token.GetToken().Equals(re.GetToken())) { return(true); } } } return(false); }
public MyArrayList GetAllTokens() { MyArrayList tokens = new MyArrayList(); RuleElement re = m_Next; while (re != null) { if (!re.IsTerminal() && !re.GetToken().Equals("")) { tokens.Add(re); } re = re.GetNext(); } return(tokens); }
private string[] Rule2String(RuleStart rs) { MyArrayList elements = new MyArrayList(); if (rs != null) { RuleElement re = rs.GetNext(); while (re != null) { elements.Add(re.GetToken()); re = re.GetNext(); } } return((string[])elements.ToArray(typeof(string))); }