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