]> git.proxmox.com Git - mirror_edk2.git/blame - BaseTools/Source/Python/Workspace/InfBuildData.py
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
BaseTools: Add Platform Override Build Options for PcdValueInit
[mirror_edk2.git] / BaseTools / Source / Python / Workspace / InfBuildData.py
CommitLineData
ae7b6df8
LG		 1## @file\r
2# This file is used to create a database used by build tool\r
3#\r
a9d9ce8e 4# Copyright (c) 2008 - 2017, Intel Corporation. All rights reserved.<BR>\r
ae7b6df8
LG		 5# (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>\r
6# This program and the accompanying materials\r
7# are licensed and made available under the terms and conditions of the BSD License\r
8# which accompanies this distribution. The full text of the license may be found at\r
9# http://opensource.org/licenses/bsd-license.php\r
10#\r
11# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
12# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
13#\r
14\r
15from Common.String import *\r
16from Common.DataType import *\r
17from Common.Misc import *\r
18from types import *\r
19\r
20from Workspace.BuildClassObject import ModuleBuildClassObject, LibraryClassObject, PcdClassObject\r
21## Module build information from INF file\r
22#\r
23# This class is used to retrieve information stored in database and convert them\r
24# into ModuleBuildClassObject form for easier use for AutoGen.\r
25#\r
26class InfBuildData(ModuleBuildClassObject):\r
27 # dict used to convert PCD type in database to string used by build tool\r
28 _PCD_TYPE_STRING_ = {\r
29 MODEL_PCD_FIXED_AT_BUILD : "FixedAtBuild",\r
30 MODEL_PCD_PATCHABLE_IN_MODULE : "PatchableInModule",\r
31 MODEL_PCD_FEATURE_FLAG : "FeatureFlag",\r
32 MODEL_PCD_DYNAMIC : "Dynamic",\r
33 MODEL_PCD_DYNAMIC_DEFAULT : "Dynamic",\r
34 MODEL_PCD_DYNAMIC_HII : "DynamicHii",\r
35 MODEL_PCD_DYNAMIC_VPD : "DynamicVpd",\r
36 MODEL_PCD_DYNAMIC_EX : "DynamicEx",\r
37 MODEL_PCD_DYNAMIC_EX_DEFAULT : "DynamicEx",\r
38 MODEL_PCD_DYNAMIC_EX_HII : "DynamicExHii",\r
39 MODEL_PCD_DYNAMIC_EX_VPD : "DynamicExVpd",\r
40 }\r
41\r
42 # dict used to convert part of [Defines] to members of InfBuildData directly\r
43 _PROPERTY_ = {\r
44 #\r
45 # Required Fields\r
46 #\r
47 TAB_INF_DEFINES_BASE_NAME : "_BaseName",\r
48 TAB_INF_DEFINES_FILE_GUID : "_Guid",\r
49 TAB_INF_DEFINES_MODULE_TYPE : "_ModuleType",\r
50 #\r
51 # Optional Fields\r
52 #\r
53 # TAB_INF_DEFINES_INF_VERSION : "_AutoGenVersion",\r
54 TAB_INF_DEFINES_COMPONENT_TYPE : "_ComponentType",\r
55 TAB_INF_DEFINES_MAKEFILE_NAME : "_MakefileName",\r
56 # TAB_INF_DEFINES_CUSTOM_MAKEFILE : "_CustomMakefile",\r
57 TAB_INF_DEFINES_DPX_SOURCE :"_DxsFile",\r
58 TAB_INF_DEFINES_VERSION_NUMBER : "_Version",\r
59 TAB_INF_DEFINES_VERSION_STRING : "_Version",\r
60 TAB_INF_DEFINES_VERSION : "_Version",\r
61 TAB_INF_DEFINES_PCD_IS_DRIVER : "_PcdIsDriver",\r
62 TAB_INF_DEFINES_SHADOW : "_Shadow",\r
63\r
64 TAB_COMPONENTS_SOURCE_OVERRIDE_PATH : "_SourceOverridePath",\r
65 }\r
66\r
67 # dict used to convert Component type to Module type\r
68 _MODULE_TYPE_ = {\r
69 "LIBRARY" : "BASE",\r
70 "SECURITY_CORE" : "SEC",\r
71 "PEI_CORE" : "PEI_CORE",\r
72 "COMBINED_PEIM_DRIVER" : "PEIM",\r
73 "PIC_PEIM" : "PEIM",\r
74 "RELOCATABLE_PEIM" : "PEIM",\r
75 "PE32_PEIM" : "PEIM",\r
76 "BS_DRIVER" : "DXE_DRIVER",\r
77 "RT_DRIVER" : "DXE_RUNTIME_DRIVER",\r
78 "SAL_RT_DRIVER" : "DXE_SAL_DRIVER",\r
79 "DXE_SMM_DRIVER" : "DXE_SMM_DRIVER",\r
80 # "SMM_DRIVER" : "DXE_SMM_DRIVER",\r
81 # "BS_DRIVER" : "DXE_SMM_DRIVER",\r
82 # "BS_DRIVER" : "UEFI_DRIVER",\r
83 "APPLICATION" : "UEFI_APPLICATION",\r
84 "LOGO" : "BASE",\r
85 }\r
86\r
87 # regular expression for converting XXX_FLAGS in [nmake] section to new type\r
88 _NMAKE_FLAG_PATTERN_ = re.compile("(?:EBC_)?([A-Z]+)_(?:STD_|PROJ_|ARCH_)?FLAGS(?:_DLL|_ASL|_EXE)?", re.UNICODE)\r
89 # dict used to convert old tool name used in [nmake] section to new ones\r
90 _TOOL_CODE_ = {\r
91 "C" : "CC",\r
92 "LIB" : "SLINK",\r
93 "LINK" : "DLINK",\r
94 }\r
95\r
96\r
97 ## Constructor of DscBuildData\r
98 #\r
99 # Initialize object of DscBuildData\r
100 #\r
101 # @param FilePath The path of platform description file\r
102 # @param RawData The raw data of DSC file\r
103 # @param BuildDataBase Database used to retrieve module/package information\r
104 # @param Arch The target architecture\r
105 # @param Platform The name of platform employing this module\r
106 # @param Macros Macros used for replacement in DSC file\r
107 #\r
108 def __init__(self, FilePath, RawData, BuildDatabase, Arch='COMMON', Target=None, Toolchain=None):\r
109 self.MetaFile = FilePath\r
110 self._ModuleDir = FilePath.Dir\r
111 self._RawData = RawData\r
112 self._Bdb = BuildDatabase\r
113 self._Arch = Arch\r
114 self._Target = Target\r
115 self._Toolchain = Toolchain\r
116 self._Platform = 'COMMON'\r
117 self._SourceOverridePath = None\r
118 if FilePath.Key in GlobalData.gOverrideDir:\r
119 self._SourceOverridePath = GlobalData.gOverrideDir[FilePath.Key]\r
120 self._Clear()\r
121\r
122 ## XXX[key] = value\r
123 def __setitem__(self, key, value):\r
124 self.__dict__[self._PROPERTY_[key]] = value\r
125\r
126 ## value = XXX[key]\r
127 def __getitem__(self, key):\r
128 return self.__dict__[self._PROPERTY_[key]]\r
129\r
130 ## "in" test support\r
131 def __contains__(self, key):\r
132 return key in self._PROPERTY_\r
133\r
134 ## Set all internal used members of InfBuildData to None\r
135 def _Clear(self):\r
136 self._HeaderComments = None\r
137 self._TailComments = None\r
138 self._Header_ = None\r
139 self._AutoGenVersion = None\r
140 self._BaseName = None\r
141 self._DxsFile = None\r
142 self._ModuleType = None\r
143 self._ComponentType = None\r
144 self._BuildType = None\r
145 self._Guid = None\r
146 self._Version = None\r
147 self._PcdIsDriver = None\r
148 self._BinaryModule = None\r
149 self._Shadow = None\r
150 self._MakefileName = None\r
151 self._CustomMakefile = None\r
152 self._Specification = None\r
153 self._LibraryClass = None\r
154 self._ModuleEntryPointList = None\r
155 self._ModuleUnloadImageList = None\r
156 self._ConstructorList = None\r
157 self._DestructorList = None\r
158 self._Defs = None\r
159 self._Binaries = None\r
160 self._Sources = None\r
161 self._LibraryClasses = None\r
162 self._Libraries = None\r
163 self._Protocols = None\r
164 self._ProtocolComments = None\r
165 self._Ppis = None\r
166 self._PpiComments = None\r
167 self._Guids = None\r
168 self._GuidsUsedByPcd = sdict()\r
169 self._GuidComments = None\r
170 self._Includes = None\r
171 self._Packages = None\r
172 self._Pcds = None\r
173 self._PcdComments = None\r
174 self._BuildOptions = None\r
175 self._Depex = None\r
176 self._DepexExpression = None\r
177 self.__Macros = None\r
178\r
179 ## Get current effective macros\r
180 def _GetMacros(self):\r
181 if self.__Macros == None:\r
182 self.__Macros = {}\r
183 # EDK_GLOBAL defined macros can be applied to EDK module\r
184 if self.AutoGenVersion < 0x00010005:\r
185 self.__Macros.update(GlobalData.gEdkGlobal)\r
186 self.__Macros.update(GlobalData.gGlobalDefines)\r
187 return self.__Macros\r
188\r
189 ## Get architecture\r
190 def _GetArch(self):\r
191 return self._Arch\r
192\r
193 ## Set architecture\r
194 #\r
195 # Changing the default ARCH to another may affect all other information\r
196 # because all information in a platform may be ARCH-related. That's\r
197 # why we need to clear all internal used members, in order to cause all\r
198 # information to be re-retrieved.\r
199 #\r
200 # @param Value The value of ARCH\r
201 #\r
202 def _SetArch(self, Value):\r
203 if self._Arch == Value:\r
204 return\r
205 self._Arch = Value\r
206 self._Clear()\r
207\r
208 ## Return the name of platform employing this module\r
209 def _GetPlatform(self):\r
210 return self._Platform\r
211\r
212 ## Change the name of platform employing this module\r
213 #\r
214 # Changing the default name of platform to another may affect some information\r
215 # because they may be PLATFORM-related. That's why we need to clear all internal\r
216 # used members, in order to cause all information to be re-retrieved.\r
217 #\r
218 def _SetPlatform(self, Value):\r
219 if self._Platform == Value:\r
220 return\r
221 self._Platform = Value\r
222 self._Clear()\r
223 def _GetHeaderComments(self):\r
224 if not self._HeaderComments:\r
225 self._HeaderComments = []\r
226 RecordList = self._RawData[MODEL_META_DATA_HEADER_COMMENT]\r
227 for Record in RecordList:\r
228 self._HeaderComments.append(Record[0])\r
229 return self._HeaderComments\r
230 def _GetTailComments(self):\r
231 if not self._TailComments:\r
232 self._TailComments = []\r
233 RecordList = self._RawData[MODEL_META_DATA_TAIL_COMMENT]\r
234 for Record in RecordList:\r
235 self._TailComments.append(Record[0])\r
236 return self._TailComments\r
237 ## Retrieve all information in [Defines] section\r
238 #\r
239 # (Retriving all [Defines] information in one-shot is just to save time.)\r
240 #\r
241 def _GetHeaderInfo(self):\r
242 RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r
243 for Record in RecordList:\r
244 Name, Value = Record[1], ReplaceMacro(Record[2], self._Macros, False)\r
245 # items defined _PROPERTY_ don't need additional processing\r
246 if Name in self:\r
247 self[Name] = Value\r
248 if self._Defs == None:\r
249 self._Defs = sdict()\r
250 self._Defs[Name] = Value\r
251 self._Macros[Name] = Value\r
252 # some special items in [Defines] section need special treatment\r
253 elif Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION', 'EDK_RELEASE_VERSION', 'PI_SPECIFICATION_VERSION'):\r
254 if Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION'):\r
255 Name = 'UEFI_SPECIFICATION_VERSION'\r
256 if self._Specification == None:\r
257 self._Specification = sdict()\r
258 self._Specification[Name] = GetHexVerValue(Value)\r
259 if self._Specification[Name] == None:\r
260 EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r
261 "'%s' format is not supported for %s" % (Value, Name),\r
262 File=self.MetaFile, Line=Record[-1])\r
263 elif Name == 'LIBRARY_CLASS':\r
264 if self._LibraryClass == None:\r
265 self._LibraryClass = []\r
266 ValueList = GetSplitValueList(Value)\r
267 LibraryClass = ValueList[0]\r
268 if len(ValueList) > 1:\r
269 SupModuleList = GetSplitValueList(ValueList[1], ' ')\r
270 else:\r
271 SupModuleList = SUP_MODULE_LIST\r
272 self._LibraryClass.append(LibraryClassObject(LibraryClass, SupModuleList))\r
273 elif Name == 'ENTRY_POINT':\r
274 if self._ModuleEntryPointList == None:\r
275 self._ModuleEntryPointList = []\r
276 self._ModuleEntryPointList.append(Value)\r
277 elif Name == 'UNLOAD_IMAGE':\r
278 if self._ModuleUnloadImageList == None:\r
279 self._ModuleUnloadImageList = []\r
280 if not Value:\r
281 continue\r
282 self._ModuleUnloadImageList.append(Value)\r
283 elif Name == 'CONSTRUCTOR':\r
284 if self._ConstructorList == None:\r
285 self._ConstructorList = []\r
286 if not Value:\r
287 continue\r
288 self._ConstructorList.append(Value)\r
289 elif Name == 'DESTRUCTOR':\r
290 if self._DestructorList == None:\r
291 self._DestructorList = []\r
292 if not Value:\r
293 continue\r
294 self._DestructorList.append(Value)\r
295 elif Name == TAB_INF_DEFINES_CUSTOM_MAKEFILE:\r
296 TokenList = GetSplitValueList(Value)\r
297 if self._CustomMakefile == None:\r
298 self._CustomMakefile = {}\r
299 if len(TokenList) < 2:\r
300 self._CustomMakefile['MSFT'] = TokenList[0]\r
301 self._CustomMakefile['GCC'] = TokenList[0]\r
302 else:\r
303 if TokenList[0] not in ['MSFT', 'GCC']:\r
304 EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r
305 "No supported family [%s]" % TokenList[0],\r
306 File=self.MetaFile, Line=Record[-1])\r
307 self._CustomMakefile[TokenList[0]] = TokenList[1]\r
308 else:\r
309 if self._Defs == None:\r
310 self._Defs = sdict()\r
311 self._Defs[Name] = Value\r
312 self._Macros[Name] = Value\r
313\r
314 #\r
315 # Retrieve information in sections specific to Edk.x modules\r
316 #\r
317 if self.AutoGenVersion >= 0x00010005:\r
318 if not self._ModuleType:\r
319 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
320 "MODULE_TYPE is not given", File=self.MetaFile)\r
321 if self._ModuleType not in SUP_MODULE_LIST:\r
322 RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r
323 for Record in RecordList:\r
324 Name = Record[1]\r
325 if Name == "MODULE_TYPE":\r
326 LineNo = Record[6]\r
327 break\r
328 EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r
329 "MODULE_TYPE %s is not supported for EDK II, valid values are:\n %s" % (self._ModuleType, ' '.join(l for l in SUP_MODULE_LIST)),\r
330 File=self.MetaFile, Line=LineNo)\r
331 if (self._Specification == None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (int(self._Specification['PI_SPECIFICATION_VERSION'], 16) < 0x0001000A):\r
332 if self._ModuleType == SUP_MODULE_SMM_CORE:\r
333 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "SMM_CORE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x0001000A", File=self.MetaFile)\r
334 if (self._Specification == None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (int(self._Specification['PI_SPECIFICATION_VERSION'], 16) < 0x00010032):\r
335 if self._ModuleType == SUP_MODULE_MM_CORE_STANDALONE:\r
336 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "MM_CORE_STANDALONE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x00010032", File=self.MetaFile)\r
337 if self._ModuleType == SUP_MODULE_MM_STANDALONE:\r
338 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "MM_STANDALONE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x00010032", File=self.MetaFile)\r
339 if self._Defs and 'PCI_DEVICE_ID' in self._Defs and 'PCI_VENDOR_ID' in self._Defs \\r
340 and 'PCI_CLASS_CODE' in self._Defs and 'PCI_REVISION' in self._Defs:\r
341 self._BuildType = 'UEFI_OPTIONROM'\r
342 if 'PCI_COMPRESS' in self._Defs:\r
343 if self._Defs['PCI_COMPRESS'] not in ('TRUE', 'FALSE'):\r
344 EdkLogger.error("build", FORMAT_INVALID, "Expected TRUE/FALSE for PCI_COMPRESS: %s" % self.MetaFile)\r
345\r
346 elif self._Defs and 'UEFI_HII_RESOURCE_SECTION' in self._Defs \\r
347 and self._Defs['UEFI_HII_RESOURCE_SECTION'] == 'TRUE':\r
348 self._BuildType = 'UEFI_HII'\r
349 else:\r
350 self._BuildType = self._ModuleType.upper()\r
351\r
352 if self._DxsFile:\r
353 File = PathClass(NormPath(self._DxsFile), self._ModuleDir, Arch=self._Arch)\r
354 # check the file validation\r
355 ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)\r
356 if ErrorCode != 0:\r
357 EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo,\r
358 File=self.MetaFile, Line=LineNo)\r
359 if self.Sources == None:\r
360 self._Sources = []\r
361 self._Sources.append(File)\r
362 else:\r
363 if not self._ComponentType:\r
364 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
365 "COMPONENT_TYPE is not given", File=self.MetaFile)\r
366 self._BuildType = self._ComponentType.upper()\r
367 if self._ComponentType in self._MODULE_TYPE_:\r
368 self._ModuleType = self._MODULE_TYPE_[self._ComponentType]\r
369 if self._ComponentType == 'LIBRARY':\r
370 self._LibraryClass = [LibraryClassObject(self._BaseName, SUP_MODULE_LIST)]\r
371 # make use some [nmake] section macros\r
372 Macros = self._Macros\r
373 Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
374 Macros['PROCESSOR'] = self._Arch\r
375 RecordList = self._RawData[MODEL_META_DATA_NMAKE, self._Arch, self._Platform]\r
376 for Name, Value, Dummy, Arch, Platform, ID, LineNo in RecordList:\r
377 Value = ReplaceMacro(Value, Macros, True)\r
378 if Name == "IMAGE_ENTRY_POINT":\r
379 if self._ModuleEntryPointList == None:\r
380 self._ModuleEntryPointList = []\r
381 self._ModuleEntryPointList.append(Value)\r
382 elif Name == "DPX_SOURCE":\r
383 File = PathClass(NormPath(Value), self._ModuleDir, Arch=self._Arch)\r
384 # check the file validation\r
385 ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)\r
386 if ErrorCode != 0:\r
387 EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo,\r
388 File=self.MetaFile, Line=LineNo)\r
389 if self.Sources == None:\r
390 self._Sources = []\r
391 self._Sources.append(File)\r
392 else:\r
393 ToolList = self._NMAKE_FLAG_PATTERN_.findall(Name)\r
394 if len(ToolList) == 0 or len(ToolList) != 1:\r
395 pass\r
396# EdkLogger.warn("build", "Don't know how to do with macro [%s]" % Name,\r
397# File=self.MetaFile, Line=LineNo)\r
398 else:\r
399 if self._BuildOptions == None:\r
400 self._BuildOptions = sdict()\r
401\r
402 if ToolList[0] in self._TOOL_CODE_:\r
403 Tool = self._TOOL_CODE_[ToolList[0]]\r
404 else:\r
405 Tool = ToolList[0]\r
406 ToolChain = "*_*_*_%s_FLAGS" % Tool\r
407 ToolChainFamily = 'MSFT' # Edk.x only support MSFT tool chain\r
408 # ignore not replaced macros in value\r
409 ValueList = GetSplitList(' ' + Value, '/D')\r
410 Dummy = ValueList[0]\r
411 for Index in range(1, len(ValueList)):\r
412 if ValueList[Index][-1] == '=' or ValueList[Index] == '':\r
413 continue\r
414 Dummy = Dummy + ' /D ' + ValueList[Index]\r
415 Value = Dummy.strip()\r
416 if (ToolChainFamily, ToolChain) not in self._BuildOptions:\r
417 self._BuildOptions[ToolChainFamily, ToolChain] = Value\r
418 else:\r
419 OptionString = self._BuildOptions[ToolChainFamily, ToolChain]\r
420 self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Value\r
421 # set _Header to non-None in order to avoid database re-querying\r
422 self._Header_ = 'DUMMY'\r
423\r
424 ## Retrieve file version\r
425 def _GetInfVersion(self):\r
426 if self._AutoGenVersion == None:\r
427 RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r
428 for Record in RecordList:\r
429 if Record[1] == TAB_INF_DEFINES_INF_VERSION:\r
430 if '.' in Record[2]:\r
431 ValueList = Record[2].split('.')\r
432 Major = '%04o' % int(ValueList[0], 0)\r
433 Minor = '%04o' % int(ValueList[1], 0)\r
434 self._AutoGenVersion = int('0x' + Major + Minor, 0)\r
435 else:\r
436 self._AutoGenVersion = int(Record[2], 0)\r
437 break\r
438 if self._AutoGenVersion == None:\r
439 self._AutoGenVersion = 0x00010000\r
440 return self._AutoGenVersion\r
441\r
442 ## Retrieve BASE_NAME\r
443 def _GetBaseName(self):\r
444 if self._BaseName == None:\r
445 if self._Header_ == None:\r
446 self._GetHeaderInfo()\r
447 if self._BaseName == None:\r
448 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BASE_NAME name", File=self.MetaFile)\r
449 return self._BaseName\r
450\r
451 ## Retrieve DxsFile\r
452 def _GetDxsFile(self):\r
453 if self._DxsFile == None:\r
454 if self._Header_ == None:\r
455 self._GetHeaderInfo()\r
456 if self._DxsFile == None:\r
457 self._DxsFile = ''\r
458 return self._DxsFile\r
459\r
460 ## Retrieve MODULE_TYPE\r
461 def _GetModuleType(self):\r
462 if self._ModuleType == None:\r
463 if self._Header_ == None:\r
464 self._GetHeaderInfo()\r
465 if self._ModuleType == None:\r
466 self._ModuleType = 'BASE'\r
467 if self._ModuleType not in SUP_MODULE_LIST:\r
468 self._ModuleType = "USER_DEFINED"\r
469 return self._ModuleType\r
470\r
471 ## Retrieve COMPONENT_TYPE\r
472 def _GetComponentType(self):\r
473 if self._ComponentType == None:\r
474 if self._Header_ == None:\r
475 self._GetHeaderInfo()\r
476 if self._ComponentType == None:\r
477 self._ComponentType = 'USER_DEFINED'\r
478 return self._ComponentType\r
479\r
480 ## Retrieve "BUILD_TYPE"\r
481 def _GetBuildType(self):\r
482 if self._BuildType == None:\r
483 if self._Header_ == None:\r
484 self._GetHeaderInfo()\r
485 if not self._BuildType:\r
486 self._BuildType = "BASE"\r
487 return self._BuildType\r
488\r
489 ## Retrieve file guid\r
490 def _GetFileGuid(self):\r
491 if self._Guid == None:\r
492 if self._Header_ == None:\r
493 self._GetHeaderInfo()\r
494 if self._Guid == None:\r
495 self._Guid = '00000000-0000-0000-0000-000000000000'\r
496 return self._Guid\r
497\r
498 ## Retrieve module version\r
499 def _GetVersion(self):\r
500 if self._Version == None:\r
501 if self._Header_ == None:\r
502 self._GetHeaderInfo()\r
503 if self._Version == None:\r
504 self._Version = '0.0'\r
505 return self._Version\r
506\r
507 ## Retrieve PCD_IS_DRIVER\r
508 def _GetPcdIsDriver(self):\r
509 if self._PcdIsDriver == None:\r
510 if self._Header_ == None:\r
511 self._GetHeaderInfo()\r
512 if self._PcdIsDriver == None:\r
513 self._PcdIsDriver = ''\r
514 return self._PcdIsDriver\r
515\r
516 ## Retrieve SHADOW\r
517 def _GetShadow(self):\r
518 if self._Shadow == None:\r
519 if self._Header_ == None:\r
520 self._GetHeaderInfo()\r
521 if self._Shadow != None and self._Shadow.upper() == 'TRUE':\r
522 self._Shadow = True\r
523 else:\r
524 self._Shadow = False\r
525 return self._Shadow\r
526\r
527 ## Retrieve CUSTOM_MAKEFILE\r
528 def _GetMakefile(self):\r
529 if self._CustomMakefile == None:\r
530 if self._Header_ == None:\r
531 self._GetHeaderInfo()\r
532 if self._CustomMakefile == None:\r
533 self._CustomMakefile = {}\r
534 return self._CustomMakefile\r
535\r
536 ## Retrieve EFI_SPECIFICATION_VERSION\r
537 def _GetSpec(self):\r
538 if self._Specification == None:\r
539 if self._Header_ == None:\r
540 self._GetHeaderInfo()\r
541 if self._Specification == None:\r
542 self._Specification = {}\r
543 return self._Specification\r
544\r
545 ## Retrieve LIBRARY_CLASS\r
546 def _GetLibraryClass(self):\r
547 if self._LibraryClass == None:\r
548 if self._Header_ == None:\r
549 self._GetHeaderInfo()\r
550 if self._LibraryClass == None:\r
551 self._LibraryClass = []\r
552 return self._LibraryClass\r
553\r
554 ## Retrieve ENTRY_POINT\r
555 def _GetEntryPoint(self):\r
556 if self._ModuleEntryPointList == None:\r
557 if self._Header_ == None:\r
558 self._GetHeaderInfo()\r
559 if self._ModuleEntryPointList == None:\r
560 self._ModuleEntryPointList = []\r
561 return self._ModuleEntryPointList\r
562\r
563 ## Retrieve UNLOAD_IMAGE\r
564 def _GetUnloadImage(self):\r
565 if self._ModuleUnloadImageList == None:\r
566 if self._Header_ == None:\r
567 self._GetHeaderInfo()\r
568 if self._ModuleUnloadImageList == None:\r
569 self._ModuleUnloadImageList = []\r
570 return self._ModuleUnloadImageList\r
571\r
572 ## Retrieve CONSTRUCTOR\r
573 def _GetConstructor(self):\r
574 if self._ConstructorList == None:\r
575 if self._Header_ == None:\r
576 self._GetHeaderInfo()\r
577 if self._ConstructorList == None:\r
578 self._ConstructorList = []\r
579 return self._ConstructorList\r
580\r
581 ## Retrieve DESTRUCTOR\r
582 def _GetDestructor(self):\r
583 if self._DestructorList == None:\r
584 if self._Header_ == None:\r
585 self._GetHeaderInfo()\r
586 if self._DestructorList == None:\r
587 self._DestructorList = []\r
588 return self._DestructorList\r
589\r
590 ## Retrieve definies other than above ones\r
591 def _GetDefines(self):\r
592 if self._Defs == None:\r
593 if self._Header_ == None:\r
594 self._GetHeaderInfo()\r
595 if self._Defs == None:\r
596 self._Defs = sdict()\r
597 return self._Defs\r
598\r
599 ## Retrieve binary files\r
600 def _GetBinaries(self):\r
601 if self._Binaries == None:\r
602 self._Binaries = []\r
603 RecordList = self._RawData[MODEL_EFI_BINARY_FILE, self._Arch, self._Platform]\r
604 Macros = self._Macros\r
605 Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
606 Macros['PROCESSOR'] = self._Arch\r
607 for Record in RecordList:\r
608 FileType = Record[0]\r
609 LineNo = Record[-1]\r
610 Target = 'COMMON'\r
611 FeatureFlag = []\r
612 if Record[2]:\r
613 TokenList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)\r
614 if TokenList:\r
615 Target = TokenList[0]\r
616 if len(TokenList) > 1:\r
617 FeatureFlag = Record[1:]\r
618\r
619 File = PathClass(NormPath(Record[1], Macros), self._ModuleDir, '', FileType, True, self._Arch, '', Target)\r
620 # check the file validation\r
621 ErrorCode, ErrorInfo = File.Validate()\r
622 if ErrorCode != 0:\r
623 EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
624 self._Binaries.append(File)\r
625 return self._Binaries\r
626\r
627 ## Retrieve binary files with error check.\r
628 def _GetBinaryFiles(self):\r
629 Binaries = self._GetBinaries()\r
630 if GlobalData.gIgnoreSource and Binaries == []:\r
631 ErrorInfo = "The INF file does not contain any Binaries to use in creating the image\n"\r
632 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, ExtraData=ErrorInfo, File=self.MetaFile)\r
633\r
634 return Binaries\r
635 ## Check whether it exists the binaries with current ARCH in AsBuild INF\r
636 def _IsSupportedArch(self):\r
637 if self._GetBinaries() and not self._GetSourceFiles():\r
638 return True\r
639 else:\r
640 return False\r
641 ## Retrieve source files\r
642 def _GetSourceFiles(self):\r
643 # Ignore all source files in a binary build mode\r
644 if GlobalData.gIgnoreSource:\r
645 self._Sources = []\r
646 return self._Sources\r
647\r
648 if self._Sources == None:\r
649 self._Sources = []\r
650 RecordList = self._RawData[MODEL_EFI_SOURCE_FILE, self._Arch, self._Platform]\r
651 Macros = self._Macros\r
652 for Record in RecordList:\r
653 LineNo = Record[-1]\r
654 ToolChainFamily = Record[1]\r
655 TagName = Record[2]\r
656 ToolCode = Record[3]\r
657 FeatureFlag = Record[4]\r
658 if self.AutoGenVersion < 0x00010005:\r
659 Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
660 Macros['PROCESSOR'] = self._Arch\r
661 SourceFile = NormPath(Record[0], Macros)\r
662 if SourceFile[0] == os.path.sep:\r
663 SourceFile = mws.join(GlobalData.gWorkspace, SourceFile[1:])\r
664 # old module source files (Edk)\r
665 File = PathClass(SourceFile, self._ModuleDir, self._SourceOverridePath,\r
666 '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)\r
667 # check the file validation\r
668 ErrorCode, ErrorInfo = File.Validate(CaseSensitive=False)\r
669 if ErrorCode != 0:\r
670 if File.Ext.lower() == '.h':\r
671 EdkLogger.warn('build', 'Include file not found', ExtraData=ErrorInfo,\r
672 File=self.MetaFile, Line=LineNo)\r
673 continue\r
674 else:\r
675 EdkLogger.error('build', ErrorCode, ExtraData=File, File=self.MetaFile, Line=LineNo)\r
676 else:\r
677 File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, '',\r
678 '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)\r
679 # check the file validation\r
680 ErrorCode, ErrorInfo = File.Validate()\r
681 if ErrorCode != 0:\r
682 EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
683\r
684 self._Sources.append(File)\r
685 return self._Sources\r
686\r
687 ## Retrieve library classes employed by this module\r
688 def _GetLibraryClassUses(self):\r
689 if self._LibraryClasses == None:\r
690 self._LibraryClasses = sdict()\r
691 RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, self._Platform]\r
692 for Record in RecordList:\r
693 Lib = Record[0]\r
694 Instance = Record[1]\r
695 if Instance:\r
696 Instance = NormPath(Instance, self._Macros)\r
697 self._LibraryClasses[Lib] = Instance\r
698 return self._LibraryClasses\r
699\r
700 ## Retrieve library names (for Edk.x style of modules)\r
701 def _GetLibraryNames(self):\r
702 if self._Libraries == None:\r
703 self._Libraries = []\r
704 RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch, self._Platform]\r
705 for Record in RecordList:\r
706 LibraryName = ReplaceMacro(Record[0], self._Macros, False)\r
707 # in case of name with '.lib' extension, which is unusual in Edk.x inf\r
708 LibraryName = os.path.splitext(LibraryName)[0]\r
709 if LibraryName not in self._Libraries:\r
710 self._Libraries.append(LibraryName)\r
711 return self._Libraries\r
712\r
713 def _GetProtocolComments(self):\r
714 self._GetProtocols()\r
715 return self._ProtocolComments\r
716 ## Retrieve protocols consumed/produced by this module\r
717 def _GetProtocols(self):\r
718 if self._Protocols == None:\r
719 self._Protocols = sdict()\r
720 self._ProtocolComments = sdict()\r
721 RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch, self._Platform]\r
722 for Record in RecordList:\r
723 CName = Record[0]\r
724 Value = ProtocolValue(CName, self.Packages, self.MetaFile.Path)\r
725 if Value == None:\r
726 PackageList = "\n\t".join([str(P) for P in self.Packages])\r
727 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
728 "Value of Protocol [%s] is not found under [Protocols] section in" % CName,\r
729 ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
730 self._Protocols[CName] = Value\r
731 CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r
732 Comments = []\r
733 for CmtRec in CommentRecords:\r
734 Comments.append(CmtRec[0])\r
735 self._ProtocolComments[CName] = Comments\r
736 return self._Protocols\r
737\r
738 def _GetPpiComments(self):\r
739 self._GetPpis()\r
740 return self._PpiComments\r
741 ## Retrieve PPIs consumed/produced by this module\r
742 def _GetPpis(self):\r
743 if self._Ppis == None:\r
744 self._Ppis = sdict()\r
745 self._PpiComments = sdict()\r
746 RecordList = self._RawData[MODEL_EFI_PPI, self._Arch, self._Platform]\r
747 for Record in RecordList:\r
748 CName = Record[0]\r
749 Value = PpiValue(CName, self.Packages, self.MetaFile.Path)\r
750 if Value == None:\r
751 PackageList = "\n\t".join([str(P) for P in self.Packages])\r
752 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
753 "Value of PPI [%s] is not found under [Ppis] section in " % CName,\r
754 ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
755 self._Ppis[CName] = Value\r
756 CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r
757 Comments = []\r
758 for CmtRec in CommentRecords:\r
759 Comments.append(CmtRec[0])\r
760 self._PpiComments[CName] = Comments\r
761 return self._Ppis\r
762\r
763 def _GetGuidComments(self):\r
764 self._GetGuids()\r
765 return self._GuidComments\r
766 ## Retrieve GUIDs consumed/produced by this module\r
767 def _GetGuids(self):\r
768 if self._Guids == None:\r
769 self._Guids = sdict()\r
770 self._GuidComments = sdict()\r
771 RecordList = self._RawData[MODEL_EFI_GUID, self._Arch, self._Platform]\r
772 for Record in RecordList:\r
773 CName = Record[0]\r
774 Value = GuidValue(CName, self.Packages, self.MetaFile.Path)\r
775 if Value == None:\r
776 PackageList = "\n\t".join([str(P) for P in self.Packages])\r
777 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
778 "Value of Guid [%s] is not found under [Guids] section in" % CName,\r
779 ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
780 self._Guids[CName] = Value\r
781 CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r
782 Comments = []\r
783 for CmtRec in CommentRecords:\r
784 Comments.append(CmtRec[0])\r
785 self._GuidComments[CName] = Comments\r
786 return self._Guids\r
787\r
788 ## Retrieve include paths necessary for this module (for Edk.x style of modules)\r
789 def _GetIncludes(self):\r
790 if self._Includes == None:\r
791 self._Includes = []\r
792 if self._SourceOverridePath:\r
793 self._Includes.append(self._SourceOverridePath)\r
794\r
795 Macros = self._Macros\r
796 if 'PROCESSOR' in GlobalData.gEdkGlobal.keys():\r
797 Macros['PROCESSOR'] = GlobalData.gEdkGlobal['PROCESSOR']\r
798 else:\r
799 Macros['PROCESSOR'] = self._Arch\r
800 RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch, self._Platform]\r
801 for Record in RecordList:\r
802 if Record[0].find('EDK_SOURCE') > -1:\r
803 Macros['EDK_SOURCE'] = GlobalData.gEcpSource\r
804 File = NormPath(Record[0], self._Macros)\r
805 if File[0] == '.':\r
806 File = os.path.join(self._ModuleDir, File)\r
807 else:\r
808 File = os.path.join(GlobalData.gWorkspace, File)\r
809 File = RealPath(os.path.normpath(File))\r
810 if File:\r
811 self._Includes.append(File)\r
812\r
813 # TRICK: let compiler to choose correct header file\r
814 Macros['EDK_SOURCE'] = GlobalData.gEdkSource\r
815 File = NormPath(Record[0], self._Macros)\r
816 if File[0] == '.':\r
817 File = os.path.join(self._ModuleDir, File)\r
818 else:\r
819 File = os.path.join(GlobalData.gWorkspace, File)\r
820 File = RealPath(os.path.normpath(File))\r
821 if File:\r
822 self._Includes.append(File)\r
823 else:\r
824 File = NormPath(Record[0], Macros)\r
825 if File[0] == '.':\r
826 File = os.path.join(self._ModuleDir, File)\r
827 else:\r
828 File = mws.join(GlobalData.gWorkspace, File)\r
829 File = RealPath(os.path.normpath(File))\r
830 if File:\r
831 self._Includes.append(File)\r
832 if not File and Record[0].find('EFI_SOURCE') > -1:\r
833 # tricky to regard WorkSpace as EFI_SOURCE\r
834 Macros['EFI_SOURCE'] = GlobalData.gWorkspace\r
835 File = NormPath(Record[0], Macros)\r
836 if File[0] == '.':\r
837 File = os.path.join(self._ModuleDir, File)\r
838 else:\r
839 File = os.path.join(GlobalData.gWorkspace, File)\r
840 File = RealPath(os.path.normpath(File))\r
841 if File:\r
842 self._Includes.append(File)\r
843 return self._Includes\r
844\r
845 ## Retrieve packages this module depends on\r
846 def _GetPackages(self):\r
847 if self._Packages == None:\r
848 self._Packages = []\r
849 RecordList = self._RawData[MODEL_META_DATA_PACKAGE, self._Arch, self._Platform]\r
850 Macros = self._Macros\r
851 Macros['EDK_SOURCE'] = GlobalData.gEcpSource\r
852 for Record in RecordList:\r
853 File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
854 LineNo = Record[-1]\r
855 # check the file validation\r
856 ErrorCode, ErrorInfo = File.Validate('.dec')\r
857 if ErrorCode != 0:\r
858 EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
859 # parse this package now. we need it to get protocol/ppi/guid value\r
860 Package = self._Bdb[File, self._Arch, self._Target, self._Toolchain]\r
861 self._Packages.append(Package)\r
862 return self._Packages\r
863\r
864 ## Retrieve PCD comments\r
865 def _GetPcdComments(self):\r
866 self._GetPcds()\r
867 return self._PcdComments\r
868 ## Retrieve PCDs used in this module\r
869 def _GetPcds(self):\r
870 if self._Pcds == None:\r
871 self._Pcds = sdict()\r
872 self._PcdComments = sdict()\r
873 self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
874 self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
875 self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r
876 self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))\r
877 self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))\r
878 return self._Pcds\r
879\r
880 ## Retrieve build options specific to this module\r
881 def _GetBuildOptions(self):\r
882 if self._BuildOptions == None:\r
883 self._BuildOptions = sdict()\r
884 RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, self._Platform]\r
885 for Record in RecordList:\r
886 ToolChainFamily = Record[0]\r
887 ToolChain = Record[1]\r
888 Option = Record[2]\r
889 if (ToolChainFamily, ToolChain) not in self._BuildOptions or Option.startswith('='):\r
890 self._BuildOptions[ToolChainFamily, ToolChain] = Option\r
891 else:\r
892 # concatenate the option string if they're for the same tool\r
893 OptionString = self._BuildOptions[ToolChainFamily, ToolChain]\r
894 self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option\r
895 return self._BuildOptions\r
896\r
897 ## Retrieve dependency expression\r
898 def _GetDepex(self):\r
899 if self._Depex == None:\r
900 self._Depex = tdict(False, 2)\r
901 RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]\r
902\r
903 # If the module has only Binaries and no Sources, then ignore [Depex]\r
904 if self.Sources == None or self.Sources == []:\r
905 if self.Binaries != None and self.Binaries != []:\r
906 return self._Depex\r
907\r
908 # PEIM and DXE drivers must have a valid [Depex] section\r
909 if len(self.LibraryClass) == 0 and len(RecordList) == 0:\r
910 if self.ModuleType == 'DXE_DRIVER' or self.ModuleType == 'PEIM' or self.ModuleType == 'DXE_SMM_DRIVER' or \\r
911 self.ModuleType == 'DXE_SAL_DRIVER' or self.ModuleType == 'DXE_RUNTIME_DRIVER':\r
912 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No [Depex] section or no valid expression in [Depex] section for [%s] module" \\r
913 % self.ModuleType, File=self.MetaFile)\r
914\r
915 if len(RecordList) != 0 and self.ModuleType == 'USER_DEFINED':\r
916 for Record in RecordList:\r
917 if Record[4] not in ['PEIM', 'DXE_DRIVER', 'DXE_SMM_DRIVER']:\r
918 EdkLogger.error('build', FORMAT_INVALID,\r
919 "'%s' module must specify the type of [Depex] section" % self.ModuleType,\r
920 File=self.MetaFile)\r
921\r
922 Depex = sdict()\r
923 for Record in RecordList:\r
924 DepexStr = ReplaceMacro(Record[0], self._Macros, False)\r
925 Arch = Record[3]\r
926 ModuleType = Record[4]\r
927 TokenList = DepexStr.split()\r
928 if (Arch, ModuleType) not in Depex:\r
929 Depex[Arch, ModuleType] = []\r
930 DepexList = Depex[Arch, ModuleType]\r
931 for Token in TokenList:\r
932 if Token in DEPEX_SUPPORTED_OPCODE:\r
933 DepexList.append(Token)\r
934 elif Token.endswith(".inf"): # module file name\r
935 ModuleFile = os.path.normpath(Token)\r
936 Module = self.BuildDatabase[ModuleFile]\r
937 if Module == None:\r
938 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "Module is not found in active platform",\r
939 ExtraData=Token, File=self.MetaFile, Line=Record[-1])\r
940 DepexList.append(Module.Guid)\r
941 else:\r
942 # get the GUID value now\r
943 Value = ProtocolValue(Token, self.Packages, self.MetaFile.Path)\r
944 if Value == None:\r
945 Value = PpiValue(Token, self.Packages, self.MetaFile.Path)\r
946 if Value == None:\r
947 Value = GuidValue(Token, self.Packages, self.MetaFile.Path)\r
948 if Value == None:\r
949 PackageList = "\n\t".join([str(P) for P in self.Packages])\r
950 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
951 "Value of [%s] is not found in" % Token,\r
952 ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
953 DepexList.append(Value)\r
954 for Arch, ModuleType in Depex:\r
955 self._Depex[Arch, ModuleType] = Depex[Arch, ModuleType]\r
956 return self._Depex\r
957\r
958 ## Retrieve depedency expression\r
959 def _GetDepexExpression(self):\r
960 if self._DepexExpression == None:\r
961 self._DepexExpression = tdict(False, 2)\r
962 RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]\r
963 DepexExpression = sdict()\r
964 for Record in RecordList:\r
965 DepexStr = ReplaceMacro(Record[0], self._Macros, False)\r
966 Arch = Record[3]\r
967 ModuleType = Record[4]\r
968 TokenList = DepexStr.split()\r
969 if (Arch, ModuleType) not in DepexExpression:\r
970 DepexExpression[Arch, ModuleType] = ''\r
971 for Token in TokenList:\r
972 DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType] + Token.strip() + ' '\r
973 for Arch, ModuleType in DepexExpression:\r
974 self._DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType]\r
975 return self._DepexExpression\r
976\r
977 def GetGuidsUsedByPcd(self):\r
978 return self._GuidsUsedByPcd\r
979 ## Retrieve PCD for given type\r
980 def _GetPcd(self, Type):\r
981 Pcds = sdict()\r
982 PcdDict = tdict(True, 4)\r
983 PcdList = []\r
984 RecordList = self._RawData[Type, self._Arch, self._Platform]\r
985 for TokenSpaceGuid, PcdCName, Setting, Arch, Platform, Id, LineNo in RecordList:\r
986 PcdDict[Arch, Platform, PcdCName, TokenSpaceGuid] = (Setting, LineNo)\r
987 PcdList.append((PcdCName, TokenSpaceGuid))\r
988 # get the guid value\r
989 if TokenSpaceGuid not in self.Guids:\r
990 Value = GuidValue(TokenSpaceGuid, self.Packages, self.MetaFile.Path)\r
991 if Value == None:\r
992 PackageList = "\n\t".join([str(P) for P in self.Packages])\r
993 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
994 "Value of Guid [%s] is not found under [Guids] section in" % TokenSpaceGuid,\r
995 ExtraData=PackageList, File=self.MetaFile, Line=LineNo)\r
996 self.Guids[TokenSpaceGuid] = Value\r
997 self._GuidsUsedByPcd[TokenSpaceGuid] = Value\r
998 CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Id]\r
999 Comments = []\r
1000 for CmtRec in CommentRecords:\r
1001 Comments.append(CmtRec[0])\r
1002 self._PcdComments[TokenSpaceGuid, PcdCName] = Comments\r
1003\r
1004 # resolve PCD type, value, datum info, etc. by getting its definition from package\r
1005 for PcdCName, TokenSpaceGuid in PcdList:\r
1006 PcdRealName = PcdCName\r
1007 Setting, LineNo = PcdDict[self._Arch, self.Platform, PcdCName, TokenSpaceGuid]\r
1008 if Setting == None:\r
1009 continue\r
1010 ValueList = AnalyzePcdData(Setting)\r
1011 DefaultValue = ValueList[0]\r
1012 Pcd = PcdClassObject(\r
1013 PcdCName,\r
1014 TokenSpaceGuid,\r
1015 '',\r
1016 '',\r
1017 DefaultValue,\r
1018 '',\r
1019 '',\r
1020 {},\r
1021 False,\r
1022 self.Guids[TokenSpaceGuid]\r
1023 )\r
1024 if Type == MODEL_PCD_PATCHABLE_IN_MODULE and ValueList[1]:\r
1025 # Patch PCD: TokenSpace.PcdCName|Value|Offset\r
1026 Pcd.Offset = ValueList[1]\r
1027\r
1028 if (PcdRealName, TokenSpaceGuid) in GlobalData.MixedPcd:\r
1029 for Package in self.Packages:\r
1030 for key in Package.Pcds:\r
1031 if (Package.Pcds[key].TokenCName, Package.Pcds[key].TokenSpaceGuidCName) == (PcdRealName, TokenSpaceGuid):\r
1032 for item in GlobalData.MixedPcd[(PcdRealName, TokenSpaceGuid)]:\r
1033 Pcd_Type = item[0].split('_')[-1]\r
1034 if Pcd_Type == Package.Pcds[key].Type:\r
1035 Value = Package.Pcds[key]\r
1036 Value.TokenCName = Package.Pcds[key].TokenCName + '_' + Pcd_Type\r
1037 if len(key) == 2:\r
1038 newkey = (Value.TokenCName, key[1])\r
1039 elif len(key) == 3:\r
1040 newkey = (Value.TokenCName, key[1], key[2])\r
1041 del Package.Pcds[key]\r
1042 Package.Pcds[newkey] = Value\r
1043 break\r
1044 else:\r
1045 pass\r
1046 else:\r
1047 pass\r
1048\r
1049 # get necessary info from package declaring this PCD\r
1050 for Package in self.Packages:\r
1051 #\r
1052 # 'dynamic' in INF means its type is determined by platform;\r
1053 # if platform doesn't give its type, use 'lowest' one in the\r
1054 # following order, if any\r
1055 #\r
1056 # "FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"\r
1057 #\r
1058 PcdType = self._PCD_TYPE_STRING_[Type]\r
1059 if Type == MODEL_PCD_DYNAMIC:\r
1060 Pcd.Pending = True\r
1061 for T in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:\r
1062 if (PcdRealName, TokenSpaceGuid) in GlobalData.MixedPcd:\r
1063 for item in GlobalData.MixedPcd[(PcdRealName, TokenSpaceGuid)]:\r
1064 if str(item[0]).endswith(T) and (item[0], item[1], T) in Package.Pcds:\r
1065 PcdType = T\r
1066 PcdCName = item[0]\r
1067 break\r
1068 else:\r
1069 pass\r
1070 break\r
1071 else:\r
1072 if (PcdRealName, TokenSpaceGuid, T) in Package.Pcds:\r
1073 PcdType = T\r
1074 break\r
1075\r
1076 else:\r
1077 Pcd.Pending = False\r
1078 if (PcdRealName, TokenSpaceGuid) in GlobalData.MixedPcd:\r
1079 for item in GlobalData.MixedPcd[(PcdRealName, TokenSpaceGuid)]:\r
1080 Pcd_Type = item[0].split('_')[-1]\r
1081 if Pcd_Type == PcdType:\r
1082 PcdCName = item[0]\r
1083 break\r
1084 else:\r
1085 pass\r
1086 else:\r
1087 pass\r
1088\r
1089 if (PcdCName, TokenSpaceGuid, PcdType) in Package.Pcds:\r
1090 PcdInPackage = Package.Pcds[PcdCName, TokenSpaceGuid, PcdType]\r
1091 Pcd.Type = PcdType\r
1092 Pcd.TokenValue = PcdInPackage.TokenValue\r
1093\r
1094 #\r
1095 # Check whether the token value exist or not.\r
1096 #\r
1097 if Pcd.TokenValue == None or Pcd.TokenValue == "":\r
1098 EdkLogger.error(\r
1099 'build',\r
1100 FORMAT_INVALID,\r
1101 "No TokenValue for PCD [%s.%s] in [%s]!" % (TokenSpaceGuid, PcdRealName, str(Package)),\r
1102 File=self.MetaFile, Line=LineNo,\r
1103 ExtraData=None\r
1104 )\r
1105 #\r
1106 # Check hexadecimal token value length and format.\r
1107 #\r
1108 ReIsValidPcdTokenValue = re.compile(r"^[0][x|X][0]*[0-9a-fA-F]{1,8}$", re.DOTALL)\r
1109 if Pcd.TokenValue.startswith("0x") or Pcd.TokenValue.startswith("0X"):\r
1110 if ReIsValidPcdTokenValue.match(Pcd.TokenValue) == None:\r
1111 EdkLogger.error(\r
1112 'build',\r
1113 FORMAT_INVALID,\r
1114 "The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid:" % (Pcd.TokenValue, TokenSpaceGuid, PcdRealName, str(Package)),\r
1115 File=self.MetaFile, Line=LineNo,\r
1116 ExtraData=None\r
1117 )\r
1118\r
1119 #\r
1120 # Check decimal token value length and format.\r
1121 #\r
1122 else:\r
1123 try:\r
1124 TokenValueInt = int (Pcd.TokenValue, 10)\r
1125 if (TokenValueInt < 0 or TokenValueInt > 4294967295):\r
1126 EdkLogger.error(\r
1127 'build',\r
1128 FORMAT_INVALID,\r
1129 "The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid, as a decimal it should between: 0 - 4294967295!" % (Pcd.TokenValue, TokenSpaceGuid, PcdRealName, str(Package)),\r
1130 File=self.MetaFile, Line=LineNo,\r
1131 ExtraData=None\r
1132 )\r
1133 except:\r
1134 EdkLogger.error(\r
1135 'build',\r
1136 FORMAT_INVALID,\r
1137 "The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid, it should be hexadecimal or decimal!" % (Pcd.TokenValue, TokenSpaceGuid, PcdRealName, str(Package)),\r
1138 File=self.MetaFile, Line=LineNo,\r
1139 ExtraData=None\r
1140 )\r
1141\r
1142 Pcd.DatumType = PcdInPackage.DatumType\r
1143 Pcd.MaxDatumSize = PcdInPackage.MaxDatumSize\r
1144 Pcd.InfDefaultValue = Pcd.DefaultValue\r
1145 if Pcd.DefaultValue in [None, '']:\r
1146 Pcd.DefaultValue = PcdInPackage.DefaultValue\r
1147 break\r
1148 else:\r
1149 EdkLogger.error(\r
1150 'build',\r
1151 FORMAT_INVALID,\r
1152 "PCD [%s.%s] in [%s] is not found in dependent packages:" % (TokenSpaceGuid, PcdRealName, self.MetaFile),\r
1153 File=self.MetaFile, Line=LineNo,\r
1154 ExtraData="\t%s" % '\n\t'.join([str(P) for P in self.Packages])\r
1155 )\r
1156 Pcds[PcdCName, TokenSpaceGuid] = Pcd\r
1157\r
1158 return Pcds\r
1159\r
1160 ## check whether current module is binary module\r
1161 def _IsBinaryModule(self):\r
1162 if self.Binaries and not self.Sources:\r
1163 return True\r
1164 elif GlobalData.gIgnoreSource:\r
1165 return True\r
1166 else:\r
1167 return False\r
1168\r
1169 _Macros = property(_GetMacros)\r
1170 Arch = property(_GetArch, _SetArch)\r
1171 Platform = property(_GetPlatform, _SetPlatform)\r
1172\r
1173 HeaderComments = property(_GetHeaderComments)\r
1174 TailComments = property(_GetTailComments)\r
1175 AutoGenVersion = property(_GetInfVersion)\r
1176 BaseName = property(_GetBaseName)\r
1177 ModuleType = property(_GetModuleType)\r
1178 ComponentType = property(_GetComponentType)\r
1179 BuildType = property(_GetBuildType)\r
1180 Guid = property(_GetFileGuid)\r
1181 Version = property(_GetVersion)\r
1182 PcdIsDriver = property(_GetPcdIsDriver)\r
1183 Shadow = property(_GetShadow)\r
1184 CustomMakefile = property(_GetMakefile)\r
1185 Specification = property(_GetSpec)\r
1186 LibraryClass = property(_GetLibraryClass)\r
1187 ModuleEntryPointList = property(_GetEntryPoint)\r
1188 ModuleUnloadImageList = property(_GetUnloadImage)\r
1189 ConstructorList = property(_GetConstructor)\r
1190 DestructorList = property(_GetDestructor)\r
1191 Defines = property(_GetDefines)\r
1192 DxsFile = property(_GetDxsFile)\r
1193\r
1194 Binaries = property(_GetBinaryFiles)\r
1195 Sources = property(_GetSourceFiles)\r
1196 LibraryClasses = property(_GetLibraryClassUses)\r
1197 Libraries = property(_GetLibraryNames)\r
1198 Protocols = property(_GetProtocols)\r
1199 ProtocolComments = property(_GetProtocolComments)\r
1200 Ppis = property(_GetPpis)\r
1201 PpiComments = property(_GetPpiComments)\r
1202 Guids = property(_GetGuids)\r
1203 GuidComments = property(_GetGuidComments)\r
1204 Includes = property(_GetIncludes)\r
1205 Packages = property(_GetPackages)\r
1206 Pcds = property(_GetPcds)\r
1207 PcdComments = property(_GetPcdComments)\r
1208 BuildOptions = property(_GetBuildOptions)\r
1209 Depex = property(_GetDepex)\r
1210 DepexExpression = property(_GetDepexExpression)\r
1211 IsBinaryModule = property(_IsBinaryModule)\r
1212 IsSupportedArch = property(_IsSupportedArch)\r
EFI Development Kit II mirror for PVE