Fixed an issue which the value of PCD from FDF file is not correct.
[people/mcb30/basetools.git] / Source / Python / Common / EdkIIWorkspaceBuild.py
1 ## @file\r
2 # This file is used to define each component of the build database\r
3 #\r
4 # Copyright (c) 2007, Intel Corporation\r
5 # All rights reserved. This program and the accompanying materials\r
6 # are licensed and made available under the terms and conditions of the BSD License\r
7 # which accompanies this distribution.  The full text of the license may be found at\r
8 # http://opensource.org/licenses/bsd-license.php\r
9 #\r
10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
12 #\r
13 \r
14 ##\r
15 # Import Modules\r
16 #\r
17 import os, string, copy, pdb, copy\r
18 import EdkLogger\r
19 import DataType\r
20 from InfClassObject import *\r
21 from DecClassObject import *\r
22 from DscClassObject import *\r
23 from String import *\r
24 from BuildToolError import *\r
25 from Misc import sdict\r
26 from CommonDataClass.CommonClass import *\r
27 \r
28 ## PcdClassObject\r
29 #\r
30 # This Class is used for PcdObject\r
31\r
32 # @param object:             Inherited from object class\r
33 # @param Name:               Input value for Name of Pcd, default is None\r
34 # @param Guid:               Input value for Guid of Pcd, default is None\r
35 # @param Type:               Input value for Type of Pcd, default is None\r
36 # @param DatumType:          Input value for DatumType of Pcd, default is None\r
37 # @param Value:              Input value for Value of Pcd, default is None\r
38 # @param Token:              Input value for Token of Pcd, default is None\r
39 # @param MaxDatumSize:       Input value for MaxDatumSize of Pcd, default is None\r
40 # @param SkuInfoList:        Input value for SkuInfoList of Pcd, default is {}\r
41 # @param IsOverrided:        Input value for IsOverrided of Pcd, default is False\r
42 #\r
43 # @var TokenCName:           To store value for TokenCName\r
44 # @var TokenSpaceGuidCName:  To store value for TokenSpaceGuidCName\r
45 # @var Type:                 To store value for Type\r
46 # @var DatumType:            To store value for DatumType\r
47 # @var TokenValue:           To store value for TokenValue\r
48 # @var MaxDatumSize:         To store value for MaxDatumSize\r
49 # @var SkuInfoList:          To store value for SkuInfoList\r
50 # @var IsOverrided:          To store value for IsOverrided\r
51 # @var Phase:                To store value for Phase, default is "DXE"\r
52 #\r
53 class PcdClassObject(object):\r
54     def __init__(self, Name = None, Guid = None, Type = None, DatumType = None, Value = None, Token = None, MaxDatumSize = None, SkuInfoList = {}, IsOverrided = False):\r
55         self.TokenCName = Name\r
56         self.TokenSpaceGuidCName = Guid\r
57         self.Type = Type\r
58         self.DatumType = DatumType\r
59         self.DefaultValue = Value\r
60         self.TokenValue = Token\r
61         self.MaxDatumSize = MaxDatumSize\r
62         self.SkuInfoList = SkuInfoList\r
63         self.IsOverrided = IsOverrided\r
64         self.Phase = "DXE"\r
65 \r
66     ## Convert the class to a string\r
67     #\r
68     #  Convert each member of the class to string\r
69     #  Organize to a signle line format string\r
70     #\r
71     #  @retval Rtn Formatted String\r
72     #\r
73     def __str__(self):\r
74         Rtn = '\tTokenCName=' + str(self.TokenCName) + ', ' + \\r
75               'TokenSpaceGuidCName=' + str(self.TokenSpaceGuidCName) + ', ' + \\r
76               'Type=' + str(self.Type) + ', ' + \\r
77               'DatumType=' + str(self.DatumType) + ', ' + \\r
78               'DefaultValue=' + str(self.DefaultValue) + ', ' + \\r
79               'TokenValue=' + str(self.TokenValue) + ', ' + \\r
80               'MaxDatumSize=' + str(self.MaxDatumSize) + ', '\r
81         for Item in self.SkuInfoList.values():\r
82             Rtn = Rtn + 'SkuId=' + Item.SkuId + ', ' + 'SkuIdName=' + Item.SkuIdName\r
83         Rtn = Rtn + str(self.IsOverrided)\r
84 \r
85         return Rtn\r
86 \r
87     ## Override __eq__ function\r
88     #\r
89     # Check whether pcds are the same\r
90     #\r
91     # @retval False The two pcds are different\r
92     # @retval True  The two pcds are the same\r
93     #\r
94     def __eq__(self, Other):\r
95         return Other != None and self.TokenCName == Other.TokenCName and self.TokenSpaceGuidCName == Other.TokenSpaceGuidCName\r
96 \r
97     ## Override __hash__ function\r
98     #\r
99     # Use (TokenCName, TokenSpaceGuidCName) as key in hash table\r
100     #\r
101     # @retval truple() Key for hash table\r
102     #\r
103     def __hash__(self):\r
104         return hash((self.TokenCName, self.TokenSpaceGuidCName))\r
105 \r
106 ## LibraryClassObject\r
107 #\r
108 # This Class defines LibraryClassObject used in BuildDatabase\r
109\r
110 # @param object:      Inherited from object class\r
111 # @param Name:        Input value for LibraryClassName, default is None\r
112 # @param SupModList:  Input value for SupModList, default is []\r
113 # @param Type:        Input value for Type, default is None\r
114 #\r
115 # @var LibraryClass:  To store value for LibraryClass\r
116 # @var SupModList:    To store value for SupModList\r
117 # @var Type:          To store value for Type\r
118 #\r
119 class LibraryClassObject(object):\r
120     def __init__(self, Name = None, SupModList = [], Type = None):\r
121         self.LibraryClass = Name\r
122         self.SupModList = SupModList\r
123         if Type != None:\r
124             self.SupModList = CleanString(Type).split(DataType.TAB_SPACE_SPLIT)\r
125 \r
126 ## ModuleBuildClassObject\r
127 #\r
128 # This Class defines ModuleBuildClass\r
129\r
130 # @param object:               Inherited from object class\r
131 #\r
132 # @var DescFilePath:           To store value for DescFilePath\r
133 # @var BaseName:               To store value for BaseName\r
134 # @var ModuleType:             To store value for ModuleType\r
135 # @var Guid:                   To store value for Guid\r
136 # @var Version:                To store value for Version\r
137 # @var PcdIsDriver:            To store value for PcdIsDriver\r
138 # @var BinaryModule:           To store value for BinaryModule\r
139 # @var CustomMakefile:         To store value for CustomMakefile\r
140 # @var Specification:          To store value for Specification\r
141 # @var Shadow                  To store value for Shadow\r
142 # @var LibraryClass:           To store value for LibraryClass, it is a list structure as\r
143 #                              [ LibraryClassObject, ...]\r
144 # @var ModuleEntryPointList:   To store value for ModuleEntryPointList\r
145 # @var ModuleUnloadImageList:  To store value for ModuleUnloadImageList\r
146 # @var ConstructorList:        To store value for ConstructorList\r
147 # @var DestructorList:         To store value for DestructorList\r
148 # @var Binaries:               To store value for Binaries, it is a list structure as\r
149 #                              [ ModuleBinaryClassObject, ...]\r
150 # @var Sources:                To store value for Sources, it is a list structure as\r
151 #                              [ ModuleSourceFilesClassObject, ... ]\r
152 # @var LibraryClasses:         To store value for LibraryClasses, it is a set structure as\r
153 #                              { [LibraryClassName, ModuleType] : LibraryClassInfFile }\r
154 # @var Protocols:              To store value for Protocols, it is a list structure as\r
155 #                              [ ProtocolName, ... ]\r
156 # @var Ppis:                   To store value for Ppis, it is a list structure as\r
157 #                              [ PpiName, ... ]\r
158 # @var Guids:                  To store value for Guids, it is a list structure as\r
159 #                              [ GuidName, ... ]\r
160 # @var Includes:               To store value for Includes, it is a list structure as\r
161 #                              [ IncludePath, ... ]\r
162 # @var Packages:               To store value for Packages, it is a list structure as\r
163 #                              [ DecFileName, ... ]\r
164 # @var Pcds:                   To store value for Pcds, it is a set structure as\r
165 #                              { [(PcdCName, PcdGuidCName)] : PcdClassObject}\r
166 # @var BuildOptions:           To store value for BuildOptions, it is a set structure as\r
167 #                              { [BuildOptionKey] : BuildOptionValue}\r
168 # @var Depex:                  To store value for Depex\r
169 #\r
170 class ModuleBuildClassObject(object):\r
171     def __init__(self):\r
172         self.AutoGenVersion          = 0\r
173         self.DescFilePath            = ''\r
174         self.BaseName                = ''\r
175         self.ModuleType              = ''\r
176         self.Guid                    = ''\r
177         self.Version                 = ''\r
178         self.PcdIsDriver             = ''\r
179         self.BinaryModule            = ''\r
180         self.Shadow                  = ''\r
181         self.CustomMakefile          = {}\r
182         self.Specification           = {}\r
183         self.LibraryClass            = []\r
184         self.ModuleEntryPointList    = []\r
185         self.ModuleUnloadImageList   = []\r
186         self.ConstructorList         = []\r
187         self.DestructorList          = []\r
188 \r
189         self.Binaries                = []\r
190         self.Sources                 = []\r
191         self.LibraryClasses          = {}\r
192         self.Libraries               = []\r
193         self.Protocols               = []\r
194         self.Ppis                    = []\r
195         self.Guids                   = []\r
196         self.Includes                = []\r
197         self.Packages                = []\r
198         self.Pcds                    = {}\r
199         self.BuildOptions            = {}\r
200         self.Depex                   = ''\r
201 \r
202     ## Convert the class to a string\r
203     #\r
204     #  Convert member DescFilePath of the class to a string\r
205     #\r
206     #  @retval string Formatted String\r
207     #\r
208     def __str__(self):\r
209         return self.DescFilePath\r
210 \r
211     ## Override __eq__ function\r
212     #\r
213     # Check whether ModuleBuildClassObjects are the same\r
214     #\r
215     # @retval False The two ModuleBuildClassObjects are different\r
216     # @retval True  The two ModuleBuildClassObjects are the same\r
217     #\r
218     def __eq__(self, Other):\r
219         return self.DescFilePath == str(Other)\r
220 \r
221     ## Override __hash__ function\r
222     #\r
223     # Use DescFilePath as key in hash table\r
224     #\r
225     # @retval string Key for hash table\r
226     #\r
227     def __hash__(self):\r
228         return hash(self.DescFilePath)\r
229 \r
230 ## PackageBuildClassObject\r
231 #\r
232 # This Class defines PackageBuildClass\r
233\r
234 # @param object:        Inherited from object class\r
235 #\r
236 # @var DescFilePath:    To store value for DescFilePath\r
237 # @var PackageName:     To store value for PackageName\r
238 # @var Guid:            To store value for Guid\r
239 # @var Version:         To store value for Version\r
240 # @var Protocols:       To store value for Protocols, it is a set structure as\r
241 #                       { [ProtocolName] : Protocol Guid, ... }\r
242 # @var Ppis:            To store value for Ppis, it is a set structure as\r
243 #                       { [PpiName] : Ppi Guid, ... }\r
244 # @var Guids:           To store value for Guids, it is a set structure as\r
245 #                       { [GuidName] : Guid, ... }\r
246 # @var Includes:        To store value for Includes, it is a list structure as\r
247 #                       [ IncludePath, ... ]\r
248 # @var LibraryClasses:  To store value for LibraryClasses, it is a set structure as\r
249 #                       { [LibraryClassName] : LibraryClassInfFile }\r
250 # @var Pcds:            To store value for Pcds, it is a set structure as\r
251 #                       { [(PcdCName, PcdGuidCName)] : PcdClassObject}\r
252 #\r
253 class PackageBuildClassObject(object):\r
254     def __init__(self):\r
255         self.DescFilePath            = ''\r
256         self.PackageName             = ''\r
257         self.Guid                    = ''\r
258         self.Version                 = ''\r
259 \r
260         self.Protocols               = {}\r
261         self.Ppis                    = {}\r
262         self.Guids                   = {}\r
263         self.Includes                = []\r
264         self.LibraryClasses          = {}\r
265         self.Pcds                    = {}\r
266 \r
267     ## Convert the class to a string\r
268     #\r
269     #  Convert member DescFilePath of the class to a string\r
270     #\r
271     #  @retval string Formatted String\r
272     #\r
273     def __str__(self):\r
274         return self.DescFilePath\r
275 \r
276     ## Override __eq__ function\r
277     #\r
278     # Check whether PackageBuildClassObjects are the same\r
279     #\r
280     # @retval False The two PackageBuildClassObjects are different\r
281     # @retval True  The two PackageBuildClassObjects are the same\r
282     #\r
283     def __eq__(self, Other):\r
284         return self.DescFilePath == str(Other)\r
285 \r
286     ## Override __hash__ function\r
287     #\r
288     # Use DescFilePath as key in hash table\r
289     #\r
290     # @retval string Key for hash table\r
291     #\r
292     def __hash__(self):\r
293         return hash(self.DescFilePath)\r
294 \r
295 ## PlatformBuildClassObject\r
296 #\r
297 # This Class defines PlatformBuildClass\r
298\r
299 # @param object:          Inherited from object class\r
300 #\r
301 # @var DescFilePath:      To store value for DescFilePath\r
302 # @var PlatformName:      To store value for PlatformName\r
303 # @var Guid:              To store value for Guid\r
304 # @var Version:           To store value for Version\r
305 # @var DscSpecification:  To store value for DscSpecification\r
306 # @var OutputDirectory:   To store value for OutputDirectory\r
307 # @var FlashDefinition:   To store value for FlashDefinition\r
308 # @var BuildNumber:       To store value for BuildNumber\r
309 # @var MakefileName:      To store value for MakefileName\r
310 # @var SkuIds:            To store value for SkuIds, it is a set structure as\r
311 #                         { 'SkuName' : SkuId, '!include' : includefilename, ...}\r
312 # @var Modules:           To store value for Modules, it is a list structure as\r
313 #                         [ InfFileName, ... ]\r
314 # @var Libraries:         To store value for Libraries, it is a list structure as\r
315 #                         [ InfFileName, ... ]\r
316 # @var LibraryClasses:    To store value for LibraryClasses, it is a set structure as\r
317 #                         { (LibraryClassName, ModuleType) : LibraryClassInfFile }\r
318 # @var Pcds:              To store value for Pcds, it is a set structure as\r
319 #                         { [(PcdCName, PcdGuidCName)] : PcdClassObject }\r
320 # @var BuildOptions:      To store value for BuildOptions, it is a set structure as\r
321 #                         { [BuildOptionKey] : BuildOptionValue }\r
322 #\r
323 class PlatformBuildClassObject(object):\r
324     def __init__(self):\r
325         self.DescFilePath            = ''\r
326         self.PlatformName            = ''\r
327         self.Guid                    = ''\r
328         self.Version                 = ''\r
329         self.DscSpecification        = ''\r
330         self.OutputDirectory         = ''\r
331         self.FlashDefinition         = ''\r
332         self.BuildNumber             = ''\r
333         self.MakefileName            = ''\r
334 \r
335         self.SkuIds                  = {}\r
336         self.Modules                 = []\r
337         self.LibraryInstances        = []\r
338         self.LibraryClasses          = {}\r
339         self.Libraries               = {}\r
340         self.Pcds                    = {}\r
341         self.BuildOptions            = {}\r
342 \r
343     ## Convert the class to a string\r
344     #\r
345     #  Convert member DescFilePath of the class to a string\r
346     #\r
347     #  @retval string Formatted String\r
348     #\r
349     def __str__(self):\r
350         return self.DescFilePath\r
351 \r
352     ## Override __eq__ function\r
353     #\r
354     # Check whether PlatformBuildClassObjects are the same\r
355     #\r
356     # @retval False The two PlatformBuildClassObjects are different\r
357     # @retval True  The two PlatformBuildClassObjects are the same\r
358     #\r
359     def __eq__(self, other):\r
360         return self.DescFilePath == str(other)\r
361 \r
362     ## Override __hash__ function\r
363     #\r
364     # Use DescFilePath as key in hash table\r
365     #\r
366     # @retval string Key for hash table\r
367     #\r
368     def __hash__(self):\r
369         return hash(self.DescFilePath)\r
370 \r
371 ## ItemBuild\r
372 #\r
373 # This Class defines Module/Platform/Package databases for build system\r
374 #\r
375 # @param object:          Inherited from object class\r
376 # @param Arch:            Build arch\r
377 # @param Platform:        Build Platform\r
378 # @param Package:         Build Package\r
379 # @param Module:          Build Module\r
380 #\r
381 # @var Arch:              To store value for Build Arch\r
382 # @var PlatformDatabase:  To store value for PlatformDatabase, it is a set structure as\r
383 #                         { [DscFileName] : PlatformBuildClassObject, ...}\r
384 # @var PackageDatabase:   To store value for PackageDatabase, it is a set structure as\r
385 #                         { [DecFileName] : PacakgeBuildClassObject, ...}\r
386 # @var ModuleDatabase:    To store value for ModuleDatabase, it is a list structure as\r
387 #                         { [InfFileName] : ModuleBuildClassObject, ...}\r
388 #\r
389 class ItemBuild(object):\r
390     def __init__(self, Arch, Platform = None, Package = None, Module = None):\r
391         self.Arch                    = Arch\r
392         self.PlatformDatabase        = {}\r
393         self.PackageDatabase         = {}\r
394         self.ModuleDatabase          = {}\r
395 \r
396 ## WorkspaceBuild\r
397 #\r
398 # This class is used to parse active platform to init all inf/dec/dsc files\r
399 # Generate module/package/platform databases for build\r
400 #\r
401 # @param object:          Inherited from object class\r
402 # @param ActivePlatform:  Input value for current active platform\r
403 # @param WorkspaceDir:    Input value for current WorkspaceDir\r
404 #\r
405 # @var WorkspaceDir:      To store value for WorkspaceDir\r
406 # @var SupArchList:       To store value for SupArchList, selection scope is in below list\r
407 #                         EBC | IA32 | X64 | IPF | ARM | PPC\r
408 # @var BuildTarget:       To store value for WorkspaceDir, selection scope is in below list\r
409 #                         RELEASE | DEBUG\r
410 # @var SkuId:             To store value for SkuId\r
411 # @var Fdf:               To store value for Fdf\r
412 # @var FdTargetList:      To store value for FdTargetList\r
413 # @var FvTargetList:      To store value for FvTargetList\r
414 # @var TargetTxt:         To store value for TargetTxt, it is a set structure as\r
415 #                         TargetTxtClassObject\r
416 # @var ToolDef:           To store value for ToolDef, it is a set structure as\r
417 #                         ToolDefClassObject\r
418 # @var InfDatabase:       To store value for InfDatabase, it is a set structure as\r
419 #                         { [InfFileName] : InfClassObject}\r
420 # @var DecDatabase:       To store value for DecDatabase, it is a set structure as\r
421 #                         { [DecFileName] : DecClassObject}\r
422 # @var DscDatabase:       To store value for DscDatabase, it is a set structure as\r
423 #                         { [DscFileName] : DscClassObject}\r
424 # @var Build:             To store value for DscDatabase, it is a set structure as\r
425 #                         ItemBuild\r
426 # @var DscFileName:       To store value for Active Platform\r
427 # @var UnFoundPcdInDsc:   To store values for the pcds defined in INF/DEC but not found in DSC, it is a set structure as\r
428 #                         { (PcdGuid, PcdCName, Arch) : DecFileName }\r
429 #\r
430 class WorkspaceBuild(object):\r
431     def __init__(self, ActivePlatform, WorkspaceDir):\r
432         self.WorkspaceDir            = NormPath(WorkspaceDir)\r
433         self.SupArchList             = []\r
434         self.BuildTarget             = []\r
435         self.SkuId                   = ''\r
436         self.Fdf                     = ''\r
437         self.FdTargetList            = []\r
438         self.FvTargetList            = []\r
439         self.TargetTxt               = None\r
440         self.ToolDef                 = None\r
441 \r
442         self.InfDatabase             = {}\r
443         self.DecDatabase             = {}\r
444         self.DscDatabase             = {}\r
445         \r
446         self.UnFoundPcdInDsc         = {}\r
447 \r
448         #\r
449         # Init build for all arches\r
450         #\r
451         self.Build                   = {}\r
452         for Arch in DataType.ARCH_LIST:\r
453             self.Build[Arch] = ItemBuild(Arch)\r
454 \r
455         #\r
456         # Get active platform\r
457         #\r
458         self.DscFileName = NormPath(ActivePlatform)\r
459         File = self.WorkspaceFile(self.DscFileName)\r
460         if os.path.exists(File) and os.path.isfile(File):\r
461             self.DscDatabase[self.DscFileName] = Dsc(File, True, True, self.WorkspaceDir)\r
462         else:\r
463             EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData = File)\r
464 \r
465         #\r
466         # Parse platform to get module\r
467         #\r
468         for DscFile in self.DscDatabase.keys():\r
469             Platform = self.DscDatabase[DscFile].Platform\r
470 \r
471             #\r
472             # Get global information\r
473             #\r
474             self.SupArchList = Platform.Header.SupArchList\r
475             self.BuildTarget = Platform.Header.BuildTargets\r
476             self.SkuId = Platform.Header.SkuIdName\r
477             self.Fdf = Platform.FlashDefinitionFile.FilePath\r
478 \r
479             #\r
480             # Get all inf files\r
481             #\r
482             for Item in Platform.LibraryClasses.LibraryList:\r
483                 for Arch in Item.SupArchList:\r
484                     self.AddToInfDatabase(Item.FilePath)\r
485 \r
486             for Item in Platform.Libraries.LibraryList:\r
487                 for Arch in Item.SupArchList:\r
488                     self.AddToInfDatabase(Item.FilePath)\r
489 \r
490             for Item in Platform.Modules.ModuleList:\r
491                 for Arch in Item.SupArchList:\r
492                     #\r
493                     # Add modules\r
494                     #\r
495                     Module = Item.FilePath\r
496                     self.AddToInfDatabase(Module)\r
497                     #\r
498                     # Add library used in modules\r
499                     #\r
500                     for Lib in Item.LibraryClasses.LibraryList:\r
501                         self.AddToInfDatabase(Lib.FilePath)\r
502                         self.UpdateLibraryClassOfModule(Module, Lib.Name, Arch, Lib.FilePath)\r
503 \r
504         #\r
505         # Parse module to get package\r
506         #\r
507         for InfFile in self.InfDatabase.keys():\r
508             Module = self.InfDatabase[InfFile].Module\r
509             #\r
510             # Get all dec\r
511             #\r
512             for Item in Module.PackageDependencies:\r
513                 for Arch in Item.SupArchList:\r
514                     self.AddToDecDatabase(Item.FilePath)\r
515     # End of self.Init()\r
516 \r
517     ## Generate PlatformDatabase\r
518     #\r
519     # Go through each arch to get all items in DscDatabase to PlatformDatabase\r
520     #\r
521     def GenPlatformDatabase(self, PcdsSet={}):\r
522         for Dsc in self.DscDatabase.keys():\r
523             Platform = self.DscDatabase[Dsc].Platform\r
524 \r
525             for Arch in self.SupArchList:\r
526                 Pb = PlatformBuildClassObject()\r
527 \r
528                 #\r
529                 # Defines\r
530                 #\r
531                 Pb.DescFilePath = Dsc\r
532                 Pb.PlatformName = Platform.Header.Name\r
533                 Pb.Guid = Platform.Header.Guid\r
534                 Pb.Version = Platform.Header.Version\r
535                 Pb.DscSpecification = Platform.Header.DscSpecification\r
536                 Pb.OutputDirectory = Platform.Header.OutputDirectory\r
537                 Pb.FlashDefinition = Platform.FlashDefinitionFile.FilePath\r
538                 Pb.BuildNumber = Platform.Header.BuildNumber\r
539 \r
540                 #\r
541                 # SkuId\r
542                 #\r
543                 for Key in Platform.SkuInfos.SkuInfoList.keys():\r
544                     Pb.SkuIds[Key] = Platform.SkuInfos.SkuInfoList[Key]\r
545 \r
546                 #\r
547                 # Module\r
548                 #\r
549                 for Item in Platform.Modules.ModuleList:\r
550                     if Arch in Item.SupArchList:\r
551                         Pb.Modules.append(Item.FilePath)\r
552 \r
553                 #\r
554                 # BuildOptions\r
555                 #\r
556                 for Item in Platform.BuildOptions.BuildOptionList:\r
557                     if Arch in Item.SupArchList:\r
558                         Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = Item.Option\r
559 \r
560                 #\r
561                 # LibraryClass\r
562                 #\r
563                 for Item in Platform.LibraryClasses.LibraryList:\r
564                     SupModuleList = self.FindSupModuleListOfLibraryClass(Item, Platform.LibraryClasses.LibraryList, Arch)\r
565                     if Arch in Item.SupArchList:\r
566                         for ModuleType in SupModuleList:\r
567                             Pb.LibraryClasses[(Item.Name, ModuleType)] = Item.FilePath\r
568 \r
569                 #\r
570                 # Libraries\r
571                 # \r
572                 for Item in Platform.Libraries.LibraryList:\r
573                     for Arch in Item.SupArchList:\r
574                         Library = self.InfDatabase[Item.FilePath]\r
575                         Pb.Libraries[Library.Module.Header.Name] = Item.FilePath\r
576                 \r
577                 #\r
578                 # Pcds\r
579                 #\r
580                 for Item in Platform.DynamicPcdBuildDefinitions:\r
581                     if Arch in Item.SupArchList:\r
582                         Name = Item.CName\r
583                         Guid = Item.TokenSpaceGuidCName\r
584                         Type = Item.ItemType\r
585                         DatumType = Item.DatumType\r
586                         Value = Item.DefaultValue\r
587                         Token = Item.Token\r
588                         MaxDatumSize = Item.MaxDatumSize\r
589                         SkuInfoList = Item.SkuInfoList\r
590                         Pb.Pcds[(Name, Guid)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)\r
591 \r
592                 for (Name, Guid) in PcdsSet:\r
593                     Value = PcdsSet[Name, Guid]\r
594                     for PcdType in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:\r
595                         for Dec in self.Build[Arch].PackageDatabase:\r
596                             Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds\r
597                             if (Name, Guid, PcdType) in Pcds:\r
598                                 Pcd = Pcds[(Name, Guid, PcdType)]\r
599                                 Type = PcdType\r
600                                 DatumType = Pcd.DatumType\r
601                                 Token = Pcd.TokenValue\r
602                                 MaxDatumSize = Pcd.MaxDatumSize\r
603                                 SkuInfoList = Pcd.SkuInfoList\r
604                                 Pb.Pcds[(Name, Guid)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)\r
605                                 break\r
606                         else:\r
607                             # nothing found\r
608                             continue\r
609                         # found in one package, find next PCD\r
610                         break\r
611                     else:\r
612                         EdkLogger.error("AutoGen", PARSER_ERROR, "PCD is not found in any package", ExtraData="%s.%s" % (Guid, Name))\r
613                 #\r
614                 # Add to database\r
615                 #\r
616                 self.Build[Arch].PlatformDatabase[Dsc] = Pb\r
617                 Pb = None\r
618 \r
619     ## Generate PackageDatabase\r
620     #\r
621     # Go through each arch to get all items in DecDatabase to PackageDatabase\r
622     #\r
623     def GenPackageDatabase(self):\r
624         for Dec in self.DecDatabase.keys():\r
625             Package = self.DecDatabase[Dec].Package\r
626 \r
627             for Arch in self.SupArchList:\r
628                 Pb = PackageBuildClassObject()\r
629 \r
630                 #\r
631                 # Defines\r
632                 #\r
633                 Pb.DescFilePath = Dec\r
634                 Pb.PackageName = Package.Header.Name\r
635                 Pb.Guid = Package.Header.Guid\r
636                 Pb.Version = Package.Header.Version\r
637 \r
638                 #\r
639                 # Protocols\r
640                 #\r
641                 for Item in Package.ProtocolDeclarations:\r
642                     if Arch in Item.SupArchList:\r
643                         Pb.Protocols[Item.CName] = Item.Guid\r
644 \r
645                 #\r
646                 # Ppis\r
647                 #\r
648                 for Item in Package.PpiDeclarations:\r
649                     if Arch in Item.SupArchList:\r
650                         Pb.Ppis[Item.CName] = Item.Guid\r
651 \r
652                 #\r
653                 # Guids\r
654                 #\r
655                 for Item in Package.GuidDeclarations:\r
656                     if Arch in Item.SupArchList:\r
657                         Pb.Guids[Item.CName] = Item.Guid\r
658 \r
659                 #\r
660                 # Includes\r
661                 #\r
662                 for Item in Package.Includes:\r
663                     if Arch in Item.SupArchList:\r
664                         Pb.Includes.append(Item.FilePath)\r
665 \r
666                 #\r
667                 # LibraryClasses\r
668                 #\r
669                 for Item in Package.LibraryClassDeclarations:\r
670                     if Arch in Item.SupArchList:\r
671                         Pb.LibraryClasses[Item.LibraryClass] = Item.RecommendedInstance\r
672 \r
673                 #\r
674                 # Pcds\r
675                 #\r
676                 for Item in Package.PcdDeclarations:\r
677                     if Arch in Item.SupArchList:\r
678                         Name = Item.CName\r
679                         Guid = Item.TokenSpaceGuidCName\r
680                         Type = Item.ItemType\r
681                         DatumType = Item.DatumType\r
682                         Value = Item.DefaultValue\r
683                         Token = Item.Token\r
684                         MaxDatumSize = Item.MaxDatumSize\r
685                         SkuInfoList = Item.SkuInfoList\r
686                         Pb.Pcds[(Name, Guid, Type)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)\r
687 \r
688                 #\r
689                 # Add to database\r
690                 #\r
691                 self.Build[Arch].PackageDatabase[Dec] = Pb\r
692                 Pb = None\r
693 \r
694     ## Generate ModuleDatabase\r
695     #\r
696     # Go through each arch to get all items in InfDatabase to ModuleDatabase\r
697     #    \r
698     def GenModuleDatabase(self, InfList = []):\r
699         for Inf in self.InfDatabase.keys():\r
700             Module = self.InfDatabase[Inf].Module\r
701 \r
702             for Arch in self.SupArchList:\r
703                 if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList):\r
704                     continue\r
705 \r
706                 Pb = ModuleBuildClassObject()\r
707 \r
708                 #\r
709                 # Defines\r
710                 #\r
711                 Pb.DescFilePath = Inf\r
712                 Pb.BaseName = Module.Header.Name\r
713                 Pb.Guid = Module.Header.Guid\r
714                 Pb.Version = Module.Header.Version\r
715                 Pb.ModuleType = Module.Header.ModuleType\r
716                 Pb.PcdIsDriver = Module.Header.PcdIsDriver\r
717                 Pb.BinaryModule = Module.Header.BinaryModule\r
718                 Pb.CustomMakefile = Module.Header.CustomMakefile\r
719                 Pb.Shadow = Module.Header.Shadow\r
720 \r
721                 #\r
722                 # Specs os Defines\r
723                 #\r
724                 Pb.Specification = Module.Header.Specification\r
725                 Pb.Specification[TAB_INF_DEFINES_EDK_RELEASE_VERSION] = Module.Header.EdkReleaseVersion\r
726                 Pb.Specification[TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION] = Module.Header.EfiSpecificationVersion\r
727                 Pb.AutoGenVersion = int(Module.Header.InfVersion, 0)\r
728 \r
729                 #\r
730                 # LibraryClass of Defines\r
731                 #\r
732                 for Item in Module.Header.LibraryClass:\r
733                     Pb.LibraryClass.append(LibraryClassObject(Item.LibraryClass, Item.SupModuleList, None))\r
734 \r
735                 #\r
736                 # Module image and library of Defines\r
737                 #\r
738                 for Item in Module.ExternImages:\r
739                     if Item.ModuleEntryPoint != '':\r
740                         Pb.ModuleEntryPointList.append(Item.ModuleEntryPoint)\r
741                     if Item.ModuleUnloadImage != '':\r
742                         Pb.ModuleUnloadImageList.append(Item.ModuleUnloadImage)\r
743                 for Item in Module.ExternLibraries:\r
744                     if Item.Constructor != '':\r
745                         Pb.ConstructorList.append(Item.Constructor)\r
746                     if Item.Destructor != '':\r
747                         Pb.DestructorList.append(Item.Destructor)\r
748 \r
749                 #\r
750                 # Binaries\r
751                 #\r
752                 for Item in Module.Binaries:\r
753                     if Arch in Item.SupArchList:\r
754                         FileName = Item.BinaryFile\r
755                         FileType = Item.FileType\r
756                         Target = Item.Target\r
757                         FeatureFlag = Item.FeatureFlag\r
758                         Pb.Binaries.append(ModuleBinaryFileClass(FileName, FileType, Target, FeatureFlag, Arch.split()))\r
759 \r
760                 #\r
761                 # Sources\r
762                 #\r
763                 for Item in Module.Sources:\r
764                     if Arch in Item.SupArchList:\r
765                         SourceFile = Item.SourceFile\r
766                         TagName = Item.TagName\r
767                         ToolCode = Item.ToolCode\r
768                         ToolChainFamily = Item.ToolChainFamily\r
769                         FeatureFlag = Item.FeatureFlag\r
770                         Pb.Sources.append(ModuleSourceFileClass(SourceFile, TagName, ToolCode, ToolChainFamily, FeatureFlag))\r
771 \r
772                 #\r
773                 # Protocols\r
774                 #\r
775                 for Item in Module.Protocols:\r
776                     if Arch in Item.SupArchList:\r
777                         Pb.Protocols.append(Item.CName)\r
778 \r
779                 #\r
780                 # Ppis\r
781                 #\r
782                 for Item in Module.Ppis:\r
783                     if Arch in Item.SupArchList:\r
784                         Pb.Ppis.append(Item.CName)\r
785 \r
786                 #\r
787                 # Guids\r
788                 #\r
789                 for Item in Module.Guids:\r
790                     if Arch in Item.SupArchList:\r
791                         Pb.Ppis.append(Item.CName)\r
792 \r
793                 #\r
794                 # Includes\r
795                 #\r
796                 for Item in Module.Includes:\r
797                     if Arch in Item.SupArchList:\r
798                         Pb.Includes.append(Item.FilePath)\r
799 \r
800                 #\r
801                 # Packages\r
802                 #\r
803                 for Item in Module.PackageDependencies:\r
804                     if Arch in Item.SupArchList:\r
805                         Pb.Packages.append(Item.FilePath)\r
806 \r
807                 #\r
808                 # BuildOptions\r
809                 #\r
810                 for Item in Module.BuildOptions:\r
811                     if Arch in Item.SupArchList:\r
812                         Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = Item.Option\r
813                 self.FindBuildOptions(Arch, Inf, Pb.BuildOptions)\r
814 \r
815                 #\r
816                 # Depex\r
817                 #\r
818                 for Item in Module.Depex:\r
819                     if Arch in Item.SupArchList:\r
820                         Pb.Depex = Pb.Depex + Item.Depex + ' '\r
821                 Pb.Depex = Pb.Depex.strip()\r
822 \r
823                 #\r
824                 # LibraryClasses\r
825                 #\r
826                 for Item in Module.LibraryClasses:\r
827                     if Arch in Item.SupArchList:\r
828                         Lib = Item.LibraryClass\r
829                         RecommendedInstance = Item.RecommendedInstance\r
830                         if Pb.LibraryClass != []:\r
831                             #\r
832                             # For Library\r
833                             #\r
834                             for Libs in Pb.LibraryClass:\r
835                                 for Type in Libs.SupModList:\r
836                                     Instance = self.FindLibraryClassInstanceOfLibrary(Lib, Arch, Type)\r
837                                     if Instance == None:\r
838                                         Instance = RecommendedInstance\r
839                                     Pb.LibraryClasses[(Lib, Type)] = Instance\r
840                         else:\r
841                             #\r
842                             # For Module\r
843                             #\r
844                             Instance = self.FindLibraryClassInstanceOfModule(Lib, Arch, Pb.ModuleType, Inf)\r
845                             if Instance == None:\r
846                                 Instance = RecommendedInstance\r
847                             Pb.LibraryClasses[(Lib, Pb.ModuleType)] = Instance\r
848 \r
849                 #\r
850                 # Libraries\r
851                 #\r
852                 for Item in Module.Libraries:\r
853                     if Arch in Item.SupArchList:\r
854                         Pb.Libraries.append(Item.Library)\r
855 \r
856                 #\r
857                 # Pcds\r
858                 #\r
859                 for Item in Module.PcdCodes:\r
860                     if Arch in Item.SupArchList:\r
861                         Name = Item.CName\r
862                         Guid = Item.TokenSpaceGuidCName\r
863                         Type = Item.ItemType\r
864                         Pb.Pcds[(Name, Guid)] = self.FindPcd(Arch, Inf, Name, Guid, Type)\r
865 \r
866                 #\r
867                 # Add to database\r
868                 #\r
869                 self.Build[Arch].ModuleDatabase[Inf] = Pb\r
870                 Pb = None\r
871 \r
872     ## Update Libraries Of Platform Database\r
873     #\r
874     # @param InfList: A list for all inf files\r
875     #\r
876     def UpdateLibrariesOfPlatform(self, InfList = []):\r
877         for Arch in self.SupArchList:\r
878             PlatformDatabase = self.Build[Arch].PlatformDatabase\r
879             for Dsc in PlatformDatabase:\r
880                 Platform = PlatformDatabase[Dsc]\r
881                 for Inf in Platform.Modules:\r
882                     if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList):\r
883                         continue\r
884                     Module = self.Build[Arch].ModuleDatabase[Inf]\r
885                     if Module.LibraryClass == None or Module.LibraryClass == []:\r
886                         self.UpdateLibrariesOfModule(Platform, Module, Arch)\r
887                         for Key in Module.LibraryClasses:\r
888                             Lib = Module.LibraryClasses[Key]\r
889                             if Lib not in Platform.LibraryInstances:\r
890                                 Platform.LibraryInstances.append(Lib)\r
891 \r
892 \r
893     ## Update Libraries Of Module Database\r
894     #\r
895     # @param Module:  The module need to be updated libraries\r
896     # @param Arch:    The supportted arch of the module\r
897     #\r
898     def UpdateLibrariesOfModule(self, Platform, Module, Arch):\r
899         ModuleDatabase = self.Build[Arch].ModuleDatabase\r
900         ModuleType = Module.ModuleType\r
901 \r
902         # check R8 module\r
903         if Module.AutoGenVersion < 0x00010005:\r
904             EdkLogger.verbose("")\r
905             EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), Arch))\r
906             LibraryConsumerList = [Module]\r
907             while len(LibraryConsumerList) > 0:\r
908                 M = LibraryConsumerList.pop()\r
909                 for LibraryName in M.Libraries:\r
910                     if LibraryName not in Platform.Libraries:\r
911                         EdkLogger.error("AutoGen", AUTOGEN_ERROR,\r
912                                         "Library instance for library class [%s] is not found" % LibraryName,\r
913                                         ExtraData="\t%s [%s]" % (str(Module), Arch))\r
914     \r
915                     LibraryFile = Platform.Libraries[LibraryName]\r
916                     if (LibraryName, ModuleType) not in Module.LibraryClasses:\r
917                         Module.LibraryClasses[LibraryName, ModuleType] = LibraryFile\r
918                         LibraryConsumerList.append(ModuleDatabase[LibraryFile])\r
919                     EdkLogger.verbose("\t" + LibraryName + " : " + LibraryFile)\r
920             return\r
921 \r
922         # R9 module\r
923         LibraryConsumerList = [Module]\r
924         Constructor         = []\r
925         ConsumedByList      = sdict()\r
926         LibraryInstance     = sdict()\r
927 \r
928         EdkLogger.verbose("")\r
929         EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), Arch))\r
930         while len(LibraryConsumerList) > 0:\r
931             M = LibraryConsumerList.pop()\r
932             for Key, LibraryPath in M.LibraryClasses.iteritems():\r
933                 # The "Key" is in format of (library_class_name, supported_module_type)\r
934                 if ModuleType != "USER_DEFINED" and ModuleType not in Key:\r
935                     EdkLogger.debug(EdkLogger.DEBUG_3, "%s for module type %s is not supported (%s)" % (Key + (LibraryPath,)))\r
936                     continue\r
937 \r
938                 LibraryClassName = Key[0]\r
939                 if LibraryClassName not in LibraryInstance or LibraryInstance[LibraryClassName] == None:\r
940                     if LibraryPath == None or LibraryPath == "":\r
941                         LibraryInstance[LibraryClassName] = None\r
942                         continue\r
943                     LibraryModule = ModuleDatabase[LibraryPath]\r
944                     LibraryInstance[LibraryClassName] = LibraryModule\r
945                     LibraryConsumerList.append(LibraryModule)\r
946                     EdkLogger.verbose("\t" + LibraryClassName + " : " + str(LibraryModule))\r
947                 elif LibraryPath == None or LibraryPath == "":\r
948                     continue\r
949                 else:\r
950                     LibraryModule = LibraryInstance[LibraryClassName]\r
951 \r
952                 if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:\r
953                     Constructor.append(LibraryModule)\r
954 \r
955                 if LibraryModule not in ConsumedByList:\r
956                     ConsumedByList[LibraryModule] = []\r
957                 if M != Module:\r
958                     if M in ConsumedByList[LibraryModule]:\r
959                         continue\r
960                     ConsumedByList[LibraryModule].append(M)\r
961         #\r
962         # Initialize the sorted output list to the empty set\r
963         #\r
964         SortedLibraryList = []\r
965         #\r
966         # Q <- Set of all nodes with no incoming edges\r
967         #\r
968         LibraryList = [] #LibraryInstance.values()\r
969         Q = []\r
970         for LibraryClassName in LibraryInstance:\r
971             M = LibraryInstance[LibraryClassName]\r
972             if M == None:\r
973                 EdkLogger.error("AutoGen", AUTOGEN_ERROR,\r
974                                 "Library instance for library class [%s] is not found" % LibraryClassName,\r
975                                 ExtraData="\t%s [%s]" % (str(Module), Arch))\r
976             LibraryList.append(M)\r
977             #\r
978             # check if there're duplicate library classes\r
979             #\r
980             for Lc in M.LibraryClass:\r
981                 if Lc.LibraryClass in LibraryInstance and str(M) != str(LibraryInstance[Lc.LibraryClass]):\r
982                     EdkLogger.error("AutoGen", AUTOGEN_ERROR,\r
983                                     "More than one library instance found for library class [%s] in module [%s]" % (Lc.LibraryClass, Module),\r
984                                     ExtraData="\t%s\n\t%s" % (LibraryInstance[Lc.LibraryClass], str(M))\r
985                                     )\r
986             if ConsumedByList[M] == []:\r
987                 Q.insert(0, M)\r
988         #\r
989         # while Q is not empty do\r
990         #\r
991         while Q != []:\r
992             #\r
993             # remove node from Q\r
994             #\r
995             Node = Q.pop()\r
996             #\r
997             # output Node\r
998             #\r
999             SortedLibraryList.append(Node)\r
1000             #\r
1001             # for each node Item with an edge e from Node to Item do\r
1002             #\r
1003             for Item in LibraryList:\r
1004                 if Node not in ConsumedByList[Item]:\r
1005                     continue\r
1006                 #\r
1007                 # remove edge e from the graph\r
1008                 #\r
1009                 ConsumedByList[Item].remove(Node)\r
1010                 #\r
1011                 # If Item has no other incoming edges then\r
1012                 #\r
1013                 if ConsumedByList[Item] == []:\r
1014                     #\r
1015                     # insert Item into Q\r
1016                     #\r
1017                     Q.insert(0, Item)\r
1018 \r
1019             EdgeRemoved = True\r
1020             while Q == [] and EdgeRemoved:\r
1021                 EdgeRemoved = False\r
1022                 #\r
1023                 # for each node Item with a Constructor\r
1024                 #\r
1025                 for Item in LibraryList:\r
1026                     if Item in Constructor:\r
1027                         #\r
1028                         # for each Node without a constructor with an edge e from Item to Node\r
1029                         #\r
1030                         for Node in ConsumedByList[Item]:\r
1031                             if Node not in Constructor:\r
1032                                 #\r
1033                                 # remove edge e from the graph\r
1034                                 #\r
1035                                 ConsumedByList[Item].remove(Node)\r
1036                                 EdgeRemoved = True\r
1037                                 if ConsumedByList[Item] == []:\r
1038                                     #\r
1039                                     # insert Item into Q\r
1040                                     #\r
1041                                     Q.insert(0, Item)\r
1042                                     break\r
1043                     if Q != []:\r
1044                         break\r
1045 \r
1046         #\r
1047         # if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle\r
1048         #\r
1049         for Item in LibraryList:\r
1050             if ConsumedByList[Item] != [] and Item in Constructor and len(Constructor) > 1:\r
1051                 ErrorMessage = 'Library [%s] with constructors has a cycle' % str(Item)\r
1052                 EdkLogger.error("AutoGen", AUTOGEN_ERROR, ErrorMessage,\r
1053                                 "\tconsumed by " + "\n\tconsumed by ".join([str(L) for L in ConsumedByList[Item]]))\r
1054             if Item not in SortedLibraryList:\r
1055                 SortedLibraryList.append(Item)\r
1056 \r
1057         #\r
1058         # Build the list of constructor and destructir names\r
1059         # The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order\r
1060         #\r
1061         SortedLibraryList.reverse()\r
1062         Module.LibraryClasses = sdict()\r
1063         for L in SortedLibraryList:\r
1064             for Lc in L.LibraryClass:\r
1065                 Module.LibraryClasses[Lc.LibraryClass, ModuleType] = str(L)\r
1066             #\r
1067             # Merge PCDs from library instance\r
1068             #\r
1069             for Key in L.Pcds:\r
1070                 if Key not in Module.Pcds:\r
1071                     LibPcd = L.Pcds[Key]\r
1072                     Module.Pcds[Key] = self.FindPcd(Arch, str(Module), LibPcd.TokenCName, LibPcd.TokenSpaceGuidCName, LibPcd.Type)\r
1073             #\r
1074             # Merge GUIDs from library instance\r
1075             #\r
1076             for CName in L.Guids:\r
1077                 if CName not in Module.Guids:\r
1078                     Module.Guids.append(CName)\r
1079             #\r
1080             # Merge Protocols from library instance\r
1081             #\r
1082             for CName in L.Protocols:\r
1083                 if CName not in Module.Protocols:\r
1084                     Module.Protocols.append(CName)\r
1085             #\r
1086             # Merge Ppis from library instance\r
1087             #\r
1088             for CName in L.Ppis:\r
1089                 if CName not in Module.Ppis:\r
1090                     Module.Ppis.append(CName)\r
1091 \r
1092     ## GenBuildDatabase\r
1093     #\r
1094     # Generate build database for all arches\r
1095     #\r
1096     # @param PcdsSet: Pcd list for override from Fdf parse result\r
1097     # @param InfList: Inf list for override from Fdf parse result\r
1098     #\r
1099     def GenBuildDatabase(self, PcdsSet = {}, InfList = []):\r
1100         #\r
1101         # Add additional inf file defined in Fdf file\r
1102         #\r
1103         for InfFile in InfList:\r
1104             self.AddToInfDatabase(NormPath(InfFile))\r
1105         \r
1106         #\r
1107         # Generate PlatformDatabase, PackageDatabase and ModuleDatabase\r
1108         #\r
1109         self.GenPackageDatabase()\r
1110         self.GenPlatformDatabase(PcdsSet)\r
1111         self.GenModuleDatabase(InfList)\r
1112         \r
1113         #\r
1114         # Update Libraries Of Platform\r
1115         #\r
1116         self.UpdateLibrariesOfPlatform(InfList)\r
1117         \r
1118         #\r
1119         # Output used Pcds not found in DSC file\r
1120         #\r
1121         self.ShowUnFoundPcds()\r
1122 \r
1123     ## ShowUnFoundPcds()\r
1124     #\r
1125     # If there is any pcd used but not defined in DSC\r
1126     # Print warning message on screen and output a list of pcds\r
1127     #\r
1128     def ShowUnFoundPcds(self):\r
1129         if self.UnFoundPcdInDsc != {}:\r
1130             WrnMessage = '**** WARNING ****\n'\r
1131             WrnMessage += 'The following Pcds were not defined in the DSC file: %s\n' % self.DscFileName\r
1132             WrnMessage += 'The default values were obtained from the DEC file that declares the PCD and the PCD default value\n'\r
1133             for (Guid, Name, Type, Arch) in self.UnFoundPcdInDsc:\r
1134                 Dec = self.UnFoundPcdInDsc[(Guid, Name, Type, Arch)]\r
1135                 Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds\r
1136                 if (Name, Guid, Type) in Pcds:\r
1137                     Pcd = Pcds[(Name, Guid, Type)]\r
1138                     PcdItemTypeUsed = Pcd.Type\r
1139                     DefaultValue = Pcd.DefaultValue\r
1140                     WrnMessage += '%s.%s: Defined in file %s, PcdItemType is Pcds%s, DefaultValue is %s\n' % (Guid, Name, Dec, PcdItemTypeUsed, DefaultValue)\r
1141             EdkLogger.info(WrnMessage)\r
1142         \r
1143     ## Create a full path with workspace dir\r
1144     #\r
1145     # Convert Filename with workspace dir to create a full path\r
1146     #\r
1147     # @param Filename: The filename need to be added workspace dir\r
1148     #\r
1149     # @retval string Full path\r
1150     #\r
1151     def WorkspaceFile(self, Filename):\r
1152         return WorkspaceFile(self.WorkspaceDir, Filename)\r
1153 \r
1154     ## Update LibraryClass of Module\r
1155     #\r
1156     # If a module of a platform has its own override libraryclass but the libraryclass not defined in the module\r
1157     # Add this libraryclass to the module\r
1158     #\r
1159     # @param InfFileName:       InfFileName specificed in platform\r
1160     # @param LibraryClass:      LibraryClass specificed in platform\r
1161     # @param Arch:              Supportted Arch\r
1162     # @param InstanceFilePath:  InstanceFilePath specificed in platform\r
1163     #\r
1164     def UpdateLibraryClassOfModule(self, InfFileName, LibraryClass, Arch, InstanceFilePath):\r
1165         #\r
1166         # Update the library instance itself to add this libraryclass name\r
1167         #\r
1168         LibraryModule = self.InfDatabase[InstanceFilePath].Module\r
1169         LibList = LibraryModule.Header.LibraryClass\r
1170         NotFound = True\r
1171         for Lib in LibList:\r
1172             #\r
1173             # Find this LibraryClass\r
1174             #\r
1175             if Lib.LibraryClass == LibraryClass:\r
1176                 NotFound = False;\r
1177                 break;\r
1178         if NotFound:\r
1179             NewLib = LibraryClassClass()\r
1180             NewLib.LibraryClass = LibraryClass\r
1181             NewLib.SupModuleList = LibraryModule.Header.ModuleType.split()\r
1182             LibraryModule.Header.LibraryClass.append(NewLib)\r
1183 \r
1184         #\r
1185         # Add it to LibraryClasses Section for the module which is using the library\r
1186         #\r
1187         Module = self.InfDatabase[InfFileName].Module\r
1188         LibList = Module.LibraryClasses\r
1189         NotFound = True\r
1190         for Lib in LibList:\r
1191             #\r
1192             # Find this LibraryClass\r
1193             #\r
1194             if Lib.LibraryClass == LibraryClass:\r
1195                 if Arch in Lib.SupArchList:\r
1196                     return\r
1197                 else:\r
1198                     Lib.SupArchList.append(Arch)\r
1199                     return\r
1200         if NotFound:\r
1201             Lib = LibraryClassClass()\r
1202             Lib.LibraryClass = LibraryClass\r
1203             Lib.SupArchList = [Arch]\r
1204             Module.LibraryClasses.append(Lib)\r
1205 \r
1206     ## Add Inf file to InfDatabase\r
1207     #\r
1208     # Create a Inf instance for input inf file and add it to InfDatabase\r
1209     #\r
1210     # @param InfFileName: The InfFileName need to be added to database\r
1211     #\r
1212     def AddToInfDatabase(self, InfFileName):\r
1213         File = self.WorkspaceFile(InfFileName)\r
1214         if os.path.exists(File) and os.path.isfile(File):\r
1215             if InfFileName not in self.InfDatabase:\r
1216                 self.InfDatabase[InfFileName] = Inf(File, True, True, self.WorkspaceDir)\r
1217         else:\r
1218             EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File)\r
1219 \r
1220     ## Add Dec file to DecDatabase\r
1221     #\r
1222     # Create a Dec instance for input dec file and add it to DecDatabase\r
1223     #\r
1224     # @param DecFileName: The DecFileName need to be added to database\r
1225     #\r
1226     def AddToDecDatabase(self, DecFileName):\r
1227         File = self.WorkspaceFile(DecFileName)\r
1228         if os.path.exists(File) and os.path.isfile(File):\r
1229             if DecFileName not in self.DecDatabase:\r
1230                 self.DecDatabase[DecFileName] = Dec(File, True, True, self.WorkspaceDir)\r
1231         else:\r
1232             EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File)\r
1233 \r
1234     ## Search LibraryClass Instance for Module\r
1235     #\r
1236     # Search PlatformBuildDatabase to find LibraryClass Instance for Module\r
1237     # Return the instance if found\r
1238     #\r
1239     # @param Lib:         Input value for Library Class Name\r
1240     # @param Arch:        Supportted Arch\r
1241     # @param ModuleType:  Supportted ModuleType\r
1242     # @param ModuleName:  Input value for Module Name\r
1243     #\r
1244     # @retval string Found LibraryClass Instance file path\r
1245     #\r
1246     def FindLibraryClassInstanceOfModule(self, Lib, Arch, ModuleType, ModuleName):\r
1247         #\r
1248         # First find if exist in <LibraryClass> of <Components> from dsc file\r
1249         #\r
1250         for Dsc in self.DscDatabase.keys():\r
1251             Platform = self.DscDatabase[Dsc].Platform\r
1252             for Module in Platform.Modules.ModuleList:\r
1253                 if Arch in Module.SupArchList:\r
1254                     if Module.FilePath == ModuleName:\r
1255                         for LibraryClass in Module.LibraryClasses.LibraryList:\r
1256                             if LibraryClass.Name == Lib:\r
1257                                 return LibraryClass.FilePath\r
1258         #\r
1259         #Second find if exist in <LibraryClass> of <LibraryClasses> from dsc file\r
1260         #\r
1261         return self.FindLibraryClassInstanceOfLibrary(Lib, Arch, ModuleType)\r
1262 \r
1263     ## Search LibraryClass Instance for Library\r
1264     #\r
1265     # Search PlatformBuildDatabase to find LibraryClass Instance for Library\r
1266     # Return the instance if found\r
1267     #\r
1268     # @param Lib:   Input value for Library Class Name\r
1269     # @param Arch:  Supportted Arch\r
1270     # @param Type:  Supportted Library Usage Type\r
1271     #\r
1272     # @retval string Found LibraryClass Instance file path\r
1273     # @retval None   Not Found\r
1274     #\r
1275     def FindLibraryClassInstanceOfLibrary(self, Lib, Arch, Type):\r
1276         for Dsc in self.DscDatabase.keys():\r
1277             Platform  = self.DscDatabase[Dsc].Platform\r
1278             if (Lib, Type) in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses:\r
1279                 return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, Type)]\r
1280             elif (Lib, '') in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses:\r
1281                 return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, '')]\r
1282         return None\r
1283 \r
1284     ## Find BuildOptions\r
1285     #\r
1286     # Search DscDatabase to find component definition of ModuleName\r
1287     # Override BuildOption if it is defined in component\r
1288     #\r
1289     # @param Arch:          Supportted Arch\r
1290     # @param ModuleName:    The module which has buildoption definition in component of platform\r
1291     # @param BuildOptions:  The set of all buildopitons\r
1292     #\r
1293     def FindBuildOptions(self, Arch, ModuleName, BuildOptions):\r
1294         for Dsc in self.DscDatabase.keys():\r
1295             #\r
1296             # First find if exist in <BuildOptions> of <Components> from dsc file\r
1297             # if find, use that override the one defined in inf file\r
1298             #\r
1299             Platform = self.DscDatabase[Dsc].Platform\r
1300             for Module in Platform.Modules.ModuleList:\r
1301                 if Arch in Module.SupArchList:\r
1302                     if Module.FilePath == ModuleName:\r
1303                         for BuildOption in Module.ModuleSaBuildOption.BuildOptionList:\r
1304                             #\r
1305                             # Add to BuildOptions\r
1306                             #\r
1307                             BuildOptions[(BuildOption.ToolChainFamily, BuildOption.ToolChain)] = BuildOption.Option\r
1308 \r
1309     ## Find Pcd\r
1310     #\r
1311     # Search platform database, package database, module database and PcdsSet from Fdf\r
1312     # Return found Pcd\r
1313     #\r
1314     # @param Arch:        Supportted Arch\r
1315     # @param ModuleName:  The module which has pcd definition in component of platform\r
1316     # @param Name:        Name of Pcd\r
1317     # @param Guid:        Guid of Pcd\r
1318     # @param Type:        Type of Pcd\r
1319     #\r
1320     # @retval PcdClassObject An instance for PcdClassObject with all members filled\r
1321     #\r
1322     def FindPcd(self, Arch, ModuleName, Name, Guid, Type):\r
1323         NewType = ''\r
1324         DatumType = ''\r
1325         Value = ''\r
1326         Token = ''\r
1327         MaxDatumSize = ''\r
1328         SkuInfoList = {}\r
1329         IsOverrided = False\r
1330         IsFoundInDsc = False\r
1331         IsFoundInDec = False\r
1332         FoundInDecFile = ''\r
1333         \r
1334         #\r
1335         # Second get information from platform database\r
1336         #\r
1337         OwnerPlatform = ''\r
1338         for Dsc in self.Build[Arch].PlatformDatabase.keys():\r
1339             Pcds = self.Build[Arch].PlatformDatabase[Dsc].Pcds\r
1340             if (Name, Guid) in Pcds:\r
1341                 OwnerPlatform = Dsc\r
1342                 Pcd = Pcds[(Name, Guid)]\r
1343                 if Pcd.Type != '' and Pcd.Type != None:\r
1344                     NewType = Pcd.Type\r
1345                     if NewType in DataType.PCD_DYNAMIC_TYPE_LIST:\r
1346                         NewType = DataType.TAB_PCDS_DYNAMIC\r
1347                     elif NewType in DataType.PCD_DYNAMIC_EX_TYPE_LIST:\r
1348                         NewType = DataType.TAB_PCDS_DYNAMIC_EX\r
1349                 else:\r
1350                     NewType = Type\r
1351 \r
1352                 if Type != '' and Type != NewType:\r
1353                     ErrorMsg = "PCD %s.%s is declared as [%s] in module\n\t%s\n\n"\\r
1354                                "    But it's used as [%s] in platform\n\t%s"\\r
1355                                % (Guid, Name, Type, ModuleName, NewType, OwnerPlatform)\r
1356                     EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg)\r
1357 \r
1358 \r
1359                 if Pcd.DatumType != '' and Pcd.DatumType != None:\r
1360                     DatumType = Pcd.DatumType\r
1361                 if Pcd.TokenValue != '' and Pcd.TokenValue != None:\r
1362                     Token = Pcd.TokenValue\r
1363                 if Pcd.DefaultValue != '' and Pcd.DefaultValue != None:\r
1364                     Value = Pcd.DefaultValue\r
1365                 if Pcd.MaxDatumSize != '' and Pcd.MaxDatumSize != None:\r
1366                     MaxDatumSize = Pcd.MaxDatumSize\r
1367                 SkuInfoList =  Pcd.SkuInfoList\r
1368                 \r
1369                 IsOverrided = True\r
1370                 IsFoundInDsc = True\r
1371                 break\r
1372 \r
1373         #\r
1374         # Third get information from <Pcd> of <Compontents> from module database\r
1375         #\r
1376         for Dsc in self.DscDatabase.keys():\r
1377             for Module in self.DscDatabase[Dsc].Platform.Modules.ModuleList:\r
1378                 if Arch in Module.SupArchList:\r
1379                     if Module.FilePath == ModuleName:\r
1380                         for Pcd in Module.PcdBuildDefinitions:\r
1381                             if (Name, Guid) == (Pcd.CName, Pcd.TokenSpaceGuidCName):\r
1382                                 if Pcd.DefaultValue != '':\r
1383                                     Value = Pcd.DefaultValue\r
1384                                 if Pcd.MaxDatumSize != '':\r
1385                                     MaxDatumSize = Pcd.MaxDatumSize\r
1386                                     \r
1387                                 IsFoundInDsc = True\r
1388                                 IsOverrided = True\r
1389                                 break\r
1390 \r
1391         #\r
1392         # First get information from package database\r
1393         #\r
1394         Pcd = None\r
1395         if NewType == '':\r
1396             if Type != '':\r
1397                 PcdTypeList = [Type]\r
1398             else:\r
1399                 PcdTypeList = ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]\r
1400 \r
1401             for Dec in self.Build[Arch].PackageDatabase.keys():\r
1402                 Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds\r
1403                 for PcdType in PcdTypeList:\r
1404                     if (Name, Guid, PcdType) in Pcds:\r
1405                         Pcd = Pcds[(Name, Guid, PcdType)]\r
1406                         NewType = PcdType\r
1407                         IsOverrided = True\r
1408                         IsFoundInDec = True\r
1409                         FoundInDecFile = Dec\r
1410                         break\r
1411                 else:\r
1412                     continue\r
1413                 break\r
1414         else:\r
1415             for Dec in self.Build[Arch].PackageDatabase.keys():\r
1416                 Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds\r
1417                 if (Name, Guid, NewType) in Pcds:\r
1418                     Pcd = Pcds[(Name, Guid, NewType)]\r
1419                     IsOverrided = True\r
1420                     IsFoundInDec = True\r
1421                     FoundInDecFile = Dec\r
1422                     break\r
1423 \r
1424         if not IsFoundInDec:\r
1425             if NewType != '':\r
1426                 SupportedPcdTypeList = []\r
1427                 OwnerPackage = ''\r
1428                 for Dec in self.Build[Arch].PackageDatabase.keys():\r
1429                     Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds\r
1430                     for PcdType in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:\r
1431                         if (Name, Guid, PcdType) in Pcds:\r
1432                             SupportedPcdTypeList.append(PcdType)\r
1433                             OwnerPackage = Dec\r
1434                 ErrorMsg = "Only [%s] is supported for Pcd '%s.%s' in package\n\t%s\n\n"\\r
1435                            "    But [%s] is specified in platform\n\t%s"\\r
1436                            % (", ".join(SupportedPcdTypeList), Guid, Name, OwnerPackage, NewType, OwnerPlatform)\r
1437             else:\r
1438                 ErrorMsg = "Pcd '%s.%s [%s]' defined in module '%s' is not found in any package" % (Guid, Name, NewType, ModuleName)\r
1439             EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg)\r
1440 \r
1441         #\r
1442         # Not found in any platform and fdf\r
1443         #\r
1444         if not IsFoundInDsc:\r
1445             Value = Pcd.DefaultValue\r
1446             if NewType.startswith("Dynamic") and SkuInfoList == {}:\r
1447                 SkuIds = self.Build[Arch].PlatformDatabase.values()[0].SkuIds\r
1448                 SkuInfoList['DEFAULT'] = SkuInfoClass(SkuIdName='DEFAULT', SkuId=SkuIds['DEFAULT'], DefaultValue=Value)\r
1449             self.UnFoundPcdInDsc[(Guid, Name, NewType, Arch)] = FoundInDecFile\r
1450         #elif Type != '' and NewType.startswith("Dynamic"):\r
1451         #    NewType = Pcd.Type\r
1452         DatumType = Pcd.DatumType\r
1453         if Token in [None, '']:\r
1454             Token = Pcd.TokenValue\r
1455         if DatumType == "VOID*" and MaxDatumSize in ['', None]:\r
1456             EdkLogger.warn("\nAutoGen", "No MaxDatumSize specified for PCD %s.%s" % (Guid, Name),\r
1457                            ExtraData=ModuleName)\r
1458             if Value[0] == 'L':\r
1459                 MaxDatumSize = str(len(Value) * 2)\r
1460             elif Value[0] == '{':\r
1461                 MaxDatumSize = str(len(Value.split(',')))\r
1462             else:\r
1463                 MaxDatumSize = str(len(Value))\r
1464 \r
1465         return PcdClassObject(Name, Guid, NewType, DatumType, Value, Token, MaxDatumSize, SkuInfoList, IsOverrided)\r
1466 \r
1467     ## Find Supportted Module List Of LibraryClass\r
1468     #\r
1469     # Search in InfDatabase, find the supmodulelist of the libraryclass\r
1470     #\r
1471     # @param LibraryClass:               LibraryClass name for search\r
1472     # @param OverridedLibraryClassList:  A list of all LibraryClass\r
1473     # @param Arch:                       Supportted Arch\r
1474     #\r
1475     # @retval list SupModuleList\r
1476     #\r
1477     def FindSupModuleListOfLibraryClass(self, LibraryClass, OverridedLibraryClassList, Arch):\r
1478         Name = LibraryClass.Name\r
1479         FilePath = LibraryClass.FilePath\r
1480         SupModuleList = copy.copy(LibraryClass.SupModuleList)\r
1481 \r
1482         #\r
1483         # If the SupModuleList means all, remove overrided module types of platform\r
1484         #\r
1485         if SupModuleList == DataType.SUP_MODULE_LIST:\r
1486             EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s supports all module types" % Name)\r
1487             for Item in OverridedLibraryClassList:\r
1488                 #\r
1489                 # Find a library class (Item) with the same name\r
1490                 #\r
1491                 if Item.Name == Name:\r
1492                     #\r
1493                     # Do nothing if it is itself\r
1494                     #\r
1495                     if Item.SupModuleList == DataType.SUP_MODULE_LIST:\r
1496                         continue\r
1497                     #\r
1498                     # If not itself, check arch first\r
1499                     #\r
1500                     if Arch in LibraryClass.SupArchList:\r
1501                         #\r
1502                         # If arch is supportted, remove all related module type\r
1503                         #\r
1504                         if Arch in Item.SupArchList:\r
1505                             for ModuleType in Item.SupModuleList:\r
1506                                 EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s has specific defined module types" % Name)\r
1507                                 if ModuleType in SupModuleList:\r
1508                                     SupModuleList.remove(ModuleType)\r
1509 \r
1510         return SupModuleList\r
1511 \r
1512     ## Find Module inf Platform\r
1513     #\r
1514     # Check if the module is defined in <Compentent> of <Platform>\r
1515     #\r
1516     # @param Inf:      Inf file (Module) need to be searched\r
1517     # @param Arch:     Supportted Arch\r
1518     # @param InfList:  A list for all Inf file\r
1519     #\r
1520     # @retval True     Mudule Found\r
1521     # @retval Flase    Module Not Found\r
1522     #\r
1523     def IsModuleDefinedInPlatform(self, Inf, Arch, InfList):\r
1524         for Dsc in self.DscDatabase.values():\r
1525             for LibraryClass in Dsc.Platform.LibraryClasses.LibraryList:\r
1526                 if Inf == LibraryClass.FilePath and Arch in LibraryClass.SupArchList:\r
1527                     return True\r
1528             for Module in Dsc.Platform.Modules.ModuleList:\r
1529                 if Inf == Module.FilePath and Arch in Module.SupArchList:\r
1530                     return True\r
1531                 for Item in Module.LibraryClasses.LibraryList:\r
1532                     if Inf == Item.FilePath:\r
1533                         return True\r
1534             for Library in Dsc.Platform.Libraries.LibraryList:\r
1535                 if Inf == Library.FilePath and Arch in Library.SupArchList:\r
1536                     return True\r
1537 \r
1538         return False\r
1539 \r
1540     ## Show all content of the workspacebuild\r
1541     #\r
1542     # Print each item of the workspacebuild with (Key = Value) pair\r
1543     #\r
1544     def ShowWorkspaceBuild(self):\r
1545         print self.DscDatabase\r
1546         print self.InfDatabase\r
1547         print self.DecDatabase\r
1548         print 'SupArchList', self.SupArchList\r
1549         print 'BuildTarget', self.BuildTarget\r
1550         print 'SkuId', self.SkuId\r
1551 \r
1552         for Arch in self.SupArchList:\r
1553             print Arch\r
1554             print 'Platform'\r
1555             for Platform in self.Build[Arch].PlatformDatabase.keys():\r
1556                 P = self.Build[Arch].PlatformDatabase[Platform]\r
1557                 print 'DescFilePath = ', P.DescFilePath\r
1558                 print 'PlatformName = ', P.PlatformName\r
1559                 print 'Guid = ', P.Guid\r
1560                 print 'Version = ', P.Version\r
1561                 print 'OutputDirectory = ', P.OutputDirectory\r
1562                 print 'FlashDefinition = ', P.FlashDefinition\r
1563                 print 'SkuIds = ', P.SkuIds\r
1564                 print 'Modules = ', P.Modules\r
1565                 print 'LibraryClasses = ', P.LibraryClasses\r
1566                 print 'Pcds = ', P.Pcds\r
1567                 for item in P.Pcds.keys():\r
1568                     print P.Pcds[item]\r
1569                 print 'BuildOptions = ', P.BuildOptions\r
1570                 print ''\r
1571             # End of Platform\r
1572 \r
1573             print 'package'\r
1574             for Package in self.Build[Arch].PackageDatabase.keys():\r
1575                 P = self.Build[Arch].PackageDatabase[Package]\r
1576                 print 'DescFilePath = ', P.DescFilePath\r
1577                 print 'PackageName = ', P.PackageName\r
1578                 print 'Guid = ', P.Guid\r
1579                 print 'Version = ', P.Version\r
1580                 print 'Protocols = ', P.Protocols\r
1581                 print 'Ppis = ', P.Ppis\r
1582                 print 'Guids = ', P.Guids\r
1583                 print 'Includes = ', P.Includes\r
1584                 print 'LibraryClasses = ', P.LibraryClasses\r
1585                 print 'Pcds = ', P.Pcds\r
1586                 for item in P.Pcds.keys():\r
1587                     print P.Pcds[item]\r
1588                 print ''\r
1589             # End of Package\r
1590 \r
1591             print 'module'\r
1592             for Module in self.Build[Arch].ModuleDatabase.keys():\r
1593                 P = self.Build[Arch].ModuleDatabase[Module]\r
1594                 print 'DescFilePath = ', P.DescFilePath\r
1595                 print 'BaseName = ', P.BaseName\r
1596                 print 'ModuleType = ', P.ModuleType\r
1597                 print 'Guid = ', P.Guid\r
1598                 print 'Version = ', P.Version\r
1599                 print 'CustomMakefile = ', P.CustomMakefile\r
1600                 print 'Specification = ', P.Specification\r
1601                 print 'Shadow = ', P.Shadow\r
1602                 print 'PcdIsDriver = ', P.PcdIsDriver\r
1603                 for Lib in P.LibraryClass:\r
1604                     print 'LibraryClassDefinition = ', Lib.LibraryClass, 'SupModList = ', Lib.SupModList\r
1605                 print 'ModuleEntryPointList = ', P.ModuleEntryPointList\r
1606                 print 'ModuleUnloadImageList = ', P.ModuleUnloadImageList\r
1607                 print 'ConstructorList = ', P.ConstructorList\r
1608                 print 'DestructorList = ', P.DestructorList\r
1609 \r
1610                 print 'Binaries = '\r
1611                 for item in P.Binaries:\r
1612                     print item.BinaryFile, item.FeatureFlag, item.SupArchList\r
1613                 print 'Sources = '\r
1614                 for item in P.Sources:\r
1615                     print item.SourceFile\r
1616                 print 'LibraryClasses = ', P.LibraryClasses\r
1617                 print 'Protocols = ', P.Protocols\r
1618                 print 'Ppis = ', P.Ppis\r
1619                 print 'Guids = ', P.Guids\r
1620                 print 'Includes = ', P.Includes\r
1621                 print 'Packages = ', P.Packages\r
1622                 print 'Pcds = ', P.Pcds\r
1623                 for item in P.Pcds.keys():\r
1624                     print P.Pcds[item]\r
1625                 print 'BuildOptions = ', P.BuildOptions\r
1626                 print 'Depex = ', P.Depex\r
1627                 print ''\r
1628             # End of Module\r
1629 \r
1630 ##\r
1631 #\r
1632 # This acts like the main() function for the script, unless it is 'import'ed into another\r
1633 # script.\r
1634 #\r
1635 if __name__ == '__main__':\r
1636     W = os.getenv('WORKSPACE')\r
1637     Ewb = WorkspaceBuild('Nt32Pkg/Nt32Pkg.dsc', W)\r
1638     Ewb.GenBuildDatabase({('PcdDevicePathSupportDevicePathFromText, gEfiMdeModulePkgTokenSpaceGuid') : 'KKKKKKKKKKKKKKKKKKKKK'}, ['Test.Inf'])\r
1639     Ewb.ShowWorkspaceBuild()\r