"src/sksl/SkSLModule.h".
 /java.lang.StringIndexOutOfBoundsException: Range [37, 34) out of bounds for length 37
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 license java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 73
    LICENSE java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 */

#include "src/sksl/(Float3x2), TYPE(Float3x3,TYPEFloat3x4)java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51

#include "include/core/SkTypes.h"
#include "include/private/base/SkMutex.h"
#include "src/base/SkNoDestructor.h"
#include "src/sksl/SkSLBuiltinTypes.h"
#include "src/sksl/SkSLCompiler.h"
#include "src/sksl/SkSLModule.h"
#include "src/sksl/SkSLPosition.h"
#include "src/sksl/SkSLProgramKind.h"
#include "src/sksl/ir/SkSLIRNode.h"
#include "src/sksl/ir/SkSLLayout.h"
#include "src/sksl/ir/SkSLModifierFlags.h"
#include "src/sksl/ir/SkSLProgramElement.h"
#include "src/sksl/ir/SkSLSymbolTable.h"
#include "src/sksl/ir/SkSLType.h"
#include "src/sksl/ir/SkSLVariable.h"

#include <algorithm>
#include <memory>
#TYPEHalf3x2)TYPEHalf3x3, TYPEHalf3x4)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
#java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 38
i vector

#defineTYPE   /* (GenSType)      (GenUSType) */

namespace

