//
// Copyright 2002 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

#include "GLSLANG/ShaderLang.h"

#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sstream>
#include <vector>
#include "angle_gl.h"

#if defined(ANGLE_ENABLE_VULKAN)
// SPIR-V tools include for disassembly.
#    include <spirv-tools/libspirv.hpp>
#endif

//
// Return codes from main.
//
enum TFailCode
{
    ESuccess = 0,
    EFailUsage,
    EFailCompile,
    EFailCompilerCreate,
};

static void usage();
static sh::GLenum FindShaderType(const char *fileName);
static bool CompileFile(char *fileName, ShHandle compiler, ShCompileOptions compileOptions);
static void LogMsg(const char *msg, const char *name, const int num, const char *logName);
static void PrintVariable(const std::string &prefix, size_t index, const sh::ShaderVariable &var);
static void PrintActiveVariables(ShHandle compiler);

// If NUM_SOURCE_STRINGS is set to a value > 1, the input file data is
// broken into that many chunks. This will affect file/line numbering in
// the preprocessor.
const unsigned int NUM_SOURCE_STRINGS = 1;
typedef std::vector<char *> ShaderSource;
static bool ReadShaderSource(const char *fileName, ShaderSource &source);
static void FreeShaderSource(ShaderSource &source);

static bool ParseGLSLOutputVersion(const std::string &, ShShaderOutput *outResult);
static bool ParseIntValue(const std::string &, int emptyDefault, int *outValue);

static void PrintSpirv(const sh::BinaryBlob &blob);

//
// Set up the per compile resources
//
void GenerateResources(ShBuiltInResources *resources)
{
    sh::InitBuiltInResources(resources);

    resources->MaxVertexAttribs             = 8;
    resources->MaxVertexUniformVectors      = 128;
    resources->MaxVaryingVectors            = 8;
    resources->MaxVertexTextureImageUnits   = 0;
    resources->MaxCombinedTextureImageUnits = 8;
    resources->MaxTextureImageUnits         = 8;
    resources->MaxFragmentUniformVectors    = 16;
    resources->MaxDrawBuffers               = 1;
    resources->MaxDualSourceDrawBuffers     = 1;

    resources->OES_standard_derivatives  = 0;
    resources->OES_EGL_image_external    = 0;
    resources->EXT_geometry_shader       = 1;
    resources->ANGLE_texture_multisample = 0;
    resources->APPLE_clip_distance       = 0;
}

