BaseTools/Source/Python/MigrationMsa2Inf/MigrationMsa2Inf.py

   1 #!/usr/bin/env python
   2 #
   3 #
   4 # Copyright (c) 2007, Intel Corporation
   5 # All rights reserved. This program and the accompanying materials
   6 # are licensed and made available under the terms and conditions of the BSD License
   7 # which accompanies this distribution.  The full text of the license may be found at
   8 # http://opensource.org/licenses/bsd-license.php
   9 #
  10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13
  14 """ This program converts EDK II MSA files into EDK II Extended INF format files """
  15
  16 import os, re, sys, fnmatch, xml.dom.minidom
  17 from optparse import OptionParser
  18 from AutoGenExterns import *
  19 from Common.XmlRoutines import  *             # XmlParseFile, XmlElement, XmlAttribute, XmlList, XmlElementData, XmlNode
  20 from Common.EdkIIWorkspace import *
  21
  22 versionNumber = "0.9"
  23 __version__ = "%prog Version " + versionNumber
  24 __copyright__ = "Copyright (c) 2007, Intel Corporation  All rights reserved."
  25
  26 commonHeaderFilename = "CommonHeader.h"
  27 entryPointFilename   = "EntryPoint.c"
  28
  29 AutoGenLibraryMapping = {
  30     "HiiLib":"HiiLibFramework",
  31     "EdkIfrSupportLib":"IfrSupportLibFramework",
  32     "EdkScsiLib":"ScsiLib",
  33     "EdkUsbLib":"UsbLib",
  34     "EdkFvbServiceLib":"FvbServiceLib",
  35     "EdkGraphicsLib":"GraphicsLib"
  36     }
  37
  38 def myOptionParser():
  39     """ Argument Parser """
  40     usage = "%prog [options] -f input_filename"
  41     parser = OptionParser(usage=usage,description=__copyright__,version="%prog " + str(versionNumber))
  42     parser.add_option("-f", "--file", dest="filename", help="Name of MSA file to convert")
  43     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.")
  44     parser.add_option("-a", "--auto", action="store_true", dest="autowrite", default=False, help="Automatically create output files and write the INF file")
  45     parser.add_option("-i", "--interactive", action="store_true", dest="interactive", default=False, help="Set Interactive mode, user must approve each change.")
  46     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")
  47     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")
  48     parser.add_option("-d", "--debug", action="store_true", dest="debug", default=False, help="Enable printing of debug messages.")
  49     parser.add_option("-c", "--convert", action="store_true", dest="convert", default=False, help="Convert package: OldMdePkg->MdePkg EdkModulePkg->MdeModulePkg.")
  50     parser.add_option("-e", "--event", action="store_true", dest="event", default=False, help="Enable handling of Exit Boot Services & Virtual Address Changed Event")
  51     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")
  52     parser.add_option("-w", "--workspace", dest="workspace", default=str(os.environ.get('WORKSPACE')), help="Specify workspace directory.")
  53     (options, args) = parser.parse_args(sys.argv[1:])
  54
  55     return options,args
  56
  57
  58 def openDatabase(f):
  59     """ Parse XML in the FrameworkDatabase.db file pointed to by f """
  60     if (options.debug and options.verbose > 1):
  61         print "Opening the database file:", f
  62     if os.path.exists(f):
  63         fdb = XmlParseFile(f)
  64     else:
  65         return "None"
  66     return fdb
  67
  68 def openSpd(s):
  69     """ Parse XML in the SPD file pointed to by s """
  70     if (options.debug and options.verbose > 1):
  71         print "Opening the SPD file:", s
  72     if os.path.exists(s):
  73         spd = XmlParseFile(s)
  74     else:
  75         return "None"
  76     return spd
  77
  78 def openMsa(m):
  79     """ Parse XML in the MSA file pointed to by m """
  80     if (options.debug and options.verbose > 1):
  81         print "Opening the MSA file:", m
  82     if os.path.exists(m):
  83         msa = XmlParseFile(m)
  84     else:
  85         return "None"
  86     return msa
  87
  88 def AddGuid(ArchList, CName, Usage):
  89     """ Add a GUID to the Architecture array that the GUID is valid for. """
  90     if "IA32" in ArchList:
  91         GuidCNameIa32.insert(0, str("  %-45s # %s" % (CName, Usage)))
  92     if "X64" in ArchList:
  93         GuidCNameX64.insert(0, str("  %-45s # %s" % (CName, Usage)))
  94     if "IPF" in ArchList:
  95         GuidCNameIPF.insert(0, str("  %-45s # %s" % (CName, Usage)))
  96     if "EBC" in ArchList:
  97         GuidCNameEBC.insert(0, str("  %-45s # %s" % (CName, Usage)))
  98     if "ALL" in ArchList:
  99         GuidCName.insert(0, str("  %-45s # %s" % (CName, Usage)))
 100
 101
 102 def removeDups(CN, ListName):
 103     """ Remove Duplicate Entries from the Guid List passed in """
 104     for Entry in ListName[:]:
 105         if " " + CN + " " in Entry:
 106             if (options.verbose > 1):
 107                 print "Removing C Name %s Entry from Guids List." % (CN)
 108             ListName.remove(Entry)
 109
 110 def chkArch(Archs):
 111     """ Process the supported architectures passed in to combine if possible """
 112     Archs = Archs.upper()
 113     if (("IA32" in Archs) & ("X64" in Archs) & ("IPF" in Archs) & ("EBC" in Archs)):
 114         Archs = "ALL"
 115     if (len(Archs) == 0):
 116         Archs = "ALL"
 117     return Archs
 118
 119 def saveSourceFile(moduleDir, sourceFilename, sourceFileContents):
 120     newFilename = os.path.join(moduleDir, sourceFilename)
 121
 122     try:
 123         f = open(newFilename, "w+")
 124         f.write(sourceFileContents)
 125         f.close()
 126     except:
 127         print "IO error in saving %s" % sourceFilename
 128
 129     return sourceFilename
 130
 131 def openSourceFile(moduleDir, sourceFilename):
 132     newFilename = os.path.join(moduleDir, sourceFilename)
 133     sourceFileContents = ""
 134     try:
 135         f = open(newFilename, "r")
 136         sourceFileContents = f.read()
 137         f.close()
 138     except:
 139         print "IO error in opening %s" % sourceFilename
 140
 141     return sourceFileContents
 142
 143 def MatchOption(eline, ToolChainFamily, Targets, Archs, ToolCode, Value):
 144     IDs = eline.split("_")
 145
 146     if len(IDs) < 5:
 147         return []
 148
 149     MatchedTargets = []
 150     if (Targets[0] == "*") or IDs[0] in Targets:
 151         MatchedTargets.append(IDs[0])
 152     elif IDs[0] == "*":
 153         MatchedTargets = Targets
 154
 155     MatchedArchs = []
 156     if Archs[0] == "*" or IDs[2] in Archs:
 157         MatchedArchs.append(IDs[2])
 158     elif IDs[2] == "*":
 159         MatchedArchs = Archs
 160
 161     if IDs[3] != ToolCode and IDs[3] != "*":
 162         return []
 163
 164     result = []
 165     for arch in MatchedArchs:
 166         for target in MatchedTargets:
 167             line = "%s:%s_%s_%s_%s_FLAGS = %s" % (ToolChainFamily, target, IDs[1], arch, ToolCode, Value)
 168             result.append(line)
 169
 170     return result
 171
 172 def main():
 173
 174     AutoGenSource = ""
 175     AutoGenHeader = ""
 176     AutoGenDeclaration = ""
 177     AutoGenModuleFolder = None
 178
 179     workspace = ""
 180
 181     if (options.workspace == None):
 182         print "ERROR: E0000: WORKSPACE not defined.\n  Please set the WORKSPACE environment variable to the location of the EDK II install directory."
 183         sys.exit(1)
 184     else:
 185         workspace = options.workspace
 186         if (options.debug):
 187             print "Using Workspace:", workspace
 188
 189     try:
 190         options.verbose +=1
 191     except:
 192         options.verbose = 1
 193         pass
 194
 195
 196     FdbPath = os.path.join(workspace, "Conf")
 197     FdbPath = os.path.join(FdbPath, "FrameworkDatabase.db")
 198     if os.path.exists(FdbPath):
 199         FdbFile = FdbPath
 200     else:
 201         print "ERROR: E0001: WORKSPACE does not contain the FrameworkDatabase File.\n  Please run EdkSetup from the EDK II install directory.\n"
 202         sys.exit(1)
 203
 204     Fdb = openDatabase(FdbFile)
 205     if (Fdb == 'None'):
 206         print "ERROR: E0002 Could not open the Framework Database file:", FdbFile
 207         sys.exit(1)
 208
 209     if (options.debug):
 210         print "FrameworkDataBase.db file:", FdbFile
 211
 212     #
 213     InitializeAutoGen(workspace, Fdb)
 214
 215     if (options.filename):
 216         filename = options.filename
 217         if ((options.verbose > 1) | (options.autowrite)):
 218             print "Filename:", filename
 219     else:
 220         print "ERROR: E0001 - You must specify an input filename"
 221         sys.exit(1)
 222
 223     if (options.outfile):
 224         outputFile = options.outfile
 225     else:
 226        outputFile = filename.replace('.msa', '.inf')
 227
 228     if ((options.verbose > 2) or (options.debug)):
 229         print "Output Filename:", outputFile
 230
 231     Msa = openMsa(filename)
 232     if (Msa == 'None'):
 233         ## Maybe developer think WORKSPACE macro is the root directory of file name
 234         ## So we will try to add WORKSPACE path into filename
 235         MsaFileName = ""
 236         MsaFileName = os.path.join(workspace, filename)
 237         Msa = openMsa(MsaFileName)
 238         if (Msa == 'None'):
 239             print "ERROR: E0002: Could not open the file:", filename
 240             sys.exit(1)
 241
 242     AutoGenModuleFolder = os.path.dirname(filename)
 243
 244     MsaHeader = "/ModuleSurfaceArea/MsaHeader/"
 245     MsaDefs = "/ModuleSurfaceArea/ModuleDefinitions/"
 246     BaseName = str(XmlElement(Msa, MsaDefs + "OutputFileBasename")).strip()
 247
 248     if (len(BaseName) < 1):
 249       BaseName = str(XmlElement(Msa, MsaHeader + "BaseName")).strip()
 250       BaseName = re.sub(' ', '_', BaseName)
 251
 252     GuidValue = str(XmlElement(Msa, MsaHeader + "GuidValue")).strip()
 253     VerString = str(XmlElement(Msa, MsaHeader + "Version")).strip()
 254     ModType = str(XmlElement(Msa, MsaHeader + "ModuleType")).strip()
 255     CopyRight = str(XmlElement(Msa, MsaHeader + "Copyright")).strip()
 256     Abstract = str(XmlElement(Msa, MsaHeader + "Abstract")).strip()
 257     Description = str(XmlElement(Msa, MsaHeader + "Description")).strip().replace("  ", " ").replace("  ", " ").replace("  ", " ")
 258     if not CopyRight.find("2007"):
 259         CopyRight = CopyRight.replace("2006", "2007")
 260     License = str(XmlElement(Msa, MsaHeader + "License")).strip().replace("  ", " ")
 261     MsaDefs = "/ModuleSurfaceArea/ModuleDefinitions/"
 262     BinModule = ""
 263     try:
 264         BinModule = str(XmlElement(Msa, MsaDefs + "BinaryModule")).strip()
 265     except:
 266         pass
 267
 268     SupportedArchitectures = ""
 269     try:
 270         SupportedArchitectures = str(XmlElement(Msa, MsaDefs + "SupportedArchitectures")).strip()
 271     except:
 272         pass
 273
 274     DefinesComments = []
 275     if (len(SupportedArchitectures) > 0):
 276         DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n")
 277         DefinesComments.append("#  VALID_ARCHITECTURES           = " + SupportedArchitectures + "\n")
 278         DefinesComments.append("#\n")
 279
 280     MsaExtern = "/ModuleSurfaceArea/Externs/"
 281     PcdIsDriver = ""
 282     try:
 283         PcdIsDriver = str(XmlElement(Msa, MsaExtern + "PcdIsDriver")).strip()
 284     except:
 285         pass
 286
 287     SpecList = []
 288     List = []
 289     try:
 290         List = XmlList(Msa, MsaExtern + "Specification")
 291     except:
 292         pass
 293
 294     if (len(List) > 0):
 295         for spec in List[:]:
 296             SpecList.insert(0, str(XmlElementData(spec)).strip())
 297
 298     DriverModules = []
 299     LibraryModules = []
 300     Externlist = []
 301     Flag = (DefinesComments == [])
 302
 303     # Data structure to insert autogen code
 304     AutoGenDriverModel = []
 305     AutoGenExitBootServices = []
 306     AutoGenVirtualAddressChanged = []
 307     AutoGenEntryPoint = ""
 308     AutoGenUnload = ""
 309     AutoGenGuid = []
 310     AutoGenLibClass = []
 311     AutoGenPackage = []
 312     AutoGenSourceFiles = []
 313     OldEntryPoint = ""
 314     OldUnload = ""
 315
 316     try:
 317         Externlist = XmlList(Msa, MsaExtern + "Extern")
 318     except:
 319         pass
 320
 321     if (len(Externlist) > 0):
 322         if (options.debug and options.verbose > 2):
 323             print "In Extern Parsing Routine"
 324         for extern in Externlist:
 325             EntryPoint = ""
 326             Unload = ""
 327             DBinding = ""
 328             CompName = ""
 329             Diag = ""
 330             Config = ""
 331             Constr = ""
 332             Destr = ""
 333             CallBack = ""
 334             lFlag = False
 335             AutoGenDriverModelItem = []
 336             try:
 337                 EntryPoint = str(XmlElementData(extern.getElementsByTagName("ModuleEntryPoint")[0])).strip()
 338                 AutoGenEntryPoint = EntryPoint
 339                 #DriverModules.append("  %-30s = %s\n" % ("ENTRY_POINT" , EntryPoint))
 340             except:
 341                 pass
 342
 343             try:
 344                 Unload = str(XmlElementData(extern.getElementsByTagName("ModuleUnloadImage")[0])).strip()
 345                 AutoGenUnload = Unload
 346                 DriverModules.append("  %-30s = %s\n" % ("UNLOAD_IMAGE", Unload))
 347             except:
 348                 pass
 349
 350             try:
 351                 DBinding = str(XmlElementData(extern.getElementsByTagName("DriverBinding")[0])).strip()
 352                 AutoGenDriverModelItem.append("&" + DBinding)
 353                 DefinesComments.append("#  %-29s =  %-45s\n" % ("DRIVER_BINDING", DBinding))
 354                 lFlag = True
 355             except:
 356                 pass
 357
 358             try:
 359                 CompName = str(XmlElementData(extern.getElementsByTagName("ComponentName")[0])).strip()
 360                 AutoGenDriverModelItem.append("&" + CompName)
 361                 DefinesComments.append("#  %-29s =  %-45s\n" % ("COMPONENT_NAME", CompName))
 362                 lFlag = True
 363             except:
 364                 if lFlag:
 365                     AutoGenDriverModelItem.append("NULL")
 366                 pass
 367
 368             try:
 369                 Config = str(XmlElementData(extern.getElementsByTagName("DriverConfig")[0])).strip()
 370                 AutoGenDriverModelItem.append("&" + Config)
 371                 DefinesComments.append("#  %-29s =  %-45s\n" % ("DRIVER_CONFIG", Config))
 372                 lFlag = True
 373             except:
 374                 if lFlag:
 375                     AutoGenDriverModelItem.append("NULL")
 376                 pass
 377
 378             try:
 379                 Diag = str(XmlElementData(extern.getElementsByTagName("DriverDiag")[0])).strip()
 380                 AutoGenDriverModelItem.append("&" + Diag)
 381                 DefinesComments.append("#  %-29s =  %-45s\n" % ("DRIVER_DIAG", Diag))
 382                 lFlag = True
 383             except:
 384                 if lFlag:
 385                     AutoGenDriverModelItem.append("NULL")
 386                 pass
 387
 388             if len(AutoGenDriverModelItem) > 0:
 389                 AutoGenDriverModel.append(AutoGenDriverModelItem)
 390
 391             try:
 392                 Constr = str(XmlElementData(extern.getElementsByTagName("Constructor")[0])).strip()
 393                 LibraryModules.append("  %-30s = %s\n" % ("CONSTRUCTOR", Constr))
 394             except:
 395                 pass
 396
 397             try:
 398                 Destr = str(XmlElementData(extern.getElementsByTagName("Destructor")[0])).strip()
 399                 LibraryModules.append("  %-30s = %s\n" % ("DESTRUCTOR", Destr))
 400             except:
 401                 pass
 402
 403             try:
 404                 CallBack = str(XmlElement(extern, "Extern/SetVirtualAddressMapCallBack")).strip()
 405                 if CallBack != "":
 406                     AutoGenVirtualAddressChanged.append(CallBack)
 407                     DefinesComments.append("#  %-29s =  %-45s\n" % ("VIRTUAL_ADDRESS_MAP_CALLBACK", CallBack))
 408                     lFlag = True
 409             except:
 410
 411                 pass
 412
 413             try:
 414                 CallBack = str(XmlElement(extern, "Extern/ExitBootServicesCallBack")).strip()
 415                 if CallBack != "":
 416                     AutoGenExitBootServices.append(CallBack)
 417                     DefinesComments.append("#  %-29s =  %-45s\n" % ("EXIT_BOOT_SERVICES_CALLBACK", CallBack))
 418                     lFlag = True
 419             except:
 420                 pass
 421
 422
 423     Flag = False
 424
 425     """ Get the Module's custom build options """
 426     MBOlines = []
 427     MBO = "/ModuleSurfaceArea/ModuleBuildOptions/Options/Option"
 428     mboList = []
 429     try:
 430         mboList = XmlList(Msa, MBO)
 431     except:
 432         pass
 433
 434     if (len(mboList) > 0):
 435         for Option in mboList:
 436             Targets = []
 437             Archs = []
 438
 439             bt = ""
 440             try:
 441                 bt = str(Option.getAttribute("BuildTargets"))
 442             except:
 443                 pass
 444
 445             if (len(bt) > 0):
 446                 if (re.findall(" ", bt) > 0):
 447                     Targets = bt.split()
 448                 else:
 449                     Targets.insert(0, bt)
 450             else:
 451                 Targets.insert(0, "*")
 452
 453             if (options.debug and options.verbose > 2):
 454                 print "Targets", len(Targets), Targets
 455
 456             pro = ""
 457             try:
 458                 pro = Option.getAttribute("SupArchList")
 459                 if (re.findall(" ", pro) > 0):
 460                     Archs = pro.split()
 461                 elif (re.findall(",", pro) > 0):
 462                     Archs = pro.split(",")
 463             except:
 464                 pass
 465
 466             if (len(pro) == 0):
 467                 Archs.insert(0, "*")
 468
 469             if (options.debug and options.verbose > 2):
 470                 print "Archs", len(Archs), Archs
 471
 472             ToolCode = ""
 473             try:
 474                 ToolCode = str(Option.getAttribute("ToolCode"))
 475             except:
 476                 pass
 477
 478             if (len(ToolCode) == 0):
 479                 ToolCode="*"
 480
 481             value = ""
 482             try:
 483                 value = str(XmlElementData(Option))
 484             except:
 485                 pass
 486             Tags = []
 487             TagName = ""
 488             try:
 489                 TagName = str(Option.getAttribute("TagName"))
 490             except:
 491                 pass
 492
 493             if (len(TagName) > 0) :
 494                 if (options.debug and options.verbose > 2):
 495                     print "TagName was defined:", TagName
 496                 Tags.insert(0, TagName)
 497             else:
 498                 if (options.debug and options.verbose > 2):
 499                     print "TagName was NOT defined!"
 500                 TagName = "*"
 501                 Tags.insert(0, "*")
 502
 503             Family = ""
 504             try:
 505                 Family = str(Option.getAttribute("ToolChainFamily")).strip()
 506             except:
 507                 pass
 508
 509             if (len(Family) > 0):
 510                 if (options.debug):
 511                     print "Searching tools_def.txt for Tool Tags that belong to:", Family, "family"
 512                 TCF = []
 513                 tdFile = ""
 514                 tdPath = os.path.join(workspace, "Tools")
 515                 tdPath = os.path.join(tdPath, "Conf")
 516                 tdPath = os.path.join(tdPath, "tools_def.txt")
 517                 tdPath = tdPath.replace("\\", "/")
 518                 if os.path.exists(tdPath):
 519                     tdFile = tdPath
 520                 else:
 521                     tdPath = os.path.join(workspace, "Conf")
 522                     tdPath = os.path.join(tdPath, "tools_def.txt")
 523                     if os.path.exists(tdPath):
 524                         tdFile = tdPath
 525                     else:
 526                         print "ERROR: E0001: WORKSPACE does not contain the tools_def.txt File.\n  Please run EdkSetup from the EDK II install directory.\n"
 527                         sys.exit(1)
 528
 529                 if (options.debug and options.verbose > 2):
 530                     print "Opening:", tdFile
 531
 532                 TagNameList = []
 533                 tools_def = open(tdFile, "r")
 534                 for tdline in tools_def:
 535                     if "# " in tdline:
 536                         continue
 537                     if "FAMILY" in tdline:
 538                         if (options.debug and options.verbose > 2):
 539                             print "Testing for FAMILY:", Family, "in the line:", tdline.strip()
 540                         if Family in tdline:
 541                             enter = tdline.split("=")[0]
 542                             if (options.debug and options.verbose > 2):
 543                                 print "Adding TNL:", tdline
 544                             TagNameList.insert(0, enter)
 545                 tools_def.close()
 546
 547                 if (options.debug and options.verbose > 2):
 548                     print "TagNameList:", TagNameList
 549
 550                 olinesSet = {}
 551                 for eline in TagNameList:
 552                     if "# " in eline:
 553                         continue
 554                     if (options.debug and options.verbose > 2):
 555                         print "ToolsDef entry:", eline
 556
 557                     olines = MatchOption(eline, Family, Targets, Archs, ToolCode, value)
 558                     for oline in olines:
 559                         olinesSet[oline] = 1
 560
 561                 for oline in olinesSet:
 562                     if (options.debug and options.verbose > 2):
 563                         print "Adding:", str(oline)
 564                     MBOlines.insert(0, oline)
 565             else:
 566                 for targ in Targets:
 567                     for arch in Archs:
 568                         oline = "  %s_%s_%s_%s_FLAGS = %s" % (targ, Tags[0], arch, str(ToolCode), str(Value))
 569                         if (options.debug and options.verbose > 2):
 570                             print "Adding:", str(oline)
 571                         MBOlines.insert(0, oline)
 572
 573
 574
 575
 576             for tag in Tags:
 577                 for targ in Targets:
 578                     for arch in Archs:
 579                         oline = "  " + str(targ) + "_" + str(tag) + "_" + str(arch) + "_" + str(ToolCode) + "_FLAGS  = " + str(value)
 580                         if (options.debug and options.verbose > 2):
 581                             print "Adding:", str(oline)
 582                         #MBOlines.insert(0, oline)
 583
 584
 585     """ Get the Library Class information """
 586     MsaLcDefs = "/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass"
 587     LcDefList = []
 588     try:
 589         LcDefList = XmlList(Msa, MsaLcDefs)
 590     except:
 591         pass
 592
 593     IamLibrary = []
 594     LibClassList = []
 595     LibClassListIa32 = []
 596     LibClassListX64 = []
 597     LibClassListIpf = []
 598     LibClassListEbc = []
 599
 600
 601     if (len(LcDefList) > 0):
 602         for Lc in LcDefList:
 603             lcKeyword = ""
 604             try:
 605                 lcKeyword = str(XmlElementData(Lc.getElementsByTagName("Keyword")[0]))
 606             except:
 607                 raise SyntaxError, "The MSA is not correctly formed, a Library Class Keyword Element is required"
 608
 609             lcUsage = ""
 610             try:
 611                 lcUsage = str(XmlAttribute(Lc, "Usage"))
 612             except:
 613                 raise SyntaxError, "The MSA is not correctly formed, a Usage Attribute is required for all Library Class Elements"
 614
 615             Archs = ""
 616             try:
 617                 Archs = str(XmlAttribute(Lc, "SupArchList"))
 618             except:
 619                 pass
 620
 621             Archs = chkArch(Archs)
 622
 623             if (options.debug and options.verbose > 2):
 624                 print "Attr: ",  lcUsage, lcKeyword, Archs
 625
 626             if (options.convert):
 627                 lcKeyword = AutoGenLibraryMapping.get(lcKeyword, lcKeyword)
 628
 629             if re.findall("PRODUCED", lcUsage, re.IGNORECASE):
 630                 try:
 631                     lcSupModList = ""
 632
 633                     try:
 634                         lcSupModList = str(XmlAttribute(Lc, "SupModuleList"))
 635                     except:
 636                         lcSupModList = ""
 637                     pass
 638
 639                     lcLine = lcKeyword
 640                     AutoGenLibClass.append(lcKeyword)
 641                     if len(lcSupModList) > 0:
 642                         lcLine = lcLine + "|" + lcSupModList
 643                     IamLibrary.insert(0, lcLine)
 644                 except:
 645                     pass
 646             elif lcKeyword != "UefiDriverModelLib":
 647                 AutoGenLibClass.append(lcKeyword)
 648                 # This section handles the library classes that are CONSUMED
 649                 if "IA32" in Archs:
 650                     LibClassListIa32.insert(0, lcKeyword)
 651                 if "X64" in Archs:
 652                     LibClassListX64.insert(0, lcKeyword)
 653                 if "IPF" in Archs:
 654                     LibClassListIpf.insert(0, lcKeyword)
 655                 if "EBC" in Archs:
 656                     LibClassListEbc.insert(0, lcKeyword)
 657                 if "ALL" in Archs:
 658                     LibClassList.insert(0, lcKeyword)
 659         if len(AutoGenDriverModel) > 0 and "UefiLib" not in LibClassList:
 660             AutoGenLibClass.append("UefiLib")
 661             LibClassList.insert(0, "UefiLib")
 662
 663     AutoGenDxsFiles = []
 664     """ Get the Source File list """
 665     SrcFilenames = []
 666     SrcFilenamesIa32 = []
 667     SrcFilenamesX64 = []
 668     SrcFilenamesIpf = []
 669     SrcFilenamesEbc = []
 670     SrcFiles = "/ModuleSurfaceArea/SourceFiles/Filename"
 671     SrcList = []
 672     try:
 673         SrcList = XmlList(Msa, SrcFiles)
 674     except:
 675         pass
 676
 677     if (len(SrcList) > 0):
 678         for fn in SrcList:
 679             file = ""
 680             Archs = ""
 681
 682             try:
 683                 Archs = fn.getAttribute("SupArchList")
 684             except:
 685                 pass
 686
 687             Archs = chkArch(Archs)
 688
 689             try:
 690                 file = str(XmlElementData(fn))
 691             except:
 692                 pass
 693
 694             if file.endswith(".dxs"):
 695                 AutoGenDxsFiles.append((file, Archs))
 696             else:
 697                 AutoGenSourceFiles.append(file)
 698                 if "IA32" in Archs:
 699                     SrcFilenamesIa32.insert(0, file)
 700                 if "X64" in Archs:
 701                     SrcFilenamesX64.insert(0, file)
 702                 if "IPF" in Archs:
 703                     SrcFilenamesIpf.insert(0, file)
 704                 if "EBC" in Archs:
 705                     SrcFilenamesEbc.insert(0, file)
 706                 if "ALL" in Archs:
 707                     SrcFilenames.insert(0, file)
 708
 709     """ Package Dependency section """
 710     DbPkgList = "/FrameworkDatabase/PackageList/Filename"
 711     WorkspacePkgs = []
 712     try:
 713         WorkspacePkgs = XmlList(Fdb, DbPkgList)
 714     except:
 715         print "Could not tet the package data from the database"
 716         sys.exit(1)
 717
 718     PkgDb = []
 719     HeaderLocations = []
 720
 721     if (options.debug and options.verbose > 1):
 722         print "Found %s packages in the WORKSPACE" % (len(WorkspacePkgs))
 723
 724     Dirs = []
 725     GuidDecls = []
 726     if (len(WorkspacePkgs) > 0):
 727         SpdHeader = "/PackageSurfaceArea/SpdHeader/"
 728         for Pkg in WorkspacePkgs[:]:
 729             PackageGuid = ""
 730             PackageVersion = ""
 731             file = ""
 732             try:
 733                 file = str(XmlElementData(Pkg))
 734             except:
 735                 pass
 736
 737             if (options.debug and options.verbose > 2):
 738                 print "PKG:", file
 739
 740             if fnmatch.fnmatch(file, "*.dec"):
 741                 print "parsing " + os.path.join(workspace, file)
 742                 PackageGuid = ""
 743                 PackageVersion = ""
 744                 try:
 745                     Lines = open(os.path.join(workspace, file)).readlines()
 746                 except:
 747                     print "Could not parse the Package file:", file
 748                     sys.exit(1)
 749
 750                 for Line in Lines:
 751                     Line = Line.split("#")[0]
 752                     Items = Line.split("=")
 753                     if len(Items) != 2:
 754                         continue
 755
 756                     Key = Items[0].strip().upper()
 757                     if Key == "PACKAGE_GUID":
 758                         PackageGuid = Items[1].strip()
 759                     if Key == "PACKAGE_VERSION":
 760                         PackageVersion = Items[1].strip()
 761
 762             else:
 763                 Spd = openSpd(os.path.join(workspace, file))
 764                 if (Spd == 'None'):
 765                     print "Could not parse the Package file:", file
 766                     sys.exit(1)
 767
 768                 path = os.path.split(file)[0]
 769                 file = file.replace(".nspd", ".dec")
 770                 file = file.replace(".spd", ".dec")
 771
 772                 try:
 773                     PackageGuid = str(XmlElement(Spd, SpdHeader + "GuidValue"))
 774                 except:
 775                     pass
 776
 777                 try:
 778                     PackageVersion = str(XmlElement(Spd, SpdHeader + "Version"))
 779                 except:
 780                     pass
 781
 782             file = file + "|" + PackageGuid + "|" + PackageVersion
 783             PkgDb.insert(0, file)
 784
 785             GuidEntries = []
 786             try:
 787                 GuidEntries = XmlList(Spd, "/PackageSurfaceArea/GuidDeclarations/Entry")
 788             except:
 789                 pass
 790
 791             if (len(GuidEntries) > 0):
 792                 for Entry in GuidEntries[:]:
 793                     try:
 794                         GuidDecls.append(str(XmlElementData(Entry.getElementsByTagName("C_Name")[0])).strip())
 795                     except:
 796                         pass
 797
 798
 799             pHdrs = []
 800             try:
 801                 pHdrs = XmlList(Spd, "/PackageSurfaceArea/PackageHeaders/IncludePkgHeader")
 802             except:
 803                 pass
 804
 805             if (len(pHdrs) > 0):
 806                 for Hdr in pHdrs[:]:
 807                     try:
 808                         ModTypeList = str(Hdr.getAttribute("ModuleType"))
 809                         if (ModType in ModTypeList):
 810                             HeaderName= str(XmlElementData(Hdr))[0]
 811                             Dirs.insert(0, os.path.join(packagepath,str(os.path.split(HeaderName))))
 812                     except:
 813                         pass
 814
 815             # Get the Guid:Header from the Packages
 816             SpdLcDec = "/PackageSurfaceArea/LibraryClassDeclarations/LibraryClass"
 817             lcList = []
 818             try:
 819                 lcList = XmlList(Spd, SpdLcDec)
 820             except:
 821                 pass
 822
 823             if (len(lcList) > 0):
 824                 for Lc in lcList[:]:
 825                     Name = ""
 826                     try:
 827                         Name = Lc.getAttribute("Name")
 828                     except:
 829                         pass
 830
 831                     Header = ""
 832                     try:
 833                         Header = XmlElementData(Lc.getElementsByTagName("IncludeHeader")[0])
 834                     except:
 835                         pass
 836
 837                     if ((len(Name) > 0) and (len(Header) > 0)):
 838                         line = Name + "|" + os.path.join(path, Header)
 839                         if (options.debug and options.verbose > 2):
 840                             print "Adding:", line
 841                         HeaderLocations.insert(0, line)
 842
 843             ishList = []
 844             try:
 845                 IndStdHeaders = "/PackageSurfaceArea/IndustryStdIncludes/IndustryStdHeader"
 846                 ishList = XmlList(Spd, IndStdHeaders)
 847             except:
 848                 pass
 849
 850             if (len(ishList) > 0):
 851                 for Lc in ishList[:]:
 852                     Name = ""
 853                     try:
 854                         Name = str(Lc.getAttribute("Name")).strip()
 855                     except:
 856                         pass
 857
 858                     Header = ""
 859                     try:
 860                         Header = str(XmlElementData(Lc.getElementsByTagName("IncludeHeader")[0])).strip()
 861                     except:
 862                         pass
 863
 864                     if ((len(Name) > 0) and (len(Header) > 0)):
 865                         line = Name + "|" + os.path.join(path, Header)
 866                         HeaderLocations.insert(0, str(line))
 867
 868     PkgList = []
 869     PkgListIa32 = []
 870     PkgListX64 = []
 871     PkgListIpf = []
 872     PkgListEbc = []
 873     Pkgs = "/ModuleSurfaceArea/PackageDependencies/Package"
 874     pkgL = []
 875     try:
 876        pkgL = XmlList(Msa, Pkgs)
 877     except:
 878        pass
 879
 880
 881     gUnknownPkgGuid = {}
 882     if (len(pkgL) > 0):
 883         if (options.debug and options.verbose > 1):
 884             print "Found %s packages in the module" % (len(pkgL))
 885         for pkg in pkgL[:]:
 886             Archs = ""
 887             pkgGuid = ""
 888             pkgVer = ""
 889
 890             FindPkgGuid = False
 891             try:
 892                 Archs = pkg.getAttribute("SupArchList")
 893             except:
 894                 pass
 895
 896             Archs = chkArch(Archs)
 897
 898             try:
 899                 pkgGuid = pkg.getAttribute("PackageGuid")
 900             except:
 901                 pass
 902
 903             if options.convert:
 904                 if pkgGuid.lower() == "5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec":
 905                     pkgGuid = "1E73767F-8F52-4603-AEB4-F29B510B6766"
 906                 if pkgGuid.lower() == "68169ab0-d41b-4009-9060-292c253ac43d":
 907                     pkgGuid = "BA0D78D6-2CAF-414b-BD4D-B6762A894288"
 908             AutoGenPackage.append(pkgGuid)
 909             try:
 910                 pkgVer = pkg.getAttribute("PackageVersion")
 911             except:
 912                 pass
 913
 914             for PkgEntry in PkgDb[:]:
 915                 if pkgGuid in PkgEntry:
 916                     if len(pkgVer) > 0:
 917                         if pkgVer in PkgEntry:
 918                             FindPkgGuid = True
 919                             if "IA32" in Archs:
 920                                 PkgListIa32.insert(0, PkgEntry.split("|")[0])
 921                             if "X64" in Archs:
 922                                 PkgListX64.insert(0, PkgEntry.split("|")[0])
 923                             if "IPF" in Archs:
 924                                 PkgListIpf.insert(0, PkgEntry.split("|")[0])
 925                             if "EBC" in Archs:
 926                                 PkgListEbc.insert(0, PkgEntry.split("|")[0])
 927                             if "ALL" in Archs:
 928                                 PkgList.insert(0, PkgEntry.split("|")[0])
 929                     else:
 930                         FindPkgGuid = True
 931                         if "IA32" in Archs:
 932                             PkgListIa32.insert(0, PkgEntry.split("|")[0])
 933                         if "X64" in Archs:
 934                             PkgListX64.insert(0, PkgEntry.split("|")[0])
 935                         if "IPF" in Archs:
 936                             PkgListIpf.insert(0, PkgEntry.split("|")[0])
 937                         if "EBC" in Archs:
 938                             PkgListEbc.insert(0, PkgEntry.split("|")[0])
 939                         if "ALL" in Archs:
 940                             PkgList.insert(0, PkgEntry.split("|")[0])
 941
 942             if not FindPkgGuid:
 943                 gUnknownPkgGuid[str(pkgGuid)] = 1
 944
 945     for UnknownPkgGuid in gUnknownPkgGuid:
 946         print "Cannot resolve package dependency Guid:", UnknownPkgGuid
 947
 948     PkgList.reverse()
 949     PkgListIa32.reverse()
 950     PkgListX64.reverse()
 951     PkgListIpf.reverse()
 952     PkgListEbc.reverse()
 953     if (options.debug):
 954         print "Package List:", PkgList
 955
 956
 957
 958     """ Setup the Global GuidCName arrays that will hold data from various MSA locations """
 959     global GuidCName
 960     global GuidCNameIa32
 961     global GuidCNameX64
 962     global GuidCNameIPF
 963     global GuidCNameEBC
 964     GuidCName = []
 965     GuidCNameIa32 = []
 966     GuidCNameX64 = []
 967     GuidCNameIPF = []
 968     GuidCNameEBC = []
 969
 970     """ Check for the GUIDs Element """
 971     Guids = "/ModuleSurfaceArea/Guids/GuidCNames"
 972     GuidList = []
 973     try:
 974         GuidList = XmlList(Msa, Guids)
 975     except:
 976         pass
 977
 978     if (len(GuidList) > 0):
 979         for Guid in GuidList:
 980             Archs = ""
 981             Usage = ""
 982             CName = ""
 983
 984             try:
 985                 Archs = Guid.getAttribute("SupArchList")
 986             except:
 987                 pass
 988
 989             Archs = chkArch(Archs)
 990
 991             try:
 992                 Usage = Guid.getAttribute("Usage")
 993             except:
 994                 pass
 995
 996             try:
 997                 CName = str(XmlElementData(Guid.getElementsByTagName("GuidCName")[0]))
 998                 if CName in GuidDecls:
 999                     if (options.debug and options.verbose > 1):
