| #!/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. |
| |
| |
| """ This program converts EDK II MSA files into EDK II Extended INF format files """ |
| |
| import os, re, sys, fnmatch, xml.dom.minidom |
| from optparse import OptionParser |
| from AutoGenExterns import * |
| from Common.XmlRoutines import * # XmlParseFile, XmlElement, XmlAttribute, XmlList, XmlElementData, XmlNode |
| from Common.EdkIIWorkspace import * |
| |
| versionNumber = "0.9" |
| __version__ = "%prog Version " + versionNumber |
| __copyright__ = "Copyright (c) 2007, Intel Corporation All rights reserved." |
| |
| commonHeaderFilename = "CommonHeader.h" |
| entryPointFilename = "EntryPoint.c" |
| |
| AutoGenLibraryMapping = { |
| "HiiLib":"HiiLibFramework", |
| "EdkIfrSupportLib":"IfrSupportLibFramework", |
| "EdkScsiLib":"ScsiLib", |
| "EdkUsbLib":"UsbLib", |
| "EdkFvbServiceLib":"FvbServiceLib", |
| "EdkGraphicsLib":"GraphicsLib" |
| } |
| |
| def myOptionParser(): |
| """ Argument Parser """ |
| usage = "%prog [options] -f input_filename" |
| parser = OptionParser(usage=usage,description=__copyright__,version="%prog " + str(versionNumber)) |
| parser.add_option("-f", "--file", dest="filename", help="Name of MSA file to convert") |
| parser.add_option("-o", "--output", dest="outfile", help="Specific Name of the INF file to create, otherwise it is the MSA filename with the extension repalced.") |
| parser.add_option("-a", "--auto", action="store_true", dest="autowrite", default=False, help="Automatically create output files and write the INF file") |
| parser.add_option("-i", "--interactive", action="store_true", dest="interactive", default=False, help="Set Interactive mode, user must approve each change.") |
| parser.add_option("-q", "--quiet", action="store_const", const=0, dest="verbose", help="Do not print any messages, just return either 0 for succes or 1 for failure") |
| parser.add_option("-v", "--verbose", action="count", dest="verbose", help="Do not print any messages, just return either 0 for succes or 1 for failure") |
| parser.add_option("-d", "--debug", action="store_true", dest="debug", default=False, help="Enable printing of debug messages.") |
| parser.add_option("-c", "--convert", action="store_true", dest="convert", default=False, help="Convert package: OldMdePkg->MdePkg EdkModulePkg->MdeModulePkg.") |
| parser.add_option("-e", "--event", action="store_true", dest="event", default=False, help="Enable handling of Exit Boot Services & Virtual Address Changed Event") |
| parser.add_option("-m", "--manual", action="store_true", dest="manual", default=False, help="Generate CommonHeader.txt, user picks up & copy it to a module common header") |
| parser.add_option("-w", "--workspace", dest="workspace", default=str(os.environ.get('WORKSPACE')), help="Specify workspace directory.") |
| (options, args) = parser.parse_args(sys.argv[1:]) |
| |
| return options,args |
| |
| |
| def openDatabase(f): |
| """ Parse XML in the FrameworkDatabase.db file pointed to by f """ |
| if (options.debug and options.verbose > 1): |
| print "Opening the database file:", f |
| if os.path.exists(f): |
| fdb = XmlParseFile(f) |
| else: |
| return "None" |
| return fdb |
| |
| def openSpd(s): |
| """ Parse XML in the SPD file pointed to by s """ |
| if (options.debug and options.verbose > 1): |
| print "Opening the SPD file:", s |
| if os.path.exists(s): |
| spd = XmlParseFile(s) |
| else: |
| return "None" |
| return spd |
| |
| def openMsa(m): |
| """ Parse XML in the MSA file pointed to by m """ |
| if (options.debug and options.verbose > 1): |
| print "Opening the MSA file:", m |
| if os.path.exists(m): |
| msa = XmlParseFile(m) |
| else: |
| return "None" |
| return msa |
| |
| def AddGuid(ArchList, CName, Usage): |
| """ Add a GUID to the Architecture array that the GUID is valid for. """ |
| if "IA32" in ArchList: |
| GuidCNameIa32.insert(0, str(" %-45s # %s" % (CName, Usage))) |
| if "X64" in ArchList: |
| GuidCNameX64.insert(0, str(" %-45s # %s" % (CName, Usage))) |
| if "IPF" in ArchList: |
| GuidCNameIPF.insert(0, str(" %-45s # %s" % (CName, Usage))) |
| if "EBC" in ArchList: |
| GuidCNameEBC.insert(0, str(" %-45s # %s" % (CName, Usage))) |
| if "ALL" in ArchList: |
| GuidCName.insert(0, str(" %-45s # %s" % (CName, Usage))) |
| |
| |
| def removeDups(CN, ListName): |
| """ Remove Duplicate Entries from the Guid List passed in """ |
| for Entry in ListName[:]: |
| if " " + CN + " " in Entry: |
| if (options.verbose > 1): |
| print "Removing C Name %s Entry from Guids List." % (CN) |
| ListName.remove(Entry) |
| |
| def chkArch(Archs): |
| """ Process the supported architectures passed in to combine if possible """ |
| Archs = Archs.upper() |
| if (("IA32" in Archs) & ("X64" in Archs) & ("IPF" in Archs) & ("EBC" in Archs)): |
| Archs = "ALL" |
| if (len(Archs) == 0): |
| Archs = "ALL" |
| return Archs |
| |
| def saveSourceFile(moduleDir, sourceFilename, sourceFileContents): |
| newFilename = os.path.join(moduleDir, sourceFilename) |
| |
| try: |
| f = open(newFilename, "w+") |
| f.write(sourceFileContents) |
| f.close() |
| except: |
| print "IO error in saving %s" % sourceFilename |
| |
| return sourceFilename |
| |
| def openSourceFile(moduleDir, sourceFilename): |
| newFilename = os.path.join(moduleDir, sourceFilename) |
| sourceFileContents = "" |
| try: |
| f = open(newFilename, "r") |
| sourceFileContents = f.read() |
| f.close() |
| except: |
| print "IO error in opening %s" % sourceFilename |
| |
| return sourceFileContents |
| |
| def MatchOption(eline, ToolChainFamily, Targets, Archs, ToolCode, Value): |
| IDs = eline.split("_") |
| |
| if len(IDs) < 5: |
| return [] |
| |
| MatchedTargets = [] |
| if (Targets[0] == "*") or IDs[0] in Targets: |
| MatchedTargets.append(IDs[0]) |
| elif IDs[0] == "*": |
| MatchedTargets = Targets |
| |
| MatchedArchs = [] |
| if Archs[0] == "*" or IDs[2] in Archs: |
| MatchedArchs.append(IDs[2]) |
| elif IDs[2] == "*": |
| MatchedArchs = Archs |
| |
| if IDs[3] != ToolCode and IDs[3] != "*": |
| return [] |
| |
| result = [] |
| for arch in MatchedArchs: |
| for target in MatchedTargets: |
| line = "%s:%s_%s_%s_%s_FLAGS = %s" % (ToolChainFamily, target, IDs[1], arch, ToolCode, Value) |
| result.append(line) |
| |
| return result |
| |
| def main(): |
| |
| AutoGenSource = "" |
| AutoGenHeader = "" |
| AutoGenDeclaration = "" |
| AutoGenModuleFolder = None |
| |
| workspace = "" |
| |
| if (options.workspace == None): |
| print "ERROR: E0000: WORKSPACE not defined.\n Please set the WORKSPACE environment variable to the location of the EDK II install directory." |
| sys.exit(1) |
| else: |
| workspace = options.workspace |
| if (options.debug): |
| print "Using Workspace:", workspace |
| |
| try: |
| options.verbose +=1 |
| except: |
| options.verbose = 1 |
| pass |
| |
| |
| FdbPath = os.path.join(workspace, "Conf") |
| FdbPath = os.path.join(FdbPath, "FrameworkDatabase.db") |
| if os.path.exists(FdbPath): |
| FdbFile = FdbPath |
| else: |
| print "ERROR: E0001: WORKSPACE does not contain the FrameworkDatabase File.\n Please run EdkSetup from the EDK II install directory.\n" |
| sys.exit(1) |
| |
| Fdb = openDatabase(FdbFile) |
| if (Fdb == 'None'): |
| print "ERROR: E0002 Could not open the Framework Database file:", FdbFile |
| sys.exit(1) |
| |
| if (options.debug): |
| print "FrameworkDataBase.db file:", FdbFile |
| |
| # |
| InitializeAutoGen(workspace, Fdb) |
| |
| if (options.filename): |
| filename = options.filename |
| if ((options.verbose > 1) | (options.autowrite)): |
| print "Filename:", filename |
| else: |
| print "ERROR: E0001 - You must specify an input filename" |
| sys.exit(1) |
| |
| if (options.outfile): |
| outputFile = options.outfile |
| else: |
| outputFile = filename.replace('.msa', '.inf') |
| |
| if ((options.verbose > 2) or (options.debug)): |
| print "Output Filename:", outputFile |
| |
| Msa = openMsa(filename) |
| if (Msa == 'None'): |
| ## Maybe developer think WORKSPACE macro is the root directory of file name |
| ## So we will try to add WORKSPACE path into filename |
| MsaFileName = "" |
| MsaFileName = os.path.join(workspace, filename) |
| Msa = openMsa(MsaFileName) |
| if (Msa == 'None'): |
| print "ERROR: E0002: Could not open the file:", filename |
| sys.exit(1) |
| |
| AutoGenModuleFolder = os.path.dirname(filename) |
| |
| MsaHeader = "/ModuleSurfaceArea/MsaHeader/" |
| MsaDefs = "/ModuleSurfaceArea/ModuleDefinitions/" |
| BaseName = str(XmlElement(Msa, MsaDefs + "OutputFileBasename")).strip() |
| |
| if (len(BaseName) < 1): |
| BaseName = str(XmlElement(Msa, MsaHeader + "BaseName")).strip() |
| BaseName = re.sub(' ', '_', BaseName) |
| |
| GuidValue = str(XmlElement(Msa, MsaHeader + "GuidValue")).strip() |
| VerString = str(XmlElement(Msa, MsaHeader + "Version")).strip() |
| ModType = str(XmlElement(Msa, MsaHeader + "ModuleType")).strip() |
| CopyRight = str(XmlElement(Msa, MsaHeader + "Copyright")).strip() |
| Abstract = str(XmlElement(Msa, MsaHeader + "Abstract")).strip() |
| Description = str(XmlElement(Msa, MsaHeader + "Description")).strip().replace(" ", " ").replace(" ", " ").replace(" ", " ") |
| if not CopyRight.find("2007"): |
| CopyRight = CopyRight.replace("2006", "2007") |
| License = str(XmlElement(Msa, MsaHeader + "License")).strip().replace(" ", " ") |
| MsaDefs = "/ModuleSurfaceArea/ModuleDefinitions/" |
| BinModule = "" |
| try: |
| BinModule = str(XmlElement(Msa, MsaDefs + "BinaryModule")).strip() |
| except: |
| pass |
| |
| SupportedArchitectures = "" |
| try: |
| SupportedArchitectures = str(XmlElement(Msa, MsaDefs + "SupportedArchitectures")).strip() |
| except: |
| pass |
| |
| DefinesComments = [] |
| if (len(SupportedArchitectures) > 0): |
| DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n") |
| DefinesComments.append("# VALID_ARCHITECTURES = " + SupportedArchitectures + "\n") |
| DefinesComments.append("#\n") |
| |
| MsaExtern = "/ModuleSurfaceArea/Externs/" |
| PcdIsDriver = "" |
| try: |
| PcdIsDriver = str(XmlElement(Msa, MsaExtern + "PcdIsDriver")).strip() |
| except: |
| pass |
| |
| SpecList = [] |
| List = [] |
| try: |
| List = XmlList(Msa, MsaExtern + "Specification") |
| except: |
| pass |
| |
| if (len(List) > 0): |
| for spec in List[:]: |
| SpecList.insert(0, str(XmlElementData(spec)).strip()) |
| |
| DriverModules = [] |
| LibraryModules = [] |
| Externlist = [] |
| Flag = (DefinesComments == []) |
| |
| # Data structure to insert autogen code |
| AutoGenDriverModel = [] |
| AutoGenExitBootServices = [] |
| AutoGenVirtualAddressChanged = [] |
| AutoGenEntryPoint = "" |
| AutoGenUnload = "" |
| AutoGenGuid = [] |
| AutoGenLibClass = [] |
| AutoGenPackage = [] |
| AutoGenSourceFiles = [] |
| OldEntryPoint = "" |
| OldUnload = "" |
| |
| try: |
| Externlist = XmlList(Msa, MsaExtern + "Extern") |
| except: |
| pass |
| |
| if (len(Externlist) > 0): |
| if (options.debug and options.verbose > 2): |
| print "In Extern Parsing Routine" |
| for extern in Externlist: |
| EntryPoint = "" |
| Unload = "" |
| DBinding = "" |
| CompName = "" |
| Diag = "" |
| Config = "" |
| Constr = "" |
| Destr = "" |
| CallBack = "" |
| lFlag = False |
| AutoGenDriverModelItem = [] |
| try: |
| EntryPoint = str(XmlElementData(extern.getElementsByTagName("ModuleEntryPoint")[0])).strip() |
| AutoGenEntryPoint = EntryPoint |
| #DriverModules.append(" %-30s = %s\n" % ("ENTRY_POINT" , EntryPoint)) |
| except: |
| pass |
| |
| try: |
| Unload = str(XmlElementData(extern.getElementsByTagName("ModuleUnloadImage")[0])).strip() |
| AutoGenUnload = Unload |
| DriverModules.append(" %-30s = %s\n" % ("UNLOAD_IMAGE", Unload)) |
| except: |
| pass |
| |
| try: |
| DBinding = str(XmlElementData(extern.getElementsByTagName("DriverBinding")[0])).strip() |
| AutoGenDriverModelItem.append("&" + DBinding) |
| DefinesComments.append("# %-29s = %-45s\n" % ("DRIVER_BINDING", DBinding)) |
| lFlag = True |
| except: |
| pass |
| |
| try: |
| CompName = str(XmlElementData(extern.getElementsByTagName("ComponentName")[0])).strip() |
| AutoGenDriverModelItem.append("&" + CompName) |
| DefinesComments.append("# %-29s = %-45s\n" % ("COMPONENT_NAME", CompName)) |
| lFlag = True |
| except: |
| if lFlag: |
| AutoGenDriverModelItem.append("NULL") |
| pass |
| |
| try: |
| Config = str(XmlElementData(extern.getElementsByTagName("DriverConfig")[0])).strip() |
| AutoGenDriverModelItem.append("&" + Config) |
| DefinesComments.append("# %-29s = %-45s\n" % ("DRIVER_CONFIG", Config)) |
| lFlag = True |
| except: |
| if lFlag: |
| AutoGenDriverModelItem.append("NULL") |
| pass |
| |
| try: |
| Diag = str(XmlElementData(extern.getElementsByTagName("DriverDiag")[0])).strip() |
| AutoGenDriverModelItem.append("&" + Diag) |
| DefinesComments.append("# %-29s = %-45s\n" % ("DRIVER_DIAG", Diag)) |
| lFlag = True |
| except: |
| if lFlag: |
| AutoGenDriverModelItem.append("NULL") |
| pass |
| |
| if len(AutoGenDriverModelItem) > 0: |
| AutoGenDriverModel.append(AutoGenDriverModelItem) |
| |
| try: |
| Constr = str(XmlElementData(extern.getElementsByTagName("Constructor")[0])).strip() |
| LibraryModules.append(" %-30s = %s\n" % ("CONSTRUCTOR", Constr)) |
| except: |
| pass |
| |
| try: |
| Destr = str(XmlElementData(extern.getElementsByTagName("Destructor")[0])).strip() |
| LibraryModules.append(" %-30s = %s\n" % ("DESTRUCTOR", Destr)) |
| except: |
| pass |
| |
| try: |
| CallBack = str(XmlElement(extern, "Extern/SetVirtualAddressMapCallBack")).strip() |
| if CallBack != "": |
| AutoGenVirtualAddressChanged.append(CallBack) |
| DefinesComments.append("# %-29s = %-45s\n" % ("VIRTUAL_ADDRESS_MAP_CALLBACK", CallBack)) |
| lFlag = True |
| except: |
| |
| pass |
| |
| try: |
| CallBack = str(XmlElement(extern, "Extern/ExitBootServicesCallBack")).strip() |
| if CallBack != "": |
| AutoGenExitBootServices.append(CallBack) |
| DefinesComments.append("# %-29s = %-45s\n" % ("EXIT_BOOT_SERVICES_CALLBACK", CallBack)) |
| lFlag = True |
| except: |
| pass |
| |
| |
| Flag = False |
| |
| """ Get the Module's custom build options """ |
| MBOlines = [] |
| MBO = "/ModuleSurfaceArea/ModuleBuildOptions/Options/Option" |
| mboList = [] |
| try: |
| mboList = XmlList(Msa, MBO) |
| except: |
| pass |
| |
| if (len(mboList) > 0): |
| for Option in mboList: |
| Targets = [] |
| Archs = [] |
| |
| bt = "" |
| try: |
| bt = str(Option.getAttribute("BuildTargets")) |
| except: |
| pass |
| |
| if (len(bt) > 0): |
| if (re.findall(" ", bt) > 0): |
| Targets = bt.split() |
| else: |
| Targets.insert(0, bt) |
| else: |
| Targets.insert(0, "*") |
| |
| if (options.debug and options.verbose > 2): |
| print "Targets", len(Targets), Targets |
| |
| pro = "" |
| try: |
| pro = Option.getAttribute("SupArchList") |
| if (re.findall(" ", pro) > 0): |
| Archs = pro.split() |
| elif (re.findall(",", pro) > 0): |
| Archs = pro.split(",") |
| except: |
| pass |
| |
| if (len(pro) == 0): |
| Archs.insert(0, "*") |
| |
| if (options.debug and options.verbose > 2): |
| print "Archs", len(Archs), Archs |
| |
| ToolCode = "" |
| try: |
| ToolCode = str(Option.getAttribute("ToolCode")) |
| except: |
| pass |
| |
| if (len(ToolCode) == 0): |
| ToolCode="*" |
| |
| value = "" |
| try: |
| value = str(XmlElementData(Option)) |
| except: |
| pass |
| Tags = [] |
| TagName = "" |
| try: |
| TagName = str(Option.getAttribute("TagName")) |
| except: |
| pass |
| |
| if (len(TagName) > 0) : |
| if (options.debug and options.verbose > 2): |
| print "TagName was defined:", TagName |
| Tags.insert(0, TagName) |
| else: |
| if (options.debug and options.verbose > 2): |
| print "TagName was NOT defined!" |
| TagName = "*" |
| Tags.insert(0, "*") |
| |
| Family = "" |
| try: |
| Family = str(Option.getAttribute("ToolChainFamily")).strip() |
| except: |
| pass |
| |
| if (len(Family) > 0): |
| if (options.debug): |
| print "Searching tools_def.txt for Tool Tags that belong to:", Family, "family" |
| TCF = [] |
| tdFile = "" |
| tdPath = os.path.join(workspace, "Tools") |
| tdPath = os.path.join(tdPath, "Conf") |
| tdPath = os.path.join(tdPath, "tools_def.txt") |
| tdPath = tdPath.replace("\\", "/") |
| if os.path.exists(tdPath): |
| tdFile = tdPath |
| else: |
| tdPath = os.path.join(workspace, "Conf") |
| tdPath = os.path.join(tdPath, "tools_def.txt") |
| if os.path.exists(tdPath): |
| tdFile = tdPath |
| else: |
| print "ERROR: E0001: WORKSPACE does not contain the tools_def.txt File.\n Please run EdkSetup from the EDK II install directory.\n" |
| sys.exit(1) |
| |
| if (options.debug and options.verbose > 2): |
| print "Opening:", tdFile |
| |
| TagNameList = [] |
| tools_def = open(tdFile, "r") |
| for tdline in tools_def: |
| if "# " in tdline: |
| continue |
| if "FAMILY" in tdline: |
| if (options.debug and options.verbose > 2): |
| print "Testing for FAMILY:", Family, "in the line:", tdline.strip() |
| if Family in tdline: |
| enter = tdline.split("=")[0] |
| if (options.debug and options.verbose > 2): |
| print "Adding TNL:", tdline |
| TagNameList.insert(0, enter) |
| tools_def.close() |
| |
| if (options.debug and options.verbose > 2): |
| print "TagNameList:", TagNameList |
| |
| olinesSet = {} |
| for eline in TagNameList: |
| if "# " in eline: |
| continue |
| if (options.debug and options.verbose > 2): |
| print "ToolsDef entry:", eline |
| |
| olines = MatchOption(eline, Family, Targets, Archs, ToolCode, value) |
| for oline in olines: |
| olinesSet[oline] = 1 |
| |
| for oline in olinesSet: |
| if (options.debug and options.verbose > 2): |
| print "Adding:", str(oline) |
| MBOlines.insert(0, oline) |
| else: |
| for targ in Targets: |
| for arch in Archs: |
| oline = " %s_%s_%s_%s_FLAGS = %s" % (targ, Tags[0], arch, str(ToolCode), str(Value)) |
| if (options.debug and options.verbose > 2): |
| print "Adding:", str(oline) |
| MBOlines.insert(0, oline) |
| |
| |
| |
| |
| for tag in Tags: |
| for targ in Targets: |
| for arch in Archs: |
| oline = " " + str(targ) + "_" + str(tag) + "_" + str(arch) + "_" + str(ToolCode) + "_FLAGS = " + str(value) |
| if (options.debug and options.verbose > 2): |
| print "Adding:", str(oline) |
| #MBOlines.insert(0, oline) |
| |
| |
| """ Get the Library Class information """ |
| MsaLcDefs = "/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass" |
| LcDefList = [] |
| try: |
| LcDefList = XmlList(Msa, MsaLcDefs) |
| except: |
| pass |
| |
| IamLibrary = [] |
| LibClassList = [] |
| LibClassListIa32 = [] |
| LibClassListX64 = [] |
| LibClassListIpf = [] |
| LibClassListEbc = [] |
| |
| |
| if (len(LcDefList) > 0): |
| for Lc in LcDefList: |
| lcKeyword = "" |
| try: |
| lcKeyword = str(XmlElementData(Lc.getElementsByTagName("Keyword")[0])) |
| except: |
| raise SyntaxError, "The MSA is not correctly formed, a Library Class Keyword Element is required" |
| |
| lcUsage = "" |
| try: |
| lcUsage = str(XmlAttribute(Lc, "Usage")) |
| except: |
| raise SyntaxError, "The MSA is not correctly formed, a Usage Attribute is required for all Library Class Elements" |
| |
| Archs = "" |
| try: |
| Archs = str(XmlAttribute(Lc, "SupArchList")) |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| if (options.debug and options.verbose > 2): |
| print "Attr: ", lcUsage, lcKeyword, Archs |
| |
| if (options.convert): |
| lcKeyword = AutoGenLibraryMapping.get(lcKeyword, lcKeyword) |
| |
| if re.findall("PRODUCED", lcUsage, re.IGNORECASE): |
| try: |
| lcSupModList = "" |
| |
| try: |
| lcSupModList = str(XmlAttribute(Lc, "SupModuleList")) |
| except: |
| lcSupModList = "" |
| pass |
| |
| lcLine = lcKeyword |
| AutoGenLibClass.append(lcKeyword) |
| if len(lcSupModList) > 0: |
| lcLine = lcLine + "|" + lcSupModList |
| IamLibrary.insert(0, lcLine) |
| except: |
| pass |
| elif lcKeyword != "UefiDriverModelLib": |
| AutoGenLibClass.append(lcKeyword) |
| # This section handles the library classes that are CONSUMED |
| if "IA32" in Archs: |
| LibClassListIa32.insert(0, lcKeyword) |
| if "X64" in Archs: |
| LibClassListX64.insert(0, lcKeyword) |
| if "IPF" in Archs: |
| LibClassListIpf.insert(0, lcKeyword) |
| if "EBC" in Archs: |
| LibClassListEbc.insert(0, lcKeyword) |
| if "ALL" in Archs: |
| LibClassList.insert(0, lcKeyword) |
| if len(AutoGenDriverModel) > 0 and "UefiLib" not in LibClassList: |
| AutoGenLibClass.append("UefiLib") |
| LibClassList.insert(0, "UefiLib") |
| |
| AutoGenDxsFiles = [] |
| """ Get the Source File list """ |
| SrcFilenames = [] |
| SrcFilenamesIa32 = [] |
| SrcFilenamesX64 = [] |
| SrcFilenamesIpf = [] |
| SrcFilenamesEbc = [] |
| SrcFiles = "/ModuleSurfaceArea/SourceFiles/Filename" |
| SrcList = [] |
| try: |
| SrcList = XmlList(Msa, SrcFiles) |
| except: |
| pass |
| |
| if (len(SrcList) > 0): |
| for fn in SrcList: |
| file = "" |
| Archs = "" |
| |
| try: |
| Archs = fn.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| file = str(XmlElementData(fn)) |
| except: |
| pass |
| |
| if file.endswith(".dxs"): |
| AutoGenDxsFiles.append((file, Archs)) |
| else: |
| AutoGenSourceFiles.append(file) |
| if "IA32" in Archs: |
| SrcFilenamesIa32.insert(0, file) |
| if "X64" in Archs: |
| SrcFilenamesX64.insert(0, file) |
| if "IPF" in Archs: |
| SrcFilenamesIpf.insert(0, file) |
| if "EBC" in Archs: |
| SrcFilenamesEbc.insert(0, file) |
| if "ALL" in Archs: |
| SrcFilenames.insert(0, file) |
| |
| """ Package Dependency section """ |
| DbPkgList = "/FrameworkDatabase/PackageList/Filename" |
| WorkspacePkgs = [] |
| try: |
| WorkspacePkgs = XmlList(Fdb, DbPkgList) |
| except: |
| print "Could not tet the package data from the database" |
| sys.exit(1) |
| |
| PkgDb = [] |
| HeaderLocations = [] |
| |
| if (options.debug and options.verbose > 1): |
| print "Found %s packages in the WORKSPACE" % (len(WorkspacePkgs)) |
| |
| Dirs = [] |
| GuidDecls = [] |
| if (len(WorkspacePkgs) > 0): |
| SpdHeader = "/PackageSurfaceArea/SpdHeader/" |
| for Pkg in WorkspacePkgs[:]: |
| PackageGuid = "" |
| PackageVersion = "" |
| file = "" |
| try: |
| file = str(XmlElementData(Pkg)) |
| except: |
| pass |
| |
| if (options.debug and options.verbose > 2): |
| print "PKG:", file |
| |
| if fnmatch.fnmatch(file, "*.dec"): |
| print "parsing " + os.path.join(workspace, file) |
| PackageGuid = "" |
| PackageVersion = "" |
| try: |
| Lines = open(os.path.join(workspace, file)).readlines() |
| except: |
| print "Could not parse the Package file:", file |
| sys.exit(1) |
| |
| for Line in Lines: |
| Line = Line.split("#")[0] |
| Items = Line.split("=") |
| if len(Items) != 2: |
| continue |
| |
| Key = Items[0].strip().upper() |
| if Key == "PACKAGE_GUID": |
| PackageGuid = Items[1].strip() |
| if Key == "PACKAGE_VERSION": |
| PackageVersion = Items[1].strip() |
| |
| else: |
| Spd = openSpd(os.path.join(workspace, file)) |
| if (Spd == 'None'): |
| print "Could not parse the Package file:", file |
| sys.exit(1) |
| |
| path = os.path.split(file)[0] |
| file = file.replace(".nspd", ".dec") |
| file = file.replace(".spd", ".dec") |
| |
| try: |
| PackageGuid = str(XmlElement(Spd, SpdHeader + "GuidValue")) |
| except: |
| pass |
| |
| try: |
| PackageVersion = str(XmlElement(Spd, SpdHeader + "Version")) |
| except: |
| pass |
| |
| file = file + "|" + PackageGuid + "|" + PackageVersion |
| PkgDb.insert(0, file) |
| |
| GuidEntries = [] |
| try: |
| GuidEntries = XmlList(Spd, "/PackageSurfaceArea/GuidDeclarations/Entry") |
| except: |
| pass |
| |
| if (len(GuidEntries) > 0): |
| for Entry in GuidEntries[:]: |
| try: |
| GuidDecls.append(str(XmlElementData(Entry.getElementsByTagName("C_Name")[0])).strip()) |
| except: |
| pass |
| |
| |
| pHdrs = [] |
| try: |
| pHdrs = XmlList(Spd, "/PackageSurfaceArea/PackageHeaders/IncludePkgHeader") |
| except: |
| pass |
| |
| if (len(pHdrs) > 0): |
| for Hdr in pHdrs[:]: |
| try: |
| ModTypeList = str(Hdr.getAttribute("ModuleType")) |
| if (ModType in ModTypeList): |
| HeaderName= str(XmlElementData(Hdr))[0] |
| Dirs.insert(0, os.path.join(packagepath,str(os.path.split(HeaderName)))) |
| except: |
| pass |
| |
| # Get the Guid:Header from the Packages |
| SpdLcDec = "/PackageSurfaceArea/LibraryClassDeclarations/LibraryClass" |
| lcList = [] |
| try: |
| lcList = XmlList(Spd, SpdLcDec) |
| except: |
| pass |
| |
| if (len(lcList) > 0): |
| for Lc in lcList[:]: |
| Name = "" |
| try: |
| Name = Lc.getAttribute("Name") |
| except: |
| pass |
| |
| Header = "" |
| try: |
| Header = XmlElementData(Lc.getElementsByTagName("IncludeHeader")[0]) |
| except: |
| pass |
| |
| if ((len(Name) > 0) and (len(Header) > 0)): |
| line = Name + "|" + os.path.join(path, Header) |
| if (options.debug and options.verbose > 2): |
| print "Adding:", line |
| HeaderLocations.insert(0, line) |
| |
| ishList = [] |
| try: |
| IndStdHeaders = "/PackageSurfaceArea/IndustryStdIncludes/IndustryStdHeader" |
| ishList = XmlList(Spd, IndStdHeaders) |
| except: |
| pass |
| |
| if (len(ishList) > 0): |
| for Lc in ishList[:]: |
| Name = "" |
| try: |
| Name = str(Lc.getAttribute("Name")).strip() |
| except: |
| pass |
| |
| Header = "" |
| try: |
| Header = str(XmlElementData(Lc.getElementsByTagName("IncludeHeader")[0])).strip() |
| except: |
| pass |
| |
| if ((len(Name) > 0) and (len(Header) > 0)): |
| line = Name + "|" + os.path.join(path, Header) |
| HeaderLocations.insert(0, str(line)) |
| |
| PkgList = [] |
| PkgListIa32 = [] |
| PkgListX64 = [] |
| PkgListIpf = [] |
| PkgListEbc = [] |
| Pkgs = "/ModuleSurfaceArea/PackageDependencies/Package" |
| pkgL = [] |
| try: |
| pkgL = XmlList(Msa, Pkgs) |
| except: |
| pass |
| |
| |
| gUnknownPkgGuid = {} |
| if (len(pkgL) > 0): |
| if (options.debug and options.verbose > 1): |
| print "Found %s packages in the module" % (len(pkgL)) |
| for pkg in pkgL[:]: |
| Archs = "" |
| pkgGuid = "" |
| pkgVer = "" |
| |
| FindPkgGuid = False |
| try: |
| Archs = pkg.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| pkgGuid = pkg.getAttribute("PackageGuid") |
| except: |
| pass |
| |
| if options.convert: |
| if pkgGuid.lower() == "5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec": |
| pkgGuid = "1E73767F-8F52-4603-AEB4-F29B510B6766" |
| if pkgGuid.lower() == "68169ab0-d41b-4009-9060-292c253ac43d": |
| pkgGuid = "BA0D78D6-2CAF-414b-BD4D-B6762A894288" |
| AutoGenPackage.append(pkgGuid) |
| try: |
| pkgVer = pkg.getAttribute("PackageVersion") |
| except: |
| pass |
| |
| for PkgEntry in PkgDb[:]: |
| if pkgGuid in PkgEntry: |
| if len(pkgVer) > 0: |
| if pkgVer in PkgEntry: |
| FindPkgGuid = True |
| if "IA32" in Archs: |
| PkgListIa32.insert(0, PkgEntry.split("|")[0]) |
| if "X64" in Archs: |
| PkgListX64.insert(0, PkgEntry.split("|")[0]) |
| if "IPF" in Archs: |
| PkgListIpf.insert(0, PkgEntry.split("|")[0]) |
| if "EBC" in Archs: |
| PkgListEbc.insert(0, PkgEntry.split("|")[0]) |
| if "ALL" in Archs: |
| PkgList.insert(0, PkgEntry.split("|")[0]) |
| else: |
| FindPkgGuid = True |
| if "IA32" in Archs: |
| PkgListIa32.insert(0, PkgEntry.split("|")[0]) |
| if "X64" in Archs: |
| PkgListX64.insert(0, PkgEntry.split("|")[0]) |
| if "IPF" in Archs: |
| PkgListIpf.insert(0, PkgEntry.split("|")[0]) |
| if "EBC" in Archs: |
| PkgListEbc.insert(0, PkgEntry.split("|")[0]) |
| if "ALL" in Archs: |
| PkgList.insert(0, PkgEntry.split("|")[0]) |
| |
| if not FindPkgGuid: |
| gUnknownPkgGuid[str(pkgGuid)] = 1 |
| |
| for UnknownPkgGuid in gUnknownPkgGuid: |
| print "Cannot resolve package dependency Guid:", UnknownPkgGuid |
| |
| PkgList.reverse() |
| PkgListIa32.reverse() |
| PkgListX64.reverse() |
| PkgListIpf.reverse() |
| PkgListEbc.reverse() |
| if (options.debug): |
| print "Package List:", PkgList |
| |
| |
| |
| """ Setup the Global GuidCName arrays that will hold data from various MSA locations """ |
| global GuidCName |
| global GuidCNameIa32 |
| global GuidCNameX64 |
| global GuidCNameIPF |
| global GuidCNameEBC |
| GuidCName = [] |
| GuidCNameIa32 = [] |
| GuidCNameX64 = [] |
| GuidCNameIPF = [] |
| GuidCNameEBC = [] |
| |
| """ Check for the GUIDs Element """ |
| Guids = "/ModuleSurfaceArea/Guids/GuidCNames" |
| GuidList = [] |
| try: |
| GuidList = XmlList(Msa, Guids) |
| except: |
| pass |
| |
| if (len(GuidList) > 0): |
| for Guid in GuidList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| |
| try: |
| Archs = Guid.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = Guid.getAttribute("Usage") |
| except: |
| pass |
| |
| try: |
| CName = str(XmlElementData(Guid.getElementsByTagName("GuidCName")[0])) |
| if CName in GuidDecls: |
| if (options.debug and options.verbose > 1): |
| print "Guids Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs) |
| AddGuid(Archs, CName, Usage) |
| AutoGenGuid.append(CName) |
| else: |
| raise AssertionError, "Guid %s defined in %s is not declared in any package (.dec) file!" % (CName, filename) |
| except: |
| pass |
| |
| if (options.debug and options.verbose > 2): |
| print "Guid C Name List:", GuidCName |
| |
| """ Check for Events """ |
| Guids = "/ModuleSurfaceArea/Events/CreateEvents/EventTypes" |
| GuidList = [] |
| try: |
| GuidList = XmlList(Msa, Guids) |
| except: |
| pass |
| |
| if (len(GuidList) > 0): |
| for Guid in GuidList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| |
| try: |
| Archs = Guid.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = Guid.getAttribute("Usage") |
| Type = str(XmlElementData(Guid.getElementsByTagName("EventType")[0])) |
| Usage += " Create Event: " + Type |
| except: |
| pass |
| |
| try: |
| CName = str(Guid.getAttribute("EventGuidCName")) |
| if CName in GuidDecls: |
| if (options.debug and options.verbose > 1): |
| print "CreateEvent Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs) |
| AddGuid(Archs, CName, Usage) |
| AutoGenGuid.append(CName) |
| else: |
| if (len(DefinesComments) == 0): |
| DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n") |
| DefinesComments.append("# Create Event Guid C Name: " + CName + " Event Type: " + Type + "\n") |
| Flag = True |
| except: |
| pass |
| |
| if (Flag): |
| DefinesComments.append("#\n") |
| Flag = False |
| |
| Guids = "/ModuleSurfaceArea/Events/SignalEvents/EventTypes" |
| GuidList = [] |
| try: |
| GuidList = XmlList(Msa, Guids) |
| except: |
| pass |
| |
| if (len(GuidList) > 0): |
| for Guid in GuidList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| |
| try: |
| Archs = Guid.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = Guid.getAttribute("Usage") |
| Type = str(XmlElementData(Guid.getElementsByTagName("EventType")[0])) |
| Usage += " Signal Event: " + Type |
| except: |
| pass |
| |
| try: |
| CName = str(Guid.getAttribute("EventGuidCName")) |
| if CName in GuidDecls: |
| if (options.debug and options.verbose > 1): |
| print "SignalEvent Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs) |
| AddGuid(Archs, CName, Usage) |
| AutoGenGuid.append(CName) |
| else: |
| if (len(DefinesComments) == 0): |
| DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n") |
| DefinesComments.append("# Signal Event Guid C Name: " + CName + " Event Type: " + Type + "\n") |
| Flag = True |
| except: |
| pass |
| |
| if (Flag): |
| DefinesComments.append("#\n") |
| Flag = False |
| |
| """ Check the HOB guids """ |
| Guids = "/ModuleSurfaceArea/Hobs/HobTypes" |
| GuidList = [] |
| try: |
| GuidList = XmlList(Msa, Guids) |
| except: |
| pass |
| |
| if (len(GuidList) > 0): |
| for Guid in GuidList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| |
| try: |
| Archs = Guid.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = Guid.getAttribute("Usage") |
| Type = str(XmlElementData(Guid.getElementsByTagName("HobType")[0])) |
| Usage += " Hob: " + Type |
| except: |
| pass |
| |
| try: |
| CName = str(Guid.getAttribute("HobGuidCName")) |
| if CName in GuidDecls: |
| if (options.debug and options.verbose > 1): |
| print "Hob Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs) |
| AddGuid(Archs, CName, Usage) |
| AutoGenGuid.append(CName) |
| else: |
| if (len(DefinesComments) == 0): |
| DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n") |
| DefinesComments.append("# HOB Guid C Name: " + CName + " Hob Type: " + Type + "\n") |
| Flag = True |
| except: |
| if (len(DefinesComments) == 0): |
| DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n") |
| DefinesComments.append("# HOB: " + Type + "\n") |
| Flag = True |
| pass |
| |
| if (Flag): |
| DefinesComments.append("#\n") |
| Flag = False |
| |
| """ Check for the SystemTables Element """ |
| Guids = "/ModuleSurfaceArea/SystemTables/SystemTableCNames" |
| GuidList = [] |
| try: |
| GuidList = XmlList(Msa, Guids) |
| except: |
| pass |
| |
| if (len(GuidList) > 0): |
| for Guid in GuidList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| |
| try: |
| Archs = Guid.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = Guid.getAttribute("Usage") |
| Usage += " System Table" |
| except: |
| pass |
| |
| try: |
| CName = str(XmlElementData(Guid.getElementsByTagName("SystemTableCName")[0])) |
| if (options.debug and options.verbose > 1): |
| print "System Table Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs) |
| AddGuid(Archs, CName, Usage) |
| AutoGenGuid.append(CName) |
| except: |
| pass |
| |
| """ Check for the DataHubs Element """ |
| Guids = "/ModuleSurfaceArea/DataHubs/DataHubRecord" |
| GuidList = [] |
| try: |
| GuidList = XmlList(Msa, Guids) |
| except: |
| pass |
| |
| if (len(GuidList) > 0): |
| for Guid in GuidList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| |
| try: |
| Archs = Guid.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = Guid.getAttribute("Usage") |
| Usage += " Data Hub" |
| except: |
| pass |
| |
| try: |
| CName = str(XmlElementData(Guid.getElementsByTagName("DataHubCName")[0])) |
| if (options.debug and options.verbose > 1): |
| print "Data Hub Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs) |
| AddGuid(Archs, CName, Usage) |
| AutoGenGuid.append(CName) |
| except: |
| pass |
| |
| """ Check for the HiiPackages Element """ |
| Guids = "/ModuleSurfaceArea/HiiPackages/HiiPackage" |
| GuidList = [] |
| try: |
| GuidList = XmlList(Msa, Guids) |
| except: |
| pass |
| |
| if (len(GuidList) > 0): |
| for Guid in GuidList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| |
| try: |
| Archs = Guid.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = Guid.getAttribute("Usage") |
| Usage += " HII Formset" |
| except: |
| pass |
| |
| try: |
| CName = str(XmlElementData(Guid.getElementsByTagName("HiiCName")[0])) |
| if (options.debug and options.verbose > 1): |
| print "Hii Formset Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs) |
| AddGuid(Archs, CName, Usage) |
| AutoGenGuid.append(CName) |
| except: |
| pass |
| |
| """ Check for the Variables Element """ |
| Guids = "/ModuleSurfaceArea/Variables/Variable" |
| GuidList = [] |
| try: |
| GuidList = XmlList(Msa, Guids) |
| except: |
| pass |
| |
| if (len(GuidList) > 0): |
| for Guid in GuidList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| VariableName = "" |
| |
| try: |
| Archs = Guid.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = Guid.getAttribute("Usage") |
| except: |
| pass |
| |
| try: |
| VariableName = str(XmlElementData(Guid.getElementsByTagName("VariableName")[0])) |
| CName = str(XmlElementData(Guid.getElementsByTagName("GuidC_Name")[0])) |
| |
| HexData = VariableName.strip().split() |
| UniString = " L\"" |
| for dig in HexData[:]: |
| UniString += str(unichr(eval(dig))) |
| UniString += "\"" |
| |
| Usage += UniString |
| |
| if CName in set(GuidDecls): |
| removeDups(CName, GuidCName) |
| removeDups(CName, GuidCNameIa32) |
| removeDups(CName, GuidCNameX64) |
| removeDups(CName, GuidCNameIPF) |
| removeDups(CName, GuidCNameEBC) |
| |
| if (options.debug): |
| print "Variable Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs) |
| AddGuid(Archs, CName, Usage) |
| AutoGenGuid.append(CName) |
| else: |
| if (len(DefinesComments) == 0): |
| DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n") |
| DefinesComments.append("# Variable Guid C Name: " + CName + " Variable Name:" + UniString + "\n") |
| Flag = True |
| except: |
| pass |
| |
| if (Flag): |
| DefinesComments.append("#\n") |
| Flag = False |
| |
| """ Check for the Protocol Element """ |
| Protocols = "/ModuleSurfaceArea/Protocols/Protocol" |
| ProtocolList = [] |
| ProtocolCName = [] |
| ProtocolCNameIa32 = [] |
| ProtocolCNameX64 = [] |
| ProtocolCNameIPF = [] |
| ProtocolCNameEBC = [] |
| |
| try: |
| ProtocolList = XmlList(Msa, Protocols) |
| except: |
| pass |
| |
| if (len(ProtocolList) > 0): |
| for Protocol in ProtocolList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| |
| try: |
| Archs = Protocol.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = Protocol.getAttribute("Usage") |
| except: |
| pass |
| |
| try: |
| CName = str(XmlElementData(Protocol.getElementsByTagName("ProtocolCName")[0])) |
| AutoGenGuid.append(CName) |
| removeDups(CName, GuidCName) |
| removeDups(CName, GuidCNameIa32) |
| removeDups(CName, GuidCNameX64) |
| removeDups(CName, GuidCNameIPF) |
| removeDups(CName, GuidCNameEBC) |
| |
| if (options.debug and options.verbose > 1): |
| print "Found %s - %s - %s " % (CName, Usage, str(len(Archs))) |
| |
| if "IA32" in Archs: |
| ProtocolCNameIa32.insert(0, str(" %-45s # PROTOCOL %s" % (CName, Usage))) |
| if "X64" in Archs: |
| ProtocolCNameX64.insert(0, str(" %-45s # PROTOCOL %s" % (CName, Usage))) |
| if "IPF" in Archs: |
| ProtocolCNameIPF.insert(0, str(" %-45s # PROTOCOL %s" % (CName, Usage))) |
| if "EBC" in Archs: |
| ProtocolCNameEBC.insert(0, str(" %-45s # PROTOCOL %s" % (CName, Usage))) |
| if "ALL" in Archs: |
| ProtocolCName.insert(0, str(" %-45s # PROTOCOL %s" % (CName, Usage))) |
| except: |
| pass |
| |
| |
| Protocols = "/ModuleSurfaceArea/Protocols/ProtocolNotify" |
| try: |
| ProtocolList = XmlList(Msa, Protocols) |
| except: |
| pass |
| |
| if (len(ProtocolList) > 0): |
| for Protocol in ProtocolList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| |
| try: |
| Archs = Protocol.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = Protocol.getAttribute("Usage") |
| except: |
| pass |
| |
| try: |
| CName = str(XmlElementData(Protocol.getElementsByTagName("ProtocolNotifyCName")[0])) |
| AutoGenGuid.append(CName) |
| removeDups(CName, GuidCName) |
| removeDups(CName, GuidCNameIa32) |
| removeDups(CName, GuidCNameX64) |
| removeDups(CName, GuidCNameIPF) |
| removeDups(CName, GuidCNameEBC) |
| |
| if "IA32" in Archs: |
| ProtocolCNameIa32.insert(0, " %-45s # PROTOCOL_NOTIFY %s" % (CName, Usage)) |
| if "X64" in Archs: |
| ProtocolCNameX64.insert(0, " %-45s # PROTOCOL_NOTIFY %s" % (CName, Usage)) |
| if "IPF" in Archs: |
| ProtocolCNameIPF.insert(0, " %-45s # PROTOCOL_NOTIFY %s" % (CName, Usage)) |
| if "EBC" in Archs: |
| ProtocolCNameEBC.insert(0, " %-45s # PROTOCOL_NOTIFY %s" % (CName, Usage)) |
| if "ALL" in Archs: |
| ProtocolCName.insert(0, " %-45s # PROTOCOL_NOTIFY %s" % (CName, Usage)) |
| except: |
| pass |
| |
| """ Check for the PPIs Element """ |
| PPIs = "/ModuleSurfaceArea/PPIs/Ppi" |
| PPIsList = [] |
| PpiCName = [] |
| PpiCNameIa32 = [] |
| PpiCNameX64 = [] |
| PpiCNameIPF = [] |
| PpiCNameEBC = [] |
| |
| try: |
| PPIsList = XmlList(Msa, PPIs) |
| except: |
| pass |
| |
| if (len(PPIsList) > 0): |
| for Ppi in PPIsList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| |
| try: |
| Archs = str(Ppi.getAttribute("SupArchList")) |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = str(Ppi.getAttribute("Usage")) |
| except: |
| pass |
| |
| try: |
| CName = str(XmlElementData(Ppi.getElementsByTagName("PpiCName")[0])).strip() |
| AutoGenGuid.append(CName) |
| removeDups(CName, GuidCName) |
| removeDups(CName, GuidCNameIa32) |
| removeDups(CName, GuidCNameX64) |
| removeDups(CName, GuidCNameIPF) |
| removeDups(CName, GuidCNameEBC) |
| |
| if "IA32" in Archs: |
| PpiCNameIa32.insert(0, " %-45s # PPI %s" % (CName, Usage)) |
| if "X64" in Archs: |
| PpiCNameX64.insert(0, " %-45s # PPI %s" % (CName, Usage)) |
| if "IPF" in Archs: |
| PpiCNameIPF.insert(0, " %-45s # PPI %s" % (CName, Usage)) |
| if "EBC" in Archs: |
| PpiCNameEBC.insert(0, " %-45s # PPI %s" % (CName, Usage)) |
| if "ALL" in Archs: |
| PpiCName.insert(0, " %-45s # PPI %s" % (CName, Usage)) |
| except: |
| pass |
| |
| |
| PPIs = "/ModuleSurfaceArea/PPIs/PpiNotify" |
| try: |
| PPIsList = XmlList(Msa, PPIs) |
| except: |
| pass |
| |
| if (len(PPIsList) > 0): |
| for Ppi in PPIsList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| |
| try: |
| Archs = Ppi.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| Usage = Ppi.getAttribute("Usage") |
| except: |
| pass |
| |
| try: |
| CName = str(XmlElementData(Ppi.getElementsByTagName("PpiNotifyCName")[0])) |
| AutoGenGuid.append(CName) |
| removeDups(CName, GuidCName) |
| removeDups(CName, GuidCNameIa32) |
| removeDups(CName, GuidCNameX64) |
| removeDups(CName, GuidCNameIPF) |
| removeDups(CName, GuidCNameEBC) |
| |
| if "IA32" in Archs: |
| PpiCNameIa32.insert(0, " %-45s # PPI_NOTIFY %s" % (CName, Usage)) |
| if "X64" in Archs: |
| PpiCNameX64.insert(0, " %-45s # PPI_NOTIFY %s" % (CName, Usage)) |
| if "IPF" in Archs: |
| PpiCNameIPF.insert(0, " %-45s # PPI_NOTIFY %s" % (CName, Usage)) |
| if "EBC" in Archs: |
| PpiCNameEBC.insert(0, " %-45s # PPI_NOTIFY %s" % (CName, Usage)) |
| if "ALL" in Archs: |
| PpiCName.insert(0, " %-45s # PPI_NOTIFY %s" % (CName, Usage)) |
| except: |
| pass |
| |
| |
| """ Get the PCD entries now """ |
| PcdCoded = "/ModuleSurfaceArea/PcdCoded/PcdEntry" |
| PcdList = [] |
| try: |
| PcdList = XmlList(Msa, PcdCoded) |
| except: |
| pass |
| |
| (PcdFF, PcdFFIa32, PcdFFX64, PcdFFIpf, PcdFFEbc) = ([],[],[],[],[]) |
| (PcdFAB, PcdFABIa32, PcdFABX64, PcdFABIpf, PcdFABEbc) = ([],[],[],[],[]) |
| (PcdPIM, PcdPIMIa32, PcdPIMX64, PcdPIMIpf, PcdPIMEbc) = ([],[],[],[],[]) |
| (PcdDY, PcdDYIa32, PcdDYX64, PcdDYIpf, PcdDYEbc) = ([],[],[],[],[]) |
| (PcdDYE, PcdDYEIa32, PcdDYEX64, PcdDYEIpf, PcdDYEEbc) = ([],[],[],[],[]) |
| |
| if (len(PcdList) > 0): |
| for Pcd in PcdList: |
| Archs = "" |
| Usage = "" |
| CName = "" |
| DefVal = "" |
| |
| try: |
| Archs = Pcd.getAttribute("SupArchList") |
| except: |
| pass |
| |
| Archs = chkArch(Archs) |
| |
| try: |
| ItemType = Pcd.getAttribute("PcdItemType") |
| except: |
| pass |
| |
| try: |
| CName = str(XmlElementData(Pcd.getElementsByTagName("C_Name")[0])) |
| except: |
| raise SyntaxError, "ERROR: MSA has a PCD with no Pcd C_Name defined" |
| |
| try: |
| TSGC = str(XmlElementData(Pcd.getElementsByTagName("TokenSpaceGuidCName")[0])) |
| except: |
| pass |
| |
| try: |
| DefVal = str(XmlElementData(Pcd.getElementsByTagName("DefaultValue"))) |
| except: |
| pass |
| |
| if (len(DefVal) > 0): |
| line = TSGC + "." + CName + "|" + DefVal |
| else: |
| line = TSGC + "." + CName |
| |
| if (ItemType == "FEATURE_FLAG"): |
| if ("IA32" in Archs): |
| PcdFFIa32.insert(0, line) |
| if ("IPF" in Archs): |
| PcdFFIpf.insert(0, line) |
| if ("X64" in Archs): |
| PcdFFX64.insert(0, line) |
| if ("EBC" in Archs): |
| PcdFFEbc.insert(0, line) |
| if ("ALL" in Archs): |
| PcdFF.insert(0, line) |
| elif (ItemType == "FIXED_AT_BUILD"): |
| if ("IA32" in Archs): |
| PcdFABIa32.insert(0, line) |
| if ("IPF" in Archs): |
| PcdFABIpf.insert(0, line) |
| if ("X64" in Archs): |
| PcdFABX64.insert(0, line) |
| if ("EBC" in Archs): |
| PcdFABEbc.insert(0, line) |
| if ("ALL" in Archs): |
| PcdFAB.insert(0, line) |
| elif (ItemType == "PATCHABLE_IN_MODULE"): |
| if ("IA32" in Archs): |
| PcdPIMIa32.insert(0, line) |
| if ("IPF" in Archs): |
| PcdPIMIpf.insert(0, line) |
| if ("X64" in Archs): |
| PcdPIMX64.insert(0, line) |
| if ("EBC" in Archs): |
| PcdPIMEbc.insert(0, line) |
| if ("ALL" in Archs): |
| PcdFAB.insert(0, line) |
| elif (ItemType == "DYNAMIC_EX"): |
| if ("IA32" in Archs): |
| PcdDYEIa32.insert(0, line) |
| if ("IPF" in Archs): |
| PcdDYEIpf.insert(0, line) |
| if ("X64" in Archs): |
| PcdDYEX64.insert(0, line) |
| if ("EBC" in Archs): |
| PcdDYEEbc.insert(0, line) |
| if ("ALL" in Archs): |
| PcdDYE.insert(0, line) |
| else: |
| if ("IA32" in Archs): |
| PcdDYIa32.insert(0, line) |
| if ("IPF" in Archs): |
| PcdDYIpf.insert(0, line) |
| if ("X64" in Archs): |
| PcdDYX64.insert(0, line) |
| if ("EBC" in Archs): |
| PcdDYEbc.insert(0, line) |
| if ("ALL" in Archs): |
| PcdDY.insert(0, line) |
| |
| """ User Extensions Section """ |
| UEList = [] |
| UESectionList = [] |
| try: |
| UESectionList = XmlList(Msa, "/ModuleSurfaceArea/UserExtensions") |
| except: |
| pass |
| |
| if (len(UESectionList) > 0): |
| for UE in UESectionList[:]: |
| UserId = "" |
| Identifier = "" |
| Value = "" |
| |
| try: |
| UserId = str(UE.getAttribute("UserID")) |
| except: |
| raise SyntaxError, "ERROR: Malformed MSA, No UserID Specified in UserExtensions element" |
| |
| try: |
| Identifier = str(UE.getAttribute("Identifier")) |
| except: |
| raise SyntaxError, "ERROR: Malformed MSA, No Identifier Specified in UserExtensions element" |
| |
| if (options.debug): |
| print "FOUND A UE Element", UserId, Identifier |
| |
| try: |
| Value = str(XmlElementData(UE)) |
| except: |
| pass |
| |
| Entry = [UserId, Identifier, Value] |
| UEList.insert(0, Entry) |
| |
| |
| |
| if (len(Externlist) > 0): |
| AutoGenSource = "" |
| AutoGenDefinitionSource = "" |
| AutoGenEntryPointSource = "" |
| AutoGenUnloadSource = "" |
| if (len(AutoGenDriverModel) > 0): |
| AutoGenCode = AddDriverBindingProtocolStatement(AutoGenDriverModel) |
| AutoGenEntryPointSource += AutoGenCode[0] |
| AutoGenUnloadSource += AutoGenCode[1] |
| AutoGenDeclaration += AutoGenCode[3] |
| |
| |
| if (len(AutoGenExitBootServices) > 0): |
| print "[Warning] Please manually add Create Event statement for Exit Boot Service Event!" |
| if options.event: |
| AutoGenCode = AddBootServiceEventStatement(AutoGenExitBootServices) |
| AutoGenEntryPointSource += AutoGenCode[0] |
| AutoGenUnloadSource += AutoGenCode[1] |
| AutoGenDefinitionSource += AutoGenCode[2] |
| AutoGenDeclaration += AutoGenCode[3] |
| |
| if (len(AutoGenVirtualAddressChanged) > 0): |
| print "[Warning] Please manually add Create Event statement for Virtual Address Change Event!" |
| if options.event: |
| AutoGenCode = AddVirtualAddressEventStatement(AutoGenVirtualAddressChanged) |
| AutoGenEntryPointSource += AutoGenCode[0] |
| AutoGenUnloadSource += AutoGenCode[1] |
| AutoGenDefinitionSource += AutoGenCode[2] |
| AutoGenDeclaration += AutoGenCode[3] |
| |
| if AutoGenEntryPointSource != "": |
| OldEntryPoint = AutoGenEntryPoint |
| AutoGenCode = AddNewEntryPointContentsStatement(BaseName, AutoGenEntryPoint, AutoGenEntryPointSource) |
| AutoGenEntryPoint = AutoGenCode[0] |
| AutoGenEntryPointSource = AutoGenCode[1] |
| AutoGenDeclaration += AutoGenCode[2] |
| |
| |
| if AutoGenEntryPoint != "": |
| DriverModules.insert(0, " %-30s = %s\n" % ("ENTRY_POINT" , AutoGenEntryPoint)) |
| |
| AutoGenSource = AutoGenDefinitionSource + AutoGenEntryPointSource + AutoGenUnloadSource |
| |
| if (lFlag): |
| DefinesComments.append("#\n") |
| |
| if (Flag and len(DefinesComments) > 0): |
| DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n") |
| |
| if (options.debug and options.verbose > 2): |
| if (len(DriverModules) > 0): |
| print DriverModules |
| if (len(LibraryModules) > 0): |
| print LibraryModules |
| if (len(DefinesComments) > 0): |
| print DefinesComments |
| |
| Depex = [] |
| DepexIa32 = [] |
| DepexX64 = [] |
| DepexIpf = [] |
| DepexEbc = [] |
| |
| for DxsFile, Archs in AutoGenDxsFiles: |
| fileContents = openSourceFile(AutoGenModuleFolder, DxsFile) |
| Contents, Unresolved = TranslateDpxSection(fileContents) |
| if Contents == "": |
| print "[warning] Cannot read dxs expression" |
| else: |
| if (len(Unresolved) > 0): |
| print "[warning] Guid Macro(s): %s cannot find corresponding cNames. Please resolve it in [depex] section in extened inf" % ",".join(Unresolved) |
| |
| if ("IA32" in Archs): |
| DepexIa32.insert(0, Contents) |
| if ("IPF" in Archs): |
| DepexIpf.insert(0, Contents) |
| if ("X64" in Archs): |
| DepexX64.insert(0, Contents) |
| if ("EBC" in Archs): |
| DepexEbc.insert(0, Contents) |
| if ("ALL" in Archs): |
| Depex.insert(0, Contents) |
| |
| AutoGenSourceHeaderFormat = "/**@file\n %s\n\n %s\n %s\n %s\n**/\n\n%s" |
| includeCommonHeaderFileStatement = "#include \"%s\"" % commonHeaderFilename |
| |
| AutoGenHeader += AddSystemIncludeStatement(ModType, AutoGenPackage) |
| AutoGenHeader += AddGuidStatement(AutoGenGuid) |
| AutoGenHeader += AddLibraryClassStatement(AutoGenLibClass) |
| |
| if options.manual: |
| saveSourceFile(AutoGenModuleFolder, "CommonHeader.txt", AutoGenHeader) |
| else: |
| |
| commonHeaderFilename2 = re.sub("(?=[^a-z])", "_", commonHeaderFilename) |
| commonHeaderFilename2 = "_" + commonHeaderFilename2.replace(".", "").upper() + "_" |
| briefDiscription = "Common header file shared by all source files." |
| detailedDiscription = "This file includes package header files, library classes and protocol, PPI & GUID definitions.\n" |
| AutoGenHeader += AutoGenDeclaration |
| AutoGenHeader = "#ifndef %s\n#define %s\n\n\n%s\n#endif\n" % (commonHeaderFilename2, commonHeaderFilename2, AutoGenHeader) |
| AutoGenHeader = AutoGenSourceHeaderFormat % (briefDiscription, detailedDiscription, CopyRight, License, AutoGenHeader) |
| saveSourceFile(AutoGenModuleFolder, commonHeaderFilename, AutoGenHeader) |
| SrcFilenames.append(commonHeaderFilename) |
| |
| for source in AutoGenSourceFiles: |
| extension = os.path.splitext(source)[1] |
| if extension == ".c": |
| sourceContents = openSourceFile(AutoGenModuleFolder, source) |
| sourceContents = AddCommonInclusionStatement(sourceContents, includeCommonHeaderFileStatement) |
| saveSourceFile(AutoGenModuleFolder, source, sourceContents) |
| |
| |
| if AutoGenSource != "": |
| briefDiscription = "Entry Point Source file." |
| detailedDiscription = "This file contains the user entry point \n" |
| AutoGenSource = AutoGenSourceHeaderFormat % (briefDiscription, detailedDiscription, CopyRight, License, AutoGenSource) |
| AutoGenSource = AddCommonInclusionStatement(AutoGenSource, includeCommonHeaderFileStatement) |
| |
| saveSourceFile(AutoGenModuleFolder, entryPointFilename, AutoGenSource) |
| SrcFilenames.append(entryPointFilename) |
| |
| |
| |
| |
| # DONE Getting data, now output it in INF format. |
| Msa.unlink() |
| Fdb.unlink() |
| Output = [] |
| |
| """ Print the converted data format """ |
| head = "#/** @file\n" |
| head += "# " + str(Abstract) + "\n#\n" |
| head += "# " + str(Description).strip().replace("\n", "\n# ") + "\n" |
| head += "# " + str(CopyRight) + "\n#\n" |
| head += "# " + str(License).replace("\n", "\n# ").replace(" ", " ").strip() + "\n#\n" |
| head += "#\n#**/\n" |
| |
| Output.append(head) |
| if (options.debug): |
| print head |
| |
| ## Defines = "\n" + "#"*80+ "\n#\n" |
| ## if (BinModule != "false"): |
| ## Defines += "# Defines Section - statements that will be processed to generate a binary image.\n" |
| ## else: |
| ## Defines += "# Defines Section - statements that will be processed to create a Makefile.\n" |
| ## Defines += "#\n" + "#"*80 + "\n" |
| |
| Defines = "\n" |
| Defines += "[Defines]\n" |
| Defines += " %-30s = %s\n" % ("INF_VERSION", "0x00010005") |
| Defines += " %-30s = %s\n" % ("BASE_NAME", BaseName) |
| Defines += " %-30s = %s\n" % ("FILE_GUID", GuidValue) |
| Defines += " %-30s = %s\n" % ("MODULE_TYPE", ModType) |
| Defines += " %-30s = %s\n" % ("VERSION_STRING", VerString) |
| |
| if (len(PcdIsDriver) > 0): |
| Defines += " %-30s = %s\n" % ("PCD_DRIVER", PcdIsDriver) |
| |
| if (len(IamLibrary) > 0): |
| lcstr = "" |
| for lc in IamLibrary[:]: |
| lcstr += lc + " " |
| Defines += " %-30s = %s" % ("LIBRARY_CLASS", lcstr) |
| Defines += "\n" |
| |
| if (len(SpecList) > 0): |
| for spec in SpecList[:]: |
| (specname, specval) = spec.split() |
| Defines += " %-30s = %s\n" % (specname, specval) |
| Defines += "\n" |
| |
| if (len(DriverModules) > 0): |
| for line in DriverModules[:]: |
| Defines += line |
| |
| if (len(LibraryModules) > 0): |
| for line in LibraryModules[:]: |
| Defines += line |
| |
| if (len(DefinesComments) > 0): |
| for line in DefinesComments[:]: |
| Defines += line |
| |
| Output.append(Defines) |
| |
| if (options.debug): |
| print Defines |
| |
| if (BinModule != "false"): |
| """ Binary Module, so sources are really binaries. """ |
| ## Sources = "\n" + "#"*80 + "\n#\n" |
| ## Sources += "# Binaries Section - list of binary files that are required for the build\n# to succeed.\n" |
| ## Sources += "#\n" + "#"*80 + "\n\n" |
| Sources = "\n" |
| if ModType == "UEFI_APPLICATION": |
| FileType = "UEFI_APP" |
| if options.verbose > 0: |
| print "WARNING: Binary Module: %s is assuming UEFI_APPLICATION file type." % (options.filename) |
| else: |
| FileType = "FV" |
| if options.verbose > 0: |
| print "WARNING: Binary Module: %s is assuming FV file type." % (options.filename) |
| |
| if (len(SrcFilenames) > 0): |
| Sources += "[Binaries.common]\n" |
| for file in SrcFilenames[:]: |
| file = file.replace("\\", "/") |
| Sources += " " + FileType + "|" + file + "\n" |
| Sources += "\n" |
| |
| if (len(SrcFilenamesIa32) > 0): |
| Sources += "[Binaries.Ia32]\n" |
| for file in SrcFilenamesIa32[:]: |
| file = file.replace("\\", "/") |
| Sources += " " + FileType + "|" + file + "\n" |
| Sources += "\n" |
| |
| if (len(SrcFilenamesX64) > 0): |
| Sources += "[Binaries.X64]\n" |
| for file in SrcFilenamesX64[:]: |
| file = file.replace("\\", "/") |
| Sources += " " + FileType + "|" + file + "\n" |
| Sources += "\n" |
| |
| if (len(SrcFilenamesIpf) > 0): |
| Sources += "[Binaries.IPF]\n" |
| for file in SrcFilenamesIpf[:]: |
| file = file.replace("\\", "/") |
| Sources += " " + FileType + "|" + file + "\n" |
| Sources += "\n" |
| |
| if (len(SrcFilenamesEbc) > 0): |
| Sources += "[Binaries.EBC]\n" |
| for file in SrcFilenamesEbc[:]: |
| file = file.replace("\\", "/") |
| Sources += " " + FileType + "|" + file + "\n" |
| Sources += "\n" |
| |
| Output.append(Sources) |
| if (options.debug): |
| print Sources |
| else: |
| ## Sources = "\n" + "#"*80 + "\n#\n" |
| ## Sources += "# Sources Section - list of files that are required for the build to succeed.\n" |
| ## Sources += "#\n" + "#"*80 + "\n\n" |
| Sources = "\n" |
| if (len(SrcFilenames) > 0): |
| Sources += "[Sources.common]\n" |
| for file in SrcFilenames[:]: |
| Sources += " " + file + "\n" |
| Sources += "\n" |
| |
| if (len(SrcFilenamesIa32) > 0): |
| Sources += "[Sources.Ia32]\n" |
| for file in SrcFilenamesIa32[:]: |
| Sources += " " + file + "\n" |
| Sources += "\n" |
| |
| if (len(SrcFilenamesX64) > 0): |
| Sources += "[Sources.X64]\n" |
| for file in SrcFilenamesX64[:]: |
| Sources += " " + file + "\n" |
| Sources += "\n" |
| |
| if (len(SrcFilenamesIpf) > 0): |
| Sources += "[Sources.IPF]\n" |
| for file in SrcFilenamesIpf[:]: |
| Sources += " " + file + "\n" |
| Sources += "\n" |
| |
| if (len(SrcFilenamesEbc) > 0): |
| Sources += "[Sources.EBC]\n" |
| for file in SrcFilenamesEbc[:]: |
| Sources += " " + file + "\n" |
| Sources += "\n" |
| |
| Output.append(Sources) |
| if (options.debug): |
| print Sources |
| |
| |
| includeLine = "" |
| if ((len(HeaderLocations) > 0) or (len(Dirs) > 0)): |
| allLcs = set(LibClassList + LibClassListIa32 + LibClassListX64 + LibClassListIpf + LibClassListEbc + Dirs) |
| Lines = [] |
| for line in HeaderLocations[:]: |
| for Lc in allLcs: |
| (keyword, header) = line.split("|") |
| if Lc in keyword: |
| if (options.debug): |
| print "FOUND", Lc, "in", keyword, "header", header |
| path = "$(WORKSPACE)/" + os.path.split(header)[0] |
| Lines.insert(0, path.strip()) |
| Includes = "" |
| ## Includes = "\n" + "#"*80 + "\n#\n" |
| ## Includes += "# Includes Section - list of Include locations that are required for\n" |
| ## Includes += "# this module.\n" |
| ## Includes += "#\n" + "#"*80 + "\n\n" |
| ## Includes += "[Includes]\n" |
| ## includeLines = [] |
| ## includeLines = set(Lines) |
| ## if (options.debug): |
| ## print "There are", len(includeLines), "entries" |
| ## for Line in includeLines: |
| ## Includes += " " + str(Line).strip().replace("\\", "/") + "\n" |
| |
| Output.append(Includes) |
| if (options.debug): |
| print Includes |
| |
| |
| |
| if ((len(PkgList) + len(PkgListIa32) + len(PkgListX64) + len(PkgListIpf) + len(PkgListEbc)) > 0): |
| """ We do this if and only if we have Package Dependencies """ |
| ## PackageDepends = "\n" + "#"*80 + "\n#\n" |
| ## PackageDepends += "# Package Dependency Section - list of Package files that are required for\n" |
| ## PackageDepends += "# this module.\n" |
| ## PackageDepends += "#\n" + "#"*80 + "\n\n" |
| PackageDepends = "\n" |
| if (len(PkgList) > 0): |
| PackageDepends += "[Packages]\n" |
| for lc in PkgList[:]: |
| lc = lc.replace("\\", "/") |
| PackageDepends += " " + lc + "\n" |
| PackageDepends += "\n" |
| |
| if (len(PkgListIa32) > 0): |
| PackageDepends += "[Packages.IA32]\n" |
| for lc in PkgListIa32[:]: |
| lc = lc.replace("\\", "/") |
| PackageDepends += " " + lc + "\n" |
| PackageDepends += "\n" |
| |
| if (len(PkgListX64) > 0): |
| PackageDepends += "[Packages.X64]\n" |
| for lc in PkgListX64[:]: |
| lc = lc.replace("\\", "/") |
| PackageDepends += " " + lc + "\n" |
| PackageDepends += "\n" |
| |
| if (len(PkgListIpf) > 0): |
| PackageDepends += "[Packages.IPF]\n" |
| for lc in PkgListIpf[:]: |
| lc = lc.replace("\\", "/") |
| PackageDepends += " " + lc + "\n" |
| PackageDepends += "\n" |
| |
| if (len(PkgListEbc) > 0): |
| PackageDepends += "[Packages.EBC]\n" |
| for lc in PkgListEbc[:]: |
| lc = lc.replace("\\", "/") |
| PackageDepends += " " + lc + "\n" |
| PackageDepends += "\n" |
| |
| Output.append(PackageDepends) |
| if (options.debug): |
| print PackageDepends |
| |
| if ((len(LibClassList) + len(LibClassListIa32) + len(LibClassListX64) + len(LibClassListIpf) + len(LibClassListEbc)) > 0): |
| ## LibraryClasses = "\n" + "#"*80 + "\n#\n" |
| ## LibraryClasses += "# Library Class Section - list of Library Classes that are required for\n" |
| ## LibraryClasses += "# this module.\n" |
| ## LibraryClasses += "#\n" + "#"*80 + "\n\n" |
| |
| LibraryClasses = "\n" |
| if (len(LibClassList) > 0): |
| LibraryClasses += "[LibraryClasses]\n" |
| for lc in LibClassList[:]: |
| LibraryClasses += " " + lc + "\n" |
| LibraryClasses += "\n" |
| |
| if (len(LibClassListIa32) > 0): |
| LibraryClasses += "[LibraryClasses.IA32]\n" |
| for lc in LibClassListIa32[:]: |
| LibraryClasses += " " + lc + "\n" |
| LibraryClasses += "\n" |
| |
| if (len(LibClassListX64) > 0): |
| LibraryClasses += "[LibraryClasses.X64]\n" |
| for lc in LibClassListX64[:]: |
| LibraryClasses += " " + lc + "\n" |
| LibraryClasses += "\n" |
| |
| if (len(LibClassListIpf) > 0): |
| LibraryClasses += "[LibraryClasses.IPF]\n" |
| for lc in LibClassListIpf[:]: |
| LibraryClasses += " " + lc + "\n" |
| LibraryClasses += "\n" |
| |
| if (len(LibClassListEbc) > 0): |
| LibraryClasses += "[LibraryClasses.EBC]\n" |
| for lc in LibClassListEbc[:]: |
| LibraryClasses += " " + lc + "\n" |
| LibraryClasses += "\n" |
| |
| Output.append(LibraryClasses) |
| if (options.debug): |
| print LibraryClasses |
| |
| # Print the Guids sections |
| if (len(GuidCName) + len(GuidCNameIa32) + len(GuidCNameIPF) + len(GuidCNameX64) + len(GuidCNameEBC)) > 0: |
| ## GuidSection = "\n" + "#"*80 + "\n#\n" |
| ## GuidSection += "# Guid C Name Section - list of Guids that this module uses or produces.\n" |
| ## GuidSection += "#\n" + "#"*80 + "\n\n" |
| GuidSection = "\n" |
| if (len(GuidCName) > 0): |
| GuidSection += "[Guids]\n" |
| for Guid in GuidCName[:]: |
| GuidSection += Guid + "\n" |
| GuidSection += "\n" |
| |
| if (len(GuidCNameIa32) > 0): |
| GuidSection += "[Guids.IA32]\n" |
| for Guid in GuidCNameIa32[:]: |
| GuidSection += Guid + "\n" |
| GuidSection += "\n" |
| |
| if (len(GuidCNameX64) > 0): |
| GuidSection += "[Guids.X64]\n" |
| for Guid in GuidCNameX64[:]: |
| GuidSection += Guid + "\n" |
| GuidSection += "\n" |
| |
| if (len(GuidCNameIPF) > 0): |
| GuidSection += "[Guids.IPF]\n" |
| for Guid in GuidCNameIPF[:]: |
| GuidSection += Guid + "\n" |
| GuidSection += "\n" |
| |
| if (len(GuidCNameEBC) > 0): |
| GuidSection += "[Guids.EBC]\n" |
| for Guid in GuidCNameEBC[:]: |
| GuidSection += Guid + "\n" |
| GuidSection += "\n" |
| |
| Output.append(GuidSection) |
| if (options.debug and options.verbose > 1): |
| print GuidSection |
| |
| # Print the Protocol sections |
| if (len(ProtocolCName) + len(ProtocolCNameIa32) + len(ProtocolCNameIPF) + len(ProtocolCNameX64) + len(ProtocolCNameEBC)) > 0: |
| ## ProtocolsSection = "\n" + "#"*80 + "\n#\n" |
| ## ProtocolsSection += "# Protocol C Name Section - list of Protocol and Protocol Notify C Names\n" |
| ## ProtocolsSection += "# that this module uses or produces.\n" |
| ## ProtocolsSection += "#\n" + "#"*80 + "\n\n" |
| |
| ProtocolsSection = "\n" |
| if (len(ProtocolCName) > 0): |
| ProtocolsSection += "[Protocols]\n" |
| for Guid in ProtocolCName[:]: |
| ProtocolsSection += Guid + "\n" |
| ProtocolsSection += "\n" |
| |
| if (len(ProtocolCNameIa32) > 0): |
| ProtocolsSection += "[Protocols.IA32]\n" |
| for Guid in ProtocolCNameIa32[:]: |
| ProtocolsSection += Guid + "\n" |
| ProtocolsSection += "\n" |
| |
| if (len(ProtocolCNameX64) > 0): |
| ProtocolsSection += "[Protocols.X64]\n" |
| for Guid in ProtocolCNameX64[:]: |
| ProtocolsSection += Guid + "\n" |
| ProtocolsSection += "\n" |
| |
| if (len(ProtocolCNameIPF) > 0): |
| ProtocolsSection += "[Protocols.IPF]\n" |
| for Guid in ProtocolCNameIPF[:]: |
| ProtocolsSection += Guid + "\n" |
| ProtocolsSection += "\n" |
| |
| if (len(ProtocolCNameEBC) > 0): |
| ProtocolsSection += "[Protocols.EBC]\n" |
| for Guid in ProtocolCNameEBC[:]: |
| ProtocolsSection += Guid + "\n" |
| ProtocolsSection += "\n" |
| |
| Output.append(ProtocolsSection) |
| if (options.debug): |
| print ProtocolsSection |
| |
| # Print the PPI sections |
| if (len(PpiCName) + len(PpiCNameIa32) + len(PpiCNameIPF) + len(PpiCNameX64) + len(PpiCNameEBC)) > 0: |
| ## PpiSection = "\n" + "#"*80 + "\n#\n" |
| ## PpiSection += "# PPI C Name Section - list of PPI and PPI Notify C Names that this module\n" |
| ## PpiSection += "# uses or produces.\n" |
| ## PpiSection += "#\n" + "#"*80 + "\n\n" |
| |
| PpiSection = "\n" |
| if (len(PpiCName) > 0): |
| PpiSection += "[Ppis]\n" |
| for Guid in PpiCName[:]: |
| PpiSection += Guid + "\n" |
| PpiSection += "\n" |
| |
| if (len(PpiCNameIa32) > 0): |
| PpiSection += "[Ppis.IA32]\n" |
| for Guid in PpiCNameIa32[:]: |
| PpiSection += Guid + "\n" |
| PpiSection += "\n" |
| |
| if (len(PpiCNameX64) > 0): |
| PpiSection += "[Ppis.X64]\n" |
| for Guid in PpiCNameX64[:]: |
| PpiSection += Guid + "\n" |
| PpiSection += "\n" |
| |
| if (len(PpiCNameIPF) > 0): |
| PpiSection += "[Ppis.IPF]\n" |
| for Guid in PpiCNameIPF[:]: |
| PpiSection += Guid + "\n" |
| PpiSection += "\n" |
| |
| if (len(PpiCNameEBC) > 0): |
| PpiSection += "[Ppis.EBC]\n" |
| for Guid in PpiCNameEBC[:]: |
| PpiSection += Guid + "\n" |
| PpiSection += "\n" |
| |
| Output.append(PpiSection) |
| if (options.debug): |
| print PpiSection |
| |
| # Print the PCD sections |
| if ((len(PcdFF)+len(PcdFFIa32)+len(PcdFFX64)+len(PcdFFIpf)+len(PcdFFEbc)) > 0): |
| ## FeatureFlagSection = "\n" + "#"*80 + "\n#\n" |
| ## FeatureFlagSection += "# Pcd FEATURE_FLAG - list of PCDs that this module is coded for.\n" |
| ## FeatureFlagSection += "#\n" + "#"*80 + "\n\n" |
| |
| FeatureFlagSection = "\n" |
| if (len(PcdFF) > 0): |
| FeatureFlagSection += "[FeaturePcd.common]\n" |
| for Entry in PcdFF[:]: |
| FeatureFlagSection += " " + Entry + "\n" |
| FeatureFlagSection += "\n" |
| if (len(PcdFFIa32) > 0): |
| FeatureFlagSection += "[FeaturePcd.IA32]\n" |
| for Entry in PcdFFIa32[:]: |
| FeatureFlagSection += " " + Entry + "\n" |
| FeatureFlagSection += "\n" |
| if (len(PcdFFX64) > 0): |
| FeatureFlagSection += "[FeaturePcd.X64]\n" |
| for Entry in PcdFFX64[:]: |
| FeatureFlagSection += " " + Entry + "\n" |
| FeatureFlagSection += "\n" |
| if (len(PcdFFIpf) > 0): |
| FeatureFlagSection += "[PcdsFeatureFlag.IPF]\n" |
| for Entry in PcdFFIpf[:]: |
| FeatureFlagSection += " " + Entry + "\n" |
| FeatureFlagSection += "\n" |
| if (len(PcdFFEbc) > 0): |
| FeatureFlagSection += "[FeaturePcd.EBC]\n" |
| for Entry in PcdFFEbc[:]: |
| FeatureFlagSection += " " + Entry + "\n" |
| FeatureFlagSection += "\n" |
| |
| Output.append(FeatureFlagSection) |
| if (options.debug): |
| print FeatureFlagSection |
| |
| if ((len(PcdFAB)+len(PcdFABIa32)+len(PcdFABX64)+len(PcdFABIpf)+len(PcdFABEbc)) > 0): |
| ## FixedAtBuildSection = "\n" + "#"*80 + "\n#\n" |
| ## FixedAtBuildSection += "# Pcd FIXED_AT_BUILD - list of PCDs that this module is coded for.\n" |
| ## FixedAtBuildSection += "#\n" + "#"*80 + "\n\n" |
| |
| FixedAtBuildSection = "\n" |
| if (len(PcdFAB) > 0): |
| FixedAtBuildSection += "[FixedPcd.common]\n" |
| for Entry in PcdFAB[:]: |
| FixedAtBuildSection += " " + Entry + "\n" |
| FixedAtBuildSection += "\n" |
| if (len(PcdFABIa32) > 0): |
| FixedAtBuildSection += "[FixedPcd.IA32]\n" |
| for Entry in PcdFABIa32[:]: |
| FixedAtBuildSection += " " + Entry + "\n" |
| FixedAtBuildSection += "\n" |
| if (len(PcdFABX64) > 0): |
| FixedAtBuildSection += "[FixedPcd.X64]\n" |
| for Entry in PcdFABX64[:]: |
| FixedAtBuildSection += " " + Entry + "\n" |
| FixedAtBuildSection += "\n" |
| if (len(PcdFABIpf) > 0): |
| FixedAtBuildSection += "[FixedPcd.IPF]\n" |
| for Entry in PcdFABIpf[:]: |
| FixedAtBuildSection += " " + Entry + "\n" |
| FixedAtBuildSection += "\n" |
| if (len(PcdFABEbc) > 0): |
| FixedAtBuildSection += "[FixedPcd.EBC]\n" |
| for Entry in PcdFABEbc[:]: |
| FixedAtBuildSection += " " + Entry + "\n" |
| FixedAtBuildSection += "\n" |
| |
| Output.append(FixedAtBuildSection) |
| if (options.debug): |
| print FixedAtBuildSection |
| |
| if ((len(PcdPIM)+len(PcdPIMIa32)+len(PcdPIMX64)+len(PcdPIMIpf)+len(PcdPIMEbc)) > 0): |
| ## PatchableInModuleSection = "\n" + "#"*80 + "\n#\n" |
| ## PatchableInModuleSection += "# Pcd PATCHABLE_IN_MODULE - list of PCDs that this module is coded for.\n" |
| ## PatchableInModuleSection += "#\n" + "#"*80 + "\n\n" |
| |
| PatchableInModuleSection = "\n" |
| if (len(PcdPIM) > 0): |
| PatchableInModuleSection += "[PatchPcd.common]\n" |
| for Entry in PcdPIM[:]: |
| PatchableInModuleSection += " " + Entry + "\n" |
| PatchableInModuleSection += "\n" |
| if (len(PcdPIMIa32) > 0): |
| PatchableInModuleSection += "[PatchPcd.IA32]\n" |
| for Entry in PcdPIMIa32[:]: |
| PatchableInModuleSection += " " + Entry + "\n" |
| PatchableInModuleSection += "\n" |
| if (len(PcdPIMX64) > 0): |
| PatchableInModuleSection += "[PatchPcd.X64]\n" |
| for Entry in PcdPIMX64[:]: |
| PatchableInModuleSection += " " + Entry + "\n" |
| PatchableInModuleSection += "\n" |
| if (len(PcdPIMIpf) > 0): |
| PatchableInModuleSection += "[PatchPcd.IPF]\n" |
| for Entry in PcdPIMIpf[:]: |
| PatchableInModuleSection += " " + Entry + "\n" |
| PatchableInModuleSection += "\n" |
| if (len(PcdPIMEbc) > 0): |
| PatchableInModuleSection += "[PatchPcd.EBC]\n" |
| for Entry in PcdPIMEbc[:]: |
| PatchableInModuleSection += " " + Entry + "\n" |
| PatchableInModuleSection += "\n" |
| |
| Output.append(PatchableInModuleSection) |
| if (options.debug): |
| print PatchableInModuleSection |
| |
| if ((len(PcdDYE)+len(PcdDYEIa32)+len(PcdDYEX64)+len(PcdDYEIpf)+len(PcdDYEEbc)) > 0): |
| ## DynamicExSection = "\n" + "#"*80 + "\n#\n" |
| ## DynamicExSection += "# Pcd DYNAMIC_EX - list of PCDs that this module is coded for.\n" |
| ## DynamicExSection += "#\n" + "#"*80 + "\n\n" |
| |
| DynamicExSection = "\n" |
| if (len(PcdDYE) > 0): |
| DynamicExSection += "[PcdEx.common]\n" |
| for Entry in PcdDYE[:]: |
| DynamicExSection += " " + Entry + "\n" |
| DynamicExSection += "\n" |
| if (len(PcdDYEIa32) > 0): |
| DynamicExSection += "[PcdEx.IA32]\n" |
| for Entry in PcdDYEIa32[:]: |
| DynamicExSection += " " + Entry + "\n" |
| DynamicExSection += "\n" |
| if (len(PcdDYEX64) > 0): |
| DynamicExSection += "[PcdEx.X64]\n" |
| for Entry in PcdDYEX64[:]: |
| DynamicExSection += " " + Entry + "\n" |
| DynamicExSection += "\n" |
| if (len(PcdDYEIpf) > 0): |
| DynamicExSection += "[PcdEx.IPF]\n" |
| for Entry in PcdDYEIpf[:]: |
| DynamicExSection += " " + Entry + "\n" |
| DynamicExSection += "\n" |
| if (len(PcdDYEEbc) > 0): |
| DynamicExSection += "[PcdEx.EBC]\n" |
| for Entry in PcdDYEEbc[:]: |
| DynamicExSection += " " + Entry + "\n" |
| DynamicExSection += "\n" |
| |
| Output.append(DynamicExSection) |
| if (options.debug): |
| print DynamicExSection |
| |
| if ((len(PcdDY)+len(PcdDYIa32)+len(PcdDYX64)+len(PcdDYIpf)+len(PcdDYEbc)) > 0): |
| ## DynamicSection = "\n" + "#"*80 + "\n#\n" |
| ## DynamicSection += "# Pcd DYNAMIC - list of PCDs that this module is coded for.\n" |
| ## DynamicSection += "#\n" + "#"*80 + "\n\n" |
| |
| DynamicSection = "\n" |
| if (len(PcdDY) > 0): |
| DynamicSection += "[Pcd.common]\n" |
| for Entry in PcdDY[:]: |
| DynamicSection += " " + Entry + "\n" |
| DynamicSection += "\n" |
| if (len(PcdDYIa32) > 0): |
| DynamicSection += "[Pcd.IA32]\n" |
| for Entry in PcdDYIa32[:]: |
| DynamicSection += " " + Entry + "\n" |
| DynamicSection += "\n" |
| if (len(PcdDYX64) > 0): |
| DynamicSection += "[Pcd.X64]\n" |
| for Entry in PcdDYX64[:]: |
| DynamicSection += " " + Entry + "\n" |
| DynamicSection += "\n" |
| if (len(PcdDYIpf) > 0): |
| DynamicSection += "[Pcd.IPF]\n" |
| for Entry in PcdDYIpf[:]: |
| DynamicSection += " " + Entry + "\n" |
| DynamicSection += "\n" |
| if (len(PcdDYEbc) > 0): |
| DynamicSection += "[Pcd.EBC]\n" |
| for Entry in PcdDYEbc[:]: |
| DynamicSection += " " + Entry + "\n" |
| DynamicSection += "\n" |
| |
| Output.append(DynamicSection) |
| if (options.debug): |
| print DynamicSection |
| |
| if ((len(Depex) + len(DepexIa32) + len(DepexX64) + len(DepexIpf) + len(DepexEbc)) > 0): |
| """ We do this if and only if we have Package Dependencies """ |
| ## Dpx = "\n" + "#"*80 + "\n#\n" |
| ## Dpx += "# Dependency Expression Section - list of Dependency expressions that are required for\n" |
| ## Dpx += "# this module.\n" |
| ## Dpx += "#\n" + "#"*80 + "\n\n" |
| Dpx = "\n" |
| if (len(Depex) > 0): |
| Dpx += "[Depex]\n" |
| for lc in Depex[:]: |
| Dpx += " " + lc + "\n" |
| Dpx += "\n" |
| |
| if (len(DepexIa32) > 0): |
| Dpx += "[Depex.IA32]\n" |
| for lc in DepexIa32[:]: |
| Dpx += " " + lc + "\n" |
| Dpx += "\n" |
| |
| if (len(DepexX64) > 0): |
| Dpx += "[Depex.X64]\n" |
| for lc in DepexX64[:]: |
| Dpx += " " + lc + "\n" |
| Dpx += "\n" |
| |
| if (len(DepexIpf) > 0): |
| Dpx += "[Depex.IPF]\n" |
| for lc in DepexIpf[:]: |
| Dpx += " " + lc + "\n" |
| Dpx += "\n" |
| |
| if (len(DepexEbc) > 0): |
| Dpx += "[Depex.EBC]\n" |
| for lc in DepexEbc[:]: |
| Dpx += " " + lc + "\n" |
| Dpx += "\n" |
| |
| Output.append(Dpx) |
| if (options.debug): |
| print Dpx |
| |
| if (len(MBOlines) > 0): |
| BuildSection = "" |
| ## BuildSection = "\n" + "#"*80 + "\n#\n" |
| ## BuildSection += "# Build Options - list of custom build options for this module.\n" |
| ## BuildSection += "#\n" + "#"*80 + "\n\n" |
| BuildSection += "\n[BuildOptions]\n" |
| for mbo in MBOlines: |
| tool, targs = mbo.split("=",2) |
| BuildSection += " %-40s = %s\n" % (tool.strip(), targs.strip()) |
| |
| Output.append(BuildSection) |
| if (options.debug): |
| print BuildSection |
| |
| |
| if (len(UEList) > 0): |
| UserExtensionSection = "" |
| for UE in UEList[:]: |
| UserExtensionSection += "[UserExtensions." + UE[0] + '."' + UE[1] + '"]\n' |
| if (len(UE[2]) > 0): |
| UserExtensionSection += '"' + UE[2] + '"\n' |
| else: |
| UserExtensionSection += "\n" |
| |
| Output.append(UserExtensionSection) |
| if (options.debug): |
| print UserExtensionSection |
| |
| print "write file", outputFile |
| if (options.autowrite): |
| fo = open(outputFile, "w") |
| for Section in Output[:]: |
| fo.writelines(Section) |
| if (options.verbose > 1): |
| print Section |
| fo.close() |
| elif (options.outfile): |
| fo = open(outputFile, "w") |
| for Section in Output[:]: |
| fo.writelines(Section) |
| fo.close() |
| else: |
| for Section in Output[:]: |
| print Section |
| |
| |
| if __name__ == '__main__': |
| |
| global options |
| global args |
| options,args = myOptionParser() |
| |
| main() |
| sys.exit(0) |
| |
