]> git.proxmox.com Git - mirror_edk2.git/blame - BaseTools/Source/Python/Common/EdkIIWorkspaceBuild.py
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Sync EDKII BaseTools to BaseTools project r1903.
[mirror_edk2.git] / BaseTools / Source / Python / Common / EdkIIWorkspaceBuild.py
CommitLineData
30fdf114
LG		 1## @file\r
2# This file is used to define each component of the build database\r
3#\r
52302d4d 4# Copyright (c) 2007 - 2010, Intel Corporation\r
30fdf114
LG		 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
17import os, string, copy, pdb, copy\r
18import EdkLogger\r
19import DataType\r
20from InfClassObject import *\r
21from DecClassObject import *\r
22from DscClassObject import *\r
23from String import *\r
24from BuildToolError import *\r
25from Misc import sdict\r
26import Database as Database\r
27import 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
54class 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
120class 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
171class 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
254class 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
324class 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
390class 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
431class 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
52302d4d
LG		 751 Pb.Specification[TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION] = ModuleHeader.UefiSpecificationVersion\r
752 Pb.Specification[TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION] = ModuleHeader.UefiSpecificationVersion\r
30fdf114
LG		 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
1661if __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
EFI Development Kit II mirror for PVE