StandAlone/StandAlone.cpp

//
//Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
//Copyright (C) 2013 LunarG, Inc.
//
//All rights reserved.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions
//are met:
//
//    Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
//    Redistributions in binary form must reproduce the above
//    copyright notice, this list of conditions and the following
//    disclaimer in the documentation and/or other materials provided
//    with the distribution.
//
//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
//"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//POSSIBILITY OF SUCH DAMAGE.
//
#include "Worklist.h"
#include "./../glslang/Include/ShHandle.h"
#include "./../glslang/Public/ShaderLang.h"
#include <string.h>
#include <stdlib.h>
#include <math.h>

#include "osinclude.h"

extern "C" {
    SH_IMPORT_EXPORT void ShOutputHtml();
}

// Command-line options
enum TOptions {
	EOptionNone               = 0x000,
	EOptionIntermediate       = 0x001,
	EOptionSuppressInfolog    = 0x002,
	EOptionMemoryLeakMode     = 0x004,
    EOptionRelaxedErrors      = 0x008,
    EOptionGiveWarnings       = 0x010,
    EOptionsLinkProgram       = 0x020,
};

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

//
// Just placeholders for testing purposes.  The stand-alone environment
// can't actually do a full link without something specifying real
// attribute bindings.
//
ShBinding FixedAttributeBindings[] = { 
    { "gl_Vertex", 15 },
    { "gl_Color", 10 },
    { "gl_Normal", 7 },
};

ShBindingTable FixedAttributeTable = { 3, FixedAttributeBindings };

EShLanguage FindLanguage(const std::string& name);
bool CompileFile(const char *fileName, ShHandle, int options, const TBuiltInResource*);
void usage();
void FreeFileData(char **data);
char** ReadFileData(const char *fileName);
void InfoLogMsg(const char* msg, const char* name, const int num);

// Use to test breaking a single shader file into multiple strings.
int NumShaderStrings = 1;

//
// Set up the per compile resources
//
void GenerateResources(TBuiltInResource& resources)
{
    resources.maxLights = 32;
    resources.maxClipPlanes = 6;
    resources.maxTextureUnits = 32;
    resources.maxTextureCoords = 32;
    resources.maxVertexAttribs = 64;
    resources.maxVertexUniformComponents = 4096;
    resources.maxVaryingFloats = 64;
    resources.maxVertexTextureImageUnits = 32;
    resources.maxCombinedTextureImageUnits = 32;
    resources.maxTextureImageUnits = 32;
    resources.maxFragmentUniformComponents = 4096;
    resources.maxDrawBuffers = 32;
    resources.maxVertexUniformVectors = 128;
    resources.maxVaryingVectors = 8;
    resources.maxFragmentUniformVectors = 16;
    resources.maxVertexOutputVectors = 16;
    resources.maxFragmentInputVectors = 15;
    resources.minProgramTexelOffset = -8;
    resources.maxProgramTexelOffset = 7;
}

glslang::TWorklist Worklist;
int Options = 0;
bool Delay = false;

bool ProcessArguments(int argc, char* argv[])
{
    argc--;
    argv++;    
    for (; argc >= 1; argc--, argv++) {
        if (argv[0][0] == '-') {
            switch (argv[0][1]) {
            case 'd':
                Delay = true;                        
                break;
            case 'i': 
                Options |= EOptionIntermediate;
                break;
            case 'l':
                Options |= EOptionsLinkProgram;
                break;
            case 'm':
                Options |= EOptionMemoryLeakMode;
                break;
            case 'r':
                Options |= EOptionRelaxedErrors;
                break;
            case 's':
                Options |= EOptionSuppressInfolog;
                break;
            default:
                return false;
            }
        } else
            Worklist.add(std::string(argv[0]));
    }

    if (Worklist.empty())
        return false;

    return true;
}

// Thread entry point, for non-linking asynchronous mode.
unsigned int
#ifdef _WIN32
    __stdcall
#endif
CompileShaders(void*)
{
    std::string shaderName;
    while (Worklist.remove(shaderName)) {
        ShHandle compiler = ShConstructCompiler(FindLanguage(shaderName), Options);
        if (compiler == 0)
            return false;

        TBuiltInResource resources;
        GenerateResources(resources);
        CompileFile(shaderName.c_str(), compiler, Options, &resources);

        if (! (Options & EOptionSuppressInfolog))
            puts(ShGetInfoLog(compiler));

        ShDestruct(compiler);
    }

    return 0;
}