int main(int argc, char *argv[])
{
    TFailCode failCode = ESuccess;

    ShCompileOptions compileOptions = 0;
    int numCompiles                 = 0;
    ShHandle vertexCompiler         = 0;
    ShHandle fragmentCompiler       = 0;
    ShHandle computeCompiler        = 0;
    ShHandle geometryCompiler       = 0;
    ShShaderSpec spec               = SH_GLES2_SPEC;
    ShShaderOutput output           = SH_ESSL_OUTPUT;

#if defined(ANGLE_ENABLE_VULKAN)
    sh::InitializeGlslang();
#endif
    sh::Initialize();

    ShBuiltInResources resources;
    GenerateResources(&resources);

    argc--;
    argv++;
    for (; (argc >= 1) && (failCode == ESuccess); argc--, argv++)
    {
        if (argv[0][0] == '-')
        {
            switch (argv[0][1])
            {
                case 'i':
                    compileOptions |= SH_INTERMEDIATE_TREE;
                    break;
                case 'o':
                    compileOptions |= SH_OBJECT_CODE;
                    break;
                case 'u':
                    compileOptions |= SH_VARIABLES;
                    break;
                case 's':
                    if (argv[0][2] == '=')
                    {
                        switch (argv[0][3])
                        {
                            case 'e':
                                if (argv[0][4] == '3')
                                {
                                    if (argv[0][5] == '1')
                                    {
                                        spec = SH_GLES3_1_SPEC;
                                    }
                                    else
                                    {
                                        spec = SH_GLES3_SPEC;
                                    }
                                }
                                else
                                {
                                    spec = SH_GLES2_SPEC;
                                }
                                break;
                            case 'w':
                                if (argv[0][4] == '3')
                                {
                                    spec = SH_WEBGL3_SPEC;
                                }
                                else if (argv[0][4] == '2')
                                {
                                    spec = SH_WEBGL2_SPEC;
                                }
                                else if (argv[0][4] == 'n')
                                {
                                    spec = SH_WEBGL_SPEC;
                                }
                                else
                                {
                                    spec                            = SH_WEBGL_SPEC;
                                    resources.FragmentPrecisionHigh = 1;
                                }
                                break;
                            case 'd':
                                if (argv[0][4] == 'c')
                                {
                                    spec = SH_GL_COMPATIBILITY_SPEC;
                                }
                                else
                                {
                                    spec = SH_GL_CORE_SPEC;
                                }
                                break;
                            default:
                                failCode = EFailUsage;
                        }
                    }
                    else
                    {
                        failCode = EFailUsage;
                    }
                    break;
                case 'b':
                    if (argv[0][2] == '=')
                    {
                        switch (argv[0][3])
                        {
                            case 'e':
                                output = SH_ESSL_OUTPUT;
                                compileOptions |= SH_INITIALIZE_UNINITIALIZED_LOCALS;
                                break;
                            case 'g':
                                if (!ParseGLSLOutputVersion(&argv[0][sizeof("-b=g") - 1], &output))
                                {
                                    failCode = EFailUsage;
                                }
                                compileOptions |= SH_INITIALIZE_UNINITIALIZED_LOCALS;
                                break;
                            case 'v':
                                output = SH_SPIRV_VULKAN_OUTPUT;
                                compileOptions |= SH_INITIALIZE_UNINITIALIZED_LOCALS;
                                break;
                            case 'h':
                                if (argv[0][4] == '1' && argv[0][5] == '1')
                                {
                                    output = SH_HLSL_4_1_OUTPUT;
                                }
                                else
                                {
                                    output = SH_HLSL_3_0_OUTPUT;
                                }
                                break;
                            case 'm':
                                if (argv[0][4] == 'v')
                                {
                                    output = SH_SPIRV_METAL_OUTPUT;
                                }
                                else
                                {
                                    output = SH_MSL_METAL_OUTPUT;
                                }
                                break;
                            default:
                                failCode = EFailUsage;
                        }
                    }
                    else
                    {
                        failCode = EFailUsage;
                    }
                    break;
                case 'x':
                    if (argv[0][2] == '=')
                    {
                        // clang-format off
                    switch (argv[0][3])
                    {
                      case 'i': resources.OES_EGL_image_external = 1; break;
                      case 'd': resources.OES_standard_derivatives = 1; break;
                      case 'r': resources.ARB_texture_rectangle = 1; break;
                      case 'b':
                          if (ParseIntValue(&argv[0][sizeof("-x=b") - 1], 1,
                                            &resources.MaxDualSourceDrawBuffers))
                          {
                              resources.EXT_blend_func_extended = 1;
                          }
                          else
                          {
                              failCode = EFailUsage;
                          }
                          break;
                      case 'w':
                          if (ParseIntValue(&argv[0][sizeof("-x=w") - 1], 1,
                                            &resources.MaxDrawBuffers))
                          {
                              resources.EXT_draw_buffers = 1;
                          }
                          else
                          {
                              failCode = EFailUsage;
                          }
                          break;
                      case 'g': resources.EXT_frag_depth = 1; break;
                      case 'l': resources.EXT_shader_texture_lod = 1; break;
                      case 'f': resources.EXT_shader_framebuffer_fetch = 1; break;
                      case 'n': resources.NV_shader_framebuffer_fetch = 1; break;
                      case 'a': resources.ARM_shader_framebuffer_fetch = 1; break;
                      case 'm':
                          resources.OVR_multiview2 = 1;
                          resources.OVR_multiview = 1;
                          compileOptions |= SH_INITIALIZE_BUILTINS_FOR_INSTANCED_MULTIVIEW;
                          compileOptions |= SH_SELECT_VIEW_IN_NV_GLSL_VERTEX_SHADER;
                          break;
                      case 'y': resources.EXT_YUV_target = 1; break;
                      case 's': resources.OES_sample_variables = 1; break;
                      default: failCode = EFailUsage;
                    }
                        // clang-format on
                    }
                    else
                    {
                        failCode = EFailUsage;
                    }
                    break;
                default:
                    failCode = EFailUsage;
            }
        }
        else
        {
            if (spec != SH_GLES2_SPEC && spec != SH_WEBGL_SPEC)
            {
                resources.MaxDrawBuffers             = 8;
                resources.MaxVertexTextureImageUnits = 16;
                resources.MaxTextureImageUnits       = 16;
            }
            ShHandle compiler = 0;
            switch (FindShaderType(argv[0]))
            {
                case GL_VERTEX_SHADER:
                    if (vertexCompiler == 0)
                    {
                        vertexCompiler =
                            sh::ConstructCompiler(GL_VERTEX_SHADER, spec, output, &resources);
                    }
                    compiler = vertexCompiler;
                    break;
                case GL_FRAGMENT_SHADER:
                    if (fragmentCompiler == 0)
                    {
                        fragmentCompiler =
                            sh::ConstructCompiler(GL_FRAGMENT_SHADER, spec, output, &resources);
                    }
                    compiler = fragmentCompiler;
                    break;
                case GL_COMPUTE_SHADER:
                    if (computeCompiler == 0)
                    {
                        computeCompiler =
                            sh::ConstructCompiler(GL_COMPUTE_SHADER, spec, output, &resources);
                    }
                    compiler = computeCompiler;
                    break;
                case GL_GEOMETRY_SHADER_EXT:
                    if (geometryCompiler == 0)
                    {
                        geometryCompiler =
                            sh::ConstructCompiler(GL_GEOMETRY_SHADER_EXT, spec, output, &resources);
                    }
                    compiler = geometryCompiler;
                    break;
                default:
                    break;
            }
            if (compiler)
            {
                switch (output)
                {
                    case SH_HLSL_3_0_OUTPUT:
                    case SH_HLSL_4_1_OUTPUT:
                    case SH_HLSL_4_0_FL9_3_OUTPUT:
                        compileOptions &= ~SH_SELECT_VIEW_IN_NV_GLSL_VERTEX_SHADER;
                        break;
                    default:
                        break;
                }

                bool compiled = CompileFile(argv[0], compiler, compileOptions);

                LogMsg("BEGIN", "COMPILER", numCompiles, "INFO LOG");
                std::string log = sh::GetInfoLog(compiler);
                puts(log.c_str());
                LogMsg("END", "COMPILER", numCompiles, "INFO LOG");
                printf("\n\n");

                if (compiled && (compileOptions & SH_OBJECT_CODE))
                {
                    LogMsg("BEGIN", "COMPILER", numCompiles, "OBJ CODE");
                    if (output != SH_SPIRV_VULKAN_OUTPUT)
                    {
                        const std::string &code = sh::GetObjectCode(compiler);
                        puts(code.c_str());
                    }
                    else
                    {
                        const sh::BinaryBlob &blob = sh::GetObjectBinaryBlob(compiler);
                        PrintSpirv(blob);
                    }
                    LogMsg("END", "COMPILER", numCompiles, "OBJ CODE");
                    printf("\n\n");
                }
                if (compiled && (compileOptions & SH_VARIABLES))
                {
                    LogMsg("BEGIN", "COMPILER", numCompiles, "VARIABLES");
                    PrintActiveVariables(compiler);
                    LogMsg("END", "COMPILER", numCompiles, "VARIABLES");
                    printf("\n\n");
                }
                if (!compiled)
                    failCode = EFailCompile;
                ++numCompiles;
            }
            else
            {
                failCode = EFailCompilerCreate;
            }
        }
    }

    if ((vertexCompiler == 0) && (fragmentCompiler == 0) && (computeCompiler == 0) &&
        (geometryCompiler == 0))
        failCode = EFailUsage;
    if (failCode == EFailUsage)
        usage();

    if (vertexCompiler)
        sh::Destruct(vertexCompiler);
    if (fragmentCompiler)
        sh::Destruct(fragmentCompiler);
    if (computeCompiler)
        sh::Destruct(computeCompiler);
    if (geometryCompiler)
        sh::Destruct(geometryCompiler);

    sh::Finalize();
#if defined(ANGLE_ENABLE_VULKAN)
    sh::FinalizeGlslang();
#endif

    return failCode;
}