1000                         print "Guids Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs)
1001                     AddGuid(Archs, CName, Usage)
1002                     AutoGenGuid.append(CName)
1003                 else:
1004                     raise AssertionError, "Guid %s defined in %s is not declared in any package (.dec) file!" % (CName, filename)
1005             except:
1006                 pass
1007
1008     if (options.debug and options.verbose > 2):
1009         print "Guid C Name List:", GuidCName
1010
1011     """ Check for Events """
1012     Guids = "/ModuleSurfaceArea/Events/CreateEvents/EventTypes"
1013     GuidList = []
1014     try:
1015         GuidList = XmlList(Msa, Guids)
1016     except:
1017         pass
1018
1019     if (len(GuidList) > 0):
1020         for Guid in GuidList:
1021             Archs = ""
1022             Usage = ""
1023             CName = ""
1024
1025             try:
1026                 Archs = Guid.getAttribute("SupArchList")
1027             except:
1028                 pass
1029
1030             Archs = chkArch(Archs)
1031
1032             try:
1033                 Usage = Guid.getAttribute("Usage")
1034                 Type = str(XmlElementData(Guid.getElementsByTagName("EventType")[0]))
1035                 Usage += "  Create Event: " + Type
1036             except:
1037                 pass
1038
1039             try:
1040                 CName = str(Guid.getAttribute("EventGuidCName"))
1041                 if CName in GuidDecls:
1042                     if (options.debug and options.verbose > 1):
1043                         print "CreateEvent Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs)
1044                     AddGuid(Archs, CName, Usage)
1045                     AutoGenGuid.append(CName)
1046                 else:
1047                     if (len(DefinesComments) == 0):
1048                         DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n")
1049                     DefinesComments.append("#  Create Event Guid C Name: " + CName + " Event Type: " + Type + "\n")
1050                     Flag = True
1051             except:
1052                 pass
1053
1054     if (Flag):
1055         DefinesComments.append("#\n")
1056         Flag = False
1057
1058     Guids = "/ModuleSurfaceArea/Events/SignalEvents/EventTypes"
1059     GuidList = []
1060     try:
1061         GuidList = XmlList(Msa, Guids)
1062     except:
1063         pass
1064
1065     if (len(GuidList) > 0):
1066         for Guid in GuidList:
1067             Archs = ""
1068             Usage = ""
1069             CName = ""
1070
1071             try:
1072                 Archs = Guid.getAttribute("SupArchList")
1073             except:
1074                 pass
1075
1076             Archs = chkArch(Archs)
1077
1078             try:
1079                 Usage = Guid.getAttribute("Usage")
1080                 Type = str(XmlElementData(Guid.getElementsByTagName("EventType")[0]))
1081                 Usage += "  Signal Event: " + Type
1082             except:
1083                 pass
1084
1085             try:
1086                 CName = str(Guid.getAttribute("EventGuidCName"))
1087                 if CName in GuidDecls:
1088                     if (options.debug and options.verbose > 1):
1089                         print "SignalEvent Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs)
1090                     AddGuid(Archs, CName, Usage)
1091                     AutoGenGuid.append(CName)
1092                 else:
1093                     if (len(DefinesComments) == 0):
1094                         DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n")
1095                     DefinesComments.append("#  Signal Event Guid C Name: " + CName + " Event Type: " + Type + "\n")
1096                     Flag = True
1097             except:
1098                 pass
1099
1100     if (Flag):
1101         DefinesComments.append("#\n")
1102         Flag = False
1103
1104     """ Check the HOB guids """
1105     Guids = "/ModuleSurfaceArea/Hobs/HobTypes"
1106     GuidList = []
1107     try:
1108         GuidList = XmlList(Msa, Guids)
1109     except:
1110         pass
1111
1112     if (len(GuidList) > 0):
1113         for Guid in GuidList:
1114             Archs = ""
1115             Usage = ""
1116             CName = ""
1117
1118             try:
1119                 Archs = Guid.getAttribute("SupArchList")
1120             except:
1121                 pass
1122
1123             Archs = chkArch(Archs)
1124
1125             try:
1126                 Usage = Guid.getAttribute("Usage")
1127                 Type = str(XmlElementData(Guid.getElementsByTagName("HobType")[0]))
1128                 Usage += "  Hob: " + Type
1129             except:
1130                 pass
1131
1132             try:
1133                 CName = str(Guid.getAttribute("HobGuidCName"))
1134                 if CName in GuidDecls:
1135                     if (options.debug and options.verbose > 1):
1136                         print "Hob Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs)
1137                     AddGuid(Archs, CName, Usage)
1138                     AutoGenGuid.append(CName)
1139                 else:
1140                     if (len(DefinesComments) == 0):
1141                         DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n")
1142                     DefinesComments.append("#  HOB Guid C Name: " + CName + " Hob Type: " + Type + "\n")
1143                     Flag = True
1144             except:
1145                 if (len(DefinesComments) == 0):
1146                     DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n")
1147                 DefinesComments.append("#  HOB: " + Type + "\n")
1148                 Flag = True
1149                 pass
1150
1151     if (Flag):
1152         DefinesComments.append("#\n")
1153         Flag = False
1154
1155     """ Check for the SystemTables Element """
1156     Guids = "/ModuleSurfaceArea/SystemTables/SystemTableCNames"
1157     GuidList = []
1158     try:
1159         GuidList = XmlList(Msa, Guids)
1160     except:
1161         pass
1162
1163     if (len(GuidList) > 0):
1164         for Guid in GuidList:
1165             Archs = ""
1166             Usage = ""
1167             CName = ""
1168
1169             try:
1170                 Archs = Guid.getAttribute("SupArchList")
1171             except:
1172                 pass
1173
1174             Archs = chkArch(Archs)
1175
1176             try:
1177                 Usage = Guid.getAttribute("Usage")
1178                 Usage += "  System Table"
1179             except:
1180                 pass
1181
1182             try:
1183                 CName = str(XmlElementData(Guid.getElementsByTagName("SystemTableCName")[0]))
1184                 if (options.debug and options.verbose > 1):
1185                     print "System Table Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs)
1186                 AddGuid(Archs, CName, Usage)
1187                 AutoGenGuid.append(CName)
1188             except:
1189                 pass
1190
1191     """ Check for the DataHubs Element """
1192     Guids = "/ModuleSurfaceArea/DataHubs/DataHubRecord"
1193     GuidList = []
1194     try:
1195         GuidList = XmlList(Msa, Guids)
1196     except:
1197         pass
1198
1199     if (len(GuidList) > 0):
1200         for Guid in GuidList:
1201             Archs = ""
1202             Usage = ""
1203             CName = ""
1204
1205             try:
1206                 Archs = Guid.getAttribute("SupArchList")
1207             except:
1208                 pass
1209
1210             Archs = chkArch(Archs)
1211
1212             try:
1213                 Usage = Guid.getAttribute("Usage")
1214                 Usage += "  Data Hub"
1215             except:
1216                 pass
1217
1218             try:
1219                 CName = str(XmlElementData(Guid.getElementsByTagName("DataHubCName")[0]))
1220                 if (options.debug and options.verbose > 1):
1221                     print "Data Hub Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs)
1222                 AddGuid(Archs, CName, Usage)
1223                 AutoGenGuid.append(CName)
1224             except:
1225                 pass
1226
1227     """ Check for the HiiPackages Element """
1228     Guids = "/ModuleSurfaceArea/HiiPackages/HiiPackage"
1229     GuidList = []
1230     try:
1231         GuidList = XmlList(Msa, Guids)
1232     except:
1233         pass
1234
1235     if (len(GuidList) > 0):
1236         for Guid in GuidList:
1237             Archs = ""
1238             Usage = ""
1239             CName = ""
1240
1241             try:
1242                 Archs = Guid.getAttribute("SupArchList")
1243             except:
1244                 pass
1245
1246             Archs = chkArch(Archs)
1247
1248             try:
1249                 Usage = Guid.getAttribute("Usage")
1250                 Usage += "  HII Formset"
1251             except:
1252                 pass
1253
1254             try:
1255                 CName = str(XmlElementData(Guid.getElementsByTagName("HiiCName")[0]))
1256                 if (options.debug and options.verbose > 1):
1257                     print "Hii Formset Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs)
1258                 AddGuid(Archs, CName, Usage)
1259                 AutoGenGuid.append(CName)
1260             except:
1261                 pass
1262
1263     """ Check for the Variables Element """
1264     Guids = "/ModuleSurfaceArea/Variables/Variable"
1265     GuidList = []
1266     try:
1267         GuidList = XmlList(Msa, Guids)
1268     except:
1269         pass
1270
1271     if (len(GuidList) > 0):
1272         for Guid in GuidList:
1273             Archs = ""
1274             Usage = ""
1275             CName = ""
1276             VariableName = ""
1277
1278             try:
1279                 Archs = Guid.getAttribute("SupArchList")
1280             except:
1281                 pass
1282
1283             Archs = chkArch(Archs)
1284
1285             try:
1286                 Usage = Guid.getAttribute("Usage")
1287             except:
1288                 pass
1289
1290             try:
1291                 VariableName = str(XmlElementData(Guid.getElementsByTagName("VariableName")[0]))
1292                 CName = str(XmlElementData(Guid.getElementsByTagName("GuidC_Name")[0]))
1293
1294                 HexData = VariableName.strip().split()
1295                 UniString = " L\""
1296                 for dig in HexData[:]:
1297                     UniString += str(unichr(eval(dig)))
1298                 UniString += "\""
1299
1300                 Usage += UniString
1301
1302                 if CName in set(GuidDecls):
1303                     removeDups(CName, GuidCName)
1304                     removeDups(CName, GuidCNameIa32)
1305                     removeDups(CName, GuidCNameX64)
1306                     removeDups(CName, GuidCNameIPF)
1307                     removeDups(CName, GuidCNameEBC)
1308
1309                     if (options.debug):
1310                         print "Variable Adding Guid CName: %-45s # %s Archs: %s" % (CName, Usage, Archs)
1311                     AddGuid(Archs, CName, Usage)
1312                     AutoGenGuid.append(CName)
1313                 else:
1314                     if (len(DefinesComments) == 0):
1315                         DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n")
1316                     DefinesComments.append("#  Variable Guid C Name: " + CName + " Variable Name:" + UniString + "\n")
1317                     Flag = True
1318             except:
1319                 pass
1320
1321     if (Flag):
1322         DefinesComments.append("#\n")
1323         Flag = False
1324
1325     """ Check for the Protocol Element """
1326     Protocols = "/ModuleSurfaceArea/Protocols/Protocol"
1327     ProtocolList = []
1328     ProtocolCName = []
1329     ProtocolCNameIa32 = []
1330     ProtocolCNameX64 = []
1331     ProtocolCNameIPF = []
1332     ProtocolCNameEBC = []
1333
1334     try:
1335         ProtocolList = XmlList(Msa, Protocols)
1336     except:
1337         pass
1338
1339     if (len(ProtocolList) > 0):
1340         for Protocol in ProtocolList:
1341             Archs = ""
1342             Usage = ""
1343             CName = ""
1344
1345             try:
1346                 Archs = Protocol.getAttribute("SupArchList")
1347             except:
1348                 pass
1349
1350             Archs = chkArch(Archs)
1351
1352             try:
1353                 Usage = Protocol.getAttribute("Usage")
1354             except:
1355                 pass
1356
1357             try:
1358                 CName = str(XmlElementData(Protocol.getElementsByTagName("ProtocolCName")[0]))
1359                 AutoGenGuid.append(CName)
1360                 removeDups(CName, GuidCName)
1361                 removeDups(CName, GuidCNameIa32)
1362                 removeDups(CName, GuidCNameX64)
1363                 removeDups(CName, GuidCNameIPF)
1364                 removeDups(CName, GuidCNameEBC)
1365
1366                 if (options.debug and options.verbose > 1):
1367                     print "Found %s - %s - %s " % (CName, Usage, str(len(Archs)))
1368
1369                 if "IA32" in Archs:
1370                     ProtocolCNameIa32.insert(0, str("  %-45s # PROTOCOL %s" % (CName, Usage)))
1371                 if "X64" in Archs:
1372                     ProtocolCNameX64.insert(0, str("  %-45s # PROTOCOL %s" % (CName, Usage)))
1373                 if "IPF" in Archs:
1374                     ProtocolCNameIPF.insert(0, str("  %-45s # PROTOCOL %s" % (CName, Usage)))
1375                 if "EBC" in Archs:
1376                     ProtocolCNameEBC.insert(0, str("  %-45s # PROTOCOL %s" % (CName, Usage)))
1377                 if "ALL" in Archs:
1378                     ProtocolCName.insert(0, str("  %-45s # PROTOCOL %s" % (CName, Usage)))
1379             except:
1380                 pass
1381
1382
1383     Protocols = "/ModuleSurfaceArea/Protocols/ProtocolNotify"
1384     try:
1385         ProtocolList = XmlList(Msa, Protocols)
1386     except:
1387         pass
1388
1389     if (len(ProtocolList) > 0):
1390         for Protocol in ProtocolList:
1391             Archs = ""
1392             Usage = ""
1393             CName = ""
1394
1395             try:
1396                 Archs = Protocol.getAttribute("SupArchList")
1397             except:
1398                 pass
1399
1400             Archs = chkArch(Archs)
1401
1402             try:
1403                 Usage = Protocol.getAttribute("Usage")
1404             except:
1405                 pass
1406
1407             try:
1408                 CName = str(XmlElementData(Protocol.getElementsByTagName("ProtocolNotifyCName")[0]))
1409                 AutoGenGuid.append(CName)
1410                 removeDups(CName, GuidCName)
1411                 removeDups(CName, GuidCNameIa32)
1412                 removeDups(CName, GuidCNameX64)
1413                 removeDups(CName, GuidCNameIPF)
1414                 removeDups(CName, GuidCNameEBC)
1415
1416                 if "IA32" in Archs:
1417                     ProtocolCNameIa32.insert(0, "  %-45s # PROTOCOL_NOTIFY %s" % (CName, Usage))
1418                 if "X64" in Archs:
1419                     ProtocolCNameX64.insert(0, "  %-45s # PROTOCOL_NOTIFY %s" % (CName, Usage))
1420                 if "IPF" in Archs:
1421                     ProtocolCNameIPF.insert(0, "  %-45s # PROTOCOL_NOTIFY %s" % (CName, Usage))
1422                 if "EBC" in Archs:
1423                     ProtocolCNameEBC.insert(0, "  %-45s # PROTOCOL_NOTIFY %s" % (CName, Usage))
1424                 if "ALL" in Archs:
1425                     ProtocolCName.insert(0, "  %-45s # PROTOCOL_NOTIFY %s" % (CName, Usage))
1426             except:
1427                 pass
1428
1429     """ Check for the PPIs Element """
1430     PPIs = "/ModuleSurfaceArea/PPIs/Ppi"
1431     PPIsList = []
1432     PpiCName = []
1433     PpiCNameIa32 = []
1434     PpiCNameX64 = []
1435     PpiCNameIPF = []
1436     PpiCNameEBC = []
1437
1438     try:
1439         PPIsList = XmlList(Msa, PPIs)
1440     except:
1441         pass
1442
1443     if (len(PPIsList) > 0):
1444         for Ppi in PPIsList:
1445             Archs = ""
1446             Usage = ""
1447             CName = ""
1448
1449             try:
1450                 Archs = str(Ppi.getAttribute("SupArchList"))
1451             except:
1452                 pass
1453
1454             Archs = chkArch(Archs)
1455
1456             try:
1457                 Usage = str(Ppi.getAttribute("Usage"))
1458             except:
1459                 pass
1460
1461             try:
1462                 CName = str(XmlElementData(Ppi.getElementsByTagName("PpiCName")[0])).strip()
1463                 AutoGenGuid.append(CName)
1464                 removeDups(CName, GuidCName)
1465                 removeDups(CName, GuidCNameIa32)
1466                 removeDups(CName, GuidCNameX64)
1467                 removeDups(CName, GuidCNameIPF)
1468                 removeDups(CName, GuidCNameEBC)
1469
1470                 if "IA32" in Archs:
1471                     PpiCNameIa32.insert(0, "  %-45s # PPI %s" % (CName, Usage))
1472                 if "X64" in Archs:
1473                     PpiCNameX64.insert(0, "  %-45s # PPI %s" % (CName, Usage))
1474                 if "IPF" in Archs:
1475                     PpiCNameIPF.insert(0, "  %-45s # PPI %s" % (CName, Usage))
1476                 if "EBC" in Archs:
1477                     PpiCNameEBC.insert(0, "  %-45s # PPI %s" % (CName, Usage))
1478                 if "ALL" in Archs:
1479                     PpiCName.insert(0, "  %-45s # PPI %s" % (CName, Usage))
1480             except:
1481                 pass
1482
1483
1484     PPIs = "/ModuleSurfaceArea/PPIs/PpiNotify"
1485     try:
1486         PPIsList = XmlList(Msa, PPIs)
1487     except:
1488         pass
1489
1490     if (len(PPIsList) > 0):
1491         for Ppi in PPIsList:
1492             Archs = ""
1493             Usage = ""
1494             CName = ""
1495
1496             try:
1497                 Archs = Ppi.getAttribute("SupArchList")
1498             except:
1499                 pass
1500
1501             Archs = chkArch(Archs)
1502
1503             try:
1504                 Usage = Ppi.getAttribute("Usage")
1505             except:
1506                 pass
1507
1508             try:
1509                 CName = str(XmlElementData(Ppi.getElementsByTagName("PpiNotifyCName")[0]))
1510                 AutoGenGuid.append(CName)
1511                 removeDups(CName, GuidCName)
1512                 removeDups(CName, GuidCNameIa32)
1513                 removeDups(CName, GuidCNameX64)
1514                 removeDups(CName, GuidCNameIPF)
1515                 removeDups(CName, GuidCNameEBC)
1516
1517                 if "IA32" in Archs:
1518                     PpiCNameIa32.insert(0, "  %-45s # PPI_NOTIFY %s" % (CName, Usage))
1519                 if "X64" in Archs:
1520                     PpiCNameX64.insert(0,  "  %-45s # PPI_NOTIFY %s" % (CName, Usage))
1521                 if "IPF" in Archs:
1522                     PpiCNameIPF.insert(0,  "  %-45s # PPI_NOTIFY %s" % (CName, Usage))
1523                 if "EBC" in Archs:
1524                     PpiCNameEBC.insert(0,  "  %-45s # PPI_NOTIFY %s" % (CName, Usage))
1525                 if "ALL" in Archs:
1526                     PpiCName.insert(0,     "  %-45s # PPI_NOTIFY %s" % (CName, Usage))
1527             except:
1528                 pass
1529
1530
1531     """ Get the PCD entries now """
1532     PcdCoded = "/ModuleSurfaceArea/PcdCoded/PcdEntry"
1533     PcdList = []
1534     try:
1535         PcdList = XmlList(Msa, PcdCoded)
1536     except:
1537         pass
1538
1539     (PcdFF, PcdFFIa32, PcdFFX64, PcdFFIpf, PcdFFEbc) = ([],[],[],[],[])
1540     (PcdFAB, PcdFABIa32, PcdFABX64, PcdFABIpf, PcdFABEbc) = ([],[],[],[],[])
1541     (PcdPIM, PcdPIMIa32, PcdPIMX64, PcdPIMIpf, PcdPIMEbc) = ([],[],[],[],[])
1542     (PcdDY, PcdDYIa32, PcdDYX64, PcdDYIpf, PcdDYEbc) = ([],[],[],[],[])
1543     (PcdDYE, PcdDYEIa32, PcdDYEX64, PcdDYEIpf, PcdDYEEbc) = ([],[],[],[],[])
1544
1545     if (len(PcdList) > 0):
1546         for Pcd in PcdList:
1547             Archs = ""
1548             Usage = ""
1549             CName = ""
1550             DefVal = ""
1551
1552             try:
1553                 Archs = Pcd.getAttribute("SupArchList")
1554             except:
1555                 pass
1556
1557             Archs = chkArch(Archs)
1558
1559             try:
1560                 ItemType = Pcd.getAttribute("PcdItemType")
1561             except:
1562                 pass
1563
1564             try:
1565                 CName = str(XmlElementData(Pcd.getElementsByTagName("C_Name")[0]))
1566             except:
1567                 raise SyntaxError, "ERROR: MSA has a PCD with no Pcd C_Name defined"
1568
1569             try:
1570                 TSGC = str(XmlElementData(Pcd.getElementsByTagName("TokenSpaceGuidCName")[0]))
1571             except:
1572                 pass
1573
1574             try:
1575                 DefVal = str(XmlElementData(Pcd.getElementsByTagName("DefaultValue")))
1576             except:
1577                 pass
1578
1579             if (len(DefVal) > 0):
1580                 line = TSGC + "." + CName + "|" + DefVal
1581             else:
1582                 line = TSGC + "." + CName
1583
1584             if (ItemType == "FEATURE_FLAG"):
1585                 if ("IA32" in Archs):
1586                     PcdFFIa32.insert(0, line)
1587                 if ("IPF" in Archs):
1588                     PcdFFIpf.insert(0, line)
1589                 if ("X64" in Archs):
1590                     PcdFFX64.insert(0, line)
1591                 if ("EBC" in Archs):
1592                     PcdFFEbc.insert(0, line)
1593                 if ("ALL" in Archs):
1594                     PcdFF.insert(0, line)
1595             elif (ItemType == "FIXED_AT_BUILD"):
1596                 if ("IA32" in Archs):
1597                     PcdFABIa32.insert(0, line)
1598                 if ("IPF" in Archs):
1599                     PcdFABIpf.insert(0, line)
1600                 if ("X64" in Archs):
1601                     PcdFABX64.insert(0, line)
1602                 if ("EBC" in Archs):
1603                     PcdFABEbc.insert(0, line)
1604                 if ("ALL" in Archs):
1605                     PcdFAB.insert(0, line)
1606             elif (ItemType == "PATCHABLE_IN_MODULE"):
1607                 if ("IA32" in Archs):
1608                     PcdPIMIa32.insert(0, line)
1609                 if ("IPF" in Archs):
1610                     PcdPIMIpf.insert(0, line)
1611                 if ("X64" in Archs):
1612                     PcdPIMX64.insert(0, line)
1613                 if ("EBC" in Archs):
1614                     PcdPIMEbc.insert(0, line)
1615                 if ("ALL" in Archs):
1616                     PcdFAB.insert(0, line)
1617             elif (ItemType == "DYNAMIC_EX"):
1618                 if ("IA32" in Archs):
1619                     PcdDYEIa32.insert(0, line)
1620                 if ("IPF" in Archs):
1621                     PcdDYEIpf.insert(0, line)
1622                 if ("X64" in Archs):
1623                     PcdDYEX64.insert(0, line)
1624                 if ("EBC" in Archs):
1625                     PcdDYEEbc.insert(0, line)
1626                 if ("ALL" in Archs):
1627                     PcdDYE.insert(0, line)
1628             else:
1629                 if ("IA32" in Archs):
1630                     PcdDYIa32.insert(0, line)
1631                 if ("IPF" in Archs):
1632                     PcdDYIpf.insert(0, line)
1633                 if ("X64" in Archs):
1634                     PcdDYX64.insert(0, line)
1635                 if ("EBC" in Archs):
1636                     PcdDYEbc.insert(0, line)
1637                 if ("ALL" in Archs):
1638                     PcdDY.insert(0, line)
1639
1640     """ User Extensions Section """
1641     UEList = []
1642     UESectionList = []
1643     try:
1644         UESectionList = XmlList(Msa, "/ModuleSurfaceArea/UserExtensions")
1645     except:
1646         pass
1647
1648     if (len(UESectionList) > 0):
1649         for UE in UESectionList[:]:
1650             UserId = ""
1651             Identifier = ""
1652             Value = ""
1653
1654             try:
1655                 UserId = str(UE.getAttribute("UserID"))
1656             except:
1657                 raise SyntaxError, "ERROR: Malformed MSA, No UserID Specified in UserExtensions element"
1658
1659             try:
1660                 Identifier = str(UE.getAttribute("Identifier"))
1661             except:
1662                 raise SyntaxError, "ERROR: Malformed MSA, No Identifier Specified in UserExtensions element"
1663
1664             if (options.debug):
1665                 print "FOUND A UE Element", UserId, Identifier
1666
1667             try:
1668                 Value = str(XmlElementData(UE))
1669             except:
1670                 pass
1671
1672             Entry = [UserId, Identifier, Value]
1673             UEList.insert(0, Entry)
1674
1675
1676
1677     if (len(Externlist) > 0):
1678         AutoGenSource = ""
1679         AutoGenDefinitionSource = ""
1680         AutoGenEntryPointSource = ""
1681         AutoGenUnloadSource = ""
1682         if (len(AutoGenDriverModel) > 0):
1683             AutoGenCode = AddDriverBindingProtocolStatement(AutoGenDriverModel)
1684             AutoGenEntryPointSource += AutoGenCode[0]
1685             AutoGenUnloadSource += AutoGenCode[1]
1686             AutoGenDeclaration += AutoGenCode[3]
1687
1688
1689         if (len(AutoGenExitBootServices) > 0):
1690             print "[Warning] Please manually add Create Event statement for Exit Boot Service Event!"
1691             if options.event:
1692                 AutoGenCode = AddBootServiceEventStatement(AutoGenExitBootServices)
1693                 AutoGenEntryPointSource += AutoGenCode[0]
1694                 AutoGenUnloadSource += AutoGenCode[1]
1695                 AutoGenDefinitionSource += AutoGenCode[2]
1696                 AutoGenDeclaration += AutoGenCode[3]
1697
1698         if (len(AutoGenVirtualAddressChanged) > 0):
1699             print "[Warning] Please manually add Create Event statement for Virtual Address Change Event!"
1700             if options.event:
1701                 AutoGenCode = AddVirtualAddressEventStatement(AutoGenVirtualAddressChanged)
1702                 AutoGenEntryPointSource += AutoGenCode[0]
1703                 AutoGenUnloadSource += AutoGenCode[1]
1704                 AutoGenDefinitionSource += AutoGenCode[2]
1705                 AutoGenDeclaration += AutoGenCode[3]
1706
1707         if AutoGenEntryPointSource != "":
1708             OldEntryPoint = AutoGenEntryPoint
1709             AutoGenCode   = AddNewEntryPointContentsStatement(BaseName, AutoGenEntryPoint, AutoGenEntryPointSource)
1710             AutoGenEntryPoint = AutoGenCode[0]
1711             AutoGenEntryPointSource = AutoGenCode[1]
1712             AutoGenDeclaration += AutoGenCode[2]
1713
1714
1715         if AutoGenEntryPoint != "":
1716             DriverModules.insert(0, "  %-30s = %s\n" % ("ENTRY_POINT" , AutoGenEntryPoint))
1717
1718         AutoGenSource = AutoGenDefinitionSource + AutoGenEntryPointSource + AutoGenUnloadSource
1719
1720         if (lFlag):
1721             DefinesComments.append("#\n")
1722
1723         if (Flag and len(DefinesComments) > 0):
1724             DefinesComments.insert(0, "\n#\n# The following information is for reference only and not required by the build tools.\n#\n")
1725
1726         if (options.debug and options.verbose > 2):
1727             if (len(DriverModules) > 0):
1728                 print DriverModules
1729             if (len(LibraryModules) > 0):
1730                 print LibraryModules
1731             if (len(DefinesComments) > 0):
1732                 print DefinesComments
1733
1734     Depex = []
1735     DepexIa32 = []
1736     DepexX64 = []
1737     DepexIpf = []
1738     DepexEbc = []
1739
1740     for DxsFile, Archs in AutoGenDxsFiles:
1741         fileContents = openSourceFile(AutoGenModuleFolder, DxsFile)
1742         Contents, Unresolved = TranslateDpxSection(fileContents)
1743         if Contents == "":
1744             print "[warning] Cannot read dxs expression"
1745         else:
1746             if (len(Unresolved) > 0):
1747                 print "[warning] Guid Macro(s): %s cannot find corresponding cNames. Please resolve it in [depex] section in extened inf" % ",".join(Unresolved)
1748
1749             if ("IA32" in Archs):
1750                 DepexIa32.insert(0, Contents)
1751             if ("IPF" in Archs):
1752                 DepexIpf.insert(0, Contents)
1753             if ("X64" in Archs):
1754                 DepexX64.insert(0, Contents)
1755             if ("EBC" in Archs):
1756                 DepexEbc.insert(0, Contents)
1757             if ("ALL" in Archs):
1758                 Depex.insert(0, Contents)
1759
1760     AutoGenSourceHeaderFormat = "/**@file\n  %s\n\n  %s\n  %s\n  %s\n**/\n\n%s"
1761     includeCommonHeaderFileStatement = "#include \"%s\"" % commonHeaderFilename
1762
1763     AutoGenHeader += AddSystemIncludeStatement(ModType, AutoGenPackage)
1764     AutoGenHeader += AddGuidStatement(AutoGenGuid)
1765     AutoGenHeader += AddLibraryClassStatement(AutoGenLibClass)
1766
1767     if options.manual:
1768         saveSourceFile(AutoGenModuleFolder, "CommonHeader.txt", AutoGenHeader)
1769     else:
1770
1771         commonHeaderFilename2 = re.sub("(?=[^a-z])", "_", commonHeaderFilename)
1772         commonHeaderFilename2 = "_" + commonHeaderFilename2.replace(".", "").upper() + "_"
1773         briefDiscription = "Common header file shared by all source files."
1774         detailedDiscription = "This file includes package header files, library classes and protocol, PPI & GUID definitions.\n"
1775         AutoGenHeader += AutoGenDeclaration
1776         AutoGenHeader = "#ifndef %s\n#define %s\n\n\n%s\n#endif\n" % (commonHeaderFilename2, commonHeaderFilename2, AutoGenHeader)
1777         AutoGenHeader = AutoGenSourceHeaderFormat % (briefDiscription, detailedDiscription, CopyRight, License, AutoGenHeader)
1778         saveSourceFile(AutoGenModuleFolder, commonHeaderFilename, AutoGenHeader)
1779         SrcFilenames.append(commonHeaderFilename)
1780
1781         for source in AutoGenSourceFiles:
1782             extension = os.path.splitext(source)[1]
1783             if extension == ".c":
1784                 sourceContents = openSourceFile(AutoGenModuleFolder, source)
1785                 sourceContents = AddCommonInclusionStatement(sourceContents, includeCommonHeaderFileStatement)
1786                 saveSourceFile(AutoGenModuleFolder, source, sourceContents)
1787
1788
1789     if AutoGenSource != "":
1790         briefDiscription = "Entry Point Source file."
1791         detailedDiscription = "This file contains the user entry point \n"
1792         AutoGenSource = AutoGenSourceHeaderFormat % (briefDiscription, detailedDiscription, CopyRight, License, AutoGenSource)
1793         AutoGenSource = AddCommonInclusionStatement(AutoGenSource, includeCommonHeaderFileStatement)
1794
1795         saveSourceFile(AutoGenModuleFolder, entryPointFilename, AutoGenSource)
1796         SrcFilenames.append(entryPointFilename)
1797
1798
1799
1800
1801     # DONE Getting data, now output it in INF format.
1802     Msa.unlink()
1803     Fdb.unlink()
1804     Output = []
1805
1806     """ Print the converted data format """
1807     head =  "#/** @file\n"
1808     head += "# " + str(Abstract) + "\n#\n"
1809     head += "# " + str(Description).strip().replace("\n", "\n# ") + "\n"
1810     head += "# " + str(CopyRight) + "\n#\n"
1811     head += "#  " + str(License).replace("\n", "\n# ").replace("  ", " ").strip() + "\n#\n"
1812     head += "#\n#**/\n"
1813
1814     Output.append(head)
1815     if (options.debug):
1816         print head
1817
1818 ##    Defines = "\n" + "#"*80+ "\n#\n"
1819 ##    if (BinModule != "false"):
1820 ##        Defines += "# Defines Section - statements that will be processed to generate a binary image.\n"
1821 ##    else:
1822 ##        Defines += "# Defines Section - statements that will be processed to create a Makefile.\n"
1823 ##    Defines += "#\n" + "#"*80 + "\n"
1824
1825     Defines  = "\n"
1826     Defines += "[Defines]\n"
1827     Defines += "  %-30s = %s\n" % ("INF_VERSION", "0x00010005")
1828     Defines += "  %-30s = %s\n" % ("BASE_NAME", BaseName)
1829     Defines += "  %-30s = %s\n" % ("FILE_GUID", GuidValue)
1830     Defines += "  %-30s = %s\n" % ("MODULE_TYPE", ModType)
1831     Defines += "  %-30s = %s\n" % ("VERSION_STRING", VerString)
1832
1833     if (len(PcdIsDriver) > 0):
1834         Defines += "  %-30s = %s\n" %  ("PCD_DRIVER", PcdIsDriver)
1835
1836     if (len(IamLibrary) > 0):
1837         lcstr = ""
1838         for lc in IamLibrary[:]:
1839             lcstr += lc + " "
1840             Defines += "  %-30s = %s" %  ("LIBRARY_CLASS", lcstr)
1841         Defines += "\n"
1842
1843     if (len(SpecList) > 0):
1844         for spec in SpecList[:]:
1845             (specname, specval) = spec.split()
1846             Defines += "  %-30s = %s\n" %  (specname, specval)
1847         Defines += "\n"
1848
1849     if (len(DriverModules) > 0):
1850         for line in DriverModules[:]:
1851             Defines += line
1852
1853     if (len(LibraryModules) > 0):
1854         for line in LibraryModules[:]:
1855             Defines += line
1856
1857     if (len(DefinesComments) > 0):
1858         for line in DefinesComments[:]:
1859             Defines += line
1860
1861     Output.append(Defines)
1862
1863     if (options.debug):
1864         print Defines
1865
1866     if (BinModule != "false"):
1867         """ Binary Module, so sources are really binaries. """
1868 ##        Sources = "\n" + "#"*80 + "\n#\n"
1869 ##        Sources += "# Binaries Section - list of binary files that are required for the build\n# to succeed.\n"
1870 ##        Sources += "#\n" + "#"*80 + "\n\n"
1871         Sources = "\n"
1872         if ModType == "UEFI_APPLICATION":
1873             FileType = "UEFI_APP"
1874             if options.verbose > 0:
1875                 print "WARNING: Binary Module: %s is assuming UEFI_APPLICATION file type." % (options.filename)
1876         else:
1877             FileType = "FV"
1878             if options.verbose > 0:
1879                 print "WARNING: Binary Module: %s is assuming FV file type." % (options.filename)
1880
1881         if (len(SrcFilenames) > 0):
1882             Sources += "[Binaries.common]\n"
1883             for file in SrcFilenames[:]:
1884                 file = file.replace("\\", "/")
1885                 Sources += "  " + FileType + "|" + file + "\n"
1886             Sources += "\n"
1887
1888         if (len(SrcFilenamesIa32) > 0):
1889             Sources += "[Binaries.Ia32]\n"
1890             for file in SrcFilenamesIa32[:]:
1891                 file = file.replace("\\", "/")
1892                 Sources += "  " + FileType + "|" + file + "\n"
1893             Sources += "\n"
1894
1895         if (len(SrcFilenamesX64) > 0):
1896             Sources += "[Binaries.X64]\n"
1897             for file in SrcFilenamesX64[:]:
1898                 file = file.replace("\\", "/")
1899                 Sources += "  " + FileType + "|" + file + "\n"
1900             Sources += "\n"
1901
1902         if (len(SrcFilenamesIpf) > 0):
1903             Sources += "[Binaries.IPF]\n"
1904             for file in SrcFilenamesIpf[:]:
1905                 file = file.replace("\\", "/")
1906                 Sources += "  " + FileType + "|" + file + "\n"
1907             Sources += "\n"
1908
1909         if (len(SrcFilenamesEbc) > 0):
1910             Sources += "[Binaries.EBC]\n"
1911             for file in SrcFilenamesEbc[:]:
1912                 file = file.replace("\\", "/")
1913                 Sources += "  " + FileType + "|" + file + "\n"
1914             Sources += "\n"
1915
1916         Output.append(Sources)
1917         if (options.debug):
1918             print Sources
1919     else:
1920 ##        Sources = "\n" + "#"*80 + "\n#\n"
1921 ##        Sources += "# Sources Section - list of files that are required for the build to succeed.\n"
1922 ##        Sources += "#\n" + "#"*80 + "\n\n"
1923         Sources = "\n"
1924         if (len(SrcFilenames) > 0):
1925             Sources += "[Sources.common]\n"
1926             for file in SrcFilenames[:]:
1927                 Sources += "  " + file + "\n"
1928             Sources += "\n"
1929
1930         if (len(SrcFilenamesIa32) > 0):
1931             Sources += "[Sources.Ia32]\n"
1932             for file in SrcFilenamesIa32[:]:
1933                 Sources += "  " + file + "\n"
1934             Sources += "\n"
1935
1936         if (len(SrcFilenamesX64) > 0):
1937             Sources += "[Sources.X64]\n"
1938             for file in SrcFilenamesX64[:]:
1939                 Sources += "  " + file + "\n"
1940             Sources += "\n"
1941
1942         if (len(SrcFilenamesIpf) > 0):
1943             Sources += "[Sources.IPF]\n"
1944             for file in SrcFilenamesIpf[:]:
1945                 Sources += "  " + file + "\n"
1946             Sources += "\n"
1947
1948         if (len(SrcFilenamesEbc) > 0):
1949             Sources += "[Sources.EBC]\n"
1950             for file in SrcFilenamesEbc[:]:
1951                 Sources += "  " + file + "\n"
1952             Sources += "\n"
1953
1954         Output.append(Sources)
1955         if (options.debug):
1956             print Sources
1957
1958
1959     includeLine = ""
1960     if ((len(HeaderLocations) > 0) or (len(Dirs) > 0)):
1961         allLcs = set(LibClassList + LibClassListIa32 + LibClassListX64 + LibClassListIpf + LibClassListEbc + Dirs)
1962         Lines = []
1963         for line in HeaderLocations[:]:
1964             for Lc in allLcs:
1965                 (keyword, header) = line.split("|")
1966                 if Lc in keyword:
1967                     if (options.debug):
1968                         print "FOUND", Lc, "in", keyword, "header", header
1969                     path = "$(WORKSPACE)/" + os.path.split(header)[0]
1970                     Lines.insert(0, path.strip())
1971         Includes = ""
1972 ##        Includes = "\n" + "#"*80 + "\n#\n"
1973 ##        Includes += "# Includes Section - list of Include locations that are required for\n"
1974 ##        Includes += "#                    this module.\n"
1975 ##        Includes += "#\n" + "#"*80 + "\n\n"
1976 ##        Includes += "[Includes]\n"
1977 ##        includeLines = []
1978 ##        includeLines = set(Lines)
1979 ##        if (options.debug):
1980 ##            print "There are", len(includeLines), "entries"
1981 ##        for Line in includeLines:
1982 ##            Includes += "  " + str(Line).strip().replace("\\", "/") + "\n"
1983
1984         Output.append(Includes)
1985         if (options.debug):
1986             print Includes
1987
1988
1989
1990     if ((len(PkgList) + len(PkgListIa32) + len(PkgListX64) + len(PkgListIpf) + len(PkgListEbc)) > 0):
1991         """ We do this if and only if we have Package Dependencies """
1992 ##        PackageDepends = "\n" + "#"*80 + "\n#\n"
1993 ##        PackageDepends += "# Package Dependency Section - list of Package files that are required for\n"
1994 ##        PackageDepends += "#                              this module.\n"
1995 ##        PackageDepends += "#\n" + "#"*80 + "\n\n"
1996         PackageDepends = "\n"
1997         if (len(PkgList) > 0):
1998             PackageDepends += "[Packages]\n"
1999             for lc in PkgList[:]:
2000                 lc = lc.replace("\\", "/")
2001                 PackageDepends += "  " + lc + "\n"
2002             PackageDepends += "\n"
2003
2004         if (len(PkgListIa32) > 0):
2005             PackageDepends += "[Packages.IA32]\n"
2006             for lc in PkgListIa32[:]:
2007                 lc = lc.replace("\\", "/")
2008                 PackageDepends += "  " + lc + "\n"
2009             PackageDepends += "\n"
2010
2011         if (len(PkgListX64) > 0):
2012             PackageDepends += "[Packages.X64]\n"
2013             for lc in PkgListX64[:]:
2014                 lc = lc.replace("\\", "/")
2015                 PackageDepends += "  " + lc + "\n"
2016             PackageDepends += "\n"
2017
2018         if (len(PkgListIpf) > 0):
2019             PackageDepends += "[Packages.IPF]\n"
2020             for lc in PkgListIpf[:]:
2021                 lc = lc.replace("\\", "/")
2022                 PackageDepends += "  " + lc + "\n"
2023             PackageDepends += "\n"
2024
2025         if (len(PkgListEbc) > 0):
2026             PackageDepends += "[Packages.EBC]\n"
2027             for lc in PkgListEbc[:]:
2028                 lc = lc.replace("\\", "/")
2029                 PackageDepends += "  " + lc + "\n"
2030             PackageDepends += "\n"
2031
2032         Output.append(PackageDepends)
2033         if (options.debug):
2034             print PackageDepends
2035
2036     if ((len(LibClassList) + len(LibClassListIa32) + len(LibClassListX64) + len(LibClassListIpf) + len(LibClassListEbc)) > 0):
2037 ##        LibraryClasses = "\n" + "#"*80 + "\n#\n"
2038 ##        LibraryClasses += "# Library Class Section - list of Library Classes that are required for\n"
2039 ##        LibraryClasses += "#                         this module.\n"
2040 ##        LibraryClasses += "#\n" + "#"*80 + "\n\n"
2041
2042         LibraryClasses = "\n"
2043         if (len(LibClassList) > 0):
2044             LibraryClasses += "[LibraryClasses]\n"
2045             for lc in LibClassList[:]:
2046               LibraryClasses += "  " + lc + "\n"
2047             LibraryClasses += "\n"
2048
2049         if (len(LibClassListIa32) > 0):
2050             LibraryClasses += "[LibraryClasses.IA32]\n"
2051             for lc in LibClassListIa32[:]:
2052                 LibraryClasses += "  " + lc + "\n"
2053             LibraryClasses += "\n"
2054
2055         if (len(LibClassListX64) > 0):
2056             LibraryClasses += "[LibraryClasses.X64]\n"
2057             for lc in LibClassListX64[:]:
2058                 LibraryClasses += "  " + lc + "\n"
2059             LibraryClasses += "\n"
2060
2061         if (len(LibClassListIpf) > 0):
2062             LibraryClasses += "[LibraryClasses.IPF]\n"
2063             for lc in LibClassListIpf[:]:
2064                 LibraryClasses += "  " + lc + "\n"
2065             LibraryClasses += "\n"
2066
2067         if (len(LibClassListEbc) > 0):
2068             LibraryClasses += "[LibraryClasses.EBC]\n"
2069             for lc in LibClassListEbc[:]:
2070                 LibraryClasses += "  " + lc + "\n"
2071             LibraryClasses += "\n"
2072
2073         Output.append(LibraryClasses)
2074         if (options.debug):
2075             print LibraryClasses
2076
2077     # Print the Guids sections
2078     if (len(GuidCName) + len(GuidCNameIa32) + len(GuidCNameIPF) + len(GuidCNameX64) + len(GuidCNameEBC)) > 0:
2079 ##        GuidSection = "\n" + "#"*80 + "\n#\n"
2080 ##        GuidSection += "# Guid C Name Section - list of Guids that this module uses or produces.\n"
2081 ##        GuidSection += "#\n" + "#"*80 + "\n\n"
2082         GuidSection = "\n"
2083         if (len(GuidCName) > 0):
2084             GuidSection += "[Guids]\n"
2085             for Guid in GuidCName[:]:
2086                 GuidSection += Guid + "\n"
2087             GuidSection += "\n"
2088
2089         if (len(GuidCNameIa32) > 0):
2090             GuidSection += "[Guids.IA32]\n"
2091             for Guid in GuidCNameIa32[:]:
2092                 GuidSection += Guid + "\n"
2093             GuidSection += "\n"
2094
2095         if (len(GuidCNameX64) > 0):
2096             GuidSection += "[Guids.X64]\n"
2097             for Guid in GuidCNameX64[:]:
2098                 GuidSection += Guid + "\n"
2099             GuidSection += "\n"
2100
2101         if (len(GuidCNameIPF) > 0):
2102             GuidSection += "[Guids.IPF]\n"
2103             for Guid in GuidCNameIPF[:]:
2104                 GuidSection += Guid + "\n"
2105             GuidSection += "\n"
2106
2107         if (len(GuidCNameEBC) > 0):
2108             GuidSection += "[Guids.EBC]\n"
2109             for Guid in GuidCNameEBC[:]:
2110                 GuidSection += Guid + "\n"
2111             GuidSection += "\n"
2112
2113         Output.append(GuidSection)
2114         if (options.debug and options.verbose > 1):
2115             print GuidSection
2116
2117     # Print the Protocol sections
2118     if (len(ProtocolCName) + len(ProtocolCNameIa32) + len(ProtocolCNameIPF) + len(ProtocolCNameX64) + len(ProtocolCNameEBC)) > 0:
2119 ##        ProtocolsSection = "\n" + "#"*80 + "\n#\n"
2120 ##        ProtocolsSection += "# Protocol C Name Section - list of Protocol and Protocol Notify C Names\n"
2121 ##        ProtocolsSection += "#                           that this module uses or produces.\n"
2122 ##        ProtocolsSection += "#\n" + "#"*80 + "\n\n"
2123
2124         ProtocolsSection = "\n"
2125         if (len(ProtocolCName) > 0):
2126             ProtocolsSection += "[Protocols]\n"
2127             for Guid in ProtocolCName[:]:
2128                 ProtocolsSection += Guid + "\n"
2129             ProtocolsSection += "\n"
2130
2131         if (len(ProtocolCNameIa32) > 0):
2132             ProtocolsSection += "[Protocols.IA32]\n"
2133             for Guid in ProtocolCNameIa32[:]:
2134                 ProtocolsSection += Guid + "\n"
2135             ProtocolsSection += "\n"
2136
2137         if (len(ProtocolCNameX64) > 0):
2138             ProtocolsSection += "[Protocols.X64]\n"
2139             for Guid in ProtocolCNameX64[:]:
2140                 ProtocolsSection += Guid + "\n"
2141             ProtocolsSection += "\n"
2142
2143         if (len(ProtocolCNameIPF) > 0):
2144             ProtocolsSection += "[Protocols.IPF]\n"
2145             for Guid in ProtocolCNameIPF[:]:
2146                 ProtocolsSection += Guid + "\n"
2147             ProtocolsSection += "\n"
2148
2149         if (len(ProtocolCNameEBC) > 0):
2150             ProtocolsSection += "[Protocols.EBC]\n"
2151             for Guid in ProtocolCNameEBC[:]:
2152                 ProtocolsSection += Guid + "\n"
2153             ProtocolsSection += "\n"
2154
2155         Output.append(ProtocolsSection)
2156         if (options.debug):
2157           print ProtocolsSection
2158
2159     # Print the PPI sections
2160     if (len(PpiCName) + len(PpiCNameIa32) + len(PpiCNameIPF) + len(PpiCNameX64) + len(PpiCNameEBC)) > 0:
2161 ##        PpiSection = "\n" + "#"*80 + "\n#\n"
2162 ##        PpiSection += "# PPI C Name Section - list of PPI and PPI Notify C Names that this module\n"
2163 ##        PpiSection += "#                      uses or produces.\n"
2164 ##        PpiSection += "#\n" + "#"*80 + "\n\n"
2165
2166         PpiSection = "\n"
2167         if (len(PpiCName) > 0):
2168             PpiSection += "[Ppis]\n"
2169             for Guid in PpiCName[:]:
2170                 PpiSection += Guid + "\n"
2171             PpiSection += "\n"
2172
2173         if (len(PpiCNameIa32) > 0):
2174             PpiSection += "[Ppis.IA32]\n"
2175             for Guid in PpiCNameIa32[:]:
2176                 PpiSection += Guid + "\n"
2177             PpiSection += "\n"
2178
2179         if (len(PpiCNameX64) > 0):
2180             PpiSection += "[Ppis.X64]\n"
2181             for Guid in PpiCNameX64[:]:
2182                 PpiSection += Guid + "\n"
2183             PpiSection += "\n"
2184
2185         if (len(PpiCNameIPF) > 0):
2186             PpiSection += "[Ppis.IPF]\n"
2187             for Guid in PpiCNameIPF[:]:
2188                 PpiSection += Guid + "\n"
2189             PpiSection += "\n"
2190
2191         if (len(PpiCNameEBC) > 0):
2192             PpiSection += "[Ppis.EBC]\n"
2193             for Guid in PpiCNameEBC[:]:
2194                 PpiSection += Guid + "\n"
2195             PpiSection += "\n"
2196
2197         Output.append(PpiSection)
2198         if (options.debug):
2199             print PpiSection
2200
2201     # Print the PCD sections
2202     if ((len(PcdFF)+len(PcdFFIa32)+len(PcdFFX64)+len(PcdFFIpf)+len(PcdFFEbc)) > 0):
2203 ##        FeatureFlagSection = "\n" + "#"*80 + "\n#\n"
2204 ##        FeatureFlagSection += "# Pcd FEATURE_FLAG - list of PCDs that this module is coded for.\n"
2205 ##        FeatureFlagSection += "#\n" + "#"*80 + "\n\n"
2206
2207         FeatureFlagSection = "\n"
2208         if (len(PcdFF) > 0):
2209             FeatureFlagSection += "[FeaturePcd.common]\n"
2210             for Entry in PcdFF[:]:
2211                 FeatureFlagSection += "  " + Entry + "\n"
2212             FeatureFlagSection += "\n"
2213         if (len(PcdFFIa32) > 0):
2214             FeatureFlagSection += "[FeaturePcd.IA32]\n"
2215             for Entry in PcdFFIa32[:]:
2216                 FeatureFlagSection += "  " + Entry + "\n"
2217             FeatureFlagSection += "\n"
2218         if (len(PcdFFX64) > 0):
2219             FeatureFlagSection += "[FeaturePcd.X64]\n"
2220             for Entry in PcdFFX64[:]:
2221                 FeatureFlagSection += "  " + Entry + "\n"
2222             FeatureFlagSection += "\n"
2223         if (len(PcdFFIpf) > 0):
2224             FeatureFlagSection += "[PcdsFeatureFlag.IPF]\n"
2225             for Entry in PcdFFIpf[:]:
2226                 FeatureFlagSection += "  " + Entry + "\n"
2227             FeatureFlagSection += "\n"
2228         if (len(PcdFFEbc) > 0):
2229             FeatureFlagSection += "[FeaturePcd.EBC]\n"
2230             for Entry in PcdFFEbc[:]:
2231                 FeatureFlagSection += "  " + Entry + "\n"
2232             FeatureFlagSection += "\n"
2233
2234         Output.append(FeatureFlagSection)
2235         if (options.debug):
2236           print FeatureFlagSection
2237
2238     if ((len(PcdFAB)+len(PcdFABIa32)+len(PcdFABX64)+len(PcdFABIpf)+len(PcdFABEbc)) > 0):
2239 ##        FixedAtBuildSection = "\n" + "#"*80 + "\n#\n"
2240 ##        FixedAtBuildSection += "# Pcd FIXED_AT_BUILD - list of PCDs that this module is coded for.\n"
2241 ##        FixedAtBuildSection += "#\n" + "#"*80 + "\n\n"
2242
2243         FixedAtBuildSection = "\n"
2244         if (len(PcdFAB) > 0):
2245             FixedAtBuildSection += "[FixedPcd.common]\n"
2246             for Entry in PcdFAB[:]:
2247                 FixedAtBuildSection += "  " + Entry + "\n"
2248             FixedAtBuildSection += "\n"
2249         if (len(PcdFABIa32) > 0):
2250             FixedAtBuildSection += "[FixedPcd.IA32]\n"
2251             for Entry in PcdFABIa32[:]:
2252                 FixedAtBuildSection += "  " + Entry + "\n"
2253             FixedAtBuildSection += "\n"
2254         if (len(PcdFABX64) > 0):
2255             FixedAtBuildSection += "[FixedPcd.X64]\n"
2256             for Entry in PcdFABX64[:]:
2257                 FixedAtBuildSection += "  " + Entry + "\n"
2258             FixedAtBuildSection += "\n"
2259         if (len(PcdFABIpf) > 0):
2260             FixedAtBuildSection += "[FixedPcd.IPF]\n"
2261             for Entry in PcdFABIpf[:]:
2262                 FixedAtBuildSection += "  " + Entry + "\n"
2263             FixedAtBuildSection += "\n"
2264         if (len(PcdFABEbc) > 0):
2265             FixedAtBuildSection += "[FixedPcd.EBC]\n"
2266             for Entry in PcdFABEbc[:]:
2267                 FixedAtBuildSection += "  " + Entry + "\n"
2268             FixedAtBuildSection += "\n"
2269
2270         Output.append(FixedAtBuildSection)
2271         if (options.debug):
2272             print FixedAtBuildSection
2273
2274     if ((len(PcdPIM)+len(PcdPIMIa32)+len(PcdPIMX64)+len(PcdPIMIpf)+len(PcdPIMEbc)) > 0):
2275 ##        PatchableInModuleSection = "\n" + "#"*80 + "\n#\n"
2276 ##        PatchableInModuleSection += "# Pcd PATCHABLE_IN_MODULE - list of PCDs that this module is coded for.\n"
2277 ##        PatchableInModuleSection += "#\n" + "#"*80 + "\n\n"
2278
2279         PatchableInModuleSection = "\n"
2280         if (len(PcdPIM) > 0):
2281             PatchableInModuleSection += "[PatchPcd.common]\n"
2282             for Entry in PcdPIM[:]:
2283                 PatchableInModuleSection += "  " + Entry + "\n"
2284             PatchableInModuleSection += "\n"
2285         if (len(PcdPIMIa32) > 0):
2286             PatchableInModuleSection += "[PatchPcd.IA32]\n"
2287             for Entry in PcdPIMIa32[:]:
2288                 PatchableInModuleSection += "  " + Entry + "\n"
2289             PatchableInModuleSection += "\n"
2290         if (len(PcdPIMX64) > 0):
2291             PatchableInModuleSection += "[PatchPcd.X64]\n"
2292             for Entry in PcdPIMX64[:]:
2293                 PatchableInModuleSection += "  " + Entry + "\n"
2294             PatchableInModuleSection += "\n"
2295         if (len(PcdPIMIpf) > 0):
2296             PatchableInModuleSection += "[PatchPcd.IPF]\n"
2297             for Entry in PcdPIMIpf[:]:
2298                 PatchableInModuleSection += "  " + Entry + "\n"
2299             PatchableInModuleSection += "\n"
2300         if (len(PcdPIMEbc) > 0):
2301             PatchableInModuleSection += "[PatchPcd.EBC]\n"
2302             for Entry in PcdPIMEbc[:]:
2303                 PatchableInModuleSection += "  " + Entry + "\n"
2304             PatchableInModuleSection += "\n"
2305
2306         Output.append(PatchableInModuleSection)
2307         if (options.debug):
2308             print PatchableInModuleSection
2309
2310     if ((len(PcdDYE)+len(PcdDYEIa32)+len(PcdDYEX64)+len(PcdDYEIpf)+len(PcdDYEEbc)) > 0):
2311 ##        DynamicExSection = "\n" + "#"*80 + "\n#\n"
2312 ##        DynamicExSection += "# Pcd DYNAMIC_EX - list of PCDs that this module is coded for.\n"
2313 ##        DynamicExSection += "#\n" + "#"*80 + "\n\n"
2314
2315         DynamicExSection = "\n"
2316         if (len(PcdDYE) > 0):
2317             DynamicExSection += "[PcdEx.common]\n"
2318             for Entry in PcdDYE[:]:
2319                 DynamicExSection += "  " + Entry + "\n"
2320             DynamicExSection += "\n"
2321         if (len(PcdDYEIa32) > 0):
2322             DynamicExSection += "[PcdEx.IA32]\n"
2323             for Entry in PcdDYEIa32[:]:
2324                 DynamicExSection += "  " + Entry + "\n"
2325             DynamicExSection += "\n"
2326         if (len(PcdDYEX64) > 0):
2327             DynamicExSection += "[PcdEx.X64]\n"
2328             for Entry in PcdDYEX64[:]:
2329                 DynamicExSection += "  " + Entry + "\n"
2330             DynamicExSection += "\n"
2331         if (len(PcdDYEIpf) > 0):
2332             DynamicExSection += "[PcdEx.IPF]\n"
2333             for Entry in PcdDYEIpf[:]:
2334                 DynamicExSection += "  " + Entry + "\n"
2335             DynamicExSection += "\n"
2336         if (len(PcdDYEEbc) > 0):
2337             DynamicExSection += "[PcdEx.EBC]\n"
2338             for Entry in PcdDYEEbc[:]:
2339                 DynamicExSection += "  " + Entry + "\n"
2340             DynamicExSection += "\n"
2341
2342         Output.append(DynamicExSection)
2343         if (options.debug):
2344             print DynamicExSection
2345
2346     if ((len(PcdDY)+len(PcdDYIa32)+len(PcdDYX64)+len(PcdDYIpf)+len(PcdDYEbc)) > 0):
2347 ##        DynamicSection = "\n" + "#"*80 + "\n#\n"
2348 ##        DynamicSection += "# Pcd DYNAMIC - list of PCDs that this module is coded for.\n"
2349 ##        DynamicSection += "#\n" + "#"*80 + "\n\n"
2350
2351         DynamicSection = "\n"
2352         if (len(PcdDY) > 0):
2353             DynamicSection += "[Pcd.common]\n"
2354             for Entry in PcdDY[:]:
2355                 DynamicSection += "  " + Entry + "\n"
2356             DynamicSection += "\n"
2357         if (len(PcdDYIa32) > 0):
2358             DynamicSection += "[Pcd.IA32]\n"
2359             for Entry in PcdDYIa32[:]:
2360                 DynamicSection += "  " + Entry + "\n"
2361             DynamicSection += "\n"
2362         if (len(PcdDYX64) > 0):
2363             DynamicSection += "[Pcd.X64]\n"
2364             for Entry in PcdDYX64[:]:
2365                 DynamicSection += "  " + Entry + "\n"
2366             DynamicSection += "\n"
2367         if (len(PcdDYIpf) > 0):
2368             DynamicSection += "[Pcd.IPF]\n"
2369             for Entry in PcdDYIpf[:]:
2370                 DynamicSection += "  " + Entry + "\n"
2371             DynamicSection += "\n"
2372         if (len(PcdDYEbc) > 0):
2373             DynamicSection += "[Pcd.EBC]\n"
2374             for Entry in PcdDYEbc[:]:
2375                 DynamicSection += "  " + Entry + "\n"
2376             DynamicSection += "\n"
2377
2378         Output.append(DynamicSection)
2379         if (options.debug):
2380             print DynamicSection
2381
2382     if ((len(Depex) + len(DepexIa32) + len(DepexX64) + len(DepexIpf) + len(DepexEbc)) > 0):
2383         """ We do this if and only if we have Package Dependencies """
2384 ##        Dpx = "\n" + "#"*80 + "\n#\n"
2385 ##        Dpx += "# Dependency Expression Section - list of Dependency expressions that are required for\n"
2386 ##        Dpx += "#                              this module.\n"
2387 ##        Dpx += "#\n" + "#"*80 + "\n\n"
2388         Dpx = "\n"
2389         if (len(Depex) > 0):
2390             Dpx += "[Depex]\n"
2391             for lc in Depex[:]:
2392                 Dpx += "  " + lc + "\n"
2393             Dpx += "\n"
2394
2395         if (len(DepexIa32) > 0):
2396             Dpx += "[Depex.IA32]\n"
2397             for lc in DepexIa32[:]:
2398                 Dpx += "  " + lc + "\n"
2399             Dpx += "\n"
2400
2401         if (len(DepexX64) > 0):
2402             Dpx += "[Depex.X64]\n"
2403             for lc in DepexX64[:]:
2404                 Dpx += "  " + lc + "\n"
2405             Dpx += "\n"
2406
2407         if (len(DepexIpf) > 0):
2408             Dpx += "[Depex.IPF]\n"
2409             for lc in DepexIpf[:]:
2410                 Dpx += "  " + lc + "\n"
2411             Dpx += "\n"
2412
2413         if (len(DepexEbc) > 0):
2414             Dpx += "[Depex.EBC]\n"
2415             for lc in DepexEbc[:]:
2416                 Dpx += "  " + lc + "\n"
2417             Dpx += "\n"
2418
2419         Output.append(Dpx)
2420         if (options.debug):
2421             print Dpx
2422
2423     if (len(MBOlines) > 0):
2424         BuildSection = ""
2425 ##        BuildSection = "\n" + "#"*80 + "\n#\n"
2426 ##        BuildSection += "# Build Options - list of custom build options for this module.\n"
2427 ##        BuildSection += "#\n" + "#"*80 + "\n\n"
2428         BuildSection += "\n[BuildOptions]\n"
2429         for mbo in MBOlines:
2430             tool, targs = mbo.split("=",2)
2431             BuildSection += "  %-40s = %s\n" %  (tool.strip(), targs.strip())
2432
2433         Output.append(BuildSection)
2434         if (options.debug):
2435             print BuildSection
2436
2437
2438     if (len(UEList) > 0):
2439         UserExtensionSection = ""
2440         for UE in UEList[:]:
2441             UserExtensionSection += "[UserExtensions." + UE[0] + '."' + UE[1] + '"]\n'
2442             if (len(UE[2]) > 0):
2443                 UserExtensionSection += '"' + UE[2] + '"\n'
2444             else:
2445                 UserExtensionSection += "\n"
2446
2447         Output.append(UserExtensionSection)
2448         if (options.debug):
2449             print UserExtensionSection
2450
2451     print "write file", outputFile
2452     if (options.autowrite):
2453         fo = open(outputFile, "w")
2454         for Section in Output[:]:
2455             fo.writelines(Section)
2456             if (options.verbose > 1):
2457                 print Section
2458         fo.close()
2459     elif (options.outfile):
2460         fo = open(outputFile, "w")
2461         for Section in Output[:]:
2462             fo.writelines(Section)
2463         fo.close()
2464     else:
2465         for Section in Output[:]:
2466             print Section
2467
2468
2469 if __name__ == '__main__':
2470
2471     global options
2472     global args
2473     options,args = myOptionParser()
2474
2475     main()
2476     sys.exit(0)
2477