#!/usr/bin/python

import sys
import os
import copy
import xml.etree.ElementTree as etree
import uuid
import getopt
import zipfile
import shutil

EXT_MAPPING = { ".c": "c", ".cc": "cpp", ".cpp": "cpp", ".h": "h", ".s": "s"}

def parseError(str):
    print("*** error: \""+str+"\"\n");

def platformCompare(a, b):
    return cmp(a.count('*'), b.count('*'))


def platformSubseteqTest(a, b):
    a4=a.split("-")
    b4=b.split("-")
    ret=len(a4)==len(b4)
    i=0
    while i<len(a4) and i<len(b4):        
        ret=ret and (a4[i]==b4[i] or b4[i]=="*")
        i=i+1
#    sys.stderr.write("platformSubseteqTest("+a+", "+b+")="+str(ret))
    return ret

def parseFile(node, ctx, list):
    path=node.attrib["path"]
    abs_path=os.path.join(ctx["base"], ctx["root"], path)
#    sys.stderr.write "path="+abs_path
    filterMatch=True
    if "platform" in node.attrib:
        filter=node.attrib["platform"]
        filterMatch=platformSubseteqTest(ctx["platform"], filter)
        
    if filterMatch:
        file_ext=os.path.splitext(path)[1]
        if file_ext in EXT_MAPPING:
            ext=EXT_MAPPING[file_ext]
            if os.path.exists(abs_path):
                install=None
                if "install" in node.attrib and node.attrib["install"]=="yes":
                    install=os.path.dirname(os.path.relpath(abs_path, ctx["root"]))
##                    sys.stderr.write install
                file_item={ "path": abs_path, "ext": ext, "install": install }
                if "x" in node.attrib:
                    file_item["x"]=node.attrib["x"]
                list.append(file_item)
            else:
                parseError("file "+abs_path+" does not exist!")
        else:
            parseError("extension "+file_ext+" is unknown")

def parseFiles(target, node, ctx):
    for child in list(node):
        if child.tag=="file":
            parseFile(child, ctx, target)
        else:
            parseError("unhandled element: "+child.tag)

def setAttr(dict, node, tag):
    if tag in node.attrib:
        dict[tag]=node.attrib[tag]        

def fallbackCompare(a, b):
    return -cmp(a.count('-'), b.count('-'))


def generateFallbackList(platform):
    ret=[]
    p4=platform.split("-")
    for i in range(1<<len(p4)):
        p=""
        for j in range(len(p4)):
            m=(i&(1<<j))==(1<<j)
#            print " "+str(i)+" "+str(j)+" "+str(m)+" "+p
            if m:
                if len(p)>0:
                    p=p+"-"
                p=p+p4[j]
        if len(p)>0:
            ret.append(p)
    ret.sort(fallbackCompare)
    return ret

def updateCtx(conf, ctx, node):
    if "root" in node.attrib:
        root=ctx["root"]
        ctx=copy.copy(ctx)    
        rel_prj_path=os.path.split(ctx["root"])[1]
        prjconfigdir=os.path.join(ctx["config"], rel_prj_path, "config")
#        print "rel_prj_path="+rel_prj_path+" prjconfigdir="+prjconfigdir
        v=node.attrib["root"].format(platform=ctx["platform"], config=os.path.join(ctx["config"], "config"), prjconfig=prjconfigdir)
        f=node.attrib["root"].format(platform="{platform}", config=os.path.join(ctx["config"], "config"), prjconfig=prjconfigdir)
        if v!=f:
            conf["format"][os.path.join(root, v)]=os.path.join(root, f)

        ctx_root=os.path.join(root, v)
        if not os.path.exists(ctx_root):
            list=generateFallbackList(ctx["platform"])
            for p in list:
                v=node.attrib["root"].format(platform=p, config=os.path.join(ctx["config"], "config"), prjconfig=prjconfigdir)
                if os.path.exists(os.path.join(root, v)):
                    map=os.path.join(root, v)
                    conf["mapping"][map]=ctx_root
                    ctx_root=map
                    list=[]
        if not os.path.exists(ctx_root) and "platforms" in conf and ctx["platform"] in conf["platforms"] and "family" in conf["platforms"][ctx["platform"]]:
            family=conf["platforms"][ctx["platform"]]["family"]
            list=generateFallbackList(family)
#            print "list="+str(list)
            for p in list:
                v=node.attrib["root"].format(platform=p, config=os.path.join(ctx["config"], "config"), prjconfig= prjconfigdir)
                if os.path.exists(os.path.join(root, v)):
                    map=os.path.join(root, v)
                    conf["mapping"][map]=ctx_root
                    ctx_root=map
                    list=[]
        ctx["root"]=ctx_root
    return ctx

def parseDefines(ctx, node, dict):
    value=None
    if "value" in node.attrib:
        value=node.attrib["value"]
    if "name" in node.attrib:
        name=node.attrib["name"]
        dict[name]=value    
    else:
               parseError("define syntax invalid ("+nv+")");

def parseSettings(conf, node, ctx, lib):
    if node.tag=="settings":
        tag="defines"
    elif node.tag=="export":
        tag="exports"
    else:
               parseError("unknown setting: "+node.tag);
    for child in list(node):
        if child.tag=="define":
            parseDefines(ctx, child, lib[tag])    
        else:
            parseError("unhanded element: "+child.tag)

def parseDeps(node):    
    if "dep" in node.attrib:
        dep=node.attrib["dep"].split()
        return dep
    else:
        return []



def parseLibrary(conf, node, ctx, seq_type):
    lib_name=node.attrib["name"]
    lib_uuid=uuid.uuid5(uuid.NAMESPACE_URL, "urn:lib:"+lib_name)
    lib={"name": lib_name, "uuid": lib_uuid, "source": { "files": []}, "header": { "files": [], "target": "", "includes": [] }, "defines": {}, "exports": {}, "deps": parseDeps(node), "mode": "c90", "align": "", "external": False }    
    ctx=updateCtx(conf, ctx, node)
    setAttr(lib, node, "mode")
    setAttr(lib, node, "align")
    if not(lib_name in ctx["externals"]) or not("external" in ctx["externals"][lib_name]) or not(ctx["externals"][lib_name]["external"]):
        for child in list(node):
            if child.tag=="source":
                parseFiles(lib["source"]["files"], list(child), updateCtx(conf, ctx, child))
            elif child.tag=="header":
                setAttr(lib["header"], child, "target")
                child_ctx=updateCtx(conf, ctx, child)
                lib["header"]["includes"].append(child_ctx["root"])
                parseFiles(lib["header"]["files"], list(child), child_ctx)
            elif child.tag=="settings":
                parseSettings(conf, child, ctx, lib)
            elif child.tag=="export":
                parseSettings(conf, child, ctx, lib)
            else:
                parseError("unhanded element: "+child.tag)
    else:
        sys.stderr.write("using external "+lib_name)
        lib["external"]=True
    conf[seq_type].append(lib)

