BaseTools/Source/Python/Common/DscClassObject.py

   1 ## @file
   2 # This file is used to define each component of DSC file
   3 #
   4 # Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR>
   5 # 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 ##
  15 # Import Modules
  16 #
  17 import Common.LongFilePathOs as os
  18 import EdkLogger as EdkLogger
  19 import Database
  20 from String import *
  21 from Parsing import *
  22 from DataType import *
  23 from Identification import *
  24 from Dictionary import *
  25 from CommonDataClass.PlatformClass import *
  26 from CommonDataClass.CommonClass import SkuInfoClass
  27 from BuildToolError import *
  28 from Misc import sdict
  29 import GlobalData
  30 from Table.TableDsc import TableDsc
  31 from Common.LongFilePathSupport import OpenLongFilePath as open
  32
  33 #
  34 # Global variable
  35 #
  36 Section = {TAB_UNKNOWN.upper() : MODEL_UNKNOWN,
  37            TAB_DSC_DEFINES.upper() : MODEL_META_DATA_HEADER,
  38            TAB_BUILD_OPTIONS.upper() : MODEL_META_DATA_BUILD_OPTION,
  39            TAB_SKUIDS.upper() : MODEL_EFI_SKU_ID,
  40            TAB_LIBRARIES.upper() : MODEL_EFI_LIBRARY_INSTANCE,
  41            TAB_LIBRARY_CLASSES.upper() : MODEL_EFI_LIBRARY_CLASS,
  42            TAB_PCDS_FIXED_AT_BUILD_NULL.upper() : MODEL_PCD_FIXED_AT_BUILD,
  43            TAB_PCDS_PATCHABLE_IN_MODULE_NULL.upper() : MODEL_PCD_PATCHABLE_IN_MODULE,
  44            TAB_PCDS_FEATURE_FLAG_NULL.upper() : MODEL_PCD_FEATURE_FLAG,
  45            TAB_PCDS_DYNAMIC_EX_NULL.upper() : MODEL_PCD_DYNAMIC_EX,
  46            TAB_PCDS_DYNAMIC_EX_DEFAULT_NULL.upper() :  MODEL_PCD_DYNAMIC_EX_DEFAULT,
  47            TAB_PCDS_DYNAMIC_EX_VPD_NULL.upper() : MODEL_PCD_DYNAMIC_EX_VPD,
  48            TAB_PCDS_DYNAMIC_EX_HII_NULL.upper() : MODEL_PCD_DYNAMIC_EX_HII,
  49            TAB_PCDS_DYNAMIC_NULL.upper() : MODEL_PCD_DYNAMIC,
  50            TAB_PCDS_DYNAMIC_DEFAULT_NULL.upper() : MODEL_PCD_DYNAMIC_DEFAULT,
  51            TAB_PCDS_DYNAMIC_VPD_NULL.upper() : MODEL_PCD_DYNAMIC_VPD,
  52            TAB_PCDS_DYNAMIC_HII_NULL.upper() : MODEL_PCD_DYNAMIC_HII,
  53            TAB_COMPONENTS.upper() : MODEL_META_DATA_COMPONENT,
  54            TAB_USER_EXTENSIONS.upper() : MODEL_META_DATA_USER_EXTENSION
  55            }
  56
  57 ## Dsc
  58 #
  59 # This class defined the structure used in Dsc object
  60 #
  61 # @param Ffilename:         Input value for Ffilename of Inf file, default is None
  62 # @param IsMergeAllArches:  Input value for IsMergeAllArches
  63 #                           True is to merge all arches
  64 #                           Fales is not to merge all arches
  65 #                           default is False
  66 # @param IsToPlatform:      Input value for IsToPlatform
  67 #                           True is to transfer to ModuleObject automatically
  68 #                           False is not to transfer to ModuleObject automatically
  69 #                           default is False
  70 # @param WorkspaceDir:      Input value for current workspace directory, default is None
  71 #
  72 # @var _NullClassIndex:     To store value for _NullClassIndex, default is 0
  73 # @var Identification:      To store value for Identification, it is a structure as Identification
  74 # @var Defines:             To store value for Defines, it is a structure as DscDefines
  75 # @var Contents:            To store value for Contents, it is a structure as DscContents
  76 # @var UserExtensions:      To store value for UserExtensions
  77 # @var Platform:            To store value for Platform, it is a structure as PlatformClass
  78 # @var WorkspaceDir:        To store value for WorkspaceDir
  79 # @var KeyList:             To store value for KeyList, a list for all Keys used in Dec
  80 #
  81 class Dsc(object):
  82     _NullClassIndex = 0
  83
  84     def __init__(self, Filename=None, IsToDatabase=False, IsToPlatform=False, WorkspaceDir=None, Database=None):
  85         self.Identification = Identification()
  86         self.Platform = PlatformClass()
  87         self.UserExtensions = ''
  88         self.WorkspaceDir = WorkspaceDir
  89         self.IsToDatabase = IsToDatabase
  90         if Database:
  91             self.Cur = Database.Cur
  92             self.TblFile = Database.TblFile
  93             self.TblDsc = Database.TblDsc
  94
  95         self.KeyList = [
  96             TAB_SKUIDS, TAB_LIBRARIES, TAB_LIBRARY_CLASSES, TAB_BUILD_OPTIONS, TAB_PCDS_FIXED_AT_BUILD_NULL, \
  97             TAB_PCDS_PATCHABLE_IN_MODULE_NULL, TAB_PCDS_FEATURE_FLAG_NULL, \
  98             TAB_PCDS_DYNAMIC_DEFAULT_NULL, TAB_PCDS_DYNAMIC_HII_NULL, TAB_PCDS_DYNAMIC_VPD_NULL, \
  99             TAB_PCDS_DYNAMIC_EX_DEFAULT_NULL, TAB_PCDS_DYNAMIC_EX_HII_NULL, TAB_PCDS_DYNAMIC_EX_VPD_NULL, \
 100             TAB_COMPONENTS, TAB_DSC_DEFINES
 101         ]
 102
 103         self.PcdToken = {}
 104
 105         #
 106         # Upper all KEYs to ignore case sensitive when parsing
 107         #
 108         self.KeyList = map(lambda c: c.upper(), self.KeyList)
 109
 110         #
 111         # Init RecordSet
 112         #
 113 #        self.RecordSet = {}
 114 #        for Key in self.KeyList:
 115 #            self.RecordSet[Section[Key]] = []
 116
 117         #
 118         # Load Dsc file if filename is not None
 119         #
 120         if Filename is not None:
 121             self.LoadDscFile(Filename)
 122
 123         #
 124         # Transfer to Platform Object if IsToPlatform is True
 125         #
 126         if IsToPlatform:
 127             self.DscToPlatform()
 128
 129     ## Transfer to Platform Object
 130     #
 131     # Transfer all contents of an Inf file to a standard Module Object
 132     #
 133     def DscToPlatform(self):
 134         #
 135         # Init global information for the file
 136         #
 137         ContainerFile = self.Identification.FileFullPath
 138
 139         #
 140         # Generate Platform Header
 141         #
 142         self.GenPlatformHeader(ContainerFile)
 143
 144         #
 145         # Generate BuildOptions
 146         #
 147         self.GenBuildOptions(ContainerFile)
 148
 149         #
 150         # Generate SkuInfos
 151         #
 152         self.GenSkuInfos(ContainerFile)
 153
 154         #
 155         # Generate Libraries
 156         #
 157         self.GenLibraries(ContainerFile)
 158
 159         #
 160         # Generate LibraryClasses
 161         #
 162         self.GenLibraryClasses(ContainerFile)
 163
 164         #
 165         # Generate Pcds
 166         #
 167         self.GenPcds(DataType.TAB_PCDS_FIXED_AT_BUILD, ContainerFile)
 168         self.GenPcds(DataType.TAB_PCDS_PATCHABLE_IN_MODULE, ContainerFile)
 169         self.GenFeatureFlagPcds(DataType.TAB_PCDS_FEATURE_FLAG, ContainerFile)
 170         self.GenDynamicDefaultPcds(DataType.TAB_PCDS_DYNAMIC_DEFAULT, ContainerFile)
 171         self.GenDynamicDefaultPcds(DataType.TAB_PCDS_DYNAMIC_EX_DEFAULT, ContainerFile)
 172         self.GenDynamicHiiPcds(DataType.TAB_PCDS_DYNAMIC_HII, ContainerFile)
 173         self.GenDynamicHiiPcds(DataType.TAB_PCDS_DYNAMIC_EX_HII, ContainerFile)
 174         self.GenDynamicVpdPcds(DataType.TAB_PCDS_DYNAMIC_VPD, ContainerFile)
 175         self.GenDynamicVpdPcds(DataType.TAB_PCDS_DYNAMIC_EX_VPD, ContainerFile)
 176
 177         #
 178         # Generate Components
 179         #
 180         self.GenComponents(ContainerFile)
 181
 182         #
 183         # Update to database
 184         #
 185         if self.IsToDatabase:
 186             for Key in self.PcdToken.keys():
 187                 SqlCommand = """update %s set Value2 = '%s' where ID = %s""" % (self.TblDsc.Table, ".".join((self.PcdToken[Key][0], self.PcdToken[Key][1])), Key)
 188                 self.TblDsc.Exec(SqlCommand)
 189     #End of DscToPlatform
 190
 191     ## Get Platform Header
 192     #
 193     # Gen Platform Header of Dsc as <Key> = <Value>
 194     #
 195     # @param ContainerFile: The Dsc file full path
 196     #
 197     def GenPlatformHeader(self, ContainerFile):
 198         EdkLogger.debug(2, "Generate PlatformHeader ...")
 199         #
 200         # Update all defines item in database
 201         #
 202         SqlCommand = """select ID, Value1, Arch, StartLine from %s
 203                         where Model = %s
 204                         and BelongsToFile = %s
 205                         and Enabled > -1""" % (self.TblDsc.Table, MODEL_META_DATA_HEADER, self.FileID)
 206         RecordSet = self.TblDsc.Exec(SqlCommand)
 207         for Record in RecordSet:
 208             ValueList = GetSplitValueList(Record[1], TAB_EQUAL_SPLIT)
 209             if len(ValueList) != 2:
 210                 RaiseParserError(Record[1], 'Defines', ContainerFile, '<Key> = <Value>', Record[3])
 211             ID, Value1, Value2, Arch = Record[0], ValueList[0], ValueList[1], Record[2]
 212             SqlCommand = """update %s set Value1 = '%s', Value2 = '%s'
 213                             where ID = %s""" % (self.TblDsc.Table, ConvertToSqlString2(Value1), ConvertToSqlString2(Value2), ID)
 214             self.TblDsc.Exec(SqlCommand)
 215
 216         #
 217         # Get detailed information
 218         #
 219         for Arch in DataType.ARCH_LIST:
 220             PlatformHeader = PlatformHeaderClass()
 221
 222             PlatformHeader.Name = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_PLATFORM_NAME, Arch, self.FileID)[0]
 223             PlatformHeader.Guid = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_PLATFORM_GUID, Arch, self.FileID)[0]
 224             PlatformHeader.Version = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_PLATFORM_VERSION, Arch, self.FileID)[0]
 225             PlatformHeader.FileName = self.Identification.FileName
 226             PlatformHeader.FullPath = self.Identification.FileFullPath
 227             PlatformHeader.DscSpecification = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_DSC_SPECIFICATION, Arch, self.FileID)[0]
 228
 229             PlatformHeader.SkuIdName = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_SKUID_IDENTIFIER, Arch, self.FileID)
 230             PlatformHeader.SupArchList = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES, Arch, self.FileID)
 231             PlatformHeader.BuildTargets = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_BUILD_TARGETS, Arch, self.FileID)
 232             PlatformHeader.OutputDirectory = NormPath(QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_OUTPUT_DIRECTORY, Arch, self.FileID)[0])
 233             PlatformHeader.BuildNumber = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_BUILD_NUMBER, Arch, self.FileID)[0]
 234             PlatformHeader.MakefileName = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_MAKEFILE_NAME, Arch, self.FileID)[0]
 235
 236             PlatformHeader.BsBaseAddress = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_BS_BASE_ADDRESS, Arch, self.FileID)[0]
 237             PlatformHeader.RtBaseAddress = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_RT_BASE_ADDRESS, Arch, self.FileID)[0]
 238
 239             self.Platform.Header[Arch] = PlatformHeader
 240             Fdf = PlatformFlashDefinitionFileClass()
 241             Fdf.FilePath = NormPath(QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_FLASH_DEFINITION, Arch, self.FileID)[0])
 242             self.Platform.FlashDefinitionFile = Fdf
 243             Prebuild = BuildScriptClass()
 244             Prebuild.FilePath = NormPath(QueryDefinesItem(self.TblDsc, TAB_DSC_PREBUILD, Arch, self.FileID)[0])
 245             self.Platform.Prebuild = Prebuild
 246             Postbuild = BuildScriptClass()
 247             Postbuild.FilePath = NormPath(QueryDefinesItem(self.TblDsc, TAB_DSC_POSTBUILD, Arch, self.FileID)[0])
 248             self.Platform.Postbuild = Postbuild
 249
 250     ## GenBuildOptions
 251     #
 252     # Gen BuildOptions of Dsc
 253     # [<Family>:]<ToolFlag>=Flag
 254     #
 255     # @param ContainerFile: The Dsc file full path
 256     #
 257     def GenBuildOptions(self, ContainerFile):
 258         EdkLogger.debug(2, "Generate %s ..." % TAB_BUILD_OPTIONS)
 259         BuildOptions = {}
 260         #
 261         # Get all include files
 262         #
 263         IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, MODEL_META_DATA_BUILD_OPTION, self.FileID)
 264
 265         #
 266         # Get all BuildOptions
 267         #
 268         RecordSet = QueryDscItem(self.TblDsc, MODEL_META_DATA_BUILD_OPTION, -1, self.FileID)
 269
 270         #
 271         # Go through each arch
 272         #
 273         for Arch in DataType.ARCH_LIST:
 274             for IncludeFile in IncludeFiles:
 275                 if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
 276                     Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, TAB_BUILD_OPTIONS, '', IncludeFile[2])
 277                     for NewItem in open(Filename, 'r').readlines():
 278                         if CleanString(NewItem) == '':
 279                             continue
 280                         (Family, ToolChain, Flag) = GetBuildOption(NewItem, Filename, -1)
 281                         MergeArches(BuildOptions, (Family, ToolChain, Flag), Arch)
 282
 283             for Record in RecordSet:
 284                 if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
 285                     (Family, ToolChain, Flag) = GetBuildOption(Record[0], ContainerFile, Record[2])
 286                     MergeArches(BuildOptions, (Family, ToolChain, Flag), Arch)
 287                     #
 288                     # Update to Database
 289                     #
 290                     if self.IsToDatabase:
 291                         SqlCommand = """update %s set Value1 = '%s', Value2 = '%s', Value3 = '%s'
 292                                         where ID = %s""" % (self.TblDsc.Table, ConvertToSqlString2(Family), ConvertToSqlString2(ToolChain), ConvertToSqlString2(Flag), Record[3])
 293                         self.TblDsc.Exec(SqlCommand)
 294
 295         for Key in BuildOptions.keys():
 296             BuildOption = BuildOptionClass(Key[0], Key[1], Key[2])
 297             BuildOption.SupArchList = BuildOptions[Key]
 298             self.Platform.BuildOptions.BuildOptionList.append(BuildOption)
 299
 300     ## GenSkuInfos
 301     #
 302     # Gen SkuInfos of Dsc
 303     # <Integer>|<UiName>
 304     #
 305     # @param ContainerFile: The Dsc file full path
 306     #
 307     def GenSkuInfos(self, ContainerFile):
 308         EdkLogger.debug(2, "Generate %s ..." % TAB_SKUIDS)
 309         #
 310         # SkuIds
 311         # <Integer>|<UiName>
 312         #
 313         self.Platform.SkuInfos.SkuInfoList['DEFAULT'] = '0'
 314
 315         #
 316         # Get all include files
 317         #
 318         IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, MODEL_EFI_SKU_ID, self.FileID)
 319
 320         #
 321         # Get all SkuInfos
 322         #
 323         RecordSet = QueryDscItem(self.TblDsc, MODEL_EFI_SKU_ID, -1, self.FileID)
 324
 325         #
 326         # Go through each arch
 327         #
 328         for Arch in DataType.ARCH_LIST:
 329             for IncludeFile in IncludeFiles:
 330                 if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
 331                     Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, TAB_SKUIDS, '', IncludeFile[2])
 332                     for NewItem in open(Filename, 'r').readlines():
 333                         if CleanString(NewItem) == '':
 334                             continue
 335                         List = GetSplitValueList(NewItem)
 336                         if len(List) != 2:
 337                             RaiseParserError(NewItem, TAB_SKUIDS, Filename, '<Integer>|<UiName>')
 338                         else:
 339                             self.Platform.SkuInfos.SkuInfoList[List[1]] = List[0]
 340
 341             for Record in RecordSet:
 342                 if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
 343                     List = GetSplitValueList(Record[0])
 344                     if len(List) != 2:
 345                         RaiseParserError(Record[0], TAB_SKUIDS, ContainerFile, '<Integer>|<UiName>')
 346                     else:
 347                         self.Platform.SkuInfos.SkuInfoList[List[1]] = List[0]
 348                         #
 349                         # Update to Database
 350                         #
 351                         if self.IsToDatabase:
 352                             SqlCommand = """update %s set Value1 = '%s', Value2 = '%s'
 353                                             where ID = %s""" % (self.TblDsc.Table, ConvertToSqlString2(List[0]), ConvertToSqlString2(List[1]), Record[3])
 354                             self.TblDsc.Exec(SqlCommand)
 355
 356     ## GenLibraries
 357     #
 358     # Gen Libraries of Dsc
 359     # <PathAndFilename>
 360     #
 361     # @param ContainerFile: The Dsc file full path
 362     #
 363     def GenLibraries(self, ContainerFile):
 364         EdkLogger.debug(2, "Generate %s ..." % TAB_LIBRARIES)
 365         Libraries = {}
 366         #
 367         # Get all include files
 368         #
 369         IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, MODEL_EFI_LIBRARY_INSTANCE, self.FileID)
 370
 371         #
 372         # Get all Libraries
 373         #
 374         RecordSet = QueryDscItem(self.TblDsc, MODEL_EFI_LIBRARY_INSTANCE, -1, self.FileID)
 375
 376         #
 377         # Go through each arch
 378         #
 379         for Arch in DataType.ARCH_LIST:
 380             for IncludeFile in IncludeFiles:
 381                 if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
 382                     Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, TAB_LIBRARIES, '', IncludeFile[2])
 383                     if os.path.exists(Filename):
 384                         for NewItem in open(Filename, 'r').readlines():
 385                             if CleanString(NewItem) == '':
 386                                 continue
 387                             MergeArches(Libraries, NewItem, Arch)
 388
 389             for Record in RecordSet:
 390                 if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
 391                     MergeArches(Libraries, Record[0], Arch)
 392
 393         for Key in Libraries.keys():
 394             Library = PlatformLibraryClass()
 395             Library.FilePath = NormPath(Key)
 396             Library.SupArchList = Libraries[Key]
 397             self.Platform.Libraries.LibraryList.append(Library)
 398
 399     ## GenLibraryClasses
 400     #
 401     # Get LibraryClasses of Dsc
 402     # <LibraryClassKeyWord>|<LibraryInstance>
 403     #
 404     # @param ContainerFile: The Dsc file full path
 405     #
 406     def GenLibraryClasses(self, ContainerFile):
 407         EdkLogger.debug(2, "Generate %s ..." % TAB_LIBRARY_CLASSES)
 408         LibraryClasses = {}
 409         #
 410         # Get all include files
 411         #
 412         IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, MODEL_EFI_LIBRARY_CLASS, self.FileID)
 413
 414         #
 415         # Get all LibraryClasses
 416         #
 417         RecordSet = QueryDscItem(self.TblDsc, MODEL_EFI_LIBRARY_CLASS, -1, self.FileID)
 418
 419         #
 420         # Go through each arch
 421         #
 422         for Arch in DataType.ARCH_LIST:
 423             for IncludeFile in IncludeFiles:
 424                 if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
 425                     Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, TAB_LIBRARY_CLASSES, '', IncludeFile[2])
 426                     for NewItem in open(Filename, 'r').readlines():
 427                         if CleanString(NewItem) == '':
 428                             continue
 429                         MergeArches(LibraryClasses, GetLibraryClass([NewItem, IncludeFile[4]], Filename, self.WorkspaceDir, -1), Arch)
 430
 431             for Record in RecordSet:
 432                 if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
 433                     (LibClassName, LibClassIns, SupModelList) = GetLibraryClass([Record[0], Record[4]], ContainerFile, self.WorkspaceDir, Record[2])
 434                     MergeArches(LibraryClasses, (LibClassName, LibClassIns, SupModelList), Arch)
 435                     #
 436                     # Update to Database
 437                     #
 438                     if self.IsToDatabase:
 439                         SqlCommand = """update %s set Value1 = '%s', Value2 = '%s', Value3 = '%s'
 440                                         where ID = %s""" % (self.TblDsc.Table, ConvertToSqlString2(LibClassName), ConvertToSqlString2(LibClassIns), ConvertToSqlString2(SupModelList), Record[3])
 441                         self.TblDsc.Exec(SqlCommand)
 442
 443         for Key in LibraryClasses.keys():
 444             Library = PlatformLibraryClass()
 445             Library.Name = Key[0]
 446             Library.FilePath = NormPath(Key[1])
 447             Library.SupModuleList = GetSplitValueList(Key[2])
 448             Library.SupArchList = LibraryClasses[Key]
 449             self.Platform.LibraryClasses.LibraryList.append(Library)
 450
 451     ## Gen Pcds
 452     #
 453     # Gen Pcd of Dsc as <PcdTokenSpaceGuidCName>.<TokenCName>|<Value>[|<Type>|<MaximumDatumSize>]
 454     #
 455     # @param Type:           The type of Pcd
 456     # @param ContainerFile:  The file which describes the pcd, used for error report
 457     #
 458     def GenPcds(self, Type='', ContainerFile=''):
 459         Pcds = {}
 460         if Type == DataType.TAB_PCDS_PATCHABLE_IN_MODULE:
 461             Model = MODEL_PCD_PATCHABLE_IN_MODULE
 462         elif Type == DataType.TAB_PCDS_FIXED_AT_BUILD:
 463             Model = MODEL_PCD_FIXED_AT_BUILD
 464         else:
 465             pass
 466         EdkLogger.debug(2, "Generate %s ..." % Type)
 467
 468         #
 469         # Get all include files
 470         #
 471         IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, Model, self.FileID)
 472
 473         #
 474         # Get all Pcds
 475         #
 476         RecordSet = QueryDscItem(self.TblDsc, Model, -1, self.FileID)
 477
 478         #
 479         # Go through each arch
 480         #
 481         for Arch in DataType.ARCH_LIST:
 482             for IncludeFile in IncludeFiles:
 483                 if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
 484                     Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, Type, '', IncludeFile[2])
 485                     for NewItem in open(Filename, 'r').readlines():
 486                         if CleanString(NewItem) == '':
 487                             continue
 488                         (TokenName, TokenGuidCName, Value, DatumType, MaxDatumSize, Type) = GetPcd(NewItem, Type, Filename, -1)
 489                         MergeArches(Pcds, (TokenName, TokenGuidCName, Value, DatumType, MaxDatumSize, Type), Arch)
 490                         self.PcdToken[Record[3]] = (TokenGuidCName, TokenName)
 491
 492             for Record in RecordSet:
 493                 if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
 494                     (TokenName, TokenGuidCName, Value, DatumType, MaxDatumSize, Type) = GetPcd(Record[0], Type, ContainerFile, Record[2])
 495                     MergeArches(Pcds, (TokenName, TokenGuidCName, Value, DatumType, MaxDatumSize, Type), Arch)
 496                     self.PcdToken[Record[3]] = (TokenGuidCName, TokenName)
 497
 498         for Key in Pcds:
 499             Pcd = PcdClass(Key[0], '', Key[1], Key[3], Key[4], Key[2], Key[5], [], {}, [])
 500             Pcd.SupArchList = Pcds[Key]
 501             self.Platform.DynamicPcdBuildDefinitions.append(Pcd)
 502
 503     ## Gen FeatureFlagPcds
 504     #
 505     # Gen FeatureFlagPcds of Dsc file as <PcdTokenSpaceGuidCName>.<TokenCName>|TRUE/FALSE
 506     #
 507     # @param Type:           The type of Pcd
 508     # @param ContainerFile:  The file which describes the pcd, used for error report
 509     #
 510     def GenFeatureFlagPcds(self, Type='', ContainerFile=''):
 511         Pcds = {}
 512         if Type == DataType.TAB_PCDS_FEATURE_FLAG:
 513             Model = MODEL_PCD_FEATURE_FLAG
 514         else:
 515             pass
 516         EdkLogger.debug(2, "Generate %s ..." % Type)
 517
 518         #
 519         # Get all include files
 520         #
 521         IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, Model, self.FileID)
 522
 523         #
 524         # Get all FeatureFlagPcds
 525         #
 526         RecordSet = QueryDscItem(self.TblDsc, Model, -1, self.FileID)
 527
 528         #
 529         # Go through each arch
 530         #
 531         for Arch in DataType.ARCH_LIST:
 532             for IncludeFile in IncludeFiles:
 533                 if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
 534                     Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, Type, '', IncludeFile[2])
 535                     for NewItem in open(Filename, 'r').readlines():
 536                         if CleanString(NewItem) == '':
 537                             continue
 538                         (TokenName, TokenGuidCName, Value, Type) = GetFeatureFlagPcd(NewItem, Type, Filename, -1)
 539                         MergeArches(Pcds, (TokenName, TokenGuidCName, Value, Type), Arch)
 540                         self.PcdToken[Record[3]] = (TokenGuidCName, TokenName)
 541
 542             for Record in RecordSet:
 543                 if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
 544                     (TokenName, TokenGuidCName, Value, Type) = GetFeatureFlagPcd(Record[0], Type, ContainerFile, Record[2])
 545                     MergeArches(Pcds, (TokenName, TokenGuidCName, Value, Type), Arch)
 546                     self.PcdToken[Record[3]] = (TokenGuidCName, TokenName)
 547
 548         for Key in Pcds:
 549             Pcd = PcdClass(Key[0], '', Key[1], '', '', Key[2], Key[3], [], {}, [])
 550             Pcd.SupArchList = Pcds[Key]
 551             self.Platform.DynamicPcdBuildDefinitions.append(Pcd)
 552
 553     ## Gen DynamicDefaultPcds
 554     #
 555     # Gen DynamicDefaultPcds of Dsc as <PcdTokenSpaceGuidCName>.<TokenCName>|<Value>[|<DatumTyp>[|<MaxDatumSize>]]
 556     #
 557     # @param Type:           The type of Pcd
 558     # @param ContainerFile:  The file which describes the pcd, used for error report
 559     #
 560     def GenDynamicDefaultPcds(self, Type='', ContainerFile=''):
 561         Pcds = {}
 562         SkuInfoList = {}
 563         if Type == DataType.TAB_PCDS_DYNAMIC_DEFAULT:
 564             Model = MODEL_PCD_DYNAMIC_DEFAULT
 565         elif Type == DataType.TAB_PCDS_DYNAMIC_EX_DEFAULT:
 566             Model = MODEL_PCD_DYNAMIC_EX_DEFAULT
 567         else:
 568             pass
 569         EdkLogger.debug(2, "Generate %s ..." % Type)
 570
 571         #
 572         # Get all include files
 573         #
 574         IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, Model, self.FileID)
 575
 576         #
 577         # Get all DynamicDefaultPcds
 578         #
 579         RecordSet = QueryDscItem(self.TblDsc, Model, -1, self.FileID)
 580
 581         #
 582         # Go through each arch
 583         #
 584         for Arch in DataType.ARCH_LIST:
 585             for IncludeFile in IncludeFiles:
 586                 if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
 587                     Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, Type, '', IncludeFile[2])
 588                     for NewItem in open(Filename, 'r').readlines():
 589                         if CleanString(NewItem) == '':
 590                             continue
 591                         (K1, K2, K3, K4, K5, K6) = GetDynamicDefaultPcd(NewItem, Type, Filename, -1)
 592                         MergeArches(Pcds, (K1, K2, K3, K4, K5, K6, IncludeFile[4]), Arch)
 593                         self.PcdToken[Record[3]] = (K2, K1)
 594
 595             for Record in RecordSet:
 596                 if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
 597                     (K1, K2, K3, K4, K5, K6) = GetDynamicDefaultPcd(Record[0], Type, ContainerFile, Record[2])
 598                     MergeArches(Pcds, (K1, K2, K3, K4, K5, K6, Record[4]), Arch)
 599                     self.PcdToken[Record[3]] = (K2, K1)
 600
 601         for Key in Pcds:
 602             (Status, SkuInfoList) = self.GenSkuInfoList(Key[6], self.Platform.SkuInfos.SkuInfoList, '', '', '', '', '', Key[2])
 603             if Status == False:
 604                 ErrorMsg = "The SKUID '%s' used in section '%s' is not defined in section [SkuIds]" % (SkuInfoList, Type)
 605                 EdkLogger.error("DSC File Parser", PARSER_ERROR, ErrorMsg, ContainerFile, RaiseError=EdkLogger.IsRaiseError)
 606             Pcd = PcdClass(Key[0], '', Key[1], Key[3], Key[4], Key[2], Key[5], [], SkuInfoList, [])
 607             Pcd.SupArchList = Pcds[Key]
 608             self.Platform.DynamicPcdBuildDefinitions.append(Pcd)
 609
 610     ## Gen DynamicHiiPcds
 611     #
 612     # Gen DynamicHiiPcds of Dsc as <PcdTokenSpaceGuidCName>.<TokenCName>|<String>|<VariableGuidCName>|<VariableOffset>[|<DefaultValue>[|<MaximumDatumSize>]]
 613     #
 614     # @param Type:           The type of Pcd
 615     # @param ContainerFile:  The file which describes the pcd, used for error report
 616     #
 617     def GenDynamicHiiPcds(self, Type='', ContainerFile=''):
 618         Pcds = {}
 619         SkuInfoList = {}
 620         if Type == DataType.TAB_PCDS_DYNAMIC_HII:
 621             Model = MODEL_PCD_DYNAMIC_HII
 622         elif Type == DataType.TAB_PCDS_DYNAMIC_EX_HII:
 623             Model = MODEL_PCD_DYNAMIC_EX_HII
 624         else:
 625             pass
 626         EdkLogger.debug(2, "Generate %s ..." % Type)
 627
 628         #
 629         # Get all include files
 630         #
 631         IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, Model, self.FileID)
 632
 633         #
 634         # Get all DynamicHiiPcds
 635         #
 636         RecordSet = QueryDscItem(self.TblDsc, Model, -1, self.FileID)
 637
 638         #
 639         # Go through each arch
 640         #
 641         for Arch in DataType.ARCH_LIST:
 642             for IncludeFile in IncludeFiles:
 643                 if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
 644                     Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, Type, '', IncludeFile[2])
 645                     for NewItem in open(Filename, 'r').readlines():
 646                         if CleanString(NewItem) == '':
 647                             continue
 648                         (K1, K2, K3, K4, K5, K6, K7, K8) = GetDynamicHiiPcd(NewItem, Type, Filename, -1)
 649                         MergeArches(Pcds, (K1, K2, K3, K4, K5, K6, K7, K8, IncludeFile[4]), Arch)
 650                         self.PcdToken[Record[3]] = (K2, K1)
 651
 652             for Record in RecordSet:
 653                 if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
 654                     (K1, K2, K3, K4, K5, K6, K7, K8) = GetDynamicHiiPcd(Record[0], Type, ContainerFile, Record[2])
 655                     MergeArches(Pcds, (K1, K2, K3, K4, K5, K6, K7, K8, Record[4]), Arch)
 656                     self.PcdToken[Record[3]] = (K2, K1)
 657
 658         for Key in Pcds:
 659             (Status, SkuInfoList) = self.GenSkuInfoList(Key[8], self.Platform.SkuInfos.SkuInfoList, Key[2], Key[3], Key[4], Key[5], '', '')
 660             if Status == False:
 661                 ErrorMsg = "The SKUID '%s' used in section '%s' is not defined in section [SkuIds]" % (SkuInfoList, Type)
 662                 EdkLogger.error("DSC File Parser", PARSER_ERROR, ErrorMsg, ContainerFile, RaiseError=EdkLogger.IsRaiseError)
 663             Pcd = PcdClass(Key[0], '', Key[1], '', Key[6], Key[5], Key[7], [], SkuInfoList, [])
 664             Pcd.SupArchList = Pcds[Key]
 665             self.Platform.DynamicPcdBuildDefinitions.append(Pcd)
 666
 667     ## Gen DynamicVpdPcds
 668     #
 669     # Gen DynamicVpdPcds of Dsc as <PcdTokenSpaceGuidCName>.<TokenCName>|<VpdOffset>[|<MaximumDatumSize>]
 670     #
 671     # @param Type:           The type of Pcd
 672     # @param ContainerFile:  The file which describes the pcd, used for error report
 673     #
 674     def GenDynamicVpdPcds(self, Type='', ContainerFile=''):
 675         Pcds = {}
 676         SkuInfoList = {}
 677         if Type == DataType.TAB_PCDS_DYNAMIC_VPD:
 678             Model = MODEL_PCD_DYNAMIC_VPD
 679         elif Type == DataType.TAB_PCDS_DYNAMIC_EX_VPD:
 680             Model = MODEL_PCD_DYNAMIC_EX_VPD
 681         else:
 682             pass
 683         EdkLogger.debug(2, "Generate %s ..." % Type)
 684
 685         #
 686         # Get all include files
 687         #
 688         IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, Model, self.FileID)
 689
 690         #
 691         # Get all DynamicVpdPcds
 692         #
 693         RecordSet = QueryDscItem(self.TblDsc, Model, -1, self.FileID)
 694
 695         #
 696         # Go through each arch
 697         #
 698         for Arch in DataType.ARCH_LIST:
 699             for IncludeFile in IncludeFiles:
 700                 if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
 701                     Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, Type, '', IncludeFile[2])
 702                     for NewItem in open(Filename, 'r').readlines():
 703                         if CleanString(NewItem) == '':
 704                             continue
 705                         (K1, K2, K3, K4, K5) = GetDynamicVpdPcd(NewItem, Type, Filename, -1)
 706                         MergeArches(Pcds, (K1, K2, K3, K4, K5, IncludeFile[4]), Arch)
 707                         self.PcdToken[Record[3]] = (K2, K1)
 708
 709             for Record in RecordSet:
 710                 if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
 711                     (K1, K2, K3, K4, K5) = GetDynamicVpdPcd(Record[0], Type, ContainerFile, Record[2])
 712                     MergeArches(Pcds, (K1, K2, K3, K4, K5, Record[4]), Arch)
 713                     self.PcdToken[Record[3]] = (K2, K1)
 714
 715         for Key in Pcds:
 716             (Status, SkuInfoList) = self.GenSkuInfoList(Key[5], self.Platform.SkuInfos.SkuInfoList, '', '', '', '', Key[2], '')
 717             if Status == False:
 718                 ErrorMsg = "The SKUID '%s' used in section '%s' is not defined in section [SkuIds]" % (SkuInfoList, Type)
 719                 EdkLogger.error("DSC File Parser", PARSER_ERROR, ErrorMsg, ContainerFile, RaiseError=EdkLogger.IsRaiseError)
 720             Pcd = PcdClass(Key[0], '', Key[1], '', Key[3], '', Key[4], [], SkuInfoList, [])
 721             Pcd.SupArchList = Pcds[Key]
 722             self.Platform.DynamicPcdBuildDefinitions.append(Pcd)
 723
 724
 725     ## Get Component
 726     #
 727     # Get Component section defined in Dsc file
 728     #
 729     # @param ContainerFile:  The file which describes the Components, used for error report
 730     #
 731     # @retval PlatformModuleClass() A instance for PlatformModuleClass
 732     #
 733     def GenComponents(self, ContainerFile):
 734         EdkLogger.debug(2, "Generate %s ..." % TAB_COMPONENTS)
 735         Components = sdict()
 736         #
 737         # Get all include files
 738         #
 739         IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, MODEL_META_DATA_COMPONENT, self.FileID)
 740
 741         #
 742         # Get all Components
 743         #
 744         RecordSet = QueryDscItem(self.TblDsc, MODEL_META_DATA_COMPONENT, -1, self.FileID)
 745
 746         #
 747         # Go through each arch
 748         #
 749         for Arch in DataType.ARCH_LIST:
 750             for IncludeFile in IncludeFiles:
 751                 if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
 752                     Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, TAB_COMPONENTS, '', IncludeFile[2])
 753                     for NewItem in open(Filename, 'r').readlines():
 754                         if CleanString(NewItem) == '':
 755                             continue
 756                         NewItems = []
 757                         GetComponents(open(Filename, 'r').read(), TAB_COMPONENTS, NewItems, TAB_COMMENT_SPLIT)
 758                         for NewComponent in NewItems:
 759                             MergeArches(Components, self.GenComponent(NewComponent, Filename), Arch)
 760
 761             for Record in RecordSet:
 762                 if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
 763                     Lib, Bo, Pcd = [], [], []
 764
 765                     SubLibSet = QueryDscItem(self.TblDsc, MODEL_EFI_LIBRARY_CLASS, Record[3], self.FileID)
 766                     for SubLib in SubLibSet:
 767                         Lib.append(TAB_VALUE_SPLIT.join([SubLib[0], SubLib[4]]))
 768
 769                     SubBoSet = QueryDscItem(self.TblDsc, MODEL_META_DATA_BUILD_OPTION, Record[3], self.FileID)
 770                     for SubBo in SubBoSet:
 771                         Bo.append(SubBo[0])
 772
 773                     SubPcdSet1 = QueryDscItem(self.TblDsc, MODEL_PCD_FIXED_AT_BUILD, Record[3], self.FileID)
 774                     SubPcdSet2 = QueryDscItem(self.TblDsc, MODEL_PCD_PATCHABLE_IN_MODULE, Record[3], self.FileID)
 775                     SubPcdSet3 = QueryDscItem(self.TblDsc, MODEL_PCD_FEATURE_FLAG, Record[3], self.FileID)
 776                     SubPcdSet4 = QueryDscItem(self.TblDsc, MODEL_PCD_DYNAMIC_EX_DEFAULT, Record[3], self.FileID)
 777                     SubPcdSet5 = QueryDscItem(self.TblDsc, MODEL_PCD_DYNAMIC_DEFAULT, Record[3], self.FileID)
 778                     for SubPcd in SubPcdSet1:
 779                         Pcd.append([DataType.TAB_PCDS_FIXED_AT_BUILD, SubPcd[0], SubPcd[3]])
 780                     for SubPcd in SubPcdSet2:
 781                         Pcd.append([DataType.TAB_PCDS_PATCHABLE_IN_MODULE, SubPcd[0], SubPcd[3]])
 782                     for SubPcd in SubPcdSet3:
 783                         Pcd.append([DataType.TAB_PCDS_FEATURE_FLAG, SubPcd[0], SubPcd[3]])
 784                     for SubPcd in SubPcdSet4:
 785                         Pcd.append([DataType.TAB_PCDS_DYNAMIC_EX, SubPcd[0], SubPcd[3]])
 786                     for SubPcd in SubPcdSet5:
 787                         Pcd.append([DataType.TAB_PCDS_DYNAMIC, SubPcd[0], SubPcd[3]])
 788                     Item = [Record[0], Lib, Bo, Pcd]
 789                     MergeArches(Components, self.GenComponent(Item, ContainerFile), Arch)
 790
 791         for Key in Components.keys():
 792             Key.SupArchList = Components[Key]
 793             self.Platform.Modules.ModuleList.append(Key)
 794
 795     ## Get Component
 796     #
 797     # Get Component section defined in Dsc file
 798     #
 799     # @param Item:           Contents includes a component block
 800     # @param ContainerFile:  The file which describes the library class, used for error report
 801     #
 802     # @retval PlatformModuleClass() A instance for PlatformModuleClass
 803     #
 804     def GenComponent(self, Item, ContainerFile, LineNo= -1):
 805         (InfFilename, ExecFilename) = GetExec(Item[0])
 806         LibraryClasses = Item[1]
 807         BuildOptions = Item[2]
 808         Pcds = Item[3]
 809         Component = PlatformModuleClass()
 810         Component.FilePath = NormPath(InfFilename)
 811         Component.ExecFilePath = NormPath(ExecFilename)
 812         CheckFileType(Component.FilePath, '.Inf', ContainerFile, 'component name', Item[0], LineNo)
 813         CheckFileExist(self.WorkspaceDir, Component.FilePath, ContainerFile, 'component', Item[0], LineNo)
 814         for Lib in LibraryClasses:
 815             List = GetSplitValueList(Lib)
 816             if len(List) != 2:
 817                 RaiseParserError(Lib, 'LibraryClasses', ContainerFile, '<ClassName>|<InfFilename>')
 818             LibName = List[0]
 819             LibFile = NormPath(List[1])
 820             if LibName == "" or LibName == "NULL":
 821                 LibName = "NULL%d" % self._NullClassIndex
 822                 self._NullClassIndex += 1
 823             CheckFileType(List[1], '.Inf', ContainerFile, 'library instance of component ', Lib, LineNo)
 824             CheckFileExist(self.WorkspaceDir, LibFile, ContainerFile, 'library instance of component', Lib, LineNo)
 825             Component.LibraryClasses.LibraryList.append(PlatformLibraryClass(LibName, LibFile))
 826         for BuildOption in BuildOptions:
 827             Key = GetBuildOption(BuildOption, ContainerFile)
 828             Component.ModuleSaBuildOption.BuildOptionList.append(BuildOptionClass(Key[0], Key[1], Key[2]))
 829         for Pcd in Pcds:
 830             Type = Pcd[0]
 831             List = GetSplitValueList(Pcd[1])
 832             PcdId = Pcd[2]
 833
 834             TokenInfo = None
 835             #
 836             # For FeatureFlag
 837             #
 838             if Type == DataType.TAB_PCDS_FEATURE_FLAG:
 839                 if len(List) != 2:
 840                     RaiseParserError(Pcd[1], 'Components', ContainerFile, '<PcdTokenSpaceGuidCName>.<PcdTokenName>|TRUE/FALSE')
 841
 842                 CheckPcdTokenInfo(List[0], 'Components', ContainerFile)
 843                 TokenInfo = GetSplitValueList(List[0], DataType.TAB_SPLIT)
 844                 Component.PcdBuildDefinitions.append(PcdClass(TokenInfo[1], '', TokenInfo[0], '', '', List[1], Type, [], {}, []))
 845             #
 846             # For FixedAtBuild or PatchableInModule
 847             #
 848             if Type == DataType.TAB_PCDS_FIXED_AT_BUILD or Type == DataType.TAB_PCDS_PATCHABLE_IN_MODULE:
 849                 List.append('')
 850                 if len(List) != 3 and len(List) != 4:
 851                     RaiseParserError(Pcd[1], 'Components', ContainerFile, '<PcdTokenSpaceGuidCName>.<PcdTokenName>|<Value>[|<MaxDatumSize>]')
 852
 853                 CheckPcdTokenInfo(List[0], 'Components', ContainerFile)
 854                 TokenInfo = GetSplitValueList(List[0], DataType.TAB_SPLIT)
 855                 Component.PcdBuildDefinitions.append(PcdClass(TokenInfo[1], '', TokenInfo[0], '', List[2], List[1], Type, [], {}, []))
 856
 857             #
 858             # For Dynamic or DynamicEx
 859             #
 860             if Type == DataType.TAB_PCDS_DYNAMIC or Type == DataType.TAB_PCDS_DYNAMIC_EX:
 861                 if len(List) != 1:
 862                     RaiseParserError(Pcd[1], 'Components', ContainerFile, '<PcdTokenSpaceGuidCName>.<PcdTokenName>')
 863
 864                 CheckPcdTokenInfo(List[0], 'Components', ContainerFile)
 865                 TokenInfo = GetSplitValueList(List[0], DataType.TAB_SPLIT)
 866                 Component.PcdBuildDefinitions.append(PcdClass(TokenInfo[1], '', TokenInfo[0], '', '', '', Type, [], {}, []))
 867
 868             #
 869             # Add to PcdToken
 870             #
 871             self.PcdToken[PcdId] = (TokenInfo[0], TokenInfo[1])
 872
 873         return Component
 874     #End of GenComponent
 875
 876     ## Gen SkuInfoList
 877     #
 878     # Gen SkuInfoList section defined in Dsc file
 879     #
 880     # @param SkuNameList:      Input value for SkuNameList
 881     # @param SkuInfo:          Input value for SkuInfo
 882     # @param VariableName:     Input value for VariableName
 883     # @param VariableGuid:     Input value for VariableGuid
 884     # @param VariableOffset:   Input value for VariableOffset
 885     # @param HiiDefaultValue:  Input value for HiiDefaultValue
 886     # @param VpdOffset:        Input value for VpdOffset
 887     # @param DefaultValue:     Input value for DefaultValue
 888     #
 889     # @retval (False, SkuName)     Not found in section SkuId Dsc file
 890     # @retval (True, SkuInfoList)  Found in section SkuId of Dsc file
 891     #
 892     def GenSkuInfoList(self, SkuNameList, SkuInfo, VariableName='', VariableGuid='', VariableOffset='', HiiDefaultValue='', VpdOffset='', DefaultValue=''):
 893         SkuNameList = GetSplitValueList(SkuNameList)
 894         if SkuNameList is None or SkuNameList == [] or SkuNameList == ['']:
 895             SkuNameList = ['DEFAULT']
 896         SkuInfoList = {}
 897         for Item in SkuNameList:
 898             if Item not in SkuInfo:
 899                 return False, Item
 900             Sku = SkuInfoClass(Item, SkuInfo[Item], VariableName, VariableGuid, VariableOffset, HiiDefaultValue, VpdOffset, DefaultValue)
 901             SkuInfoList[Item] = Sku
 902
 903         return True, SkuInfoList
 904
 905     ## Parse Include statement
 906     #
 907     # Get include file path
 908     #
 909     # 1. Insert a record into TblFile ???
 910     # 2. Insert a record into TblDsc
 911     # Value1: IncludeFilePath
 912     #
 913     # @param LineValue:  The line of incude statement
 914     def ParseInclude(self, LineValue, StartLine, Table, FileID, Filename, SectionName, Model, Arch):
 915         EdkLogger.debug(EdkLogger.DEBUG_2, "!include statement '%s' found in section %s" % (LineValue, SectionName))
 916         SectionModel = Section[SectionName.upper()]
 917         IncludeFile = CleanString(LineValue[LineValue.upper().find(DataType.TAB_INCLUDE.upper() + ' ') + len(DataType.TAB_INCLUDE + ' ') : ])
 918         Table.Insert(Model, IncludeFile, '', '', Arch, SectionModel, FileID, StartLine, -1, StartLine, -1, 0)
 919
 920     ## Parse DEFINE statement
 921     #
 922     # Get DEFINE macros
 923     #
 924     # 1. Insert a record into TblDsc
 925     # Value1: Macro Name
 926     # Value2: Macro Value
 927     #
 928     def ParseDefine(self, LineValue, StartLine, Table, FileID, Filename, SectionName, Model, Arch):
 929         EdkLogger.debug(EdkLogger.DEBUG_2, "DEFINE statement '%s' found in section %s" % (LineValue, SectionName))
 930         SectionModel = Section[SectionName.upper()]
 931         Define = GetSplitValueList(CleanString(LineValue[LineValue.upper().find(DataType.TAB_DEFINE.upper() + ' ') + len(DataType.TAB_DEFINE + ' ') : ]), TAB_EQUAL_SPLIT, 1)
 932         Table.Insert(Model, Define[0], Define[1], '', Arch, SectionModel, FileID, StartLine, -1, StartLine, -1, 0)
 933
 934     ## Parse Defines section
 935     #
 936     # Get one item in defines section
 937     #
 938     # Value1: Item Name
 939     # Value2: Item Value
 940     #
 941     def ParseDefinesSection(self, LineValue, StartLine, Table, FileID, Filename, SectionName, Model, Arch):
 942         EdkLogger.debug(EdkLogger.DEBUG_2, "Parse '%s' found in section %s" % (LineValue, SectionName))
 943         Defines = GetSplitValueList(LineValue, TAB_EQUAL_SPLIT, 1)
 944         if len(Defines) != 2:
 945             RaiseParserError(LineValue, SectionName, Filename, '', StartLine)
 946         self.TblDsc.Insert(Model, Defines[0], Defines[1], '', Arch, -1, FileID, StartLine, -1, StartLine, -1, 0)
 947
 948     ## Insert conditional statements
 949     #
 950     # Pop an item from IfDefList
 951     # Insert conditional statements to database
 952     #
 953     # @param Filename:   Path of parsing file
 954     # @param IfDefList:  A list stored current conditional statements
 955     # @param EndLine:    The end line no
 956     # @param ArchList:   Support arch list
 957     #
 958     def InsertConditionalStatement(self, Filename, FileID, BelongsToItem, IfDefList, EndLine, ArchList):
 959         (Value1, Value2, Value3, Model, StartColumn, EndColumn, Enabled) = ('', '', '', -1, -1, -1, 0)
 960         if IfDefList == []:
 961             ErrorMsg = 'Not suited conditional statement in file %s' % Filename
 962             EdkLogger.error("DSC File Parser", PARSER_ERROR, ErrorMsg, Filename, RaiseError=EdkLogger.IsRaiseError)
 963         else:
 964             #
 965             # Get New Dsc item ID
 966             #
 967             DscID = self.TblDsc.GetCount() + 1
 968
 969             #
 970             # Pop the conditional statements which is closed
 971             #
 972             PreviousIf = IfDefList.pop()
 973             EdkLogger.debug(EdkLogger.DEBUG_5, 'Previous IfDef: ' + str(PreviousIf))
 974
 975             #
 976             # !ifdef and !ifndef
 977             #
 978             if PreviousIf[2] in (MODEL_META_DATA_CONDITIONAL_STATEMENT_IFDEF, MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF):
 979                 Value1 = PreviousIf[0]
 980                 Model = PreviousIf[2]
 981                 self.TblDsc.Insert(Model, Value1, Value2, Value3, ArchList, BelongsToItem, self.FileID, PreviousIf[1], StartColumn, EndLine, EndColumn, Enabled)
 982             #
 983             # !if and !elseif
 984             #
 985             elif PreviousIf[2] in (MODEL_META_DATA_CONDITIONAL_STATEMENT_IF, Model):
 986                 List = PreviousIf[0].split(' ')
 987                 Value1, Value2, Value3 = '', '==', '0'
 988                 if len(List) == 3:
 989                     Value1 = List[0]
 990                     Value2 = List[1]
 991                     Value3 = List[2]
 992                     Value3 = SplitString(Value3)
 993                 if len(List) == 1:
 994                     Value1 = List[0]
 995                 Model = PreviousIf[2]
 996                 self.TblDsc.Insert(Model, Value1, Value2, Value3, ArchList, BelongsToItem, self.FileID, PreviousIf[1], StartColumn, EndLine, EndColumn, Enabled)
 997             #
 998             # !else
 999             #
