WIP Builder script to compile and link c++ projects without dependencies with IDE project. Can be launched from an IDE with custom build tool target, but all the dependencies must be handled by the target.js file and builder.js

builder.js

/*
    @file builder.js (WIP)
    @author David Gallardo @galloscript 
    @brief  Builder script to compile and link c++ projects without dependencies with IDE project.
            Can be launched from an IDE with custom build tool target, but all the dependencies 
            must be handled by the target.js file and builder.js
*/

/*
    Example emtest.target.js

    exports.GetTargetData = function(aEnv)
    {
        var lData = {};
        lData.TargetName = 'emtest';
        lData.TargetType = 'exe';
        lData.SrcPath    = '.';

        return lData;
    };
*/

/*
    Example build.sh
    
    #!/bin/bash
    DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
    BUILDER=$DIR"/../builder.js"
    node $BUILDER build emtest macosx Release x86_64 $DIR
    node $BUILDER build emtest emscripten release wasm $DIR
*/


//- Modules ---------------------------------------
const spawn = require('child_process').spawnSync;
const fs = require('fs');

//- Constants -------------------------------------
const BUILDER_PLATFORM_WINDOWS      = 'mswindows'
const BUILDER_PLATFORM_MACOSX       = 'macosx'
const BUILDER_PLATFORM_EMSCRIPTEN   = 'emscripten'

//Platform exclusive directories
const BUILDER_WINDOWS_SOURCES_DIRNAME    = 'win';
const BUILDER_OSX_SOURCES_DIRNAME        = 'osx';
const BUILDER_EMSCRIPTEN_SOURCES_DIRNAME = 'ems';

//Target type
const BUILDER_STATIC_LIBRARY    = 'lib';
const BUILDER_DYNAMIC_LIBRARY   = 'dylib';
const BUILDER_EXECUTABLE        = 'exe';

//Configurations
const BUILDER_CONFIGURATIONS = 
{
    BUILDER_DEBUG   : 'debug',
    BUILDER_RELEASE : 'release'
};

//Versions
const BUILDER_VC_VERSION        = '14';
const BUILDER_OSXSDK_VERSION    = '10.11';

//- Global Configuration --------------------------
var GlobalConfig = {};

//- Utility ---------------------------------------

function CreatePathDirectories(aPath)
{
    aPath.split('/').reduce((path, folder) => 
    {
        path += folder + '/';
        if (!fs.existsSync(path))
        {
            fs.mkdirSync(path);
        }
        return path;
    }, '');   
}


//Returns a list of relative paths to compilable files
function TraverseSourcesDirectoryTree(aFiles, aDir, aExtensions, aExcluded)
{
    //console.log('Traversing '+aDir);
    var lList = fs.readdirSync(aDir);
    for(var f = 0; f < lList.length; ++f)
    {
        var lFile = aDir + '/' + lList[f];
        var lStat = fs.statSync(lFile);
        if (lStat && lStat.isDirectory())
        {
            TraverseSourcesDirectoryTree(aFiles, lFile, aExtensions, aExcluded);
        }
        else
        {
            var lExtension = lFile.replace(/.*\./, '').toLowerCase();
            if( (aExtensions.length == 0) || (aExtensions.indexOf(lExtension) != -1) )
            {
                aFiles.push(lFile);
            }
        }
    }
}

function PrepareCommand(aCommandStr, aOutputParamsObj)
{
    //Remove double whitespaces and split into array
    aCommandStr = aCommandStr.replace(/  +/g, ' ');

    console.log("Command: "+aCommandStr);

    //console.log(lSourceFiles[f]);
    var lCommandArray = aCommandStr.split(' ');

    //Separate command from parameters
    var lCommandExecutable = lCommandArray[0];
    lCommandArray.shift();
    aOutputParamsObj.CommandName = lCommandExecutable;
    aOutputParamsObj.CommandParameters = lCommandArray;
}

