makefile.js

// Special build system used for Halfix builds. Supports the following features:
//  - All built object files go in build/objs (no cluttering src/)
//  - Build multiple targets at once (i.e. switch between Emscripten and native
//  builds without having to clean)
//  - Parallel build (same as make -j)
//  - Certain files can be conditionally built based on the target
//  - Dependency resolution and conditional compilation (note: this is a bit
//  buggy)
//  - Automatic dependency regeneration (via redep)
//  - Simple to use (no configuration, multi-platform, etc.)
// Usage:
//  node makefile.js [target] [options]
// Omit 'target' for default native build.
// Run with --help for options and target list.

var fs = require('fs');
var child_process = require('child_process');
var os = require('os');

function load_json(e) {
    return JSON.parse(fs.readFileSync('build/' + e + '-files.json'));
}

var files = JSON.parse(fs.readFileSync('build/files.json'));
for (var i = 0; i < files.length; i++) {
    var nm = files[i];
    files[i] = load_json(nm);
    files[i].__name = nm;
}

var bits = os.arch() === 'x64' ? 64 : 32; // Add your architecture here!
var flags = [
    '-Wall', '-Wextra',
    '-g3', '-std=c99'
    // '-Wno-format-extra-args', '-Wno-format'
];
var end_flags = [], fincc_flags = [];

// flags.push.apply(flags, '-I/usr/include/SDL -D_GNU_SOURCE=1
// -D_REENTRANT'.split(' '));
// flags.push.apply(flags, '-L/usr/lib/x86_64-linux-gnu -lSDL -lSDLmain'.split('
// '));
end_flags = '-lSDL2 -lSDL2main -lm'.split(' ');

if (process.platform.endsWith('bsd')) {
    end_flags.splice(0, 0, process.platform == 'netbsd' ? '-L/usr/pkg/lib' : '-L/usr/local/lib');
    flags.push(process.platform == 'netbsd' ? '-I/usr/pkg/include' : '-I/usr/local/include');
    flags.push('-DBSD_BUILD');
}

if (os.endianness() === 'BE') {
    console.warn('WARNING: This emulator has not been tested on big-endian platforms and may not work.');
    flags.push('-DCFG_BIG_ENDIAN');
}

// XXX: capture live output from allegro-config --shared
//end_flags.push('-lalleg');

function getFlagsFromExec(a) {
    var child = child_process.execSync(a);
    console.log(child.toString());
    return child.toString().replace(/\n/g, '').split(' ');
}
function merge(dst, src) {
    for (var i = 0; i < src.length; i = i + 1 | 0)dst.push(src[i]);
}

var build32 = false;
var verbose = false;
var cc = process.env.CC || 'gcc',
    fincc = process.env.CC || 'gcc';
var build_type = 'native';

var optimization = '-O0';

var result = null;

var wasm = 0;

