7ffb825efa9a752e0a73f6515f9fa02b38d24233
[mirror_edk2.git] / BaseTools / Source / Python / Workspace / DscBuildData.py
1 ## @file
2 # This file is used to create a database used by build tool
3 #
4 # Copyright (c) 2008 - 2018, Intel Corporation. All rights reserved.<BR>
5 # (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
6 # This program and the accompanying materials
7 # are licensed and made available under the terms and conditions of the BSD License
8 # which accompanies this distribution. The full text of the license may be found at
9 # http://opensource.org/licenses/bsd-license.php
10 #
11 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13 #
14
15 ## Platform build information from DSC file
16 #
17 # This class is used to retrieve information stored in database and convert them
18 # into PlatformBuildClassObject form for easier use for AutoGen.
19 #
20 from Common.String import *
21 from Common.DataType import *
22 from Common.Misc import *
23 from types import *
24 from Common.Expression import *
25 from CommonDataClass.CommonClass import SkuInfoClass
26 from Common.TargetTxtClassObject import *
27 from Common.ToolDefClassObject import *
28 from MetaDataTable import *
29 from MetaFileTable import *
30 from MetaFileParser import *
31
32 from WorkspaceCommon import GetDeclaredPcd
33 from Common.Misc import AnalyzeDscPcd
34 from Common.Misc import ProcessDuplicatedInf
35 import re
36 from Common.Parsing import IsValidWord
37 from Common.VariableAttributes import VariableAttributes
38 import Common.GlobalData as GlobalData
39 import subprocess
40 from Common.Misc import SaveFileOnChange
41 from Workspace.BuildClassObject import PlatformBuildClassObject, StructurePcd, PcdClassObject, ModuleBuildClassObject
42 from collections import OrderedDict
43
44 #
45 # Treat CHAR16 as a synonym for UINT16. CHAR16 support is required for VFR C structs
46 #
47 PcdValueInitName = 'PcdValueInit'
48 PcdSupportedBaseTypes = ['BOOLEAN', 'UINT8', 'UINT16', 'UINT32', 'UINT64', 'CHAR16']
49 PcdSupportedBaseTypeWidth = {'BOOLEAN':8, 'UINT8':8, 'UINT16':16, 'UINT32':32, 'UINT64':64}
50 PcdUnsupportedBaseTypes = ['INT8', 'INT16', 'INT32', 'INT64', 'CHAR8', 'UINTN', 'INTN', 'VOID']
51
52 PcdMainCHeader = '''
53 /**
54 DO NOT EDIT
55 FILE auto-generated
56 **/
57
58 #include <stdio.h>
59 #include <stdlib.h>
60 #include <string.h>
61 #include <PcdValueCommon.h>
62 '''
63
64 PcdMainCEntry = '''
65 int
66 main (
67 int argc,
68 char *argv[]
69 )
70 {
71 return PcdValueMain (argc, argv);
72 }
73 '''
74
75 PcdMakefileHeader = '''
76 #
77 # DO NOT EDIT
78 # This file is auto-generated by build utility
79 #
80
81 '''
82
83 WindowsCFLAGS = 'CFLAGS = $(CFLAGS) /wd4200 /wd4034 /wd4101 '
84 LinuxCFLAGS = 'BUILD_CFLAGS += -Wno-pointer-to-int-cast -Wno-unused-variable '
85 PcdMakefileEnd = '''
86 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.common
87
88 LIBS = $(LIB_PATH)\Common.lib
89
90 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.app
91 '''
92
93 PcdGccMakefile = '''
94 MAKEROOT ?= $(EDK_TOOLS_PATH)/Source/C
95 LIBS = -lCommon
96 '''
97
98 ## Regular expression for finding header file inclusions
99 from AutoGen.GenMake import gIncludePattern
100
101 ## Find dependencies for one source file
102 #
103 # By searching recursively "#include" directive in file, find out all the
104 # files needed by given source file. The dependecies will be only searched
105 # in given search path list.
106 #
107 # @param SearchPathList The list of search path
108 #
109 # @retval list The list of files the given source file depends on
110 #
111 def GetDependencyList(FileStack,SearchPathList):
112 DepDb = dict()
113 DependencySet = set(FileStack)
114 while len(FileStack) > 0:
115 F = FileStack.pop()
116 FullPathDependList = []
117 CurrentFileDependencyList = []
118 if F in DepDb:
119 CurrentFileDependencyList = DepDb[F]
120 else:
121 try:
122 Fd = open(F, 'r')
123 FileContent = Fd.read()
124 except BaseException, X:
125 EdkLogger.error("build", FILE_OPEN_FAILURE, ExtraData=F + "\n\t" + str(X))
126 finally:
127 if "Fd" in dir(locals()):
128 Fd.close()
129
130 if len(FileContent) == 0:
131 continue
132
133 if FileContent[0] == 0xff or FileContent[0] == 0xfe:
134 FileContent = unicode(FileContent, "utf-16")
135 IncludedFileList = gIncludePattern.findall(FileContent)
136
137 for Inc in IncludedFileList:
138 Inc = Inc.strip()
139 Inc = os.path.normpath(Inc)
140 CurrentFileDependencyList.append(Inc)
141 DepDb[F] = CurrentFileDependencyList
142
143 CurrentFilePath = os.path.dirname(F)
144 PathList = [CurrentFilePath] + SearchPathList
145 for Inc in CurrentFileDependencyList:
146 for SearchPath in PathList:
147 FilePath = os.path.join(SearchPath, Inc)
148 if not os.path.exists(FilePath):
149 continue
150 if FilePath not in DependencySet:
151 FileStack.append(FilePath)
152 FullPathDependList.append(FilePath)
153 break
154 DependencySet.update(FullPathDependList)
155 DependencyList = list(DependencySet) # remove duplicate ones
156
157 return DependencyList
158
159 class DscBuildData(PlatformBuildClassObject):
160 # dict used to convert PCD type in database to string used by build tool
161 _PCD_TYPE_STRING_ = {
162 MODEL_PCD_FIXED_AT_BUILD : "FixedAtBuild",
163 MODEL_PCD_PATCHABLE_IN_MODULE : "PatchableInModule",
164 MODEL_PCD_FEATURE_FLAG : "FeatureFlag",
165 MODEL_PCD_DYNAMIC : "Dynamic",
166 MODEL_PCD_DYNAMIC_DEFAULT : "Dynamic",
167 MODEL_PCD_DYNAMIC_HII : "DynamicHii",
168 MODEL_PCD_DYNAMIC_VPD : "DynamicVpd",
169 MODEL_PCD_DYNAMIC_EX : "DynamicEx",
170 MODEL_PCD_DYNAMIC_EX_DEFAULT : "DynamicEx",
171 MODEL_PCD_DYNAMIC_EX_HII : "DynamicExHii",
172 MODEL_PCD_DYNAMIC_EX_VPD : "DynamicExVpd",
173 }
174
175 # dict used to convert part of [Defines] to members of DscBuildData directly
176 _PROPERTY_ = {
177 #
178 # Required Fields
179 #
180 TAB_DSC_DEFINES_PLATFORM_NAME : "_PlatformName",
181 TAB_DSC_DEFINES_PLATFORM_GUID : "_Guid",
182 TAB_DSC_DEFINES_PLATFORM_VERSION : "_Version",
183 TAB_DSC_DEFINES_DSC_SPECIFICATION : "_DscSpecification",
184 # TAB_DSC_DEFINES_OUTPUT_DIRECTORY : "_OutputDirectory",
185 # TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES : "_SupArchList",
186 # TAB_DSC_DEFINES_BUILD_TARGETS : "_BuildTargets",
187 TAB_DSC_DEFINES_SKUID_IDENTIFIER : "_SkuName",
188 # TAB_DSC_DEFINES_FLASH_DEFINITION : "_FlashDefinition",
189 TAB_DSC_DEFINES_BUILD_NUMBER : "_BuildNumber",
190 TAB_DSC_DEFINES_MAKEFILE_NAME : "_MakefileName",
191 TAB_DSC_DEFINES_BS_BASE_ADDRESS : "_BsBaseAddress",
192 TAB_DSC_DEFINES_RT_BASE_ADDRESS : "_RtBaseAddress",
193 # TAB_DSC_DEFINES_RFC_LANGUAGES : "_RFCLanguages",
194 # TAB_DSC_DEFINES_ISO_LANGUAGES : "_ISOLanguages",
195 }
196
197 # used to compose dummy library class name for those forced library instances
198 _NullLibraryNumber = 0
199
200 ## Constructor of DscBuildData
201 #
202 # Initialize object of DscBuildData
203 #
204 # @param FilePath The path of platform description file
205 # @param RawData The raw data of DSC file
206 # @param BuildDataBase Database used to retrieve module/package information
207 # @param Arch The target architecture
208 # @param Platform (not used for DscBuildData)
209 # @param Macros Macros used for replacement in DSC file
210 #
211 def __init__(self, FilePath, RawData, BuildDataBase, Arch='COMMON', Target=None, Toolchain=None):
212 self.MetaFile = FilePath
213 self._RawData = RawData
214 self._Bdb = BuildDataBase
215 self._Arch = Arch
216 self._Target = Target
217 self._Toolchain = Toolchain
218 self._ToolChainFamily = None
219 self._Clear()
220 self._HandleOverridePath()
221 self.WorkspaceDir = os.getenv("WORKSPACE") if os.getenv("WORKSPACE") else ""
222 self.DefaultStores = None
223 self.SkuIdMgr = SkuClass(self.SkuName, self.SkuIds)
224 @property
225 def OutputPath(self):
226 if os.getenv("WORKSPACE"):
227 return os.path.join(os.getenv("WORKSPACE"), self.OutputDirectory, self._Target + "_" + self._Toolchain,PcdValueInitName)
228 else:
229 return os.path.dirname(self.DscFile)
230
231 ## XXX[key] = value
232 def __setitem__(self, key, value):
233 self.__dict__[self._PROPERTY_[key]] = value
234
235 ## value = XXX[key]
236 def __getitem__(self, key):
237 return self.__dict__[self._PROPERTY_[key]]
238
239 ## "in" test support
240 def __contains__(self, key):
241 return key in self._PROPERTY_
242
243 ## Set all internal used members of DscBuildData to None
244 def _Clear(self):
245 self._Header = None
246 self._PlatformName = None
247 self._Guid = None
248 self._Version = None
249 self._DscSpecification = None
250 self._OutputDirectory = None
251 self._SupArchList = None
252 self._BuildTargets = None
253 self._SkuName = None
254 self._PcdInfoFlag = None
255 self._VarCheckFlag = None
256 self._FlashDefinition = None
257 self._Prebuild = None
258 self._Postbuild = None
259 self._BuildNumber = None
260 self._MakefileName = None
261 self._BsBaseAddress = None
262 self._RtBaseAddress = None
263 self._SkuIds = None
264 self._Modules = None
265 self._LibraryInstances = None
266 self._LibraryClasses = None
267 self._Pcds = None
268 self._DecPcds = None
269 self._BuildOptions = None
270 self._ModuleTypeOptions = None
271 self._LoadFixAddress = None
272 self._RFCLanguages = None
273 self._ISOLanguages = None
274 self._VpdToolGuid = None
275 self.__Macros = None
276 self.DefaultStores = None
277
278
279 ## handle Override Path of Module
280 def _HandleOverridePath(self):
281 RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]
282 Macros = self._Macros
283 Macros["EDK_SOURCE"] = GlobalData.gEcpSource
284 for Record in RecordList:
285 ModuleId = Record[6]
286 LineNo = Record[7]
287 ModuleFile = PathClass(NormPath(Record[0]), GlobalData.gWorkspace, Arch=self._Arch)
288 RecordList = self._RawData[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH, self._Arch, None, ModuleId]
289 if RecordList != []:
290 SourceOverridePath = mws.join(GlobalData.gWorkspace, NormPath(RecordList[0][0]))
291
292 # Check if the source override path exists
293 if not os.path.isdir(SourceOverridePath):
294 EdkLogger.error('build', FILE_NOT_FOUND, Message='Source override path does not exist:', File=self.MetaFile, ExtraData=SourceOverridePath, Line=LineNo)
295
296 # Add to GlobalData Variables
297 GlobalData.gOverrideDir[ModuleFile.Key] = SourceOverridePath
298
299 ## Get current effective macros
300 def _GetMacros(self):
301 if self.__Macros is None:
302 self.__Macros = {}
303 self.__Macros.update(GlobalData.gPlatformDefines)
304 self.__Macros.update(GlobalData.gGlobalDefines)
305 self.__Macros.update(GlobalData.gCommandLineDefines)
306 return self.__Macros
307
308 ## Get architecture
309 def _GetArch(self):
310 return self._Arch
311
312 ## Set architecture
313 #
314 # Changing the default ARCH to another may affect all other information
315 # because all information in a platform may be ARCH-related. That's
316 # why we need to clear all internal used members, in order to cause all
317 # information to be re-retrieved.
318 #
319 # @param Value The value of ARCH
320 #
321 def _SetArch(self, Value):
322 if self._Arch == Value:
323 return
324 self._Arch = Value
325 self._Clear()
326
327 ## Retrieve all information in [Defines] section
328 #
329 # (Retriving all [Defines] information in one-shot is just to save time.)
330 #
331 def _GetHeaderInfo(self):
332 RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]
333 for Record in RecordList:
334 Name = Record[1]
335 # items defined _PROPERTY_ don't need additional processing
336
337 # some special items in [Defines] section need special treatment
338 if Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:
339 self._OutputDirectory = NormPath(Record[2], self._Macros)
340 if ' ' in self._OutputDirectory:
341 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",
342 File=self.MetaFile, Line=Record[-1],
343 ExtraData=self._OutputDirectory)
344 elif Name == TAB_DSC_DEFINES_FLASH_DEFINITION:
345 self._FlashDefinition = PathClass(NormPath(Record[2], self._Macros), GlobalData.gWorkspace)
346 ErrorCode, ErrorInfo = self._FlashDefinition.Validate('.fdf')
347 if ErrorCode != 0:
348 EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=Record[-1],
349 ExtraData=ErrorInfo)
350 elif Name == TAB_DSC_PREBUILD:
351 PrebuildValue = Record[2]
352 if Record[2][0] == '"':
353 if Record[2][-1] != '"':
354 EdkLogger.error('build', FORMAT_INVALID, 'Missing double quotes in the end of %s statement.' % TAB_DSC_PREBUILD,
355 File=self.MetaFile, Line=Record[-1])
356 PrebuildValue = Record[2][1:-1]
357 self._Prebuild = PrebuildValue
358 elif Name == TAB_DSC_POSTBUILD:
359 PostbuildValue = Record[2]
360 if Record[2][0] == '"':
361 if Record[2][-1] != '"':
362 EdkLogger.error('build', FORMAT_INVALID, 'Missing double quotes in the end of %s statement.' % TAB_DSC_POSTBUILD,
363 File=self.MetaFile, Line=Record[-1])
364 PostbuildValue = Record[2][1:-1]
365 self._Postbuild = PostbuildValue
366 elif Name == TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES:
367 self._SupArchList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)
368 elif Name == TAB_DSC_DEFINES_BUILD_TARGETS:
369 self._BuildTargets = GetSplitValueList(Record[2])
370 elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:
371 if self._SkuName is None:
372 self._SkuName = Record[2]
373 if GlobalData.gSKUID_CMD:
374 self._SkuName = GlobalData.gSKUID_CMD
375 elif Name == TAB_DSC_DEFINES_PCD_INFO_GENERATION:
376 self._PcdInfoFlag = Record[2]
377 elif Name == TAB_DSC_DEFINES_PCD_VAR_CHECK_GENERATION:
378 self._VarCheckFlag = Record[2]
379 elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:
380 try:
381 self._LoadFixAddress = int (Record[2], 0)
382 except:
383 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (Record[2]))
384 elif Name == TAB_DSC_DEFINES_RFC_LANGUAGES:
385 if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:
386 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for RFC_LANGUAGES must have double quotes around it, for example: RFC_LANGUAGES = "en-us;zh-hans"',
387 File=self.MetaFile, Line=Record[-1])
388 LanguageCodes = Record[2][1:-1]
389 if not LanguageCodes:
390 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more RFC4646 format language code must be provided for RFC_LANGUAGES statement',
391 File=self.MetaFile, Line=Record[-1])
392 LanguageList = GetSplitValueList(LanguageCodes, TAB_SEMI_COLON_SPLIT)
393 # check whether there is empty entries in the list
394 if None in LanguageList:
395 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more empty language code is in RFC_LANGUAGES statement',
396 File=self.MetaFile, Line=Record[-1])
397 self._RFCLanguages = LanguageList
398 elif Name == TAB_DSC_DEFINES_ISO_LANGUAGES:
399 if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:
400 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for ISO_LANGUAGES must have double quotes around it, for example: ISO_LANGUAGES = "engchn"',
401 File=self.MetaFile, Line=Record[-1])
402 LanguageCodes = Record[2][1:-1]
403 if not LanguageCodes:
404 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more ISO639-2 format language code must be provided for ISO_LANGUAGES statement',
405 File=self.MetaFile, Line=Record[-1])
406 if len(LanguageCodes) % 3:
407 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'bad ISO639-2 format for ISO_LANGUAGES',
408 File=self.MetaFile, Line=Record[-1])
409 LanguageList = []
410 for i in range(0, len(LanguageCodes), 3):
411 LanguageList.append(LanguageCodes[i:i + 3])
412 self._ISOLanguages = LanguageList
413 elif Name == TAB_DSC_DEFINES_VPD_TOOL_GUID:
414 #
415 # try to convert GUID to a real UUID value to see whether the GUID is format
416 # for VPD_TOOL_GUID is correct.
417 #
418 try:
419 uuid.UUID(Record[2])
420 except:
421 EdkLogger.error("build", FORMAT_INVALID, "Invalid GUID format for VPD_TOOL_GUID", File=self.MetaFile)
422 self._VpdToolGuid = Record[2]
423 elif Name in self:
424 self[Name] = Record[2]
425 # set _Header to non-None in order to avoid database re-querying
426 self._Header = 'DUMMY'
427
428 ## Retrieve platform name
429 def _GetPlatformName(self):
430 if self._PlatformName is None:
431 if self._Header is None:
432 self._GetHeaderInfo()
433 if self._PlatformName is None:
434 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_NAME", File=self.MetaFile)
435 return self._PlatformName
436
437 ## Retrieve file guid
438 def _GetFileGuid(self):
439 if self._Guid is None:
440 if self._Header is None:
441 self._GetHeaderInfo()
442 if self._Guid is None:
443 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_GUID", File=self.MetaFile)
444 return self._Guid
445
446 ## Retrieve platform version
447 def _GetVersion(self):
448 if self._Version is None:
449 if self._Header is None:
450 self._GetHeaderInfo()
451 if self._Version is None:
452 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_VERSION", File=self.MetaFile)
453 return self._Version
454
455 ## Retrieve platform description file version
456 def _GetDscSpec(self):
457 if self._DscSpecification is None:
458 if self._Header is None:
459 self._GetHeaderInfo()
460 if self._DscSpecification is None:
461 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No DSC_SPECIFICATION", File=self.MetaFile)
462 return self._DscSpecification
463
464 ## Retrieve OUTPUT_DIRECTORY
465 def _GetOutpuDir(self):
466 if self._OutputDirectory is None:
467 if self._Header is None:
468 self._GetHeaderInfo()
469 if self._OutputDirectory is None:
470 self._OutputDirectory = os.path.join("Build", self._PlatformName)
471 return self._OutputDirectory
472
473 ## Retrieve SUPPORTED_ARCHITECTURES
474 def _GetSupArch(self):
475 if self._SupArchList is None:
476 if self._Header is None:
477 self._GetHeaderInfo()
478 if self._SupArchList is None:
479 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No SUPPORTED_ARCHITECTURES", File=self.MetaFile)
480 return self._SupArchList
481
482 ## Retrieve BUILD_TARGETS
483 def _GetBuildTarget(self):
484 if self._BuildTargets is None:
485 if self._Header is None:
486 self._GetHeaderInfo()
487 if self._BuildTargets is None:
488 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BUILD_TARGETS", File=self.MetaFile)
489 return self._BuildTargets
490
491 def _GetPcdInfoFlag(self):
492 if self._PcdInfoFlag is None or self._PcdInfoFlag.upper() == 'FALSE':
493 return False
494 elif self._PcdInfoFlag.upper() == 'TRUE':
495 return True
496 else:
497 return False
498 def _GetVarCheckFlag(self):
499 if self._VarCheckFlag is None or self._VarCheckFlag.upper() == 'FALSE':
500 return False
501 elif self._VarCheckFlag.upper() == 'TRUE':
502 return True
503 else:
504 return False
505
506 # # Retrieve SKUID_IDENTIFIER
507 def _GetSkuName(self):
508 if self._SkuName is None:
509 if self._Header is None:
510 self._GetHeaderInfo()
511 if self._SkuName is None:
512 self._SkuName = 'DEFAULT'
513 return self._SkuName
514
515 ## Override SKUID_IDENTIFIER
516 def _SetSkuName(self, Value):
517 self._SkuName = Value
518
519 def _GetFdfFile(self):
520 if self._FlashDefinition is None:
521 if self._Header is None:
522 self._GetHeaderInfo()
523 if self._FlashDefinition is None:
524 self._FlashDefinition = ''
525 return self._FlashDefinition
526
527 def _GetPrebuild(self):
528 if self._Prebuild is None:
529 if self._Header is None:
530 self._GetHeaderInfo()
531 if self._Prebuild is None:
532 self._Prebuild = ''
533 return self._Prebuild
534
535 def _GetPostbuild(self):
536 if self._Postbuild is None:
537 if self._Header is None:
538 self._GetHeaderInfo()
539 if self._Postbuild is None:
540 self._Postbuild = ''
541 return self._Postbuild
542
543 ## Retrieve FLASH_DEFINITION
544 def _GetBuildNumber(self):
545 if self._BuildNumber is None:
546 if self._Header is None:
547 self._GetHeaderInfo()
548 if self._BuildNumber is None:
549 self._BuildNumber = ''
550 return self._BuildNumber
551
552 ## Retrieve MAKEFILE_NAME
553 def _GetMakefileName(self):
554 if self._MakefileName is None:
555 if self._Header is None:
556 self._GetHeaderInfo()
557 if self._MakefileName is None:
558 self._MakefileName = ''
559 return self._MakefileName
560
561 ## Retrieve BsBaseAddress
562 def _GetBsBaseAddress(self):
563 if self._BsBaseAddress is None:
564 if self._Header is None:
565 self._GetHeaderInfo()
566 if self._BsBaseAddress is None:
567 self._BsBaseAddress = ''
568 return self._BsBaseAddress
569
570 ## Retrieve RtBaseAddress
571 def _GetRtBaseAddress(self):
572 if self._RtBaseAddress is None:
573 if self._Header is None:
574 self._GetHeaderInfo()
575 if self._RtBaseAddress is None:
576 self._RtBaseAddress = ''
577 return self._RtBaseAddress
578
579 ## Retrieve the top address for the load fix address
580 def _GetLoadFixAddress(self):
581 if self._LoadFixAddress is None:
582 if self._Header is None:
583 self._GetHeaderInfo()
584
585 if self._LoadFixAddress is None:
586 self._LoadFixAddress = self._Macros.get(TAB_FIX_LOAD_TOP_MEMORY_ADDRESS, '0')
587
588 try:
589 self._LoadFixAddress = int (self._LoadFixAddress, 0)
590 except:
591 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (self._LoadFixAddress))
592
593 #
594 # If command line defined, should override the value in DSC file.
595 #
596 if 'FIX_LOAD_TOP_MEMORY_ADDRESS' in GlobalData.gCommandLineDefines.keys():
597 try:
598 self._LoadFixAddress = int(GlobalData.gCommandLineDefines['FIX_LOAD_TOP_MEMORY_ADDRESS'], 0)
599 except:
600 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (GlobalData.gCommandLineDefines['FIX_LOAD_TOP_MEMORY_ADDRESS']))
601
602 if self._LoadFixAddress < 0:
603 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid negative value 0x%x" % (self._LoadFixAddress))
604 if self._LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self._LoadFixAddress % 0x1000 != 0:
605 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid unaligned 4K value 0x%x" % (self._LoadFixAddress))
606
607 return self._LoadFixAddress
608
609 ## Retrieve RFCLanguage filter
610 def _GetRFCLanguages(self):
611 if self._RFCLanguages is None:
612 if self._Header is None:
613 self._GetHeaderInfo()
614 if self._RFCLanguages is None:
615 self._RFCLanguages = []
616 return self._RFCLanguages
617
618 ## Retrieve ISOLanguage filter
619 def _GetISOLanguages(self):
620 if self._ISOLanguages is None:
621 if self._Header is None:
622 self._GetHeaderInfo()
623 if self._ISOLanguages is None:
624 self._ISOLanguages = []
625 return self._ISOLanguages
626 ## Retrieve the GUID string for VPD tool
627 def _GetVpdToolGuid(self):
628 if self._VpdToolGuid is None:
629 if self._Header is None:
630 self._GetHeaderInfo()
631 if self._VpdToolGuid is None:
632 self._VpdToolGuid = ''
633 return self._VpdToolGuid
634
635 ## Retrieve [SkuIds] section information
636 def _GetSkuIds(self):
637 if self._SkuIds is None:
638 self._SkuIds = OrderedDict()
639 RecordList = self._RawData[MODEL_EFI_SKU_ID, self._Arch]
640 for Record in RecordList:
641 if Record[0] in [None, '']:
642 EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID number',
643 File=self.MetaFile, Line=Record[-1])
644 if Record[1] in [None, '']:
645 EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID name',
646 File=self.MetaFile, Line=Record[-1])
647 Pattern = re.compile('^[1-9]\d*|0$')
648 HexPattern = re.compile(r'0[xX][0-9a-fA-F]+$')
649 if Pattern.match(Record[0]) is None and HexPattern.match(Record[0]) is None:
650 EdkLogger.error('build', FORMAT_INVALID, "The format of the Sku ID number is invalid. It only support Integer and HexNumber",
651 File=self.MetaFile, Line=Record[-1])
652 if not IsValidWord(Record[1]):
653 EdkLogger.error('build', FORMAT_INVALID, "The format of the Sku ID name is invalid. The correct format is '(a-zA-Z0-9_)(a-zA-Z0-9_-.)*'",
654 File=self.MetaFile, Line=Record[-1])
655 self._SkuIds[Record[1].upper()] = (str(self.ToInt(Record[0])), Record[1].upper(), Record[2].upper())
656 if 'DEFAULT' not in self._SkuIds:
657 self._SkuIds['DEFAULT'] = ("0","DEFAULT","DEFAULT")
658 if 'COMMON' not in self._SkuIds:
659 self._SkuIds['COMMON'] = ("0","DEFAULT","DEFAULT")
660 return self._SkuIds
661 def ToInt(self,intstr):
662 return int(intstr,16) if intstr.upper().startswith("0X") else int(intstr)
663 def _GetDefaultStores(self):
664 if self.DefaultStores is None:
665 self.DefaultStores = OrderedDict()
666 RecordList = self._RawData[MODEL_EFI_DEFAULT_STORES, self._Arch]
667 for Record in RecordList:
668 if Record[0] in [None, '']:
669 EdkLogger.error('build', FORMAT_INVALID, 'No DefaultStores ID number',
670 File=self.MetaFile, Line=Record[-1])
671 if Record[1] in [None, '']:
672 EdkLogger.error('build', FORMAT_INVALID, 'No DefaultStores ID name',
673 File=self.MetaFile, Line=Record[-1])
674 Pattern = re.compile('^[1-9]\d*|0$')
675 HexPattern = re.compile(r'0[xX][0-9a-fA-F]+$')
676 if Pattern.match(Record[0]) is None and HexPattern.match(Record[0]) is None:
677 EdkLogger.error('build', FORMAT_INVALID, "The format of the DefaultStores ID number is invalid. It only support Integer and HexNumber",
678 File=self.MetaFile, Line=Record[-1])
679 if not IsValidWord(Record[1]):
680 EdkLogger.error('build', FORMAT_INVALID, "The format of the DefaultStores ID name is invalid. The correct format is '(a-zA-Z0-9_)(a-zA-Z0-9_-.)*'",
681 File=self.MetaFile, Line=Record[-1])
682 self.DefaultStores[Record[1].upper()] = (self.ToInt(Record[0]),Record[1].upper())
683 if TAB_DEFAULT_STORES_DEFAULT not in self.DefaultStores:
684 self.DefaultStores[TAB_DEFAULT_STORES_DEFAULT] = (0,TAB_DEFAULT_STORES_DEFAULT)
685 GlobalData.gDefaultStores = self.DefaultStores.keys()
686 if GlobalData.gDefaultStores:
687 GlobalData.gDefaultStores.sort()
688 return self.DefaultStores
689
690 ## Retrieve [Components] section information
691 def _GetModules(self):
692 if self._Modules is not None:
693 return self._Modules
694
695 self._Modules = OrderedDict()
696 RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]
697 Macros = self._Macros
698 Macros["EDK_SOURCE"] = GlobalData.gEcpSource
699 for Record in RecordList:
700 DuplicatedFile = False
701
702 ModuleFile = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
703 ModuleId = Record[6]
704 LineNo = Record[7]
705
706 # check the file validation
707 ErrorCode, ErrorInfo = ModuleFile.Validate('.inf')
708 if ErrorCode != 0:
709 EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
710 ExtraData=ErrorInfo)
711 # Check duplication
712 # If arch is COMMON, no duplicate module is checked since all modules in all component sections are selected
713 if self._Arch != 'COMMON' and ModuleFile in self._Modules:
714 DuplicatedFile = True
715
716 Module = ModuleBuildClassObject()
717 Module.MetaFile = ModuleFile
718
719 # get module private library instance
720 RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, ModuleId]
721 for Record in RecordList:
722 LibraryClass = Record[0]
723 LibraryPath = PathClass(NormPath(Record[1], Macros), GlobalData.gWorkspace, Arch=self._Arch)
724 LineNo = Record[-1]
725
726 # check the file validation
727 ErrorCode, ErrorInfo = LibraryPath.Validate('.inf')
728 if ErrorCode != 0:
729 EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
730 ExtraData=ErrorInfo)
731
732 if LibraryClass == '' or LibraryClass == 'NULL':
733 self._NullLibraryNumber += 1
734 LibraryClass = 'NULL%d' % self._NullLibraryNumber
735 EdkLogger.verbose("Found forced library for %s\n\t%s [%s]" % (ModuleFile, LibraryPath, LibraryClass))
736 Module.LibraryClasses[LibraryClass] = LibraryPath
737 if LibraryPath not in self.LibraryInstances:
738 self.LibraryInstances.append(LibraryPath)
739
740 # get module private PCD setting
741 for Type in [MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE, \
742 MODEL_PCD_FEATURE_FLAG, MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:
743 RecordList = self._RawData[Type, self._Arch, None, ModuleId]
744 for TokenSpaceGuid, PcdCName, Setting, Dummy1, Dummy2, Dummy3, Dummy4,Dummy5 in RecordList:
745 TokenList = GetSplitValueList(Setting)
746 DefaultValue = TokenList[0]
747 # the format is PcdName| Value | VOID* | MaxDatumSize
748 if len(TokenList) > 2:
749 MaxDatumSize = TokenList[2]
750 else:
751 MaxDatumSize = ''
752 TypeString = self._PCD_TYPE_STRING_[Type]
753 Pcd = PcdClassObject(
754 PcdCName,
755 TokenSpaceGuid,
756 TypeString,
757 '',
758 DefaultValue,
759 '',
760 MaxDatumSize,
761 {},
762 False,
763 None
764 )
765 Module.Pcds[PcdCName, TokenSpaceGuid] = Pcd
766
767 # get module private build options
768 RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, None, ModuleId]
769 for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4,Dummy5 in RecordList:
770 if (ToolChainFamily, ToolChain) not in Module.BuildOptions:
771 Module.BuildOptions[ToolChainFamily, ToolChain] = Option
772 else:
773 OptionString = Module.BuildOptions[ToolChainFamily, ToolChain]
774 Module.BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option
775
776 RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, None, ModuleId]
777 if DuplicatedFile and not RecordList:
778 EdkLogger.error('build', FILE_DUPLICATED, File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)
779 if RecordList:
780 if len(RecordList) != 1:
781 EdkLogger.error('build', OPTION_UNKNOWN, 'Only FILE_GUID can be listed in <Defines> section.',
782 File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)
783 ModuleFile = ProcessDuplicatedInf(ModuleFile, RecordList[0][2], GlobalData.gWorkspace)
784 ModuleFile.Arch = self._Arch
785
786 self._Modules[ModuleFile] = Module
787 return self._Modules
788
789 ## Retrieve all possible library instances used in this platform
790 def _GetLibraryInstances(self):
791 if self._LibraryInstances is None:
792 self._GetLibraryClasses()
793 return self._LibraryInstances
794
795 ## Retrieve [LibraryClasses] information
796 def _GetLibraryClasses(self):
797 if self._LibraryClasses is None:
798 self._LibraryInstances = []
799 #
800 # tdict is a special dict kind of type, used for selecting correct
801 # library instance for given library class and module type
802 #
803 LibraryClassDict = tdict(True, 3)
804 # track all library class names
805 LibraryClassSet = set()
806 RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, -1]
807 Macros = self._Macros
808 for Record in RecordList:
809 LibraryClass, LibraryInstance, Dummy, Arch, ModuleType, Dummy,Dummy, LineNo = Record
810 if LibraryClass == '' or LibraryClass == 'NULL':
811 self._NullLibraryNumber += 1
812 LibraryClass = 'NULL%d' % self._NullLibraryNumber
813 EdkLogger.verbose("Found forced library for arch=%s\n\t%s [%s]" % (Arch, LibraryInstance, LibraryClass))
814 LibraryClassSet.add(LibraryClass)
815 LibraryInstance = PathClass(NormPath(LibraryInstance, Macros), GlobalData.gWorkspace, Arch=self._Arch)
816 # check the file validation
817 ErrorCode, ErrorInfo = LibraryInstance.Validate('.inf')
818 if ErrorCode != 0:
819 EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
820 ExtraData=ErrorInfo)
821
822 if ModuleType != 'COMMON' and ModuleType not in SUP_MODULE_LIST:
823 EdkLogger.error('build', OPTION_UNKNOWN, "Unknown module type [%s]" % ModuleType,
824 File=self.MetaFile, ExtraData=LibraryInstance, Line=LineNo)
825 LibraryClassDict[Arch, ModuleType, LibraryClass] = LibraryInstance
826 if LibraryInstance not in self._LibraryInstances:
827 self._LibraryInstances.append(LibraryInstance)
828
829 # resolve the specific library instance for each class and each module type
830 self._LibraryClasses = tdict(True)
831 for LibraryClass in LibraryClassSet:
832 # try all possible module types
833 for ModuleType in SUP_MODULE_LIST:
834 LibraryInstance = LibraryClassDict[self._Arch, ModuleType, LibraryClass]
835 if LibraryInstance is None:
836 continue
837 self._LibraryClasses[LibraryClass, ModuleType] = LibraryInstance
838
839 # for Edk style library instances, which are listed in different section
840 Macros["EDK_SOURCE"] = GlobalData.gEcpSource
841 RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch]
842 for Record in RecordList:
843 File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
844 LineNo = Record[-1]
845 # check the file validation
846 ErrorCode, ErrorInfo = File.Validate('.inf')
847 if ErrorCode != 0:
848 EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
849 ExtraData=ErrorInfo)
850 if File not in self._LibraryInstances:
851 self._LibraryInstances.append(File)
852 #
853 # we need the module name as the library class name, so we have
854 # to parse it here. (self._Bdb[] will trigger a file parse if it
855 # hasn't been parsed)
856 #
857 Library = self._Bdb[File, self._Arch, self._Target, self._Toolchain]
858 self._LibraryClasses[Library.BaseName, ':dummy:'] = Library
859 return self._LibraryClasses
860
861 def _ValidatePcd(self, PcdCName, TokenSpaceGuid, Setting, PcdType, LineNo):
862 if self._DecPcds is None:
863
864 FdfInfList = []
865 if GlobalData.gFdfParser:
866 FdfInfList = GlobalData.gFdfParser.Profile.InfList
867
868 PkgSet = set()
869 for Inf in FdfInfList:
870 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch=self._Arch)
871 if ModuleFile in self._Modules:
872 continue
873 ModuleData = self._Bdb[ModuleFile, self._Arch, self._Target, self._Toolchain]
874 PkgSet.update(ModuleData.Packages)
875
876 self._DecPcds, self._GuidDict = GetDeclaredPcd(self, self._Bdb, self._Arch, self._Target, self._Toolchain,PkgSet)
877 self._GuidDict.update(GlobalData.gPlatformPcds)
878
879 if (PcdCName, TokenSpaceGuid) not in self._DecPcds:
880 EdkLogger.error('build', PARSER_ERROR,
881 "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (TokenSpaceGuid, PcdCName, self._Arch),
882 File=self.MetaFile, Line=LineNo)
883 ValueList, IsValid, Index = AnalyzeDscPcd(Setting, PcdType, self._DecPcds[PcdCName, TokenSpaceGuid].DatumType)
884 if not IsValid:
885 if PcdType not in [MODEL_PCD_FEATURE_FLAG, MODEL_PCD_FIXED_AT_BUILD]:
886 EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect.", File=self.MetaFile, Line=LineNo,
887 ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))
888 else:
889 if ValueList[2] == '-1':
890 EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect.", File=self.MetaFile, Line=LineNo,
891 ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))
892 if ValueList[Index]:
893 DatumType = self._DecPcds[PcdCName, TokenSpaceGuid].DatumType
894 try:
895 ValueList[Index] = ValueExpressionEx(ValueList[Index], DatumType, self._GuidDict)(True)
896 except BadExpression, Value:
897 EdkLogger.error('Parser', FORMAT_INVALID, Value, File=self.MetaFile, Line=LineNo,
898 ExtraData="PCD [%s.%s] Value \"%s\" " % (
899 TokenSpaceGuid, PcdCName, ValueList[Index]))
900 except EvaluationException, Excpt:
901 if hasattr(Excpt, 'Pcd'):
902 if Excpt.Pcd in GlobalData.gPlatformOtherPcds:
903 EdkLogger.error('Parser', FORMAT_INVALID, "Cannot use this PCD (%s) in an expression as"
904 " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"
905 " of the DSC file" % Excpt.Pcd,
906 File=self.MetaFile, Line=LineNo)
907 else:
908 EdkLogger.error('Parser', FORMAT_INVALID, "PCD (%s) is not defined in DSC file" % Excpt.Pcd,
909 File=self.MetaFile, Line=LineNo)
910 else:
911 EdkLogger.error('Parser', FORMAT_INVALID, "Invalid expression: %s" % str(Excpt),
912 File=self.MetaFile, Line=LineNo)
913
914 if ValueList[Index]:
915 Valid, ErrStr = CheckPcdDatum(self._DecPcds[PcdCName, TokenSpaceGuid].DatumType, ValueList[Index])
916 if not Valid:
917 EdkLogger.error('build', FORMAT_INVALID, ErrStr, File=self.MetaFile, Line=LineNo,
918 ExtraData="%s.%s" % (TokenSpaceGuid, PcdCName))
919 if PcdType in (MODEL_PCD_DYNAMIC_DEFAULT, MODEL_PCD_DYNAMIC_EX_DEFAULT):
920 if self._DecPcds[PcdCName, TokenSpaceGuid].DatumType.strip() != ValueList[1].strip():
921 EdkLogger.error('build', FORMAT_INVALID, "Pcd datumtype used in DSC file is not the same as its declaration in DEC file." , File=self.MetaFile, Line=LineNo,
922 ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))
923 if (TokenSpaceGuid + '.' + PcdCName) in GlobalData.gPlatformPcds:
924 if GlobalData.gPlatformPcds[TokenSpaceGuid + '.' + PcdCName] != ValueList[Index]:
925 GlobalData.gPlatformPcds[TokenSpaceGuid + '.' + PcdCName] = ValueList[Index]
926 return ValueList
927
928 def _FilterPcdBySkuUsage(self,Pcds):
929 available_sku = self.SkuIdMgr.AvailableSkuIdSet
930 sku_usage = self.SkuIdMgr.SkuUsageType
931 if sku_usage == SkuClass.SINGLE:
932 for pcdname in Pcds:
933 pcd = Pcds[pcdname]
934 Pcds[pcdname].SkuInfoList = {"DEFAULT":pcd.SkuInfoList[skuid] for skuid in pcd.SkuInfoList if skuid in available_sku}
935 if type(pcd) is StructurePcd and pcd.SkuOverrideValues:
936 Pcds[pcdname].SkuOverrideValues = {"DEFAULT":pcd.SkuOverrideValues[skuid] for skuid in pcd.SkuOverrideValues if skuid in available_sku}
937 else:
938 for pcdname in Pcds:
939 pcd = Pcds[pcdname]
940 Pcds[pcdname].SkuInfoList = {skuid:pcd.SkuInfoList[skuid] for skuid in pcd.SkuInfoList if skuid in available_sku}
941 if type(pcd) is StructurePcd and pcd.SkuOverrideValues:
942 Pcds[pcdname].SkuOverrideValues = {skuid:pcd.SkuOverrideValues[skuid] for skuid in pcd.SkuOverrideValues if skuid in available_sku}
943 return Pcds
944 def CompleteHiiPcdsDefaultStores(self,Pcds):
945 HiiPcd = [Pcds[pcd] for pcd in Pcds if Pcds[pcd].Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]]
946 DefaultStoreMgr = DefaultStore(self.DefaultStores)
947 for pcd in HiiPcd:
948 for skuid in pcd.SkuInfoList:
949 skuobj = pcd.SkuInfoList.get(skuid)
950 if TAB_DEFAULT_STORES_DEFAULT not in skuobj.DefaultStoreDict:
951 PcdDefaultStoreSet = set([defaultstorename for defaultstorename in skuobj.DefaultStoreDict])
952 mindefaultstorename = DefaultStoreMgr.GetMin(PcdDefaultStoreSet)
953 skuobj.DefaultStoreDict[TAB_DEFAULT_STORES_DEFAULT] = copy.deepcopy(skuobj.DefaultStoreDict[mindefaultstorename])
954 return Pcds
955
956 def RecoverCommandLinePcd(self):
957 def UpdateCommandLineValue(pcd):
958 if pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
959 self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
960 pcd.PcdValueFromComm = pcd.DefaultValue
961 elif pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
962 pcd.PcdValueFromComm = pcd.SkuInfoList.get("DEFAULT").HiiDefaultValue
963 else:
964 pcd.PcdValueFromComm = pcd.SkuInfoList.get("DEFAULT").DefaultValue
965 for pcd in self._Pcds:
966 if isinstance(self._Pcds[pcd],StructurePcd) and (self._Pcds[pcd].PcdValueFromComm or self._Pcds[pcd].PcdFieldValueFromComm):
967 UpdateCommandLineValue(self._Pcds[pcd])
968
969 def __ParsePcdFromCommandLine(self):
970 if GlobalData.BuildOptionPcd:
971 for i, pcd in enumerate(GlobalData.BuildOptionPcd):
972 if type(pcd) is tuple:
973 continue
974 (pcdname, pcdvalue) = pcd.split('=')
975 if not pcdvalue:
976 EdkLogger.error('build', AUTOGEN_ERROR, "No Value specified for the PCD %s." % (pcdname))
977 if '.' in pcdname:
978 (Name1, Name2) = pcdname.split('.',1)
979 if "." in Name2:
980 (Name3, FieldName) = Name2.split(".",1)
981 if ((Name3,Name1)) in self.DecPcds:
982 HasTokenSpace = True
983 TokenCName = Name3
984 TokenSpaceGuidCName = Name1
985 else:
986 FieldName = Name2
987 TokenCName = Name1
988 TokenSpaceGuidCName = ''
989 HasTokenSpace = False
990 else:
991 if ((Name2,Name1)) in self.DecPcds:
992 HasTokenSpace = True
993 TokenCName = Name2
994 TokenSpaceGuidCName = Name1
995 FieldName =""
996 else:
997 FieldName = Name2
998 TokenCName = Name1
999 TokenSpaceGuidCName = ''
1000 HasTokenSpace = False
1001 else:
1002 FieldName = ""
1003 TokenCName = pcdname
1004 TokenSpaceGuidCName = ''
1005 HasTokenSpace = False
1006 TokenSpaceGuidCNameList = []
1007 FoundFlag = False
1008 PcdDatumType = ''
1009 DisplayName = TokenCName
1010 if FieldName:
1011 DisplayName = TokenCName + '.' + FieldName
1012 if not HasTokenSpace:
1013 for key in self.DecPcds:
1014 PcdItem = self.DecPcds[key]
1015 if TokenCName == PcdItem.TokenCName:
1016 if not PcdItem.TokenSpaceGuidCName in TokenSpaceGuidCNameList:
1017 if len (TokenSpaceGuidCNameList) < 1:
1018 TokenSpaceGuidCNameList.append(PcdItem.TokenSpaceGuidCName)
1019 TokenSpaceGuidCName = PcdItem.TokenSpaceGuidCName
1020 PcdDatumType = PcdItem.DatumType
1021 FoundFlag = True
1022 else:
1023 EdkLogger.error(
1024 'build',
1025 AUTOGEN_ERROR,
1026 "The Pcd %s is found under multiple different TokenSpaceGuid: %s and %s." % (DisplayName, PcdItem.TokenSpaceGuidCName, TokenSpaceGuidCNameList[0])
1027 )
1028 else:
1029 if (TokenCName, TokenSpaceGuidCName) in self.DecPcds:
1030 PcdDatumType = self.DecPcds[(TokenCName, TokenSpaceGuidCName)].DatumType
1031 FoundFlag = True
1032 if not FoundFlag:
1033 if HasTokenSpace:
1034 EdkLogger.error('build', AUTOGEN_ERROR, "The Pcd %s.%s is not found in the DEC file." % (TokenSpaceGuidCName, DisplayName))
1035 else:
1036 EdkLogger.error('build', AUTOGEN_ERROR, "The Pcd %s is not found in the DEC file." % (DisplayName))
1037 pcdvalue = pcdvalue.replace("\\\\\\'", '\\\\\\"').replace('\\\'', '\'').replace('\\\\\\"', "\\'")
1038 if FieldName:
1039 pcdvalue = self.HandleFlexiblePcd(TokenSpaceGuidCName, TokenCName, pcdvalue, PcdDatumType, self._GuidDict, FieldName)
1040 else:
1041 pcdvalue = self.HandleFlexiblePcd(TokenSpaceGuidCName, TokenCName, pcdvalue, PcdDatumType, self._GuidDict)
1042 IsValid, Cause = CheckPcdDatum(PcdDatumType, pcdvalue)
1043 if not IsValid:
1044 EdkLogger.error("build", FORMAT_INVALID, Cause, ExtraData="%s.%s" % (TokenSpaceGuidCName, TokenCName))
1045 GlobalData.BuildOptionPcd[i] = (TokenSpaceGuidCName, TokenCName, FieldName, pcdvalue,("build command options",1))
1046
1047 for BuildData in self._Bdb._CACHE_.values():
1048 if BuildData.MetaFile.Ext == '.dec' or BuildData.MetaFile.Ext == '.dsc':
1049 continue
1050 for key in BuildData.Pcds:
1051 PcdItem = BuildData.Pcds[key]
1052 if (TokenSpaceGuidCName, TokenCName) == (PcdItem.TokenSpaceGuidCName, PcdItem.TokenCName) and FieldName =="":
1053 PcdItem.DefaultValue = pcdvalue
1054
1055 def HandleFlexiblePcd(self, TokenSpaceGuidCName, TokenCName, PcdValue, PcdDatumType, GuidDict, FieldName=''):
1056 if FieldName:
1057 IsArray = False
1058 TokenCName += '.' + FieldName
1059 if PcdValue.startswith('H'):
1060 if FieldName and IsFieldValueAnArray(PcdValue[1:]):
1061 PcdDatumType = 'VOID*'
1062 IsArray = True
1063 if FieldName and not IsArray:
1064 return PcdValue
1065 try:
1066 PcdValue = ValueExpressionEx(PcdValue[1:], PcdDatumType, GuidDict)(True)
1067 except BadExpression, Value:
1068 EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %
1069 (TokenSpaceGuidCName, TokenCName, PcdValue, Value))
1070 elif PcdValue.startswith("L'") or PcdValue.startswith("'"):
1071 if FieldName and IsFieldValueAnArray(PcdValue):
1072 PcdDatumType = 'VOID*'
1073 IsArray = True
1074 if FieldName and not IsArray:
1075 return PcdValue
1076 try:
1077 PcdValue = ValueExpressionEx(PcdValue, PcdDatumType, GuidDict)(True)
1078 except BadExpression, Value:
1079 EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %
1080 (TokenSpaceGuidCName, TokenCName, PcdValue, Value))
1081 elif PcdValue.startswith('L'):
1082 PcdValue = 'L"' + PcdValue[1:] + '"'
1083 if FieldName and IsFieldValueAnArray(PcdValue):
1084 PcdDatumType = 'VOID*'
1085 IsArray = True
1086 if FieldName and not IsArray:
1087 return PcdValue
1088 try:
1089 PcdValue = ValueExpressionEx(PcdValue, PcdDatumType, GuidDict)(True)
1090 except BadExpression, Value:
1091 EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %
1092 (TokenSpaceGuidCName, TokenCName, PcdValue, Value))
1093 else:
1094 if PcdValue.upper() == 'FALSE':
1095 PcdValue = str(0)
1096 if PcdValue.upper() == 'TRUE':
1097 PcdValue = str(1)
1098 if not FieldName:
1099 if PcdDatumType not in ['UINT8','UINT16','UINT32','UINT64','BOOLEAN']:
1100 PcdValue = '"' + PcdValue + '"'
1101 else:
1102 IsArray = False
1103 Base = 10
1104 if PcdValue.upper().startswith('0X'):
1105 Base = 16
1106 try:
1107 Num = int(PcdValue, Base)
1108 except:
1109 PcdValue = '"' + PcdValue + '"'
1110 if IsFieldValueAnArray(PcdValue):
1111 PcdDatumType = 'VOID*'
1112 IsArray = True
1113 if not IsArray:
1114 return PcdValue
1115 try:
1116 PcdValue = ValueExpressionEx(PcdValue, PcdDatumType, GuidDict)(True)
1117 except BadExpression, Value:
1118 EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %
1119 (TokenSpaceGuidCName, TokenCName, PcdValue, Value))
1120 return PcdValue
1121
1122 ## Retrieve all PCD settings in platform
1123 def _GetPcds(self):
1124 if self._Pcds is None:
1125 self._Pcds = OrderedDict()
1126 self.__ParsePcdFromCommandLine()
1127 self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))
1128 self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))
1129 self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))
1130 self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_DEFAULT))
1131 self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_HII))
1132 self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_VPD))
1133 self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_EX_DEFAULT))
1134 self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_EX_HII))
1135 self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_EX_VPD))
1136
1137 self._Pcds = self.CompletePcdValues(self._Pcds)
1138 self._Pcds = self.OverrideByFdfCommOverAll(self._Pcds)
1139 self._Pcds = self.UpdateStructuredPcds(MODEL_PCD_TYPE_LIST, self._Pcds)
1140 self._Pcds = self.CompleteHiiPcdsDefaultStores(self._Pcds)
1141 self._Pcds = self._FilterPcdBySkuUsage(self._Pcds)
1142
1143 self.RecoverCommandLinePcd()
1144 return self._Pcds
1145
1146 def _dumpPcdInfo(self,Pcds):
1147 for pcd in Pcds:
1148 pcdobj = Pcds[pcd]
1149 if not pcdobj.TokenCName.startswith("Test"):
1150 continue
1151 for skuid in pcdobj.SkuInfoList:
1152 if pcdobj.Type in (self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]):
1153 for storename in pcdobj.SkuInfoList[skuid].DefaultStoreDict:
1154 print "PcdCName: %s, SkuName: %s, StoreName: %s, Value: %s" % (".".join((pcdobj.TokenSpaceGuidCName, pcdobj.TokenCName)), skuid,storename,str(pcdobj.SkuInfoList[skuid].DefaultStoreDict[storename]))
1155 else:
1156 print "PcdCName: %s, SkuName: %s, Value: %s" % (".".join((pcdobj.TokenSpaceGuidCName, pcdobj.TokenCName)), skuid,str(pcdobj.SkuInfoList[skuid].DefaultValue))
1157 ## Retrieve [BuildOptions]
1158 def _GetBuildOptions(self):
1159 if self._BuildOptions is None:
1160 self._BuildOptions = OrderedDict()
1161 #
1162 # Retrieve build option for EDKII and EDK style module
1163 #
1164 for CodeBase in (EDKII_NAME, EDK_NAME):
1165 RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, CodeBase]
1166 for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4,Dummy5 in RecordList:
1167 if Dummy3.upper() != 'COMMON':
1168 continue
1169 CurKey = (ToolChainFamily, ToolChain, CodeBase)
1170 #
1171 # Only flags can be appended
1172 #
1173 if CurKey not in self._BuildOptions or not ToolChain.endswith('_FLAGS') or Option.startswith('='):
1174 self._BuildOptions[CurKey] = Option
1175 else:
1176 if ' ' + Option not in self._BuildOptions[CurKey]:
1177 self._BuildOptions[CurKey] += ' ' + Option
1178 return self._BuildOptions
1179
1180 def GetBuildOptionsByModuleType(self, Edk, ModuleType):
1181 if self._ModuleTypeOptions is None:
1182 self._ModuleTypeOptions = OrderedDict()
1183 if (Edk, ModuleType) not in self._ModuleTypeOptions:
1184 options = OrderedDict()
1185 self._ModuleTypeOptions[Edk, ModuleType] = options
1186 DriverType = '%s.%s' % (Edk, ModuleType)
1187 CommonDriverType = '%s.%s' % ('COMMON', ModuleType)
1188 RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch]
1189 for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4,Dummy5 in RecordList:
1190 Type = Dummy2 + '.' + Dummy3
1191 if Type.upper() == DriverType.upper() or Type.upper() == CommonDriverType.upper():
1192 Key = (ToolChainFamily, ToolChain, Edk)
1193 if Key not in options or not ToolChain.endswith('_FLAGS') or Option.startswith('='):
1194 options[Key] = Option
1195 else:
1196 if ' ' + Option not in options[Key]:
1197 options[Key] += ' ' + Option
1198 return self._ModuleTypeOptions[Edk, ModuleType]
1199
1200 def GetStructurePcdInfo(self, PcdSet):
1201 structure_pcd_data = {}
1202 for item in PcdSet:
1203 if (item[0],item[1]) not in structure_pcd_data:
1204 structure_pcd_data[(item[0],item[1])] = []
1205 structure_pcd_data[(item[0],item[1])].append(item)
1206
1207 return structure_pcd_data
1208 def OverrideByFdfComm(self,StruPcds):
1209 StructurePcdInCom = OrderedDict()
1210 for item in GlobalData.BuildOptionPcd:
1211 if len(item) == 5 and (item[1],item[0]) in StruPcds:
1212 StructurePcdInCom[(item[0],item[1],item[2] )] = (item[3],item[4])
1213 GlobalPcds = set([(item[0],item[1]) for item in StructurePcdInCom.keys()])
1214 for Pcd in StruPcds.values():
1215 if (Pcd.TokenSpaceGuidCName,Pcd.TokenCName) not in GlobalPcds:
1216 continue
1217 FieldValues = OrderedDict()
1218 for item in StructurePcdInCom:
1219 if (Pcd.TokenSpaceGuidCName,Pcd.TokenCName) == (item[0],item[1]) and item[2]:
1220 FieldValues[item[2]] = StructurePcdInCom[item]
1221 for field in FieldValues:
1222 if field not in Pcd.PcdFieldValueFromComm:
1223 Pcd.PcdFieldValueFromComm[field] = ["","",""]
1224 Pcd.PcdFieldValueFromComm[field][0] = FieldValues[field][0]
1225 Pcd.PcdFieldValueFromComm[field][1] = FieldValues[field][1][0]
1226 Pcd.PcdFieldValueFromComm[field][2] = FieldValues[field][1][1]
1227 return StruPcds
1228 def OverrideByFdfCommOverAll(self,AllPcds):
1229 def CheckStructureInComm(commpcds):
1230 if not commpcds:
1231 return False
1232 if len(commpcds[0]) == 5:
1233 return True
1234 return False
1235
1236 if CheckStructureInComm(GlobalData.BuildOptionPcd):
1237 StructurePcdInCom = {(item[0],item[1],item[2] ):(item[3],item[4]) for item in GlobalData.BuildOptionPcd } if GlobalData.BuildOptionPcd else {}
1238 NoFiledValues = {(item[0],item[1]):StructurePcdInCom[item] for item in StructurePcdInCom if not item[2]}
1239 else:
1240 NoFiledValues = {(item[0],item[1]):[item[2]] for item in GlobalData.BuildOptionPcd}
1241 for Guid,Name in NoFiledValues:
1242 if (Name,Guid) in AllPcds:
1243 Pcd = AllPcds.get((Name,Guid))
1244 if isinstance(self._DecPcds.get((Pcd.TokenCName,Pcd.TokenSpaceGuidCName), None),StructurePcd):
1245 self._DecPcds.get((Pcd.TokenCName,Pcd.TokenSpaceGuidCName)).PcdValueFromComm = NoFiledValues[(Pcd.TokenSpaceGuidCName,Pcd.TokenCName)][0]
1246 else:
1247 Pcd.PcdValueFromComm = NoFiledValues[(Pcd.TokenSpaceGuidCName,Pcd.TokenCName)][0]
1248 Pcd.DefaultValue = NoFiledValues[(Pcd.TokenSpaceGuidCName,Pcd.TokenCName)][0]
1249 for sku in Pcd.SkuInfoList:
1250 SkuInfo = Pcd.SkuInfoList[sku]
1251 if SkuInfo.DefaultValue:
1252 SkuInfo.DefaultValue = NoFiledValues[(Pcd.TokenSpaceGuidCName,Pcd.TokenCName)][0]
1253 else:
1254 SkuInfo.HiiDefaultValue = NoFiledValues[(Pcd.TokenSpaceGuidCName,Pcd.TokenCName)][0]
1255 for defaultstore in SkuInfo.DefaultStoreDict:
1256 SkuInfo.DefaultStoreDict[defaultstore] = NoFiledValues[(Pcd.TokenSpaceGuidCName,Pcd.TokenCName)][0]
1257 if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII]]:
1258 if Pcd.DatumType == "VOID*":
1259 if not Pcd.MaxDatumSize:
1260 Pcd.MaxDatumSize = '0'
1261 CurrentSize = int(Pcd.MaxDatumSize,16) if Pcd.MaxDatumSize.upper().startswith("0X") else int(Pcd.MaxDatumSize)
1262 OptionSize = len((StringToArray(Pcd.PcdValueFromComm)).split(","))
1263 MaxSize = max(CurrentSize, OptionSize)
1264 Pcd.MaxDatumSize = str(MaxSize)
1265 else:
1266 PcdInDec = self.DecPcds.get((Name,Guid))
1267 if PcdInDec:
1268 PcdInDec.PcdValueFromComm = NoFiledValues[(Guid,Name)][0]
1269 if PcdInDec.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
1270 self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE],
1271 self._PCD_TYPE_STRING_[MODEL_PCD_FEATURE_FLAG]]:
1272 self.Pcds[Name, Guid] = copy.deepcopy(PcdInDec)
1273 self.Pcds[Name, Guid].DefaultValue = NoFiledValues[( Guid,Name)][0]
1274 return AllPcds
1275 def UpdateStructuredPcds(self, TypeList, AllPcds):
1276
1277 DynamicPcdType = [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],
1278 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1279 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_VPD],
1280 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_DEFAULT],
1281 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII],
1282 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_VPD]]
1283
1284 Pcds = AllPcds
1285 DefaultStoreMgr = DefaultStore(self.DefaultStores)
1286 SkuIds = self.SkuIdMgr.AvailableSkuIdSet
1287 SkuIds.update({'DEFAULT':0})
1288 DefaultStores = set([storename for pcdobj in AllPcds.values() for skuobj in pcdobj.SkuInfoList.values() for storename in skuobj.DefaultStoreDict.keys()])
1289
1290 S_PcdSet = []
1291 # Find out all possible PCD candidates for self._Arch
1292 RecordList = []
1293
1294 for Type in TypeList:
1295 RecordList.extend(self._RawData[Type, self._Arch])
1296
1297 for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, default_store, Dummy4,Dummy5 in RecordList:
1298 SkuName = SkuName.upper()
1299 default_store = default_store.upper()
1300 SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
1301 if SkuName not in SkuIds:
1302 continue
1303
1304 if SkuName in SkuIds and "." in TokenSpaceGuid:
1305 S_PcdSet.append([ TokenSpaceGuid.split(".")[0],TokenSpaceGuid.split(".")[1], PcdCName,SkuName, default_store,Dummy5, AnalyzePcdExpression(Setting)[0]])
1306
1307 # handle pcd value override
1308 StrPcdSet = self.GetStructurePcdInfo(S_PcdSet)
1309 S_pcd_set = OrderedDict()
1310 for str_pcd in StrPcdSet:
1311 str_pcd_obj = Pcds.get((str_pcd[1], str_pcd[0]), None)
1312 str_pcd_dec = self._DecPcds.get((str_pcd[1], str_pcd[0]), None)
1313 if not isinstance (str_pcd_dec, StructurePcd):
1314 EdkLogger.error('build', PARSER_ERROR,
1315 "Pcd (%s.%s) is not declared as Structure PCD in DEC files. Arch: ['%s']" % (str_pcd[0], str_pcd[1], self._Arch),
1316 File=self.MetaFile,Line = StrPcdSet[str_pcd][0][5])
1317 if str_pcd_dec:
1318 str_pcd_obj_str = StructurePcd()
1319 str_pcd_obj_str.copy(str_pcd_dec)
1320 if str_pcd_obj:
1321 str_pcd_obj_str.copy(str_pcd_obj)
1322 if str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1323 str_pcd_obj_str.DefaultFromDSC = {skuname:{defaultstore: str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.get(defaultstore, str_pcd_obj.SkuInfoList[skuname].HiiDefaultValue) for defaultstore in DefaultStores} for skuname in str_pcd_obj.SkuInfoList}
1324 else:
1325 str_pcd_obj_str.DefaultFromDSC = {skuname:{defaultstore: str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.get(defaultstore, str_pcd_obj.SkuInfoList[skuname].DefaultValue) for defaultstore in DefaultStores} for skuname in str_pcd_obj.SkuInfoList}
1326 for str_pcd_data in StrPcdSet[str_pcd]:
1327 if str_pcd_data[3] in SkuIds:
1328 str_pcd_obj_str.AddOverrideValue(str_pcd_data[2], str(str_pcd_data[6]), 'DEFAULT' if str_pcd_data[3] == 'COMMON' else str_pcd_data[3],TAB_DEFAULT_STORES_DEFAULT if str_pcd_data[4] == 'COMMON' else str_pcd_data[4], self.MetaFile.File if self.WorkspaceDir not in self.MetaFile.File else self.MetaFile.File[len(self.WorkspaceDir) if self.WorkspaceDir.endswith(os.path.sep) else len(self.WorkspaceDir)+1:],LineNo=str_pcd_data[5])
1329 S_pcd_set[str_pcd[1], str_pcd[0]] = str_pcd_obj_str
1330 else:
1331 EdkLogger.error('build', PARSER_ERROR,
1332 "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (str_pcd[0], str_pcd[1], self._Arch),
1333 File=self.MetaFile,Line = StrPcdSet[str_pcd][0][5])
1334 # Add the Structure PCD that only defined in DEC, don't have override in DSC file
1335 for Pcd in self.DecPcds:
1336 if type (self._DecPcds[Pcd]) is StructurePcd:
1337 if Pcd not in S_pcd_set:
1338 str_pcd_obj_str = StructurePcd()
1339 str_pcd_obj_str.copy(self._DecPcds[Pcd])
1340 str_pcd_obj = Pcds.get(Pcd, None)
1341 if str_pcd_obj:
1342 str_pcd_obj_str.copy(str_pcd_obj)
1343 if str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1344 str_pcd_obj_str.DefaultFromDSC = {skuname:{defaultstore: str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.get(defaultstore, str_pcd_obj.SkuInfoList[skuname].HiiDefaultValue) for defaultstore in DefaultStores} for skuname in str_pcd_obj.SkuInfoList}
1345 else:
1346 str_pcd_obj_str.DefaultFromDSC = {skuname:{defaultstore: str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.get(defaultstore, str_pcd_obj.SkuInfoList[skuname].DefaultValue) for defaultstore in DefaultStores} for skuname in str_pcd_obj.SkuInfoList}
1347 S_pcd_set[Pcd] = str_pcd_obj_str
1348 if S_pcd_set:
1349 GlobalData.gStructurePcd[self.Arch] = S_pcd_set
1350 for stru_pcd in S_pcd_set.values():
1351 for skuid in SkuIds:
1352 if skuid in stru_pcd.SkuOverrideValues:
1353 continue
1354 nextskuid = self.SkuIdMgr.GetNextSkuId(skuid)
1355 NoDefault = False
1356 if skuid not in stru_pcd.SkuOverrideValues:
1357 while nextskuid not in stru_pcd.SkuOverrideValues:
1358 if nextskuid == "DEFAULT":
1359 NoDefault = True
1360 break
1361 nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1362 stru_pcd.SkuOverrideValues[skuid] = copy.deepcopy(stru_pcd.SkuOverrideValues[nextskuid]) if not NoDefault else copy.deepcopy({defaultstorename: stru_pcd.DefaultValues for defaultstorename in DefaultStores} if DefaultStores else {TAB_DEFAULT_STORES_DEFAULT:stru_pcd.DefaultValues})
1363 if not NoDefault:
1364 stru_pcd.ValueChain[(skuid,'')]= (nextskuid,'')
1365 if stru_pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1366 for skuid in SkuIds:
1367 nextskuid = skuid
1368 NoDefault = False
1369 if skuid not in stru_pcd.SkuOverrideValues:
1370 while nextskuid not in stru_pcd.SkuOverrideValues:
1371 if nextskuid == "DEFAULT":
1372 NoDefault = True
1373 break
1374 nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1375 if NoDefault:
1376 continue
1377 PcdDefaultStoreSet = set([defaultstorename for defaultstorename in stru_pcd.SkuOverrideValues[nextskuid]])
1378 mindefaultstorename = DefaultStoreMgr.GetMin(PcdDefaultStoreSet)
1379
1380 for defaultstoreid in DefaultStores:
1381 if defaultstoreid not in stru_pcd.SkuOverrideValues[skuid]:
1382 stru_pcd.SkuOverrideValues[skuid][defaultstoreid] = copy.deepcopy(stru_pcd.SkuOverrideValues[nextskuid][mindefaultstorename])
1383 stru_pcd.ValueChain[(skuid,defaultstoreid)]= (nextskuid,mindefaultstorename)
1384 S_pcd_set = self.OverrideByFdfComm(S_pcd_set)
1385 Str_Pcd_Values = self.GenerateByteArrayValue(S_pcd_set)
1386 if Str_Pcd_Values:
1387 for (skuname,StoreName,PcdGuid,PcdName,PcdValue) in Str_Pcd_Values:
1388 str_pcd_obj = S_pcd_set.get((PcdName, PcdGuid))
1389 if str_pcd_obj is None:
1390 print PcdName, PcdGuid
1391 raise
1392 if str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1393 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1394 if skuname not in str_pcd_obj.SkuInfoList:
1395 str_pcd_obj.SkuInfoList[skuname] = SkuInfoClass(SkuIdName=skuname, SkuId=self.SkuIds[skuname][0], HiiDefaultValue=PcdValue, DefaultStore = {StoreName:PcdValue})
1396 else:
1397 str_pcd_obj.SkuInfoList[skuname].HiiDefaultValue = PcdValue
1398 str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.update({StoreName:PcdValue})
1399 elif str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
1400 self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
1401 if skuname in (self.SkuIdMgr.SystemSkuId, 'DEFAULT', 'COMMON'):
1402 str_pcd_obj.DefaultValue = PcdValue
1403 else:
1404 if skuname not in str_pcd_obj.SkuInfoList:
1405 nextskuid = self.SkuIdMgr.GetNextSkuId(skuname)
1406 NoDefault = False
1407 while nextskuid not in str_pcd_obj.SkuInfoList:
1408 if nextskuid == "DEFAULT":
1409 NoDefault = True
1410 break
1411 nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1412 str_pcd_obj.SkuInfoList[skuname] = copy.deepcopy(str_pcd_obj.SkuInfoList[nextskuid]) if not NoDefault else SkuInfoClass(SkuIdName=skuname, SkuId=self.SkuIds[skuname][0], DefaultValue=PcdValue)
1413 str_pcd_obj.SkuInfoList[skuname].SkuId = self.SkuIds[skuname][0]
1414 str_pcd_obj.SkuInfoList[skuname].SkuIdName = skuname
1415 else:
1416 str_pcd_obj.SkuInfoList[skuname].DefaultValue = PcdValue
1417 for str_pcd_obj in S_pcd_set.values():
1418 if str_pcd_obj.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1419 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1420 continue
1421 PcdDefaultStoreSet = set([defaultstorename for skuobj in str_pcd_obj.SkuInfoList.values() for defaultstorename in skuobj.DefaultStoreDict])
1422 DefaultStoreObj = DefaultStore(self._GetDefaultStores())
1423 mindefaultstorename = DefaultStoreObj.GetMin(PcdDefaultStoreSet)
1424 str_pcd_obj.SkuInfoList[self.SkuIdMgr.SystemSkuId].HiiDefaultValue = str_pcd_obj.SkuInfoList[self.SkuIdMgr.SystemSkuId].DefaultStoreDict[mindefaultstorename]
1425
1426 for str_pcd_obj in S_pcd_set.values():
1427
1428 str_pcd_obj.MaxDatumSize = self.GetStructurePcdMaxSize(str_pcd_obj)
1429 Pcds[str_pcd_obj.TokenCName, str_pcd_obj.TokenSpaceGuidCName] = str_pcd_obj
1430
1431 for pcdkey in Pcds:
1432 pcd = Pcds[pcdkey]
1433 if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1434 pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
1435 del(pcd.SkuInfoList['COMMON'])
1436 elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1437 del(pcd.SkuInfoList['COMMON'])
1438
1439 map(self.FilterSkuSettings,[Pcds[pcdkey] for pcdkey in Pcds if Pcds[pcdkey].Type in DynamicPcdType])
1440 return Pcds
1441
1442 ## Retrieve non-dynamic PCD settings
1443 #
1444 # @param Type PCD type
1445 #
1446 # @retval a dict object contains settings of given PCD type
1447 #
1448 def _GetPcd(self, Type):
1449 Pcds = OrderedDict()
1450 #
1451 # tdict is a special dict kind of type, used for selecting correct
1452 # PCD settings for certain ARCH
1453 #
1454 AvailableSkuIdSet = copy.copy(self.SkuIds)
1455
1456 PcdDict = tdict(True, 3)
1457 PcdSet = set()
1458 # Find out all possible PCD candidates for self._Arch
1459 RecordList = self._RawData[Type, self._Arch]
1460 PcdValueDict = OrderedDict()
1461 for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4,Dummy5 in RecordList:
1462 SkuName = SkuName.upper()
1463 SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
1464 if SkuName not in AvailableSkuIdSet:
1465 EdkLogger.error('build ', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
1466 File=self.MetaFile, Line=Dummy5)
1467 if SkuName in (self.SkuIdMgr.SystemSkuId, 'DEFAULT', 'COMMON'):
1468 if "." not in TokenSpaceGuid:
1469 PcdSet.add((PcdCName, TokenSpaceGuid, SkuName, Dummy5))
1470 PcdDict[Arch, PcdCName, TokenSpaceGuid, SkuName] = Setting
1471
1472 for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdSet:
1473 Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid, SkuName]
1474 if Setting is None:
1475 continue
1476 PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
1477 if (PcdCName, TokenSpaceGuid) in PcdValueDict:
1478 PcdValueDict[PcdCName, TokenSpaceGuid][SkuName] = (PcdValue, DatumType, MaxDatumSize)
1479 else:
1480 PcdValueDict[PcdCName, TokenSpaceGuid] = {SkuName:(PcdValue, DatumType, MaxDatumSize)}
1481
1482 PcdsKeys = PcdValueDict.keys()
1483 for PcdCName, TokenSpaceGuid in PcdsKeys:
1484
1485 PcdSetting = PcdValueDict[PcdCName, TokenSpaceGuid]
1486 PcdValue = None
1487 DatumType = None
1488 MaxDatumSize = None
1489 if 'COMMON' in PcdSetting:
1490 PcdValue, DatumType, MaxDatumSize = PcdSetting['COMMON']
1491 if 'DEFAULT' in PcdSetting:
1492 PcdValue, DatumType, MaxDatumSize = PcdSetting['DEFAULT']
1493 if self.SkuIdMgr.SystemSkuId in PcdSetting:
1494 PcdValue, DatumType, MaxDatumSize = PcdSetting[self.SkuIdMgr.SystemSkuId]
1495
1496 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
1497 PcdCName,
1498 TokenSpaceGuid,
1499 self._PCD_TYPE_STRING_[Type],
1500 DatumType,
1501 PcdValue,
1502 '',
1503 MaxDatumSize,
1504 {},
1505 False,
1506 None,
1507 IsDsc=True)
1508
1509
1510 return Pcds
1511
1512 def __UNICODE2OCTList(self,Value):
1513 Value = Value.strip()
1514 Value = Value[2:-1]
1515 List = []
1516 for Item in Value:
1517 Temp = '%04X' % ord(Item)
1518 List.append('0x' + Temp[2:4])
1519 List.append('0x' + Temp[0:2])
1520 List.append('0x00')
1521 List.append('0x00')
1522 return List
1523 def __STRING2OCTList(self,Value):
1524 OCTList = []
1525 Value = Value.strip('"')
1526 for char in Value:
1527 Temp = '%02X' % ord(char)
1528 OCTList.append('0x' + Temp)
1529 OCTList.append('0x00')
1530 return OCTList
1531
1532 def GetStructurePcdMaxSize(self, str_pcd):
1533 pcd_default_value = str_pcd.DefaultValue
1534 sku_values = [skuobj.HiiDefaultValue if str_pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]] else skuobj.DefaultValue for skuobj in str_pcd.SkuInfoList.values()]
1535 sku_values.append(pcd_default_value)
1536
1537 def get_length(value):
1538 Value = value.strip()
1539 if len(value) > 1:
1540 if Value.startswith('GUID') and Value.endswith(')'):
1541 return 16
1542 if Value.startswith('L"') and Value.endswith('"'):
1543 return len(Value[2:-1])
1544 if Value[0] == '"' and Value[-1] == '"':
1545 return len(Value) - 2
1546 if Value[0] == '{' and Value[-1] == '}':
1547 return len(Value.split(","))
1548 if Value.startswith("L'") and Value.endswith("'") and len(list(Value[2:-1])) > 1:
1549 return len(list(Value[2:-1]))
1550 if Value[0] == "'" and Value[-1] == "'" and len(list(Value[1:-1])) > 1:
1551 return len(Value) - 2
1552 return len(Value)
1553
1554 return str(max([pcd_size for pcd_size in [get_length(item) for item in sku_values]]))
1555
1556 def ExecuteCommand (self, Command):
1557 try:
1558 Process = subprocess.Popen(Command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
1559 except:
1560 EdkLogger.error('Build', COMMAND_FAILURE, 'Can not execute command: %s' % Command)
1561 Result = Process.communicate()
1562 return Process.returncode, Result[0], Result[1]
1563
1564 def IntToCString(self, Value, ValueSize):
1565 Result = '"'
1566 if not isinstance (Value, str):
1567 for Index in range(0, ValueSize):
1568 Result = Result + '\\x%02x' % (Value & 0xff)
1569 Value = Value >> 8
1570 Result = Result + '"'
1571 return Result
1572
1573 def GetPcdMaxSize(self,Pcd):
1574 MaxSize = int(Pcd.MaxDatumSize,10) if Pcd.MaxDatumSize else 0
1575 if Pcd.DatumType not in ['BOOLEAN','UINT8','UINT16','UINT32','UINT64']:
1576 if Pcd.PcdValueFromComm:
1577 if Pcd.PcdValueFromComm.startswith("{") and Pcd.PcdValueFromComm.endswith("}"):
1578 MaxSize = max([len(Pcd.PcdValueFromComm.split(",")),MaxSize])
1579 elif Pcd.PcdValueFromComm.startswith("\"") or Pcd.PcdValueFromComm.startswith("\'"):
1580 MaxSize = max([len(Pcd.PcdValueFromComm)-2+1,MaxSize])
1581 elif Pcd.PcdValueFromComm.startswith("L\""):
1582 MaxSize = max([2*(len(Pcd.PcdValueFromComm)-3+1),MaxSize])
1583 else:
1584 MaxSize = max([len(Pcd.PcdValueFromComm),MaxSize])
1585 elif Pcd.DatumType not in ['BOOLEAN','UINT8']:
1586 MaxSize = 1
1587 elif Pcd.DatumType == 'UINT16':
1588 MaxSize = 2
1589 elif Pcd.DatumType == 'UINT32':
1590 MaxSize = 4
1591 elif Pcd.DatumType == 'UINT64':
1592 MaxSize = 8
1593 return MaxSize
1594 def GenerateSizeFunction(self,Pcd):
1595 CApp = "// Default Value in Dec \n"
1596 CApp = CApp + "void Cal_%s_%s_Size(UINT32 *Size){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1597 for FieldList in [Pcd.DefaultValues]:
1598 if not FieldList:
1599 continue
1600 for FieldName in FieldList:
1601 FieldName = "." + FieldName
1602 IsArray = IsFieldValueAnArray(FieldList[FieldName.strip(".")][0])
1603 if IsArray and not (FieldList[FieldName.strip(".")][0].startswith('{GUID') and FieldList[FieldName.strip(".")][0].endswith('}')):
1604 try:
1605 Value = ValueExpressionEx(FieldList[FieldName.strip(".")][0], "VOID*", self._GuidDict)(True)
1606 except BadExpression:
1607 EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1608 (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2]))
1609 Value, ValueSize = ParseFieldValue(Value)
1610 CApp = CApp + ' __FLEXIBLE_SIZE(*Size, %s, %s, %d / __ARRAY_ELEMENT_SIZE(%s, %s) + ((%d %% __ARRAY_ELEMENT_SIZE(%s, %s)) ? 1 : 0)); // From %s Line %d Value %s \n' % (Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2], FieldList[FieldName.strip(".")][0]);
1611 else:
1612 NewFieldName = ''
1613 FieldName_ori = FieldName.strip('.')
1614 while '[' in FieldName:
1615 NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1616 ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1617 FieldName = FieldName.split(']', 1)[1]
1618 FieldName = NewFieldName + FieldName
1619 while '[' in FieldName:
1620 FieldName = FieldName.rsplit('[', 1)[0]
1621 CApp = CApp + ' __FLEXIBLE_SIZE(*Size, %s, %s, %d); // From %s Line %d Value %s\n' % (Pcd.DatumType, FieldName.strip("."), ArrayIndex + 1, FieldList[FieldName_ori][1], FieldList[FieldName_ori][2], FieldList[FieldName_ori][0])
1622 for skuname in Pcd.SkuOverrideValues:
1623 if skuname == "COMMON":
1624 continue
1625 for defaultstorenameitem in Pcd.SkuOverrideValues[skuname]:
1626 CApp = CApp + "// SkuName: %s, DefaultStoreName: %s \n" % (skuname, defaultstorenameitem)
1627 for FieldList in [Pcd.SkuOverrideValues[skuname].get(defaultstorenameitem)]:
1628 if not FieldList:
1629 continue
1630 for FieldName in FieldList:
1631 FieldName = "." + FieldName
1632 IsArray = IsFieldValueAnArray(FieldList[FieldName.strip(".")][0])
1633 if IsArray and not (FieldList[FieldName.strip(".")][0].startswith('{GUID') and FieldList[FieldName.strip(".")][0].endswith('}')):
1634 try:
1635 Value = ValueExpressionEx(FieldList[FieldName.strip(".")][0], "VOID*", self._GuidDict)(True)
1636 except BadExpression:
1637 EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1638 (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2]))
1639 Value, ValueSize = ParseFieldValue(Value)
1640 CApp = CApp + ' __FLEXIBLE_SIZE(*Size, %s, %s, %d / __ARRAY_ELEMENT_SIZE(%s, %s) + ((%d %% __ARRAY_ELEMENT_SIZE(%s, %s)) ? 1 : 0)); // From %s Line %d Value %s\n' % (Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2], FieldList[FieldName.strip(".")][0]);
1641 else:
1642 NewFieldName = ''
1643 FieldName_ori = FieldName.strip('.')
1644 while '[' in FieldName:
1645 NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1646 ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1647 FieldName = FieldName.split(']', 1)[1]
1648 FieldName = NewFieldName + FieldName
1649 while '[' in FieldName:
1650 FieldName = FieldName.rsplit('[', 1)[0]
1651 CApp = CApp + ' __FLEXIBLE_SIZE(*Size, %s, %s, %d); // From %s Line %d Value %s \n' % (Pcd.DatumType, FieldName.strip("."), ArrayIndex + 1, FieldList[FieldName_ori][1], FieldList[FieldName_ori][2], FieldList[FieldName_ori][0])
1652 if Pcd.PcdFieldValueFromComm:
1653 CApp = CApp + "// From Command Line \n"
1654 for FieldName in Pcd.PcdFieldValueFromComm:
1655 FieldName = "." + FieldName
1656 IsArray = IsFieldValueAnArray(Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0])
1657 if IsArray and not (Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0].startswith('{GUID') and Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0].endswith('}')):
1658 try:
1659 Value = ValueExpressionEx(Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0], "VOID*", self._GuidDict)(True)
1660 except BadExpression:
1661 EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1662 (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), Pcd.PcdFieldValueFromComm[FieldName.strip(".")][1], Pcd.PcdFieldValueFromComm[FieldName.strip(".")][2]))
1663 Value, ValueSize = ParseFieldValue(Value)
1664 CApp = CApp + ' __FLEXIBLE_SIZE(*Size, %s, %s, %d / __ARRAY_ELEMENT_SIZE(%s, %s) + ((%d %% __ARRAY_ELEMENT_SIZE(%s, %s)) ? 1 : 0)); // From %s Line %d Value %s\n' % (Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), Pcd.PcdFieldValueFromComm[FieldName.strip(".")][1], Pcd.PcdFieldValueFromComm[FieldName.strip(".")][2], Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0]);
1665 else:
1666 NewFieldName = ''
1667 FieldName_ori = FieldName.strip('.')
1668 while '[' in FieldName:
1669 NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1670 ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1671 FieldName = FieldName.split(']', 1)[1]
1672 FieldName = NewFieldName + FieldName
1673 while '[' in FieldName:
1674 FieldName = FieldName.rsplit('[', 1)[0]
1675 CApp = CApp + ' __FLEXIBLE_SIZE(*Size, %s, %s, %d); // From %s Line %d Value %s \n' % (Pcd.DatumType, FieldName.strip("."), ArrayIndex + 1, Pcd.PcdFieldValueFromComm[FieldName_ori][1], Pcd.PcdFieldValueFromComm[FieldName_ori][2], Pcd.PcdFieldValueFromComm[FieldName_ori][0])
1676 CApp = CApp + " *Size = (%d > *Size ? %d : *Size); // The Pcd maxsize is %d \n" % (self.GetPcdMaxSize(Pcd),self.GetPcdMaxSize(Pcd),self.GetPcdMaxSize(Pcd))
1677 CApp = CApp + "}\n"
1678 return CApp
1679 def GenerateSizeStatments(self,Pcd):
1680 CApp = ' Size = sizeof(%s);\n' % (Pcd.DatumType)
1681 CApp = CApp + ' Cal_%s_%s_Size(&Size);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1682 return CApp
1683 def GenerateDefaultValueAssignFunction(self,Pcd):
1684 CApp = "// Default value in Dec \n"
1685 CApp = CApp + "void Assign_%s_%s_Default_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName,Pcd.DatumType)
1686 CApp = CApp + ' UINT32 FieldSize;\n'
1687 CApp = CApp + ' CHAR8 *Value;\n'
1688 DefaultValueFromDec = Pcd.DefaultValueFromDec
1689 IsArray = IsFieldValueAnArray(Pcd.DefaultValueFromDec)
1690 if IsArray:
1691 try:
1692 DefaultValueFromDec = ValueExpressionEx(Pcd.DefaultValueFromDec, "VOID*")(True)
1693 except BadExpression:
1694 EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from DEC: %s" %
1695 (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, DefaultValueFromDec))
1696 DefaultValueFromDec = StringToArray(DefaultValueFromDec)
1697 Value, ValueSize = ParseFieldValue (DefaultValueFromDec)
1698 if isinstance(Value, str):
1699 CApp = CApp + ' Pcd = %s; // From DEC Default Value %s\n' % (Value, Pcd.DefaultValueFromDec)
1700 elif IsArray:
1701 #
1702 # Use memcpy() to copy value into field
1703 #
1704 CApp = CApp + ' Value = %s; // From DEC Default Value %s\n' % (self.IntToCString(Value, ValueSize), Pcd.DefaultValueFromDec)
1705 CApp = CApp + ' memcpy (Pcd, Value, %d);\n' % (ValueSize)
1706 for FieldList in [Pcd.DefaultValues]:
1707 if not FieldList:
1708 continue
1709 for FieldName in FieldList:
1710 IsArray = IsFieldValueAnArray(FieldList[FieldName][0])
1711 if IsArray:
1712 try:
1713 FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], "VOID*", self._GuidDict)(True)
1714 except BadExpression:
1715 EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1716 (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1],FieldList[FieldName][2]))
1717
1718 try:
1719 Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1720 except Exception:
1721 EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " % (".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName,FieldName)),FieldList[FieldName][1], FieldList[FieldName][2]))
1722 if isinstance(Value, str):
1723 CApp = CApp + ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1724 elif IsArray:
1725 #
1726 # Use memcpy() to copy value into field
1727 #
1728 CApp = CApp + ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1729 CApp = CApp + ' Value = %s; // From %s Line %d Value %s\n' % (self.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1730 CApp = CApp + ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1731 else:
1732 if ValueSize > 4:
1733 CApp = CApp + ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1734 else:
1735 CApp = CApp + ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1736 CApp = CApp + "}\n"
1737 return CApp
1738 def GenerateDefaultValueAssignStatement(self,Pcd):
1739 CApp = ' Assign_%s_%s_Default_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1740 return CApp
1741 def GenerateInitValueFunction(self,Pcd,SkuName,DefaultStoreName):
1742 CApp = "// Value in Dsc for Sku: %s, DefaultStore %s\n" % (SkuName,DefaultStoreName)
1743 CApp = CApp + "void Assign_%s_%s_%s_%s_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName,SkuName,DefaultStoreName,Pcd.DatumType)
1744 CApp = CApp + ' UINT32 FieldSize;\n'
1745 CApp = CApp + ' CHAR8 *Value;\n'
1746
1747 CApp = CApp + "// SkuName: %s, DefaultStoreName: %s \n" % ('DEFAULT', TAB_DEFAULT_STORES_DEFAULT)
1748 inherit_OverrideValues = Pcd.SkuOverrideValues[SkuName]
1749 if (SkuName,DefaultStoreName) == ('DEFAULT',TAB_DEFAULT_STORES_DEFAULT):
1750 pcddefaultvalue = Pcd.DefaultFromDSC.get('DEFAULT',{}).get(TAB_DEFAULT_STORES_DEFAULT, Pcd.DefaultValue) if Pcd.DefaultFromDSC else Pcd.DefaultValue
1751 else:
1752 if not Pcd.DscRawValue:
1753 # handle the case that structure pcd is not appear in DSC
1754 self.CopyDscRawValue(Pcd)
1755 pcddefaultvalue = Pcd.DscRawValue.get(SkuName,{}).get(DefaultStoreName)
1756 for FieldList in [pcddefaultvalue,inherit_OverrideValues.get(DefaultStoreName)]:
1757 if not FieldList:
1758 continue
1759 if pcddefaultvalue and FieldList == pcddefaultvalue:
1760 IsArray = IsFieldValueAnArray(FieldList)
1761 if IsArray:
1762 try:
1763 FieldList = ValueExpressionEx(FieldList, "VOID*")(True)
1764 except BadExpression:
1765 EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from DSC: %s" %
1766 (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldList))
1767 Value, ValueSize = ParseFieldValue (FieldList)
1768
1769 if (SkuName,DefaultStoreName) == ('DEFAULT',TAB_DEFAULT_STORES_DEFAULT):
1770 if isinstance(Value, str):
1771 CApp = CApp + ' Pcd = %s; // From DSC Default Value %s\n' % (Value, Pcd.DefaultFromDSC.get('DEFAULT',{}).get(TAB_DEFAULT_STORES_DEFAULT, Pcd.DefaultValue) if Pcd.DefaultFromDSC else Pcd.DefaultValue)
1772 elif IsArray:
1773 #
1774 # Use memcpy() to copy value into field
1775 #
1776 CApp = CApp + ' Value = %s; // From DSC Default Value %s\n' % (self.IntToCString(Value, ValueSize), Pcd.DefaultFromDSC.get('DEFAULT',{}).get(TAB_DEFAULT_STORES_DEFAULT, Pcd.DefaultValue) if Pcd.DefaultFromDSC else Pcd.DefaultValue)
1777 CApp = CApp + ' memcpy (Pcd, Value, %d);\n' % (ValueSize)
1778 else:
1779 if isinstance(Value, str):
1780 CApp = CApp + ' Pcd = %s; // From DSC Default Value %s\n' % (Value, Pcd.DscRawValue.get(SkuName,{}).get(DefaultStoreName))
1781 elif IsArray:
1782 #
1783 # Use memcpy() to copy value into field
1784 #
1785 CApp = CApp + ' Value = %s; // From DSC Default Value %s\n' % (self.IntToCString(Value, ValueSize), Pcd.DscRawValue.get(SkuName,{}).get(DefaultStoreName))
1786 CApp = CApp + ' memcpy (Pcd, Value, %d);\n' % (ValueSize)
1787 continue
1788 if (SkuName,DefaultStoreName) == ('DEFAULT',TAB_DEFAULT_STORES_DEFAULT) or (( (SkuName,'') not in Pcd.ValueChain) and ( (SkuName,DefaultStoreName) not in Pcd.ValueChain )):
1789 for FieldName in FieldList:
1790 IsArray = IsFieldValueAnArray(FieldList[FieldName][0])
1791 if IsArray:
1792 try:
1793 FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], "VOID*", self._GuidDict)(True)
1794 except BadExpression:
1795 EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1796 (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))
1797 try:
1798 Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1799 except Exception:
1800 EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " % (".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName,FieldName)),FieldList[FieldName][1], FieldList[FieldName][2]))
1801 if isinstance(Value, str):
1802 CApp = CApp + ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1803 elif IsArray:
1804 #
1805 # Use memcpy() to copy value into field
1806 #
1807 CApp = CApp + ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1808 CApp = CApp + ' Value = %s; // From %s Line %d Value %s\n' % (self.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1809 CApp = CApp + ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1810 else:
1811 if ValueSize > 4:
1812 CApp = CApp + ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1813 else:
1814 CApp = CApp + ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1815 CApp = CApp + "}\n"
1816 return CApp
1817 def GenerateInitValueStatement(self,Pcd,SkuName,DefaultStoreName):
1818 CApp = ' Assign_%s_%s_%s_%s_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName,SkuName,DefaultStoreName)
1819 return CApp
1820 def GenerateCommandLineValue(self,Pcd):
1821 CApp = "// Value in CommandLine\n"
1822 CApp = CApp + "void Assign_%s_%s_CommandLine_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName,Pcd.DatumType)
1823 CApp = CApp + ' UINT32 FieldSize;\n'
1824 CApp = CApp + ' CHAR8 *Value;\n'
1825
1826 pcddefaultvalue = Pcd.PcdValueFromComm
1827 for FieldList in [pcddefaultvalue,Pcd.PcdFieldValueFromComm]:
1828 if not FieldList:
1829 continue
1830 if pcddefaultvalue and FieldList == pcddefaultvalue:
1831 IsArray = IsFieldValueAnArray(FieldList)
1832 if IsArray:
1833 try:
1834 FieldList = ValueExpressionEx(FieldList, "VOID*")(True)
1835 except BadExpression:
1836 EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from Command: %s" %
1837 (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldList))
1838 Value, ValueSize = ParseFieldValue (FieldList)
1839
1840 if isinstance(Value, str):
1841 CApp = CApp + ' Pcd = %s; // From Command Line \n' % (Value)
1842 elif IsArray:
1843 #
1844 # Use memcpy() to copy value into field
1845 #
1846 CApp = CApp + ' Value = %s; // From Command Line.\n' % (self.IntToCString(Value, ValueSize))
1847 CApp = CApp + ' memcpy (Pcd, Value, %d);\n' % (ValueSize)
1848 continue
1849 for FieldName in FieldList:
1850 IsArray = IsFieldValueAnArray(FieldList[FieldName][0])
1851 if IsArray:
1852 try:
1853 FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], "VOID*", self._GuidDict)(True)
1854 except BadExpression:
1855 EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1856 (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))
1857 except:
1858 print "error"
1859 try:
1860 Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1861 except Exception:
1862 EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " % (".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName,FieldName)),FieldList[FieldName][1], FieldList[FieldName][2]))
1863 if isinstance(Value, str):
1864 CApp = CApp + ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1865 elif IsArray:
1866 #
1867 # Use memcpy() to copy value into field
1868 #
1869 CApp = CApp + ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1870 CApp = CApp + ' Value = %s; // From %s Line %d Value %s\n' % (self.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1871 CApp = CApp + ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1872 else:
1873 if ValueSize > 4:
1874 CApp = CApp + ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1875 else:
1876 CApp = CApp + ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1877 CApp = CApp + "}\n"
1878 return CApp
1879 def GenerateCommandLineValueStatement(self,Pcd):
1880 CApp = ' Assign_%s_%s_CommandLine_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1881 return CApp
1882 def GenerateInitializeFunc(self, SkuName, DefaultStore, Pcd, InitByteValue, CApp):
1883 OverrideValues = {DefaultStore:""}
1884 if Pcd.SkuOverrideValues:
1885 OverrideValues = Pcd.SkuOverrideValues[SkuName]
1886 for DefaultStoreName in OverrideValues.keys():
1887 CApp = CApp + 'void\n'
1888 CApp = CApp + 'Initialize_%s_%s_%s_%s(\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1889 CApp = CApp + ' void\n'
1890 CApp = CApp + ' )\n'
1891 CApp = CApp + '{\n'
1892 CApp = CApp + ' UINT32 Size;\n'
1893 CApp = CApp + ' UINT32 FieldSize;\n'
1894 CApp = CApp + ' CHAR8 *Value;\n'
1895 CApp = CApp + ' UINT32 OriginalSize;\n'
1896 CApp = CApp + ' VOID *OriginalPcd;\n'
1897 CApp = CApp + ' %s *Pcd; // From %s Line %d \n' % (Pcd.DatumType, Pcd.PkgPath, Pcd.PcdDefineLineNo)
1898 CApp = CApp + '\n'
1899
1900 if SkuName in Pcd.SkuInfoList:
1901 DefaultValue = Pcd.SkuInfoList[SkuName].DefaultStoreDict.get(DefaultStoreName,Pcd.SkuInfoList[SkuName].HiiDefaultValue if Pcd.SkuInfoList[SkuName].HiiDefaultValue else Pcd.SkuInfoList[SkuName].DefaultValue)
1902 else:
1903 DefaultValue = Pcd.DefaultValue
1904 PcdDefaultValue = StringToArray(DefaultValue.strip())
1905
1906 InitByteValue += '%s.%s.%s.%s|%s|%s\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType, PcdDefaultValue)
1907
1908 #
1909 # Get current PCD value and size
1910 #
1911 CApp = CApp + ' OriginalPcd = PcdGetPtr (%s, %s, %s, %s, &OriginalSize);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1912
1913 #
1914 # Determine the size of the PCD. For simple structures, sizeof(TYPE) provides
1915 # the correct value. For structures with a flexible array member, the flexible
1916 # array member is detected, and the size is based on the highest index used with
1917 # the flexible array member. The flexible array member must be the last field
1918 # in a structure. The size formula for this case is:
1919 # OFFSET_OF(FlexbleArrayField) + sizeof(FlexibleArray[0]) * (HighestIndex + 1)
1920 #
1921 CApp = CApp + self.GenerateSizeStatments(Pcd)
1922
1923 #
1924 # Allocate and zero buffer for the PCD
1925 # Must handle cases where current value is smaller, larger, or same size
1926 # Always keep that larger one as the current size
1927 #
1928 CApp = CApp + ' Size = (OriginalSize > Size ? OriginalSize : Size);\n'
1929 CApp = CApp + ' Pcd = (%s *)malloc (Size);\n' % (Pcd.DatumType)
1930 CApp = CApp + ' memset (Pcd, 0, Size);\n'
1931
1932 #
1933 # Copy current PCD value into allocated buffer.
1934 #
1935 CApp = CApp + ' memcpy (Pcd, OriginalPcd, OriginalSize);\n'
1936
1937 #
1938 # Assign field values in PCD
1939 #
1940 CApp = CApp + self.GenerateDefaultValueAssignStatement(Pcd)
1941 if Pcd.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
1942 self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
1943 for skuname in self.SkuIdMgr.GetSkuChain(SkuName):
1944 storeset = [DefaultStoreName] if DefaultStoreName == TAB_DEFAULT_STORES_DEFAULT else [TAB_DEFAULT_STORES_DEFAULT, DefaultStoreName]
1945 for defaultstorenameitem in storeset:
1946 CApp = CApp + "// SkuName: %s, DefaultStoreName: %s \n" % (skuname, defaultstorenameitem)
1947 CApp = CApp + self.GenerateInitValueStatement(Pcd,skuname,defaultstorenameitem)
1948 if skuname == SkuName:
1949 break
1950 else:
1951 CApp = CApp + "// SkuName: %s, DefaultStoreName: STANDARD \n" % self.SkuIdMgr.SystemSkuId
1952 CApp = CApp + self.GenerateInitValueStatement(Pcd,self.SkuIdMgr.SystemSkuId,TAB_DEFAULT_STORES_DEFAULT)
1953 CApp = CApp + self.GenerateCommandLineValueStatement(Pcd)
1954 #
1955 # Set new PCD value and size
1956 #
1957 CApp = CApp + ' PcdSetPtr (%s, %s, %s, %s, Size, (UINT8 *)Pcd);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1958
1959 #
1960 # Free PCD
1961 #
1962 CApp = CApp + ' free (Pcd);\n'
1963 CApp = CApp + '}\n'
1964 CApp = CApp + '\n'
1965 return InitByteValue, CApp
1966
1967 def GenerateByteArrayValue (self, StructuredPcds):
1968 #
1969 # Generate/Compile/Run C application to determine if there are any flexible array members
1970 #
1971 if not StructuredPcds:
1972 return
1973
1974 InitByteValue = ""
1975 CApp = PcdMainCHeader
1976
1977 Includes = {}
1978 IncludeFiles = set()
1979 for PcdName in StructuredPcds:
1980 Pcd = StructuredPcds[PcdName]
1981 for IncludeFile in Pcd.StructuredPcdIncludeFile:
1982 if IncludeFile not in Includes:
1983 Includes[IncludeFile] = True
1984 IncludeFiles.add(IncludeFile)
1985 CApp = CApp + '#include <%s>\n' % (IncludeFile)
1986 CApp = CApp + '\n'
1987 for PcdName in StructuredPcds:
1988 Pcd = StructuredPcds[PcdName]
1989 CApp = CApp + self.GenerateSizeFunction(Pcd)
1990 CApp = CApp + self.GenerateDefaultValueAssignFunction(Pcd)
1991 CApp = CApp + self.GenerateCommandLineValue(Pcd)
1992 if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
1993 self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
1994 CApp = CApp + self.GenerateInitValueFunction(Pcd,self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT)
1995 else:
1996 for SkuName in self.SkuIdMgr.SkuOverrideOrder():
1997 if SkuName not in Pcd.SkuOverrideValues:
1998 continue
1999 for DefaultStoreName in Pcd.SkuOverrideValues[SkuName]:
2000 CApp = CApp + self.GenerateInitValueFunction(Pcd,SkuName,DefaultStoreName)
2001 if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
2002 self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2003 InitByteValue, CApp = self.GenerateInitializeFunc(self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT, Pcd, InitByteValue, CApp)
2004 else:
2005 for SkuName in self.SkuIdMgr.SkuOverrideOrder():
2006 if SkuName not in Pcd.SkuOverrideValues:
2007 continue
2008 for DefaultStoreName in Pcd.DefaultStoreName:
2009 Pcd = StructuredPcds[PcdName]
2010 InitByteValue, CApp = self.GenerateInitializeFunc(SkuName, DefaultStoreName, Pcd, InitByteValue, CApp)
2011
2012 CApp = CApp + 'VOID\n'
2013 CApp = CApp + 'PcdEntryPoint(\n'
2014 CApp = CApp + ' VOID\n'
2015 CApp = CApp + ' )\n'
2016 CApp = CApp + '{\n'
2017 for Pcd in StructuredPcds.values():
2018 if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2019 CApp = CApp + ' Initialize_%s_%s_%s_%s();\n' % (self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2020 else:
2021 for SkuName in self.SkuIdMgr.SkuOverrideOrder():
2022 if SkuName not in Pcd.SkuOverrideValues:
2023 continue
2024 for DefaultStoreName in Pcd.SkuOverrideValues[SkuName]:
2025 CApp = CApp + ' Initialize_%s_%s_%s_%s();\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2026 CApp = CApp + '}\n'
2027
2028 CApp = CApp + PcdMainCEntry + '\n'
2029
2030 if not os.path.exists(self.OutputPath):
2031 os.makedirs(self.OutputPath)
2032 CAppBaseFileName = os.path.join(self.OutputPath, PcdValueInitName)
2033 SaveFileOnChange(CAppBaseFileName + '.c', CApp, False)
2034
2035 MakeApp = PcdMakefileHeader
2036 if sys.platform == "win32":
2037 MakeApp = MakeApp + 'APPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s\%s.obj\n' % (self.OutputPath, PcdValueInitName) + 'INC = '
2038 else:
2039 MakeApp = MakeApp + PcdGccMakefile
2040 MakeApp = MakeApp + 'APPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s/%s.o\n' % (self.OutputPath, PcdValueInitName) + \
2041 'include $(MAKEROOT)/Makefiles/app.makefile\n' + 'INCLUDE +='
2042
2043 IncSearchList = []
2044 PlatformInc = {}
2045 for Cache in self._Bdb._CACHE_.values():
2046 if Cache.MetaFile.Ext.lower() != '.dec':
2047 continue
2048 if Cache.Includes:
2049 if str(Cache.MetaFile.Path) not in PlatformInc:
2050 PlatformInc[str(Cache.MetaFile.Path)] = []
2051 PlatformInc[str(Cache.MetaFile.Path)].append (os.path.dirname(Cache.MetaFile.Path))
2052 PlatformInc[str(Cache.MetaFile.Path)].extend (Cache.CommonIncludes)
2053
2054 PcdDependDEC = []
2055 for Pcd in StructuredPcds.values():
2056 for PackageDec in Pcd.PackageDecs:
2057 Package = os.path.normpath(mws.join(GlobalData.gWorkspace, PackageDec))
2058 if not os.path.exists(Package):
2059 EdkLogger.error('Build', RESOURCE_NOT_AVAILABLE, "The dependent Package %s of PCD %s.%s is not exist." % (PackageDec, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
2060 if Package not in PcdDependDEC:
2061 PcdDependDEC.append(Package)
2062
2063 if PlatformInc and PcdDependDEC:
2064 for pkg in PcdDependDEC:
2065 if pkg in PlatformInc:
2066 for inc in PlatformInc[pkg]:
2067 MakeApp += '-I' + str(inc) + ' '
2068 IncSearchList.append(inc)
2069 MakeApp = MakeApp + '\n'
2070
2071 CC_FLAGS = LinuxCFLAGS
2072 if sys.platform == "win32":
2073 CC_FLAGS = WindowsCFLAGS
2074 BuildOptions = {}
2075 for Options in self.BuildOptions:
2076 if Options[2] != EDKII_NAME:
2077 continue
2078 Family = Options[0]
2079 if Family and Family != self.ToolChainFamily:
2080 continue
2081 Target, Tag, Arch, Tool, Attr = Options[1].split("_")
2082 if Tool != 'CC':
2083 continue
2084
2085 if Target == "*" or Target == self._Target:
2086 if Tag == "*" or Tag == self._Toolchain:
2087 if Arch == "*" or Arch == self.Arch:
2088 if Tool not in BuildOptions:
2089 BuildOptions[Tool] = {}
2090 if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or self.BuildOptions[Options].startswith('='):
2091 BuildOptions[Tool][Attr] = self.BuildOptions[Options]
2092 else:
2093 # append options for the same tool except PATH
2094 if Attr != 'PATH':
2095 BuildOptions[Tool][Attr] += " " + self.BuildOptions[Options]
2096 else:
2097 BuildOptions[Tool][Attr] = self.BuildOptions[Options]
2098 if BuildOptions:
2099 for Tool in BuildOptions:
2100 for Attr in BuildOptions[Tool]:
2101 if Attr == "FLAGS":
2102 Value = BuildOptions[Tool][Attr]
2103 ValueList = Value.split()
2104 if ValueList:
2105 for Id, Item in enumerate(ValueList):
2106 if Item == '-D' or Item == '/D':
2107 CC_FLAGS += ' ' + Item
2108 if Id + 1 < len(ValueList):
2109 CC_FLAGS += ' ' + ValueList[Id + 1]
2110 elif Item.startswith('/D') or Item.startswith('-D'):
2111 CC_FLAGS += ' ' + Item
2112 MakeApp += CC_FLAGS
2113
2114 if sys.platform == "win32":
2115 MakeApp = MakeApp + PcdMakefileEnd
2116 MakeApp = MakeApp + '\n'
2117 IncludeFileFullPaths = []
2118 for includefile in IncludeFiles:
2119 for includepath in IncSearchList:
2120 includefullpath = os.path.join(str(includepath),includefile)
2121 if os.path.exists(includefullpath):
2122 IncludeFileFullPaths.append(os.path.normpath(includefullpath))
2123 break
2124 SearchPathList = []
2125 SearchPathList.append(os.path.normpath(mws.join(GlobalData.gWorkspace, "BaseTools/Source/C/Include")))
2126 SearchPathList.append(os.path.normpath(mws.join(GlobalData.gWorkspace, "BaseTools/Source/C/Common")))
2127 SearchPathList.extend([str(item) for item in IncSearchList])
2128 IncFileList = GetDependencyList(IncludeFileFullPaths,SearchPathList)
2129 for include_file in IncFileList:
2130 MakeApp += "$(OBJECTS) : %s\n" % include_file
2131 MakeFileName = os.path.join(self.OutputPath, 'Makefile')
2132 MakeApp += "$(OBJECTS) : %s\n" % MakeFileName
2133 SaveFileOnChange(MakeFileName, MakeApp, False)
2134
2135 InputValueFile = os.path.join(self.OutputPath, 'Input.txt')
2136 OutputValueFile = os.path.join(self.OutputPath, 'Output.txt')
2137 SaveFileOnChange(InputValueFile, InitByteValue, False)
2138
2139 PcdValueInitExe = PcdValueInitName
2140 if not sys.platform == "win32":
2141 PcdValueInitExe = os.path.join(os.getenv("EDK_TOOLS_PATH"), 'Source', 'C', 'bin', PcdValueInitName)
2142 else:
2143 PcdValueInitExe = os.path.join(os.getenv("EDK_TOOLS_PATH"), 'Bin', 'Win32', PcdValueInitName) +".exe"
2144
2145 Messages = ''
2146 if sys.platform == "win32":
2147 MakeCommand = 'nmake -f %s' % (MakeFileName)
2148 returncode, StdOut, StdErr = self.ExecuteCommand (MakeCommand)
2149 Messages = StdOut
2150 else:
2151 MakeCommand = 'make -f %s' % (MakeFileName)
2152 returncode, StdOut, StdErr = self.ExecuteCommand (MakeCommand)
2153 Messages = StdErr
2154 Messages = Messages.split('\n')
2155 MessageGroup = []
2156 if returncode <>0:
2157 CAppBaseFileName = os.path.join(self.OutputPath, PcdValueInitName)
2158 File = open (CAppBaseFileName + '.c', 'r')
2159 FileData = File.readlines()
2160 File.close()
2161 for Message in Messages:
2162 if " error" in Message or "warning" in Message:
2163 FileInfo = Message.strip().split('(')
2164 if len (FileInfo) > 1:
2165 FileName = FileInfo [0]
2166 FileLine = FileInfo [1].split (')')[0]
2167 else:
2168 FileInfo = Message.strip().split(':')
2169 FileName = FileInfo [0]
2170 FileLine = FileInfo [1]
2171 if FileLine.isdigit():
2172 error_line = FileData[int (FileLine) - 1]
2173 if r"//" in error_line:
2174 c_line,dsc_line = error_line.split(r"//")
2175 else:
2176 dsc_line = error_line
2177 message_itmes = Message.split(":")
2178 Index = 0
2179 if "PcdValueInit.c" not in Message:
2180 if not MessageGroup:
2181 MessageGroup.append(Message)
2182 break
2183 else:
2184 for item in message_itmes:
2185 if "PcdValueInit.c" in item:
2186 Index = message_itmes.index(item)
2187 message_itmes[Index] = dsc_line.strip()
2188 break
2189 MessageGroup.append(":".join(message_itmes[Index:]).strip())
2190 continue
2191 else:
2192 MessageGroup.append(Message)
2193 if MessageGroup:
2194 EdkLogger.error("build", PCD_STRUCTURE_PCD_ERROR, "\n".join(MessageGroup) )
2195 else:
2196 EdkLogger.error('Build', COMMAND_FAILURE, 'Can not execute command: %s' % MakeCommand)
2197
2198 if self.NeedUpdateOutput(OutputValueFile, PcdValueInitExe ,InputValueFile):
2199 Command = PcdValueInitExe + ' -i %s -o %s' % (InputValueFile, OutputValueFile)
2200 returncode, StdOut, StdErr = self.ExecuteCommand (Command)
2201 if returncode <> 0:
2202 EdkLogger.warn('Build', COMMAND_FAILURE, 'Can not collect output from command: %s' % Command)
2203
2204 File = open (OutputValueFile, 'r')
2205 FileBuffer = File.readlines()
2206 File.close()
2207
2208 StructurePcdSet = []
2209 for Pcd in FileBuffer:
2210 PcdValue = Pcd.split ('|')
2211 PcdInfo = PcdValue[0].split ('.')
2212 StructurePcdSet.append((PcdInfo[0],PcdInfo[1], PcdInfo[2], PcdInfo[3], PcdValue[2].strip()))
2213 return StructurePcdSet
2214
2215 def NeedUpdateOutput(self,OutputFile, ValueCFile, StructureInput):
2216 if not os.path.exists(OutputFile):
2217 return True
2218 if os.stat(OutputFile).st_mtime <= os.stat(ValueCFile).st_mtime:
2219 return True
2220 if os.stat(OutputFile).st_mtime <= os.stat(StructureInput).st_mtime:
2221 return True
2222 return False
2223
2224 ## Retrieve dynamic PCD settings
2225 #
2226 # @param Type PCD type
2227 #
2228 # @retval a dict object contains settings of given PCD type
2229 #
2230 def _GetDynamicPcd(self, Type):
2231
2232
2233 Pcds = OrderedDict()
2234 #
2235 # tdict is a special dict kind of type, used for selecting correct
2236 # PCD settings for certain ARCH and SKU
2237 #
2238 PcdDict = tdict(True, 4)
2239 PcdList = []
2240 # Find out all possible PCD candidates for self._Arch
2241 RecordList = self._RawData[Type, self._Arch]
2242 AvailableSkuIdSet = copy.copy(self.SkuIds)
2243
2244
2245 for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4,Dummy5 in RecordList:
2246 SkuName = SkuName.upper()
2247 SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
2248 if SkuName not in AvailableSkuIdSet:
2249 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
2250 File=self.MetaFile, Line=Dummy5)
2251 if "." not in TokenSpaceGuid:
2252 PcdList.append((PcdCName, TokenSpaceGuid, SkuName, Dummy5))
2253 PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
2254
2255 # Remove redundant PCD candidates, per the ARCH and SKU
2256 for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:
2257
2258 Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]
2259 if Setting is None:
2260 continue
2261
2262 PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
2263 SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], '', '', '', '', '', PcdValue)
2264 if (PcdCName, TokenSpaceGuid) in Pcds.keys():
2265 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
2266 pcdObject.SkuInfoList[SkuName] = SkuInfo
2267 if MaxDatumSize.strip():
2268 CurrentMaxSize = int(MaxDatumSize.strip(), 0)
2269 else:
2270 CurrentMaxSize = 0
2271 if pcdObject.MaxDatumSize:
2272 PcdMaxSize = int(pcdObject.MaxDatumSize, 0)
2273 else:
2274 PcdMaxSize = 0
2275 if CurrentMaxSize > PcdMaxSize:
2276 pcdObject.MaxDatumSize = str(CurrentMaxSize)
2277 else:
2278 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
2279 PcdCName,
2280 TokenSpaceGuid,
2281 self._PCD_TYPE_STRING_[Type],
2282 DatumType,
2283 PcdValue,
2284 '',
2285 MaxDatumSize,
2286 {SkuName : SkuInfo},
2287 False,
2288 None,
2289 IsDsc=True)
2290
2291 for pcd in Pcds.values():
2292 pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
2293 # Only fix the value while no value provided in DSC file.
2294 for sku in pcd.SkuInfoList.values():
2295 if not sku.DefaultValue:
2296 sku.DefaultValue = pcdDecObject.DefaultValue
2297 if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():
2298 valuefromDec = pcdDecObject.DefaultValue
2299 SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '', '', '', valuefromDec)
2300 pcd.SkuInfoList['DEFAULT'] = SkuInfo
2301 elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
2302 pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
2303 del(pcd.SkuInfoList['COMMON'])
2304 elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
2305 del(pcd.SkuInfoList['COMMON'])
2306
2307 map(self.FilterSkuSettings,Pcds.values())
2308
2309 return Pcds
2310
2311 def FilterSkuSettings(self, PcdObj):
2312
2313 if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE:
2314 if 'DEFAULT' in PcdObj.SkuInfoList.keys() and self.SkuIdMgr.SystemSkuId not in PcdObj.SkuInfoList.keys():
2315 PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId] = PcdObj.SkuInfoList['DEFAULT']
2316 PcdObj.SkuInfoList = {'DEFAULT':PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId]}
2317 PcdObj.SkuInfoList['DEFAULT'].SkuIdName = 'DEFAULT'
2318 PcdObj.SkuInfoList['DEFAULT'].SkuId = '0'
2319
2320 elif self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.DEFAULT:
2321 PcdObj.SkuInfoList = {'DEFAULT':PcdObj.SkuInfoList['DEFAULT']}
2322
2323 return PcdObj
2324
2325
2326 def CompareVarAttr(self, Attr1, Attr2):
2327 if not Attr1 or not Attr2: # for empty string
2328 return True
2329 Attr1s = [attr.strip() for attr in Attr1.split(",")]
2330 Attr1Set = set(Attr1s)
2331 Attr2s = [attr.strip() for attr in Attr2.split(",")]
2332 Attr2Set = set(Attr2s)
2333 if Attr2Set == Attr1Set:
2334 return True
2335 else:
2336 return False
2337 def CopyDscRawValue(self,Pcd):
2338 if Pcd.DscRawValue is None:
2339 Pcd.DscRawValue = dict()
2340 if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD], self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2341 if self.SkuIdMgr.SystemSkuId not in Pcd.DscRawValue:
2342 Pcd.DscRawValue[self.SkuIdMgr.SystemSkuId] = {}
2343 Pcd.DscRawValue[self.SkuIdMgr.SystemSkuId][TAB_DEFAULT_STORES_DEFAULT] = Pcd.DefaultValue
2344 for skuname in Pcd.SkuInfoList:
2345 Pcd.DscRawValue[skuname] = {}
2346 if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
2347 for defaultstore in Pcd.SkuInfoList[skuname].DefaultStoreDict:
2348 Pcd.DscRawValue[skuname][defaultstore] = Pcd.SkuInfoList[skuname].DefaultStoreDict[defaultstore]
2349 else:
2350 Pcd.DscRawValue[skuname][TAB_DEFAULT_STORES_DEFAULT] = Pcd.SkuInfoList[skuname].DefaultValue
2351 def CompletePcdValues(self,PcdSet):
2352 Pcds = {}
2353 DefaultStoreObj = DefaultStore(self._GetDefaultStores())
2354 SkuIds = {skuname:skuid for skuname,skuid in self.SkuIdMgr.AvailableSkuIdSet.items() if skuname !='COMMON'}
2355 DefaultStores = set([storename for pcdobj in PcdSet.values() for skuobj in pcdobj.SkuInfoList.values() for storename in skuobj.DefaultStoreDict.keys()])
2356 for PcdCName, TokenSpaceGuid in PcdSet:
2357 PcdObj = PcdSet[(PcdCName, TokenSpaceGuid)]
2358 self.CopyDscRawValue(PcdObj)
2359 if PcdObj.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],
2360 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
2361 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_VPD],
2362 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_DEFAULT],
2363 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII],
2364 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_VPD]]:
2365 Pcds[PcdCName, TokenSpaceGuid]= PcdObj
2366 continue
2367 PcdType = PcdObj.Type
2368 if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
2369 for skuid in PcdObj.SkuInfoList:
2370 skuobj = PcdObj.SkuInfoList[skuid]
2371 mindefaultstorename = DefaultStoreObj.GetMin(set([defaultstorename for defaultstorename in skuobj.DefaultStoreDict]))
2372 for defaultstorename in DefaultStores:
2373 if defaultstorename not in skuobj.DefaultStoreDict:
2374 skuobj.DefaultStoreDict[defaultstorename] = copy.deepcopy(skuobj.DefaultStoreDict[mindefaultstorename])
2375 skuobj.HiiDefaultValue = skuobj.DefaultStoreDict[mindefaultstorename]
2376 for skuname,skuid in SkuIds.items():
2377 if skuname not in PcdObj.SkuInfoList:
2378 nextskuid = self.SkuIdMgr.GetNextSkuId(skuname)
2379 while nextskuid not in PcdObj.SkuInfoList:
2380 nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
2381 PcdObj.SkuInfoList[skuname] = copy.deepcopy(PcdObj.SkuInfoList[nextskuid])
2382 PcdObj.SkuInfoList[skuname].SkuId = skuid
2383 PcdObj.SkuInfoList[skuname].SkuIdName = skuname
2384 if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
2385 PcdObj.DefaultValue = PcdObj.SkuInfoList.values()[0].HiiDefaultValue if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE else PcdObj.SkuInfoList["DEFAULT"].HiiDefaultValue
2386 Pcds[PcdCName, TokenSpaceGuid]= PcdObj
2387 return Pcds
2388 ## Retrieve dynamic HII PCD settings
2389 #
2390 # @param Type PCD type
2391 #
2392 # @retval a dict object contains settings of given PCD type
2393 #
2394 def _GetDynamicHiiPcd(self, Type):
2395
2396 VariableAttrs = {}
2397
2398 Pcds = OrderedDict()
2399 #
2400 # tdict is a special dict kind of type, used for selecting correct
2401 # PCD settings for certain ARCH and SKU
2402 #
2403 PcdDict = tdict(True, 5)
2404 PcdSet = set()
2405 RecordList = self._RawData[Type, self._Arch]
2406 # Find out all possible PCD candidates for self._Arch
2407 AvailableSkuIdSet = copy.copy(self.SkuIds)
2408 DefaultStoresDefine = self._GetDefaultStores()
2409
2410 for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, DefaultStore, Dummy4,Dummy5 in RecordList:
2411 SkuName = SkuName.upper()
2412 SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
2413 DefaultStore = DefaultStore.upper()
2414 if DefaultStore == "COMMON":
2415 DefaultStore = TAB_DEFAULT_STORES_DEFAULT
2416 if SkuName not in AvailableSkuIdSet:
2417 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
2418 File=self.MetaFile, Line=Dummy5)
2419 if DefaultStore not in DefaultStoresDefine:
2420 EdkLogger.error('build', PARAMETER_INVALID, 'DefaultStores %s is not defined in [DefaultStores] section' % DefaultStore,
2421 File=self.MetaFile, Line=Dummy5)
2422 if "." not in TokenSpaceGuid:
2423 PcdSet.add((PcdCName, TokenSpaceGuid, SkuName,DefaultStore, Dummy5))
2424 PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid,DefaultStore] = Setting
2425
2426
2427 # Remove redundant PCD candidates, per the ARCH and SKU
2428 for PcdCName, TokenSpaceGuid, SkuName,DefaultStore, Dummy4 in PcdSet:
2429
2430 Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid,DefaultStore]
2431 if Setting is None:
2432 continue
2433 VariableName, VariableGuid, VariableOffset, DefaultValue, VarAttribute = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
2434
2435 rt, Msg = VariableAttributes.ValidateVarAttributes(VarAttribute)
2436 if not rt:
2437 EdkLogger.error("build", PCD_VARIABLE_ATTRIBUTES_ERROR, "Variable attributes settings for %s is incorrect.\n %s" % (".".join((TokenSpaceGuid, PcdCName)), Msg),
2438 ExtraData="[%s]" % VarAttribute)
2439 ExceedMax = False
2440 FormatCorrect = True
2441 if VariableOffset.isdigit():
2442 if int(VariableOffset, 10) > 0xFFFF:
2443 ExceedMax = True
2444 elif re.match(r'[\t\s]*0[xX][a-fA-F0-9]+$', VariableOffset):
2445 if int(VariableOffset, 16) > 0xFFFF:
2446 ExceedMax = True
2447 # For Offset written in "A.B"
2448 elif VariableOffset.find('.') > -1:
2449 VariableOffsetList = VariableOffset.split(".")
2450 if not (len(VariableOffsetList) == 2
2451 and IsValidWord(VariableOffsetList[0])
2452 and IsValidWord(VariableOffsetList[1])):
2453 FormatCorrect = False
2454 else:
2455 FormatCorrect = False
2456 if not FormatCorrect:
2457 EdkLogger.error('Build', FORMAT_INVALID, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid, PcdCName)))
2458
2459 if ExceedMax:
2460 EdkLogger.error('Build', OPTION_VALUE_INVALID, "The variable offset value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid, PcdCName)))
2461 if (VariableName, VariableGuid) not in VariableAttrs:
2462 VariableAttrs[(VariableName, VariableGuid)] = VarAttribute
2463 else:
2464 if not self.CompareVarAttr(VariableAttrs[(VariableName, VariableGuid)], VarAttribute):
2465 EdkLogger.error('Build', PCD_VARIABLE_ATTRIBUTES_CONFLICT_ERROR, "The variable %s.%s for DynamicHii PCDs has conflicting attributes [%s] and [%s] " % (VariableGuid, VariableName, VarAttribute, VariableAttrs[(VariableName, VariableGuid)]))
2466
2467 pcdDecObject = self._DecPcds[PcdCName, TokenSpaceGuid]
2468 if (PcdCName, TokenSpaceGuid) in Pcds.keys():
2469 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
2470 if SkuName in pcdObject.SkuInfoList:
2471 Skuitem = pcdObject.SkuInfoList[SkuName]
2472 Skuitem.DefaultStoreDict.update({DefaultStore:DefaultValue})
2473 else:
2474 SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute,DefaultStore={DefaultStore:DefaultValue})
2475 pcdObject.SkuInfoList[SkuName] = SkuInfo
2476 else:
2477 SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute,DefaultStore={DefaultStore:DefaultValue})
2478 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
2479 PcdCName,
2480 TokenSpaceGuid,
2481 self._PCD_TYPE_STRING_[Type],
2482 '',
2483 DefaultValue,
2484 '',
2485 '',
2486 {SkuName : SkuInfo},
2487 False,
2488 None,
2489 pcdDecObject.validateranges,
2490 pcdDecObject.validlists,
2491 pcdDecObject.expressions,
2492 IsDsc=True)
2493
2494
2495 for pcd in Pcds.values():
2496 SkuInfoObj = pcd.SkuInfoList.values()[0]
2497 pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
2498 pcd.DatumType = pcdDecObject.DatumType
2499 # Only fix the value while no value provided in DSC file.
2500 for sku in pcd.SkuInfoList.values():
2501 if (sku.HiiDefaultValue == "" or sku.HiiDefaultValue is None):
2502 sku.HiiDefaultValue = pcdDecObject.DefaultValue
2503 for default_store in sku.DefaultStoreDict:
2504 sku.DefaultStoreDict[default_store]=pcdDecObject.DefaultValue
2505 pcd.DefaultValue = pcdDecObject.DefaultValue
2506 if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():
2507 valuefromDec = pcdDecObject.DefaultValue
2508 SkuInfo = SkuInfoClass('DEFAULT', '0', SkuInfoObj.VariableName, SkuInfoObj.VariableGuid, SkuInfoObj.VariableOffset, valuefromDec,VariableAttribute=SkuInfoObj.VariableAttribute,DefaultStore={DefaultStore:valuefromDec})
2509 pcd.SkuInfoList['DEFAULT'] = SkuInfo
2510 elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
2511 pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
2512 del(pcd.SkuInfoList['COMMON'])
2513 elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
2514 del(pcd.SkuInfoList['COMMON'])
2515
2516 if pcd.MaxDatumSize.strip():
2517 MaxSize = int(pcd.MaxDatumSize, 0)
2518 else:
2519 MaxSize = 0
2520 if pcd.DatumType not in ['BOOLEAN','UINT8','UINT16','UINT32','UINT64']:
2521 for (_, skuobj) in pcd.SkuInfoList.items():
2522 datalen = 0
2523 skuobj.HiiDefaultValue = StringToArray(skuobj.HiiDefaultValue)
2524 datalen = len(skuobj.HiiDefaultValue.split(","))
2525 if datalen > MaxSize:
2526 MaxSize = datalen
2527 for defaultst in skuobj.DefaultStoreDict:
2528 skuobj.DefaultStoreDict[defaultst] = StringToArray(skuobj.DefaultStoreDict[defaultst])
2529 pcd.DefaultValue = StringToArray(pcd.DefaultValue)
2530 pcd.MaxDatumSize = str(MaxSize)
2531 rt, invalidhii = self.CheckVariableNameAssignment(Pcds)
2532 if not rt:
2533 invalidpcd = ",".join(invalidhii)
2534 EdkLogger.error('build', PCD_VARIABLE_INFO_ERROR, Message='The same HII PCD must map to the same EFI variable for all SKUs', File=self.MetaFile, ExtraData=invalidpcd)
2535
2536 map(self.FilterSkuSettings,Pcds.values())
2537
2538 return Pcds
2539
2540 def CheckVariableNameAssignment(self,Pcds):
2541 invalidhii = []
2542 for pcdname in Pcds:
2543 pcd = Pcds[pcdname]
2544 varnameset = set([sku.VariableName for (skuid,sku) in pcd.SkuInfoList.items()])
2545 if len(varnameset) > 1:
2546 invalidhii.append(".".join((pcdname[1],pcdname[0])))
2547 if len(invalidhii):
2548 return False,invalidhii
2549 else:
2550 return True, []
2551 ## Retrieve dynamic VPD PCD settings
2552 #
2553 # @param Type PCD type
2554 #
2555 # @retval a dict object contains settings of given PCD type
2556 #
2557 def _GetDynamicVpdPcd(self, Type):
2558
2559
2560 Pcds = OrderedDict()
2561 #
2562 # tdict is a special dict kind of type, used for selecting correct
2563 # PCD settings for certain ARCH and SKU
2564 #
2565 PcdDict = tdict(True, 4)
2566 PcdList = []
2567
2568 # Find out all possible PCD candidates for self._Arch
2569 RecordList = self._RawData[Type, self._Arch]
2570 AvailableSkuIdSet = copy.copy(self.SkuIds)
2571
2572 for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4,Dummy5 in RecordList:
2573 SkuName = SkuName.upper()
2574 SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
2575 if SkuName not in AvailableSkuIdSet:
2576 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
2577 File=self.MetaFile, Line=Dummy5)
2578 if "." not in TokenSpaceGuid:
2579 PcdList.append((PcdCName, TokenSpaceGuid, SkuName, Dummy5))
2580 PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
2581
2582 # Remove redundant PCD candidates, per the ARCH and SKU
2583 for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:
2584 Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]
2585 if Setting is None:
2586 continue
2587 #
2588 # For the VOID* type, it can have optional data of MaxDatumSize and InitialValue
2589 # For the Integer & Boolean type, the optional data can only be InitialValue.
2590 # At this point, we put all the data into the PcdClssObject for we don't know the PCD's datumtype
2591 # until the DEC parser has been called.
2592 #
2593 VpdOffset, MaxDatumSize, InitialValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
2594 SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], '', '', '', '', VpdOffset, InitialValue)
2595 if (PcdCName, TokenSpaceGuid) in Pcds.keys():
2596 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
2597 pcdObject.SkuInfoList[SkuName] = SkuInfo
2598 if MaxDatumSize.strip():
2599 CurrentMaxSize = int(MaxDatumSize.strip(), 0)
2600 else:
2601 CurrentMaxSize = 0
2602 if pcdObject.MaxDatumSize:
2603 PcdMaxSize = int(pcdObject.MaxDatumSize, 0)
2604 else:
2605 PcdMaxSize = 0
2606 if CurrentMaxSize > PcdMaxSize:
2607 pcdObject.MaxDatumSize = str(CurrentMaxSize)
2608 else:
2609 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
2610 PcdCName,
2611 TokenSpaceGuid,
2612 self._PCD_TYPE_STRING_[Type],
2613 '',
2614 InitialValue,
2615 '',
2616 MaxDatumSize,
2617 {SkuName : SkuInfo},
2618 False,
2619 None,
2620 IsDsc=True)
2621 for pcd in Pcds.values():
2622 SkuInfoObj = pcd.SkuInfoList.values()[0]
2623 pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
2624 pcd.DatumType = pcdDecObject.DatumType
2625 # Only fix the value while no value provided in DSC file.
2626 for sku in pcd.SkuInfoList.values():
2627 if not sku.DefaultValue:
2628 sku.DefaultValue = pcdDecObject.DefaultValue
2629 if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():
2630 valuefromDec = pcdDecObject.DefaultValue
2631 SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '', '', SkuInfoObj.VpdOffset, valuefromDec)
2632 pcd.SkuInfoList['DEFAULT'] = SkuInfo
2633 elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
2634 pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
2635 del(pcd.SkuInfoList['COMMON'])
2636 elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
2637 del(pcd.SkuInfoList['COMMON'])
2638
2639
2640 map(self.FilterSkuSettings,Pcds.values())
2641 return Pcds
2642
2643 ## Add external modules
2644 #