private WorkspaceEntry ParseEntry()

in tools/nuget2bazel/WorkspaceParser.cs [51:155]
97 lines of code
27 McCabe index (conditional complexity)

        private WorkspaceEntry ParseEntry()
        {
            while (!IsEof() && IsWhitespace()) ++_pos;

            if (IsEof())
                return null;

            var result = new WorkspaceEntry();

            string package = null;
            string version = null;

            RequireToken(TokenCode.NUGET_PACKAGE);
            RequireToken(TokenCode.LPAR);

            var finished = false;
            while (!finished)
            {
                var (token, val) = PeekToken();
                switch (token)
                {
                    case TokenCode.NAME:
                        RequireToken(TokenCode.NAME);
                        RequireToken(TokenCode.EQUAL);
                        try
                        {
                            RequireToken(TokenCode.STRING);
                        }
                        catch (UnexpectedToken ex)
                        {
                            result.Variable = ex.Literal;
                        }
                        break;
                    case TokenCode.SOURCE:
                        RequireToken(TokenCode.SOURCE);
                        RequireToken(TokenCode.EQUAL);
                        RequireToken(TokenCode.SOURCE);
                        result.NugetSourceCustom = true;
                        break;
                    case TokenCode.CORE_FILES:
                        result.Core_Files = RequireDictionaryList(TokenCode.CORE_FILES);
                        break;
                    case TokenCode.CORE_LIB:
                        result.CoreLib = RequireDictionary(TokenCode.CORE_LIB);
                        break;
                    case TokenCode.CORE_REF:
                        result.CoreRef = RequireDictionary(TokenCode.CORE_REF);
                        break;
                    case TokenCode.MONO_DEPS:
                        result.Mono_Deps = RequireArray(TokenCode.MONO_DEPS);
                        break;
                    case TokenCode.MONO_FILES:
                        result.Mono_Files = RequireArray(TokenCode.MONO_FILES);
                        break;
                    case TokenCode.MONO_LIB:
                        result.MonoLib = RequireAssignment(TokenCode.MONO_LIB);
                        break;
                    case TokenCode.MONO_REF:
                        result.MonoRef = RequireAssignment(TokenCode.MONO_REF);
                        break;
                    case TokenCode.NET_DEPS:
                        result.Net_Deps = RequireDictionaryList(TokenCode.NET_DEPS);
                        break;
                    case TokenCode.NET_FILES:
                        result.Net_Files = RequireDictionaryList(TokenCode.NET_FILES);
                        break;
                    case TokenCode.NET_LIB:
                        result.NetLib = RequireDictionary(TokenCode.NET_LIB);
                        break;
                    case TokenCode.NET_REF:
                        result.NetRef = RequireDictionary(TokenCode.NET_REF);
                        break;
                    case TokenCode.PACKAGE:
                        package = RequireAssignment(TokenCode.PACKAGE);
                        break;
                    case TokenCode.VERSION:
                        version = RequireAssignment(TokenCode.VERSION);
                        break;
                    case TokenCode.SHA256:
                        result.Sha256 = RequireAssignment(TokenCode.SHA256);
                        break;
                    case TokenCode.CORE_TOOL:
                        result.CoreTool = RequireDictionary(TokenCode.CORE_TOOL);
                        break;
                    case TokenCode.NET_TOOL:
                        result.NetTool = RequireDictionary(TokenCode.NET_TOOL);
                        break;
                    case TokenCode.MONO_TOOL:
                        result.MonoTool = RequireAssignment(TokenCode.MONO_TOOL);
                        break;
                    case TokenCode.CORE_DEPS:
                        result.Core_Deps = RequireDictionaryList(TokenCode.CORE_DEPS);
                        break;
                    case TokenCode.RPAR:
                        finished = true;
                        GetToken();
                        break;
                }

            }

            result.PackageIdentity = new PackageIdentity(package, new NuGetVersion(version));

            return result;
        }