1000             elif PreviousIf[2] in (MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE, Model):
1001                 Value1 = PreviousIf[0].strip()
1002                 Model = PreviousIf[2]
1003                 self.TblDsc.Insert(Model, Value1, Value2, Value3, ArchList, BelongsToItem, self.FileID, PreviousIf[1], StartColumn, EndLine, EndColumn, Enabled)
1004
1005     ## Load Dsc file
1006     #
1007     # Load the file if it exists
1008     #
1009     # @param Filename:  Input value for filename of Dsc file
1010     #
1011     def LoadDscFile(self, Filename):
1012         #
1013         # Insert a record for file
1014         #
1015         Filename = NormPath(Filename)
1016         self.Identification.FileFullPath = Filename
1017         (self.Identification.FileRelativePath, self.Identification.FileName) = os.path.split(Filename)
1018         self.FileID = self.TblFile.InsertFile(Filename, MODEL_FILE_DSC)
1019
1020         #
1021         # Init DscTable
1022         #
1023         #self.TblDsc.Table = "Dsc%s" % FileID
1024         #self.TblDsc.Create()
1025
1026         #
1027         # Init common datas
1028         #
1029         IfDefList, SectionItemList, CurrentSection, ArchList, ThirdList, IncludeFiles = \
1030         [], [], TAB_UNKNOWN, [], [], []
1031         LineNo = 0
1032
1033         #
1034         # Parse file content
1035         #
1036         IsFindBlockComment = False
1037         ReservedLine = ''
1038         for Line in open(Filename, 'r'):
1039             LineNo = LineNo + 1
1040             #
1041             # Remove comment block
1042             #
1043             if Line.find(TAB_COMMENT_EDK_START) > -1:
1044                 ReservedLine = GetSplitList(Line, TAB_COMMENT_EDK_START, 1)[0]
1045                 IsFindBlockComment = True
1046             if Line.find(TAB_COMMENT_EDK_END) > -1:
1047                 Line = ReservedLine + GetSplitList(Line, TAB_COMMENT_EDK_END, 1)[1]
1048                 ReservedLine = ''
1049                 IsFindBlockComment = False
1050             if IsFindBlockComment:
1051                 continue
1052
1053             #
1054             # Remove comments at tail and remove spaces again
1055             #
1056             Line = CleanString(Line)
1057             if Line == '':
1058                 continue
1059
1060             #
1061             # Find a new section tab
1062             # First insert previous section items
1063             # And then parse the content of the new section
1064             #
1065             if Line.startswith(TAB_SECTION_START) and Line.endswith(TAB_SECTION_END):
1066                 #
1067                 # Insert items data of previous section
1068                 #
1069                 self.InsertSectionItemsIntoDatabase(self.FileID, Filename, CurrentSection, SectionItemList, ArchList, ThirdList, IfDefList)
1070                 #
1071                 # Parse the new section
1072                 #
1073                 SectionItemList = []
1074                 ArchList = []
1075                 ThirdList = []
1076
1077                 CurrentSection = ''
1078                 LineList = GetSplitValueList(Line[len(TAB_SECTION_START):len(Line) - len(TAB_SECTION_END)], TAB_COMMA_SPLIT)
1079                 for Item in LineList:
1080                     ItemList = GetSplitValueList(Item, TAB_SPLIT)
1081                     if CurrentSection == '':
1082                         CurrentSection = ItemList[0]
1083                     else:
1084                         if CurrentSection != ItemList[0]:
1085                             EdkLogger.error("Parser", PARSER_ERROR, "Different section names '%s' and '%s' are found in one section definition, this is not allowed." % (CurrentSection, ItemList[0]), File=Filename, Line=LineNo, RaiseError=EdkLogger.IsRaiseError)
1086                     if CurrentSection.upper() not in self.KeyList:
1087                         RaiseParserError(Line, CurrentSection, Filename, '', LineNo)
1088                         CurrentSection = TAB_UNKNOWN
1089                         continue
1090                     ItemList.append('')
1091                     ItemList.append('')
1092                     if len(ItemList) > 5:
1093                         RaiseParserError(Line, CurrentSection, Filename, '', LineNo)
1094                     else:
1095                         if ItemList[1] != '' and ItemList[1].upper() not in ARCH_LIST_FULL:
1096                             EdkLogger.error("Parser", PARSER_ERROR, "Invalid Arch definition '%s' found" % ItemList[1], File=Filename, Line=LineNo, RaiseError=EdkLogger.IsRaiseError)
1097                         ArchList.append(ItemList[1].upper())
1098                         ThirdList.append(ItemList[2])
1099
1100                 continue
1101
1102             #
1103             # Not in any defined section
1104             #
1105             if CurrentSection == TAB_UNKNOWN:
1106                 ErrorMsg = "%s is not in any defined section" % Line
1107                 EdkLogger.error("Parser", PARSER_ERROR, ErrorMsg, File=Filename, Line=LineNo, RaiseError=EdkLogger.IsRaiseError)
1108
1109             #
1110             # Add a section item
1111             #
1112             SectionItemList.append([Line, LineNo])
1113             # End of parse
1114         #End of For
1115
1116         #
1117         # Insert items data of last section
1118         #
1119         self.InsertSectionItemsIntoDatabase(self.FileID, Filename, CurrentSection, SectionItemList, ArchList, ThirdList, IfDefList)
1120
1121         #
1122         # Parse conditional statements
1123         #
1124         self.ParseConditionalStatement()
1125
1126         #
1127         # Replace all DEFINE macros with its actual values
1128         #
1129         #ParseDefineMacro2(self.TblDsc, self.RecordSet, GlobalData.gGlobalDefines)
1130         ParseDefineMacro(self.TblDsc, GlobalData.gGlobalDefines)
1131
1132
1133     ## ParseConditionalStatement
1134     #
1135     # Search all conditional statement and disable no match records
1136     #
1137     def ParseConditionalStatement(self):
1138         #
1139         # Disabled all !if/!elif/!ifdef statements without DEFINE
1140         #
1141         SqlCommand = """select A.StartLine, A.EndLine from %s as A
1142                         where A.Model in (%s, %s, %s)
1143                         and A.Enabled = 0
1144                         and A.BelongsToFile = %s
1145                         and A.Value1 not in (select B.Value1 from %s as B
1146                                              where B.Model = %s
1147                                              and B.Enabled = 0
1148                                              and A.StartLine > B.StartLine
1149                                              and A.Arch = B.Arch
1150                                              and A.BelongsToItem = B.BelongsToItem
1151                                              and A.BelongsToFile = B.BelongsToFile) """ % \
1152                         (self.TblDsc.Table, \
1153                          MODEL_META_DATA_CONDITIONAL_STATEMENT_IF, MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE, MODEL_META_DATA_CONDITIONAL_STATEMENT_IFDEF, \
1154                          self.FileID, \
1155                          self.TblDsc.Table, \
1156                          MODEL_META_DATA_DEFINE)
1157         RecordSet = self.TblDsc.Exec(SqlCommand)
1158         for Record in RecordSet:
1159             SqlCommand = """Update %s set Enabled = -1 where StartLine >= %s and EndLine <= %s""" % (self.TblDsc.Table, Record[0], Record[1])
1160             self.TblDsc.Exec(SqlCommand)
1161
1162         #
1163         # Disabled !ifndef with DEFINE
1164         #
1165         SqlCommand = """select A.StartLine, A.EndLine from %s as A
1166                         where A.Model = %s
1167                         and A.Enabled = 0
1168                         and A.BelongsToFile = %s
1169                         and A.Value1 in (select B.Value1 from %s as B
1170                                          where B.Model = %s
1171                                          and B.Enabled = 0
1172                                          and A.StartLine > B.StartLine
1173                                          and A.Arch = B.Arch
1174                                          and A.BelongsToItem = B.BelongsToItem
1175                                          and A.BelongsToFile = B.BelongsToFile)""" % \
1176                         (self.TblDsc.Table, \
1177                          MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF, \
1178                          self.FileID, \
1179                          self.TblDsc.Table, \
1180                          MODEL_META_DATA_DEFINE)
1181         RecordSet = self.TblDsc.Exec(SqlCommand)
1182         for Record in RecordSet:
1183             SqlCommand = """Update %s set Enabled = -1 where StartLine >= %s and EndLine <= %s""" % (self.TblDsc.Table, Record[0], Record[1])
1184             EdkLogger.debug(4, "SqlCommand: %s" % SqlCommand)
1185             self.Cur.execute(SqlCommand)
1186
1187         #
1188         # Disabled !if, !elif and !else with un-match value
1189         #
1190         SqlCommand = """select A.Model, A.Value1, A.Value2, A.Value3, A.StartLine, A.EndLine, B.Value2 from %s as A join %s as B
1191                         where A.Model in (%s, %s)
1192                         and A.Enabled = 0
1193                         and A.BelongsToFile = %s
1194                         and B.Enabled = 0
1195                         and B.Model = %s
1196                         and A.Value1 = B.Value1
1197                         and A.StartLine > B.StartLine
1198                         and A.BelongsToItem = B.BelongsToItem
1199                         and A.BelongsToFile = B.BelongsToFile""" % \
1200                         (self.TblDsc.Table, self.TblDsc.Table, \
1201                          MODEL_META_DATA_CONDITIONAL_STATEMENT_IF, MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE, \
1202                          self.FileID, MODEL_META_DATA_DEFINE)
1203         RecordSet = self.TblDsc.Exec(SqlCommand)
1204         DisabledList = []
1205         for Record in RecordSet:
1206             if Record[0] == MODEL_META_DATA_CONDITIONAL_STATEMENT_IF:
1207                 if not self.Compare(Record[6], Record[2], Record[3]):
1208                     SqlCommand = """Update %s set Enabled = -1 where StartLine >= %s and EndLine <= %s""" % (self.TblDsc.Table, Record[4], Record[5])
1209                     self.TblDsc.Exec(SqlCommand)
1210                 else:
1211                     DisabledList.append(Record[1])
1212                 continue
1213             if Record[0] == MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE and Record[1] in DisabledList:
1214                 SqlCommand = """Update %s set Enabled = -1 where StartLine >= %s and EndLine <= %s""" % (self.TblDsc.Table, Record[4], Record[5])
1215                 self.TblDsc.Exec(SqlCommand)
1216
1217     ## Compare
1218     #
1219     # Compare two values
1220     # @param Value1:
1221     # @param CompareType:
1222     # @param Value2:
1223     #
1224     def Compare(self, Value1, CompareType, Value2):
1225         Command = """Value1 %s Value2""" % CompareType
1226         return eval(Command)
1227
1228     ## First time to insert records to database
1229     #
1230     # Insert item data of a section to database
1231     # @param FileID:           The ID of belonging file
1232     # @param Filename:         The name of belonging file
1233     # @param CurrentSection:   The name of currect section
1234     # @param SectionItemList:  A list of items of the section
1235     # @param ArchList:         A list of arches
1236     # @param ThirdList:        A list of third parameters, ModuleType for LibraryClass and SkuId for Dynamic Pcds
1237     # @param IfDefList:        A list of all conditional statements
1238     #
1239     def InsertSectionItemsIntoDatabase(self, FileID, Filename, CurrentSection, SectionItemList, ArchList, ThirdList, IfDefList):
1240         #
1241         # Insert each item data of a section
1242         #
1243         for Index in range(0, len(ArchList)):
1244             Arch = ArchList[Index]
1245             Third = ThirdList[Index]
1246             if Arch == '':
1247                 Arch = TAB_ARCH_COMMON.upper()
1248
1249             Model = Section[CurrentSection.upper()]
1250             #Records = self.RecordSet[Model]
1251
1252             for SectionItem in SectionItemList:
1253                 BelongsToItem, EndLine, EndColumn = -1, -1, -1
1254                 LineValue, StartLine, EndLine = SectionItem[0], SectionItem[1], SectionItem[1]
1255
1256
1257                 EdkLogger.debug(4, "Parsing %s ..." % LineValue)
1258                 #
1259                 # Parse '!ifdef'
1260                 #
1261                 if LineValue.upper().find(TAB_IF_DEF.upper()) > -1:
1262                     IfDefList.append((LineValue[len(TAB_IF_N_DEF):].strip(), StartLine, MODEL_META_DATA_CONDITIONAL_STATEMENT_IFDEF))
1263                     continue
1264
1265                 #
1266                 # Parse '!ifndef'
1267                 #
1268                 if LineValue.upper().find(TAB_IF_N_DEF.upper()) > -1:
1269                     IfDefList.append((LineValue[len(TAB_IF_N_DEF):].strip(), StartLine, MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF))
1270                     continue
1271
1272                 #
1273                 # Parse '!endif'
1274                 #
1275                 if LineValue.upper().find(TAB_END_IF.upper()) > -1:
1276                     self.InsertConditionalStatement(Filename, FileID, Model, IfDefList, StartLine, Arch)
1277                     continue
1278                 #
1279                 # Parse '!if'
1280                 #
1281                 if LineValue.upper().find(TAB_IF.upper()) > -1:
1282                     IfDefList.append((LineValue[len(TAB_IF):].strip(), StartLine, MODEL_META_DATA_CONDITIONAL_STATEMENT_IF))
1283                     continue
1284
1285                 #
1286                 # Parse '!elseif'
1287                 #
1288                 if LineValue.upper().find(TAB_ELSE_IF.upper()) > -1:
1289                     self.InsertConditionalStatement(Filename, FileID, Model, IfDefList, StartLine - 1, Arch)
1290                     IfDefList.append((LineValue[len(TAB_ELSE_IF):].strip(), StartLine, MODEL_META_DATA_CONDITIONAL_STATEMENT_IF))
1291                     continue
1292
1293                 #
1294                 # Parse '!else'
1295                 #
1296                 if LineValue.upper().find(TAB_ELSE.upper()) > -1:
1297                     Key = IfDefList[-1][0].split(' ' , 1)[0].strip()
1298                     self.InsertConditionalStatement(Filename, FileID, Model, IfDefList, StartLine, Arch)
1299                     IfDefList.append((Key, StartLine, MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE))
1300                     continue
1301
1302                 #
1303                 # Parse !include statement first
1304                 #
1305                 if LineValue.upper().find(DataType.TAB_INCLUDE.upper() + ' ') > -1:
1306                     self.ParseInclude(LineValue, StartLine, self.TblDsc, FileID, Filename, CurrentSection, MODEL_META_DATA_INCLUDE, Arch)
1307                     continue
1308
1309                 #
1310                 # And then parse DEFINE statement
1311                 #
1312                 if LineValue.upper().find(DataType.TAB_DEFINE.upper() + ' ') > -1:
1313                     self.ParseDefine(LineValue, StartLine, self.TblDsc, FileID, Filename, CurrentSection, MODEL_META_DATA_DEFINE, Arch)
1314                     continue
1315
1316                 #
1317                 # At last parse other sections
1318                 #
1319                 if CurrentSection == TAB_LIBRARY_CLASSES or CurrentSection in TAB_PCD_DYNAMIC_TYPE_LIST or CurrentSection in TAB_PCD_DYNAMIC_EX_TYPE_LIST:
1320                     ID = self.TblDsc.Insert(Model, LineValue, Third, '', Arch, -1, FileID, StartLine, -1, StartLine, -1, 0)
1321                     #Records.append([LineValue, Arch, StartLine, ID, Third])
1322                     continue
1323                 elif CurrentSection != TAB_COMPONENTS:
1324                     ID = self.TblDsc.Insert(Model, LineValue, '', '', Arch, -1, FileID, StartLine, -1, StartLine, -1, 0)
1325                     #Records.append([LineValue, Arch, StartLine, ID, Third])
1326                     continue
1327
1328             #
1329             # Parse COMPONENT section
1330             #
1331             if CurrentSection == TAB_COMPONENTS:
1332                 Components = []
1333                 GetComponent(SectionItemList, Components)
1334                 for Component in Components:
1335                     EdkLogger.debug(4, "Parsing component %s ..." % Component)
1336                     DscItmeID = self.TblDsc.Insert(MODEL_META_DATA_COMPONENT, Component[0], '', '', Arch, -1, FileID, StartLine, -1, StartLine, -1, 0)
1337                     for Item in Component[1]:
1338                         List = GetSplitValueList(Item, MaxSplit=2)
1339                         LibName, LibIns = '', ''
1340                         if len(List) == 2:
1341                             LibName = List[0]
1342                             LibIns = List[1]
1343                         else:
1344                             LibName = List[0]
1345                         self.TblDsc.Insert(MODEL_EFI_LIBRARY_CLASS, LibName, LibIns, '', Arch, DscItmeID, FileID, StartLine, -1, StartLine, -1, 0)
1346                     for Item in Component[2]:
1347                         self.TblDsc.Insert(MODEL_META_DATA_BUILD_OPTION, Item, '', '', Arch, DscItmeID, FileID, StartLine, -1, StartLine, -1, 0)
1348                     for Item in Component[3]:
1349                         Model = Section[Item[0].upper()]
1350                         self.TblDsc.Insert(Model, Item[1], '', '', Arch, DscItmeID, FileID, StartLine, -1, StartLine, -1, 0)
1351
1352     ## Show detailed information of Dsc
1353     #
1354     # Print all members and their values of Dsc class
1355     #
1356     def ShowDsc(self):
1357         print TAB_SECTION_START + TAB_INF_DEFINES + TAB_SECTION_END
1358         printDict(self.Defines.DefinesDictionary)
1359
1360         for Key in self.KeyList:
1361             for Arch in DataType.ARCH_LIST_FULL:
1362                 Command = "printList(TAB_SECTION_START + '" + \
1363                                     Key + DataType.TAB_SPLIT + Arch + \
1364                                     "' + TAB_SECTION_END, self.Contents[arch]." + Key + ')'
1365                 eval(Command)
1366
1367     ## Show detailed information of Platform
1368     #
1369     # Print all members and their values of Platform class
1370     #
1371     def ShowPlatform(self):
1372         M = self.Platform
1373         for Arch in M.Header.keys():
1374             print '\nArch =', Arch
1375             print 'Filename =', M.Header[Arch].FileName
1376             print 'FullPath =', M.Header[Arch].FullPath
1377             print 'BaseName =', M.Header[Arch].Name
1378             print 'Guid =', M.Header[Arch].Guid
1379             print 'Version =', M.Header[Arch].Version
1380             print 'DscSpecification =', M.Header[Arch].DscSpecification
1381             print 'SkuId =', M.Header[Arch].SkuIdName
1382             print 'SupArchList =', M.Header[Arch].SupArchList
1383             print 'BuildTargets =', M.Header[Arch].BuildTargets
1384             print 'OutputDirectory =', M.Header[Arch].OutputDirectory
1385             print 'BuildNumber =', M.Header[Arch].BuildNumber
1386             print 'MakefileName =', M.Header[Arch].MakefileName
1387             print 'BsBaseAddress =', M.Header[Arch].BsBaseAddress
1388             print 'RtBaseAddress =', M.Header[Arch].RtBaseAddress
1389             print 'Define =', M.Header[Arch].Define
1390         print 'Fdf =', M.FlashDefinitionFile.FilePath
1391         print '\nBuildOptions =', M.BuildOptions, M.BuildOptions.IncludeFiles
1392         for Item in M.BuildOptions.BuildOptionList:
1393             print '\t', 'ToolChainFamily =', Item.ToolChainFamily, 'ToolChain =', Item.ToolChain, 'Option =', Item.Option, 'Arch =', Item.SupArchList
1394         print '\nSkuIds =', M.SkuInfos.SkuInfoList, M.SkuInfos.IncludeFiles
1395         print '\nLibraries =', M.Libraries, M.Libraries.IncludeFiles
1396         for Item in M.Libraries.LibraryList:
1397             print '\t', Item.FilePath, Item.SupArchList, Item.Define
1398         print '\nLibraryClasses =', M.LibraryClasses, M.LibraryClasses.IncludeFiles
1399         for Item in M.LibraryClasses.LibraryList:
1400             print '\t', Item.Name, Item.FilePath, Item.SupModuleList, Item.SupArchList, Item.Define
1401         print '\nPcds =', M.DynamicPcdBuildDefinitions
1402         for Item in M.DynamicPcdBuildDefinitions:
1403             print '\tCname=', Item.CName, 'TSG=', Item.TokenSpaceGuidCName, 'Value=', Item.DefaultValue, 'Token=', Item.Token, 'Type=', Item.ItemType, 'Datum=', Item.DatumType, 'Size=', Item.MaxDatumSize, 'Arch=', Item.SupArchList, Item.SkuInfoList
1404             for Sku in Item.SkuInfoList.values():
1405                 print '\t\t', str(Sku)
1406         print '\nComponents =', M.Modules.ModuleList, M.Modules.IncludeFiles
1407         for Item in M.Modules.ModuleList:
1408             print '\t', Item.FilePath, Item.ExecFilePath, Item.SupArchList
1409             for Lib in Item.LibraryClasses.LibraryList:
1410                 print '\t\tLib:', Lib.Name, Lib.FilePath
1411             for Bo in Item.ModuleSaBuildOption.BuildOptionList:
1412                 print '\t\tBuildOption:', Bo.ToolChainFamily, Bo.ToolChain, Bo.Option
1413             for Pcd in Item.PcdBuildDefinitions:
1414                 print '\t\tPcd:', Pcd.CName, Pcd.TokenSpaceGuidCName, Pcd.MaxDatumSize, Pcd.DefaultValue, Pcd.ItemType
1415
1416 ##
1417 #
1418 # This acts like the main() function for the script, unless it is 'import'ed into another
1419 # script.
1420 #
1421 if __name__ == '__main__':
1422     EdkLogger.Initialize()
1423     EdkLogger.SetLevel(EdkLogger.DEBUG_0)
1424
1425     W = os.getenv('WORKSPACE')
1426     F = os.path.join(W, 'Nt32Pkg/Nt32Pkg.dsc')
1427
1428     Db = Database.Database('Dsc.db')
1429     Db.InitDatabase()
1430
1431     P = Dsc(os.path.normpath(F), True, True, W, Db)
1432     P.ShowPlatform()
1433
1434     Db.Close()