//- Compiler Configs ------------------------------
function ConfigureShared(aConfiguration, aWorkingDir, aTargetData)
{
    GlobalConfig.WorkingDir             = aWorkingDir;
    GlobalConfig.SourcesExtensions      = ['cpp', 'c', 'cc', 'cxx'];
    GlobalConfig.ExcludedDirectories    = 
    [   
        'avoid',
        'deprecated',
        BUILDER_WINDOWS_SOURCES_DIRNAME, 
        BUILDER_OSX_SOURCES_DIRNAME
    ];

    GlobalConfig.IntermediatePath = 'intermediate/'+aConfiguration+'/${TARGET_NAME}';

    GlobalConfig.IncludePaths = [];
    GlobalConfig.LibraryPaths = [ GlobalConfig.WorkingDir+'/bin/'+aConfiguration ];
    GlobalConfig.Libraries =  [];
    GlobalConfig.Frameworks = [];

    GlobalConfig.OutputPath = 'bin/'+aConfiguration;
}

function ConfigureVC(aConfiguration, aTargetData)
{
    GlobalConfig.ExcludedDirectories.splice(GlobalConfig.ExcludedDirectories.indexOf(BUILDER_WINDOWS_SOURCES_DIRNAME), 1);

    GlobalConfig.ObjExtension               = '.obj';
    GlobalConfig.StaticLibraryExtension     = '.lib';
    GlobalConfig.DynamicLibraryExtension    = '.dll';
    GlobalConfig.ExecutableExtension        = '.exe';
    GlobalConfig.LibraryPrefix              = '';

    //TODO: config for visual studio c++ compiler & linker
}

function ConfigureOSXClang(aConfiguration, aTargetData)
{
    GlobalConfig.SourcesExtensions = GlobalConfig.SourcesExtensions.concat(['m', 'mm']);
    GlobalConfig.ExcludedDirectories.splice(GlobalConfig.ExcludedDirectories.indexOf(BUILDER_OSX_SOURCES_DIRNAME), 1);

    GlobalConfig.ObjExtension               = '.o';
    GlobalConfig.StaticLibraryExtension     = '.a';
    GlobalConfig.DynamicLibraryExtension    = '.dylib';
    GlobalConfig.ExecutableExtension        = '';
    GlobalConfig.LibraryPrefix              = 'lib';

    GlobalConfig.CompilerCommand            = 'clang++ ${SOURCE_FILE} -c -g -Wall -arch x86_64 -mmacosx-version-min='+BUILDER_OSXSDK_VERSION+' -std=gnu++11 -stdlib=libc++ ${COMPILER_PARAMS} -o ${OBJECT_FILE}';
    GlobalConfig.CompilerAppendIncludePath  = ' -I${PATH}';
    
    switch(aConfiguration)
    {
        case BUILDER_CONFIGURATIONS.BUILDER_DEBUG:
        GlobalConfig.CompilerParams = ' -O0 -DDEBUG=1';
        break;
        case BUILDER_CONFIGURATIONS.BUILDER_RELEASE:
        default:
        GlobalConfig.CompilerParams = ' -Os';
        break;
    };

    GlobalConfig.CompilerExtraParams        = ' -Werror -Wno-missing-field-initializers -Wno-missing-prototypes -Werror=return-type '+
                                              ' -Wdocumentation -Wunreachable-code -Werror=deprecated-objc-isa-usage '+
                                              ' -Werror=objc-root-class -Wno-missing-braces -Wparentheses -Wswitch -Wunused-function '+
                                              ' -Wno-unused-label -Wno-unused-parameter -Wunused-variable -Wunused-value '+
                                              ' -Wempty-body -Wconditional-uninitialized -Wno-unknown-pragmas -Wshadow '+
                                              ' -Wno-four-char-constants -Wno-conversion -Wconstant-conversion -Wint-conversion '+
                                              ' -Wbool-conversion -Wenum-conversion -Wassign-enum -Wsign-compare -Wshorten-64-to-32 '+
                                              ' -Wpointer-sign -Wnewline-eof';

    GlobalConfig.LinkerAppendLibrary        = ' -l${LIBRARY_NAME}';
    GlobalConfig.LinkerAppendLibraryPath    = ' -L${LIBRARY_PATH}';
    GlobalConfig.LinkerAppendFramework      = ' -framework ${FRAMEWORK_NAME}';

    GlobalConfig.StaticLibraryCommand       = 'Libtool -static ${OBJECT_FILE_LIST} ${DEPENCENCIES} -o ${LIBRARY_FILE}';
    GlobalConfig.DynamicLibraryCommand      = 'Libtool -dynamic ${OBJECT_FILE_LIST} ${DEPENCENCIES} -o ${LIBRARY_FILE}';

    var lSysRoot                            = '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX'+BUILDER_OSXSDK_VERSION+'.sdk';
    GlobalConfig.ExecutableCommand          = 'clang++ ${OBJECT_FILE_LIST} -arch x86_64 -isysroot '+lSysRoot+' -mmacosx-version-min='+BUILDER_OSXSDK_VERSION+' ${DEPENCENCIES} -o ${EXECUTABLE_FILE}';

}

