#!/usr/bin/env python

# Copyright (c) 2007, Intel Corporation
# All rights reserved. This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License
# which accompanies this distribution.  The full text of the license may be found at
# http://opensource.org/licenses/bsd-license.php
#
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

"""Generate build file for given platform"""

import os, sys, copy
import xml.dom.minidom, pprint
import FrameworkElement

from SurfaceAreaElement import *
from XmlRoutines import *
from AntTasks import *
from sets import Set

class BuildFile:
    def __init__(self, workspace, platform, toolchain, target):
        if workspace == None or workspace == "":
            raise Exception("No workspace, no build")
        if platform == None or platform == "":
            raise Exception("No platform, no build")
        if toolchain == None or toolchain == "":
            raise Exception("No toolchain, no build")
        if target == None or target == "":
            raise Exception("No target, no build")
        
        self.Workspace = workspace
        self.Platform = platform
        self.Toolchain = toolchain
        self.Target = target
        self.Path = ""

    def Generate(self):
        """Generate the build file"""
        pass

# generating build.xml for platform
class AntPlatformBuildFile(BuildFile):
    def __init__(self, workspace, platform, toolchain, target):
        BuildFile.__init__(self, workspace, platform, toolchain, target)
        # Form the build file path, hard-coded at present. It should be specified by a configuration file
        self.Path = os.path.join(self.Workspace.Path, self.Platform.OutputPath, target + "_" + toolchain, "build.xml")
        print ""
        # Generate a common build option property file in the format of Java's property file
        self.DefaultBuildOptions()
        
        # new a build file object
        self.BuildXml = AntBuildFile(name="platform", basedir=".", default="all")
        
        # generate the top level properties, tasks, etc.
        self.Header()
        
        # generate "prebuild" target
        self.PreBuild()
        
        # generate "libraries" target for building library modules
        self.Libraries()
        
        # generate "modules" target for building non-library modules
        self.Modules()
        
        # generate "fvs" target for building firmware volume. (not supported yet)
        
        # generate "fds" target for building FlashDevice. (not supported yet)
        
        # generate "postbuild" target
        self.PostBuild()

    def Generate(self):
        print "Generating platform build file ...", self.Path
        self.BuildXml.Create(self.Path)

    def Header(self):
        _topLevel = self.BuildXml
        # import external tasks
        _topLevel.SubTask("taskdef", resource="GenBuild.tasks")
        _topLevel.SubTask("taskdef", resource="frameworktasks.tasks")
        _topLevel.SubTask("taskdef", resource="net/sf/antcontrib/antlib.xml")

        # platform wide properties
        _topLevel.Blankline()
        _topLevel.Comment("WORKSPACE wide attributes")
        _topLevel.SubTask("property", environment="env")
        _topLevel.SubTask("property", name="WORKSPACE_DIR", value="${env.WORKSPACE}")
        _topLevel.SubTask("property", name="CONFIG_DIR", value="${WORKSPACE_DIR}/Tools/Conf")

        _topLevel.Blankline()
        _topLevel.Comment("Common build attributes")
        _topLevel.SubTask("property", name="THREAD_COUNT", value=self.Workspace.ThreadCount)
        _topLevel.SubTask("property", name="SINGLE_MODULE_BUILD", value="no")
        _topLevel.SubTask("property", name="MODULE_BUILD_TARGET", value="platform_module_build")

        _topLevel.Blankline()
        _topLevel.SubTask("property", name="TOOLCHAIN", value=self.Toolchain)
        _topLevel.SubTask("property", name="TARGET", value=self.Target)
        
        _topLevel.Blankline()
        _topLevel.Comment("Platform attributes")
        _topLevel.SubTask("property", name="PLATFORM", value=self.Platform.Name)
        _topLevel.SubTask("property", name="PLATFORM_GUID", value=self.Platform.GuidValue)
        _topLevel.SubTask("property", name="PLATFORM_VERSION", value=self.Platform.Version)
        _topLevel.SubTask("property", name="PLATFORM_RELATIVE_DIR", value=self.Platform.Dir)
        _topLevel.SubTask("property", name="PLATFORM_DIR", value="${WORKSPACE_DIR}/${PLATFORM_RELATIVE_DIR}")
        _topLevel.SubTask("property", name="PLATFORM_OUTPUT_DIR", value=self.Platform.OutputPath)

        # user configurable build path for platform
        _topLevel.Blankline()
        _topLevel.Comment("Common path definition for platform build")
        _topLevel.SubTask("property", file="${WORKSPACE_DIR}/Tools/Python/buildgen/platform_build_path.txt")
        
        # common build tasks in the form of Ant macro
        _topLevel.Blankline()
        _topLevel.Comment("Task Macros for Compiling, Assembling, Linking, etc.")
        _topLevel.SubTask("import", file="${CONFIG_DIR}/BuildMacro.xml")
        _topLevel.Blankline()
        _topLevel.SubTask("echo", message="${PLATFORM}-${PLATFORM_VERSION} (${PLATFORM_RELATIVE_DIR})", level="info")
        
        # define the targets execution sequence
        _topLevel.Blankline()
        _topLevel.Comment("Default target")
        _topLevel.SubTask("target", name="all", depends="prebuild, libraries, modules, postbuild")

    def PreBuild(self):
        _topLevel = self.BuildXml
        _topLevel.Blankline()
        _topLevel.Comment(" TARGET: prebuild ")
        
        # prebuild is defined by user in the fpd file through <UserExtionsion> element,
        # which has attribute "identifier=0" or "identifier=prebuild"
        prebuildTasks = []
        if self.Platform.UserExtensions.has_key("0"):
            prebuildTasks = self.Platform.UserExtensions["0"]
        elif self.Platform.UserExtensions.has_key("postbuild"):
            prebuildTasks = self.Platform.UserExtensions["prebuild"]

        _topLevel.SubTask("target", prebuildTasks, name="prebuild")

    def Libraries(self):
        _topLevel = self.BuildXml
        _topLevel.Blankline()
        _topLevel.Comment(" TARGET: libraries ")
        
        librariesTarget = _topLevel.SubTask("target", name="libraries")
        parallelBuild = librariesTarget.SubTask("parallel", threadCount="${THREAD_COUNT}")
        
        libraryNumber = 0
        for arch in self.Platform.Libraries:
            libraryNumber += len(self.Platform.Libraries[arch])
        libraryIndex = 0
        for arch in self.Platform.Libraries:
            for lib in self.Platform.Libraries[arch]:
                libraryIndex += 1
                print "Generating library build files ... %d%%\r" % int((float(libraryIndex) / float(libraryNumber)) * 100),
                buildFile = AntModuleBuildFile(self.Workspace, self.Platform, lib, self.Toolchain, self.Target, arch)
                buildFile.Generate()
                buildDir = os.path.join("${TARGET_DIR}", arch, lib.Module.Package.SubPath(lib.Module.Dir),
                                        lib.Module.FileBaseName)
                parallelBuild.SubTask("ant", dir=buildDir,
                                      #antfile="build.xml",
                                      inheritAll="true",
                                      target="${MODULE_BUILD_TARGET}")
        print ""

    def Modules(self):
        _topLevel = self.BuildXml
        _topLevel.Blankline()
        _topLevel.Comment(" TARGET: modules ")

        modulesTarget = _topLevel.SubTask("target", name="modules")
        parallelBuild = modulesTarget.SubTask("parallel", threadCount="${THREAD_COUNT}")

        moduleNumber = 0
        for arch in self.Platform.Modules:
            moduleNumber += len(self.Platform.Modules[arch])
            
        moduleIndex = 0
        for arch in self.Platform.Modules:
            for module in self.Platform.Modules[arch]:
                moduleIndex += 1
                print "Generating module build files ... %d%%\r" % int((float(moduleIndex) / float(moduleNumber)) * 100),
                
                buildDir = os.path.join("${TARGET_DIR}", arch, module.Module.Package.SubPath(module.Module.Dir),
                                        module.Module.FileBaseName)
                parallelBuild.SubTask("ant", dir=buildDir,
                                      #antfile="build.xml",
                                      inheritAll="true",
                                      target="${MODULE_BUILD_TARGET}")
                buildFile = AntModuleBuildFile(self.Workspace, self.Platform, module, self.Toolchain, self.Target, arch)
                buildFile.Generate()
        print ""

    def Fvs(self):
        pass

    def Fds(self):
        pass

    def PostBuild(self):
        _topLevel = self.BuildXml
        _topLevel.Blankline()
        _topLevel.Comment(" TARGET: postbuild ")
        
        # postbuild is defined by user in the fpd file through <UserExtionsion> element,
        # which has attribute "identifier=1" or "identifier=postbuild"
        postbuildTasks = []
        if self.Platform.UserExtensions.has_key("1"):
            postbuildTasks = self.Platform.UserExtensions["1"]
        elif self.Platform.UserExtensions.has_key("postbuild"):
            postbuildTasks = self.Platform.UserExtensions["postbuild"]
            
        _topLevel.SubTask("target", postbuildTasks, name="postbuild")

    def Clean(self):
        pass

    def CleanAll(self):
        pass

    def UserExtensions(self):
        pass

    def DefaultBuildOptions(self):
        """Generate ${ARCH}_build.opt which contains the default build&tool definitions"""
        tools = self.Workspace.ToolConfig.ToolCodes
        for arch in self.Workspace.ActiveArchs:
            validTools = []
            for tool in tools:
                key = (self.Toolchain, self.Target, arch, tool, "NAME")
                if self.Workspace.ToolConfig[key] == "": continue
                validTools.append(tool)
                
            optFileDir = os.path.join(self.Workspace.Path, self.Platform.OutputPath,
                                      self.Target + "_" + self.Toolchain)
            optFileName = arch + "_build.opt"
            if not os.path.exists(optFileDir): os.makedirs(optFileDir)
            f = open(os.path.join(optFileDir, optFileName), "w")
            
            for tool in validTools:
                key = (self.Toolchain, self.Target, arch, tool, "FLAGS")
                if key in self.Platform.BuildOptions:
                    flag = self.Platform.BuildOptions[key]
                else:
                    key = (self.Toolchain, self.Target, arch, tool, "FAMILY")
                    family = self.Workspace.ToolConfig[key]
                    key = (family, self.Target, arch, tool, "FLAGS")
                    if key in self.Platform.BuildOptions:
                        flag = self.Platform.BuildOptions[key]
                    else:
                        flag = ""
                f.write("PLATFORM_%s_FLAGS=%s\n" % (tool, flag))
            f.write("\n")

            for tool in validTools:
                key = (self.Toolchain, self.Target, arch, tool, "FLAGS")
                flag = self.Workspace.ToolConfig[key]
                f.write("DEFAULT_%s_FLAGS=%s\n" % (tool, flag))

            f.write("\n")
            for tool in validTools:
                for attr in self.Workspace.ToolConfig.Attributes:
                    if attr == "FLAGS": continue
                    key = (self.Toolchain, self.Target, arch, tool, attr)
                    value = self.Workspace.ToolConfig[key]
                    if attr == "NAME":
                        path = self.Workspace.ToolConfig[(self.Toolchain, self.Target, arch, tool, "PATH")]
                        f.write("%s=%s\n" % (tool, os.path.join(path, value)))
                    else:
                        f.write("%s_%s=%s\n" % (tool, attr, value))
                f.write("%s_FLAGS=${DEFAULT_%s_FLAGS} ${DEFAULT_MODULE_%s_FLAGS} ${PLATFORM_%s_FLAGS} ${MODULE_%s_FLAGS}\n" %
                        (tool, tool, tool, tool, tool))
                f.write("\n")

            f.close()

