Fixed a typo in variable member
[people/mcb30/basetools.git] / Source / Python / AutoGen / AutoGen.py
1 ## @file\r
2 # Generate AutoGen.h, AutoGen.c and *.depex files\r
3 #\r
4 # Copyright (c) 2007, Intel Corporation\r
5 # All rights reserved. This program and the accompanying materials\r
6 # are licensed and made available under the terms and conditions of the BSD License\r
7 # which accompanies this distribution.  The full text of the license may be found at\r
8 # http://opensource.org/licenses/bsd-license.php\r
9 #\r
10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
12 #\r
13 \r
14 ## Import Modules\r
15 #\r
16 import sys\r
17 import os\r
18 import re\r
19 import os.path as path\r
20 import imp\r
21 from optparse import OptionParser\r
22 from optparse import make_option\r
23 \r
24 import Common.EdkLogger\r
25 import GenC\r
26 import GenMake\r
27 import GenDepex\r
28 \r
29 from StrGather import *\r
30 from BuildEngine import *\r
31 \r
32 from Common.BuildToolError import *\r
33 from Common.EdkIIWorkspaceBuild import *\r
34 from Common.EdkIIWorkspace import *\r
35 from Common.DataType import *\r
36 from Common.Misc import *\r
37 from Common.String import *\r
38 from GenFds.FdfParser import *\r
39 \r
40 ## Regular expression for splitting Dependency Expression stirng into tokens\r
41 gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)")\r
42 \r
43 ## Mapping Makefile type\r
44 gMakeTypeMap = {"MSFT":"nmake", "GCC":"gmake"}\r
45 \r
46 ## Default output flag for all tools\r
47 gDefaultOutputFlag = "-o "\r
48 \r
49 ## Output flags for specific tools\r
50 gOutputFlag = {\r
51     ("MSFT", "CC", "OUTPUT")      :   "/Fo",\r
52     ("MSFT", "SLINK", "OUTPUT")   :   "/OUT:",\r
53     ("MSFT", "DLINK", "OUTPUT")   :   "/OUT:",\r
54     ("MSFT", "ASMLINK", "OUTPUT") :   "/OUT:",\r
55     ("MSFT", "PCH", "OUTPUT")     :   "/Fp",\r
56     ("MSFT", "ASM", "OUTPUT")     :   "/Fo",\r
57 \r
58     ("INTEL", "CC", "OUTPUT")          :   "/Fo",\r
59     ("INTEL", "SLINK", "OUTPUT")       :   "/OUT:",\r
60     ("INTEL", "DLINK", "OUTPUT")       :   "/OUT:",\r
61     ("INTEL", "ASMLINK", "OUTPUT")     :   "/OUT:",\r
62     ("INTEL", "PCH", "OUTPUT")         :   "/Fp",\r
63     ("INTEL", "ASM", "OUTPUT")         :   "/Fo",\r
64 \r
65     ("GCC", "CC", "OUTPUT")        :   "-o ",\r
66     ("GCC", "SLINK", "OUTPUT")     :   "-cr ",\r
67     ("GCC", "DLINK", "OUTPUT")     :   "-o ",\r
68     ("GCC", "ASMLINK", "OUTPUT")   :   "-o ",\r
69     ("GCC", "PCH", "OUTPUT")       :   "-o ",\r
70     ("GCC", "ASM", "OUTPUT")       :   "-o ",\r
71 }\r
72 \r
73 ## Flag for include file search path\r
74 gIncludeFlag = {"MSFT" : "/I", "GCC" : "-I", "INTEL" : "-I"}\r
75 \r
76 ## Build rule configuration file\r
77 gBuildRuleFile = 'Conf/build_rule.txt'\r
78 \r
79 ## default file name for AutoGen\r
80 gAutoGenCodeFileName = "AutoGen.c"\r
81 gAutoGenHeaderFileName = "AutoGen.h"\r
82 gAutoGenDepexFileName = "%(module_name)s.depex"\r
83 \r
84 class AutoGen(object):\r
85     # database to maintain the objects of PlatformAutoGen\r
86     _CACHE_ = {}    # (platform file, BuildTarget, ToolChain) : {ARCH : AutoGen object}\r
87 \r
88     def __new__(Class, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
89         # check if the object has been created\r
90         Key = (Target, Toolchain)\r
91         if Key not in Class._CACHE_ or Arch not in Class._CACHE_[Key] \\r
92            or MetaFile not in Class._CACHE_[Key][Arch]:\r
93             AutoGenObject = super(AutoGen, Class).__new__(Class)\r
94             if not AutoGenObject._Init(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
95                 return None\r
96             if Key not in Class._CACHE_:\r
97                 Class._CACHE_[Key] = {}\r
98             if Arch not in Class._CACHE_[Key]:\r
99                 Class._CACHE_[Key][Arch] = {}\r
100             Class._CACHE_[Key][Arch][MetaFile] = AutoGenObject\r
101         else:\r
102             AutoGenObject = Class._CACHE_[Key][Arch][MetaFile]\r
103 \r
104         return AutoGenObject\r
105 \r
106     ## hash() operator\r
107     #\r
108     #  The file path of platform file will be used to represent hash value of this object\r
109     #\r
110     #   @retval int     Hash value of the file path of platform file\r
111     #\r
112     def __hash__(self):\r
113         return hash(self._MetaFile)\r
114 \r
115     ## str() operator\r
116     #\r
117     #  The file path of platform file will be used to represent this object\r
118     #\r
119     #   @retval string  String of platform file path\r
120     #\r
121     def __str__(self):\r
122         return self._MetaFile\r
123 \r
124     ## "==" operator\r
125     def __eq__(self, Other):\r
126         return Other != None and self._MetaFile == str(Other)\r
127 \r
128 class WorkspaceAutoGen(AutoGen):\r
129     def _Init(self, WorkspaceDir, ActivePlatform, Target, Toolchain, ArchList, MetaFileDb,\r
130               BuildConfig, ToolDefinition, FlashDefinitionFile='', Fds=[], Fvs=[], SkuId=''):\r
131         self._MetaFile      = str(ActivePlatform)\r
132         self.WorkspaceDir   = WorkspaceDir\r
133         self.Platform       = ActivePlatform\r
134         self.BuildTarget    = Target\r
135         self.ToolChain      = Toolchain\r
136         self.ArchList       = ArchList\r
137         self.SkuId          = SkuId\r
138 \r
139         self.BuildDatabase  = MetaFileDb\r
140         self.TargetTxt      = BuildConfig\r
141         self.ToolDef        = ToolDefinition\r
142         self.FdfFile        = FlashDefinitionFile\r
143         self.FdTargetList   = Fds\r
144         self.FvTargetList   = Fvs\r
145         self.AutoGenObjectList = []\r
146 \r
147         # there's many relative directory operation, so ...\r
148         os.chdir(self.WorkspaceDir)\r
149 \r
150         # parse FDF file to get PCDs in it, if any\r
151         if self.FdfFile != None and self.FdfFile != '':\r
152             Fdf = FdfParser(os.path.join(self.WorkspaceDir, self.FdfFile))\r
153             Fdf.ParseFile()\r
154             PcdSet = Fdf.Profile.PcdDict\r
155             ModuleList = Fdf.Profile.InfList\r
156         else:\r
157             PcdSet = {}\r
158             ModuleList = []\r
159 \r
160         # apply SKU and inject PCDs from Flash Definition file\r
161         for Arch in self.ArchList:\r
162             Platform = self.BuildDatabase[self._MetaFile, Arch]\r
163             Platform.SkuName = self.SkuId\r
164             for Name, Guid in PcdSet:\r
165                 Platform.AddPcd(Name, Guid, PcdSet[Name, Guid])\r
166 \r
167             Pa = PlatformAutoGen(self, self._MetaFile, Target, Toolchain, Arch)\r
168             self.AutoGenObjectList.append(Pa)\r
169             #for M in ModuleList:\r
170             #    Platform.AddModule(M)\r
171 \r
172         self._BuildDir = None\r
173         self._FvDir = None\r
174         self._MakeFileDir = None\r
175         self._BuildCommand = None\r
176 \r
177         return True\r
178 \r
179     def _GetFvDir(self):\r
180         if self._FvDir == None:\r
181             self._FvDir = path.join(self.BuildDir, 'FV')\r
182         return self._FvDir\r
183             \r
184     def _GetBuildDir(self):\r
185         return self.AutoGenObjectList[0].BuildDir\r
186 \r
187     def _GetOutputDir(self):\r
188         return self.Platform.OutputDirectory\r
189 \r
190     def _GetName(self):\r
191         return self.Platform.PlatformName\r
192 \r
193     def _GetGuid(self):\r
194         return self.Platform.Guid\r
195 \r
196     def _GetVersion(self):\r
197         return self.Platform.Version\r
198 \r
199     def _GetToolPaths(self):\r
200         return self.AutoGenObjectList[0].ToolPath\r
201 \r
202     def _GetToolOptions(self):\r
203         return self.AutoGenObjectList[0].ToolOption\r
204 \r
205     ## Return directory of platform makefile\r
206     #\r
207     #   @retval     string  Makefile directory\r
208     #\r
209     def _GetMakeFileDir(self):\r
210         if self._MakeFileDir == None:\r
211             self._MakeFileDir = self.BuildDir\r
212         return self._MakeFileDir\r
213 \r
214     ## Return build command string\r
215     #\r
216     #   @retval     string  Build command string\r
217     #\r
218     def _GetBuildCommand(self):\r
219         if self._BuildCommand == None:\r
220             # BuildCommand should be all the same. So just get one from platform AutoGen\r
221             self._BuildCommand = self.AutoGenObjectList[0].BuildCommand\r
222         return self._BuildCommand\r
223 \r
224     ## Create makefile for the platform and mdoules in it\r
225     #\r
226     #   @param      CreateLibraryCodeFile   Flag indicating if the makefile for\r
227     #                                       modules will be created as well\r
228     #\r
229     def CreateMakeFile(self, CreateDepsMakeFile=False):\r
230         # create makefile for platform\r
231         Makefile = GenMake.TopLevelMakefile(self)\r
232         if Makefile.Generate():\r
233             EdkLogger.verbose("Generated makefile for platform [%s] %s\n" %\r
234                            (self._MetaFile, self.ArchList))\r
235         else:\r
236             EdkLogger.verbose("Skipped the generation of makefile for platform [%s] %s\n" %\r
237                            (self._MetaFile, self.ArchList))\r
238 \r
239         if CreateDepsMakeFile:\r
240             for Pa in self.AutoGenObjectList:\r
241                 Pa.CreateMakeFile(CreateDepsMakeFile)\r
242 \r
243     ## Create autogen code for platform and modules\r
244     #\r
245     #  Since there's no autogen code for platform, this method will do nothing\r
246     #  if CreateModuleCodeFile is set to False.\r
247     #\r
248     #   @param      CreateModuleCodeFile    Flag indicating if creating module's\r
249     #                                       autogen code file or not\r
250     #\r
251     def CreateCodeFile(self, CreateDepsCodeFile=False):\r
252         if not CreateDepsCodeFile:\r
253             return\r
254         for Pa in self.AutoGenObjectList:\r
255             Pa.CreateCodeFile(CreateDepsCodeFile)\r
256 \r
257     Name                = property(_GetName)\r
258     Guid                = property(_GetGuid)\r
259     Version             = property(_GetVersion)                       \r
260     OutputDir           = property(_GetOutputDir)\r
261 \r
262     ToolPath            = property(_GetToolPaths)    # toolcode : tool path\r
263     ToolOption          = property(_GetToolOptions)    # toolcode : tool option string\r
264 \r
265     BuildDir            = property(_GetBuildDir)\r
266     FvDir               = property(_GetFvDir)\r
267     MakeFileDir         = property(_GetMakeFileDir)\r
268     BuildCommand        = property(_GetBuildCommand)\r
269 \r
270 ## AutoGen class for platform\r
271 #\r
272 #  PlatformAutoGen class will re-organize the original information in platform\r
273 #  file in order to generate makefile for platform.\r
274 #\r
275 class PlatformAutoGen(AutoGen):\r
276     ## The real constructor of PlatformAutoGen\r
277     #\r
278     #  This method is not supposed to be called by users of PlatformAutoGen. It's\r
279     #  only used by factory method New() to do real initialization work for an\r
280     #  object of PlatformAutoGen\r
281     #\r
282     #   @param      Workspace       EdkIIWorkspaceBuild object\r
283     #   @param      PlatformFile    Platform file (DSC file)\r
284     #   @param      Target          Build target (DEBUG, RELEASE)\r
285     #   @param      Toolchain       Name of tool chain\r
286     #   @param      ArchList        List of arch the platform supports\r
287     #\r
288     def _Init(self, Workspace, PlatformFile, Target, Toolchain, Arch):\r
289         EdkLogger.verbose("\nAutoGen platform [%s] [%s]" % (PlatformFile, Arch))\r
290 \r
291         self._MetaFile = str(PlatformFile)\r
292         self.Workspace = Workspace\r
293         self.WorkspaceDir = Workspace.WorkspaceDir\r
294         self.ToolChain = Toolchain\r
295         self.BuildTarget = Target\r
296         self.Arch = Arch\r
297         self.SourceDir = path.dirname(PlatformFile)\r
298         self.FdTargetList = self.Workspace.FdTargetList\r
299         self.FvTargetList = self.Workspace.FvTargetList\r
300 \r
301         # flag indicating if the makefile/C-code file has been created or not\r
302         self.IsMakeFileCreated  = False\r
303         self.IsCodeFileCreated  = False\r
304 \r
305         self._Platform   = None\r
306         self._Name       = None\r
307         self._Guid       = None\r
308         self._Version    = None\r
309 \r
310         self._BuildRule = None\r
311         self._SourceDir = None\r
312         self._BuildDir = None\r
313         self._OutputDir = None\r
314         self._FvDir = None\r
315         self._MakeFileDir = None\r
316         self._FdfFile = None\r
317 \r
318         self._PcdTokenNumber = None    # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
319         self._DynamicPcdList = None    # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
320         self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
321 \r
322         self._ToolPath = None          # toolcode : tool path\r
323         self._ToolDllPath = None       # toolcode : lib path\r
324         self._ToolStaticLib = None     # toolcode : lib path\r
325         self._ToolChainFamily = None   # toolcode : tool chain family\r
326         self._BuildOption = None       # toolcode : option\r
327         self._OutputFlag = None        # toolcode : output flag\r
328         self._IncludeFlag = None       # toolcode : include flag\r
329         self._ToolOption = None        # toolcode : tool option string\r
330         self._PackageList = None\r
331         self._ModuleAutoGenList  = None\r
332         self._LibraryAutoGenList = None\r
333         self._BuildCommand = None\r
334 \r
335         # get the original module/package/platform objects\r
336         self.BuildDatabase = Workspace.BuildDatabase\r
337         return True\r
338 \r
339     ## Create autogen code for platform and modules\r
340     #\r
341     #  Since there's no autogen code for platform, this method will do nothing\r
342     #  if CreateModuleCodeFile is set to False.\r
343     #\r
344     #   @param      CreateModuleCodeFile    Flag indicating if creating module's\r
345     #                                       autogen code file or not\r
346     #\r
347     def CreateCodeFile(self, CreateModuleCodeFile=False):\r
348         # only module has code to be greated, so do nothing if CreateModuleCodeFile is False\r
349         if self.IsCodeFileCreated or not CreateModuleCodeFile:\r
350             return\r
351 \r
352         for Ma in self.ModuleAutoGenList:\r
353             Ma.CreateCodeFile(True)\r
354 \r
355         # don't do this twice\r
356         self.IsCodeFileCreated = True\r
357 \r
358     ## Create makefile for the platform and mdoules in it\r
359     #\r
360     #   @param      CreateLibraryCodeFile   Flag indicating if the makefile for\r
361     #                                       modules will be created as well\r
362     #\r
363     def CreateMakeFile(self, CreateModuleMakeFile=False):\r
364         if CreateModuleMakeFile:\r
365             for ModuleFile in self.Platform.Modules:\r
366                 Ma = ModuleAutoGen(self.Workspace, ModuleFile, \r
367                                               self.BuildTarget, self.ToolChain,\r
368                                               self.Arch, self._MetaFile)\r
369                 Ma.CreateMakeFile(True)\r
370 \r
371         # no need to create makefile for the platform more than once\r
372         if self.IsMakeFileCreated:\r
373             return\r
374 \r
375         # create makefile for platform\r
376         Makefile = GenMake.PlatformMakefile(self)\r
377         if Makefile.Generate():\r
378             EdkLogger.verbose("Generated makefile for platform [%s] [%s]\n" %\r
379                            (self._MetaFile, self.Arch))\r
380         else:\r
381             EdkLogger.verbose("Skipped the generation of makefile for platform [%s] [%s]\n" %\r
382                            (self._MetaFile, self.Arch))\r
383         self.IsMakeFileCreated = True\r
384 \r
385     def _GetPlatform(self):\r
386         if self._Platform == None:\r
387             self._Platform = self.BuildDatabase[self._MetaFile, self.Arch]\r
388         return self._Platform\r
389 \r
390     def _GetName(self):\r
391         return self.Platform.PlatformName\r
392 \r
393     def _GetGuid(self):\r
394         return self.Platform.Guid\r
395 \r
396     def _GetVersion(self):\r
397         return self.Platform.Version\r
398 \r
399     def _GetFdfFile(self):\r
400         if self._FdfFile == None:\r
401             if self.Workspace.FdfFile != "":\r
402                 self._FdfFile= path.join(self.WorkspaceDir, self.Workspace.FdfFile)\r
403             else:\r
404                 self._FdfFile = ''\r
405         return self._FdfFile\r
406 \r
407     def _GetDebugDir(self):\r
408         return ''\r
409 \r
410     def _GetOutputDir(self):\r
411         return self.Platform.OutputDirectory\r
412 \r
413     def _GetBuildDir(self):\r
414         if self._BuildDir == None:\r
415             if os.path.isabs(self.OutputDir):\r
416                 self._BuildDir = path.join(\r
417                                             path.abspath(self.OutputDir), \r
418                                             self.BuildTarget + "_" + self.ToolChain,\r
419                                             )\r
420             else:\r
421                 self._BuildDir = path.join(\r
422                                             self.WorkspaceDir,\r
423                                             self.OutputDir,\r
424                                             self.BuildTarget + "_" + self.ToolChain,\r
425                                             )\r
426         return self._BuildDir\r
427 \r
428     ## Return directory of platform makefile\r
429     #\r
430     #   @retval     string  Makefile directory\r
431     #\r
432     def _GetMakeFileDir(self):\r
433         if self._MakeFileDir == None:\r
434             self._MakeFileDir = path.join(self.BuildDir, self.Arch)\r
435         return self._MakeFileDir\r
436 \r
437     ## Return build command string\r
438     #\r
439     #   @retval     string  Build command string\r
440     #\r
441     def _GetBuildCommand(self):\r
442         if self._BuildCommand == None:\r
443             self._BuildCommand = tuple()\r
444             if "MAKE" in self.ToolPath:\r
445                 self._BuildCommand += (self.ToolPath["MAKE"],)\r
446                 if "MAKE" in self.ToolOption:\r
447                     NewOption = self.ToolOption["MAKE"].strip()\r
448                     if NewOption != '':\r
449                       self._BuildCommand += (NewOption,)\r
450         return self._BuildCommand\r
451 \r
452     ## Get tool chain definition\r
453     #\r
454     #  Get each tool defition for given tool chain from tools_def.txt and platform\r
455     #\r
456     #   @param      Info    PlatformBuildInfo object to store the definition\r
457     #\r
458     def _GetToolDefinition(self):\r
459         ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDictionary\r
460         ToolCodeList = self.Workspace.ToolDef.ToolsDefTxtDatabase["COMMAND_TYPE"]\r
461         self._ToolPath = {}\r
462         self._ToolDllPath = {}\r
463         self._ToolChainFamily = {}\r
464         self._ToolOption = {}\r
465         self._OutputFlag = {}\r
466         self._IncludeFlag = {}\r
467         for Tool in ToolCodeList:\r
468             KeyBaseString = "%s_%s_%s_%s" % (self.BuildTarget, self.ToolChain, self.Arch, Tool)\r
469 \r
470             Key = "%s_PATH" % KeyBaseString\r
471             if Key not in ToolDefinition:\r
472                 continue\r
473             Path = ToolDefinition[Key]\r
474 \r
475             Key = "%s_FAMILY" % KeyBaseString\r
476             if Key in ToolDefinition:\r
477                 Family = ToolDefinition[Key]\r
478             else:\r
479                 Family = ""\r
480 \r
481             Key = "%s_FLAGS" % KeyBaseString\r
482             if Key in ToolDefinition:\r
483                 Option = ToolDefinition[Key]\r
484             else:\r
485                 Option = ""\r
486 \r
487             Key = "%s_DLL" % KeyBaseString\r
488             if Key in ToolDefinition:\r
489                 Dll = ToolDefinition[Key]\r
490                 # set the DLL path in system's PATH environment\r
491                 os.environ["PATH"] = Dll + os.pathsep + os.environ["PATH"]\r
492             else:\r
493                 Dll = ""\r
494 \r
495             Key = KeyBaseString + "_OUTPUT"\r
496             if Key in ToolDefinition:\r
497                 OutputFlag = ToolDefinition[Key]\r
498             elif (Family, Tool, "OUTPUT") in gOutputFlag:\r
499                 OutputFlag = gOutputFlag[Family, Tool, "OUTPUT"]\r
500                 if OutputFlag[0] == '"' and OutputFlag[-1] == '"':\r
501                     OutputFlag = OutputFlag[1:-1]\r
502             else:\r
503                 OutputFlag = gDefaultOutputFlag\r
504 \r
505             InputFlag = gIncludeFlag[Family]\r
506 \r
507             self._ToolPath[Tool] = Path\r
508             self._ToolDllPath[Tool] = Dll\r
509             self._ToolChainFamily[Tool] = Family\r
510             self._ToolOption[Tool] = Option\r
511             self._OutputFlag[Tool] = OutputFlag\r
512             self._IncludeFlag[Tool] = InputFlag\r
513 \r
514     def _GetToolPaths(self):\r
515         if self._ToolPath == None:\r
516             self._GetToolDefinition()\r
517         return self._ToolPath\r
518 \r
519     def _GetToolDllPaths(self):\r
520         if self._ToolDllPath == None:\r
521             self._GetToolDefinition()\r
522         return self._ToolDllPath\r
523 \r
524     def _GetToolStaticLibs(self):\r
525         if self._ToolStaticLib == None:\r
526             self._GetToolDefinition()\r
527         return self._ToolStaticLib\r
528 \r
529     def _GetToolChainFamilies(self):\r
530         if self._ToolChainFamily == None:\r
531             self._GetToolDefinition()\r
532         return self._ToolChainFamily\r
533 \r
534     def _GetBuildOptions(self):\r
535         if self._BuildOption == None:\r
536             self._BuildOption = self._ExpandBuildOption(self.Platform.BuildOptions)\r
537         return self._BuildOption\r
538 \r
539     def _GetOuputFlags(self):\r
540         if self._OutputFlag == None:\r
541             self._GetToolDefinition()\r
542         return self._OutputFlag\r
543 \r
544     def _GetIncludeFlags(self):\r
545         if self._IncludeFlag == None:\r
546             self._GetToolDefinition()\r
547         return self._IncludeFlag\r
548 \r
549     def _GetToolOptions(self):\r
550         if self._ToolOption == None:\r
551             self._GetToolDefinition()\r
552         return self._ToolOption\r
553 \r
554     ## Parse build_rule.txt in $(WORKSPACE)/Conf/build_rule.txt\r
555     #\r
556     #   @retval     BuildRule object\r
557     #\r
558     def _GetBuildRule(self):\r
559         if self._BuildRule == None:\r
560             BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF]\r
561             if BuildRuleFile in [None, '']:\r
562                 BuildRuleFile = gBuildRuleFile\r
563             self._BuildRule = BuildRule(BuildRuleFile)\r
564         return self._BuildRule\r
565 \r
566     def _GetPackageList(self):\r
567         if self._PackageList == None:\r
568             self._PackageList = set()\r
569             for La in self.LibraryAutoGenList:\r
570                 self._PackageList.update(La.DependentPackageList)\r
571             for Ma in self.ModuleAutoGenList:\r
572                 self._PackageList.update(Ma.DependentPackageList)\r
573         return self._PackageList\r
574 \r
575     ## Collect dynamic PCDs\r
576     #\r
577     #  Gather dynamic PCDs list from each module and their settings from platform\r
578     #\r
579     #   @param      Platform    The object of the platform\r
580     #   @param      Arch        One of the arch the platform supports\r
581     #\r
582     #   @retval     lsit        The list of dynamic PCD\r
583     #\r
584     def _GetPcdList(self):\r
585         self._NonDynamicPcdList = []\r
586         self._DynamicPcdList = []\r
587 \r
588         # for gathering error information\r
589         NotFoundPcdList = set()\r
590         NoDatumTypePcdList = set()\r
591 \r
592         self._GuidValue = {}\r
593         for F in self.Platform.Modules:\r
594             M = ModuleAutoGen(self.Workspace, F, self.BuildTarget, self.ToolChain, self.Arch, self._MetaFile)\r
595             #GuidValue.update(M.Guids)\r
596             for PcdFromModule in M.PcdList:\r
597                 # check if the setting of the PCD is found in platform\r
598                 #if not PcdFromModule.IsOverrided:\r
599                 #    NotFoundPcdList.add("%s [%s]" % (" | ".join(Key), F))\r
600                 #    continue\r
601 \r
602                 # make sure that the "VOID*" kind of datum has MaxDatumSize set\r
603                 if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize == None:\r
604                     NoDatumTypePcdList.add("%s [%s]" % (" | ".join(Key), F))\r
605 \r
606                 if PcdFromModule.Type in GenC.gDynamicPcd or PcdFromModule.Type in GenC.gDynamicExPcd:\r
607                     # for autogen code purpose\r
608                     if M.ModuleType in ["PEIM", "PEI_CORE"]:\r
609                         PcdFromModule.Phase = "PEI"\r
610                     if PcdFromModule not in self._DynamicPcdList:\r
611                         self._DynamicPcdList.append(PcdFromModule)\r
612                 elif PcdFromModule not in self._NonDynamicPcdList:\r
613                     self._NonDynamicPcdList.append(PcdFromModule)\r
614 \r
615         # print out error information and break the build, if error found\r
616         if len(NoDatumTypePcdList) > 0:\r
617             NoDatumTypePcdListString = "\n\t\t".join(NoDatumTypePcdList)\r
618             EdkLogger.error("AutoGen", AUTOGEN_ERROR, "PCD setting error",\r
619                             ExtraData="\n\tPCD(s) without MaxDatumSize:\n\t\t%s\n"\r
620                                       % NoDatumTypePcdListString)\r
621 \r
622     def _GetNonDynamicPcdList(self):\r
623         if self._NonDynamicPcdList == None:\r
624             self._GetPcdList()\r
625         return self._NonDynamicPcdList\r
626 \r
627     def _GetDynamicPcdList(self):\r
628         if self._DynamicPcdList == None:\r
629             self._GetPcdList()\r
630         return self._DynamicPcdList\r
631 \r
632     ## Generate Token Number for all PCD\r
633     #\r
634     #   @param      Platform        The object of the platform\r
635     #   @param      DynamicPcdList  The list of all dynamic PCDs\r
636     #\r
637     #   @retval     dict            A dict object containing the PCD and its token number\r
638     #\r
639     def _GetPcdTokenNumbers(self):\r
640         if self._PcdTokenNumber == None:\r
641             self._PcdTokenNumber = sdict()\r
642             TokenNumber = 1\r
643             for Pcd in self.DynamicPcdList:\r
644                 if Pcd.Phase == "PEI":\r
645                     EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
646                     self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
647                     TokenNumber += 1\r
648         \r
649             for Pcd in self.DynamicPcdList:\r
650                 if Pcd.Phase == "DXE":\r
651                     EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
652                     self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
653                     TokenNumber += 1\r
654         \r
655             for Pcd in self.NonDynamicPcdList:\r
656                 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
657                 TokenNumber += 1\r
658         return self._PcdTokenNumber\r
659 \r
660     def _GetAutoGenObjectList(self):\r
661         self._ModuleAutoGenList = []\r
662         self._LibraryAutoGenList = []\r
663         for ModuleFile in self.Platform.Modules:\r
664             Ma = ModuleAutoGen(\r
665                     self.Workspace,\r
666                     ModuleFile,\r
667                     self.BuildTarget,\r
668                     self.ToolChain, \r
669                     self.Arch, \r
670                     self._MetaFile\r
671                     )\r
672             if Ma not in self._ModuleAutoGenList:\r
673                 self._ModuleAutoGenList.append(Ma)\r
674             for La in Ma.LibraryAutoGenList:\r
675                 if La not in self._LibraryAutoGenList:\r
676                     self._LibraryAutoGenList.append(La)\r
677 \r
678     def _GetModuleAutoGenList(self):\r
679         if self._ModuleAutoGenList == None:\r
680             self._GetAutoGenObjectList()\r
681         return self._ModuleAutoGenList\r
682 \r
683     def _GetLibraryAutoGenList(self):\r
684         if self._LibraryAutoGenList == None:\r
685             self._GetAutoGenObjectList()\r
686         return self._LibraryAutoGenList\r
687 \r
688     ## Test if a module is supported by the platform\r
689     #\r
690     #  An error will be raised directly if the module or its arch is not supported\r
691     #  by the platform or current configuration\r
692     #\r
693     #   @param      Module  The module file\r
694     #   @param      Arch    The arch the module will be built for\r
695     #\r
696     def ValidModule(self, Module):\r
697         #if Arch not in self.Workspace.SupArchList:\r
698         #    return False\r
699         #    #EdkLogger.error("AutoGen", AUTOGEN_ERROR, "[%s] is not supported by active platform [%s] [%s]!"\r
700         #    #                                          % (Arch, self._MetaFile, self.Workspace.SupArchList))\r
701         #if Arch not in self.ArchList:\r
702         #    return False\r
703         #    #EdkLogger.error("AutoGen", AUTOGEN_ERROR, "[%s] is not supported by current build configuration!" % Arch)\r
704         return Module in self.Platform.Modules or Module in self.Platform.LibraryInstances\r
705 \r
706     def ApplyLibraryInstance(self, Module):\r
707         ModuleType = Module.ModuleType\r
708         # apply library instances from platform\r
709         for LibraryClass in Module.LibraryClasses:\r
710             LibraryInstance = self.Platform.LibraryClasses[LibraryClass, ModuleType]\r
711             if LibraryInstance == None:\r
712                 continue\r
713             Module.LibraryClasses[LibraryClass] = LibraryInstance\r
714 \r
715         # override library instances with module specific setting\r
716         PlatformModule = self.Platform.Modules[str(Module)]\r
717         for LibraryClass in PlatformModule.LibraryClasses:\r
718             Module.LibraryClasses[LibraryClass] = PlatformModule.LibraryClasses[LibraryClass]\r
719 \r
720         # R9 module\r
721         LibraryConsumerList = [Module]\r
722         Constructor         = []\r
723         ConsumedByList      = sdict()\r
724         LibraryInstance     = sdict()\r
725 \r
726         EdkLogger.verbose("")\r
727         EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))\r
728         while len(LibraryConsumerList) > 0:\r
729             M = LibraryConsumerList.pop()\r
730             for LibraryClassName in M.LibraryClasses:\r
731                 LibraryPath = M.LibraryClasses[LibraryClassName]\r
732                 if LibraryPath == None or LibraryPath == "":\r
733                     LibraryPath = self.Platform.LibraryClasses[LibraryClassName, ModuleType]\r
734                     if LibraryPath == None and LibraryClassName not in LibraryInstance:\r
735                         LibraryInstance[LibraryClassName] = None\r
736                         continue\r
737                 if LibraryClassName not in LibraryInstance:\r
738                     LibraryModule = self.BuildDatabase[LibraryPath, self.Arch]\r
739                     # for those forced library instance (NULL library), add a fake library class\r
740                     if LibraryClassName.startswith("NULL"):\r
741                         LibraryModule.LibraryClass.append(LibraryClassObject(LibraryClassName, [ModuleType]))\r
742                     elif ModuleType not in LibraryModule.LibraryClass[0].SupModList:\r
743                         EdkLogger.error("build", OPTION_MISSING,\r
744                                         "Module type [%s] is not supported by library instance [%s]" \\r
745                                         % (ModuleType, LibraryPath), File=self._MetaFile, \r
746                                         ExtraData="\tconsumed by [%s]" % str(Module))\r
747 \r
748                     LibraryInstance[LibraryClassName] = LibraryModule\r
749                     LibraryConsumerList.append(LibraryModule)\r
750                     EdkLogger.verbose("\t" + str(LibraryClassName) + " : " + str(LibraryModule))\r
751                 else:\r
752                     LibraryModule = LibraryInstance[LibraryClassName]\r
753 \r
754                 if LibraryModule == None:\r
755                     continue\r
756 \r
757                 if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:\r
758                     Constructor.append(LibraryModule)\r
759 \r
760                 if LibraryModule not in ConsumedByList:\r
761                     ConsumedByList[LibraryModule] = []\r
762                 # don't add current module itself to consumer list\r
763                 if M != Module:\r
764                     if M in ConsumedByList[LibraryModule]:\r
765                         continue\r
766                     ConsumedByList[LibraryModule].append(M)\r
767         #\r
768         # Initialize the sorted output list to the empty set\r
769         #\r
770         SortedLibraryList = []\r
771         #\r
772         # Q <- Set of all nodes with no incoming edges\r
773         #\r
774         LibraryList = [] #LibraryInstance.values()\r
775         Q = []\r
776         for LibraryClassName in LibraryInstance:\r
777             M = LibraryInstance[LibraryClassName]\r
778             if M == None:\r
779                 EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,\r
780                                 "Library instance of library class [%s] is not found" % LibraryClassName,\r
781                                 File=self._MetaFile, ExtraData="consumed by [%s] [%s]" % (str(Module), self.Arch))\r
782             LibraryList.append(M)\r
783             #\r
784             # check if there're library classes\r
785             #\r
786             #for Lc in M.LibraryClass:\r
787             #    if Lc.SupModList != None and ModuleType not in Lc.SupModList:\r
788             #        EdkLogger.error("build", OPTION_MISSING,\r
789             #                        "Module type [%s] is not supported by library instance [%s]" % (ModuleType, str(M)),\r
790             #                        File=self._MetaFile, ExtraData="\tconsumed by [%s]" % str(Module))\r
791 \r
792                 #if Lc.LibraryClass in LibraryInstance and str(M) != str(LibraryInstance[Lc.LibraryClass]):\r
793                 #    EdkLogger.error("build", OPTION_CONFLICT,\r
794                 #                    "More than one library instance found for library class [%s] in module [%s]" % (Lc.LibraryClass, str(Module)),\r
795                 #                    ExtraData="\t%s\n\t%s" % (LibraryInstance[Lc.LibraryClass], str(M))\r
796                 #                    )\r
797             if ConsumedByList[M] == []:\r
798                 Q.insert(0, M)\r
799 \r
800         #\r
801         # start the  DAG algorithm\r
802         #\r
803         while True:\r
804             EdgeRemoved = True\r
805             while Q == [] and EdgeRemoved:\r
806                 EdgeRemoved = False\r
807                 # for each node Item with a Constructor\r
808                 for Item in LibraryList:\r
809                     if Item not in Constructor:\r
810                         continue\r
811                     # for each Node without a constructor with an edge e from Item to Node\r
812                     for Node in ConsumedByList[Item]:\r
813                         if Node in Constructor:\r
814                             continue\r
815                         # remove edge e from the graph if Node has no constructor\r
816                         ConsumedByList[Item].remove(Node)\r
817                         EdgeRemoved = True\r
818                         if ConsumedByList[Item] == []:\r
819                             # insert Item into Q\r
820                             Q.insert(0, Item)\r
821                             break\r
822                     if Q != []:\r
823                         break\r
824             # DAG is done if there's no more incoming edge for all nodes\r
825             if Q == []:\r
826                 break\r
827 \r
828             # remove node from Q\r
829             Node = Q.pop()\r
830             # output Node\r
831             SortedLibraryList.append(Node)\r
832 \r
833             # for each node Item with an edge e from Node to Item do\r
834             for Item in LibraryList:\r
835                 if Node not in ConsumedByList[Item]:\r
836                     continue\r
837                 # remove edge e from the graph\r
838                 ConsumedByList[Item].remove(Node)\r
839 \r
840                 if ConsumedByList[Item] != []:\r
841                     continue\r
842                 # insert Item into Q, if Item has no other incoming edges\r
843                 Q.insert(0, Item)\r
844 \r
845         #\r
846         # if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle\r
847         #\r
848         for Item in LibraryList:\r
849             if ConsumedByList[Item] != [] and Item in Constructor and len(Constructor) > 1:\r
850                 ErrorMessage = "\tconsumed by " + "\n\tconsumed by ".join([str(L) for L in ConsumedByList[Item]])\r
851                 EdkLogger.error("build", BUILD_ERROR, 'Library [%s] with constructors has a cycle' % str(Item),\r
852                                 ExtraData=ErrorMessage, File=self._MetaFile)\r
853             if Item not in SortedLibraryList:\r
854                 SortedLibraryList.append(Item)\r
855 \r
856         #\r
857         # Build the list of constructor and destructir names\r
858         # The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order\r
859         #                \r
860         SortedLibraryList.reverse()\r
861         return SortedLibraryList\r
862     \r
863 \r
864     def _OverridePcd(self, ToPcd, FromPcd):\r
865         # \r
866         # in case there's PCDs coming from FDF file, which have no type given.\r
867         # at this point, PcdInModule.Type has the type found from dependent\r
868         # package\r
869         # \r
870         if FromPcd != None:\r
871             if FromPcd.Type not in [None, '']:\r
872                 ToPcd.Type = FromPcd.Type\r
873             if FromPcd.MaxDatumSize not in [None, '']:\r
874                 ToPcd.MaxDatumSize = FromPcd.MaxDatumSize\r
875             if FromPcd.DefaultValue not in [None, '']:\r
876                 ToPcd.DefaultValue = FromPcd.DefaultValue\r
877             if FromPcd.TokenValue not in [None, '']:\r
878                 ToPcd.TokenValue = FromPcd.TokenValue\r
879             if FromPcd.MaxDatumSize not in [None, '']:\r
880                 ToPcd.MaxDatumSize = FromPcd.MaxDatumSize\r
881             if FromPcd.DatumType not in [None, '']:\r
882                 ToPcd.DatumType = FromPcd.DatumType\r
883             if FromPcd.SkuInfoList not in [None, '', []]:\r
884                 ToPcd.SkuInfoList = FromPcd.SkuInfoList\r
885 \r
886         if ToPcd.DatumType == "VOID*" and ToPcd.MaxDatumSize in ['', None]:\r
887             EdkLogger.verbose("No MaxDatumSize specified for PCD %s.%s" \\r
888                               % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName))\r
889             Value = ToPcd.DefaultValue\r
890             if Value[0] == 'L':\r
891                 ToPcd.MaxDatumSize = str(len(Value) * 2)\r
892             elif Value[0] == '{':\r
893                 ToPcd.MaxDatumSize = str(len(Value.split(',')))\r
894             else:\r
895                 ToPcd.MaxDatumSize = str(len(Value))\r
896 \r
897         # apply default SKU for dynamic PCDS if specified one is not available\r
898         if (ToPcd.Type in PCD_DYNAMIC_TYPE_LIST or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_LIST) \\r
899             and ToPcd.SkuInfoList in [None, {}, '']:\r
900             if self.Platform.SkuName in self.Platform.SkuIds:\r
901                 SkuName = self.Platform.SkuName\r
902             else:\r
903                 SkuName = 'DEFAULT'\r
904             ToPcd.SkuInfoList = {\r
905                 SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName], '', '', '', '', '', ToPcd.DefaultValue)\r
906             }\r
907 \r
908     def ApplyPcdSetting(self, Module):\r
909         for Name,Guid in Module.Pcds:\r
910             PcdInModule = Module.Pcds[Name,Guid]\r
911             if (Name,Guid) in self.Platform.Pcds:\r
912                 PcdInPlatform = self.Platform.Pcds[Name,Guid]\r
913             else:\r
914                 PcdInPlatform = None\r
915             self._OverridePcd(PcdInModule, PcdInPlatform)\r
916             for SkuId in PcdInModule.SkuInfoList:\r
917                 Sku = PcdInModule.SkuInfoList[SkuId]\r
918                 if Sku.VariableGuid == '': continue\r
919                 Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList)\r
920                 if Sku.VariableGuidValue == None:\r
921                     PackageList = '\t' + "\n\t".join([str(P) for P in Module.Packages])\r
922                     EdkLogger.error(\r
923                                 'build',\r
924                                 RESOURCE_NOT_AVAILABLE,\r
925                                 "Value of [%s] is not found in" % Sku.VariableGuid,\r
926                                 ExtraData=PackageList + "\n\t(used with %s.%s from module %s)" \\r
927                                                         % (Guid, Name, str(Module)),\r
928                                 File=self._MetaFile\r
929                                 )\r
930 \r
931         # override PCD settings with module specific setting\r
932         if Module in self.Platform.Modules:\r
933             PlatformModule = self.Platform.Modules[str(Module)]\r
934             for Key  in PlatformModule.Pcds:\r
935                 if Key in Module.Pcds:\r
936                     self._OverridePcd(Module.Pcds[Key], PlatformModule.Pcds[Key])\r
937         return Module.Pcds.values()\r
938 \r
939     ##\r
940     # for R8.x modules\r
941     # \r
942     def ResolveLibraryReference(self, Module):\r
943         EdkLogger.verbose("")\r
944         EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))\r
945         LibraryConsumerList = [Module]\r
946 \r
947         # "CompilerStub" is a must for R8 modules\r
948         Module.Libraries.append("CompilerStub")\r
949         LibraryList = []\r
950         while len(LibraryConsumerList) > 0:\r
951             M = LibraryConsumerList.pop()\r
952             for LibraryName in M.Libraries:\r
953                 Library = self.Platform.LibraryClasses[LibraryName, ':dummy:']\r
954                 if Library == None:\r
955                     EdkLogger.warn("build", "Library [%s] is not found" % LibraryName, File=str(M),\r
956                                     ExtraData="\t%s [%s]" % (str(Module), self.Arch))\r
957                     continue\r
958 \r
959                 if Library not in LibraryList:\r
960                     LibraryList.append(Library)\r
961                     LibraryConsumerList.append(Library)\r
962                     EdkLogger.verbose("\t" + LibraryName + " : " + str(Library) + ' ' + str(type(Library)))\r
963         return LibraryList\r
964 \r
965     def _ExpandBuildOption(self, Options):\r
966         BuildOptions = {}\r
967         for Key in Options:\r
968             Family = Key[0]\r
969             Target, Tag, Arch, Tool, Attr = Key[1].split("_")\r
970             # if no tool defined for the option, skip it\r
971             if Tool not in self.Workspace.ToolPath:\r
972                 continue\r
973             # if tool chain family doesn't match, skip it\r
974             if Family != None and Family != "" and Family != self.ToolChainFamily[Tool]:\r
975                 continue\r
976             # expand any wildcard\r
977             if Target == "*" or Target == self.BuildTarget:\r
978                 if Tag == "*" or Tag == self.ToolChain:\r
979                     if Arch == "*" or Arch == self.Arch:\r
980                         if Tool not in BuildOptions:\r
981                             BuildOptions[Tool] = Options[Key]\r
982                         else:\r
983                             # append options for the same tool\r
984                             BuildOptions[Tool] += " " + Options[Key]\r
985         return BuildOptions\r
986 \r
987     def ApplyBuildOption(self, Module):\r
988         PlatformOptions = self.BuildOption\r
989         ModuleOptions = self._ExpandBuildOption(Module.BuildOptions)\r
990         if Module in self.Platform.Modules:\r
991             PlatformModule = self.Platform.Modules[str(Module)]\r
992             PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions)\r
993         else:\r
994             PlatformModuleOptions = {}\r
995 \r
996         BuildOptions = {}\r
997         # for those tools that have no option in module file, give it a empty string\r
998         for Tool in self.Workspace.ToolPath:\r
999             if Tool in self.ToolOption and Module.ModuleType != 'USER_DEFINED':\r
1000                 BuildOptions[Tool] = self.ToolOption[Tool]\r
1001             else:\r
1002                 BuildOptions[Tool] = ''\r
1003             if Tool in ModuleOptions:\r
1004                 BuildOptions[Tool] += " " + ModuleOptions[Tool]\r
1005             if Tool in PlatformOptions:\r
1006                 BuildOptions[Tool] += " " + PlatformOptions[Tool]\r
1007             if Tool in PlatformModuleOptions:\r
1008                 BuildOptions[Tool] += " " + PlatformModuleOptions[Tool]\r
1009         return BuildOptions\r
1010 \r
1011     Platform            = property(_GetPlatform)\r
1012     Name                = property(_GetName)\r
1013     Guid                = property(_GetGuid)\r
1014     Version             = property(_GetVersion)\r
1015                        \r
1016     OutputDir           = property(_GetOutputDir)\r
1017     BuildDir            = property(_GetBuildDir)\r
1018     MakeFileDir         = property(_GetMakeFileDir)\r
1019     FdfFile             = property(_GetFdfFile)\r
1020     \r
1021     PcdTokenNumber      = property(_GetPcdTokenNumbers)    # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
1022     DynamicPcdList      = property(_GetDynamicPcdList)    # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
1023     NonDynamicPcdList   = property(_GetNonDynamicPcdList)    # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
1024     PackageList         = property(_GetPackageList)\r
1025 \r
1026     ToolPath            = property(_GetToolPaths)    # toolcode : tool path\r
1027     ToolDllPath         = property(_GetToolDllPaths)    # toolcode : lib path\r
1028     ToolStaticLib       = property(_GetToolStaticLibs)    # toolcode : lib path\r
1029     ToolChainFamily     = property(_GetToolChainFamilies)    # toolcode : tool chain family\r
1030     BuildOption         = property(_GetBuildOptions)    # toolcode : option\r
1031     OutputFlag          = property(_GetOuputFlags)    # toolcode : output flag\r
1032     IncludeFlag         = property(_GetIncludeFlags)    # toolcode : include flag\r
1033     ToolOption          = property(_GetToolOptions)    # toolcode : tool option string\r
1034 \r
1035     BuildCommand        = property(_GetBuildCommand)\r
1036     BuildRule           = property(_GetBuildRule)\r
1037     ModuleAutoGenList   = property(_GetModuleAutoGenList)\r
1038     LibraryAutoGenList  = property(_GetLibraryAutoGenList)\r
1039 \r
1040 ## AutoGen class\r
1041 #\r
1042 # This class encapsules the AutoGen behaviors for the build tools. In addition to\r
1043 # the generation of AutoGen.h and AutoGen.c, it can generate *.depex file according\r
1044 # to the [depex] section in module's inf file. The result of parsing unicode file\r
1045 # has been incorporated either.\r
1046 #\r
1047 class ModuleAutoGen(AutoGen):\r
1048     ## The real constructor of ModuleAutoGen\r
1049     #\r
1050     #  This method is not supposed to be called by users of ModuleAutoGen. It's\r
1051     #  only used by factory method New() to do real initialization work for an\r
1052     #  object of ModuleAutoGen\r
1053     #\r
1054     #   @param      Workspace           EdkIIWorkspaceBuild object\r
1055     #   @param      PlatformAutoGenObj  Platform file (DSC file)\r
1056     #   @param      ModuleFile          The path of module file\r
1057     #   @param      Target              Build target (DEBUG, RELEASE)\r
1058     #   @param      Toolchain           Name of tool chain\r
1059     #   @param      Arch                The arch the module supports\r
1060     #\r
1061     def _Init(self, Workspace, ModuleFile, Target, Toolchain, Arch, PlatformFile):\r
1062         EdkLogger.verbose("\nAutoGen module [%s] [%s]" % (ModuleFile, Arch))\r
1063 \r
1064         self.Workspace = Workspace\r
1065         self.WorkspaceDir = Workspace.WorkspaceDir\r
1066 \r
1067         self._MetaFile = str(ModuleFile)\r
1068         self.PlatformInfo = PlatformAutoGen(Workspace, PlatformFile, Target, Toolchain, Arch)\r
1069         if not self.PlatformInfo.ValidModule(self._MetaFile):\r
1070             EdkLogger.verbose("Module [%s] for [%s] is not employed by active platform\n" \\r
1071                               % (self._MetaFile, Arch))\r
1072             return False\r
1073 \r
1074         self.SourceDir = path.dirname(self._MetaFile)\r
1075         self.FileBase, self.FileExt = path.splitext(path.basename(self._MetaFile))\r
1076 \r
1077         self.ToolChain = Toolchain\r
1078         self.ToolChainFamily = "MSFT"\r
1079         self.BuildTarget = Target\r
1080         self.Arch = Arch\r
1081 \r
1082         self.IsMakeFileCreated = False\r
1083         self.IsCodeFileCreated = False\r
1084 \r
1085         self.BuildDatabase = self.Workspace.BuildDatabase\r
1086 \r
1087         self._Module          = None\r
1088         self._Name            = None\r
1089         self._Guid            = None\r
1090         self._Version         = None\r
1091         self._ModuleType      = None\r
1092         self._ComponentType   = None\r
1093         self._PcdIsDriver     = None\r
1094         self._AutoGenVersion  = None\r
1095         self._LibraryFlag     = None\r
1096         self._CustomMakefile  = None\r
1097         self._Macro           = None\r
1098 \r
1099         self._BuildDir        = None\r
1100         self._OutputDir       = None\r
1101         self._DebugDir        = None\r
1102         self._MakeFileDir     = None\r
1103 \r
1104         self._IncludePathList = None\r
1105         self._AutoGenFileList = None\r
1106         self._UnicodeFileList = None\r
1107         self._SourceFileList  = None\r
1108         self._ObjectFileList  = None\r
1109         self._BinaryFileDict  = None\r
1110 \r
1111         self._DependentPackageList    = None\r
1112         self._DependentLibraryList    = None\r
1113         self._LibraryAutoGenList      = None\r
1114         self._DerivedPackageList      = None\r
1115         self._PcdList                 = None\r
1116         self._GuidList                = None\r
1117         self._ProtocolList            = None\r
1118         self._PpiList                 = None\r
1119         self._DepexList               = None\r
1120         self._BuildOption             = None\r
1121 \r
1122         return True\r
1123 \r
1124 \r
1125     def _GetModule(self):\r
1126         if self._Module == None:\r
1127             self._Module = self.Workspace.BuildDatabase[self._MetaFile, self.Arch]\r
1128         return self._Module\r
1129 \r
1130     def _GetBaseName(self):\r
1131         return self.Module.BaseName\r
1132 \r
1133     def _GetGuid(self):\r
1134         return self.Module.Guid\r
1135 \r
1136     def _GetVersion(self):\r
1137         return self.Module.Version\r
1138 \r
1139     def _GetModuleType(self):\r
1140         return self.Module.ModuleType\r
1141 \r
1142     def _GetComponentType(self):\r
1143         return self.Module.ComponentType\r
1144 \r
1145     def _GetPcdIsDriver(self):\r
1146         return self.Module.PcdIsDriver\r
1147 \r
1148     def _GetAutoGenVersion(self):\r
1149         return self.Module.AutoGenVersion\r
1150 \r
1151     def _IsLibrary(self):\r
1152         if self._LibraryFlag == None:\r
1153             if self.Module.LibraryClass != None and self.Module.LibraryClass != []:\r
1154                 self._LibraryFlag = True\r
1155             else:\r
1156                 self._LibraryFlag = False\r
1157         return self._LibraryFlag\r
1158 \r
1159     def _GetBuildDir(self):\r
1160         if self._BuildDir == None:\r
1161             self._BuildDir = path.join(\r
1162                                     self.PlatformInfo.BuildDir,\r
1163                                     self.Arch,\r
1164                                     self.SourceDir,\r
1165                                     self.FileBase\r
1166                                     )\r
1167         return self._BuildDir\r
1168 \r
1169     def _GetOutputDir(self):\r
1170         if self._OutputDir == None:\r
1171             self._OutputDir = path.join(self.BuildDir, "OUTPUT")\r
1172         return self._OutputDir\r
1173 \r
1174     def _GetDebugDir(self):\r
1175         if self._DebugDir == None:\r
1176             self._DebugDir = path.join(self.BuildDir, "DEBUG")\r
1177         return self._DebugDir\r
1178 \r
1179     def _GetMakeFileDir(self):\r
1180         return path.join(PlatformInfo.BuildDir, self.BuildDir)\r
1181 \r
1182     def _GetCustomMakefile(self):\r
1183         if self._CustomMakefile == None:\r
1184             self._CustomMakefile = {}\r
1185             for Type in self.Module.CustomMakefile:\r
1186                 MakeType = gMakeTypeMap[Type]\r
1187                 self._CustomMakefile[MakeType] = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])    \r
1188         return self._CustomMakefile\r
1189 \r
1190     ## Return the directory of the makefile\r
1191     #\r
1192     #   @retval     string  The directory string of module's makefile\r
1193     #\r
1194     def _GetMakeFileDir(self):\r
1195         return self.BuildDir\r
1196 \r
1197     ## Return build command string\r
1198     #\r
1199     #   @retval     string  Build command string\r
1200     #\r
1201     def _GetBuildCommand(self):\r
1202         return self.PlatformInfo.BuildCommand\r
1203 \r
1204     ## Get object list of all packages the module and its dependent libraries belong to\r
1205     #\r
1206     #   @retval     list    The list of package object\r
1207     #\r
1208     def _GetDerivedPackageList(self):\r
1209         PackageList = []\r
1210         for M in [self.Module] + self.DependentLibraryList:\r
1211             for Package in M.Packages:\r
1212                 if Package in PackageList:\r
1213                     continue\r
1214                 PackageList.append(Package)\r
1215         return PackageList\r
1216 \r
1217     ## Parse dependency expression\r
1218     #\r
1219     #   @param      Info    The object of ModuleBuildInfo\r
1220     #   @retval     list    The token list of the dependency expression after parsed\r
1221     #\r
1222     def _GetDepexTokenList(self):\r
1223         if self._DepexList == None:\r
1224             self._DepexList = self.Module.Depex\r
1225             EdkLogger.verbose("DEPEX = %s" % self._DepexList)\r
1226             #\r
1227             # Append depex from dependent libraries\r
1228             #\r
1229             for Lib in self.DependentLibraryList:\r
1230                 if Lib.Depex != None and Lib.Depex != []:\r
1231                     if self._DepexList != []:\r
1232                         self._DepexList.append('AND')\r
1233                     self._DepexList.append('(')\r
1234                     self._DepexList.extend(Lib.Depex)\r
1235                     self._DepexList.append(')')\r
1236                     EdkLogger.verbose("DEPEX (+%s) = %s" % (Lib.BaseName, self._DepexList))\r
1237 \r
1238             for I in range(0, len(self._DepexList)):\r
1239                 Token = self._DepexList[I]\r
1240                 if Token.endswith(".inf"):  # module file name\r
1241                     ModuleFile = os.path.normpath(Token)\r
1242                     self._DepexList[I] = self.BuildDatabase[ModuleFile].Guid\r
1243         return self._DepexList\r
1244 \r
1245     ## Return the list of macro in module\r
1246     #\r
1247     #   @retval     list    The list of macro defined in module file\r
1248     #\r
1249     def _GetMacroList(self):\r
1250         return self.Module.Specification\r
1251 \r
1252     ## Tool option for the module build\r
1253     #\r
1254     #   @param      PlatformInfo    The object of PlatformBuildInfo\r
1255     #   @retval     dict            The dict containing valid options\r
1256     #\r
1257     def _GetModuleBuildOption(self):\r
1258         if self._BuildOption == None:\r
1259             self._BuildOption = self.PlatformInfo.ApplyBuildOption(self.Module)\r
1260         return self._BuildOption\r
1261 \r
1262     ## Return a list of files which can be built from source\r
1263     #\r
1264     #  What kind of files can be built is determined by build rules in\r
1265     #  $(WORKSPACE)/Conf/build_rule.txt and toolchain family.\r
1266     #\r
1267     def _GetSourceFileList(self):\r
1268         if self._SourceFileList != None:\r
1269             return self._SourceFileList\r
1270 \r
1271         self._SourceFileList = []\r
1272         self._UnicodeFileList = []\r
1273         # use toolchain family of CC as the primary toolchain family\r
1274         if "CC" not in self.PlatformInfo.ToolChainFamily:\r
1275             EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Tool [CC] is not defined for %s [%s, %s]" \\r
1276                              % (self.ToolChain, self.BuildTarget, self.Arch))\r
1277         ToolChainFamily = self.PlatformInfo.ToolChainFamily["CC"]\r
1278         BuildRule = self.PlatformInfo.BuildRule\r
1279         for F in self.Module.Sources:\r
1280             SourceFile = F.SourceFile\r
1281             # match tool chain\r
1282             if F.TagName != "" and F.TagName != self.ToolChain:\r
1283                 EdkLogger.verbose("The toolchain [%s] for processing file [%s] is found, "\r
1284                                   "but [%s] is needed" % (F.TagName, F.SourceFile, self.ToolChain))\r
1285                 continue\r
1286             # match tool chain family\r
1287             if F.ToolChainFamily != "" and F.ToolChainFamily != ToolChainFamily:\r
1288                 EdkLogger.verbose("The file [%s] must be built by tools of [%s], "\r
1289                                   "but current toolchain family is [%s]" % (SourceFile, F.ToolChainFamily, ToolChainFamily))\r
1290                 continue\r
1291 \r
1292             # add the file path into search path list for file including\r
1293             Dir = path.dirname(SourceFile)\r
1294             if Dir != "":\r
1295                 Dir = path.join(self.WorkspaceDir, self.SourceDir, Dir)\r
1296                 if Dir not in self.IncludePathList:\r
1297                     self.IncludePathList.insert(0, Dir)\r
1298 \r
1299             # skip unknown file\r
1300             Base, Ext = path.splitext(SourceFile)\r
1301 \r
1302             # skip file which needs a tool having no matching toolchain family\r
1303             FileType, RuleObject = BuildRule.Get(Ext, ToolChainFamily)\r
1304             # unicode must be processed by AutoGen\r
1305             if FileType == "Unicode-Text-File":\r
1306                 self._UnicodeFileList.append(os.path.join(self.WorkspaceDir, self.SourceDir, SourceFile))\r
1307 \r
1308             # if there's dxs file, don't use content in [depex] section to generate .depex file\r
1309             if FileType == "Dependency-Expression-File":\r
1310                 self._DepexList = []\r
1311 \r
1312             # no command, no build\r
1313             if RuleObject != None and RuleObject.CommandList == []:\r
1314                 RuleObject = None\r
1315             if [SourceFile, FileType, RuleObject] not in self._SourceFileList:\r
1316                 self._SourceFileList.append([SourceFile, FileType, RuleObject])\r
1317 \r
1318         return self._SourceFileList\r
1319 \r
1320     def _GetUnicodeFileList(self):\r
1321         if self._UnicodeFileList == None:\r
1322             self._GetSourceFileList()\r
1323         return self._UnicodeFileList\r
1324 \r
1325     ## Return a list of files which can be built from binary\r
1326     #\r
1327     #  "Build" binary files are just to copy them to build directory.\r
1328     #\r
1329     #   @param      PlatformInfo    The object of PlatformBuildInfo\r
1330     #   @retval     list            The list of files which can be built later\r
1331     #\r
1332     def _GetBinaryFiles(self):\r
1333         if self._BinaryFileDict == None:\r
1334             self._BinaryFileDict = sdict()\r
1335             for F in self.Module.Binaries:\r
1336                 if F.Target != '*' and F.Target != self.BuildTarget:\r
1337                     continue\r
1338                 if F.FileType not in self._BinaryFileDict:\r
1339                     self._BinaryFileDict[F.FileType] = []\r
1340                 self._BinaryFileDict[F.FileType].append(F.BinaryFile)\r
1341         return self._BinaryFileDict\r
1342 \r
1343     ## Get the list of package object the module depends on\r
1344     #\r
1345     #   @retval     list    The package object list\r
1346     #\r
1347     def _GetDependentPackageList(self):\r
1348         return self.Module.Packages\r
1349 \r
1350     ## Return the list of auto-generated code file\r
1351     #\r
1352     #   @param      BuildInfo   The object ModuleBuildInfo\r
1353     #   @retval     list        The list of auto-generated file\r
1354     #\r
1355     def _GetAutoGenFileList(self):\r
1356         if self._AutoGenFileList == None:\r
1357             self._AutoGenFileList = {}\r
1358             AutoGenC = TemplateString()\r
1359             AutoGenH = TemplateString()\r
1360             GenC.CreateCode(self, AutoGenC, AutoGenH)\r
1361             if str(AutoGenC) != "":\r
1362                 self._AutoGenFileList[gAutoGenCodeFileName] = AutoGenC\r
1363             if str(AutoGenH) != "":\r
1364                 self._AutoGenFileList[gAutoGenHeaderFileName] = AutoGenH\r
1365         return self._AutoGenFileList\r
1366 \r
1367     def _GetLibraryList(self):\r
1368         if self._DependentLibraryList == None:\r
1369             # only merge library classes and PCD for non-library module\r
1370             if self.IsLibrary:\r
1371                 self._DependentLibraryList = []\r
1372             else:\r
1373                 if self.AutoGenVersion < 0x00010005:\r
1374                     self._DependentLibraryList = self.PlatformInfo.ResolveLibraryReference(self.Module)\r
1375                 else:\r
1376                     self._DependentLibraryList = self.PlatformInfo.ApplyLibraryInstance(self.Module)\r
1377         return self._DependentLibraryList\r
1378 \r
1379     ## Get the list of PCD\r
1380     #\r
1381     #   @param      DependentLibraryList    The list of dependent library\r
1382     #   @retval     list                    The list of PCD\r
1383     #\r
1384     def _GetPcdList(self):\r
1385         if self._PcdList == None:\r
1386             if not self.IsLibrary:\r
1387                 # derive PCDs from libraries first\r
1388                 for Library in self.DependentLibraryList:\r
1389                     for Key in Library.Pcds:\r
1390                         if Key in self.Module.Pcds:\r
1391                             continue\r
1392                         self.Module.Pcds[Key] = Library.Pcds[Key]\r
1393                 # apply PCD settings from platform            \r
1394             self._PcdList = self.PlatformInfo.ApplyPcdSetting(self.Module)\r
1395         return self._PcdList\r
1396 \r
1397     ## Get the GUID value mapping\r
1398     #\r
1399     #   @retval     dict    The mapping between GUID cname and its value\r
1400     #\r
1401     def _GetGuidList(self):\r
1402         if self._GuidList == None:\r
1403             self._GuidList = self.Module.Guids\r
1404             for Library in self.DependentLibraryList:\r
1405                 self._GuidList.update(Library.Guids)\r
1406         return self._GuidList\r
1407 \r
1408     ## Get the protocol value mapping\r
1409     #\r
1410     #   @retval     dict    The mapping between protocol cname and its value\r
1411     #\r
1412     def _GetProtocolList(self):\r
1413         if self._ProtocolList == None:\r
1414             self._ProtocolList = self.Module.Protocols\r
1415             for Library in self.DependentLibraryList:\r
1416                 self._ProtocolList.update(Library.Protocols)\r
1417         return self._ProtocolList\r
1418 \r
1419     ## Get the PPI value mapping\r
1420     #\r
1421     #   @retval     dict    The mapping between PPI cname and its value\r
1422     #\r
1423     def _GetPpiList(self):\r
1424         if self._PpiList == None:\r
1425             self._PpiList = self.Module.Ppis\r
1426             for Library in self.DependentLibraryList:\r
1427                 self._PpiList.update(Library.Ppis)\r
1428         return self._PpiList\r
1429 \r
1430     ## Get the list of include search path\r
1431     #\r
1432     #   @param      DependentPackageList    The list of package object\r
1433     #   @retval     list                    The list path\r
1434     #\r
1435     def _GetIncludePathList(self):\r
1436         if self._IncludePathList == None:\r
1437             self._IncludePathList = []\r
1438             if self.AutoGenVersion < 0x00010005:\r
1439                 for Inc in self.Module.Includes:\r
1440                     # '.' means "relative to module directory".\r
1441                     if Inc[0] == ".":\r
1442                         Inc = path.join(self.WorkspaceDir, self.SourceDir, Inc)\r
1443                     else:\r
1444                         Inc = path.join(self.WorkspaceDir, Inc)\r
1445                     if Inc in self._IncludePathList:\r
1446                         continue\r
1447                     self._IncludePathList.append(Inc)\r
1448                     # for r8 modules\r
1449                     self._IncludePathList.append(path.join(Inc, self.Arch.capitalize()))\r
1450                 # r8 module needs to put DEBUG_DIR at the end search path and not to use SOURCE_DIR all the time\r
1451                 self._IncludePathList.append(self.DebugDir)\r
1452             else:\r
1453                 self._IncludePathList.append(os.path.join(self.WorkspaceDir, self.SourceDir))\r
1454                 self._IncludePathList.append(self.DebugDir)\r
1455 \r
1456             for Package in self.Module.Packages:\r
1457                 PackageDir = path.join(self.WorkspaceDir, path.dirname(str(Package)))\r
1458                 if PackageDir not in self._IncludePathList:\r
1459                     self._IncludePathList.append(PackageDir)\r
1460                 for Inc in Package.Includes:\r
1461                     Inc = path.join(PackageDir, Inc)\r
1462                     if Inc not in self._IncludePathList:\r
1463                         self._IncludePathList.append(Inc)\r
1464         return self._IncludePathList\r
1465 \r
1466     ## Create makefile for the module and its dependent libraries\r
1467     #\r
1468     #   @param      CreateLibraryMakeFile   Flag indicating if or not the makefiles of\r
1469     #                                       dependent libraries will be created\r
1470     #\r
1471     def CreateMakeFile(self, CreateLibraryMakeFile=True):\r
1472         if self.IsMakeFileCreated:\r
1473             return\r
1474 \r
1475         PlatformInfo = self.PlatformInfo\r
1476         if not self.IsLibrary and CreateLibraryMakeFile:\r
1477             for LibraryAutoGen in self.LibraryAutoGenList:\r
1478                 LibraryAutoGen.CreateMakeFile()\r
1479 \r
1480         if len(self.CustomMakefile) == 0:\r
1481             Makefile = GenMake.ModuleMakefile(self)\r
1482         else:\r
1483             Makefile = GenMake.CustomMakefile(self)\r
1484         if Makefile.Generate():\r
1485             EdkLogger.verbose("Generated makefile for module %s [%s]" %\r
1486                            (self.Name, self.Arch))\r
1487         else:\r
1488             EdkLogger.verbose("Skipped the generation of makefile for module %s [%s]" %\r
1489                               (self.Name, self.Arch))\r
1490 \r
1491         self.IsMakeFileCreated = True\r
1492 \r
1493     ## Create autogen code for the module and its dependent libraries\r
1494     #\r
1495     #   @param      CreateLibraryCodeFile   Flag indicating if or not the code of\r
1496     #                                       dependent libraries will be created\r
1497     #\r
1498     def CreateCodeFile(self, CreateLibraryCodeFile=True):\r
1499         if self.IsCodeFileCreated:\r
1500             return\r
1501 \r
1502         PlatformInfo = self.PlatformInfo\r
1503         if not self.IsLibrary and CreateLibraryCodeFile:\r
1504             for LibraryAutoGen in self.LibraryAutoGenList:\r
1505                 LibraryAutoGen.CreateCodeFile()\r
1506 \r
1507         AutoGenList = []\r
1508         IgoredAutoGenList = []\r
1509         for File in self.AutoGenFileList:\r
1510             if GenC.Generate(path.join(self.DebugDir, File), str(self.AutoGenFileList[File])):\r
1511                 AutoGenList.append(File)\r
1512             else:\r
1513                 IgoredAutoGenList.append(File)\r
1514 \r
1515         if self.DepexList != []:\r
1516             Dpx = GenDepex.DependencyExpression(self.DepexList, self.ModuleType, True)\r
1517             DpxFile = gAutoGenDepexFileName % {"module_name" : self.Name}\r
1518 \r
1519             if Dpx.Generate(path.join(self.OutputDir, DpxFile)):\r
1520                 AutoGenList.append(DpxFile)\r
1521             else:\r
1522                 IgoredAutoGenList.append(DpxFile)\r
1523 \r
1524         if IgoredAutoGenList == []:\r
1525             EdkLogger.verbose("Generated [%s] files for module %s [%s]" %\r
1526                            (" ".join(AutoGenList), self.Name, self.Arch))\r
1527         elif AutoGenList == []:\r
1528             EdkLogger.verbose("Skipped the generation of [%s] files for module %s [%s]" %\r
1529                            (" ".join(IgoredAutoGenList), self.Name, self.Arch))\r
1530         else:\r
1531             EdkLogger.verbose("Generated [%s] (skipped %s) files for module %s [%s]" %\r
1532                            (" ".join(AutoGenList), " ".join(IgoredAutoGenList), self.Name, self.Arch))\r
1533 \r
1534         self.IsCodeFileCreated = True\r
1535         return AutoGenList\r
1536 \r
1537     def _GetLibraryAutoGenList(self):\r
1538         if self._LibraryAutoGenList == None:\r
1539             self._LibraryAutoGenList = []\r
1540             for Library in self.DependentLibraryList:\r
1541                 La = ModuleAutoGen(\r
1542                         self.Workspace,\r
1543                         str(Library),\r
1544                         self.BuildTarget,\r
1545                         self.ToolChain,\r
1546                         self.Arch,\r
1547                         str(self.PlatformInfo)\r
1548                         )\r
1549                 if La not in self._LibraryAutoGenList:\r
1550                     self._LibraryAutoGenList.append(La)\r
1551         return self._LibraryAutoGenList\r
1552 \r
1553     ## Return build command string\r
1554     #\r
1555     #   @retval     string  Build command string\r
1556     #\r
1557     def _GetBuildCommand(self):\r
1558         return self.PlatformInfo.BuildCommand\r
1559 \r
1560 \r
1561     Module          = property(_GetModule)\r
1562     Name            = property(_GetBaseName)\r
1563     Guid            = property(_GetGuid)\r
1564     Version         = property(_GetVersion)\r
1565     ModuleType      = property(_GetModuleType)\r
1566     ComponentType   = property(_GetComponentType)\r
1567     PcdIsDriver     = property(_GetPcdIsDriver)\r
1568     AutoGenVersion  = property(_GetAutoGenVersion)\r
1569     Macro           = property(_GetMacroList)\r
1570 \r
1571     IsLibrary       = property(_IsLibrary)\r
1572 \r
1573     BuildDir        = property(_GetBuildDir)\r
1574     OutputDir       = property(_GetOutputDir)\r
1575     DebugDir        = property(_GetDebugDir)\r
1576     MakeFileDir     = property(_GetMakeFileDir)\r
1577     CustomMakefile  = property(_GetCustomMakefile)\r
1578 \r
1579     IncludePathList = property(_GetIncludePathList)\r
1580     AutoGenFileList = property(_GetAutoGenFileList)\r
1581     UnicodeFileList = property(_GetUnicodeFileList)\r
1582     SourceFileList  = property(_GetSourceFileList)\r
1583     BinaryFileDict  = property(_GetBinaryFiles) # FileType : [File List]\r
1584 \r
1585     DependentPackageList    = property(_GetDependentPackageList)\r
1586     DependentLibraryList    = property(_GetLibraryList)\r
1587     LibraryAutoGenList      = property(_GetLibraryAutoGenList)\r
1588     DerivedPackageList      = property(_GetDerivedPackageList)\r
1589 \r
1590     PcdList                 = property(_GetPcdList)\r
1591     GuidList                = property(_GetGuidList)\r
1592     ProtocolList            = property(_GetProtocolList)\r
1593     PpiList                 = property(_GetPpiList)\r
1594     DepexList               = property(_GetDepexTokenList)\r
1595     BuildOption             = property(_GetModuleBuildOption)\r
1596     BuildCommand            = property(_GetBuildCommand)\r
1597 \r
1598 # This acts like the main() function for the script, unless it is 'import'ed into another script.\r
1599 if __name__ == '__main__':\r
1600     pass\r
1601 \r