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);
        }
        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);
        }
 protected bool BetaTotalRuleEpsFree(RuleElement re)
 {
     while (re != null)
     {
         if (re.IsTerminal())
         {
             return(true);
         }
         else
         {
             if (re.GetToken().Length > 0)
             {
                 RuleToken rt = (RuleToken)re;
                 if (TotalRuleEpsFree(rt.GetConnected()))
                 {
                     return(true);
                 }
             }
             else
             {
                 return(false);
             }
         }
         re = re.GetNext();
     }
     return(false);
 }
        protected virtual bool RuleIsEpsilonFree(RuleStart rs)
        {
            RuleElement re = null;

            if (rs != null)
            {
                re = rs.GetNext();
            }
            else
            {
                return(false);
            }
            while (re != null)
            {
                if (re.IsTerminal())
                {
                    rs.GetRuleConnect().EpsilonFree = true;
                    return(true);
                }
                else
                {
                    if (re.GetToken().Equals(""))
                    {
                        rs.GetRuleConnect().EpsilonFree = false;
                        return(false);
                    }
                    else
                    {
                        RuleToken rt  = (RuleToken)re;
                        bool      res = RuleIsEpsilonFree(rt.GetConnected());
                        if (res)
                        {
                            rs.GetRuleConnect().EpsilonFree = res;
                            return(res);
                        }
                        else
                        {
                            re = re.GetNext();
                        }
                    }
                }
            }
            rs.GetRuleConnect().EpsilonFree = false;
            return(false);
        }