2 # This file is used to create a database used by build tool
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
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.
15 ## Platform build information from DSC file
17 # This class is used to retrieve information stored in database and convert them
18 # into PlatformBuildClassObject form for easier use for AutoGen.
20 from Common
.String
import *
21 from Common
.DataType
import *
22 from Common
.Misc
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 *
32 from WorkspaceCommon
import GetDeclaredPcd
33 from Common
.Misc
import AnalyzeDscPcd
34 from Common
.Misc
import ProcessDuplicatedInf
36 from Common
.Parsing
import IsValidWord
37 from Common
.VariableAttributes
import VariableAttributes
38 import Common
.GlobalData
as GlobalData
40 from Common
.Misc
import SaveFileOnChange
41 from Workspace
.BuildClassObject
import PlatformBuildClassObject
, StructurePcd
, PcdClassObject
, ModuleBuildClassObject
42 from collections
import OrderedDict
45 # Treat CHAR16 as a synonym for UINT16. CHAR16 support is required for VFR C structs
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']
61 #include <PcdValueCommon.h>
71 return PcdValueMain (argc, argv);
75 PcdMakefileHeader
= '''
78 # This file is auto-generated by build utility
83 WindowsCFLAGS
= 'CFLAGS = $(CFLAGS) /wd4200 /wd4034 /wd4101 '
84 LinuxCFLAGS
= 'BUILD_CFLAGS += -Wno-pointer-to-int-cast -Wno-unused-variable '
86 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.common
88 LIBS = $(LIB_PATH)\Common.lib
90 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.app
94 MAKEROOT ?= $(EDK_TOOLS_PATH)/Source/C
98 ## Regular expression for finding header file inclusions
99 from AutoGen
.GenMake
import gIncludePattern
101 ## Find dependencies for one source file
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.
107 # @param SearchPathList The list of search path
109 # @retval list The list of files the given source file depends on
111 def GetDependencyList(FileStack
,SearchPathList
):
113 DependencySet
= set(FileStack
)
114 while len(FileStack
) > 0:
116 FullPathDependList
= []
117 CurrentFileDependencyList
= []
119 CurrentFileDependencyList
= DepDb
[F
]
123 FileContent
= Fd
.read()
124 except BaseException
, X
:
125 EdkLogger
.error("build", FILE_OPEN_FAILURE
, ExtraData
=F
+ "\n\t" + str(X
))
127 if "Fd" in dir(locals()):
130 if len(FileContent
) == 0:
133 if FileContent
[0] == 0xff or FileContent
[0] == 0xfe:
134 FileContent
= unicode(FileContent
, "utf-16")
135 IncludedFileList
= gIncludePattern
.findall(FileContent
)
137 for Inc
in IncludedFileList
:
139 Inc
= os
.path
.normpath(Inc
)
140 CurrentFileDependencyList
.append(Inc
)
141 DepDb
[F
] = CurrentFileDependencyList
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
):
150 if FilePath
not in DependencySet
:
151 FileStack
.append(FilePath
)
152 FullPathDependList
.append(FilePath
)
154 DependencySet
.update(FullPathDependList
)
155 DependencyList
= list(DependencySet
) # remove duplicate ones
157 return DependencyList
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",
175 # dict used to convert part of [Defines] to members of DscBuildData directly
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",
197 # used to compose dummy library class name for those forced library instances
198 _NullLibraryNumber
= 0
200 ## Constructor of DscBuildData
202 # Initialize object of DscBuildData
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
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
216 self
._Target
= Target
217 self
._Toolchain
= Toolchain
218 self
._ToolChainFamily
= None
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
)
225 def OutputPath(self
):
226 if os
.getenv("WORKSPACE"):
227 return os
.path
.join(os
.getenv("WORKSPACE"), self
.OutputDirectory
, self
._Target
+ "_" + self
._Toolchain
,PcdValueInitName
)
229 return os
.path
.dirname(self
.DscFile
)
232 def __setitem__(self
, key
, value
):
233 self
.__dict
__[self
._PROPERTY
_[key
]] = value
236 def __getitem__(self
, key
):
237 return self
.__dict
__[self
._PROPERTY
_[key
]]
240 def __contains__(self
, key
):
241 return key
in self
._PROPERTY
_
243 ## Set all internal used members of DscBuildData to None
246 self
._PlatformName
= None
249 self
._DscSpecification
= None
250 self
._OutputDirectory
= None
251 self
._SupArchList
= None
252 self
._BuildTargets
= 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
265 self
._LibraryInstances
= None
266 self
._LibraryClasses
= 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
276 self
.DefaultStores
= None
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
:
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
]
290 SourceOverridePath
= mws
.join(GlobalData
.gWorkspace
, NormPath(RecordList
[0][0]))
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
)
296 # Add to GlobalData Variables
297 GlobalData
.gOverrideDir
[ModuleFile
.Key
] = SourceOverridePath
299 ## Get current effective macros
300 def _GetMacros(self
):
301 if self
.__Macros
is None:
303 self
.__Macros
.update(GlobalData
.gPlatformDefines
)
304 self
.__Macros
.update(GlobalData
.gGlobalDefines
)
305 self
.__Macros
.update(GlobalData
.gCommandLineDefines
)
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.
319 # @param Value The value of ARCH
321 def _SetArch(self
, Value
):
322 if self
._Arch
== Value
:
327 ## Retrieve all information in [Defines] section
329 # (Retriving all [Defines] information in one-shot is just to save time.)
331 def _GetHeaderInfo(self
):
332 RecordList
= self
._RawData
[MODEL_META_DATA_HEADER
, self
._Arch
]
333 for Record
in RecordList
:
335 # items defined _PROPERTY_ don't need additional processing
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')
348 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=Record
[-1],
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
:
381 self
._LoadFixAddress
= int (Record
[2], 0)
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])
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
:
415 # try to convert GUID to a real UUID value to see whether the GUID is format
416 # for VPD_TOOL_GUID is correct.
421 EdkLogger
.error("build", FORMAT_INVALID
, "Invalid GUID format for VPD_TOOL_GUID", File
=self
.MetaFile
)
422 self
._VpdToolGuid
= Record
[2]
424 self
[Name
] = Record
[2]
425 # set _Header to non-None in order to avoid database re-querying
426 self
._Header
= 'DUMMY'
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
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
)
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
)
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
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
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
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
491 def _GetPcdInfoFlag(self
):
492 if self
._PcdInfoFlag
is None or self
._PcdInfoFlag
.upper() == 'FALSE':
494 elif self
._PcdInfoFlag
.upper() == 'TRUE':
498 def _GetVarCheckFlag(self
):
499 if self
._VarCheckFlag
is None or self
._VarCheckFlag
.upper() == 'FALSE':
501 elif self
._VarCheckFlag
.upper() == 'TRUE':
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'
515 ## Override SKUID_IDENTIFIER
516 def _SetSkuName(self
, Value
):
517 self
._SkuName
= Value
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
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:
533 return self
._Prebuild
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:
541 return self
._Postbuild
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
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
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
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
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
()
585 if self
._LoadFixAddress
is None:
586 self
._LoadFixAddress
= self
._Macros
.get(TAB_FIX_LOAD_TOP_MEMORY_ADDRESS
, '0')
589 self
._LoadFixAddress
= int (self
._LoadFixAddress
, 0)
591 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (self
._LoadFixAddress
))
594 # If command line defined, should override the value in DSC file.
596 if 'FIX_LOAD_TOP_MEMORY_ADDRESS' in GlobalData
.gCommandLineDefines
.keys():
598 self
._LoadFixAddress
= int(GlobalData
.gCommandLineDefines
['FIX_LOAD_TOP_MEMORY_ADDRESS'], 0)
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']))
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
))
607 return self
._LoadFixAddress
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
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
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")
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
690 ## Retrieve [Components] section information
691 def _GetModules(self
):
692 if self
._Modules
is not None:
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
702 ModuleFile
= PathClass(NormPath(Record
[0], Macros
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
706 # check the file validation
707 ErrorCode
, ErrorInfo
= ModuleFile
.Validate('.inf')
709 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
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
716 Module
= ModuleBuildClassObject()
717 Module
.MetaFile
= ModuleFile
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
)
726 # check the file validation
727 ErrorCode
, ErrorInfo
= LibraryPath
.Validate('.inf')
729 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
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
)
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]
752 TypeString
= self
._PCD
_TYPE
_STRING
_[Type
]
753 Pcd
= PcdClassObject(
765 Module
.Pcds
[PcdCName
, TokenSpaceGuid
] = Pcd
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
773 OptionString
= Module
.BuildOptions
[ToolChainFamily
, ToolChain
]
774 Module
.BuildOptions
[ToolChainFamily
, ToolChain
] = OptionString
+ " " + Option
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
)
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
786 self
._Modules
[ModuleFile
] = Module
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
795 ## Retrieve [LibraryClasses] information
796 def _GetLibraryClasses(self
):
797 if self
._LibraryClasses
is None:
798 self
._LibraryInstances
= []
800 # tdict is a special dict kind of type, used for selecting correct
801 # library instance for given library class and module type
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')
819 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
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
)
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:
837 self
._LibraryClasses
[LibraryClass
, ModuleType
] = LibraryInstance
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
)
845 # check the file validation
846 ErrorCode
, ErrorInfo
= File
.Validate('.inf')
848 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
850 if File
not in self
._LibraryInstances
:
851 self
._LibraryInstances
.append(File
)
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)
857 Library
= self
._Bdb
[File
, self
._Arch
, self
._Target
, self
._Toolchain
]
858 self
._LibraryClasses
[Library
.BaseName
, ':dummy:'] = Library
859 return self
._LibraryClasses
861 def _ValidatePcd(self
, PcdCName
, TokenSpaceGuid
, Setting
, PcdType
, LineNo
):
862 if self
._DecPcds
is None:
865 if GlobalData
.gFdfParser
:
866 FdfInfList
= GlobalData
.gFdfParser
.Profile
.InfList
869 for Inf
in FdfInfList
:
870 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
871 if ModuleFile
in self
._Modules
:
873 ModuleData
= self
._Bdb
[ModuleFile
, self
._Arch
, self
._Target
, self
._Toolchain
]
874 PkgSet
.update(ModuleData
.Packages
)
876 self
._DecPcds
, self
._GuidDict
= GetDeclaredPcd(self
, self
._Bdb
, self
._Arch
, self
._Target
, self
._Toolchain
,PkgSet
)
877 self
._GuidDict
.update(GlobalData
.gPlatformPcds
)
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
)
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
))
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
))
893 DatumType
= self
._DecPcds
[PcdCName
, TokenSpaceGuid
].DatumType
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
)
908 EdkLogger
.error('Parser', FORMAT_INVALID
, "PCD (%s) is not defined in DSC file" % Excpt
.Pcd
,
909 File
=self
.MetaFile
, Line
=LineNo
)
911 EdkLogger
.error('Parser', FORMAT_INVALID
, "Invalid expression: %s" % str(Excpt
),
912 File
=self
.MetaFile
, Line
=LineNo
)
915 Valid
, ErrStr
= CheckPcdDatum(self
._DecPcds
[PcdCName
, TokenSpaceGuid
].DatumType
, ValueList
[Index
])
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
]
928 def _FilterPcdBySkuUsage(self
,Pcds
):
929 available_sku
= self
.SkuIdMgr
.AvailableSkuIdSet
930 sku_usage
= self
.SkuIdMgr
.SkuUsageType
931 if sku_usage
== SkuClass
.SINGLE
:
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
}
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
}
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
)
948 for skuid
in pcd
.SkuInfoList
:
949 skuobj
= pcd
.SkuInfoList
.get(skuid
)
950 if "STANDARD" not in skuobj
.DefaultStoreDict
:
951 PcdDefaultStoreSet
= set([defaultstorename
for defaultstorename
in skuobj
.DefaultStoreDict
])
952 mindefaultstorename
= DefaultStoreMgr
.GetMin(PcdDefaultStoreSet
)
953 skuobj
.DefaultStoreDict
['STANDARD'] = copy
.deepcopy(skuobj
.DefaultStoreDict
[mindefaultstorename
])
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
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
])
969 def __ParsePcdFromCommandLine(self
):
970 if GlobalData
.BuildOptionPcd
:
971 for i
, pcd
in enumerate(GlobalData
.BuildOptionPcd
):
972 if type(pcd
) is tuple:
974 (pcdname
, pcdvalue
) = pcd
.split('=')
976 EdkLogger
.error('build', AUTOGEN_ERROR
, "No Value specified for the PCD %s." % (pcdname
))
978 (Name1
, Name2
) = pcdname
.split('.',1)
980 (Name3
, FieldName
) = Name2
.split(".",1)
981 if ((Name3
,Name1
)) in self
.DecPcds
:
984 TokenSpaceGuidCName
= Name1
988 TokenSpaceGuidCName
= ''
989 HasTokenSpace
= False
991 if ((Name2
,Name1
)) in self
.DecPcds
:
994 TokenSpaceGuidCName
= Name1
999 TokenSpaceGuidCName
= ''
1000 HasTokenSpace
= False
1003 TokenCName
= pcdname
1004 TokenSpaceGuidCName
= ''
1005 HasTokenSpace
= False
1006 TokenSpaceGuidCNameList
= []
1009 DisplayName
= TokenCName
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
1026 "The Pcd %s is found under multiple different TokenSpaceGuid: %s and %s." % (DisplayName
, PcdItem
.TokenSpaceGuidCName
, TokenSpaceGuidCNameList
[0])
1029 if (TokenCName
, TokenSpaceGuidCName
) in self
.DecPcds
:
1030 PcdDatumType
= self
.DecPcds
[(TokenCName
, TokenSpaceGuidCName
)].DatumType
1034 EdkLogger
.error('build', AUTOGEN_ERROR
, "The Pcd %s.%s is not found in the DEC file." % (TokenSpaceGuidCName
, DisplayName
))
1036 EdkLogger
.error('build', AUTOGEN_ERROR
, "The Pcd %s is not found in the DEC file." % (DisplayName
))
1037 pcdvalue
= pcdvalue
.replace("\\\\\\'", '\\\\\\"').replace('\\\'', '\'').replace('\\\\\\"', "\\'")
1039 pcdvalue
= self
.HandleFlexiblePcd(TokenSpaceGuidCName
, TokenCName
, pcdvalue
, PcdDatumType
, self
._GuidDict
, FieldName
)
1041 pcdvalue
= self
.HandleFlexiblePcd(TokenSpaceGuidCName
, TokenCName
, pcdvalue
, PcdDatumType
, self
._GuidDict
)
1042 IsValid
, Cause
= CheckPcdDatum(PcdDatumType
, pcdvalue
)
1044 EdkLogger
.error("build", FORMAT_INVALID
, Cause
, ExtraData
="%s.%s" % (TokenSpaceGuidCName
, TokenCName
))
1045 GlobalData
.BuildOptionPcd
[i
] = (TokenSpaceGuidCName
, TokenCName
, FieldName
, pcdvalue
,("build command options",1))
1047 for BuildData
in self
._Bdb
._CACHE
_.values():
1048 if BuildData
.MetaFile
.Ext
== '.dec' or BuildData
.MetaFile
.Ext
== '.dsc':
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
1055 def HandleFlexiblePcd(self
, TokenSpaceGuidCName
, TokenCName
, PcdValue
, PcdDatumType
, GuidDict
, FieldName
=''):
1058 TokenCName
+= '.' + FieldName
1059 if PcdValue
.startswith('H'):
1060 if FieldName
and IsFieldValueAnArray(PcdValue
[1:]):
1061 PcdDatumType
= 'VOID*'
1063 if FieldName
and not IsArray
:
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*'
1074 if FieldName
and not IsArray
:
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*'
1086 if FieldName
and not IsArray
:
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
))
1094 if PcdValue
.upper() == 'FALSE':
1096 if PcdValue
.upper() == 'TRUE':
1099 if PcdDatumType
not in ['UINT8','UINT16','UINT32','UINT64','BOOLEAN']:
1100 PcdValue
= '"' + PcdValue
+ '"'
1104 if PcdValue
.upper().startswith('0X'):
1107 Num
= int(PcdValue
, Base
)
1109 PcdValue
= '"' + PcdValue
+ '"'
1110 if IsFieldValueAnArray(PcdValue
):
1111 PcdDatumType
= 'VOID*'
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
))
1122 ## Retrieve all PCD settings in platform
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
))
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
)
1143 self
.RecoverCommandLinePcd()
1146 def _dumpPcdInfo(self
,Pcds
):
1149 if not pcdobj
.TokenCName
.startswith("Test"):
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
]))
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()
1162 # Retrieve build option for EDKII and EDK style module
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':
1169 CurKey
= (ToolChainFamily
, ToolChain
, CodeBase
)
1171 # Only flags can be appended
1173 if CurKey
not in self
._BuildOptions
or not ToolChain
.endswith('_FLAGS') or Option
.startswith('='):
1174 self
._BuildOptions
[CurKey
] = Option
1176 if ' ' + Option
not in self
._BuildOptions
[CurKey
]:
1177 self
._BuildOptions
[CurKey
] += ' ' + Option
1178 return self
._BuildOptions
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
1196 if ' ' + Option
not in options
[Key
]:
1197 options
[Key
] += ' ' + Option
1198 return self
._ModuleTypeOptions
[Edk
, ModuleType
]
1200 def GetStructurePcdInfo(self
, PcdSet
):
1201 structure_pcd_data
= {}
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
)
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
:
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]
1228 def OverrideByFdfCommOverAll(self
,AllPcds
):
1229 def CheckStructureInComm(commpcds
):
1232 if len(commpcds
[0]) == 5:
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]}
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]
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]
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
)
1266 PcdInDec
= self
.DecPcds
.get((Name
,Guid
))
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]
1275 def UpdateStructuredPcds(self
, TypeList
, AllPcds
):
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
]]
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()])
1291 # Find out all possible PCD candidates for self._Arch
1294 for Type
in TypeList
:
1295 RecordList
.extend(self
._RawData
[Type
, self
._Arch
])
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
:
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]])
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])
1318 str_pcd_obj_str
= StructurePcd()
1319 str_pcd_obj_str
.copy(str_pcd_dec
)
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
}
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],'STANDARD' 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
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)
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
}
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
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
:
1354 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(skuid
)
1356 if skuid
not in stru_pcd
.SkuOverrideValues
:
1357 while nextskuid
not in stru_pcd
.SkuOverrideValues
:
1358 if nextskuid
== "DEFAULT":
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 {'STANDARD':stru_pcd
.DefaultValues
})
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
:
1369 if skuid
not in stru_pcd
.SkuOverrideValues
:
1370 while nextskuid
not in stru_pcd
.SkuOverrideValues
:
1371 if nextskuid
== "DEFAULT":
1374 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
1377 PcdDefaultStoreSet
= set([defaultstorename
for defaultstorename
in stru_pcd
.SkuOverrideValues
[nextskuid
]])
1378 mindefaultstorename
= DefaultStoreMgr
.GetMin(PcdDefaultStoreSet
)
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
)
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
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
})
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
1404 if skuname
not in str_pcd_obj
.SkuInfoList
:
1405 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(skuname
)
1407 while nextskuid
not in str_pcd_obj
.SkuInfoList
:
1408 if nextskuid
== "DEFAULT":
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
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
]]:
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
]
1426 for str_pcd_obj
in S_pcd_set
.values():
1428 str_pcd_obj
.MaxDatumSize
= self
.GetStructurePcdMaxSize(str_pcd_obj
)
1429 Pcds
[str_pcd_obj
.TokenCName
, str_pcd_obj
.TokenSpaceGuidCName
] = str_pcd_obj
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'])
1439 map(self
.FilterSkuSettings
,[Pcds
[pcdkey
] for pcdkey
in Pcds
if Pcds
[pcdkey
].Type
in DynamicPcdType
])
1442 ## Retrieve non-dynamic PCD settings
1444 # @param Type PCD type
1446 # @retval a dict object contains settings of given PCD type
1448 def _GetPcd(self
, Type
):
1449 Pcds
= OrderedDict()
1451 # tdict is a special dict kind of type, used for selecting correct
1452 # PCD settings for certain ARCH
1454 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
1456 PcdDict
= tdict(True, 3)
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
1472 for PcdCName
, TokenSpaceGuid
, SkuName
, Dummy4
in PcdSet
:
1473 Setting
= PcdDict
[self
._Arch
, PcdCName
, TokenSpaceGuid
, SkuName
]
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
)
1480 PcdValueDict
[PcdCName
, TokenSpaceGuid
] = {SkuName
:(PcdValue
, DatumType
, MaxDatumSize
)}
1482 PcdsKeys
= PcdValueDict
.keys()
1483 for PcdCName
, TokenSpaceGuid
in PcdsKeys
:
1485 PcdSetting
= PcdValueDict
[PcdCName
, TokenSpaceGuid
]
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
]
1496 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
1499 self
._PCD
_TYPE
_STRING
_[Type
],
1512 def __UNICODE2OCTList(self
,Value
):
1513 Value
= Value
.strip()
1517 Temp
= '%04X' % ord(Item
)
1518 List
.append('0x' + Temp
[2:4])
1519 List
.append('0x' + Temp
[0:2])
1523 def __STRING2OCTList(self
,Value
):
1525 Value
= Value
.strip('"')
1527 Temp
= '%02X' % ord(char
)
1528 OCTList
.append('0x' + Temp
)
1529 OCTList
.append('0x00')
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
)
1537 def get_length(value
):
1538 Value
= value
.strip()
1540 if Value
.startswith('GUID') and Value
.endswith(')'):
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
1554 return str(max([pcd_size
for pcd_size
in [get_length(item
) for item
in sku_values
]]))
1556 def ExecuteCommand (self
, Command
):
1558 Process
= subprocess
.Popen(Command
, stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
, shell
=True)
1560 EdkLogger
.error('Build', COMMAND_FAILURE
, 'Can not execute command: %s' % Command
)
1561 Result
= Process
.communicate()
1562 return Process
.returncode
, Result
[0], Result
[1]
1564 def IntToCString(self
, Value
, ValueSize
):
1566 if not isinstance (Value
, str):
1567 for Index
in range(0, ValueSize
):
1568 Result
= Result
+ '\\x%02x' % (Value
& 0xff)
1570 Result
= Result
+ '"'
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
])
1584 MaxSize
= max([len(Pcd
.PcdValueFromComm
),MaxSize
])
1585 elif Pcd
.DatumType
not in ['BOOLEAN','UINT8']:
1587 elif Pcd
.DatumType
== 'UINT16':
1589 elif Pcd
.DatumType
== 'UINT32':
1591 elif Pcd
.DatumType
== 'UINT64':
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
]:
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('}')):
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]);
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":
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
)]:
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('}')):
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]);
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('}')):
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]);
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
))
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
)
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
)
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
)
1702 # Use memcpy() to copy value into field
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
]:
1709 for FieldName
in FieldList
:
1710 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
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]))
1719 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
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])
1726 # Use memcpy() to copy value into field
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
)
1733 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1735 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1738 def GenerateDefaultValueAssignStatement(self
,Pcd
):
1739 CApp
= ' Assign_%s_%s_Default_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
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'
1747 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: %s \n" % ('DEFAULT', 'STANDARD')
1748 inherit_OverrideValues
= Pcd
.SkuOverrideValues
[SkuName
]
1749 if (SkuName
,DefaultStoreName
) == ('DEFAULT','STANDARD'):
1750 pcddefaultvalue
= Pcd
.DefaultFromDSC
.get('DEFAULT',{}).get('STANDARD', Pcd
.DefaultValue
) if Pcd
.DefaultFromDSC
else Pcd
.DefaultValue
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
)]:
1759 if pcddefaultvalue
and FieldList
== pcddefaultvalue
:
1760 IsArray
= IsFieldValueAnArray(FieldList
)
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
)
1769 if (SkuName
,DefaultStoreName
) == ('DEFAULT','STANDARD'):
1770 if isinstance(Value
, str):
1771 CApp
= CApp
+ ' Pcd = %s; // From DSC Default Value %s\n' % (Value
, Pcd
.DefaultFromDSC
.get('DEFAULT',{}).get('STANDARD', Pcd
.DefaultValue
) if Pcd
.DefaultFromDSC
else Pcd
.DefaultValue
)
1774 # Use memcpy() to copy value into field
1776 CApp
= CApp
+ ' Value = %s; // From DSC Default Value %s\n' % (self
.IntToCString(Value
, ValueSize
), Pcd
.DefaultFromDSC
.get('DEFAULT',{}).get('STANDARD', Pcd
.DefaultValue
) if Pcd
.DefaultFromDSC
else Pcd
.DefaultValue
)
1777 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1779 if isinstance(Value
, str):
1780 CApp
= CApp
+ ' Pcd = %s; // From DSC Default Value %s\n' % (Value
, Pcd
.DscRawValue
.get(SkuName
,{}).get(DefaultStoreName
))
1783 # Use memcpy() to copy value into field
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
)
1788 if (SkuName
,DefaultStoreName
) == ('DEFAULT','STANDARD') or (( (SkuName
,'') not in Pcd
.ValueChain
) and ( (SkuName
,DefaultStoreName
) not in Pcd
.ValueChain
)):
1789 for FieldName
in FieldList
:
1790 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
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]))
1798 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
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])
1805 # Use memcpy() to copy value into field
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
)
1812 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1814 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1817 def GenerateInitValueStatement(self
,Pcd
,SkuName
,DefaultStoreName
):
1818 CApp
= ' Assign_%s_%s_%s_%s_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
,SkuName
,DefaultStoreName
)
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'
1826 pcddefaultvalue
= Pcd
.PcdValueFromComm
1827 for FieldList
in [pcddefaultvalue
,Pcd
.PcdFieldValueFromComm
]:
1830 if pcddefaultvalue
and FieldList
== pcddefaultvalue
:
1831 IsArray
= IsFieldValueAnArray(FieldList
)
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
)
1840 if isinstance(Value
, str):
1841 CApp
= CApp
+ ' Pcd = %s; // From Command Line \n' % (Value
)
1844 # Use memcpy() to copy value into field
1846 CApp
= CApp
+ ' Value = %s; // From Command Line.\n' % (self
.IntToCString(Value
, ValueSize
))
1847 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1849 for FieldName
in FieldList
:
1850 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
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]))
1860 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
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])
1867 # Use memcpy() to copy value into field
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
)
1874 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1876 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1879 def GenerateCommandLineValueStatement(self
,Pcd
):
1880 CApp
= ' Assign_%s_%s_CommandLine_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
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'
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
)
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
)
1903 DefaultValue
= Pcd
.DefaultValue
1904 PcdDefaultValue
= StringToArray(DefaultValue
.strip())
1906 InitByteValue
+= '%s.%s.%s.%s|%s|%s\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Pcd
.DatumType
, PcdDefaultValue
)
1909 # Get current PCD value and size
1911 CApp
= CApp
+ ' OriginalPcd = PcdGetPtr (%s, %s, %s, %s, &OriginalSize);\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
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)
1921 CApp
= CApp
+ self
.GenerateSizeStatments(Pcd
)
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
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'
1933 # Copy current PCD value into allocated buffer.
1935 CApp
= CApp
+ ' memcpy (Pcd, OriginalPcd, OriginalSize);\n'
1938 # Assign field values in PCD
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
== 'STANDARD' else ['STANDARD', 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
:
1951 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: STANDARD \n" % self
.SkuIdMgr
.SystemSkuId
1952 CApp
= CApp
+ self
.GenerateInitValueStatement(Pcd
,self
.SkuIdMgr
.SystemSkuId
,"STANDARD")
1953 CApp
= CApp
+ self
.GenerateCommandLineValueStatement(Pcd
)
1955 # Set new PCD value and size
1957 CApp
= CApp
+ ' PcdSetPtr (%s, %s, %s, %s, Size, (UINT8 *)Pcd);\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1962 CApp
= CApp
+ ' free (Pcd);\n'
1965 return InitByteValue
, CApp
1967 def GenerateByteArrayValue (self
, StructuredPcds
):
1969 # Generate/Compile/Run C application to determine if there are any flexible array members
1971 if not StructuredPcds
:
1975 CApp
= PcdMainCHeader
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
)
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
, 'STANDARD')
1996 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
1997 if SkuName
not in Pcd
.SkuOverrideValues
:
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
, 'STANDARD', Pcd
, InitByteValue
, CApp
)
2005 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
2006 if SkuName
not in Pcd
.SkuOverrideValues
:
2008 for DefaultStoreName
in Pcd
.DefaultStoreName
:
2009 Pcd
= StructuredPcds
[PcdName
]
2010 InitByteValue
, CApp
= self
.GenerateInitializeFunc(SkuName
, DefaultStoreName
, Pcd
, InitByteValue
, CApp
)
2012 CApp
= CApp
+ 'VOID\n'
2013 CApp
= CApp
+ 'PcdEntryPoint(\n'
2014 CApp
= CApp
+ ' VOID\n'
2015 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
, 'STANDARD', Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2021 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
2022 if SkuName
not in Pcd
.SkuOverrideValues
:
2024 for DefaultStoreName
in Pcd
.SkuOverrideValues
[SkuName
]:
2025 CApp
= CApp
+ ' Initialize_%s_%s_%s_%s();\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2028 CApp
= CApp
+ PcdMainCEntry
+ '\n'
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)
2035 MakeApp
= PcdMakefileHeader
2036 if sys
.platform
== "win32":
2037 MakeApp
= MakeApp
+ 'APPNAME = %s\n' % (PcdValueInitName
) + 'OBJECTS = %s\%s.obj\n' % (self
.OutputPath
, PcdValueInitName
) + 'INC = '
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 +='
2045 for Cache
in self
._Bdb
._CACHE
_.values():
2046 if Cache
.MetaFile
.Ext
.lower() != '.dec':
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
)
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
)
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'
2071 CC_FLAGS
= LinuxCFLAGS
2072 if sys
.platform
== "win32":
2073 CC_FLAGS
= WindowsCFLAGS
2075 for Options
in self
.BuildOptions
:
2076 if Options
[2] != EDKII_NAME
:
2079 if Family
and Family
!= self
.ToolChainFamily
:
2081 Target
, Tag
, Arch
, Tool
, Attr
= Options
[1].split("_")
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
]
2093 # append options for the same tool except PATH
2095 BuildOptions
[Tool
][Attr
] += " " + self
.BuildOptions
[Options
]
2097 BuildOptions
[Tool
][Attr
] = self
.BuildOptions
[Options
]
2099 for Tool
in BuildOptions
:
2100 for Attr
in BuildOptions
[Tool
]:
2102 Value
= BuildOptions
[Tool
][Attr
]
2103 ValueList
= Value
.split()
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
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
))
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)
2135 InputValueFile
= os
.path
.join(self
.OutputPath
, 'Input.txt')
2136 OutputValueFile
= os
.path
.join(self
.OutputPath
, 'Output.txt')
2137 SaveFileOnChange(InputValueFile
, InitByteValue
, False)
2139 PcdValueInitExe
= PcdValueInitName
2140 if not sys
.platform
== "win32":
2141 PcdValueInitExe
= os
.path
.join(os
.getenv("EDK_TOOLS_PATH"), 'Source', 'C', 'bin', PcdValueInitName
)
2143 PcdValueInitExe
= os
.path
.join(os
.getenv("EDK_TOOLS_PATH"), 'Bin', 'Win32', PcdValueInitName
) +".exe"
2146 if sys
.platform
== "win32":
2147 MakeCommand
= 'nmake -f %s' % (MakeFileName
)
2148 returncode
, StdOut
, StdErr
= self
.ExecuteCommand (MakeCommand
)
2151 MakeCommand
= 'make -f %s' % (MakeFileName
)
2152 returncode
, StdOut
, StdErr
= self
.ExecuteCommand (MakeCommand
)
2154 Messages
= Messages
.split('\n')
2157 CAppBaseFileName
= os
.path
.join(self
.OutputPath
, PcdValueInitName
)
2158 File
= open (CAppBaseFileName
+ '.c', 'r')
2159 FileData
= File
.readlines()
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]
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
"//")
2176 dsc_line
= error_line
2177 message_itmes
= Message
.split(":")
2179 if "PcdValueInit.c" not in Message
:
2180 if not MessageGroup
:
2181 MessageGroup
.append(Message
)
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()
2189 MessageGroup
.append(":".join(message_itmes
[Index
:]).strip())
2192 MessageGroup
.append(Message
)
2194 EdkLogger
.error("build", PCD_STRUCTURE_PCD_ERROR
, "\n".join(MessageGroup
) )
2196 EdkLogger
.error('Build', COMMAND_FAILURE
, 'Can not execute command: %s' % MakeCommand
)
2198 if self
.NeedUpdateOutput(OutputValueFile
, PcdValueInitExe
,InputValueFile
):
2199 Command
= PcdValueInitExe
+ ' -i %s -o %s' % (InputValueFile
, OutputValueFile
)
2200 returncode
, StdOut
, StdErr
= self
.ExecuteCommand (Command
)
2202 EdkLogger
.warn('Build', COMMAND_FAILURE
, 'Can not collect output from command: %s' % Command
)
2204 File
= open (OutputValueFile
, 'r')
2205 FileBuffer
= File
.readlines()
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
2215 def NeedUpdateOutput(self
,OutputFile
, ValueCFile
, StructureInput
):
2216 if not os
.path
.exists(OutputFile
):
2218 if os
.stat(OutputFile
).st_mtime
<= os
.stat(ValueCFile
).st_mtime
:
2220 if os
.stat(OutputFile
).st_mtime
<= os
.stat(StructureInput
).st_mtime
:
2224 ## Retrieve dynamic PCD settings
2226 # @param Type PCD type
2228 # @retval a dict object contains settings of given PCD type
2230 def _GetDynamicPcd(self
, Type
):
2233 Pcds
= OrderedDict()
2235 # tdict is a special dict kind of type, used for selecting correct
2236 # PCD settings for certain ARCH and SKU
2238 PcdDict
= tdict(True, 4)
2240 # Find out all possible PCD candidates for self._Arch
2241 RecordList
= self
._RawData
[Type
, self
._Arch
]
2242 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
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
2255 # Remove redundant PCD candidates, per the ARCH and SKU
2256 for PcdCName
, TokenSpaceGuid
, SkuName
, Dummy4
in PcdList
:
2258 Setting
= PcdDict
[self
._Arch
, SkuName
, PcdCName
, TokenSpaceGuid
]
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)
2271 if pcdObject
.MaxDatumSize
:
2272 PcdMaxSize
= int(pcdObject
.MaxDatumSize
, 0)
2275 if CurrentMaxSize
> PcdMaxSize
:
2276 pcdObject
.MaxDatumSize
= str(CurrentMaxSize
)
2278 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
2281 self
._PCD
_TYPE
_STRING
_[Type
],
2286 {SkuName
: SkuInfo
},
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 (sku
.DefaultValue
== "" or sku
.DefaultValue
==None):
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'])
2307 map(self
.FilterSkuSettings
,Pcds
.values())
2311 def FilterSkuSettings(self
, PcdObj
):
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'
2320 elif self
.SkuIdMgr
.SkuUsageType
== self
.SkuIdMgr
.DEFAULT
:
2321 PcdObj
.SkuInfoList
= {'DEFAULT':PcdObj
.SkuInfoList
['DEFAULT']}
2326 def CompareVarAttr(self
, Attr1
, Attr2
):
2327 if not Attr1
or not Attr2
: # for empty string
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
:
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
]['STANDARD'] = 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
]
2350 Pcd
.DscRawValue
[skuname
]['STANDARD'] = Pcd
.SkuInfoList
[skuname
].DefaultValue
2351 def CompletePcdValues(self
,PcdSet
):
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
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
2388 ## Retrieve dynamic HII PCD settings
2390 # @param Type PCD type
2392 # @retval a dict object contains settings of given PCD type
2394 def _GetDynamicHiiPcd(self
, Type
):
2398 Pcds
= OrderedDict()
2400 # tdict is a special dict kind of type, used for selecting correct
2401 # PCD settings for certain ARCH and SKU
2403 PcdDict
= tdict(True, 5)
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
()
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
= "STANDARD"
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
2427 # Remove redundant PCD candidates, per the ARCH and SKU
2428 for PcdCName
, TokenSpaceGuid
, SkuName
,DefaultStore
, Dummy4
in PcdSet
:
2430 Setting
= PcdDict
[self
._Arch
, SkuName
, PcdCName
, TokenSpaceGuid
,DefaultStore
]
2433 VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VarAttribute
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
2435 rt
, Msg
= VariableAttributes
.ValidateVarAttributes(VarAttribute
)
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
)
2440 FormatCorrect
= True
2441 if VariableOffset
.isdigit():
2442 if int(VariableOffset
, 10) > 0xFFFF:
2444 elif re
.match(r
'[\t\s]*0[xX][a-fA-F0-9]+$', VariableOffset
):
2445 if int(VariableOffset
, 16) > 0xFFFF:
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
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
)))
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
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
)]))
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
})
2474 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VariableAttribute
=VarAttribute
,DefaultStore
={DefaultStore
:DefaultValue
})
2475 pcdObject
.SkuInfoList
[SkuName
] = SkuInfo
2477 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VariableAttribute
=VarAttribute
,DefaultStore
={DefaultStore
:DefaultValue
})
2478 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
2481 self
._PCD
_TYPE
_STRING
_[Type
],
2486 {SkuName
: SkuInfo
},
2489 pcdDecObject
.validateranges
,
2490 pcdDecObject
.validlists
,
2491 pcdDecObject
.expressions
,
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'])
2516 if pcd
.MaxDatumSize
.strip():
2517 MaxSize
= int(pcd
.MaxDatumSize
, 0)
2520 if pcd
.DatumType
not in ['BOOLEAN','UINT8','UINT16','UINT32','UINT64']:
2521 for (_
, skuobj
) in pcd
.SkuInfoList
.items():
2523 skuobj
.HiiDefaultValue
= StringToArray(skuobj
.HiiDefaultValue
)
2524 datalen
= len(skuobj
.HiiDefaultValue
.split(","))
2525 if datalen
> MaxSize
:
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
)
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
)
2536 map(self
.FilterSkuSettings
,Pcds
.values())
2540 def CheckVariableNameAssignment(self
,Pcds
):
2542 for pcdname
in Pcds
:
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])))
2548 return False,invalidhii
2551 ## Retrieve dynamic VPD PCD settings
2553 # @param Type PCD type
2555 # @retval a dict object contains settings of given PCD type
2557 def _GetDynamicVpdPcd(self
, Type
):
2560 Pcds
= OrderedDict()
2562 # tdict is a special dict kind of type, used for selecting correct
2563 # PCD settings for certain ARCH and SKU
2565 PcdDict
= tdict(True, 4)
2568 # Find out all possible PCD candidates for self._Arch
2569 RecordList
= self
._RawData
[Type
, self
._Arch
]
2570 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
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
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
]
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.
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)
2602 if pcdObject
.MaxDatumSize
:
2603 PcdMaxSize
= int(pcdObject
.MaxDatumSize
, 0)
2606 if CurrentMaxSize
> PcdMaxSize
:
2607 pcdObject
.MaxDatumSize
= str(CurrentMaxSize
)
2609 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
2612 self
._PCD
_TYPE
_STRING
_[Type
],
2617 {SkuName
: SkuInfo
},
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 (sku
.DefaultValue
== "" or sku
.DefaultValue
==None):
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'])
2640 map(self
.FilterSkuSettings
,Pcds
.values())
2643 ## Add external modules
2645 # The external modules are mostly those listed in FDF file, which don't
2648 # @param FilePath The path of module description file
2650 def AddModule(self
, FilePath
):
2651 FilePath
= NormPath(FilePath
)
2652 if FilePath
not in self
.Modules
:
2653 Module
= ModuleBuildClassObject()
2654 Module
.MetaFile
= FilePath
2655 self
.Modules
.append(Module
)
2657 def _GetToolChainFamily(self
):
2658 self
._ToolChainFamily
= "MSFT"
2659 BuildConfigurationFile
= os
.path
.normpath(os
.path
.join(GlobalData
.gConfDirectory
, "target.txt"))
2660 if os
.path
.isfile(BuildConfigurationFile
) == True:
2661 TargetTxt
= TargetTxtClassObject()
2662 TargetTxt
.LoadTargetTxtFile(BuildConfigurationFile
)
2663 ToolDefinitionFile
= TargetTxt
.TargetTxtDictionary
[DataType
.TAB_TAT_DEFINES_TOOL_CHAIN_CONF
]
2664 if ToolDefinitionFile
== '':
2665 ToolDefinitionFile
= "tools_def.txt"
2666 ToolDefinitionFile
= os
.path
.normpath(mws
.join(self
.WorkspaceDir
, 'Conf', ToolDefinitionFile
))
2667 if os
.path
.isfile(ToolDefinitionFile
) == True:
2668 ToolDef
= ToolDefClassObject()
2669 ToolDef
.LoadToolDefFile(ToolDefinitionFile
)
2670 ToolDefinition
= ToolDef
.ToolsDefTxtDatabase
2671 if TAB_TOD_DEFINES_FAMILY
not in ToolDefinition \
2672 or self
._Toolchain
not in ToolDefinition
[TAB_TOD_DEFINES_FAMILY
] \
2673 or not ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][self
._Toolchain
]:
2674 self
._ToolChainFamily
= "MSFT"
2676 self
._ToolChainFamily
= ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][self
._Toolchain
]
2677 return self
._ToolChainFamily
2679 ## Add external PCDs
2681 # The external PCDs are mostly those listed in FDF file to specify address
2682 # or offset information.
2684 # @param Name Name of the PCD
2685 # @param Guid Token space guid of the PCD
2686 # @param Value Value of the PCD
2688 def AddPcd(self
, Name
, Guid
, Value
):
2689 if (Name
, Guid
) not in self
.Pcds
:
2690 self
.Pcds
[Name
, Guid
] = PcdClassObject(Name
, Guid
, '', '', '', '', '', {}, False, None)
2691 self
.Pcds
[Name
, Guid
].DefaultValue
= Value
2694 if self
._DecPcds
is None:
2696 if GlobalData
.gFdfParser
:
2697 FdfInfList
= GlobalData
.gFdfParser
.Profile
.InfList
2699 for Inf
in FdfInfList
:
2700 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
2701 if ModuleFile
in self
._Modules
:
2703 ModuleData
= self
._Bdb
[ModuleFile
, self
._Arch
, self
._Target
, self
._Toolchain
]
2704 PkgSet
.update(ModuleData
.Packages
)
2705 self
._DecPcds
, self
._GuidDict
= GetDeclaredPcd(self
, self
._Bdb
, self
._Arch
, self
._Target
, self
._Toolchain
,PkgSet
)
2706 return self
._DecPcds
2707 _Macros
= property(_GetMacros
)
2708 Arch
= property(_GetArch
, _SetArch
)
2709 Platform
= property(_GetPlatformName
)
2710 PlatformName
= property(_GetPlatformName
)
2711 Guid
= property(_GetFileGuid
)
2712 Version
= property(_GetVersion
)
2713 DscSpecification
= property(_GetDscSpec
)
2714 OutputDirectory
= property(_GetOutpuDir
)
2715 SupArchList
= property(_GetSupArch
)
2716 BuildTargets
= property(_GetBuildTarget
)
2717 SkuName
= property(_GetSkuName
, _SetSkuName
)
2718 PcdInfoFlag
= property(_GetPcdInfoFlag
)
2719 VarCheckFlag
= property(_GetVarCheckFlag
)
2720 FlashDefinition
= property(_GetFdfFile
)
2721 Prebuild
= property(_GetPrebuild
)
2722 Postbuild
= property(_GetPostbuild
)
2723 BuildNumber
= property(_GetBuildNumber
)
2724 MakefileName
= property(_GetMakefileName
)
2725 BsBaseAddress
= property(_GetBsBaseAddress
)
2726 RtBaseAddress
= property(_GetRtBaseAddress
)
2727 LoadFixAddress
= property(_GetLoadFixAddress
)
2728 RFCLanguages
= property(_GetRFCLanguages
)
2729 ISOLanguages
= property(_GetISOLanguages
)
2730 VpdToolGuid
= property(_GetVpdToolGuid
)
2731 SkuIds
= property(_GetSkuIds
)
2732 Modules
= property(_GetModules
)
2733 LibraryInstances
= property(_GetLibraryInstances
)
2734 LibraryClasses
= property(_GetLibraryClasses
)
2735 Pcds
= property(_GetPcds
)
2736 BuildOptions
= property(_GetBuildOptions
)
2737 ToolChainFamily
= property(_GetToolChainFamily
)