public ParseRule(Condition result, ParseRuleCollapsableLevel collapsableLevel, params List <Condition>[] requiredTokens)
            : this()
        {
            Contract.Requires(requiredTokens != null);

            Result           = result.Token;
            CollapsableLevel = collapsableLevel;
            RequiredTokens   = new Condition[requiredTokens.Length][];

            for (int i = 0; i < requiredTokens.Length; i++)
            {
                RequiredTokens[i] = new Condition[requiredTokens[i].Count];

                for (int j = 0; j < requiredTokens[i].Count; j++)
                {
                    RequiredTokens[i][j] = requiredTokens[i][j];
                }
            }
        }
        private bool MatchCondition(Condition token, int sourceOffset, Condition[] alternative, ParseRuleCollapsableLevel collapsableLevel,
                                    ref AstNode node, ref int tokensConsumed)
        {
            var     lookupTokensConsumed = 0;
            AstNode matchedNode          = Match(sourceOffset + tokensConsumed, alternative, ref lookupTokensConsumed);

            if (matchedNode.IsNull)
            {
                return(false);
            }
            else
            {
                var childrenCount = matchedNode.ChildrenCount;

                if (collapsableLevel == ParseRuleCollapsableLevel.Always ||
                    (collapsableLevel == ParseRuleCollapsableLevel.OneChild && childrenCount == 1))
                {
                    for (int i = 0; i < childrenCount; i++)
                    {
                        node.AddChild(m_RootNode, matchedNode.Children[i]);
                    }
                }
                else
                {
                    matchedNode.Type = token.Token;
                    node.AddChild(m_RootNode, matchedNode);
                }

                tokensConsumed += lookupTokensConsumed;
                LastMatched     = tokensConsumed;
                return(true);
            }
        }