configure

#!/usr/bin/python

# ./configure --platform=linux
#   > PLATFORM_LFLAGS=-lGL

# ./configure --platform=osx
#   > PLATFORM_LFLAGS=-framework OpenGL

# ./configure --debug
#   > DEBUG=-g -O0 -fno-inline
#   > EXECUTABLE=platformerd
#   > DEBUG_DEFINES=-DFOB_LOGGING -DFOB_ASSERTS_ENABLED

import subprocess
import getopt
import sys
import re

#-----------------------------------------------------------------------------
# Return the platform-specific header include paths.
#
def GetHeaderPaths(platform):
    paths = "-I./inc "

    if "linux" == platform:
        paths += " -I/usr/local/include"
        paths += " -I/usr/local/include/SDL"
        paths += " -I/usr/include/SDL"

    elif "osx" == platform:
        paths += " -I/Library/Frameworks/SDL.framework/Headers"
        paths += " -I/Library/Frameworks/SDL_image.framework/Headers"

    elif "windows" == platform:
        pass

    return paths

#-----------------------------------------------------------------------------
# Return the platform-specific linker flags.
#
def GetLinkerFlags(platform):

    if "linux" == platform:
        return "-lGL"

    elif "osx" == platform:
        return "-framework OpenGL " + \
               "-framework SDL " + \
               "-framework SDL_image " + \
               "-framework Cocoa"

    elif "windows" == platform:
        return ""

#-----------------------------------------------------------------------------
# Define a constant which specifies the platform we're working on.
#
def GetPlatformFlags(platform):

    if "linux" == platform:
        return "-DPLATFORM_LINUX"

    elif "osx" == platform:
        return "-DPLATFORM_OSX"

    elif "windows" == platform:
        return "-DPLATFORM_WINDOWS"

#-----------------------------------------------------------------------------
# Return a string that hopefully represents what the platform is.
#
def GetPlatform():
    os = subprocess.Popen(
        ["uname", "-s"],
        stdout = subprocess.PIPE
    ).communicate()[0].lower().strip()

    if os == "darwin":
        return "osx"

    elif os == "linux":
        return "linux"

    else:
        return "windows"

#-----------------------------------------------------------------------------
# Print out some useful text explaining how to use this script.
#
def Usage():
    print "usage: " + __file__ + " [options]"
    print "options:"
    print "\t[-d|--debug] configure for a debug build"


#-----------------------------------------------------------------------------
# Main
#-----------------------------------------------------------------------------


#-----------------------------------------------------------------------------
#
if __name__ == "__main__":
    debug = False
    makefile = "makefile"

    #-------------------------------------------------------------------------
    # Process all of our command-line options.
    #
    try:
        opts, args = getopt.getopt(
            sys.argv[1:],
            "hpd",
            ["help", "platform", "debug"]
        )
    except getopt.GetoptError, err:
        print str(err)
        Usage()
        sys.exit(2)

    for option, argument in opts:
        if option in ("-h", "--help"):
            Usage()
            sys.exit()
        elif option in ("-d", "--debug"):
            debug = True;
        else:
            assert False, "unhandled option"
    #
    # Finish processing command-line options.
    #-------------------------------------------------------------------------

    # First, copy makefile.template to makefile.
    subprocess.Popen(["cp", "makefile.template", makefile]);

    # Find the platform we're on.
    platform = GetPlatform()

    # Set the include directories.
    lines = open(makefile).readlines()
    out = open(makefile, "w")
    for line in lines:
        if re.match("CINCLUDES=", line):
            line = "CINCLUDES=" + GetHeaderPaths(platform) + "\n";
        out.write(line)
    out.close()

    # Set the linker flags.
    lines = open(makefile).readlines()
    out = open(makefile, "w")
    for line in lines:
        if re.match("PLATFORM_LFLAGS=", line):
            line = "PLATFORM_LFLAGS=" + GetLinkerFlags(platform) + "\n"
        out.write(line)
    out.close()

    # Set the platform defines.
    lines = open(makefile).readlines()
    out = open(makefile, "w")
    for line in lines:
        if re.match("PLATFORM_DEFINES=", line):
            line = "PLATFORM_DEFINES=" + GetPlatformFlags(platform) + "\n"
        out.write(line)
    out.close()

    if debug:
        # Setup our DEBUG values.
        lines = open(makefile).readlines()
        out = open(makefile, "w")
        for line in lines:
            #   > DEBUG=-g -O0 -fno-inline
            if re.match("DEBUG=", line):
                line = "DEBUG=-g -O0 -fno-inline\n"
            #   > DEBUG_DEFINES=-DFOB_LOGGING -DFOB_ASSERTS_ENABLED
            elif re.match("DEBUG_DEFINES=", line):
                line = "DEBUG_DEFINES=-DFOB_LOGGING -DFOB_ASSERTS_ENABLED\n"
            #   > EXECUTABLE=platformerd
            elif re.match("EXECUTABLE=", line):
                line = "EXECUTABLE=platformerd"
            out.write(line)
        out.close()