﻿/*Author:Martin.Holzherr;Date:20080922;Context:"PEG Support for C#";Licence:CPOL
 * <<History>> 
 *  20080922;V1.0 created
 *  20080929;UTF16BE;Added UTF16BE read support to <<FileLoader.LoadFile(out string src)>>
 * <</History>>
*/
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Diagnostics;
using System.Text;
using System;
namespace Peg.Base
{
    #region Input File Support
    public enum EncodingClass { unicode, utf8, binary, ascii };
    public enum UnicodeDetection { notApplicable, BOM, FirstCharIsAscii };
    public class FileLoader
    {
        public enum FileEncoding { none, ascii, binary, utf8, unicode, utf16be, utf16le, utf32le, utf32be, uniCodeBOM };
        public FileLoader(EncodingClass encodingClass, UnicodeDetection detection, string path)
        {
            encoding_ = GetEncoding(encodingClass, detection, path);
            path_ = path;
        }
        public bool IsBinaryFile()
        {
            return encoding_ == FileEncoding.binary;
        }
        public bool LoadFile(out byte[] src)
        {
            src = null;
            if (!IsBinaryFile()) return false;
            using (BinaryReader brdr = new BinaryReader(File.Open(path_, FileMode.Open,FileAccess.Read)))
            {
                src = brdr.ReadBytes((int)brdr.BaseStream.Length);
                return true;
            }
        }
        public bool LoadFile(out string src)
        {
            src = null;
            Encoding textEncoding = FileEncodingToTextEncoding();
            if (textEncoding == null)
            {
                if (encoding_ == FileEncoding.binary) return false;
                using (StreamReader rd = new StreamReader(path_, true))
                {
                    src = rd.ReadToEnd();
                    return true;
                }
            }
            else
            {
                if (encoding_ == FileEncoding.utf16be)//UTF16BE
                {
                    using (BinaryReader brdr = new BinaryReader(File.Open(path_, FileMode.Open, FileAccess.Read)))
                    {
                        byte[] bytes = brdr.ReadBytes((int)brdr.BaseStream.Length);
                        StringBuilder s = new StringBuilder();
                        for (int i = 0; i < bytes.Length; i += 2)
                        {
                            char c = (char)(bytes[i] << 8 | bytes[i + 1]);
                            s.Append(c);
                        }
                        src = s.ToString();
                        return true;
                    }
                }
                else
                {
                    using (StreamReader rd = new StreamReader(path_, textEncoding))
                    {
                        src = rd.ReadToEnd();
                        return true;
                    }
                }
            }

        }
        Encoding FileEncodingToTextEncoding()
        {
            switch (encoding_)
            {
                case FileEncoding.utf8: return new UTF8Encoding();
                case FileEncoding.utf32be:
                case FileEncoding.utf32le: return new UTF32Encoding();
                case FileEncoding.unicode:
                case FileEncoding.utf16be:
                case FileEncoding.utf16le: return new UnicodeEncoding();
                case FileEncoding.ascii: return new ASCIIEncoding();
                case FileEncoding.binary:
                case FileEncoding.uniCodeBOM: return null;
                default: Debug.Assert(false);
                    return null;

            }
        }
        static FileEncoding DetermineUnicodeWhenFirstCharIsAscii(string path)
        {
            using (BinaryReader br = new BinaryReader(File.Open(path, FileMode.Open, FileAccess.Read)))
            {
                byte[] startBytes = br.ReadBytes(4);
                if (startBytes.Length == 0) return FileEncoding.none;
                if (startBytes.Length == 1 || startBytes.Length == 3) return FileEncoding.utf8;
                if (startBytes.Length == 2 && startBytes[0] != 0) return FileEncoding.utf16le;
                if (startBytes.Length == 2 && startBytes[0] == 0) return FileEncoding.utf16be;
                if (startBytes[0] == 0 && startBytes[1] == 0) return FileEncoding.utf32be;
                if (startBytes[0] == 0 && startBytes[1] != 0) return FileEncoding.utf16be;
                if (startBytes[0] != 0 && startBytes[1] == 0) return FileEncoding.utf16le;
                return FileEncoding.utf8;
            }
        }
        FileEncoding GetEncoding(EncodingClass encodingClass, UnicodeDetection detection, string path)
        {
            switch (encodingClass)
            {
                case EncodingClass.ascii: return FileEncoding.ascii;
                case EncodingClass.unicode:
                    {
                        if (detection == UnicodeDetection.FirstCharIsAscii)
                        {
                            return DetermineUnicodeWhenFirstCharIsAscii(path);
                        }
                        else if (detection == UnicodeDetection.BOM)
                        {
                            return FileEncoding.uniCodeBOM;
                        }
                        else return FileEncoding.unicode;
                    }
                case EncodingClass.utf8: return FileEncoding.utf8;
                case EncodingClass.binary: return FileEncoding.binary;
            }
            return FileEncoding.none;
        }
        string path_;
        public readonly FileEncoding encoding_;
    }
    #endregion Input File Support
    #region Error handling
    public class PegException : System.Exception
    {
        public PegException()
            : base("Fatal parsing error ocurred")
        {
        }
    }
    public struct PegError
    {
        internal SortedList<int, int> lineStarts;
        void AddLineStarts(string s, int first, int last, ref int lineNo, out int colNo)
        {
            colNo = 2;
            for (int i = first + 1; i <= last; ++i, ++colNo)
            {
                if (s[i - 1] == '\n')
                {
                    lineStarts[i] = ++lineNo;
                    colNo = 1;
                }
            }
            --colNo;
        }
        public void GetLineAndCol(string s, int pos, out int lineNo, out int colNo)
        {
            for (int i = lineStarts.Count(); i > 0; --i)
            {
                KeyValuePair<int, int> curLs = lineStarts.ElementAt(i - 1);
                if (curLs.Key == pos)
                {
                    lineNo = curLs.Value;
                    colNo = 1;
                    return;
                }
                if (curLs.Key < pos)
                {
                    lineNo = curLs.Value;
                    AddLineStarts(s, curLs.Key, pos, ref lineNo, out colNo);
                    return;
                }
            }
            lineNo = 1;
            AddLineStarts(s, 0, pos, ref lineNo, out colNo);
        }
    }
    #endregion Error handling
    #region Syntax/Parse-Tree related classes
    public enum ESpecialNodes { eFatal = -10001, eAnonymNTNode = -1000, eAnonymASTNode = -1001, eAnonymousNode = -100 }
    public enum ECreatorPhase { eCreate, eCreationComplete, eCreateAndComplete }
    public struct PegBegEnd//indices into the source string
    {
        public int Length
        {
            get { return posEnd_ - posBeg_; }
        }
        public string GetAsString(string src)
        {
            Debug.Assert(src.Length >= posEnd_);
            return src.Substring(posBeg_, Length);
        }
        public int posBeg_;
        public int posEnd_;
    }
    public class PegNode : ICloneable
    {
        #region Constructors
        public PegNode(PegNode parent, int id, PegBegEnd match, PegNode child, PegNode next)
        {
            parent_ = parent; id_ = id; child_ = child; next_ = next;
            match_ = match;
        }
        public PegNode(PegNode parent, int id, PegBegEnd match, PegNode child)
            : this(parent, id, match, child, null)
        {
        }
        public PegNode(PegNode parent, int id, PegBegEnd match)
            : this(parent, id, match, null, null)
        { }
        public PegNode(PegNode parent, int id)
            : this(parent, id, new PegBegEnd(), null, null)
        {
        }
        #endregion Constructors
        #region Public Members
        public virtual string GetAsString(string s)
        {
            return match_.GetAsString(s);
        }
        public virtual PegNode Clone()
        {
            PegNode clone= new PegNode(parent_, id_, match_);
            CloneSubTrees(clone);
            return clone;
        }
        #endregion Public Members
        #region Protected Members
        protected void CloneSubTrees(PegNode clone)
        {
            PegNode child = null, next = null;
            if (child_ != null)
            {
                child = child_.Clone();
                child.parent_ = clone;
            }
            if (next_ != null)
            {
                next = next_.Clone();
                next.parent_ = clone;
            }
            clone.child_ = child;
            clone.next_ = next;
        }
        #endregion Protected Members
        #region Data Members
        public int id_;
        public PegNode parent_, child_, next_;
        public PegBegEnd match_;
        #endregion Data Members

