Added code to check if 'COMMON' in result of parsed sections.
[people/mcb30/basetools.git] / Source / Python / Common / InfClassObject.py
1 ## @file\r
2 # This file is used to define each component of INF file\r
3 #\r
4 # Copyright (c) 2007, Intel Corporation\r
5 # All rights reserved. This program and the accompanying materials\r
6 # are licensed and made available under the terms and conditions of the BSD License\r
7 # which accompanies this distribution.  The full text of the license may be found at\r
8 # http://opensource.org/licenses/bsd-license.php\r
9 #\r
10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
12 #\r
13 \r
14 ##\r
15 # Import Modules\r
16 #\r
17 import os\r
18 import re\r
19 import EdkLogger\r
20 from CommonDataClass.CommonClass import LibraryClassClass\r
21 from CommonDataClass.ModuleClass import *\r
22 from String import *\r
23 from DataType import *\r
24 from Identification import *\r
25 from Dictionary import *\r
26 from BuildToolError import *\r
27 from Misc import sdict\r
28 import GlobalData\r
29 \r
30 gComponentType2ModuleType = {\r
31     "LIBRARY"               :   "BASE",\r
32     "SECURITY_CORE"         :   "SEC",\r
33     "PEI_CORE"              :   "PEI_CORE",\r
34     "COMBINED_PEIM_DRIVER"  :   "PEIM",\r
35     "PIC_PEIM"              :   "PEIM",\r
36     "RELOCATABLE_PEIM"      :   "PEIM",\r
37     "PE32_PEIM"             :   "PEIM",\r
38     "BS_DRIVER"             :   "DXE_DRIVER",\r
39     "RT_DRIVER"             :   "DXE_RUNTIME_DRIVER",\r
40     "SAL_RT_DRIVER"         :   "DXE_SAL_DRIVER",\r
41 #    "BS_DRIVER"             :   "DXE_SMM_DRIVER",\r
42 #    "BS_DRIVER"             :   "UEFI_DRIVER",\r
43     "APPLICATION"           :   "UEFI_APPLICATION",\r
44     "LOGO"                  :   "BASE",\r
45 }\r
46 \r
47 gNmakeFlagPattern = re.compile("(?:EBC_)?([A-Z]+)_(?:STD_|PROJ_|ARCH_)?FLAGS(?:_DLL|_ASL|_EXE)?", re.UNICODE)\r
48 gNmakeFlagName2ToolCode = {\r
49     "C"         :   "CC",\r
50     "LIB"       :   "SLINK",\r
51     "LINK"      :   "DLINK",\r
52 }\r
53 \r
54 ## InfObject\r
55 #\r
56 # This class defined basic Inf object which is used by inheriting\r
57\r
58 # @param object:       Inherited from object class\r
59 #\r
60 class InfObject(object):\r
61     def __init__(self):\r
62         object.__init__()\r
63 \r
64 ## InfDefines\r
65 #\r
66 # This class defined basic Defines used in Inf object\r
67\r
68 # @param InfObject:        Inherited from InfObject class\r
69 #\r
70 # @var DefinesDictionary:  To store value for DefinesDictionary \r
71 #\r
72 class InfDefines(InfObject):\r
73     def __init__(self):\r
74         self.DefinesDictionary = {\r
75             #\r
76             # Required Fields\r
77             #\r
78             TAB_INF_DEFINES_BASE_NAME                               : [''],\r
79             TAB_INF_DEFINES_FILE_GUID                               : [''],\r
80             TAB_INF_DEFINES_MODULE_TYPE                             : [''],\r
81             TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION               : [''],\r
82             TAB_INF_DEFINES_EDK_RELEASE_VERSION                     : [''],\r
83             \r
84             #\r
85             # Optional Fields\r
86             #\r
87             TAB_INF_DEFINES_INF_VERSION                             : [''],\r
88             TAB_INF_DEFINES_BINARY_MODULE                           : [''],\r
89             TAB_INF_DEFINES_LIBRARY_CLASS                           : [''],\r
90             TAB_INF_DEFINES_COMPONENT_TYPE                          : [''],\r
91             TAB_INF_DEFINES_MAKEFILE_NAME                           : [''],\r
92             TAB_INF_DEFINES_BUILD_NUMBER                            : [''],\r
93             TAB_INF_DEFINES_BUILD_TYPE                              : [''],\r
94             TAB_INF_DEFINES_FFS_EXT                                 : [''],\r
95             TAB_INF_DEFINES_FV_EXT                                  : [''],\r
96             TAB_INF_DEFINES_SOURCE_FV                               : [''],\r
97             TAB_INF_DEFINES_VERSION_NUMBER                          : [''],\r
98             TAB_INF_DEFINES_VERSION_STRING                          : [''],\r
99             TAB_INF_DEFINES_VERSION                                 : [''],\r
100             TAB_INF_DEFINES_PCD_IS_DRIVER                           : [''],\r
101             TAB_INF_DEFINES_TIANO_R8_FLASHMAP_H                     : [''],\r
102             TAB_INF_DEFINES_ENTRY_POINT                             : [''],\r
103             TAB_INF_DEFINES_UNLOAD_IMAGE                            : [''],\r
104             TAB_INF_DEFINES_CONSTRUCTOR                             : [''],\r
105             TAB_INF_DEFINES_DESTRUCTOR                              : [''],\r
106             TAB_INF_DEFINES_DEFINE                                  : [''],\r
107             TAB_INF_DEFINES_SPEC                                    : [''],\r
108             TAB_INF_DEFINES_CUSTOM_MAKEFILE                         : [''],\r
109             TAB_INF_DEFINES_SHADOW                                  : [''],\r
110             TAB_INF_DEFINES_MACRO                                   : {}\r
111         }\r
112 \r
113     def extend(self, InfDefinesObj):\r
114         for Item in InfDefinesObj.DefinesDictionary:\r
115             if Item == TAB_INF_DEFINES_MACRO:\r
116                 self.DefinesDictionary[Item].update(InfDefinesObj.DefinesDictionary[Item])\r
117             else:\r
118                 if InfDefinesObj.DefinesDictionary[Item][0] != '':\r
119                     if self.DefinesDictionary[Item][0] == '':\r
120                         self.DefinesDictionary[Item] = []\r
121                     self.DefinesDictionary[Item].extend(InfDefinesObj.DefinesDictionary[Item])\r
122 \r
123 ## InfContents\r
124 #\r
125 # This class defined basic Contents used in Inf object\r
126\r
127 # @param InfObject:   Inherited from InfObject class\r
128 #\r
129 # @var Sources:       To store value for Sources\r
130 # @var BuildOptions:  To store value for BuildOptions\r
131 # @var Binaries:      To store value for Binaries\r
132 # @var Includes:      To store value for Includes\r
133 # @var Guids:         To store value for Guids\r
134 # @var Protocols:     To store value for Protocols\r
135 # @var Ppis:          To store value for Ppis\r
136 # @var Libraries:     To store value for Libraries\r
137 # @var Packages:      To store value for Packages\r
138 # @var FixedPcd:      To store value for FixedPcd\r
139 # @var PatchPcd:      To store value for PatchPcd\r
140 # @var Pcd:           To store value for Pcd\r
141 # @var PcdEx:         To store value for PcdEx\r
142 # @var Depex:         To store value for Depex\r
143 # @var Nmake:         To store value for Nmake\r
144 #\r
145 class InfContents(InfObject):\r
146     def __init__(self):\r
147         self.Sources = []\r
148         self.BuildOptions = []\r
149         self.Binaries = []\r
150         self.Includes = []\r
151         self.Guids = []\r
152         self.Protocols = []\r
153         self.Ppis = []\r
154         self.Libraries = []\r
155         self.LibraryClasses = []\r
156         self.Packages = []\r
157         self.FixedPcd = []\r
158         self.PatchPcd = []\r
159         self.FeaturePcd = []\r
160         self.Pcd = []\r
161         self.PcdEx = []\r
162         self.Depex = []\r
163         self.Nmake = []\r
164 \r
165 ## Inf\r
166 #\r
167 # This class defined the structure used in Inf object\r
168\r
169 # @param InfObject:         Inherited from InfObject class\r
170 # @param Ffilename:         Input value for Ffilename of Inf file, default is None\r
171 # @param IsMergeAllArches:  Input value for IsMergeAllArches\r
172 #                           True is to merge all arches\r
173 #                           Fales is not to merge all arches\r
174 #                           default is False\r
175 # @param IsToModule:        Input value for IsToModule\r
176 #                           True is to transfer to ModuleObject automatically\r
177 #                           False is not to transfer to ModuleObject automatically\r
178 #                           default is False\r
179 # @param WorkspaceDir:      Input value for current workspace directory, default is None\r
180 #\r
181 # @var Identification:      To store value for Identification, it is a structure as Identification\r
182 # @var Defines:             To store value for Defines, it is a structure as InfDefines\r
183 # @var UserExtensions:      To store value for UserExtensions\r
184 # @var Module:              To store value for Module, it is a structure as ModuleClass\r
185 # @var WorkspaceDir:        To store value for WorkspaceDir\r
186 # @var Contents:            To store value for Contents, it is a structure as InfContents\r
187 # @var KeyList:             To store value for KeyList, a list for all Keys used in Dec\r
188 #\r
189 class Inf(InfObject):\r
190     def __init__(self, Filename = None, IsMergeAllArches = False, IsToModule = False, WorkspaceDir = None):\r
191         self.Identification = Identification()\r
192         self.Defines = {} # InfDefines()\r
193         self.Contents = {}\r
194         self.UserExtensions = ''\r
195         self.Module = ModuleClass()\r
196         self.WorkspaceDir = WorkspaceDir\r
197         self._Macro = {}    # for inf file local replacement\r
198 \r
199         for Arch in DataType.ARCH_LIST_FULL:\r
200             self.Contents[Arch] = InfContents()\r
201 \r
202         self.KeyList = [\r
203             TAB_SOURCES, TAB_BUILD_OPTIONS, TAB_BINARIES, TAB_INCLUDES, TAB_GUIDS, \r
204             TAB_PROTOCOLS, TAB_PPIS, TAB_LIBRARY_CLASSES, TAB_PACKAGES, TAB_LIBRARIES, \r
205             TAB_INF_FIXED_PCD, TAB_INF_PATCH_PCD, TAB_INF_FEATURE_PCD, TAB_INF_PCD, \r
206             TAB_INF_PCD_EX, TAB_DEPEX, TAB_NMAKE\r
207         ]\r
208 \r
209         #\r
210         # Load Inf file if filename is not None\r
211         #\r
212         if Filename != None:\r
213             self.LoadInfFile(Filename)\r
214         \r
215         #\r
216         # Merge contents of Inf from all arches if IsMergeAllArches is True\r
217         #        \r
218         if IsMergeAllArches:\r
219             self.MergeAllArches()\r
220 \r
221         #\r
222         # Transfer to Module Object if IsToModule is True\r
223         #\r
224         if IsToModule:\r
225             self.InfToModule()\r
226 \r
227     ## Merge contents of Inf from all arches\r
228     #\r
229     # Find the contents defined in all arches and merge them to all\r
230     #\r
231     def MergeAllArches(self):\r
232         if DataType.TAB_ARCH_COMMON.upper() in self.Defines:\r
233             for Arch in DataType.ARCH_LIST:\r
234                 if Arch not in self.Defines:\r
235                     self.Defines[Arch] = InfDefines()\r
236                 self.Defines[Arch].extend(self.Defines[DataType.TAB_ARCH_COMMON.upper()])\r
237                 self._Macro.update(self.Defines[Arch].DefinesDictionary[TAB_INF_DEFINES_MACRO])\r
238         self._Macro.update(GlobalData.gGlobalDefines)\r
239         # print "###",self._Macro\r
240 \r
241         if DataType.TAB_ARCH_COMMON in self.Contents:\r
242             for Key in self.KeyList:\r
243                 for Arch in DataType.ARCH_LIST:\r
244                     Command = "self.Contents[Arch]." + Key + ".extend(" + "self.Contents['" + DataType.TAB_ARCH_COMMON + "']." + Key + ")"\r
245                     eval(Command)     \r
246 \r
247     ## Parse Inf file\r
248     #\r
249     # Go through input lines one by one to find the value defined in Key section.\r
250     # Save them to KeyField\r
251     #\r
252     # @param Lines:     Lines need to be parsed\r
253     # @param Key:       The key value of the section to be located\r
254     # @param KeyField:  To save the found contents\r
255     #\r
256     def ParseInf(self, Lines, Key, KeyField):\r
257         newKey = SplitModuleType(Key)\r
258         if newKey[0].upper().find(DataType.TAB_LIBRARY_CLASSES.upper()) != -1:\r
259             GetLibraryClassesWithModuleType(Lines, Key, KeyField, TAB_COMMENT_SPLIT)\r
260         else:\r
261             GetMultipleValuesOfKeyFromLines(Lines, Key, KeyField, TAB_COMMENT_SPLIT)\r
262 \r
263     ## Convert [Defines] section content to ModuleHeaderClass\r
264     #\r
265     # Convert [Defines] section content to ModuleHeaderClass\r
266     #\r
267     # @param Defines        The content under [Defines] section\r
268     # @param ModuleHeader   An object of ModuleHeaderClass\r
269     # @param Arch           The supported ARCH\r
270     #\r
271     def DefinesToModuleHeader(self, Defines, ModuleHeader, Arch):\r
272         ModuleHeader.SupArchList.append(Arch)\r
273         # macro definitions\r
274         ModuleHeader.MacroDefines.update(Defines.DefinesDictionary[TAB_INF_DEFINES_MACRO])\r
275         ModuleHeader.MacroDefines.update(GlobalData.gGlobalDefines)\r
276         #\r
277         # Get value for Header\r
278         #\r
279         ModuleHeader.InfVersion = Defines.DefinesDictionary[TAB_INF_DEFINES_INF_VERSION][0]\r
280         # R8 modules may use macro in base name\r
281         ModuleHeader.Name = ReplaceMacro(Defines.DefinesDictionary[TAB_INF_DEFINES_BASE_NAME][0], ModuleHeader.MacroDefines)\r
282         ModuleHeader.Guid = Defines.DefinesDictionary[TAB_INF_DEFINES_FILE_GUID][0]\r
283         \r
284         ModuleHeader.FileName = self.Identification.FileName\r
285         ModuleHeader.FullPath = self.Identification.FileFullPath\r
286         File = ModuleHeader.FullPath\r
287         \r
288         ModuleHeader.EfiSpecificationVersion = Defines.DefinesDictionary[TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION][0]\r
289         ModuleHeader.EdkReleaseVersion = Defines.DefinesDictionary[TAB_INF_DEFINES_EDK_RELEASE_VERSION][0]\r
290            \r
291         ModuleHeader.ModuleType = Defines.DefinesDictionary[TAB_INF_DEFINES_MODULE_TYPE][0]\r
292         ModuleHeader.BinaryModule = Defines.DefinesDictionary[TAB_INF_DEFINES_BINARY_MODULE][0]\r
293         ModuleHeader.ComponentType = Defines.DefinesDictionary[TAB_INF_DEFINES_COMPONENT_TYPE][0]\r
294         ModuleHeader.MakefileName = Defines.DefinesDictionary[TAB_INF_DEFINES_MAKEFILE_NAME][0]\r
295         ModuleHeader.BuildNumber = Defines.DefinesDictionary[TAB_INF_DEFINES_BUILD_NUMBER][0]\r
296         ModuleHeader.BuildType = Defines.DefinesDictionary[TAB_INF_DEFINES_BUILD_TYPE][0]\r
297         ModuleHeader.FfsExt = Defines.DefinesDictionary[TAB_INF_DEFINES_FFS_EXT][0]\r
298         ModuleHeader.FvExt = Defines.DefinesDictionary[TAB_INF_DEFINES_FV_EXT][0]\r
299         ModuleHeader.SourceFv = Defines.DefinesDictionary[TAB_INF_DEFINES_SOURCE_FV][0]\r
300         ModuleHeader.PcdIsDriver = Defines.DefinesDictionary[TAB_INF_DEFINES_PCD_IS_DRIVER][0]\r
301         ModuleHeader.TianoR8FlashMap_h = Defines.DefinesDictionary[TAB_INF_DEFINES_TIANO_R8_FLASHMAP_H][0]\r
302         ModuleHeader.Shadow = Defines.DefinesDictionary[TAB_INF_DEFINES_SHADOW][0]\r
303         \r
304         #\r
305         # Get version of INF\r
306         #\r
307         if ModuleHeader.InfVersion != "":\r
308             # R9 inf\r
309             VersionNumber = Defines.DefinesDictionary[TAB_INF_DEFINES_VERSION_NUMBER][0]\r
310             VersionString = Defines.DefinesDictionary[TAB_INF_DEFINES_VERSION_STRING][0]\r
311             if len(VersionNumber) > 0 and len(VersionString) == 0:\r
312                 EdkLogger.warn(2000, 'VERSION_NUMBER depricated; INF file %s should be modified to use VERSION_STRING instead.' % self.Identification.FileFullPath)\r
313                 ModuleHeader.Version = VersionNumber\r
314             if len(VersionString) > 0:\r
315                 if len(VersionNumber) > 0:\r
316                     EdkLogger.warn(2001, 'INF file %s defines both VERSION_NUMBER and VERSION_STRING, using VERSION_STRING' % self.Identification.FileFullPath)\r
317                 ModuleHeader.Version = VersionString\r
318         else:\r
319             # R8 inf\r
320             ModuleHeader.InfVersion = "0x00010000"\r
321             VersionNumber = Defines.DefinesDictionary[TAB_INF_DEFINES_VERSION][0]\r
322             VersionString = Defines.DefinesDictionary[TAB_INF_DEFINES_VERSION_STRING][0]\r
323             if VersionString == '' and VersionNumber != '':\r
324                 VersionString = VersionNumber\r
325             if ModuleHeader.ComponentType in gComponentType2ModuleType:\r
326                 ModuleHeader.ModuleType = gComponentType2ModuleType[ModuleHeader.ComponentType]\r
327             elif ModuleHeader.ComponentType != '':\r
328                 EdkLogger.error("Parser", PARSER_ERROR, "Unsupported R8 component type [%s]" % ModuleHeader.ComponentType,\r
329                                 ExtraData=File)\r
330         #\r
331         # LibraryClass of Defines\r
332         #\r
333         if Defines.DefinesDictionary[TAB_INF_DEFINES_LIBRARY_CLASS][0] != '':\r
334             for Item in Defines.DefinesDictionary[TAB_INF_DEFINES_LIBRARY_CLASS]:\r
335                 List = GetSplitValueList(Item, DataType.TAB_VALUE_SPLIT, 1)\r
336                 Lib = LibraryClassClass()\r
337                 Lib.LibraryClass = CleanString(List[0])\r
338                 if len(List) == 1:\r
339                     Lib.SupModuleList = DataType.SUP_MODULE_LIST\r
340                 elif len(List) == 2:\r
341                     Lib.SupModuleList = GetSplitValueList(CleanString(List[1]), ' ')\r
342                 ModuleHeader.LibraryClass.append(Lib)\r
343         elif ModuleHeader.ComponentType == "LIBRARY":\r
344             Lib = LibraryClassClass()\r
345             Lib.LibraryClass = ModuleHeader.Name\r
346             Lib.SupModuleList = DataType.SUP_MODULE_LIST\r
347             ModuleHeader.LibraryClass.append(Lib)\r
348         \r
349         #\r
350         # Custom makefile of Defines\r
351         #\r
352         if Defines.DefinesDictionary[TAB_INF_DEFINES_CUSTOM_MAKEFILE][0] != '':\r
353             for Item in Defines.DefinesDictionary[TAB_INF_DEFINES_CUSTOM_MAKEFILE]:\r
354                 List = Item.split(DataType.TAB_VALUE_SPLIT)\r
355                 if len(List) == 2:\r
356                     ModuleHeader.CustomMakefile[CleanString(List[0])] = CleanString(List[1])\r
357                 else:\r
358                     RaiseParserError(Item, 'CUSTOM_MAKEFILE of Defines', File, 'CUSTOM_MAKEFILE=<Family>|<Filename>')\r
359         \r
360         #\r
361         # EntryPoint and UnloadImage of Defines\r
362         #\r
363         if Defines.DefinesDictionary[TAB_INF_DEFINES_ENTRY_POINT][0] != '':\r
364             for Item in Defines.DefinesDictionary[TAB_INF_DEFINES_ENTRY_POINT]:\r
365                 Image = ModuleExternImageClass()\r
366                 Image.ModuleEntryPoint = CleanString(Item)\r
367                 self.Module.ExternImages.append(Image)\r
368         if Defines.DefinesDictionary[TAB_INF_DEFINES_UNLOAD_IMAGE][0] != '':\r
369             for Item in Defines.DefinesDictionary[TAB_INF_DEFINES_UNLOAD_IMAGE]:\r
370                 Image = ModuleExternImageClass()\r
371                 Image.ModuleUnloadImage = CleanString(Item)\r
372                 self.Module.ExternImages.append(Image)\r
373         \r
374         #\r
375         # Constructor and Destructor of Defines\r
376         #\r
377         if Defines.DefinesDictionary[TAB_INF_DEFINES_CONSTRUCTOR][0] != '':\r
378             for Item in Defines.DefinesDictionary[TAB_INF_DEFINES_CONSTRUCTOR]:\r
379                 LibraryClass = ModuleExternLibraryClass()\r
380                 LibraryClass.Constructor = CleanString(Item)\r
381                 self.Module.ExternLibraries.append(LibraryClass)\r
382         if Defines.DefinesDictionary[TAB_INF_DEFINES_DESTRUCTOR][0] != '':\r
383             for Item in Defines.DefinesDictionary[TAB_INF_DEFINES_DESTRUCTOR]:\r
384                 LibraryClass = ModuleExternLibraryClass()\r
385                 LibraryClass.Destructor = CleanString(Item)\r
386                 self.Module.ExternLibraries.append(LibraryClass)\r
387         \r
388         #\r
389         # Define of Defines\r
390         #\r
391         if Defines.DefinesDictionary[TAB_INF_DEFINES_DEFINE][0] != '':\r
392             for Item in Defines.DefinesDictionary[TAB_INF_DEFINES_DEFINE]:\r
393                 List = Item.split(DataType.TAB_EQUAL_SPLIT)\r
394                 if len(List) != 2:\r
395                     RaiseParserError(Item, 'DEFINE of Defines', File, 'DEFINE <Word> = <Word>')\r
396                 else:\r
397                     ModuleHeader.Define[CleanString(List[0])] = CleanString(List[1])\r
398         \r
399         #\r
400         # Spec\r
401         #\r
402         if Defines.DefinesDictionary[TAB_INF_DEFINES_SPEC][0] != '':\r
403             for Item in Defines.DefinesDictionary[TAB_INF_DEFINES_SPEC]:\r
404                 List = Item.split(DataType.TAB_EQUAL_SPLIT)\r
405                 if len(List) != 2:\r
406                     RaiseParserError(Item, 'SPEC of Defines', File, 'SPEC <Word> = <Version>')\r
407                 else:\r
408                     ModuleHeader.Specification[CleanString(List[0])] = CleanString(List[1])\r
409                 \r
410 \r
411     ## Transfer to Module Object\r
412     # \r
413     # Transfer all contents of an Inf file to a standard Module Object\r
414     #\r
415     def InfToModule(self):\r
416         File = self.Identification.FileFullPath\r
417         for Arch in DataType.ARCH_LIST:\r
418             if Arch not in self.Defines:\r
419                 continue\r
420             ModuleHeader = ModuleHeaderClass()\r
421             self.DefinesToModuleHeader(self.Defines[Arch], ModuleHeader, Arch)\r
422             self.Module.Header[Arch] = ModuleHeader\r
423         #\r
424         # BuildOptions\r
425         # [<Family>:]<ToolFlag>=Flag\r
426         #\r
427         BuildOptions = {}\r
428         for Arch in DataType.ARCH_LIST:\r
429             for Item in self.Contents[Arch].BuildOptions:\r
430                 MergeArches(BuildOptions, GetBuildOption(Item, File), Arch)\r
431         for Key in BuildOptions.keys():\r
432             BuildOption = BuildOptionClass(Key[0], Key[1], Key[2])\r
433             BuildOption.SupArchList = BuildOptions[Key]\r
434             self.Module.BuildOptions.append(BuildOption)    \r
435         \r
436         #\r
437         # Includes\r
438         #\r
439         Includes = sdict()\r
440         for Arch in DataType.ARCH_LIST:\r
441             for Item in self.Contents[Arch].Includes:\r
442                 MergeArches(Includes, Item, Arch)\r
443         for Key in Includes.keys():\r
444             Include = IncludeClass()\r
445             Include.FilePath = NormPath(Key, self._Macro)\r
446             Include.SupArchList = Includes[Key]\r
447             self.Module.Includes.append(Include)\r
448         \r
449         #\r
450         # Libraries\r
451         #\r
452         Libraries = sdict()\r
453         for Arch in DataType.ARCH_LIST:\r
454             for Item in self.Contents[Arch].Libraries:\r
455                 MergeArches(Libraries, Item, Arch)\r
456         for Key in Libraries.keys():\r
457             Library = ModuleLibraryClass()\r
458             # replace macro and remove file extension\r
459             Library.Library = ReplaceMacro(Key, self._Macro).rsplit('.', 1)[0]\r
460             Library.SupArchList = Libraries[Key]\r
461             self.Module.Libraries.append(Library)\r
462         \r
463         #\r
464         # LibraryClasses\r
465         # LibraryClass[|<LibraryClassInstanceFilename>[|<TokenSpaceGuidCName>.<PcdCName>]]\r
466         #\r
467         LibraryClasses = {}\r
468         Defines = {}\r
469         for Arch in DataType.ARCH_LIST:\r
470             for Item in self.Contents[Arch].LibraryClasses:\r
471                 Status = GenDefines(Item[0], Arch, Defines)\r
472                 #\r
473                 # Find DEFINE statement\r
474                 #\r
475                 if Status == 0:\r
476                     pass\r
477                 #\r
478                 # Find DEFINE statement but in wrong format\r
479                 #\r
480                 elif Status == -1:\r
481                     RaiseParserError(Item[0], 'LibraryClasses', File, 'DEFINE <VarName> = <PATH>')\r
482                 #\r
483                 # Not find DEFINE statement\r
484                 #\r
485                 elif Status == 1:\r
486                     #\r
487                     # { (LibraryClass, Instance, PcdFeatureFlag, ModuleType1|ModuleType2|ModuleType3) : [Arch1, Arch2, ...] }\r
488                     #\r
489                     ItemList = GetSplitValueList((Item[0] + DataType.TAB_VALUE_SPLIT * 2))\r
490                     CheckFileType(ItemList[1], '.Inf', File, 'LibraryClasses', Item[0])\r
491                     CheckFileExist(self.WorkspaceDir, ItemList[1], File, 'LibraryClasses', Item[0])\r
492                     CheckPcdTokenInfo(ItemList[2], 'LibraryClasses', File)\r
493                     MergeArches(LibraryClasses, (ItemList[0], ItemList[1], ItemList[2], DataType.TAB_VALUE_SPLIT.join(Item[1])), Arch)\r
494         for Key in LibraryClasses.keys():\r
495             KeyList = Key[0].split(DataType.TAB_VALUE_SPLIT)\r
496             LibraryClass = LibraryClassClass()\r
497             LibraryClass.Define = Defines\r
498             LibraryClass.LibraryClass = Key[0]\r
499             LibraryClass.RecommendedInstance = NormPath(Key[1], self._Macro)\r
500             LibraryClass.FeatureFlag = Key[2]\r
501             LibraryClass.SupArchList = LibraryClasses[Key]\r
502             if Key[3] != '':\r
503                 LibraryClass.SupModuleList = GetSplitValueList(Key[3])\r
504             else:\r
505                 LibraryClass.SupModuleList = DataType.SUP_MODULE_LIST\r
506             self.Module.LibraryClasses.append(LibraryClass)\r
507         \r
508         #\r
509         # Packages\r
510         #\r
511         Packages = {}\r
512         Defines = {}\r
513         for Arch in DataType.ARCH_LIST:\r
514             for Item in self.Contents[Arch].Packages:\r
515                 Status = GenDefines(Item, Arch, Defines)\r
516                 #\r
517                 # Find DEFINE statement\r
518                 #\r
519                 if Status == 0:\r
520                     pass\r
521                 #\r
522                 # Find DEFINE statement but in wrong format\r
523                 #\r
524                 elif Status == -1:\r
525                     RaiseParserError(Item[0], 'Packages', File, 'DEFINE <VarName> = <PATH>')\r
526                 #\r
527                 # Not find DEFINE statement\r
528                 #\r
529                 elif Status == 1:\r
530                     CheckFileType(Item, '.Dec', File, 'package', Item)\r
531                     CheckFileExist(self.WorkspaceDir, Item, File, 'Packages', Item)\r
532                     MergeArches(Packages, Item, Arch)\r
533         for Key in Packages.keys():\r
534             Package = ModulePackageDependencyClass()\r
535             Package.Define = Defines\r
536             Package.FilePath = NormPath(Key, self._Macro)\r
537             Package.SupArchList = Packages[Key]\r
538             self.Module.PackageDependencies.append(Package)\r
539             \r
540         #\r
541         # Nmake\r
542         #\r
543         Nmakes = sdict()\r
544         for Arch in DataType.ARCH_LIST:\r
545             for Item in self.Contents[Arch].Nmake:\r
546                 MergeArches(Nmakes, Item, Arch)\r
547         for Key in Nmakes.keys():\r
548             List = GetSplitValueList(Key, DataType.TAB_EQUAL_SPLIT, MaxSplit=1)\r
549             if len(List) != 2:\r
550                 RaiseParserError(Item[0], 'Nmake', File, '<MacroName> = <Value>')\r
551             Nmake = ModuleNmakeClass()\r
552             Nmake.Name = List[0]\r
553             Nmake.Value = List[1]\r
554             Nmake.SupArchList = Nmakes[Key]\r
555             self.Module.Nmake.append(Nmake)\r
556 \r
557             # convert R8 format to R9 format\r
558             if Nmake.Name == "IMAGE_ENTRY_POINT":\r
559                 Image = ModuleExternImageClass()\r
560                 Image.ModuleEntryPoint = Nmake.Value\r
561                 self.Module.ExternImages.append(Image)\r
562             elif Nmake.Name == "DPX_SOURCE":\r
563                 Source = ModuleSourceFileClass(NormPath(Nmake.Value, self._Macro), "", "", "", "", Nmake.SupArchList)\r
564                 self.Module.Sources.append(Source)\r
565             else:\r
566                 ToolList = gNmakeFlagPattern.findall(Nmake.Name)\r
567                 if len(ToolList) == 0 or len(ToolList) != 1:\r
568                     EdkLogger.warn("\nParser", "Don't know how to do with MACRO: %s" % Nmake.Name, \r
569                                    ExtraData=File)\r
570                 else:\r
571                     if ToolList[0] in gNmakeFlagName2ToolCode:\r
572                         Tool = gNmakeFlagName2ToolCode[ToolList[0]]\r
573                     else:\r
574                         Tool = ToolList[0]\r
575                     BuildOption = BuildOptionClass("MSFT", "*_*_*_%s_FLAGS" % Tool, Nmake.Value)\r
576                     BuildOption.SupArchList = Nmake.SupArchList\r
577                     self.Module.BuildOptions.append(BuildOption)\r
578         \r
579         #\r
580         # Pcds\r
581         # <TokenSpaceGuidCName>.<PcdCName>[|<Value>]\r
582         #\r
583         Pcds = {}\r
584         for Arch in DataType.ARCH_LIST:\r
585             for Item in self.Contents[Arch].FixedPcd:\r
586                 #\r
587                 # Library should not have FixedPcd\r
588                 #\r
589                 if self.Module.Header[Arch].LibraryClass != {}:\r
590                     pass\r
591                 MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_FIXED_AT_BUILD, File), Arch)\r
592             \r
593             for Item in self.Contents[Arch].PatchPcd:\r
594                 MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_PATCHABLE_IN_MODULE, File), Arch)\r
595             \r
596             for Item in self.Contents[Arch].FeaturePcd:\r
597                 MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_FEATURE_FLAG, File), Arch)\r
598             \r
599             for Item in self.Contents[Arch].PcdEx:\r
600                 MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_DYNAMIC_EX, File), Arch)\r
601             \r
602             for Item in self.Contents[Arch].Pcd:\r
603                 MergeArches(Pcds, self.GetPcdOfInf(Item, "", File), Arch)\r
604                 #MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_DYNAMIC_EX, File), Arch)\r
605                 #MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_FEATURE_FLAG, File), Arch)\r
606                 #MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_FIXED_AT_BUILD, File), Arch)\r
607                 #MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_PATCHABLE_IN_MODULE, File), Arch)\r
608                 \r
609         for Key in Pcds.keys():\r
610             Pcd = PcdClass()\r
611             Pcd.CName = Key[1]\r
612             Pcd.TokenSpaceGuidCName = Key[0]\r
613             Pcd.DefaultValue = Key[2]\r
614             Pcd.ItemType = Key[3]\r
615             Pcd.SupArchList = Pcds[Key]\r
616             self.Module.PcdCodes.append(Pcd)\r
617         \r
618         #\r
619         # Sources\r
620         # <Filename>[|<Family>[|<TagName>[|<ToolCode>[|<PcdFeatureFlag>]]]]\r
621         #\r
622         Sources = {}\r
623         for Arch in DataType.ARCH_LIST:\r
624             for Item in self.Contents[Arch].Sources:\r
625                 ItemNew = Item + DataType.TAB_VALUE_SPLIT * 4\r
626                 List = GetSplitValueList(ItemNew)\r
627                 if len(List) < 5 or len(List) > 9:\r
628                     RaiseParserError(Item, 'Sources', File, '<Filename>[|<Family>[|<TagName>[|<ToolCode>[|<PcdFeatureFlag>]]]]')\r
629                 List[0] = NormPath(List[0], self._Macro)\r
630                 CheckFileExist(self.Identification.FileRelativePath, List[0], File, 'Sources', Item)\r
631                 CheckPcdTokenInfo(List[4], 'Sources', File)\r
632                 MergeArches(Sources, (List[0], List[1], List[2], List[3], List[4]), Arch)\r
633         for Key in Sources.keys():\r
634             Source = ModuleSourceFileClass(Key[0], Key[2], Key[3], Key[1], Key[4], Sources[Key])\r
635             self.Module.Sources.append(Source)\r
636 \r
637         #\r
638         # UserExtensions\r
639         #\r
640         if self.UserExtensions != '':\r
641             UserExtension = UserExtensionsClass()\r
642             Lines = self.UserExtensions.splitlines()\r
643             List = GetSplitValueList(Lines[0], DataType.TAB_SPLIT, 2)\r
644             if len(List) != 3:\r
645                 RaiseParserError(Lines[0], 'UserExtensions', File, "UserExtensions.UserId.'Identifier'")\r
646             else:\r
647                 UserExtension.UserID = List[1]\r
648                 UserExtension.Identifier = List[2][0:-1].replace("'", '').replace('\"', '')\r
649                 for Line in Lines[1:]:\r
650                     UserExtension.Content = UserExtension.Content + CleanString(Line) + '\n'\r
651             self.Module.UserExtensions.append(UserExtension)\r
652         \r
653         #\r
654         # Guids\r
655         #\r
656         Guids = {}\r
657         for Arch in DataType.ARCH_LIST:\r
658             for Item in self.Contents[Arch].Guids:\r
659                 MergeArches(Guids, Item, Arch)\r
660         for Key in Guids.keys():\r
661             Guid = GuidClass()\r
662             Guid.CName = Key\r
663             Guid.SupArchList = Guids[Key]\r
664             self.Module.Guids.append(Guid)\r
665 \r
666         #\r
667         # Protocols\r
668         #\r
669         Protocols = {}\r
670         for Arch in DataType.ARCH_LIST:\r
671             for Item in self.Contents[Arch].Protocols:\r
672                 MergeArches(Protocols, Item, Arch)\r
673         for Key in Protocols.keys():\r
674             Protocol = ProtocolClass()\r
675             Protocol.CName = Key\r
676             Protocol.SupArchList = Protocols[Key]\r
677             self.Module.Protocols.append(Protocol)\r
678         \r
679         #\r
680         # Ppis\r
681         #\r
682         Ppis = {}\r
683         for Arch in DataType.ARCH_LIST:\r
684             for Item in self.Contents[Arch].Ppis:\r
685                 MergeArches(Ppis, Item, Arch)\r
686         for Key in Ppis.keys():\r
687             Ppi = PpiClass()\r
688             Ppi.CName = Key\r
689             Ppi.SupArchList = Ppis[Key]\r
690             self.Module.Ppis.append(Ppi)\r
691         \r
692         #\r
693         # Depex\r
694         #\r
695         Depex = {}\r
696         Defines = {}\r
697         for Arch in DataType.ARCH_LIST:\r
698             Line = ''\r
699             for Item in self.Contents[Arch].Depex:\r
700                 Status = GenDefines(Item, Arch, Defines)\r
701                 #\r
702                 # Find DEFINE statement\r
703                 #\r
704                 if Status == 0:\r
705                     pass\r
706                 #\r
707                 # Find DEFINE statement but in wrong format\r
708                 #\r
709                 elif Status == -1:\r
710                     RaiseParserError(Item, 'Depex', File, 'DEFINE <VarName> = <PATH>')\r
711                 #\r
712                 # Not find DEFINE statement\r
713                 #\r
714                 elif Status == 1:\r
715                     Line = Line + Item + ' '\r
716             MergeArches(Depex, Line, Arch)\r
717         for Key in Depex.keys():\r
718             Dep = ModuleDepexClass()\r
719             Dep.Depex = Key\r
720             Dep.SupArchList = Depex[Key]\r
721             Dep.Define = Defines\r
722             self.Module.Depex.append(Dep)\r
723         \r
724         #\r
725         # Binaries\r
726         # <FileType>|<Filename>|<Target>[|<TokenSpaceGuidCName>.<PcdCName>]\r
727         #\r
728         Binaries = {}\r
729         for Arch in DataType.ARCH_LIST:\r
730             for Item in self.Contents[Arch].Binaries:\r
731                 ItemNew = Item + DataType.TAB_VALUE_SPLIT\r
732                 List = GetSplitValueList(ItemNew)\r
733                 if len(List) != 4 and len(List) != 5:\r
734                     RaiseParserError(Item, 'Binaries', File, "<FileType>|<Filename>|<Target>[|<TokenSpaceGuidCName>.<PcdCName>]")\r
735                 else:\r
736                     CheckPcdTokenInfo(List[3], 'Binaries', File)\r
737                     MergeArches(Binaries, (List[0], List[1], List[2], List[3]), Arch)\r
738         for Key in Binaries.keys():\r
739             Binary = ModuleBinaryFileClass(NormPath(Key[1], self._Macro), Key[0], Key[2], Key[3], Binaries[Key])\r
740             self.Module.Binaries.append(Binary)\r
741         \r
742     ## Get Pcd Values of Inf\r
743     #\r
744     # Get Pcd of Inf as <TokenSpaceGuidCName>.<PcdCName>[|<Value>]\r
745     #\r
746     # @param Item:  The string describes pcd\r
747     # @param Type:  The type of Pcd\r
748     # @param File:  The file which describes the pcd, used for error report\r
749     #\r
750     # @retval (TokenSpcCName, TokenCName, Value, ItemType) Formatted Pcd Item\r
751     #\r
752     def GetPcdOfInf(self, Item, Type, File):\r
753         Format = '<TokenSpaceGuidCName>.<PcdCName>[|<Value>]'\r
754         InfType = ''\r
755         if Type == TAB_PCDS_FIXED_AT_BUILD:\r
756             InfType = TAB_INF_FIXED_PCD\r
757         elif Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
758             InfType = TAB_INF_PATCH_PCD\r
759         elif Type == TAB_PCDS_FEATURE_FLAG:\r
760             InfType = TAB_INF_FEATURE_PCD        \r
761         elif Type == TAB_PCDS_DYNAMIC_EX:\r
762             InfType = TAB_INF_PCD_EX        \r
763         elif Type == TAB_PCDS_DYNAMIC:\r
764             InfType = TAB_INF_PCD\r
765         List = GetSplitValueList(Item + DataType.TAB_VALUE_SPLIT)\r
766         if len(List) < 2 or len(List) > 3:\r
767             RaiseParserError(Item, InfType, File, Format)\r
768         TokenInfo = GetSplitValueList(List[0], DataType.TAB_SPLIT)\r
769         if len(TokenInfo) != 2:\r
770             RaiseParserError(Item, InfType, File, Format)\r
771         if len(List) == 3 and List[1] == '':\r
772             #\r
773             # Value is empty\r
774             #\r
775             RaiseParserError(Item, 'Pcds' + Type, File, Format)\r
776 \r
777         return (TokenInfo[0], TokenInfo[1], List[1], Type)\r
778 \r
779     ## Parse [Defines] section\r
780     #\r
781     # Parse [Defines] section into InfDefines object\r
782     #\r
783     # @param InfFile    The path of the INF file\r
784     # @param Section    The title of "Defines" section\r
785     # @param Lines      The content of "Defines" section\r
786     #\r
787     def ParseDefines(self, InfFile, Section, Lines):\r
788         TokenList = Section.split(TAB_SPLIT)\r
789         if len(TokenList) == 3:\r
790             RaiseParserError(Section, "Defines", InfFile, "[xx.yy.%s] format (with platform) is not supported")\r
791         if len(TokenList) == 2:\r
792             Arch = TokenList[1].upper()\r
793         else:\r
794             Arch = TAB_ARCH_COMMON.upper()\r
795 \r
796         if Arch not in self.Defines:\r
797             self.Defines[Arch] = InfDefines()\r
798         GetSingleValueOfKeyFromLines(Lines, self.Defines[Arch].DefinesDictionary, \r
799                                      TAB_COMMENT_SPLIT, TAB_EQUAL_SPLIT, False, None)\r
800 \r
801     ## Load Inf file\r
802     #\r
803     # Load the file if it exists\r
804     #\r
805     # @param Filename:  Input value for filename of Inf file\r
806     #\r
807     def LoadInfFile(self, Filename):     \r
808         (Filepath, Name) = os.path.split(Filename)\r
809         self.Identification.FileName = Name\r
810         self.Identification.FileFullPath = Filename\r
811         self.Identification.FileRelativePath = Filepath\r
812         \r
813         F = open(Filename, 'r').read()\r
814         F = PreCheck(Filename, F, self.KeyList)\r
815         Sects = F.split(DataType.TAB_SECTION_START)\r
816         for Sect in Sects:\r
817             TabList = GetSplitValueList(Sect.split(TAB_SECTION_END, 1)[0], DataType.TAB_COMMA_SPLIT)\r
818             for Tab in TabList:\r
819                 if Tab.upper().find(TAB_INF_DEFINES.upper()) > -1:\r
820                     self.ParseDefines(Filename, Tab, Sect)\r
821                     continue\r
822                 if Tab.upper().find(DataType.TAB_USER_EXTENSIONS.upper()) > -1:\r
823                     self.UserExtensions = Sect\r
824                     continue\r
825                 for Arch in DataType.ARCH_LIST_FULL + [DataType.TAB_ARCH_NULL, "PLATFORM"]:\r
826                     for Key in self.KeyList:\r
827                         if Arch != DataType.TAB_ARCH_NULL:\r
828                             Target = (Key + DataType.TAB_SPLIT + Arch).upper()\r
829                         else:\r
830                             Target = Key.upper()\r
831                         if SplitModuleType(Tab)[0].upper() == Target:\r
832                             if Arch != DataType.TAB_ARCH_NULL and Arch != "PLATFORM":\r
833                                 Command = 'self.ParseInf(Sect, Tab, self.Contents[Arch].' + Key + ')'\r
834                                 eval(Command)\r
835                                 continue\r
836                             else:\r
837                                 Command = "self.ParseInf(Sect, Tab, self.Contents['" + DataType.TAB_ARCH_COMMON + "']." + Key + ')'\r
838                                 eval(Command)\r
839                                 continue\r
840             #EndFor\r
841 \r
842     ## Show detailed information of Inf\r
843     #\r
844     # Print all members and their values of Inf class\r
845     #\r
846     def ShowInf(self):\r
847         print TAB_SECTION_START + TAB_INF_DEFINES + TAB_SECTION_END\r
848         printDict(self.Defines.DefinesDictionary)\r
849 \r
850         for key in self.KeyList:\r
851             for arch in DataType.ARCH_LIST_FULL:\r
852                 Command = "printList(TAB_SECTION_START + '" + \\r
853                           key + DataType.TAB_SPLIT + arch + \\r
854                           "' + TAB_SECTION_END, self.Contents[arch]." + key + ')'\r
855                 eval(Command)\r
856         print ""\r
857     \r
858     ## Show detailed information of Module\r
859     #\r
860     # Print all members and their values of Module class\r
861     #\r
862     def ShowModule(self):\r
863         M = self.Module\r
864         print 'Filename =', M.Header.FileName\r
865         print 'FullPath =', M.Header.FullPath\r
866         print 'BaseName =', M.Header.Name\r
867         print 'Guid =', M.Header.Guid\r
868         print 'Version =', M.Header.Version\r
869         print 'InfVersion =', M.Header.InfVersion\r
870         print 'EfiSpecificationVersion =', M.Header.EfiSpecificationVersion\r
871         print 'EdkReleaseVersion =', M.Header.EdkReleaseVersion                \r
872         print 'ModuleType =', M.Header.ModuleType\r
873         print 'BinaryModule =', M.Header.BinaryModule\r
874         print 'ComponentType =', M.Header.ComponentType\r
875         print 'MakefileName =', M.Header.MakefileName\r
876         print 'BuildNumber =', M.Header.BuildNumber\r
877         print 'BuildType =', M.Header.BuildType\r
878         print 'FfsExt =', M.Header.FfsExt\r
879         print 'FvExt =', M.Header.FvExt\r
880         print 'SourceFv =', M.Header.SourceFv\r
881         print 'PcdIsDriver =', M.Header.PcdIsDriver\r
882         print 'TianoR8FlashMap_h =', M.Header.TianoR8FlashMap_h\r
883         print 'Shadow =', M.Header.Shadow\r
884         print 'LibraryClass =', M.Header.LibraryClass\r
885         for Item in M.Header.LibraryClass:\r
886             print Item.LibraryClass, DataType.TAB_VALUE_SPLIT.join(Item.SupModuleList)\r
887         print 'CustomMakefile =', M.Header.CustomMakefile\r
888         for Item in self.Module.ExternImages:\r
889             print 'Entry_Point = %s, UnloadImage = %s' % (Item.ModuleEntryPoint, Item.ModuleUnloadImage)\r
890         for Item in self.Module.ExternLibraries:\r
891             print 'Constructor = %s, Destructor = %s' % (Item.Constructor, Item.Destructor)\r
892         print 'Define =', M.Header.Define\r
893         print 'Specification =', M.Header.Specification\r
894         print '\nBuildOptions =', M.BuildOptions\r
895         for Item in M.BuildOptions:\r
896             print Item.ToolChainFamily, Item.ToolChain, Item.Option, Item.SupArchList\r
897         print '\nIncludes =', M.Includes\r
898         for Item in M.Includes:\r
899             print Item.FilePath, Item.SupArchList\r
900         print '\nLibraries =', M.Libraries\r
901         for Item in M.Libraries:\r
902             print Item.Library, Item.SupArchList\r
903         print '\nLibraryClasses =', M.LibraryClasses\r
904         for Item in M.LibraryClasses:\r
905             print Item.LibraryClass, Item.RecommendedInstance, Item.FeatureFlag, Item.SupModuleList, Item.SupArchList, Item.Define\r
906         print '\nPackageDependencies =', M.PackageDependencies\r
907         for Item in M.PackageDependencies:\r
908             print Item.FilePath, Item.SupArchList, Item.Define\r
909         print '\nNmake =', M.Nmake\r
910         for Item in M.Nmake:\r
911             print Item.Name, Item.Value, Item.SupArchList\r
912         print '\nPcds =', M.PcdCodes\r
913         for Item in M.PcdCodes:\r
914             print '\tCName=',Item.CName, 'TokenSpaceGuidCName=', Item.TokenSpaceGuidCName, 'DefaultValue=', Item.DefaultValue, 'ItemType=', Item.ItemType, Item.SupArchList\r
915         print '\nSources =', M.Sources\r
916         for Source in M.Sources:\r
917             print Source.SourceFile, 'Fam=', Source.ToolChainFamily, 'Pcd=', Source.FeatureFlag, 'Tag=', Source.TagName, 'ToolCode=', Source.ToolCode, Source.SupArchList\r
918         print '\nUserExtensions =', M.UserExtensions\r
919         for UserExtension in M.UserExtensions:\r
920             print UserExtension.UserID, UserExtension.Identifier,UserExtension.Content\r
921         print '\nGuids =', M.Guids\r
922         for Item in M.Guids:\r
923             print Item.CName, Item.SupArchList\r
924         print '\nProtocols =', M.Protocols\r
925         for Item in M.Protocols:\r
926             print Item.CName, Item.SupArchList\r
927         print '\nPpis =', M.Ppis\r
928         for Item in M.Ppis:\r
929             print Item.CName, Item.SupArchList\r
930         print '\nDepex =', M.Depex\r
931         for Item in M.Depex:\r
932             print Item.Depex, Item.SupArchList, Item.Define\r
933         print '\nBinaries =', M.Binaries\r
934         for Binary in M.Binaries:\r
935             print 'Type=', Binary.FileType, 'Target=', Binary.Target, 'Name=', Binary.BinaryFile, 'FeatureFlag=', Binary.FeatureFlag, 'SupArchList=', Binary.SupArchList\r
936 \r
937 ##\r
938 #\r
939 # This acts like the main() function for the script, unless it is 'import'ed into another\r
940 # script.\r
941 #\r
942 if __name__ == '__main__':\r
943     import sys\r
944     print os.path.abspath(sys.argv[1])\r
945     P = Inf(os.path.abspath(sys.argv[1]), True, True, os.getenv('WORKSPACE'))\r
946     P.ShowModule()\r