/// <summary>Parse the input X# source code file and generate the matching target assembly
    /// language.</summary>
    /// <param name="aReader">X# source code reader.</param>
    /// <returns>The resulting target assembler content. The returned object contains
    /// a code and a data block.</returns>
    public Assembler Generate(TextReader aReader)
    {
      if (aReader == null)
      {
        throw new ArgumentNullException(nameof(aReader));
      }
      mPatterns.EmitUserComments = EmitUserComments;
      mLineNo = 0;
      var xResult = new Assembler();
      try
      {
        // Read one X# source code line at a time and process it.
        while (true)
        {
          mLineNo++;
          string xLine = aReader.ReadLine();
          if (xLine == null)
          {
            break;
          }

          ProcessLine(xLine, mLineNo);
        }
        AssertLastFunctionComplete();
        return xResult;
      }
      finally
      {
        Assembler.ClearCurrentInstance();
      }
    }

 public static DataTable Parse(TextReader stream, CsvHeadersAction Headers, char delimiter)
 {
     DataTable table = new DataTable();
     CsvStream csv = new CsvStream(stream);
     string[] row = csv.GetNextRow(delimiter);
     if (row == null)
         return null;
     if (Headers == CsvHeadersAction.SkipHeaderLine)
     {
         row = csv.GetNextRow(delimiter);
     }
     if (Headers == CsvHeadersAction.UseAsColumnNames)
     {
         //foreach (string header in row)
         for (int i = 0;i<row.Length;i++)
         {
             if (row[i] != null && row[i].Length > 0 && !table.Columns.Contains(row[i]))
                 table.Columns.Add(row[i], typeof(string));
             else
                 table.Columns.Add(GetNextColumnHeader(table), typeof(string));
         }
         row = csv.GetNextRow(delimiter);
     }
     while (row != null)
     {
         while (row.Length > table.Columns.Count)
             table.Columns.Add(GetNextColumnHeader(table), typeof(string));
         table.Rows.Add(row);
         row = csv.GetNextRow(delimiter);
     }
     stream.Close();
     stream.Dispose();
     return table;
 }

        public BufferedCharReader(TextReader reader, int bufferSize)
        {
            Debug.Assert(reader != null);

            _reader = reader;
            _bufferSize = Math.Max(256, bufferSize);
        }

 /// <summary>
 /// �ִʴ��������캯��
 /// </summary>
 /// <param name="input">�ı���ȡ��</param>
 public ThesaurusSpliter(TextReader input)
 {
     this.input = input;
     //����������.ģ�����뷨���������Ĺ���
     assoStream = new AssociateStream();
     ReadBuffer();
 }

        // Main parser
        internal WsdlParser(TextReader input, String outputDir, ArrayList outCodeStreamList, String locationURL, bool bWrappedProxy, String proxyNamespace)
        {
            Util.Log("WsdlParser.WsdlParser outputDir "+outputDir+" locationURL "+locationURL+" bWrappedProxy "+bWrappedProxy+" proxyNamespace "+proxyNamespace);
            // Initialize member variables
            _XMLReader = null;
            _readerStreamsWsdl = new ReaderStream(locationURL);
            _readerStreamsWsdl.InputStream = input;
            _writerStreams = null;
            _outputDir = outputDir;
            _outCodeStreamList = outCodeStreamList;
            _bWrappedProxy = bWrappedProxy;
            if (proxyNamespace == null || proxyNamespace.Length == 0)
                _proxyNamespace = "InteropNS";
            else
                _proxyNamespace = proxyNamespace;
            if (outputDir == null)
                outputDir = ".";

            int length = outputDir.Length;
            if (length > 0)
            {
                char endChar = outputDir[length-1];
                if (endChar != '\\' && endChar != '/')
                    _outputDir = _outputDir + '\\';
            }
            //_namespaceStack = null;
            _URTNamespaces = new ArrayList();
            _blockDefault = SchemaBlockType.ALL;
            _primedNametable = CreatePrimedNametable();
            
        }

 private string AccumulatePartial(TextReader reader)
 {
     StringBuilder buffer = new StringBuilder();
     buffer.Append(">");
     do
     {
         reader.Read();
     }
     while(char.IsWhiteSpace((char)reader.Peek()));
     while(true)
     {
         var peek = (char)reader.Peek();
         if (peek == '}' || peek == '~' || char.IsWhiteSpace(peek))
         {
             break;
         }
         var node = reader.Read();
         if (node == -1)
         {
             throw new InvalidOperationException("Reached end of template before the expression was closed.");
         }
         else
         {
             buffer.Append((char)node);
         }
     }
     return buffer.ToString();
 }

        internal OperatorScanner(TextReader reader, ErrorReporter reporter)
            : base(reader, reporter)
        {
            twoCharacterOperators = new Dictionary<char, IDictionary<char, Type>>();
            twoCharacterOperators[':'] = new Dictionary<char, Type>();
            twoCharacterOperators[':']['='] = typeof(AssignmentToken);

            twoCharacterOperators['.'] = new Dictionary<char, Type>();
            twoCharacterOperators['.']['.'] = typeof(RangeToken);

            singleCharacterOperators = new Dictionary<char, Type>();

            singleCharacterOperators.Add('+', typeof(PlusToken));
            singleCharacterOperators.Add('-', typeof(MinusToken));
            singleCharacterOperators.Add('*', typeof(MultiplyToken));
            singleCharacterOperators.Add('/', typeof(DivideToken));
            singleCharacterOperators.Add('<', typeof(LessThanToken));
            singleCharacterOperators.Add('=', typeof(ComparisonToken));
            singleCharacterOperators.Add('&', typeof(AndToken));
            singleCharacterOperators.Add('!', typeof(NotToken));
            singleCharacterOperators.Add(';', typeof(SemicolonToken));
            singleCharacterOperators.Add(':', typeof(ColonToken));
            singleCharacterOperators.Add('(', typeof(LParenToken));
            singleCharacterOperators.Add(')', typeof(RParenToken));
        }

        public int RunCommand(TextReader input, TextWriter output, string tenant, string[] args, Dictionary<string, string> switches)
        {
            try {
                tenant = tenant ?? "Default";

                var env = FindOrCreateTenant(tenant);

                var parameters = new CommandParameters {
                    Arguments = args,
                    Switches = switches,
                    Input = input,
                    Output = output
                };

                env.Resolve<ICommandManager>().Execute(parameters);

                return 0;
            }
            catch (Exception e) {
                for (int i = 0; e != null; e = e.InnerException, i++) {
                    if (i > 0) {
                        output.WriteLine("-------------------------------------------------------------------");
                    }
                    output.WriteLine("Error: {0}", e.Message);
                    output.WriteLine("{0}", e.StackTrace);
                }
                return 5;
            }
        }

		public TemplateParser (string filename, TextReader input)
		{
			this.filename = filename;
			fileText = input.ReadToEnd ();
			StringReader reader = new StringReader (fileText);
			tokenizer = new TemplateTokenizer (reader);
		}

        private void Initialize(TextReader input)
        {
            rand = new Random();
            fortunes = new List<string>();

            StringBuilder sb = new StringBuilder();
            string line = input.ReadLine();
            while (line != null)
            {
                if (line == "%")
                {
                    if (sb.Length > 0)
                    {
                        fortunes.Add(sb.ToString());
                        sb.Clear();
                    }
                }
                else
                {
                    if (sb.Length > 0)
                    {
                        sb.Append(' ');
                    }
                    sb.Append(line);
                }
                line = input.ReadLine();
            }
            if (sb.Length > 0)
            {
                fortunes.Add(sb.ToString());
            }
        }

 public XsvReader(TextReader reader, string commentString = null)
 {
     if (reader == null)
     { throw new ArgumentNullException("reader"); }
     this.BaseReader = reader;
     this.CommentString = commentString;
 }

		protected override void DoOpen (FileInfo info)
		{
			if (Extension == ".gz" || Extension == ".bz2" || Extension == ".lzma")
				GetCompressedInfoReader ();
			else
				reader = base.TextReader;
		}

        public override Sector Parse(TextReader reader)
        {
            Sector sector = new Sector();

            StringBuilder accum = new StringBuilder();
            while (true)
            {
                string line = reader.ReadLine();
                if (line == null)
                    break;
                if (Regex.IsMatch(line, @"^\s*$"))
                    continue;
                if (Regex.IsMatch(line, @"^\s*#"))
                    continue;
                if (Char.IsWhiteSpace(line[0]))
                {
                    accum.Append(" ");
                    accum.Append(Regex.Replace(line, @"^\s+", ""));
                    continue;
                }

                if (accum.Length > 0)
                    Apply(accum.ToString(), sector);

                accum.Clear();
                accum.Append(line);
            }
            if (accum.Length > 0)
            {
                Apply(accum.ToString(), sector);
            }

            return sector;
        }

 public Instruction[] Parse(TextReader reader)
 {
     Token token;
     mReader = reader;
     mScratchpad = new List<Instruction>();
     mState = Idle;
     while(mState != null && ReadNextToken(out token)) {
         mState = mState(token);
         if (mState == null) {
             mReader = null;
             mBuilder.Length = 0;
             mScratchpad.Clear();
             mBlock.Clear();
             return null;
         }
     }
     mReader = null;
     var result = mScratchpad.ToArray();
     mBuilder.Length = 0;
     mScratchpad.Clear();
     if (mBlock.Count > 0) {
         mBlock.Clear();
         return null;
     }
     return result;
 }

  public XmlConverter(TextReader rdr, XmlWriter writer, IPlatform platform)
  {
      this.rdr = rdr;
      this.writer = writer;
      this.platform = platform;
      this.parserState = new ParserState();
 }

		bool raise_on_number_error; // FIXME: use it

		public JavaScriptReader (TextReader reader, bool raiseOnNumberError)
		{
			if (reader == null)
				throw new ArgumentNullException ("reader");
			this.r = reader;
			raise_on_number_error = raiseOnNumberError;
		}

 /// <summary>
 /// Deserialize an IfcXml file to an iso_10303_28 object
 /// </summary>
 /// <param name="reader"></param>
 /// <exception cref="XmlException"></exception>
 /// <exception cref="InvalidOperationException"></exception>
 /// <returns></returns>
 public iso_10303 Deserialize(TextReader reader){
     if(reader == null)
         throw new ArgumentNullException("reader");
     
     iso_10303 deserializedUos;
     IfcXmlValidator validator;
     try{
         validator = new IfcXmlValidator( reader );
         
         deserializedUos = (iso_10303)serializer.Deserialize( validator.Reader );
         
     }catch(XmlException xe){
         logger.Error( String.Format(CultureInfo.InvariantCulture, "Deserialize failed: {0}", xe.Message) );
         throw;
     }catch(InvalidOperationException ioe){
         logger.Error(String.Format(CultureInfo.InvariantCulture, "Deserialize failed: {0}", ioe.Message));
         throw;
     }finally{
         reader.Close();
     }
     
     if(!validator.IsValid){
         StringBuilder warningBuilder = new StringBuilder();
         foreach(String warning in validator.Messages){
             warningBuilder.AppendLine( warning );
         }
         throw new XmlException(String.Format(CultureInfo.InvariantCulture, "Not valid IfcXml: {0}", warningBuilder.ToString()));
         
     }
     return deserializedUos;
 }

        public override TokenStream TokenStream(string fieldName, TextReader reader)
        {
            string str = reader.ReadToEnd();
            StringBuilder builder = new StringBuilder(str);
            builder.Replace('.', ' ');
            builder.Replace('<', ' ');
            builder.Replace('>', ' ');
            builder.Replace('[', ' ');
            builder.Replace(']', ' ');
            builder.Replace('(', ' ');
            builder.Replace(')', ' ');
            builder.Replace(',', ' ');

            builder.Replace("  ", " ");

            str = builder.ToString();
            
            for (int i = builder.Length - 1; i > 0; i--)
            {
                if (char.IsUpper(builder[i]))
                    builder.Insert(i, ' ');
            }

            builder.Append(' ').Append(str);

            return new LowerCaseFilter(new WhitespaceTokenizer(new StringReader(builder.ToString())));
        }

		public static WSABooParser CreateParser(int tabSize, string readerName, TextReader reader, Boo.Lang.Parser.ParserErrorHandler errorHandler)
		{
			var parser = new WSABooParser(CreateBooLexer(tabSize, readerName, reader));
			parser.setFilename(readerName);
			parser.Error += errorHandler;
			return parser;
		}

        public override object Deserialize(TextReader tr)
        {
            if (tr != null)
            {
                string value = tr.ReadToEnd();

                ICalendarObject co = SerializationContext.Peek() as ICalendarObject;
                if (co != null)
                {
                    EncodableDataType dt = new EncodableDataType();
                    dt.AssociatedObject = co;
                    value = Decode(dt, value);
                }

                value = TextUtil.Normalize(value, SerializationContext).ReadToEnd();

                try
                {
                    Uri uri = new Uri(value);
                    return uri;
                }
                catch
                {
                }
            }
            return null;
        }