        #region ICloneable Members

        object ICloneable.Clone()
        {
            return Clone();
        }

        #endregion
    }
    internal struct PegTree
    {
        internal enum AddPolicy { eAddAsChild, eAddAsSibling };
        internal PegNode root_;
        internal PegNode cur_;
        internal AddPolicy addPolicy;
    }
    public abstract class PrintNode
    {
        public abstract int LenMaxLine();
        public abstract bool IsLeaf(PegNode p);
        public virtual bool IsSkip(PegNode p) { return false; }
        public abstract void PrintNodeBeg(PegNode p, bool bAlignVertical, ref int nOffsetLineBeg, int nLevel);
        public abstract void PrintNodeEnd(PegNode p, bool bAlignVertical, ref int nOffsetLineBeg, int nLevel);
        public abstract int LenNodeBeg(PegNode p);
        public abstract int LenNodeEnd(PegNode p);
        public abstract void PrintLeaf(PegNode p, ref int nOffsetLineBeg, bool bAlignVertical);
        public abstract int LenLeaf(PegNode p);
        public abstract int LenDistNext(PegNode p, bool bAlignVertical, ref int nOffsetLineBeg, int nLevel);
        public abstract void PrintDistNext(PegNode p, bool bAlignVertical, ref int nOffsetLineBeg, int nLevel);
    }
    public class TreePrint : PrintNode
    {
        #region Data Members
        public delegate string GetNodeName(PegNode node);
        string src_;
        TextWriter treeOut_;
        int nMaxLineLen_;
        bool bVerbose_;
        GetNodeName GetNodeName_;
        #endregion Data Members
        #region Methods
        public TreePrint(TextWriter treeOut, string src, int nMaxLineLen, GetNodeName GetNodeName, bool bVerbose)
        {
            treeOut_ = treeOut;
            nMaxLineLen_ = nMaxLineLen;
            bVerbose_ = bVerbose;
            GetNodeName_ = GetNodeName;
            src_ = src;
        }

        public void PrintTree(PegNode parent, int nOffsetLineBeg, int nLevel)
        {
            if (IsLeaf(parent))
            {
                PrintLeaf(parent, ref nOffsetLineBeg, false);
                treeOut_.Flush();
                return;
            }
            bool bAlignVertical =
                DetermineLineLength(parent, nOffsetLineBeg) > LenMaxLine();
            PrintNodeBeg(parent, bAlignVertical, ref nOffsetLineBeg, nLevel);
            int nOffset = nOffsetLineBeg;
            for (PegNode p = parent.child_; p != null; p = p.next_)
            {
                if (IsSkip(p)) continue;

                if (IsLeaf(p))
                {
                    PrintLeaf(p, ref nOffsetLineBeg, bAlignVertical);
                }
                else
                {
                    PrintTree(p, nOffsetLineBeg, nLevel + 1);
                }
                if (bAlignVertical)
                {
                    nOffsetLineBeg = nOffset;
                }
                while (p.next_ != null && IsSkip(p.next_)) p = p.next_;

                if (p.next_ != null)
                {
                    PrintDistNext(p, bAlignVertical, ref nOffsetLineBeg, nLevel);
                }
            }
            PrintNodeEnd(parent, bAlignVertical, ref  nOffsetLineBeg, nLevel);
            treeOut_.Flush();
        }
        int DetermineLineLength(PegNode parent, int nOffsetLineBeg)
        {
            int nLen = LenNodeBeg(parent);
            PegNode p;
            for (p = parent.child_; p != null; p = p.next_)
            {
                if (IsSkip(p)) continue;
                if (IsLeaf(p))
                {
                    nLen += LenLeaf(p);
                }
                else
                {
                    nLen += DetermineLineLength(p, nOffsetLineBeg);
                }
                if (nLen + nOffsetLineBeg > LenMaxLine())
                {
                    return nLen + nOffsetLineBeg;
                }
            }
            nLen += LenNodeEnd(p);
            return nLen;
        }
        public override int LenMaxLine() { return nMaxLineLen_; }
        public override void
            PrintNodeBeg(PegNode p, bool bAlignVertical, ref int nOffsetLineBeg, int nLevel)
        {
            PrintIdAsName(p);
            treeOut_.Write("<");
            if (bAlignVertical)
            {
                treeOut_.WriteLine();
                treeOut_.Write(new string(' ', nOffsetLineBeg += 2));
            }
            else
            {
                ++nOffsetLineBeg;
            }
        }
        public override void
            PrintNodeEnd(PegNode p, bool bAlignVertical, ref int nOffsetLineBeg, int nLevel)
        {
            if (bAlignVertical)
            {
                treeOut_.WriteLine();
                treeOut_.Write(new string(' ', nOffsetLineBeg -= 2));
            }
            treeOut_.Write('>');
            if (!bAlignVertical)
            {
                ++nOffsetLineBeg;
            }
        }
        public override int LenNodeBeg(PegNode p) { return LenIdAsName(p) + 1; }
        public override int LenNodeEnd(PegNode p) { return 1; }
        public override void PrintLeaf(PegNode p, ref int nOffsetLineBeg, bool bAlignVertical)
        {
            if (bVerbose_)
            {
                PrintIdAsName(p);
                treeOut_.Write('<');
            }
            int len = p.match_.posEnd_ - p.match_.posBeg_;
            treeOut_.Write("'");
            if (len > 0)
            {
                treeOut_.Write(src_.Substring(p.match_.posBeg_, p.match_.posEnd_ - p.match_.posBeg_));
            }
            treeOut_.Write("'");
            if (bVerbose_) treeOut_.Write('>');
        }
        public override int LenLeaf(PegNode p)
        {
            int nLen = p.match_.posEnd_ - p.match_.posBeg_ + 2;
            if (bVerbose_) nLen += LenIdAsName(p) + 2;
            return nLen;
        }
        public override bool IsLeaf(PegNode p)
        {
            return p.child_ == null;
        }

        public override void
            PrintDistNext(PegNode p, bool bAlignVertical, ref int nOffsetLineBeg, int nLevel)
        {
            if (bAlignVertical)
            {
                treeOut_.WriteLine();
                treeOut_.Write(new string(' ', nOffsetLineBeg));
            }
            else
            {
                treeOut_.Write(' ');
                ++nOffsetLineBeg;
            }
        }