var argv = process.argv.slice(2);
for (var i = 0; i < argv.length; i++) {
    switch (argv[i]) {
        case 'redep':
            recompute_dependencies();
            console.log('Successfuly recalculated dependencies');
            process.exit(0);
            break;
        case 'clean':
            console.log('Removing all built files in build/');
            child_process.execSync(process.platform.startsWith('win') ? 'del build\\objs\\*.o' : 'rm build/objs/*.o');
            process.exit(0);
            break;
        case 'gtk':
            merge(flags, getFlagsFromExec('pkg-config --cflags gtk+-3.0'));
            merge(end_flags, getFlagsFromExec('pkg-config --libs gtk+-3.0'));
            build_type = 'gtk';
            break;
        case 'win32':
            build_type = 'win32';
            if (end_flags.includes('-lSDL2'))
                end_flags.splice(end_flags.indexOf('-lSDL2'), 1);
            if (end_flags.includes('-lSDL2main'))
                end_flags.splice(end_flags.indexOf('-lSDL2main'), 1);
            end_flags.push('-lgdi32', '-lcomdlg32');
            break;
        case 'mobile':
            build_type = 'mobile';
            flags.push('-DMOBILE_BUILD');
            end_flags.push('-lSDL2_ttf');
            break;
        case 'libcpu':
            build_type = 'libcpu';
            files[0] = {};
            files[2] = {};
            flags.push('-fPIC', '-shared');
            console.log(build_type);
            flags.push('-DLIBCPU');
            break;
        case 'libcpu-wasm':
            build_type = 'libcpu';
            result = 'libcpu.wasm';
            files[0] = {};
            files[2] = {};
            flags.push('-fPIC');
            cc = fincc = 'emcc';
            flags.push('-s', 'SIDE_MODULE=1');
            flags.push('-DLIBCPU');
            break;
        case 'release':
            if (!argv.includes('--optimization-level'))
                argv.push('--optimization-level', '3');
            argv.push('--disable-debug');
            break;
        case '--optimization-level':
            if (isNaN(parseInt(argv[i + 1])))
                optimization = '-O';
            else
                optimization = '-O' + (argv[++i]);
            break;
        case '--verbose':
            verbose = true;
            break;
        case '--32-bit':
            flags.push('-m32');
            break;
        case '--instrument':
            flags.push('-DINSTRUMENT');
            break;
        case '--profile':
            end_flags.push('-pg');
            break;
        case '--output':
            result = argv[++i];
            break;
        case '--zlib':
            end_flags.push('-lz');
            flags.push('-DENABLE_ZLIB');
            break;
        case '--logging':
            flags.push('-DENABLE_LOGGING');
            break;
        case 'emscripten':
            result = 'halfix.js';
            fincc = cc = 'emcc';
            build_type = 'emscripten';

            // List appropriate flags
            var my_flags = '';
            my_flags = my_flags.split(' ');
            end_flags.push('-s', 'NO_FILESYSTEM=1',
                '-s', 'TOTAL_MEMORY=256MB'
                //'-s', 'ASSERTIONS=1',
                //'-s', 'SAFE_HEAP=1'    
            );
            for (var j = 0; j < my_flags.length; j++) end_flags.push(my_flags[j]);
            break;
        case '--enable-wasm':
            wasm = 1;
            break;
        case '--cc':
            cc = fincc = argv[++i];
            break;
        case '--fincc':
            fincc = argv[++i];
            break;
        case '--disable-debug':
            flags.splice(flags.indexOf('-g3'), 1);
            break;
        case '--help':
            console.log('Actions:');
            console.log(
                '  redep                     Recalculate dependencies (useful for building)');
            console.log('  clean                     Remove all build files');
            console.log('\nTargets (besides native):');
            console.log('  emscripten                Build Emscripten target');
            console.log('\nBuild types:');
            console.log('  release                   Build fastest possible executable');
            console.log('\nOptions:');
            console.log(' --verbose                  Verbose logging during build');
            console.log(' --32-bit                   Build 32-bit target');
            console.log(
                ' --optimization-level [n]   Set optimization level of build to n (leave empty for -O)');
            console.log(' --output [path]            Set output file to path');
            console.log(
                ' --instrument               Enable instrumentation callbacks');
            console.log(' --profile                  Compile with -pg');
            console.log(' --disable-debug            Compile without debugging information');
            console.log(' --enable-wasm              Compile for WASM target');
            process.exit(0);
        default:
            console.error(
                'Unknown option ' + argv[i] +
                '. Run with --help to see all available options.');
            process.exit(1);
    }
}
if (!result) result = 'halfix';


if (build_type === 'emscripten') {
    end_flags.push('-s', 'WASM=' + wasm);
    // Emscripten no longer supports dynCall, apparently. 
    // Should've known better than to rely on an internal, undocumented method. 
    //end_flags.push(
    //    '-s', '\'EXTRA_EXPORTED_RUNTIME_METHODS=['dynCall_vii']\'');
    console.log(end_flags);
}

if (build_type === 'native' || build_type === 'mobile') {
    flags.push('-DSDL2_BUILD');
    flags.push('-DSDL2_INC_DIR');
    if (build_type === 'mobile')
        flags.push('-DMOBILE_WIP');
}