//
//   print usage to stdout
//
void usage()
{
    // clang-format off
    printf(
        "Usage: translate [-i -o -u -l -b=e -b=g -b=h9 -x=i -x=d] file1 file2 ...\n"
        "Where: filename : filename ending in .frag or .vert\n"
        "       -i       : print intermediate tree\n"
        "       -o       : print translated code\n"
        "       -u       : print active attribs, uniforms, varyings and program outputs\n"
        "       -s=e2    : use GLES2 spec (this is by default)\n"
        "       -s=e3    : use GLES3 spec\n"
        "       -s=e31   : use GLES31 spec (in development)\n"
        "       -s=w     : use WebGL 1.0 spec\n"
        "       -s=wn    : use WebGL 1.0 spec with no highp support in fragment shaders\n"
        "       -s=w2    : use WebGL 2.0 spec\n"
        "       -s=d     : use Desktop Core spec (in development)\n"
        "       -s=dc    : use Desktop Compatibility spec (in development)\n"
        "       -b=e     : output GLSL ES code (this is by default)\n"
        "       -b=g     : output GLSL code (compatibility profile)\n"
        "       -b=g[NUM]: output GLSL code (NUM can be 130, 140, 150, 330, 400, 410, 420, 430, "
        "440, 450)\n"
        "       -b=v     : output Vulkan SPIR-V code\n"
        "       -b=h9    : output HLSL9 code\n"
        "       -b=h11   : output HLSL11 code\n"
        "       -b=m     : output MSL code (direct)\n"
        "       -b=mv    : output MSL code (via SPIR-V)\n"
        "       -x=i     : enable GL_OES_EGL_image_external\n"
        "       -x=d     : enable GL_OES_EGL_standard_derivatives\n"
        "       -x=r     : enable ARB_texture_rectangle\n"
        "       -x=b[NUM]: enable EXT_blend_func_extended (NUM default 1)\n"
        "       -x=w[NUM]: enable EXT_draw_buffers (NUM default 1)\n"
        "       -x=g     : enable EXT_frag_depth\n"
        "       -x=l     : enable EXT_shader_texture_lod\n"
        "       -x=f     : enable EXT_shader_framebuffer_fetch\n"
        "       -x=n     : enable NV_shader_framebuffer_fetch\n"
        "       -x=a     : enable ARM_shader_framebuffer_fetch\n"
        "       -x=m     : enable OVR_multiview\n"
        "       -x=y     : enable YUV_target\n"
        "       -x=s     : enable OES_sample_variables\n");
    // clang-format on
}