        public override int
            LenDistNext(PegNode p, bool bAlignVertical, ref int nOffsetLineBeg, int nLevel)
        {
            return 1;
        }
        int LenIdAsName(PegNode p)
        {
            string name = GetNodeName_(p);
            return name.Length;
        }
        void PrintIdAsName(PegNode p)
        {
            string name = GetNodeName_(p);
            treeOut_.Write(name);
        }
        #endregion Methods
    }
    #endregion Syntax/Parse-Tree related classes
    #region Parsers
    public abstract class PegBaseParser
    {
        #region Data Types
        public delegate bool Matcher();
        public delegate PegNode Creator(ECreatorPhase ePhase, PegNode parentOrCreated, int id);
        #endregion Data Types
        #region Data members
        protected int srcLen_;
        protected int pos_;
        protected bool bMute_;
        protected TextWriter errOut_;
        protected Creator nodeCreator_;
        protected int maxpos_;
        PegTree tree;
        #endregion Data members
        public virtual string GetRuleNameFromId(int id)
        {//normally overridden
            switch (id)
            {
                case (int)ESpecialNodes.eFatal: return "FATAL";
                case (int)ESpecialNodes.eAnonymNTNode: return "Nonterminal";
                case (int)ESpecialNodes.eAnonymASTNode: return "ASTNode";
                case (int)ESpecialNodes.eAnonymousNode: return "Node";
                default: return id.ToString();
            }
        }
        public virtual void GetProperties(out EncodingClass encoding, out UnicodeDetection detection)
        {
            encoding = EncodingClass.ascii;
            detection = UnicodeDetection.notApplicable;
        }
        public int GetMaximumPosition()
        {
            return maxpos_;
        }
        protected PegNode DefaultNodeCreator(ECreatorPhase phase, PegNode parentOrCreated, int id)
        {
            if (phase == ECreatorPhase.eCreate || phase == ECreatorPhase.eCreateAndComplete)
                return new PegNode(parentOrCreated, id);
            else
            {
                if (parentOrCreated.match_.posEnd_ > maxpos_)
                    maxpos_ = parentOrCreated.match_.posEnd_;
                return null;
            }
        }
        #region Constructors
         public PegBaseParser(TextWriter errOut)
        {
            srcLen_ = pos_ = 0;
            errOut_ = errOut;
            nodeCreator_ = DefaultNodeCreator;
        }
        #endregion Constructors
        #region Reinitialization, TextWriter access,Tree Access
         public void Construct(TextWriter Fout)
         {
             srcLen_ = pos_ = 0;
             bMute_ = false;
             SetErrorDestination(Fout);
             ResetTree();
         }
         public void Rewind() { pos_ = 0; }
         public void SetErrorDestination(TextWriter errOut)
         {
             errOut_ = errOut == null ? new StreamWriter(System.Console.OpenStandardError())
                 : errOut;
         }
        #endregion Reinitialization, TextWriter access,Tree Access
         #region Tree root access, Tree Node generation/display
         public PegNode GetRoot() { return tree.root_; }
         public void ResetTree()
         {
             tree.root_ = null;
             tree.cur_ = null;
             tree.addPolicy = PegTree.AddPolicy.eAddAsChild;
         }
         void AddTreeNode(int nId, PegTree.AddPolicy newAddPolicy, Creator createNode, ECreatorPhase ePhase)
         {
             if (bMute_) return;
             if (tree.root_ == null)
             {
                 tree.root_ = tree.cur_ = createNode(ePhase, tree.cur_, nId);
             }
             else if (tree.addPolicy == PegTree.AddPolicy.eAddAsChild)
             {
                 tree.cur_ = tree.cur_.child_ = createNode(ePhase, tree.cur_, nId);
             }
             else
             {
                 tree.cur_ = tree.cur_.next_ = createNode(ePhase, tree.cur_.parent_, nId);
             }
             tree.addPolicy = newAddPolicy;
         }
         void RestoreTree(PegNode prevCur, PegTree.AddPolicy prevPolicy)
         {
             if (bMute_) return;
             if (prevCur == null)
             {
                 tree.root_ = null;
             }
             else if (prevPolicy == PegTree.AddPolicy.eAddAsChild)
             {
                 prevCur.child_ = null;
             }
             else
             {
                 prevCur.next_ = null;
             }
             tree.cur_ = prevCur;
             tree.addPolicy = prevPolicy;
         }
         public bool TreeChars(Matcher toMatch)
         {
             return TreeCharsWithId((int)ESpecialNodes.eAnonymousNode, toMatch);
         }
         public bool TreeChars(Creator nodeCreator, Matcher toMatch)
         {
             return TreeCharsWithId(nodeCreator, (int)ESpecialNodes.eAnonymousNode, toMatch);
         }
         public bool TreeCharsWithId(int nId, Matcher toMatch)
         {
             return TreeCharsWithId(nodeCreator_, nId, toMatch);
         }
         public bool TreeCharsWithId(Creator nodeCreator, int nId, Matcher toMatch)
         {
             int pos = pos_;
             if (toMatch())
             {
                 if (!bMute_)
                 {
                     AddTreeNode(nId, PegTree.AddPolicy.eAddAsSibling, nodeCreator, ECreatorPhase.eCreateAndComplete);
                     tree.cur_.match_.posBeg_ = pos;
                     tree.cur_.match_.posEnd_ = pos_;
                 }
                 return true;
             }
             return false;
         }
         public bool TreeNT(int nRuleId, Matcher toMatch)
         {
             return TreeNT(nodeCreator_, nRuleId, toMatch);
         }
         public bool TreeNT(Creator nodeCreator, int nRuleId, Matcher toMatch)
         {
             if (bMute_) return toMatch();
             PegNode prevCur = tree.cur_, ruleNode;
             PegTree.AddPolicy prevPolicy = tree.addPolicy;
             int posBeg = pos_;
             AddTreeNode(nRuleId, PegTree.AddPolicy.eAddAsChild, nodeCreator, ECreatorPhase.eCreate);
             ruleNode = tree.cur_;
             bool bMatches = toMatch();
             if (!bMatches) RestoreTree(prevCur, prevPolicy);
             else
             {
                 ruleNode.match_.posBeg_ = posBeg;
                 ruleNode.match_.posEnd_ = pos_;
                 tree.cur_ = ruleNode;
                 tree.addPolicy = PegTree.AddPolicy.eAddAsSibling;
                 nodeCreator(ECreatorPhase.eCreationComplete, ruleNode, nRuleId);
             }
             return bMatches;
         }
         public bool TreeAST(int nRuleId, Matcher toMatch)
         {
             return TreeAST(nodeCreator_, nRuleId, toMatch);
         }
         public bool TreeAST(Creator nodeCreator, int nRuleId, Matcher toMatch)
         {
             if (bMute_) return toMatch();
             bool bMatches = TreeNT(nodeCreator, nRuleId, toMatch);
             if (bMatches)
             {
                 if (tree.cur_.child_ != null && tree.cur_.child_.next_ == null && tree.cur_.parent_ != null)
                 {
                     if (tree.cur_.parent_.child_ == tree.cur_)
                     {
                         tree.cur_.parent_.child_ = tree.cur_.child_;
                         tree.cur_.child_.parent_ = tree.cur_.parent_;
                         tree.cur_ = tree.cur_.child_;
                     }
                     else
                     {
                         PegNode prev;
                         for (prev = tree.cur_.parent_.child_; prev != null && prev.next_ != tree.cur_; prev = prev.next_)
                         {
                         }
                         if (prev != null)
                         {
                             prev.next_ = tree.cur_.child_;
                             tree.cur_.child_.parent_ = tree.cur_.parent_;
                             tree.cur_ = tree.cur_.child_;
                         }
                     }
                 }
             }
             return bMatches;
         }
         public bool TreeNT(Matcher toMatch)
         {
             return TreeNT((int)ESpecialNodes.eAnonymNTNode, toMatch);
         }
         public bool TreeNT(Creator nodeCreator, Matcher toMatch)
         {
             return TreeNT(nodeCreator, (int)ESpecialNodes.eAnonymNTNode, toMatch);
         }
         public bool TreeAST(Matcher toMatch)
         {
             return TreeAST((int)ESpecialNodes.eAnonymASTNode, toMatch);
         }
         public bool TreeAST(Creator nodeCreator, Matcher toMatch)
         {
             return TreeAST(nodeCreator, (int)ESpecialNodes.eAnonymASTNode, toMatch);
         }
         public virtual string TreeNodeToString(PegNode node)
         {
             return GetRuleNameFromId(node.id_);
         }
         public void SetNodeCreator(Creator nodeCreator)
         {
             Debug.Assert(nodeCreator != null);
             nodeCreator_ = nodeCreator;
         }
         #endregion Tree Node generation
         #region PEG  e1 e2 .. ; &e1 ; !e1 ;  e? ; e* ; e+ ; e{a,b} ; .
         public bool And(Matcher pegSequence)
         {
             PegNode prevCur = tree.cur_;
             PegTree.AddPolicy prevPolicy = tree.addPolicy;
             int pos0 = pos_;
             bool bMatches = pegSequence();
             if (!bMatches)
             {
                 pos_ = pos0;
                 RestoreTree(prevCur, prevPolicy);
             }
             return bMatches;
         }
         public bool Peek(Matcher toMatch)
         {
             int pos0 = pos_;
             bool prevMute = bMute_;
             bMute_ = true;
             bool bMatches = toMatch();
             bMute_ = prevMute;
             pos_ = pos0;
             return bMatches;
         }
         public bool Not(Matcher toMatch)
         {
             int pos0 = pos_;
             bool prevMute = bMute_;
             bMute_ = true;
             bool bMatches = toMatch();
             bMute_ = prevMute;
             pos_ = pos0;
             return !bMatches;
         }
         public bool PlusRepeat(Matcher toRepeat)
         {
             int i;
             for (i = 0; ; ++i)
             {
                 int pos0 = pos_;
                 if (!toRepeat())
                 {
                     pos_ = pos0;
                     break;
                 }
             }
             return i > 0;
         }
         public bool OptRepeat(Matcher toRepeat)
         {
             for (; ; )
             {
                 int pos0 = pos_;
                 if (!toRepeat())
                 {
                     pos_ = pos0;
                     return true;
                 }
             }
         }
         public bool Option(Matcher toMatch)
         {
             int pos0 = pos_;
             if (!toMatch()) pos_ = pos0;
             return true;
         }
         public bool ForRepeat(int count, Matcher toRepeat)
         {
             PegNode prevCur = tree.cur_;
             PegTree.AddPolicy prevPolicy = tree.addPolicy;
             int pos0 = pos_;
             int i;
             for (i = 0; i < count; ++i)
             {
                 if (!toRepeat())
                 {
                     pos_ = pos0;
                     RestoreTree(prevCur, prevPolicy);
                     return false;
                 }
             }
             return true;
         }
         public bool ForRepeat(int lower, int upper, Matcher toRepeat)
         {
             PegNode prevCur = tree.cur_;
             PegTree.AddPolicy prevPolicy = tree.addPolicy;
             int pos0 = pos_;
             int i;
             for (i = 0; i < upper; ++i)
             {
                 if (!toRepeat()) break;
             }
             if (i < lower)
             {
                 pos_ = pos0;
                 RestoreTree(prevCur, prevPolicy);
                 return false;
             }
             return true;
         }
         public bool Any()
         {
             if (pos_ < srcLen_)
             {
                 ++pos_;
                 return true;
             }
             return false;
         }
         #endregion PEG  e1 e2 .. ; &e1 ; !e1 ;  e? ; e* ; e+ ; e{a,b} ; .
    }
    public class PegByteParser : PegBaseParser
    {
        #region Data members
        protected byte[] src_;
        PegError errors;
        #endregion Data members
        