// https://github.com/emscripten-core/emscripten/issues/5659
if (build_type === 'emscripten')
    for (var i = 0; i < flags.length; i++) {
        if (flags[i] === '-std=c99') flags[i] = '-std=gnu99';
        if (end_flags.indexOf('WASM=1') !== -1) {
            //if (flags[i] === '-g3') flags[i] = '-g4';
        }
    }

if (result.indexOf('.js') !== -1 && build_type == 'libcpu') {
    for (var i = 0; i < flags.length; i++)
        if (flags[i] === '-shared') flags[i] = '';
    flags.push('-s', 'STANDALONE_WASM=1');
}
if (result.indexOf('.js') !== -1 || result.indexOf('.wasm') !== -1) {
    end_flags.splice(end_flags.indexOf('-lSDLmain'), 1);
    end_flags.splice(end_flags.indexOf('-lz'), 1);
}
flags.push('-D' + build_type.toUpperCase() + '_BUILD');

/*
if (optimization !== 0) {
    var i = flags.indexOf('-g3');
    flags[i] = '';
}*/

flags.push(optimization);

var path = require('path');

// A relatively unique, but distinct path.
// Combines the hash of the path, real name, and file flags
function find_object_file_name(fn) {
    var name = path.basename(fn, '.c');
    var dirname = path.dirname(fn);
    var result = 0;
    for (var i = 0; i < dirname.length; i++) {
        result += dirname.charCodeAt(i) | 0;
    }
    return 'build/objs/' + result.toString(36) + '-' + name + '-' +
        find_file_append() + '.o';
}

function find_file_append() {
    var id = 0;
    // Based on the current flags, we generate a unique number.
    // To make it as short is possible, we use the base 36 encoding.
    if (flags.indexOf('-m32') !== -1) { // Separate 32-bit build.
        id |= 0x80000000;
    }

    // ADD YOUR FLAGS HERE
    if (flags.indexOf('-g3') !== -1) id |= 1;
    if (flags.indexOf('-O0') !== -1) id |= 2;
    if (flags.indexOf('-O1') !== -1) id |= 4;
    if (flags.indexOf('-O2') !== -1) id |= 8;
    if (flags.indexOf('-O3') !== -1) id |= 16;
    if (cc === 'emcc') id |= 32;
    if (flags.indexOf('-pie') !== -1) id |= 64;
    if (flags.indexOf('-DINSTRUMENT') !== -1) id |= 128;
    if (flags.indexOf('-O') !== -1) id |= 256;
    if (flags.indexOf('-DLIBCPU') !== -1) id |= 512;
    if (flags.indexOf('SIDE_MODULE=1') !== -1) id |= 1024;

    // Hash the name of the build
    var x = 0;
    for (var i = 0; i < build_type.length; i++)
        x = (x + build_type.charCodeAt(i)) | 0;
    x ^= build_type.length;
    id |= x << 11;
    return id.toString(36);
}

var to_compile = [];
// Find a list of the files in our directory, so we know what we're looking at.
var build_files = fs.readdirSync('build/');

var all_files = [];

function run_pre_cmd(file_entry) {
    for (var i = 0; i < file_entry.tasks.length; i++) {
        child_process.execSync(file_entry.tasks[i]);
    }
}

function prune_out_similar() {
    var m = -1;
    for (var i = 0; i < flags.length; i++) {
        if (flags[i] === '-m32' || flags[i] === '-m64') {
            if (m !== -1) flags[m] = '';
            m = i;
        }
    }
}

