public ParserResult(TokenInfo token, bool isSuccessed, LambdaExpression expr, SyntaxException error = null)
 {
     IsSuccessed = isSuccessed;
     Expression = expr;
     Token = token;
     Error = error;
 }

 private static Run CreateTextRun(string code, TokenInfo token)
 {
     var text = code.Substring(token.SourceSpan.Start.Index, token.SourceSpan.Length);
     var result = new Run(text);
     var style = _colorizationStyles.ContainsKey(token.Category) ? _colorizationStyles[token.Category] : _colorizationStyles[TokenCategory.None];
     result.Style = Application.Current.FindResource(style) as Style;
     return result;
 }

        private ChannelInformations GetChannelInformation(string baseUrl, TokenInfo googleAuthorization, HttpClient httpClient)
        {
            var getChannels = baseUrl + "/channels?part=contentDetails&mine=true";
            var channelResponse = MakeYoutubeGetRequest(googleAuthorization, httpClient, getChannels);
            var channelInformation = new JavaScriptSerializer().Deserialize<ChannelInformations>(channelResponse);

            return channelInformation;
        }

 private ParserResult MapRuleAction(ParserResult other)
 {
     Type source = Token.SourceType;
     Type target = other.Token.TargetType;
     var invoker = (IInvoker)Utilities.CreateType(typeof(MapGroupInvoker<,>), source, target)
                    .CreateInstance(Expression, other.Expression);
     var expr = invoker.Invoke();
     var token = new TokenInfo(RegisterKeys.MapRule, source, target);
     return new ParserResult(token, true, expr);
 }

            public static bool IsUnaryOperator(TokenInfo token)
            {
                switch (token.Token)
                {
                    case Token.Plus:
                    case Token.Minus:
                    case Token.Not:
                        return true;
                }

                return false;
            }

        private PlayListInformations GetPlayListInformation(ChannelInformations channelInformation, string baseUrl, TokenInfo googleAuthorization, HttpClient httpClient)
        {
            PlayListInformations playlistInformation = new PlayListInformations();
            foreach (var item in channelInformation.items)
            {
                var playlistItemUrl = baseUrl + "/playlistItems?part=snippet&playlistId=" + item.contentDetails.relatedPlaylists.uploads;
                var playlistResponse = MakeYoutubeGetRequest(googleAuthorization, httpClient, playlistItemUrl);
                playlistInformation = new JavaScriptSerializer().Deserialize<PlayListInformations>(playlistResponse);
            }

            return playlistInformation;
        }

        /// <summary>
        /// 为客户端创建令牌
        /// </summary>
        /// <returns></returns>
        public string CreateToken()
        {
            string returnStr = "";
            if (Signature != GetParam("sig").ToString())
            {
                ErrorCode = (int)ErrorType.API_EC_SIGNATURE;
                return returnStr;
            }

            //应用程序类型为Web的时候应用程序没有调用此方法的权限
            if (this.App.ApplicationType == (int)ApplicationType.WEB)
            {
                ErrorCode = (int)ErrorType.API_EC_PERMISSION_DENIED;
                return returnStr;
            }

            OnlineUserInfo oluserinfo = OnlineUsers.UpdateInfo(Config.Passwordkey, Config.Onlinetimeout);
            int olid = oluserinfo.Olid;

            string expires = string.Empty;
            DateTime expireUTCTime;
            TokenInfo token = new TokenInfo();

            if (System.Web.HttpContext.Current.Request.Cookies["dnt"] == null || System.Web.HttpContext.Current.Request.Cookies["dnt"]["expires"] == null)
            {
                token.Token = "";
                if (Format == FormatType.JSON)
                    returnStr = "";
                else
                    returnStr = SerializationHelper.Serialize(token);
                return returnStr;
            }
            expires = System.Web.HttpContext.Current.Request.Cookies["dnt"]["expires"].ToString();
            ShortUserInfo userinfo = Discuz.Forum.Users.GetShortUserInfo(oluserinfo.Userid);
            expireUTCTime = DateTime.Parse(userinfo.Lastvisit).ToUniversalTime().AddSeconds(Convert.ToDouble(expires));
            expires = Utils.ConvertToUnixTimestamp(expireUTCTime).ToString();

            string time = string.Empty;
            if (oluserinfo == null)
                time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            else
                time = DateTime.Parse(oluserinfo.Lastupdatetime).ToString("yyyy-MM-dd HH:mm:ss");

            string authToken = Common.DES.Encode(string.Format("{0},{1},{2}", olid.ToString(), time, expires), this.Secret.Substring(0, 10)).Replace("+", "[");
            token.Token = authToken;
            if (Format == FormatType.JSON)
                returnStr = authToken;
            else
                returnStr = SerializationHelper.Serialize(token);
            return returnStr;

        }

            public static bool IsArithmeticOperator(TokenInfo token)
            {
                switch (token.Token)
                {
                    case Token.Plus:
                    case Token.Minus:
                    case Token.Slash:
                    case Token.Star:
                    case Token.Percent:
                    case Token.Mod:
                        return true;
                }

                return false;
            }

            public static bool IsBinaryOperator(TokenInfo token)
            {
                switch (token.Token)
                {
                    case Token.Plus:
                    case Token.Minus:
                    case Token.Slash:
                    case Token.Star:
                    case Token.Percent:
                    case Token.LeftAngleBracket:
                    case Token.RightAngleBracket:
                    case Token.Is:
                    case Token.IsNot:
                    case Token.Mod:
                    case Token.Equality:
                    case Token.Inequality:
                    case Token.Period:
                        return true;
                }

                return false;
            }

        public override bool Run(CommandParameter commandParam, ref string result)
        {
            if (commandParam.AppInfo.ApplicationType == (int)ApplicationType.WEB)
            {
                result = Util.CreateErrorMessage(ErrorType.API_EC_PERMISSION_DENIED, commandParam.ParamList);
                return false;
            }
            TokenInfo token = new TokenInfo();

            if (System.Web.HttpContext.Current.Request.Cookies["dnt"] == null || System.Web.HttpContext.Current.Request.Cookies["dnt"]["expires"] == null)
            {
                token.Token = "";
                result = commandParam.Format == FormatType.JSON ? string.Empty : SerializationHelper.Serialize(token);
                return true;
            }

            OnlineUserInfo oluserinfo = OnlineUsers.UpdateInfo(commandParam.GeneralConfig.Passwordkey, commandParam.GeneralConfig.Onlinetimeout);
            int olid = oluserinfo.Olid;

            string expires = string.Empty;
            DateTime expireUTCTime;

            expires = System.Web.HttpContext.Current.Request.Cookies["dnt"]["expires"].ToString();
            ShortUserInfo userinfo = Discuz.Forum.Users.GetShortUserInfo(oluserinfo.Userid);
            expireUTCTime = DateTime.Parse(userinfo.Lastvisit).ToUniversalTime().AddSeconds(Convert.ToDouble(expires));
            expires = Utils.ConvertToUnixTimestamp(expireUTCTime).ToString();

            string time = string.Empty;
            if (oluserinfo == null)
                time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            else
                time = DateTime.Parse(oluserinfo.Lastupdatetime).ToString("yyyy-MM-dd HH:mm:ss");

            string authToken = Common.DES.Encode(string.Format("{0},{1},{2}", olid.ToString(), time, expires), commandParam.AppInfo.Secret.Substring(0, 10)).Replace("+", "[");
            token.Token = authToken;
            result = commandParam.Format == FormatType.JSON ? authToken : SerializationHelper.Serialize(token);
            return true;
        }

        public Videos GetVideoList(TokenInfo tokenInfo)
        {
            var httpClient = new HttpClient();
            var baseUrl = "https://www.googleapis.com/youtube/v3";

            var channelInformation = GetChannelInformation(baseUrl, tokenInfo, httpClient);
            var playlistInformation = GetPlayListInformation(channelInformation, baseUrl, tokenInfo, httpClient);

            var video = playlistInformation.items.Select(x => new Video
            {
                Description = x.snippet.description,
                Name = x.snippet.title,
                ThumbnailUrl = x.snippet.thumbnails.high.url,
                VideoUrl = @"http://www.youtube.com/embed/" + x.snippet.resourceId.VideoId,
                PublishedDate = x.snippet.publishedAt
            }).ToList();

            var videos = new Videos
            {
                VideoList = video
            };

            return videos;
        }

 public int GetTokenInfoAt(TokenInfo[] infos, int col, ref TokenInfo info) {
   for (int i = 0, len = infos.Length; i < len; i++) {
     int start = infos[i].startIndex; // 1-based to zero based.
     int end = infos[i].endIndex; // 1-based to zero based.
     if (i == 0 && start > col)
       return -1;
     if (col >= start && col <= end) {
       info = infos[i];
       return i;
     }
   }
   return -1;
 }

    internal void BeginParse( int line, int idx, TokenInfo info, ParseReason reason, IVsTextView view, ParseResultHandler callback) {
     
      string text = null;
      if (reason == ParseReason.MemberSelect || reason == ParseReason.MethodTip)
        text = this.GetTextUpToLine( line );
      else if (reason == ParseReason.CompleteWord || reason == ParseReason.QuickInfo)
        text = this.GetTextUpToLine( line+1 );
      else
        text = this.GetTextUpToLine( 0 ); // get all the text.      

      string fname = this.GetFilePath();

      this.service.BeginParse(new ParseRequest(line, idx, info, text, fname, reason, view), callback); 
    }

 public virtual void MatchBraces(IVsTextView textView, int line, int idx, TokenInfo info) {
   this.BeginParse(line, idx, info, ParseReason.HighlightBraces, textView, new ParseResultHandler(this.HandleMatchBracesResponse));
 }

 internal void ScanInterpolatedStringLiteralTop(ArrayBuilder<Interpolation> interpolations, bool isVerbatim, ref TokenInfo info, ref SyntaxDiagnosticInfo error, out bool closeQuoteMissing)
 {
     var subScanner = new InterpolatedStringScanner(this, isVerbatim);
     subScanner.ScanInterpolatedStringLiteralTop(interpolations, ref info, out closeQuoteMissing);
     error = subScanner.error;
     info.Text = TextWindow.GetText(false);
 }

        private void ScanVerbatimStringLiteral(ref TokenInfo info, bool allowNewlines = true)
        {
            _builder.Length = 0;

            if (TextWindow.PeekChar() == '@' && TextWindow.PeekChar(1) == '"')
            {
                TextWindow.AdvanceChar(2);
                bool done = false;
                char ch;
                _builder.Length = 0;
                while (!done)
                {
                    switch (ch = TextWindow.PeekChar())
                    {
                        case '"':
                            TextWindow.AdvanceChar();
                            if (TextWindow.PeekChar() == '"')
                            {
                                // Doubled quote -- skip & put the single quote in the string
                                TextWindow.AdvanceChar();
                                _builder.Append(ch);
                            }
                            else
                            {
                                done = true;
                            }

                            break;

                        case SlidingTextWindow.InvalidCharacter:
                            if (!TextWindow.IsReallyAtEnd())
                            {
                                goto default;
                            }

                            // Reached the end of the source without finding the end-quote.  Give
                            // an error back at the starting point.
                            this.AddError(ErrorCode.ERR_UnterminatedStringLit);
                            done = true;
                            break;

                        default:
                            if (!allowNewlines && SyntaxFacts.IsNewLine(ch))
                            {
                                this.AddError(ErrorCode.ERR_UnterminatedStringLit);
                                done = true;
                                break;
                            }

                            TextWindow.AdvanceChar();
                            _builder.Append(ch);
                            break;
                    }
                }

                info.Kind = SyntaxKind.StringLiteralToken;
                info.Text = TextWindow.GetText(false);
                info.StringValue = _builder.ToString();
            }
            else
            {
                info.Kind = SyntaxKind.None;
                info.Text = null;
                info.StringValue = null;
            }
        }

        private int GetLeadingMultiLineStrings(Tokenizer tokenizer, ITextSnapshot snapshot, int firstLine, int currentLine, out int validPrevLine, ref TokenInfo startToken)
        {
            validPrevLine = currentLine;
            int prevLine = currentLine - 1;
            int length = 0;

            while (prevLine >= 0) {
                LineTokenization prevLineTokenization;
                if (!_tokenCache.TryGetTokenization(prevLine, out prevLineTokenization)) {
                    LineTokenization lineTokenizationTemp;
                    int currentLineTemp = _tokenCache.IndexOfPreviousTokenization(firstLine, 0, out lineTokenizationTemp) + 1;
                    object stateTemp = lineTokenizationTemp.State;

                    while (currentLineTemp <= snapshot.LineCount) {
                        if (!_tokenCache.TryGetTokenization(currentLineTemp, out lineTokenizationTemp)) {
                            lineTokenizationTemp = TokenizeLine(tokenizer, snapshot, stateTemp, currentLineTemp);
                            _tokenCache[currentLineTemp] = lineTokenizationTemp;
                        }

                        stateTemp = lineTokenizationTemp.State;
                    }

                    prevLineTokenization = TokenizeLine(tokenizer, snapshot, stateTemp, prevLine);
                    _tokenCache[prevLine] = prevLineTokenization;
                }

                if (prevLineTokenization.Tokens.Length != 0) {
                    if (prevLineTokenization.Tokens[prevLineTokenization.Tokens.Length - 1].Category != TokenCategory.IncompleteMultiLineStringLiteral) {
                        break;
                    }

                    startToken = prevLineTokenization.Tokens[prevLineTokenization.Tokens.Length - 1];
                    length += startToken.SourceSpan.Length;
                }

                validPrevLine = prevLine;
                prevLine--;

                if (prevLineTokenization.Tokens.Length > 1) {
                    // http://pytools.codeplex.com/workitem/749
                    // if there are multiple tokens on this line then our multi-line string
                    // is terminated.
                    break;
                }
            }
            return length;
        }

 private static Span SnapshotSpanToSpan(ITextSnapshot snapshot, TokenInfo token, int lineNumber)
 {
     var line = snapshot.GetLineFromLineNumber(lineNumber);
     var index = line.Start.Position + token.SourceSpan.Start.Column - 1;
     var tokenSpan = new Span(index, token.SourceSpan.Length);
     return tokenSpan;
 }

        private ClassificationSpan ClassifyToken(SnapshotSpan span, TokenInfo token, int lineNumber)
        {
            IClassificationType classification = null;

            if (token.Category == TokenCategory.Operator) {
                if (token.Trigger == TokenTriggers.MemberSelect) {
                    classification = _provider.DotClassification;
                }
            } else if (token.Category == TokenCategory.Grouping) {
                if (token.Trigger == (TokenTriggers.MatchBraces | TokenTriggers.ParameterStart)) {
                    classification = _provider.OpenGroupingClassification;
                } else if (token.Trigger == (TokenTriggers.MatchBraces | TokenTriggers.ParameterEnd)) {
                    classification = _provider.CloseGroupingClassification;
                }
            } else if (token.Category == TokenCategory.Delimiter) {
                if (token.Trigger == TokenTriggers.ParameterNext) {
                    classification = _provider.CommaClassification;
                }
            }

            if (classification == null) {
                CategoryMap.TryGetValue(token.Category, out classification);
            }

            if (classification != null) {
                var line = span.Snapshot.GetLineFromLineNumber(lineNumber);
                var index = line.Start.Position + token.SourceSpan.Start.Column - 1;
                var tokenSpan = new Span(index, token.SourceSpan.Length);
                var intersection = span.Intersection(tokenSpan);
                if (intersection != null && intersection.Value.Length > 0) {
                    return new ClassificationSpan(new SnapshotSpan(span.Snapshot, tokenSpan), classification);
                }
            }

            return null;
        }

 public LineTokenization(TokenInfo[] tokens, object state) {
     Tokens = tokens;
     State = state;
 }