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 __future__
import print_function
21 from __future__
import absolute_import
22 from Common
.StringUtils
import *
23 from Common
.DataType
import *
24 from Common
.Misc
import *
26 from Common
.Expression
import *
27 from CommonDataClass
.CommonClass
import SkuInfoClass
28 from Common
.TargetTxtClassObject
import *
29 from Common
.ToolDefClassObject
import *
30 from .MetaDataTable
import *
31 from .MetaFileTable
import *
32 from .MetaFileParser
import *
34 from .WorkspaceCommon
import GetDeclaredPcd
35 from Common
.Misc
import AnalyzeDscPcd
36 from Common
.Misc
import ProcessDuplicatedInf
38 from Common
.Parsing
import IsValidWord
39 from Common
.VariableAttributes
import VariableAttributes
40 import Common
.GlobalData
as GlobalData
42 from Common
.Misc
import SaveFileOnChange
43 from Workspace
.BuildClassObject
import PlatformBuildClassObject
, StructurePcd
, PcdClassObject
, ModuleBuildClassObject
44 from collections
import OrderedDict
, defaultdict
46 PcdValueInitName
= 'PcdValueInit'
57 #include <PcdValueCommon.h>
67 return PcdValueMain (argc, argv);
71 PcdMakefileHeader
= '''
74 # This file is auto-generated by build utility
79 WindowsCFLAGS
= 'CFLAGS = $(CFLAGS) /wd4200 /wd4034 /wd4101 '
80 LinuxCFLAGS
= 'BUILD_CFLAGS += -Wno-pointer-to-int-cast -Wno-unused-variable '
82 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.common
84 LIBS = $(LIB_PATH)\Common.lib
86 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.app
90 MAKEROOT ?= $(EDK_TOOLS_PATH)/Source/C
94 variablePattern
= re
.compile(r
'[\t\s]*0[xX][a-fA-F0-9]+$')
95 SkuIdPattern
= re
.compile(r
'^[a-zA-Z_][a-zA-Z0-9_]*$')
96 ## regular expressions for finding decimal and hex numbers
97 Pattern
= re
.compile('^[1-9]\d*|0$')
98 HexPattern
= re
.compile(r
'0[xX][0-9a-fA-F]+$')
99 ## Regular expression for finding header file inclusions
100 from AutoGen
.GenMake
import gIncludePattern
102 ## Find dependencies for one source file
104 # By searching recursively "#include" directive in file, find out all the
105 # files needed by given source file. The dependecies will be only searched
106 # in given search path list.
108 # @param SearchPathList The list of search path
110 # @retval list The list of files the given source file depends on
112 def GetDependencyList(FileStack
, SearchPathList
):
114 DependencySet
= set(FileStack
)
115 while len(FileStack
) > 0:
117 FullPathDependList
= []
118 CurrentFileDependencyList
= []
120 CurrentFileDependencyList
= DepDb
[F
]
124 FileContent
= Fd
.read()
125 except BaseException
as X
:
126 EdkLogger
.error("build", FILE_OPEN_FAILURE
, ExtraData
=F
+ "\n\t" + str(X
))
128 if "Fd" in dir(locals()):
131 if len(FileContent
) == 0:
134 if FileContent
[0] == 0xff or FileContent
[0] == 0xfe:
135 FileContent
= unicode(FileContent
, "utf-16")
136 IncludedFileList
= gIncludePattern
.findall(FileContent
)
138 for Inc
in IncludedFileList
:
140 Inc
= os
.path
.normpath(Inc
)
141 CurrentFileDependencyList
.append(Inc
)
142 DepDb
[F
] = CurrentFileDependencyList
144 CurrentFilePath
= os
.path
.dirname(F
)
145 PathList
= [CurrentFilePath
] + SearchPathList
146 for Inc
in CurrentFileDependencyList
:
147 for SearchPath
in PathList
:
148 FilePath
= os
.path
.join(SearchPath
, Inc
)
149 if not os
.path
.exists(FilePath
):
151 if FilePath
not in DependencySet
:
152 FileStack
.append(FilePath
)
153 FullPathDependList
.append(FilePath
)
155 DependencySet
.update(FullPathDependList
)
156 DependencyList
= list(DependencySet
) # remove duplicate ones
158 return DependencyList
160 class DscBuildData(PlatformBuildClassObject
):
161 # dict used to convert PCD type in database to string used by build tool
162 _PCD_TYPE_STRING_
= {
163 MODEL_PCD_FIXED_AT_BUILD
: TAB_PCDS_FIXED_AT_BUILD
,
164 MODEL_PCD_PATCHABLE_IN_MODULE
: TAB_PCDS_PATCHABLE_IN_MODULE
,
165 MODEL_PCD_FEATURE_FLAG
: TAB_PCDS_FEATURE_FLAG
,
166 MODEL_PCD_DYNAMIC
: TAB_PCDS_DYNAMIC
,
167 MODEL_PCD_DYNAMIC_DEFAULT
: TAB_PCDS_DYNAMIC
,
168 MODEL_PCD_DYNAMIC_HII
: TAB_PCDS_DYNAMIC_HII
,
169 MODEL_PCD_DYNAMIC_VPD
: TAB_PCDS_DYNAMIC_VPD
,
170 MODEL_PCD_DYNAMIC_EX
: TAB_PCDS_DYNAMIC_EX
,
171 MODEL_PCD_DYNAMIC_EX_DEFAULT
: TAB_PCDS_DYNAMIC_EX
,
172 MODEL_PCD_DYNAMIC_EX_HII
: TAB_PCDS_DYNAMIC_EX_HII
,
173 MODEL_PCD_DYNAMIC_EX_VPD
: TAB_PCDS_DYNAMIC_EX_VPD
,
176 # dict used to convert part of [Defines] to members of DscBuildData directly
181 TAB_DSC_DEFINES_PLATFORM_NAME
: "_PlatformName",
182 TAB_DSC_DEFINES_PLATFORM_GUID
: "_Guid",
183 TAB_DSC_DEFINES_PLATFORM_VERSION
: "_Version",
184 TAB_DSC_DEFINES_DSC_SPECIFICATION
: "_DscSpecification",
185 # TAB_DSC_DEFINES_OUTPUT_DIRECTORY : "_OutputDirectory",
186 # TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES : "_SupArchList",
187 # TAB_DSC_DEFINES_BUILD_TARGETS : "_BuildTargets",
188 TAB_DSC_DEFINES_SKUID_IDENTIFIER
: "_SkuName",
189 # TAB_DSC_DEFINES_FLASH_DEFINITION : "_FlashDefinition",
190 TAB_DSC_DEFINES_BUILD_NUMBER
: "_BuildNumber",
191 TAB_DSC_DEFINES_MAKEFILE_NAME
: "_MakefileName",
192 TAB_DSC_DEFINES_BS_BASE_ADDRESS
: "_BsBaseAddress",
193 TAB_DSC_DEFINES_RT_BASE_ADDRESS
: "_RtBaseAddress",
194 # TAB_DSC_DEFINES_RFC_LANGUAGES : "_RFCLanguages",
195 # TAB_DSC_DEFINES_ISO_LANGUAGES : "_ISOLanguages",
198 # used to compose dummy library class name for those forced library instances
199 _NullLibraryNumber
= 0
201 ## Constructor of DscBuildData
203 # Initialize object of DscBuildData
205 # @param FilePath The path of platform description file
206 # @param RawData The raw data of DSC file
207 # @param BuildDataBase Database used to retrieve module/package information
208 # @param Arch The target architecture
209 # @param Platform (not used for DscBuildData)
210 # @param Macros Macros used for replacement in DSC file
212 def __init__(self
, FilePath
, RawData
, BuildDataBase
, Arch
=TAB_ARCH_COMMON
, Target
=None, Toolchain
=None):
213 self
.MetaFile
= FilePath
214 self
._RawData
= RawData
215 self
._Bdb
= BuildDataBase
217 self
._Target
= Target
218 self
._Toolchain
= Toolchain
219 self
._ToolChainFamily
= None
221 self
._HandleOverridePath
()
222 self
.WorkspaceDir
= os
.getenv("WORKSPACE") if os
.getenv("WORKSPACE") else ""
223 self
.DefaultStores
= None
224 self
.SkuIdMgr
= SkuClass(self
.SkuName
, self
.SkuIds
)
227 def OutputPath(self
):
228 if os
.getenv("WORKSPACE"):
229 return os
.path
.join(os
.getenv("WORKSPACE"), self
.OutputDirectory
, self
._Target
+ "_" + self
._Toolchain
, PcdValueInitName
)
231 return os
.path
.dirname(self
.DscFile
)
234 def __setitem__(self
, key
, value
):
235 self
.__dict
__[self
._PROPERTY
_[key
]] = value
238 def __getitem__(self
, key
):
239 return self
.__dict
__[self
._PROPERTY
_[key
]]
242 def __contains__(self
, key
):
243 return key
in self
._PROPERTY
_
245 ## Set all internal used members of DscBuildData to None
248 self
._PlatformName
= None
251 self
._DscSpecification
= None
252 self
._OutputDirectory
= None
253 self
._SupArchList
= None
254 self
._BuildTargets
= None
256 self
._PcdInfoFlag
= None
257 self
._VarCheckFlag
= None
258 self
._FlashDefinition
= None
259 self
._Prebuild
= None
260 self
._Postbuild
= None
261 self
._BuildNumber
= None
262 self
._MakefileName
= None
263 self
._BsBaseAddress
= None
264 self
._RtBaseAddress
= None
267 self
._LibraryInstances
= None
268 self
._LibraryClasses
= None
271 self
._BuildOptions
= None
272 self
._ModuleTypeOptions
= None
273 self
._LoadFixAddress
= None
274 self
._RFCLanguages
= None
275 self
._ISOLanguages
= None
276 self
._VpdToolGuid
= None
277 self
._MacroDict
= None
278 self
.DefaultStores
= None
280 ## handle Override Path of Module
281 def _HandleOverridePath(self
):
282 RecordList
= self
._RawData
[MODEL_META_DATA_COMPONENT
, self
._Arch
]
283 for Record
in RecordList
:
286 ModuleFile
= PathClass(NormPath(Record
[0]), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
287 RecordList
= self
._RawData
[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH
, self
._Arch
, None, ModuleId
]
289 SourceOverridePath
= mws
.join(GlobalData
.gWorkspace
, NormPath(RecordList
[0][0]))
291 # Check if the source override path exists
292 if not os
.path
.isdir(SourceOverridePath
):
293 EdkLogger
.error('build', FILE_NOT_FOUND
, Message
='Source override path does not exist:', File
=self
.MetaFile
, ExtraData
=SourceOverridePath
, Line
=LineNo
)
295 # Add to GlobalData Variables
296 GlobalData
.gOverrideDir
[ModuleFile
.Key
] = SourceOverridePath
298 ## Get current effective macros
301 if self
._MacroDict
is None:
303 self
._MacroDict
.update(GlobalData
.gPlatformDefines
)
304 self
._MacroDict
.update(GlobalData
.gGlobalDefines
)
305 self
._MacroDict
.update(GlobalData
.gCommandLineDefines
)
306 return self
._MacroDict
313 ## Retrieve all information in [Defines] section
315 # (Retriving all [Defines] information in one-shot is just to save time.)
317 def _GetHeaderInfo(self
):
318 RecordList
= self
._RawData
[MODEL_META_DATA_HEADER
, self
._Arch
]
319 for Record
in RecordList
:
321 # items defined _PROPERTY_ don't need additional processing
323 # some special items in [Defines] section need special treatment
324 if Name
== TAB_DSC_DEFINES_OUTPUT_DIRECTORY
:
325 self
._OutputDirectory
= NormPath(Record
[2], self
._Macros
)
326 if ' ' in self
._OutputDirectory
:
327 EdkLogger
.error("build", FORMAT_NOT_SUPPORTED
, "No space is allowed in OUTPUT_DIRECTORY",
328 File
=self
.MetaFile
, Line
=Record
[-1],
329 ExtraData
=self
._OutputDirectory
)
330 elif Name
== TAB_DSC_DEFINES_FLASH_DEFINITION
:
331 self
._FlashDefinition
= PathClass(NormPath(Record
[2], self
._Macros
), GlobalData
.gWorkspace
)
332 ErrorCode
, ErrorInfo
= self
._FlashDefinition
.Validate('.fdf')
334 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=Record
[-1],
336 elif Name
== TAB_DSC_PREBUILD
:
337 PrebuildValue
= Record
[2]
338 if Record
[2][0] == '"':
339 if Record
[2][-1] != '"':
340 EdkLogger
.error('build', FORMAT_INVALID
, 'Missing double quotes in the end of %s statement.' % TAB_DSC_PREBUILD
,
341 File
=self
.MetaFile
, Line
=Record
[-1])
342 PrebuildValue
= Record
[2][1:-1]
343 self
._Prebuild
= PrebuildValue
344 elif Name
== TAB_DSC_POSTBUILD
:
345 PostbuildValue
= Record
[2]
346 if Record
[2][0] == '"':
347 if Record
[2][-1] != '"':
348 EdkLogger
.error('build', FORMAT_INVALID
, 'Missing double quotes in the end of %s statement.' % TAB_DSC_POSTBUILD
,
349 File
=self
.MetaFile
, Line
=Record
[-1])
350 PostbuildValue
= Record
[2][1:-1]
351 self
._Postbuild
= PostbuildValue
352 elif Name
== TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES
:
353 self
._SupArchList
= GetSplitValueList(Record
[2], TAB_VALUE_SPLIT
)
354 elif Name
== TAB_DSC_DEFINES_BUILD_TARGETS
:
355 self
._BuildTargets
= GetSplitValueList(Record
[2])
356 elif Name
== TAB_DSC_DEFINES_SKUID_IDENTIFIER
:
357 if self
._SkuName
is None:
358 self
._SkuName
= Record
[2]
359 if GlobalData
.gSKUID_CMD
:
360 self
._SkuName
= GlobalData
.gSKUID_CMD
361 elif Name
== TAB_DSC_DEFINES_PCD_INFO_GENERATION
:
362 self
._PcdInfoFlag
= Record
[2]
363 elif Name
== TAB_DSC_DEFINES_PCD_VAR_CHECK_GENERATION
:
364 self
._VarCheckFlag
= Record
[2]
365 elif Name
== TAB_FIX_LOAD_TOP_MEMORY_ADDRESS
:
367 self
._LoadFixAddress
= int (Record
[2], 0)
369 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (Record
[2]))
370 elif Name
== TAB_DSC_DEFINES_RFC_LANGUAGES
:
371 if not Record
[2] or Record
[2][0] != '"' or Record
[2][-1] != '"' or len(Record
[2]) == 1:
372 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"',
373 File
=self
.MetaFile
, Line
=Record
[-1])
374 LanguageCodes
= Record
[2][1:-1]
375 if not LanguageCodes
:
376 EdkLogger
.error('build', FORMAT_NOT_SUPPORTED
, 'one or more RFC4646 format language code must be provided for RFC_LANGUAGES statement',
377 File
=self
.MetaFile
, Line
=Record
[-1])
378 LanguageList
= GetSplitValueList(LanguageCodes
, TAB_SEMI_COLON_SPLIT
)
379 # check whether there is empty entries in the list
380 if None in LanguageList
:
381 EdkLogger
.error('build', FORMAT_NOT_SUPPORTED
, 'one or more empty language code is in RFC_LANGUAGES statement',
382 File
=self
.MetaFile
, Line
=Record
[-1])
383 self
._RFCLanguages
= LanguageList
384 elif Name
== TAB_DSC_DEFINES_ISO_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 ISO_LANGUAGES must have double quotes around it, for example: ISO_LANGUAGES = "engchn"',
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 ISO639-2 format language code must be provided for ISO_LANGUAGES statement',
391 File
=self
.MetaFile
, Line
=Record
[-1])
392 if len(LanguageCodes
) % 3:
393 EdkLogger
.error('build', FORMAT_NOT_SUPPORTED
, 'bad ISO639-2 format for ISO_LANGUAGES',
394 File
=self
.MetaFile
, Line
=Record
[-1])
396 for i
in range(0, len(LanguageCodes
), 3):
397 LanguageList
.append(LanguageCodes
[i
:i
+ 3])
398 self
._ISOLanguages
= LanguageList
399 elif Name
== TAB_DSC_DEFINES_VPD_TOOL_GUID
:
401 # try to convert GUID to a real UUID value to see whether the GUID is format
402 # for VPD_TOOL_GUID is correct.
407 EdkLogger
.error("build", FORMAT_INVALID
, "Invalid GUID format for VPD_TOOL_GUID", File
=self
.MetaFile
)
408 self
._VpdToolGuid
= Record
[2]
410 self
[Name
] = Record
[2]
411 # set _Header to non-None in order to avoid database re-querying
412 self
._Header
= 'DUMMY'
414 ## Retrieve platform name
416 def PlatformName(self
):
417 if self
._PlatformName
is None:
418 if self
._Header
is None:
419 self
._GetHeaderInfo
()
420 if self
._PlatformName
is None:
421 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No PLATFORM_NAME", File
=self
.MetaFile
)
422 return self
._PlatformName
426 return self
.PlatformName
428 ## Retrieve file guid
431 if self
._Guid
is None:
432 if self
._Header
is None:
433 self
._GetHeaderInfo
()
434 if self
._Guid
is None:
435 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No PLATFORM_GUID", File
=self
.MetaFile
)
438 ## Retrieve platform version
441 if self
._Version
is None:
442 if self
._Header
is None:
443 self
._GetHeaderInfo
()
444 if self
._Version
is None:
445 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No PLATFORM_VERSION", File
=self
.MetaFile
)
448 ## Retrieve platform description file version
450 def DscSpecification(self
):
451 if self
._DscSpecification
is None:
452 if self
._Header
is None:
453 self
._GetHeaderInfo
()
454 if self
._DscSpecification
is None:
455 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No DSC_SPECIFICATION", File
=self
.MetaFile
)
456 return self
._DscSpecification
458 ## Retrieve OUTPUT_DIRECTORY
460 def OutputDirectory(self
):
461 if self
._OutputDirectory
is None:
462 if self
._Header
is None:
463 self
._GetHeaderInfo
()
464 if self
._OutputDirectory
is None:
465 self
._OutputDirectory
= os
.path
.join("Build", self
._PlatformName
)
466 return self
._OutputDirectory
468 ## Retrieve SUPPORTED_ARCHITECTURES
470 def SupArchList(self
):
471 if self
._SupArchList
is None:
472 if self
._Header
is None:
473 self
._GetHeaderInfo
()
474 if self
._SupArchList
is None:
475 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No SUPPORTED_ARCHITECTURES", File
=self
.MetaFile
)
476 return self
._SupArchList
478 ## Retrieve BUILD_TARGETS
480 def BuildTargets(self
):
481 if self
._BuildTargets
is None:
482 if self
._Header
is None:
483 self
._GetHeaderInfo
()
484 if self
._BuildTargets
is None:
485 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No BUILD_TARGETS", File
=self
.MetaFile
)
486 return self
._BuildTargets
489 def PcdInfoFlag(self
):
490 if self
._PcdInfoFlag
is None or self
._PcdInfoFlag
.upper() == 'FALSE':
492 elif self
._PcdInfoFlag
.upper() == 'TRUE':
498 def VarCheckFlag(self
):
499 if self
._VarCheckFlag
is None or self
._VarCheckFlag
.upper() == 'FALSE':
501 elif self
._VarCheckFlag
.upper() == 'TRUE':
506 # # Retrieve SKUID_IDENTIFIER
509 if self
._SkuName
is None:
510 if self
._Header
is None:
511 self
._GetHeaderInfo
()
512 if self
._SkuName
is None:
513 self
._SkuName
= TAB_DEFAULT
516 ## Override SKUID_IDENTIFIER
518 def SkuName(self
, Value
):
519 self
._SkuName
= Value
522 def FlashDefinition(self
):
523 if self
._FlashDefinition
is None:
524 if self
._Header
is None:
525 self
._GetHeaderInfo
()
526 if self
._FlashDefinition
is None:
527 self
._FlashDefinition
= ''
528 return self
._FlashDefinition
532 if self
._Prebuild
is None:
533 if self
._Header
is None:
534 self
._GetHeaderInfo
()
535 if self
._Prebuild
is None:
537 return self
._Prebuild
541 if self
._Postbuild
is None:
542 if self
._Header
is None:
543 self
._GetHeaderInfo
()
544 if self
._Postbuild
is None:
546 return self
._Postbuild
548 ## Retrieve FLASH_DEFINITION
550 def BuildNumber(self
):
551 if self
._BuildNumber
is None:
552 if self
._Header
is None:
553 self
._GetHeaderInfo
()
554 if self
._BuildNumber
is None:
555 self
._BuildNumber
= ''
556 return self
._BuildNumber
558 ## Retrieve MAKEFILE_NAME
560 def MakefileName(self
):
561 if self
._MakefileName
is None:
562 if self
._Header
is None:
563 self
._GetHeaderInfo
()
564 if self
._MakefileName
is None:
565 self
._MakefileName
= ''
566 return self
._MakefileName
568 ## Retrieve BsBaseAddress
570 def BsBaseAddress(self
):
571 if self
._BsBaseAddress
is None:
572 if self
._Header
is None:
573 self
._GetHeaderInfo
()
574 if self
._BsBaseAddress
is None:
575 self
._BsBaseAddress
= ''
576 return self
._BsBaseAddress
578 ## Retrieve RtBaseAddress
580 def RtBaseAddress(self
):
581 if self
._RtBaseAddress
is None:
582 if self
._Header
is None:
583 self
._GetHeaderInfo
()
584 if self
._RtBaseAddress
is None:
585 self
._RtBaseAddress
= ''
586 return self
._RtBaseAddress
588 ## Retrieve the top address for the load fix address
590 def LoadFixAddress(self
):
591 if self
._LoadFixAddress
is None:
592 if self
._Header
is None:
593 self
._GetHeaderInfo
()
595 if self
._LoadFixAddress
is None:
596 self
._LoadFixAddress
= self
._Macros
.get(TAB_FIX_LOAD_TOP_MEMORY_ADDRESS
, '0')
599 self
._LoadFixAddress
= int (self
._LoadFixAddress
, 0)
601 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (self
._LoadFixAddress
))
604 # If command line defined, should override the value in DSC file.
606 if 'FIX_LOAD_TOP_MEMORY_ADDRESS' in GlobalData
.gCommandLineDefines
:
608 self
._LoadFixAddress
= int(GlobalData
.gCommandLineDefines
['FIX_LOAD_TOP_MEMORY_ADDRESS'], 0)
610 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']))
612 if self
._LoadFixAddress
< 0:
613 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid negative value 0x%x" % (self
._LoadFixAddress
))
614 if self
._LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
._LoadFixAddress
% 0x1000 != 0:
615 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid unaligned 4K value 0x%x" % (self
._LoadFixAddress
))
617 return self
._LoadFixAddress
619 ## Retrieve RFCLanguage filter
621 def RFCLanguages(self
):
622 if self
._RFCLanguages
is None:
623 if self
._Header
is None:
624 self
._GetHeaderInfo
()
625 if self
._RFCLanguages
is None:
626 self
._RFCLanguages
= []
627 return self
._RFCLanguages
629 ## Retrieve ISOLanguage filter
631 def ISOLanguages(self
):
632 if self
._ISOLanguages
is None:
633 if self
._Header
is None:
634 self
._GetHeaderInfo
()
635 if self
._ISOLanguages
is None:
636 self
._ISOLanguages
= []
637 return self
._ISOLanguages
639 ## Retrieve the GUID string for VPD tool
641 def VpdToolGuid(self
):
642 if self
._VpdToolGuid
is None:
643 if self
._Header
is None:
644 self
._GetHeaderInfo
()
645 if self
._VpdToolGuid
is None:
646 self
._VpdToolGuid
= ''
647 return self
._VpdToolGuid
649 ## Retrieve [SkuIds] section information
652 if self
._SkuIds
is None:
653 self
._SkuIds
= OrderedDict()
654 RecordList
= self
._RawData
[MODEL_EFI_SKU_ID
, self
._Arch
]
655 for Record
in RecordList
:
657 EdkLogger
.error('build', FORMAT_INVALID
, 'No Sku ID number',
658 File
=self
.MetaFile
, Line
=Record
[-1])
660 EdkLogger
.error('build', FORMAT_INVALID
, 'No Sku ID name',
661 File
=self
.MetaFile
, Line
=Record
[-1])
662 if not Pattern
.match(Record
[0]) and not HexPattern
.match(Record
[0]):
663 EdkLogger
.error('build', FORMAT_INVALID
, "The format of the Sku ID number is invalid. It only support Integer and HexNumber",
664 File
=self
.MetaFile
, Line
=Record
[-1])
665 if not SkuIdPattern
.match(Record
[1]) or (Record
[2] and not SkuIdPattern
.match(Record
[2])):
666 EdkLogger
.error('build', FORMAT_INVALID
, "The format of the Sku ID name is invalid. The correct format is '(a-zA-Z_)(a-zA-Z0-9_)*'",
667 File
=self
.MetaFile
, Line
=Record
[-1])
668 self
._SkuIds
[Record
[1].upper()] = (str(DscBuildData
.ToInt(Record
[0])), Record
[1].upper(), Record
[2].upper())
669 if TAB_DEFAULT
not in self
._SkuIds
:
670 self
._SkuIds
[TAB_DEFAULT
] = ("0", TAB_DEFAULT
, TAB_DEFAULT
)
671 if TAB_COMMON
not in self
._SkuIds
:
672 self
._SkuIds
[TAB_COMMON
] = ("0", TAB_DEFAULT
, TAB_DEFAULT
)
677 return int(intstr
, 16) if intstr
.upper().startswith("0X") else int(intstr
)
679 def _GetDefaultStores(self
):
680 if self
.DefaultStores
is None:
681 self
.DefaultStores
= OrderedDict()
682 RecordList
= self
._RawData
[MODEL_EFI_DEFAULT_STORES
, self
._Arch
]
683 for Record
in RecordList
:
685 EdkLogger
.error('build', FORMAT_INVALID
, 'No DefaultStores ID number',
686 File
=self
.MetaFile
, Line
=Record
[-1])
688 EdkLogger
.error('build', FORMAT_INVALID
, 'No DefaultStores ID name',
689 File
=self
.MetaFile
, Line
=Record
[-1])
690 if not Pattern
.match(Record
[0]) and not HexPattern
.match(Record
[0]):
691 EdkLogger
.error('build', FORMAT_INVALID
, "The format of the DefaultStores ID number is invalid. It only support Integer and HexNumber",
692 File
=self
.MetaFile
, Line
=Record
[-1])
693 if not IsValidWord(Record
[1]):
694 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_-.)*'",
695 File
=self
.MetaFile
, Line
=Record
[-1])
696 self
.DefaultStores
[Record
[1].upper()] = (DscBuildData
.ToInt(Record
[0]), Record
[1].upper())
697 if TAB_DEFAULT_STORES_DEFAULT
not in self
.DefaultStores
:
698 self
.DefaultStores
[TAB_DEFAULT_STORES_DEFAULT
] = (0, TAB_DEFAULT_STORES_DEFAULT
)
699 GlobalData
.gDefaultStores
= sorted(self
.DefaultStores
.keys())
700 return self
.DefaultStores
702 ## Retrieve [Components] section information
705 if self
._Modules
is not None:
708 self
._Modules
= OrderedDict()
709 RecordList
= self
._RawData
[MODEL_META_DATA_COMPONENT
, self
._Arch
]
710 Macros
= self
._Macros
711 Macros
["EDK_SOURCE"] = GlobalData
.gEcpSource
712 for Record
in RecordList
:
713 DuplicatedFile
= False
715 ModuleFile
= PathClass(NormPath(Record
[0], Macros
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
719 # check the file validation
720 ErrorCode
, ErrorInfo
= ModuleFile
.Validate('.inf')
722 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
725 # If arch is COMMON, no duplicate module is checked since all modules in all component sections are selected
726 if self
._Arch
!= TAB_ARCH_COMMON
and ModuleFile
in self
._Modules
:
727 DuplicatedFile
= True
729 Module
= ModuleBuildClassObject()
730 Module
.MetaFile
= ModuleFile
732 # get module private library instance
733 RecordList
= self
._RawData
[MODEL_EFI_LIBRARY_CLASS
, self
._Arch
, None, ModuleId
]
734 for Record
in RecordList
:
735 LibraryClass
= Record
[0]
736 LibraryPath
= PathClass(NormPath(Record
[1], Macros
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
739 # check the file validation
740 ErrorCode
, ErrorInfo
= LibraryPath
.Validate('.inf')
742 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
745 if LibraryClass
== '' or LibraryClass
== 'NULL':
746 self
._NullLibraryNumber
+= 1
747 LibraryClass
= 'NULL%d' % self
._NullLibraryNumber
748 EdkLogger
.verbose("Found forced library for %s\n\t%s [%s]" % (ModuleFile
, LibraryPath
, LibraryClass
))
749 Module
.LibraryClasses
[LibraryClass
] = LibraryPath
750 if LibraryPath
not in self
.LibraryInstances
:
751 self
.LibraryInstances
.append(LibraryPath
)
753 # get module private PCD setting
754 for Type
in [MODEL_PCD_FIXED_AT_BUILD
, MODEL_PCD_PATCHABLE_IN_MODULE
, \
755 MODEL_PCD_FEATURE_FLAG
, MODEL_PCD_DYNAMIC
, MODEL_PCD_DYNAMIC_EX
]:
756 RecordList
= self
._RawData
[Type
, self
._Arch
, None, ModuleId
]
757 for TokenSpaceGuid
, PcdCName
, Setting
, Dummy1
, Dummy2
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
758 TokenList
= GetSplitValueList(Setting
)
759 DefaultValue
= TokenList
[0]
760 # the format is PcdName| Value | VOID* | MaxDatumSize
761 if len(TokenList
) > 2:
762 MaxDatumSize
= TokenList
[2]
765 TypeString
= self
._PCD
_TYPE
_STRING
_[Type
]
766 Pcd
= PcdClassObject(
778 Module
.Pcds
[PcdCName
, TokenSpaceGuid
] = Pcd
780 # get module private build options
781 RecordList
= self
._RawData
[MODEL_META_DATA_BUILD_OPTION
, self
._Arch
, None, ModuleId
]
782 for ToolChainFamily
, ToolChain
, Option
, Dummy1
, Dummy2
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
783 if (ToolChainFamily
, ToolChain
) not in Module
.BuildOptions
:
784 Module
.BuildOptions
[ToolChainFamily
, ToolChain
] = Option
786 OptionString
= Module
.BuildOptions
[ToolChainFamily
, ToolChain
]
787 Module
.BuildOptions
[ToolChainFamily
, ToolChain
] = OptionString
+ " " + Option
789 RecordList
= self
._RawData
[MODEL_META_DATA_HEADER
, self
._Arch
, None, ModuleId
]
790 if DuplicatedFile
and not RecordList
:
791 EdkLogger
.error('build', FILE_DUPLICATED
, File
=self
.MetaFile
, ExtraData
=str(ModuleFile
), Line
=LineNo
)
793 if len(RecordList
) != 1:
794 EdkLogger
.error('build', OPTION_UNKNOWN
, 'Only FILE_GUID can be listed in <Defines> section.',
795 File
=self
.MetaFile
, ExtraData
=str(ModuleFile
), Line
=LineNo
)
796 ModuleFile
= ProcessDuplicatedInf(ModuleFile
, RecordList
[0][2], GlobalData
.gWorkspace
)
797 ModuleFile
.Arch
= self
._Arch
799 self
._Modules
[ModuleFile
] = Module
802 ## Retrieve all possible library instances used in this platform
804 def LibraryInstances(self
):
805 if self
._LibraryInstances
is None:
807 return self
._LibraryInstances
809 ## Retrieve [LibraryClasses] information
811 def LibraryClasses(self
):
812 if self
._LibraryClasses
is None:
813 self
._LibraryInstances
= []
815 # tdict is a special dict kind of type, used for selecting correct
816 # library instance for given library class and module type
818 LibraryClassDict
= tdict(True, 3)
819 # track all library class names
820 LibraryClassSet
= set()
821 RecordList
= self
._RawData
[MODEL_EFI_LIBRARY_CLASS
, self
._Arch
, None, -1]
822 Macros
= self
._Macros
823 for Record
in RecordList
:
824 LibraryClass
, LibraryInstance
, Dummy
, Arch
, ModuleType
, Dummy
, Dummy
, LineNo
= Record
825 if LibraryClass
== '' or LibraryClass
== 'NULL':
826 self
._NullLibraryNumber
+= 1
827 LibraryClass
= 'NULL%d' % self
._NullLibraryNumber
828 EdkLogger
.verbose("Found forced library for arch=%s\n\t%s [%s]" % (Arch
, LibraryInstance
, LibraryClass
))
829 LibraryClassSet
.add(LibraryClass
)
830 LibraryInstance
= PathClass(NormPath(LibraryInstance
, Macros
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
831 # check the file validation
832 ErrorCode
, ErrorInfo
= LibraryInstance
.Validate('.inf')
834 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
837 if ModuleType
!= TAB_COMMON
and ModuleType
not in SUP_MODULE_LIST
:
838 EdkLogger
.error('build', OPTION_UNKNOWN
, "Unknown module type [%s]" % ModuleType
,
839 File
=self
.MetaFile
, ExtraData
=LibraryInstance
, Line
=LineNo
)
840 LibraryClassDict
[Arch
, ModuleType
, LibraryClass
] = LibraryInstance
841 if LibraryInstance
not in self
._LibraryInstances
:
842 self
._LibraryInstances
.append(LibraryInstance
)
844 # resolve the specific library instance for each class and each module type
845 self
._LibraryClasses
= tdict(True)
846 for LibraryClass
in LibraryClassSet
:
847 # try all possible module types
848 for ModuleType
in SUP_MODULE_LIST
:
849 LibraryInstance
= LibraryClassDict
[self
._Arch
, ModuleType
, LibraryClass
]
850 if LibraryInstance
is None:
852 self
._LibraryClasses
[LibraryClass
, ModuleType
] = LibraryInstance
854 # for Edk style library instances, which are listed in different section
855 Macros
["EDK_SOURCE"] = GlobalData
.gEcpSource
856 RecordList
= self
._RawData
[MODEL_EFI_LIBRARY_INSTANCE
, self
._Arch
]
857 for Record
in RecordList
:
858 File
= PathClass(NormPath(Record
[0], Macros
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
860 # check the file validation
861 ErrorCode
, ErrorInfo
= File
.Validate('.inf')
863 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
865 if File
not in self
._LibraryInstances
:
866 self
._LibraryInstances
.append(File
)
868 # we need the module name as the library class name, so we have
869 # to parse it here. (self._Bdb[] will trigger a file parse if it
870 # hasn't been parsed)
872 Library
= self
._Bdb
[File
, self
._Arch
, self
._Target
, self
._Toolchain
]
873 self
._LibraryClasses
[Library
.BaseName
, ':dummy:'] = Library
874 return self
._LibraryClasses
876 def _ValidatePcd(self
, PcdCName
, TokenSpaceGuid
, Setting
, PcdType
, LineNo
):
877 if self
._DecPcds
is None:
880 if GlobalData
.gFdfParser
:
881 FdfInfList
= GlobalData
.gFdfParser
.Profile
.InfList
884 for Inf
in FdfInfList
:
885 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
886 if ModuleFile
in self
._Modules
:
888 ModuleData
= self
._Bdb
[ModuleFile
, self
._Arch
, self
._Target
, self
._Toolchain
]
889 PkgSet
.update(ModuleData
.Packages
)
891 self
._DecPcds
, self
._GuidDict
= GetDeclaredPcd(self
, self
._Bdb
, self
._Arch
, self
._Target
, self
._Toolchain
, PkgSet
)
892 self
._GuidDict
.update(GlobalData
.gPlatformPcds
)
894 if (PcdCName
, TokenSpaceGuid
) not in self
._DecPcds
:
895 EdkLogger
.error('build', PARSER_ERROR
,
896 "Pcd (%s.%s) defined in DSC is not declared in DEC files referenced in INF files in FDF. Arch: ['%s']" % (TokenSpaceGuid
, PcdCName
, self
._Arch
),
897 File
=self
.MetaFile
, Line
=LineNo
)
898 ValueList
, IsValid
, Index
= AnalyzeDscPcd(Setting
, PcdType
, self
._DecPcds
[PcdCName
, TokenSpaceGuid
].DatumType
)
900 if PcdType
not in [MODEL_PCD_FEATURE_FLAG
, MODEL_PCD_FIXED_AT_BUILD
]:
901 EdkLogger
.error('build', FORMAT_INVALID
, "Pcd format incorrect.", File
=self
.MetaFile
, Line
=LineNo
,
902 ExtraData
="%s.%s|%s" % (TokenSpaceGuid
, PcdCName
, Setting
))
904 if ValueList
[2] == '-1':
905 EdkLogger
.error('build', FORMAT_INVALID
, "Pcd format incorrect.", File
=self
.MetaFile
, Line
=LineNo
,
906 ExtraData
="%s.%s|%s" % (TokenSpaceGuid
, PcdCName
, Setting
))
908 DatumType
= self
._DecPcds
[PcdCName
, TokenSpaceGuid
].DatumType
910 ValueList
[Index
] = ValueExpressionEx(ValueList
[Index
], DatumType
, self
._GuidDict
)(True)
911 except BadExpression
as Value
:
912 EdkLogger
.error('Parser', FORMAT_INVALID
, Value
, File
=self
.MetaFile
, Line
=LineNo
,
913 ExtraData
="PCD [%s.%s] Value \"%s\" " % (
914 TokenSpaceGuid
, PcdCName
, ValueList
[Index
]))
915 except EvaluationException
as Excpt
:
916 if hasattr(Excpt
, 'Pcd'):
917 if Excpt
.Pcd
in GlobalData
.gPlatformOtherPcds
:
918 EdkLogger
.error('Parser', FORMAT_INVALID
, "Cannot use this PCD (%s) in an expression as"
919 " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"
920 " of the DSC file" % Excpt
.Pcd
,
921 File
=self
.MetaFile
, Line
=LineNo
)
923 EdkLogger
.error('Parser', FORMAT_INVALID
, "PCD (%s) is not defined in DSC file" % Excpt
.Pcd
,
924 File
=self
.MetaFile
, Line
=LineNo
)
926 EdkLogger
.error('Parser', FORMAT_INVALID
, "Invalid expression: %s" % str(Excpt
),
927 File
=self
.MetaFile
, Line
=LineNo
)
930 Valid
, ErrStr
= CheckPcdDatum(self
._DecPcds
[PcdCName
, TokenSpaceGuid
].DatumType
, ValueList
[Index
])
932 EdkLogger
.error('build', FORMAT_INVALID
, ErrStr
, File
=self
.MetaFile
, Line
=LineNo
,
933 ExtraData
="%s.%s" % (TokenSpaceGuid
, PcdCName
))
934 if PcdType
in (MODEL_PCD_DYNAMIC_DEFAULT
, MODEL_PCD_DYNAMIC_EX_DEFAULT
, MODEL_PCD_FIXED_AT_BUILD
, MODEL_PCD_PATCHABLE_IN_MODULE
):
935 if self
._DecPcds
[PcdCName
, TokenSpaceGuid
].DatumType
.strip() != ValueList
[1].strip():
936 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
,
937 ExtraData
="%s.%s|%s" % (TokenSpaceGuid
, PcdCName
, Setting
))
938 if (TokenSpaceGuid
+ '.' + PcdCName
) in GlobalData
.gPlatformPcds
:
939 if GlobalData
.gPlatformPcds
[TokenSpaceGuid
+ '.' + PcdCName
] != ValueList
[Index
]:
940 GlobalData
.gPlatformPcds
[TokenSpaceGuid
+ '.' + PcdCName
] = ValueList
[Index
]
943 def _FilterPcdBySkuUsage(self
, Pcds
):
944 available_sku
= self
.SkuIdMgr
.AvailableSkuIdSet
945 sku_usage
= self
.SkuIdMgr
.SkuUsageType
946 if sku_usage
== SkuClass
.SINGLE
:
949 Pcds
[pcdname
].SkuInfoList
= {TAB_DEFAULT
:pcd
.SkuInfoList
[skuid
] for skuid
in pcd
.SkuInfoList
if skuid
in available_sku
}
950 if isinstance(pcd
, StructurePcd
) and pcd
.SkuOverrideValues
:
951 Pcds
[pcdname
].SkuOverrideValues
= {TAB_DEFAULT
:pcd
.SkuOverrideValues
[skuid
] for skuid
in pcd
.SkuOverrideValues
if skuid
in available_sku
}
955 Pcds
[pcdname
].SkuInfoList
= {skuid
:pcd
.SkuInfoList
[skuid
] for skuid
in pcd
.SkuInfoList
if skuid
in available_sku
}
956 if isinstance(pcd
, StructurePcd
) and pcd
.SkuOverrideValues
:
957 Pcds
[pcdname
].SkuOverrideValues
= {skuid
:pcd
.SkuOverrideValues
[skuid
] for skuid
in pcd
.SkuOverrideValues
if skuid
in available_sku
}
960 def CompleteHiiPcdsDefaultStores(self
, Pcds
):
961 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
]]]
962 DefaultStoreMgr
= DefaultStore(self
.DefaultStores
)
964 for skuid
in pcd
.SkuInfoList
:
965 skuobj
= pcd
.SkuInfoList
.get(skuid
)
966 if TAB_DEFAULT_STORES_DEFAULT
not in skuobj
.DefaultStoreDict
:
967 PcdDefaultStoreSet
= set(defaultstorename
for defaultstorename
in skuobj
.DefaultStoreDict
)
968 mindefaultstorename
= DefaultStoreMgr
.GetMin(PcdDefaultStoreSet
)
969 skuobj
.DefaultStoreDict
[TAB_DEFAULT_STORES_DEFAULT
] = copy
.deepcopy(skuobj
.DefaultStoreDict
[mindefaultstorename
])
972 def RecoverCommandLinePcd(self
):
973 def UpdateCommandLineValue(pcd
):
974 if pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
975 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
976 pcd
.PcdValueFromComm
= pcd
.DefaultValue
977 elif pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
978 pcd
.PcdValueFromComm
= pcd
.SkuInfoList
.get(TAB_DEFAULT
).HiiDefaultValue
980 pcd
.PcdValueFromComm
= pcd
.SkuInfoList
.get(TAB_DEFAULT
).DefaultValue
981 for pcd
in self
._Pcds
:
982 if isinstance(self
._Pcds
[pcd
], StructurePcd
) and (self
._Pcds
[pcd
].PcdValueFromComm
or self
._Pcds
[pcd
].PcdFieldValueFromComm
):
983 UpdateCommandLineValue(self
._Pcds
[pcd
])
985 def __ParsePcdFromCommandLine(self
):
986 if GlobalData
.BuildOptionPcd
:
987 for i
, pcd
in enumerate(GlobalData
.BuildOptionPcd
):
988 if isinstance(pcd
, tuple):
990 (pcdname
, pcdvalue
) = pcd
.split('=')
992 EdkLogger
.error('build', AUTOGEN_ERROR
, "No Value specified for the PCD %s." % (pcdname
))
994 (Name1
, Name2
) = pcdname
.split('.', 1)
996 (Name3
, FieldName
) = Name2
.split(".", 1)
997 if ((Name3
, Name1
)) in self
.DecPcds
:
1000 TokenSpaceGuidCName
= Name1
1004 TokenSpaceGuidCName
= ''
1005 HasTokenSpace
= False
1007 if ((Name2
, Name1
)) in self
.DecPcds
:
1008 HasTokenSpace
= True
1010 TokenSpaceGuidCName
= Name1
1015 TokenSpaceGuidCName
= ''
1016 HasTokenSpace
= False
1019 TokenCName
= pcdname
1020 TokenSpaceGuidCName
= ''
1021 HasTokenSpace
= False
1022 TokenSpaceGuidCNameList
= []
1025 DisplayName
= TokenCName
1027 DisplayName
= TokenCName
+ '.' + FieldName
1028 if not HasTokenSpace
:
1029 for key
in self
.DecPcds
:
1030 PcdItem
= self
.DecPcds
[key
]
1031 if TokenCName
== PcdItem
.TokenCName
:
1032 if not PcdItem
.TokenSpaceGuidCName
in TokenSpaceGuidCNameList
:
1033 if len (TokenSpaceGuidCNameList
) < 1:
1034 TokenSpaceGuidCNameList
.append(PcdItem
.TokenSpaceGuidCName
)
1035 TokenSpaceGuidCName
= PcdItem
.TokenSpaceGuidCName
1036 PcdDatumType
= PcdItem
.DatumType
1042 "The Pcd %s is found under multiple different TokenSpaceGuid: %s and %s." % (DisplayName
, PcdItem
.TokenSpaceGuidCName
, TokenSpaceGuidCNameList
[0])
1045 if (TokenCName
, TokenSpaceGuidCName
) in self
.DecPcds
:
1046 PcdDatumType
= self
.DecPcds
[(TokenCName
, TokenSpaceGuidCName
)].DatumType
1050 EdkLogger
.error('build', AUTOGEN_ERROR
, "The Pcd %s.%s is not found in the DEC file." % (TokenSpaceGuidCName
, DisplayName
))
1052 EdkLogger
.error('build', AUTOGEN_ERROR
, "The Pcd %s is not found in the DEC file." % (DisplayName
))
1053 pcdvalue
= pcdvalue
.replace("\\\\\\'", '\\\\\\"').replace('\\\'', '\'').replace('\\\\\\"', "\\'")
1055 pcdvalue
= DscBuildData
.HandleFlexiblePcd(TokenSpaceGuidCName
, TokenCName
, pcdvalue
, PcdDatumType
, self
._GuidDict
, FieldName
)
1057 pcdvalue
= DscBuildData
.HandleFlexiblePcd(TokenSpaceGuidCName
, TokenCName
, pcdvalue
, PcdDatumType
, self
._GuidDict
)
1058 IsValid
, Cause
= CheckPcdDatum(PcdDatumType
, pcdvalue
)
1060 EdkLogger
.error("build", FORMAT_INVALID
, Cause
, ExtraData
="%s.%s" % (TokenSpaceGuidCName
, TokenCName
))
1061 GlobalData
.BuildOptionPcd
[i
] = (TokenSpaceGuidCName
, TokenCName
, FieldName
, pcdvalue
, ("build command options", 1))
1063 for BuildData
in self
._Bdb
._CACHE
_.values():
1064 if BuildData
.MetaFile
.Ext
== '.dec' or BuildData
.MetaFile
.Ext
== '.dsc':
1066 for key
in BuildData
.Pcds
:
1067 PcdItem
= BuildData
.Pcds
[key
]
1068 if (TokenSpaceGuidCName
, TokenCName
) == (PcdItem
.TokenSpaceGuidCName
, PcdItem
.TokenCName
) and FieldName
=="":
1069 PcdItem
.DefaultValue
= pcdvalue
1070 #In command line, the latter full assign value in commandLine should override the former field assign value.
1071 #For example, --pcd Token.pcd.field="" --pcd Token.pcd=H"{}"
1074 if GlobalData
.BuildOptionPcd
:
1075 for pcdTuple
in GlobalData
.BuildOptionPcd
:
1076 TokenSpaceGuid
, Token
, Field
= pcdTuple
[0], pcdTuple
[1], pcdTuple
[2]
1078 if (TokenSpaceGuid
, Token
) not in field_assign
:
1079 field_assign
[TokenSpaceGuid
, Token
] = []
1080 field_assign
[TokenSpaceGuid
, Token
].append(pcdTuple
)
1082 if (TokenSpaceGuid
, Token
) in field_assign
:
1083 delete_assign
.extend(field_assign
[TokenSpaceGuid
, Token
])
1084 field_assign
[TokenSpaceGuid
, Token
] = []
1085 for item
in delete_assign
:
1086 GlobalData
.BuildOptionPcd
.remove(item
)
1089 def HandleFlexiblePcd(TokenSpaceGuidCName
, TokenCName
, PcdValue
, PcdDatumType
, GuidDict
, FieldName
=''):
1092 TokenCName
+= '.' + FieldName
1093 if PcdValue
.startswith('H'):
1094 if FieldName
and IsFieldValueAnArray(PcdValue
[1:]):
1095 PcdDatumType
= TAB_VOID
1097 if FieldName
and not IsArray
:
1100 PcdValue
= ValueExpressionEx(PcdValue
[1:], PcdDatumType
, GuidDict
)(True)
1101 except BadExpression
as Value
:
1102 EdkLogger
.error('Parser', FORMAT_INVALID
, 'PCD [%s.%s] Value "%s", %s' %
1103 (TokenSpaceGuidCName
, TokenCName
, PcdValue
, Value
))
1104 elif PcdValue
.startswith("L'") or PcdValue
.startswith("'"):
1105 if FieldName
and IsFieldValueAnArray(PcdValue
):
1106 PcdDatumType
= TAB_VOID
1108 if FieldName
and not IsArray
:
1111 PcdValue
= ValueExpressionEx(PcdValue
, PcdDatumType
, GuidDict
)(True)
1112 except BadExpression
as Value
:
1113 EdkLogger
.error('Parser', FORMAT_INVALID
, 'PCD [%s.%s] Value "%s", %s' %
1114 (TokenSpaceGuidCName
, TokenCName
, PcdValue
, Value
))
1115 elif PcdValue
.startswith('L'):
1116 PcdValue
= 'L"' + PcdValue
[1:] + '"'
1117 if FieldName
and IsFieldValueAnArray(PcdValue
):
1118 PcdDatumType
= TAB_VOID
1120 if FieldName
and not IsArray
:
1123 PcdValue
= ValueExpressionEx(PcdValue
, PcdDatumType
, GuidDict
)(True)
1124 except BadExpression
as Value
:
1125 EdkLogger
.error('Parser', FORMAT_INVALID
, 'PCD [%s.%s] Value "%s", %s' %
1126 (TokenSpaceGuidCName
, TokenCName
, PcdValue
, Value
))
1128 if PcdValue
.upper() == 'FALSE':
1130 if PcdValue
.upper() == 'TRUE':
1133 if PcdDatumType
not in TAB_PCD_NUMERIC_TYPES
:
1134 PcdValue
= '"' + PcdValue
+ '"'
1138 if PcdValue
.upper().startswith('0X'):
1141 Num
= int(PcdValue
, Base
)
1143 PcdValue
= '"' + PcdValue
+ '"'
1144 if IsFieldValueAnArray(PcdValue
):
1145 PcdDatumType
= TAB_VOID
1150 PcdValue
= ValueExpressionEx(PcdValue
, PcdDatumType
, GuidDict
)(True)
1151 except BadExpression
as Value
:
1152 EdkLogger
.error('Parser', FORMAT_INVALID
, 'PCD [%s.%s] Value "%s", %s' %
1153 (TokenSpaceGuidCName
, TokenCName
, PcdValue
, Value
))
1156 ## Retrieve all PCD settings in platform
1159 if self
._Pcds
is None:
1160 self
._Pcds
= OrderedDict()
1161 self
.__ParsePcdFromCommandLine
()
1162 self
._Pcds
.update(self
._GetPcd
(MODEL_PCD_FIXED_AT_BUILD
))
1163 self
._Pcds
.update(self
._GetPcd
(MODEL_PCD_PATCHABLE_IN_MODULE
))
1164 self
._Pcds
.update(self
._GetPcd
(MODEL_PCD_FEATURE_FLAG
))
1165 self
._Pcds
.update(self
._GetDynamicPcd
(MODEL_PCD_DYNAMIC_DEFAULT
))
1166 self
._Pcds
.update(self
._GetDynamicHiiPcd
(MODEL_PCD_DYNAMIC_HII
))
1167 self
._Pcds
.update(self
._GetDynamicVpdPcd
(MODEL_PCD_DYNAMIC_VPD
))
1168 self
._Pcds
.update(self
._GetDynamicPcd
(MODEL_PCD_DYNAMIC_EX_DEFAULT
))
1169 self
._Pcds
.update(self
._GetDynamicHiiPcd
(MODEL_PCD_DYNAMIC_EX_HII
))
1170 self
._Pcds
.update(self
._GetDynamicVpdPcd
(MODEL_PCD_DYNAMIC_EX_VPD
))
1172 self
._Pcds
= self
.CompletePcdValues(self
._Pcds
)
1173 self
._Pcds
= self
.OverrideByFdfOverAll(self
._Pcds
)
1174 self
._Pcds
= self
.OverrideByCommOverAll(self
._Pcds
)
1175 self
._Pcds
= self
.UpdateStructuredPcds(MODEL_PCD_TYPE_LIST
, self
._Pcds
)
1176 self
._Pcds
= self
.CompleteHiiPcdsDefaultStores(self
._Pcds
)
1177 self
._Pcds
= self
._FilterPcdBySkuUsage
(self
._Pcds
)
1179 self
.RecoverCommandLinePcd()
1182 ## Retrieve [BuildOptions]
1184 def BuildOptions(self
):
1185 if self
._BuildOptions
is None:
1186 self
._BuildOptions
= OrderedDict()
1188 # Retrieve build option for EDKII and EDK style module
1190 for CodeBase
in (EDKII_NAME
, EDK_NAME
):
1191 RecordList
= self
._RawData
[MODEL_META_DATA_BUILD_OPTION
, self
._Arch
, CodeBase
]
1192 for ToolChainFamily
, ToolChain
, Option
, Dummy1
, Dummy2
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
1193 if Dummy3
.upper() != TAB_COMMON
:
1195 CurKey
= (ToolChainFamily
, ToolChain
, CodeBase
)
1197 # Only flags can be appended
1199 if CurKey
not in self
._BuildOptions
or not ToolChain
.endswith('_FLAGS') or Option
.startswith('='):
1200 self
._BuildOptions
[CurKey
] = Option
1202 if ' ' + Option
not in self
._BuildOptions
[CurKey
]:
1203 self
._BuildOptions
[CurKey
] += ' ' + Option
1204 return self
._BuildOptions
1206 def GetBuildOptionsByModuleType(self
, Edk
, ModuleType
):
1207 if self
._ModuleTypeOptions
is None:
1208 self
._ModuleTypeOptions
= OrderedDict()
1209 if (Edk
, ModuleType
) not in self
._ModuleTypeOptions
:
1210 options
= OrderedDict()
1211 self
._ModuleTypeOptions
[Edk
, ModuleType
] = options
1212 DriverType
= '%s.%s' % (Edk
, ModuleType
)
1213 CommonDriverType
= '%s.%s' % (TAB_COMMON
, ModuleType
)
1214 RecordList
= self
._RawData
[MODEL_META_DATA_BUILD_OPTION
, self
._Arch
]
1215 for ToolChainFamily
, ToolChain
, Option
, Dummy1
, Dummy2
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
1216 Type
= Dummy2
+ '.' + Dummy3
1217 if Type
.upper() == DriverType
.upper() or Type
.upper() == CommonDriverType
.upper():
1218 Key
= (ToolChainFamily
, ToolChain
, Edk
)
1219 if Key
not in options
or not ToolChain
.endswith('_FLAGS') or Option
.startswith('='):
1220 options
[Key
] = Option
1222 if ' ' + Option
not in options
[Key
]:
1223 options
[Key
] += ' ' + Option
1224 return self
._ModuleTypeOptions
[Edk
, ModuleType
]
1227 def GetStructurePcdInfo(PcdSet
):
1228 structure_pcd_data
= defaultdict(list)
1230 structure_pcd_data
[(item
[0], item
[1])].append(item
)
1232 return structure_pcd_data
1235 def OverrideByFdf(StruPcds
,workspace
):
1236 if GlobalData
.gFdfParser
is None:
1238 StructurePcdInFdf
= OrderedDict()
1239 fdfpcd
= GlobalData
.gFdfParser
.Profile
.PcdDict
1240 fdfpcdlocation
= GlobalData
.gFdfParser
.Profile
.PcdLocalDict
1241 for item
in fdfpcd
:
1242 if len(item
[2]) and (item
[0],item
[1]) in StruPcds
:
1243 StructurePcdInFdf
[(item
[1],item
[0],item
[2] )] = fdfpcd
[item
]
1244 GlobalPcds
= {(item
[0],item
[1]) for item
in StructurePcdInFdf
}
1245 for Pcd
in StruPcds
.values():
1246 if (Pcd
.TokenSpaceGuidCName
,Pcd
.TokenCName
) not in GlobalPcds
:
1248 FieldValues
= OrderedDict()
1249 for item
in StructurePcdInFdf
:
1250 if (Pcd
.TokenSpaceGuidCName
,Pcd
.TokenCName
) == (item
[0],item
[1]) and item
[2]:
1251 FieldValues
[item
[2]] = StructurePcdInFdf
[item
]
1252 for field
in FieldValues
:
1253 if field
not in Pcd
.PcdFieldValueFromFdf
:
1254 Pcd
.PcdFieldValueFromFdf
[field
] = ["","",""]
1255 Pcd
.PcdFieldValueFromFdf
[field
][0] = FieldValues
[field
]
1256 Pcd
.PcdFieldValueFromFdf
[field
][1] = os
.path
.relpath(fdfpcdlocation
[(Pcd
.TokenCName
,Pcd
.TokenSpaceGuidCName
,field
)][0],workspace
)
1257 Pcd
.PcdFieldValueFromFdf
[field
][2] = fdfpcdlocation
[(Pcd
.TokenCName
,Pcd
.TokenSpaceGuidCName
,field
)][1]
1262 def OverrideByComm(StruPcds
):
1263 StructurePcdInCom
= OrderedDict()
1264 for item
in GlobalData
.BuildOptionPcd
:
1265 if len(item
) == 5 and (item
[1], item
[0]) in StruPcds
:
1266 StructurePcdInCom
[(item
[0], item
[1], item
[2] )] = (item
[3], item
[4])
1267 GlobalPcds
= {(item
[0], item
[1]) for item
in StructurePcdInCom
}
1268 for Pcd
in StruPcds
.values():
1269 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) not in GlobalPcds
:
1271 FieldValues
= OrderedDict()
1272 for item
in StructurePcdInCom
:
1273 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (item
[0], item
[1]) and item
[2]:
1274 FieldValues
[item
[2]] = StructurePcdInCom
[item
]
1275 for field
in FieldValues
:
1276 if field
not in Pcd
.PcdFieldValueFromComm
:
1277 Pcd
.PcdFieldValueFromComm
[field
] = ["", "", ""]
1278 Pcd
.PcdFieldValueFromComm
[field
][0] = FieldValues
[field
][0]
1279 Pcd
.PcdFieldValueFromComm
[field
][1] = FieldValues
[field
][1][0]
1280 Pcd
.PcdFieldValueFromComm
[field
][2] = FieldValues
[field
][1][1]
1283 def OverrideByCommOverAll(self
,AllPcds
):
1284 def CheckStructureInComm(commpcds
):
1287 if len(commpcds
[0]) == 5:
1290 NoFiledValues
= OrderedDict()
1291 if CheckStructureInComm(GlobalData
.BuildOptionPcd
):
1292 StructurePcdInCom
= OrderedDict()
1293 for item
in GlobalData
.BuildOptionPcd
:
1294 StructurePcdInCom
[(item
[0], item
[1], item
[2] )] = (item
[3], item
[4])
1295 for item
in StructurePcdInCom
:
1297 NoFiledValues
[(item
[0], item
[1])] = StructurePcdInCom
[item
]
1299 for item
in GlobalData
.BuildOptionPcd
:
1300 NoFiledValues
[(item
[0], item
[1])] = [item
[2]]
1301 for Guid
, Name
in NoFiledValues
:
1302 if (Name
, Guid
) in AllPcds
:
1303 Pcd
= AllPcds
.get((Name
, Guid
))
1304 if isinstance(self
._DecPcds
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), None), StructurePcd
):
1305 self
._DecPcds
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)).PcdValueFromComm
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1307 Pcd
.PcdValueFromComm
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1308 Pcd
.DefaultValue
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1309 for sku
in Pcd
.SkuInfoList
:
1310 SkuInfo
= Pcd
.SkuInfoList
[sku
]
1311 if SkuInfo
.DefaultValue
:
1312 SkuInfo
.DefaultValue
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1314 SkuInfo
.HiiDefaultValue
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1315 for defaultstore
in SkuInfo
.DefaultStoreDict
:
1316 SkuInfo
.DefaultStoreDict
[defaultstore
] = NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1317 if Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
]]:
1318 if Pcd
.DatumType
== TAB_VOID
:
1319 if not Pcd
.MaxDatumSize
:
1320 Pcd
.MaxDatumSize
= '0'
1321 CurrentSize
= int(Pcd
.MaxDatumSize
, 16) if Pcd
.MaxDatumSize
.upper().startswith("0X") else int(Pcd
.MaxDatumSize
)
1322 OptionSize
= len((StringToArray(Pcd
.PcdValueFromComm
)).split(","))
1323 MaxSize
= max(CurrentSize
, OptionSize
)
1324 Pcd
.MaxDatumSize
= str(MaxSize
)
1326 PcdInDec
= self
.DecPcds
.get((Name
, Guid
))
1328 PcdInDec
.PcdValueFromComm
= NoFiledValues
[(Guid
, Name
)][0]
1329 if PcdInDec
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
1330 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
],
1331 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FEATURE_FLAG
],
1332 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC
],
1333 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX
]]:
1334 self
.Pcds
[Name
, Guid
] = copy
.deepcopy(PcdInDec
)
1335 self
.Pcds
[Name
, Guid
].DefaultValue
= NoFiledValues
[( Guid
, Name
)][0]
1336 if PcdInDec
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC
],
1337 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX
]]:
1338 self
.Pcds
[Name
, Guid
].SkuInfoList
= {TAB_DEFAULT
:SkuInfoClass(TAB_DEFAULT
, self
.SkuIds
[TAB_DEFAULT
][0], '', '', '', '', '', NoFiledValues
[( Guid
, Name
)][0])}
1341 def OverrideByFdfOverAll(self
,AllPcds
):
1343 if GlobalData
.gFdfParser
is None:
1345 NoFiledValues
= GlobalData
.gFdfParser
.Profile
.PcdDict
1346 for Name
,Guid
,Field
in NoFiledValues
:
1349 Value
= NoFiledValues
[(Name
,Guid
,Field
)]
1350 if (Name
,Guid
) in AllPcds
:
1351 Pcd
= AllPcds
.get((Name
,Guid
))
1352 if isinstance(self
._DecPcds
.get((Pcd
.TokenCName
,Pcd
.TokenSpaceGuidCName
), None),StructurePcd
):
1353 self
._DecPcds
.get((Pcd
.TokenCName
,Pcd
.TokenSpaceGuidCName
)).PcdValueFromComm
= Value
1355 Pcd
.PcdValueFromComm
= Value
1356 Pcd
.DefaultValue
= Value
1357 for sku
in Pcd
.SkuInfoList
:
1358 SkuInfo
= Pcd
.SkuInfoList
[sku
]
1359 if SkuInfo
.DefaultValue
:
1360 SkuInfo
.DefaultValue
= Value
1362 SkuInfo
.HiiDefaultValue
= Value
1363 for defaultstore
in SkuInfo
.DefaultStoreDict
:
1364 SkuInfo
.DefaultStoreDict
[defaultstore
] = Value
1365 if Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
]]:
1366 if Pcd
.DatumType
== TAB_VOID
:
1367 if not Pcd
.MaxDatumSize
:
1368 Pcd
.MaxDatumSize
= '0'
1369 CurrentSize
= int(Pcd
.MaxDatumSize
,16) if Pcd
.MaxDatumSize
.upper().startswith("0X") else int(Pcd
.MaxDatumSize
)
1370 OptionSize
= len((StringToArray(Pcd
.PcdValueFromComm
)).split(","))
1371 MaxSize
= max(CurrentSize
, OptionSize
)
1372 Pcd
.MaxDatumSize
= str(MaxSize
)
1374 PcdInDec
= self
.DecPcds
.get((Name
,Guid
))
1376 PcdInDec
.PcdValueFromFdf
= Value
1377 if PcdInDec
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
1378 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
],
1379 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FEATURE_FLAG
]]:
1380 self
.Pcds
[Name
, Guid
] = copy
.deepcopy(PcdInDec
)
1381 self
.Pcds
[Name
, Guid
].DefaultValue
= Value
1384 def UpdateStructuredPcds(self
, TypeList
, AllPcds
):
1386 DynamicPcdType
= [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_DEFAULT
],
1387 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
1388 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_VPD
],
1389 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_DEFAULT
],
1390 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
],
1391 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_VPD
]]
1394 DefaultStoreMgr
= DefaultStore(self
.DefaultStores
)
1395 SkuIds
= self
.SkuIds
1396 DefaultStores
= {storename
for pcdobj
in AllPcds
.values() for skuobj
in pcdobj
.SkuInfoList
.values() for storename
in skuobj
.DefaultStoreDict
}
1399 # Find out all possible PCD candidates for self._Arch
1402 for Type
in TypeList
:
1403 RecordList
.extend(self
._RawData
[Type
, self
._Arch
])
1405 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, default_store
, Dummy4
, Dummy5
in RecordList
:
1406 SkuName
= SkuName
.upper()
1407 default_store
= default_store
.upper()
1408 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
1409 if SkuName
not in SkuIds
:
1412 if SkuName
in SkuIds
and "." in TokenSpaceGuid
:
1413 S_PcdSet
.append([ TokenSpaceGuid
.split(".")[0], TokenSpaceGuid
.split(".")[1], PcdCName
, SkuName
, default_store
, Dummy5
, AnalyzePcdExpression(Setting
)[0]])
1415 # handle pcd value override
1416 StrPcdSet
= DscBuildData
.GetStructurePcdInfo(S_PcdSet
)
1417 S_pcd_set
= OrderedDict()
1418 for str_pcd
in StrPcdSet
:
1419 str_pcd_obj
= Pcds
.get((str_pcd
[1], str_pcd
[0]), None)
1420 str_pcd_dec
= self
._DecPcds
.get((str_pcd
[1], str_pcd
[0]), None)
1421 if not isinstance (str_pcd_dec
, StructurePcd
):
1422 EdkLogger
.error('build', PARSER_ERROR
,
1423 "Pcd (%s.%s) is not declared as Structure PCD in DEC files. Arch: ['%s']" % (str_pcd
[0], str_pcd
[1], self
._Arch
),
1424 File
=self
.MetaFile
, Line
= StrPcdSet
[str_pcd
][0][5])
1426 str_pcd_obj_str
= StructurePcd()
1427 str_pcd_obj_str
.copy(str_pcd_dec
)
1429 str_pcd_obj_str
.copy(str_pcd_obj
)
1430 if str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1431 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
}
1433 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
}
1434 for str_pcd_data
in StrPcdSet
[str_pcd
]:
1435 if str_pcd_data
[3] in SkuIds
:
1436 str_pcd_obj_str
.AddOverrideValue(str_pcd_data
[2], str(str_pcd_data
[6]), TAB_DEFAULT
if str_pcd_data
[3] == TAB_COMMON
else str_pcd_data
[3], TAB_DEFAULT_STORES_DEFAULT
if str_pcd_data
[4] == TAB_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])
1437 S_pcd_set
[str_pcd
[1], str_pcd
[0]] = str_pcd_obj_str
1439 EdkLogger
.error('build', PARSER_ERROR
,
1440 "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (str_pcd
[0], str_pcd
[1], self
._Arch
),
1441 File
=self
.MetaFile
, Line
= StrPcdSet
[str_pcd
][0][5])
1442 # Add the Structure PCD that only defined in DEC, don't have override in DSC file
1443 for Pcd
in self
.DecPcds
:
1444 if isinstance(self
._DecPcds
[Pcd
], StructurePcd
):
1445 if Pcd
not in S_pcd_set
:
1446 str_pcd_obj_str
= StructurePcd()
1447 str_pcd_obj_str
.copy(self
._DecPcds
[Pcd
])
1448 str_pcd_obj
= Pcds
.get(Pcd
, None)
1450 str_pcd_obj_str
.copy(str_pcd_obj
)
1451 if str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1452 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
}
1454 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
}
1455 S_pcd_set
[Pcd
] = str_pcd_obj_str
1457 GlobalData
.gStructurePcd
[self
.Arch
] = S_pcd_set
1458 for stru_pcd
in S_pcd_set
.values():
1459 for skuid
in SkuIds
:
1460 if skuid
in stru_pcd
.SkuOverrideValues
:
1462 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(skuid
)
1464 if skuid
not in stru_pcd
.SkuOverrideValues
:
1465 while nextskuid
not in stru_pcd
.SkuOverrideValues
:
1466 if nextskuid
== TAB_DEFAULT
:
1469 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
1470 stru_pcd
.SkuOverrideValues
[skuid
] = copy
.deepcopy(stru_pcd
.SkuOverrideValues
[nextskuid
]) if not NoDefault
else copy
.deepcopy({defaultstorename
: stru_pcd
.DefaultValues
for defaultstorename
in DefaultStores
} if DefaultStores
else {}) #{TAB_DEFAULT_STORES_DEFAULT:stru_pcd.DefaultValues})
1472 stru_pcd
.ValueChain
.add((skuid
, ''))
1473 if stru_pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1474 for skuid
in SkuIds
:
1477 if skuid
not in stru_pcd
.SkuOverrideValues
:
1478 while nextskuid
not in stru_pcd
.SkuOverrideValues
:
1479 if nextskuid
== TAB_DEFAULT
:
1482 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
1485 PcdDefaultStoreSet
= set(defaultstorename
for defaultstorename
in stru_pcd
.SkuOverrideValues
[nextskuid
])
1486 mindefaultstorename
= DefaultStoreMgr
.GetMin(PcdDefaultStoreSet
)
1488 for defaultstoreid
in DefaultStores
:
1489 if defaultstoreid
not in stru_pcd
.SkuOverrideValues
[skuid
]:
1490 stru_pcd
.SkuOverrideValues
[skuid
][defaultstoreid
] = copy
.deepcopy(stru_pcd
.SkuOverrideValues
[nextskuid
][mindefaultstorename
])
1491 stru_pcd
.ValueChain
.add((skuid
, defaultstoreid
))
1492 S_pcd_set
= DscBuildData
.OverrideByFdf(S_pcd_set
,self
.WorkspaceDir
)
1493 S_pcd_set
= DscBuildData
.OverrideByComm(S_pcd_set
)
1494 Str_Pcd_Values
= self
.GenerateByteArrayValue(S_pcd_set
)
1496 for (skuname
, StoreName
, PcdGuid
, PcdName
, PcdValue
) in Str_Pcd_Values
:
1497 str_pcd_obj
= S_pcd_set
.get((PcdName
, PcdGuid
))
1498 if str_pcd_obj
is None:
1499 print(PcdName
, PcdGuid
)
1501 if str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
1502 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1503 if skuname
not in str_pcd_obj
.SkuInfoList
:
1504 str_pcd_obj
.SkuInfoList
[skuname
] = SkuInfoClass(SkuIdName
=skuname
, SkuId
=self
.SkuIds
[skuname
][0], HiiDefaultValue
=PcdValue
, DefaultStore
= {StoreName
:PcdValue
})
1506 str_pcd_obj
.SkuInfoList
[skuname
].HiiDefaultValue
= PcdValue
1507 str_pcd_obj
.SkuInfoList
[skuname
].DefaultStoreDict
.update({StoreName
:PcdValue
})
1508 elif str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
1509 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
1510 if skuname
in (self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT
, TAB_COMMON
):
1511 str_pcd_obj
.DefaultValue
= PcdValue
1513 if skuname
not in str_pcd_obj
.SkuInfoList
:
1514 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(skuname
)
1516 while nextskuid
not in str_pcd_obj
.SkuInfoList
:
1517 if nextskuid
== TAB_DEFAULT
:
1520 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
1521 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
)
1522 str_pcd_obj
.SkuInfoList
[skuname
].SkuId
= self
.SkuIds
[skuname
][0]
1523 str_pcd_obj
.SkuInfoList
[skuname
].SkuIdName
= skuname
1525 str_pcd_obj
.SkuInfoList
[skuname
].DefaultValue
= PcdValue
1526 for str_pcd_obj
in S_pcd_set
.values():
1527 if str_pcd_obj
.Type
not in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
1528 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1530 PcdDefaultStoreSet
= set(defaultstorename
for skuobj
in str_pcd_obj
.SkuInfoList
.values() for defaultstorename
in skuobj
.DefaultStoreDict
)
1531 DefaultStoreObj
= DefaultStore(self
._GetDefaultStores
())
1532 mindefaultstorename
= DefaultStoreObj
.GetMin(PcdDefaultStoreSet
)
1533 str_pcd_obj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
].HiiDefaultValue
= str_pcd_obj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
].DefaultStoreDict
[mindefaultstorename
]
1535 for str_pcd_obj
in S_pcd_set
.values():
1537 str_pcd_obj
.MaxDatumSize
= self
.GetStructurePcdMaxSize(str_pcd_obj
)
1538 Pcds
[str_pcd_obj
.TokenCName
, str_pcd_obj
.TokenSpaceGuidCName
] = str_pcd_obj
1542 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
1543 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
1544 del pcd
.SkuInfoList
[TAB_COMMON
]
1545 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
1546 del pcd
.SkuInfoList
[TAB_COMMON
]
1548 map(self
.FilterSkuSettings
, [Pcds
[pcdkey
] for pcdkey
in Pcds
if Pcds
[pcdkey
].Type
in DynamicPcdType
])
1551 ## Retrieve non-dynamic PCD settings
1553 # @param Type PCD type
1555 # @retval a dict object contains settings of given PCD type
1557 def _GetPcd(self
, Type
):
1558 Pcds
= OrderedDict()
1560 # tdict is a special dict kind of type, used for selecting correct
1561 # PCD settings for certain ARCH
1563 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
1565 PcdDict
= tdict(True, 3)
1567 # Find out all possible PCD candidates for self._Arch
1568 RecordList
= self
._RawData
[Type
, self
._Arch
]
1569 PcdValueDict
= OrderedDict()
1570 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
1571 SkuName
= SkuName
.upper()
1572 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
1573 if SkuName
not in AvailableSkuIdSet
:
1574 EdkLogger
.error('build ', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
1575 File
=self
.MetaFile
, Line
=Dummy5
)
1576 if SkuName
in (self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT
, TAB_COMMON
):
1577 if "." not in TokenSpaceGuid
:
1578 PcdSet
.add((PcdCName
, TokenSpaceGuid
, SkuName
, Dummy5
))
1579 PcdDict
[Arch
, PcdCName
, TokenSpaceGuid
, SkuName
] = Setting
1581 for PcdCName
, TokenSpaceGuid
, SkuName
, Dummy4
in PcdSet
:
1582 Setting
= PcdDict
[self
._Arch
, PcdCName
, TokenSpaceGuid
, SkuName
]
1585 PcdValue
, DatumType
, MaxDatumSize
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
1587 if int(MaxDatumSize
, 0) > 0xFFFF:
1588 EdkLogger
.error('build', FORMAT_INVALID
, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
1589 File
=self
.MetaFile
, Line
=Dummy4
)
1590 if int(MaxDatumSize
, 0) < 0:
1591 EdkLogger
.error('build', FORMAT_INVALID
, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
1592 File
=self
.MetaFile
, Line
=Dummy4
)
1593 if (PcdCName
, TokenSpaceGuid
) in PcdValueDict
:
1594 PcdValueDict
[PcdCName
, TokenSpaceGuid
][SkuName
] = (PcdValue
, DatumType
, MaxDatumSize
)
1596 PcdValueDict
[PcdCName
, TokenSpaceGuid
] = {SkuName
:(PcdValue
, DatumType
, MaxDatumSize
)}
1598 for ((PcdCName
, TokenSpaceGuid
), PcdSetting
) in PcdValueDict
.iteritems():
1599 if self
.SkuIdMgr
.SystemSkuId
in PcdSetting
:
1600 PcdValue
, DatumType
, MaxDatumSize
= PcdSetting
[self
.SkuIdMgr
.SystemSkuId
]
1601 elif TAB_DEFAULT
in PcdSetting
:
1602 PcdValue
, DatumType
, MaxDatumSize
= PcdSetting
[TAB_DEFAULT
]
1603 elif TAB_COMMON
in PcdSetting
:
1604 PcdValue
, DatumType
, MaxDatumSize
= PcdSetting
[TAB_COMMON
]
1610 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
1613 self
._PCD
_TYPE
_STRING
_[Type
],
1623 if self
.SkuIdMgr
.SystemSkuId
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
1624 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[self
.SkuIdMgr
.SystemSkuId
] = {}
1625 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[self
.SkuIdMgr
.SystemSkuId
][TAB_DEFAULT_STORES_DEFAULT
] = PcdValue
1628 def GetStructurePcdMaxSize(self
, str_pcd
):
1629 pcd_default_value
= str_pcd
.DefaultValue
1630 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()]
1631 sku_values
.append(pcd_default_value
)
1633 def get_length(value
):
1634 Value
= value
.strip()
1636 if Value
.startswith(TAB_GUID
) and Value
.endswith(')'):
1638 if Value
.startswith('L"') and Value
.endswith('"'):
1639 return len(Value
[2:-1])
1640 if Value
[0] == '"' and Value
[-1] == '"':
1641 return len(Value
) - 2
1642 if Value
[0] == '{' and Value
[-1] == '}':
1643 return len(Value
.split(","))
1644 if Value
.startswith("L'") and Value
.endswith("'") and len(list(Value
[2:-1])) > 1:
1645 return len(list(Value
[2:-1]))
1646 if Value
[0] == "'" and Value
[-1] == "'" and len(list(Value
[1:-1])) > 1:
1647 return len(Value
) - 2
1650 return str(max(get_length(item
) for item
in sku_values
))
1653 def ExecuteCommand (Command
):
1655 Process
= subprocess
.Popen(Command
, stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
, shell
=True)
1657 EdkLogger
.error('Build', COMMAND_FAILURE
, 'Can not execute command: %s' % Command
)
1658 Result
= Process
.communicate()
1659 return Process
.returncode
, Result
[0], Result
[1]
1662 def IntToCString(Value
, ValueSize
):
1664 if not isinstance (Value
, str):
1665 for Index
in range(0, ValueSize
):
1666 Result
= Result
+ '\\x%02x' % (Value
& 0xff)
1668 Result
= Result
+ '"'
1671 def GenerateSizeFunction(self
, Pcd
):
1672 CApp
= "// Default Value in Dec \n"
1673 CApp
= CApp
+ "void Cal_%s_%s_Size(UINT32 *Size){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1674 for FieldList
in [Pcd
.DefaultValues
]:
1677 for FieldName
in FieldList
:
1678 FieldName
= "." + FieldName
1679 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
.strip(".")][0])
1680 if IsArray
and not (FieldList
[FieldName
.strip(".")][0].startswith('{GUID') and FieldList
[FieldName
.strip(".")][0].endswith('}')):
1682 Value
= ValueExpressionEx(FieldList
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1683 except BadExpression
:
1684 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1685 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), FieldList
[FieldName
.strip(".")][1], FieldList
[FieldName
.strip(".")][2]))
1686 Value
, ValueSize
= ParseFieldValue(Value
)
1687 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]);
1690 FieldName_ori
= FieldName
.strip('.')
1691 while '[' in FieldName
:
1692 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1693 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1694 FieldName
= FieldName
.split(']', 1)[1]
1695 FieldName
= NewFieldName
+ FieldName
1696 while '[' in FieldName
:
1697 FieldName
= FieldName
.rsplit('[', 1)[0]
1698 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])
1699 for skuname
in Pcd
.SkuOverrideValues
:
1700 if skuname
== TAB_COMMON
:
1702 for defaultstorenameitem
in Pcd
.SkuOverrideValues
[skuname
]:
1703 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: %s \n" % (skuname
, defaultstorenameitem
)
1704 for FieldList
in [Pcd
.SkuOverrideValues
[skuname
].get(defaultstorenameitem
)]:
1707 for FieldName
in FieldList
:
1708 FieldName
= "." + FieldName
1709 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
.strip(".")][0])
1710 if IsArray
and not (FieldList
[FieldName
.strip(".")][0].startswith('{GUID') and FieldList
[FieldName
.strip(".")][0].endswith('}')):
1712 Value
= ValueExpressionEx(FieldList
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1713 except BadExpression
:
1714 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1715 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), FieldList
[FieldName
.strip(".")][1], FieldList
[FieldName
.strip(".")][2]))
1716 Value
, ValueSize
= ParseFieldValue(Value
)
1717 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]);
1720 FieldName_ori
= FieldName
.strip('.')
1721 while '[' in FieldName
:
1722 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1723 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1724 FieldName
= FieldName
.split(']', 1)[1]
1725 FieldName
= NewFieldName
+ FieldName
1726 while '[' in FieldName
:
1727 FieldName
= FieldName
.rsplit('[', 1)[0]
1728 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])
1729 if Pcd
.PcdFieldValueFromFdf
:
1730 CApp
= CApp
+ "// From fdf \n"
1731 for FieldName
in Pcd
.PcdFieldValueFromFdf
:
1732 FieldName
= "." + FieldName
1733 IsArray
= IsFieldValueAnArray(Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0])
1734 if IsArray
and not (Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0].startswith('{GUID') and Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0].endswith('}')):
1736 Value
= ValueExpressionEx(Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1737 except BadExpression
:
1738 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1739 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][1], Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][2]))
1740 Value
, ValueSize
= ParseFieldValue(Value
)
1741 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
.PcdFieldValueFromFdf
[FieldName
.strip(".")][1], Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][2], Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0]);
1744 FieldName_ori
= FieldName
.strip('.')
1745 while '[' in FieldName
:
1746 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1747 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1748 FieldName
= FieldName
.split(']', 1)[1]
1749 FieldName
= NewFieldName
+ FieldName
1750 while '[' in FieldName
:
1751 FieldName
= FieldName
.rsplit('[', 1)[0]
1752 CApp
= CApp
+ ' __FLEXIBLE_SIZE(*Size, %s, %s, %d); // From %s Line %s Value %s \n' % (Pcd
.DatumType
, FieldName
.strip("."), ArrayIndex
+ 1, Pcd
.PcdFieldValueFromFdf
[FieldName_ori
][1], Pcd
.PcdFieldValueFromFdf
[FieldName_ori
][2], Pcd
.PcdFieldValueFromFdf
[FieldName_ori
][0])
1753 if Pcd
.PcdFieldValueFromComm
:
1754 CApp
= CApp
+ "// From Command Line \n"
1755 for FieldName
in Pcd
.PcdFieldValueFromComm
:
1756 FieldName
= "." + FieldName
1757 IsArray
= IsFieldValueAnArray(Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0])
1758 if IsArray
and not (Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0].startswith('{GUID') and Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0].endswith('}')):
1760 Value
= ValueExpressionEx(Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1761 except BadExpression
:
1762 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1763 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][1], Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][2]))
1764 Value
, ValueSize
= ParseFieldValue(Value
)
1765 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]);
1768 FieldName_ori
= FieldName
.strip('.')
1769 while '[' in FieldName
:
1770 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1771 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1772 FieldName
= FieldName
.split(']', 1)[1]
1773 FieldName
= NewFieldName
+ FieldName
1774 while '[' in FieldName
:
1775 FieldName
= FieldName
.rsplit('[', 1)[0]
1776 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])
1777 CApp
= CApp
+ " *Size = (%d > *Size ? %d : *Size); // The Pcd maxsize is %d \n" % (Pcd
.GetPcdMaxSize(), Pcd
.GetPcdMaxSize(), Pcd
.GetPcdMaxSize())
1782 def GenerateSizeStatments(Pcd
):
1783 CApp
= ' Size = sizeof(%s);\n' % (Pcd
.DatumType
)
1784 CApp
= CApp
+ ' Cal_%s_%s_Size(&Size);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1787 def GenerateDefaultValueAssignFunction(self
, Pcd
):
1788 CApp
= "// Default value in Dec \n"
1789 CApp
= CApp
+ "void Assign_%s_%s_Default_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Pcd
.DatumType
)
1790 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1791 CApp
= CApp
+ ' CHAR8 *Value;\n'
1792 DefaultValueFromDec
= Pcd
.DefaultValueFromDec
1793 IsArray
= IsFieldValueAnArray(Pcd
.DefaultValueFromDec
)
1796 DefaultValueFromDec
= ValueExpressionEx(Pcd
.DefaultValueFromDec
, TAB_VOID
)(True)
1797 except BadExpression
:
1798 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from DEC: %s" %
1799 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, DefaultValueFromDec
))
1800 DefaultValueFromDec
= StringToArray(DefaultValueFromDec
)
1801 Value
, ValueSize
= ParseFieldValue (DefaultValueFromDec
)
1802 if isinstance(Value
, str):
1803 CApp
= CApp
+ ' Pcd = %s; // From DEC Default Value %s\n' % (Value
, Pcd
.DefaultValueFromDec
)
1806 # Use memcpy() to copy value into field
1808 CApp
= CApp
+ ' Value = %s; // From DEC Default Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), Pcd
.DefaultValueFromDec
)
1809 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1810 for FieldList
in [Pcd
.DefaultValues
]:
1813 for FieldName
in FieldList
:
1814 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
1817 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
1818 except BadExpression
:
1819 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1820 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
1823 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
1825 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]))
1826 if isinstance(Value
, str):
1827 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1830 # Use memcpy() to copy value into field
1832 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
1833 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1834 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
1837 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1839 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1844 def GenerateDefaultValueAssignStatement(Pcd
):
1845 CApp
= ' Assign_%s_%s_Default_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1848 def GenerateInitValueFunction(self
, Pcd
, SkuName
, DefaultStoreName
):
1849 CApp
= "// Value in Dsc for Sku: %s, DefaultStore %s\n" % (SkuName
, DefaultStoreName
)
1850 CApp
= CApp
+ "void Assign_%s_%s_%s_%s_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, SkuName
, DefaultStoreName
, Pcd
.DatumType
)
1851 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1852 CApp
= CApp
+ ' CHAR8 *Value;\n'
1854 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: %s \n" % (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
)
1855 inherit_OverrideValues
= Pcd
.SkuOverrideValues
[SkuName
]
1856 if (SkuName
, DefaultStoreName
) == (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
):
1857 pcddefaultvalue
= Pcd
.DefaultFromDSC
.get(TAB_DEFAULT
, {}).get(TAB_DEFAULT_STORES_DEFAULT
) if Pcd
.DefaultFromDSC
else None
1859 pcddefaultvalue
= Pcd
.DscRawValue
.get(SkuName
, {}).get(DefaultStoreName
)
1860 for FieldList
in [pcddefaultvalue
, inherit_OverrideValues
.get(DefaultStoreName
)]:
1863 if pcddefaultvalue
and FieldList
== pcddefaultvalue
:
1864 IsArray
= IsFieldValueAnArray(FieldList
)
1867 FieldList
= ValueExpressionEx(FieldList
, TAB_VOID
)(True)
1868 except BadExpression
:
1869 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from DSC: %s" %
1870 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldList
))
1871 Value
, ValueSize
= ParseFieldValue (FieldList
)
1873 if (SkuName
, DefaultStoreName
) == (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
):
1874 if isinstance(Value
, str):
1875 CApp
= CApp
+ ' Pcd = %s; // From DSC Default Value %s\n' % (Value
, Pcd
.DefaultFromDSC
.get(TAB_DEFAULT
, {}).get(TAB_DEFAULT_STORES_DEFAULT
, Pcd
.DefaultValue
) if Pcd
.DefaultFromDSC
else Pcd
.DefaultValue
)
1878 # Use memcpy() to copy value into field
1880 CApp
= CApp
+ ' Value = %s; // From DSC Default Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), Pcd
.DefaultFromDSC
.get(TAB_DEFAULT
, {}).get(TAB_DEFAULT_STORES_DEFAULT
, Pcd
.DefaultValue
) if Pcd
.DefaultFromDSC
else Pcd
.DefaultValue
)
1881 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1883 if isinstance(Value
, str):
1884 CApp
= CApp
+ ' Pcd = %s; // From DSC Default Value %s\n' % (Value
, Pcd
.DscRawValue
.get(SkuName
, {}).get(DefaultStoreName
))
1887 # Use memcpy() to copy value into field
1889 CApp
= CApp
+ ' Value = %s; // From DSC Default Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), Pcd
.DscRawValue
.get(SkuName
, {}).get(DefaultStoreName
))
1890 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1892 if (SkuName
, DefaultStoreName
) == (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
) or (( (SkuName
, '') not in Pcd
.ValueChain
) and ( (SkuName
, DefaultStoreName
) not in Pcd
.ValueChain
)):
1893 for FieldName
in FieldList
:
1894 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
1897 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
1898 except BadExpression
:
1899 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1900 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
1902 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
1904 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]))
1905 if isinstance(Value
, str):
1906 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1909 # Use memcpy() to copy value into field
1911 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
1912 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1913 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
1916 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1918 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1923 def GenerateInitValueStatement(Pcd
, SkuName
, DefaultStoreName
):
1924 CApp
= ' Assign_%s_%s_%s_%s_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, SkuName
, DefaultStoreName
)
1927 def GenerateCommandLineValue(self
, Pcd
):
1928 CApp
= "// Value in CommandLine\n"
1929 CApp
= CApp
+ "void Assign_%s_%s_CommandLine_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Pcd
.DatumType
)
1930 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1931 CApp
= CApp
+ ' CHAR8 *Value;\n'
1933 pcddefaultvalue
= Pcd
.PcdValueFromComm
1934 for FieldList
in [pcddefaultvalue
, Pcd
.PcdFieldValueFromComm
]:
1937 if pcddefaultvalue
and FieldList
== pcddefaultvalue
:
1938 IsArray
= IsFieldValueAnArray(FieldList
)
1941 FieldList
= ValueExpressionEx(FieldList
, TAB_VOID
)(True)
1942 except BadExpression
:
1943 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from Command: %s" %
1944 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldList
))
1945 Value
, ValueSize
= ParseFieldValue (FieldList
)
1947 if isinstance(Value
, str):
1948 CApp
= CApp
+ ' Pcd = %s; // From Command Line \n' % (Value
)
1951 # Use memcpy() to copy value into field
1953 CApp
= CApp
+ ' Value = %s; // From Command Line.\n' % (DscBuildData
.IntToCString(Value
, ValueSize
))
1954 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1956 for FieldName
in FieldList
:
1957 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
1960 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
1961 except BadExpression
:
1962 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1963 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
1967 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
1969 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]))
1970 if isinstance(Value
, str):
1971 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1974 # Use memcpy() to copy value into field
1976 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
1977 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1978 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
1981 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1983 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1988 def GenerateCommandLineValueStatement(Pcd
):
1989 CApp
= ' Assign_%s_%s_CommandLine_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1991 def GenerateFdfValue(self
,Pcd
):
1992 CApp
= "// Value in Fdf\n"
1993 CApp
= CApp
+ "void Assign_%s_%s_Fdf_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
,Pcd
.DatumType
)
1994 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1995 CApp
= CApp
+ ' CHAR8 *Value;\n'
1997 pcddefaultvalue
= Pcd
.PcdValueFromFdf
1998 for FieldList
in [pcddefaultvalue
,Pcd
.PcdFieldValueFromFdf
]:
2001 if pcddefaultvalue
and FieldList
== pcddefaultvalue
:
2002 IsArray
= IsFieldValueAnArray(FieldList
)
2005 FieldList
= ValueExpressionEx(FieldList
, TAB_VOID
)(True)
2006 except BadExpression
:
2007 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from Fdf: %s" %
2008 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldList
))
2009 Value
, ValueSize
= ParseFieldValue (FieldList
)
2011 if isinstance(Value
, str):
2012 CApp
= CApp
+ ' Pcd = %s; // From Fdf \n' % (Value
)
2015 # Use memcpy() to copy value into field
2017 CApp
= CApp
+ ' Value = %s; // From Fdf .\n' % (DscBuildData
.IntToCString(Value
, ValueSize
))
2018 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
2020 for FieldName
in FieldList
:
2021 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
2024 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
2025 except BadExpression
:
2026 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
2027 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
2031 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
2033 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]))
2034 if isinstance(Value
, str):
2035 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2038 # Use memcpy() to copy value into field
2040 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
2041 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2042 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
2045 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2047 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %s Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2052 def GenerateFdfValueStatement(Pcd
):
2053 CApp
= ' Assign_%s_%s_Fdf_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2056 def GenerateInitializeFunc(self
, SkuName
, DefaultStore
, Pcd
, InitByteValue
, CApp
):
2057 OverrideValues
= {DefaultStore
:""}
2058 if Pcd
.SkuOverrideValues
:
2059 OverrideValues
= Pcd
.SkuOverrideValues
[SkuName
]
2060 if not OverrideValues
:
2061 OverrideValues
= {TAB_DEFAULT_STORES_DEFAULT
:Pcd
.DefaultValues
}
2062 for DefaultStoreName
in OverrideValues
:
2063 CApp
= CApp
+ 'void\n'
2064 CApp
= CApp
+ 'Initialize_%s_%s_%s_%s(\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2065 CApp
= CApp
+ ' void\n'
2066 CApp
= CApp
+ ' )\n'
2068 CApp
= CApp
+ ' UINT32 Size;\n'
2069 CApp
= CApp
+ ' UINT32 FieldSize;\n'
2070 CApp
= CApp
+ ' CHAR8 *Value;\n'
2071 CApp
= CApp
+ ' UINT32 OriginalSize;\n'
2072 CApp
= CApp
+ ' VOID *OriginalPcd;\n'
2073 CApp
= CApp
+ ' %s *Pcd; // From %s Line %d \n' % (Pcd
.DatumType
, Pcd
.PkgPath
, Pcd
.PcdDefineLineNo
)
2076 if SkuName
in Pcd
.SkuInfoList
:
2077 DefaultValue
= Pcd
.SkuInfoList
[SkuName
].DefaultStoreDict
.get(DefaultStoreName
, Pcd
.SkuInfoList
[SkuName
].HiiDefaultValue
if Pcd
.SkuInfoList
[SkuName
].HiiDefaultValue
else Pcd
.SkuInfoList
[SkuName
].DefaultValue
)
2079 DefaultValue
= Pcd
.DefaultValue
2080 PcdDefaultValue
= StringToArray(DefaultValue
.strip())
2082 InitByteValue
+= '%s.%s.%s.%s|%s|%s\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Pcd
.DatumType
, PcdDefaultValue
)
2085 # Get current PCD value and size
2087 CApp
= CApp
+ ' OriginalPcd = PcdGetPtr (%s, %s, %s, %s, &OriginalSize);\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2090 # Determine the size of the PCD. For simple structures, sizeof(TYPE) provides
2091 # the correct value. For structures with a flexible array member, the flexible
2092 # array member is detected, and the size is based on the highest index used with
2093 # the flexible array member. The flexible array member must be the last field
2094 # in a structure. The size formula for this case is:
2095 # OFFSET_OF(FlexbleArrayField) + sizeof(FlexibleArray[0]) * (HighestIndex + 1)
2097 CApp
= CApp
+ DscBuildData
.GenerateSizeStatments(Pcd
)
2100 # Allocate and zero buffer for the PCD
2101 # Must handle cases where current value is smaller, larger, or same size
2102 # Always keep that larger one as the current size
2104 CApp
= CApp
+ ' Size = (OriginalSize > Size ? OriginalSize : Size);\n'
2105 CApp
= CApp
+ ' Pcd = (%s *)malloc (Size);\n' % (Pcd
.DatumType
)
2106 CApp
= CApp
+ ' memset (Pcd, 0, Size);\n'
2109 # Copy current PCD value into allocated buffer.
2111 CApp
= CApp
+ ' memcpy (Pcd, OriginalPcd, OriginalSize);\n'
2114 # Assign field values in PCD
2116 CApp
= CApp
+ DscBuildData
.GenerateDefaultValueAssignStatement(Pcd
)
2117 if Pcd
.Type
not in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
2118 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
2119 for skuname
in self
.SkuIdMgr
.GetSkuChain(SkuName
):
2120 storeset
= [DefaultStoreName
] if DefaultStoreName
== TAB_DEFAULT_STORES_DEFAULT
else [TAB_DEFAULT_STORES_DEFAULT
, DefaultStoreName
]
2121 for defaultstorenameitem
in storeset
:
2122 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: %s \n" % (skuname
, defaultstorenameitem
)
2123 CApp
= CApp
+ DscBuildData
.GenerateInitValueStatement(Pcd
, skuname
, defaultstorenameitem
)
2124 if skuname
== SkuName
:
2127 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: STANDARD \n" % self
.SkuIdMgr
.SystemSkuId
2128 CApp
= CApp
+ DscBuildData
.GenerateInitValueStatement(Pcd
, self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
)
2129 CApp
= CApp
+ DscBuildData
.GenerateFdfValueStatement(Pcd
)
2130 CApp
= CApp
+ DscBuildData
.GenerateCommandLineValueStatement(Pcd
)
2132 # Set new PCD value and size
2134 CApp
= CApp
+ ' PcdSetPtr (%s, %s, %s, %s, Size, (UINT8 *)Pcd);\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2139 CApp
= CApp
+ ' free (Pcd);\n'
2142 return InitByteValue
, CApp
2143 def SkuOverrideValuesEmpty(self
,OverrideValues
):
2144 if not OverrideValues
:
2146 for key
in OverrideValues
:
2147 if OverrideValues
[key
]:
2151 def GenerateByteArrayValue (self
, StructuredPcds
):
2153 # Generate/Compile/Run C application to determine if there are any flexible array members
2155 if not StructuredPcds
:
2159 CApp
= PcdMainCHeader
2161 IncludeFiles
= set()
2162 for PcdName
in StructuredPcds
:
2163 Pcd
= StructuredPcds
[PcdName
]
2164 for IncludeFile
in Pcd
.StructuredPcdIncludeFile
:
2165 if IncludeFile
not in IncludeFiles
:
2166 IncludeFiles
.add(IncludeFile
)
2167 CApp
= CApp
+ '#include <%s>\n' % (IncludeFile
)
2169 for PcdName
in StructuredPcds
:
2170 Pcd
= StructuredPcds
[PcdName
]
2171 CApp
= CApp
+ self
.GenerateSizeFunction(Pcd
)
2172 CApp
= CApp
+ self
.GenerateDefaultValueAssignFunction(Pcd
)
2173 CApp
= CApp
+ self
.GenerateFdfValue(Pcd
)
2174 CApp
= CApp
+ self
.GenerateCommandLineValue(Pcd
)
2175 if self
.SkuOverrideValuesEmpty(Pcd
.SkuOverrideValues
) or Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
2176 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
2177 CApp
= CApp
+ self
.GenerateInitValueFunction(Pcd
, self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
)
2179 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
2180 if SkuName
not in Pcd
.SkuOverrideValues
:
2182 for DefaultStoreName
in Pcd
.SkuOverrideValues
[SkuName
]:
2183 CApp
= CApp
+ self
.GenerateInitValueFunction(Pcd
, SkuName
, DefaultStoreName
)
2184 if self
.SkuOverrideValuesEmpty(Pcd
.SkuOverrideValues
) or Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
2185 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
2186 InitByteValue
, CApp
= self
.GenerateInitializeFunc(self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
, Pcd
, InitByteValue
, CApp
)
2188 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
2189 if SkuName
not in Pcd
.SkuOverrideValues
:
2191 for DefaultStoreName
in Pcd
.DefaultStoreName
:
2192 Pcd
= StructuredPcds
[PcdName
]
2193 InitByteValue
, CApp
= self
.GenerateInitializeFunc(SkuName
, DefaultStoreName
, Pcd
, InitByteValue
, CApp
)
2195 CApp
= CApp
+ 'VOID\n'
2196 CApp
= CApp
+ 'PcdEntryPoint(\n'
2197 CApp
= CApp
+ ' VOID\n'
2198 CApp
= CApp
+ ' )\n'
2200 for Pcd
in StructuredPcds
.values():
2201 if self
.SkuOverrideValuesEmpty(Pcd
.SkuOverrideValues
) or Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
2202 CApp
= CApp
+ ' Initialize_%s_%s_%s_%s();\n' % (self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2204 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
2205 if SkuName
not in self
.SkuIdMgr
.AvailableSkuIdSet
:
2207 for DefaultStoreName
in Pcd
.SkuOverrideValues
[SkuName
]:
2208 CApp
= CApp
+ ' Initialize_%s_%s_%s_%s();\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2211 CApp
= CApp
+ PcdMainCEntry
+ '\n'
2213 if not os
.path
.exists(self
.OutputPath
):
2214 os
.makedirs(self
.OutputPath
)
2215 CAppBaseFileName
= os
.path
.join(self
.OutputPath
, PcdValueInitName
)
2216 SaveFileOnChange(CAppBaseFileName
+ '.c', CApp
, False)
2218 MakeApp
= PcdMakefileHeader
2219 if sys
.platform
== "win32":
2220 MakeApp
= MakeApp
+ 'APPNAME = %s\n' % (PcdValueInitName
) + 'OBJECTS = %s\%s.obj\n' % (self
.OutputPath
, PcdValueInitName
) + 'INC = '
2222 MakeApp
= MakeApp
+ PcdGccMakefile
2223 MakeApp
= MakeApp
+ 'APPNAME = %s\n' % (PcdValueInitName
) + 'OBJECTS = %s/%s.o\n' % (self
.OutputPath
, PcdValueInitName
) + \
2224 'include $(MAKEROOT)/Makefiles/app.makefile\n' + 'INCLUDE +='
2227 PlatformInc
= OrderedDict()
2228 for Cache
in self
._Bdb
._CACHE
_.values():
2229 if Cache
.MetaFile
.Ext
.lower() != '.dec':
2232 if str(Cache
.MetaFile
.Path
) not in PlatformInc
:
2233 PlatformInc
[str(Cache
.MetaFile
.Path
)] = []
2234 PlatformInc
[str(Cache
.MetaFile
.Path
)].append (os
.path
.dirname(Cache
.MetaFile
.Path
))
2235 PlatformInc
[str(Cache
.MetaFile
.Path
)].extend (Cache
.CommonIncludes
)
2238 for Pcd
in StructuredPcds
.values():
2239 for PackageDec
in Pcd
.PackageDecs
:
2240 Package
= os
.path
.normpath(mws
.join(GlobalData
.gWorkspace
, PackageDec
))
2241 if not os
.path
.exists(Package
):
2242 EdkLogger
.error('Build', RESOURCE_NOT_AVAILABLE
, "The dependent Package %s of PCD %s.%s is not exist." % (PackageDec
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
))
2243 if Package
not in PcdDependDEC
:
2244 PcdDependDEC
.append(Package
)
2246 if PlatformInc
and PcdDependDEC
:
2247 for pkg
in PcdDependDEC
:
2248 if pkg
in PlatformInc
:
2249 for inc
in PlatformInc
[pkg
]:
2250 MakeApp
+= '-I' + str(inc
) + ' '
2251 IncSearchList
.append(inc
)
2252 MakeApp
= MakeApp
+ '\n'
2254 CC_FLAGS
= LinuxCFLAGS
2255 if sys
.platform
== "win32":
2256 CC_FLAGS
= WindowsCFLAGS
2257 BuildOptions
= OrderedDict()
2258 for Options
in self
.BuildOptions
:
2259 if Options
[2] != EDKII_NAME
:
2262 if Family
and Family
!= self
.ToolChainFamily
:
2264 Target
, Tag
, Arch
, Tool
, Attr
= Options
[1].split("_")
2268 if Target
== "*" or Target
== self
._Target
:
2269 if Tag
== "*" or Tag
== self
._Toolchain
:
2270 if Arch
== "*" or Arch
== self
.Arch
:
2271 if Tool
not in BuildOptions
:
2272 BuildOptions
[Tool
] = OrderedDict()
2273 if Attr
!= "FLAGS" or Attr
not in BuildOptions
[Tool
] or self
.BuildOptions
[Options
].startswith('='):
2274 BuildOptions
[Tool
][Attr
] = self
.BuildOptions
[Options
]
2276 # append options for the same tool except PATH
2278 BuildOptions
[Tool
][Attr
] += " " + self
.BuildOptions
[Options
]
2280 BuildOptions
[Tool
][Attr
] = self
.BuildOptions
[Options
]
2282 for Tool
in BuildOptions
:
2283 for Attr
in BuildOptions
[Tool
]:
2285 Value
= BuildOptions
[Tool
][Attr
]
2286 ValueList
= Value
.split()
2288 for Id
, Item
in enumerate(ValueList
):
2289 if Item
in ['-D', '/D', '-U', '/U']:
2290 CC_FLAGS
+= ' ' + Item
2291 if Id
+ 1 < len(ValueList
):
2292 CC_FLAGS
+= ' ' + ValueList
[Id
+ 1]
2293 elif Item
.startswith(('-D', '/D', '-U', '/U')):
2294 CC_FLAGS
+= ' ' + Item
2297 if sys
.platform
== "win32":
2298 MakeApp
= MakeApp
+ PcdMakefileEnd
2299 MakeApp
= MakeApp
+ '\n'
2300 IncludeFileFullPaths
= []
2301 for includefile
in IncludeFiles
:
2302 for includepath
in IncSearchList
:
2303 includefullpath
= os
.path
.join(str(includepath
), includefile
)
2304 if os
.path
.exists(includefullpath
):
2305 IncludeFileFullPaths
.append(os
.path
.normpath(includefullpath
))
2308 SearchPathList
.append(os
.path
.normpath(mws
.join(GlobalData
.gWorkspace
, "BaseTools/Source/C/Include")))
2309 SearchPathList
.append(os
.path
.normpath(mws
.join(GlobalData
.gWorkspace
, "BaseTools/Source/C/Common")))
2310 SearchPathList
.extend(str(item
) for item
in IncSearchList
)
2311 IncFileList
= GetDependencyList(IncludeFileFullPaths
, SearchPathList
)
2312 for include_file
in IncFileList
:
2313 MakeApp
+= "$(OBJECTS) : %s\n" % include_file
2314 MakeFileName
= os
.path
.join(self
.OutputPath
, 'Makefile')
2315 MakeApp
+= "$(OBJECTS) : %s\n" % MakeFileName
2316 SaveFileOnChange(MakeFileName
, MakeApp
, False)
2318 InputValueFile
= os
.path
.join(self
.OutputPath
, 'Input.txt')
2319 OutputValueFile
= os
.path
.join(self
.OutputPath
, 'Output.txt')
2320 SaveFileOnChange(InputValueFile
, InitByteValue
, False)
2322 PcdValueInitExe
= PcdValueInitName
2323 if not sys
.platform
== "win32":
2324 PcdValueInitExe
= os
.path
.join(os
.getenv("EDK_TOOLS_PATH"), 'Source', 'C', 'bin', PcdValueInitName
)
2326 PcdValueInitExe
= os
.path
.join(os
.getenv("EDK_TOOLS_PATH"), 'Bin', 'Win32', PcdValueInitName
) +".exe"
2329 if sys
.platform
== "win32":
2330 MakeCommand
= 'nmake -f %s' % (MakeFileName
)
2331 returncode
, StdOut
, StdErr
= DscBuildData
.ExecuteCommand (MakeCommand
)
2334 MakeCommand
= 'make -f %s' % (MakeFileName
)
2335 returncode
, StdOut
, StdErr
= DscBuildData
.ExecuteCommand (MakeCommand
)
2337 Messages
= Messages
.split('\n')
2340 CAppBaseFileName
= os
.path
.join(self
.OutputPath
, PcdValueInitName
)
2341 File
= open (CAppBaseFileName
+ '.c', 'r')
2342 FileData
= File
.readlines()
2344 for Message
in Messages
:
2345 if " error" in Message
or "warning" in Message
:
2346 FileInfo
= Message
.strip().split('(')
2347 if len (FileInfo
) > 1:
2348 FileName
= FileInfo
[0]
2349 FileLine
= FileInfo
[1].split (')')[0]
2351 FileInfo
= Message
.strip().split(':')
2352 FileName
= FileInfo
[0]
2353 FileLine
= FileInfo
[1]
2354 if FileLine
.isdigit():
2355 error_line
= FileData
[int (FileLine
) - 1]
2356 if r
"//" in error_line
:
2357 c_line
, dsc_line
= error_line
.split(r
"//")
2359 dsc_line
= error_line
2360 message_itmes
= Message
.split(":")
2362 if "PcdValueInit.c" not in Message
:
2363 if not MessageGroup
:
2364 MessageGroup
.append(Message
)
2367 for item
in message_itmes
:
2368 if "PcdValueInit.c" in item
:
2369 Index
= message_itmes
.index(item
)
2370 message_itmes
[Index
] = dsc_line
.strip()
2372 MessageGroup
.append(":".join(message_itmes
[Index
:]).strip())
2375 MessageGroup
.append(Message
)
2377 EdkLogger
.error("build", PCD_STRUCTURE_PCD_ERROR
, "\n".join(MessageGroup
) )
2379 EdkLogger
.error('Build', COMMAND_FAILURE
, 'Can not execute command: %s' % MakeCommand
)
2381 if DscBuildData
.NeedUpdateOutput(OutputValueFile
, PcdValueInitExe
, InputValueFile
):
2382 Command
= PcdValueInitExe
+ ' -i %s -o %s' % (InputValueFile
, OutputValueFile
)
2383 returncode
, StdOut
, StdErr
= DscBuildData
.ExecuteCommand (Command
)
2385 EdkLogger
.warn('Build', COMMAND_FAILURE
, 'Can not collect output from command: %s' % Command
)
2387 File
= open (OutputValueFile
, 'r')
2388 FileBuffer
= File
.readlines()
2391 StructurePcdSet
= []
2392 for Pcd
in FileBuffer
:
2393 PcdValue
= Pcd
.split ('|')
2394 PcdInfo
= PcdValue
[0].split ('.')
2395 StructurePcdSet
.append((PcdInfo
[0], PcdInfo
[1], PcdInfo
[2], PcdInfo
[3], PcdValue
[2].strip()))
2396 return StructurePcdSet
2399 def NeedUpdateOutput(OutputFile
, ValueCFile
, StructureInput
):
2400 if not os
.path
.exists(OutputFile
):
2402 if os
.stat(OutputFile
).st_mtime
<= os
.stat(ValueCFile
).st_mtime
:
2404 if os
.stat(OutputFile
).st_mtime
<= os
.stat(StructureInput
).st_mtime
:
2408 ## Retrieve dynamic PCD settings
2410 # @param Type PCD type
2412 # @retval a dict object contains settings of given PCD type
2414 def _GetDynamicPcd(self
, Type
):
2417 Pcds
= OrderedDict()
2419 # tdict is a special dict kind of type, used for selecting correct
2420 # PCD settings for certain ARCH and SKU
2422 PcdDict
= tdict(True, 4)
2424 # Find out all possible PCD candidates for self._Arch
2425 RecordList
= self
._RawData
[Type
, self
._Arch
]
2426 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
2429 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
2430 SkuName
= SkuName
.upper()
2431 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
2432 if SkuName
not in AvailableSkuIdSet
:
2433 EdkLogger
.error('build', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
2434 File
=self
.MetaFile
, Line
=Dummy5
)
2435 if "." not in TokenSpaceGuid
:
2436 PcdList
.append((PcdCName
, TokenSpaceGuid
, SkuName
, Dummy5
))
2437 PcdDict
[Arch
, SkuName
, PcdCName
, TokenSpaceGuid
] = Setting
2439 # Remove redundant PCD candidates, per the ARCH and SKU
2440 for PcdCName
, TokenSpaceGuid
, SkuName
, Dummy4
in PcdList
:
2442 Setting
= PcdDict
[self
._Arch
, SkuName
, PcdCName
, TokenSpaceGuid
]
2446 PcdValue
, DatumType
, MaxDatumSize
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
2448 if int(MaxDatumSize
, 0) > 0xFFFF:
2449 EdkLogger
.error('build', FORMAT_INVALID
, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2450 File
=self
.MetaFile
, Line
=Dummy4
)
2451 if int(MaxDatumSize
, 0) < 0:
2452 EdkLogger
.error('build', FORMAT_INVALID
, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2453 File
=self
.MetaFile
, Line
=Dummy4
)
2454 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], '', '', '', '', '', PcdValue
)
2455 if (PcdCName
, TokenSpaceGuid
) in Pcds
:
2456 pcdObject
= Pcds
[PcdCName
, TokenSpaceGuid
]
2457 pcdObject
.SkuInfoList
[SkuName
] = SkuInfo
2458 if MaxDatumSize
.strip():
2459 CurrentMaxSize
= int(MaxDatumSize
.strip(), 0)
2462 if pcdObject
.MaxDatumSize
:
2463 PcdMaxSize
= int(pcdObject
.MaxDatumSize
, 0)
2466 if CurrentMaxSize
> PcdMaxSize
:
2467 pcdObject
.MaxDatumSize
= str(CurrentMaxSize
)
2469 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
2472 self
._PCD
_TYPE
_STRING
_[Type
],
2477 OrderedDict({SkuName
: SkuInfo
}),
2482 if SkuName
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
2483 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
] = {}
2484 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
][TAB_DEFAULT_STORES_DEFAULT
] = PcdValue
2486 for pcd
in Pcds
.values():
2487 pcdDecObject
= self
._DecPcds
[pcd
.TokenCName
, pcd
.TokenSpaceGuidCName
]
2488 # Only fix the value while no value provided in DSC file.
2489 for sku
in pcd
.SkuInfoList
.values():
2490 if not sku
.DefaultValue
:
2491 sku
.DefaultValue
= pcdDecObject
.DefaultValue
2492 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
not in pcd
.SkuInfoList
:
2493 valuefromDec
= pcdDecObject
.DefaultValue
2494 SkuInfo
= SkuInfoClass(TAB_DEFAULT
, '0', '', '', '', '', '', valuefromDec
)
2495 pcd
.SkuInfoList
[TAB_DEFAULT
] = SkuInfo
2496 elif TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2497 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
2498 del pcd
.SkuInfoList
[TAB_COMMON
]
2499 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2500 del pcd
.SkuInfoList
[TAB_COMMON
]
2502 map(self
.FilterSkuSettings
, Pcds
.values())
2506 def FilterSkuSettings(self
, PcdObj
):
2508 if self
.SkuIdMgr
.SkuUsageType
== self
.SkuIdMgr
.SINGLE
:
2509 if TAB_DEFAULT
in PcdObj
.SkuInfoList
and self
.SkuIdMgr
.SystemSkuId
not in PcdObj
.SkuInfoList
:
2510 PcdObj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
] = PcdObj
.SkuInfoList
[TAB_DEFAULT
]
2511 PcdObj
.SkuInfoList
= {TAB_DEFAULT
:PcdObj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
]}
2512 PcdObj
.SkuInfoList
[TAB_DEFAULT
].SkuIdName
= TAB_DEFAULT
2513 PcdObj
.SkuInfoList
[TAB_DEFAULT
].SkuId
= '0'
2515 elif self
.SkuIdMgr
.SkuUsageType
== self
.SkuIdMgr
.DEFAULT
:
2516 PcdObj
.SkuInfoList
= {TAB_DEFAULT
:PcdObj
.SkuInfoList
[TAB_DEFAULT
]}
2521 def CompareVarAttr(Attr1
, Attr2
):
2522 if not Attr1
or not Attr2
: # for empty string
2524 Attr1s
= [attr
.strip() for attr
in Attr1
.split(",")]
2525 Attr1Set
= set(Attr1s
)
2526 Attr2s
= [attr
.strip() for attr
in Attr2
.split(",")]
2527 Attr2Set
= set(Attr2s
)
2528 if Attr2Set
== Attr1Set
:
2533 def CompletePcdValues(self
, PcdSet
):
2534 Pcds
= OrderedDict()
2535 DefaultStoreObj
= DefaultStore(self
._GetDefaultStores
())
2536 SkuIds
= {skuname
:skuid
for skuname
, skuid
in self
.SkuIdMgr
.AvailableSkuIdSet
.items() if skuname
!= TAB_COMMON
}
2537 DefaultStores
= set(storename
for pcdobj
in PcdSet
.values() for skuobj
in pcdobj
.SkuInfoList
.values() for storename
in skuobj
.DefaultStoreDict
)
2538 for PcdCName
, TokenSpaceGuid
in PcdSet
:
2539 PcdObj
= PcdSet
[(PcdCName
, TokenSpaceGuid
)]
2541 if PcdObj
.Type
not in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_DEFAULT
],
2542 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
2543 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_VPD
],
2544 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_DEFAULT
],
2545 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
],
2546 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_VPD
]]:
2547 Pcds
[PcdCName
, TokenSpaceGuid
]= PcdObj
2549 PcdType
= PcdObj
.Type
2550 if PcdType
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
2551 for skuid
in PcdObj
.SkuInfoList
:
2552 skuobj
= PcdObj
.SkuInfoList
[skuid
]
2553 mindefaultstorename
= DefaultStoreObj
.GetMin(set(defaultstorename
for defaultstorename
in skuobj
.DefaultStoreDict
))
2554 for defaultstorename
in DefaultStores
:
2555 if defaultstorename
not in skuobj
.DefaultStoreDict
:
2556 skuobj
.DefaultStoreDict
[defaultstorename
] = copy
.deepcopy(skuobj
.DefaultStoreDict
[mindefaultstorename
])
2557 skuobj
.HiiDefaultValue
= skuobj
.DefaultStoreDict
[mindefaultstorename
]
2558 for skuname
, skuid
in SkuIds
.items():
2559 if skuname
not in PcdObj
.SkuInfoList
:
2560 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(skuname
)
2561 while nextskuid
not in PcdObj
.SkuInfoList
:
2562 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
2563 PcdObj
.SkuInfoList
[skuname
] = copy
.deepcopy(PcdObj
.SkuInfoList
[nextskuid
])
2564 PcdObj
.SkuInfoList
[skuname
].SkuId
= skuid
2565 PcdObj
.SkuInfoList
[skuname
].SkuIdName
= skuname
2566 if PcdType
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
2567 PcdObj
.DefaultValue
= PcdObj
.SkuInfoList
.values()[0].HiiDefaultValue
if self
.SkuIdMgr
.SkuUsageType
== self
.SkuIdMgr
.SINGLE
else PcdObj
.SkuInfoList
[TAB_DEFAULT
].HiiDefaultValue
2568 Pcds
[PcdCName
, TokenSpaceGuid
]= PcdObj
2570 ## Retrieve dynamic HII PCD settings
2572 # @param Type PCD type
2574 # @retval a dict object contains settings of given PCD type
2576 def _GetDynamicHiiPcd(self
, Type
):
2580 Pcds
= OrderedDict()
2581 UserDefinedDefaultStores
= []
2583 # tdict is a special dict kind of type, used for selecting correct
2584 # PCD settings for certain ARCH and SKU
2586 PcdDict
= tdict(True, 5)
2588 RecordList
= self
._RawData
[Type
, self
._Arch
]
2589 # Find out all possible PCD candidates for self._Arch
2590 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
2591 DefaultStoresDefine
= self
._GetDefaultStores
()
2593 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, DefaultStore
, Dummy4
, Dummy5
in RecordList
:
2594 SkuName
= SkuName
.upper()
2595 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
2596 DefaultStore
= DefaultStore
.upper()
2597 if DefaultStore
== TAB_COMMON
:
2598 DefaultStore
= TAB_DEFAULT_STORES_DEFAULT
2600 #The end user define [DefaultStores] and [SKUID_IDENTIFIER.Menufacturing] in DSC
2601 UserDefinedDefaultStores
.append((PcdCName
, TokenSpaceGuid
))
2602 if SkuName
not in AvailableSkuIdSet
:
2603 EdkLogger
.error('build', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
2604 File
=self
.MetaFile
, Line
=Dummy5
)
2605 if DefaultStore
not in DefaultStoresDefine
:
2606 EdkLogger
.error('build', PARAMETER_INVALID
, 'DefaultStores %s is not defined in [DefaultStores] section' % DefaultStore
,
2607 File
=self
.MetaFile
, Line
=Dummy5
)
2608 if "." not in TokenSpaceGuid
:
2609 PcdSet
.add((PcdCName
, TokenSpaceGuid
, SkuName
, DefaultStore
, Dummy5
))
2610 PcdDict
[Arch
, SkuName
, PcdCName
, TokenSpaceGuid
, DefaultStore
] = Setting
2613 # Remove redundant PCD candidates, per the ARCH and SKU
2614 for PcdCName
, TokenSpaceGuid
, SkuName
, DefaultStore
, Dummy4
in PcdSet
:
2616 Setting
= PcdDict
[self
._Arch
, SkuName
, PcdCName
, TokenSpaceGuid
, DefaultStore
]
2619 VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VarAttribute
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
2621 rt
, Msg
= VariableAttributes
.ValidateVarAttributes(VarAttribute
)
2623 EdkLogger
.error("build", PCD_VARIABLE_ATTRIBUTES_ERROR
, "Variable attributes settings for %s is incorrect.\n %s" % (".".join((TokenSpaceGuid
, PcdCName
)), Msg
),
2624 ExtraData
="[%s]" % VarAttribute
)
2626 FormatCorrect
= True
2627 if VariableOffset
.isdigit():
2628 if int(VariableOffset
, 10) > 0xFFFF:
2630 elif variablePattern
.match(VariableOffset
):
2631 if int(VariableOffset
, 16) > 0xFFFF:
2633 # For Offset written in "A.B"
2634 elif VariableOffset
.find('.') > -1:
2635 VariableOffsetList
= VariableOffset
.split(".")
2636 if not (len(VariableOffsetList
) == 2
2637 and IsValidWord(VariableOffsetList
[0])
2638 and IsValidWord(VariableOffsetList
[1])):
2639 FormatCorrect
= False
2641 FormatCorrect
= False
2642 if not FormatCorrect
:
2643 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid
, PcdCName
)))
2646 EdkLogger
.error('Build', OPTION_VALUE_INVALID
, "The variable offset value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)))
2647 if (VariableName
, VariableGuid
) not in VariableAttrs
:
2648 VariableAttrs
[(VariableName
, VariableGuid
)] = VarAttribute
2650 if not DscBuildData
.CompareVarAttr(VariableAttrs
[(VariableName
, VariableGuid
)], VarAttribute
):
2651 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
)]))
2653 pcdDecObject
= self
._DecPcds
[PcdCName
, TokenSpaceGuid
]
2654 if (PcdCName
, TokenSpaceGuid
) in Pcds
:
2655 pcdObject
= Pcds
[PcdCName
, TokenSpaceGuid
]
2656 if SkuName
in pcdObject
.SkuInfoList
:
2657 Skuitem
= pcdObject
.SkuInfoList
[SkuName
]
2658 Skuitem
.DefaultStoreDict
.update({DefaultStore
:DefaultValue
})
2660 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VariableAttribute
=VarAttribute
, DefaultStore
={DefaultStore
:DefaultValue
})
2661 pcdObject
.SkuInfoList
[SkuName
] = SkuInfo
2663 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VariableAttribute
=VarAttribute
, DefaultStore
={DefaultStore
:DefaultValue
})
2664 PcdClassObj
= PcdClassObject(
2667 self
._PCD
_TYPE
_STRING
_[Type
],
2672 OrderedDict({SkuName
: SkuInfo
}),
2675 pcdDecObject
.validateranges
,
2676 pcdDecObject
.validlists
,
2677 pcdDecObject
.expressions
,
2679 if (PcdCName
, TokenSpaceGuid
) in UserDefinedDefaultStores
:
2680 PcdClassObj
.UserDefinedDefaultStoresFlag
= True
2681 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObj
2683 if SkuName
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
2684 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
] = {}
2685 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
][DefaultStore
] = DefaultValue
2686 for pcd
in Pcds
.values():
2687 SkuInfoObj
= pcd
.SkuInfoList
.values()[0]
2688 pcdDecObject
= self
._DecPcds
[pcd
.TokenCName
, pcd
.TokenSpaceGuidCName
]
2689 pcd
.DatumType
= pcdDecObject
.DatumType
2690 # Only fix the value while no value provided in DSC file.
2691 for sku
in pcd
.SkuInfoList
.values():
2692 if (sku
.HiiDefaultValue
== "" or sku
.HiiDefaultValue
is None):
2693 sku
.HiiDefaultValue
= pcdDecObject
.DefaultValue
2694 for default_store
in sku
.DefaultStoreDict
:
2695 sku
.DefaultStoreDict
[default_store
]=pcdDecObject
.DefaultValue
2696 pcd
.DefaultValue
= pcdDecObject
.DefaultValue
2697 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
not in pcd
.SkuInfoList
:
2698 valuefromDec
= pcdDecObject
.DefaultValue
2699 SkuInfo
= SkuInfoClass(TAB_DEFAULT
, '0', SkuInfoObj
.VariableName
, SkuInfoObj
.VariableGuid
, SkuInfoObj
.VariableOffset
, valuefromDec
, VariableAttribute
=SkuInfoObj
.VariableAttribute
, DefaultStore
={DefaultStore
:valuefromDec
})
2700 pcd
.SkuInfoList
[TAB_DEFAULT
] = SkuInfo
2701 elif TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2702 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
2703 del pcd
.SkuInfoList
[TAB_COMMON
]
2704 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2705 del pcd
.SkuInfoList
[TAB_COMMON
]
2707 if pcd
.MaxDatumSize
.strip():
2708 MaxSize
= int(pcd
.MaxDatumSize
, 0)
2711 if pcd
.DatumType
not in TAB_PCD_NUMERIC_TYPES
:
2712 for (_
, skuobj
) in pcd
.SkuInfoList
.items():
2714 skuobj
.HiiDefaultValue
= StringToArray(skuobj
.HiiDefaultValue
)
2715 datalen
= len(skuobj
.HiiDefaultValue
.split(","))
2716 if datalen
> MaxSize
:
2718 for defaultst
in skuobj
.DefaultStoreDict
:
2719 skuobj
.DefaultStoreDict
[defaultst
] = StringToArray(skuobj
.DefaultStoreDict
[defaultst
])
2720 pcd
.DefaultValue
= StringToArray(pcd
.DefaultValue
)
2721 pcd
.MaxDatumSize
= str(MaxSize
)
2722 rt
, invalidhii
= DscBuildData
.CheckVariableNameAssignment(Pcds
)
2724 invalidpcd
= ",".join(invalidhii
)
2725 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
)
2727 map(self
.FilterSkuSettings
, Pcds
.values())
2732 def CheckVariableNameAssignment(Pcds
):
2734 for pcdname
in Pcds
:
2736 varnameset
= set(sku
.VariableName
for (skuid
, sku
) in pcd
.SkuInfoList
.items())
2737 if len(varnameset
) > 1:
2738 invalidhii
.append(".".join((pcdname
[1], pcdname
[0])))
2740 return False, invalidhii
2743 ## Retrieve dynamic VPD PCD settings
2745 # @param Type PCD type
2747 # @retval a dict object contains settings of given PCD type
2749 def _GetDynamicVpdPcd(self
, Type
):
2752 Pcds
= OrderedDict()
2754 # tdict is a special dict kind of type, used for selecting correct
2755 # PCD settings for certain ARCH and SKU
2757 PcdDict
= tdict(True, 4)
2760 # Find out all possible PCD candidates for self._Arch
2761 RecordList
= self
._RawData
[Type
, self
._Arch
]
2762 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
2764 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
2765 SkuName
= SkuName
.upper()
2766 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
2767 if SkuName
not in AvailableSkuIdSet
:
2768 EdkLogger
.error('build', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
2769 File
=self
.MetaFile
, Line
=Dummy5
)
2770 if "." not in TokenSpaceGuid
:
2771 PcdList
.append((PcdCName
, TokenSpaceGuid
, SkuName
, Dummy5
))
2772 PcdDict
[Arch
, SkuName
, PcdCName
, TokenSpaceGuid
] = Setting
2774 # Remove redundant PCD candidates, per the ARCH and SKU
2775 for PcdCName
, TokenSpaceGuid
, SkuName
, Dummy4
in PcdList
:
2776 Setting
= PcdDict
[self
._Arch
, SkuName
, PcdCName
, TokenSpaceGuid
]
2780 # For the VOID* type, it can have optional data of MaxDatumSize and InitialValue
2781 # For the Integer & Boolean type, the optional data can only be InitialValue.
2782 # At this point, we put all the data into the PcdClssObject for we don't know the PCD's datumtype
2783 # until the DEC parser has been called.
2785 VpdOffset
, MaxDatumSize
, InitialValue
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
2787 if int(MaxDatumSize
, 0) > 0xFFFF:
2788 EdkLogger
.error('build', FORMAT_INVALID
, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2789 File
=self
.MetaFile
, Line
=Dummy4
)
2790 if int(MaxDatumSize
, 0) < 0:
2791 EdkLogger
.error('build', FORMAT_INVALID
, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2792 File
=self
.MetaFile
, Line
=Dummy4
)
2793 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], '', '', '', '', VpdOffset
, InitialValue
)
2794 if (PcdCName
, TokenSpaceGuid
) in Pcds
:
2795 pcdObject
= Pcds
[PcdCName
, TokenSpaceGuid
]
2796 pcdObject
.SkuInfoList
[SkuName
] = SkuInfo
2797 if MaxDatumSize
.strip():
2798 CurrentMaxSize
= int(MaxDatumSize
.strip(), 0)
2801 if pcdObject
.MaxDatumSize
:
2802 PcdMaxSize
= int(pcdObject
.MaxDatumSize
, 0)
2805 if CurrentMaxSize
> PcdMaxSize
:
2806 pcdObject
.MaxDatumSize
= str(CurrentMaxSize
)
2808 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
2811 self
._PCD
_TYPE
_STRING
_[Type
],
2816 OrderedDict({SkuName
: SkuInfo
}),
2821 if SkuName
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
2822 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
] = {}
2823 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
][TAB_DEFAULT_STORES_DEFAULT
] = InitialValue
2824 for pcd
in Pcds
.values():
2825 SkuInfoObj
= pcd
.SkuInfoList
.values()[0]
2826 pcdDecObject
= self
._DecPcds
[pcd
.TokenCName
, pcd
.TokenSpaceGuidCName
]
2827 pcd
.DatumType
= pcdDecObject
.DatumType
2828 # Only fix the value while no value provided in DSC file.
2829 for sku
in pcd
.SkuInfoList
.values():
2830 if not sku
.DefaultValue
:
2831 sku
.DefaultValue
= pcdDecObject
.DefaultValue
2832 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
not in pcd
.SkuInfoList
:
2833 valuefromDec
= pcdDecObject
.DefaultValue
2834 SkuInfo
= SkuInfoClass(TAB_DEFAULT
, '0', '', '', '', '', SkuInfoObj
.VpdOffset
, valuefromDec
)
2835 pcd
.SkuInfoList
[TAB_DEFAULT
] = SkuInfo
2836 elif TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2837 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
2838 del pcd
.SkuInfoList
[TAB_COMMON
]
2839 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2840 del pcd
.SkuInfoList
[TAB_COMMON
]
2843 map(self
.FilterSkuSettings
, Pcds
.values())
2846 ## Add external modules
2848 # The external modules are mostly those listed in FDF file, which don't
2851 # @param FilePath The path of module description file
2853 def AddModule(self
, FilePath
):
2854 FilePath
= NormPath(FilePath
)
2855 if FilePath
not in self
.Modules
:
2856 Module
= ModuleBuildClassObject()
2857 Module
.MetaFile
= FilePath
2858 self
.Modules
.append(Module
)
2861 def ToolChainFamily(self
):
2862 self
._ToolChainFamily
= TAB_COMPILER_MSFT
2863 BuildConfigurationFile
= os
.path
.normpath(os
.path
.join(GlobalData
.gConfDirectory
, "target.txt"))
2864 if os
.path
.isfile(BuildConfigurationFile
) == True:
2865 TargetTxt
= TargetTxtClassObject()
2866 TargetTxt
.LoadTargetTxtFile(BuildConfigurationFile
)
2867 ToolDefinitionFile
= TargetTxt
.TargetTxtDictionary
[DataType
.TAB_TAT_DEFINES_TOOL_CHAIN_CONF
]
2868 if ToolDefinitionFile
== '':
2869 ToolDefinitionFile
= "tools_def.txt"
2870 ToolDefinitionFile
= os
.path
.normpath(mws
.join(self
.WorkspaceDir
, 'Conf', ToolDefinitionFile
))
2871 if os
.path
.isfile(ToolDefinitionFile
) == True:
2872 ToolDef
= ToolDefClassObject()
2873 ToolDef
.LoadToolDefFile(ToolDefinitionFile
)
2874 ToolDefinition
= ToolDef
.ToolsDefTxtDatabase
2875 if TAB_TOD_DEFINES_FAMILY
not in ToolDefinition \
2876 or self
._Toolchain
not in ToolDefinition
[TAB_TOD_DEFINES_FAMILY
] \
2877 or not ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][self
._Toolchain
]:
2878 self
._ToolChainFamily
= TAB_COMPILER_MSFT
2880 self
._ToolChainFamily
= ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][self
._Toolchain
]
2881 return self
._ToolChainFamily
2883 ## Add external PCDs
2885 # The external PCDs are mostly those listed in FDF file to specify address
2886 # or offset information.
2888 # @param Name Name of the PCD
2889 # @param Guid Token space guid of the PCD
2890 # @param Value Value of the PCD
2892 def AddPcd(self
, Name
, Guid
, Value
):
2893 if (Name
, Guid
) not in self
.Pcds
:
2894 self
.Pcds
[Name
, Guid
] = PcdClassObject(Name
, Guid
, '', '', '', '', '', {}, False, None)
2895 self
.Pcds
[Name
, Guid
].DefaultValue
= Value
2899 if self
._DecPcds
is None:
2901 if GlobalData
.gFdfParser
:
2902 FdfInfList
= GlobalData
.gFdfParser
.Profile
.InfList
2904 for Inf
in FdfInfList
:
2905 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
2906 if ModuleFile
in self
._Modules
:
2908 ModuleData
= self
._Bdb
[ModuleFile
, self
._Arch
, self
._Target
, self
._Toolchain
]
2909 PkgSet
.update(ModuleData
.Packages
)
2910 self
._DecPcds
, self
._GuidDict
= GetDeclaredPcd(self
, self
._Bdb
, self
._Arch
, self
._Target
, self
._Toolchain
, PkgSet
)
2911 return self
._DecPcds