public override ParseNode_Base Parse(SyntaxTreeBuilder pSyntaxTreeBuilder)
 {
     if (FirstSet.Contains(pSyntaxTreeBuilder.TokenScanner.Current.tokenId))
     {
         return(node.Parse(pSyntaxTreeBuilder));
     }
     return(parent.NextAfterChild(this, pSyntaxTreeBuilder));
 }
 public override ParseNode_Base Parse(SyntaxTreeBuilder pSyntaxTreeBuilder)
 {
     if (FirstSet.Contains(pSyntaxTreeBuilder.TokenScanner.Current.tokenId) && CheckPredicate(pSyntaxTreeBuilder))
     {
         return(node.Parse(pSyntaxTreeBuilder));
     }
     else
     {
         return(parent.NextAfterChild(this, pSyntaxTreeBuilder)); // .Parse2(pSyntaxTreeBuilder, goal);
     }
 }
    public override bool Scan(SyntaxTreeBuilder pSyntaxTreeBuilder)
    {
        if (!pSyntaxTreeBuilder.KeepScanning)
        {
            return(true);
        }

        if (FirstSet.Contains(pSyntaxTreeBuilder.TokenScanner.Current.tokenId) && CheckPredicate(pSyntaxTreeBuilder))
        {
            return(node.Scan(pSyntaxTreeBuilder));
        }
        return(true);
    }
    public override bool Scan(SyntaxTreeBuilder pSyntaxTreeBuilder)
    {
        if (!pSyntaxTreeBuilder.KeepScanning)
        {
            return(true);
        }

        if (!FirstSet.Contains(pSyntaxTreeBuilder.TokenScanner.Current.tokenId))
        {
            return(false);
        }
        pSyntaxTreeBuilder.TokenScanner.MoveNext();
        return(true);
    }
    public override bool Scan(SyntaxTreeBuilder pSyntaxTreeBuilder)
    {
        if (!pSyntaxTreeBuilder.KeepScanning)
        {
            return(true);
        }

        var ifNode = node as ParseNode_ManyOpt_If ?? node as ParseNode_ManyOpt_IfNot;

        if (ifNode != null)
        {
            int tokenIndex, line;
            do
            {
                tokenIndex = pSyntaxTreeBuilder.TokenScanner.CurrentTokenIndex;
                line       = pSyntaxTreeBuilder.TokenScanner.CurrentLine - 1;
                if (!node.Scan(pSyntaxTreeBuilder))
                {
                    return(false);
                }
                if (!pSyntaxTreeBuilder.KeepScanning)
                {
                    return(true);
                }
            } while (pSyntaxTreeBuilder.TokenScanner.CurrentTokenIndex != tokenIndex || pSyntaxTreeBuilder.TokenScanner.CurrentLine - 1 != line);
        }
        else
        {
            while (FirstSet.Contains(pSyntaxTreeBuilder.TokenScanner.Current.tokenId))
            {
                int tokenIndex = pSyntaxTreeBuilder.TokenScanner.CurrentTokenIndex;
                int line       = pSyntaxTreeBuilder.TokenScanner.CurrentLine;
                if (!node.Scan(pSyntaxTreeBuilder))
                {
                    return(false);
                }
                if (!pSyntaxTreeBuilder.KeepScanning)
                {
                    return(true);
                }
                if (pSyntaxTreeBuilder.TokenScanner.CurrentTokenIndex == tokenIndex && pSyntaxTreeBuilder.TokenScanner.CurrentLine - 1 == line)
                {
                    throw new Exception("Infinite loop!!!");
                }
            }
        }
        return(true);
    }
 public override bool Scan(SyntaxTreeBuilder pSyntaxTreeBuilder)
 {
     if (!pSyntaxTreeBuilder.KeepScanning)
     {
         return(true);
     }
     if (FirstSet.Contains(pSyntaxTreeBuilder.TokenScanner.Current))
     {
         return(rhs.Scan(pSyntaxTreeBuilder));
     }
     else if (!FirstSet.ContainsEmpty())
     {
         return(false);
     }
     return(true);
 }
    public override ParseNode_Base Parse(SyntaxTreeBuilder pSyntaxTreeBuilder)
    {
        if (!FirstSet.Contains(pSyntaxTreeBuilder.TokenScanner.Current.tokenId))
        {
            pSyntaxTreeBuilder.SyntaxErrorExpected(FirstSet);
            return(this);
        }

        pSyntaxTreeBuilder.SyntaxRule_Cur.AddToken(pSyntaxTreeBuilder.TokenScanner).ParseNode = this;
        pSyntaxTreeBuilder.TokenScanner.MoveNext();
        if (pSyntaxTreeBuilder.ErrorMessage == null)
        {
            pSyntaxTreeBuilder.SyntaxRule_Err = pSyntaxTreeBuilder.SyntaxRule_Cur;
            pSyntaxTreeBuilder.ParseNode_Err  = pSyntaxTreeBuilder.ParseNode_Cur;
        }

        return(parent.NextAfterChild(this, pSyntaxTreeBuilder));
    }
    public override ParseNode_Base Parse(SyntaxTreeBuilder pSyntaxTreeBuilder)
    {
        bool           wasError = pSyntaxTreeBuilder.ErrorMessage != null;
        ParseNode_Base ret      = null;

        if (FirstSet.Contains(pSyntaxTreeBuilder.TokenScanner.Current))
        {
            ret = rhs.Parse(pSyntaxTreeBuilder);
        }
        if ((ret == null || !wasError && pSyntaxTreeBuilder.ErrorMessage != null) && !FirstSet.ContainsEmpty())
        {
            pSyntaxTreeBuilder.SyntaxErrorExpected(FirstSet);
            return(ret ?? this);
        }
        if (ret != null)
        {
            return(ret);
        }
        return(NextAfterChild(rhs, pSyntaxTreeBuilder)); // ready to be reduced
    }
    public override ParseNode_Base Parse(SyntaxTreeBuilder pSyntaxTreeBuilder)
    {
        var ifNode = node as ParseNode_ManyOpt_If;

        if (ifNode != null)
        {
            if (!ifNode.Matches(pSyntaxTreeBuilder))
            {
                return(parent.NextAfterChild(this, pSyntaxTreeBuilder));
            }

            var tokenIndex = pSyntaxTreeBuilder.TokenScanner.CurrentTokenIndex;
            var line       = pSyntaxTreeBuilder.TokenScanner.CurrentLine;
            var nextNode   = node.Parse(pSyntaxTreeBuilder);
            if (nextNode != this || pSyntaxTreeBuilder.TokenScanner.CurrentTokenIndex != tokenIndex || pSyntaxTreeBuilder.TokenScanner.CurrentLine != line)
            {
                return(nextNode);
            }
            //Debug.Log("Exiting Many " + this + " in goal: " + pSyntaxTreeBuilder.CurrentParseTreeNode);
        }
        else
        {
            if (!FirstSet.Contains(pSyntaxTreeBuilder.TokenScanner.Current.tokenId))
            {
                return(parent.NextAfterChild(this, pSyntaxTreeBuilder));
            }

            var tokenIndex = pSyntaxTreeBuilder.TokenScanner.CurrentTokenIndex;
            var line       = pSyntaxTreeBuilder.TokenScanner.CurrentLine;
            var nextNode   = node.Parse(pSyntaxTreeBuilder);
            if (!(nextNode == this && pSyntaxTreeBuilder.TokenScanner.CurrentTokenIndex == tokenIndex && pSyntaxTreeBuilder.TokenScanner.CurrentLine == line))
            {
                // throw new Exception("Infinite loop!!! while parsing " + pSyntaxTreeBuilder.Current + " on line " + pSyntaxTreeBuilder.CurrentLine());
                return(nextNode);
            }
        }
        return(parent.NextAfterChild(this, pSyntaxTreeBuilder));
    }
 public override bool Matches(SyntaxTreeBuilder pSyntaxTreeBuilder)
 {
     return(FirstSet.Contains(pSyntaxTreeBuilder.TokenScanner.Current) && CheckPredicate(pSyntaxTreeBuilder));
 }