//
// For linking mode: Will independently parse each item in the worklist, but then put them
// in the same program and link them together.
//
// Uses the new C++ interface instead of the old handle-based interface.
//
void CompileAndLinkShaders()
{
    // keep track of what to free
    std::list<glslang::TShader*> shaders;

    EShMessages messages = EShMsgDefault;
    if (Options & EOptionRelaxedErrors)
        messages = (EShMessages)(messages | EShMsgRelaxedErrors);
    if (Options & EOptionIntermediate)
        messages = (EShMessages)(messages | EShMsgAST);

    TBuiltInResource resources;
    GenerateResources(resources);

    //
    // Per-shader processing...
    //

    glslang::TProgram program;
    std::string shaderName;
    while (Worklist.remove(shaderName)) {
        EShLanguage stage = FindLanguage(shaderName);
        glslang::TShader* shader = new glslang::TShader(stage);
        shaders.push_back(shader);
    
        char** shaderStrings = ReadFileData(shaderName.c_str());
        if (! shaderStrings) {
            usage();
            return;
        }

        shader->setStrings(shaderStrings, 1);

        shader->parse(&resources, 100, false, messages);
        
        program.addShader(shader);

        if (! (Options & EOptionSuppressInfolog)) {
            puts(shaderName.c_str());
            puts(shader->getInfoLog());
            puts(shader->getInfoDebugLog());
        }

        FreeFileData(shaderStrings);
    }

    //
    // Program-level processing...
    //

    program.link(messages);
    if (! (Options & EOptionSuppressInfolog)) {
        puts(program.getInfoLog());
        puts(program.getInfoDebugLog());
    }

    // free everything up
    while (shaders.size() > 0) {
        delete shaders.back();
        shaders.pop_back();
    }

    // TODO: memory: for each compile, need a GetThreadPoolAllocator().pop();
}

int C_DECL main(int argc, char* argv[])
{
    bool compileFailed = false;
    bool linkFailed = false;
    
    // Init for front-end proper
    ShInitialize();

    // Init for for standalone
    glslang::InitGlobalLock();

    if (! ProcessArguments(argc, argv)) {
        usage();
        return EFailUsage;
    }

    //
    // Two modes:
    // 1) linking all arguments together, single-threaded
    // 2) independent arguments, can be tackled by multiple asynchronous threads, for testing thread safety
    //

    // TODO: finish threading, allow external control over number of threads
    const int NumThreads = 1;
    if (NumThreads > 1) {
        void* threads[NumThreads];
        for (int t = 0; t < NumThreads; ++t) {
            threads[t] = glslang::OS_CreateThread(&CompileShaders);
            if (! threads[t]) {
                printf("Failed to create thread\n");
                return EFailThreadCreate;
            }
        }
        glslang::OS_WaitForAllThreads(threads, NumThreads);
    } else {
        if (Options & EOptionsLinkProgram) {
            CompileAndLinkShaders();
        } else {
            if (! CompileShaders(0))
                compileFailed = true;
        }
    }

    if (Delay)
        glslang::OS_Sleep(1000000);

    if (compileFailed)
        return EFailCompile;
    if (linkFailed)
        return EFailLink;

    return 0;
}

//
//   Deduce the language from the filename.  Files must end in one of the
//   following extensions:
//
//   .vert = vertex
//   .tesc = tessellation control
//   .tese = tessellation evaluation
//   .geom = geometry
//   .frag = fragment
//   .comp = compute
//
EShLanguage FindLanguage(const std::string& name)
{
    size_t ext = name.rfind('.');
    if (ext == std::string::npos) {
        usage();
        return EShLangVertex;
    }

    std::string suffix = name.substr(ext + 1, std::string::npos);
    if (suffix == "vert")
        return EShLangVertex;
    else if (suffix == "tesc")
        return EShLangTessControl;
    else if (suffix == "tese")
        return EShLangTessEvaluation;
    else if (suffix == "geom")
        return EShLangGeometry;
    else if (suffix == "frag")
        return EShLangFragment;
    else if (suffix == "comp")
        return EShLangCompute;

    usage();
    return EShLangVertex;
}