function ConfigureEmscripten(aConfiguration, aTargetData)
{
    GlobalConfig.ObjExtension               = '.bc';
    GlobalConfig.StaticLibraryExtension     = '.bc';
    GlobalConfig.DynamicLibraryExtension    = '.bc';
    GlobalConfig.ExecutableExtension        = '.html';
    GlobalConfig.LibraryPrefix              = 'lib';

    GlobalConfig.CompilerCommand            = 'emcc ${SOURCE_FILE} -c -g -Wall ${COMPILER_PARAMS} -o ${OBJECT_FILE}';
    GlobalConfig.CompilerAppendIncludePath  = ' -I${PATH}';
    
    switch(aConfiguration)
    {
        case BUILDER_CONFIGURATIONS.BUILDER_DEBUG:
        GlobalConfig.CompilerParams = ' -O0 -DDEBUG=1';
        break;
        case BUILDER_CONFIGURATIONS.BUILDER_RELEASE:
        default:
        GlobalConfig.CompilerParams = ' -Os';
        break;
    };

    GlobalConfig.CompilerExtraParams        = ' -Werror -Wno-missing-field-initializers -Wno-missing-prototypes -Werror=return-type '+
                                              ' -Wdocumentation -Wunreachable-code -Werror=deprecated-objc-isa-usage '+
                                              ' -Werror=objc-root-class -Wno-missing-braces -Wparentheses -Wswitch -Wunused-function '+
                                              ' -Wno-unused-label -Wno-unused-parameter -Wunused-variable -Wunused-value '+
                                              ' -Wempty-body -Wconditional-uninitialized -Wno-unknown-pragmas -Wshadow '+
                                              ' -Wno-four-char-constants -Wno-conversion -Wconstant-conversion -Wint-conversion '+
                                              ' -Wbool-conversion -Wenum-conversion -Wassign-enum -Wsign-compare -Wshorten-64-to-32 '+
                                              ' -Wpointer-sign -Wnewline-eof';

    GlobalConfig.LinkerAppendLibrary        = ' -l${LIBRARY_NAME}';
    GlobalConfig.LinkerAppendLibraryPath    = ' -L${LIBRARY_PATH}';
    GlobalConfig.LinkerAppendFramework      = ' -framework ${FRAMEWORK_NAME}';

    GlobalConfig.StaticLibraryCommand       = 'emcc ${OBJECT_FILE_LIST} ${DEPENCENCIES} -o ${LIBRARY_FILE}';
    GlobalConfig.DynamicLibraryCommand      = 'emcc ${OBJECT_FILE_LIST} ${DEPENCENCIES} -o ${LIBRARY_FILE}';

    GlobalConfig.ExecutableCommand          = 'emcc ${OBJECT_FILE_LIST} ${DEPENCENCIES} -o ${EXECUTABLE_FILE}';

}