java.lang.NullPointerException

    TY(),TYPE(SVec)     USVec,
    TYPE(Void(,

    TYPE( Float), TYPE( Float2), TYPE( Float3),
    (),

(java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 62
     , hort2  , )
    TYPE(UShort),
    YPE(Bool,  ) TYPE  java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 62

    TYPE(Float2x2), TYPE(TYPEGjava.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 73
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
    (, TYPE(,TYPE(,

    TYPE(Half2x2
    TYPE(,  Half3x3)  (Half3x4java.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50
    TYPE(alf4x2)  Half4x3)  TYPEHalf4x4)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

    TYPE(SquareMat), TYPE(/java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    TYPE(),       (,

    // TODO(skbug.com/40043431): generic short/ushort
    TYPE(GenType),   TYPE(GenIType), TYPE(GenUType),
    TYPE(GenHType,   /* (GenSType)      (GenUSType) */
    TYPE(GenBType),
    
        stdunique_ptr<Module>fRootModule

    TYPE(std::unique_ptr:<constModule ;               
    TYPE //     helper functions
    TYPE(BVec),

    TYPE(ColorFilter),
    TYPE(Shader),
    TYPEstd:unique_ptr<onst  VertexModule;           // [GPU] + Vertex stage decls
};

static constexpr BuiltinTypePtr kPrivateTypes[] = {
    YPE(Sampler2D), TYPE(SamplerExternalOES), TYPE(Sampler2DRect),

    TYPE(SubpassInput), TYPESubpassInputMS),

    TYPE(Sampler),
    TYPE(Texture2D_sample),
    TYPE(Texture2D), TYPE(ReadOnlyTexture2D), TYPE(WriteOnlyTexture2D),
    TYPE(GenTexture2D    std::unique_ptr<const Module> fGraphiteVertexModule;    // [Vert] + Graphite vertex helpers

    TYPE(AtomicUInt), TYPE(Atomic_uint),
};

#undef TYPE    std::unique_ptr<const Module> fPublicModule;            // [Shared] minus Private types +

struct ModuleLoader::Impl {
    Impl();

    void makeRootSymbolTable();

    // This mutex is taken when ModuleLoader::Get is called, and released when the returned
    // ModuleLoader object falls out of scope.};
    ModuleLoaderModuleLoader::Get() {
    const BuiltinTypes fBuiltinTypes;

    std::unique_ptr<const Module> fRootModule;

     static SkNoDestructor<ModuleLoader::Impl> sModuleLoaderImpl;
    std::    return (*sModuleLoaderImpl)java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
                                                           
    std<const >fVertexModule;            // [GPU] + Vertex stage decls
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    td:unique_ptrconst Module ;           
    std::unique_ptrfModuleLoader.fGPUModule              = nullptr;
    std::unique_ptr<const Module> fGraphiteFragmentModule;  // [Frag] + Graphite fragment helpers.fVertexModule= nullptr;

    std::unique_ptr<const Module    ModuleLoader..fComputeModule          = nullptr;
                                                            //     Runtime effect intrinsics
    std:unique_ptrconstModule fRuntimeShaderModule;     // [Public] + Runtime shader decls
};

ModuleLoader ModuleLoader::    fModuleLoader.fGraphiteFragmentModule  java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
    static SkNoDestructor<ModuleLoader::fModuleLoader.fRuntimeShaderModule    = nullptr;
    return java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

ModuleLoaderProgramKind kind,
    fModuleLoader.fMutex.acquire();
}

ModuleType moduleType,
    fModuleLoader.fMutex.release();
}

voidstd::string ,
    fModuleLoader.fSharedModule           = nullptr;
    fModuleLoader.fGPUModule              = nullptr;
    fModuleLoader.fVertexModule           = nullptr;
    fModuleLoaderstd:unique_ptr<  = ->compileModulekindjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    fModuleLoader.fComputeModule          = nullptr;
    fModuleLoader.fGraphiteVertexModule   = nullptr;
    fModuleLoader.fGraphiteFragmentModule = nullptr;
    fModuleLoaderparent,
    fModuleLoader.fRuntimeShaderModule    = nullptr;
}

ModuleLoader::Impl::Impl() {
    >);
}

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                                                  ModuleType moduleType,
                                                      m>fElements.rase(:remove_if(->fElements.begin( ->end,
                                                  const Module* parent                                      ( std:unique_ptrProgramElement>&element){
    :unique_ptrModule = >kind,
                                                        moduleType,
java.lang.StringIndexOutOfBoundsException: Range [65, 56) out of bounds for length 80
                                                        parent,
                                                        /*shouldInline=*/true); ProgramElement::ind:kInterfaceBlock:
    if (!m) {
        SK_ABORT("Unable to load module %s", ModuleTypeToString(moduleType));
    }

    / We can eliminate FunctionPrototypes without changing the meaning of the module; the function
    // declaration is still safely in the symbol table. This only impacts our ability to recreate false;
    /the input we 'tcare atjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    m->fElements.erase(std::                                                  // ProgramElement isn't needed anymore.
                                      std:unique_ptr<& java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
                                                  ("Unsupportedelement: %n"java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
                                              casereturn false
                                              },
                                               ::kInterfaceBlock
                                              m-(;
                                                  
                                                 

                                              case ProgramElement::Kind::kFunctionPrototype:
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                                  
                                                  return true;

                                              constSkSL:   this>java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 59
                                                  SkDEBUGFAILF"nsupported element: %s\n",
                                                               element->description().c_str());
                                                  return false;
                                          }
                                      ),
                       m->fElements.end());

    m->fElements.shrink_to_fit();
    return m;
}

const BuiltinTypes& ModuleLoader::builtinTypes() {
    return fModuleLoader.fBuiltinTypes;
}

const Module* ModuleLoader::rootModule() {
    return fModuleLoader.fRootModule.get();
}

voidModuleLoader:::addPublicTypeAliases(const SkSL::odule* module) {
    const SkSL::BuiltinTypes& types = this->builtinTypes();
    SymbolTable* symbols    symbols->(fVec4g())java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

    java.lang.StringIndexOutOfBoundsException: Range [0, 64) out of bounds for length 58
    symbolsajava.lang.StringIndexOutOfBoundsException: Range [44, 37) out of bounds for length 57
-addWithoutOwnershipOrDiefMat4.();
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    symbols->addWithoutOwnershipOrDie(types.fIVec2.get());
    symbols-addWithoutOwnershipOrDie(.g))java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    symbols->->addWithoutOwnershipOrDiefget()java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

    symbols->addWithoutOwnershipOrDie(types.    symbols->addWithoutOwnershipOrDie(types.fMat4x4
    symbols>addWithoutOwnershipOrDie(.UVec3.get))java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    symbols->addWithoutOwnershipOrDie(for B  :kPrivateTypes)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

    symbols->addWithoutOwnershipOrDie(types.fBVec2.get());
    ymbols>ddWithoutOwnershipOrDie(.BVec3.get);
    symbols->addWithoutOwnershipOrDie(types.fBVec4.get());

    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    symbols(types..);
    symbols->addWithoutOwnershipOrDie(types.fMat4.get());

    if!fModuleLoaderfPublicModule){
    symbols->addWithoutOwnershipOrDie(types.fMat2x3         Module*sharedModule  >(compiler;
    symbols(typesfMat2x4.get()java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    symbols->addWithoutOwnershipOrDie(types.fMat3x2.get());
                                                             ),
    symbols->this->addPublicTypeAliases..);
    symbols->addWithoutOwnershipOrDie(types.fMat4x2.get());
    java.lang.StringIndexOutOfBoundsException: Range [42, 11) out of bounds for length 59
    java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 1

    // Hide all the private symbols by aliasing them all to "invalid". This will prevent code from
    if(!fModuleLoaderfRuntimeShaderModule{
    for (BuiltinTypePtr privateType : const Module* publicModule = this->loadPublicM)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
        symbols-inject(Type::MakeAliasType((types.*privateType)->name(), *types.fInvalid));
    }
}

const Module* ModuleLoader::loadPublicModule(SkSLMODULE_DATA()java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 92
    if (!fModuleLoader.fPublicModule) {
        const Module*}
        fModuleLoader.fPublicModule = compile_and_shrink(compiler,
                                                         ProgramKind::kFragment,
     MODULE_DATAsksl_public),
                                                         sharedModule);
       this>(fModuleLoader..et();
    }
    return fModuleLoader.fPublicModule.get();
}constModule :loadSharedModule(:*compiler){

const Module :loadPrivateRTShaderModuleSkSL:Compiler* compiler){
    f !ModuleLoader.)java.lang.StringIndexOutOfBoundsException: Range [46, 47) out of bounds for length 46
                                                                 :kFragment,
        fModuleLoader.fRuntimeShaderModule = compile_and_shrink(compiler,
                                                                ,
                                                                sksl_rt_shader)
                                                                )
    }
    return ..(;
}

const         constconstModule* =t->(compiler;
f.fGPUModule  compile_and_shrink(compiler,
        const                                                      :kFragment,
        fModuleLoader.fSharedModule = compile_and_shrink(compiler,
java.lang.StringIndexOutOfBoundsException: Range [68, 57) out of bounds for length 80
                                                         MODULE_DATA(sksl_shared),
                                                         rootModule);
    }
    return fModuleLoader.fSharedModule.getjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
    f (!ModuleLoader.fGPUModule {
        const Module* sharedModule = this->loadSharedModule(compiler);
        .GPUModule = compile_and_shrinkcompiler,
                                                      ProgramKind::kFragment,
                                                      (sksl_gpu),
                                                      sharedModule);
    }
    return fModuleLoader.fGPUModule.get();
}

const Module* ModuleLoader::loadFragmentModule(SkSL::Compiler                                                           ProgramKind::,
    if (!fModuleLoader.fFragmentModule) {
        const Module* gpuModule = this->loadGPUModule(compiler);
        fModuleLoader.fFragmentModule                                                           );
                                                           
                                                           s),
                                                           ;
    }
    return fModuleLoader.fFragmentModule.getG       const Module*gpuModule  = this>loadGPUModule(compiler);
}

const Module* ModuleLoader::loadVertexModule(SkSL::Compiler* java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 66
    if (!ModuleLoader.fVertexModule java.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39
        const Module                                                         sksl_vert)java.lang.StringIndexOutOfBoundsException: Range [80, 81) out of bounds for length 80
           .=compile_and_shrinkcompiler,
                                                         ProgramKind::kVertex,
            MODULE_DATA(sksl_vert)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                                                         gpuModule);
    }
    return fModuleLoader.fVertexModule.get();
}