//
//   Deduce the shader type from the filename.  Files must end in one of the
//   following extensions:
//
//   .frag*    = fragment shader
//   .vert*    = vertex shader
//
sh::GLenum FindShaderType(const char *fileName)
{
    assert(fileName);

    const char *ext = strrchr(fileName, '.');

    if (ext && strcmp(ext, ".sl") == 0)
        for (; ext > fileName && ext[0] != '.'; ext--)
            ;

    ext = strrchr(fileName, '.');
    if (ext)
    {
        if (strncmp(ext, ".frag", 5) == 0)
            return GL_FRAGMENT_SHADER;
        if (strncmp(ext, ".vert", 5) == 0)
            return GL_VERTEX_SHADER;
        if (strncmp(ext, ".comp", 5) == 0)
            return GL_COMPUTE_SHADER;
        if (strncmp(ext, ".geom", 5) == 0)
            return GL_GEOMETRY_SHADER_EXT;
    }

    return GL_FRAGMENT_SHADER;
}

//
//   Read a file's data into a string, and compile it using sh::Compile
//
bool CompileFile(char *fileName, ShHandle compiler, ShCompileOptions compileOptions)
{
    ShaderSource source;
    if (!ReadShaderSource(fileName, source))
        return false;

    int ret = sh::Compile(compiler, &source[0], source.size(), compileOptions);

    FreeShaderSource(source);
    return ret ? true : false;
}

void LogMsg(const char *msg, const char *name, const int num, const char *logName)
{
    printf("#### %s %s %d %s ####\n", msg, name, num, logName);
}

