/// <inheritdoc/>
        public ClassifierAction NextCharacter(char nextCharacter)
        {
            if (isFirstCharacter)
            {
                isFirstCharacter = false;

                return(nextCharacter == '\''
                                        ? ClassifierAction.ContinueReading()
                                        : ClassifierAction.GiveUp());
            }
            else
            {
                if (nextCharacter == '\\')
                {
                    isEscaped = true;
                    return(ClassifierAction.ContinueReading());
                }
                else if (nextCharacter == '\'')
                {
                    if (isEscaped)
                    {
                        isEscaped = false;
                        return(ClassifierAction.ContinueReading());
                    }
                    else
                    {
                        return(ClassifierAction.TokenizeImmediately());
                    }
                }
                else
                {
                    return(ClassifierAction.ContinueReading());
                }
            }
        }
        /// <inheritdoc/>
        public ClassifierAction NextCharacter(char nextCharacter)
        {
            bool isMatched = nextCharacter == MatchedCharacter;

            return(isMatched
                                ? ClassifierAction.TokenizeImmediately()
                                : ClassifierAction.GiveUp());
        }
 /// <inheritdoc/>
 public ClassifierAction NextCharacter(char nextCharacter)
 {
     return(nextCharacter switch
     {
         '\r' => ClassifierAction.ContinueReading(),
         '\n' => ClassifierAction.TokenizeImmediately(),
         _ => ClassifierAction.GiveUp()
     });
        /// <inheritdoc/>
        public ClassifierAction NextCharacter(char nextCharacter)
        {
            switch (state)
            {
            case State.ExpectingStartingSlash:
            {
                if (nextCharacter == '/')
                {
                    state = State.ExpectingStartingAsterisk;
                    return(ClassifierAction.ContinueReading());
                }
                else
                {
                    return(ClassifierAction.GiveUp());
                }
            }

            case State.ExpectingStartingAsterisk:
            {
                if (nextCharacter == '*')
                {
                    state = State.ExpectingEndingAsterisk;
                    return(ClassifierAction.ContinueReading());
                }
                else
                {
                    return(ClassifierAction.GiveUp());
                }
            }

            case State.ExpectingEndingAsterisk:
            {
                if (nextCharacter == '*')
                {
                    state = State.ExpectingEndingSlash;
                }
                return(ClassifierAction.ContinueReading());
            }

            default:
            {
                if (nextCharacter == '/')
                {
                    return(ClassifierAction.TokenizeImmediately());
                }
                else
                {
                    state = State.ExpectingStartingAsterisk;
                    return(ClassifierAction.ContinueReading());
                }
            }
            }
        }
 /// <inheritdoc/>
 public ClassifierAction NextCharacter(char nextCharacter)
 {
     if (modeIndex == 0)
     {
         modeIndex = 1;
         if (nextCharacter == '/')
         {
             return(ClassifierAction.ContinueReading());
         }
         else
         {
             return(ClassifierAction.GiveUp());
         }
     }
     else if (modeIndex == 1)
     {
         modeIndex = 2;
         if (nextCharacter == '*')
         {
             return(ClassifierAction.ContinueReading());
         }
         else
         {
             return(ClassifierAction.GiveUp());
         }
     }
     else if (modeIndex == 2)
     {
         if (nextCharacter == '*')
         {
             modeIndex = 3;
             return(ClassifierAction.ContinueReading());
         }
         else
         {
             return(ClassifierAction.ContinueReading());
         }
     }
     else
     {
         if (nextCharacter == '/')
         {
             return(ClassifierAction.TokenizeImmediately());
         }
         else
         {
             modeIndex = 2;
             return(ClassifierAction.ContinueReading());
         }
     }
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="UvssClassifierVisitor"/> class.
        /// </summary>
        /// <param name="registry">The classification type registry service.</param>
        /// <param name="classifier">The action which is called when a span is classified.</param>
        public UvssClassifierVisitor(IClassificationTypeRegistryService registry, ClassifierAction classifier)
        {
            this.typeUvssComment = registry.GetClassificationType("UvssComment");
            this.typeUvssNumber = registry.GetClassificationType("UvssNumber");
            this.typeUvssKeyword = registry.GetClassificationType("UvssKeyword");
            this.typeUvssSelector = registry.GetClassificationType("UvssSelector");
            this.typeUvssPropertyName = registry.GetClassificationType("UvssPropertyName");
            this.typeUvssPropertyValue = registry.GetClassificationType("UvssPropertyValue");
            this.typeUvssStoryboard = registry.GetClassificationType("UvssStoryboard");
            this.typeUvssTypeName = registry.GetClassificationType("UvssTypeName");
            this.typeUvssDirective = registry.GetClassificationType("UvssDirective");

            this.classifier = classifier;
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="UvssClassifierVisitor"/> class.
        /// </summary>
        /// <param name="registry">The classification type registry service.</param>
        /// <param name="classifier">The action which is called when a span is classified.</param>
        public UvssClassifierVisitor(IClassificationTypeRegistryService registry, ClassifierAction classifier)
        {
            this.typeUvssComment       = registry.GetClassificationType("UvssComment");
            this.typeUvssNumber        = registry.GetClassificationType("UvssNumber");
            this.typeUvssKeyword       = registry.GetClassificationType("UvssKeyword");
            this.typeUvssSelector      = registry.GetClassificationType("UvssSelector");
            this.typeUvssPropertyName  = registry.GetClassificationType("UvssPropertyName");
            this.typeUvssPropertyValue = registry.GetClassificationType("UvssPropertyValue");
            this.typeUvssStoryboard    = registry.GetClassificationType("UvssStoryboard");
            this.typeUvssTypeName      = registry.GetClassificationType("UvssTypeName");
            this.typeUvssDirective     = registry.GetClassificationType("UvssDirective");

            this.classifier = classifier;
        }
 /// <inheritdoc/>
 public ClassifierAction NextCharacter(char nextCharacter)
 {
     if (characterIndex == 0 ||
         characterIndex == 1)
     {
         characterIndex++;
         return(nextCharacter == '/'
                                 ? ClassifierAction.ContinueReading()
                                 : ClassifierAction.GiveUp());
     }
     else
     {
         return(nextCharacter == '\n' ||
                nextCharacter == '\r'
                                 ? ClassifierAction.TokenizeFromLast()
                                 : ClassifierAction.ContinueReading());
     }
 }
Example #9
0
        /// <inheritdoc/>
        public ClassifierAction NextCharacter(char nextCharacter)
        {
            bool isMatched = IsMatched(nextCharacter);

            if (!IsFirstCharacter)
            {
                if (!isMatched)
                {
                    return(ClassifierAction.TokenizeFromLast());
                }
            }

            IsFirstCharacter = false;

            return(isMatched
                                ? ClassifierAction.ContinueReading()
                                : ClassifierAction.GiveUp());
        }
        /// <inheritdoc/>
        public ClassifierAction NextCharacter(char nextCharacter)
        {
            bool isMatched = char.IsWhiteSpace(nextCharacter) &&
                             nextCharacter != '\r' &&
                             nextCharacter != '\n';

            if (!IsFirstCharacter)
            {
                if (!isMatched)
                {
                    return(ClassifierAction.TokenizeFromLast());
                }
            }

            IsFirstCharacter = false;

            return(isMatched
                                ? ClassifierAction.ContinueReading()
                                : ClassifierAction.GiveUp());
        }
Example #11
0
 /// <inheritdoc/>
 public ClassifierAction NextCharacter(char nextCharacter)
 {
     if (currentIndex == Keyword.Length)
     {
         return(char.IsLetterOrDigit(nextCharacter)
                                 ? ClassifierAction.GiveUp()
                                 : ClassifierAction.TokenizeFromLast());
     }
     else
     {
         if (nextCharacter == Keyword[currentIndex])
         {
             currentIndex++;
             return(ClassifierAction.ContinueReading());
         }
         else
         {
             return(ClassifierAction.GiveUp());
         }
     }
 }
        /// <inheritdoc/>
        public ClassifierAction NextCharacter(char nextCharacter)
        {
            string keyword = MatchedString;

            if (currentIndex == keyword.Length)
            {
                return(ClassifierAction.TokenizeFromLast());
            }
            else
            {
                if (nextCharacter == keyword[currentIndex])
                {
                    currentIndex++;
                    return(ClassifierAction.ContinueReading());
                }
                else
                {
                    return(ClassifierAction.GiveUp());
                }
            }
        }
 /// <inheritdoc/>
 public ClassifierAction NextCharacter(char nextCharacter)
 {
     if (characterIndex == 0)
     {
         characterIndex++;
         if (nextCharacter == '/')
         {
             return(ClassifierAction.ContinueReading());
         }
         else
         {
             return(ClassifierAction.GiveUp());
         }
     }
     if (characterIndex == 1)
     {
         characterIndex++;
         if (nextCharacter == '/')
         {
             return(ClassifierAction.ContinueReading());
         }
         else
         {
             return(ClassifierAction.GiveUp());
         }
     }
     else
     {
         characterIndex++;
         if (nextCharacter == '\n')
         {
             return(ClassifierAction.TokenizeImmediately());
         }
         else
         {
             return(ClassifierAction.ContinueReading());
         }
     }
 }
Example #14
0
        /// <inheritdoc/>
        public ClassifierAction NextCharacter(char nextCharacter)
        {
            bool isMatched = char.IsDigit(nextCharacter) ||
                             nextCharacter == '.';

            if (!isFirstCharacter)
            {
                if (!isMatched)
                {
                    return(ClassifierAction.TokenizeFromLast());
                }
            }
            else if (nextCharacter == '-')
            {
                return(ClassifierAction.ContinueReading());
            }

            isFirstCharacter = false;

            return(isMatched
                                ? ClassifierAction.ContinueReading()
                                : ClassifierAction.GiveUp());
        }