2f6fa1d11c83790025e54401a77cfd0b3a1f10ba
[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):\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                 #\r
593                 # Add to database\r
594                 #\r
595                 self.Build[Arch].PlatformDatabase[Dsc] = Pb\r
596                 Pb = None\r
597 \r
598     ## Generate PackageDatabase\r
599     #\r
600     # Go through each arch to get all items in DecDatabase to PackageDatabase\r
601     #\r
602     def GenPackageDatabase(self):\r
603         for Dec in self.DecDatabase.keys():\r
604             Package = self.DecDatabase[Dec].Package\r
605 \r
606             for Arch in self.SupArchList:\r
607                 Pb = PackageBuildClassObject()\r
608 \r
609                 #\r
610                 # Defines\r
611                 #\r
612                 Pb.DescFilePath = Dec\r
613                 Pb.PackageName = Package.Header.Name\r
614                 Pb.Guid = Package.Header.Guid\r
615                 Pb.Version = Package.Header.Version\r
616 \r
617                 #\r
618                 # Protocols\r
619                 #\r
620                 for Item in Package.ProtocolDeclarations:\r
621                     if Arch in Item.SupArchList:\r
622                         Pb.Protocols[Item.CName] = Item.Guid\r
623 \r
624                 #\r
625                 # Ppis\r
626                 #\r
627                 for Item in Package.PpiDeclarations:\r
628                     if Arch in Item.SupArchList:\r
629                         Pb.Ppis[Item.CName] = Item.Guid\r
630 \r
631                 #\r
632                 # Guids\r
633                 #\r
634                 for Item in Package.GuidDeclarations:\r
635                     if Arch in Item.SupArchList:\r
636                         Pb.Guids[Item.CName] = Item.Guid\r
637 \r
638                 #\r
639                 # Includes\r
640                 #\r
641                 for Item in Package.Includes:\r
642                     if Arch in Item.SupArchList:\r
643                         Pb.Includes.append(Item.FilePath)\r
644 \r
645                 #\r
646                 # LibraryClasses\r
647                 #\r
648                 for Item in Package.LibraryClassDeclarations:\r
649                     if Arch in Item.SupArchList:\r
650                         Pb.LibraryClasses[Item.LibraryClass] = Item.RecommendedInstance\r
651 \r
652                 #\r
653                 # Pcds\r
654                 #\r
655                 for Item in Package.PcdDeclarations:\r
656                     if Arch in Item.SupArchList:\r
657                         Name = Item.CName\r
658                         Guid = Item.TokenSpaceGuidCName\r
659                         Type = Item.ItemType\r
660                         DatumType = Item.DatumType\r
661                         Value = Item.DefaultValue\r
662                         Token = Item.Token\r
663                         MaxDatumSize = Item.MaxDatumSize\r
664                         SkuInfoList = Item.SkuInfoList\r
665                         Pb.Pcds[(Name, Guid, Type)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)\r
666 \r
667                 #\r
668                 # Add to database\r
669                 #\r
670                 self.Build[Arch].PackageDatabase[Dec] = Pb\r
671                 Pb = None\r
672 \r
673     ## Generate ModuleDatabase\r
674     #\r
675     # Go through each arch to get all items in InfDatabase to ModuleDatabase\r
676     #    \r
677     def GenModuleDatabase(self, PcdsSet = {}, InfList = []):\r
678         for Inf in self.InfDatabase.keys():\r
679             Module = self.InfDatabase[Inf].Module\r
680 \r
681             for Arch in self.SupArchList:\r
682                 if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList):\r
683                     continue\r
684 \r
685                 Pb = ModuleBuildClassObject()\r
686 \r
687                 #\r
688                 # Defines\r
689                 #\r
690                 Pb.DescFilePath = Inf\r
691                 Pb.BaseName = Module.Header.Name\r
692                 Pb.Guid = Module.Header.Guid\r
693                 Pb.Version = Module.Header.Version\r
694                 Pb.ModuleType = Module.Header.ModuleType\r
695                 Pb.PcdIsDriver = Module.Header.PcdIsDriver\r
696                 Pb.BinaryModule = Module.Header.BinaryModule\r
697                 Pb.CustomMakefile = Module.Header.CustomMakefile\r
698                 Pb.Shadow = Module.Header.Shadow\r
699 \r
700                 #\r
701                 # Specs os Defines\r
702                 #\r
703                 Pb.Specification = Module.Header.Specification\r
704                 Pb.Specification[TAB_INF_DEFINES_EDK_RELEASE_VERSION] = Module.Header.EdkReleaseVersion\r
705                 Pb.Specification[TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION] = Module.Header.EfiSpecificationVersion\r
706                 Pb.AutoGenVersion = int(Module.Header.InfVersion, 0)\r
707 \r
708                 #\r
709                 # LibraryClass of Defines\r
710                 #\r
711                 for Item in Module.Header.LibraryClass:\r
712                     Pb.LibraryClass.append(LibraryClassObject(Item.LibraryClass, Item.SupModuleList, None))\r
713 \r
714                 #\r
715                 # Module image and library of Defines\r
716                 #\r
717                 for Item in Module.ExternImages:\r
718                     if Item.ModuleEntryPoint != '':\r
719                         Pb.ModuleEntryPointList.append(Item.ModuleEntryPoint)\r
720                     if Item.ModuleUnloadImage != '':\r
721                         Pb.ModuleUnloadImageList.append(Item.ModuleUnloadImage)\r
722                 for Item in Module.ExternLibraries:\r
723                     if Item.Constructor != '':\r
724                         Pb.ConstructorList.append(Item.Constructor)\r
725                     if Item.Destructor != '':\r
726                         Pb.DestructorList.append(Item.Destructor)\r
727 \r
728                 #\r
729                 # Binaries\r
730                 #\r
731                 for Item in Module.Binaries:\r
732                     if Arch in Item.SupArchList:\r
733                         FileName = Item.BinaryFile\r
734                         FileType = Item.FileType\r
735                         Target = Item.Target\r
736                         FeatureFlag = Item.FeatureFlag\r
737                         Pb.Binaries.append(ModuleBinaryFileClass(FileName, FileType, Target, FeatureFlag, Arch.split()))\r
738 \r
739                 #\r
740                 # Sources\r
741                 #\r
742                 for Item in Module.Sources:\r
743                     if Arch in Item.SupArchList:\r
744                         SourceFile = Item.SourceFile\r
745                         TagName = Item.TagName\r
746                         ToolCode = Item.ToolCode\r
747                         ToolChainFamily = Item.ToolChainFamily\r
748                         FeatureFlag = Item.FeatureFlag\r
749                         Pb.Sources.append(ModuleSourceFileClass(SourceFile, TagName, ToolCode, ToolChainFamily, FeatureFlag))\r
750 \r
751                 #\r
752                 # Protocols\r
753                 #\r
754                 for Item in Module.Protocols:\r
755                     if Arch in Item.SupArchList:\r
756                         Pb.Protocols.append(Item.CName)\r
757 \r
758                 #\r
759                 # Ppis\r
760                 #\r
761                 for Item in Module.Ppis:\r
762                     if Arch in Item.SupArchList:\r
763                         Pb.Ppis.append(Item.CName)\r
764 \r
765                 #\r
766                 # Guids\r
767                 #\r
768                 for Item in Module.Guids:\r
769                     if Arch in Item.SupArchList:\r
770                         Pb.Ppis.append(Item.CName)\r
771 \r
772                 #\r
773                 # Includes\r
774                 #\r
775                 for Item in Module.Includes:\r
776                     if Arch in Item.SupArchList:\r
777                         Pb.Includes.append(Item.FilePath)\r
778 \r
779                 #\r
780                 # Packages\r
781                 #\r
782                 for Item in Module.PackageDependencies:\r
783                     if Arch in Item.SupArchList:\r
784                         Pb.Packages.append(Item.FilePath)\r
785 \r
786                 #\r
787                 # BuildOptions\r
788                 #\r
789                 for Item in Module.BuildOptions:\r
790                     if Arch in Item.SupArchList:\r
791                         Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = Item.Option\r
792                 self.FindBuildOptions(Arch, Inf, Pb.BuildOptions)\r
793 \r
794                 #\r
795                 # Depex\r
796                 #\r
797                 for Item in Module.Depex:\r
798                     if Arch in Item.SupArchList:\r
799                         Pb.Depex = Pb.Depex + Item.Depex + ' '\r
800                 Pb.Depex = Pb.Depex.strip()\r
801 \r
802                 #\r
803                 # LibraryClasses\r
804                 #\r
805                 for Item in Module.LibraryClasses:\r
806                     if Arch in Item.SupArchList:\r
807                         Lib = Item.LibraryClass\r
808                         RecommendedInstance = Item.RecommendedInstance\r
809                         if Pb.LibraryClass != []:\r
810                             #\r
811                             # For Library\r
812                             #\r
813                             for Libs in Pb.LibraryClass:\r
814                                 for Type in Libs.SupModList:\r
815                                     Instance = self.FindLibraryClassInstanceOfLibrary(Lib, Arch, Type)\r
816                                     if Instance == None:\r
817                                         Instance = RecommendedInstance\r
818                                     Pb.LibraryClasses[(Lib, Type)] = Instance\r
819                         else:\r
820                             #\r
821                             # For Module\r
822                             #\r
823                             Instance = self.FindLibraryClassInstanceOfModule(Lib, Arch, Pb.ModuleType, Inf)\r
824                             if Instance == None:\r
825                                 Instance = RecommendedInstance\r
826                             Pb.LibraryClasses[(Lib, Pb.ModuleType)] = Instance\r
827 \r
828                 #\r
829                 # Libraries\r
830                 #\r
831                 for Item in Module.Libraries:\r
832                     if Arch in Item.SupArchList:\r
833                         Pb.Libraries.append(Item.Library)\r
834 \r
835                 #\r
836                 # Pcds\r
837                 #\r
838                 for Item in Module.PcdCodes:\r
839                     if Arch in Item.SupArchList:\r
840                         Name = Item.CName\r
841                         Guid = Item.TokenSpaceGuidCName\r
842                         Type = Item.ItemType\r
843                         Pb.Pcds[(Name, Guid)] = self.FindPcd(Arch, Inf, Name, Guid, Type, PcdsSet)\r
844 \r
845                 #\r
846                 # Add to database\r
847                 #\r
848                 self.Build[Arch].ModuleDatabase[Inf] = Pb\r
849                 Pb = None\r
850 \r
851     ## Update Libraries Of Platform Database\r
852     #\r
853     # @param InfList: A list for all inf files\r
854     #\r
855     def UpdateLibrariesOfPlatform(self, InfList = []):\r
856         for Arch in self.SupArchList:\r
857             PlatformDatabase = self.Build[Arch].PlatformDatabase\r
858             for Dsc in PlatformDatabase:\r
859                 Platform = PlatformDatabase[Dsc]\r
860                 for Inf in Platform.Modules:\r
861                     if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList):\r
862                         continue\r
863                     Module = self.Build[Arch].ModuleDatabase[Inf]\r
864                     if Module.LibraryClass == None or Module.LibraryClass == []:\r
865                         self.UpdateLibrariesOfModule(Platform, Module, Arch)\r
866                         for Key in Module.LibraryClasses:\r
867                             Lib = Module.LibraryClasses[Key]\r
868                             if Lib not in Platform.LibraryInstances:\r
869                                 Platform.LibraryInstances.append(Lib)\r
870 \r
871 \r
872     ## Update Libraries Of Module Database\r
873     #\r
874     # @param Module:  The module need to be updated libraries\r
875     # @param Arch:    The supportted arch of the module\r
876     #\r
877     def UpdateLibrariesOfModule(self, Platform, Module, Arch):\r
878         ModuleDatabase = self.Build[Arch].ModuleDatabase\r
879         ModuleType = Module.ModuleType\r
880 \r
881         # check R8 module\r
882         if Module.AutoGenVersion < 0x00010005:\r
883             EdkLogger.verbose("")\r
884             EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), Arch))\r
885             LibraryConsumerList = [Module]\r
886             while len(LibraryConsumerList) > 0:\r
887                 M = LibraryConsumerList.pop()\r
888                 for LibraryName in M.Libraries:\r
889                     if LibraryName not in Platform.Libraries:\r
890                         EdkLogger.error("AutoGen", AUTOGEN_ERROR,\r
891                                         "Library instance for library class [%s] is not found" % LibraryName,\r
892                                         ExtraData="\t%s [%s]" % (str(Module), Arch))\r
893     \r
894                     LibraryFile = Platform.Libraries[LibraryName]\r
895                     if (LibraryName, ModuleType) not in Module.LibraryClasses:\r
896                         Module.LibraryClasses[LibraryName, ModuleType] = LibraryFile\r
897                         LibraryConsumerList.append(ModuleDatabase[LibraryFile])\r
898                     EdkLogger.verbose("\t" + LibraryName + " : " + LibraryFile)\r
899             return\r
900 \r
901         # R9 module\r
902         LibraryConsumerList = [Module]\r
903         Constructor         = []\r
904         ConsumedByList      = sdict()\r
905         LibraryInstance     = sdict()\r
906 \r
907         EdkLogger.verbose("")\r
908         EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), Arch))\r
909         while len(LibraryConsumerList) > 0:\r
910             M = LibraryConsumerList.pop()\r
911             for Key, LibraryPath in M.LibraryClasses.iteritems():\r
912                 # The "Key" is in format of (library_class_name, supported_module_type)\r
913                 if ModuleType != "USER_DEFINED" and ModuleType not in Key:\r
914                     EdkLogger.debug(EdkLogger.DEBUG_3, "%s for module type %s is not supported (%s)" % (Key + (LibraryPath,)))\r
915                     continue\r
916 \r
917                 LibraryClassName = Key[0]\r
918                 if LibraryClassName not in LibraryInstance or LibraryInstance[LibraryClassName] == None:\r
919                     if LibraryPath == None or LibraryPath == "":\r
920                         LibraryInstance[LibraryClassName] = None\r
921                         continue\r
922                     LibraryModule = ModuleDatabase[LibraryPath]\r
923                     LibraryInstance[LibraryClassName] = LibraryModule\r
924                     LibraryConsumerList.append(LibraryModule)\r
925                     EdkLogger.verbose("\t" + LibraryClassName + " : " + str(LibraryModule))\r
926                 elif LibraryPath == None or LibraryPath == "":\r
927                     continue\r
928                 else:\r
929                     LibraryModule = LibraryInstance[LibraryClassName]\r
930 \r
931                 if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:\r
932                     Constructor.append(LibraryModule)\r
933 \r
934                 if LibraryModule not in ConsumedByList:\r
935                     ConsumedByList[LibraryModule] = []\r
936                 if M != Module:\r
937                     if M in ConsumedByList[LibraryModule]:\r
938                         continue\r
939                     ConsumedByList[LibraryModule].append(M)\r
940         #\r
941         # Initialize the sorted output list to the empty set\r
942         #\r
943         SortedLibraryList = []\r
944         #\r
945         # Q <- Set of all nodes with no incoming edges\r
946         #\r
947         LibraryList = [] #LibraryInstance.values()\r
948         Q = []\r
949         for LibraryClassName in LibraryInstance:\r
950             M = LibraryInstance[LibraryClassName]\r
951             if M == None:\r
952                 EdkLogger.error("AutoGen", AUTOGEN_ERROR,\r
953                                 "Library instance for library class [%s] is not found" % LibraryClassName,\r
954                                 ExtraData="\t%s [%s]" % (str(Module), Arch))\r
955             LibraryList.append(M)\r
956             #\r
957             # check if there're duplicate library classes\r
958             #\r
959             for Lc in M.LibraryClass:\r
960                 if Lc.LibraryClass in LibraryInstance and str(M) != str(LibraryInstance[Lc.LibraryClass]):\r
961                     EdkLogger.error("AutoGen", AUTOGEN_ERROR,\r
962                                     "More than one library instance found for library class [%s] in module [%s]" % (Lc.LibraryClass, Module),\r
963                                     ExtraData="\t%s\n\t%s" % (LibraryInstance[Lc.LibraryClass], str(M))\r
964                                     )\r
965             if ConsumedByList[M] == []:\r
966                 Q.insert(0, M)\r
967         #\r
968         # while Q is not empty do\r
969         #\r
970         while Q != []:\r
971             #\r
972             # remove node from Q\r
973             #\r
974             Node = Q.pop()\r
975             #\r
976             # output Node\r
977             #\r
978             SortedLibraryList.append(Node)\r
979             #\r
980             # for each node Item with an edge e from Node to Item do\r
981             #\r
982             for Item in LibraryList:\r
983                 if Node not in ConsumedByList[Item]:\r
984                     continue\r
985                 #\r
986                 # remove edge e from the graph\r
987                 #\r
988                 ConsumedByList[Item].remove(Node)\r
989                 #\r
990                 # If Item has no other incoming edges then\r
991                 #\r
992                 if ConsumedByList[Item] == []:\r
993                     #\r
994                     # insert Item into Q\r
995                     #\r
996                     Q.insert(0, Item)\r
997 \r
998             EdgeRemoved = True\r
999             while Q == [] and EdgeRemoved:\r
1000                 EdgeRemoved = False\r
1001                 #\r
1002                 # for each node Item with a Constructor\r
1003                 #\r
1004                 for Item in LibraryList:\r
1005                     if Item in Constructor:\r
1006                         #\r
1007                         # for each Node without a constructor with an edge e from Item to Node\r
1008                         #\r
1009                         for Node in ConsumedByList[Item]:\r
1010                             if Node not in Constructor:\r
1011                                 #\r
1012                                 # remove edge e from the graph\r
1013                                 #\r
1014                                 ConsumedByList[Item].remove(Node)\r
1015                                 EdgeRemoved = True\r
1016                                 if ConsumedByList[Item] == []:\r
1017                                     #\r
1018                                     # insert Item into Q\r
1019                                     #\r
1020                                     Q.insert(0, Item)\r
1021                                     break\r
1022                     if Q != []:\r
1023                         break\r
1024 \r
1025         #\r
1026         # if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle\r
1027         #\r
1028         for Item in LibraryList:\r
1029             if ConsumedByList[Item] != [] and Item in Constructor and len(Constructor) > 1:\r
1030                 ErrorMessage = 'Library [%s] with constructors has a cycle' % str(Item)\r
1031                 EdkLogger.error("AutoGen", AUTOGEN_ERROR, ErrorMessage,\r
1032                                 "\tconsumed by " + "\n\tconsumed by ".join([str(L) for L in ConsumedByList[Item]]))\r
1033             if Item not in SortedLibraryList:\r
1034                 SortedLibraryList.append(Item)\r
1035 \r
1036         #\r
1037         # Build the list of constructor and destructir names\r
1038         # The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order\r
1039         #\r
1040         SortedLibraryList.reverse()\r
1041         Module.LibraryClasses = sdict()\r
1042         for L in SortedLibraryList:\r
1043             for Lc in L.LibraryClass:\r
1044                 Module.LibraryClasses[Lc.LibraryClass, ModuleType] = str(L)\r
1045             #\r
1046             # Merge PCDs from library instance\r
1047             #\r
1048             for Key in L.Pcds:\r
1049                 if Key not in Module.Pcds:\r
1050                     LibPcd = L.Pcds[Key]\r
1051                     Module.Pcds[Key] = self.FindPcd(Arch, str(Module), LibPcd.TokenCName, LibPcd.TokenSpaceGuidCName, LibPcd.Type, [])\r
1052             #\r
1053             # Merge GUIDs from library instance\r
1054             #\r
1055             for CName in L.Guids:\r
1056                 if CName not in Module.Guids:\r
1057                     Module.Guids.append(CName)\r
1058             #\r
1059             # Merge Protocols from library instance\r
1060             #\r
1061             for CName in L.Protocols:\r
1062                 if CName not in Module.Protocols:\r
1063                     Module.Protocols.append(CName)\r
1064             #\r
1065             # Merge Ppis from library instance\r
1066             #\r
1067             for CName in L.Ppis:\r
1068                 if CName not in Module.Ppis:\r
1069                     Module.Ppis.append(CName)\r
1070 \r
1071     ## GenBuildDatabase\r
1072     #\r
1073     # Generate build database for all arches\r
1074     #\r
1075     # @param PcdsSet: Pcd list for override from Fdf parse result\r
1076     # @param InfList: Inf list for override from Fdf parse result\r
1077     #\r
1078     def GenBuildDatabase(self, PcdsSet = {}, InfList = []):\r
1079         #\r
1080         # Add additional inf file defined in Fdf file\r
1081         #\r
1082         for InfFile in InfList:\r
1083             self.AddToInfDatabase(NormPath(InfFile))\r
1084         \r
1085         #\r
1086         # Generate PlatformDatabase, PackageDatabase and ModuleDatabase\r
1087         #\r
1088         self.GenPlatformDatabase()\r
1089         self.GenPackageDatabase()\r
1090         self.GenModuleDatabase(PcdsSet, InfList)\r
1091         \r
1092         #\r
1093         # Update Libraries Of Platform\r
1094         #\r
1095         self.UpdateLibrariesOfPlatform(InfList)\r
1096         \r
1097         #\r
1098         # Output used Pcds not found in DSC file\r
1099         #\r
1100         self.ShowUnFoundPcds()\r
1101 \r
1102     ## ShowUnFoundPcds()\r
1103     #\r
1104     # If there is any pcd used but not defined in DSC\r
1105     # Print warning message on screen and output a list of pcds\r
1106     #\r
1107     def ShowUnFoundPcds(self):\r
1108         if self.UnFoundPcdInDsc != {}:\r
1109             WrnMessage = '**** WARNING ****\n'\r
1110             WrnMessage += 'The following Pcds were not defined in the DSC file: %s\n' % self.DscFileName\r
1111             WrnMessage += 'The default values were obtained from the DEC file that declares the PCD and the PCD default value\n'\r
1112             for (Guid, Name, Type, Arch) in self.UnFoundPcdInDsc:\r
1113                 Dec = self.UnFoundPcdInDsc[(Guid, Name, Type, Arch)]\r
1114                 Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds\r
1115                 if (Name, Guid, Type) in Pcds:\r
1116                     Pcd = Pcds[(Name, Guid, Type)]\r
1117                     PcdItemTypeUsed = Pcd.Type\r
1118                     DefaultValue = Pcd.DefaultValue\r
1119                     WrnMessage += '%s.%s: Defined in file %s, PcdItemType is Pcds%s, DefaultValue is %s\n' % (Guid, Name, Dec, PcdItemTypeUsed, DefaultValue)\r
1120             EdkLogger.info(WrnMessage)\r
1121         \r
1122     ## Create a full path with workspace dir\r
1123     #\r
1124     # Convert Filename with workspace dir to create a full path\r
1125     #\r
1126     # @param Filename: The filename need to be added workspace dir\r
1127     #\r
1128     # @retval string Full path\r
1129     #\r
1130     def WorkspaceFile(self, Filename):\r
1131         return WorkspaceFile(self.WorkspaceDir, Filename)\r
1132 \r
1133     ## Update LibraryClass of Module\r
1134     #\r
1135     # If a module of a platform has its own override libraryclass but the libraryclass not defined in the module\r
1136     # Add this libraryclass to the module\r
1137     #\r
1138     # @param InfFileName:       InfFileName specificed in platform\r
1139     # @param LibraryClass:      LibraryClass specificed in platform\r
1140     # @param Arch:              Supportted Arch\r
1141     # @param InstanceFilePath:  InstanceFilePath specificed in platform\r
1142     #\r
1143     def UpdateLibraryClassOfModule(self, InfFileName, LibraryClass, Arch, InstanceFilePath):\r
1144         #\r
1145         # Update the library instance itself to add this libraryclass name\r
1146         #\r
1147         LibraryModule = self.InfDatabase[InstanceFilePath].Module\r
1148         LibList = LibraryModule.Header.LibraryClass\r
1149         NotFound = True\r
1150         for Lib in LibList:\r
1151             #\r
1152             # Find this LibraryClass\r
1153             #\r
1154             if Lib.LibraryClass == LibraryClass:\r
1155                 NotFound = False;\r
1156                 break;\r
1157         if NotFound:\r
1158             NewLib = LibraryClassClass()\r
1159             NewLib.LibraryClass = LibraryClass\r
1160             NewLib.SupModuleList = LibraryModule.Header.ModuleType.split()\r
1161             LibraryModule.Header.LibraryClass.append(NewLib)\r
1162 \r
1163         #\r
1164         # Add it to LibraryClasses Section for the module which is using the library\r
1165         #\r
1166         Module = self.InfDatabase[InfFileName].Module\r
1167         LibList = Module.LibraryClasses\r
1168         NotFound = True\r
1169         for Lib in LibList:\r
1170             #\r
1171             # Find this LibraryClass\r
1172             #\r
1173             if Lib.LibraryClass == LibraryClass:\r
1174                 if Arch in Lib.SupArchList:\r
1175                     return\r
1176                 else:\r
1177                     Lib.SupArchList.append(Arch)\r
1178                     return\r
1179         if NotFound:\r
1180             Lib = LibraryClassClass()\r
1181             Lib.LibraryClass = LibraryClass\r
1182             Lib.SupArchList = [Arch]\r
1183             Module.LibraryClasses.append(Lib)\r
1184 \r
1185     ## Add Inf file to InfDatabase\r
1186     #\r
1187     # Create a Inf instance for input inf file and add it to InfDatabase\r
1188     #\r
1189     # @param InfFileName: The InfFileName need to be added to database\r
1190     #\r
1191     def AddToInfDatabase(self, InfFileName):\r
1192         File = self.WorkspaceFile(InfFileName)\r
1193         if os.path.exists(File) and os.path.isfile(File):\r
1194             if InfFileName not in self.InfDatabase:\r
1195                 self.InfDatabase[InfFileName] = Inf(File, True, True, self.WorkspaceDir)\r
1196         else:\r
1197             EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File)\r
1198 \r
1199     ## Add Dec file to DecDatabase\r
1200     #\r
1201     # Create a Dec instance for input dec file and add it to DecDatabase\r
1202     #\r
1203     # @param DecFileName: The DecFileName need to be added to database\r
1204     #\r
1205     def AddToDecDatabase(self, DecFileName):\r
1206         File = self.WorkspaceFile(DecFileName)\r
1207         if os.path.exists(File) and os.path.isfile(File):\r
1208             if DecFileName not in self.DecDatabase:\r
1209                 self.DecDatabase[DecFileName] = Dec(File, True, True, self.WorkspaceDir)\r
1210         else:\r
1211             EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File)\r
1212 \r
1213     ## Search LibraryClass Instance for Module\r
1214     #\r
1215     # Search PlatformBuildDatabase to find LibraryClass Instance for Module\r
1216     # Return the instance if found\r
1217     #\r
1218     # @param Lib:         Input value for Library Class Name\r
1219     # @param Arch:        Supportted Arch\r
1220     # @param ModuleType:  Supportted ModuleType\r
1221     # @param ModuleName:  Input value for Module Name\r
1222     #\r
1223     # @retval string Found LibraryClass Instance file path\r
1224     #\r
1225     def FindLibraryClassInstanceOfModule(self, Lib, Arch, ModuleType, ModuleName):\r
1226         #\r
1227         # First find if exist in <LibraryClass> of <Components> from dsc file\r
1228         #\r
1229         for Dsc in self.DscDatabase.keys():\r
1230             Platform = self.DscDatabase[Dsc].Platform\r
1231             for Module in Platform.Modules.ModuleList:\r
1232                 if Arch in Module.SupArchList:\r
1233                     if Module.FilePath == ModuleName:\r
1234                         for LibraryClass in Module.LibraryClasses.LibraryList:\r
1235                             if LibraryClass.Name == Lib:\r
1236                                 return LibraryClass.FilePath\r
1237         #\r
1238         #Second find if exist in <LibraryClass> of <LibraryClasses> from dsc file\r
1239         #\r
1240         return self.FindLibraryClassInstanceOfLibrary(Lib, Arch, ModuleType)\r
1241 \r
1242     ## Search LibraryClass Instance for Library\r
1243     #\r
1244     # Search PlatformBuildDatabase to find LibraryClass Instance for Library\r
1245     # Return the instance if found\r
1246     #\r
1247     # @param Lib:   Input value for Library Class Name\r
1248     # @param Arch:  Supportted Arch\r
1249     # @param Type:  Supportted Library Usage Type\r
1250     #\r
1251     # @retval string Found LibraryClass Instance file path\r
1252     # @retval None   Not Found\r
1253     #\r
1254     def FindLibraryClassInstanceOfLibrary(self, Lib, Arch, Type):\r
1255         for Dsc in self.DscDatabase.keys():\r
1256             Platform  = self.DscDatabase[Dsc].Platform\r
1257             if (Lib, Type) in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses:\r
1258                 return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, Type)]\r
1259             elif (Lib, '') in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses:\r
1260                 return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, '')]\r
1261         return None\r
1262 \r
1263     ## Find BuildOptions\r
1264     #\r
1265     # Search DscDatabase to find component definition of ModuleName\r
1266     # Override BuildOption if it is defined in component\r
1267     #\r
1268     # @param Arch:          Supportted Arch\r
1269     # @param ModuleName:    The module which has buildoption definition in component of platform\r
1270     # @param BuildOptions:  The set of all buildopitons\r
1271     #\r
1272     def FindBuildOptions(self, Arch, ModuleName, BuildOptions):\r
1273         for Dsc in self.DscDatabase.keys():\r
1274             #\r
1275             # First find if exist in <BuildOptions> of <Components> from dsc file\r
1276             # if find, use that override the one defined in inf file\r
1277             #\r
1278             Platform = self.DscDatabase[Dsc].Platform\r
1279             for Module in Platform.Modules.ModuleList:\r
1280                 if Arch in Module.SupArchList:\r
1281                     if Module.FilePath == ModuleName:\r
1282                         for BuildOption in Module.ModuleSaBuildOption.BuildOptionList:\r
1283                             #\r
1284                             # Add to BuildOptions\r
1285                             #\r
1286                             BuildOptions[(BuildOption.ToolChainFamily, BuildOption.ToolChain)] = BuildOption.Option\r
1287 \r
1288     ## Find Pcd\r
1289     #\r
1290     # Search platform database, package database, module database and PcdsSet from Fdf\r
1291     # Return found Pcd\r
1292     #\r
1293     # @param Arch:        Supportted Arch\r
1294     # @param ModuleName:  The module which has pcd definition in component of platform\r
1295     # @param Name:        Name of Pcd\r
1296     # @param Guid:        Guid of Pcd\r
1297     # @param Type:        Type of Pcd\r
1298     # @param PcdsSet:     A PcdSet get from Fdf parse result\r
1299     #\r
1300     # @retval PcdClassObject An instance for PcdClassObject with all members filled\r
1301     #\r
1302     def FindPcd(self, Arch, ModuleName, Name, Guid, Type, PcdsSet):\r
1303         NewType = ''\r
1304         DatumType = ''\r
1305         Value = ''\r
1306         Token = ''\r
1307         MaxDatumSize = ''\r
1308         SkuInfoList = {}\r
1309         IsOverrided = False\r
1310         IsFoundInDsc = False\r
1311         IsFoundInDec = False\r
1312         FoundInDecFile = ''\r
1313         \r
1314         #\r
1315         # Second get information from platform database\r
1316         #\r
1317         OwnerPlatform = ''\r
1318         for Dsc in self.Build[Arch].PlatformDatabase.keys():\r
1319             Pcds = self.Build[Arch].PlatformDatabase[Dsc].Pcds\r
1320             if (Name, Guid) in Pcds:\r
1321                 OwnerPlatform = Dsc\r
1322                 Pcd = Pcds[(Name, Guid)]\r
1323                 if Pcd.Type != '' and Pcd.Type != None:\r
1324                     NewType = Pcd.Type\r
1325                     if NewType in DataType.PCD_DYNAMIC_TYPE_LIST:\r
1326                         NewType = DataType.TAB_PCDS_DYNAMIC\r
1327                     elif NewType in DataType.PCD_DYNAMIC_EX_TYPE_LIST:\r
1328                         NewType = DataType.TAB_PCDS_DYNAMIC_EX\r
1329                 else:\r
1330                     NewType = Type\r
1331 \r
1332                 if Type != '' and Type != NewType:\r
1333                     ErrorMsg = "PCD %s.%s is declared as [%s] in module\n\t%s\n\n"\\r
1334                                "    But it's used as [%s] in platform\n\t%s"\\r
1335                                % (Guid, Name, Type, ModuleName, NewType, OwnerPlatform)\r
1336                     EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg)\r
1337 \r
1338 \r
1339                 if Pcd.DatumType != '' and Pcd.DatumType != None:\r
1340                     DatumType = Pcd.DatumType\r
1341                 if Pcd.TokenValue != '' and Pcd.TokenValue != None:\r
1342                     Token = Pcd.TokenValue\r
1343                 if Pcd.DefaultValue != '' and Pcd.DefaultValue != None:\r
1344                     Value = Pcd.DefaultValue\r
1345                 if Pcd.MaxDatumSize != '' and Pcd.MaxDatumSize != None:\r
1346                     MaxDatumSize = Pcd.MaxDatumSize\r
1347                 SkuInfoList =  Pcd.SkuInfoList\r
1348                 \r
1349                 IsOverrided = True\r
1350                 IsFoundInDsc = True\r
1351                 break\r
1352 \r
1353         #\r
1354         # Third get information from <Pcd> of <Compontents> from module database\r
1355         #\r
1356         for Dsc in self.DscDatabase.keys():\r
1357             for Module in self.DscDatabase[Dsc].Platform.Modules.ModuleList:\r
1358                 if Arch in Module.SupArchList:\r
1359                     if Module.FilePath == ModuleName:\r
1360                         for Pcd in Module.PcdBuildDefinitions:\r
1361                             if (Name, Guid) == (Pcd.CName, Pcd.TokenSpaceGuidCName):\r
1362                                 if Pcd.DefaultValue != '':\r
1363                                     Value = Pcd.DefaultValue\r
1364                                 if Pcd.MaxDatumSize != '':\r
1365                                     MaxDatumSize = Pcd.MaxDatumSize\r
1366                                     \r
1367                                 IsFoundInDsc = True\r
1368                                 IsOverrided = True\r
1369                                 break\r
1370 \r
1371         #\r
1372         # Last get information from PcdsSet defined by FDF\r
1373         #\r
1374         if (Name, Guid) in PcdsSet:\r
1375             Value = PcdsSet[(Name, Guid)]\r
1376             IsFoundInDsc = True\r
1377             IsOverrided = True\r
1378 \r
1379         #\r
1380         # First get information from package database\r
1381         #\r
1382         Pcd = None\r
1383         if NewType == '':\r
1384             if Type != '':\r
1385                 PcdTypeList = [Type]\r
1386             else:\r
1387                 PcdTypeList = ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]\r
1388 \r
1389             for Dec in self.Build[Arch].PackageDatabase.keys():\r
1390                 Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds\r
1391                 for PcdType in PcdTypeList:\r
1392                     if (Name, Guid, PcdType) in Pcds:\r
1393                         Pcd = Pcds[(Name, Guid, PcdType)]\r
1394                         NewType = PcdType\r
1395                         IsOverrided = True\r
1396                         IsFoundInDec = True\r
1397                         FoundInDecFile = Dec\r
1398                         break\r
1399                 else:\r
1400                     continue\r
1401                 break\r
1402         else:\r
1403             for Dec in self.Build[Arch].PackageDatabase.keys():\r
1404                 Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds\r
1405                 if (Name, Guid, NewType) in Pcds:\r
1406                     Pcd = Pcds[(Name, Guid, NewType)]\r
1407                     IsOverrided = True\r
1408                     IsFoundInDec = True\r
1409                     FoundInDecFile = Dec\r
1410                     break\r
1411 \r
1412         if not IsFoundInDec:\r
1413             if NewType != '':\r
1414                 SupportedPcdTypeList = []\r
1415                 OwnerPackage = ''\r
1416                 for Dec in self.Build[Arch].PackageDatabase.keys():\r
1417                     Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds\r
1418                     for PcdType in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:\r
1419                         if (Name, Guid, PcdType) in Pcds:\r
1420                             SupportedPcdTypeList.append(PcdType)\r
1421                             OwnerPackage = Dec\r
1422                 ErrorMsg = "Only [%s] is supported for Pcd '%s.%s' in package\n\t%s\n\n"\\r
1423                            "    But [%s] is specified in platform\n\t%s"\\r
1424                            % (", ".join(SupportedPcdTypeList), Guid, Name, OwnerPackage, NewType, OwnerPlatform)\r
1425             else:\r
1426                 ErrorMsg = "Pcd '%s.%s [%s]' defined in module '%s' is not found in any package" % (Guid, Name, NewType, ModuleName)\r
1427             EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg)\r
1428 \r
1429         #\r
1430         # Not found in any platform and fdf\r
1431         #\r
1432         if not IsFoundInDsc:\r
1433             Value = Pcd.DefaultValue\r
1434             if NewType.startswith("Dynamic") and SkuInfoList == {}:\r
1435                 SkuIds = self.Build[Arch].PlatformDatabase.values()[0].SkuIds\r
1436                 SkuInfoList['DEFAULT'] = SkuInfoClass(SkuIdName='DEFAULT', SkuId=SkuIds['DEFAULT'], DefaultValue=Value)\r
1437             self.UnFoundPcdInDsc[(Guid, Name, NewType, Arch)] = FoundInDecFile\r
1438         #elif Type != '' and NewType.startswith("Dynamic"):\r
1439         #    NewType = Pcd.Type\r
1440         DatumType = Pcd.DatumType\r
1441         if Token in [None, '']:\r
1442             Token = Pcd.TokenValue\r
1443         if DatumType == "VOID*" and MaxDatumSize in ['', None]:\r
1444             EdkLogger.warn("\nAutoGen", "No MaxDatumSize specified for PCD %s.%s" % (Guid, Name),\r
1445                            ExtraData=ModuleName)\r
1446             if Value[0] == 'L':\r
1447                 MaxDatumSize = str(len(Value) * 2)\r
1448             elif Value[0] == '{':\r
1449                 MaxDatumSize = str(len(Value.split(',')))\r
1450             else:\r
1451                 MaxDatumSize = str(len(Value))\r
1452 \r
1453         return PcdClassObject(Name, Guid, NewType, DatumType, Value, Token, MaxDatumSize, SkuInfoList, IsOverrided)\r
1454 \r
1455     ## Find Supportted Module List Of LibraryClass\r
1456     #\r
1457     # Search in InfDatabase, find the supmodulelist of the libraryclass\r
1458     #\r
1459     # @param LibraryClass:               LibraryClass name for search\r
1460     # @param OverridedLibraryClassList:  A list of all LibraryClass\r
1461     # @param Arch:                       Supportted Arch\r
1462     #\r
1463     # @retval list SupModuleList\r
1464     #\r
1465     def FindSupModuleListOfLibraryClass(self, LibraryClass, OverridedLibraryClassList, Arch):\r
1466         Name = LibraryClass.Name\r
1467         FilePath = LibraryClass.FilePath\r
1468         SupModuleList = copy.copy(LibraryClass.SupModuleList)\r
1469 \r
1470         #\r
1471         # If the SupModuleList means all, remove overrided module types of platform\r
1472         #\r
1473         if SupModuleList == DataType.SUP_MODULE_LIST:\r
1474             EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s supports all module types" % Name)\r
1475             for Item in OverridedLibraryClassList:\r
1476                 #\r
1477                 # Find a library class (Item) with the same name\r
1478                 #\r
1479                 if Item.Name == Name:\r
1480                     #\r
1481                     # Do nothing if it is itself\r
1482                     #\r
1483                     if Item.SupModuleList == DataType.SUP_MODULE_LIST:\r
1484                         continue\r
1485                     #\r
1486                     # If not itself, check arch first\r
1487                     #\r
1488                     if Arch in LibraryClass.SupArchList:\r
1489                         #\r
1490                         # If arch is supportted, remove all related module type\r
1491                         #\r
1492                         if Arch in Item.SupArchList:\r
1493                             for ModuleType in Item.SupModuleList:\r
1494                                 EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s has specific defined module types" % Name)\r
1495                                 if ModuleType in SupModuleList:\r
1496                                     SupModuleList.remove(ModuleType)\r
1497 \r
1498         return SupModuleList\r
1499 \r
1500     ## Find Module inf Platform\r
1501     #\r
1502     # Check if the module is defined in <Compentent> of <Platform>\r
1503     #\r
1504     # @param Inf:      Inf file (Module) need to be searched\r
1505     # @param Arch:     Supportted Arch\r
1506     # @param InfList:  A list for all Inf file\r
1507     #\r
1508     # @retval True     Mudule Found\r
1509     # @retval Flase    Module Not Found\r
1510     #\r
1511     def IsModuleDefinedInPlatform(self, Inf, Arch, InfList):\r
1512         for Dsc in self.DscDatabase.values():\r
1513             for LibraryClass in Dsc.Platform.LibraryClasses.LibraryList:\r
1514                 if Inf == LibraryClass.FilePath and Arch in LibraryClass.SupArchList:\r
1515                     return True\r
1516             for Module in Dsc.Platform.Modules.ModuleList:\r
1517                 if Inf == Module.FilePath and Arch in Module.SupArchList:\r
1518                     return True\r
1519                 for Item in Module.LibraryClasses.LibraryList:\r
1520                     if Inf == Item.FilePath:\r
1521                         return True\r
1522             for Library in Dsc.Platform.Libraries.LibraryList:\r
1523                 if Inf == Library.FilePath and Arch in Library.SupArchList:\r
1524                     return True\r
1525 \r
1526         return False\r
1527 \r
1528     ## Show all content of the workspacebuild\r
1529     #\r
1530     # Print each item of the workspacebuild with (Key = Value) pair\r
1531     #\r
1532     def ShowWorkspaceBuild(self):\r
1533         print self.DscDatabase\r
1534         print self.InfDatabase\r
1535         print self.DecDatabase\r
1536         print 'SupArchList', self.SupArchList\r
1537         print 'BuildTarget', self.BuildTarget\r
1538         print 'SkuId', self.SkuId\r
1539 \r
1540         for Arch in self.SupArchList:\r
1541             print Arch\r
1542             print 'Platform'\r
1543             for Platform in self.Build[Arch].PlatformDatabase.keys():\r
1544                 P = self.Build[Arch].PlatformDatabase[Platform]\r
1545                 print 'DescFilePath = ', P.DescFilePath\r
1546                 print 'PlatformName = ', P.PlatformName\r
1547                 print 'Guid = ', P.Guid\r
1548                 print 'Version = ', P.Version\r
1549                 print 'OutputDirectory = ', P.OutputDirectory\r
1550                 print 'FlashDefinition = ', P.FlashDefinition\r
1551                 print 'SkuIds = ', P.SkuIds\r
1552                 print 'Modules = ', P.Modules\r
1553                 print 'LibraryClasses = ', P.LibraryClasses\r
1554                 print 'Pcds = ', P.Pcds\r
1555                 for item in P.Pcds.keys():\r
1556                     print P.Pcds[item]\r
1557                 print 'BuildOptions = ', P.BuildOptions\r
1558                 print ''\r
1559             # End of Platform\r
1560 \r
1561             print 'package'\r
1562             for Package in self.Build[Arch].PackageDatabase.keys():\r
1563                 P = self.Build[Arch].PackageDatabase[Package]\r
1564                 print 'DescFilePath = ', P.DescFilePath\r
1565                 print 'PackageName = ', P.PackageName\r
1566                 print 'Guid = ', P.Guid\r
1567                 print 'Version = ', P.Version\r
1568                 print 'Protocols = ', P.Protocols\r
1569                 print 'Ppis = ', P.Ppis\r
1570                 print 'Guids = ', P.Guids\r
1571                 print 'Includes = ', P.Includes\r
1572                 print 'LibraryClasses = ', P.LibraryClasses\r
1573                 print 'Pcds = ', P.Pcds\r
1574                 for item in P.Pcds.keys():\r
1575                     print P.Pcds[item]\r
1576                 print ''\r
1577             # End of Package\r
1578 \r
1579             print 'module'\r
1580             for Module in self.Build[Arch].ModuleDatabase.keys():\r
1581                 P = self.Build[Arch].ModuleDatabase[Module]\r
1582                 print 'DescFilePath = ', P.DescFilePath\r
1583                 print 'BaseName = ', P.BaseName\r
1584                 print 'ModuleType = ', P.ModuleType\r
1585                 print 'Guid = ', P.Guid\r
1586                 print 'Version = ', P.Version\r
1587                 print 'CustomMakefile = ', P.CustomMakefile\r
1588                 print 'Specification = ', P.Specification\r
1589                 print 'Shadow = ', P.Shadow\r
1590                 print 'PcdIsDriver = ', P.PcdIsDriver\r
1591                 for Lib in P.LibraryClass:\r
1592                     print 'LibraryClassDefinition = ', Lib.LibraryClass, 'SupModList = ', Lib.SupModList\r
1593                 print 'ModuleEntryPointList = ', P.ModuleEntryPointList\r
1594                 print 'ModuleUnloadImageList = ', P.ModuleUnloadImageList\r
1595                 print 'ConstructorList = ', P.ConstructorList\r
1596                 print 'DestructorList = ', P.DestructorList\r
1597 \r
1598                 print 'Binaries = '\r
1599                 for item in P.Binaries:\r
1600                     print item.BinaryFile, item.FeatureFlag, item.SupArchList\r
1601                 print 'Sources = '\r
1602                 for item in P.Sources:\r
1603                     print item.SourceFile\r
1604                 print 'LibraryClasses = ', P.LibraryClasses\r
1605                 print 'Protocols = ', P.Protocols\r
1606                 print 'Ppis = ', P.Ppis\r
1607                 print 'Guids = ', P.Guids\r
1608                 print 'Includes = ', P.Includes\r
1609                 print 'Packages = ', P.Packages\r
1610                 print 'Pcds = ', P.Pcds\r
1611                 for item in P.Pcds.keys():\r
1612                     print P.Pcds[item]\r
1613                 print 'BuildOptions = ', P.BuildOptions\r
1614                 print 'Depex = ', P.Depex\r
1615                 print ''\r
1616             # End of Module\r
1617 \r
1618 ##\r
1619 #\r
1620 # This acts like the main() function for the script, unless it is 'import'ed into another\r
1621 # script.\r
1622 #\r
1623 if __name__ == '__main__':\r
1624     W = os.getenv('WORKSPACE')\r
1625     Ewb = WorkspaceBuild('Nt32Pkg/Nt32Pkg.dsc', W)\r
1626     Ewb.GenBuildDatabase({('PcdDevicePathSupportDevicePathFromText, gEfiMdeModulePkgTokenSpaceGuid') : 'KKKKKKKKKKKKKKKKKKKKK'}, ['Test.Inf'])\r
1627     Ewb.ShowWorkspaceBuild()\r