diff options
Diffstat (limited to 'Tools/Python/buildgen/SurfaceAreaElement.py')
| -rw-r--r-- | Tools/Python/buildgen/SurfaceAreaElement.py | 1555 |
1 files changed, 0 insertions, 1555 deletions
diff --git a/Tools/Python/buildgen/SurfaceAreaElement.py b/Tools/Python/buildgen/SurfaceAreaElement.py deleted file mode 100644 index ec84582b11..0000000000 --- a/Tools/Python/buildgen/SurfaceAreaElement.py +++ /dev/null @@ -1,1555 +0,0 @@ -#!/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.
-
-"""Framework SurfaceArea Elemments"""
-#
-# TODO: FFS layout, Flash, FV, PCD
-#
-import os, sys, re, getopt, string, glob, xml.dom.minidom, pprint, time, copy, shelve, pickle
-from XmlRoutines import *
-import FrameworkElement
-import BuildConfig
-
-################################################################################
-##
-## Convert given list to a string in the format like: [a, b, c]
-##
-################################################################################
-def ListString(lst):
- return "[%s]" % ",".join(lst)
-
-class SurfaceAreaElement:
- """Base class for Surface Area XML element"""
- _ModuleTypes = ('BASE', 'SEC', 'PEI_CORE', 'PEIM', 'DXE_CORE', 'DXE_DRIVER',
- 'DXE_RUNTIME_DRIVER', 'DXE_SAL_DRIVER', 'DXE_SMM_DRIVER',
- 'TOOL', 'UEFI_DRIVER', 'UEFI_APPLICATION', 'USER_DEFINED')
- _GuidTypes = ('DATA_HUB_RECORD', 'EFI_EVENT', 'EFI_SYSTEM_CONFIGURATION_TABLE',
- 'EFI_VARIABLE', 'GUID', 'HII_PACKAGE_LIST', 'HOB', 'TOKEN_SPACE_GUID')
- _Archs = ('EBC', 'IA32', 'X64', 'IPF', 'ARM', 'PPC')
- _Usages = ('ALWAYS_CONSUMED', 'SOMETIMES_CONSUMED', 'ALWAYS_PRODUCED',
- 'SOMETIMES_PRODUCED', 'TO_START', 'BY_START', 'PRIVATE')
- _FileTypes = {
- ".c" : "CCode",
- ".C" : "CCode",
- ".cpp" : "CCode",
- ".Cpp" : "CCode",
- ".CPP" : "CCode",
- ".h" : "CHeader",
- ".H" : "CHeader",
- ".asm" : "ASM",
- ".Asm" : "Assembly",
- ".ASM" : "Assembly",
- ".s" : "IpfAssembly",
- ".S" : "GccAssembly",
- ".uni" : "UNI",
- ".Uni" : "Unicode",
- ".UNI" : "Unicode",
- ".vfr" : "VFR",
- ".Vfr" : "VFR",
- ".VFR" : "VFR",
- ".dxs" : "DPX",
- ".Dxs" : "DPX",
- ".DXS" : "DPX",
- ".fv" : "FirmwareVolume",
- ".Fv" : "FirmwareVolume",
- ".FV" : "FirmwareVolume",
- ".efi" : "EFI",
- ".Efi" : "EFI",
- ".EFI" : "EFI",
- ".SEC" : "FFS",
- ".PEI" : "FFS",
- ".DXE" : "FFS",
- ".APP" : "FFS",
- ".FYI" : "FFS",
- ".FFS" : "FFS",
- ".bmp" : "BMP",
- ".i" : "PPCode",
- ".asl" : "ASL",
- ".Asl" : "ASL",
- ".ASL" : "ASL",
- }
- _ToolMapping = {
- "CCode" : "CC",
- "CHeader" : "",
- "ASM" : "ASM",
- "Assembly" : "ASM",
- "IpfAssembly" : "ASM",
- "GccAssembly" : "ASM",
- "UNI" : "",
- "Unicode" : "",
- "VFR" : "",
- "DPX" : "",
- "FirmwareVolume" : "",
- "EFI" : "",
- "FFS" : "",
- "PPCode" : "PP",
- "BMP" : "",
- }
-
- _BuildableFileTypes = ("CCode", "ASM", "Assembly", "IpfAssembly", "GccAssembly", "UNI", "Unicode", "VFR", "DPX", "EFI")
-
- def __init__(self, workspace, owner=None, dom=None, parse=True, postprocess=True):
- self._Workspace = workspace
-
- if owner == None: self._Owner = ""
- else: self._Owner = owner
-
- if dom == None: self._Root = ""
- else: self._Root = dom
-
- self._Elements = {}
-
- if parse: self.Parse()
- if postprocess: self.Postprocess()
-
- def Parse(self):
- """Parse the XML element in DOM form"""
- pass
-
- def Postprocess(self):
- """Re-organize the original information form XML DOM into a format which can be used directly"""
- pass
-
- def GetArchList(self, dom):
- """Parse the SupArchList attribute. If not spcified, return all ARCH supported"""
- archs = XmlAttribute(dom, "SupArchList").split()
- if archs == []:
- if self._Owner.Archs != []:
- archs = self._Owner.Archs
- elif self._Workspace.ActiveArchs != []:
- archs = self._Workspace.ActiveArchs
- elif self._Workspace.ActivePlatform != "" and self._Workspace.ActivePlatform.Archs != []:
- archs = self._Workspace.ActivePlatform.Archs
- else:
- archs = self._Archs
- return archs
-
- def GetModuleTypeList(self, dom):
- """Parse the SupModuleList attribute. If not specified, return all supported module types"""
- moduleTypes = XmlAttribute(dom, "SupModuleList").split()
- if moduleTypes == []:
- moduleTypes = self._ModuleTypes
- return moduleTypes
-
- def GetGuidTypeList(self, dom):
- """Parse GuidTypeList attribute. Default to GUID if not specified"""
- guidTypes = XmlAttribute(dom, "GuidTypeList")
- if guidTypes == []:
- guidTypes = ["GUID"]
- return guidTypes
-
- def GetFeatureList(self, dom):
- """Parse FeatureFlag attribute"""
- return XmlAttribute(dom, "FeatureFlag").split()
-
- def GetToolchainTagList(self, dom):
- """Parse TagName attribute. Return all defined toolchains defined in tools_def.txt if not given"""
- toolchainTagString = XmlAttribute(dom, "TagName")
- if toolchainTagString == "":
- return self._Workspace.ToolConfig.Toolchains
- return toolchainTagString.split()
-
- def GetToolchainFamilyList(self, dom):
- """Parse ToolChainFamily attribute. Return all defined toolchain families in tools_def.txt if not given"""
- familyString = XmlAttribute(dom, "ToolChainFamily")
- if familyString != "":
- return familyString.split()
- return self._Workspace.ToolConfig.Families
-
- def GetTargetList(self, dom):
- """Parse BuildTargets attribute. Return all build targets defined in tools_def.txt if not given"""
- targetList = XmlAttribute(dom, "BuildTargets").split()
- if targetList == []:
- targetList = self._Workspace.ToolConfig.Targets
- return targetList
-
- def GetUsage(self, dom):
- """Parse Usage attribute. Default to ALWAYS_CONSUMED if not given"""
- usageString = XmlAttribute(dom, "Usage")
- if usageString == "":
- return "ALWAYS_CONSUMED"
- return usageString
-
- def GetBuildOptionList(self, dom):
- """Parse Options/Option element. Return a options dictionay with keys as (toolchain, target, arch, toolcode, attr)"""
- optionList = XmlList(dom, "/Options/Option")
- buildOptions = {}
- for option in optionList:
- targets = self.GetTargetList(option)
- toolchainFamilies = self.GetToolchainFamilyList(option)
- toolchainTags = self.GetToolchainTagList(option)
- toolcode = XmlAttribute(option, "ToolCode")
- archs = self.GetArchList(option)
- flag = XmlElementData(option)
- # print flag
-
- toolchains = []
- if toolchainTags != []:
- toolchains = toolchainTags
- elif toolchainFamilies != []:
- toolchains = toolchainFamilies
- else:
- raise Exception("No toolchain specified for a build option: " + self._Owner.Name)
-
- if targets == []: targets = self._Workspace.ActiveTargets
- if archs == []: archs = self._Workspace.ActiveArchs
-
- for toolchain in toolchains:
- for target in targets:
- for arch in archs:
- buildOptions[(toolchain, target, arch, toolcode, "FLAGS")] = flag
- return buildOptions
-
- def GetFvBindingList(self, dom):
- """Parse FvBinding element. If not specified, return NULL FV"""
- fvBindingList = XmlElementData(dom).split()
- if fvBindingList == []:
- fvBindingList = ["NULL"]
- return fvBindingList
-
- def IsBuildable(self, type):
- """Test if a file with the type can be built by a tool"""
- return type in self._BuildableFileTypes
-
- def GetToolCode(self, type):
- """Get the toolcode which must be used to build files with the type"""
- toolcode = ""
- if type in self._ToolMapping:
- toolcode = self._ToolMapping[type]
- return toolcode
-
- def GetBoolean(self, dom):
- """Transate true/false in string form to python's True/False value"""
- boolString = XmlElementData(dom).upper()
- if boolString == "" or boolString == "FALSE" or boolString == "NO":
- return False
- else:
- return True
-
-class LibraryDeclaration(FrameworkElement.LibraryInterface, SurfaceAreaElement):
- def __init__(self, workspace, package, dom):
- FrameworkElement.LibraryInterface.__init__(self)
- self.Package = package
- SurfaceAreaElement.__init__(self, workspace, package, dom)
-
- def Parse(self):
- dom = self._Root
- self.Name = XmlAttribute(dom, "Name")
- self.Path = os.path.normpath(XmlElementData(XmlNode(dom, "/LibraryClass/IncludeHeader")))
- self.Dir = os.path.dirname(self.Path)
-
- attribute = XmlAttribute(dom, "RecommendedInstanceGuid")
- if attribute is not '':
- self.FavoriteIntance = FrameworkElement.Module()
- self.FavoriteIntance.Guid = attribute
-
- attribute = XmlAttribute(dom, "RecommendedInstanceVersion")
- if attribute is not '':
- if self.FavoriteIntance == "":
- raise "No GUID for the recommened library instance"
- self.FavoriteIntance.Version = attribute
-
- self.Archs = self.GetArchList(dom)
- self.ModuleTypes = self.GetModuleTypeList(dom)
-
-class LibraryClass(FrameworkElement.LibraryClass, SurfaceAreaElement):
- def __init__(self, workspace, module, dom):
- FrameworkElement.LibraryClass.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, module, dom)
-
- def Parse(self):
- dom = self._Root
-
- self.Name = XmlElementData(XmlNode(dom, "/LibraryClass/Keyword"))
- self.Usage = self.GetUsage(dom)
- self.Features = self.GetFeatureList(dom)
- self.Archs = self.GetArchList(dom)
-
- attribute = XmlAttribute(dom, "RecommendedInstanceGuid")
- if attribute is not '':
- self.FavoriteIntance = FrameworkElement.Module()
- self.FavoriteIntance.Guid = attribute
-
- attribute = XmlAttribute(dom, "RecommendedInstanceVersion")
- if attribute is not '':
- if self.FavoriteIntance == "":
- self.FavoriteIntance = FrameworkElement.Module()
- self.FavoriteIntance.Version = attribute
-
-class SourceFile(FrameworkElement.SourceFile, SurfaceAreaElement):
- def __init__(self, workspace, module, dom):
- FrameworkElement.SourceFile.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, module, dom)
-
- def Parse(self):
- dom = self._Root
- self.Path = os.path.normpath(XmlElementData(dom))
- self.Dir = os.path.dirname(self.Path)
- self.Type = self.GetFileType()
- self.Toolchains = self.GetToolchainTagList(dom)
- self.Families = self.GetToolchainFamilyList(dom)
- self.Archs = self.GetArchList(dom)
- self.Features = self.GetFeatureList(dom)
-
- def GetFileType(self):
- type = XmlAttribute(self._Root, "ToolCode")
- if type == "":
- fileName = os.path.basename(self.Path)
- self.BaseName,self.Ext = os.path.splitext(fileName)
- if self.Ext in self._FileTypes:
- type = self._FileTypes[self.Ext]
- else:
- type = ""
- return type
-
-class PackageDependency(FrameworkElement.PackageDependency, SurfaceAreaElement):
- def __init__(self, workspace, module, dom):
- FrameworkElement.PackageDependency.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, module, dom)
-
- def Parse(self):
- dom = self._Root
- self.GuidValue = XmlAttribute(dom, "PackageGuid").upper()
- self.Version = XmlAttribute(dom, "PackageVersion")
- self.Archs = self.GetArchList(dom)
- self.Features = self.GetFeatureList(dom)
-
- def Postprocess(self):
- self.Package = self._Workspace.GetPackage(self.GuidValue, self.Version)
- if self.Package == "": raise "No package with GUID=" + self.GuidValue + "VERSION=" + self.Version
-
-class Protocol(FrameworkElement.Protocol, SurfaceAreaElement):
- def __init__(self, workspace, module, dom):
- FrameworkElement.Protocol.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, module, dom)
-
- def Parse(self):
- dom = self._Root
- self.CName = XmlElementData(XmlNode(dom, "/Protocol/ProtocolCName"))
- self.Usage = self.GetUsage(dom)
- self.Archs = self.GetArchList(dom)
- self.Features = self.GetFeatureList(dom)
-
- def Postprocess(self):
- for pd in self._Owner._Elements["PackageDependencies"]:
- if self.CName not in pd.Package.Protocols: continue
- self.GuidValue = pd.Package.Protocols[self.CName]
-
-class ProtocolNotify(FrameworkElement.ProtocolNotify, SurfaceAreaElement):
- def __init__(self, workspace, module, dom):
- FrameworkElement.ProtocolNotify.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, module, dom)
-
- def Parse(self):
- dom = self._Root
-
- self.CName = XmlElementData(XmlNode(dom, "/ProtocolNotify/ProtocolCName"))
- self.Usage = self.GetUsage(dom)
- self.Archs = self.GetArchList(dom)
- self.Features = self.GetFeatureList(dom)
-
- def Postprocess(self):
- for pd in self._Owner._Elements["PackageDependencies"]:
- if self.CName not in pd.Package.Protocols: continue
- self.GuidValue = pd.Package.Protocols[self.CName]
-
-class Ppi(FrameworkElement.Ppi, SurfaceAreaElement):
- def __init__(self, workspace, module, dom):
- FrameworkElement.Ppi.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, module, dom)
-
- def Parse(self):
- dom = self._Root
- self.CName = XmlElementData(XmlNode(dom, "/Ppi/PpiCName"))
- self.Usage = self.GetUsage(dom)
- self.Archs = self.GetArchList(dom)
- self.Features = self.GetFeatureList(dom)
-
- def Postprocess(self):
- for pd in self._Owner._Elements["PackageDependencies"]:
- if self.CName not in pd.Package.Ppis: continue
- self.GuidValue = pd.Package.Ppis[self.CName]
-
-class PpiNotify(FrameworkElement.PpiNotify, SurfaceAreaElement):
- def __init__(self, workspace, module, dom):
- FrameworkElement.PpiNotify.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, module, dom)
-
- def Parse(self):
- dom = self._Root
- self.CName = XmlElementData(XmlNode(dom, "/PpiNotify/PpiCName"))
- self.Usage = self.GetUsage(dom)
- self.Archs = self.GetArchList(dom)
- self.Features = self.GetFeatureList(dom)
-
- def Postprocess(self):
- for pd in self._Owner._Elements["PackageDependencies"]:
- if self.CName not in pd.Package.Ppis: continue
- self.GuidValue = pd.Package.Ppis[self.CName]
-
-class Guid(FrameworkElement.Guid, SurfaceAreaElement):
- def __init__(self, workspace, module, dom):
- FrameworkElement.Guid.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, module, dom)
-
- def Parse(self):
- dom = self._Root
- self.CName = XmlElementData(XmlNode(dom, "/GuidCNames/GuidCName"))
- self.Usage = self.GetUsage(dom)
- self.Archs = self.GetArchList(dom)
- self.Features = self.GetFeatureList(dom)
-
- def Postprocess(self):
- for pd in self._Owner._Elements["PackageDependencies"]:
- if self.CName not in pd.Package.Guids: continue
- self.GuidValue = pd.Package.Guids[self.CName]
-
-class Extern(FrameworkElement.Extern, SurfaceAreaElement):
- def __init__(self, workspace, module, dom):
- FrameworkElement.Extern.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, module, dom)
-
- def Parse(self):
- dom = self._Root
- self.Archs = self.GetArchList(dom)
- self.Features = self.GetFeatureList(dom)
-
- extern = XmlNode(dom, "/Extern/ModuleEntryPoint")
- if extern is not None and extern is not '':
- self.ModuleEntryPoints.append(XmlElementData(extern))
-
- extern = XmlNode(dom, "/Extern/ModuleUnloadImage")
- if extern is not None and extern is not '':
- self.ModuleUnloadImages.append(XmlElementData(extern))
-
- extern = XmlNode(dom, "/Extern/Constructor")
- if extern is not None and extern is not '':
- self.Constructors.append(XmlElementData(extern))
-
- extern = XmlNode(dom, "/Extern/Destructor")
- if extern is not None and extern is not '':
- self.Destructors.append(XmlElementData(extern))
-
- extern = XmlNode(dom, "/Extern/DriverBinding")
- if extern is not None and extern is not '':
- self.DriverBindings.append(XmlElementData(extern))
-
- extern = XmlNode(dom, "/Extern/ComponentName")
- if extern is not None and extern is not '':
- self.ComponentNames.append(XmlElementData(extern))
-
- extern = XmlNode(dom, "/Extern/DriverConfig")
- if extern is not None and extern is not '':
- self.DriverConfigs.append(XmlElementData(extern))
-
- extern = XmlNode(dom, "/Extern/DriverDiag")
- if extern is not None and extern is not '':
- self.DriverDiags.append(XmlElementData(extern))
-
- extern = XmlNode(dom, "/Extern/SetVirtualAddressMapCallBacks")
- if extern is not None and extern is not '':
- self.SetVirtualAddressMapCallBacks.append(XmlElementData(extern))
-
- extern = XmlNode(dom, "/Extern/ExitBootServicesCallBack")
- if extern is not None and extern is not '':
- self.ExitBootServicesCallBacks.append(XmlElementData(extern))
-
-class IndustryStdHeader(FrameworkElement.IncludeFile, SurfaceAreaElement):
- def __init__(self, workspace, package, dom):
- FrameworkElement.IncludeFile.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, package, dom)
-
- def Parse(self):
- dom = self._Root
- self.Path = os.path.normpath(XmlElementData(XmlNode(dom, "/IndustryStdHeader/IncludeHeader")))
- self.Dir = os.path.dirname(self.Path)
- self.Archs = self.GetArchList(dom)
- self.ModuleTypes = self.GetModuleTypeList(dom)
-
-class PackageHeader(FrameworkElement.IncludeFile, SurfaceAreaElement):
- def __init__(self, workspace, package, dom):
- FrameworkElement.IncludeFile.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, package, dom)
-
- def Parse(self):
- dom = self._Root
- self.Path = os.path.normpath(XmlElementData(dom))
- self.Dir = os.path.dirname(self.Path)
- self.ModuleType = XmlAttribute(dom, "ModuleType")
-
-class GuidDeclaration(FrameworkElement.Guid, SurfaceAreaElement):
- def __init__(self, workspace, package, dom):
- FrameworkElement.Guid.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, package, dom)
-
- def Parse(self):
- dom = self._Root
- self.CName = XmlElementData(XmlNode(dom, "/Entry/C_Name"))
- self.GuidValue = XmlElementData(XmlNode(dom, "/Entry/GuidValue")).upper()
- self.Name = XmlAttribute(dom, "Name")
- self.Types = self.GetGuidTypeList(dom)
- self.Archs = self.GetArchList(dom)
- self.ModuleTypes = self.GetModuleTypeList(dom)
-
- def Postprocess(self):
- pass
-
-class ProtocolDeclaration(GuidDeclaration, SurfaceAreaElement):
- pass
-
-class PpiDeclaration(GuidDeclaration, SurfaceAreaElement):
- pass
-
-class PcdDeclaration(FrameworkElement.Pcd, SurfaceAreaElement):
- def __init__(self, workspace, package, dom):
- FrameworkElement.Pcd.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, package, dom)
-
- def Parse(self):
- dom = self._Root
- self.Types = XmlElementData(XmlNode(dom, "/PcdEntry/ValidUsage")).split()
- self.CName = XmlElementData(XmlNode(dom, "/PcdEntry/C_Name"))
- self.Token = XmlElementData(XmlNode(dom, "/PcdEntry/Token"))
- self.TokenSpace = XmlElementData(XmlNode(dom, "/PcdEntry/TokenSpaceGuidCName"))
- self.DatumType = XmlElementData(XmlNode(dom, "/PcdEntry/DatumType"))
- self.Default = XmlElementData(XmlNode(dom, "/PcdEntry/DefaultValue"))
- self.Archs = self.GetArchList(dom)
- self.ModuleTypes= self.GetModuleTypeList(dom)
-
-class LibraryInstance(FrameworkElement.PlatformModule, SurfaceAreaElement):
- def __init__(self, workspace, platformModule, dom):
- FrameworkElement.PlatformModule.__init__(self)
- SurfaceAreaElement.__init__(self, workspace, platformModule, dom)
-
- def Parse(self):
- dom = self._Root
- self.GuidValue = XmlAttribute(dom, "ModuleGuid").upper()
- self.Version = XmlAttribute(dom, "ModuleVersion")
- self._Elements["PackageGuid"] = XmlAttribute(dom, "PackageGuid").upper()
- self._Elements["PackageVersion"] = XmlAttribute(dom, "PackageVersion")
-
- def Postprocess(self):
- self.Module = self._Workspace.GetModule(self.GuidValue, self.Version,
- self._Elements["PackageGuid"], self._Elements["PackageVersion"])
- self.Platform = self._Owner.Platform
- self.Archs = self._Owner.Archs
- self.Pcds = self._Owner.Pcds
- self.BuildType = "lib"
-
-class PlatformModule(FrameworkElement.PlatformModule, SurfaceAreaElement):
- def __init__(self, workspace, platform, dom):
- FrameworkElement.PlatformModule.__init__(self)
- self.Platform = platform
- SurfaceAreaElement.__init__(self, workspace, platform, dom)
-
- def Parse(self):
- dom = self._Root
- self.GuidValue = XmlAttribute(dom, "ModuleGuid").upper()
- self.Version = XmlAttribute(dom, "ModuleVersion")
- self.Archs = self.GetArchList(dom)
-
- self._Elements["PackageGuid"] = XmlAttribute(dom, "PackageGuid").upper()
- self._Elements["PackageVersion"] = XmlAttribute(dom, "PackageVersion")
-
- libraryList = XmlList(dom, "/ModuleSA/Libraries/Instance")
- for lib in libraryList:
- self.Libraries.append(LibraryInstance(self._Workspace, self, lib))
-
- dom = XmlNode(dom, "/ModuleSA/ModuleSaBuildOptions")
- self.FvBindings = self.GetFvBindingList(XmlNode(dom, "/ModuleSaBuildOptions/FvBinding"))
- self.FfsLayouts = XmlElementData(XmlNode(dom, "/ModuleSaBuildOptions/FfsFormatKey")).split()
- self.BuildOptions = self.GetBuildOptionList(XmlNode(dom, "/ModuleSaBuildOptions/Options"))
-
- def Postprocess(self):
- self.Module = self._Workspace.GetModule(self.GuidValue, self.Version,
- self._Elements["PackageGuid"], self._Elements["PackageVersion"])
- if self.Module == "":
- raise Exception("No module found: \n\t\tGUID=%s \n\t\tVERSION=%s \n\t\tPACKAGE_GUID=%s \n\t\tPACKAGE_VERSION=%s" % (
- self.GuidValue, self.Version, self._Elements["PackageGuid"], self._Elements["PackageVersion"]))
-
-## def SetupEnvironment(self):
-## self.Environment = {
-## "ARCH" : "",
-## "MODULE_BUILD_TARGET" : "",
-## "SINGLE_MODULE_BUILD" : "",
-## "PLATFORM_PREBUILD" : "",
-## "PLATFORM_POSTBUILD" : "",
-## "LIBS" : "",
-## "SOURCE_FILES" : "",
-## "ENTRYPOINT" : "_ModuleEntryPoint",
-## } # name/value pairs
-## self.Environment["MODULE_BUILD_TARGET"] = "platform_module_build"
-
-class ModuleSurfaceArea(FrameworkElement.Module, SurfaceAreaElement):
- def __init__(self, workspace, package, path):
- FrameworkElement.Module.__init__(self)
-
- self.Path = os.path.normpath(path)
- self.Dir = os.path.dirname(self.Path)
- self.FileBaseName,_ext = os.path.splitext(os.path.basename(self.Path))
- self.Package = package
- SurfaceAreaElement.__init__(self, workspace, package)
-
- def _MsaHeader(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- self.Name = XmlElementData(XmlNode(dom, "/MsaHeader/ModuleName"))
- self.Type = XmlElementData(XmlNode(dom, "/MsaHeader/ModuleType"))
- self.GuidValue = XmlElementData(XmlNode(dom, "/MsaHeader/GuidValue")).upper()
- self.Version = XmlElementData(XmlNode(dom, "/MsaHeader/Version"))
-
- def _ModuleDefinitions(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- self.Archs = XmlElementData(XmlNode(dom, "/ModuleDefinitions/SupportedArchitectures")).split()
- self.IsBinary = self.GetBoolean(XmlNode(dom, "/ModuleDefinitions/BinaryModule"))
- self.BaseName = XmlElementData(XmlNode(dom, "/ModuleDefinitions/OutputFileBasename"))
-
- def _LibraryClassDefinitions(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- lcList = []
- for lc in XmlList(dom, "/LibraryClassDefinitions/LibraryClass"):
- lcList.append(LibraryClass(self._Workspace, self, lc))
- self._Elements["LibraryClassDefinitions"] = lcList
-
- def _SourceFiles(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- srcList = []
- for f in XmlList(dom, "/SourceFiles/Filename"):
- srcList.append(SourceFile(self._Workspace, self, f))
- self._Elements["SourceFiles"] = srcList
-
- def _NonProcessedFiles(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- for f in XmlList(dom, "/NonProcessedFiles/Filename"):
- self.NonProcessedFiles.append(SourceFile(self._Workspace, self, f))
-
- def _PackageDependencies(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- pdList = []
- for pkg in XmlList(dom, "/PackageDependencies/Package"):
- pdList.append(PackageDependency(self._Workspace, self, pkg))
- self._Elements["PackageDependencies"] = pdList
-
- def _Protocols(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
-
- protocolList = []
- for p in XmlList(dom, "/Protocols/Protocol"):
- protocolList.append(Protocol(self._Workspace, self, p))
- for p in XmlList(dom, "/Protocols/ProtocolNotify"):
- protocolList.append(ProtocolNotify(self._Workspace, self, p))
-
- self._Elements["Protocols"] = protocolList
-
- def _Ppis(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
-
- ppiList = []
- for p in XmlList(dom, "/PPIs/Ppi"):
- ppiList.append(Ppi(self._Workspace, self, p))
- for p in XmlList(dom, "/PPIs/PpiNotify"):
- ppiList.append(PpiNotify(self._Workspace, self, p))
-
- self._Elements["PPIs"] = ppiList
-
- def _Guids(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- guidList = []
- for g in XmlList(dom, "/Guids/GuidCNames"):
- guidList.append(Guid(self._Workspace, self, g))
- self._Elements["Guids"] = guidList
-
- def _Externs(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- self.PcdIsDriver = self.GetBoolean(XmlNode(dom, "/Externs/PcdIsDriver"))
- self.NeedsFlashMap_h = self.GetBoolean(XmlNode(dom, "/Externs/TianoR8FlashMap_h"))
-
- externList = []
- specs = FrameworkElement.Extern()
- specs.Archs = self._Archs
- externList.append(specs)
- for spec in XmlList(dom, "/Externs/Specification"):
- specs.Specifications.append(XmlElementData(spec))
- for ext in XmlList(dom, "/Externs/Extern"):
- externList.append(Extern(self._Workspace, self, ext))
- self._Elements["Externs"] = externList
-
- def _ModuleBuildOptions(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- self.BuildOptions = self.GetBuildOptionList(XmlNode(dom, "/ModuleBuildOptions/Options"))
-
- def _UserExtensions(self, xpath):
- domList = XmlList(self._Root, xpath)
- if domList == []: return
- for extension in domList:
- userId = XmlAttribute(extension, "UserID")
- identifier = XmlAttribute(extension, "Identifier")
- if userId == '' or identifier == '':
- raise Exception("No UserId or Identifier specified")
- if userId != "TianoCore": continue
- if identifier not in self.UserExtensions:
- self.UserExtensions[identifier] = []
-
- contentList = self.UserExtensions[identifier]
- for node in extension.childNodes:
- #print node.nodeType
- contentList.append(node.cloneNode(True))
-
- def Parse(self):
- fileFullPath = self._Workspace.SubPath(os.path.dirname(self.Package.Path), self.Path)
- self._Root = xml.dom.minidom.parse(fileFullPath)
- assert self._Root.documentElement.tagName == "ModuleSurfaceArea"
-
- # print " Parsing...",self.Path
- self._MsaHeader("/ModuleSurfaceArea/MsaHeader")
- self._ModuleDefinitions("/ModuleSurfaceArea/ModuleDefinitions")
- self._PackageDependencies("/ModuleSurfaceArea/PackageDependencies")
- self._LibraryClassDefinitions("/ModuleSurfaceArea/LibraryClassDefinitions")
- self._SourceFiles("/ModuleSurfaceArea/SourceFiles")
- self._NonProcessedFiles("/ModuleSurfaceArea/NonProcessedFiles")
- self._Protocols("/ModuleSurfaceArea/Protocols")
- self._Ppis("/ModuleSurfaceArea/Ppis")
- self._Guids("/ModuleSurfaceArea/Guids")
- self._Externs("/ModuleSurfaceArea/Externs")
- self._ModuleBuildOptions("/ModuleSurfaceArea/ModuleBuildOptions")
- self._UserExtensions("/ModuleSurfaceArea/UserExtensions")
-
- def Postprocess(self):
- # resolve package dependency
- if self._Elements.has_key("PackageDependencies"):
- for pd in self._Elements["PackageDependencies"]:
- package = pd.Package
- if self.Type not in package.PackageIncludes:
- print "! Module type %s is not supported in the package %s" % (self.Type, package.Name)
-
- for arch in pd.Archs:
- if arch not in self.IncludePaths:
- self.IncludePaths[arch] = []
- self.IncludePaths[arch].append(package.SubPath("Include"))
- self.IncludePaths[arch].append(package.SubPath("Include", arch.capitalize()))
-
- if arch not in self.IncludeFiles:
- self.IncludeFiles[arch] = []
- if self.Type in package.PackageIncludes:
- for path in package.PackageIncludes[self.Type]:
- self.IncludeFiles[arch].append(package.SubPath(path))
-
- # resolve library class
- if self._Elements.has_key("LibraryClassDefinitions"):
- for lc in self._Elements["LibraryClassDefinitions"]:
- lc.Interface = self.GetLibraryInterface(lc.Name)
- if "ALWAYS_PRODUCED" in lc.Usage:
- self.IsLibrary = True
- lc.Interface.Instances.append(self)
- else:
- lc.Interface.Consumers.append(self)
-
- for arch in lc.Archs:
- if arch not in self.LibraryClasses:
- self.LibraryClasses[arch] = []
- self.LibraryClasses[arch].append(lc)
-
- # expand source files
- if self._Elements.has_key("SourceFiles"):
- for src in self._Elements["SourceFiles"]:
- for arch in src.Archs:
- if arch not in self.SourceFiles:
- self.SourceFiles[arch] = {}
- if src.Type not in self.SourceFiles[arch]:
- self.SourceFiles[arch][src.Type] = []
- self.SourceFiles[arch][src.Type].append(src)
-
- # expand guids
- if self._Elements.has_key("Guids"):
- for guid in self._Elements["Guids"]:
- for arch in guid.Archs:
- if arch not in self.Guids:
- self.Guids[arch] = []
- self.Guids[arch].append(guid)
-
- # expand protocol
- if self._Elements.has_key("Protocols"):
- for protocol in self._Elements["Protocols"]:
- for arch in protocol.Archs:
- if arch not in self.Protocols:
- self.Protocols[arch] = []
- self.Protocols[arch].append(protocol)
-
- # expand ppi
- if self._Elements.has_key("PPIs"):
- for ppi in self._Elements["PPIs"]:
- for arch in ppi.Archs:
- if arch not in self.Ppis:
- self.Ppis[arch] = []
- self.Ppis[arch].append(ppi)
-
- # expand extern
- if self._Elements.has_key("Externs"):
- for extern in self._Elements["Externs"]:
- for arch in extern.Archs:
- if arch not in self.Externs:
- self.Externs[arch] = []
- self.Externs[arch].append(extern)
-
- def GetLibraryInterface(self, name):
- if name in self.Package.LibraryInterfaces:
- return self.Package.LibraryInterfaces[name]
- for pd in self._Elements["PackageDependencies"]:
- if name in pd.Package.LibraryInterfaces:
- return pd.Package.LibraryInterfaces[name]
- return ""
-## def SetupEnvironment(self):
-## self.Environment["MODULE"] = self.Name
-## self.Environment["MODULE_GUID"] = self.GuidValue
-## self.Environment["MODULE_VERSION"] = self.Version
-## self.Environment["MODULE_TYPE"] = self.Type
-## self.Environment["MODULE_FILE_BASE_NAME"] = os.path.basename(self.Path).split(".")[0]
-## self.Environment["MODULE_RELATIVE_DIR"] = os.path.dirname(self.Path)
-## self.Environment["BASE_NAME"] = self.OutputName
-
-class Workspace(FrameworkElement.Workspace, SurfaceAreaElement):
- _Db = "Tools/Conf/FrameworkDatabase.db"
- _Target = "Tools/Conf/Target.txt"
- _PlatformBuildPath = "Tools/Conf/platform_build_path.txt"
- _ModuleBuildPath = "Tools/Conf/module_build_path.txt"
-
- def __init__(self, path, fpdList=None, msaList=None):
- FrameworkElement.Workspace.__init__(self)
- SurfaceAreaElement.__init__(self, self, None, None, False, False)
- self.Path = os.path.normpath(path)
- self.Dir = os.path.dirname(self.Path)
- self._Elements["PlatformList"] = fpdList
- self._Elements["ModuleList"] = msaList
- self.Parse()
- self.Postprocess()
-
- def _FdbHeader(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- self.Name = XmlElementData(XmlNode(dom, "/FdbHeader/DatabaseName"))
- self.GuidValue = XmlElementData(XmlNode(dom, "/FdbHeader/GuidValue")).upper()
- self.Version = XmlElementData(XmlNode(dom, "/FdbHeader/Version"))
-
- def _PackageList(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
-
- fileList = XmlList(dom, "/PackageList/Filename")
- packages = []
- for f in fileList:
- packages.append(os.path.normpath(XmlElementData(f)))
- self._Elements["PackageList"] = packages
-
- def _PlatformList(self, xpath):
- if len(self._Elements["PlatformList"]) > 0:
- return
-
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
-
- fileList = XmlList(dom, "/PlatformList/Filename")
- platforms = []
- for f in fileList:
- platforms.append(os.path.normpath(XmlElementData(f)))
- self._Elements["PlatformList"] = platforms
-
- def _FarList(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
-
- fileList = XmlList(dom, "/FarList/Filename")
- fars = []
- for f in fileList:
- fars.append(os.path.normpath(XmlElementData(f)))
- self._Elements["FarList"] = fars
-
- def ParseWorkspaceDatabase(self):
- # parse frameworkdatabase.db
- self._Root = xml.dom.minidom.parse(self.SubPath(self._Db))
- assert self._Root.documentElement.tagName == "FrameworkDatabase"
-
- self._FdbHeader("/FrameworkDatabase/FdbHeader")
- self._PackageList("/FrameworkDatabase/PackageList")
- self._PlatformList("/FrameworkDatabase/PlatformList")
- self._FarList("/FrameworkDatabase/FarList")
-
- def ParseConfig(self):
- # parse target.txt
- self.ParseTargetConfig()
- # parse tools_def.txt
- self.ParseToolConfig()
- # parse platform/module_build_path.txt
-
- # active toolchain
- # print self.TargetConfig
- self.ActiveToolchain = self.TargetConfig["TOOL_CHAIN_TAG"]
- if self.ActiveToolchain not in self.ToolConfig.Toolchains:
- raise "Not supported tool chain tag %s" % self.ActiveToolchain
-
- # active toolchain family
- self.ActiveFamilies = []
- for key in self.ToolConfig:
- if self.ActiveToolchain in key and "FAMILY" in key:
- family = self.ToolConfig[key]
- if family not in self.ActiveFamilies:
- self.ActiveFamilies.append(family)
-
-
- def ParsePackage(self, packagePaths=None):
- if packagePaths == None:
- return
-
- for packagePath in packagePaths:
- self.Packages.append(PackageSurfaceArea(self, packagePath))
-
- def ParsePlatform(self, platformPaths=None):
- # Only one active platform is allowed
- activePlatformPath = ""
- if self.TargetConfig["ACTIVE_PLATFORM"] == "":
- if platformPaths != None and len(platformPaths) == 1:
- activePlatformPath = platformPaths[0]
- else:
- raise Exception("No active platform specified or implied!")
- else:
- activePlatformPath = os.path.normpath(self.TargetConfig["ACTIVE_PLATFORM"])
-
- self.ActivePlatform = PlatformSurfaceArea(self, activePlatformPath)
- self.Platforms.append(self.ActivePlatform)
-
- def ParseTargetConfig(self):
- self.TargetConfig = BuildConfig.TargetConfig(self.SubPath(self._Target))
- # print self.TargetConfig
-
- def ParseToolConfig(self):
- self.ToolConfig = BuildConfig.ToolConfig(self.SubPath(self.TargetConfig["TOOL_CHAIN_CONF"]))
-
- def GetModule(self, guid, version, packageGuid, packageVersion):
- moduleGuidIndex = self.ModuleXref["GUID"]
- if guid not in moduleGuidIndex:
- print "! No module has GUID=" + guid
- return ""
-
- moduleVersionList = moduleGuidIndex[guid]
- # print moduleVersionList
- moduleList = []
- module = ""
- if version != "":
- if version in moduleVersionList:
- moduleList = moduleVersionList[version]
- else:
- return ""
- else:
- ## no version given, return the first one
- version = "0.0"
- for ver in moduleVersionList:
- if ver > version: version = ver
- moduleList = moduleVersionList[version]
-
- if packageGuid == "":
- ## if no package GUID given, just return the latest one
- version = "0.0"
- for m in moduleList:
- if m.Package.Version > version:
- version = m.Package.Version
- module = m
- else:
- version = "0.0"
- for m in moduleList:
- if m.Package.GuidValue != packageGuid: continue
- if packageVersion == "":
- ## if no version given, just return the latest
- if m.Package.Version > version:
- version = m.Package.Version
- module = m
- elif packageVersion == m.Package.Version:
- module = m
- break;
-
- return module
-
- def GetModuleByPath(self, path):
- ownerPackage = ""
- ownerPackageFullPath = ""
- for package in self.Packages:
- ownerPackageFullPath = self.SubPath(package.Path)
- if path.startswith(packageFullPath): break
-
- if ownerPackage == "":
- return ""
-
- for module in ownerPackage.Modules:
- moduleFullPath = os.path.join(ownerPackageFullPath, module.Path)
- if moduleFullPath == path:
- return module
-
- return ""
-
- def GetPackage(self, guid, version):
- packageGuidIndex = self.PackageXref["GUID"]
- if guid not in packageGuidIndex:
- # raise Exception("No package has GUID=" + guid)
- return ""
-
- packageList = packageGuidIndex[guid]
- package = ""
- if version != "":
- if version in packageList:
- package = packageList[version]
- else:
- ## no version given, return the latest one
- version = "0.0"
- for ver in packageList:
- if ver > version: version = ver
- package = packageList[version]
-
- return package
-
- def GetPlatform(self, guid, version):
- pass
-
- def GetPlatformByPath(self, path):
- for platform in self.Platforms:
- platformFullPath = self.SubPath(platform.Path)
- if platformFullPath == path:
- return platform
- return ""
-
- def GetLibraryInterface(self, name, package):
- if name not in self.LibraryInterfaceXref["NAME"]:
- return ""
- liList = self.LibraryInterfaceXref["NAME"][name]
- for li in liList:
- if li.Package == package:
- return li
- return ""
-
- def SubPath(self, *relativePathList):
- return os.path.normpath(os.path.join(self.Path, *relativePathList))
-
- def SetupCrossRef(self):
- ##
- ## setup platform cross reference as nest-dict
- ## guid -> {version -> platform}
- ##
- ## platformList = self.Platforms
- ## for p in platformList:
- ## guid = p.GuidValue
- ## version = p.Version
- ## if guid not in self.PlatformIndex:
- ## self.PlatformIndex[guid] = {}
- ## if version in self.PlatformIndex[guid]:
- ## raise Exception("Duplicate platform")
- ## self.PlatformIndex[guid][version] = p
-
- ##
- ## setup package cross reference as nest-dict
- ## guid -> {version -> package}
- ## name -> [package list]
- ## path -> package
- ##
- packageList = self.Packages
- for p in packageList:
- guid = p.GuidValue
- version = p.Version
- packageGuidIndex = self.PackageXref["GUID"]
- if guid not in packageGuidIndex:
- packageGuidIndex[guid] = {}
- if version in packageGuidIndex[guid]:
- raise Exception("Duplicate package: %s-%s [%s]" % p.Name, version, guid)
- packageGuidIndex[guid][version] = p
-
- packageNameIndex = self.PackageXref["NAME"]
- name = p.Name
- if name not in packageNameIndex:
- packageNameIndex[name] = []
- packageNameIndex[name].append(p)
-
- packagePathIndex = self.PackageXref["PATH"]
- path = p.Path
- if path in packagePathIndex:
- raise Exception("Duplicate package: %s %s" % p.Name, p.Path)
- packagePathIndex[path] = p.Path
-
- ##
- ## setup library class cross reference as
- ## library class name -> library class object
- ##
- for lcname in p.LibraryInterfaces:
- if lcname not in self.LibraryInterfaceXref["NAME"]:
- # raise Exception("Duplicate library class: %s in package %s" % (lcname, name))
- self.LibraryInterfaceXref["NAME"][lcname] = []
- lcInterface = p.LibraryInterfaces[lcname]
- self.LibraryInterfaceXref["NAME"][lcname].append(lcInterface)
-
- lcHeader = p.SubPath(lcInterface.Path)
- if lcHeader not in self.LibraryInterfaceXref["PATH"]:
- # raise Exception("Duplicate library class interface: %s in package %s" % (lcInterface, name))
- self.LibraryInterfaceXref["PATH"][lcHeader] = []
- self.LibraryInterfaceXref["PATH"][lcHeader].append(lcInterface)
-
- ##
- ## setup package cross reference as nest-dict
- ## guid -> {version -> [module list]}
- ## name -> [module list]
- ## path -> module
- for p in packageList:
- p.ParseMsaFile()
-
- moduleList = p.Modules
- for m in moduleList:
- name = m.Name
- path = m.Path
- guid = m.GuidValue
- version = m.Version
- moduleGuidIndex = self.ModuleXref["GUID"]
- if guid not in moduleGuidIndex:
- moduleGuidIndex[guid] = {}
- else:
- print "! Duplicate module GUID found:", guid, p.SubPath(path)
- dm = moduleGuidIndex[guid].values()[0][0]
- print " ", dm.GuidValue,\
- dm.Package.SubPath(dm.Path)
-
- if version not in moduleGuidIndex[guid]:
- moduleGuidIndex[guid][version] = []
- if m in moduleGuidIndex[guid][version]:
- raise Exception("Duplicate modules in the same package: %s-%s [%s]" % (name, version, guid))
- moduleGuidIndex[guid][version].append(m)
-
- modulePathIndex = self.ModuleXref["PATH"]
- path = p.SubPath(m.Path)
- if path in modulePathIndex:
- raise Exception("Duplicate modules in the same package: %s %s" % (name, path))
- modulePathIndex[path] = m
-
- moduleNameIndex = self.ModuleXref["NAME"]
- if name not in moduleNameIndex:
- moduleNameIndex[name] = []
- moduleNameIndex[name].append(m)
-
- def GetToolDef(self, toolchain, target, arch, toolcode, attr):
- return self.ToolConfig[(toolchain, target, arch, toolcode, attr)]
-
- def Parse(self):
- self.ParseConfig()
- self.ParseWorkspaceDatabase()
-
- def SetupBuild(self):
- # active archs
- self.ActiveArchs = self.TargetConfig["TARGET_ARCH"].split()
- if self.ActiveArchs == []:
- self.ActiveArchs = self.ActivePlatform.Archs
-
- # active targets
- self.ActiveTargets = self.TargetConfig["TARGET"].split()
- if self.ActiveTargets == []:
- self.ActiveTargets = self.ActivePlatform.Targets
-
-
- # active modules
- for msa in self._Elements["ModuleList"]:
- module = self.GetModuleByPath(msa)
- if module == "":
- raise Exception(msa + " is not in any package!")
- self.ActiveModules.append(module)
- self.IndividualModuleBuild = True
- if self.TargetConfig["MULTIPLE_THREAD"].upper() == "ENABLE":
- self.MultiThreadBuild = True
- if "MAX_CONCURRENT_THREAD_NUMBER" in self.TargetConfig:
- self.ThreadCount = self.TargetConfig["MAX_CONCURRENT_THREAD_NUMBER"]
- else:
- self.ThreadCount = "1"
-
- def Postprocess(self):
- self.ParsePackage(self._Elements["PackageList"])
- self.SetupCrossRef()
- self.ParsePlatform(self._Elements["PlatformList"])
- self.SetupBuild()
-
-## def SetupEnvironment(self):
-## config = BuildConfig.Config(self.SubPath(self._PlatformBuildPath))
-## for name in config:
-## self.Environment[name] = config[name]
-##
-## config = BuildConfig.Config(self.SubPath(self._ModuleBuildPath))
-## for name in config:
-## self.Environment[name] = config[name]
-##
-## multiThread = self.TargetConfig["MULTIPLE_THREAD"].upper()
-## threadNumber = self.TargetConfig["MAX_CONCURRENT_THREAD_NUMBER"]
-## if multiThread == "" or multiThread == "FALSE":
-## self.Environment["MULTIPLE_THREAD"] = False
-## self.Environment["MAX_CONCURRENT_THREAD_NUMBER"] = 1
-## else:
-## self.Environment["MULTIPLE_THREAD"] = True
-## if threadNumber != "":
-## self.Environment["MAX_CONCURRENT_THREAD_NUMBER"] = threadNumber
-## else:
-## self.Environment["MAX_CONCURRENT_THREAD_NUMBER"] = 2
-
-class PackageSurfaceArea(FrameworkElement.Package, SurfaceAreaElement):
- def __init__(self, workspace, path):
- FrameworkElement.Package.__init__(self)
-
- self.Path = os.path.normpath(path)
- self.Dir = os.path.dirname(self.Path)
- SurfaceAreaElement.__init__(self, workspace, workspace, None, True, True)
-
- def _SpdHeader(self, xpath):
- dom = XmlNode(self._Root, xpath)
- self.Name = XmlElementData(XmlNode(dom, "/SpdHeader/PackageName"))
- self.GuidValue = XmlElementData(XmlNode(dom, "/SpdHeader/GuidValue")).upper()
- self.Version = XmlElementData(XmlNode(dom, "/SpdHeader/Version"))
-
- def _PackageDefinitions(self, xpath):
- dom = XmlNode(self._Root, xpath)
- self.ReadOnly = XmlElementData(XmlNode(dom, "/PackageDefinitions/ReadOnly"))
- self.Repackage = XmlElementData(XmlNode(dom, "/PackageDefinitions/RePackage"))
-
- def _LibraryClassDeclarations(self, xpath):
- dom = XmlNode(self._Root, xpath)
- lcdList = XmlList(dom, "/LibraryClassDeclarations/LibraryClass")
- lcds = []
- for lc in lcdList:
- lcds.append(LibraryDeclaration(self._Workspace, self, lc))
- self._Elements["LibraryClassDeclarations"] = lcds
-
- def _IndustryStdIncludes(self, xpath):
- dom = XmlNode(self._Root, xpath)
- headerList = XmlList(dom, "/IndustryStdIncludes/IndustryStdHeader")
- headers = []
- for h in headerList:
- headers.append(IndustryStdHeader(self._Workspace, self, h))
- self._Elements["IndustryStdIncludes"] = headers
-
- def _MsaFiles(self, xpath):
- dom = XmlNode(self._Root, xpath)
- msaFileList = XmlList(dom, "/MsaFiles/Filename")
- msaFiles = []
- for msa in msaFileList:
- filePath = os.path.normpath(XmlElementData(msa))
- msaFiles.append(filePath)
- self._Elements["MsaFiles"] = msaFiles
-
- def _PackageHeaders(self, xpath):
- dom = XmlNode(self._Root, xpath)
- headerList = XmlList(dom, "/PackageHeaders/IncludePkgHeader")
- headers = []
- for h in headerList:
- headers.append(PackageHeader(self._Workspace, self, h))
- self._Elements["PackageHeaders"] = headers
-
- def _GuidDeclarations(self, xpath):
- dom = XmlNode(self._Root, xpath)
- guidList = XmlList(dom, "/GuidDeclarations/Entry")
- guids = []
- for guid in guidList:
- guids.append(GuidDeclaration(self._Workspace, self, guid))
- self._Elements["GuidDeclarations"] = guids
-
- def _ProtocolDeclarations(self, xpath):
- dom = XmlNode(self._Root, xpath)
- protocolList = XmlList(dom, "/ProtocolDeclarations/Entry")
- protocols = []
- for p in protocolList:
- protocols.append(ProtocolDeclaration(self._Workspace, self, p))
- self._Elements["ProtocolDeclarations"] = protocols
-
- def _PpiDeclarations(self, xpath):
- dom = XmlNode(self._Root, xpath)
- ppiList = XmlList(dom, "/PpiDeclarations/Entry")
- ppis = []
- for p in ppiList:
- ppis.append(PpiDeclaration(self._Workspace, self, p))
- self._Elements["PpiDeclarations"] = ppis
-
- def _PcdDeclarations(self, xpath):
- dom = XmlNode(self._Root, xpath)
- pcdList = XmlList(dom, "/PcdDeclarations/PcdEntry")
- pcds = []
- for p in pcdList:
- pcds.append(PcdDeclaration(self._Workspace, self, p))
- self._Elements["PcdDeclarations"] = pcds
-
- def SubPath(self, *relativePathList):
- return os.path.normpath(os.path.join(self.Dir, *relativePathList))
-
- def Parse(self):
- self._Root = xml.dom.minidom.parse(self._Workspace.SubPath(self.Path))
- assert self._Root.documentElement.tagName == "PackageSurfaceArea"
-
- # print "Parsing...",self.Path
- self._SpdHeader("/PackageSurfaceArea/SpdHeader")
- self._PackageDefinitions("/PackageSurfaceArea/PackageDefinitions")
- self._LibraryClassDeclarations("/PackageSurfaceArea/LibraryClassDeclarations")
- self._IndustryStdIncludes("/PackageSurfaceArea/IndustryStdIncludes")
- self._MsaFiles("/PackageSurfaceArea/MsaFiles")
- self._PackageHeaders("/PackageSurfaceArea/PackageHeaders")
- self._GuidDeclarations("/PackageSurfaceArea/GuidDeclarations")
- self._ProtocolDeclarations("/PackageSurfaceArea/ProtocolDeclarations")
- self._PpiDeclarations("/PackageSurfaceArea/PpiDeclarations")
- self._PcdDeclarations("/PackageSurfaceArea/PcdDeclarations")
-
- def Postprocess(self):
- # setup guid, protocol, ppi
- for guid in self._Elements["GuidDeclarations"]:
- if guid.CName in self.Guids:
- print "! Duplicate GUID CName (%s) in package %s" % (guid.CName, self.Path)
- self.Guids[guid.CName] = guid
-
- for protocol in self._Elements["ProtocolDeclarations"]:
- if protocol.CName in self.Protocols:
- print "! Duplicate Protocol CName (%s) in package %s" % (protocol.CName, self.Path)
- self.Protocols[protocol.CName] = protocol
-
- for ppi in self._Elements["PpiDeclarations"]:
- if ppi.CName in self.Ppis:
- print "! Duplicate PPI CName (%s) in package (%s)" % (ppi.CName, self.Path)
- self.Ppis[ppi.CName] = ppi
-
- # package header
- for inc in self._Elements["PackageHeaders"]:
- if inc.ModuleType not in self.PackageIncludes:
- self.PackageIncludes[inc.ModuleType] = []
- self.PackageIncludes[inc.ModuleType].append(inc.Path)
-
- # library class
- for lcd in self._Elements["LibraryClassDeclarations"]:
- if lcd.Name in self.LibraryInterfaces:
- raise "Duplicate library class: " + lcd.Name
- self.LibraryInterfaces[lcd.Name] = lcd
-
- # parse mas files
- # self.ParseMsaFile()
- # resolve RecommendedInstance
-
- def ParseMsaFile(self):
- for msaFilePath in self._Elements["MsaFiles"]:
- self.Modules.append(ModuleSurfaceArea(self._Workspace, self, msaFilePath))
-
-class PlatformSurfaceArea(FrameworkElement.Platform, SurfaceAreaElement):
- def __init__(self, workspace, path):
- FrameworkElement.Platform.__init__(self)
-
- self.Path = os.path.normpath(path)
- self.Dir = os.path.dirname(self.Path)
- SurfaceAreaElement.__init__(self, workspace)
-
- def _PlatformHeader(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- self.Name = XmlElementData(XmlNode(dom, "/PlatformHeader/PlatformName"))
- self.GuidValue = XmlElementData(XmlNode(dom, "/PlatformHeader/GuidValue")).upper()
- self.Version = XmlElementData(XmlNode(dom, "/PlatformHeader/Version"))
-
- def _PlatformDefinitions(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- self.Archs = XmlElementData(XmlNode(dom, "/PlatformDefinitions/SupportedArchitectures")).split()
- if self.Archs == []:
- raise Exception("No ARCH specified in platform " + self.Path)
- self.Targets = XmlElementData(XmlNode(dom, "/PlatformDefinitions/BuildTargets")).split()
- self.OutputPath = os.path.normpath(XmlElementData(XmlNode(dom, "/PlatformDefinitions/OutputDirectory")))
-
- def _Flash(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
-
- def _FrameworkModules(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- moduleList = XmlList(dom, "/FrameworkModules/ModuleSA")
- modules = []
- for m in moduleList:
- modules.append(PlatformModule(self._Workspace, self, m))
- self._Elements["FrameworkModules"] = modules
-
- def _DynamicPcdBuildDefinitions(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
-
- def _BuildOptions(self, xpath):
- dom = XmlNode(self._Root, xpath)
- if dom == '': return
- self.BuildOptions = self.GetBuildOptionList(XmlNode(dom, "/BuildOptions/Options"))
- # print self.BuildOptions
-
- def _UserExtensions(self, xpath):
- domList = XmlList(self._Root, xpath)
- if domList == []: return
- for extension in domList:
- userId = XmlAttribute(extension, "UserID")
- identifier = XmlAttribute(extension, "Identifier")
-
- if userId == '' or identifier == '':
- raise Exception("No UserId or Identifier specified")
- if userId != "TianoCore": continue
- if identifier not in self.UserExtensions:
- self.UserExtensions[identifier] = []
-
- contentList = self.UserExtensions[identifier]
- for node in extension.childNodes:
- # print node.nodeType
- contentList.append(node.cloneNode(True))
-
- def Parse(self):
- self._Root = xml.dom.minidom.parse(self._Workspace.SubPath(self.Path))
- assert self._Root.documentElement.tagName == "PlatformSurfaceArea"
-
- self._PlatformHeader("/PlatformSurfaceArea/PlatformHeader")
- self._PlatformDefinitions("/PlatformSurfaceArea/PlatformDefinitions")
- self._Flash("/PlatformSurfaceArea/Flash")
- self._FrameworkModules("/PlatformSurfaceArea/FrameworkModules")
- self._DynamicPcdBuildDefinitions("/PlatformSurfaceArea/DynamicPcdBuildDefinitions")
- self._BuildOptions("/PlatformSurfaceArea/BuildOptions")
- self._UserExtensions("/PlatformSurfaceArea/UserExtensions")
-
- def Postprocess(self):
- # summarize all library modules for build
- for module in self._Elements["FrameworkModules"]:
- for arch in module.Archs:
- if arch not in self.Modules:
- self.Modules[arch] = []
- self.Modules[arch].append(module)
-
- if arch not in self.Libraries:
- self.Libraries[arch] = []
- for li in module.Libraries:
- if li in self.Libraries[arch]: continue
- self.Libraries[arch].append(li)
-
- # FV
- for fvName in module.FvBindings:
- if fvName not in self.Fvs:
- self.Fvs[fvName] = []
- self.Fvs[fvName].append(module)
- # build options
- # user extension
-
-## def SetupEnvironment(self):
-## self.Environment["PLATFORM"] = self.Name
-## self.Environment["PLATFORM_GUID"] = self.GuidValue
-## self.Environment["PLATFORM_VERSION"] = self.Version
-## self.Environment["PLATFORM_RELATIVE_DIR"] = self.Path
-## self.Environment["PLATFORM_OUTPUT_DIR"] = self.OutputPath
-
-def PrintWorkspace(ws):
- print "\nPlatforms:\n"
- for guid in ws.PlatformXref["GUID"]:
- for ver in ws.PlatformXref["GUID"][guid]:
- platform = ws.PlatformXref["GUID"][guid][ver]
- print " %s %s-%s" % (guid, platform.Name, ver)
- for pm in platform.Modules:
- print " %-40s %-10s <%s-%s>" % (pm.Module.Name+"-"+pm.Module.Version,
- ListString(pm.Archs), pm.Module.Package.Name,
- pm.Module.Package.Version)
- for li in pm.Libraries:
- print " %-47s <%s-%s>" % (li.Module.Name+"-"+li.Module.Version,
- li.Module.Package.Name, li.Module.Package.Version)
- print ""
-
- print "\nPackages:\n"
- for guid in ws.PackageXref["GUID"]:
- for ver in ws.PackageXref["GUID"][guid]:
- print " %s %s-%s" % (guid, ws.PackageXref["GUID"][guid][ver].Name, ver)
-
- print "\nModules:\n"
- for guid in ws.ModuleXref["GUID"]:
- for ver in ws.ModuleXref["GUID"][guid]:
- for module in ws.ModuleXref["GUID"][guid][ver]:
- print " %s %-40s [%s-%s]" % (guid, module.Name+"-"+ver, module.Package.Name, module.Package.Version)
- print " Depending on packages:"
- for arch in module.IncludePaths:
- print " ", arch, ":"
- for path in module.IncludePaths[arch]:
- print " ", path
- print "\n"
-
- for arch in module.IncludeFiles:
- print " ", arch, ":"
- for path in module.IncludeFiles[arch]:
- print " ", path
- print "\n"
-
- print " Source files:"
- for arch in module.SourceFiles:
- print " ", arch, ":"
- for type in module.SourceFiles[arch]:
- for src in module.SourceFiles[arch][type]:
- print " %-40s (%s)" % (src.Path, src.Type)
- print "\n"
- print "\nLibrary Classes:"
- for name in ws.LibraryInterfaceXref["NAME"]:
- lcList = ws.LibraryInterfaceXref["NAME"][name]
- for lc in lcList:
- pkgPath = os.path.dirname(lc.Package.Path)
- print "\n [%s] <%s>" % (lc.Name, pkgPath + os.path.sep + lc.Path)
-
- print " Produced By:"
- for li in lc.Instances:
- print " %-40s <%s>" % (li.Name+"-"+li.Version, li.Package.SubPath(li.Path))
-
- print " Consumed By:"
- for li in lc.Consumers:
- print " %-40s <%s>" % (li.Name+"-"+li.Version, li.Package.SubPath(li.Path))
-
- print "\nActive Platform:"
- for arch in ws.ActivePlatform.Libraries:
- print " Library Instances (%s) (%d libraries)" % (arch , len(ws.ActivePlatform.Libraries[arch]))
- for li in ws.ActivePlatform.Libraries[arch]:
- print " %s-%s (%s-%s)" % (li.Module.Name, li.Module.Version,
- li.Module.Package.Name, li.Module.Package.Version)
-
- for arch in ws.ActivePlatform.Modules:
- print " Driver Modules (%s) (%d modules)" % (arch, len(ws.ActivePlatform.Modules[arch]))
- for m in ws.ActivePlatform.Modules[arch]:
- print " %s-%s (%s-%s)" % (m.Module.Name, m.Module.Version,
- m.Module.Package.Name, m.Module.Package.Version)
-
- for fv in ws.ActivePlatform.Fvs:
- print
- print " Firmware Volume (%s) (%d modules)" % (fv, len(ws.ActivePlatform.Fvs[fv]))
- for m in ws.ActivePlatform.Fvs[fv]:
- print " %s-%s (%s-%s)" % (m.Module.Name, m.Module.Version,
- m.Module.Package.Name, m.Module.Package.Version)
-
-# for test
-if __name__ == "__main__":
- # os.environ["WORKSPACE"]
- workspacePath = os.getenv("WORKSPACE", os.getcwd())
- saFile = ""
- if len(sys.argv) <= 1:
- saFile = os.path.join(workspacePath, "Tools/Conf/FrameworkDatabase.db")
- else:
- saFile = sys.argv[1]
-
- print "Parsing ... %s\n" % saFile
-
- startTime = time.clock()
- sa = Workspace(workspacePath, [], [])
- # sa = PackageSurfaceArea(saFile)
- # sa = PlatformSurfaceArea(saFile)
- # sa = ModuleSurfaceArea(saFile)
- # print sa
-
- PrintWorkspace(sa)
- print "\n[Finished in %fs]" % (time.clock() - startTime)
-
|