//- Build -----------------------------------------
function Build(aTargetData, aConfiguration, aArchitecture, aPlatform)
{
    //Compiler
    var lCompilerCommand    = GlobalConfig.CompilerCommand;
    var lCompilerParams     = '';
    var lIntermediatePath   = GlobalConfig.IntermediatePath.replace('${TARGET_NAME}', aTargetData.TargetName);

    //Appen Include paths
    for(var i = 0; i < GlobalConfig.IncludePaths.length; ++i)
    {
        lCompilerParams += GlobalConfig.CompilerAppendIncludePath.replace('${PATH}', GlobalConfig.IncludePaths[i]);
    }

    //Append extra configuracion params
    lCompilerParams += GlobalConfig.CompilerParams;
    lCompilerParams += GlobalConfig.CompilerExtraParams;

    //Replace params
    lCompilerCommand = lCompilerCommand.replace('${COMPILER_PARAMS}', lCompilerParams);

    //Iterate files
    var lSourceFiles = [];
    var lObjectFiles = [];
    TraverseSourcesDirectoryTree(lSourceFiles, GlobalConfig.WorkingDir+'/'+aTargetData.SrcPath, GlobalConfig.SourcesExtensions, GlobalConfig.ExcludedDirectories);

    if(lSourceFiles.length == 0)
    {
        console.error('[builder.js] No source files found.');
        return 1;
    }

    var lOk = true; 
    for(var f = 0; f < lSourceFiles.length; ++f)
    {   
        //filename withoud working dir path
        var lRelativePath = lSourceFiles[f].replace(GlobalConfig.WorkingDir+'/', '');
        
        //Object file path
        var lIntermediateFilePath = GlobalConfig.WorkingDir+'/'+lIntermediatePath+'/'+lRelativePath+GlobalConfig.ObjExtension;
        var lIntermediateFileDirectory =  lIntermediateFilePath.substring(0, lIntermediateFilePath.lastIndexOf("/"));
        lObjectFiles.push(lIntermediateFilePath);

        // Create Intermediate directory if it doens't exist
        CreatePathDirectories(lIntermediateFileDirectory);

        //Create File command
        var lFileCommand = lCompilerCommand.replace('${SOURCE_FILE}', GlobalConfig.WorkingDir+'/'+lRelativePath).replace('${OBJECT_FILE}', lIntermediateFilePath);
        var lCommandData = {CommandName : '', CommandParameters : []};
        PrepareCommand(lFileCommand, lCommandData);

        //TODO: Exclude older object files
        //TODO: Multythread AND/OR Unity build
        //Run the compiler command
        var s = spawn(lCommandData.CommandName, lCommandData.CommandParameters, { stdio: 'inherit' }); 
        lOk = lOk && (s.status == 0);
    }

    if(!lOk) return 2;

    //Create Library
    if(BUILDER_STATIC_LIBRARY == aTargetData.TargetType)
    {
        var lLibraryOutputPath =     GlobalConfig.WorkingDir+
                                 '/'+GlobalConfig.OutputPath+
                                 '/'+GlobalConfig.LibraryPrefix
                                    +aTargetData.TargetName
                                    +GlobalConfig.StaticLibraryExtension;

        var lLibraryOutputDirectory =  lLibraryOutputPath.substring(0, lLibraryOutputPath.lastIndexOf("/"));

        var lLinkCommand = GlobalConfig.StaticLibraryCommand
            .replace('${OBJECT_FILE_LIST}', lObjectFiles.join(' '))
            .replace('${DEPENCENCIES}', '')
            .replace('${LIBRARY_FILE}', lLibraryOutputPath);

        var lCommandData = {CommandName : '', CommandParameters : []};
        PrepareCommand(lLinkCommand, lCommandData);

        // Create Output directory if it doens't exist
        CreatePathDirectories(lLibraryOutputDirectory);

        //Run the libtool command
        var s = spawn(lCommandData.CommandName, lCommandData.CommandParameters, { stdio: 'inherit' }); //(s.status == 0);
    }
    //Create Executable
    else if(BUILDER_EXECUTABLE == aTargetData.TargetType)
    {
        var lDepencencies = '';
        for(var i = 0; i < GlobalConfig.LibraryPaths.length; ++i)
        {
            lDepencencies += GlobalConfig.LinkerAppendLibraryPath.replace('${LIBRARY_PATH}', GlobalConfig.LibraryPaths[i]); 
        }

        for(var i = 0; i < GlobalConfig.Libraries.length; ++i)
        {
            lDepencencies += GlobalConfig.LinkerAppendLibrary.replace('${LIBRARY_NAME}', GlobalConfig.Libraries[i]); 
        }

        //TODO: append frameworks

        var lExecutableOutputPath = GlobalConfig.WorkingDir+'/'+GlobalConfig.OutputPath+'/'+aTargetData.TargetName+GlobalConfig.ExecutableExtension;
        var lExecutableOutputDirectory =  lExecutableOutputPath.substring(0, lExecutableOutputPath.lastIndexOf("/"));

        var lLinkCommand = GlobalConfig.ExecutableCommand
            .replace('${OBJECT_FILE_LIST}', lObjectFiles.join(' '))
            .replace('${DEPENCENCIES}', lDepencencies)
            .replace('${EXECUTABLE_FILE}', lExecutableOutputPath);

        var lCommandData = {CommandName : '', CommandParameters : []};
        PrepareCommand(lLinkCommand, lCommandData);

        // Create Output directory if it doens't exist
        CreatePathDirectories(lExecutableOutputDirectory);

        //Run the linker command
        var s = spawn(lCommandData.CommandName, lCommandData.CommandParameters, { stdio: 'inherit' }); //(s.status == 0);
    }
}


