7e92f73f324433734cb1e449330dcf4c9ca3b073
[people/mcb30/basetools.git] / Source / Python / Common / EdkIIWorkspaceBuild.py
1 # Copyright (c) 2007, Intel Corporation\r
2 # All rights reserved. This program and the accompanying materials\r
3 # are licensed and made available under the terms and conditions of the BSD License\r
4 # which accompanies this distribution.    The full text of the license may be found at\r
5 # http://opensource.org/licenses/bsd-license.php\r
6 #\r
7 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
8 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
9 \r
10 #\r
11 # This file is used to define each component of the build database\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 #\r
29 # This Class is used for PcdObject\r
30 #\r
31 class PcdClassObject(object):\r
32     def __init__(self, Name = None, Guid = None, Type = None, DatumType = None, Value = None, Token = None, MaxDatumSize = None, SkuInfoList = {}, IsOverrided = False):\r
33         self.TokenCName = Name\r
34         self.TokenSpaceGuidCName = Guid\r
35         self.Type = Type\r
36         self.DatumType = DatumType\r
37         self.DefaultValue = Value\r
38         self.TokenValue = Token\r
39         self.MaxDatumSize = MaxDatumSize\r
40         self.SkuInfoList = SkuInfoList\r
41         self.IsOverrided = IsOverrided\r
42         self.Phase = "DXE"\r
43 \r
44     def __str__(self):\r
45         rtn = '\tTokenCName=' + str(self.TokenCName) + ', ' + \\r
46               'TokenSpaceGuidCName=' + str(self.TokenSpaceGuidCName) + ', ' + \\r
47               'Type=' + str(self.Type) + ', ' + \\r
48               'DatumType=' + str(self.DatumType) + ', ' + \\r
49               'DefaultValue=' + str(self.DefaultValue) + ', ' + \\r
50               'TokenValue=' + str(self.TokenValue) + ', ' + \\r
51               'MaxDatumSize=' + str(self.MaxDatumSize) + ', '\r
52         for Item in self.SkuInfoList.values():\r
53             rtn = rtn + 'SkuId=' + Item.SkuId + ', ' + 'SkuIdName=' + Item.SkuIdName\r
54         rtn = rtn + str(self.IsOverrided)\r
55 \r
56         return rtn\r
57 \r
58     def __eq__(self, other):\r
59         return other != None and self.TokenCName == other.TokenCName and self.TokenSpaceGuidCName == other.TokenSpaceGuidCName\r
60 \r
61     def __hash__(self):\r
62         return hash((self.TokenCName, self.TokenSpaceGuidCName))\r
63 \r
64 #\r
65 # This Class is used for LibraryClassObject\r
66 #\r
67 class LibraryClassObject(object):\r
68     def __init__(self, Name = None, SupModList = [], Type = None):\r
69         self.LibraryClass = Name\r
70         self.SupModList = SupModList\r
71         if Type != None:\r
72             self.SupModList = CleanString(Type).split(DataType.TAB_SPACE_SPLIT)\r
73 \r
74 class ModuleBuildClassObject(object):\r
75     def __init__(self):\r
76         self.DescFilePath            = ''\r
77         self.BaseName                = ''\r
78         self.ModuleType              = ''\r
79         self.Guid                    = ''\r
80         self.Version                 = ''\r
81         self.PcdIsDriver             = ''\r
82         self.BinaryModule            = ''\r
83         self.CustomMakefile          = {}\r
84         self.Specification           = {}\r
85         self.LibraryClass            = []      # [ LibraryClassObject, ...]\r
86         self.ModuleEntryPointList    = []\r
87         self.ModuleUnloadImageList   = []\r
88         self.ConstructorList         = []\r
89         self.DestructorList          = []\r
90 \r
91         self.Binaries                = []        #[ ModuleBinaryClassObject, ...]\r
92         self.Sources                 = []        #[ ModuleSourceFilesClassObject, ... ]\r
93         self.LibraryClasses          = {}        #{ [LibraryClassName, ModuleType] : LibraryClassInfFile }\r
94         self.Protocols               = []        #[ ProtocolName, ... ]\r
95         self.Ppis                    = []        #[ PpiName, ... ]\r
96         self.Guids                   = []        #[ GuidName, ... ]\r
97         self.Includes                = []        #[ IncludePath, ... ]\r
98         self.Packages                = []        #[ DecFileName, ... ]\r
99         self.Pcds                    = {}        #{ [(PcdCName, PcdGuidCName)] : PcdClassObject}\r
100         self.BuildOptions            = {}        #{ [BuildOptionKey] : BuildOptionValue}\r
101         self.Depex                   = ''\r
102 \r
103     def __str__(self):\r
104         return self.DescFilePath\r
105 \r
106     def __eq__(self, other):\r
107         return self.DescFilePath == str(other)\r
108 \r
109     def __hash__(self):\r
110         return hash(self.DescFilePath)\r
111 \r
112 class PackageBuildClassObject(object):\r
113     def __init__(self):\r
114         self.DescFilePath            = ''\r
115         self.PackageName             = ''\r
116         self.Guid                    = ''\r
117         self.Version                 = ''\r
118 \r
119         self.Protocols               = {}       #{ [ProtocolName] : Protocol Guid, ... }\r
120         self.Ppis                    = {}       #{ [PpiName] : Ppi Guid, ... }\r
121         self.Guids                   = {}       #{ [GuidName] : Guid, ... }\r
122         self.Includes                = []       #[ IncludePath, ... ]\r
123         self.LibraryClasses          = {}       #{ [LibraryClassName] : LibraryClassInfFile }\r
124         self.Pcds                    = {}       #{ [(PcdCName, PcdGuidCName)] : PcdClassObject}\r
125 \r
126     def __str__(self):\r
127         return self.DescFilePath\r
128 \r
129     def __eq__(self, other):\r
130         return self.DescFilePath == str(other)\r
131 \r
132     def __hash__(self):\r
133         return hash(self.DescFilePath)\r
134 \r
135 class PlatformBuildClassObject(object):\r
136     def __init__(self):\r
137         self.DescFilePath            = ''\r
138         self.PlatformName            = ''\r
139         self.Guid                    = ''\r
140         self.Version                 = ''\r
141         self.DscSpecification        = ''\r
142         self.OutputDirectory         = ''\r
143         self.FlashDefinition         = ''\r
144         self.BuildNumber             = ''\r
145         self.MakefileName            = ''\r
146 \r
147         self.SkuIds                  = {}       #{ 'SkuName' : SkuId, '!include' : includefilename, ...}\r
148         self.Modules                 = []       #[ InfFileName, ... ]\r
149         self.Libraries               = []       #[ InfFileName, ... ]\r
150         self.LibraryClasses          = {}       #{ (LibraryClassName, ModuleType) : LibraryClassInfFile }\r
151         self.Pcds                    = {}       #{ [(PcdCName, PcdGuidCName)] : PcdClassObject }\r
152         self.BuildOptions            = {}       #{ [BuildOptionKey] : BuildOptionValue }\r
153 \r
154     def __str__(self):\r
155         return self.DescFilePath\r
156 \r
157     def __eq__(self, other):\r
158         return self.DescFilePath == str(other)\r
159 \r
160     def __hash__(self):\r
161         return hash(self.DescFilePath)\r
162 \r
163 class ItemBuild(object):\r
164     def __init__(self, Arch, Platform = None, Package = None, Module = None):\r
165         self.Arch                    = Arch\r
166         self.PlatformDatabase        = {}        #{ [DscFileName] : PlatformBuildClassObject, ...}\r
167         self.PackageDatabase         = {}        #{ [DecFileName] : PacakgeBuildClassObject, ...}\r
168         self.ModuleDatabase          = {}        #{ [InfFileName] : ModuleBuildClassObject, ...}\r
169 \r
170 #\r
171 # This class is used to parse active platform to init all inf/dec/dsc files\r
172 # Generate module/package/platform databases for build\r
173 #\r
174 class WorkspaceBuild(object):\r
175     def __init__(self, ActivePlatform, WorkspaceDir):\r
176         self.WorkspaceDir            = NormPath(WorkspaceDir)\r
177         self.SupArchList             = []        #[ 'IA32', 'X64', ...]\r
178         self.BuildTarget             = []        #[ 'RELEASE', 'DEBUG']\r
179         self.SkuId                   = ''\r
180         self.Fdf                     = ''\r
181         self.FdTargetList            = []\r
182         self.FvTargetList            = []\r
183         self.TargetTxt               = None\r
184         self.ToolDef                 = None\r
185 \r
186         self.InfDatabase             = {}        #{ [InfFileName] : InfClassObject}\r
187         self.DecDatabase             = {}        #{ [DecFileName] : DecClassObject}\r
188         self.DscDatabase             = {}        #{ [DscFileName] : DscClassObject}\r
189 \r
190         #\r
191         # Init build for all arches\r
192         #\r
193         self.Build                   = {}\r
194         for Arch in DataType.ARCH_LIST:\r
195             self.Build[Arch] = ItemBuild(Arch)\r
196 \r
197         #\r
198         # Get active platform\r
199         #\r
200         DscFileName = NormPath(ActivePlatform)\r
201         File = self.WorkspaceFile(DscFileName)\r
202         if os.path.exists(File) and os.path.isfile(File):\r
203             self.DscDatabase[DscFileName] = Dsc(File, True, True, self.WorkspaceDir)\r
204         else:\r
205             EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData = File)\r
206 \r
207         #\r
208         # Parse platform to get module\r
209         #\r
210         for DscFile in self.DscDatabase.keys():\r
211             Platform = self.DscDatabase[DscFile].Platform\r
212 \r
213             #\r
214             # Get global information\r
215             #\r
216             self.SupArchList = Platform.Header.SupArchList\r
217             self.BuildTarget = Platform.Header.BuildTargets\r
218             self.SkuId = Platform.Header.SkuIdName\r
219             self.Fdf = NormPath(Platform.FlashDefinitionFile.FilePath)\r
220 \r
221             #\r
222             # Get all inf files\r
223             #\r
224             for Item in Platform.LibraryClasses.LibraryList:\r
225                 for Arch in Item.SupArchList:\r
226                     self.AddToInfDatabase(Item.FilePath)\r
227 \r
228             for Item in Platform.Modules.ModuleList:\r
229                 for Arch in Item.SupArchList:\r
230                     #\r
231                     # Add modules\r
232                     #\r
233                     Module = Item.FilePath\r
234                     self.AddToInfDatabase(Module)\r
235                     #\r
236                     # Add library used in modules\r
237                     #\r
238                     for Lib in Item.LibraryClasses.LibraryList:\r
239                         self.AddToInfDatabase(Lib.FilePath)\r
240                         self.UpdateLibraryClassOfModule(Module, Lib.Name, Arch, Lib.FilePath)\r
241 \r
242         #\r
243         # Parse module to get package\r
244         #\r
245         for InfFile in self.InfDatabase.keys():\r
246             Module = self.InfDatabase[InfFile].Module\r
247             #\r
248             # Get all dec\r
249             #\r
250             for Item in Module.PackageDependencies:\r
251                 for Arch in Item.SupArchList:\r
252                     self.AddToDecDatabase(Item.FilePath)\r
253     # End of self.Init()\r
254 \r
255     #\r
256     # Generate PlatformDatabase\r
257     #\r
258     def GenPlatformDatabase(self):\r
259         for Dsc in self.DscDatabase.keys():\r
260             Platform = self.DscDatabase[Dsc].Platform\r
261 \r
262             for Arch in self.SupArchList:\r
263                 pb = PlatformBuildClassObject()\r
264 \r
265                 # Defines\r
266                 pb.DescFilePath = Dsc\r
267                 pb.PlatformName = Platform.Header.Name\r
268                 pb.Guid = Platform.Header.Guid\r
269                 pb.Version = Platform.Header.Version\r
270                 pb.DscSpecification = Platform.Header.DscSpecification\r
271                 pb.OutputDirectory = NormPath(Platform.Header.OutputDirectory)\r
272                 pb.FlashDefinition = NormPath(Platform.FlashDefinitionFile.FilePath)\r
273                 pb.BuildNumber = Platform.Header.BuildNumber\r
274 \r
275                 # SkuId\r
276                 for Key in Platform.SkuInfos.SkuInfoList.keys():\r
277                     pb.SkuIds[Key] = Platform.SkuInfos.SkuInfoList[Key]\r
278 \r
279                 # Module\r
280                 for Item in Platform.Modules.ModuleList:\r
281                     if Arch in Item.SupArchList:\r
282                         pb.Modules.append(NormPath(Item.FilePath))\r
283 \r
284                 # BuildOptions\r
285                 for Item in Platform.BuildOptions.BuildOptionList:\r
286                     if Arch in Item.SupArchList:\r
287                         pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = Item.Option\r
288 \r
289                 # LibraryClass\r
290                 for Item in Platform.LibraryClasses.LibraryList:\r
291                     SupModuleList = self.FindSupModuleListOfLibraryClass(Item, Platform.LibraryClasses.LibraryList)\r
292                     if Arch in Item.SupArchList:\r
293                         for ModuleType in SupModuleList:\r
294                             pb.LibraryClasses[(Item.Name, ModuleType)] = NormPath(Item.FilePath)\r
295 \r
296                 # Pcds\r
297                 for Item in Platform.DynamicPcdBuildDefinitions:\r
298                     if Arch in Item.SupArchList:\r
299                         Name = Item.CName\r
300                         Guid = Item.TokenSpaceGuidCName\r
301                         Type = Item.ItemType\r
302                         DatumType = Item.DatumType\r
303                         Value = Item.DefaultValue\r
304                         Token = Item.Token\r
305                         MaxDatumSize = Item.MaxDatumSize\r
306                         SkuInfoList = Item.SkuInfoList\r
307                         pb.Pcds[(Name, Guid)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)\r
308 \r
309                 # Add to database\r
310                 self.Build[Arch].PlatformDatabase[Dsc] = pb\r
311                 pb = None\r
312 \r
313     #\r
314     # Generate PackageDatabase\r
315     #\r
316     def GenPackageDatabase(self):\r
317         for Dec in self.DecDatabase.keys():\r
318             Package = self.DecDatabase[Dec].Package\r
319 \r
320             for Arch in self.SupArchList:\r
321                 pb = PackageBuildClassObject()\r
322 \r
323                 # Defines\r
324                 pb.DescFilePath = Dec\r
325                 pb.PackageName = Package.Header.Name\r
326                 pb.Guid = Package.Header.Guid\r
327                 pb.Version = Package.Header.Version\r
328 \r
329                 # Protocols\r
330                 for Item in Package.ProtocolDeclarations:\r
331                     if Arch in Item.SupArchList:\r
332                         pb.Protocols[Item.CName] = Item.Guid\r
333 \r
334                 # Ppis\r
335                 for Item in Package.PpiDeclarations:\r
336                     if Arch in Item.SupArchList:\r
337                         pb.Ppis[Item.CName] = Item.Guid\r
338 \r
339                 # Guids\r
340                 for Item in Package.GuidDeclarations:\r
341                     if Arch in Item.SupArchList:\r
342                         pb.Ppis[Item.CName] = Item.Guid\r
343 \r
344                 # Includes\r
345                 for Item in Package.Includes:\r
346                     if Arch in Item.SupArchList:\r
347                         pb.Includes.append(NormPath(Item.FilePath))\r
348 \r
349                 # LibraryClasses\r
350                 for Item in Package.LibraryClassDeclarations:\r
351                     if Arch in Item.SupArchList:\r
352                         pb.LibraryClasses[Item.LibraryClass] = NormPath(Item.RecommendedInstance)\r
353 \r
354                 # Pcds\r
355                 for Item in Package.PcdDeclarations:\r
356                     if Arch in Item.SupArchList:\r
357                         Name = Item.CName\r
358                         Guid = Item.TokenSpaceGuidCName\r
359                         Type = Item.ItemType\r
360                         DatumType = Item.DatumType\r
361                         Value = Item.DefaultValue\r
362                         Token = Item.Token\r
363                         MaxDatumSize = Item.MaxDatumSize\r
364                         SkuInfoList = Item.SkuInfoList\r
365                         pb.Pcds[(Name, Guid)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)\r
366 \r
367                 # Add to database\r
368                 self.Build[Arch].PackageDatabase[Dec] = pb\r
369                 pb = None\r
370 \r
371     #\r
372     # Generate ModuleDatabase\r
373     #\r
374     def GenModuleDatabase(self, PcdsSet = {}, InfList = []):\r
375         for Inf in self.InfDatabase.keys():\r
376             Module = self.InfDatabase[Inf].Module\r
377 \r
378             for Arch in self.SupArchList:\r
379                 if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList):\r
380                     continue\r
381 \r
382                 pb = ModuleBuildClassObject()\r
383 \r
384                 # Defines\r
385                 pb.DescFilePath = Inf\r
386                 pb.BaseName = Module.Header.Name\r
387                 pb.Guid = Module.Header.Guid\r
388                 pb.Version = Module.Header.Version\r
389                 pb.ModuleType = Module.Header.ModuleType\r
390                 pb.PcdIsDriver = Module.Header.PcdIsDriver\r
391                 pb.BinaryModule = Module.Header.BinaryModule\r
392                 pb.CustomMakefile = Module.Header.CustomMakefile\r
393 \r
394                 # Specs os Defines\r
395                 pb.Specification = Module.Header.Specification\r
396                 pb.Specification[TAB_INF_DEFINES_EDK_RELEASE_VERSION] = Module.Header.EdkReleaseVersion\r
397                 pb.Specification[TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION] = Module.Header.EfiSpecificationVersion\r
398 \r
399                 # LibraryClass of Defines\r
400                 for Item in Module.Header.LibraryClass:\r
401                     pb.LibraryClass.append(LibraryClassObject(Item.LibraryClass, Item.SupModuleList, None))\r
402 \r
403                 # Module image and library of Defines\r
404                 for Item in Module.ExternImages:\r
405                     if Item.ModuleEntryPoint != '':\r
406                         pb.ModuleEntryPointList.append(Item.ModuleEntryPoint)\r
407                     if Item.ModuleUnloadImage != '':\r
408                         pb.ModuleUnloadImageList.append(Item.ModuleUnloadImage)\r
409                 for Item in Module.ExternLibraries:\r
410                     if Item.Constructor != '':\r
411                         pb.ConstructorList.append(Item.Constructor)\r
412                     if Item.Destructor != '':\r
413                         pb.DestructorList.append(Item.Destructor)\r
414 \r
415                 # Binaries\r
416                 for Item in Module.Binaries:\r
417                     if Arch in Item.SupArchList:\r
418                         FileName = NormPath(Item.BinaryFile)\r
419                         FileType = Item.FileType\r
420                         Target = Item.Target\r
421                         FeatureFlag = Item.FeatureFlag\r
422                         pb.Binaries.append(ModuleBinaryFileClass(FileName, FileType, Target, FeatureFlag))\r
423 \r
424                 #Sources\r
425                 for Item in Module.Sources:\r
426                     if Arch in Item.SupArchList:\r
427                         SourceFile = NormPath(Item.SourceFile)\r
428                         TagName = Item.TagName\r
429                         ToolCode = Item.ToolCode\r
430                         ToolChainFamily = Item.ToolChainFamily\r
431                         FeatureFlag = Item.FeatureFlag\r
432                         pb.Sources.append(ModuleSourceFileClass(SourceFile, TagName, ToolCode, ToolChainFamily, FeatureFlag))\r
433 \r
434                 # Protocols\r
435                 for Item in Module.Protocols:\r
436                     if Arch in Item.SupArchList:\r
437                         pb.Protocols.append(Item.CName)\r
438 \r
439                 # Ppis\r
440                 for Item in Module.Ppis:\r
441                     if Arch in Item.SupArchList:\r
442                         pb.Ppis.append(Item.CName)\r
443 \r
444                 # Guids\r
445                 for Item in Module.Guids:\r
446                     if Arch in Item.SupArchList:\r
447                         pb.Ppis.append(Item.CName)\r
448 \r
449                 # Includes\r
450                 for Item in Module.Includes:\r
451                     if Arch in Item.SupArchList:\r
452                         pb.Includes.append(NormPath(Item.FilePath))\r
453 \r
454                 # Packages\r
455                 for Item in Module.PackageDependencies:\r
456                     if Arch in Item.SupArchList:\r
457                         pb.Packages.append(NormPath(Item.FilePath))\r
458 \r
459                 # BuildOptions\r
460                 for Item in Module.BuildOptions:\r
461                     if Arch in Item.SupArchList:\r
462                         pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = Item.Option\r
463                 self.FindBuildOptions(Arch, Inf, pb.BuildOptions)\r
464 \r
465                 # Depex\r
466                 for Item in Module.Depex:\r
467                     if Arch in Item.SupArchList:\r
468                         pb.Depex = pb.Depex + Item.Depex + ' '\r
469                 pb.Depex = pb.Depex.strip()\r
470 \r
471                 # LibraryClasses\r
472                 for Item in Module.LibraryClasses:\r
473                     if Arch in Item.SupArchList:\r
474                         Lib = Item.LibraryClass\r
475                         RecommendedInstance = Item.RecommendedInstance\r
476                         if pb.LibraryClass != []:\r
477                             # For Library\r
478                             for Libs in pb.LibraryClass:\r
479                                 for Type in Libs.SupModList:\r
480                                     Instance = self.FindLibraryClassInstanceOfLibrary(Lib, Arch, Type)\r
481                                     if Instance == None:\r
482                                         Instance = RecommendedInstance\r
483                                     pb.LibraryClasses[(Lib, Type)] = NormPath(Instance)\r
484                         else:\r
485                             # For Module\r
486                             Instance = self.FindLibraryClassInstanceOfModule(Lib, Arch, pb.ModuleType, Inf)\r
487                             if Instance == None:\r
488                                 Instance = RecommendedInstance\r
489                             pb.LibraryClasses[(Lib, pb.ModuleType)] = NormPath(Instance)\r
490 \r
491                 # Pcds\r
492                 for Item in Module.PcdCodes:\r
493                     if Arch in Item.SupArchList:\r
494                         Name = Item.CName\r
495                         Guid = Item.TokenSpaceGuidCName\r
496                         Type = Item.ItemType\r
497                         pb.Pcds[(Name, Guid)] = self.FindPcd(Arch, Inf, Name, Guid, Type, PcdsSet)\r
498 \r
499                 # Add to database\r
500                 self.Build[Arch].ModuleDatabase[Inf] = pb\r
501                 pb = None\r
502 \r
503     #\r
504     # Update Libraries Of Platform Database\r
505     #\r
506     def UpdateLibrariesOfPlatform(self, InfList = []):\r
507         for Arch in self.SupArchList:\r
508             PlatformDatabase = self.Build[Arch].PlatformDatabase\r
509             for Dsc in PlatformDatabase:\r
510                 Platform = PlatformDatabase[Dsc]\r
511                 for Inf in Platform.Modules:\r
512                     if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList):\r
513                         continue\r
514                     Module = self.Build[Arch].ModuleDatabase[NormPath(Inf)]\r
515                     if Module.LibraryClass == None or Module.LibraryClass == []:\r
516                         self.UpdateLibrariesOfModule(Module, Arch)\r
517                         for Key in Module.LibraryClasses:\r
518                             Lib = Module.LibraryClasses[Key]\r
519                             if Lib not in Platform.Libraries:\r
520                                 Platform.Libraries.append(Lib)\r
521 ##                    Stack = [NormPath(str(Module))]\r
522 ##                    Libs = []\r
523 ##                    while len(Stack) > 0:\r
524 ##                        M = self.Build[Arch].ModuleDatabase[Stack.pop()]\r
525 ##                        for Key, Lib in M.LibraryClasses.iteritems():\r
526 ##                            if Module.ModuleType not in Key or Lib == None or Lib == "":\r
527 ##                                continue\r
528 ##                            Lib = NormPath(Lib)\r
529 ##                            if Lib not in Platform.Libraries:\r
530 ##                                Platform.Libraries.append(Lib)\r
531 ##                            if Lib not in Libs:\r
532 ##                                Libs.append(Lib)\r
533 ##                                Stack.append(Lib)\r
534 \r
535     def UpdateLibrariesOfModule(self, Module, Arch):\r
536         ModuleDatabase = self.Build[Arch].ModuleDatabase\r
537 \r
538         ModuleType = Module.ModuleType\r
539         LibraryConsumerList = [Module]\r
540 \r
541         Constructor         = []\r
542         ConsumedByList      = sdict()\r
543         LibraryInstance     = sdict()\r
544 \r
545         EdkLogger.verbose("")\r
546         EdkLogger.verbose("Library instances of module [%s]:" % str(Module))\r
547         while len(LibraryConsumerList) > 0:\r
548             module = LibraryConsumerList.pop()\r
549             for Key, LibraryPath in module.LibraryClasses.iteritems():\r
550                 # The "Key" is in format of (library_class_name, supported_module_type)\r
551                 LibraryClassName = Key[0]\r
552                 if ModuleType != "USER_DEFINED" and ModuleType not in Key:\r
553                     EdkLogger.debug(EdkLogger.DEBUG_3, "%s for module type %s is not supported (%s)" % (Key + (LibraryPath,)))\r
554                     continue\r
555                 if LibraryPath == None or LibraryPath == "":\r
556                     EdkLogger.warn(None, "Library instance for library class %s is not found" % LibraryClassName)\r
557                     continue\r
558 \r
559                 LibraryModule = ModuleDatabase[LibraryPath]\r
560                 if LibraryClassName not in LibraryInstance:\r
561                     LibraryConsumerList.append(LibraryModule)\r
562                     LibraryInstance[LibraryClassName] = LibraryModule\r
563                     EdkLogger.verbose("\t" + LibraryClassName + " : " + str(LibraryModule))\r
564 \r
565                 if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:\r
566                     Constructor.append(LibraryModule)\r
567 \r
568                 if LibraryModule not in ConsumedByList:\r
569                     ConsumedByList[LibraryModule] = []\r
570                 if module != Module:\r
571                     if module in ConsumedByList[LibraryModule]:\r
572                         continue\r
573                     ConsumedByList[LibraryModule].append(module)\r
574         #\r
575         # Initialize the sorted output list to the empty set\r
576         #\r
577         SortedLibraryList = []\r
578         #\r
579         # Q <- Set of all nodes with no incoming edges\r
580         #\r
581         LibraryList = LibraryInstance.values()\r
582         Q = []\r
583         for m in LibraryList:\r
584             #\r
585             # check if there're duplicate library classes\r
586             #\r
587             for Lc in m.LibraryClass:\r
588                 if Lc.LibraryClass in LibraryInstance and str(m) != str(LibraryInstance[Lc.LibraryClass]):\r
589                     EdkLogger.error("AutoGen", AUTOGEN_ERROR,\r
590                                     "More than one library instance found for library class %s in module %s" % (Lc.LibraryClass, Module),\r
591                                     ExtraData="\t%s\n\t%s" % (LibraryInstance[Lc.LibraryClass], str(m))\r
592                                     )\r
593             if ConsumedByList[m] == []:\r
594                 Q.insert(0, m)\r
595         #\r
596         # while Q is not empty do\r
597         #\r
598         while Q != []:\r
599             #\r
600             # remove node n from Q\r
601             #\r
602             n = Q.pop()\r
603             #\r
604             # output n\r
605             #\r
606             SortedLibraryList.append(n)\r
607             #\r
608             # for each node m with an edge e from n to m do\r
609             #\r
610             for m in LibraryList:\r
611                 if n not in ConsumedByList[m]:\r
612                     continue\r
613                 #\r
614                 # remove edge e from the graph\r
615                 #\r
616                 ConsumedByList[m].remove(n)\r
617                 #\r
618                 # If m has no other incoming edges then\r
619                 #\r
620                 if ConsumedByList[m] == []:\r
621                     #\r
622                     # insert m into Q\r
623                     #\r
624                     Q.insert(0,m)\r
625 \r
626             EdgeRemoved = True\r
627             while Q == [] and EdgeRemoved:\r
628                 EdgeRemoved = False\r
629                 #\r
630                 # for each node m with a Constructor\r
631                 #\r
632                 for m in LibraryList:\r
633                     if m in Constructor:\r
634                         #\r
635                         # for each node n without a constructor with an edge e from m to n\r
636                         #\r
637                         for n in ConsumedByList[m]:\r
638                             if n not in Constructor:\r
639                                 #\r
640                                 # remove edge e from the graph\r
641                                 #\r
642                                 ConsumedByList[m].remove(n)\r
643                                 EdgeRemoved = True\r
644                                 if ConsumedByList[m] == []:\r
645                                     #\r
646                                     # insert m into Q\r
647                                     #\r
648                                     Q.insert(0,m)\r
649                                     break\r
650                     if Q != []:\r
651                         break\r
652 \r
653         #\r
654         # if any remaining node m in the graph has a constructor and an incoming edge, then the graph has a cycle\r
655         #\r
656         for m in LibraryList:\r
657             if ConsumedByList[m] != [] and m in Constructor and len(Constructor) > 1:\r
658                 ErrorMessage = 'Library [%s] with constructors has a cycle' % str(m)\r
659                 EdkLogger.error("AutoGen", AUTOGEN_ERROR, ErrorMessage,\r
660                                 "\tconsumed by " + "\n\tconsumed by ".join([str(l) for l in ConsumedByList[m]]))\r
661             if m not in SortedLibraryList:\r
662                 SortedLibraryList.append(m)\r
663 \r
664         #\r
665         # Build the list of constructor and destructir names\r
666         # The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order\r
667         #\r
668         SortedLibraryList.reverse()\r
669         Module.LibraryClasses = sdict()\r
670         for L in SortedLibraryList:\r
671             for Lc in L.LibraryClass:\r
672                 Module.LibraryClasses[Lc.LibraryClass, ModuleType] = str(L)\r
673             #\r
674             # Merge PCDs from library instance\r
675             #\r
676             for Key in L.Pcds:\r
677                 if Key not in Module.Pcds:\r
678                     Module.Pcds[Key] = L.Pcds[Key]\r
679             #\r
680             # Merge GUIDs from library instance\r
681             #\r
682             for CName in L.Guids:\r
683                 if CName not in Module.Guids:\r
684                     Module.Guids.append(CName)\r
685             #\r
686             # Merge Protocols from library instance\r
687             #\r
688             for CName in L.Protocols:\r
689                 if CName not in Module.Protocols:\r
690                     Module.Protocols.append(CName)\r
691             #\r
692             # Merge Ppis from library instance\r
693             #\r
694             for CName in L.Ppis:\r
695                 if CName not in Module.Ppis:\r
696                     Module.Ppis.append(CName)\r
697 \r
698     #\r
699     # Generate build database for all arches\r
700     #\r
701     def GenBuildDatabase(self, PcdsSet = {}, InfList = []):\r
702         for InfFile in InfList:\r
703             self.AddToInfDatabase(InfFile)\r
704         self.GenPlatformDatabase()\r
705         self.GenPackageDatabase()\r
706         self.GenModuleDatabase(PcdsSet, InfList)\r
707         self.UpdateLibrariesOfPlatform(InfList)\r
708 \r
709     #\r
710     # Return a full path with workspace dir\r
711     #\r
712     def WorkspaceFile(self, Filename):\r
713         return WorkspaceFile(self.WorkspaceDir, Filename)\r
714 \r
715     #\r
716     # If a module of a platform has its own override libraryclass but the libraryclass not defined in the module\r
717     # Add this libraryclass to the module\r
718     #\r
719     def UpdateLibraryClassOfModule(self, InfFileName, LibraryClass, Arch, InstanceFilePath):\r
720         #\r
721         # Update the library instance itself to add this libraryclass name\r
722         #\r
723         LibList = self.InfDatabase[NormPath(InstanceFilePath)].Module.Header.LibraryClass\r
724         NotFound = True\r
725         for Lib in LibList:\r
726             #\r
727             # Find this LibraryClass\r
728             #\r
729             if Lib.LibraryClass == LibraryClass:\r
730                 NotFound = False;\r
731                 break;\r
732         if NotFound:\r
733             NewLib = LibraryClassClass()\r
734             NewLib.LibraryClass = LibraryClass\r
735             NewLib.SupModuleList = self.InfDatabase[NormPath(InstanceFilePath)].Module.Header.ModuleType.split()\r
736             self.InfDatabase[NormPath(InstanceFilePath)].Module.Header.LibraryClass.append(NewLib)\r
737 \r
738         #\r
739         # Add it to LibraryClasses Section for the module which is using the library\r
740         #\r
741         LibList = self.InfDatabase[NormPath(InfFileName)].Module.LibraryClasses\r
742         NotFound = True\r
743         for Lib in LibList:\r
744             #\r
745             # Find this LibraryClass\r
746             #\r
747             if Lib.LibraryClass == LibraryClass:\r
748                 if Arch in Lib.SupArchList:\r
749                     return\r
750                 else:\r
751                     Lib.SupArchList.append(Arch)\r
752                     return\r
753         if NotFound:\r
754             Lib = LibraryClassClass()\r
755             Lib.LibraryClass = LibraryClass\r
756             Lib.SupArchList = [Arch]\r
757             self.InfDatabase[NormPath(InfFileName)].Module.LibraryClasses.append(Lib)\r
758 \r
759     #\r
760     # Create a Inf instance for input inf file and add it to InfDatabase\r
761     #\r
762     def AddToInfDatabase(self, InfFileName):\r
763         InfFileName = NormPath(InfFileName)\r
764         File = self.WorkspaceFile(InfFileName)\r
765         if os.path.exists(File) and os.path.isfile(File):\r
766             if InfFileName not in self.InfDatabase:\r
767                 self.InfDatabase[InfFileName] = Inf(File, True, True, self.WorkspaceDir)\r
768         else:\r
769             EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File)\r
770 \r
771     #\r
772     # Create a Dec instance for input dec file and add it to DecDatabase\r
773     #\r
774     def AddToDecDatabase(self, DecFileName):\r
775         DecFileName = NormPath(DecFileName)\r
776         File = self.WorkspaceFile(DecFileName)\r
777         if os.path.exists(File) and os.path.isfile(File):\r
778             if DecFileName not in self.DecDatabase:\r
779                 self.DecDatabase[DecFileName] = Dec(File, True, True, self.WorkspaceDir)\r
780         else:\r
781             EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File)\r
782 \r
783     #\r
784     # Search PlatformBuildDatabase to find LibraryClass Instance for Module\r
785     # Return the instance if found\r
786     #\r
787     def FindLibraryClassInstanceOfModule(self, Lib, Arch, ModuleType, ModuleName):\r
788         #\r
789         # First find if exist in <LibraryClass> of <Components> from dsc file\r
790         #\r
791         for Dsc in self.DscDatabase.keys():\r
792             Platform = self.DscDatabase[Dsc].Platform\r
793             for Module in Platform.Modules.ModuleList:\r
794                 if Arch in Module.SupArchList:\r
795                     if NormPath(Module.FilePath) == ModuleName:\r
796                         for LibraryClass in Module.LibraryClasses.LibraryList:\r
797                             if LibraryClass.Name == Lib:\r
798                                 return NormPath(LibraryClass.FilePath)\r
799         #\r
800         #Second find if exist in <LibraryClass> of <LibraryClasses> from dsc file\r
801         #\r
802         return self.FindLibraryClassInstanceOfLibrary(Lib, Arch, ModuleType)\r
803 \r
804     #\r
805     # Search PlatformBuildDatabase to find LibraryClass Instance for Library\r
806     # Return the instance if found\r
807     #\r
808     def FindLibraryClassInstanceOfLibrary(self, Lib, Arch, Type):\r
809         for Dsc in self.DscDatabase.keys():\r
810             Platform  = self.DscDatabase[Dsc].Platform\r
811             if (Lib, Type) in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses:\r
812                 return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, Type)]\r
813             elif (Lib, '') in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses:\r
814                 return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, '')]\r
815         return None\r
816 \r
817     #\r
818     # Search DscDatabase to find component definition of ModuleName\r
819     # Override BuildOption if it is defined in component\r
820     #\r
821     def FindBuildOptions(self, Arch, ModuleName, BuildOptions):\r
822         for Dsc in self.DscDatabase.keys():\r
823             #\r
824             # First find if exist in <BuildOptions> of <Components> from dsc file\r
825             # if find, use that override the one defined in inf file\r
826             #\r
827             Platform = self.DscDatabase[Dsc].Platform\r
828             for Module in Platform.Modules.ModuleList:\r
829                 if Arch in Module.SupArchList:\r
830                     if NormPath(Module.FilePath) == ModuleName:\r
831                         for BuildOption in Module.ModuleSaBuildOption.BuildOptionList:\r
832                             BuildOptions[(BuildOption.ToolChainFamily, BuildOption.ToolChain)] = BuildOption.Option\r
833 \r
834     #\r
835     # Search platform database, package database, module database and PcdsSet from Fdf\r
836     # Return found Pcd\r
837     #\r
838     def FindPcd(self, Arch, ModuleName, Name, Guid, Type, PcdsSet):\r
839         DatumType = ''\r
840         Value = ''\r
841         Token = ''\r
842         MaxDatumSize = ''\r
843         SkuInfoList = {}\r
844         IsOverrided = False\r
845         IsFoundInDsc = False\r
846         IsFoundInDec = False\r
847         #\r
848         # First get information from platform database\r
849         #\r
850         for Dsc in self.Build[Arch].PlatformDatabase.keys():\r
851             Pcds = self.Build[Arch].PlatformDatabase[Dsc].Pcds\r
852             if (Name, Guid) in Pcds:\r
853                 Type = Pcds[(Name, Guid)].Type\r
854                 DatumType = Pcds[(Name, Guid)].DatumType\r
855                 Value = Pcds[(Name, Guid)].DefaultValue\r
856                 Token = Pcds[(Name, Guid)].TokenValue\r
857                 MaxDatumSize = Pcds[(Name, Guid)].MaxDatumSize\r
858                 SkuInfoList =  Pcds[(Name, Guid)].SkuInfoList\r
859                 IsOverrided = True\r
860                 IsFoundInDsc = True\r
861                 break\r
862 \r
863         #\r
864         # Second get information from package database\r
865         #\r
866         for Dec in self.Build[Arch].PackageDatabase.keys():\r
867             Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds\r
868             if (Name, Guid) in Pcds:\r
869                 DatumType = Pcds[(Name, Guid)].DatumType\r
870                 Token = Pcds[(Name, Guid)].TokenValue\r
871                 IsOverrided = True\r
872                 IsFoundInDec = True\r
873                 break\r
874         if not IsFoundInDec:\r
875             ErrorMsg = "Pcd '%s.%s' defined in module '%s' is not found in any package" % (Guid, Name, ModuleName)\r
876             EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg)\r
877 \r
878         #\r
879         # Third get information from <Pcd> of <Compontents> from module database\r
880         #\r
881         for Dsc in self.DscDatabase.keys():\r
882             for Module in self.DscDatabase[Dsc].Platform.Modules.ModuleList:\r
883                 if Arch in Module.SupArchList:\r
884                     if NormPath(Module.FilePath) == ModuleName:\r
885                         for Pcd in Module.PcdBuildDefinitions:\r
886                             if (Name, Guid) == (Pcd.CName, Pcd.TokenSpaceGuidCName):\r
887                                 if Pcd.DefaultValue != '':\r
888                                     Value = Pcd.DefaultValue\r
889                                 if Pcd.MaxDatumSize != '':\r
890                                     MaxDatumSize = Pcd.MaxDatumSize\r
891                                 IsFoundInDsc = True\r
892                                 IsOverrided = True\r
893                                 break\r
894 \r
895         #\r
896         # Last get information from PcdsSet defined by FDF\r
897         #\r
898         if (Name, Guid) in PcdsSet:\r
899             Value = PcdsSet[(Name, Guid)]\r
900             IsFoundInDsc = True\r
901             IsOverrided = True\r
902 \r
903         #\r
904         # Not found in any platform and fdf\r
905         #\r
906         if not IsFoundInDsc:\r
907             ErrorMsg = "Pcd '%s.%s' defined in module '%s' is not found in any platform" % (Guid, Name, ModuleName)\r
908             EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg)\r
909 \r
910         return PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, IsOverrided)\r
911 \r
912     #\r
913     # Search in InfDatabase, find the supmodulelist of the libraryclass\r
914     #\r
915     def FindSupModuleListOfLibraryClass(self, LibraryClass, OverridedLibraryClassList):\r
916         Name = LibraryClass.Name\r
917         FilePath = NormPath(LibraryClass.FilePath)\r
918         SupModuleList = copy.copy(LibraryClass.SupModuleList)\r
919 \r
920         #\r
921         # If the SupModuleList means all, remove overrided module types of platform\r
922         #\r
923         if SupModuleList == DataType.SUP_MODULE_LIST:\r
924             EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s supports all module types" % Name)\r
925             for Item in OverridedLibraryClassList:\r
926                 #\r
927                 # Find a library class with the same name\r
928                 #\r
929                 if Item.Name == Name:\r
930                     #\r
931                     # Do nothing if it is itself\r
932                     #\r
933                     if Item.SupModuleList == DataType.SUP_MODULE_LIST:\r
934                         continue\r
935                     #\r
936                     # If not itself, check arch first\r
937                     #\r
938                     for Arch in LibraryClass.SupArchList:\r
939                         #\r
940                         # If arch is supportted, remove all related module type\r
941                         #\r
942                         if Arch in Item.SupArchList:\r
943                             for ModuleType in Item.SupModuleList:\r
944                                 EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s has specific defined module types" % Name)\r
945                                 if ModuleType in SupModuleList:\r
946                                     SupModuleList.remove(ModuleType)\r
947 \r
948         return SupModuleList\r
949 \r
950     #\r
951     # Check if the module is defined in <Compentent> of <Platform>\r
952     #\r
953     def IsModuleDefinedInPlatform(self, Inf, Arch, InfList):\r
954 #        for InfFile in InfList:\r
955 #            if Inf == NormPath(InfFile):\r
956 #                return True\r
957         Inf = NormPath(Inf)\r
958         for Dsc in self.DscDatabase.values():\r
959             for LibraryClass in Dsc.Platform.LibraryClasses.LibraryList:\r
960                 if Inf == NormPath(LibraryClass.FilePath) and Arch in LibraryClass.SupArchList:\r
961                     return True\r
962             for Module in Dsc.Platform.Modules.ModuleList:\r
963                 if Inf == NormPath(Module.FilePath) and Arch in Module.SupArchList:\r
964                     return True\r
965                 for Item in Module.LibraryClasses.LibraryList:\r
966                     if Inf == NormPath(Item.FilePath):\r
967                         return True\r
968 \r
969         return False\r
970 \r
971     #\r
972     # Show all content of the workspacebuild\r
973     #\r
974     def ShowWorkspaceBuild(self):\r
975         print ewb.DscDatabase\r
976         print ewb.InfDatabase\r
977         print ewb.DecDatabase\r
978         print 'SupArchList', ewb.SupArchList\r
979         print 'BuildTarget', ewb.BuildTarget\r
980         print 'SkuId', ewb.SkuId\r
981 \r
982         for arch in ewb.SupArchList:\r
983             print arch\r
984             print 'Platform'\r
985             for platform in ewb.Build[arch].PlatformDatabase.keys():\r
986                 p = ewb.Build[arch].PlatformDatabase[platform]\r
987                 print 'DescFilePath = ', p.DescFilePath\r
988                 print 'PlatformName = ', p.PlatformName\r
989                 print 'Guid = ', p.Guid\r
990                 print 'Version = ', p.Version\r
991                 print 'OutputDirectory = ', p.OutputDirectory\r
992                 print 'FlashDefinition = ', p.FlashDefinition\r
993                 print 'SkuIds = ', p.SkuIds\r
994                 print 'Modules = ', p.Modules\r
995                 print 'LibraryClasses = ', p.LibraryClasses\r
996                 print 'Pcds = ', p.Pcds\r
997                 for item in p.Pcds.keys():\r
998                     print p.Pcds[item]\r
999                 print 'BuildOptions = ', p.BuildOptions\r
1000                 print ''\r
1001             # End of Platform\r
1002 \r
1003             print 'package'\r
1004             for package in ewb.Build[arch].PackageDatabase.keys():\r
1005                 p = ewb.Build[arch].PackageDatabase[package]\r
1006                 print 'DescFilePath = ', p.DescFilePath\r
1007                 print 'PackageName = ', p.PackageName\r
1008                 print 'Guid = ', p.Guid\r
1009                 print 'Version = ', p.Version\r
1010                 print 'Protocols = ', p.Protocols\r
1011                 print 'Ppis = ', p.Ppis\r
1012                 print 'Guids = ', p.Guids\r
1013                 print 'Includes = ', p.Includes\r
1014                 print 'LibraryClasses = ', p.LibraryClasses\r
1015                 print 'Pcds = ', p.Pcds\r
1016                 for item in p.Pcds.keys():\r
1017                     print p.Pcds[item]\r
1018                 print ''\r
1019             # End of Package\r
1020 \r
1021             print 'module'\r
1022             for module in ewb.Build[arch].ModuleDatabase.keys():\r
1023                 p = ewb.Build[arch].ModuleDatabase[module]\r
1024                 print 'DescFilePath = ', p.DescFilePath\r
1025                 print 'BaseName = ', p.BaseName\r
1026                 print 'ModuleType = ', p.ModuleType\r
1027                 print 'Guid = ', p.Guid\r
1028                 print 'Version = ', p.Version\r
1029                 print 'CustomMakefile = ', p.CustomMakefile\r
1030                 print 'Specification = ', p.Specification\r
1031                 print 'PcdIsDriver = ', p.PcdIsDriver\r
1032                 for Lib in p.LibraryClass:\r
1033                     print 'LibraryClassDefinition = ', Lib.LibraryClass, 'SupModList = ', Lib.SupModList\r
1034                 print 'ModuleEntryPointList = ', p.ModuleEntryPointList\r
1035                 print 'ModuleUnloadImageList = ', p.ModuleUnloadImageList\r
1036                 print 'ConstructorList = ', p.ConstructorList\r
1037                 print 'DestructorList = ', p.DestructorList\r
1038 \r
1039                 print 'Binaries = '\r
1040                 for item in p.Binaries:\r
1041                     print item.BinaryFile, item.FeatureFlag\r
1042                 print 'Sources = '\r
1043                 for item in p.Sources:\r
1044                     print item.SourceFile\r
1045                 print 'LibraryClasses = ', p.LibraryClasses\r
1046                 print 'Protocols = ', p.Protocols\r
1047                 print 'Ppis = ', p.Ppis\r
1048                 print 'Guids = ', p.Guids\r
1049                 print 'Includes = ', p.Includes\r
1050                 print 'Packages = ', p.Packages\r
1051                 print 'Pcds = ', p.Pcds\r
1052                 for item in p.Pcds.keys():\r
1053                     print p.Pcds[item]\r
1054                 print 'BuildOptions = ', p.BuildOptions\r
1055                 print 'Depex = ', p.Depex\r
1056                 print ''\r
1057             # End of Module\r
1058 \r
1059 #\r
1060 # This acts like the main() function for the script, unless it is 'import'ed into another\r
1061 # script.\r
1062 #\r
1063 if __name__ == '__main__':\r
1064     # Nothing to do here. Could do some unit tests.\r
1065     w = os.getenv('WORKSPACE')\r
1066     ewb = WorkspaceBuild('Nt32Pkg/Nt32Pkg.dsc', w)\r
1067     ewb.GenBuildDatabase({('PcdDevicePathSupportDevicePathFromText, gEfiMdeModulePkgTokenSpaceGuid') : 'KKKKKKKKKKKKKKKKKKKKK'}, ['Test.Inf'])\r
1068     ewb.ShowWorkspaceBuild()\r