def isExcluded(conf, ctx, lib):
#    sys.stderr.write conf["platforms"]
    if ctx["platform"] in conf["platforms"]:
        platform=conf["platforms"][ctx["platform"]]
        return lib in platform["exclude"]
    else:
        return False

def parsePlatform(conf, node, ctx):
    if "name" in node.attrib:
        name=node.attrib["name"]
        platform={ "exclude": {}, "libs": [], "ldflags": "" }
        setAttr(platform, node, "family")
        setAttr(platform, node, "cc")
        setAttr(platform, node, "ar")
        setAttr(platform, node, "ld")
        setAttr(platform, node, "cflags")
        setAttr(platform, node, "cflags_c")
        setAttr(platform, node, "cflags_cpp")
        setAttr(platform, node, "cppflags")
        setAttr(platform, node, "ldflags")
        setAttr(platform, node, "host")
        if "exclude" in node.attrib:
            for prj in node.attrib["exclude"].split(" "):
                platform["exclude"][prj]=None
#            sys.stderr.write platform["exclude"]
        if "libs" in node.attrib:
            platform["libs"].extend(node.attrib["libs"].split(" "))
        conf["platforms"][name]=platform
    else:
        parseError("no name given for platform")
        

def parseTargets(conf, node, ctx):
    for child in list(node):
        if child.tag=="include":
            path=os.path.abspath(os.path.join(ctx["root"], child.attrib["path"]))
            new_ctx=copy.copy(ctx)        
            new_ctx["root"]=os.path.dirname(path)
            parseConfiguration(conf, path, new_ctx)
        elif child.tag=="library":
            parseLibrary(conf, child, ctx, "libraries")
        elif child.tag=="tool":
            parseLibrary(conf, child, ctx, "tools")
        elif child.tag=="platform":
            parsePlatform(conf, child, ctx)
        else:
            parseError("unhanded element: "+child.tag)

def parseConfiguration(conf, filename, ctx):
    sys.stderr.write("parsing "+filename+"\n")
    tree=etree.parse(filename)
    if tree is not None:
        parseTargets(conf, tree.getroot(), ctx)
    else:
        parseError("failed to open file \""+filename+"\"")



def depClosure2(conf, deps, ignoreExternal):
    ret=[]    
    gray=set(deps)
    black=set()
    while len(gray)>0:
        for lib in conf["libraries"]:
            if lib["name"] in gray:
                gray.remove(lib["name"])
                black.add(lib["name"])
                if not(ignoreExternal) or not(lib["external"]):
                    ret.append((lib, []))
                    lib_deps=lib["deps"]
                    for lib_dep in lib_deps:
                        if not lib_dep in black:
                            gray.add(lib_dep)
    return ret

def depCompare(a, b):
    if a[0] in b[1]:
        return 1
    elif b[0] in a[1]:
        return -1
    else:
        return 0

def depClosureStr(req_deps, deps):
    ret="depClosure("+str(req_deps)+") ="
    for lib in deps:
        ret=ret+" "+lib[0]["name"]+"<"
        for x in lib[1]:
            ret=ret+" "+x[0]["name"]
        ret=ret+" >"
    return ret

def depClosure(conf, req_deps, ignoreExternal):
    deps=depClosure2(conf, req_deps, ignoreExternal)
    for lib in deps:
        lib[1].extend(depClosure2(conf, lib[0]["deps"], ignoreExternal))
#    print depClosureStr(req_deps, deps)
#    deps.sort(depCompare)
#    print depClosureStr(req_deps, deps)
    ret=[]    
    for lib in deps:
        ret.append(lib[0]["name"])
#    print "\n"
    return ret

def gatherIncludeDirs(conf, ctx, deps):
    ret=[]
    aux={}
    for lib in conf["libraries"]:
        if lib["name"] in deps:
            for file in lib["header"]["files"]:
                if file["install"] is not None:
                    dir=os.path.dirname(file["path"])
                    dir=os.path.abspath(dir.rstrip(file["install"]))
                    dir=os.path.relpath(dir, ctx["base"])
                    if dir not in aux:
                        aux[dir]=None
                        ret.append(dir)
#    sys.stderr.write ret
    return ret

def gatherSources(conf, ctx, lib):
    sources=[]
    for file in lib["source"]["files"]:
        rel_source=os.path.relpath(file["path"], ctx["base"])
        sources.append((rel_source, file))
    return sources

#def generateOBJS(conf, ctx, lib, out, obj_dir, cppflags):
#    objs=[]
#    for file in lib["source"]["files"]:
#        rel_source=os.path.relpath(file["path"], ctx["base"])
#        rel_obj=os.path.join(obj_dir, os.path.splitext(rel_source)[0]+".o")
#        out_dir=os.path.dirname(rel_obj)
#        out.write(rel_obj+": "+rel_source+"\n")
#        out.write("\t@mkdir -p "+out_dir+"\n")
#        specific=""
#        if file["ext"]=="c":
#            specific ="$(CFLAGS_C) "
#        elif file["ext"]=="cpp":
#            specific ="$(CFLAGS_CPP) "
#        out.write("\t$(CC) -c $(CFLAGS) "+ specific +"$(CPPFLAGS)"+cppflags+" "+ rel_source+" -o "+rel_obj+"\n")
#        objs.append(rel_obj)
#    return objs

def generateDEPS(conf, ctx, lib, out, obj_dir, cppflags, filename):
    for file in lib["source"]["files"]:
        rel_source=os.path.relpath(file["path"], ctx["base"])
        specific=""
        if file["ext"]=="c":
            specific ="$(CFLAGS_C) "
        elif file["ext"]=="cpp":
            specific ="$(CFLAGS_CPP) "
        out.write("\tmakedepend -a -f"+filename+" $(CPPFLAGS)"+cppflags+" "+ rel_source+"\n")

def generateCPPFLAGS(conf, ctx, lib, build_dir):
    cppflags=""
    for define in lib["defines"]:
        if lib["defines"][define] is None:
            cppflags=cppflags+" -D"+define
        else:
            cppflags=cppflags+" -D"+define+"="+lib["defines"][define]
    for dir in lib["header"]["includes"]:
        abs_dir=os.path.abspath(dir)
        rel_dir=os.path.relpath(abs_dir, os.path.join(ctx["base"], build_dir))