        #region PEG optimizations
        public sealed class BytesetData     
        {
            public struct Range
            {
                public Range(byte low, byte high) { this.low = low; this.high = high; }
                public byte low;
                public byte high;
            }
            System.Collections.BitArray charSet_;
            bool bNegated_;
            public BytesetData(System.Collections.BitArray b)
                : this(b, false)
            {
            }
            public BytesetData(System.Collections.BitArray b, bool bNegated)
            {
                charSet_ = new System.Collections.BitArray(b);
                bNegated_ = bNegated;
            }
            public BytesetData(Range[] r, byte[] c)
                : this(r, c, false)
            {
            }
            public BytesetData(Range[] r, byte[] c, bool bNegated)
            {
                int max = 0;
                if (r != null) foreach (Range val in r) if (val.high > max) max = val.high;
                if (c != null) foreach (int val in c) if (val > max) max = val;
                charSet_ = new System.Collections.BitArray(max + 1, false);
                if (r != null)
                {
                    foreach (Range val in r)
                    {
                        for (int i = val.low; i <= val.high; ++i)
                        {
                            charSet_[i] = true;
                        }
                    }
                }
                if (c != null) foreach (int val in c) charSet_[val] = true;
                bNegated_ = bNegated;
            }
            public bool Matches(byte c)
            {
                bool bMatches = c < charSet_.Length && charSet_[(int)c];
                if (bNegated_) return !bMatches;
                else return bMatches;
            }
        }
        /*     public class BytesetData
             {
                 public struct Range
                 {
                     public Range(byte low, byte high) { this.low = low; this.high = high; }
                     public byte low;
                     public byte high;
                 }
                 protected System.Collections.BitArray charSet_;
                 bool bNegated_;
                 public BytesetData(System.Collections.BitArray b, bool bNegated)
                 {
                     charSet_ = new System.Collections.BitArray(b);
                     bNegated_ = bNegated;
                 }
                 public BytesetData(byte[] c, bool bNegated)
                 {
                     int max = 0;
                     foreach (int val in c) if (val > max) max = val;
                     charSet_ = new System.Collections.BitArray(max + 1, false);
                     foreach (int val in c) charSet_[val] = true;
                     bNegated_ = bNegated;
                 }
                 public BytesetData(Range[] r, byte[] c, bool bNegated)
                 {
                     int max = 0;
                     foreach (Range val in r) if (val.high > max) max = val.high;
                     foreach (int val in c) if (val > max) max = val;
                     charSet_ = new System.Collections.BitArray(max + 1, false);
                     foreach (Range val in r)
                     {
                         for (int i = val.low; i <= val.high; ++i)
                         {
                             charSet_[i] = true;
                         }
                     }
                     foreach (int val in c) charSet_[val] = true;
                 }


                 public bool Matches(byte c)
                 {
                     bool bMatches = c < charSet_.Length && charSet_[(int)c];
                     if (bNegated_) return !bMatches;
                     else return bMatches;
                 }
             }*/
        #endregion PEG optimizations
        #region Constructors
        public PegByteParser()
            : this(null)
        {
        }
        public PegByteParser(byte[] src):base(null)
        {
            SetSource(src);
        }
        public PegByteParser(byte[] src, TextWriter errOut):base(errOut)
        {
            SetSource(src);
        }
        #endregion Constructors
        #region Reinitialization, Source Code access, TextWriter access,Tree Access
        public void Construct(byte[] src, TextWriter Fout)
        {
            base.Construct(Fout);
            SetSource(src);
        }
        public void SetSource(byte[] src)
        {
            if (src == null) src = new byte[0];
            src_ = src; srcLen_ = src.Length;
            errors.lineStarts = new SortedList<int, int>();
            errors.lineStarts[0] = 1;
        }
        public byte[] GetSource() { return src_; }
        
