###############################################################################
##
##      ##  ######
##       ######  ###
##  ## ###############        Shark 3D Engine (www.shark3d.com)
##   ########## # # #
##    ########                Copyright (c) 1996-2006 Spinor GmbH.
##   ######### # # #          All rights reserved.
##  ##   ##########
##      ##
##
###############################################################################

##############################################################################
# Basic functions:

def sysmsg(txt):
    print "shark3d:", txt

def isdelim(c):
    return c == '/' or c == '\\'
    
def getwithdelim(path):
    if path != "" and not isdelim(path[-1]):
        return path + "/"
    else:
        return path
    
def isequivchar(c1, c2):
    if isdelim(c1) and isdelim(c2):    
        return True
    return c1 == c2
        
def isequivpath(p1, p2):
    effp1 = os.path.abspath(p1)
    effp2 = os.path.abspath(p2)
    if len(effp1) != len(effp2):
        return False
    for i in range(len(effp1)):
        if not isequivchar(effp1[i], effp2[i]):
            return False
    return True
        
def iswithin(fr, to):
    efffr = os.path.abspath(getwithdelim(fr))
    effto = os.path.abspath(to)
    return isequivpath(efffr, effto[0:len(efffr)])

def subpath(fr, to):
    efffr = getwithdelim(os.path.abspath(fr))
    effto = os.path.abspath(to)
    if isequivpath(efffr, effto[0:len(efffr)]):
        return effto[len(efffr):]
    else:
        err = "'%s' is not in '%s'." % (effto, efffr)
        raise StandardError, err

def mapfile(targetpath, targetbase, srcbase, srcsuffix):
    targetpath = os.path.abspath(targetpath)
    targetbase = os.path.abspath(targetbase)
    srcbase = os.path.abspath(srcbase)
    if targetbase != None:
        targetresname = subpath(targetbase, targetpath)
    else:
        targetresname = targetpath
    if srcsuffix != None:
        srcresname = os.path.splitext(targetresname)[0] + srcsuffix
    else:
        srcresname = targetresname
    if srcbase != None:
        srcpath = os.path.join(srcbase, srcresname)
    else:
        srcpath = srcresname
    return srcpath

def boolparam(b):
    if b:
        return "1"
    else:
        return "0"
    
def execescape(arg):
    # Unfortunately needed for Windows.
    # See http://mail.python.org/pipermail/python-bugs-list/
    #                           2001-December/008754.html
    arg = re.sub("\\\\", "\\\\\\\\", arg)
    arg = re.sub("\\\\\"", "\\\\\"", arg)
    arg = "\"" + arg + "\""
    return arg
    
def execcmd(prog, args, quiet = False):
    normprog = os.path.normpath(prog)
    effprog = normprog
    escprog = execescape(normprog)
    effargs = [escprog]
    effcmd = escprog
    for arg in args:
        escarg = execescape(arg)
        effargs = effargs + [escarg]
        effcmd = effcmd + " " + escarg
    if not quiet:        
        sysmsg(effcmd)
    result = 0
    try:
        result = os.spawnv(os.P_WAIT, effprog, effargs)
    except:
        result = 9999
    if result != 0:
        err = "Execution of '%s' failed with return value %i. " \
                % (normprog, result)
        sysmsg(err)
        return 1
    return 0
        
def getenv(key):
    val = ""
    try:
        val = os.environ[key]
    except KeyError:
        val = ""
    return val
    
def createdirrec(dir):
    if not os.path.exists(dir):
        os.makedirs(dir)
    
def createfilefirrec(path):
    dir = os.path.dirname(path)
    createdirrec(dir)
        
##############################################################################
# Builder management:

def is_target(path):
    if iswithin(bin_dir, path):
        return True
    if iswithin(tmp_dir, path):
        return True
    return False

def detect_builder(path):
    if is_target(path):
        for pat, bld in bldlst.iteritems():
            if fnmatch.fnmatch(path, pat):
                return (True, bld)
        return (False, None)
    else:
        return (True, None)

def define_builder(path):
    (found, bld) = detect_builder(path)
    if found:
        if not bld is None:
            bld(env, path, [])
    else:
        err = "No builder found for '%s'." % (path)
        raise StandardError, err
        
##############################################################################
# Snake utility functions:

def snkcollect(path, field):

    collecttxt = os.path.join(tmp_dir, "collect.txt")

    execcmd(tool_snk, \
        ["collect", path, collecttxt, field, "-quiet", "1"], \
        True)
    
    txtfile = open(collecttxt, "r")
    txtline = txtfile.readline()
    list = []
    while txtline:
        entry = re.match('^(.*)$', txtline).group(1)
        list.append(entry)
        txtline = txtfile.readline()
    txtfile.close()
    
    return list
    
def snkfetch(path, field):
    
    collecttxt = os.path.join(tmp_dir, "collect.txt")

    execcmd(tool_snk, \
        ["access", path, collecttxt, field, "-quiet", "1"], \
        True)
    
    txtfile = open(collecttxt, "r")
    txtline = txtfile.readline()
    entry = re.match('^(.*)$', txtline).group(1)
    txtfile.close()
    
    return entry 
    
##############################################################################
# Collect targets:

def collect_targets(dir):
    targetslst = os.path.join(tmp_dir, "res_targets.lst")

    execcmd(tool_targets, \
            ["res_targets.cfg", targetslst, dir, "-quiet", "1"], \
            True)
    
    targets_list = snkcollect(targetslst, "targets")
    
    return targets_list
        
##############################################################################
# Command line evaluation:

def eval_targets():
    createdirrec(tmp_dir)
    createdirrec(bin_dir)
    for param in COMMAND_LINE_TARGETS:
        if os.path.isdir(param):
            targetdir = getwithdelim(os.path.abspath(param))
            if iswithin(bin_dir, targetdir):
                targetdir = mapfile(targetdir, bin_dir, src_dir, None)
            sysmsg("Scanning '%s'... " % (targetdir))
            targetreslist = collect_targets(targetdir)
            sysmsg("Found %i targets in '%s'. " \
                    % (len(targetreslist), targetdir))
            for targetres in targetreslist:
                targetpath = os.path.join(bin_dir, targetres)
                define_builder(targetpath)
        else:
            targetpath = os.path.abspath(param)
            if iswithin(src_dir, targetpath):
                targetpath = mapfile(targetpath, src_dir, bin_dir, None)
            elif iswithin(bin_dir, targetpath):
                targetpath = targetpath
            else:
                err = "'%s' is not in '%s' or '%s'." \
                        % (targetpath, src_dir, bin_dir)
                raise StandardError, err            
            sysmsg("Using explicit target '%s'. " % (targetpath))
            define_builder(targetpath)

##############################################################################
# Global variables and settings:

env = Environment()

bldlst = {}

SourceSignatures('timestamp')

Default(None)

##############################################################################
# End of file.