a74a3df94930760d04468cb89b5ab296b18d0c13
[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(self.Defines) 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             ModuleHeader = ModuleHeaderClass()\r
419             self.DefinesToModuleHeader(self.Defines[Arch], ModuleHeader, Arch)\r
420             self.Module.Header[Arch] = ModuleHeader\r
421         #\r
422         # BuildOptions\r
423         # [<Family>:]<ToolFlag>=Flag\r
424         #\r
425         BuildOptions = {}\r
426         for Arch in DataType.ARCH_LIST:\r
427             for Item in self.Contents[Arch].BuildOptions:\r
428                 MergeArches(BuildOptions, GetBuildOption(Item, File), Arch)\r
429         for Key in BuildOptions.keys():\r
430             BuildOption = BuildOptionClass(Key[0], Key[1], Key[2])\r
431             BuildOption.SupArchList = BuildOptions[Key]\r
432             self.Module.BuildOptions.append(BuildOption)    \r
433         \r
434         #\r
435         # Includes\r
436         #\r
437         Includes = sdict()\r
438         for Arch in DataType.ARCH_LIST:\r
439             for Item in self.Contents[Arch].Includes:\r
440                 MergeArches(Includes, Item, Arch)\r
441         for Key in Includes.keys():\r
442             Include = IncludeClass()\r
443             Include.FilePath = NormPath(Key, self._Macro)\r
444             Include.SupArchList = Includes[Key]\r
445             self.Module.Includes.append(Include)\r
446         \r
447         #\r
448         # Libraries\r
449         #\r
450         Libraries = sdict()\r
451         for Arch in DataType.ARCH_LIST:\r
452             for Item in self.Contents[Arch].Libraries:\r
453                 MergeArches(Libraries, Item, Arch)\r
454         for Key in Libraries.keys():\r
455             Library = ModuleLibraryClass()\r
456             # replace macro and remove file extension\r
457             Library.Library = ReplaceMacro(Key, self._Macro).rsplit('.', 1)[0]\r
458             Library.SupArchList = Libraries[Key]\r
459             self.Module.Libraries.append(Library)\r
460         \r
461         #\r
462         # LibraryClasses\r
463         # LibraryClass[|<LibraryClassInstanceFilename>[|<TokenSpaceGuidCName>.<PcdCName>]]\r
464         #\r
465         LibraryClasses = {}\r
466         Defines = {}\r
467         for Arch in DataType.ARCH_LIST:\r
468             for Item in self.Contents[Arch].LibraryClasses:\r
469                 Status = GenDefines(Item[0], Arch, Defines)\r
470                 #\r
471                 # Find DEFINE statement\r
472                 #\r
473                 if Status == 0:\r
474                     pass\r
475                 #\r
476                 # Find DEFINE statement but in wrong format\r
477                 #\r
478                 elif Status == -1:\r
479                     RaiseParserError(Item[0], 'LibraryClasses', File, 'DEFINE <VarName> = <PATH>')\r
480                 #\r
481                 # Not find DEFINE statement\r
482                 #\r
483                 elif Status == 1:\r
484                     #\r
485                     # { (LibraryClass, Instance, PcdFeatureFlag, ModuleType1|ModuleType2|ModuleType3) : [Arch1, Arch2, ...] }\r
486                     #\r
487                     ItemList = GetSplitValueList((Item[0] + DataType.TAB_VALUE_SPLIT * 2))\r
488                     CheckFileType(ItemList[1], '.Inf', File, 'LibraryClasses', Item[0])\r
489                     CheckFileExist(self.WorkspaceDir, ItemList[1], File, 'LibraryClasses', Item[0])\r
490                     CheckPcdTokenInfo(ItemList[2], 'LibraryClasses', File)\r
491                     MergeArches(LibraryClasses, (ItemList[0], ItemList[1], ItemList[2], DataType.TAB_VALUE_SPLIT.join(Item[1])), Arch)\r
492         for Key in LibraryClasses.keys():\r
493             KeyList = Key[0].split(DataType.TAB_VALUE_SPLIT)\r
494             LibraryClass = LibraryClassClass()\r
495             LibraryClass.Define = Defines\r
496             LibraryClass.LibraryClass = Key[0]\r
497             LibraryClass.RecommendedInstance = NormPath(Key[1], self._Macro)\r
498             LibraryClass.FeatureFlag = Key[2]\r
499             LibraryClass.SupArchList = LibraryClasses[Key]\r
500             if Key[3] != '':\r
501                 LibraryClass.SupModuleList = GetSplitValueList(Key[3])\r
502             else:\r
503                 LibraryClass.SupModuleList = DataType.SUP_MODULE_LIST\r
504             self.Module.LibraryClasses.append(LibraryClass)\r
505         \r
506         #\r
507         # Packages\r
508         #\r
509         Packages = {}\r
510         Defines = {}\r
511         for Arch in DataType.ARCH_LIST:\r
512             for Item in self.Contents[Arch].Packages:\r
513                 Status = GenDefines(Item, Arch, Defines)\r
514                 #\r
515                 # Find DEFINE statement\r
516                 #\r
517                 if Status == 0:\r
518                     pass\r
519                 #\r
520                 # Find DEFINE statement but in wrong format\r
521                 #\r
522                 elif Status == -1:\r
523                     RaiseParserError(Item[0], 'Packages', File, 'DEFINE <VarName> = <PATH>')\r
524                 #\r
525                 # Not find DEFINE statement\r
526                 #\r
527                 elif Status == 1:\r
528                     CheckFileType(Item, '.Dec', File, 'package', Item)\r
529                     CheckFileExist(self.WorkspaceDir, Item, File, 'Packages', Item)\r
530                     MergeArches(Packages, Item, Arch)\r
531         for Key in Packages.keys():\r
532             Package = ModulePackageDependencyClass()\r
533             Package.Define = Defines\r
534             Package.FilePath = NormPath(Key, self._Macro)\r
535             Package.SupArchList = Packages[Key]\r
536             self.Module.PackageDependencies.append(Package)\r
537             \r
538         #\r
539         # Nmake\r
540         #\r
541         Nmakes = sdict()\r
542         for Arch in DataType.ARCH_LIST:\r
543             for Item in self.Contents[Arch].Nmake:\r
544                 MergeArches(Nmakes, Item, Arch)\r
545         for Key in Nmakes.keys():\r
546             List = GetSplitValueList(Key, DataType.TAB_EQUAL_SPLIT, MaxSplit=1)\r
547             if len(List) != 2:\r
548                 RaiseParserError(Item[0], 'Nmake', File, '<MacroName> = <Value>')\r
549             Nmake = ModuleNmakeClass()\r
550             Nmake.Name = List[0]\r
551             Nmake.Value = List[1]\r
552             Nmake.SupArchList = Nmakes[Key]\r
553             self.Module.Nmake.append(Nmake)\r
554 \r
555             # convert R8 format to R9 format\r
556             if Nmake.Name == "IMAGE_ENTRY_POINT":\r
557                 Image = ModuleExternImageClass()\r
558                 Image.ModuleEntryPoint = Nmake.Value\r
559                 self.Module.ExternImages.append(Image)\r
560             elif Nmake.Name == "DPX_SOURCE":\r
561                 Source = ModuleSourceFileClass(NormPath(Nmake.Value, self._Macro), "", "", "", "", Nmake.SupArchList)\r
562                 self.Module.Sources.append(Source)\r
563             else:\r
564                 ToolList = gNmakeFlagPattern.findall(Nmake.Name)\r
565                 if len(ToolList) == 0 or len(ToolList) != 1:\r
566                     EdkLogger.warn("\nParser", "Don't know how to do with MACRO: %s" % Nmake.Name, \r
567                                    ExtraData=File)\r
568                 else:\r
569                     if ToolList[0] in gNmakeFlagName2ToolCode:\r
570                         Tool = gNmakeFlagName2ToolCode[ToolList[0]]\r
571                     else:\r
572                         Tool = ToolList[0]\r
573                     BuildOption = BuildOptionClass("MSFT", "*_*_*_%s_FLAGS" % Tool, Nmake.Value)\r
574                     BuildOption.SupArchList = Nmake.SupArchList\r
575                     self.Module.BuildOptions.append(BuildOption)\r
576         \r
577         #\r
578         # Pcds\r
579         # <TokenSpaceGuidCName>.<PcdCName>[|<Value>]\r
580         #\r
581         Pcds = {}\r
582         for Arch in DataType.ARCH_LIST:\r
583             for Item in self.Contents[Arch].FixedPcd:\r
584                 #\r
585                 # Library should not have FixedPcd\r
586                 #\r
587                 if self.Module.Header[Arch].LibraryClass != {}:\r
588                     pass\r
589                 MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_FIXED_AT_BUILD, File), Arch)\r
590             \r
591             for Item in self.Contents[Arch].PatchPcd:\r
592                 MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_PATCHABLE_IN_MODULE, File), Arch)\r
593             \r
594             for Item in self.Contents[Arch].FeaturePcd:\r
595                 MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_FEATURE_FLAG, File), Arch)\r
596             \r
597             for Item in self.Contents[Arch].PcdEx:\r
598                 MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_DYNAMIC_EX, File), Arch)\r
599             \r
600             for Item in self.Contents[Arch].Pcd:\r
601                 MergeArches(Pcds, self.GetPcdOfInf(Item, "", File), Arch)\r
602                 #MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_DYNAMIC_EX, File), Arch)\r
603                 #MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_FEATURE_FLAG, File), Arch)\r
604                 #MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_FIXED_AT_BUILD, File), Arch)\r
605                 #MergeArches(Pcds, self.GetPcdOfInf(Item, TAB_PCDS_PATCHABLE_IN_MODULE, File), Arch)\r
606                 \r
607         for Key in Pcds.keys():\r
608             Pcd = PcdClass()\r
609             Pcd.CName = Key[1]\r
610             Pcd.TokenSpaceGuidCName = Key[0]\r
611             Pcd.DefaultValue = Key[2]\r
612             Pcd.ItemType = Key[3]\r
613             Pcd.SupArchList = Pcds[Key]\r
614             self.Module.PcdCodes.append(Pcd)\r
615         \r
616         #\r
617         # Sources\r
618         # <Filename>[|<Family>[|<TagName>[|<ToolCode>[|<PcdFeatureFlag>]]]]\r
619         #\r
620         Sources = {}\r
621         for Arch in DataType.ARCH_LIST:\r
622             for Item in self.Contents[Arch].Sources:\r
623                 ItemNew = Item + DataType.TAB_VALUE_SPLIT * 4\r
624                 List = GetSplitValueList(ItemNew)\r
625                 if len(List) < 5 or len(List) > 9:\r
626                     RaiseParserError(Item, 'Sources', File, '<Filename>[|<Family>[|<TagName>[|<ToolCode>[|<PcdFeatureFlag>]]]]')\r
627                 List[0] = NormPath(List[0], self._Macro)\r
628                 CheckFileExist(self.Identification.FileRelativePath, List[0], File, 'Sources', Item)\r
629                 CheckPcdTokenInfo(List[4], 'Sources', File)\r
630                 MergeArches(Sources, (List[0], List[1], List[2], List[3], List[4]), Arch)\r
631         for Key in Sources.keys():\r
632             Source = ModuleSourceFileClass(Key[0], Key[2], Key[3], Key[1], Key[4], Sources[Key])\r
633             self.Module.Sources.append(Source)\r
634 \r
635         #\r
636         # UserExtensions\r
637         #\r
638         if self.UserExtensions != '':\r
639             UserExtension = UserExtensionsClass()\r
640             Lines = self.UserExtensions.splitlines()\r
641             List = GetSplitValueList(Lines[0], DataType.TAB_SPLIT, 2)\r
642             if len(List) != 3:\r
643                 RaiseParserError(Lines[0], 'UserExtensions', File, "UserExtensions.UserId.'Identifier'")\r
644             else:\r
645                 UserExtension.UserID = List[1]\r
646                 UserExtension.Identifier = List[2][0:-1].replace("'", '').replace('\"', '')\r
647                 for Line in Lines[1:]:\r
648                     UserExtension.Content = UserExtension.Content + CleanString(Line) + '\n'\r
649             self.Module.UserExtensions.append(UserExtension)\r
650         \r
651         #\r
652         # Guids\r
653         #\r
654         Guids = {}\r
655         for Arch in DataType.ARCH_LIST:\r
656             for Item in self.Contents[Arch].Guids:\r
657                 MergeArches(Guids, Item, Arch)\r
658         for Key in Guids.keys():\r
659             Guid = GuidClass()\r
660             Guid.CName = Key\r
661             Guid.SupArchList = Guids[Key]\r
662             self.Module.Guids.append(Guid)\r
663 \r
664         #\r
665         # Protocols\r
666         #\r
667         Protocols = {}\r
668         for Arch in DataType.ARCH_LIST:\r
669             for Item in self.Contents[Arch].Protocols:\r
670                 MergeArches(Protocols, Item, Arch)\r
671         for Key in Protocols.keys():\r
672             Protocol = ProtocolClass()\r
673             Protocol.CName = Key\r
674             Protocol.SupArchList = Protocols[Key]\r
675             self.Module.Protocols.append(Protocol)\r
676         \r
677         #\r
678         # Ppis\r
679         #\r
680         Ppis = {}\r
681         for Arch in DataType.ARCH_LIST:\r
682             for Item in self.Contents[Arch].Ppis:\r
683                 MergeArches(Ppis, Item, Arch)\r
684         for Key in Ppis.keys():\r
685             Ppi = PpiClass()\r
686             Ppi.CName = Key\r
687             Ppi.SupArchList = Ppis[Key]\r
688             self.Module.Ppis.append(Ppi)\r
689         \r
690         #\r
691         # Depex\r
692         #\r
693         Depex = {}\r
694         Defines = {}\r
695         for Arch in DataType.ARCH_LIST:\r
696             Line = ''\r
697             for Item in self.Contents[Arch].Depex:\r
698                 Status = GenDefines(Item, Arch, Defines)\r
699                 #\r
700                 # Find DEFINE statement\r
701                 #\r
702                 if Status == 0:\r
703                     pass\r
704                 #\r
705                 # Find DEFINE statement but in wrong format\r
706                 #\r
707                 elif Status == -1:\r
708                     RaiseParserError(Item, 'Depex', File, 'DEFINE <VarName> = <PATH>')\r
709                 #\r
710                 # Not find DEFINE statement\r
711                 #\r
712                 elif Status == 1:\r
713                     Line = Line + Item + ' '\r
714             MergeArches(Depex, Line, Arch)\r
715         for Key in Depex.keys():\r
716             Dep = ModuleDepexClass()\r
717             Dep.Depex = Key\r
718             Dep.SupArchList = Depex[Key]\r
719             Dep.Define = Defines\r
720             self.Module.Depex.append(Dep)\r
721         \r
722         #\r
723         # Binaries\r
724         # <FileType>|<Filename>|<Target>[|<TokenSpaceGuidCName>.<PcdCName>]\r
725         #\r
726         Binaries = {}\r
727         for Arch in DataType.ARCH_LIST:\r
728             for Item in self.Contents[Arch].Binaries:\r
729                 ItemNew = Item + DataType.TAB_VALUE_SPLIT\r
730                 List = GetSplitValueList(ItemNew)\r
731                 if len(List) != 4 and len(List) != 5:\r
732                     RaiseParserError(Item, 'Binaries', File, "<FileType>|<Filename>|<Target>[|<TokenSpaceGuidCName>.<PcdCName>]")\r
733                 else:\r
734                     CheckPcdTokenInfo(List[3], 'Binaries', File)\r
735                     MergeArches(Binaries, (List[0], List[1], List[2], List[3]), Arch)\r
736         for Key in Binaries.keys():\r
737             Binary = ModuleBinaryFileClass(NormPath(Key[1], self._Macro), Key[0], Key[2], Key[3], Binaries[Key])\r
738             self.Module.Binaries.append(Binary)\r
739         \r
740     ## Get Pcd Values of Inf\r
741     #\r
742     # Get Pcd of Inf as <TokenSpaceGuidCName>.<PcdCName>[|<Value>]\r
743     #\r
744     # @param Item:  The string describes pcd\r
745     # @param Type:  The type of Pcd\r
746     # @param File:  The file which describes the pcd, used for error report\r
747     #\r
748     # @retval (TokenSpcCName, TokenCName, Value, ItemType) Formatted Pcd Item\r
749     #\r
750     def GetPcdOfInf(self, Item, Type, File):\r
751         Format = '<TokenSpaceGuidCName>.<PcdCName>[|<Value>]'\r
752         InfType = ''\r
753         if Type == TAB_PCDS_FIXED_AT_BUILD:\r
754             InfType = TAB_INF_FIXED_PCD\r
755         elif Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
756             InfType = TAB_INF_PATCH_PCD\r
757         elif Type == TAB_PCDS_FEATURE_FLAG:\r
758             InfType = TAB_INF_FEATURE_PCD        \r
759         elif Type == TAB_PCDS_DYNAMIC_EX:\r
760             InfType = TAB_INF_PCD_EX        \r
761         elif Type == TAB_PCDS_DYNAMIC:\r
762             InfType = TAB_INF_PCD\r
763         List = GetSplitValueList(Item + DataType.TAB_VALUE_SPLIT)\r
764         if len(List) < 2 or len(List) > 3:\r
765             RaiseParserError(Item, InfType, File, Format)\r
766         TokenInfo = GetSplitValueList(List[0], DataType.TAB_SPLIT)\r
767         if len(TokenInfo) != 2:\r
768             RaiseParserError(Item, InfType, File, Format)\r
769         if len(List) == 3 and List[1] == '':\r
770             #\r
771             # Value is empty\r
772             #\r
773             RaiseParserError(Item, 'Pcds' + Type, File, Format)\r
774 \r
775         return (TokenInfo[0], TokenInfo[1], List[1], Type)\r
776 \r
777     ## Parse [Defines] section\r
778     #\r
779     # Parse [Defines] section into InfDefines object\r
780     #\r
781     # @param InfFile    The path of the INF file\r
782     # @param Section    The title of "Defines" section\r
783     # @param Lines      The content of "Defines" section\r
784     #\r
785     def ParseDefines(self, InfFile, Section, Lines):\r
786         TokenList = Section.split(TAB_SPLIT)\r
787         if len(TokenList) == 3:\r
788             RaiseParserError(Section, "Defines", InfFile, "[xx.yy.%s] format (with platform) is not supported")\r
789         if len(TokenList) == 2:\r
790             Arch = TokenList[1].upper()\r
791         else:\r
792             Arch = TAB_ARCH_COMMON.upper()\r
793 \r
794         if Arch not in self.Defines:\r
795             self.Defines[Arch] = InfDefines()\r
796         GetSingleValueOfKeyFromLines(Lines, self.Defines[Arch].DefinesDictionary, \r
797                                      TAB_COMMENT_SPLIT, TAB_EQUAL_SPLIT, False, None)\r
798 \r
799     ## Load Inf file\r
800     #\r
801     # Load the file if it exists\r
802     #\r
803     # @param Filename:  Input value for filename of Inf file\r
804     #\r
805     def LoadInfFile(self, Filename):     \r
806         (Filepath, Name) = os.path.split(Filename)\r
807         self.Identification.FileName = Name\r
808         self.Identification.FileFullPath = Filename\r
809         self.Identification.FileRelativePath = Filepath\r
810         \r
811         F = open(Filename, 'r').read()\r
812         F = PreCheck(Filename, F, self.KeyList)\r
813         Sects = F.split(DataType.TAB_SECTION_START)\r
814         for Sect in Sects:\r
815             TabList = GetSplitValueList(Sect.split(TAB_SECTION_END, 1)[0], DataType.TAB_COMMA_SPLIT)\r
816             for Tab in TabList:\r
817                 if Tab.upper().find(TAB_INF_DEFINES.upper()) > -1:\r
818                     self.ParseDefines(Filename, Tab, Sect)\r
819                     continue\r
820                 if Tab.upper().find(DataType.TAB_USER_EXTENSIONS.upper()) > -1:\r
821                     self.UserExtensions = Sect\r
822                     continue\r
823                 for Arch in DataType.ARCH_LIST_FULL + [DataType.TAB_ARCH_NULL, "PLATFORM"]:\r
824                     for Key in self.KeyList:\r
825                         if Arch != DataType.TAB_ARCH_NULL:\r
826                             Target = (Key + DataType.TAB_SPLIT + Arch).upper()\r
827                         else:\r
828                             Target = Key.upper()\r
829                         if SplitModuleType(Tab)[0].upper() == Target:\r
830                             if Arch != DataType.TAB_ARCH_NULL and Arch != "PLATFORM":\r
831                                 Command = 'self.ParseInf(Sect, Tab, self.Contents[Arch].' + Key + ')'\r
832                                 eval(Command)\r
833                                 continue\r
834                             else:\r
835                                 Command = "self.ParseInf(Sect, Tab, self.Contents['" + DataType.TAB_ARCH_COMMON + "']." + Key + ')'\r
836                                 eval(Command)\r
837                                 continue\r
838             #EndFor\r
839 \r
840     ## Show detailed information of Inf\r
841     #\r
842     # Print all members and their values of Inf class\r
843     #\r
844     def ShowInf(self):\r
845         print TAB_SECTION_START + TAB_INF_DEFINES + TAB_SECTION_END\r
846         printDict(self.Defines.DefinesDictionary)\r
847 \r
848         for key in self.KeyList:\r
849             for arch in DataType.ARCH_LIST_FULL:\r
850                 Command = "printList(TAB_SECTION_START + '" + \\r
851                           key + DataType.TAB_SPLIT + arch + \\r
852                           "' + TAB_SECTION_END, self.Contents[arch]." + key + ')'\r
853                 eval(Command)\r
854         print ""\r
855     \r
856     ## Show detailed information of Module\r
857     #\r
858     # Print all members and their values of Module class\r
859     #\r
860     def ShowModule(self):\r
861         M = self.Module\r
862         print 'Filename =', M.Header.FileName\r
863         print 'FullPath =', M.Header.FullPath\r
864         print 'BaseName =', M.Header.Name\r
865         print 'Guid =', M.Header.Guid\r
866         print 'Version =', M.Header.Version\r
867         print 'InfVersion =', M.Header.InfVersion\r
868         print 'EfiSpecificationVersion =', M.Header.EfiSpecificationVersion\r
869         print 'EdkReleaseVersion =', M.Header.EdkReleaseVersion                \r
870         print 'ModuleType =', M.Header.ModuleType\r
871         print 'BinaryModule =', M.Header.BinaryModule\r
872         print 'ComponentType =', M.Header.ComponentType\r
873         print 'MakefileName =', M.Header.MakefileName\r
874         print 'BuildNumber =', M.Header.BuildNumber\r
875         print 'BuildType =', M.Header.BuildType\r
876         print 'FfsExt =', M.Header.FfsExt\r
877         print 'FvExt =', M.Header.FvExt\r
878         print 'SourceFv =', M.Header.SourceFv\r
879         print 'PcdIsDriver =', M.Header.PcdIsDriver\r
880         print 'TianoR8FlashMap_h =', M.Header.TianoR8FlashMap_h\r
881         print 'Shadow =', M.Header.Shadow\r
882         print 'LibraryClass =', M.Header.LibraryClass\r
883         for Item in M.Header.LibraryClass:\r
884             print Item.LibraryClass, DataType.TAB_VALUE_SPLIT.join(Item.SupModuleList)\r
885         print 'CustomMakefile =', M.Header.CustomMakefile\r
886         for Item in self.Module.ExternImages:\r
887             print 'Entry_Point = %s, UnloadImage = %s' % (Item.ModuleEntryPoint, Item.ModuleUnloadImage)\r
888         for Item in self.Module.ExternLibraries:\r
889             print 'Constructor = %s, Destructor = %s' % (Item.Constructor, Item.Destructor)\r
890         print 'Define =', M.Header.Define\r
891         print 'Specification =', M.Header.Specification\r
892         print '\nBuildOptions =', M.BuildOptions\r
893         for Item in M.BuildOptions:\r
894             print Item.ToolChainFamily, Item.ToolChain, Item.Option, Item.SupArchList\r
895         print '\nIncludes =', M.Includes\r
896         for Item in M.Includes:\r
897             print Item.FilePath, Item.SupArchList\r
898         print '\nLibraries =', M.Libraries\r
899         for Item in M.Libraries:\r
900             print Item.Library, Item.SupArchList\r
901         print '\nLibraryClasses =', M.LibraryClasses\r
902         for Item in M.LibraryClasses:\r
903             print Item.LibraryClass, Item.RecommendedInstance, Item.FeatureFlag, Item.SupModuleList, Item.SupArchList, Item.Define\r
904         print '\nPackageDependencies =', M.PackageDependencies\r
905         for Item in M.PackageDependencies:\r
906             print Item.FilePath, Item.SupArchList, Item.Define\r
907         print '\nNmake =', M.Nmake\r
908         for Item in M.Nmake:\r
909             print Item.Name, Item.Value, Item.SupArchList\r
910         print '\nPcds =', M.PcdCodes\r
911         for Item in M.PcdCodes:\r
912             print '\tCName=',Item.CName, 'TokenSpaceGuidCName=', Item.TokenSpaceGuidCName, 'DefaultValue=', Item.DefaultValue, 'ItemType=', Item.ItemType, Item.SupArchList\r
913         print '\nSources =', M.Sources\r
914         for Source in M.Sources:\r
915             print Source.SourceFile, 'Fam=', Source.ToolChainFamily, 'Pcd=', Source.FeatureFlag, 'Tag=', Source.TagName, 'ToolCode=', Source.ToolCode, Source.SupArchList\r
916         print '\nUserExtensions =', M.UserExtensions\r
917         for UserExtension in M.UserExtensions:\r
918             print UserExtension.UserID, UserExtension.Identifier,UserExtension.Content\r
919         print '\nGuids =', M.Guids\r
920         for Item in M.Guids:\r
921             print Item.CName, Item.SupArchList\r
922         print '\nProtocols =', M.Protocols\r
923         for Item in M.Protocols:\r
924             print Item.CName, Item.SupArchList\r
925         print '\nPpis =', M.Ppis\r
926         for Item in M.Ppis:\r
927             print Item.CName, Item.SupArchList\r
928         print '\nDepex =', M.Depex\r
929         for Item in M.Depex:\r
930             print Item.Depex, Item.SupArchList, Item.Define\r
931         print '\nBinaries =', M.Binaries\r
932         for Binary in M.Binaries:\r
933             print 'Type=', Binary.FileType, 'Target=', Binary.Target, 'Name=', Binary.BinaryFile, 'FeatureFlag=', Binary.FeatureFlag, 'SupArchList=', Binary.SupArchList\r
934 \r
935 ##\r
936 #\r
937 # This acts like the main() function for the script, unless it is 'import'ed into another\r
938 # script.\r
939 #\r
940 if __name__ == '__main__':\r
941     import sys\r
942     print os.path.abspath(sys.argv[1])\r
943     P = Inf(os.path.abspath(sys.argv[1]), True, True, os.getenv('WORKSPACE'))\r
944     P.ShowModule()\r