//
// Read a file's data into a string, and compile it using the old interface ShCompile, 
// for non-linkable results.
//
bool CompileFile(const char *fileName, ShHandle compiler, int Options, const TBuiltInResource* resources)
{
    int ret;
    char** shaderStrings = ReadFileData(fileName);
    if (! shaderStrings) {
        usage();
        return false;
    }

    int* lengths = new int[NumShaderStrings];

    // move to length-based strings, rather than null-terminated strings
    for (int s = 0; s < NumShaderStrings; ++s)
        lengths[s] = strlen(shaderStrings[s]);

    if (! shaderStrings)
        return false;

    EShMessages messages = EShMsgDefault;
    if (Options & EOptionRelaxedErrors)
        messages = (EShMessages)(messages | EShMsgRelaxedErrors);
    if (Options & EOptionIntermediate)
        messages = (EShMessages)(messages | EShMsgAST);
    
    for (int i = 0; i < ((Options & EOptionMemoryLeakMode) ? 100 : 1); ++i) {
        for (int j = 0; j < ((Options & EOptionMemoryLeakMode) ? 100 : 1); ++j) {
            //ret = ShCompile(compiler, shaderStrings, NumShaderStrings, lengths, EShOptNone, resources, Options, 100, false, messages);
            ret = ShCompile(compiler, shaderStrings, NumShaderStrings, 0, EShOptNone, resources, Options, 100, false, messages);
            //const char* multi[4] = { "# ve", "rsion", " 300 e", "s" };
            //const char* multi[7] = { "/", "/", "\\", "\n", "\n", "#", "version 300 es" };
            //ret = ShCompile(compiler, multi, 4, 0, EShOptNone, resources, Options, 100, false, messages);
        }

        if (Options & EOptionMemoryLeakMode)
            glslang::OS_DumpMemoryCounters();
    }

    delete [] lengths;
    FreeFileData(shaderStrings);

    return ret ? true : false;
}

//
//   print usage to stdout
//
void usage()
{
    printf("Usage: standalone [ options ] filename\n"
           "Where: filename is a name ending in\n"
           "    .vert for a vertex shader\n"
           "    .tesc for a tessellation control shader\n"
           "    .tese for a tessellation evaluation shader\n"
           "    .geom for a geometry shader\n"
           "    .frag for a fragment shader\n"
           "    .comp for a compute shader\n\n"
           "Compilation warnings and errors will be printed to stdout.\n"
           "To get other information, use one of the following options:\n"
           "-i: intermediate tree (glslang AST) is printed out\n"
           "-d: delay exit\n"
           "-l: link validation of all input files\n"
           "-m: memory leak mode\n"
           "-s: silent mode\n"
           "-r: relaxed semantic error-checking mode\n");
}

#ifndef _WIN32

#include <errno.h>

int fopen_s(
   FILE** pFile,
   const char *filename,
   const char *mode
)
{
   if (!pFile || !filename || !mode) {
      return EINVAL;
   }

   FILE* f = fopen(filename, mode);
   if (! f) {
      if (errno != 0) {
         return errno;
      } else {
         return ENOENT;
      }
   }
   *pFile = f;

   return 0;
}

#endif

//
//   Malloc a string of sufficient size and read a string into it.
//
char** ReadFileData(const char *fileName) 
{
    FILE *in;
	int errorCode = fopen_s(&in, fileName, "r");
    char *fdata;
    int count = 0;
    const int maxSourceStrings = 5;
    char** return_data = (char**)malloc(maxSourceStrings+1);

    //return_data[MAX_SOURCE_STRINGS]=NULL;
	if (errorCode) {
        printf("Error: unable to open input file: %s\n", fileName);
        return 0;
    }
    
    while (fgetc(in) != EOF)
        count++;

	fseek(in, 0, SEEK_SET);
	
	
	if (!(fdata = (char *)malloc(count+2))) {
            printf("Error allocating memory\n");
            return 0;
    }
	if (fread(fdata,1,count, in)!=count) {
            printf("Error reading input file: %s\n", fileName);
            return 0;
    }
    fdata[count] = '\0';
    fclose(in);
    if(count==0){
        return_data[0]=(char*)malloc(count+2);
        return_data[0][0]='\0';
        NumShaderStrings=0;
        return return_data;       
    }

	int len = (int)(ceil)((float)count/(float)NumShaderStrings);
    int ptr_len=0,i=0;
	while(count>0){
		return_data[i]=(char*)malloc(len+2);
		memcpy(return_data[i],fdata+ptr_len,len);
		return_data[i][len]='\0';
		count-=(len);
		ptr_len+=(len);
		if(count<len){
            if(count==0){
               NumShaderStrings=(i+1);
               break;
            }
           len = count;
		}  
		++i;
	}
    return return_data;
}

void FreeFileData(char **data)
{
    for(int i=0;i<NumShaderStrings;i++)
        free(data[i]);
}

void InfoLogMsg(const char* msg, const char* name, const int num)
{
    printf(num >= 0 ? "#### %s %s %d INFO LOG ####\n" :
           "#### %s %s INFO LOG ####\n", msg, name, num);
}