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:
1291 if CheckStructureInComm(GlobalData
.BuildOptionPcd
):
1292 StructurePcdInCom
= {(item
[0], item
[1], item
[2] ):(item
[3], item
[4]) for item
in GlobalData
.BuildOptionPcd
} if GlobalData
.BuildOptionPcd
else {}
1293 NoFiledValues
= {(item
[0], item
[1]):StructurePcdInCom
[item
] for item
in StructurePcdInCom
if not item
[2]}
1295 NoFiledValues
= {(item
[0], item
[1]):[item
[2]] for item
in GlobalData
.BuildOptionPcd
}
1296 for Guid
, Name
in NoFiledValues
:
1297 if (Name
, Guid
) in AllPcds
:
1298 Pcd
= AllPcds
.get((Name
, Guid
))
1299 if isinstance(self
._DecPcds
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), None), StructurePcd
):
1300 self
._DecPcds
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)).PcdValueFromComm
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1302 Pcd
.PcdValueFromComm
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1303 Pcd
.DefaultValue
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1304 for sku
in Pcd
.SkuInfoList
:
1305 SkuInfo
= Pcd
.SkuInfoList
[sku
]
1306 if SkuInfo
.DefaultValue
:
1307 SkuInfo
.DefaultValue
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1309 SkuInfo
.HiiDefaultValue
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1310 for defaultstore
in SkuInfo
.DefaultStoreDict
:
1311 SkuInfo
.DefaultStoreDict
[defaultstore
] = NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1312 if Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
]]:
1313 if Pcd
.DatumType
== TAB_VOID
:
1314 if not Pcd
.MaxDatumSize
:
1315 Pcd
.MaxDatumSize
= '0'
1316 CurrentSize
= int(Pcd
.MaxDatumSize
, 16) if Pcd
.MaxDatumSize
.upper().startswith("0X") else int(Pcd
.MaxDatumSize
)
1317 OptionSize
= len((StringToArray(Pcd
.PcdValueFromComm
)).split(","))
1318 MaxSize
= max(CurrentSize
, OptionSize
)
1319 Pcd
.MaxDatumSize
= str(MaxSize
)
1321 PcdInDec
= self
.DecPcds
.get((Name
, Guid
))
1323 PcdInDec
.PcdValueFromComm
= NoFiledValues
[(Guid
, Name
)][0]
1324 if PcdInDec
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
1325 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
],
1326 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FEATURE_FLAG
],
1327 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC
],
1328 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX
]]:
1329 self
.Pcds
[Name
, Guid
] = copy
.deepcopy(PcdInDec
)
1330 self
.Pcds
[Name
, Guid
].DefaultValue
= NoFiledValues
[( Guid
, Name
)][0]
1331 if PcdInDec
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC
],
1332 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX
]]:
1333 self
.Pcds
[Name
, Guid
].SkuInfoList
= {TAB_DEFAULT
:SkuInfoClass(TAB_DEFAULT
, self
.SkuIds
[TAB_DEFAULT
][0], '', '', '', '', '', NoFiledValues
[( Guid
, Name
)][0])}
1336 def OverrideByFdfOverAll(self
,AllPcds
):
1338 if GlobalData
.gFdfParser
is None:
1340 NoFiledValues
= GlobalData
.gFdfParser
.Profile
.PcdDict
1341 for Name
,Guid
,Field
in NoFiledValues
:
1344 Value
= NoFiledValues
[(Name
,Guid
,Field
)]
1345 if (Name
,Guid
) in AllPcds
:
1346 Pcd
= AllPcds
.get((Name
,Guid
))
1347 if isinstance(self
._DecPcds
.get((Pcd
.TokenCName
,Pcd
.TokenSpaceGuidCName
), None),StructurePcd
):
1348 self
._DecPcds
.get((Pcd
.TokenCName
,Pcd
.TokenSpaceGuidCName
)).PcdValueFromComm
= Value
1350 Pcd
.PcdValueFromComm
= Value
1351 Pcd
.DefaultValue
= Value
1352 for sku
in Pcd
.SkuInfoList
:
1353 SkuInfo
= Pcd
.SkuInfoList
[sku
]
1354 if SkuInfo
.DefaultValue
:
1355 SkuInfo
.DefaultValue
= Value
1357 SkuInfo
.HiiDefaultValue
= Value
1358 for defaultstore
in SkuInfo
.DefaultStoreDict
:
1359 SkuInfo
.DefaultStoreDict
[defaultstore
] = Value
1360 if Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
]]:
1361 if Pcd
.DatumType
== TAB_VOID
:
1362 if not Pcd
.MaxDatumSize
:
1363 Pcd
.MaxDatumSize
= '0'
1364 CurrentSize
= int(Pcd
.MaxDatumSize
,16) if Pcd
.MaxDatumSize
.upper().startswith("0X") else int(Pcd
.MaxDatumSize
)
1365 OptionSize
= len((StringToArray(Pcd
.PcdValueFromComm
)).split(","))
1366 MaxSize
= max(CurrentSize
, OptionSize
)
1367 Pcd
.MaxDatumSize
= str(MaxSize
)
1369 PcdInDec
= self
.DecPcds
.get((Name
,Guid
))
1371 PcdInDec
.PcdValueFromFdf
= Value
1372 if PcdInDec
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
1373 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
],
1374 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FEATURE_FLAG
]]:
1375 self
.Pcds
[Name
, Guid
] = copy
.deepcopy(PcdInDec
)
1376 self
.Pcds
[Name
, Guid
].DefaultValue
= Value
1379 def UpdateStructuredPcds(self
, TypeList
, AllPcds
):
1381 DynamicPcdType
= [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_DEFAULT
],
1382 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
1383 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_VPD
],
1384 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_DEFAULT
],
1385 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
],
1386 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_VPD
]]
1389 DefaultStoreMgr
= DefaultStore(self
.DefaultStores
)
1390 SkuIds
= self
.SkuIds
1391 DefaultStores
= {storename
for pcdobj
in AllPcds
.values() for skuobj
in pcdobj
.SkuInfoList
.values() for storename
in skuobj
.DefaultStoreDict
}
1394 # Find out all possible PCD candidates for self._Arch
1397 for Type
in TypeList
:
1398 RecordList
.extend(self
._RawData
[Type
, self
._Arch
])
1400 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, default_store
, Dummy4
, Dummy5
in RecordList
:
1401 SkuName
= SkuName
.upper()
1402 default_store
= default_store
.upper()
1403 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
1404 if SkuName
not in SkuIds
:
1407 if SkuName
in SkuIds
and "." in TokenSpaceGuid
:
1408 S_PcdSet
.append([ TokenSpaceGuid
.split(".")[0], TokenSpaceGuid
.split(".")[1], PcdCName
, SkuName
, default_store
, Dummy5
, AnalyzePcdExpression(Setting
)[0]])
1410 # handle pcd value override
1411 StrPcdSet
= DscBuildData
.GetStructurePcdInfo(S_PcdSet
)
1412 S_pcd_set
= OrderedDict()
1413 for str_pcd
in StrPcdSet
:
1414 str_pcd_obj
= Pcds
.get((str_pcd
[1], str_pcd
[0]), None)
1415 str_pcd_dec
= self
._DecPcds
.get((str_pcd
[1], str_pcd
[0]), None)
1416 if not isinstance (str_pcd_dec
, StructurePcd
):
1417 EdkLogger
.error('build', PARSER_ERROR
,
1418 "Pcd (%s.%s) is not declared as Structure PCD in DEC files. Arch: ['%s']" % (str_pcd
[0], str_pcd
[1], self
._Arch
),
1419 File
=self
.MetaFile
, Line
= StrPcdSet
[str_pcd
][0][5])
1421 str_pcd_obj_str
= StructurePcd()
1422 str_pcd_obj_str
.copy(str_pcd_dec
)
1424 str_pcd_obj_str
.copy(str_pcd_obj
)
1425 if str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1426 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
}
1428 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
}
1429 for str_pcd_data
in StrPcdSet
[str_pcd
]:
1430 if str_pcd_data
[3] in SkuIds
:
1431 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])
1432 S_pcd_set
[str_pcd
[1], str_pcd
[0]] = str_pcd_obj_str
1434 EdkLogger
.error('build', PARSER_ERROR
,
1435 "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (str_pcd
[0], str_pcd
[1], self
._Arch
),
1436 File
=self
.MetaFile
, Line
= StrPcdSet
[str_pcd
][0][5])
1437 # Add the Structure PCD that only defined in DEC, don't have override in DSC file
1438 for Pcd
in self
.DecPcds
:
1439 if isinstance(self
._DecPcds
[Pcd
], StructurePcd
):
1440 if Pcd
not in S_pcd_set
:
1441 str_pcd_obj_str
= StructurePcd()
1442 str_pcd_obj_str
.copy(self
._DecPcds
[Pcd
])
1443 str_pcd_obj
= Pcds
.get(Pcd
, None)
1445 str_pcd_obj_str
.copy(str_pcd_obj
)
1446 if str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1447 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
}
1449 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
}
1450 S_pcd_set
[Pcd
] = str_pcd_obj_str
1452 GlobalData
.gStructurePcd
[self
.Arch
] = S_pcd_set
1453 for stru_pcd
in S_pcd_set
.values():
1454 for skuid
in SkuIds
:
1455 if skuid
in stru_pcd
.SkuOverrideValues
:
1457 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(skuid
)
1459 if skuid
not in stru_pcd
.SkuOverrideValues
:
1460 while nextskuid
not in stru_pcd
.SkuOverrideValues
:
1461 if nextskuid
== TAB_DEFAULT
:
1464 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
1465 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})
1467 stru_pcd
.ValueChain
.add((skuid
, ''))
1468 if stru_pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1469 for skuid
in SkuIds
:
1472 if skuid
not in stru_pcd
.SkuOverrideValues
:
1473 while nextskuid
not in stru_pcd
.SkuOverrideValues
:
1474 if nextskuid
== TAB_DEFAULT
:
1477 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
1480 PcdDefaultStoreSet
= set(defaultstorename
for defaultstorename
in stru_pcd
.SkuOverrideValues
[nextskuid
])
1481 mindefaultstorename
= DefaultStoreMgr
.GetMin(PcdDefaultStoreSet
)
1483 for defaultstoreid
in DefaultStores
:
1484 if defaultstoreid
not in stru_pcd
.SkuOverrideValues
[skuid
]:
1485 stru_pcd
.SkuOverrideValues
[skuid
][defaultstoreid
] = copy
.deepcopy(stru_pcd
.SkuOverrideValues
[nextskuid
][mindefaultstorename
])
1486 stru_pcd
.ValueChain
.add((skuid
, defaultstoreid
))
1487 S_pcd_set
= DscBuildData
.OverrideByFdf(S_pcd_set
,self
.WorkspaceDir
)
1488 S_pcd_set
= DscBuildData
.OverrideByComm(S_pcd_set
)
1489 Str_Pcd_Values
= self
.GenerateByteArrayValue(S_pcd_set
)
1491 for (skuname
, StoreName
, PcdGuid
, PcdName
, PcdValue
) in Str_Pcd_Values
:
1492 str_pcd_obj
= S_pcd_set
.get((PcdName
, PcdGuid
))
1493 if str_pcd_obj
is None:
1494 print(PcdName
, PcdGuid
)
1496 if str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
1497 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1498 if skuname
not in str_pcd_obj
.SkuInfoList
:
1499 str_pcd_obj
.SkuInfoList
[skuname
] = SkuInfoClass(SkuIdName
=skuname
, SkuId
=self
.SkuIds
[skuname
][0], HiiDefaultValue
=PcdValue
, DefaultStore
= {StoreName
:PcdValue
})
1501 str_pcd_obj
.SkuInfoList
[skuname
].HiiDefaultValue
= PcdValue
1502 str_pcd_obj
.SkuInfoList
[skuname
].DefaultStoreDict
.update({StoreName
:PcdValue
})
1503 elif str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
1504 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
1505 if skuname
in (self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT
, TAB_COMMON
):
1506 str_pcd_obj
.DefaultValue
= PcdValue
1508 if skuname
not in str_pcd_obj
.SkuInfoList
:
1509 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(skuname
)
1511 while nextskuid
not in str_pcd_obj
.SkuInfoList
:
1512 if nextskuid
== TAB_DEFAULT
:
1515 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
1516 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
)
1517 str_pcd_obj
.SkuInfoList
[skuname
].SkuId
= self
.SkuIds
[skuname
][0]
1518 str_pcd_obj
.SkuInfoList
[skuname
].SkuIdName
= skuname
1520 str_pcd_obj
.SkuInfoList
[skuname
].DefaultValue
= PcdValue
1521 for str_pcd_obj
in S_pcd_set
.values():
1522 if str_pcd_obj
.Type
not in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
1523 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1525 PcdDefaultStoreSet
= set(defaultstorename
for skuobj
in str_pcd_obj
.SkuInfoList
.values() for defaultstorename
in skuobj
.DefaultStoreDict
)
1526 DefaultStoreObj
= DefaultStore(self
._GetDefaultStores
())
1527 mindefaultstorename
= DefaultStoreObj
.GetMin(PcdDefaultStoreSet
)
1528 str_pcd_obj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
].HiiDefaultValue
= str_pcd_obj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
].DefaultStoreDict
[mindefaultstorename
]
1530 for str_pcd_obj
in S_pcd_set
.values():
1532 str_pcd_obj
.MaxDatumSize
= self
.GetStructurePcdMaxSize(str_pcd_obj
)
1533 Pcds
[str_pcd_obj
.TokenCName
, str_pcd_obj
.TokenSpaceGuidCName
] = str_pcd_obj
1537 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
1538 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
1539 del pcd
.SkuInfoList
[TAB_COMMON
]
1540 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
1541 del pcd
.SkuInfoList
[TAB_COMMON
]
1543 map(self
.FilterSkuSettings
, [Pcds
[pcdkey
] for pcdkey
in Pcds
if Pcds
[pcdkey
].Type
in DynamicPcdType
])
1546 ## Retrieve non-dynamic PCD settings
1548 # @param Type PCD type
1550 # @retval a dict object contains settings of given PCD type
1552 def _GetPcd(self
, Type
):
1553 Pcds
= OrderedDict()
1555 # tdict is a special dict kind of type, used for selecting correct
1556 # PCD settings for certain ARCH
1558 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
1560 PcdDict
= tdict(True, 3)
1562 # Find out all possible PCD candidates for self._Arch
1563 RecordList
= self
._RawData
[Type
, self
._Arch
]
1564 PcdValueDict
= OrderedDict()
1565 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
1566 SkuName
= SkuName
.upper()
1567 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
1568 if SkuName
not in AvailableSkuIdSet
:
1569 EdkLogger
.error('build ', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
1570 File
=self
.MetaFile
, Line
=Dummy5
)
1571 if SkuName
in (self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT
, TAB_COMMON
):
1572 if "." not in TokenSpaceGuid
:
1573 PcdSet
.add((PcdCName
, TokenSpaceGuid
, SkuName
, Dummy5
))
1574 PcdDict
[Arch
, PcdCName
, TokenSpaceGuid
, SkuName
] = Setting
1576 for PcdCName
, TokenSpaceGuid
, SkuName
, Dummy4
in PcdSet
:
1577 Setting
= PcdDict
[self
._Arch
, PcdCName
, TokenSpaceGuid
, SkuName
]
1580 PcdValue
, DatumType
, MaxDatumSize
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
1582 if int(MaxDatumSize
, 0) > 0xFFFF:
1583 EdkLogger
.error('build', FORMAT_INVALID
, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
1584 File
=self
.MetaFile
, Line
=Dummy4
)
1585 if int(MaxDatumSize
, 0) < 0:
1586 EdkLogger
.error('build', FORMAT_INVALID
, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
1587 File
=self
.MetaFile
, Line
=Dummy4
)
1588 if (PcdCName
, TokenSpaceGuid
) in PcdValueDict
:
1589 PcdValueDict
[PcdCName
, TokenSpaceGuid
][SkuName
] = (PcdValue
, DatumType
, MaxDatumSize
)
1591 PcdValueDict
[PcdCName
, TokenSpaceGuid
] = {SkuName
:(PcdValue
, DatumType
, MaxDatumSize
)}
1593 for ((PcdCName
, TokenSpaceGuid
), PcdSetting
) in PcdValueDict
.iteritems():
1594 if self
.SkuIdMgr
.SystemSkuId
in PcdSetting
:
1595 PcdValue
, DatumType
, MaxDatumSize
= PcdSetting
[self
.SkuIdMgr
.SystemSkuId
]
1596 elif TAB_DEFAULT
in PcdSetting
:
1597 PcdValue
, DatumType
, MaxDatumSize
= PcdSetting
[TAB_DEFAULT
]
1598 elif TAB_COMMON
in PcdSetting
:
1599 PcdValue
, DatumType
, MaxDatumSize
= PcdSetting
[TAB_COMMON
]
1605 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
1608 self
._PCD
_TYPE
_STRING
_[Type
],
1618 if self
.SkuIdMgr
.SystemSkuId
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
1619 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[self
.SkuIdMgr
.SystemSkuId
] = {}
1620 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[self
.SkuIdMgr
.SystemSkuId
][TAB_DEFAULT_STORES_DEFAULT
] = PcdValue
1623 def GetStructurePcdMaxSize(self
, str_pcd
):
1624 pcd_default_value
= str_pcd
.DefaultValue
1625 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()]
1626 sku_values
.append(pcd_default_value
)
1628 def get_length(value
):
1629 Value
= value
.strip()
1631 if Value
.startswith(TAB_GUID
) and Value
.endswith(')'):
1633 if Value
.startswith('L"') and Value
.endswith('"'):
1634 return len(Value
[2:-1])
1635 if Value
[0] == '"' and Value
[-1] == '"':
1636 return len(Value
) - 2
1637 if Value
[0] == '{' and Value
[-1] == '}':
1638 return len(Value
.split(","))
1639 if Value
.startswith("L'") and Value
.endswith("'") and len(list(Value
[2:-1])) > 1:
1640 return len(list(Value
[2:-1]))
1641 if Value
[0] == "'" and Value
[-1] == "'" and len(list(Value
[1:-1])) > 1:
1642 return len(Value
) - 2
1645 return str(max(get_length(item
) for item
in sku_values
))
1648 def ExecuteCommand (Command
):
1650 Process
= subprocess
.Popen(Command
, stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
, shell
=True)
1652 EdkLogger
.error('Build', COMMAND_FAILURE
, 'Can not execute command: %s' % Command
)
1653 Result
= Process
.communicate()
1654 return Process
.returncode
, Result
[0], Result
[1]
1657 def IntToCString(Value
, ValueSize
):
1659 if not isinstance (Value
, str):
1660 for Index
in range(0, ValueSize
):
1661 Result
= Result
+ '\\x%02x' % (Value
& 0xff)
1663 Result
= Result
+ '"'
1666 def GenerateSizeFunction(self
, Pcd
):
1667 CApp
= "// Default Value in Dec \n"
1668 CApp
= CApp
+ "void Cal_%s_%s_Size(UINT32 *Size){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1669 for FieldList
in [Pcd
.DefaultValues
]:
1672 for FieldName
in FieldList
:
1673 FieldName
= "." + FieldName
1674 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
.strip(".")][0])
1675 if IsArray
and not (FieldList
[FieldName
.strip(".")][0].startswith('{GUID') and FieldList
[FieldName
.strip(".")][0].endswith('}')):
1677 Value
= ValueExpressionEx(FieldList
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1678 except BadExpression
:
1679 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1680 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), FieldList
[FieldName
.strip(".")][1], FieldList
[FieldName
.strip(".")][2]))
1681 Value
, ValueSize
= ParseFieldValue(Value
)
1682 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]);
1685 FieldName_ori
= FieldName
.strip('.')
1686 while '[' in FieldName
:
1687 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1688 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1689 FieldName
= FieldName
.split(']', 1)[1]
1690 FieldName
= NewFieldName
+ FieldName
1691 while '[' in FieldName
:
1692 FieldName
= FieldName
.rsplit('[', 1)[0]
1693 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])
1694 for skuname
in Pcd
.SkuOverrideValues
:
1695 if skuname
== TAB_COMMON
:
1697 for defaultstorenameitem
in Pcd
.SkuOverrideValues
[skuname
]:
1698 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: %s \n" % (skuname
, defaultstorenameitem
)
1699 for FieldList
in [Pcd
.SkuOverrideValues
[skuname
].get(defaultstorenameitem
)]:
1702 for FieldName
in FieldList
:
1703 FieldName
= "." + FieldName
1704 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
.strip(".")][0])
1705 if IsArray
and not (FieldList
[FieldName
.strip(".")][0].startswith('{GUID') and FieldList
[FieldName
.strip(".")][0].endswith('}')):
1707 Value
= ValueExpressionEx(FieldList
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1708 except BadExpression
:
1709 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1710 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), FieldList
[FieldName
.strip(".")][1], FieldList
[FieldName
.strip(".")][2]))
1711 Value
, ValueSize
= ParseFieldValue(Value
)
1712 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]);
1715 FieldName_ori
= FieldName
.strip('.')
1716 while '[' in FieldName
:
1717 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1718 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1719 FieldName
= FieldName
.split(']', 1)[1]
1720 FieldName
= NewFieldName
+ FieldName
1721 while '[' in FieldName
:
1722 FieldName
= FieldName
.rsplit('[', 1)[0]
1723 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])
1724 if Pcd
.PcdFieldValueFromFdf
:
1725 CApp
= CApp
+ "// From fdf \n"
1726 for FieldName
in Pcd
.PcdFieldValueFromFdf
:
1727 FieldName
= "." + FieldName
1728 IsArray
= IsFieldValueAnArray(Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0])
1729 if IsArray
and not (Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0].startswith('{GUID') and Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0].endswith('}')):
1731 Value
= ValueExpressionEx(Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1732 except BadExpression
:
1733 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1734 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][1], Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][2]))
1735 Value
, ValueSize
= ParseFieldValue(Value
)
1736 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]);
1739 FieldName_ori
= FieldName
.strip('.')
1740 while '[' in FieldName
:
1741 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1742 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1743 FieldName
= FieldName
.split(']', 1)[1]
1744 FieldName
= NewFieldName
+ FieldName
1745 while '[' in FieldName
:
1746 FieldName
= FieldName
.rsplit('[', 1)[0]
1747 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])
1748 if Pcd
.PcdFieldValueFromComm
:
1749 CApp
= CApp
+ "// From Command Line \n"
1750 for FieldName
in Pcd
.PcdFieldValueFromComm
:
1751 FieldName
= "." + FieldName
1752 IsArray
= IsFieldValueAnArray(Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0])
1753 if IsArray
and not (Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0].startswith('{GUID') and Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0].endswith('}')):
1755 Value
= ValueExpressionEx(Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1756 except BadExpression
:
1757 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1758 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][1], Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][2]))
1759 Value
, ValueSize
= ParseFieldValue(Value
)
1760 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]);
1763 FieldName_ori
= FieldName
.strip('.')
1764 while '[' in FieldName
:
1765 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1766 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1767 FieldName
= FieldName
.split(']', 1)[1]
1768 FieldName
= NewFieldName
+ FieldName
1769 while '[' in FieldName
:
1770 FieldName
= FieldName
.rsplit('[', 1)[0]
1771 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])
1772 CApp
= CApp
+ " *Size = (%d > *Size ? %d : *Size); // The Pcd maxsize is %d \n" % (Pcd
.GetPcdMaxSize(), Pcd
.GetPcdMaxSize(), Pcd
.GetPcdMaxSize())
1777 def GenerateSizeStatments(Pcd
):
1778 CApp
= ' Size = sizeof(%s);\n' % (Pcd
.DatumType
)
1779 CApp
= CApp
+ ' Cal_%s_%s_Size(&Size);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1782 def GenerateDefaultValueAssignFunction(self
, Pcd
):
1783 CApp
= "// Default value in Dec \n"
1784 CApp
= CApp
+ "void Assign_%s_%s_Default_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Pcd
.DatumType
)
1785 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1786 CApp
= CApp
+ ' CHAR8 *Value;\n'
1787 DefaultValueFromDec
= Pcd
.DefaultValueFromDec
1788 IsArray
= IsFieldValueAnArray(Pcd
.DefaultValueFromDec
)
1791 DefaultValueFromDec
= ValueExpressionEx(Pcd
.DefaultValueFromDec
, TAB_VOID
)(True)
1792 except BadExpression
:
1793 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from DEC: %s" %
1794 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, DefaultValueFromDec
))
1795 DefaultValueFromDec
= StringToArray(DefaultValueFromDec
)
1796 Value
, ValueSize
= ParseFieldValue (DefaultValueFromDec
)
1797 if isinstance(Value
, str):
1798 CApp
= CApp
+ ' Pcd = %s; // From DEC Default Value %s\n' % (Value
, Pcd
.DefaultValueFromDec
)
1801 # Use memcpy() to copy value into field
1803 CApp
= CApp
+ ' Value = %s; // From DEC Default Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), Pcd
.DefaultValueFromDec
)
1804 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1805 for FieldList
in [Pcd
.DefaultValues
]:
1808 for FieldName
in FieldList
:
1809 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
1812 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
1813 except BadExpression
:
1814 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1815 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
1818 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
1820 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]))
1821 if isinstance(Value
, str):
1822 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1825 # Use memcpy() to copy value into field
1827 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
1828 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1829 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
1832 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1834 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1839 def GenerateDefaultValueAssignStatement(Pcd
):
1840 CApp
= ' Assign_%s_%s_Default_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1843 def GenerateInitValueFunction(self
, Pcd
, SkuName
, DefaultStoreName
):
1844 CApp
= "// Value in Dsc for Sku: %s, DefaultStore %s\n" % (SkuName
, DefaultStoreName
)
1845 CApp
= CApp
+ "void Assign_%s_%s_%s_%s_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, SkuName
, DefaultStoreName
, Pcd
.DatumType
)
1846 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1847 CApp
= CApp
+ ' CHAR8 *Value;\n'
1849 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: %s \n" % (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
)
1850 inherit_OverrideValues
= Pcd
.SkuOverrideValues
[SkuName
]
1851 if (SkuName
, DefaultStoreName
) == (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
):
1852 pcddefaultvalue
= Pcd
.DefaultFromDSC
.get(TAB_DEFAULT
, {}).get(TAB_DEFAULT_STORES_DEFAULT
) if Pcd
.DefaultFromDSC
else None
1854 pcddefaultvalue
= Pcd
.DscRawValue
.get(SkuName
, {}).get(DefaultStoreName
)
1855 for FieldList
in [pcddefaultvalue
, inherit_OverrideValues
.get(DefaultStoreName
)]:
1858 if pcddefaultvalue
and FieldList
== pcddefaultvalue
:
1859 IsArray
= IsFieldValueAnArray(FieldList
)
1862 FieldList
= ValueExpressionEx(FieldList
, TAB_VOID
)(True)
1863 except BadExpression
:
1864 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from DSC: %s" %
1865 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldList
))
1866 Value
, ValueSize
= ParseFieldValue (FieldList
)
1868 if (SkuName
, DefaultStoreName
) == (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
):
1869 if isinstance(Value
, str):
1870 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
)
1873 # Use memcpy() to copy value into field
1875 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
)
1876 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1878 if isinstance(Value
, str):
1879 CApp
= CApp
+ ' Pcd = %s; // From DSC Default Value %s\n' % (Value
, Pcd
.DscRawValue
.get(SkuName
, {}).get(DefaultStoreName
))
1882 # Use memcpy() to copy value into field
1884 CApp
= CApp
+ ' Value = %s; // From DSC Default Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), Pcd
.DscRawValue
.get(SkuName
, {}).get(DefaultStoreName
))
1885 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1887 if (SkuName
, DefaultStoreName
) == (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
) or (( (SkuName
, '') not in Pcd
.ValueChain
) and ( (SkuName
, DefaultStoreName
) not in Pcd
.ValueChain
)):
1888 for FieldName
in FieldList
:
1889 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
1892 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
1893 except BadExpression
:
1894 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1895 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
1897 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
1899 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]))
1900 if isinstance(Value
, str):
1901 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1904 # Use memcpy() to copy value into field
1906 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
1907 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1908 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
1911 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1913 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1918 def GenerateInitValueStatement(Pcd
, SkuName
, DefaultStoreName
):
1919 CApp
= ' Assign_%s_%s_%s_%s_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, SkuName
, DefaultStoreName
)
1922 def GenerateCommandLineValue(self
, Pcd
):
1923 CApp
= "// Value in CommandLine\n"
1924 CApp
= CApp
+ "void Assign_%s_%s_CommandLine_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Pcd
.DatumType
)
1925 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1926 CApp
= CApp
+ ' CHAR8 *Value;\n'
1928 pcddefaultvalue
= Pcd
.PcdValueFromComm
1929 for FieldList
in [pcddefaultvalue
, Pcd
.PcdFieldValueFromComm
]:
1932 if pcddefaultvalue
and FieldList
== pcddefaultvalue
:
1933 IsArray
= IsFieldValueAnArray(FieldList
)
1936 FieldList
= ValueExpressionEx(FieldList
, TAB_VOID
)(True)
1937 except BadExpression
:
1938 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from Command: %s" %
1939 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldList
))
1940 Value
, ValueSize
= ParseFieldValue (FieldList
)
1942 if isinstance(Value
, str):
1943 CApp
= CApp
+ ' Pcd = %s; // From Command Line \n' % (Value
)
1946 # Use memcpy() to copy value into field
1948 CApp
= CApp
+ ' Value = %s; // From Command Line.\n' % (DscBuildData
.IntToCString(Value
, ValueSize
))
1949 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1951 for FieldName
in FieldList
:
1952 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
1955 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
1956 except BadExpression
:
1957 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1958 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
1962 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
1964 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]))
1965 if isinstance(Value
, str):
1966 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1969 # Use memcpy() to copy value into field
1971 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
1972 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1973 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
1976 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1978 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1983 def GenerateCommandLineValueStatement(Pcd
):
1984 CApp
= ' Assign_%s_%s_CommandLine_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1986 def GenerateFdfValue(self
,Pcd
):
1987 CApp
= "// Value in Fdf\n"
1988 CApp
= CApp
+ "void Assign_%s_%s_Fdf_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
,Pcd
.DatumType
)
1989 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1990 CApp
= CApp
+ ' CHAR8 *Value;\n'
1992 pcddefaultvalue
= Pcd
.PcdValueFromFdf
1993 for FieldList
in [pcddefaultvalue
,Pcd
.PcdFieldValueFromFdf
]:
1996 if pcddefaultvalue
and FieldList
== pcddefaultvalue
:
1997 IsArray
= IsFieldValueAnArray(FieldList
)
2000 FieldList
= ValueExpressionEx(FieldList
, TAB_VOID
)(True)
2001 except BadExpression
:
2002 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from Fdf: %s" %
2003 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldList
))
2004 Value
, ValueSize
= ParseFieldValue (FieldList
)
2006 if isinstance(Value
, str):
2007 CApp
= CApp
+ ' Pcd = %s; // From Fdf \n' % (Value
)
2010 # Use memcpy() to copy value into field
2012 CApp
= CApp
+ ' Value = %s; // From Fdf .\n' % (DscBuildData
.IntToCString(Value
, ValueSize
))
2013 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
2015 for FieldName
in FieldList
:
2016 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
2019 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
2020 except BadExpression
:
2021 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
2022 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
2026 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
2028 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]))
2029 if isinstance(Value
, str):
2030 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2033 # Use memcpy() to copy value into field
2035 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
2036 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2037 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
2040 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2042 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %s Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2047 def GenerateFdfValueStatement(Pcd
):
2048 CApp
= ' Assign_%s_%s_Fdf_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2051 def GenerateInitializeFunc(self
, SkuName
, DefaultStore
, Pcd
, InitByteValue
, CApp
):
2052 OverrideValues
= {DefaultStore
:""}
2053 if Pcd
.SkuOverrideValues
:
2054 OverrideValues
= Pcd
.SkuOverrideValues
[SkuName
]
2055 if not OverrideValues
:
2056 OverrideValues
= {TAB_DEFAULT_STORES_DEFAULT
:Pcd
.DefaultValues
}
2057 for DefaultStoreName
in OverrideValues
:
2058 CApp
= CApp
+ 'void\n'
2059 CApp
= CApp
+ 'Initialize_%s_%s_%s_%s(\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2060 CApp
= CApp
+ ' void\n'
2061 CApp
= CApp
+ ' )\n'
2063 CApp
= CApp
+ ' UINT32 Size;\n'
2064 CApp
= CApp
+ ' UINT32 FieldSize;\n'
2065 CApp
= CApp
+ ' CHAR8 *Value;\n'
2066 CApp
= CApp
+ ' UINT32 OriginalSize;\n'
2067 CApp
= CApp
+ ' VOID *OriginalPcd;\n'
2068 CApp
= CApp
+ ' %s *Pcd; // From %s Line %d \n' % (Pcd
.DatumType
, Pcd
.PkgPath
, Pcd
.PcdDefineLineNo
)
2071 if SkuName
in Pcd
.SkuInfoList
:
2072 DefaultValue
= Pcd
.SkuInfoList
[SkuName
].DefaultStoreDict
.get(DefaultStoreName
, Pcd
.SkuInfoList
[SkuName
].HiiDefaultValue
if Pcd
.SkuInfoList
[SkuName
].HiiDefaultValue
else Pcd
.SkuInfoList
[SkuName
].DefaultValue
)
2074 DefaultValue
= Pcd
.DefaultValue
2075 PcdDefaultValue
= StringToArray(DefaultValue
.strip())
2077 InitByteValue
+= '%s.%s.%s.%s|%s|%s\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Pcd
.DatumType
, PcdDefaultValue
)
2080 # Get current PCD value and size
2082 CApp
= CApp
+ ' OriginalPcd = PcdGetPtr (%s, %s, %s, %s, &OriginalSize);\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2085 # Determine the size of the PCD. For simple structures, sizeof(TYPE) provides
2086 # the correct value. For structures with a flexible array member, the flexible
2087 # array member is detected, and the size is based on the highest index used with
2088 # the flexible array member. The flexible array member must be the last field
2089 # in a structure. The size formula for this case is:
2090 # OFFSET_OF(FlexbleArrayField) + sizeof(FlexibleArray[0]) * (HighestIndex + 1)
2092 CApp
= CApp
+ DscBuildData
.GenerateSizeStatments(Pcd
)
2095 # Allocate and zero buffer for the PCD
2096 # Must handle cases where current value is smaller, larger, or same size
2097 # Always keep that larger one as the current size
2099 CApp
= CApp
+ ' Size = (OriginalSize > Size ? OriginalSize : Size);\n'
2100 CApp
= CApp
+ ' Pcd = (%s *)malloc (Size);\n' % (Pcd
.DatumType
)
2101 CApp
= CApp
+ ' memset (Pcd, 0, Size);\n'
2104 # Copy current PCD value into allocated buffer.
2106 CApp
= CApp
+ ' memcpy (Pcd, OriginalPcd, OriginalSize);\n'
2109 # Assign field values in PCD
2111 CApp
= CApp
+ DscBuildData
.GenerateDefaultValueAssignStatement(Pcd
)
2112 if Pcd
.Type
not in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
2113 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
2114 for skuname
in self
.SkuIdMgr
.GetSkuChain(SkuName
):
2115 storeset
= [DefaultStoreName
] if DefaultStoreName
== TAB_DEFAULT_STORES_DEFAULT
else [TAB_DEFAULT_STORES_DEFAULT
, DefaultStoreName
]
2116 for defaultstorenameitem
in storeset
:
2117 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: %s \n" % (skuname
, defaultstorenameitem
)
2118 CApp
= CApp
+ DscBuildData
.GenerateInitValueStatement(Pcd
, skuname
, defaultstorenameitem
)
2119 if skuname
== SkuName
:
2122 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: STANDARD \n" % self
.SkuIdMgr
.SystemSkuId
2123 CApp
= CApp
+ DscBuildData
.GenerateInitValueStatement(Pcd
, self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
)
2124 CApp
= CApp
+ DscBuildData
.GenerateFdfValueStatement(Pcd
)
2125 CApp
= CApp
+ DscBuildData
.GenerateCommandLineValueStatement(Pcd
)
2127 # Set new PCD value and size
2129 CApp
= CApp
+ ' PcdSetPtr (%s, %s, %s, %s, Size, (UINT8 *)Pcd);\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2134 CApp
= CApp
+ ' free (Pcd);\n'
2137 return InitByteValue
, CApp
2138 def SkuOverrideValuesEmpty(self
,OverrideValues
):
2139 if not OverrideValues
:
2141 for key
in OverrideValues
:
2142 if OverrideValues
[key
]:
2146 def GenerateByteArrayValue (self
, StructuredPcds
):
2148 # Generate/Compile/Run C application to determine if there are any flexible array members
2150 if not StructuredPcds
:
2154 CApp
= PcdMainCHeader
2156 IncludeFiles
= set()
2157 for PcdName
in StructuredPcds
:
2158 Pcd
= StructuredPcds
[PcdName
]
2159 for IncludeFile
in Pcd
.StructuredPcdIncludeFile
:
2160 if IncludeFile
not in IncludeFiles
:
2161 IncludeFiles
.add(IncludeFile
)
2162 CApp
= CApp
+ '#include <%s>\n' % (IncludeFile
)
2164 for PcdName
in StructuredPcds
:
2165 Pcd
= StructuredPcds
[PcdName
]
2166 CApp
= CApp
+ self
.GenerateSizeFunction(Pcd
)
2167 CApp
= CApp
+ self
.GenerateDefaultValueAssignFunction(Pcd
)
2168 CApp
= CApp
+ self
.GenerateFdfValue(Pcd
)
2169 CApp
= CApp
+ self
.GenerateCommandLineValue(Pcd
)
2170 if self
.SkuOverrideValuesEmpty(Pcd
.SkuOverrideValues
) or Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
2171 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
2172 CApp
= CApp
+ self
.GenerateInitValueFunction(Pcd
, self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
)
2174 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
2175 if SkuName
not in Pcd
.SkuOverrideValues
:
2177 for DefaultStoreName
in Pcd
.SkuOverrideValues
[SkuName
]:
2178 CApp
= CApp
+ self
.GenerateInitValueFunction(Pcd
, SkuName
, DefaultStoreName
)
2179 if self
.SkuOverrideValuesEmpty(Pcd
.SkuOverrideValues
) or Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
2180 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
2181 InitByteValue
, CApp
= self
.GenerateInitializeFunc(self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
, Pcd
, InitByteValue
, CApp
)
2183 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
2184 if SkuName
not in Pcd
.SkuOverrideValues
:
2186 for DefaultStoreName
in Pcd
.DefaultStoreName
:
2187 Pcd
= StructuredPcds
[PcdName
]
2188 InitByteValue
, CApp
= self
.GenerateInitializeFunc(SkuName
, DefaultStoreName
, Pcd
, InitByteValue
, CApp
)
2190 CApp
= CApp
+ 'VOID\n'
2191 CApp
= CApp
+ 'PcdEntryPoint(\n'
2192 CApp
= CApp
+ ' VOID\n'
2193 CApp
= CApp
+ ' )\n'
2195 for Pcd
in StructuredPcds
.values():
2196 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
]]:
2197 CApp
= CApp
+ ' Initialize_%s_%s_%s_%s();\n' % (self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2199 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
2200 if SkuName
not in self
.SkuIdMgr
.AvailableSkuIdSet
:
2202 for DefaultStoreName
in Pcd
.SkuOverrideValues
[SkuName
]:
2203 CApp
= CApp
+ ' Initialize_%s_%s_%s_%s();\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2206 CApp
= CApp
+ PcdMainCEntry
+ '\n'
2208 if not os
.path
.exists(self
.OutputPath
):
2209 os
.makedirs(self
.OutputPath
)
2210 CAppBaseFileName
= os
.path
.join(self
.OutputPath
, PcdValueInitName
)
2211 SaveFileOnChange(CAppBaseFileName
+ '.c', CApp
, False)
2213 MakeApp
= PcdMakefileHeader
2214 if sys
.platform
== "win32":
2215 MakeApp
= MakeApp
+ 'APPNAME = %s\n' % (PcdValueInitName
) + 'OBJECTS = %s\%s.obj\n' % (self
.OutputPath
, PcdValueInitName
) + 'INC = '
2217 MakeApp
= MakeApp
+ PcdGccMakefile
2218 MakeApp
= MakeApp
+ 'APPNAME = %s\n' % (PcdValueInitName
) + 'OBJECTS = %s/%s.o\n' % (self
.OutputPath
, PcdValueInitName
) + \
2219 'include $(MAKEROOT)/Makefiles/app.makefile\n' + 'INCLUDE +='
2223 for Cache
in self
._Bdb
._CACHE
_.values():
2224 if Cache
.MetaFile
.Ext
.lower() != '.dec':
2227 if str(Cache
.MetaFile
.Path
) not in PlatformInc
:
2228 PlatformInc
[str(Cache
.MetaFile
.Path
)] = []
2229 PlatformInc
[str(Cache
.MetaFile
.Path
)].append (os
.path
.dirname(Cache
.MetaFile
.Path
))
2230 PlatformInc
[str(Cache
.MetaFile
.Path
)].extend (Cache
.CommonIncludes
)
2233 for Pcd
in StructuredPcds
.values():
2234 for PackageDec
in Pcd
.PackageDecs
:
2235 Package
= os
.path
.normpath(mws
.join(GlobalData
.gWorkspace
, PackageDec
))
2236 if not os
.path
.exists(Package
):
2237 EdkLogger
.error('Build', RESOURCE_NOT_AVAILABLE
, "The dependent Package %s of PCD %s.%s is not exist." % (PackageDec
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
))
2238 if Package
not in PcdDependDEC
:
2239 PcdDependDEC
.append(Package
)
2241 if PlatformInc
and PcdDependDEC
:
2242 for pkg
in PcdDependDEC
:
2243 if pkg
in PlatformInc
:
2244 for inc
in PlatformInc
[pkg
]:
2245 MakeApp
+= '-I' + str(inc
) + ' '
2246 IncSearchList
.append(inc
)
2247 MakeApp
= MakeApp
+ '\n'
2249 CC_FLAGS
= LinuxCFLAGS
2250 if sys
.platform
== "win32":
2251 CC_FLAGS
= WindowsCFLAGS
2253 for Options
in self
.BuildOptions
:
2254 if Options
[2] != EDKII_NAME
:
2257 if Family
and Family
!= self
.ToolChainFamily
:
2259 Target
, Tag
, Arch
, Tool
, Attr
= Options
[1].split("_")
2263 if Target
== "*" or Target
== self
._Target
:
2264 if Tag
== "*" or Tag
== self
._Toolchain
:
2265 if Arch
== "*" or Arch
== self
.Arch
:
2266 if Tool
not in BuildOptions
:
2267 BuildOptions
[Tool
] = {}
2268 if Attr
!= "FLAGS" or Attr
not in BuildOptions
[Tool
] or self
.BuildOptions
[Options
].startswith('='):
2269 BuildOptions
[Tool
][Attr
] = self
.BuildOptions
[Options
]
2271 # append options for the same tool except PATH
2273 BuildOptions
[Tool
][Attr
] += " " + self
.BuildOptions
[Options
]
2275 BuildOptions
[Tool
][Attr
] = self
.BuildOptions
[Options
]
2277 for Tool
in BuildOptions
:
2278 for Attr
in BuildOptions
[Tool
]:
2280 Value
= BuildOptions
[Tool
][Attr
]
2281 ValueList
= Value
.split()
2283 for Id
, Item
in enumerate(ValueList
):
2284 if Item
in ['-D', '/D', '-U', '/U']:
2285 CC_FLAGS
+= ' ' + Item
2286 if Id
+ 1 < len(ValueList
):
2287 CC_FLAGS
+= ' ' + ValueList
[Id
+ 1]
2288 elif Item
.startswith(('-D', '/D', '-U', '/U')):
2289 CC_FLAGS
+= ' ' + Item
2292 if sys
.platform
== "win32":
2293 MakeApp
= MakeApp
+ PcdMakefileEnd
2294 MakeApp
= MakeApp
+ '\n'
2295 IncludeFileFullPaths
= []
2296 for includefile
in IncludeFiles
:
2297 for includepath
in IncSearchList
:
2298 includefullpath
= os
.path
.join(str(includepath
), includefile
)
2299 if os
.path
.exists(includefullpath
):
2300 IncludeFileFullPaths
.append(os
.path
.normpath(includefullpath
))
2303 SearchPathList
.append(os
.path
.normpath(mws
.join(GlobalData
.gWorkspace
, "BaseTools/Source/C/Include")))
2304 SearchPathList
.append(os
.path
.normpath(mws
.join(GlobalData
.gWorkspace
, "BaseTools/Source/C/Common")))
2305 SearchPathList
.extend(str(item
) for item
in IncSearchList
)
2306 IncFileList
= GetDependencyList(IncludeFileFullPaths
, SearchPathList
)
2307 for include_file
in IncFileList
:
2308 MakeApp
+= "$(OBJECTS) : %s\n" % include_file
2309 MakeFileName
= os
.path
.join(self
.OutputPath
, 'Makefile')
2310 MakeApp
+= "$(OBJECTS) : %s\n" % MakeFileName
2311 SaveFileOnChange(MakeFileName
, MakeApp
, False)
2313 InputValueFile
= os
.path
.join(self
.OutputPath
, 'Input.txt')
2314 OutputValueFile
= os
.path
.join(self
.OutputPath
, 'Output.txt')
2315 SaveFileOnChange(InputValueFile
, InitByteValue
, False)
2317 PcdValueInitExe
= PcdValueInitName
2318 if not sys
.platform
== "win32":
2319 PcdValueInitExe
= os
.path
.join(os
.getenv("EDK_TOOLS_PATH"), 'Source', 'C', 'bin', PcdValueInitName
)
2321 PcdValueInitExe
= os
.path
.join(os
.getenv("EDK_TOOLS_PATH"), 'Bin', 'Win32', PcdValueInitName
) +".exe"
2324 if sys
.platform
== "win32":
2325 MakeCommand
= 'nmake -f %s' % (MakeFileName
)
2326 returncode
, StdOut
, StdErr
= DscBuildData
.ExecuteCommand (MakeCommand
)
2329 MakeCommand
= 'make -f %s' % (MakeFileName
)
2330 returncode
, StdOut
, StdErr
= DscBuildData
.ExecuteCommand (MakeCommand
)
2332 Messages
= Messages
.split('\n')
2335 CAppBaseFileName
= os
.path
.join(self
.OutputPath
, PcdValueInitName
)
2336 File
= open (CAppBaseFileName
+ '.c', 'r')
2337 FileData
= File
.readlines()
2339 for Message
in Messages
:
2340 if " error" in Message
or "warning" in Message
:
2341 FileInfo
= Message
.strip().split('(')
2342 if len (FileInfo
) > 1:
2343 FileName
= FileInfo
[0]
2344 FileLine
= FileInfo
[1].split (')')[0]
2346 FileInfo
= Message
.strip().split(':')
2347 FileName
= FileInfo
[0]
2348 FileLine
= FileInfo
[1]
2349 if FileLine
.isdigit():
2350 error_line
= FileData
[int (FileLine
) - 1]
2351 if r
"//" in error_line
:
2352 c_line
, dsc_line
= error_line
.split(r
"//")
2354 dsc_line
= error_line
2355 message_itmes
= Message
.split(":")
2357 if "PcdValueInit.c" not in Message
:
2358 if not MessageGroup
:
2359 MessageGroup
.append(Message
)
2362 for item
in message_itmes
:
2363 if "PcdValueInit.c" in item
:
2364 Index
= message_itmes
.index(item
)
2365 message_itmes
[Index
] = dsc_line
.strip()
2367 MessageGroup
.append(":".join(message_itmes
[Index
:]).strip())
2370 MessageGroup
.append(Message
)
2372 EdkLogger
.error("build", PCD_STRUCTURE_PCD_ERROR
, "\n".join(MessageGroup
) )
2374 EdkLogger
.error('Build', COMMAND_FAILURE
, 'Can not execute command: %s' % MakeCommand
)
2376 if DscBuildData
.NeedUpdateOutput(OutputValueFile
, PcdValueInitExe
, InputValueFile
):
2377 Command
= PcdValueInitExe
+ ' -i %s -o %s' % (InputValueFile
, OutputValueFile
)
2378 returncode
, StdOut
, StdErr
= DscBuildData
.ExecuteCommand (Command
)
2380 EdkLogger
.warn('Build', COMMAND_FAILURE
, 'Can not collect output from command: %s' % Command
)
2382 File
= open (OutputValueFile
, 'r')
2383 FileBuffer
= File
.readlines()
2386 StructurePcdSet
= []
2387 for Pcd
in FileBuffer
:
2388 PcdValue
= Pcd
.split ('|')
2389 PcdInfo
= PcdValue
[0].split ('.')
2390 StructurePcdSet
.append((PcdInfo
[0], PcdInfo
[1], PcdInfo
[2], PcdInfo
[3], PcdValue
[2].strip()))
2391 return StructurePcdSet
2394 def NeedUpdateOutput(OutputFile
, ValueCFile
, StructureInput
):
2395 if not os
.path
.exists(OutputFile
):
2397 if os
.stat(OutputFile
).st_mtime
<= os
.stat(ValueCFile
).st_mtime
:
2399 if os
.stat(OutputFile
).st_mtime
<= os
.stat(StructureInput
).st_mtime
:
2403 ## Retrieve dynamic PCD settings
2405 # @param Type PCD type
2407 # @retval a dict object contains settings of given PCD type
2409 def _GetDynamicPcd(self
, Type
):
2412 Pcds
= OrderedDict()
2414 # tdict is a special dict kind of type, used for selecting correct
2415 # PCD settings for certain ARCH and SKU
2417 PcdDict
= tdict(True, 4)
2419 # Find out all possible PCD candidates for self._Arch
2420 RecordList
= self
._RawData
[Type
, self
._Arch
]
2421 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
2424 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
2425 SkuName
= SkuName
.upper()
2426 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
2427 if SkuName
not in AvailableSkuIdSet
:
2428 EdkLogger
.error('build', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
2429 File
=self
.MetaFile
, Line
=Dummy5
)
2430 if "." not in TokenSpaceGuid
:
2431 PcdList
.append((PcdCName
, TokenSpaceGuid
, SkuName
, Dummy5
))
2432 PcdDict
[Arch
, SkuName
, PcdCName
, TokenSpaceGuid
] = Setting
2434 # Remove redundant PCD candidates, per the ARCH and SKU
2435 for PcdCName
, TokenSpaceGuid
, SkuName
, Dummy4
in PcdList
:
2437 Setting
= PcdDict
[self
._Arch
, SkuName
, PcdCName
, TokenSpaceGuid
]
2441 PcdValue
, DatumType
, MaxDatumSize
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
2443 if int(MaxDatumSize
, 0) > 0xFFFF:
2444 EdkLogger
.error('build', FORMAT_INVALID
, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2445 File
=self
.MetaFile
, Line
=Dummy4
)
2446 if int(MaxDatumSize
, 0) < 0:
2447 EdkLogger
.error('build', FORMAT_INVALID
, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2448 File
=self
.MetaFile
, Line
=Dummy4
)
2449 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], '', '', '', '', '', PcdValue
)
2450 if (PcdCName
, TokenSpaceGuid
) in Pcds
:
2451 pcdObject
= Pcds
[PcdCName
, TokenSpaceGuid
]
2452 pcdObject
.SkuInfoList
[SkuName
] = SkuInfo
2453 if MaxDatumSize
.strip():
2454 CurrentMaxSize
= int(MaxDatumSize
.strip(), 0)
2457 if pcdObject
.MaxDatumSize
:
2458 PcdMaxSize
= int(pcdObject
.MaxDatumSize
, 0)
2461 if CurrentMaxSize
> PcdMaxSize
:
2462 pcdObject
.MaxDatumSize
= str(CurrentMaxSize
)
2464 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
2467 self
._PCD
_TYPE
_STRING
_[Type
],
2472 {SkuName
: SkuInfo
},
2477 if SkuName
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
2478 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
] = {}
2479 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
][TAB_DEFAULT_STORES_DEFAULT
] = PcdValue
2481 for pcd
in Pcds
.values():
2482 pcdDecObject
= self
._DecPcds
[pcd
.TokenCName
, pcd
.TokenSpaceGuidCName
]
2483 # Only fix the value while no value provided in DSC file.
2484 for sku
in pcd
.SkuInfoList
.values():
2485 if not sku
.DefaultValue
:
2486 sku
.DefaultValue
= pcdDecObject
.DefaultValue
2487 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
not in pcd
.SkuInfoList
:
2488 valuefromDec
= pcdDecObject
.DefaultValue
2489 SkuInfo
= SkuInfoClass(TAB_DEFAULT
, '0', '', '', '', '', '', valuefromDec
)
2490 pcd
.SkuInfoList
[TAB_DEFAULT
] = SkuInfo
2491 elif TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2492 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
2493 del pcd
.SkuInfoList
[TAB_COMMON
]
2494 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2495 del pcd
.SkuInfoList
[TAB_COMMON
]
2497 map(self
.FilterSkuSettings
, Pcds
.values())
2501 def FilterSkuSettings(self
, PcdObj
):
2503 if self
.SkuIdMgr
.SkuUsageType
== self
.SkuIdMgr
.SINGLE
:
2504 if TAB_DEFAULT
in PcdObj
.SkuInfoList
and self
.SkuIdMgr
.SystemSkuId
not in PcdObj
.SkuInfoList
:
2505 PcdObj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
] = PcdObj
.SkuInfoList
[TAB_DEFAULT
]
2506 PcdObj
.SkuInfoList
= {TAB_DEFAULT
:PcdObj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
]}
2507 PcdObj
.SkuInfoList
[TAB_DEFAULT
].SkuIdName
= TAB_DEFAULT
2508 PcdObj
.SkuInfoList
[TAB_DEFAULT
].SkuId
= '0'
2510 elif self
.SkuIdMgr
.SkuUsageType
== self
.SkuIdMgr
.DEFAULT
:
2511 PcdObj
.SkuInfoList
= {TAB_DEFAULT
:PcdObj
.SkuInfoList
[TAB_DEFAULT
]}
2516 def CompareVarAttr(Attr1
, Attr2
):
2517 if not Attr1
or not Attr2
: # for empty string
2519 Attr1s
= [attr
.strip() for attr
in Attr1
.split(",")]
2520 Attr1Set
= set(Attr1s
)
2521 Attr2s
= [attr
.strip() for attr
in Attr2
.split(",")]
2522 Attr2Set
= set(Attr2s
)
2523 if Attr2Set
== Attr1Set
:
2528 def CompletePcdValues(self
, PcdSet
):
2530 DefaultStoreObj
= DefaultStore(self
._GetDefaultStores
())
2531 SkuIds
= {skuname
:skuid
for skuname
, skuid
in self
.SkuIdMgr
.AvailableSkuIdSet
.items() if skuname
!= TAB_COMMON
}
2532 DefaultStores
= set(storename
for pcdobj
in PcdSet
.values() for skuobj
in pcdobj
.SkuInfoList
.values() for storename
in skuobj
.DefaultStoreDict
)
2533 for PcdCName
, TokenSpaceGuid
in PcdSet
:
2534 PcdObj
= PcdSet
[(PcdCName
, TokenSpaceGuid
)]
2536 if PcdObj
.Type
not in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_DEFAULT
],
2537 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
2538 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_VPD
],
2539 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_DEFAULT
],
2540 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
],
2541 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_VPD
]]:
2542 Pcds
[PcdCName
, TokenSpaceGuid
]= PcdObj
2544 PcdType
= PcdObj
.Type
2545 if PcdType
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
2546 for skuid
in PcdObj
.SkuInfoList
:
2547 skuobj
= PcdObj
.SkuInfoList
[skuid
]
2548 mindefaultstorename
= DefaultStoreObj
.GetMin(set(defaultstorename
for defaultstorename
in skuobj
.DefaultStoreDict
))
2549 for defaultstorename
in DefaultStores
:
2550 if defaultstorename
not in skuobj
.DefaultStoreDict
:
2551 skuobj
.DefaultStoreDict
[defaultstorename
] = copy
.deepcopy(skuobj
.DefaultStoreDict
[mindefaultstorename
])
2552 skuobj
.HiiDefaultValue
= skuobj
.DefaultStoreDict
[mindefaultstorename
]
2553 for skuname
, skuid
in SkuIds
.items():
2554 if skuname
not in PcdObj
.SkuInfoList
:
2555 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(skuname
)
2556 while nextskuid
not in PcdObj
.SkuInfoList
:
2557 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
2558 PcdObj
.SkuInfoList
[skuname
] = copy
.deepcopy(PcdObj
.SkuInfoList
[nextskuid
])
2559 PcdObj
.SkuInfoList
[skuname
].SkuId
= skuid
2560 PcdObj
.SkuInfoList
[skuname
].SkuIdName
= skuname
2561 if PcdType
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
2562 PcdObj
.DefaultValue
= PcdObj
.SkuInfoList
.values()[0].HiiDefaultValue
if self
.SkuIdMgr
.SkuUsageType
== self
.SkuIdMgr
.SINGLE
else PcdObj
.SkuInfoList
[TAB_DEFAULT
].HiiDefaultValue
2563 Pcds
[PcdCName
, TokenSpaceGuid
]= PcdObj
2565 ## Retrieve dynamic HII PCD settings
2567 # @param Type PCD type
2569 # @retval a dict object contains settings of given PCD type
2571 def _GetDynamicHiiPcd(self
, Type
):
2575 Pcds
= OrderedDict()
2576 UserDefinedDefaultStores
= []
2578 # tdict is a special dict kind of type, used for selecting correct
2579 # PCD settings for certain ARCH and SKU
2581 PcdDict
= tdict(True, 5)
2583 RecordList
= self
._RawData
[Type
, self
._Arch
]
2584 # Find out all possible PCD candidates for self._Arch
2585 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
2586 DefaultStoresDefine
= self
._GetDefaultStores
()
2588 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, DefaultStore
, Dummy4
, Dummy5
in RecordList
:
2589 SkuName
= SkuName
.upper()
2590 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
2591 DefaultStore
= DefaultStore
.upper()
2592 if DefaultStore
== TAB_COMMON
:
2593 DefaultStore
= TAB_DEFAULT_STORES_DEFAULT
2595 #The end user define [DefaultStores] and [SKUID_IDENTIFIER.Menufacturing] in DSC
2596 UserDefinedDefaultStores
.append((PcdCName
, TokenSpaceGuid
))
2597 if SkuName
not in AvailableSkuIdSet
:
2598 EdkLogger
.error('build', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
2599 File
=self
.MetaFile
, Line
=Dummy5
)
2600 if DefaultStore
not in DefaultStoresDefine
:
2601 EdkLogger
.error('build', PARAMETER_INVALID
, 'DefaultStores %s is not defined in [DefaultStores] section' % DefaultStore
,
2602 File
=self
.MetaFile
, Line
=Dummy5
)
2603 if "." not in TokenSpaceGuid
:
2604 PcdSet
.add((PcdCName
, TokenSpaceGuid
, SkuName
, DefaultStore
, Dummy5
))
2605 PcdDict
[Arch
, SkuName
, PcdCName
, TokenSpaceGuid
, DefaultStore
] = Setting
2608 # Remove redundant PCD candidates, per the ARCH and SKU
2609 for PcdCName
, TokenSpaceGuid
, SkuName
, DefaultStore
, Dummy4
in PcdSet
:
2611 Setting
= PcdDict
[self
._Arch
, SkuName
, PcdCName
, TokenSpaceGuid
, DefaultStore
]
2614 VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VarAttribute
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
2616 rt
, Msg
= VariableAttributes
.ValidateVarAttributes(VarAttribute
)
2618 EdkLogger
.error("build", PCD_VARIABLE_ATTRIBUTES_ERROR
, "Variable attributes settings for %s is incorrect.\n %s" % (".".join((TokenSpaceGuid
, PcdCName
)), Msg
),
2619 ExtraData
="[%s]" % VarAttribute
)
2621 FormatCorrect
= True
2622 if VariableOffset
.isdigit():
2623 if int(VariableOffset
, 10) > 0xFFFF:
2625 elif variablePattern
.match(VariableOffset
):
2626 if int(VariableOffset
, 16) > 0xFFFF:
2628 # For Offset written in "A.B"
2629 elif VariableOffset
.find('.') > -1:
2630 VariableOffsetList
= VariableOffset
.split(".")
2631 if not (len(VariableOffsetList
) == 2
2632 and IsValidWord(VariableOffsetList
[0])
2633 and IsValidWord(VariableOffsetList
[1])):
2634 FormatCorrect
= False
2636 FormatCorrect
= False
2637 if not FormatCorrect
:
2638 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid
, PcdCName
)))
2641 EdkLogger
.error('Build', OPTION_VALUE_INVALID
, "The variable offset value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)))
2642 if (VariableName
, VariableGuid
) not in VariableAttrs
:
2643 VariableAttrs
[(VariableName
, VariableGuid
)] = VarAttribute
2645 if not DscBuildData
.CompareVarAttr(VariableAttrs
[(VariableName
, VariableGuid
)], VarAttribute
):
2646 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
)]))
2648 pcdDecObject
= self
._DecPcds
[PcdCName
, TokenSpaceGuid
]
2649 if (PcdCName
, TokenSpaceGuid
) in Pcds
:
2650 pcdObject
= Pcds
[PcdCName
, TokenSpaceGuid
]
2651 if SkuName
in pcdObject
.SkuInfoList
:
2652 Skuitem
= pcdObject
.SkuInfoList
[SkuName
]
2653 Skuitem
.DefaultStoreDict
.update({DefaultStore
:DefaultValue
})
2655 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VariableAttribute
=VarAttribute
, DefaultStore
={DefaultStore
:DefaultValue
})
2656 pcdObject
.SkuInfoList
[SkuName
] = SkuInfo
2658 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VariableAttribute
=VarAttribute
, DefaultStore
={DefaultStore
:DefaultValue
})
2659 PcdClassObj
= PcdClassObject(
2662 self
._PCD
_TYPE
_STRING
_[Type
],
2667 {SkuName
: SkuInfo
},
2670 pcdDecObject
.validateranges
,
2671 pcdDecObject
.validlists
,
2672 pcdDecObject
.expressions
,
2674 if (PcdCName
, TokenSpaceGuid
) in UserDefinedDefaultStores
:
2675 PcdClassObj
.UserDefinedDefaultStoresFlag
= True
2676 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObj
2678 if SkuName
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
2679 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
] = {}
2680 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
][DefaultStore
] = DefaultValue
2681 for pcd
in Pcds
.values():
2682 SkuInfoObj
= pcd
.SkuInfoList
.values()[0]
2683 pcdDecObject
= self
._DecPcds
[pcd
.TokenCName
, pcd
.TokenSpaceGuidCName
]
2684 pcd
.DatumType
= pcdDecObject
.DatumType
2685 # Only fix the value while no value provided in DSC file.
2686 for sku
in pcd
.SkuInfoList
.values():
2687 if (sku
.HiiDefaultValue
== "" or sku
.HiiDefaultValue
is None):
2688 sku
.HiiDefaultValue
= pcdDecObject
.DefaultValue
2689 for default_store
in sku
.DefaultStoreDict
:
2690 sku
.DefaultStoreDict
[default_store
]=pcdDecObject
.DefaultValue
2691 pcd
.DefaultValue
= pcdDecObject
.DefaultValue
2692 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
not in pcd
.SkuInfoList
:
2693 valuefromDec
= pcdDecObject
.DefaultValue
2694 SkuInfo
= SkuInfoClass(TAB_DEFAULT
, '0', SkuInfoObj
.VariableName
, SkuInfoObj
.VariableGuid
, SkuInfoObj
.VariableOffset
, valuefromDec
, VariableAttribute
=SkuInfoObj
.VariableAttribute
, DefaultStore
={DefaultStore
:valuefromDec
})
2695 pcd
.SkuInfoList
[TAB_DEFAULT
] = SkuInfo
2696 elif TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2697 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
2698 del pcd
.SkuInfoList
[TAB_COMMON
]
2699 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2700 del pcd
.SkuInfoList
[TAB_COMMON
]
2702 if pcd
.MaxDatumSize
.strip():
2703 MaxSize
= int(pcd
.MaxDatumSize
, 0)
2706 if pcd
.DatumType
not in TAB_PCD_NUMERIC_TYPES
:
2707 for (_
, skuobj
) in pcd
.SkuInfoList
.items():
2709 skuobj
.HiiDefaultValue
= StringToArray(skuobj
.HiiDefaultValue
)
2710 datalen
= len(skuobj
.HiiDefaultValue
.split(","))
2711 if datalen
> MaxSize
:
2713 for defaultst
in skuobj
.DefaultStoreDict
:
2714 skuobj
.DefaultStoreDict
[defaultst
] = StringToArray(skuobj
.DefaultStoreDict
[defaultst
])
2715 pcd
.DefaultValue
= StringToArray(pcd
.DefaultValue
)
2716 pcd
.MaxDatumSize
= str(MaxSize
)
2717 rt
, invalidhii
= DscBuildData
.CheckVariableNameAssignment(Pcds
)
2719 invalidpcd
= ",".join(invalidhii
)
2720 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
)
2722 map(self
.FilterSkuSettings
, Pcds
.values())
2727 def CheckVariableNameAssignment(Pcds
):
2729 for pcdname
in Pcds
:
2731 varnameset
= set(sku
.VariableName
for (skuid
, sku
) in pcd
.SkuInfoList
.items())
2732 if len(varnameset
) > 1:
2733 invalidhii
.append(".".join((pcdname
[1], pcdname
[0])))
2735 return False, invalidhii
2738 ## Retrieve dynamic VPD PCD settings
2740 # @param Type PCD type
2742 # @retval a dict object contains settings of given PCD type
2744 def _GetDynamicVpdPcd(self
, Type
):
2747 Pcds
= OrderedDict()
2749 # tdict is a special dict kind of type, used for selecting correct
2750 # PCD settings for certain ARCH and SKU
2752 PcdDict
= tdict(True, 4)
2755 # Find out all possible PCD candidates for self._Arch
2756 RecordList
= self
._RawData
[Type
, self
._Arch
]
2757 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
2759 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
2760 SkuName
= SkuName
.upper()
2761 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
2762 if SkuName
not in AvailableSkuIdSet
:
2763 EdkLogger
.error('build', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
2764 File
=self
.MetaFile
, Line
=Dummy5
)
2765 if "." not in TokenSpaceGuid
:
2766 PcdList
.append((PcdCName
, TokenSpaceGuid
, SkuName
, Dummy5
))
2767 PcdDict
[Arch
, SkuName
, PcdCName
, TokenSpaceGuid
] = Setting
2769 # Remove redundant PCD candidates, per the ARCH and SKU
2770 for PcdCName
, TokenSpaceGuid
, SkuName
, Dummy4
in PcdList
:
2771 Setting
= PcdDict
[self
._Arch
, SkuName
, PcdCName
, TokenSpaceGuid
]
2775 # For the VOID* type, it can have optional data of MaxDatumSize and InitialValue
2776 # For the Integer & Boolean type, the optional data can only be InitialValue.
2777 # At this point, we put all the data into the PcdClssObject for we don't know the PCD's datumtype
2778 # until the DEC parser has been called.
2780 VpdOffset
, MaxDatumSize
, InitialValue
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
2782 if int(MaxDatumSize
, 0) > 0xFFFF:
2783 EdkLogger
.error('build', FORMAT_INVALID
, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2784 File
=self
.MetaFile
, Line
=Dummy4
)
2785 if int(MaxDatumSize
, 0) < 0:
2786 EdkLogger
.error('build', FORMAT_INVALID
, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2787 File
=self
.MetaFile
, Line
=Dummy4
)
2788 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], '', '', '', '', VpdOffset
, InitialValue
)
2789 if (PcdCName
, TokenSpaceGuid
) in Pcds
:
2790 pcdObject
= Pcds
[PcdCName
, TokenSpaceGuid
]
2791 pcdObject
.SkuInfoList
[SkuName
] = SkuInfo
2792 if MaxDatumSize
.strip():
2793 CurrentMaxSize
= int(MaxDatumSize
.strip(), 0)
2796 if pcdObject
.MaxDatumSize
:
2797 PcdMaxSize
= int(pcdObject
.MaxDatumSize
, 0)
2800 if CurrentMaxSize
> PcdMaxSize
:
2801 pcdObject
.MaxDatumSize
= str(CurrentMaxSize
)
2803 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
2806 self
._PCD
_TYPE
_STRING
_[Type
],
2811 {SkuName
: SkuInfo
},
2816 if SkuName
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
2817 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
] = {}
2818 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
][TAB_DEFAULT_STORES_DEFAULT
] = InitialValue
2819 for pcd
in Pcds
.values():
2820 SkuInfoObj
= pcd
.SkuInfoList
.values()[0]
2821 pcdDecObject
= self
._DecPcds
[pcd
.TokenCName
, pcd
.TokenSpaceGuidCName
]
2822 pcd
.DatumType
= pcdDecObject
.DatumType
2823 # Only fix the value while no value provided in DSC file.
2824 for sku
in pcd
.SkuInfoList
.values():
2825 if not sku
.DefaultValue
:
2826 sku
.DefaultValue
= pcdDecObject
.DefaultValue
2827 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
not in pcd
.SkuInfoList
:
2828 valuefromDec
= pcdDecObject
.DefaultValue
2829 SkuInfo
= SkuInfoClass(TAB_DEFAULT
, '0', '', '', '', '', SkuInfoObj
.VpdOffset
, valuefromDec
)
2830 pcd
.SkuInfoList
[TAB_DEFAULT
] = SkuInfo
2831 elif TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2832 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
2833 del pcd
.SkuInfoList
[TAB_COMMON
]
2834 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2835 del pcd
.SkuInfoList
[TAB_COMMON
]
2838 map(self
.FilterSkuSettings
, Pcds
.values())
2841 ## Add external modules
2843 # The external modules are mostly those listed in FDF file, which don't
2846 # @param FilePath The path of module description file
2848 def AddModule(self
, FilePath
):
2849 FilePath
= NormPath(FilePath
)
2850 if FilePath
not in self
.Modules
:
2851 Module
= ModuleBuildClassObject()
2852 Module
.MetaFile
= FilePath
2853 self
.Modules
.append(Module
)
2856 def ToolChainFamily(self
):
2857 self
._ToolChainFamily
= TAB_COMPILER_MSFT
2858 BuildConfigurationFile
= os
.path
.normpath(os
.path
.join(GlobalData
.gConfDirectory
, "target.txt"))
2859 if os
.path
.isfile(BuildConfigurationFile
) == True:
2860 TargetTxt
= TargetTxtClassObject()
2861 TargetTxt
.LoadTargetTxtFile(BuildConfigurationFile
)
2862 ToolDefinitionFile
= TargetTxt
.TargetTxtDictionary
[DataType
.TAB_TAT_DEFINES_TOOL_CHAIN_CONF
]
2863 if ToolDefinitionFile
== '':
2864 ToolDefinitionFile
= "tools_def.txt"
2865 ToolDefinitionFile
= os
.path
.normpath(mws
.join(self
.WorkspaceDir
, 'Conf', ToolDefinitionFile
))
2866 if os
.path
.isfile(ToolDefinitionFile
) == True:
2867 ToolDef
= ToolDefClassObject()
2868 ToolDef
.LoadToolDefFile(ToolDefinitionFile
)
2869 ToolDefinition
= ToolDef
.ToolsDefTxtDatabase
2870 if TAB_TOD_DEFINES_FAMILY
not in ToolDefinition \
2871 or self
._Toolchain
not in ToolDefinition
[TAB_TOD_DEFINES_FAMILY
] \
2872 or not ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][self
._Toolchain
]:
2873 self
._ToolChainFamily
= TAB_COMPILER_MSFT
2875 self
._ToolChainFamily
= ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][self
._Toolchain
]
2876 return self
._ToolChainFamily
2878 ## Add external PCDs
2880 # The external PCDs are mostly those listed in FDF file to specify address
2881 # or offset information.
2883 # @param Name Name of the PCD
2884 # @param Guid Token space guid of the PCD
2885 # @param Value Value of the PCD
2887 def AddPcd(self
, Name
, Guid
, Value
):
2888 if (Name
, Guid
) not in self
.Pcds
:
2889 self
.Pcds
[Name
, Guid
] = PcdClassObject(Name
, Guid
, '', '', '', '', '', {}, False, None)
2890 self
.Pcds
[Name
, Guid
].DefaultValue
= Value
2894 if self
._DecPcds
is None:
2896 if GlobalData
.gFdfParser
:
2897 FdfInfList
= GlobalData
.gFdfParser
.Profile
.InfList
2899 for Inf
in FdfInfList
:
2900 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
2901 if ModuleFile
in self
._Modules
:
2903 ModuleData
= self
._Bdb
[ModuleFile
, self
._Arch
, self
._Target
, self
._Toolchain
]
2904 PkgSet
.update(ModuleData
.Packages
)
2905 self
._DecPcds
, self
._GuidDict
= GetDeclaredPcd(self
, self
._Bdb
, self
._Arch
, self
._Target
, self
._Toolchain
, PkgSet
)
2906 return self
._DecPcds