diff options
Diffstat (limited to 'source/compiler-core')
27 files changed, 866 insertions, 387 deletions
diff --git a/source/compiler-core/slang-artifact-associated-impl.cpp b/source/compiler-core/slang-artifact-associated-impl.cpp index cbecd1360..88ed9f665 100644 --- a/source/compiler-core/slang-artifact-associated-impl.cpp +++ b/source/compiler-core/slang-artifact-associated-impl.cpp @@ -196,10 +196,14 @@ void ArtifactDiagnostics::requireErrorDiagnostic() typedef ArtifactDiagnostic::Severity Severity; switch (severity) { - default: return UnownedStringSlice::fromLiteral("Unknown"); - case Severity::Info: return UnownedStringSlice::fromLiteral("Info"); - case Severity::Warning: return UnownedStringSlice::fromLiteral("Warning"); - case Severity::Error: return UnownedStringSlice::fromLiteral("Error"); + default: + return UnownedStringSlice::fromLiteral("Unknown"); + case Severity::Info: + return UnownedStringSlice::fromLiteral("Info"); + case Severity::Warning: + return UnownedStringSlice::fromLiteral("Warning"); + case Severity::Error: + return UnownedStringSlice::fromLiteral("Error"); } } diff --git a/source/compiler-core/slang-artifact-associated-impl.h b/source/compiler-core/slang-artifact-associated-impl.h index 515cedb2d..ff8f03163 100644 --- a/source/compiler-core/slang-artifact-associated-impl.h +++ b/source/compiler-core/slang-artifact-associated-impl.h @@ -162,8 +162,10 @@ struct ShaderBindingRange case slang::ShaderResource: case slang::UnorderedAccess: case slang::SamplerState: - case slang::DescriptorTableSlot: return true; - default: return false; + case slang::DescriptorTableSlot: + return true; + default: + return false; } } }; diff --git a/source/compiler-core/slang-artifact-container-util.cpp b/source/compiler-core/slang-artifact-container-util.cpp index 935cabe8f..574028c48 100644 --- a/source/compiler-core/slang-artifact-container-util.cpp +++ b/source/compiler-core/slang-artifact-container-util.cpp @@ -677,8 +677,12 @@ SlangResult ArtifactContainerReader::_readContainerDirectory( case IArtifact::ContainedKind::Associated: containerArtifact->addAssociated(artifact); break; - case IArtifact::ContainedKind::Children: containerArtifact->addChild(artifact); break; - default: SLANG_ASSERT(!"Can't add artifact to this kind"); return SLANG_FAIL; + case IArtifact::ContainedKind::Children: + containerArtifact->addChild(artifact); + break; + default: + SLANG_ASSERT(!"Can't add artifact to this kind"); + return SLANG_FAIL; } } } diff --git a/source/compiler-core/slang-artifact-desc-util.cpp b/source/compiler-core/slang-artifact-desc-util.cpp index 078398400..c1575ba16 100644 --- a/source/compiler-core/slang-artifact-desc-util.cpp +++ b/source/compiler-core/slang-artifact-desc-util.cpp @@ -261,25 +261,38 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL { switch (target) { - case SLANG_TARGET_UNKNOWN: return Desc::make(Kind::Unknown, Payload::None, Style::Unknown, 0); - case SLANG_TARGET_NONE: return Desc::make(Kind::None, Payload::None, Style::Unknown, 0); + case SLANG_TARGET_UNKNOWN: + return Desc::make(Kind::Unknown, Payload::None, Style::Unknown, 0); + case SLANG_TARGET_NONE: + return Desc::make(Kind::None, Payload::None, Style::Unknown, 0); case SLANG_GLSL: { // For the moment we Desc::make all just map to GLSL, but we could use flags // or some other mechanism to distinguish the types return Desc::make(Kind::Source, Payload::GLSL, Style::Kernel, 0); } - case SLANG_HLSL: return Desc::make(Kind::Source, Payload::HLSL, Style::Kernel, 0); - case SLANG_SPIRV: return Desc::make(Kind::ObjectCode, Payload::SPIRV, Style::Kernel, 0); - case SLANG_SPIRV_ASM: return Desc::make(Kind::Assembly, Payload::SPIRV, Style::Kernel, 0); - case SLANG_DXBC: return Desc::make(Kind::ObjectCode, Payload::DXBC, Style::Kernel, 0); - case SLANG_DXBC_ASM: return Desc::make(Kind::Assembly, Payload::DXBC, Style::Kernel, 0); - case SLANG_DXIL: return Desc::make(Kind::ObjectCode, Payload::DXIL, Style::Kernel, 0); - case SLANG_DXIL_ASM: return Desc::make(Kind::Assembly, Payload::DXIL, Style::Kernel, 0); - case SLANG_C_SOURCE: return Desc::make(Kind::Source, Payload::C, Style::Kernel, 0); - case SLANG_CPP_SOURCE: return Desc::make(Kind::Source, Payload::Cpp, Style::Kernel, 0); - case SLANG_HOST_CPP_SOURCE: return Desc::make(Kind::Source, Payload::Cpp, Style::Host, 0); - case SLANG_CPP_PYTORCH_BINDING: return Desc::make(Kind::Source, Payload::Cpp, Style::Host, 0); + case SLANG_HLSL: + return Desc::make(Kind::Source, Payload::HLSL, Style::Kernel, 0); + case SLANG_SPIRV: + return Desc::make(Kind::ObjectCode, Payload::SPIRV, Style::Kernel, 0); + case SLANG_SPIRV_ASM: + return Desc::make(Kind::Assembly, Payload::SPIRV, Style::Kernel, 0); + case SLANG_DXBC: + return Desc::make(Kind::ObjectCode, Payload::DXBC, Style::Kernel, 0); + case SLANG_DXBC_ASM: + return Desc::make(Kind::Assembly, Payload::DXBC, Style::Kernel, 0); + case SLANG_DXIL: + return Desc::make(Kind::ObjectCode, Payload::DXIL, Style::Kernel, 0); + case SLANG_DXIL_ASM: + return Desc::make(Kind::Assembly, Payload::DXIL, Style::Kernel, 0); + case SLANG_C_SOURCE: + return Desc::make(Kind::Source, Payload::C, Style::Kernel, 0); + case SLANG_CPP_SOURCE: + return Desc::make(Kind::Source, Payload::Cpp, Style::Kernel, 0); + case SLANG_HOST_CPP_SOURCE: + return Desc::make(Kind::Source, Payload::Cpp, Style::Host, 0); + case SLANG_CPP_PYTORCH_BINDING: + return Desc::make(Kind::Source, Payload::Cpp, Style::Host, 0); case SLANG_HOST_EXECUTABLE: return Desc::make(Kind::Executable, Payload::HostCPU, Style::Host, 0); case SLANG_HOST_SHARED_LIBRARY: @@ -294,20 +307,26 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL // Not entirely clear how best to represent PTX here. We could mark as 'Assembly'. // Saying it is 'Executable' implies it is Binary (which PTX isn't). Executable also // implies 'complete for executation', irrespective of it being text. - case SLANG_PTX: return Desc::make(Kind::ObjectCode, Payload::PTX, Style::Kernel, 0); - case SLANG_OBJECT_CODE: return Desc::make(Kind::ObjectCode, Payload::HostCPU, Style::Kernel, 0); + case SLANG_PTX: + return Desc::make(Kind::ObjectCode, Payload::PTX, Style::Kernel, 0); + case SLANG_OBJECT_CODE: + return Desc::make(Kind::ObjectCode, Payload::HostCPU, Style::Kernel, 0); case SLANG_HOST_HOST_CALLABLE: return Desc::make(Kind::HostCallable, Payload::HostCPU, Style::Host, 0); - case SLANG_METAL: return Desc::make(Kind::Source, Payload::Metal, Style::Kernel, 0); - case SLANG_METAL_LIB: return Desc::make(Kind::ObjectCode, Payload::MetalAIR, Style::Kernel, 0); + case SLANG_METAL: + return Desc::make(Kind::Source, Payload::Metal, Style::Kernel, 0); + case SLANG_METAL_LIB: + return Desc::make(Kind::ObjectCode, Payload::MetalAIR, Style::Kernel, 0); case SLANG_METAL_LIB_ASM: return Desc::make(Kind::Assembly, Payload::MetalAIR, Style::Kernel, 0); - case SLANG_WGSL: return Desc::make(Kind::Source, Payload::WGSL, Style::Kernel, 0); + case SLANG_WGSL: + return Desc::make(Kind::Source, Payload::WGSL, Style::Kernel, 0); case SLANG_WGSL_SPIRV_ASM: return Desc::make(Kind::Assembly, Payload::WGSL_SPIRV, Style::Kernel, 0); case SLANG_WGSL_SPIRV: return Desc::make(Kind::ObjectCode, Payload::WGSL_SPIRV, Style::Kernel, 0); - default: break; + default: + break; } SLANG_UNEXPECTED("Unhandled type"); @@ -320,13 +339,20 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL switch (language) { default: - case SLANG_SOURCE_LANGUAGE_UNKNOWN: return Payload::Unknown; - case SLANG_SOURCE_LANGUAGE_SLANG: return Payload::Slang; - case SLANG_SOURCE_LANGUAGE_HLSL: return Payload::HLSL; - case SLANG_SOURCE_LANGUAGE_GLSL: return Payload::GLSL; - case SLANG_SOURCE_LANGUAGE_C: return Payload::C; - case SLANG_SOURCE_LANGUAGE_CPP: return Payload::Cpp; - case SLANG_SOURCE_LANGUAGE_CUDA: return Payload::CUDA; + case SLANG_SOURCE_LANGUAGE_UNKNOWN: + return Payload::Unknown; + case SLANG_SOURCE_LANGUAGE_SLANG: + return Payload::Slang; + case SLANG_SOURCE_LANGUAGE_HLSL: + return Payload::HLSL; + case SLANG_SOURCE_LANGUAGE_GLSL: + return Payload::GLSL; + case SLANG_SOURCE_LANGUAGE_C: + return Payload::C; + case SLANG_SOURCE_LANGUAGE_CPP: + return Payload::Cpp; + case SLANG_SOURCE_LANGUAGE_CUDA: + return Payload::CUDA; } } @@ -339,20 +365,28 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL { switch (desc.kind) { - case ArtifactKind::None: return SLANG_TARGET_NONE; + case ArtifactKind::None: + return SLANG_TARGET_NONE; case ArtifactKind::Source: { switch (desc.payload) { - case Payload::HLSL: return SLANG_HLSL; - case Payload::GLSL: return SLANG_GLSL; - case Payload::C: return SLANG_C_SOURCE; + case Payload::HLSL: + return SLANG_HLSL; + case Payload::GLSL: + return SLANG_GLSL; + case Payload::C: + return SLANG_C_SOURCE; case Payload::Cpp: return (desc.style == Style::Host) ? SLANG_HOST_CPP_SOURCE : SLANG_CPP_SOURCE; - case Payload::CUDA: return SLANG_CUDA_SOURCE; - case Payload::Metal: return SLANG_METAL; - case Payload::WGSL: return SLANG_WGSL; - default: break; + case Payload::CUDA: + return SLANG_CUDA_SOURCE; + case Payload::Metal: + return SLANG_METAL; + case Payload::WGSL: + return SLANG_WGSL; + default: + break; } break; } @@ -360,16 +394,24 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL { switch (desc.payload) { - case Payload::SPIRV: return SLANG_SPIRV_ASM; - case Payload::DXIL: return SLANG_DXIL_ASM; - case Payload::DXBC: return SLANG_DXBC_ASM; - case Payload::PTX: return SLANG_PTX; - case Payload::MetalAIR: return SLANG_METAL_LIB_ASM; - case Payload::WGSL_SPIRV: return SLANG_WGSL_SPIRV_ASM; - default: break; + case Payload::SPIRV: + return SLANG_SPIRV_ASM; + case Payload::DXIL: + return SLANG_DXIL_ASM; + case Payload::DXBC: + return SLANG_DXBC_ASM; + case Payload::PTX: + return SLANG_PTX; + case Payload::MetalAIR: + return SLANG_METAL_LIB_ASM; + case Payload::WGSL_SPIRV: + return SLANG_WGSL_SPIRV_ASM; + default: + break; } } - default: break; + default: + break; } if (isDerivedFrom(desc.kind, ArtifactKind::CompileBinary)) @@ -378,28 +420,38 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL { switch (desc.kind) { - case Kind::Executable: return SLANG_HOST_EXECUTABLE; + case Kind::Executable: + return SLANG_HOST_EXECUTABLE; case Kind::SharedLibrary: return desc.style == ArtifactStyle::Host ? SLANG_HOST_SHARED_LIBRARY : SLANG_SHADER_SHARED_LIBRARY; case Kind::HostCallable: return desc.style == ArtifactStyle::Host ? SLANG_HOST_HOST_CALLABLE : SLANG_SHADER_HOST_CALLABLE; - case Kind::ObjectCode: return SLANG_OBJECT_CODE; - default: break; + case Kind::ObjectCode: + return SLANG_OBJECT_CODE; + default: + break; } } else { switch (desc.payload) { - case Payload::SPIRV: return SLANG_SPIRV; - case Payload::DXIL: return SLANG_DXIL; - case Payload::DXBC: return SLANG_DXBC; - case Payload::PTX: return SLANG_PTX; - case Payload::MetalAIR: return SLANG_METAL_LIB_ASM; - case Payload::WGSL_SPIRV: return SLANG_WGSL_SPIRV; - default: break; + case Payload::SPIRV: + return SLANG_SPIRV; + case Payload::DXIL: + return SLANG_DXIL; + case Payload::DXBC: + return SLANG_DXBC; + case Payload::PTX: + return SLANG_PTX; + case Payload::MetalAIR: + return SLANG_METAL_LIB_ASM; + case Payload::WGSL_SPIRV: + return SLANG_WGSL_SPIRV; + default: + break; } } } @@ -483,7 +535,8 @@ static const KindExtension g_cpuKindExts[] = { { return true; } - default: break; + default: + break; } return false; } @@ -642,35 +695,52 @@ static UnownedStringSlice _getPayloadExtension(ArtifactPayload payload) switch (payload) { /* Source types */ - case Payload::HLSL: return toSlice("hlsl"); - case Payload::GLSL: return toSlice("glsl"); + case Payload::HLSL: + return toSlice("hlsl"); + case Payload::GLSL: + return toSlice("glsl"); - case Payload::Cpp: return toSlice("cpp"); - case Payload::C: return toSlice("c"); + case Payload::Cpp: + return toSlice("cpp"); + case Payload::C: + return toSlice("c"); - case Payload::Metal: return toSlice("metal"); + case Payload::Metal: + return toSlice("metal"); - case Payload::CUDA: return toSlice("cu"); + case Payload::CUDA: + return toSlice("cu"); - case Payload::Slang: return toSlice("slang"); + case Payload::Slang: + return toSlice("slang"); /* Binary types */ - case Payload::DXIL: return toSlice("dxil"); - case Payload::DXBC: return toSlice("dxbc"); - case Payload::SPIRV: return toSlice("spv"); + case Payload::DXIL: + return toSlice("dxil"); + case Payload::DXBC: + return toSlice("dxbc"); + case Payload::SPIRV: + return toSlice("spv"); - case Payload::PTX: return toSlice("ptx"); + case Payload::PTX: + return toSlice("ptx"); - case Payload::LLVMIR: return toSlice("llvm-ir"); + case Payload::LLVMIR: + return toSlice("llvm-ir"); - case Payload::SlangIR: return toSlice("slang-ir"); + case Payload::SlangIR: + return toSlice("slang-ir"); - case Payload::MetalAIR: return toSlice("metallib"); + case Payload::MetalAIR: + return toSlice("metallib"); - case Payload::PdbDebugInfo: return toSlice("pdb"); - case Payload::SourceMap: return toSlice("map"); + case Payload::PdbDebugInfo: + return toSlice("pdb"); + case Payload::SourceMap: + return toSlice("map"); - default: break; + default: + break; } return UnownedStringSlice(); } @@ -778,7 +848,8 @@ SlangResult ArtifactDescUtil::appendDefaultExtension(const ArtifactDesc& desc, S } break; } - default: break; + default: + break; } if (ArtifactDescUtil::isGpuUsable(desc)) diff --git a/source/compiler-core/slang-artifact-diagnostic-util.cpp b/source/compiler-core/slang-artifact-diagnostic-util.cpp index bf1f0474b..98f8f2245 100644 --- a/source/compiler-core/slang-artifact-diagnostic-util.cpp +++ b/source/compiler-core/slang-artifact-diagnostic-util.cpp @@ -13,10 +13,14 @@ namespace Slang { switch (severity) { - default: return UnownedStringSlice::fromLiteral("Unknown"); - case Severity::Info: return UnownedStringSlice::fromLiteral("Info"); - case Severity::Warning: return UnownedStringSlice::fromLiteral("Warning"); - case Severity::Error: return UnownedStringSlice::fromLiteral("Error"); + default: + return UnownedStringSlice::fromLiteral("Unknown"); + case Severity::Info: + return UnownedStringSlice::fromLiteral("Info"); + case Severity::Warning: + return UnownedStringSlice::fromLiteral("Warning"); + case Severity::Error: + return UnownedStringSlice::fromLiteral("Error"); } } diff --git a/source/compiler-core/slang-artifact-handler-impl.cpp b/source/compiler-core/slang-artifact-handler-impl.cpp index b19a9bd6e..571c45c7b 100644 --- a/source/compiler-core/slang-artifact-handler-impl.cpp +++ b/source/compiler-core/slang-artifact-handler-impl.cpp @@ -256,7 +256,8 @@ SlangResult DefaultArtifactHandler::_createOSFile( } break; } - default: break; + default: + break; } if (path.getLength()) diff --git a/source/compiler-core/slang-artifact-impl.cpp b/source/compiler-core/slang-artifact-impl.cpp index bb7584510..31c01f1de 100644 --- a/source/compiler-core/slang-artifact-impl.cpp +++ b/source/compiler-core/slang-artifact-impl.cpp @@ -138,10 +138,17 @@ void Artifact::clear(IArtifact::ContainedKind kind) { switch (kind) { - case ContainedKind::Associated: m_associated.clear(); break; - case ContainedKind::Representation: m_representations.clear(); break; - case ContainedKind::Children: m_children.clear(); break; - default: break; + case ContainedKind::Associated: + m_associated.clear(); + break; + case ContainedKind::Representation: + m_representations.clear(); + break; + case ContainedKind::Children: + m_children.clear(); + break; + default: + break; } } @@ -149,10 +156,17 @@ void Artifact::removeAt(ContainedKind kind, Index i) { switch (kind) { - case ContainedKind::Associated: m_associated.removeAt(i); break; - case ContainedKind::Representation: m_representations.removeAt(i); break; - case ContainedKind::Children: m_children.removeAt(i); break; - default: break; + case ContainedKind::Associated: + m_associated.removeAt(i); + break; + case ContainedKind::Representation: + m_representations.removeAt(i); + break; + case ContainedKind::Children: + m_children.removeAt(i); + break; + default: + break; } } @@ -217,7 +231,8 @@ void* Artifact::findRepresentation(ContainedKind kind, const Guid& guid) { switch (kind) { - case ContainedKind::Associated: return _findRepresentation(_getRawView(m_associated), guid); + case ContainedKind::Associated: + return _findRepresentation(_getRawView(m_associated), guid); case ContainedKind::Representation: return _findRepresentation(_getRawView(m_representations), guid); case ContainedKind::Children: diff --git a/source/compiler-core/slang-diagnostic-sink.cpp b/source/compiler-core/slang-diagnostic-sink.cpp index 537892f08..f9a7d9c88 100644 --- a/source/compiler-core/slang-diagnostic-sink.cpp +++ b/source/compiler-core/slang-diagnostic-sink.cpp @@ -102,7 +102,9 @@ static void formatDiagnosticMessage( switch (d) { // A double dollar sign `$$` is used to emit a single `$` - case '$': sb.append('$'); break; + case '$': + sb.append('$'); + break; // A single digit means to emit the corresponding argument. // TODO: support more than 10 arguments, and add options @@ -133,7 +135,9 @@ static void formatDiagnosticMessage( } break; - default: SLANG_INVALID_OPERATION("invalid diagnostic message format"); break; + default: + SLANG_INVALID_OPERATION("invalid diagnostic message format"); + break; } spanBegin = spanEnd; @@ -759,9 +763,12 @@ const DiagnosticInfo* DiagnosticsLookup::findDiagnosticByName(const UnownedStrin const auto convention = NameConventionUtil::inferConventionFromText(slice); switch (convention) { - case NameConvention::Invalid: return nullptr; - case NameConvention::LowerCamel: return findDiagnosticByExactName(slice); - default: break; + case NameConvention::Invalid: + return nullptr; + case NameConvention::LowerCamel: + return findDiagnosticByExactName(slice); + default: + break; } StringBuilder buf; diff --git a/source/compiler-core/slang-diagnostic-sink.h b/source/compiler-core/slang-diagnostic-sink.h index 9a4116855..90f1bfccf 100644 --- a/source/compiler-core/slang-diagnostic-sink.h +++ b/source/compiler-core/slang-diagnostic-sink.h @@ -36,13 +36,20 @@ inline const char* getSeverityName(Severity severity) { switch (severity) { - case Severity::Disable: return "ignored"; - case Severity::Note: return "note"; - case Severity::Warning: return "warning"; - case Severity::Error: return "error"; - case Severity::Fatal: return "fatal error"; - case Severity::Internal: return "internal error"; - default: return "unknown error"; + case Severity::Disable: + return "ignored"; + case Severity::Note: + return "note"; + case Severity::Warning: + return "warning"; + case Severity::Error: + return "error"; + case Severity::Fatal: + return "fatal error"; + case Severity::Internal: + return "internal error"; + default: + return "unknown error"; } } diff --git a/source/compiler-core/slang-doc-extractor.cpp b/source/compiler-core/slang-doc-extractor.cpp index d8a27822f..f2f4775fa 100644 --- a/source/compiler-core/slang-doc-extractor.cpp +++ b/source/compiler-core/slang-doc-extractor.cpp @@ -81,7 +81,8 @@ ranges. return comment.startsWith(UnownedStringSlice::fromLiteral("///<")) ? comment.tail(4) : comment; } - default: break; + default: + break; } return comment; } @@ -121,18 +122,28 @@ static Index _findTokenIndex(SourceLoc loc, const Token* toks, Index numToks) switch (type) { default: - case MarkupType::None: return 0; - case MarkupType::BlockBefore: return MarkupFlag::Before | MarkupFlag::IsBlock; - case MarkupType::BlockAfter: return MarkupFlag::After | MarkupFlag::IsBlock; - case MarkupType::OrdinaryBlockBefore: return MarkupFlag::Before | MarkupFlag::IsBlock; - - case MarkupType::LineBangBefore: return MarkupFlag::Before | MarkupFlag::IsMultiToken; - case MarkupType::LineSlashBefore: return MarkupFlag::Before | MarkupFlag::IsMultiToken; - case MarkupType::OrdinaryLineBefore: return MarkupFlag::Before | MarkupFlag::IsMultiToken; - - case MarkupType::LineBangAfter: return MarkupFlag::After | MarkupFlag::IsMultiToken; - case MarkupType::LineSlashAfter: return MarkupFlag::After | MarkupFlag::IsMultiToken; - case MarkupType::OrdinaryLineAfter: return MarkupFlag::After | MarkupFlag::IsMultiToken; + case MarkupType::None: + return 0; + case MarkupType::BlockBefore: + return MarkupFlag::Before | MarkupFlag::IsBlock; + case MarkupType::BlockAfter: + return MarkupFlag::After | MarkupFlag::IsBlock; + case MarkupType::OrdinaryBlockBefore: + return MarkupFlag::Before | MarkupFlag::IsBlock; + + case MarkupType::LineBangBefore: + return MarkupFlag::Before | MarkupFlag::IsMultiToken; + case MarkupType::LineSlashBefore: + return MarkupFlag::Before | MarkupFlag::IsMultiToken; + case MarkupType::OrdinaryLineBefore: + return MarkupFlag::Before | MarkupFlag::IsMultiToken; + + case MarkupType::LineBangAfter: + return MarkupFlag::After | MarkupFlag::IsMultiToken; + case MarkupType::LineSlashAfter: + return MarkupFlag::After | MarkupFlag::IsMultiToken; + case MarkupType::OrdinaryLineAfter: + return MarkupFlag::After | MarkupFlag::IsMultiToken; } } @@ -175,7 +186,8 @@ static Index _findTokenIndex(SourceLoc loc, const Token* toks, Index numToks) : MarkupType::OrdinaryLineAfter; break; } - default: break; + default: + break; } return MarkupType::None; } @@ -346,7 +358,8 @@ SlangResult DocMarkupExtractor::_extractMarkup( break; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } return SLANG_OK; @@ -475,7 +488,8 @@ Index DocMarkupExtractor::_findStartIndex(const FindInfo& info, Location locatio } break; } - default: break; + default: + break; } } diff --git a/source/compiler-core/slang-downstream-compiler-util.cpp b/source/compiler-core/slang-downstream-compiler-util.cpp index 1ab35d4fe..68fc241b9 100644 --- a/source/compiler-core/slang-downstream-compiler-util.cpp +++ b/source/compiler-core/slang-downstream-compiler-util.cpp @@ -336,7 +336,8 @@ DownstreamCompilerMatchVersion DownstreamCompilerUtil::getCompiledVersion() compiler = findCompiler(set, MatchType::Newest, desc); break; } - default: break; + default: + break; } set->setDefaultCompiler(sourceLanguage, compiler); diff --git a/source/compiler-core/slang-dxc-compiler.cpp b/source/compiler-core/slang-dxc-compiler.cpp index b694c4cf6..cfc4771e6 100644 --- a/source/compiler-core/slang-dxc-compiler.cpp +++ b/source/compiler-core/slang-dxc-compiler.cpp @@ -488,14 +488,18 @@ SlangResult DXCDownstreamCompiler::compile(const CompileOptions& inOptions, IArt switch (options.matrixLayout) { - default: break; + default: + break; - case SLANG_MATRIX_LAYOUT_ROW_MAJOR: args.add(L"-Zpr"); break; + case SLANG_MATRIX_LAYOUT_ROW_MAJOR: + args.add(L"-Zpr"); + break; } switch (options.floatingPointMode) { - default: break; + default: + break; case FloatingPointMode::Precise: args.add(L"-Gis"); // "force IEEE strictness" @@ -505,19 +509,31 @@ SlangResult DXCDownstreamCompiler::compile(const CompileOptions& inOptions, IArt switch (options.optimizationLevel) { - default: break; + default: + break; - case OptimizationLevel::None: args.add(L"-Od"); break; - case OptimizationLevel::Default: args.add(L"-O1"); break; - case OptimizationLevel::High: args.add(L"-O2"); break; - case OptimizationLevel::Maximal: args.add(L"-O3"); break; + case OptimizationLevel::None: + args.add(L"-Od"); + break; + case OptimizationLevel::Default: + args.add(L"-O1"); + break; + case OptimizationLevel::High: + args.add(L"-O2"); + break; + case OptimizationLevel::Maximal: + args.add(L"-O3"); + break; } switch (options.debugInfoType) { - case DebugInfoType::None: break; + case DebugInfoType::None: + break; - default: args.add(L"-Zi"); break; + default: + args.add(L"-Zi"); + break; } // Slang strives to produce correct code, and by default diff --git a/source/compiler-core/slang-fxc-compiler.cpp b/source/compiler-core/slang-fxc-compiler.cpp index 0c571c10b..c42516399 100644 --- a/source/compiler-core/slang-fxc-compiler.cpp +++ b/source/compiler-core/slang-fxc-compiler.cpp @@ -265,9 +265,12 @@ SlangResult FXCDownstreamCompiler::compile(const CompileOptions& inOptions, IArt switch (options.floatingPointMode) { - default: break; + default: + break; - case FloatingPointMode::Precise: flags |= D3DCOMPILE_IEEE_STRICTNESS; break; + case FloatingPointMode::Precise: + flags |= D3DCOMPILE_IEEE_STRICTNESS; + break; } flags |= D3DCOMPILE_ENABLE_STRICTNESS; @@ -275,19 +278,31 @@ SlangResult FXCDownstreamCompiler::compile(const CompileOptions& inOptions, IArt switch (options.optimizationLevel) { - default: break; - - case OptimizationLevel::None: flags |= D3DCOMPILE_OPTIMIZATION_LEVEL0; break; - case OptimizationLevel::Default: flags |= D3DCOMPILE_OPTIMIZATION_LEVEL1; break; - case OptimizationLevel::High: flags |= D3DCOMPILE_OPTIMIZATION_LEVEL2; break; - case OptimizationLevel::Maximal: flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3; break; + default: + break; + + case OptimizationLevel::None: + flags |= D3DCOMPILE_OPTIMIZATION_LEVEL0; + break; + case OptimizationLevel::Default: + flags |= D3DCOMPILE_OPTIMIZATION_LEVEL1; + break; + case OptimizationLevel::High: + flags |= D3DCOMPILE_OPTIMIZATION_LEVEL2; + break; + case OptimizationLevel::Maximal: + flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3; + break; } switch (options.debugInfoType) { - case DebugInfoType::None: break; + case DebugInfoType::None: + break; - default: flags |= D3DCOMPILE_DEBUG; break; + default: + flags |= D3DCOMPILE_DEBUG; + break; } ComPtr<ISlangBlob> sourceBlob; diff --git a/source/compiler-core/slang-gcc-compiler-util.cpp b/source/compiler-core/slang-gcc-compiler-util.cpp index 67ee6f8b3..f12f44338 100644 --- a/source/compiler-core/slang-gcc-compiler-util.cpp +++ b/source/compiler-core/slang-gcc-compiler-util.cpp @@ -438,7 +438,8 @@ static SlangResult _parseGCCFamilyLine( prevLineResult = lineRes; break; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } } @@ -553,7 +554,8 @@ static SlangResult _parseGCCFamilyLine( cmdLine.addArg("-O4"); break; } - default: break; + default: + break; } if (options.debugInfoType != DebugInfoType::None) @@ -568,7 +570,8 @@ static SlangResult _parseGCCFamilyLine( switch (options.floatingPointMode) { - case FloatingPointMode::Default: break; + case FloatingPointMode::Default: + break; case FloatingPointMode::Precise: { // cmdLine.addArg("-fno-unsafe-math-optimizations"); @@ -619,7 +622,8 @@ static SlangResult _parseGCCFamilyLine( cmdLine.addArg("-c"); break; } - default: break; + default: + break; } // Add defines diff --git a/source/compiler-core/slang-glslang-compiler.cpp b/source/compiler-core/slang-glslang-compiler.cpp index fd80c7581..5550ac8ad 100644 --- a/source/compiler-core/slang-glslang-compiler.cpp +++ b/source/compiler-core/slang-glslang-compiler.cpp @@ -208,9 +208,15 @@ SlangResult GlslangDownstreamCompiler::compile( switch (options.sourceLanguage) { - case SLANG_SOURCE_LANGUAGE_GLSL: request.action = GLSLANG_ACTION_COMPILE_GLSL_TO_SPIRV; break; - case SLANG_SOURCE_LANGUAGE_SPIRV: request.action = GLSLANG_ACTION_OPTIMIZE_SPIRV; break; - default: SLANG_ASSERT(!"Can only handle GLSL or SPIR-V as input."); return SLANG_FAIL; + case SLANG_SOURCE_LANGUAGE_GLSL: + request.action = GLSLANG_ACTION_COMPILE_GLSL_TO_SPIRV; + break; + case SLANG_SOURCE_LANGUAGE_SPIRV: + request.action = GLSLANG_ACTION_OPTIMIZE_SPIRV; + break; + default: + SLANG_ASSERT(!"Can only handle GLSL or SPIR-V as input."); + return SLANG_FAIL; } request.sourcePath = sourcePath.getBuffer(); diff --git a/source/compiler-core/slang-json-lexer.cpp b/source/compiler-core/slang-json-lexer.cpp index 84b6b24bc..7f1499a21 100644 --- a/source/compiler-core/slang-json-lexer.cpp +++ b/source/compiler-core/slang-json-lexer.cpp @@ -147,7 +147,8 @@ JSONTokenType JSONLexer::advance() switch (c) { - case 0: return _setToken(JSONTokenType::EndOfFile, cursor - 1); + case 0: + return _setToken(JSONTokenType::EndOfFile, cursor - 1); case '"': { cursor = _lexString(cursor); @@ -190,12 +191,18 @@ JSONTokenType JSONLexer::advance() cursor = _lexWhitespace(cursor); break; } - case ':': return _setToken(JSONTokenType::Colon, cursor); - case ',': return _setToken(JSONTokenType::Comma, cursor); - case '[': return _setToken(JSONTokenType::LBracket, cursor); - case ']': return _setToken(JSONTokenType::RBracket, cursor); - case '{': return _setToken(JSONTokenType::LBrace, cursor); - case '}': return _setToken(JSONTokenType::RBrace, cursor); + case ':': + return _setToken(JSONTokenType::Colon, cursor); + case ',': + return _setToken(JSONTokenType::Comma, cursor); + case '[': + return _setToken(JSONTokenType::LBracket, cursor); + case ']': + return _setToken(JSONTokenType::RBracket, cursor); + case '{': + return _setToken(JSONTokenType::LBrace, cursor); + case '}': + return _setToken(JSONTokenType::RBrace, cursor); case '-': case '0': @@ -398,7 +405,8 @@ const char* JSONLexer::_lexString(const char* cursor) } } // Somewhat surprisingly it appears it's valid to have \r\n inside of quotes. - default: break; + default: + break; } } } @@ -445,7 +453,8 @@ const char* JSONLexer::_lexBlockComment(const char* cursor) } break; } - default: break; + default: + break; } } } @@ -481,21 +490,36 @@ UnownedStringSlice getJSONTokenAsText(JSONTokenType type) { switch (type) { - case JSONTokenType::Invalid: return UnownedStringSlice::fromLiteral("invalid"); - case JSONTokenType::IntegerLiteral: return UnownedStringSlice::fromLiteral("integer literal"); - case JSONTokenType::FloatLiteral: return UnownedStringSlice::fromLiteral("float literal"); - case JSONTokenType::StringLiteral: return UnownedStringSlice::fromLiteral("string literal"); - case JSONTokenType::LBracket: return UnownedStringSlice::fromLiteral("["); - case JSONTokenType::RBracket: return UnownedStringSlice::fromLiteral("]"); - case JSONTokenType::LBrace: return UnownedStringSlice::fromLiteral("{"); - case JSONTokenType::RBrace: return UnownedStringSlice::fromLiteral("}"); - case JSONTokenType::Comma: return UnownedStringSlice::fromLiteral(","); - case JSONTokenType::Colon: return UnownedStringSlice::fromLiteral(":"); - case JSONTokenType::True: return UnownedStringSlice::fromLiteral("true"); - case JSONTokenType::False: return UnownedStringSlice::fromLiteral("false"); - case JSONTokenType::Null: return UnownedStringSlice::fromLiteral("null"); - case JSONTokenType::EndOfFile: return UnownedStringSlice::fromLiteral("end of file"); - default: break; + case JSONTokenType::Invalid: + return UnownedStringSlice::fromLiteral("invalid"); + case JSONTokenType::IntegerLiteral: + return UnownedStringSlice::fromLiteral("integer literal"); + case JSONTokenType::FloatLiteral: + return UnownedStringSlice::fromLiteral("float literal"); + case JSONTokenType::StringLiteral: + return UnownedStringSlice::fromLiteral("string literal"); + case JSONTokenType::LBracket: + return UnownedStringSlice::fromLiteral("["); + case JSONTokenType::RBracket: + return UnownedStringSlice::fromLiteral("]"); + case JSONTokenType::LBrace: + return UnownedStringSlice::fromLiteral("{"); + case JSONTokenType::RBrace: + return UnownedStringSlice::fromLiteral("}"); + case JSONTokenType::Comma: + return UnownedStringSlice::fromLiteral(","); + case JSONTokenType::Colon: + return UnownedStringSlice::fromLiteral(":"); + case JSONTokenType::True: + return UnownedStringSlice::fromLiteral("true"); + case JSONTokenType::False: + return UnownedStringSlice::fromLiteral("false"); + case JSONTokenType::Null: + return UnownedStringSlice::fromLiteral("null"); + case JSONTokenType::EndOfFile: + return UnownedStringSlice::fromLiteral("end of file"); + default: + break; } SLANG_UNEXPECTED("JSONTokenType not known"); } diff --git a/source/compiler-core/slang-json-native.cpp b/source/compiler-core/slang-json-native.cpp index e4b425801..1f9a4dbc6 100644 --- a/source/compiler-core/slang-json-native.cpp +++ b/source/compiler-core/slang-json-native.cpp @@ -285,7 +285,8 @@ SlangResult JSONToNativeConverter::convert(const JSONValue& in, const RttiInfo* } return SLANG_FAIL; } - default: break; + default: + break; } return SLANG_FAIL; } @@ -408,7 +409,8 @@ SlangResult NativeToJSONConverter::convert(const RttiInfo* rttiInfo, const void* switch (rttiInfo->m_kind) { - case RttiInfo::Kind::Invalid: return SLANG_FAIL; + case RttiInfo::Kind::Invalid: + return SLANG_FAIL; case RttiInfo::Kind::Bool: { out = JSONValue::makeBool(RttiUtil::asBool(rttiInfo, in)); @@ -512,7 +514,8 @@ SlangResult NativeToJSONConverter::convert(const RttiInfo* rttiInfo, const void* } break; } - default: break; + default: + break; } return SLANG_E_NOT_IMPLEMENTED; diff --git a/source/compiler-core/slang-json-parser.h b/source/compiler-core/slang-json-parser.h index d226e7fb9..89be90d81 100644 --- a/source/compiler-core/slang-json-parser.h +++ b/source/compiler-core/slang-json-parser.h @@ -155,10 +155,14 @@ protected: { switch (m_kind) { - case Kind::Root: return (m_flags & Flag::HasPrevious) == 0; - case Kind::Array: return true; - case Kind::Object: return (m_flags & Flag::HasKey) != 0; - default: return false; + case Kind::Root: + return (m_flags & Flag::HasPrevious) == 0; + case Kind::Array: + return true; + case Kind::Object: + return (m_flags & Flag::HasKey) != 0; + default: + return false; } } diff --git a/source/compiler-core/slang-json-value.cpp b/source/compiler-core/slang-json-value.cpp index 2738058ee..ae38bd086 100644 --- a/source/compiler-core/slang-json-value.cpp +++ b/source/compiler-core/slang-json-value.cpp @@ -66,15 +66,19 @@ bool JSONValue::asBool() const { switch (type) { - case JSONValue::Type::True: return true; + case JSONValue::Type::True: + return true; case JSONValue::Type::False: case JSONValue::Type::Null: { return false; } - case JSONValue::Type::IntegerValue: return intValue != 0; - case JSONValue::Type::FloatValue: return floatValue != 0; - default: break; + case JSONValue::Type::IntegerValue: + return intValue != 0; + case JSONValue::Type::FloatValue: + return floatValue != 0; + default: + break; } if (isLexeme(type)) @@ -93,14 +97,18 @@ int64_t JSONValue::asInteger() const { switch (type) { - case JSONValue::Type::True: return 1; + case JSONValue::Type::True: + return 1; case JSONValue::Type::False: case JSONValue::Type::Null: { return 0; } - case JSONValue::Type::IntegerValue: return intValue; - case JSONValue::Type::FloatValue: return int64_t(floatValue); break; + case JSONValue::Type::IntegerValue: + return intValue; + case JSONValue::Type::FloatValue: + return int64_t(floatValue); + break; } if (isLexeme(type)) @@ -119,15 +127,19 @@ double JSONValue::asFloat() const { switch (type) { - case JSONValue::Type::True: return 1.0; + case JSONValue::Type::True: + return 1.0; case JSONValue::Type::False: case JSONValue::Type::Null: { return 0.0; } - case JSONValue::Type::IntegerValue: return double(intValue); - case JSONValue::Type::FloatValue: return floatValue; - default: break; + case JSONValue::Type::IntegerValue: + return double(intValue); + case JSONValue::Type::FloatValue: + return floatValue; + default: + break; } if (isLexeme(type)) @@ -261,8 +273,10 @@ bool PersistentJSONValue::operator==(const ThisType& rhs) const // The type is all that needs to be checked return true; } - case Type::IntegerValue: return intValue == rhs.intValue; - case Type::FloatValue: return floatValue == rhs.floatValue; + case Type::IntegerValue: + return intValue == rhs.intValue; + case Type::FloatValue: + return floatValue == rhs.floatValue; case Type::StringRepresentation: { if (stringRep == rhs.stringRep) @@ -273,7 +287,8 @@ bool PersistentJSONValue::operator==(const ThisType& rhs) const auto rhsSlice = StringRepresentation::asSlice(rhs.stringRep); return thisSlice == rhsSlice; } - default: break; + default: + break; } SLANG_ASSERT(!"Not valid Persistent type"); @@ -577,7 +592,8 @@ UnownedStringSlice JSONContainer::getString(const JSONValue& in) { return UnownedStringSlice(); } - default: break; + default: + break; } SLANG_ASSERT(!"Not a string type"); @@ -635,9 +651,12 @@ bool JSONContainer::asBool(const JSONValue& value) { switch (value.type) { - case JSONValue::Type::IntegerLexeme: return asInteger(value) != 0; - case JSONValue::Type::FloatLexeme: return asFloat(value) != 0.0; - default: return value.asBool(); + case JSONValue::Type::IntegerLexeme: + return asInteger(value) != 0; + case JSONValue::Type::FloatLexeme: + return asFloat(value) != 0.0; + default: + return value.asBool(); } } @@ -665,7 +684,8 @@ JSONValue JSONContainer::asValue(const JSONValue& inValue) value.type = JSONValue::Type::FloatValue; break; } - default: break; + default: + break; } return value; @@ -711,7 +731,8 @@ void JSONContainer::clearSourceManagerDependency(JSONValue* ioValues, Index valu } break; } - default: break; + default: + break; } } @@ -734,8 +755,10 @@ int64_t JSONContainer::asInteger(const JSONValue& value) SLANG_ASSERT(!"Couldn't convert int"); return 0; } - case JSONValue::Type::FloatLexeme: return int64_t(asFloat(value)); - default: return value.asInteger(); + case JSONValue::Type::FloatLexeme: + return int64_t(asFloat(value)); + default: + return value.asInteger(); } } @@ -743,7 +766,8 @@ double JSONContainer::asFloat(const JSONValue& value) { switch (value.type) { - case JSONValue::Type::IntegerLexeme: return double(asInteger(value)); + case JSONValue::Type::IntegerLexeme: + return double(asInteger(value)); case JSONValue::Type::FloatLexeme: { UnownedStringSlice slice = getLexeme(value); @@ -755,7 +779,8 @@ double JSONContainer::asFloat(const JSONValue& value) SLANG_ASSERT(!"Couldn't convert double"); return 0.0; } - default: return value.asFloat(); + default: + return value.asFloat(); } } @@ -963,7 +988,8 @@ void JSONContainer::_destroyRange(Index rangeIndex) } break; } - default: break; + default: + break; } range.type = Range::Type::Destroyed; @@ -1148,15 +1174,18 @@ bool JSONContainer::areEqual(const JSONValue& a, const JSONValue& b) { default: // Invalid are never equal - case JSONValue::Type::Invalid: return false; + case JSONValue::Type::Invalid: + return false; case JSONValue::Type::True: case JSONValue::Type::False: case JSONValue::Type::Null: { return true; } - case JSONValue::Type::IntegerLexeme: return asInteger(a) == asInteger(b); - case JSONValue::Type::FloatLexeme: return asFloat(a) == asFloat(b); + case JSONValue::Type::IntegerLexeme: + return asInteger(a) == asInteger(b); + case JSONValue::Type::FloatLexeme: + return asFloat(a) == asFloat(b); case JSONValue::Type::StringLexeme: { // If the lexemes are equal they are equal @@ -1165,9 +1194,12 @@ bool JSONContainer::areEqual(const JSONValue& a, const JSONValue& b) // Else we want to decode the string to be sure if they are equal. return lexemeA == lexemeB || getStringKey(a) == getStringKey(b); } - case JSONValue::Type::IntegerValue: return a.intValue == b.intValue; - case JSONValue::Type::FloatValue: return a.floatValue == b.floatValue; - case JSONValue::Type::StringValue: return a.stringKey == b.stringKey; + case JSONValue::Type::IntegerValue: + return a.intValue == b.intValue; + case JSONValue::Type::FloatValue: + return a.floatValue == b.floatValue; + case JSONValue::Type::StringValue: + return a.stringKey == b.stringKey; case JSONValue::Type::StringRepresentation: { return a.stringRep == b.stringRep || StringRepresentation::asSlice(a.stringRep) == @@ -1208,10 +1240,14 @@ bool JSONContainer::areEqual(const JSONValue& a, const JSONValue& b) { switch (kind) { - case JSONValue::Kind::String: return getStringKey(a) == getStringKey(b); - case JSONValue::Kind::Integer: return asInteger(a) == asInteger(b); - case JSONValue::Kind::Float: return asFloat(a) == asFloat(b); - default: break; + case JSONValue::Kind::String: + return getStringKey(a) == getStringKey(b); + case JSONValue::Kind::Integer: + return asInteger(a) == asInteger(b); + case JSONValue::Kind::Float: + return asFloat(a) == asFloat(b); + default: + break; } } @@ -1224,9 +1260,12 @@ void JSONContainer::traverseRecursively(const JSONValue& value, JSONListener* li switch (value.type) { - case Type::True: return listener->addBoolValue(true, value.loc); - case Type::False: return listener->addBoolValue(false, value.loc); - case Type::Null: return listener->addNullValue(value.loc); + case Type::True: + return listener->addBoolValue(true, value.loc); + case Type::False: + return listener->addBoolValue(false, value.loc); + case Type::Null: + return listener->addNullValue(value.loc); case Type::StringLexeme: return listener->addLexemeValue(JSONTokenType::StringLiteral, getLexeme(value), value.loc); @@ -1235,8 +1274,10 @@ void JSONContainer::traverseRecursively(const JSONValue& value, JSONListener* li case Type::FloatLexeme: return listener->addLexemeValue(JSONTokenType::FloatLiteral, getLexeme(value), value.loc); - case Type::IntegerValue: return listener->addIntegerValue(value.intValue, value.loc); - case Type::FloatValue: return listener->addFloatValue(value.floatValue, value.loc); + case Type::IntegerValue: + return listener->addIntegerValue(value.intValue, value.loc); + case Type::FloatValue: + return listener->addFloatValue(value.floatValue, value.loc); case Type::StringValue: { const auto slice = getStringFromKey(value.stringKey); @@ -1471,9 +1512,12 @@ void JSONBuilder::addLexemeValue(JSONTokenType type, const UnownedStringSlice& v { switch (type) { - case JSONTokenType::True: return _add(JSONValue::makeBool(true, loc)); - case JSONTokenType::False: return _add(JSONValue::makeBool(false, loc)); - case JSONTokenType::Null: return _add(JSONValue::makeNull(loc)); + case JSONTokenType::True: + return _add(JSONValue::makeBool(true, loc)); + case JSONTokenType::False: + return _add(JSONValue::makeBool(false, loc)); + case JSONTokenType::Null: + return _add(JSONValue::makeNull(loc)); case JSONTokenType::IntegerLiteral: { diff --git a/source/compiler-core/slang-lexer.cpp b/source/compiler-core/slang-lexer.cpp index df95f5f1e..bf109e7fb 100644 --- a/source/compiler-core/slang-lexer.cpp +++ b/source/compiler-core/slang-lexer.cpp @@ -206,7 +206,8 @@ static int _peek(Lexer* lexer, int offset = 0) c = e; continue; } - default: break; + default: + break; } // Only continue this while loop in the case where we consumed @@ -261,7 +262,8 @@ static int _advance(Lexer* lexer) // escaped newline. continue; - default: break; + default: + break; } } @@ -291,9 +293,12 @@ static void _lexLineComment(Lexer* lexer) { case '\n': case '\r': - case kEOF: return; + case kEOF: + return; - default: _advance(lexer); continue; + default: + _advance(lexer); + continue; } } } @@ -309,18 +314,25 @@ static void _lexBlockComment(Lexer* lexer) return; case '\n': - case '\r': _handleNewLine(lexer); continue; + case '\r': + _handleNewLine(lexer); + continue; case '*': _advance(lexer); switch (_peek(lexer)) { - case '/': _advance(lexer); return; + case '/': + _advance(lexer); + return; - default: continue; + default: + continue; } - default: _advance(lexer); continue; + default: + _advance(lexer); + continue; } } } @@ -332,9 +344,12 @@ static void _lexHorizontalSpace(Lexer* lexer) switch (_peek(lexer)) { case ' ': - case '\t': _advance(lexer); continue; + case '\t': + _advance(lexer); + continue; - default: return; + default: + return; } } } @@ -382,7 +397,9 @@ static void _lexDigits(Lexer* lexer, int base) case '6': case '7': case '8': - case '9': digitVal = c - '0'; break; + case '9': + digitVal = c - '0'; + break; case 'a': case 'b': @@ -456,7 +473,8 @@ static bool _isNumberExponent(int c, int base) { switch (c) { - default: return false; + default: + return false; case 'e': case 'E': @@ -502,7 +520,9 @@ static bool _maybeLexNumberExponent(Lexer* lexer, int base) switch (_peek(lexer)) { case '+': - case '-': _advance(lexer); break; + case '-': + _advance(lexer); + break; } // TODO(tfoley): it would be an error to not see digits here... @@ -535,7 +555,8 @@ static TokenType _lexNumber(Lexer* lexer, int base) { // 123.xxxx or 123.rrrr case 'x': - case 'r': break; + case 'r': + break; default: tokenType = TokenType::FloatingPointLiteral; @@ -563,10 +584,13 @@ static int _maybeReadDigit(char const** ioCursor, int base) int c = *cursor; switch (c) { - default: return -1; + default: + return -1; // TODO: need to decide on digit separator characters - case '_': cursor++; continue; + case '_': + cursor++; + continue; case '0': case '1': @@ -577,7 +601,9 @@ static int _maybeReadDigit(char const** ioCursor, int base) case '6': case '7': case '8': - case '9': cursor++; return c - '0'; + case '9': + cursor++; + return c - '0'; case 'a': case 'b': @@ -617,10 +643,14 @@ static int _readOptionalBase(char const** ioCursor) switch (*cursor) { case 'x': - case 'X': cursor++; return 16; + case 'X': + cursor++; + return 16; case 'b': - case 'B': cursor++; return 2; + case 'B': + cursor++; + return 2; case '0': case '1': @@ -631,9 +661,11 @@ static int _readOptionalBase(char const** ioCursor) case '6': case '7': case '8': - case '9': return 8; + case '9': + return 8; - default: return 10; + default: + return 10; } } @@ -731,14 +763,17 @@ FloatingPointLiteralValue getFloatingPointLiteralValue( bool exponentIsNegative = false; switch (*cursor) { - default: break; + default: + break; case '-': exponentIsNegative = true; cursor++; break; - case '+': cursor++; break; + case '+': + cursor++; + break; } int exponentRadix = 10; @@ -824,7 +859,9 @@ static void _lexStringLiteralBody(Lexer* lexer, char quote) case 'n': case 'r': case 't': - case 'v': _advance(lexer); break; + case 'v': + _advance(lexer); + break; case '0': case '1': @@ -874,7 +911,9 @@ static void _lexStringLiteralBody(Lexer* lexer, char quote) } break; - default: _advance(lexer); continue; + default: + _advance(lexer); + continue; } } } @@ -921,7 +960,9 @@ static void _lexRawStringLiteralBody(Lexer* lexer) sink->diagnose(_getSourceLoc(lexer), LexerDiagnostics::endOfFileInLiteral); } return; - default: _advance(lexer); continue; + default: + _advance(lexer); + continue; } } } @@ -992,16 +1033,32 @@ String getStringLiteralTokenValue(Token const& token) case '\'': case '\"': case '\\': - case '?': valueBuilder.append(d); continue; + case '?': + valueBuilder.append(d); + continue; // Traditional escape sequences for special characters - case 'a': valueBuilder.append('\a'); continue; - case 'b': valueBuilder.append('\b'); continue; - case 'f': valueBuilder.append('\f'); continue; - case 'n': valueBuilder.append('\n'); continue; - case 'r': valueBuilder.append('\r'); continue; - case 't': valueBuilder.append('\t'); continue; - case 'v': valueBuilder.append('\v'); continue; + case 'a': + valueBuilder.append('\a'); + continue; + case 'b': + valueBuilder.append('\b'); + continue; + case 'f': + valueBuilder.append('\f'); + continue; + case 'n': + valueBuilder.append('\n'); + continue; + case 'r': + valueBuilder.append('\r'); + continue; + case 't': + valueBuilder.append('\t'); + continue; + case 'v': + valueBuilder.append('\v'); + continue; // Octal escape: up to 3 characters case '0': @@ -1093,15 +1150,21 @@ static TokenType _lexTokenImpl(Lexer* lexer) int nextCodePoint = _peek(lexer); switch (nextCodePoint) { - default: break; + default: + break; - case kEOF: return TokenType::EndOfFile; + case kEOF: + return TokenType::EndOfFile; case '\r': - case '\n': _handleNewLine(lexer); return TokenType::NewLine; + case '\n': + _handleNewLine(lexer); + return TokenType::NewLine; case ' ': - case '\t': _lexHorizontalSpace(lexer); return TokenType::WhiteSpace; + case '\t': + _lexHorizontalSpace(lexer); + return TokenType::WhiteSpace; case '.': _advance(lexer); @@ -1116,7 +1179,8 @@ static TokenType _lexTokenImpl(Lexer* lexer) case '6': case '7': case '8': - case '9': return _lexNumberAfterDecimalPoint(lexer, 10); + case '9': + return _lexNumberAfterDecimalPoint(lexer, 10); case '.': // Note: consuming the second `.` here means that @@ -1128,12 +1192,16 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); switch (_peek(lexer)) { - case '.': _advance(lexer); return TokenType::Ellipsis; + case '.': + _advance(lexer); + return TokenType::Ellipsis; - default: return TokenType::DotDot; + default: + return TokenType::DotDot; } - default: return TokenType::Dot; + default: + return TokenType::Dot; } case '1': @@ -1144,7 +1212,8 @@ static TokenType _lexTokenImpl(Lexer* lexer) case '6': case '7': case '8': - case '9': return _lexNumber(lexer, 10); + case '9': + return _lexNumber(lexer, 10); case '0': { @@ -1152,22 +1221,30 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); switch (_peek(lexer)) { - default: return _maybeLexNumberSuffix(lexer, TokenType::IntegerLiteral); + default: + return _maybeLexNumberSuffix(lexer, TokenType::IntegerLiteral); case '.': switch (_peek(lexer, 1)) { // 0.xxxx or 0.rrrr case 'x': - case 'r': return _maybeLexNumberSuffix(lexer, TokenType::IntegerLiteral); - default: _advance(lexer); return _lexNumberAfterDecimalPoint(lexer, 10); + case 'r': + return _maybeLexNumberSuffix(lexer, TokenType::IntegerLiteral); + default: + _advance(lexer); + return _lexNumberAfterDecimalPoint(lexer, 10); } case 'x': - case 'X': _advance(lexer); return _lexNumber(lexer, 16); + case 'X': + _advance(lexer); + return _lexNumber(lexer, 16); case 'b': - case 'B': _advance(lexer); return _lexNumber(lexer, 2); + case 'B': + _advance(lexer); + return _lexNumber(lexer, 2); case '0': case '1': @@ -1238,12 +1315,16 @@ static TokenType _lexTokenImpl(Lexer* lexer) case 'X': case 'Y': case 'Z': - case '_': _lexIdentifier(lexer); return TokenType::Identifier; + case '_': + _lexIdentifier(lexer); + return TokenType::Identifier; case 'R': _advance(lexer); switch (_peek(lexer)) { - default: _lexIdentifier(lexer); return TokenType::Identifier; + default: + _lexIdentifier(lexer); + return TokenType::Identifier; case '\"': _advance(lexer); _lexRawStringLiteralBody(lexer); @@ -1265,34 +1346,51 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); switch (_peek(lexer)) { - case '+': _advance(lexer); return TokenType::OpInc; - case '=': _advance(lexer); return TokenType::OpAddAssign; - default: return TokenType::OpAdd; + case '+': + _advance(lexer); + return TokenType::OpInc; + case '=': + _advance(lexer); + return TokenType::OpAddAssign; + default: + return TokenType::OpAdd; } case '-': _advance(lexer); switch (_peek(lexer)) { - case '-': _advance(lexer); return TokenType::OpDec; - case '=': _advance(lexer); return TokenType::OpSubAssign; - case '>': _advance(lexer); return TokenType::RightArrow; - default: return TokenType::OpSub; + case '-': + _advance(lexer); + return TokenType::OpDec; + case '=': + _advance(lexer); + return TokenType::OpSubAssign; + case '>': + _advance(lexer); + return TokenType::RightArrow; + default: + return TokenType::OpSub; } case '*': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpMulAssign; - default: return TokenType::OpMul; + case '=': + _advance(lexer); + return TokenType::OpMulAssign; + default: + return TokenType::OpMul; } case '/': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpDivAssign; + case '=': + _advance(lexer); + return TokenType::OpDivAssign; case '/': _advance(lexer); _lexLineComment(lexer); @@ -1301,41 +1399,58 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); _lexBlockComment(lexer); return TokenType::BlockComment; - default: return TokenType::OpDiv; + default: + return TokenType::OpDiv; } case '%': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpModAssign; - default: return TokenType::OpMod; + case '=': + _advance(lexer); + return TokenType::OpModAssign; + default: + return TokenType::OpMod; } case '|': _advance(lexer); switch (_peek(lexer)) { - case '|': _advance(lexer); return TokenType::OpOr; - case '=': _advance(lexer); return TokenType::OpOrAssign; - default: return TokenType::OpBitOr; + case '|': + _advance(lexer); + return TokenType::OpOr; + case '=': + _advance(lexer); + return TokenType::OpOrAssign; + default: + return TokenType::OpBitOr; } case '&': _advance(lexer); switch (_peek(lexer)) { - case '&': _advance(lexer); return TokenType::OpAnd; - case '=': _advance(lexer); return TokenType::OpAndAssign; - default: return TokenType::OpBitAnd; + case '&': + _advance(lexer); + return TokenType::OpAnd; + case '=': + _advance(lexer); + return TokenType::OpAndAssign; + default: + return TokenType::OpBitAnd; } case '^': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpXorAssign; - default: return TokenType::OpBitXor; + case '=': + _advance(lexer); + return TokenType::OpXorAssign; + default: + return TokenType::OpBitXor; } case '>': @@ -1346,11 +1461,17 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpShrAssign; - default: return TokenType::OpRsh; + case '=': + _advance(lexer); + return TokenType::OpShrAssign; + default: + return TokenType::OpRsh; } - case '=': _advance(lexer); return TokenType::OpGeq; - default: return TokenType::OpGreater; + case '=': + _advance(lexer); + return TokenType::OpGeq; + default: + return TokenType::OpGreater; } case '<': @@ -1361,41 +1482,60 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpShlAssign; - default: return TokenType::OpLsh; + case '=': + _advance(lexer); + return TokenType::OpShlAssign; + default: + return TokenType::OpLsh; } - case '=': _advance(lexer); return TokenType::OpLeq; - default: return TokenType::OpLess; + case '=': + _advance(lexer); + return TokenType::OpLeq; + default: + return TokenType::OpLess; } case '=': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpEql; - default: return TokenType::OpAssign; + case '=': + _advance(lexer); + return TokenType::OpEql; + default: + return TokenType::OpAssign; } case '!': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpNeq; - default: return TokenType::OpNot; + case '=': + _advance(lexer); + return TokenType::OpNeq; + default: + return TokenType::OpNot; } case '#': _advance(lexer); switch (_peek(lexer)) { - case '#': _advance(lexer); return TokenType::PoundPound; + case '#': + _advance(lexer); + return TokenType::PoundPound; - case '?': _advance(lexer); return TokenType::CompletionRequest; + case '?': + _advance(lexer); + return TokenType::CompletionRequest; - default: return TokenType::Pound; + default: + return TokenType::Pound; } - case '~': _advance(lexer); return TokenType::OpBitNot; + case '~': + _advance(lexer); + return TokenType::OpBitNot; case ':': { @@ -1407,18 +1547,38 @@ static TokenType _lexTokenImpl(Lexer* lexer) } return TokenType::Colon; } - case ';': _advance(lexer); return TokenType::Semicolon; - case ',': _advance(lexer); return TokenType::Comma; - - case '{': _advance(lexer); return TokenType::LBrace; - case '}': _advance(lexer); return TokenType::RBrace; - case '[': _advance(lexer); return TokenType::LBracket; - case ']': _advance(lexer); return TokenType::RBracket; - case '(': _advance(lexer); return TokenType::LParent; - case ')': _advance(lexer); return TokenType::RParent; - - case '?': _advance(lexer); return TokenType::QuestionMark; - case '@': _advance(lexer); return TokenType::At; + case ';': + _advance(lexer); + return TokenType::Semicolon; + case ',': + _advance(lexer); + return TokenType::Comma; + + case '{': + _advance(lexer); + return TokenType::LBrace; + case '}': + _advance(lexer); + return TokenType::RBrace; + case '[': + _advance(lexer); + return TokenType::LBracket; + case ']': + _advance(lexer); + return TokenType::RBracket; + case '(': + _advance(lexer); + return TokenType::LParent; + case ')': + _advance(lexer); + return TokenType::RParent; + + case '?': + _advance(lexer); + return TokenType::QuestionMark; + case '@': + _advance(lexer); + return TokenType::At; case '$': { _advance(lexer); @@ -1565,7 +1725,8 @@ Token Lexer::lexToken() } continue; - default: break; + default: + break; } } *dst++ = c; @@ -1603,12 +1764,14 @@ TokenList Lexer::lexAllSemanticTokens() // switch (token.type) { - default: break; + default: + break; case TokenType::WhiteSpace: case TokenType::BlockComment: case TokenType::LineComment: - case TokenType::NewLine: continue; + case TokenType::NewLine: + continue; } tokenList.add(token); @@ -1625,10 +1788,12 @@ TokenList Lexer::lexAllMarkupTokens() Token token = lexToken(); switch (token.type) { - default: break; + default: + break; case TokenType::WhiteSpace: - case TokenType::NewLine: continue; + case TokenType::NewLine: + continue; } tokenList.add(token); diff --git a/source/compiler-core/slang-name-convention-util.cpp b/source/compiler-core/slang-name-convention-util.cpp index cb44aa10e..3c57f8bc4 100644 --- a/source/compiler-core/slang-name-convention-util.cpp +++ b/source/compiler-core/slang-name-convention-util.cpp @@ -34,8 +34,12 @@ namespace Slang { switch (c) { - case '-': flags |= Flag::Dash; break; - case '_': flags |= Flag::Underscore; break; + case '-': + flags |= Flag::Dash; + break; + case '_': + flags |= Flag::Underscore; + break; default: { if (CharUtil::isLower(c)) @@ -63,21 +67,28 @@ namespace Slang switch (flags) { // We'll assume it's lower camel. - case Flag::Lower: return NameConvention::LowerCamel; + case Flag::Lower: + return NameConvention::LowerCamel; // We'll assume it's upper snake. It almost certainly isn't camel, and snake is more usual // than kabab. - case Flag::Upper: return NameConvention::UpperSnake; + case Flag::Upper: + return NameConvention::UpperSnake; case Flag::Upper | Flag::Lower: { // Looks like camel, choose the right case based on first char return CharUtil::isUpper(slice[0]) ? NameConvention::UpperCamel : NameConvention::LowerCamel; } - case Flag::Lower | Flag::Dash: return NameConvention::LowerKabab; - case Flag::Upper | Flag::Dash: return NameConvention::UpperKabab; - case Flag::Lower | Flag::Underscore: return NameConvention::LowerSnake; - case Flag::Upper | Flag::Underscore: return NameConvention::UpperSnake; - default: break; + case Flag::Lower | Flag::Dash: + return NameConvention::LowerKabab; + case Flag::Upper | Flag::Dash: + return NameConvention::UpperKabab; + case Flag::Lower | Flag::Underscore: + return NameConvention::LowerSnake; + case Flag::Upper | Flag::Underscore: + return NameConvention::UpperSnake; + default: + break; } // Don't know what this style is @@ -90,9 +101,12 @@ namespace Slang { switch (c) { - case '-': return NameStyle::Kabab; - case '_': return NameStyle::Snake; - default: break; + case '-': + return NameStyle::Kabab; + case '_': + return NameStyle::Snake; + default: + break; } } return NameStyle::Camel; @@ -249,8 +263,10 @@ void NameConventionUtil::split(const UnownedStringSlice& slice, List<UnownedStri switch (style) { - case NameStyle::Kabab: return join(slices, slicesCount, convention, '-', out); - case NameStyle::Snake: return join(slices, slicesCount, convention, '_', out); + case NameStyle::Kabab: + return join(slices, slicesCount, convention, '-', out); + case NameStyle::Snake: + return join(slices, slicesCount, convention, '_', out); case NameStyle::Camel: { Index totalSize = 0; diff --git a/source/compiler-core/slang-nvrtc-compiler.cpp b/source/compiler-core/slang-nvrtc-compiler.cpp index 2a4597ddc..c5ccc8e23 100644 --- a/source/compiler-core/slang-nvrtc-compiler.cpp +++ b/source/compiler-core/slang-nvrtc-compiler.cpp @@ -91,7 +91,8 @@ static SlangResult _asResult(nvrtcResult res) { return SLANG_E_INTERNAL_FAIL; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } } @@ -806,7 +807,8 @@ SlangResult NVRTCDownstreamCompiler::compile( switch (options.floatingPointMode) { - case FloatingPointMode::Default: break; + case FloatingPointMode::Default: + break; case FloatingPointMode::Precise: { break; diff --git a/source/compiler-core/slang-source-embed-util.cpp b/source/compiler-core/slang-source-embed-util.cpp index a4d3bf629..cfb83ed57 100644 --- a/source/compiler-core/slang-source-embed-util.cpp +++ b/source/compiler-core/slang-source-embed-util.cpp @@ -184,7 +184,8 @@ static SlangResult _append( // literalSuffix = toSlice("ULL"); break; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } // Output the variable @@ -247,7 +248,9 @@ static SlangResult _append( switch (bytesPerElement) { - case 1: _appendHex<uint8_t>(lineBytes, workView, dstChars, bytesForLine, buf); break; + case 1: + _appendHex<uint8_t>(lineBytes, workView, dstChars, bytesForLine, buf); + break; case 2: _appendHex<uint16_t>((const uint16_t*)lineBytes, workView, dstChars, bytesForLine, buf); break; diff --git a/source/compiler-core/slang-source-loc.cpp b/source/compiler-core/slang-source-loc.cpp index 53eafbeaa..5058a1522 100644 --- a/source/compiler-core/slang-source-loc.cpp +++ b/source/compiler-core/slang-source-loc.cpp @@ -18,13 +18,15 @@ const String PathInfo::getMostUniqueIdentity() const { switch (type) { - case Type::Normal: return uniqueIdentity; + case Type::Normal: + return uniqueIdentity; case Type::FoundPath: case Type::FromString: { return foundPath; } - default: return ""; + default: + return ""; } } @@ -69,7 +71,8 @@ bool PathInfo::operator==(const ThisType& rhs) const // Only have a found path return foundPath == rhs.foundPath; } - default: break; + default: + break; } return false; @@ -79,10 +82,18 @@ void PathInfo::appendDisplayName(StringBuilder& out) const { switch (type) { - case Type::TokenPaste: out << "[Token Paste]"; break; - case Type::TypeParse: out << "[Type Parse]"; break; - case Type::Unknown: out << "[Unknown]"; break; - case Type::CommandLine: out << "[Command Line]"; break; + case Type::TokenPaste: + out << "[Token Paste]"; + break; + case Type::TypeParse: + out << "[Type Parse]"; + break; + case Type::Unknown: + out << "[Unknown]"; + break; + case Type::CommandLine: + out << "[Command Line]"; + break; case Type::Normal: case Type::FromString: case Type::FoundPath: @@ -93,7 +104,8 @@ void PathInfo::appendDisplayName(StringBuilder& out) const out); break; } - default: break; + default: + break; } } diff --git a/source/compiler-core/slang-token.cpp b/source/compiler-core/slang-token.cpp index 5dd64b96a..8b9ec3582 100644 --- a/source/compiler-core/slang-token.cpp +++ b/source/compiler-core/slang-token.cpp @@ -10,10 +10,13 @@ char const* TokenTypeToString(TokenType type) { switch (type) { - default: SLANG_ASSERT(!"unexpected"); return "<uknown>"; + default: + SLANG_ASSERT(!"unexpected"); + return "<uknown>"; #define TOKEN(NAME, DESC) \ - case TokenType::NAME: return DESC; + case TokenType::NAME: \ + return DESC; #include "slang-token-defs.h" } } diff --git a/source/compiler-core/slang-visual-studio-compiler-util.cpp b/source/compiler-core/slang-visual-studio-compiler-util.cpp index 449b0f973..d831abbd4 100644 --- a/source/compiler-core/slang-visual-studio-compiler-util.cpp +++ b/source/compiler-core/slang-visual-studio-compiler-util.cpp @@ -202,12 +202,14 @@ static void _addFile( cmdLine.addArg("/Ox"); break; } - default: break; + default: + break; } switch (options.floatingPointMode) { - case FloatingPointMode::Default: break; + case FloatingPointMode::Default: + break; case FloatingPointMode::Precise: { // precise is default behavior, VS also has 'strict' @@ -253,7 +255,8 @@ static void _addFile( cmdLine.addPrefixPathArg("/Fe", modulePath, ".exe"); break; } - default: break; + default: + break; } // Object file specify it's location - needed if we are out diff --git a/source/compiler-core/windows/slang-win-visual-studio-util.cpp b/source/compiler-core/windows/slang-win-visual-studio-util.cpp index 8496bb3fd..ed09448b5 100644 --- a/source/compiler-core/windows/slang-win-visual-studio-util.cpp +++ b/source/compiler-core/windows/slang-win-visual-studio-util.cpp @@ -155,12 +155,18 @@ static SlangResult _parseVersion(UnownedStringSlice versionString, SemanticVersi switch (version) { - case 1400: return _makeVersion(8); - case 1500: return _makeVersion(9); - case 1600: return _makeVersion(10); - case 1700: return _makeVersion(11); - case 1800: return _makeVersion(12); - default: break; + case 1400: + return _makeVersion(8); + case 1500: + return _makeVersion(9); + case 1600: + return _makeVersion(10); + case 1700: + return _makeVersion(11); + case 1800: + return _makeVersion(12); + default: + break; } // Seems like versions go in runs of 10 at this point @@ -174,41 +180,64 @@ static SlangResult _parseVersion(UnownedStringSlice versionString, SemanticVersi { switch (version) { - case 1910: return _makeVersion(15, 0); - case 1911: return _makeVersion(15, 3); - case 1912: return _makeVersion(15, 5); - case 1913: return _makeVersion(15, 6); - case 1914: return _makeVersion(15, 7); - case 1915: return _makeVersion(15, 8); - case 1916: return _makeVersion(15, 9); - default: return _makeVersion(15); + case 1910: + return _makeVersion(15, 0); + case 1911: + return _makeVersion(15, 3); + case 1912: + return _makeVersion(15, 5); + case 1913: + return _makeVersion(15, 6); + case 1914: + return _makeVersion(15, 7); + case 1915: + return _makeVersion(15, 8); + case 1916: + return _makeVersion(15, 9); + default: + return _makeVersion(15); } } else if (version >= 1920 && version < 1930) { switch (version) { - case 1920: return _makeVersion(16, 0); - case 1921: return _makeVersion(16, 1); - case 1922: return _makeVersion(16, 2); - case 1923: return _makeVersion(16, 3); - case 1924: return _makeVersion(16, 4); - case 1925: return _makeVersion(16, 5); - case 1926: return _makeVersion(16, 6); - case 1927: return _makeVersion(16, 7); - case 1928: return _makeVersion(16, 9); - case 1929: return _makeVersion(16, 11); - default: return _makeVersion(16); + case 1920: + return _makeVersion(16, 0); + case 1921: + return _makeVersion(16, 1); + case 1922: + return _makeVersion(16, 2); + case 1923: + return _makeVersion(16, 3); + case 1924: + return _makeVersion(16, 4); + case 1925: + return _makeVersion(16, 5); + case 1926: + return _makeVersion(16, 6); + case 1927: + return _makeVersion(16, 7); + case 1928: + return _makeVersion(16, 9); + case 1929: + return _makeVersion(16, 11); + default: + return _makeVersion(16); } } else if (version >= 1930 && version < 1940) { switch (version) { - case 1930: return _makeVersion(17, 0); - case 1931: return _makeVersion(17, 1); - case 1932: return _makeVersion(17, 2); - default: return _makeVersion(17); + case 1930: + return _makeVersion(17, 0); + case 1931: + return _makeVersion(17, 1); + case 1932: + return _makeVersion(17, 2); + default: + return _makeVersion(17); } } else if (version >= 1940) |