#        sys.stderr.write("abs_dir="+str(abs_dir)+" build_dir="+os.path.join(ctx["base"], build_dir)+" rel_dir="+str(rel_dir))
        cppflags=cppflags+" -I"+rel_dir
    dep_closure=depClosure(conf, lib["deps"], False)
    dep_dirs=gatherIncludeDirs(conf, ctx, dep_closure)
    for dir in dep_dirs:
        abs_dir=os.path.abspath(dir)
        rel_dir=os.path.relpath(abs_dir, os.path.join(ctx["base"], build_dir))
#        sys.stderr.write("abs_dir="+str(abs_dir)+" build_dir="+os.path.join(ctx["base"], build_dir)+" rel_dir="+str(rel_dir))
        cppflags=cppflags+" -I"+rel_dir
    for dep_lib in conf["libraries"]:
        if dep_lib["name"] in ctx["externals"]:
            ext_lib=ctx["externals"][dep_lib["name"]]
            if "external" in ext_lib and ext_lib["external"]:                        
                if "cppflags" in ext_lib:
                    cppflags=cppflags+" "+ext_lib["cppflags"]

    return cppflags


def generateVCXPROJ(conf, ctx, lib, type):
    filename=os.path.abspath("win32\\"+lib["name"]+"\\"+lib["name"]+".vcxproj")
    filepath=os.path.dirname(filename)
    prj_uuid=lib["uuid"]
    sys.stderr.write("generating "+filename+"\n")
    try:
        os.makedirs(os.path.dirname(filename))
    except OSError:
        pass

    out=open(filename, "w")
    out.write("<Project DefaultTargets=\"Build\" ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n");
    out.write("<ItemGroup Label=\"ProjectConfigurations\">\n");
    out.write(" <ProjectConfiguration Include=\"Debug|Win32\">\n");
    out.write("   <Configuration>Debug</Configuration>\n");
    out.write("   <Platform>Win32</Platform>\n");
    out.write(" </ProjectConfiguration>\n");
    out.write("<ProjectConfiguration Include=\"Release|Win32\">\n");
    out.write("   <Configuration>Release</Configuration>\n");
    out.write("   <Platform>Win32</Platform>\n");
    out.write("</ProjectConfiguration>\n");
    out.write("</ItemGroup>\n");
    out.write("<PropertyGroup Label=\"Globals\">\n");
    out.write("    <ProjectGuid>{"+str(prj_uuid)+"}</ProjectGuid>\n");
    out.write("    <Keyword>Win32Proj</Keyword>\n");
    out.write("    <RootNamespace>"+lib["name"]+"</RootNamespace>\n");
    out.write("</PropertyGroup>\n");
    out.write("<Import Project=\"$(VCTargetsPath)\Microsoft.Cpp.default.props\" />\n");
    out.write("  <PropertyGroup Condition=\"'$(Configuration)|$(Platform)'=='Debug|Win32'\" Label=\"Configuration\">\n");
    out.write("    <ConfigurationType>"+type+"</ConfigurationType>\n");
    out.write("    <UseDebugLibraries>true</UseDebugLibraries>\n");
    out.write("    <CharacterSet>Unicode</CharacterSet>\n");
    out.write("  </PropertyGroup>\n");
    out.write("  <PropertyGroup Condition=\"'$(Configuration)|$(Platform)'=='Release|Win32'\" Label=\"Configuration\">\n");
    out.write("    <ConfigurationType>"+type+"</ConfigurationType>\n");
    out.write("    <UseDebugLibraries>false</UseDebugLibraries>\n");
    out.write("    <WholeProgramOptimization>true</WholeProgramOptimization>\n");
    out.write("    <CharacterSet>Unicode</CharacterSet>\n");
    out.write("  </PropertyGroup>\n");
    out.write("<Import Project=\"$(VCTargetsPath)\Microsoft.Cpp.props\" />\n");
    out.write("<ImportGroup Label=\"ExtensionSettings\" />\n");
    out.write("<ImportGroup Label=\"PropertySheets\" />\n");
    out.write("<PropertyGroup Label=\"UserMacros\" />\n");
    out.write("<PropertyGroup />\n");
    out.write("<ItemDefinitionGroup>\n");
    out.write("<ClCompile>\n");
    dep_closure=depClosure(conf, lib["deps"], False)
    cpp_defs="WIN32;"
    for define in lib["defines"]:
        if lib["defines"][define] is None:
            cpp_defs=cpp_defs+define+";"
        else:
            cpp_defs=cpp_defs+define+"="+lib["defines"][define]+";"
    for dep in dep_closure:
        for dep_lib in conf["libraries"]:
            if dep_lib["name"]==dep and not isExcluded(conf, ctx, dep):
                for define in dep_lib["exports"]:
                    if dep_lib["exports"][define] is None:
                        cpp_defs=cpp_defs+define+";"
                    else:
                        cpp_defs=cpp_defs+define+"="+dep_lib["defines"][define]+";"
    cpp_defs=cpp_defs+"_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)"
    out.write("<PreprocessorDefinitions>"+cpp_defs+"</PreprocessorDefinitions>\n" )
    AdditionalIncludeDirectories=""
    for dir in lib["header"]["includes"]:
        AdditionalIncludeDirectories=AdditionalIncludeDirectories+os.path.relpath(os.path.abspath(dir), filepath)+";"    
    dep_dirs=gatherIncludeDirs(conf, ctx, dep_closure)
    for dir in dep_dirs:
        abs_path=os.path.relpath(os.path.abspath(dir), filepath)
        AdditionalIncludeDirectories=AdditionalIncludeDirectories+abs_path+";"
    AdditionalIncludeDirectories=AdditionalIncludeDirectories+"%(AdditionalIncludeDirectories)"
    out.write("<AdditionalIncludeDirectories>"+AdditionalIncludeDirectories+"</AdditionalIncludeDirectories>\n")
    if "c99"==lib["mode"]:
        out.write("<CompileAs>CompileAsCpp</CompileAs>\n");
    if ""!=lib["align"]:
        out.write("<StructMemberAlignment>"+lib["align"]+"Byte</StructMemberAlignment>\n");
    out.write("</ClCompile>\n");
    if "Application"==type:
        out.write("<Link>\n");
        out.write("<AdditionalDependencies>")
        if ctx["platform"] in conf["platforms"]:
            ext_libs=conf["platforms"][ctx["platform"]]["libs"]
        else:
            ext_libs={}
#        sys.stderr.write ext_libs
        for ext_lib in ext_libs:
#            sys.stderr.write ext_lib
            out.write(ext_lib+";")
        out.write("%(AdditionalDependencies)</AdditionalDependencies> \n")
        out.write("</Link>\n");
        out.write("</ItemDefinitionGroup>\n");


    out.write("<ItemDefinitionGroup Condition=\"'$(Configuration)|$(Platform)'=='Debug|Win32'\">\n")
    out.write("<ClCompile>\n");
    out.write("<WarningLevel>Level3</WarningLevel>\n")
    out.write("<Optimization>Disabled</Optimization>\n")
    out.write("<DisableSpecificWarnings>4996</DisableSpecificWarnings>\n")
    out.write("</ClCompile>\n");
    if "Application"==type:
        out.write("<Link>\n");
        out.write("<GenerateDebugInformation>true</GenerateDebugInformation>\n")
        out.write("<SubSystem>Console</SubSystem>\n")
        out.write("</Link>\n");    
        out.write("</ItemDefinitionGroup>\n");

    out.write("<ItemDefinitionGroup Condition=\"'$(Configuration)|$(Platform)'=='Release|Win32'\">\n")
    out.write("<ClCompile>\n")
    out.write("<Optimization>MaxSpeed</Optimization>\n")
    out.write("<DisableSpecificWarnings>4996</DisableSpecificWarnings>\n")
    out.write("<FunctionLevelLinking>true</FunctionLevelLinking> \n")
    out.write("<IntrinsicFunctions>true</IntrinsicFunctions> \n")
    out.write("</ClCompile>\n");
    if "Application"==type:
        out.write("<Link>\n");
        out.write("<GenerateDebugInformation>false</GenerateDebugInformation>\n")
        out.write("<SubSystem>Console</SubSystem>\n")
        out.write("<EnableCOMDATFolding>true</EnableCOMDATFolding>\n")
        out.write("<OptimizeReferences>true</OptimizeReferences>\n")
        out.write("</Link>\n");    
        out.write("</ItemDefinitionGroup>\n");

        out.write("<ItemGroup>\n");
        for file in lib["header"]["files"]:
            if "h"==file["ext"]:
                out.write("  <ClInclude Include=\""+os.path.relpath(file["path"], filepath)+"\"/>\n");
        out.write("</ItemGroup>\n");
        out.write("<ItemGroup>\n");
        for file in lib["source"]["files"]:
            if "cpp"==file["ext"] or "c"==file["ext"] or "s"==file["ext"]:
                out.write("  <ClCompile Include=\""+os.path.relpath(file["path"], filepath)+"\">\n");
                out.write("  </ClCompile>\n");
        out.write("</ItemGroup>\n");
        out.write("<ItemGroup>\n");
    for dep in dep_closure:
        for dep_lib in conf["libraries"]:
            if dep_lib["name"]==dep and not isExcluded(conf, ctx, dep_lib["name"]):
                out.write("<ProjectReference Include=\"../"+dep_lib["name"]+"/"+dep_lib["name"]+".vcxproj\">\n")
                out.write("<Project>{"+str(dep_lib["uuid"])+"}</Project>\n")
                out.write("</ProjectReference>\n")
        out.write("</ItemGroup>\n")
        out.write("<Import Project=\"$(VCTargetsPath)\Microsoft.Cpp.targets\" />\n");
        out.write("<ImportGroup Label=\"ExtensionTargets\" />\n");
        out.write("</Project>\n");
    out.close()

def writeProject(out, solution_uuid, lib):
    out.write("Project(\"{"+str(solution_uuid)+"}\") = \""+lib["name"]+"\", \""+lib["name"]+"\\"+lib["name"]+".vcxproj\", \"{"+str(lib["uuid"])+"}\"\n")
    out.write("EndProject\n")

def generatePlatformList(conf, ctx):
    add=[]
    for platform in conf["platforms"]:
        if platformSubseteqTest(ctx["platform"], platform):
            add.append(platform)
    #add.sort(platformCompare)
    add.sort()
    return add

def generateConfiguration(ctx, includes, platform):
    conf={ "libraries": [], "tools": [], "platforms": {}, "mapping": {}, "format": {} }
    ctx["platform"]=platform
    for include in includes:
        parseConfiguration(conf, include, ctx)
    if ctx["platform"] not in conf["platforms"]:    
        add=generatePlatformList(conf, ctx);
        if len(add)>0:
            conf["platforms"][ctx["platform"]]=conf["platforms"][add[0]]
    return conf

def generateWin32(ctx, source):
    platform=ctx["platforms"][0]
    conf=generateConfiguration(ctx, [source], platform)
    sys.stderr.write("generate win32 project")
    for lib in conf["libraries"]:
        if not isExcluded(conf, ctx, lib["name"]):
            generateVCXPROJ(conf, ctx, lib, "StaticLibrary")
    for tool in conf["tools"]:
        if not isExcluded(conf, ctx, tool["name"]):
            generateVCXPROJ(conf, ctx, tool, "Application")
    solution_file=os.path.abspath("win32\\solution.sln")
    solution_uuid=uuid.uuid5(uuid.NAMESPACE_URL, solution_file)
    out=open(solution_file, "w")
    out.write("\n")
    out.write("Microsoft Visual Studio Solution File, Format Version 11.00\n")
    for lib in conf["libraries"]:
        if not isExcluded(conf, ctx, lib["name"]):
            writeProject(out, solution_uuid, lib)
    for tool in conf["tools"]:
        if not isExcluded(conf, ctx, tool["name"]):
            writeProject(out, solution_uuid, tool)
    out.write("\n")
    out.close()


