public void Advance()

in resharper/resharper-unity/src/Unity/Yaml/Psi/Parsing/UnityYamlLexer.cs [33:175]
125 lines of code
41 McCabe index (conditional complexity)

        public void Advance()
        {
            bool findHeader = false;
            if (myCurOffset > EndOffset)
            {
                myTokenNodeType = null;
                return;
            }

            var isInteresting = false;
            myTokenStartOffset = myCurOffset;
            while (true)
            {
                if (myCurOffset > EndOffset)
                {
                    EatUntilDocumentEnd();
                    return;
                }
                
                switch (myBuffer[myCurOffset])
                {
                    case '%':
                        findHeader = true;
                        while (true)
                        {
                            if (myCurOffset > EndOffset)
                            {
                                myTokenNodeType = UnityYamlTokenType.DOCUMENT;
                                return;
                            }

                            if (myBuffer[myCurOffset] == '\r')
                            {
                                myCurOffset++;
                                myCurrentLineOffset = 0;
                                if (myCurOffset <= EndOffset && myBuffer[myCurOffset] == '\n')
                                    myCurOffset++;
                                break;
                            }

                            if (myBuffer[myCurOffset] == '\n')
                            {
                                myCurOffset++;
                                myCurrentLineOffset = 0;
                                break;
                            }
                            myCurOffset++;
                        }

                        break;
                    case '-':
                        if (findHeader)
                        {
                            myTokenNodeType = UnityYamlTokenType.USELESS_DOCUMENT;
                            return;
                        }
                        myCurOffset++;
                        if (myCurOffset + 1 <= EndOffset && myBuffer[myCurOffset] == '-' &&
                            myBuffer[myCurOffset + 1] == '-')
                        {
                            myCurOffset++;
                            myCurOffset++;
                            if (myCurOffset <= EndOffset && myBuffer[myCurOffset] == ' ')
                            {
                                myCurOffset++;
                                var sb = new StringBuilder();
                                while (myCurOffset <= EndOffset && myBuffer[myCurOffset] != ' '
                                                                  && myBuffer[myCurOffset] != '\r'
                                                                  && myBuffer[myCurOffset] != '\n')
                                {
                                    sb.Append(Buffer[myCurOffset]);
                                    myCurOffset++; 
                                }

                                var tag = sb.ToString();
                                if (tag.Equals("!u!1") ||
                                    tag.Equals("!u!4") ||
                                    tag.Equals("!u!1001") ||
                                    tag.Equals("!u!114") ||
                                    tag.Equals("!u!224") ||
                                    tag.Equals("!u!1102") ||
                                    tag.Equals("!u!1107") ||
                                    tag.Equals("!u!74") ||
                                    tag.Equals("!u!95"))
                                {
                                    isInteresting = true;
                                }
                            }
                        }

                        myCurrentLineOffset = 1; // just mark that it is not line start
                        EatUntilDocumentEnd();
                        return;

                    default:
                        EatUntilDocumentEnd();
                        return;
                }
            }

            void EatUntilDocumentEnd()
            {
                while (true)
                {
                    if (myCurOffset > EndOffset)
                    {
                        myTokenNodeType = UnityYamlTokenType.DOCUMENT;
                        break;
                    }

                    var curChar = myBuffer[myCurOffset];
                    if (curChar == '\r')
                    {
                        myCurrentLineOffset = 0;
                        myCurOffset++;
                        continue;
                    }

                    if (curChar == '\n')
                    {
                        myCurrentLineOffset = 0;
                        myCurOffset++;
                        continue;
                    }
                    
                    if (myCurrentLineOffset == 0 && myCurOffset + 2 <= EndOffset && (
                            (curChar == '-' && myBuffer[myCurOffset + 1] == '-' &&
                             myBuffer[myCurOffset + 2] == '-')))
                    {
                        
                        myTokenNodeType = isInteresting ? UnityYamlTokenType.DOCUMENT : UnityYamlTokenType.USELESS_DOCUMENT;
                        // debug highlightings...
                        // myTokenNodeType = isInteresting ? UnityYamlTokenType.DOCUMENT : YamlTokenType.COMMENT;

                        break;
                    }

                    myCurrentLineOffset++;
                    myCurOffset++;

                }
            }
        }