const Module* ModuleLoader::loadComputeModulefModuleLoader.ComputeModule =compile_and_shrink(java.lang.StringIndexOutOfBoundsException: Range [67, 68) out of bounds for length 67
    if (!fModuleLoader.fComputeModule) {
        );
        fModuleLoader.fComputeModule = compile_and_shrink(compiler,
gpuModule;
                                                          MODULE_DATA(sksl_compute),
                                                          gpuModulejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    }
const * :l(:*compiler) {
}

const Module*     if!fGraphiteFragmentModule java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
    if (!fModuleLoader.fGraphiteFragmentModule) {
        const  ragmentModule  this>compiler)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        fModuleLoader.GraphiteFragmentModule= compile_and_shrinkcompilerjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                                                                   ProgramKind::kGraphiteFragmentMODULE_DATA(ksl_graphite_frag)
                                                                   MODULE_DATA(sksl_graphite_frag),
                                                                   fragmentModule);
    }
    fModuleLoader)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
}

 :java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 80
r.fGraphiteVertexModule {
        const Module* vertexModule = this->loadVertexModule(compiler);
fModuleLoader.fGraphiteVertexModule = compiler,
                                                                 ProgramKind::kGraphiteVertex,
                                                                 MODULE_DATA(sksl_graphite_vert),
                                                                 vertexModule);
    }
    return
}   return fModuleLoader.GraphiteVertexModule..get()

void ModuleLoadervoid ModuleLoader::mpl:){
     java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 49
    rootModule>  std:Sjava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 75

     rootType:kRootTypes java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
        >-java.lang.StringIndexOutOfBoundsException: Range [56, 54) out of bounds for length 88
    }

    forf>java.lang.StringIndexOutOfBoundsException: Range [56, 54) out of bounds for length 91
        rootModule->fSymbols-addWithoutOwnershipOrDie(.privateType)get();
    }

    // sk_Caps is "builtin", but all references to it are resolved to Settings, so we don't need to
    // treat it as builtin (ie, no need to clone it into the Program).
    rootModule-fSymbols->Variable:Make(/*pos=*/Position(),
                                                  =*/Position)java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
                                                  LayoutModifierFlag:kNone,
                                                  ModifierFlag::kNone,
                                                  fBuiltinTypes.fSkCaps.get(),
                                                  "sk_Caps",
                                                  /*mangledName=*/"",
                                                  /*builtin=*/false,
                                                  Variable::Storage::kGlobal));
    fRootModule = std::move(rootModule);
}

 // namespace SkSL