mirror of
https://git.proxmox.com/git/mirror_edk2
synced 2025-10-31 15:06:49 +00:00
b4667b1105
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2327 6f19259b-4bc3-4df7-8a09-765794883524
1556 lines
66 KiB
Python
1556 lines
66 KiB
Python
#!/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)
|
|
|