void PrintVariable(const std::string &prefix, size_t index, const sh::ShaderVariable &var)
{
    std::string typeName;
    switch (var.type)
    {
        case GL_FLOAT:
            typeName = "GL_FLOAT";
            break;
        case GL_FLOAT_VEC2:
            typeName = "GL_FLOAT_VEC2";
            break;
        case GL_FLOAT_VEC3:
            typeName = "GL_FLOAT_VEC3";
            break;
        case GL_FLOAT_VEC4:
            typeName = "GL_FLOAT_VEC4";
            break;
        case GL_INT:
            typeName = "GL_INT";
            break;
        case GL_INT_VEC2:
            typeName = "GL_INT_VEC2";
            break;
        case GL_INT_VEC3:
            typeName = "GL_INT_VEC3";
            break;
        case GL_INT_VEC4:
            typeName = "GL_INT_VEC4";
            break;
        case GL_UNSIGNED_INT:
            typeName = "GL_UNSIGNED_INT";
            break;
        case GL_UNSIGNED_INT_VEC2:
            typeName = "GL_UNSIGNED_INT_VEC2";
            break;
        case GL_UNSIGNED_INT_VEC3:
            typeName = "GL_UNSIGNED_INT_VEC3";
            break;
        case GL_UNSIGNED_INT_VEC4:
            typeName = "GL_UNSIGNED_INT_VEC4";
            break;
        case GL_BOOL:
            typeName = "GL_BOOL";
            break;
        case GL_BOOL_VEC2:
            typeName = "GL_BOOL_VEC2";
            break;
        case GL_BOOL_VEC3:
            typeName = "GL_BOOL_VEC3";
            break;
        case GL_BOOL_VEC4:
            typeName = "GL_BOOL_VEC4";
            break;
        case GL_FLOAT_MAT2:
            typeName = "GL_FLOAT_MAT2";
            break;
        case GL_FLOAT_MAT3:
            typeName = "GL_FLOAT_MAT3";
            break;
        case GL_FLOAT_MAT4:
            typeName = "GL_FLOAT_MAT4";
            break;
        case GL_FLOAT_MAT2x3:
            typeName = "GL_FLOAT_MAT2x3";
            break;
        case GL_FLOAT_MAT3x2:
            typeName = "GL_FLOAT_MAT3x2";
            break;
        case GL_FLOAT_MAT4x2:
            typeName = "GL_FLOAT_MAT4x2";
            break;
        case GL_FLOAT_MAT2x4:
            typeName = "GL_FLOAT_MAT2x4";
            break;
        case GL_FLOAT_MAT3x4:
            typeName = "GL_FLOAT_MAT3x4";
            break;
        case GL_FLOAT_MAT4x3:
            typeName = "GL_FLOAT_MAT4x3";
            break;

        case GL_SAMPLER_2D:
            typeName = "GL_SAMPLER_2D";
            break;
        case GL_SAMPLER_3D:
            typeName = "GL_SAMPLER_3D";
            break;
        case GL_SAMPLER_CUBE:
            typeName = "GL_SAMPLER_CUBE";
            break;
        case GL_SAMPLER_CUBE_SHADOW:
            typeName = "GL_SAMPLER_CUBE_SHADOW";
            break;
        case GL_SAMPLER_2D_SHADOW:
            typeName = "GL_SAMPLER_2D_ARRAY_SHADOW";
            break;
        case GL_SAMPLER_2D_ARRAY:
            typeName = "GL_SAMPLER_2D_ARRAY";
            break;
        case GL_SAMPLER_2D_ARRAY_SHADOW:
            typeName = "GL_SAMPLER_2D_ARRAY_SHADOW";
            break;
        case GL_SAMPLER_2D_MULTISAMPLE:
            typeName = "GL_SAMPLER_2D_MULTISAMPLE";
            break;
        case GL_IMAGE_2D:
            typeName = "GL_IMAGE_2D";
            break;
        case GL_IMAGE_3D:
            typeName = "GL_IMAGE_3D";
            break;
        case GL_IMAGE_CUBE:
            typeName = "GL_IMAGE_CUBE";
            break;
        case GL_IMAGE_2D_ARRAY:
            typeName = "GL_IMAGE_2D_ARRAY";
            break;

        case GL_INT_SAMPLER_2D:
            typeName = "GL_INT_SAMPLER_2D";
            break;
        case GL_INT_SAMPLER_3D:
            typeName = "GL_INT_SAMPLER_3D";
            break;
        case GL_INT_SAMPLER_CUBE:
            typeName = "GL_INT_SAMPLER_CUBE";
            break;
        case GL_INT_SAMPLER_2D_ARRAY:
            typeName = "GL_INT_SAMPLER_2D_ARRAY";
            break;
        case GL_INT_SAMPLER_2D_MULTISAMPLE:
            typeName = "GL_INT_SAMPLER_2D_MULTISAMPLE";
            break;
        case GL_INT_IMAGE_2D:
            typeName = "GL_INT_IMAGE_2D";
            break;
        case GL_INT_IMAGE_3D:
            typeName = "GL_INT_IMAGE_3D";
            break;
        case GL_INT_IMAGE_CUBE:
            typeName = "GL_INT_IMAGE_CUBE";
            break;
        case GL_INT_IMAGE_2D_ARRAY:
            typeName = "GL_INT_IMAGE_2D_ARRAY";
            break;

        case GL_UNSIGNED_INT_SAMPLER_2D:
            typeName = "GL_UNSIGNED_INT_SAMPLER_2D";
            break;
        case GL_UNSIGNED_INT_SAMPLER_3D:
            typeName = "GL_UNSIGNED_INT_SAMPLER_3D";
            break;
        case GL_UNSIGNED_INT_SAMPLER_CUBE:
            typeName = "GL_UNSIGNED_INT_SAMPLER_CUBE";
            break;
        case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
            typeName = "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY";
            break;
        case GL_UNSIGNED_INT_ATOMIC_COUNTER:
            typeName = "GL_UNSIGNED_INT_ATOMIC_COUNTER";
            break;
        case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
            typeName = "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE";
            break;
        case GL_UNSIGNED_INT_IMAGE_2D:
            typeName = "GL_UNSIGNED_INT_IMAGE_2D";
            break;
        case GL_UNSIGNED_INT_IMAGE_3D:
            typeName = "GL_UNSIGNED_INT_IMAGE_3D";
            break;
        case GL_UNSIGNED_INT_IMAGE_CUBE:
            typeName = "GL_UNSIGNED_INT_IMAGE_CUBE";
            break;
        case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
            typeName = "GL_UNSIGNED_INT_IMAGE_2D_ARRAY";
            break;

        case GL_SAMPLER_EXTERNAL_OES:
            typeName = "GL_SAMPLER_EXTERNAL_OES";
            break;
        case GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT:
            typeName = "GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT";
            break;
        default:
            typeName = "UNKNOWN";
            break;
    }

    printf("%s %u : name=%s, mappedName=%s, type=%s, arraySizes=", prefix.c_str(),
           static_cast<unsigned int>(index), var.name.c_str(), var.mappedName.c_str(),
           typeName.c_str());
    for (unsigned int arraySize : var.arraySizes)
    {
        printf("%u ", arraySize);
    }
    printf("\n");
    if (var.fields.size())
    {
        std::string structPrefix;
        for (size_t i = 0; i < prefix.size(); ++i)
            structPrefix += ' ';
        printf("%s  struct %s\n", structPrefix.c_str(), var.structOrBlockName.c_str());
        structPrefix += "    field";
        for (size_t i = 0; i < var.fields.size(); ++i)
            PrintVariable(structPrefix, i, var.fields[i]);
    }
}