class AntModuleBuildFile(BuildFile):
    def __init__(self, workspace, platform, module, toolchain, target, arch):
        BuildFile.__init__(self, workspace, platform, toolchain, target)
        self.Module = module
        self.Arch = arch
        self.Path = os.path.join(self.Workspace.Path, self.Platform.OutputPath,
                                 target + "_" + toolchain, arch, self.Module.Module.Package.Dir,
                                 self.Module.Module.Dir, self.Module.Module.FileBaseName, "build.xml")
        self.BuildXml = AntBuildFile(self.Module.Module.Name)

        self.SourceFiles = self.GetSourceFiles()
        
        self.Header()
        self.PreBuild()
        self.Libraries()
        self.Sourcefiles()
        self.Sections()
        self.Ffs()
        self.PostBuild()

    def Generate(self):
        # print self.Path,"\r",
        self.BuildXml.Create(self.Path)

    def Header(self):
        _topLevel = self.BuildXml
        _topLevel.SubTask("taskdef", resource="frameworktasks.tasks")
        _topLevel.SubTask("taskdef", resource="cpptasks.tasks")
        _topLevel.SubTask("taskdef", resource="cpptasks.types")
        _topLevel.SubTask("taskdef", resource="net/sf/antcontrib/antlib.xml")

        _topLevel.Blankline()
        _topLevel.Comment(" TODO ")
        _topLevel.SubTask("property", environment="env")
        _topLevel.SubTask("property", name="WORKSPACE_DIR", value="${env.WORKSPACE}")

        _topLevel.Blankline()
        _topLevel.Comment("Common build attributes")
        _topLevel.SubTask("property", name="SINGLE_MODULE_BUILD", value="yes")
        _topLevel.SubTask("property", name="MODULE_BUILD_TARGET", value="single_module_build")
        _topLevel.SubTask("property", name="PLATFORM_PREBUILD", value="yes")
        _topLevel.SubTask("property", name="PLATFORM_POSTBUILD", value="no")
        
        _topLevel.Blankline()
        _topLevel.Comment(" TODO ")
        ifTask = _topLevel.SubTask("if")
        ifTask.SubTask("istrue", value="${SINGLE_MODULE_BUILD}")
        thenTask = ifTask.SubTask("then")
        platformBuildFile = os.path.join("${WORKSPACE_DIR}", self.Platform.OutputPath,
                                         self.Target + "_" + self.Toolchain, "build.xml")
        thenTask.SubTask("import", file=platformBuildFile)
        
        _topLevel.Blankline()
        _topLevel.SubTask("property", name="ARCH", value=self.Arch)
        
        module = self.Module.Module
        package = module.Package
        _topLevel.Blankline()
        _topLevel.SubTask("property", name="PACKAGE", value=package.Name)
        _topLevel.SubTask("property", name="PACKAGE_GUID", value=package.GuidValue)
        _topLevel.SubTask("property", name="PACKAGE_VERSION", value=package.Version)
        _topLevel.SubTask("property", name="PACKAGE_RELATIVE_DIR", value=package.Dir)
        _topLevel.SubTask("property", name="PACKAGE_DIR", value=os.path.join("${WORKSPACE_DIR}","${PACKAGE_RELATIVE_DIR}"))
        
        _topLevel.Blankline()
        _topLevel.SubTask("property", name="MODULE", value=module.Name)
        _topLevel.SubTask("property", name="MODULE_GUID", value=module.GuidValue)
        _topLevel.SubTask("property", name="MODULE_VERSION", value=module.Version)
        _topLevel.SubTask("property", name="MODULE_TYPE", value=module.Type)
        _topLevel.SubTask("property", name="MODULE_FILE_BASE_NAME", value=module.FileBaseName)
        _topLevel.SubTask("property", name="MODULE_RELATIVE_DIR", value=module.Dir)
        _topLevel.SubTask("property", name="MODULE_DIR", value=os.path.join("${PACKAGE_DIR}", "${MODULE_RELATIVE_DIR}"))
        _topLevel.SubTask("property", name="BASE_NAME", value=module.BaseName)

        _topLevel.Blankline()
        _topLevel.SubTask("property", file="${WORKSPACE_DIR}/Tools/Python/buildgen/module_build_path.txt")
        
        self._BuildOption()
        
        _topLevel.Blankline()
        _topLevel.SubTask("property", name="ENTRYPOINT", value="_ModuleEntryPoint")
        
        _topLevel.SubTask("property", name="SOURCE_FILES", value="\n    ".join(self._GetSourceFileList()))
        _topLevel.SubTask("property", name="LIBS", value="\n    ".join(self._GetLibList()))
        
        _topLevel.Blankline()
        _topLevel.SubTask("property", file="${PLATFORM_BUILD_DIR}/%s_build.opt" % self.Arch)
        _topLevel.Blankline()
        _topLevel.SubTask("echo", message="${MODULE}-${MODULE_VERSION} [${ARCH}] from package ${PACKAGE}-${PACKAGE_VERSION} (${MODULE_RELATIVE_DIR})", level="info")

        _topLevel.Blankline()
        _topLevel.Comment("Default target")
        _topLevel.SubTask("target", name="all", depends="single_module_build")
        _topLevel.SubTask("target", name="platform_module_build", depends="prebuild, sourcefiles, sections, output, postbuild")
        _topLevel.SubTask("target", name="single_module_build", depends="prebuild, libraries, sourcefiles, sections, output, postbuild")

    def _BuildOption(self):
        _topLevel = self.BuildXml
        _topLevel.Blankline()
        baseModule = self.Module.Module
        tools = self.Workspace.ToolConfig.ToolCodes

        for tool in tools:
            key = (self.Toolchain, self.Target, self.Arch, tool, "FLAGS")
            flag = ""
            if key in baseModule.BuildOptions:
                flag = baseModule.BuildOptions[key]
            _topLevel.SubTask("property", name="DEFAULT_MODULE_%s_FLAGS" % tool, value=flag)

        _topLevel.Blankline()
        for tool in tools:
            key = (self.Toolchain, self.Target, self.Arch, tool, "FLAGS")
            flag = ""
            if key in self.Module.BuildOptions:
                flag = self.Module.BuildOptions[key]
            _topLevel.SubTask("property", name="MODULE_%s_FLAGS" % tool, value=flag)

    def PreBuild(self):
        _topLevel = self.BuildXml
        _topLevel.Blankline()
        _topLevel.Comment(" TARGET: prebuild ")

        prebuildTasks = []
        module = self.Module.Module
        if module.UserExtensions.has_key("0"):
            prebuildTasks = module.UserExtensions["0"]
        elif module.UserExtensions.has_key("postbuild"):
            prebuildTasks = module.UserExtensions["prebuild"]

        _topLevel.SubTask("target", prebuildTasks, name="prebuild")


    def Libraries(self):
        _topLevel = self.BuildXml
        _topLevel.Blankline()
        _topLevel.Comment(" TARGET: libraries ")
        
        librariesTarget = _topLevel.SubTask("target", name="libraries")
        parallelBuild = librariesTarget.SubTask("parallel", threadCount="${THREAD_COUNT}")
        for lib in self.Module.Libraries:
            module = lib.Module
            buildDir = os.path.join("${BIN_DIR}", module.Package.SubPath(module.Dir), module.FileBaseName)
            libTask = parallelBuild.SubTask("ant", dir=buildDir,
                                            inheritAll="false",
                                            target="${MODULE_BUILD_TARGET}")
            libTask.SubTask("property", name="PLATFORM_PREBUILD", value="false")
            libTask.SubTask("property", name="PLATFORM_POSTBUILD", value="false")

    def Sourcefiles(self):
        _topLevel = self.BuildXml
        _topLevel.Blankline()
        _topLevel.Comment(" TARGET: sourcefiles ")
        _sourcefilesTarget = _topLevel.SubTask("target", name="sourcefiles")
        
        _incTask = AntTask(self.BuildXml.Document, "EXTRA.INC")
        _incTask.SubTask("includepath", path="${WORKSPACE_DIR}")
        _incTask.SubTask("includepath", path="${MODULE_DIR}")
        _incTask.SubTask("includepath", path=os.path.join("${MODULE_DIR}", self.Arch.capitalize()))
        _incTask.SubTask("includepath", path="${DEST_DIR_DEBUG}")
        if self.Arch in self.Module.Module.IncludePaths:
            for inc in self.Module.Module.IncludePaths[self.Arch]:
                _incTask.SubTask("includepath", path=os.path.join("${WORKSPACE_DIR}", inc))
            
        # init
        if not self.Module.Module.IsBinary:
            _buildTask = _sourcefilesTarget.SubTask("Build_Init")
            _buildTask.AddSubTask(_incTask)
        
            # AutoGen firt
            _buildTask = _sourcefilesTarget.SubTask("Build_AUTOGEN", FILEEXT="c", FILENAME="AutoGen", FILEPATH=".")
            _buildTask.AddSubTask(_incTask)

        # uni file follows
        type = "UNI"
        if type in self.SourceFiles:
            for srcpath in self.SourceFiles[type]:
                taskName = "Build_" + type
                fileDir = os.path.dirname(srcpath)
                if fileDir == "": fileDir = "."
                fileBaseName,fileExt = os.path.basename(srcpath).rsplit(".", 1)
                _buildTask = _sourcefilesTarget.SubTask(taskName, FILENAME=fileBaseName, FILEEXT=fileExt, FILEPATH=fileDir)
                _buildTask.AddSubTask(_incTask)

        # others: c, vfr, ...
        for type in self.SourceFiles:
            if type == "Unicode": continue
            for srcpath in self.SourceFiles[type]:
                taskName = "Build_" + type
                fileDir = os.path.dirname(srcpath)
                if fileDir == "": fileDir = "."
                fileBaseName,fileExt = os.path.basename(srcpath).rsplit(".", 1)
                _buildTask = _sourcefilesTarget.SubTask(taskName, FILENAME=fileBaseName, FILEEXT=fileExt, FILEPATH=fileDir)
                _buildTask.AddSubTask(_incTask)

    def Sections(self):
        _topLevel = self.BuildXml
        _topLevel.Blankline()
        _topLevel.Comment(" TARGET: sections ")
        _sectionsTarget = _topLevel.SubTask("target", name="sections")

    def Ffs(self):
        _topLevel = self.BuildXml
        _topLevel.Blankline()
        _topLevel.Comment(" TARGET: output ")
        _sectionsTarget = _topLevel.SubTask("target", name="output")

    def PostBuild(self):
        _topLevel = self.BuildXml
        _topLevel.Blankline()
        _topLevel.Comment(" TARGET: postbuild ")

        postbuildTasks = []
        module = self.Module.Module
        if module.UserExtensions.has_key("1"):
            postbuildTasks = module.UserExtensions["1"]
        elif module.UserExtensions.has_key("postbuild"):
            postbuildTasks = module.UserExtensions["postbuild"]

        _topLevel.SubTask("target", postbuildTasks, name="postbuild")

    def Clean(self):
        pass

    def CleanAll(self):
        pass

    def UserExtensions(self):
        pass
    
    def GetSourceFiles(self):
        ## check arch, toolchain, family, toolcode, ext
        ##  if the arch of source file supports active arch
        ##  if the toolchain of source file supports active toolchain
        ##  if the toolchain family of source file supports active toolchain family
        ##  if the ext of the source file is supported by the toolcode
        module = self.Module.Module
        files = {}  # file type -> src
        for type in module.SourceFiles[self.Arch]:
            if not module.IsBuildable(type):
                # print type,"is not buildable"
                continue
        
            if type not in files:
                files[type] = []
            for src in module.SourceFiles[self.Arch][type]:
                if self.Toolchain not in src.Toolchains:
                    # print self.Toolchain,"not in ",src.Toolchains
                    continue
                if not self.IsCompatible(src.Families, self.Workspace.ActiveFamilies):
                    # print src.Families,"not compatible with",self.Workspace.ActiveFamilies
                    continue
                toolcode = src.GetToolCode(src.Type)
                if toolcode != "":
                    ext = self.Workspace.GetToolDef(self.Toolchain, self.Target, self.Arch, toolcode, "EXT")
                    if ext != "" and ext != src.Ext:
                        # print ext,"in tools_def.txt is not the same as",src.Ext
                        continue
                ## fileFullPath = os.path.join("${MODULE_DIR}", )
                ## print fileFullPath
                files[type].append(src.Path)

        return files

    def Intersection(self, list1, list2):
        return list(Set(list1) & Set(list2))

    def IsCompatible(self, list1, list2):
        return len(self.Intersection(list1, list2)) > 0

    def _GetLibList(self):
        libList = []
        for lib in self.Module.Libraries:
            module = lib.Module
            libList.append(os.path.join("${BIN_DIR}", module.Name + ".lib"))
        return libList
    
    def _GetSourceFileList(self):
        srcList = []
        for type in self.SourceFiles:
            srcList.extend(self.SourceFiles[type])
        return srcList

class NmakeFile(BuildFile):
    pass

class GmakeFile(BuildFile):
    pass

# for test
if __name__ == "__main__":
    workspacePath = os.getenv("WORKSPACE", os.getcwd())
    startTime = time.clock()
    ws = Workspace(workspacePath, [], [])
    
    # generate build.xml
    ap = ws.ActivePlatform
    for target in ws.ActiveTargets:
        ant = AntPlatformBuildFile(ws, ap, ws.ActiveToolchain, target)
        ant.Generate()
    
    print "\n[Finished in %fs]" % (time.clock() - startTime)