        #endregion Reinitialization, Source Code access, TextWriter access,Tree Access
        #region Setting host variables
        public bool Into(Matcher toMatch,out byte[] into)
        {
            int pos = pos_;
            if (toMatch())
            {
                int nLen = pos_ - pos;
                into= new byte[nLen];
                for(int i=0;i<nLen;++i){
                    into[i] = src_[i+pos];
                }
                return true;
            }
            else
            {
                into = null;
                return false;
            }
        }
        public bool Into(Matcher toMatch,out PegBegEnd begEnd)
        {
            begEnd.posBeg_ = pos_;
            bool bMatches = toMatch();
            begEnd.posEnd_ = pos_;
            return bMatches;
        }
        public bool Into(Matcher toMatch,out int into)
        {
            byte[] s;
            into = 0;
            if (!Into(toMatch,out s)) return false;
            into = 0;
            for (int i = 0; i < s.Length; ++i)
            {
                into <<= 8;
                into |= s[i];
            }
            return true;
        }
        public bool Into(Matcher toMatch,out double into)
        {
            byte[] s;
            into = 0.0;
            if (!Into(toMatch,out s)) return false;
            System.Text.Encoding encoding = System.Text.Encoding.UTF8;
            string sAsString = encoding.GetString(s);
            if (!System.Double.TryParse(sAsString, out into)) return false;
            return true;
        }
        public bool BitsInto(int lowBitNo, int highBitNo,out int into)
        {
            if (pos_ < srcLen_)
            {
                into = (src_[pos_] >> (lowBitNo - 1)) & ((1 << highBitNo) - 1);
                ++pos_;
                return true;
            }
            into = 0;
            return false;
        }
        public bool BitsInto(int lowBitNo, int highBitNo, BytesetData toMatch, out int into)
        {
            if (pos_ < srcLen_)
            {
                byte value = (byte)((src_[pos_] >> (lowBitNo - 1)) & ((1 << highBitNo) - 1));
                ++pos_;
                into = value;
                return toMatch.Matches(value);
            }
            into = 0;
            return false;
        }
        #endregion Setting host variables
        #region Error handling
        void LogOutMsg(string sErrKind, string sMsg)
        {
            errOut_.WriteLine("<{0}>{1}:{2}", pos_, sErrKind, sMsg);
            errOut_.Flush();
        }
        public virtual bool Fatal(string sMsg)
        {

            LogOutMsg("FATAL", sMsg);
            throw new PegException();
        }
        public bool Warning(string sMsg)
        {
            LogOutMsg("WARNING", sMsg);
            return true;
        }
        #endregion Error handling
       #region PEG Bit level equivalents for PEG e1 ; &e1 ; !e1; e1:into ; 
        public bool Bits(int lowBitNo, int highBitNo, byte toMatch)
        {
            if (pos_ < srcLen_ && ((src_[pos_] >> (lowBitNo - 1)) & ((1 << highBitNo) - 1)) == toMatch)
            {
                ++pos_;
                return true;
            }
            return false;
        }
        public bool Bits(int lowBitNo, int highBitNo,BytesetData toMatch)
        {
            if( pos_ < srcLen_ )
            {
                byte value= (byte)((src_[pos_] >> (lowBitNo - 1)) & ((1 << highBitNo) - 1));
                ++pos_;
                return toMatch.Matches(value);
            }
            return false;
        }
        public bool PeekBits(int lowBitNo, int highBitNo, byte toMatch)
        {
            return pos_ < srcLen_ && ((src_[pos_] >> (lowBitNo - 1)) & ((1 << highBitNo) - 1)) == toMatch;
        }
        public bool NotBits(int lowBitNo, int highBitNo, byte toMatch)
        {
            return !(pos_ < srcLen_ && ((src_[pos_] >> (lowBitNo - 1)) & ((1 << highBitNo) - 1)) == toMatch);
        }
        public bool IntoBits(int lowBitNo,int highBitNo,out int val)
        {
            return BitsInto(lowBitNo,highBitNo,out val);
        }
        public bool IntoBits(int lowBitNo, int highBitNo, BytesetData toMatch, out int val)
        {
            return BitsInto(lowBitNo, highBitNo, out val);
        }
        public bool Bit(int bitNo,byte toMatch)
        {
            if (pos_ < srcLen_ && ((src_[pos_]>>(bitNo-1))&1)==toMatch){
                ++pos_;
                return true;
            }
            return false;
        }
        public bool PeekBit(int bitNo, byte toMatch)
        {
            return pos_ < srcLen_ && ((src_[pos_] >> (bitNo - 1)) & 1) == toMatch;
        }
        public bool NotBit(int bitNo, byte toMatch)
        {
            return !(pos_ < srcLen_ && ((src_[pos_] >> (bitNo - 1)) & 1) == toMatch);
        }
        #endregion PEG Bit level equivalents for PEG e1 ; &e1 ; !e1; e1:into ;
        #region PEG '<Literal>' / '<Literal>'/i / [low1-high1,low2-high2..] / [<CharList>]
        public bool Char(byte c1)
        {
            if (pos_ < srcLen_ && src_[pos_] == c1)
            { ++pos_; return true; }
            return false;
        }
        public bool Char(byte c1, byte c2)
        {
            if (pos_ + 1 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2)
            { pos_ += 2; return true; }
            return false;
        }
        public bool Char(byte c1, byte c2, byte c3)
        {
            if (pos_ + 2 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3)
            { pos_ += 3; return true; }
            return false;
        }
        public bool Char(byte c1, byte c2, byte c3, byte c4)
        {
            if (pos_ + 3 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3
                && src_[pos_ + 3] == c4)
            { pos_ += 4; return true; }
            return false;
        }
        public bool Char(byte c1, byte c2, byte c3, byte c4, byte c5)
        {
            if (pos_ + 4 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3
                && src_[pos_ + 3] == c4
                && src_[pos_ + 4] == c5)
            { pos_ += 5; return true; }
            return false;
        }
        public bool Char(byte c1, byte c2, byte c3, byte c4, byte c5, byte c6)
        {
            if (pos_ + 5 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3
                && src_[pos_ + 3] == c4
                && src_[pos_ + 4] == c5
                && src_[pos_ + 5] == c6)
            { pos_ += 6; return true; }
            return false;
        }
        public bool Char(byte c1, byte c2, byte c3, byte c4, byte c5, byte c6, byte c7)
        {
            if (pos_ + 6 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3
                && src_[pos_ + 3] == c4
                && src_[pos_ + 4] == c5
                && src_[pos_ + 5] == c6
                && src_[pos_ + 6] == c7)
            { pos_ += 7; return true; }
            return false;
        }
        public bool Char(byte c1, byte c2, byte c3, byte c4, byte c5, byte c6, byte c7, byte c8)
        {
            if (pos_ + 7 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3
                && src_[pos_ + 3] == c4
                && src_[pos_ + 4] == c5
                && src_[pos_ + 5] == c6
                && src_[pos_ + 6] == c7
                && src_[pos_ + 7] == c8)
            { pos_ += 8; return true; }
            return false;
        }
        public bool Char(byte[] s)
        {
            int sLength = s.Length;
            if (pos_ + sLength > srcLen_) return false;
            for (int i = 0; i < sLength; ++i)
            {
                if (s[i] != src_[pos_ + i]) return false;
            }
            pos_ += sLength;
            return true;
        }
        public static byte ToUpper(byte c)
        {
            if (c >= 97 && c <= 122) return (byte)(c - 32); else return c;
        }
        public bool IChar(byte c1)
        {
            if (pos_ < srcLen_ && ToUpper(src_[pos_]) == c1)
            { ++pos_; return true; }
            return false;
        }
        public bool IChar(byte c1, byte c2)
        {
            if (pos_ + 1 < srcLen_
                && ToUpper(src_[pos_]) == ToUpper(c1)
                && ToUpper(src_[pos_ + 1]) == ToUpper(c2))
            { pos_ += 2; return true; }
            return false;
        }
        public bool IChar(byte c1, byte c2, byte c3)
        {
            if (pos_ + 2 < srcLen_
                && ToUpper(src_[pos_]) == ToUpper(c1)
                && ToUpper(src_[pos_ + 1]) == ToUpper(c2)
                && ToUpper(src_[pos_ + 2]) == ToUpper(c3))
            { pos_ += 3; return true; }
            return false;
        }
        public bool IChar(byte c1, byte c2, byte c3, byte c4)
        {
            if (pos_ + 3 < srcLen_
                && ToUpper(src_[pos_]) == ToUpper(c1)
                && ToUpper(src_[pos_ + 1]) == ToUpper(c2)
                && ToUpper(src_[pos_ + 2]) == ToUpper(c3)
                && ToUpper(src_[pos_ + 3]) == ToUpper(c4))
            { pos_ += 4; return true; }
            return false;
        }
        public bool IChar(byte c1, byte c2, byte c3, byte c4, byte c5)
        {
            if (pos_ + 4 < srcLen_
                && ToUpper(src_[pos_]) == ToUpper(c1)
                && ToUpper(src_[pos_ + 1]) == ToUpper(c2)
                && ToUpper(src_[pos_ + 2]) == ToUpper(c3)
                && ToUpper(src_[pos_ + 3]) == ToUpper(c4)
                && ToUpper(src_[pos_ + 4]) == ToUpper(c5))
            { pos_ += 5; return true; }
            return false;
        }
        public bool IChar(byte c1, byte c2, byte c3, byte c4, byte c5, byte c6)
        {
            if (pos_ + 5 < srcLen_
                && ToUpper(src_[pos_]) == ToUpper(c1)
                && ToUpper(src_[pos_ + 1]) == ToUpper(c2)
                && ToUpper(src_[pos_ + 2]) == ToUpper(c3)
                && ToUpper(src_[pos_ + 3]) == ToUpper(c4)
                && ToUpper(src_[pos_ + 4]) == ToUpper(c5)
                && ToUpper(src_[pos_ + 5]) == ToUpper(c6))
            { pos_ += 6; return true; }
            return false;
        }
        public bool IChar(byte c1, byte c2, byte c3, byte c4, byte c5, byte c6, byte c7)
        {
            if (pos_ + 6 < srcLen_
                && ToUpper(src_[pos_]) == ToUpper(c1)
                && ToUpper(src_[pos_ + 1]) == ToUpper(c2)
                && ToUpper(src_[pos_ + 2]) == ToUpper(c3)
                && ToUpper(src_[pos_ + 3]) == ToUpper(c4)
                && ToUpper(src_[pos_ + 4]) == ToUpper(c5)
                && ToUpper(src_[pos_ + 5]) == ToUpper(c6)
                && ToUpper(src_[pos_ + 6]) == ToUpper(c7))
            { pos_ += 7; return true; }
            return false;
        }
        public bool IChar(byte[] s)
        {
            int sLength = s.Length;
            if (pos_ + sLength > srcLen_) return false;
            for (int i = 0; i < sLength; ++i)
            {
                if (s[i] != ToUpper(src_[pos_ + i])) return false;
            }
            pos_ += sLength;
            return true;
        }
        public bool In(byte c0, byte c1)
        {
            if (pos_ < srcLen_
                && src_[pos_] >= c0 && src_[pos_] <= c1)
            {
                ++pos_;
                return true;
            }
            return false;
        }
        public bool In(byte c0, byte c1, byte c2, byte c3)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                if (c >= c0 && c <= c1
                    || c >= c2 && c <= c3)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool In(byte c0, byte c1, byte c2, byte c3, byte c4, byte c5)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                if (c >= c0 && c <= c1
                    || c >= c2 && c <= c3
                    || c >= c4 && c <= c5)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool In(byte c0, byte c1, byte c2, byte c3, byte c4, byte c5, byte c6, byte c7)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                if (c >= c0 && c <= c1
                    || c >= c2 && c <= c3
                    || c >= c4 && c <= c5
                    || c >= c6 && c <= c7)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool In(byte[] s)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                for (int i = 0; i < s.Length - 1; i += 2)
                {
                    if (c >= s[i] && c <= s[i + 1])
                    {
                        ++pos_;
                        return true;
                    }
                }
            }
            return false;
        }
        public bool NotIn(byte[] s)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                for (int i = 0; i < s.Length - 1; i += 2)
                {
                    if ( c >= s[i] && c <= s[i + 1] ) return false;
                }
                ++pos_;
                return true;
            }
            return false;
        }
        public bool OneOf(byte c0, byte c1)
        {
            if (pos_ < srcLen_
                && (src_[pos_] == c0 || src_[pos_] == c1))
            {
                ++pos_;
                return true;
            }
            return false;
        }
        public bool OneOf(byte c0, byte c1, byte c2)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                if (c == c0 || c == c1 || c == c2)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(byte c0, byte c1, byte c2, byte c3)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                if (c == c0 || c == c1 || c == c2 || c == c3)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(byte c0, byte c1, byte c2, byte c3, byte c4)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                if (c == c0 || c == c1 || c == c2 || c == c3 || c == c4)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(byte c0, byte c1, byte c2, byte c3, byte c4, byte c5)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                if (c == c0 || c == c1 || c == c2 || c == c3 || c == c4 || c == c5)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(byte c0, byte c1, byte c2, byte c3, byte c4, byte c5, byte c6)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                if (c == c0 || c == c1 || c == c2 || c == c3 || c == c4 || c == c5 || c == c6)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(byte c0, byte c1, byte c2, byte c3, byte c4, byte c5, byte c6, byte c7)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                if (c == c0 || c == c1 || c == c2 || c == c3 || c == c4 || c == c5 || c == c6 || c == c7)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(byte[] s)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                for (int i = 0; i < s.Length; ++i)
                {
                    if (c == s[i]) { ++pos_; return true; }
                }
            }
            return false;
        }
        public bool NotOneOf(byte[] s)
        {
            if (pos_ < srcLen_)
            {
                byte c = src_[pos_];
                for (int i = 0; i < s.Length; ++i)
                {
                    if (c == s[i]) { return false; }
                }
                return true;
            }
            return false;
        }
        public bool OneOf(BytesetData bset)
        {
            if(pos_ < srcLen_ && bset.Matches(src_[pos_]))
            {
                ++pos_; return true;
            }
            return false;
        }
        #endregion PEG '<Literal>' / '<Literal>'/i / [low1-high1,low2-high2..] / [<CharList>]
    }
    public class PegCharParser : PegBaseParser
    {
        #region Data members
        protected string src_;
        PegError errors;
        #endregion Data members
        #region PEG optimizations
        public sealed class OptimizedCharset
        {
            public struct Range
            {
                public Range(char low, char high) { this.low = low; this.high = high; }
                public char low;
                public char high;
            }
            System.Collections.BitArray charSet_;
            bool bNegated_;
            public OptimizedCharset(System.Collections.BitArray b)
                : this(b, false)
            {
            }
            public OptimizedCharset(System.Collections.BitArray b, bool bNegated)
            {
                charSet_ = new System.Collections.BitArray(b);
                bNegated_ = bNegated;
            }
            public OptimizedCharset(Range[] r, char[] c)
                : this(r, c, false)
            {
            }
            public OptimizedCharset(Range[] r, char[] c, bool bNegated)
            {
                int max = 0;
                if (r != null) foreach (Range val in r) if (val.high > max) max = val.high;
                if (c != null) foreach (int val in c) if (val > max) max = val;
                charSet_ = new System.Collections.BitArray(max + 1, false);
                if (r != null)
                {
                    foreach (Range val in r)
                    {
                        for (int i = val.low; i <= val.high; ++i)
                        {
                            charSet_[i] = true;
                        }
                    }
                }
                if (c != null) foreach (int val in c) charSet_[val] = true;
                bNegated_ = bNegated;
            }


            public bool Matches(char c)
            {
                bool bMatches = c < charSet_.Length && charSet_[(int)c];
                if (bNegated_) return !bMatches;
                else return bMatches;
            }
        }
        public sealed class OptimizedLiterals
        {
            internal class Trie
            {
                internal Trie(char cThis,int nIndex, string[] literals)
                {
                    cThis_ = cThis;
                    char cMax = char.MinValue;
                    cMin_ = char.MaxValue;
                    HashSet<char> followChars = new HashSet<char>();
                    
                    foreach (string literal in literals)
                    {
                        if (literal==null ||  nIndex > literal.Length ) continue;
                        if (nIndex == literal.Length)
                        {
                            bLitEnd_ = true;
                            continue;
                        }
                        char c = literal[nIndex];
                        followChars.Add(c);
                        if ( c < cMin_) cMin_ = c;
                        if ( c > cMax) cMax = c;
                    }
                    if (followChars.Count == 0)
                    {
                        children_ = null;
                    }
                    else
                    {
                        children_ = new Trie[(cMax - cMin_) + 1];
                        foreach (char c in followChars)
                        {
                            List<string> subLiterals = new List<string>();
                            foreach (string s in literals)
                            {
                                if ( nIndex >= s.Length ) continue;
                                if (c == s[nIndex])
                                {
                                    subLiterals.Add(s);
                                }
                            }
                            children_[c - cMin_] = new Trie(c, nIndex + 1, subLiterals.ToArray());
                        }
                    }

                }
                internal char cThis_;           //character stored in this node
                internal bool bLitEnd_;         //end of literal

                internal char cMin_;            //first valid character in children
                internal Trie[] children_;      //contains the successor node of cThis_;
            }
            internal Trie literalsRoot;
            public OptimizedLiterals(string[] litAlternatives)
            {
                literalsRoot = new Trie('\u0000', 0, litAlternatives);
            }
        }
        #endregion  PEG optimizations
        #region Constructors
        public PegCharParser():this("")
        {
           

        }
        public PegCharParser(string src):base(null)
        {
            SetSource(src);
        }
        public PegCharParser(string src, TextWriter errOut):base(errOut)
        {
            SetSource(src);
            nodeCreator_ = DefaultNodeCreator;
        }
        #endregion Constructors
        #region Overrides
        public override string TreeNodeToString(PegNode node)
        {
            string label = base.TreeNodeToString(node);
            if (node.id_ == (int)ESpecialNodes.eAnonymousNode)
            {
                string value = node.GetAsString(src_);
                if (value.Length < 32) label += " <" + value + ">";
                else label += " <" + value.Substring(0, 29) + "...>";
            }
            return label;
        }
        #endregion Overrides
        #region Reinitialization, Source Code access, TextWriter access,Tree Access
        public void Construct(string src, TextWriter Fout)
        {
            base.Construct(Fout);
            SetSource(src);
        }
        public void SetSource(string src)
        {
            if (src == null) src = "";
            src_ = src; srcLen_ = src.Length; pos_ = 0;
            errors.lineStarts = new SortedList<int, int>();
            errors.lineStarts[0] = 1;
        }
        public string GetSource() { return src_; }
        #endregion Reinitialization, Source Code access, TextWriter access,Tree Access
        #region Setting host variables
        public bool Into(Matcher toMatch,out string into)
        {
            int pos = pos_;
            if (toMatch())
            {
                into = src_.Substring(pos, pos_ - pos);
                return true;
            }
            else
            {
                into = "";
                return false;
            }
        }
        public bool Into(Matcher toMatch,out PegBegEnd begEnd)
        {
            begEnd.posBeg_ = pos_;
            bool bMatches = toMatch();
            begEnd.posEnd_ = pos_;
            return bMatches;
        }
        public bool Into(Matcher toMatch,out int into)
        {
            string s;
            into = 0;
            if (!Into(toMatch,out s)) return false;
            if (!System.Int32.TryParse(s, out into)) return false;
            return true;
        }
        public bool Into(Matcher toMatch,out double into)
        {
            string s;
            into = 0.0;
            if (!Into(toMatch,out s)) return false;
            if (!System.Double.TryParse(s, out into)) return false;
            return true;
        }
        #endregion Setting host variables
        #region Error handling
        void LogOutMsg(string sErrKind, string sMsg)
        {
            int lineNo, colNo;
            errors.GetLineAndCol(src_, pos_, out lineNo, out colNo);
            errOut_.WriteLine("<{0},{1},{2}>{3}:{4}", lineNo, colNo, maxpos_, sErrKind, sMsg);
            errOut_.Flush();
        }
        public virtual bool Fatal(string sMsg)
        {

            LogOutMsg("FATAL", sMsg);
            throw new PegException();
            //return false;
        }
        public bool Warning(string sMsg)
        {
            LogOutMsg("WARNING", sMsg);
            return true;
        }
        #endregion Error handling
        #region PEG  optimized version of  e* ; e+ 
        public bool OptRepeat(OptimizedCharset charset)
        {
            for (; pos_ < srcLen_ && charset.Matches(src_[pos_]); ++pos_) ;
            return true;
        }
        public bool PlusRepeat(OptimizedCharset charset)
        {
            int pos0 = pos_;
            for (; pos_ < srcLen_ && charset.Matches(src_[pos_]); ++pos_) ;
            return pos_ > pos0;
        }
        #endregion PEG  optimized version of  e* ; e+
        #region PEG '<Literal>' / '<Literal>'/i / [low1-high1,low2-high2..] / [<CharList>]
        public bool Char(char c1)
        {
            if (pos_ < srcLen_ && src_[pos_] == c1)
            { ++pos_; return true; }
            return false;
        }
        public bool Char(char c1, char c2)
        {
            if (pos_ + 1 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2)
            { pos_ += 2; return true; }
            return false;
        }
        public bool Char(char c1, char c2, char c3)
        {
            if (pos_ + 2 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3)
            { pos_ += 3; return true; }
            return false;
        }
        public bool Char(char c1, char c2, char c3, char c4)
        {
            if (pos_ + 3 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3
                && src_[pos_ + 3] == c4)
            { pos_ += 4; return true; }
            return false;
        }
        public bool Char(char c1, char c2, char c3, char c4, char c5)
        {
            if (pos_ + 4 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3
                && src_[pos_ + 3] == c4
                && src_[pos_ + 4] == c5)
            { pos_ += 5; return true; }
            return false;
        }
        public bool Char(char c1, char c2, char c3, char c4, char c5, char c6)
        {
            if (pos_ + 5 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3
                && src_[pos_ + 3] == c4
                && src_[pos_ + 4] == c5
                && src_[pos_ + 5] == c6)
            { pos_ += 6; return true; }
            return false;
        }
        public bool Char(char c1, char c2, char c3, char c4, char c5, char c6, char c7)
        {
            if (pos_ + 6 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3
                && src_[pos_ + 3] == c4
                && src_[pos_ + 4] == c5
                && src_[pos_ + 5] == c6
                && src_[pos_ + 6] == c7)
            { pos_ += 7; return true; }
            return false;
        }
        public bool Char(char c1, char c2, char c3, char c4, char c5, char c6, char c7, char c8)
        {
            if (pos_ + 7 < srcLen_
                && src_[pos_] == c1
                && src_[pos_ + 1] == c2
                && src_[pos_ + 2] == c3
                && src_[pos_ + 3] == c4
                && src_[pos_ + 4] == c5
                && src_[pos_ + 5] == c6
                && src_[pos_ + 6] == c7
                && src_[pos_ + 7] == c8)
            { pos_ += 8; return true; }
            return false;
        }
        public bool Char(string s)
        {
            int sLength = s.Length;
            if (pos_ + sLength > srcLen_) return false;
            for (int i = 0; i < sLength; ++i)
            {
                if (s[i] != src_[pos_ + i]) return false;
            }
            pos_ += sLength;
            return true;
        }
        public bool IChar(char c1)
        {
            if (pos_ < srcLen_ && System.Char.ToUpper(src_[pos_]) == c1)
            { ++pos_; return true; }
            return false;
        }
        public bool IChar(char c1, char c2)
        {
            if (pos_ + 1 < srcLen_
                && System.Char.ToUpper(src_[pos_]) == System.Char.ToUpper(c1)
                && System.Char.ToUpper(src_[pos_ + 1]) == System.Char.ToUpper(c2))
            { pos_ += 2; return true; }
            return false;
        }
        public bool IChar(char c1, char c2, char c3)
        {
            if (pos_ + 2 < srcLen_
                && System.Char.ToUpper(src_[pos_]) == System.Char.ToUpper(c1)
                && System.Char.ToUpper(src_[pos_ + 1]) == System.Char.ToUpper(c2)
                && System.Char.ToUpper(src_[pos_ + 2]) == System.Char.ToUpper(c3))
            { pos_ += 3; return true; }
            return false;
        }
        public bool IChar(char c1, char c2, char c3, char c4)
        {
            if (pos_ + 3 < srcLen_
                && System.Char.ToUpper(src_[pos_]) == System.Char.ToUpper(c1)
                && System.Char.ToUpper(src_[pos_ + 1]) == System.Char.ToUpper(c2)
                && System.Char.ToUpper(src_[pos_ + 2]) == System.Char.ToUpper(c3)
                && System.Char.ToUpper(src_[pos_ + 3]) == System.Char.ToUpper(c4))
            { pos_ += 4; return true; }
            return false;
        }
        public bool IChar(char c1, char c2, char c3, char c4, char c5)
        {
            if (pos_ + 4 < srcLen_
                && System.Char.ToUpper(src_[pos_]) == System.Char.ToUpper(c1)
                && System.Char.ToUpper(src_[pos_ + 1]) == System.Char.ToUpper(c2)
                && System.Char.ToUpper(src_[pos_ + 2]) == System.Char.ToUpper(c3)
                && System.Char.ToUpper(src_[pos_ + 3]) == System.Char.ToUpper(c4)
                && System.Char.ToUpper(src_[pos_ + 4]) == System.Char.ToUpper(c5))
            { pos_ += 5; return true; }
            return false;
        }
        public bool IChar(char c1, char c2, char c3, char c4, char c5, char c6)
        {
            if (pos_ + 5 < srcLen_
                && System.Char.ToUpper(src_[pos_]) == System.Char.ToUpper(c1)
                && System.Char.ToUpper(src_[pos_ + 1]) == System.Char.ToUpper(c2)
                && System.Char.ToUpper(src_[pos_ + 2]) == System.Char.ToUpper(c3)
                && System.Char.ToUpper(src_[pos_ + 3]) == System.Char.ToUpper(c4)
                && System.Char.ToUpper(src_[pos_ + 4]) == System.Char.ToUpper(c5)
                && System.Char.ToUpper(src_[pos_ + 5]) == System.Char.ToUpper(c6))
            { pos_ += 6; return true; }
            return false;
        }
        public bool IChar(char c1, char c2, char c3, char c4, char c5, char c6, char c7)
        {
            if (pos_ + 6 < srcLen_
                && System.Char.ToUpper(src_[pos_]) == System.Char.ToUpper(c1)
                && System.Char.ToUpper(src_[pos_ + 1]) == System.Char.ToUpper(c2)
                && System.Char.ToUpper(src_[pos_ + 2]) == System.Char.ToUpper(c3)
                && System.Char.ToUpper(src_[pos_ + 3]) == System.Char.ToUpper(c4)
                && System.Char.ToUpper(src_[pos_ + 4]) == System.Char.ToUpper(c5)
                && System.Char.ToUpper(src_[pos_ + 5]) == System.Char.ToUpper(c6)
                && System.Char.ToUpper(src_[pos_ + 6]) == System.Char.ToUpper(c7))
            { pos_ += 7; return true; }
            return false;
        }
        public bool IChar(string s)
        {
            int sLength = s.Length;
            if (pos_ + sLength > srcLen_) return false;
            for (int i = 0; i < sLength; ++i)
            {
                if (s[i] != System.Char.ToUpper(src_[pos_ + i])) return false;
            }
            pos_ += sLength;
            return true;
        }

        public bool In(char c0, char c1)
        {
            if (pos_ < srcLen_
                && src_[pos_] >= c0 && src_[pos_] <= c1)
            {
                ++pos_;
                return true;
            }
            return false;
        }
        public bool In(char c0, char c1, char c2, char c3)
        {
            if (pos_ < srcLen_)
            {
                char c = src_[pos_];
                if (c >= c0 && c <= c1
                    || c >= c2 && c <= c3)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool In(char c0, char c1, char c2, char c3, char c4, char c5)
        {
            if (pos_ < srcLen_)
            {
                char c = src_[pos_];
                if (c >= c0 && c <= c1
                    || c >= c2 && c <= c3
                    || c >= c4 && c <= c5)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool In(char c0, char c1, char c2, char c3, char c4, char c5, char c6, char c7)
        {
            if (pos_ < srcLen_)
            {
                char c = src_[pos_];
                if (c >= c0 && c <= c1
                    || c >= c2 && c <= c3
                    || c >= c4 && c <= c5
                    || c >= c6 && c <= c7)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool In(string s)
        {
            if (pos_ < srcLen_)
            {
                char c = src_[pos_];
                for (int i = 0; i < s.Length - 1; i += 2)
                {
                    if (!(c >= s[i] && c <= s[i + 1])) return false;
                }
                ++pos_;
                return true;
            }
            return false;
        }
        public bool NotIn(string s)
        {
            if (pos_ < srcLen_)
            {
                char c = src_[pos_];
                for (int i = 0; i < s.Length - 1; i += 2)
                {
                    if ( c >= s[i] && c <= s[i + 1]) return false;
                }
                ++pos_;
                return true;
            }
            return false;
        }
        public bool OneOf(char c0, char c1)
        {
            if (pos_ < srcLen_
                && (src_[pos_] == c0 || src_[pos_] == c1))
            {
                ++pos_;
                return true;
            }
            return false;
        }
        public bool OneOf(char c0, char c1, char c2)
        {
            if (pos_ < srcLen_)
            {
                char c = src_[pos_];
                if (c == c0 || c == c1 || c == c2)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(char c0, char c1, char c2, char c3)
        {
            if (pos_ < srcLen_)
            {
                char c = src_[pos_];
                if (c == c0 || c == c1 || c == c2 || c == c3)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(char c0, char c1, char c2, char c3, char c4)
        {
            if (pos_ < srcLen_)
            {
                char c = src_[pos_];
                if (c == c0 || c == c1 || c == c2 || c == c3 || c == c4)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(char c0, char c1, char c2, char c3, char c4, char c5)
        {
            if (pos_ < srcLen_)
            {
                char c = src_[pos_];
                if (c == c0 || c == c1 || c == c2 || c == c3 || c == c4 || c == c5)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(char c0, char c1, char c2, char c3, char c4, char c5, char c6)
        {
            if (pos_ < srcLen_)
            {
                char c = src_[pos_];
                if (c == c0 || c == c1 || c == c2 || c == c3 || c == c4 || c == c5 || c == c6)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(char c0, char c1, char c2, char c3, char c4, char c5, char c6, char c7)
        {
            if (pos_ < srcLen_)
            {
                char c = src_[pos_];
                if (c == c0 || c == c1 || c == c2 || c == c3 || c == c4 || c == c5 || c == c6 || c == c7)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(string s)
        {
            if (pos_ < srcLen_)
            {
                if (s.IndexOf(src_[pos_]) != -1)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool NotOneOf(string s)
        {
            if (pos_ < srcLen_)
            {
                if (s.IndexOf(src_[pos_]) == -1)
                {
                    ++pos_;
                    return true;
                }
            }
            return false;
        }
        public bool OneOf(OptimizedCharset cset)
        {
            if (pos_ < srcLen_ && cset.Matches(src_[pos_]))
            {
                ++pos_; return true;
            }
            return false;
        }
        public bool OneOfLiterals(OptimizedLiterals litAlt)
        {
            OptimizedLiterals.Trie node = litAlt.literalsRoot;
            int matchPos = pos_-1;
            for (int pos = pos_; pos < srcLen_ ; ++pos)
            {
                char c = src_[pos];
                if (    node.children_==null 
                    ||  c < node.cMin_ || c > node.cMin_ + node.children_.Length - 1
                    ||  node.children_[c - node.cMin_] == null)
                {
                    break;
                }
                node = node.children_[c - node.cMin_];
                if (node.bLitEnd_) matchPos = pos + 1;
            }
            if (matchPos >= pos_)
            {
                pos_= matchPos;
                return true;
            }
            else return false;
        }
        #endregion PEG '<Literal>' / '<Literal>'/i / [low1-high1,low2-high2..] / [<CharList>]
    }
    #endregion Parsers
}