static void PrintActiveVariables(ShHandle compiler)
{
    const std::vector<sh::ShaderVariable> *uniforms       = sh::GetUniforms(compiler);
    const std::vector<sh::ShaderVariable> *inputVaryings  = sh::GetInputVaryings(compiler);
    const std::vector<sh::ShaderVariable> *outputVaryings = sh::GetOutputVaryings(compiler);
    const std::vector<sh::ShaderVariable> *attributes     = sh::GetAttributes(compiler);
    const std::vector<sh::ShaderVariable> *outputs        = sh::GetOutputVariables(compiler);
    for (size_t varCategory = 0; varCategory < 5; ++varCategory)
    {
        size_t numVars = 0;
        std::string varCategoryName;
        if (varCategory == 0)
        {
            numVars         = uniforms->size();
            varCategoryName = "uniform";
        }
        else if (varCategory == 1)
        {
            numVars         = inputVaryings->size();
            varCategoryName = "input varying";
        }
        else if (varCategory == 2)
        {
            numVars         = outputVaryings->size();
            varCategoryName = "output varying";
        }
        else if (varCategory == 3)
        {
            numVars         = attributes->size();
            varCategoryName = "attribute";
        }
        else
        {
            numVars         = outputs->size();
            varCategoryName = "output";
        }

        for (size_t i = 0; i < numVars; ++i)
        {
            const sh::ShaderVariable *var;
            if (varCategory == 0)
                var = &((*uniforms)[i]);
            else if (varCategory == 1)
                var = &((*inputVaryings)[i]);
            else if (varCategory == 2)
                var = &((*outputVaryings)[i]);
            else if (varCategory == 3)
                var = &((*attributes)[i]);
            else
                var = &((*outputs)[i]);

            PrintVariable(varCategoryName, i, *var);
        }
        printf("\n");
    }
}