def writeSourceRules(conf, ctx, lib_type, out, lib, build_dir):
    dirs={}
    sources=gatherSources(conf, ctx, lib)
    out.write("objs_"+lib["name"]+"=\\\n")
    for source in sources:
        out.write("     $(BUILD_DIR)/"+os.path.splitext(source[0])[0]+".o\\\n")
        dirs[os.path.dirname(source[0])]=None
    out.write("     \n")
    out.write(lib["name"]+"_includes="+generateCPPFLAGS(conf, ctx, lib, build_dir)+"\n")
    out.write("\n")
    includes="$("+lib["name"]+"_includes)"
    lib_type_flags=""
    if lib_type=="shared":
        if platformSubseteqTest(ctx["platform"], "linux-*-gcc-*"):
            lib_type_flags=" -fPIC -DPIC"
        elif platformSubseteqTest(ctx["platform"], "darwin-*-gcc-*"):
            lib_type_flags=" -fno-common"
    # write special rules
    for source in sources:
        file=source[1]
        if "x" in file:
            special="-x "+file["x"]+" "
            out.write("$(BUILD_DIR)/"+os.path.splitext(source[0])[0]+".o: $(SRC_DIR)/"+source[0]+"\n")
            out.write("\t@mkdir -p $(dir $@)\n")
            out.write("\t$(CC) $(CFLAGS) $(CFLAGS_C) $(CPPFLAGS) "+special+includes+lib_type_flags+" -c \"$<\" -o \"$@\"\n")
    # write generic rules
    for dir in dirs:
        for ext in EXT_MAPPING:
            if EXT_MAPPING[ext]=='c' or EXT_MAPPING[ext]=='s':
                out.write("$(BUILD_DIR)/"+dir+"/%.o: $(SRC_DIR)/"+dir+"/%"+ext+"\n")
                out.write("\t@mkdir -p $(dir $@)\n")
                out.write("\t$(CC) $(CFLAGS) $(CFLAGS_C) $(CPPFLAGS) "+includes+lib_type_flags+" -c \"$<\" -o \"$@\"\n")
                out.write("\n")
            elif EXT_MAPPING[ext]=='cpp':
                out.write("$(BUILD_DIR)/"+dir+"/%.o: $(SRC_DIR)/"+dir+"/%"+ext+"\n")
                out.write("\t@mkdir -p $(dir $@)\n")
                out.write("\t$(CC) $(CFLAGS) $(CFLAGS_CPP) $(CPPFLAGS) "+includes+lib_type_flags+" -c \"$<\" -o \"$@\"\n")
                out.write("\n")

def writeMakefileFlags(conf, ctx, out):
    platform=ctx["platform"]
    out.write("CC="+conf["platforms"][platform]["cc"]+"\n");
    out.write("AR="+conf["platforms"][platform]["ar"]+"\n");
    out.write("CFLAGS="+conf["platforms"][platform]["cflags"]+"\n")
    out.write("CFLAGS_C="+conf["platforms"][platform]["cflags_c"]+"\n")
    out.write("CFLAGS_CPP="+conf["platforms"][platform]["cflags_cpp"]+"\n")
    out.write("CPPFLAGS="+conf["platforms"][platform]["cppflags"]+"\n");
    out.write("LDFLAGS="+conf["platforms"][platform]["ldflags"]+"\n");

def getSharedExt(conf, ctx):
    if platformSubseteqTest(ctx["platform"], "darwin-*-gcc-*"):
        return ".dylib"
    else:
        return ".so"

def generateExtLDFlags(conf, ctx):
    ext_ldflags=""
    for dep_lib in conf["libraries"]:
        if dep_lib["name"] in ctx["externals"]:
            ext_lib=ctx["externals"][dep_lib["name"]]
            if "external" in ext_lib and ext_lib["external"]:                        
                if "ldflags" in ext_lib:
                    ext_ldflags=ext_ldflags+" "+ext_lib["ldflags"]
    return ext_ldflags

def generateLDFlags(conf, ctx, lib_type, initial_deps, exclude_deps, lib_form):
    ret=""
    deps=depClosure(conf, initial_deps, True)
    for dep in deps:
        if not(dep in exclude_deps):
            if lib_type=="static":
                ret=ret+" $(BUILD_DIR)/lib"+dep+".a"
            if lib_type=="shared":
                if lib_form:
                    ret=ret+" -L$(BUILD_DIR) -l"+dep
                else:
                    ret=ret+" $(BUILD_DIR)/lib"+dep+getSharedExt(conf, ctx)

    return ret