// Create a list of which files we should be looking at. Note that this function
// may be called more than once if our flags change (i.e. we're compiling for a
// 64-bit target and all of a sudden compile.c forces us to go 32-bit)
function check_comp(obj) {
    top: for (var name in obj) {
        if (name == 'description' || name == 'archive' || name == '__name')
            continue;
        var file_entry = obj[name];
        // First, go through our files and see if we should compile them or not.
        var adf = file_entry.additional_flags;

        var additional_args = [];
        for (var i = 0; i < adf.length; i++) {
            var additional_flags = adf[i];
            if (additional_flags[0] === '@') {
                var toks = additional_flags.split('=');
                switch (toks[0]) {
                    case '@flags':
                        var parts = toks[1].split('|');
                        var noparts = [];
                        for (var j = 0; j < parts.length; j++) {
                            if (parts[j][0] === '!') {
                                noparts.push(parts[j].substring(1));
                                parts[j] = null;
                            }
                        }
                        if (parts.length == 1 && parts[0] === null) parts = [];
                        if (parts.length === 0) parts.push(build_type);
                        var x = false;
                        for (var j = 0; j < parts.length; j++) {
                            x = x || (parts[j]);
                        }
                        if (!x) parts.push(build_type);
                        // console.log(parts, noparts, build_type);
                        if (parts.indexOf(build_type) === -1 ||
                            noparts.indexOf(build_type) !== -1) {
                            if (verbose)
                                console.log(
                                    'Skipping file ' + name + ' because build type is \'' +
                                    build_type + '\'');
                            continue top;
                        }
                        break;
                    case '@options':
                        prune_out_similar();
                        var parts = toks[1].split('|');
                        var noparts = [];
                        for (var j = 0; j < parts.length; j++) {
                            if (parts[j][0] === '!') {
                                noparts.push(parts[j].substring(1));
                                parts[j] = null;
                            }
                        }
                        for (var j = 0; j < parts.length; j++) {
                            if (flags.indexOf(parts[j]) === -1) {
                                if (verbose)
                                    console.log(
                                        'Skipping file ' + name +
                                        ' because build does not include flag \'' + parts[j] +
                                        '\'');
                                continue top;
                            }
                        }
                        for (var j = 0; j < parts.length; j++) {
                            console.log
                            if (flags.indexOf(noparts[j]) !== -1) {
                                if (verbose)
                                    console.log(
                                        'Skipping file ' + name +
                                        ' because build does  include flag \'' + parts[j] + '\'');
                                continue top;
                            }
                        }
                        break;
                    case '@use':
                        // Check if our flags are mutually exclusive
                        if (flags.indexOf(toks[1]) === -1) {
                            if (verbose) {
                                console.log(
                                    'Recomputing files to compile to account for ' + toks[1]);
                            }
                            flags.push(toks[1]);
                            // Uh oh... we have a problem.
                            // We have to go back and recompute the files to find.
                            to_compile = [];
                            all_files = [];
                            throw 'recompute';
                        }
                        break;
                }
            } else {
                additional_args.push(additional_flags);
            }
        }

        all_files.push(name);
        var objn = find_object_file_name(name);
        // Check if the file exists.
        var d = fs.existsSync(objn);
        if (!d) {
            run_pre_cmd(file_entry);
            if (verbose)
                console.log('Rebuilding because file ' + objn + ' does not exist');
            to_compile.push({
                name: name,
                additional_args: additional_args,
                includes: file_entry.include_paths
            });
            continue top;
        }

        // Check if we've modified the file since then
        var obj_mtime = get_mtime(objn);

        // Get the mtime
        var fe_mtime = get_mtime(name);
        if (obj_mtime < fe_mtime) {
            run_pre_cmd(file_entry);
            if (verbose)
                console.log(
                    'Rebuilding ' + name + ' because the object file (' + objn +
                    ') was modified before the file');
            // console.log('obj', new Date(obj_mtime), 'dd', new Date(fe_mtime));
            to_compile.push({
                name: name,
                additional_args: additional_args,
                includes: file_entry.include_paths
            });
            continue top;
        }
        // Get its dependencies.
        var deps = file_entry.dependencies;
        for (var i = 0; i < deps.length; i++) {
            var dep_mtime = get_mtime(deps[i]);
            if (dep_mtime > obj_mtime) {
                // UH OH... we have updated our dependency.
                run_pre_cmd(file_entry);
                if (verbose)
                    console.log('Rebuilding ' + name + ' because dependency ' + deps[i]);
                to_compile.push({
                    name: name,
                    additional_args: additional_args,
                    includes: file_entry.include_paths
                });
                continue top; // No need to check the rest; we already know it is going
                // to be
                // compiled.
            }
        }
    }
}

var redo = false;