static bool ReadShaderSource(const char *fileName, ShaderSource &source)
{
    FILE *in = fopen(fileName, "rb");
    if (!in)
    {
        printf("Error: unable to open input file: %s\n", fileName);
        return false;
    }

    // Obtain file size.
    fseek(in, 0, SEEK_END);
    size_t count = ftell(in);
    rewind(in);

    int len = (int)ceil((float)count / (float)NUM_SOURCE_STRINGS);
    source.reserve(NUM_SOURCE_STRINGS);
    // Notice the usage of do-while instead of a while loop here.
    // It is there to handle empty files in which case a single empty
    // string is added to vector.
    do
    {
        char *data   = new char[len + 1];
        size_t nread = fread(data, 1, len, in);
        data[nread]  = '\0';
        source.push_back(data);

        count -= nread;
    } while (count > 0);

    fclose(in);
    return true;
}

static void FreeShaderSource(ShaderSource &source)
{
    for (ShaderSource::size_type i = 0; i < source.size(); ++i)
    {
        delete[] source[i];
    }
    source.clear();
}

static bool ParseGLSLOutputVersion(const std::string &num, ShShaderOutput *outResult)
{
    if (num.length() == 0)
    {
        *outResult = SH_GLSL_COMPATIBILITY_OUTPUT;
        return true;
    }
    std::istringstream input(num);
    int value;
    if (!(input >> value && input.eof()))
    {
        return false;
    }

    switch (value)
    {
        case 130:
            *outResult = SH_GLSL_130_OUTPUT;
            return true;
        case 140:
            *outResult = SH_GLSL_140_OUTPUT;
            return true;
        case 150:
            *outResult = SH_GLSL_150_CORE_OUTPUT;
            return true;
        case 330:
            *outResult = SH_GLSL_330_CORE_OUTPUT;
            return true;
        case 400:
            *outResult = SH_GLSL_400_CORE_OUTPUT;
            return true;
        case 410:
            *outResult = SH_GLSL_410_CORE_OUTPUT;
            return true;
        case 420:
            *outResult = SH_GLSL_420_CORE_OUTPUT;
            return true;
        case 430:
            *outResult = SH_GLSL_430_CORE_OUTPUT;
            return true;
        case 440:
            *outResult = SH_GLSL_440_CORE_OUTPUT;
            return true;
        case 450:
            *outResult = SH_GLSL_450_CORE_OUTPUT;
            return true;
        default:
            break;
    }
    return false;
}

static bool ParseIntValue(const std::string &num, int emptyDefault, int *outValue)
{
    if (num.length() == 0)
    {
        *outValue = emptyDefault;
        return true;
    }

    std::istringstream input(num);
    int value;
    if (!(input >> value && input.eof()))
    {
        return false;
    }
    *outValue = value;
    return true;
}

static void PrintSpirv(const sh::BinaryBlob &blob)
{
#if defined(ANGLE_ENABLE_VULKAN)
    spvtools::SpirvTools spirvTools(SPV_ENV_VULKAN_1_1);

    std::string readableSpirv;
    spirvTools.Disassemble(blob, &readableSpirv, 0);

    puts(readableSpirv.c_str());
#endif
}