Python script for generating build files for platform and modules, which uses the enhanced XmlRoutines.py written by Bruce.

The functionalities include:
- parse all packages(.spd) and modules(.msa)
- parse active platform(.fpd). You must set active platform in target.txt otherwise nothing will be parsed.
- parse tools_def.txt and target.txt
- generate Ant build files for active platform and its modules. The generated build file is re-designed and can be called separately once generated.
- multi-thread build

The functionalities which haven't been implemented include:
- AutoGen. No AutoGen.h and AutoGen.c will be generated. If you want run the build file, you have to run the "build" command in advance to generate the AutoGen.h/.c files and remove the any other intermediate files.
- generate FFS and FV files. Only compiling will be done by the generated build file.

Usage:
- type "python ${WORKSPACE}/Tools/Python/buildgen/BuildFile.py" in shell to generate build file
- goto "${WORKSPACE}/Build/${platform}/${target}_${toolchaintag}/", type "ant" to run the build file


git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2278 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 574 insertions, 0 deletions

diff --git a/Tools/Python/buildgen/BuildFile.py b/Tools/Python/buildgen/BuildFile.py
new file mode 100644
index 0000000000..8514e4c8a4
--- /dev/null
+++ b/Tools/Python/buildgen/BuildFile.py
@@ -0,0 +1,574 @@
+#!/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:

+            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 tools:

+                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 tools:

+                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 tools:

+                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":

+                        f.write("%s=%s\n" % (tool, 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)