public virtual void Load( TextReader r, int size, int readChunkSize )
 {
     if ( r == null )
     {
         return;
     }
     if ( size <= 0 )
     {
         size = InitialBufferSize;
     }
     if ( readChunkSize <= 0 )
     {
         readChunkSize = ReadBufferSize;
     }
     // System.out.println("load "+size+" in chunks of "+readChunkSize);
     try
     {
         data = r.ReadToEnd().ToCharArray();
         base.n = data.Length;
     }
     finally
     {
         r.Dispose();
     }
 }

 public virtual void Load( TextReader r, int size, int readChunkSize )
 {
     if ( r == null )
     {
         return;
     }
     if ( size <= 0 )
     {
         size = INITIAL_BUFFER_SIZE;
     }
     if ( readChunkSize <= 0 )
     {
         readChunkSize = READ_BUFFER_SIZE;
     }
     // System.out.println("load "+size+" in chunks of "+readChunkSize);
     try
     {
         data = r.ReadToEnd().ToCharArray();
         base.n = data.Length;
     }
     finally
     {
         r.Close();
     }
 }

 public Lexer(System.IO.TextReader rdr)
 {
     this.rdr = rdr;
     st = State.StartOfLine;
     lookahead = new Token(TokenType.EOFile);
     sb = new StringBuilder();
 }

        public Feature Parse(TextReader featureFileReader)
        {
            var gherkinParser = new Gherkin.Parser();
            Gherkin.Ast.Feature feature = gherkinParser.Parse(featureFileReader);
            Feature result = new Mapper(feature.Language).MapToFeature(feature);

            return result;
        }

 /// <summary>
 /// Creates a StringTemplateGroup instance that manages a set of
 /// templates defined in a "group file".
 /// </summary>
 /// <param name="reader">Input stream for group file data</param>
 /// <param name="lexer">Lexer to use for breaking up templates into chunks</param>
 /// <param name="errorListener">Error message sink</param>
 /// <param name="superGroup">Parent (or super/base) group</param>
 /// <returns>A StringTemplateGroup instance or null if no group is found</returns>
 public StringTemplateGroup CreateGroup(
     TextReader reader,
     Type lexer,
     IStringTemplateErrorListener errorListener,
     StringTemplateGroup superGroup)
 {
     return new StringTemplateGroup(reader, lexer, errorListener, superGroup);
 }

        public CharBuffer(System.IO.TextReader reader, Int32 bufferSize)
        {
            _baseReader = reader;
            _bufferPtrBegin = 0;
            _bufferPtrEnd = 0;
            _bufferSize = Math.Max(bufferSize, MinBufferSize);
            _buffer = new Char[bufferSize];

            this.FillBuffer();
        }

 public PosEventReader(System.IO.TextReader data, IPosContextGenerator contextGenerator)
 {
     mContextGenerator = contextGenerator;
     mTextReader = data;
     string nextLine = mTextReader.ReadLine();
     if (nextLine != null)
     {
         AddEvents(nextLine);
     }
 }

        public Feature Parse(TextReader featureFileReader)
        {
            string fileContent = featureFileReader.ReadToEnd();

            var parser = new PicklesParser(this.languageService.GetLanguage());
            Lexer lexer = this.languageService.GetNativeLexer(parser);
            lexer.scan(fileContent);

            return parser.GetFeature();
        }

 public void Main(string[] args, 
     System.IO.TextReader In,
     System.IO.TextWriter Out,
     System.IO.TextWriter Error)
 {
     //this version of Main allows alternate streams
     this.In = In;
     this.Out = Out;
     this.Error = Error;
     this.Main(args);
 }

 public SimpleCharStream(System.IO.TextReader dstream, int startline,
     int startcolumn, int buffersize)
 {
     inputStream = dstream;
     line = startline;
     column = startcolumn - 1;
     available = bufsize = buffersize;
     buffer = new char[buffersize];
     bufline = new int[buffersize];
     bufcolumn = new int[buffersize];
 }

		public void Initialize(System.IO.TextReader reader, LexicalStates lexicalState, bool atBol)
		{
			this.expanding_token = false;
			this.token_start = 0;
			this.chars_read = 0;
			this.lookahead_index = 0;
			this.token_chunk_start = 0;
			this.token_end = 0;
			this.reader = reader;
			this.yy_at_bol = atBol;
			this.current_lexical_state = lexicalState;
		}

        public Feature Parse(TextReader featureFileReader)
        {
            var language = this.DetermineLanguage();
            var gherkinParser = new Gherkin.Parser();

            Gherkin.Ast.Feature feature = gherkinParser.Parse(
                new Gherkin.TokenScanner(featureFileReader),
                new Gherkin.TokenMatcher(language));

            Feature result = new Mapper(feature.Language).MapToFeature(feature);

            return result;
        }

        public Feature Parse(TextReader featureFileReader)
        {
            var language = this.DetermineLanguage();
            var gherkinParser = new Gherkin.Parser();

            Gherkin.Ast.GherkinDocument gherkinDocument = gherkinParser.Parse(
                new Gherkin.TokenScanner(featureFileReader),
                new Gherkin.TokenMatcher(language));

            Feature result = new Mapper(this.configuration, gherkinDocument.Feature.Language).MapToFeature(gherkinDocument);

            return result;
        }

        public Lexer(System.IO.TextReader reader)
        {
            _allowComments = true;
            _allowSingleQuotedStrings = true;

            _inputBuffer = 0;
            _stringBuffer = new System.Text.StringBuilder(128);
            _state = 1;
            EndOfInput = false;
            _reader = reader;

            _fsmContext = new FsmContext {L = this};
        }

        public ReaderInput(string name, System.IO.TextReader reader)
        {
            if (null == name)
            {
                throw new ArgumentNullException("name");
            }

            if (null == reader)
            {
                throw new ArgumentNullException("reader");
            }

            _name = name;
            _reader = reader;
        }

		internal Field(System.String name, System.IO.TextReader reader)
		{
			if (name == null)
				throw new System.ArgumentException("name cannot be null");
			if (reader == null)
				throw new System.ArgumentException("value cannot be null");
			
			this.name = String.Intern(name); // Field names are interned
			this.readerValue = reader;
		}

 public ANTLRReaderStream( TextReader r, int size, int readChunkSize )
 {
     Load( r, size, readChunkSize );
 }

 public CommandBase()
 {
     //by default, read from/write to standard streams
     this.In = System.Console.In;
     this.Out = System.Console.Out;
     this.Error = System.Console.Error;
 }

        public static void Main(string[] args)
        {
            nick = "SecureIRC";
            owner = "SecureIRC";
            server = "irc.entalyan.com";
            port = 6999;
            chan = "#SecureIRC";
            pass = ""; //Enter just the password

            //Connect to irc server and get input and output text streams from TcpClient.
            sock.Connect(server, port);
            if (!sock.Connected)
            {
                Console.WriteLine("Failed to connect!");
                return;
            }
            input = new System.IO.StreamReader(sock.GetStream());
            output = new System.IO.StreamWriter(sock.GetStream());

            //Starting USER and NICK login commands 
            output.Write(
                "PASS " + nick + ":" + pass + "\r\n" +
                "USER " + nick + " 0 * :" + owner + "\r\n" +
                "NICK " + nick + "\r\n" +
                "PRIVMSG #SecureIRC Successful login at: " + DateTime.Now.ToString() + "\r\n"
            );
            output.Flush();

            Listen();

            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();

        }

 protected void Initializer(string FeatureName)
 {
     this.In = System.Console.In;
     this.Out = System.Console.Out;
     this.Error = System.Console.Out;
     Name = FeatureName;
 }