public UnexpectedTokenException(Token current, TokenKind[] tokenKinds)
     : base(string.Format("On line {0} expected {1} but got {2}.",
     current.Line, string.Join(",",tokenKinds), current.Kind ))
 {
     EncounteredToken = current;
     ExpectedTokenKinds = tokenKinds;
 }

 public BinaryExpression(int line, int col, Expression lhs, TokenKind op, Expression rhs)
     : base(line, col)
 {
     this.lhs = lhs;
     this.rhs = rhs;
     this.op = op;
 }

 public BinaryOperatorTerminal(string @operator, TokenKind tokenKind)
     : base("-" + @operator, "(?<_operator_" + @operator + ">" + dash_pattern + @operator + ")")
 {
     this.Operator = @operator;
     this.TokenKind = tokenKind;
     Priority = TerminalPriority.ReservedWords;
 }

 public Token(TokenKind kind, string text, int line, int column)
 {
     this.kind = kind;
     this.line = line;
     this.column = column;
     this.text = text;
 }

 public Token(TokenKind kind, string value, int line, int column)
 {
     this.kind = kind;
     this.value = value;
     this.line = line;
     this.column = column;
 }

 public void Reset()
 {
     this.kind		= TokenKind.EOF;
       this.text		= string.Empty;
       this.value	= -1L;
       this.pos		= -1;
 }

 public AssignmentStatementAst(IScriptExtent extent, ExpressionAst left, TokenKind @operator, StatementAst right, IScriptExtent errorPosition) : base(extent)
 {
     if (((left == null) || (right == null)) || (errorPosition == null))
     {
         throw PSTraceSource.NewArgumentNullException((left == null) ? "left" : ((right == null) ? "right" : "errorPosition"));
     }
     if ((@operator.GetTraits() & TokenFlags.AssignmentOperator) == TokenFlags.None)
     {
         throw PSTraceSource.NewArgumentException("operator");
     }
     PipelineAst ast = right as PipelineAst;
     if ((ast != null) && (ast.PipelineElements.Count == 1))
     {
         CommandExpressionAst ast2 = ast.PipelineElements[0] as CommandExpressionAst;
         if (ast2 != null)
         {
             right = ast2;
             right.ClearParent();
         }
     }
     this.Operator = @operator;
     this.Left = left;
     base.SetParent(left);
     this.Right = right;
     base.SetParent(right);
     this.ErrorPosition = errorPosition;
 }

        private Token Match(TokenKind kind)
        {
            if (_lookahead.Kind == kind)
                return ReadToken();

            throw new ParserError(_lookahead.Position, "Expected '" + kind.ToString() + "', found '" + _lookahead.ToString() + "'");
        }

 internal void SetIsCommandArgument()
 {
     if (this._kind != TokenKind.Identifier)
     {
         this._kind = TokenKind.Generic;
     }
 }

 public TokenKindTests()
 {
     lower = new Pattern("Lowercase", @"[a-z]+");
     upper = new Pattern("Uppercase", @"[A-Z]+");
     caseInsensitive = new Pattern("Case Insensitive", @"[a-z]+", RegexOptions.IgnoreCase);
     abcDEF = new Text("abcDEF");
 }

		/// <summary>
		/// 初始化 Token 对象。
		/// </summary>
		/// <param name="kind">指定 Token 类型。</param>
		/// <param name="data">指定 Token 内容。</param>
		/// <param name="line">指定 Token 所在的行数</param>
		/// <param name="col">指定 Token 所在的列数</param>
		public Token(TokenKind kind, string data, int line, int col)
		{
			_TokenKind = kind;
			_Line = line;
			_Col = col;
			_Data = data;
		}

 public Token(TokenKind kind, string data, int line, int col)
 {
     _tokenKind = kind;
     _line      = line;
     _col       = col;
     _data      = data;
 }

 public Token(TokenKind kind, string data, int line, int col)
 {
     this.TokenKind = kind;
     this.Data = data;
     this.Line = line;
     this.Col = col;
 }

 public Token(int line, int col, string data,TokenKind tokenKind)
 {
     this.Line = line;
     this.Col = col;
     this.Text = data;
     this.Kind = tokenKind;
 }

 public void Ensure(TokenKind kind, string readerName)
 {
     if (current.Kind != kind)
     {
         throw new ParserException($"Expected {kind} while reading {readerName}). Was {current}.");
     }
 }

		/// <summary>
		/// 初始化预定义运算符表达式。
		/// </summary>
		/// <param name="line">指定预定义运算符表达式所在位置的行数。</param>
		/// <param name="col">指定预定义运算符表达式所在位置的列数。</param>
		/// <param name="lhs">指定预定义运算符表达式的左侧值。</param>
		/// <param name="op">指定预定义运算符表达式的运算符。</param>
		/// <param name="rhs">指定预定义运算符表达式的右侧值。</param>
		public BinaryExpression(int line, int col, Expression lhs, TokenKind op, Expression rhs)
			: base(line, col)
		{
			_Lhs = lhs;
			_Rhs = rhs;
			_op = op;
		}

 public Token(TokenKind kind, string value, int line, int column)
 {
     _kind = kind;
     _value = value;
     _line = line;
     _column = column;
 }

        public BinaryExpression(TokenKind type, Expression left, Expression right)
        {
            ContractUtils.RequiresNotNull(left, "left");
            ContractUtils.RequiresNotNull(right, "right");

            switch (type)
            {
                case TokenKind.Add: _op = MSAst.ExpressionType.Add; break;
                case TokenKind.Subtract: _op = MSAst.ExpressionType.Subtract; break;
                case TokenKind.Mod: _op = MSAst.ExpressionType.Modulo; break;
                case TokenKind.Multiply: _op = MSAst.ExpressionType.Multiply; break;
                case TokenKind.Divide: _op = MSAst.ExpressionType.Divide; break;
                case TokenKind.LessThan: _op = MSAst.ExpressionType.LessThan; break;
                case TokenKind.LessThanOrEqual: _op = MSAst.ExpressionType.LessThanOrEqual; break;
                case TokenKind.GreaterThan: _op = MSAst.ExpressionType.GreaterThan; break;
                case TokenKind.GreaterThanOrEqual: _op = MSAst.ExpressionType.GreaterThanOrEqual; break;
                case TokenKind.Equals: _op = MSAst.ExpressionType.Equal; break;
                case TokenKind.NotEquals: _op = MSAst.ExpressionType.NotEqual; break;
                case TokenKind.LogicalAnd: _op = MSAst.ExpressionType.And; break;
                case TokenKind.LogicalOr: _op = MSAst.ExpressionType.Or; break;
                default: throw Assert.Unreachable;
            }

            _left = left;
            _right = right;
            StartIndex = left.StartIndex;
            EndIndex = right.EndIndex;
        }

 public Token(TokenKind kind, string data, int line, int col)
 {
     this.tokenKind = kind;
     this.line = line;
     this.col = col;
     this.data = data;
 }

 public Token(TokenKind kind, string value, int line, int column)
 {
     this.Kind = kind;
     this.Value = value;
     this.Line = line;
     this.Column = column;
 }