def generateLibraryMakefile(conf, ctx, lib_type, lib, filename, build_dir, src_dir):
    sys.stderr.write("generating "+filename+"\n")
    if not os.path.exists(os.path.dirname(filename)):
            os.makedirs(os.path.dirname(filename))
    out=open(filename, "w")
    out.write("# Generated.\n")
    # compiler flags
    writeMakefileFlags(conf, ctx, out)
    out.write("BUILD_DIR=.\n")
    out.write("SRC_DIR="+src_dir+"\n")
    out.write("\n")
    out.write(".PHONY: all clean\n")
    out.write("\n")
    out.write("# library "+lib["name"]+"\n")
    out.write("all:")
    if lib_type=="static":
        out.write(" $(BUILD_DIR)/lib"+lib["name"]+".a")
    if lib_type=="shared":
        out.write(" $(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx))
    out.write("\n\n")
    writeSourceRules(conf, ctx, lib_type, out, lib, build_dir)
    if lib_type=="static":
        out.write("$(BUILD_DIR)/lib"+lib["name"]+".a: $(objs_"+lib["name"]+")\n")
        out.write("\t$(AR) -rcs $(BUILD_DIR)/lib"+lib["name"]+".a $(objs_"+lib["name"]+")\n")
        out.write("\n")
    if lib_type=="shared":
        ld_deps=generateLDFlags(conf, ctx, lib_type, lib["deps"], [lib["name"]], True)+generateExtLDFlags(conf, ctx)
        out.write("$(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx)+": $(objs_"+lib["name"]+")\n")
        if platformSubseteqTest(ctx["platform"], "darwin-*-gcc-*"):
            out.write("\t$(CC) -dynamiclib -install_name lib"+lib["name"]+getSharedExt(conf, ctx)+" -o $(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx)+" $(objs_"+lib["name"]+")"+ld_deps+"\n")
        else:
            out.write("\t$(CC) -shared -Wl,-soname,lib"+lib["name"]+getSharedExt(conf, ctx)+" -Wl,-z,defs  -fPIC -o $(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx)+" $(objs_"+lib["name"]+")"+ld_deps+" -lc\n")
            out.write("\tstrip --remove-section=.comment --remove-section=.note --strip-unneeded $(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx))
        out.write("\n")
    out.write("clean:\n")
    out.write("\trm -rf $(BUILD_DIR)/lib"+lib["name"]+".a $(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx)+" $(objs_"+lib["name"]+")\n")
    out.close()
    
def generateLibraryInclude(conf, ctx, lib, filename, build_dir, src_dir):
    sys.stderr.write("generating "+filename+"\n")
    if not os.path.exists(os.path.dirname(filename)):
            os.makedirs(os.path.dirname(filename))
    ret=[]
    lib_deps=lib["deps"]
    lib_deps.append(lib["name"])
#    out.write("deps="+str(lib["deps"])+"\n");
    dep_closure=depClosure(conf, lib_deps, False)
    dep_dirs=gatherIncludeDirs(conf, ctx, dep_closure)
    for dep in dep_dirs:
        dep_dir=os.path.join(ctx["base"], str(dep))
        if dep_dir in conf["mapping"]:
            dep_dir=conf["mapping"][dep_dir]
        if dep_dir in conf["format"]:
            ln_src=os.path.join(build_dir, "include", os.path.relpath(conf["format"][dep_dir], ctx["base"]).format(platform="platform").replace(os.sep, "_"))
            ln_dst=os.path.join(src_dir, dep)
            if os.path.exists(ln_src):
                os.remove(ln_src)
            print("symlink("+ln_dst+", "+ln_src+")"+str(os.path.exists(ln_src)))
            os.symlink(ln_dst, ln_src)
            ret.append(ln_src)
        else:
            ret.append(dep)

    out=open(filename, "w")
    for file in ret:
        out.write(file+"\n")
    out.close()


def generateToolMakefile(conf, ctx, lib_type, tool, filename, build_dir, src_dir):
    sys.stderr.write("generating "+filename+"\n")
    if not os.path.exists(os.path.dirname(filename)):
            os.makedirs(os.path.dirname(filename))
    out=open(filename, "w")
    out.write("# Generated.\n")
    # compiler flags
    writeMakefileFlags(conf, ctx, out)
    out.write("BUILD_DIR=.\n")
    out.write("SRC_DIR="+src_dir+"\n")
    out.write("\n")
    out.write(".PHONY: all clean\n")
    out.write("\n")
    out.write("# tool "+tool["name"]+"\n")
    out.write("all: $(BUILD_DIR)/"+ tool["name"]+"\n\n")
    writeSourceRules(conf, ctx, "static", out, tool, build_dir)
    out.write(tool["name"]+"_ld="+generateLDFlags(conf, ctx, lib_type, tool["deps"], [], False)+"\n")
#    deps=depClosure(conf, tool["deps"], True)
#    for dep in deps:
#        if lib_type=="static":
#            out.write(" $(BUILD_DIR)/lib"+ dep +".a")    
#        if lib_type=="shared":
#            out.write(" $(BUILD_DIR)/lib"+ dep +getSharedExt(conf, ctx))    
#    out.write("\n")
    ext_ldflags=generateExtLDFlags(conf, ctx)
#    ext_ldflags=""
#    for dep_lib in conf["libraries"]:
#        if dep_lib["name"] in ctx["externals"]:
#            ext_lib=ctx["externals"][dep_lib["name"]]
#            if "external" in ext_lib and ext_lib["external"]:                        
#                if "ldflags" in ext_lib:
#                    ext_ldflags=ext_ldflags+" "+ext_lib["ldflags"]

    out.write("$(BUILD_DIR)/"+tool["name"]+": $(objs_"+tool["name"]+") $("+tool["name"]+"_ld)\n")            
    static_flag=""
    if lib_type=="static" and platformSubseteqTest(ctx["platform"], "linux-*-gcc-*"):
        static_flag=" --static"
    out.write("\t$(CC) $(CFLAGS) $(CPPFLAGS) -o $(BUILD_DIR)/"+tool["name"]+" $(objs_"+tool["name"]+") "+generateLDFlags(conf, ctx, lib_type, tool["deps"], [], True)+ ext_ldflags+" $(LDFLAGS)\n")
    out.write("\n")
    out.write("clean:\n")
    out.write("\trm -f $(BUILD_DIR)/"+tool["name"]+" $(objs_"+tool["name"]+")\n")


def generateTypedMakefile(conf, ctx, lib_type):
    obj_dir=os.path.join("build", ctx["platform"], lib_type)
    filename=os.path.join(obj_dir, "Makefile")
    sys.stderr.write("generating "+filename+"\n")
    if not os.path.exists(os.path.dirname(filename)):
            os.makedirs(os.path.dirname(filename))
    out=open(filename, "w")
    out.write("# Generated.\n")

    # generate phony targets
    out.write(".PHONY: all clean tools dep")
    for lib in conf["libraries"]:
        if not lib["external"]:
            out.write(" "+lib["name"])
    for tool in conf["tools"]:
        out.write(" "+tool["name"])
    out.write("\n")
    # all
    out.write("all:")
    for lib in conf["libraries"]:
        if not lib["external"]:
            out.write(" "+lib["name"])
    out.write(" tools\n")
    # tools
    out.write("tools:")
    for tool in conf["tools"]:
        out.write(" "+tool["name"])
    out.write("\n")

    # generate libs
    for lib in conf["libraries"]:
        if not lib["external"]:
            makefile=os.path.join(obj_dir, "Makefile."+lib["name"])
            generateLibraryMakefile(conf, ctx, lib_type, lib, makefile, obj_dir, os.path.join("..", "..", ".."))
            libincludefile=os.path.join(obj_dir, "include", lib["name"]+".inc")
            generateLibraryInclude(conf, ctx, lib, libincludefile, obj_dir, os.path.join("..", "..", "..", ".."))
            out.write(lib["name"]+":")
            deps=depClosure(conf, lib["deps"], True)
            for dep in deps:
                if lib["name"]!=dep:
                    out.write(" "+dep)
            out.write("\n")
            out.write("\t$(MAKE) -f "+"Makefile."+lib["name"]+"\n\n")
    
    # generate tools
    for tool in conf["tools"]:
        makefile=os.path.join(obj_dir, "Makefile."+tool["name"])
        generateToolMakefile(conf, ctx, lib_type, tool, makefile, obj_dir, os.path.join("..", "..", ".."))
        deps=depClosure(conf, tool["deps"], True)
        out.write(tool["name"]+":")
        for dep in deps:
            if tool["name"]!=dep:
                out.write(" "+dep)
        out.write("\n")
        out.write("\t$(MAKE) -f "+"Makefile."+ tool["name"]+"\n\n")

    out.write("clean:\n")
    for lib in conf["libraries"]:
        if not lib["external"]:
            out.write("\t$(MAKE) -f "+"Makefile."+lib["name"]+" clean\n")
    for tool in conf["tools"]:
        out.write("\t$(MAKE) -f "+"Makefile."+tool["name"]+" clean\n")


#    out.write("dep:\n")
#    for lib in conf["libraries"]:
#        generateDEPS(conf, ctx, lib, out, obj_dir, generateCPPFLAGS(conf, ctx, lib), filename)
#    for tool in conf["tools"]:
#        generateDEPS(conf, ctx, tool, out, obj_dir, generateCPPFLAGS(conf, ctx, tool), filename)

    out.write("package: all\n")
    out.write("\tcd ../../.. && ./generate.py --include Makefile.xml");
    for ext_lib in ctx["externals"]:
        if ctx["externals"][ext_lib]["external"]:
            name=ext_lib
            if "xml"==ext_lib:
                name="libxml"
            out.write(" --with-"+name+"=yes")
            if "cppflags" in ctx["externals"][ext_lib]:
                out.write(" --with-"+name+"-cppflags=\""+ctx["externals"][ext_lib]["cppflags"]+"\"")
            if "ldflags" in ctx["externals"][ext_lib]:
                out.write(" --with-"+name+"-ldflags=\""+ctx["externals"][ext_lib]["ldflags"]+"\"")
    out.write(" --package package_"+lib_type+".zip --type "+lib_type)
    out.write(" --config-dir "+ctx["config"]+" "+ctx["platform"])
    out.write("\n")

    obj_dir=os.path.join(ctx["base"], "build", ctx["platform"], lib_type)
    tool_ext=""
    if lib_type=="static":
        lib_ext=".a"
    else:
        lib_ext=getSharedExt(conf, ctx)
    lib_prefix="lib"
    base="$(DESTDIR)/usr/"
    out.write("install: all\n")
    for lib in conf["libraries"]:
        if not lib["external"] and not isExcluded(conf, ctx, lib["name"]):
            for include in lib["header"]["files"]:
                if None!=include["install"]:
                    target=base+"include/"
                    if len(include["install"])>0:
                        target=target+include["install"]+"/"
                    target=target+os.path.split(include["path"])[1]
                    out.write("\t@mkdir -p "+os.path.dirname(target)+"\n")
                    out.write("\t@cp "+include["path"]+" "+target+"\n")
            target=base+"lib/"+lib_prefix+lib["name"]+lib_ext
            out.write("\t@mkdir -p "+os.path.dirname(target)+"\n")
            if lib_type=="shared":
                out.write("\t@cp "+os.path.join(obj_dir, lib_prefix+lib["name"]+lib_ext)+" "+target+".1\n")
                out.write("\tldconfig -v -n "+os.path.dirname(target)+"\n")
            else:
                out.write("\t@cp "+os.path.join(obj_dir, lib_prefix+lib["name"]+lib_ext)+" "+target+"\n")
    for tool in conf["tools"]:
        if not isExcluded(conf, ctx, tool["name"]):
            target=base+"bin/"+tool["name"]+tool_ext
            out.write("\t@mkdir -p "+os.path.dirname(target)+"\n")
            out.write("\t@cp "+os.path.join(obj_dir, tool["name"]+tool_ext)+" "+target+"\n")
    target=base+"lib/pkgconfig/libopc.pc"
    out.write("\t@mkdir -p "+os.path.dirname(target)+"\n")    
    out.write("\t@cp "+os.path.join(ctx["base"], "config", "libopc.pc")+" "+target+"\n")
    out.close()


def generateTypedMakefiles(ctx, source, lib_types):
    for platform in ctx["platforms"]:
        conf=generateConfiguration(ctx, [source], platform)
        if ctx["platform"] in conf["platforms"]:    
            for lib_type in lib_types:        
                generateTypedMakefile(conf, ctx, lib_type)
        else:
            parseError("platform "+ctx["platform"]+" is unknown.")
            sys.stderr.write("available platforms:");
            for platform in conf["platforms"]:
                sys.stderr.write(platform+"\n")
    out=open("Makefile", "w")
    out.write(".PHONY: all clean");
    for platform in ctx["platforms"]:
        for lib_type in lib_types:        
            out.write(" "+platform+"."+lib_type);
    for lib_type in lib_types:        
        out.write(" "+lib_type);
    out.write("\n");
    out.write("all:");
    for lib_type in lib_types:        
        out.write(" "+lib_type);
    out.write("\n");

    for lib_type in lib_types:        
        out.write(lib_type+":");
        for platform in ctx["platforms"]:
            out.write(" "+platform+"."+lib_type);
        out.write("\n");

    for lib_type in lib_types:        
        for platform in ctx["platforms"]:
            out.write(platform+"."+lib_type+": build"+os.sep+platform+os.sep+lib_type+os.sep+"Makefile\n");
            out.write("\t@$(MAKE) -C build"+os.sep+platform+os.sep+lib_type+"\n");
    out.write("clean:\n")
    for lib_type in lib_types:        
        for platform in ctx["platforms"]:
            out.write("\t@$(MAKE) -C build"+os.sep+platform+os.sep+lib_type+" clean\n");    
    out.write("package:\n")
    for lib_type in lib_types:        
        for platform in ctx["platforms"]:
            out.write("\t@$(MAKE) -C build"+os.sep+platform+os.sep+lib_type+" package\n")
    out.write("install:\n")
    for lib_type in lib_types:        
        for platform in ctx["platforms"]:
            out.write("\t@$(MAKE) -C build"+os.sep+platform+os.sep+lib_type+" install\n")
    out.close()

def dumpEnvironment(ctx, includes, platform):
    conf=generateConfiguration(ctx, includes, platform)
    if platform in conf["platforms"]:            
        p=conf["platforms"][platform]
#        print(str(p))
        host=""
        if "host" in p:
            host="HOST=\""+p["host"]+"\" "
        sys.stdout.write("export CC=\""+p["cc"]+"\" "+
             "export AR=\""+p["ar"]+"\" "+
             "export LD=\""+p["ld"]+"\" "
             "export CPPFLAGS=\""+p["cppflags"]+"\" "
             "export CFLAGS=\""+p["cflags"]+"\" "+
             host
            )
    else:
        parseError("platform "+platform+" is unknown.")
        sys.stderr.write("available platforms:");
        for platform in conf["platforms"]:
            sys.stderr.write(platform)    

def set_external_flag(ctx, lib, flag, value):
#    sys.stderr.write("SETTING "+lib+" "+flag+" "+str(value)+"\n")
    if lib in ctx["externals"]:
        ctx["externals"][lib][flag]=value
    else:
        ctx["externals"][lib]={flag: value}

def is_external(ctx, lib):
    if lib in ctx["externals"]:
        if "external" in ctx["externals"][lib]:
            return ctx["externals"][lib]["external"]
        else:
            return False
    else:
        return False


def generateZipPackage(ctx, source, lib_type, install_zip):
    zip=zipfile.ZipFile(install_zip, 'w', zipfile.ZIP_DEFLATED)
    base=os.path.splitext(install_zip)[0]+"/"
    platform=ctx["platforms"][0]
    conf=generateConfiguration(ctx, [source], platform)
    if platformSubseteqTest(ctx["platforms"][0], "win32-*-*"):
        obj_dir=os.path.join("win32", ctx["platform"].split('-')[1])
        tool_ext=".exe"
        lib_exts=[".lib"]
        if (lib_type=="shared"):
            shared_exts.append(".dll")        
        lib_prefix=""
    else:
        obj_dir=os.path.join("build", ctx["platform"], lib_type)
        tool_ext=""
        if lib_type=="shared":
            lib_exts=[".dylib"]
        else:
            lib_exts=[".a"]
        lib_prefix="lib"
    for lib in conf["libraries"]:
        if not lib["external"] and not isExcluded(conf, ctx, lib["name"]):
            for include in lib["header"]["files"]:
                if None!=include["install"]:
                    target=base+"include/"
                    if len(include["install"])>0:
                        target=target+include["install"]+"/"
                    target=target+os.path.split(include["path"])[1]
                    zip.write(include["path"], target)
            for lib_ext in lib_exts:
                target=base+"lib/"+lib_prefix+lib["name"]+lib_ext
#                print "ADD "+os.path.join(obj_dir, lib_prefix+lib["name"]+lib_ext)
                zip.write(os.path.join(obj_dir, lib_prefix+lib["name"]+lib_ext), target)
    for tool in conf["tools"]:
        if not isExcluded(conf, ctx, tool["name"]):
            target=base+"bin/"+tool["name"]+tool_ext
            zip.write(os.path.join(obj_dir, tool["name"]+tool_ext), target)
    zip.write(os.path.join("third_party", "LICENSE"), base+"/LICENSE.THIRD_PARTY")
    zip.write("LICENSE", base+"/LICENSE")
    zip.close()



def installFiles(ctx, source, lib_type, base):
    copy_ctx=None
    platform=ctx["platforms"][0]
    conf=generateConfiguration(ctx, [source], platform)
    if platformSubseteqTest(ctx["platforms"][0], "win32-*-*"):
        obj_dir=os.path.join("win32", ctx["platform"].split('-')[1])
        tool_ext=".exe"
        lib_exts=[".lib"]
        lib_prefix=""
    else:
        obj_dir=os.path.join("build", ctx["platform"], lib_type)
        tool_ext=""
        lib_exts=[".a", getSharedExt(conf, ctx)]
        lib_prefix="lib"
    for lib in conf["libraries"]:
        if not lib["external"] and not isExcluded(conf, ctx, lib["name"]):
            for include in lib["header"]["files"]:
                if None!=include["install"]:
                    target=base+"include/"
                    if len(include["install"])>0:
                        target=target+include["install"]+"/"
                    target=target+os.path.split(include["path"])[1]
                    copyFile(copy_ctx, include["path"], target)
            for lib_ext in lib_exts:
                target=base+"lib/"+lib_prefix+lib["name"]+lib_ext
                copyFile(copy_ctx, os.path.join(obj_dir, lib_prefix+lib["name"]+lib_ext), target)
    for tool in conf["tools"]:
        if not isExcluded(conf, ctx, tool["name"]):
            target=base+"bin/"+tool["name"]+tool_ext
            copyFile(copy_ctx, os.path.join(obj_dir, tool["name"]+tool_ext), target)
    copyFile(copy_ctx, os.path.join("third_party", "LICENSE"), base+"/LICENSE.THIRD_PARTY")
    copyFile(copy_ctx, "LICENSE", base+"/LICENSE")

def usage():
    print("usage:")
    print(" generate [--include \"Makefile.xml\"]")
    print("          [--config-dir \"config/\"]")
    print("          [--print-env \"linux-release-gcc\"]")
    print("          [--package \"xyz.zip/\"]")

if __name__ == "__main__":    
    try:
        opts, args = getopt.getopt(sys.argv[1:], "h", ["help", "include=", "config-dir=", "print-env=", 
            "package=", "install=", 
            "with-zlib-cppflags=", "with-zlib-ldflags=", "with-zlib=",
            "with-libxml-cppflags=", "with-libxml-ldflags=", "with-libxml=",
            "type="])
    except(getopt.GetoptError, err):
        # print help information and exit:
        print(str(err)) # will print something like "option -a not recognized"
        usage()
        sys.exit(2)
    ctx={ "base": os.path.abspath(os.curdir), "root": os.path.abspath(os.curdir), "platform": "?-?-?", "platforms": [], "externals": {} }
    ctx["config"]=ctx["base"]
    includes=[]
    dump_env=[]
    install_zip=None
    target_type="static"
    for o, a in opts:
        if o in ("-h", "--help"):
            usage()
            sys.exit(0)
        elif o in ("--include"):
            includes.append(a)
        elif o in ("--config-dir"):
            ctx["config"]=os.path.join(ctx["base"], a)
        elif o in ("--print-env"):
            args=[]
            dump_env=[a]
        elif o in ("--package"):
            install_zip=a
        elif o in ("--install"):
            install_files=a
        elif o in ("--with-zlib"):
            set_external_flag(ctx, "zlib", "external", "yes"==a)
        elif o in ("--with-zlib-cppflags"):
            set_external_flag(ctx, "zlib", "cppflags", a)
        elif o in ("--with-zlib-ldflags"):
            set_external_flag(ctx, "zlib", "ldflags", a)
        elif o in ("--with-libxml"):
            set_external_flag(ctx, "xml", "external", "yes"==a)
        elif o in ("--with-libxml-cppflags"):
            set_external_flag(ctx, "xml", "cppflags", a)
        elif o in ("--with-libxml-ldflags"):
            set_external_flag(ctx, "xml", "ldflags", a)
        elif o in ("--type"):
            target_type=a

    for platform in args:
        ctx["platforms"].append(platform)

    if 1==len(ctx["platforms"]) and None!=install_zip and 1==len(includes):
        ctx["root"]=os.path.abspath(os.path.split(includes[0])[0])
        generateZipPackage(ctx, includes[0], target_type, install_zip)
    elif 1==len(ctx["platforms"]) and platformSubseteqTest(ctx["platforms"][0], "win32-*-msvc-*") and 1==len(includes):
        ctx["root"]=os.path.abspath(os.path.split(includes[0])[0])
        generateWin32(ctx, includes[0])
    else:
        if is_external(ctx, "zlib") and is_external(ctx, "xml"):
            lib_types=["static", "shared"]
        else:
            lib_types=["static"]
        if not os.path.exists("build"):
            os.makedirs("build")
        f=open(os.path.join("build", "configure.ctx"), "w")
        f.write(str(ctx))
        f.close()        
        for include in includes:
            ctx["root"]=os.path.abspath(os.path.split(include)[0])
            generateTypedMakefiles(ctx, include, lib_types)

    for platform in dump_env:
        dumpEnvironment(ctx, includes, platform)