function Main()
{
    var lAction         = process.argv[2];
    var lTargetName     = process.argv[3];
    var lPlatform       = process.argv[4];
    var lConfiguration  = process.argv[5];
    var lArchitecture   = process.argv[6];
    var lWorkingDir     = process.argv[7] || process.pwd();

    console.log(lWorkingDir);

    if(!lArchitecture)
    {
        console.error('[builder.js] Incorrect number of arguments.');
        console.error('[builder.js] node builder.js action[build|clean] target_name platform[macosx|mswindows|emscripten] configuration[debug|release] architecture[x86|x86_64]');
        
        console.error('Current arguments: ');

        process.argv.forEach(function (val, index, array) 
        {
            console.error(index + ': ' + val);
        });

        return 1;
    }

    lAction         = lAction.toLowerCase();
    lPlatform       = lPlatform.toLowerCase();
    lConfiguration  = lConfiguration.toLowerCase();
    lArchitecture   = lArchitecture.toLowerCase();

    //Target data
    var lTargetFileName = lWorkingDir+'/'+lTargetName+'.target.js';
    var lTargetData     = require(lTargetFileName).GetTargetData();

    //Shared configuration
    ConfigureShared(lConfiguration, lWorkingDir, lTargetData);
    
    switch(lPlatform)
    {
        case BUILDER_PLATFORM_WINDOWS:      ConfigureVC(lConfiguration, lTargetData);         break;
        case BUILDER_PLATFORM_MACOSX:       ConfigureOSXClang(lConfiguration, lTargetData);   break;
        case BUILDER_PLATFORM_EMSCRIPTEN:   ConfigureEmscripten(lConfiguration, lTargetData); break;
    }    
    
    return Build(lTargetData, lConfiguration, lArchitecture, lPlatform);
}


var r = Main();
process.exit(r);