function check() {
    try {
        redo = false;
        for (var i = 0; i < files.length; i++) {
            check_comp(files[i]);
        }
        prune_out_similar();
    } catch (e) {
        if (e === 'recompute')
            redo = true;
        else
            throw e;
    }
}

do {
    check();
} while (redo);

var errored = [];
var child_processes = [];
var processes_to_complete = to_compile.length;
var processes_completed = 0;

if (to_compile.length === 0) {
    if (!fs.existsSync(result)) {
        done_compiling();
    } else {
        console.log('No files to compile');
        // process.exit(0);
        done_compiling();
    }
}

for (var i = 0; i < to_compile.length; i++) {
    var name = to_compile[i].name;
    var cmdline = flags.join(' ') + ' ' + name + ' ' +
        to_compile[i].additional_args.join(' ') + ' -c -o ' +
        find_object_file_name(name);
    var in_args = cmdline.trim().split(/\s+/);
    for (var j = 0; j < to_compile[i].includes.length; j++) {
        in_args.push('-I' + to_compile[i].includes[j]);
    }

    console.log(cc + ' ' + in_args.join(' '));
    child_processes[i] = child_process.spawn(cc, in_args, {
        stdio: 'inherit'
    });

    // Nasty hack
    child_processes[i].__filename__ = name;
    child_processes[i].on('close', function (code, signal) {
        if (code !== 0) {
            console.error('Failed to compile: ' + this.__filename__);
            errored.push(this.__filename__);
        }
        processes_completed++;
        if (processes_completed === processes_to_complete) {
            done_compiling();
        }
    });
}

function done_compiling() {
    console.log(
        '' + processes_completed - errored.length + '/' + processes_to_complete +
        ' compiled successfully!');
    console.log(
        'Files that errored: ' + errored.length === 0 ? 'NONE' :
            errored.join(', '));
    if (errored.length === 0) {
        // Final build step!
        // XXX: Fix for your platform
        if (fincc !== 'ar')
            var cmdstring = fincc + ' ' + fincc_flags.join(' ') + flags.join(' ') + ' -o ' + result + ' ';
        else
            var cmdstring = fincc + ' rv -o ' + result + ' ';
        for (var i = 0; i < all_files.length; i++) {
            cmdstring += find_object_file_name(all_files[i]) + ' ';
        }
        if (fincc !== 'ar')
            cmdstring += end_flags.join(' ');
        // if (build_type !== 'emscripten') { // apparently, emscripten has it built
        // in! how nice of them
        //    cmdstring += ['', '-lSDL', '-lSDLmain', '-I/usr/include/SDL'].join('
        //    ');
        //}
        try {
            console.log(cmdstring);
            child_process.execSync(cmdstring);
        } catch (e) {
            console.log('Compilation failed. See stdout for details');
            process.exit(1);
        }
    } else {
        process.exit(1);
    }
}
// A simple utility to get mtime.
function get_mtime(n) {
    var stat = fs.statSync(n);
    return stat.mtime.getTime();
}

function recompute_indiv(obj, file) {
    delete obj.__name; // Don't include in json
    for (var name in obj) {
        if (name == 'description' || name == 'archive') continue;
        var file_entry = obj[name];
        var cmd = 'gcc -MM ' + name + ' '; // We do this the lazy way
        for (var i = 0; i < file_entry.include_paths.length; i++) {
            cmd += '-I' + file_entry.include_paths[i] + ' ';
        }
        var output = child_process.execSync(cmd) + '';
        // First, connect the lines
        output = output.split('\\').join('');
        // Then get rid of that silly .o stuff at the beginning.
        output = output.substring(output.indexOf(':') + 1).trim();
        // Get our file list
        var files = output.split(/\s+/g);
        console.assert(
            name === files.shift(), 'Error: incorrect file'); // The first one
        // should be the C
        // source itself
        file_entry.dependencies = files;
    }
    fs.writeFileSync(
        'build/' + file + '-files.json', JSON.stringify(obj, null, 4));
}
end_flags

function
    recompute_dependencies() {
    // Simply recompute all dependencies for our files
    for (var i = 0; i < files.length; i++) {
        recompute_indiv(files[i], files[i].__name);
    }
}