2 # This file is used to create a database used by build tool
4 # Copyright (c) 2008 - 2018, Intel Corporation. All rights reserved.<BR>
5 # (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
6 # This program and the accompanying materials
7 # are licensed and made available under the terms and conditions of the BSD License
8 # which accompanies this distribution. The full text of the license may be found at
9 # http://opensource.org/licenses/bsd-license.php
11 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 ## Platform build information from DSC file
17 # This class is used to retrieve information stored in database and convert them
18 # into PlatformBuildClassObject form for easier use for AutoGen.
20 from Common
.StringUtils
import *
21 from Common
.DataType
import *
22 from Common
.Misc
import *
24 from Common
.Expression
import *
25 from CommonDataClass
.CommonClass
import SkuInfoClass
26 from Common
.TargetTxtClassObject
import *
27 from Common
.ToolDefClassObject
import *
28 from .MetaDataTable
import *
29 from .MetaFileTable
import *
30 from .MetaFileParser
import *
32 from .WorkspaceCommon
import GetDeclaredPcd
33 from Common
.Misc
import AnalyzeDscPcd
34 from Common
.Misc
import ProcessDuplicatedInf
36 from Common
.Parsing
import IsValidWord
37 from Common
.VariableAttributes
import VariableAttributes
38 import Common
.GlobalData
as GlobalData
40 from Common
.Misc
import SaveFileOnChange
41 from Workspace
.BuildClassObject
import PlatformBuildClassObject
, StructurePcd
, PcdClassObject
, ModuleBuildClassObject
42 from collections
import OrderedDict
, defaultdict
44 PcdValueInitName
= 'PcdValueInit'
55 #include <PcdValueCommon.h>
65 return PcdValueMain (argc, argv);
69 PcdMakefileHeader
= '''
72 # This file is auto-generated by build utility
77 WindowsCFLAGS
= 'CFLAGS = $(CFLAGS) /wd4200 /wd4034 /wd4101 '
78 LinuxCFLAGS
= 'BUILD_CFLAGS += -Wno-pointer-to-int-cast -Wno-unused-variable '
80 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.common
82 LIBS = $(LIB_PATH)\Common.lib
84 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.app
88 MAKEROOT ?= $(EDK_TOOLS_PATH)/Source/C
92 variablePattern
= re
.compile(r
'[\t\s]*0[xX][a-fA-F0-9]+$')
93 SkuIdPattern
= re
.compile(r
'^[a-zA-Z_][a-zA-Z0-9_]*$')
94 ## regular expressions for finding decimal and hex numbers
95 Pattern
= re
.compile('^[1-9]\d*|0$')
96 HexPattern
= re
.compile(r
'0[xX][0-9a-fA-F]+$')
97 ## Regular expression for finding header file inclusions
98 from AutoGen
.GenMake
import gIncludePattern
100 ## Find dependencies for one source file
102 # By searching recursively "#include" directive in file, find out all the
103 # files needed by given source file. The dependecies will be only searched
104 # in given search path list.
106 # @param SearchPathList The list of search path
108 # @retval list The list of files the given source file depends on
110 def GetDependencyList(FileStack
, SearchPathList
):
112 DependencySet
= set(FileStack
)
113 while len(FileStack
) > 0:
115 FullPathDependList
= []
116 CurrentFileDependencyList
= []
118 CurrentFileDependencyList
= DepDb
[F
]
122 FileContent
= Fd
.read()
123 except BaseException
as X
:
124 EdkLogger
.error("build", FILE_OPEN_FAILURE
, ExtraData
=F
+ "\n\t" + str(X
))
126 if "Fd" in dir(locals()):
129 if len(FileContent
) == 0:
132 if FileContent
[0] == 0xff or FileContent
[0] == 0xfe:
133 FileContent
= unicode(FileContent
, "utf-16")
134 IncludedFileList
= gIncludePattern
.findall(FileContent
)
136 for Inc
in IncludedFileList
:
138 Inc
= os
.path
.normpath(Inc
)
139 CurrentFileDependencyList
.append(Inc
)
140 DepDb
[F
] = CurrentFileDependencyList
142 CurrentFilePath
= os
.path
.dirname(F
)
143 PathList
= [CurrentFilePath
] + SearchPathList
144 for Inc
in CurrentFileDependencyList
:
145 for SearchPath
in PathList
:
146 FilePath
= os
.path
.join(SearchPath
, Inc
)
147 if not os
.path
.exists(FilePath
):
149 if FilePath
not in DependencySet
:
150 FileStack
.append(FilePath
)
151 FullPathDependList
.append(FilePath
)
153 DependencySet
.update(FullPathDependList
)
154 DependencyList
= list(DependencySet
) # remove duplicate ones
156 return DependencyList
158 class DscBuildData(PlatformBuildClassObject
):
159 # dict used to convert PCD type in database to string used by build tool
160 _PCD_TYPE_STRING_
= {
161 MODEL_PCD_FIXED_AT_BUILD
: TAB_PCDS_FIXED_AT_BUILD
,
162 MODEL_PCD_PATCHABLE_IN_MODULE
: TAB_PCDS_PATCHABLE_IN_MODULE
,
163 MODEL_PCD_FEATURE_FLAG
: TAB_PCDS_FEATURE_FLAG
,
164 MODEL_PCD_DYNAMIC
: TAB_PCDS_DYNAMIC
,
165 MODEL_PCD_DYNAMIC_DEFAULT
: TAB_PCDS_DYNAMIC
,
166 MODEL_PCD_DYNAMIC_HII
: TAB_PCDS_DYNAMIC_HII
,
167 MODEL_PCD_DYNAMIC_VPD
: TAB_PCDS_DYNAMIC_VPD
,
168 MODEL_PCD_DYNAMIC_EX
: TAB_PCDS_DYNAMIC_EX
,
169 MODEL_PCD_DYNAMIC_EX_DEFAULT
: TAB_PCDS_DYNAMIC_EX
,
170 MODEL_PCD_DYNAMIC_EX_HII
: TAB_PCDS_DYNAMIC_EX_HII
,
171 MODEL_PCD_DYNAMIC_EX_VPD
: TAB_PCDS_DYNAMIC_EX_VPD
,
174 # dict used to convert part of [Defines] to members of DscBuildData directly
179 TAB_DSC_DEFINES_PLATFORM_NAME
: "_PlatformName",
180 TAB_DSC_DEFINES_PLATFORM_GUID
: "_Guid",
181 TAB_DSC_DEFINES_PLATFORM_VERSION
: "_Version",
182 TAB_DSC_DEFINES_DSC_SPECIFICATION
: "_DscSpecification",
183 # TAB_DSC_DEFINES_OUTPUT_DIRECTORY : "_OutputDirectory",
184 # TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES : "_SupArchList",
185 # TAB_DSC_DEFINES_BUILD_TARGETS : "_BuildTargets",
186 TAB_DSC_DEFINES_SKUID_IDENTIFIER
: "_SkuName",
187 # TAB_DSC_DEFINES_FLASH_DEFINITION : "_FlashDefinition",
188 TAB_DSC_DEFINES_BUILD_NUMBER
: "_BuildNumber",
189 TAB_DSC_DEFINES_MAKEFILE_NAME
: "_MakefileName",
190 TAB_DSC_DEFINES_BS_BASE_ADDRESS
: "_BsBaseAddress",
191 TAB_DSC_DEFINES_RT_BASE_ADDRESS
: "_RtBaseAddress",
192 # TAB_DSC_DEFINES_RFC_LANGUAGES : "_RFCLanguages",
193 # TAB_DSC_DEFINES_ISO_LANGUAGES : "_ISOLanguages",
196 # used to compose dummy library class name for those forced library instances
197 _NullLibraryNumber
= 0
199 ## Constructor of DscBuildData
201 # Initialize object of DscBuildData
203 # @param FilePath The path of platform description file
204 # @param RawData The raw data of DSC file
205 # @param BuildDataBase Database used to retrieve module/package information
206 # @param Arch The target architecture
207 # @param Platform (not used for DscBuildData)
208 # @param Macros Macros used for replacement in DSC file
210 def __init__(self
, FilePath
, RawData
, BuildDataBase
, Arch
=TAB_ARCH_COMMON
, Target
=None, Toolchain
=None):
211 self
.MetaFile
= FilePath
212 self
._RawData
= RawData
213 self
._Bdb
= BuildDataBase
215 self
._Target
= Target
216 self
._Toolchain
= Toolchain
217 self
._ToolChainFamily
= None
219 self
._HandleOverridePath
()
220 self
.WorkspaceDir
= os
.getenv("WORKSPACE") if os
.getenv("WORKSPACE") else ""
221 self
.DefaultStores
= None
222 self
.SkuIdMgr
= SkuClass(self
.SkuName
, self
.SkuIds
)
225 def OutputPath(self
):
226 if os
.getenv("WORKSPACE"):
227 return os
.path
.join(os
.getenv("WORKSPACE"), self
.OutputDirectory
, self
._Target
+ "_" + self
._Toolchain
, PcdValueInitName
)
229 return os
.path
.dirname(self
.DscFile
)
232 def __setitem__(self
, key
, value
):
233 self
.__dict
__[self
._PROPERTY
_[key
]] = value
236 def __getitem__(self
, key
):
237 return self
.__dict
__[self
._PROPERTY
_[key
]]
240 def __contains__(self
, key
):
241 return key
in self
._PROPERTY
_
243 ## Set all internal used members of DscBuildData to None
246 self
._PlatformName
= None
249 self
._DscSpecification
= None
250 self
._OutputDirectory
= None
251 self
._SupArchList
= None
252 self
._BuildTargets
= None
254 self
._PcdInfoFlag
= None
255 self
._VarCheckFlag
= None
256 self
._FlashDefinition
= None
257 self
._Prebuild
= None
258 self
._Postbuild
= None
259 self
._BuildNumber
= None
260 self
._MakefileName
= None
261 self
._BsBaseAddress
= None
262 self
._RtBaseAddress
= None
265 self
._LibraryInstances
= None
266 self
._LibraryClasses
= None
269 self
._BuildOptions
= None
270 self
._ModuleTypeOptions
= None
271 self
._LoadFixAddress
= None
272 self
._RFCLanguages
= None
273 self
._ISOLanguages
= None
274 self
._VpdToolGuid
= None
275 self
._MacroDict
= None
276 self
.DefaultStores
= None
278 ## handle Override Path of Module
279 def _HandleOverridePath(self
):
280 RecordList
= self
._RawData
[MODEL_META_DATA_COMPONENT
, self
._Arch
]
281 for Record
in RecordList
:
284 ModuleFile
= PathClass(NormPath(Record
[0]), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
285 RecordList
= self
._RawData
[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH
, self
._Arch
, None, ModuleId
]
287 SourceOverridePath
= mws
.join(GlobalData
.gWorkspace
, NormPath(RecordList
[0][0]))
289 # Check if the source override path exists
290 if not os
.path
.isdir(SourceOverridePath
):
291 EdkLogger
.error('build', FILE_NOT_FOUND
, Message
='Source override path does not exist:', File
=self
.MetaFile
, ExtraData
=SourceOverridePath
, Line
=LineNo
)
293 # Add to GlobalData Variables
294 GlobalData
.gOverrideDir
[ModuleFile
.Key
] = SourceOverridePath
296 ## Get current effective macros
299 if self
._MacroDict
is None:
301 self
._MacroDict
.update(GlobalData
.gPlatformDefines
)
302 self
._MacroDict
.update(GlobalData
.gGlobalDefines
)
303 self
._MacroDict
.update(GlobalData
.gCommandLineDefines
)
304 return self
._MacroDict
311 ## Retrieve all information in [Defines] section
313 # (Retriving all [Defines] information in one-shot is just to save time.)
315 def _GetHeaderInfo(self
):
316 RecordList
= self
._RawData
[MODEL_META_DATA_HEADER
, self
._Arch
]
317 for Record
in RecordList
:
319 # items defined _PROPERTY_ don't need additional processing
321 # some special items in [Defines] section need special treatment
322 if Name
== TAB_DSC_DEFINES_OUTPUT_DIRECTORY
:
323 self
._OutputDirectory
= NormPath(Record
[2], self
._Macros
)
324 if ' ' in self
._OutputDirectory
:
325 EdkLogger
.error("build", FORMAT_NOT_SUPPORTED
, "No space is allowed in OUTPUT_DIRECTORY",
326 File
=self
.MetaFile
, Line
=Record
[-1],
327 ExtraData
=self
._OutputDirectory
)
328 elif Name
== TAB_DSC_DEFINES_FLASH_DEFINITION
:
329 self
._FlashDefinition
= PathClass(NormPath(Record
[2], self
._Macros
), GlobalData
.gWorkspace
)
330 ErrorCode
, ErrorInfo
= self
._FlashDefinition
.Validate('.fdf')
332 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=Record
[-1],
334 elif Name
== TAB_DSC_PREBUILD
:
335 PrebuildValue
= Record
[2]
336 if Record
[2][0] == '"':
337 if Record
[2][-1] != '"':
338 EdkLogger
.error('build', FORMAT_INVALID
, 'Missing double quotes in the end of %s statement.' % TAB_DSC_PREBUILD
,
339 File
=self
.MetaFile
, Line
=Record
[-1])
340 PrebuildValue
= Record
[2][1:-1]
341 self
._Prebuild
= PrebuildValue
342 elif Name
== TAB_DSC_POSTBUILD
:
343 PostbuildValue
= Record
[2]
344 if Record
[2][0] == '"':
345 if Record
[2][-1] != '"':
346 EdkLogger
.error('build', FORMAT_INVALID
, 'Missing double quotes in the end of %s statement.' % TAB_DSC_POSTBUILD
,
347 File
=self
.MetaFile
, Line
=Record
[-1])
348 PostbuildValue
= Record
[2][1:-1]
349 self
._Postbuild
= PostbuildValue
350 elif Name
== TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES
:
351 self
._SupArchList
= GetSplitValueList(Record
[2], TAB_VALUE_SPLIT
)
352 elif Name
== TAB_DSC_DEFINES_BUILD_TARGETS
:
353 self
._BuildTargets
= GetSplitValueList(Record
[2])
354 elif Name
== TAB_DSC_DEFINES_SKUID_IDENTIFIER
:
355 if self
._SkuName
is None:
356 self
._SkuName
= Record
[2]
357 if GlobalData
.gSKUID_CMD
:
358 self
._SkuName
= GlobalData
.gSKUID_CMD
359 elif Name
== TAB_DSC_DEFINES_PCD_INFO_GENERATION
:
360 self
._PcdInfoFlag
= Record
[2]
361 elif Name
== TAB_DSC_DEFINES_PCD_VAR_CHECK_GENERATION
:
362 self
._VarCheckFlag
= Record
[2]
363 elif Name
== TAB_FIX_LOAD_TOP_MEMORY_ADDRESS
:
365 self
._LoadFixAddress
= int (Record
[2], 0)
367 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (Record
[2]))
368 elif Name
== TAB_DSC_DEFINES_RFC_LANGUAGES
:
369 if not Record
[2] or Record
[2][0] != '"' or Record
[2][-1] != '"' or len(Record
[2]) == 1:
370 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"',
371 File
=self
.MetaFile
, Line
=Record
[-1])
372 LanguageCodes
= Record
[2][1:-1]
373 if not LanguageCodes
:
374 EdkLogger
.error('build', FORMAT_NOT_SUPPORTED
, 'one or more RFC4646 format language code must be provided for RFC_LANGUAGES statement',
375 File
=self
.MetaFile
, Line
=Record
[-1])
376 LanguageList
= GetSplitValueList(LanguageCodes
, TAB_SEMI_COLON_SPLIT
)
377 # check whether there is empty entries in the list
378 if None in LanguageList
:
379 EdkLogger
.error('build', FORMAT_NOT_SUPPORTED
, 'one or more empty language code is in RFC_LANGUAGES statement',
380 File
=self
.MetaFile
, Line
=Record
[-1])
381 self
._RFCLanguages
= LanguageList
382 elif Name
== TAB_DSC_DEFINES_ISO_LANGUAGES
:
383 if not Record
[2] or Record
[2][0] != '"' or Record
[2][-1] != '"' or len(Record
[2]) == 1:
384 EdkLogger
.error('build', FORMAT_NOT_SUPPORTED
, 'language code for ISO_LANGUAGES must have double quotes around it, for example: ISO_LANGUAGES = "engchn"',
385 File
=self
.MetaFile
, Line
=Record
[-1])
386 LanguageCodes
= Record
[2][1:-1]
387 if not LanguageCodes
:
388 EdkLogger
.error('build', FORMAT_NOT_SUPPORTED
, 'one or more ISO639-2 format language code must be provided for ISO_LANGUAGES statement',
389 File
=self
.MetaFile
, Line
=Record
[-1])
390 if len(LanguageCodes
) % 3:
391 EdkLogger
.error('build', FORMAT_NOT_SUPPORTED
, 'bad ISO639-2 format for ISO_LANGUAGES',
392 File
=self
.MetaFile
, Line
=Record
[-1])
394 for i
in range(0, len(LanguageCodes
), 3):
395 LanguageList
.append(LanguageCodes
[i
:i
+ 3])
396 self
._ISOLanguages
= LanguageList
397 elif Name
== TAB_DSC_DEFINES_VPD_TOOL_GUID
:
399 # try to convert GUID to a real UUID value to see whether the GUID is format
400 # for VPD_TOOL_GUID is correct.
405 EdkLogger
.error("build", FORMAT_INVALID
, "Invalid GUID format for VPD_TOOL_GUID", File
=self
.MetaFile
)
406 self
._VpdToolGuid
= Record
[2]
408 self
[Name
] = Record
[2]
409 # set _Header to non-None in order to avoid database re-querying
410 self
._Header
= 'DUMMY'
412 ## Retrieve platform name
414 def PlatformName(self
):
415 if self
._PlatformName
is None:
416 if self
._Header
is None:
417 self
._GetHeaderInfo
()
418 if self
._PlatformName
is None:
419 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No PLATFORM_NAME", File
=self
.MetaFile
)
420 return self
._PlatformName
424 return self
.PlatformName
426 ## Retrieve file guid
429 if self
._Guid
is None:
430 if self
._Header
is None:
431 self
._GetHeaderInfo
()
432 if self
._Guid
is None:
433 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No PLATFORM_GUID", File
=self
.MetaFile
)
436 ## Retrieve platform version
439 if self
._Version
is None:
440 if self
._Header
is None:
441 self
._GetHeaderInfo
()
442 if self
._Version
is None:
443 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No PLATFORM_VERSION", File
=self
.MetaFile
)
446 ## Retrieve platform description file version
448 def DscSpecification(self
):
449 if self
._DscSpecification
is None:
450 if self
._Header
is None:
451 self
._GetHeaderInfo
()
452 if self
._DscSpecification
is None:
453 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No DSC_SPECIFICATION", File
=self
.MetaFile
)
454 return self
._DscSpecification
456 ## Retrieve OUTPUT_DIRECTORY
458 def OutputDirectory(self
):
459 if self
._OutputDirectory
is None:
460 if self
._Header
is None:
461 self
._GetHeaderInfo
()
462 if self
._OutputDirectory
is None:
463 self
._OutputDirectory
= os
.path
.join("Build", self
._PlatformName
)
464 return self
._OutputDirectory
466 ## Retrieve SUPPORTED_ARCHITECTURES
468 def SupArchList(self
):
469 if self
._SupArchList
is None:
470 if self
._Header
is None:
471 self
._GetHeaderInfo
()
472 if self
._SupArchList
is None:
473 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No SUPPORTED_ARCHITECTURES", File
=self
.MetaFile
)
474 return self
._SupArchList
476 ## Retrieve BUILD_TARGETS
478 def BuildTargets(self
):
479 if self
._BuildTargets
is None:
480 if self
._Header
is None:
481 self
._GetHeaderInfo
()
482 if self
._BuildTargets
is None:
483 EdkLogger
.error('build', ATTRIBUTE_NOT_AVAILABLE
, "No BUILD_TARGETS", File
=self
.MetaFile
)
484 return self
._BuildTargets
487 def PcdInfoFlag(self
):
488 if self
._PcdInfoFlag
is None or self
._PcdInfoFlag
.upper() == 'FALSE':
490 elif self
._PcdInfoFlag
.upper() == 'TRUE':
496 def VarCheckFlag(self
):
497 if self
._VarCheckFlag
is None or self
._VarCheckFlag
.upper() == 'FALSE':
499 elif self
._VarCheckFlag
.upper() == 'TRUE':
504 # # Retrieve SKUID_IDENTIFIER
507 if self
._SkuName
is None:
508 if self
._Header
is None:
509 self
._GetHeaderInfo
()
510 if self
._SkuName
is None:
511 self
._SkuName
= TAB_DEFAULT
514 ## Override SKUID_IDENTIFIER
516 def SkuName(self
, Value
):
517 self
._SkuName
= Value
520 def FlashDefinition(self
):
521 if self
._FlashDefinition
is None:
522 if self
._Header
is None:
523 self
._GetHeaderInfo
()
524 if self
._FlashDefinition
is None:
525 self
._FlashDefinition
= ''
526 return self
._FlashDefinition
530 if self
._Prebuild
is None:
531 if self
._Header
is None:
532 self
._GetHeaderInfo
()
533 if self
._Prebuild
is None:
535 return self
._Prebuild
539 if self
._Postbuild
is None:
540 if self
._Header
is None:
541 self
._GetHeaderInfo
()
542 if self
._Postbuild
is None:
544 return self
._Postbuild
546 ## Retrieve FLASH_DEFINITION
548 def BuildNumber(self
):
549 if self
._BuildNumber
is None:
550 if self
._Header
is None:
551 self
._GetHeaderInfo
()
552 if self
._BuildNumber
is None:
553 self
._BuildNumber
= ''
554 return self
._BuildNumber
556 ## Retrieve MAKEFILE_NAME
558 def MakefileName(self
):
559 if self
._MakefileName
is None:
560 if self
._Header
is None:
561 self
._GetHeaderInfo
()
562 if self
._MakefileName
is None:
563 self
._MakefileName
= ''
564 return self
._MakefileName
566 ## Retrieve BsBaseAddress
568 def BsBaseAddress(self
):
569 if self
._BsBaseAddress
is None:
570 if self
._Header
is None:
571 self
._GetHeaderInfo
()
572 if self
._BsBaseAddress
is None:
573 self
._BsBaseAddress
= ''
574 return self
._BsBaseAddress
576 ## Retrieve RtBaseAddress
578 def RtBaseAddress(self
):
579 if self
._RtBaseAddress
is None:
580 if self
._Header
is None:
581 self
._GetHeaderInfo
()
582 if self
._RtBaseAddress
is None:
583 self
._RtBaseAddress
= ''
584 return self
._RtBaseAddress
586 ## Retrieve the top address for the load fix address
588 def LoadFixAddress(self
):
589 if self
._LoadFixAddress
is None:
590 if self
._Header
is None:
591 self
._GetHeaderInfo
()
593 if self
._LoadFixAddress
is None:
594 self
._LoadFixAddress
= self
._Macros
.get(TAB_FIX_LOAD_TOP_MEMORY_ADDRESS
, '0')
597 self
._LoadFixAddress
= int (self
._LoadFixAddress
, 0)
599 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (self
._LoadFixAddress
))
602 # If command line defined, should override the value in DSC file.
604 if 'FIX_LOAD_TOP_MEMORY_ADDRESS' in GlobalData
.gCommandLineDefines
:
606 self
._LoadFixAddress
= int(GlobalData
.gCommandLineDefines
['FIX_LOAD_TOP_MEMORY_ADDRESS'], 0)
608 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']))
610 if self
._LoadFixAddress
< 0:
611 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid negative value 0x%x" % (self
._LoadFixAddress
))
612 if self
._LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
._LoadFixAddress
% 0x1000 != 0:
613 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid unaligned 4K value 0x%x" % (self
._LoadFixAddress
))
615 return self
._LoadFixAddress
617 ## Retrieve RFCLanguage filter
619 def RFCLanguages(self
):
620 if self
._RFCLanguages
is None:
621 if self
._Header
is None:
622 self
._GetHeaderInfo
()
623 if self
._RFCLanguages
is None:
624 self
._RFCLanguages
= []
625 return self
._RFCLanguages
627 ## Retrieve ISOLanguage filter
629 def ISOLanguages(self
):
630 if self
._ISOLanguages
is None:
631 if self
._Header
is None:
632 self
._GetHeaderInfo
()
633 if self
._ISOLanguages
is None:
634 self
._ISOLanguages
= []
635 return self
._ISOLanguages
637 ## Retrieve the GUID string for VPD tool
639 def VpdToolGuid(self
):
640 if self
._VpdToolGuid
is None:
641 if self
._Header
is None:
642 self
._GetHeaderInfo
()
643 if self
._VpdToolGuid
is None:
644 self
._VpdToolGuid
= ''
645 return self
._VpdToolGuid
647 ## Retrieve [SkuIds] section information
650 if self
._SkuIds
is None:
651 self
._SkuIds
= OrderedDict()
652 RecordList
= self
._RawData
[MODEL_EFI_SKU_ID
, self
._Arch
]
653 for Record
in RecordList
:
655 EdkLogger
.error('build', FORMAT_INVALID
, 'No Sku ID number',
656 File
=self
.MetaFile
, Line
=Record
[-1])
658 EdkLogger
.error('build', FORMAT_INVALID
, 'No Sku ID name',
659 File
=self
.MetaFile
, Line
=Record
[-1])
660 if not Pattern
.match(Record
[0]) and not HexPattern
.match(Record
[0]):
661 EdkLogger
.error('build', FORMAT_INVALID
, "The format of the Sku ID number is invalid. It only support Integer and HexNumber",
662 File
=self
.MetaFile
, Line
=Record
[-1])
663 if not SkuIdPattern
.match(Record
[1]) or (Record
[2] and not SkuIdPattern
.match(Record
[2])):
664 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_)*'",
665 File
=self
.MetaFile
, Line
=Record
[-1])
666 self
._SkuIds
[Record
[1].upper()] = (str(DscBuildData
.ToInt(Record
[0])), Record
[1].upper(), Record
[2].upper())
667 if TAB_DEFAULT
not in self
._SkuIds
:
668 self
._SkuIds
[TAB_DEFAULT
] = ("0", TAB_DEFAULT
, TAB_DEFAULT
)
669 if TAB_COMMON
not in self
._SkuIds
:
670 self
._SkuIds
[TAB_COMMON
] = ("0", TAB_DEFAULT
, TAB_DEFAULT
)
675 return int(intstr
, 16) if intstr
.upper().startswith("0X") else int(intstr
)
677 def _GetDefaultStores(self
):
678 if self
.DefaultStores
is None:
679 self
.DefaultStores
= OrderedDict()
680 RecordList
= self
._RawData
[MODEL_EFI_DEFAULT_STORES
, self
._Arch
]
681 for Record
in RecordList
:
683 EdkLogger
.error('build', FORMAT_INVALID
, 'No DefaultStores ID number',
684 File
=self
.MetaFile
, Line
=Record
[-1])
686 EdkLogger
.error('build', FORMAT_INVALID
, 'No DefaultStores ID name',
687 File
=self
.MetaFile
, Line
=Record
[-1])
688 if not Pattern
.match(Record
[0]) and not HexPattern
.match(Record
[0]):
689 EdkLogger
.error('build', FORMAT_INVALID
, "The format of the DefaultStores ID number is invalid. It only support Integer and HexNumber",
690 File
=self
.MetaFile
, Line
=Record
[-1])
691 if not IsValidWord(Record
[1]):
692 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_-.)*'",
693 File
=self
.MetaFile
, Line
=Record
[-1])
694 self
.DefaultStores
[Record
[1].upper()] = (DscBuildData
.ToInt(Record
[0]), Record
[1].upper())
695 if TAB_DEFAULT_STORES_DEFAULT
not in self
.DefaultStores
:
696 self
.DefaultStores
[TAB_DEFAULT_STORES_DEFAULT
] = (0, TAB_DEFAULT_STORES_DEFAULT
)
697 GlobalData
.gDefaultStores
= sorted(self
.DefaultStores
.keys())
698 return self
.DefaultStores
700 ## Retrieve [Components] section information
703 if self
._Modules
is not None:
706 self
._Modules
= OrderedDict()
707 RecordList
= self
._RawData
[MODEL_META_DATA_COMPONENT
, self
._Arch
]
708 Macros
= self
._Macros
709 Macros
["EDK_SOURCE"] = GlobalData
.gEcpSource
710 for Record
in RecordList
:
711 DuplicatedFile
= False
713 ModuleFile
= PathClass(NormPath(Record
[0], Macros
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
717 # check the file validation
718 ErrorCode
, ErrorInfo
= ModuleFile
.Validate('.inf')
720 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
723 # If arch is COMMON, no duplicate module is checked since all modules in all component sections are selected
724 if self
._Arch
!= TAB_ARCH_COMMON
and ModuleFile
in self
._Modules
:
725 DuplicatedFile
= True
727 Module
= ModuleBuildClassObject()
728 Module
.MetaFile
= ModuleFile
730 # get module private library instance
731 RecordList
= self
._RawData
[MODEL_EFI_LIBRARY_CLASS
, self
._Arch
, None, ModuleId
]
732 for Record
in RecordList
:
733 LibraryClass
= Record
[0]
734 LibraryPath
= PathClass(NormPath(Record
[1], Macros
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
737 # check the file validation
738 ErrorCode
, ErrorInfo
= LibraryPath
.Validate('.inf')
740 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
743 if LibraryClass
== '' or LibraryClass
== 'NULL':
744 self
._NullLibraryNumber
+= 1
745 LibraryClass
= 'NULL%d' % self
._NullLibraryNumber
746 EdkLogger
.verbose("Found forced library for %s\n\t%s [%s]" % (ModuleFile
, LibraryPath
, LibraryClass
))
747 Module
.LibraryClasses
[LibraryClass
] = LibraryPath
748 if LibraryPath
not in self
.LibraryInstances
:
749 self
.LibraryInstances
.append(LibraryPath
)
751 # get module private PCD setting
752 for Type
in [MODEL_PCD_FIXED_AT_BUILD
, MODEL_PCD_PATCHABLE_IN_MODULE
, \
753 MODEL_PCD_FEATURE_FLAG
, MODEL_PCD_DYNAMIC
, MODEL_PCD_DYNAMIC_EX
]:
754 RecordList
= self
._RawData
[Type
, self
._Arch
, None, ModuleId
]
755 for TokenSpaceGuid
, PcdCName
, Setting
, Dummy1
, Dummy2
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
756 TokenList
= GetSplitValueList(Setting
)
757 DefaultValue
= TokenList
[0]
758 # the format is PcdName| Value | VOID* | MaxDatumSize
759 if len(TokenList
) > 2:
760 MaxDatumSize
= TokenList
[2]
763 TypeString
= self
._PCD
_TYPE
_STRING
_[Type
]
764 Pcd
= PcdClassObject(
776 Module
.Pcds
[PcdCName
, TokenSpaceGuid
] = Pcd
778 # get module private build options
779 RecordList
= self
._RawData
[MODEL_META_DATA_BUILD_OPTION
, self
._Arch
, None, ModuleId
]
780 for ToolChainFamily
, ToolChain
, Option
, Dummy1
, Dummy2
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
781 if (ToolChainFamily
, ToolChain
) not in Module
.BuildOptions
:
782 Module
.BuildOptions
[ToolChainFamily
, ToolChain
] = Option
784 OptionString
= Module
.BuildOptions
[ToolChainFamily
, ToolChain
]
785 Module
.BuildOptions
[ToolChainFamily
, ToolChain
] = OptionString
+ " " + Option
787 RecordList
= self
._RawData
[MODEL_META_DATA_HEADER
, self
._Arch
, None, ModuleId
]
788 if DuplicatedFile
and not RecordList
:
789 EdkLogger
.error('build', FILE_DUPLICATED
, File
=self
.MetaFile
, ExtraData
=str(ModuleFile
), Line
=LineNo
)
791 if len(RecordList
) != 1:
792 EdkLogger
.error('build', OPTION_UNKNOWN
, 'Only FILE_GUID can be listed in <Defines> section.',
793 File
=self
.MetaFile
, ExtraData
=str(ModuleFile
), Line
=LineNo
)
794 ModuleFile
= ProcessDuplicatedInf(ModuleFile
, RecordList
[0][2], GlobalData
.gWorkspace
)
795 ModuleFile
.Arch
= self
._Arch
797 self
._Modules
[ModuleFile
] = Module
800 ## Retrieve all possible library instances used in this platform
802 def LibraryInstances(self
):
803 if self
._LibraryInstances
is None:
805 return self
._LibraryInstances
807 ## Retrieve [LibraryClasses] information
809 def LibraryClasses(self
):
810 if self
._LibraryClasses
is None:
811 self
._LibraryInstances
= []
813 # tdict is a special dict kind of type, used for selecting correct
814 # library instance for given library class and module type
816 LibraryClassDict
= tdict(True, 3)
817 # track all library class names
818 LibraryClassSet
= set()
819 RecordList
= self
._RawData
[MODEL_EFI_LIBRARY_CLASS
, self
._Arch
, None, -1]
820 Macros
= self
._Macros
821 for Record
in RecordList
:
822 LibraryClass
, LibraryInstance
, Dummy
, Arch
, ModuleType
, Dummy
, Dummy
, LineNo
= Record
823 if LibraryClass
== '' or LibraryClass
== 'NULL':
824 self
._NullLibraryNumber
+= 1
825 LibraryClass
= 'NULL%d' % self
._NullLibraryNumber
826 EdkLogger
.verbose("Found forced library for arch=%s\n\t%s [%s]" % (Arch
, LibraryInstance
, LibraryClass
))
827 LibraryClassSet
.add(LibraryClass
)
828 LibraryInstance
= PathClass(NormPath(LibraryInstance
, Macros
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
829 # check the file validation
830 ErrorCode
, ErrorInfo
= LibraryInstance
.Validate('.inf')
832 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
835 if ModuleType
!= TAB_COMMON
and ModuleType
not in SUP_MODULE_LIST
:
836 EdkLogger
.error('build', OPTION_UNKNOWN
, "Unknown module type [%s]" % ModuleType
,
837 File
=self
.MetaFile
, ExtraData
=LibraryInstance
, Line
=LineNo
)
838 LibraryClassDict
[Arch
, ModuleType
, LibraryClass
] = LibraryInstance
839 if LibraryInstance
not in self
._LibraryInstances
:
840 self
._LibraryInstances
.append(LibraryInstance
)
842 # resolve the specific library instance for each class and each module type
843 self
._LibraryClasses
= tdict(True)
844 for LibraryClass
in LibraryClassSet
:
845 # try all possible module types
846 for ModuleType
in SUP_MODULE_LIST
:
847 LibraryInstance
= LibraryClassDict
[self
._Arch
, ModuleType
, LibraryClass
]
848 if LibraryInstance
is None:
850 self
._LibraryClasses
[LibraryClass
, ModuleType
] = LibraryInstance
852 # for Edk style library instances, which are listed in different section
853 Macros
["EDK_SOURCE"] = GlobalData
.gEcpSource
854 RecordList
= self
._RawData
[MODEL_EFI_LIBRARY_INSTANCE
, self
._Arch
]
855 for Record
in RecordList
:
856 File
= PathClass(NormPath(Record
[0], Macros
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
858 # check the file validation
859 ErrorCode
, ErrorInfo
= File
.Validate('.inf')
861 EdkLogger
.error('build', ErrorCode
, File
=self
.MetaFile
, Line
=LineNo
,
863 if File
not in self
._LibraryInstances
:
864 self
._LibraryInstances
.append(File
)
866 # we need the module name as the library class name, so we have
867 # to parse it here. (self._Bdb[] will trigger a file parse if it
868 # hasn't been parsed)
870 Library
= self
._Bdb
[File
, self
._Arch
, self
._Target
, self
._Toolchain
]
871 self
._LibraryClasses
[Library
.BaseName
, ':dummy:'] = Library
872 return self
._LibraryClasses
874 def _ValidatePcd(self
, PcdCName
, TokenSpaceGuid
, Setting
, PcdType
, LineNo
):
875 if self
._DecPcds
is None:
878 if GlobalData
.gFdfParser
:
879 FdfInfList
= GlobalData
.gFdfParser
.Profile
.InfList
882 for Inf
in FdfInfList
:
883 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
884 if ModuleFile
in self
._Modules
:
886 ModuleData
= self
._Bdb
[ModuleFile
, self
._Arch
, self
._Target
, self
._Toolchain
]
887 PkgSet
.update(ModuleData
.Packages
)
889 self
._DecPcds
, self
._GuidDict
= GetDeclaredPcd(self
, self
._Bdb
, self
._Arch
, self
._Target
, self
._Toolchain
, PkgSet
)
890 self
._GuidDict
.update(GlobalData
.gPlatformPcds
)
892 if (PcdCName
, TokenSpaceGuid
) not in self
._DecPcds
:
893 EdkLogger
.error('build', PARSER_ERROR
,
894 "Pcd (%s.%s) defined in DSC is not declared in DEC files referenced in INF files in FDF. Arch: ['%s']" % (TokenSpaceGuid
, PcdCName
, self
._Arch
),
895 File
=self
.MetaFile
, Line
=LineNo
)
896 ValueList
, IsValid
, Index
= AnalyzeDscPcd(Setting
, PcdType
, self
._DecPcds
[PcdCName
, TokenSpaceGuid
].DatumType
)
898 if PcdType
not in [MODEL_PCD_FEATURE_FLAG
, MODEL_PCD_FIXED_AT_BUILD
]:
899 EdkLogger
.error('build', FORMAT_INVALID
, "Pcd format incorrect.", File
=self
.MetaFile
, Line
=LineNo
,
900 ExtraData
="%s.%s|%s" % (TokenSpaceGuid
, PcdCName
, Setting
))
902 if ValueList
[2] == '-1':
903 EdkLogger
.error('build', FORMAT_INVALID
, "Pcd format incorrect.", File
=self
.MetaFile
, Line
=LineNo
,
904 ExtraData
="%s.%s|%s" % (TokenSpaceGuid
, PcdCName
, Setting
))
906 DatumType
= self
._DecPcds
[PcdCName
, TokenSpaceGuid
].DatumType
908 ValueList
[Index
] = ValueExpressionEx(ValueList
[Index
], DatumType
, self
._GuidDict
)(True)
909 except BadExpression
as Value
:
910 EdkLogger
.error('Parser', FORMAT_INVALID
, Value
, File
=self
.MetaFile
, Line
=LineNo
,
911 ExtraData
="PCD [%s.%s] Value \"%s\" " % (
912 TokenSpaceGuid
, PcdCName
, ValueList
[Index
]))
913 except EvaluationException
as Excpt
:
914 if hasattr(Excpt
, 'Pcd'):
915 if Excpt
.Pcd
in GlobalData
.gPlatformOtherPcds
:
916 EdkLogger
.error('Parser', FORMAT_INVALID
, "Cannot use this PCD (%s) in an expression as"
917 " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"
918 " of the DSC file" % Excpt
.Pcd
,
919 File
=self
.MetaFile
, Line
=LineNo
)
921 EdkLogger
.error('Parser', FORMAT_INVALID
, "PCD (%s) is not defined in DSC file" % Excpt
.Pcd
,
922 File
=self
.MetaFile
, Line
=LineNo
)
924 EdkLogger
.error('Parser', FORMAT_INVALID
, "Invalid expression: %s" % str(Excpt
),
925 File
=self
.MetaFile
, Line
=LineNo
)
928 Valid
, ErrStr
= CheckPcdDatum(self
._DecPcds
[PcdCName
, TokenSpaceGuid
].DatumType
, ValueList
[Index
])
930 EdkLogger
.error('build', FORMAT_INVALID
, ErrStr
, File
=self
.MetaFile
, Line
=LineNo
,
931 ExtraData
="%s.%s" % (TokenSpaceGuid
, PcdCName
))
932 if PcdType
in (MODEL_PCD_DYNAMIC_DEFAULT
, MODEL_PCD_DYNAMIC_EX_DEFAULT
, MODEL_PCD_FIXED_AT_BUILD
, MODEL_PCD_PATCHABLE_IN_MODULE
):
933 if self
._DecPcds
[PcdCName
, TokenSpaceGuid
].DatumType
.strip() != ValueList
[1].strip():
934 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
,
935 ExtraData
="%s.%s|%s" % (TokenSpaceGuid
, PcdCName
, Setting
))
936 if (TokenSpaceGuid
+ '.' + PcdCName
) in GlobalData
.gPlatformPcds
:
937 if GlobalData
.gPlatformPcds
[TokenSpaceGuid
+ '.' + PcdCName
] != ValueList
[Index
]:
938 GlobalData
.gPlatformPcds
[TokenSpaceGuid
+ '.' + PcdCName
] = ValueList
[Index
]
941 def _FilterPcdBySkuUsage(self
, Pcds
):
942 available_sku
= self
.SkuIdMgr
.AvailableSkuIdSet
943 sku_usage
= self
.SkuIdMgr
.SkuUsageType
944 if sku_usage
== SkuClass
.SINGLE
:
947 Pcds
[pcdname
].SkuInfoList
= {TAB_DEFAULT
:pcd
.SkuInfoList
[skuid
] for skuid
in pcd
.SkuInfoList
if skuid
in available_sku
}
948 if isinstance(pcd
, StructurePcd
) and pcd
.SkuOverrideValues
:
949 Pcds
[pcdname
].SkuOverrideValues
= {TAB_DEFAULT
:pcd
.SkuOverrideValues
[skuid
] for skuid
in pcd
.SkuOverrideValues
if skuid
in available_sku
}
953 Pcds
[pcdname
].SkuInfoList
= {skuid
:pcd
.SkuInfoList
[skuid
] for skuid
in pcd
.SkuInfoList
if skuid
in available_sku
}
954 if isinstance(pcd
, StructurePcd
) and pcd
.SkuOverrideValues
:
955 Pcds
[pcdname
].SkuOverrideValues
= {skuid
:pcd
.SkuOverrideValues
[skuid
] for skuid
in pcd
.SkuOverrideValues
if skuid
in available_sku
}
958 def CompleteHiiPcdsDefaultStores(self
, Pcds
):
959 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
]]]
960 DefaultStoreMgr
= DefaultStore(self
.DefaultStores
)
962 for skuid
in pcd
.SkuInfoList
:
963 skuobj
= pcd
.SkuInfoList
.get(skuid
)
964 if TAB_DEFAULT_STORES_DEFAULT
not in skuobj
.DefaultStoreDict
:
965 PcdDefaultStoreSet
= set(defaultstorename
for defaultstorename
in skuobj
.DefaultStoreDict
)
966 mindefaultstorename
= DefaultStoreMgr
.GetMin(PcdDefaultStoreSet
)
967 skuobj
.DefaultStoreDict
[TAB_DEFAULT_STORES_DEFAULT
] = copy
.deepcopy(skuobj
.DefaultStoreDict
[mindefaultstorename
])
970 def RecoverCommandLinePcd(self
):
971 def UpdateCommandLineValue(pcd
):
972 if pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
973 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
974 pcd
.PcdValueFromComm
= pcd
.DefaultValue
975 elif pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
976 pcd
.PcdValueFromComm
= pcd
.SkuInfoList
.get(TAB_DEFAULT
).HiiDefaultValue
978 pcd
.PcdValueFromComm
= pcd
.SkuInfoList
.get(TAB_DEFAULT
).DefaultValue
979 for pcd
in self
._Pcds
:
980 if isinstance(self
._Pcds
[pcd
], StructurePcd
) and (self
._Pcds
[pcd
].PcdValueFromComm
or self
._Pcds
[pcd
].PcdFieldValueFromComm
):
981 UpdateCommandLineValue(self
._Pcds
[pcd
])
983 def __ParsePcdFromCommandLine(self
):
984 if GlobalData
.BuildOptionPcd
:
985 for i
, pcd
in enumerate(GlobalData
.BuildOptionPcd
):
986 if isinstance(pcd
, tuple):
988 (pcdname
, pcdvalue
) = pcd
.split('=')
990 EdkLogger
.error('build', AUTOGEN_ERROR
, "No Value specified for the PCD %s." % (pcdname
))
992 (Name1
, Name2
) = pcdname
.split('.', 1)
994 (Name3
, FieldName
) = Name2
.split(".", 1)
995 if ((Name3
, Name1
)) in self
.DecPcds
:
998 TokenSpaceGuidCName
= Name1
1002 TokenSpaceGuidCName
= ''
1003 HasTokenSpace
= False
1005 if ((Name2
, Name1
)) in self
.DecPcds
:
1006 HasTokenSpace
= True
1008 TokenSpaceGuidCName
= Name1
1013 TokenSpaceGuidCName
= ''
1014 HasTokenSpace
= False
1017 TokenCName
= pcdname
1018 TokenSpaceGuidCName
= ''
1019 HasTokenSpace
= False
1020 TokenSpaceGuidCNameList
= []
1023 DisplayName
= TokenCName
1025 DisplayName
= TokenCName
+ '.' + FieldName
1026 if not HasTokenSpace
:
1027 for key
in self
.DecPcds
:
1028 PcdItem
= self
.DecPcds
[key
]
1029 if TokenCName
== PcdItem
.TokenCName
:
1030 if not PcdItem
.TokenSpaceGuidCName
in TokenSpaceGuidCNameList
:
1031 if len (TokenSpaceGuidCNameList
) < 1:
1032 TokenSpaceGuidCNameList
.append(PcdItem
.TokenSpaceGuidCName
)
1033 TokenSpaceGuidCName
= PcdItem
.TokenSpaceGuidCName
1034 PcdDatumType
= PcdItem
.DatumType
1040 "The Pcd %s is found under multiple different TokenSpaceGuid: %s and %s." % (DisplayName
, PcdItem
.TokenSpaceGuidCName
, TokenSpaceGuidCNameList
[0])
1043 if (TokenCName
, TokenSpaceGuidCName
) in self
.DecPcds
:
1044 PcdDatumType
= self
.DecPcds
[(TokenCName
, TokenSpaceGuidCName
)].DatumType
1048 EdkLogger
.error('build', AUTOGEN_ERROR
, "The Pcd %s.%s is not found in the DEC file." % (TokenSpaceGuidCName
, DisplayName
))
1050 EdkLogger
.error('build', AUTOGEN_ERROR
, "The Pcd %s is not found in the DEC file." % (DisplayName
))
1051 pcdvalue
= pcdvalue
.replace("\\\\\\'", '\\\\\\"').replace('\\\'', '\'').replace('\\\\\\"', "\\'")
1053 pcdvalue
= DscBuildData
.HandleFlexiblePcd(TokenSpaceGuidCName
, TokenCName
, pcdvalue
, PcdDatumType
, self
._GuidDict
, FieldName
)
1055 pcdvalue
= DscBuildData
.HandleFlexiblePcd(TokenSpaceGuidCName
, TokenCName
, pcdvalue
, PcdDatumType
, self
._GuidDict
)
1056 IsValid
, Cause
= CheckPcdDatum(PcdDatumType
, pcdvalue
)
1058 EdkLogger
.error("build", FORMAT_INVALID
, Cause
, ExtraData
="%s.%s" % (TokenSpaceGuidCName
, TokenCName
))
1059 GlobalData
.BuildOptionPcd
[i
] = (TokenSpaceGuidCName
, TokenCName
, FieldName
, pcdvalue
, ("build command options", 1))
1061 for BuildData
in self
._Bdb
._CACHE
_.values():
1062 if BuildData
.MetaFile
.Ext
== '.dec' or BuildData
.MetaFile
.Ext
== '.dsc':
1064 for key
in BuildData
.Pcds
:
1065 PcdItem
= BuildData
.Pcds
[key
]
1066 if (TokenSpaceGuidCName
, TokenCName
) == (PcdItem
.TokenSpaceGuidCName
, PcdItem
.TokenCName
) and FieldName
=="":
1067 PcdItem
.DefaultValue
= pcdvalue
1068 #In command line, the latter full assign value in commandLine should override the former field assign value.
1069 #For example, --pcd Token.pcd.field="" --pcd Token.pcd=H"{}"
1072 if GlobalData
.BuildOptionPcd
:
1073 for pcdTuple
in GlobalData
.BuildOptionPcd
:
1074 TokenSpaceGuid
, Token
, Field
= pcdTuple
[0], pcdTuple
[1], pcdTuple
[2]
1076 if (TokenSpaceGuid
, Token
) not in field_assign
:
1077 field_assign
[TokenSpaceGuid
, Token
] = []
1078 field_assign
[TokenSpaceGuid
, Token
].append(pcdTuple
)
1080 if (TokenSpaceGuid
, Token
) in field_assign
:
1081 delete_assign
.extend(field_assign
[TokenSpaceGuid
, Token
])
1082 field_assign
[TokenSpaceGuid
, Token
] = []
1083 for item
in delete_assign
:
1084 GlobalData
.BuildOptionPcd
.remove(item
)
1087 def HandleFlexiblePcd(TokenSpaceGuidCName
, TokenCName
, PcdValue
, PcdDatumType
, GuidDict
, FieldName
=''):
1090 TokenCName
+= '.' + FieldName
1091 if PcdValue
.startswith('H'):
1092 if FieldName
and IsFieldValueAnArray(PcdValue
[1:]):
1093 PcdDatumType
= TAB_VOID
1095 if FieldName
and not IsArray
:
1098 PcdValue
= ValueExpressionEx(PcdValue
[1:], PcdDatumType
, GuidDict
)(True)
1099 except BadExpression
as Value
:
1100 EdkLogger
.error('Parser', FORMAT_INVALID
, 'PCD [%s.%s] Value "%s", %s' %
1101 (TokenSpaceGuidCName
, TokenCName
, PcdValue
, Value
))
1102 elif PcdValue
.startswith("L'") or PcdValue
.startswith("'"):
1103 if FieldName
and IsFieldValueAnArray(PcdValue
):
1104 PcdDatumType
= TAB_VOID
1106 if FieldName
and not IsArray
:
1109 PcdValue
= ValueExpressionEx(PcdValue
, PcdDatumType
, GuidDict
)(True)
1110 except BadExpression
as Value
:
1111 EdkLogger
.error('Parser', FORMAT_INVALID
, 'PCD [%s.%s] Value "%s", %s' %
1112 (TokenSpaceGuidCName
, TokenCName
, PcdValue
, Value
))
1113 elif PcdValue
.startswith('L'):
1114 PcdValue
= 'L"' + PcdValue
[1:] + '"'
1115 if FieldName
and IsFieldValueAnArray(PcdValue
):
1116 PcdDatumType
= TAB_VOID
1118 if FieldName
and not IsArray
:
1121 PcdValue
= ValueExpressionEx(PcdValue
, PcdDatumType
, GuidDict
)(True)
1122 except BadExpression
as Value
:
1123 EdkLogger
.error('Parser', FORMAT_INVALID
, 'PCD [%s.%s] Value "%s", %s' %
1124 (TokenSpaceGuidCName
, TokenCName
, PcdValue
, Value
))
1126 if PcdValue
.upper() == 'FALSE':
1128 if PcdValue
.upper() == 'TRUE':
1131 if PcdDatumType
not in TAB_PCD_NUMERIC_TYPES
:
1132 PcdValue
= '"' + PcdValue
+ '"'
1136 if PcdValue
.upper().startswith('0X'):
1139 Num
= int(PcdValue
, Base
)
1141 PcdValue
= '"' + PcdValue
+ '"'
1142 if IsFieldValueAnArray(PcdValue
):
1143 PcdDatumType
= TAB_VOID
1148 PcdValue
= ValueExpressionEx(PcdValue
, PcdDatumType
, GuidDict
)(True)
1149 except BadExpression
as Value
:
1150 EdkLogger
.error('Parser', FORMAT_INVALID
, 'PCD [%s.%s] Value "%s", %s' %
1151 (TokenSpaceGuidCName
, TokenCName
, PcdValue
, Value
))
1154 ## Retrieve all PCD settings in platform
1157 if self
._Pcds
is None:
1158 self
._Pcds
= OrderedDict()
1159 self
.__ParsePcdFromCommandLine
()
1160 self
._Pcds
.update(self
._GetPcd
(MODEL_PCD_FIXED_AT_BUILD
))
1161 self
._Pcds
.update(self
._GetPcd
(MODEL_PCD_PATCHABLE_IN_MODULE
))
1162 self
._Pcds
.update(self
._GetPcd
(MODEL_PCD_FEATURE_FLAG
))
1163 self
._Pcds
.update(self
._GetDynamicPcd
(MODEL_PCD_DYNAMIC_DEFAULT
))
1164 self
._Pcds
.update(self
._GetDynamicHiiPcd
(MODEL_PCD_DYNAMIC_HII
))
1165 self
._Pcds
.update(self
._GetDynamicVpdPcd
(MODEL_PCD_DYNAMIC_VPD
))
1166 self
._Pcds
.update(self
._GetDynamicPcd
(MODEL_PCD_DYNAMIC_EX_DEFAULT
))
1167 self
._Pcds
.update(self
._GetDynamicHiiPcd
(MODEL_PCD_DYNAMIC_EX_HII
))
1168 self
._Pcds
.update(self
._GetDynamicVpdPcd
(MODEL_PCD_DYNAMIC_EX_VPD
))
1170 self
._Pcds
= self
.CompletePcdValues(self
._Pcds
)
1171 self
._Pcds
= self
.OverrideByFdfOverAll(self
._Pcds
)
1172 self
._Pcds
= self
.OverrideByCommOverAll(self
._Pcds
)
1173 self
._Pcds
= self
.UpdateStructuredPcds(MODEL_PCD_TYPE_LIST
, self
._Pcds
)
1174 self
._Pcds
= self
.CompleteHiiPcdsDefaultStores(self
._Pcds
)
1175 self
._Pcds
= self
._FilterPcdBySkuUsage
(self
._Pcds
)
1177 self
.RecoverCommandLinePcd()
1180 ## Retrieve [BuildOptions]
1182 def BuildOptions(self
):
1183 if self
._BuildOptions
is None:
1184 self
._BuildOptions
= OrderedDict()
1186 # Retrieve build option for EDKII and EDK style module
1188 for CodeBase
in (EDKII_NAME
, EDK_NAME
):
1189 RecordList
= self
._RawData
[MODEL_META_DATA_BUILD_OPTION
, self
._Arch
, CodeBase
]
1190 for ToolChainFamily
, ToolChain
, Option
, Dummy1
, Dummy2
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
1191 if Dummy3
.upper() != TAB_COMMON
:
1193 CurKey
= (ToolChainFamily
, ToolChain
, CodeBase
)
1195 # Only flags can be appended
1197 if CurKey
not in self
._BuildOptions
or not ToolChain
.endswith('_FLAGS') or Option
.startswith('='):
1198 self
._BuildOptions
[CurKey
] = Option
1200 if ' ' + Option
not in self
._BuildOptions
[CurKey
]:
1201 self
._BuildOptions
[CurKey
] += ' ' + Option
1202 return self
._BuildOptions
1204 def GetBuildOptionsByModuleType(self
, Edk
, ModuleType
):
1205 if self
._ModuleTypeOptions
is None:
1206 self
._ModuleTypeOptions
= OrderedDict()
1207 if (Edk
, ModuleType
) not in self
._ModuleTypeOptions
:
1208 options
= OrderedDict()
1209 self
._ModuleTypeOptions
[Edk
, ModuleType
] = options
1210 DriverType
= '%s.%s' % (Edk
, ModuleType
)
1211 CommonDriverType
= '%s.%s' % (TAB_COMMON
, ModuleType
)
1212 RecordList
= self
._RawData
[MODEL_META_DATA_BUILD_OPTION
, self
._Arch
]
1213 for ToolChainFamily
, ToolChain
, Option
, Dummy1
, Dummy2
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
1214 Type
= Dummy2
+ '.' + Dummy3
1215 if Type
.upper() == DriverType
.upper() or Type
.upper() == CommonDriverType
.upper():
1216 Key
= (ToolChainFamily
, ToolChain
, Edk
)
1217 if Key
not in options
or not ToolChain
.endswith('_FLAGS') or Option
.startswith('='):
1218 options
[Key
] = Option
1220 if ' ' + Option
not in options
[Key
]:
1221 options
[Key
] += ' ' + Option
1222 return self
._ModuleTypeOptions
[Edk
, ModuleType
]
1225 def GetStructurePcdInfo(PcdSet
):
1226 structure_pcd_data
= defaultdict(list)
1228 structure_pcd_data
[(item
[0], item
[1])].append(item
)
1230 return structure_pcd_data
1233 def OverrideByFdf(StruPcds
,workspace
):
1234 if GlobalData
.gFdfParser
is None:
1236 StructurePcdInFdf
= OrderedDict()
1237 fdfpcd
= GlobalData
.gFdfParser
.Profile
.PcdDict
1238 fdfpcdlocation
= GlobalData
.gFdfParser
.Profile
.PcdLocalDict
1239 for item
in fdfpcd
:
1240 if len(item
[2]) and (item
[0],item
[1]) in StruPcds
:
1241 StructurePcdInFdf
[(item
[1],item
[0],item
[2] )] = fdfpcd
[item
]
1242 GlobalPcds
= {(item
[0],item
[1]) for item
in StructurePcdInFdf
}
1243 for Pcd
in StruPcds
.values():
1244 if (Pcd
.TokenSpaceGuidCName
,Pcd
.TokenCName
) not in GlobalPcds
:
1246 FieldValues
= OrderedDict()
1247 for item
in StructurePcdInFdf
:
1248 if (Pcd
.TokenSpaceGuidCName
,Pcd
.TokenCName
) == (item
[0],item
[1]) and item
[2]:
1249 FieldValues
[item
[2]] = StructurePcdInFdf
[item
]
1250 for field
in FieldValues
:
1251 if field
not in Pcd
.PcdFieldValueFromFdf
:
1252 Pcd
.PcdFieldValueFromFdf
[field
] = ["","",""]
1253 Pcd
.PcdFieldValueFromFdf
[field
][0] = FieldValues
[field
]
1254 Pcd
.PcdFieldValueFromFdf
[field
][1] = os
.path
.relpath(fdfpcdlocation
[(Pcd
.TokenCName
,Pcd
.TokenSpaceGuidCName
,field
)][0],workspace
)
1255 Pcd
.PcdFieldValueFromFdf
[field
][2] = fdfpcdlocation
[(Pcd
.TokenCName
,Pcd
.TokenSpaceGuidCName
,field
)][1]
1260 def OverrideByComm(StruPcds
):
1261 StructurePcdInCom
= OrderedDict()
1262 for item
in GlobalData
.BuildOptionPcd
:
1263 if len(item
) == 5 and (item
[1], item
[0]) in StruPcds
:
1264 StructurePcdInCom
[(item
[0], item
[1], item
[2] )] = (item
[3], item
[4])
1265 GlobalPcds
= {(item
[0], item
[1]) for item
in StructurePcdInCom
}
1266 for Pcd
in StruPcds
.values():
1267 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) not in GlobalPcds
:
1269 FieldValues
= OrderedDict()
1270 for item
in StructurePcdInCom
:
1271 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (item
[0], item
[1]) and item
[2]:
1272 FieldValues
[item
[2]] = StructurePcdInCom
[item
]
1273 for field
in FieldValues
:
1274 if field
not in Pcd
.PcdFieldValueFromComm
:
1275 Pcd
.PcdFieldValueFromComm
[field
] = ["", "", ""]
1276 Pcd
.PcdFieldValueFromComm
[field
][0] = FieldValues
[field
][0]
1277 Pcd
.PcdFieldValueFromComm
[field
][1] = FieldValues
[field
][1][0]
1278 Pcd
.PcdFieldValueFromComm
[field
][2] = FieldValues
[field
][1][1]
1281 def OverrideByCommOverAll(self
,AllPcds
):
1282 def CheckStructureInComm(commpcds
):
1285 if len(commpcds
[0]) == 5:
1288 NoFiledValues
= OrderedDict()
1289 if CheckStructureInComm(GlobalData
.BuildOptionPcd
):
1290 StructurePcdInCom
= OrderedDict()
1291 for item
in GlobalData
.BuildOptionPcd
:
1292 StructurePcdInCom
[(item
[0], item
[1], item
[2] )] = (item
[3], item
[4])
1293 for item
in StructurePcdInCom
:
1295 NoFiledValues
[(item
[0], item
[1])] = StructurePcdInCom
[item
]
1297 for item
in GlobalData
.BuildOptionPcd
:
1298 NoFiledValues
[(item
[0], item
[1])] = [item
[2]]
1299 for Guid
, Name
in NoFiledValues
:
1300 if (Name
, Guid
) in AllPcds
:
1301 Pcd
= AllPcds
.get((Name
, Guid
))
1302 if isinstance(self
._DecPcds
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), None), StructurePcd
):
1303 self
._DecPcds
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)).PcdValueFromComm
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1305 Pcd
.PcdValueFromComm
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1306 Pcd
.DefaultValue
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1307 for sku
in Pcd
.SkuInfoList
:
1308 SkuInfo
= Pcd
.SkuInfoList
[sku
]
1309 if SkuInfo
.DefaultValue
:
1310 SkuInfo
.DefaultValue
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1312 SkuInfo
.HiiDefaultValue
= NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1313 for defaultstore
in SkuInfo
.DefaultStoreDict
:
1314 SkuInfo
.DefaultStoreDict
[defaultstore
] = NoFiledValues
[(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)][0]
1315 if Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
]]:
1316 if Pcd
.DatumType
== TAB_VOID
:
1317 if not Pcd
.MaxDatumSize
:
1318 Pcd
.MaxDatumSize
= '0'
1319 CurrentSize
= int(Pcd
.MaxDatumSize
, 16) if Pcd
.MaxDatumSize
.upper().startswith("0X") else int(Pcd
.MaxDatumSize
)
1320 OptionSize
= len((StringToArray(Pcd
.PcdValueFromComm
)).split(","))
1321 MaxSize
= max(CurrentSize
, OptionSize
)
1322 Pcd
.MaxDatumSize
= str(MaxSize
)
1324 PcdInDec
= self
.DecPcds
.get((Name
, Guid
))
1326 PcdInDec
.PcdValueFromComm
= NoFiledValues
[(Guid
, Name
)][0]
1327 if PcdInDec
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
1328 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
],
1329 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FEATURE_FLAG
],
1330 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC
],
1331 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX
]]:
1332 self
.Pcds
[Name
, Guid
] = copy
.deepcopy(PcdInDec
)
1333 self
.Pcds
[Name
, Guid
].DefaultValue
= NoFiledValues
[( Guid
, Name
)][0]
1334 if PcdInDec
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC
],
1335 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX
]]:
1336 self
.Pcds
[Name
, Guid
].SkuInfoList
= {TAB_DEFAULT
:SkuInfoClass(TAB_DEFAULT
, self
.SkuIds
[TAB_DEFAULT
][0], '', '', '', '', '', NoFiledValues
[( Guid
, Name
)][0])}
1339 def OverrideByFdfOverAll(self
,AllPcds
):
1341 if GlobalData
.gFdfParser
is None:
1343 NoFiledValues
= GlobalData
.gFdfParser
.Profile
.PcdDict
1344 for Name
,Guid
,Field
in NoFiledValues
:
1347 Value
= NoFiledValues
[(Name
,Guid
,Field
)]
1348 if (Name
,Guid
) in AllPcds
:
1349 Pcd
= AllPcds
.get((Name
,Guid
))
1350 if isinstance(self
._DecPcds
.get((Pcd
.TokenCName
,Pcd
.TokenSpaceGuidCName
), None),StructurePcd
):
1351 self
._DecPcds
.get((Pcd
.TokenCName
,Pcd
.TokenSpaceGuidCName
)).PcdValueFromComm
= Value
1353 Pcd
.PcdValueFromComm
= Value
1354 Pcd
.DefaultValue
= Value
1355 for sku
in Pcd
.SkuInfoList
:
1356 SkuInfo
= Pcd
.SkuInfoList
[sku
]
1357 if SkuInfo
.DefaultValue
:
1358 SkuInfo
.DefaultValue
= Value
1360 SkuInfo
.HiiDefaultValue
= Value
1361 for defaultstore
in SkuInfo
.DefaultStoreDict
:
1362 SkuInfo
.DefaultStoreDict
[defaultstore
] = Value
1363 if Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
]]:
1364 if Pcd
.DatumType
== TAB_VOID
:
1365 if not Pcd
.MaxDatumSize
:
1366 Pcd
.MaxDatumSize
= '0'
1367 CurrentSize
= int(Pcd
.MaxDatumSize
,16) if Pcd
.MaxDatumSize
.upper().startswith("0X") else int(Pcd
.MaxDatumSize
)
1368 OptionSize
= len((StringToArray(Pcd
.PcdValueFromComm
)).split(","))
1369 MaxSize
= max(CurrentSize
, OptionSize
)
1370 Pcd
.MaxDatumSize
= str(MaxSize
)
1372 PcdInDec
= self
.DecPcds
.get((Name
,Guid
))
1374 PcdInDec
.PcdValueFromFdf
= Value
1375 if PcdInDec
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
1376 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
],
1377 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FEATURE_FLAG
]]:
1378 self
.Pcds
[Name
, Guid
] = copy
.deepcopy(PcdInDec
)
1379 self
.Pcds
[Name
, Guid
].DefaultValue
= Value
1382 def UpdateStructuredPcds(self
, TypeList
, AllPcds
):
1384 DynamicPcdType
= [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_DEFAULT
],
1385 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
1386 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_VPD
],
1387 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_DEFAULT
],
1388 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
],
1389 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_VPD
]]
1392 DefaultStoreMgr
= DefaultStore(self
.DefaultStores
)
1393 SkuIds
= self
.SkuIds
1394 DefaultStores
= {storename
for pcdobj
in AllPcds
.values() for skuobj
in pcdobj
.SkuInfoList
.values() for storename
in skuobj
.DefaultStoreDict
}
1397 # Find out all possible PCD candidates for self._Arch
1400 for Type
in TypeList
:
1401 RecordList
.extend(self
._RawData
[Type
, self
._Arch
])
1403 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, default_store
, Dummy4
, Dummy5
in RecordList
:
1404 SkuName
= SkuName
.upper()
1405 default_store
= default_store
.upper()
1406 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
1407 if SkuName
not in SkuIds
:
1410 if SkuName
in SkuIds
and "." in TokenSpaceGuid
:
1411 S_PcdSet
.append([ TokenSpaceGuid
.split(".")[0], TokenSpaceGuid
.split(".")[1], PcdCName
, SkuName
, default_store
, Dummy5
, AnalyzePcdExpression(Setting
)[0]])
1413 # handle pcd value override
1414 StrPcdSet
= DscBuildData
.GetStructurePcdInfo(S_PcdSet
)
1415 S_pcd_set
= OrderedDict()
1416 for str_pcd
in StrPcdSet
:
1417 str_pcd_obj
= Pcds
.get((str_pcd
[1], str_pcd
[0]), None)
1418 str_pcd_dec
= self
._DecPcds
.get((str_pcd
[1], str_pcd
[0]), None)
1419 if not isinstance (str_pcd_dec
, StructurePcd
):
1420 EdkLogger
.error('build', PARSER_ERROR
,
1421 "Pcd (%s.%s) is not declared as Structure PCD in DEC files. Arch: ['%s']" % (str_pcd
[0], str_pcd
[1], self
._Arch
),
1422 File
=self
.MetaFile
, Line
= StrPcdSet
[str_pcd
][0][5])
1424 str_pcd_obj_str
= StructurePcd()
1425 str_pcd_obj_str
.copy(str_pcd_dec
)
1427 str_pcd_obj_str
.copy(str_pcd_obj
)
1428 if str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1429 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
}
1431 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
}
1432 for str_pcd_data
in StrPcdSet
[str_pcd
]:
1433 if str_pcd_data
[3] in SkuIds
:
1434 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])
1435 S_pcd_set
[str_pcd
[1], str_pcd
[0]] = str_pcd_obj_str
1437 EdkLogger
.error('build', PARSER_ERROR
,
1438 "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (str_pcd
[0], str_pcd
[1], self
._Arch
),
1439 File
=self
.MetaFile
, Line
= StrPcdSet
[str_pcd
][0][5])
1440 # Add the Structure PCD that only defined in DEC, don't have override in DSC file
1441 for Pcd
in self
.DecPcds
:
1442 if isinstance(self
._DecPcds
[Pcd
], StructurePcd
):
1443 if Pcd
not in S_pcd_set
:
1444 str_pcd_obj_str
= StructurePcd()
1445 str_pcd_obj_str
.copy(self
._DecPcds
[Pcd
])
1446 str_pcd_obj
= Pcds
.get(Pcd
, None)
1448 str_pcd_obj_str
.copy(str_pcd_obj
)
1449 if str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1450 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
}
1452 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
}
1453 S_pcd_set
[Pcd
] = str_pcd_obj_str
1455 GlobalData
.gStructurePcd
[self
.Arch
] = S_pcd_set
1456 for stru_pcd
in S_pcd_set
.values():
1457 for skuid
in SkuIds
:
1458 if skuid
in stru_pcd
.SkuOverrideValues
:
1460 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(skuid
)
1462 if skuid
not in stru_pcd
.SkuOverrideValues
:
1463 while nextskuid
not in stru_pcd
.SkuOverrideValues
:
1464 if nextskuid
== TAB_DEFAULT
:
1467 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
1468 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})
1470 stru_pcd
.ValueChain
.add((skuid
, ''))
1471 if stru_pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1472 for skuid
in SkuIds
:
1475 if skuid
not in stru_pcd
.SkuOverrideValues
:
1476 while nextskuid
not in stru_pcd
.SkuOverrideValues
:
1477 if nextskuid
== TAB_DEFAULT
:
1480 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
1483 PcdDefaultStoreSet
= set(defaultstorename
for defaultstorename
in stru_pcd
.SkuOverrideValues
[nextskuid
])
1484 mindefaultstorename
= DefaultStoreMgr
.GetMin(PcdDefaultStoreSet
)
1486 for defaultstoreid
in DefaultStores
:
1487 if defaultstoreid
not in stru_pcd
.SkuOverrideValues
[skuid
]:
1488 stru_pcd
.SkuOverrideValues
[skuid
][defaultstoreid
] = copy
.deepcopy(stru_pcd
.SkuOverrideValues
[nextskuid
][mindefaultstorename
])
1489 stru_pcd
.ValueChain
.add((skuid
, defaultstoreid
))
1490 S_pcd_set
= DscBuildData
.OverrideByFdf(S_pcd_set
,self
.WorkspaceDir
)
1491 S_pcd_set
= DscBuildData
.OverrideByComm(S_pcd_set
)
1492 Str_Pcd_Values
= self
.GenerateByteArrayValue(S_pcd_set
)
1494 for (skuname
, StoreName
, PcdGuid
, PcdName
, PcdValue
) in Str_Pcd_Values
:
1495 str_pcd_obj
= S_pcd_set
.get((PcdName
, PcdGuid
))
1496 if str_pcd_obj
is None:
1497 print(PcdName
, PcdGuid
)
1499 if str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
1500 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1501 if skuname
not in str_pcd_obj
.SkuInfoList
:
1502 str_pcd_obj
.SkuInfoList
[skuname
] = SkuInfoClass(SkuIdName
=skuname
, SkuId
=self
.SkuIds
[skuname
][0], HiiDefaultValue
=PcdValue
, DefaultStore
= {StoreName
:PcdValue
})
1504 str_pcd_obj
.SkuInfoList
[skuname
].HiiDefaultValue
= PcdValue
1505 str_pcd_obj
.SkuInfoList
[skuname
].DefaultStoreDict
.update({StoreName
:PcdValue
})
1506 elif str_pcd_obj
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
1507 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
1508 if skuname
in (self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT
, TAB_COMMON
):
1509 str_pcd_obj
.DefaultValue
= PcdValue
1511 if skuname
not in str_pcd_obj
.SkuInfoList
:
1512 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(skuname
)
1514 while nextskuid
not in str_pcd_obj
.SkuInfoList
:
1515 if nextskuid
== TAB_DEFAULT
:
1518 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
1519 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
)
1520 str_pcd_obj
.SkuInfoList
[skuname
].SkuId
= self
.SkuIds
[skuname
][0]
1521 str_pcd_obj
.SkuInfoList
[skuname
].SkuIdName
= skuname
1523 str_pcd_obj
.SkuInfoList
[skuname
].DefaultValue
= PcdValue
1524 for str_pcd_obj
in S_pcd_set
.values():
1525 if str_pcd_obj
.Type
not in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
1526 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
1528 PcdDefaultStoreSet
= set(defaultstorename
for skuobj
in str_pcd_obj
.SkuInfoList
.values() for defaultstorename
in skuobj
.DefaultStoreDict
)
1529 DefaultStoreObj
= DefaultStore(self
._GetDefaultStores
())
1530 mindefaultstorename
= DefaultStoreObj
.GetMin(PcdDefaultStoreSet
)
1531 str_pcd_obj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
].HiiDefaultValue
= str_pcd_obj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
].DefaultStoreDict
[mindefaultstorename
]
1533 for str_pcd_obj
in S_pcd_set
.values():
1535 str_pcd_obj
.MaxDatumSize
= self
.GetStructurePcdMaxSize(str_pcd_obj
)
1536 Pcds
[str_pcd_obj
.TokenCName
, str_pcd_obj
.TokenSpaceGuidCName
] = str_pcd_obj
1537 Pcds
[str_pcd_obj
.TokenCName
, str_pcd_obj
.TokenSpaceGuidCName
].CustomAttribute
['IsStru']=True
1541 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
1542 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
1543 del pcd
.SkuInfoList
[TAB_COMMON
]
1544 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
1545 del pcd
.SkuInfoList
[TAB_COMMON
]
1547 map(self
.FilterSkuSettings
, [Pcds
[pcdkey
] for pcdkey
in Pcds
if Pcds
[pcdkey
].Type
in DynamicPcdType
])
1550 ## Retrieve non-dynamic PCD settings
1552 # @param Type PCD type
1554 # @retval a dict object contains settings of given PCD type
1556 def _GetPcd(self
, Type
):
1557 Pcds
= OrderedDict()
1559 # tdict is a special dict kind of type, used for selecting correct
1560 # PCD settings for certain ARCH
1562 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
1564 PcdDict
= tdict(True, 3)
1566 # Find out all possible PCD candidates for self._Arch
1567 RecordList
= self
._RawData
[Type
, self
._Arch
]
1568 PcdValueDict
= OrderedDict()
1569 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
1570 SkuName
= SkuName
.upper()
1571 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
1572 if SkuName
not in AvailableSkuIdSet
:
1573 EdkLogger
.error('build ', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
1574 File
=self
.MetaFile
, Line
=Dummy5
)
1575 if SkuName
in (self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT
, TAB_COMMON
):
1576 if "." not in TokenSpaceGuid
:
1577 PcdSet
.add((PcdCName
, TokenSpaceGuid
, SkuName
, Dummy5
))
1578 PcdDict
[Arch
, PcdCName
, TokenSpaceGuid
, SkuName
] = Setting
1580 for PcdCName
, TokenSpaceGuid
, SkuName
, Dummy4
in PcdSet
:
1581 Setting
= PcdDict
[self
._Arch
, PcdCName
, TokenSpaceGuid
, SkuName
]
1584 PcdValue
, DatumType
, MaxDatumSize
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
1586 if int(MaxDatumSize
, 0) > 0xFFFF:
1587 EdkLogger
.error('build', FORMAT_INVALID
, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
1588 File
=self
.MetaFile
, Line
=Dummy4
)
1589 if int(MaxDatumSize
, 0) < 0:
1590 EdkLogger
.error('build', FORMAT_INVALID
, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
1591 File
=self
.MetaFile
, Line
=Dummy4
)
1592 if (PcdCName
, TokenSpaceGuid
) in PcdValueDict
:
1593 PcdValueDict
[PcdCName
, TokenSpaceGuid
][SkuName
] = (PcdValue
, DatumType
, MaxDatumSize
)
1595 PcdValueDict
[PcdCName
, TokenSpaceGuid
] = {SkuName
:(PcdValue
, DatumType
, MaxDatumSize
)}
1597 for ((PcdCName
, TokenSpaceGuid
), PcdSetting
) in PcdValueDict
.items():
1598 if self
.SkuIdMgr
.SystemSkuId
in PcdSetting
:
1599 PcdValue
, DatumType
, MaxDatumSize
= PcdSetting
[self
.SkuIdMgr
.SystemSkuId
]
1600 elif TAB_DEFAULT
in PcdSetting
:
1601 PcdValue
, DatumType
, MaxDatumSize
= PcdSetting
[TAB_DEFAULT
]
1602 elif TAB_COMMON
in PcdSetting
:
1603 PcdValue
, DatumType
, MaxDatumSize
= PcdSetting
[TAB_COMMON
]
1609 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
1612 self
._PCD
_TYPE
_STRING
_[Type
],
1622 if self
.SkuIdMgr
.SystemSkuId
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
1623 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[self
.SkuIdMgr
.SystemSkuId
] = {}
1624 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[self
.SkuIdMgr
.SystemSkuId
][TAB_DEFAULT_STORES_DEFAULT
] = PcdValue
1627 def GetStructurePcdMaxSize(self
, str_pcd
):
1628 pcd_default_value
= str_pcd
.DefaultValue
1629 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()]
1630 sku_values
.append(pcd_default_value
)
1632 def get_length(value
):
1633 Value
= value
.strip()
1635 if Value
.startswith(TAB_GUID
) and Value
.endswith(')'):
1637 if Value
.startswith('L"') and Value
.endswith('"'):
1638 return len(Value
[2:-1])
1639 if Value
[0] == '"' and Value
[-1] == '"':
1640 return len(Value
) - 2
1641 if Value
[0] == '{' and Value
[-1] == '}':
1642 return len(Value
.split(","))
1643 if Value
.startswith("L'") and Value
.endswith("'") and len(list(Value
[2:-1])) > 1:
1644 return len(list(Value
[2:-1]))
1645 if Value
[0] == "'" and Value
[-1] == "'" and len(list(Value
[1:-1])) > 1:
1646 return len(Value
) - 2
1649 return str(max(get_length(item
) for item
in sku_values
))
1652 def ExecuteCommand (Command
):
1654 Process
= subprocess
.Popen(Command
, stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
, shell
=True)
1656 EdkLogger
.error('Build', COMMAND_FAILURE
, 'Can not execute command: %s' % Command
)
1657 Result
= Process
.communicate()
1658 return Process
.returncode
, Result
[0], Result
[1]
1661 def IntToCString(Value
, ValueSize
):
1663 if not isinstance (Value
, str):
1664 for Index
in range(0, ValueSize
):
1665 Result
= Result
+ '\\x%02x' % (Value
& 0xff)
1667 Result
= Result
+ '"'
1670 def GenerateSizeFunction(self
, Pcd
):
1671 CApp
= "// Default Value in Dec \n"
1672 CApp
= CApp
+ "void Cal_%s_%s_Size(UINT32 *Size){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1673 for FieldList
in [Pcd
.DefaultValues
]:
1676 for FieldName
in FieldList
:
1677 FieldName
= "." + FieldName
1678 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
.strip(".")][0])
1679 if IsArray
and not (FieldList
[FieldName
.strip(".")][0].startswith('{GUID') and FieldList
[FieldName
.strip(".")][0].endswith('}')):
1681 Value
= ValueExpressionEx(FieldList
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1682 except BadExpression
:
1683 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1684 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), FieldList
[FieldName
.strip(".")][1], FieldList
[FieldName
.strip(".")][2]))
1685 Value
, ValueSize
= ParseFieldValue(Value
)
1686 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]);
1689 FieldName_ori
= FieldName
.strip('.')
1690 while '[' in FieldName
:
1691 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1692 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1693 FieldName
= FieldName
.split(']', 1)[1]
1694 FieldName
= NewFieldName
+ FieldName
1695 while '[' in FieldName
:
1696 FieldName
= FieldName
.rsplit('[', 1)[0]
1697 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])
1698 for skuname
in Pcd
.SkuOverrideValues
:
1699 if skuname
== TAB_COMMON
:
1701 for defaultstorenameitem
in Pcd
.SkuOverrideValues
[skuname
]:
1702 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: %s \n" % (skuname
, defaultstorenameitem
)
1703 for FieldList
in [Pcd
.SkuOverrideValues
[skuname
].get(defaultstorenameitem
)]:
1706 for FieldName
in FieldList
:
1707 FieldName
= "." + FieldName
1708 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
.strip(".")][0])
1709 if IsArray
and not (FieldList
[FieldName
.strip(".")][0].startswith('{GUID') and FieldList
[FieldName
.strip(".")][0].endswith('}')):
1711 Value
= ValueExpressionEx(FieldList
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1712 except BadExpression
:
1713 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1714 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), FieldList
[FieldName
.strip(".")][1], FieldList
[FieldName
.strip(".")][2]))
1715 Value
, ValueSize
= ParseFieldValue(Value
)
1716 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]);
1719 FieldName_ori
= FieldName
.strip('.')
1720 while '[' in FieldName
:
1721 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1722 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1723 FieldName
= FieldName
.split(']', 1)[1]
1724 FieldName
= NewFieldName
+ FieldName
1725 while '[' in FieldName
:
1726 FieldName
= FieldName
.rsplit('[', 1)[0]
1727 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])
1728 if Pcd
.PcdFieldValueFromFdf
:
1729 CApp
= CApp
+ "// From fdf \n"
1730 for FieldName
in Pcd
.PcdFieldValueFromFdf
:
1731 FieldName
= "." + FieldName
1732 IsArray
= IsFieldValueAnArray(Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0])
1733 if IsArray
and not (Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0].startswith('{GUID') and Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0].endswith('}')):
1735 Value
= ValueExpressionEx(Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1736 except BadExpression
:
1737 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1738 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][1], Pcd
.PcdFieldValueFromFdf
[FieldName
.strip(".")][2]))
1739 Value
, ValueSize
= ParseFieldValue(Value
)
1740 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]);
1743 FieldName_ori
= FieldName
.strip('.')
1744 while '[' in FieldName
:
1745 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1746 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1747 FieldName
= FieldName
.split(']', 1)[1]
1748 FieldName
= NewFieldName
+ FieldName
1749 while '[' in FieldName
:
1750 FieldName
= FieldName
.rsplit('[', 1)[0]
1751 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])
1752 if Pcd
.PcdFieldValueFromComm
:
1753 CApp
= CApp
+ "// From Command Line \n"
1754 for FieldName
in Pcd
.PcdFieldValueFromComm
:
1755 FieldName
= "." + FieldName
1756 IsArray
= IsFieldValueAnArray(Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0])
1757 if IsArray
and not (Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0].startswith('{GUID') and Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0].endswith('}')):
1759 Value
= ValueExpressionEx(Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][0], TAB_VOID
, self
._GuidDict
)(True)
1760 except BadExpression
:
1761 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1762 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
.strip('.'))), Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][1], Pcd
.PcdFieldValueFromComm
[FieldName
.strip(".")][2]))
1763 Value
, ValueSize
= ParseFieldValue(Value
)
1764 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]);
1767 FieldName_ori
= FieldName
.strip('.')
1768 while '[' in FieldName
:
1769 NewFieldName
= NewFieldName
+ FieldName
.split('[', 1)[0] + '[0]'
1770 ArrayIndex
= int(FieldName
.split('[', 1)[1].split(']', 1)[0])
1771 FieldName
= FieldName
.split(']', 1)[1]
1772 FieldName
= NewFieldName
+ FieldName
1773 while '[' in FieldName
:
1774 FieldName
= FieldName
.rsplit('[', 1)[0]
1775 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])
1776 CApp
= CApp
+ " *Size = (%d > *Size ? %d : *Size); // The Pcd maxsize is %d \n" % (Pcd
.GetPcdMaxSize(), Pcd
.GetPcdMaxSize(), Pcd
.GetPcdMaxSize())
1781 def GenerateSizeStatments(Pcd
):
1782 CApp
= ' Size = sizeof(%s);\n' % (Pcd
.DatumType
)
1783 CApp
= CApp
+ ' Cal_%s_%s_Size(&Size);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1786 def GenerateDefaultValueAssignFunction(self
, Pcd
):
1787 CApp
= "// Default value in Dec \n"
1788 CApp
= CApp
+ "void Assign_%s_%s_Default_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Pcd
.DatumType
)
1789 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1790 CApp
= CApp
+ ' CHAR8 *Value;\n'
1791 DefaultValueFromDec
= Pcd
.DefaultValueFromDec
1792 IsArray
= IsFieldValueAnArray(Pcd
.DefaultValueFromDec
)
1795 DefaultValueFromDec
= ValueExpressionEx(Pcd
.DefaultValueFromDec
, TAB_VOID
)(True)
1796 except BadExpression
:
1797 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from DEC: %s" %
1798 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, DefaultValueFromDec
))
1799 DefaultValueFromDec
= StringToArray(DefaultValueFromDec
)
1800 Value
, ValueSize
= ParseFieldValue (DefaultValueFromDec
)
1801 if isinstance(Value
, str):
1802 CApp
= CApp
+ ' Pcd = %s; // From DEC Default Value %s\n' % (Value
, Pcd
.DefaultValueFromDec
)
1805 # Use memcpy() to copy value into field
1807 CApp
= CApp
+ ' Value = %s; // From DEC Default Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), Pcd
.DefaultValueFromDec
)
1808 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1809 for FieldList
in [Pcd
.DefaultValues
]:
1812 for FieldName
in FieldList
:
1813 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
1816 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
1817 except BadExpression
:
1818 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1819 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
1822 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
1824 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]))
1825 if isinstance(Value
, str):
1826 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1829 # Use memcpy() to copy value into field
1831 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
1832 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1833 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
1836 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1838 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1843 def GenerateDefaultValueAssignStatement(Pcd
):
1844 CApp
= ' Assign_%s_%s_Default_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1847 def GenerateInitValueFunction(self
, Pcd
, SkuName
, DefaultStoreName
):
1848 CApp
= "// Value in Dsc for Sku: %s, DefaultStore %s\n" % (SkuName
, DefaultStoreName
)
1849 CApp
= CApp
+ "void Assign_%s_%s_%s_%s_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, SkuName
, DefaultStoreName
, Pcd
.DatumType
)
1850 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1851 CApp
= CApp
+ ' CHAR8 *Value;\n'
1853 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: %s \n" % (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
)
1854 inherit_OverrideValues
= Pcd
.SkuOverrideValues
[SkuName
]
1855 if (SkuName
, DefaultStoreName
) == (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
):
1856 pcddefaultvalue
= Pcd
.DefaultFromDSC
.get(TAB_DEFAULT
, {}).get(TAB_DEFAULT_STORES_DEFAULT
) if Pcd
.DefaultFromDSC
else None
1858 pcddefaultvalue
= Pcd
.DscRawValue
.get(SkuName
, {}).get(DefaultStoreName
)
1859 for FieldList
in [pcddefaultvalue
, inherit_OverrideValues
.get(DefaultStoreName
)]:
1862 if pcddefaultvalue
and FieldList
== pcddefaultvalue
:
1863 IsArray
= IsFieldValueAnArray(FieldList
)
1866 FieldList
= ValueExpressionEx(FieldList
, TAB_VOID
)(True)
1867 except BadExpression
:
1868 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from DSC: %s" %
1869 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldList
))
1870 Value
, ValueSize
= ParseFieldValue (FieldList
)
1872 if (SkuName
, DefaultStoreName
) == (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
):
1873 if isinstance(Value
, str):
1874 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
)
1877 # Use memcpy() to copy value into field
1879 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
)
1880 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1882 if isinstance(Value
, str):
1883 CApp
= CApp
+ ' Pcd = %s; // From DSC Default Value %s\n' % (Value
, Pcd
.DscRawValue
.get(SkuName
, {}).get(DefaultStoreName
))
1886 # Use memcpy() to copy value into field
1888 CApp
= CApp
+ ' Value = %s; // From DSC Default Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), Pcd
.DscRawValue
.get(SkuName
, {}).get(DefaultStoreName
))
1889 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1891 if (SkuName
, DefaultStoreName
) == (TAB_DEFAULT
, TAB_DEFAULT_STORES_DEFAULT
) or (( (SkuName
, '') not in Pcd
.ValueChain
) and ( (SkuName
, DefaultStoreName
) not in Pcd
.ValueChain
)):
1892 for FieldName
in FieldList
:
1893 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
1896 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
1897 except BadExpression
:
1898 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1899 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
1901 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
1903 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]))
1904 if isinstance(Value
, str):
1905 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1908 # Use memcpy() to copy value into field
1910 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
1911 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1912 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
1915 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1917 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1922 def GenerateInitValueStatement(Pcd
, SkuName
, DefaultStoreName
):
1923 CApp
= ' Assign_%s_%s_%s_%s_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, SkuName
, DefaultStoreName
)
1926 def GenerateCommandLineValue(self
, Pcd
):
1927 CApp
= "// Value in CommandLine\n"
1928 CApp
= CApp
+ "void Assign_%s_%s_CommandLine_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Pcd
.DatumType
)
1929 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1930 CApp
= CApp
+ ' CHAR8 *Value;\n'
1932 pcddefaultvalue
= Pcd
.PcdValueFromComm
1933 for FieldList
in [pcddefaultvalue
, Pcd
.PcdFieldValueFromComm
]:
1936 if pcddefaultvalue
and FieldList
== pcddefaultvalue
:
1937 IsArray
= IsFieldValueAnArray(FieldList
)
1940 FieldList
= ValueExpressionEx(FieldList
, TAB_VOID
)(True)
1941 except BadExpression
:
1942 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from Command: %s" %
1943 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldList
))
1944 Value
, ValueSize
= ParseFieldValue (FieldList
)
1946 if isinstance(Value
, str):
1947 CApp
= CApp
+ ' Pcd = %s; // From Command Line \n' % (Value
)
1950 # Use memcpy() to copy value into field
1952 CApp
= CApp
+ ' Value = %s; // From Command Line.\n' % (DscBuildData
.IntToCString(Value
, ValueSize
))
1953 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
1955 for FieldName
in FieldList
:
1956 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
1959 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
1960 except BadExpression
:
1961 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
1962 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
1966 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
1968 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]))
1969 if isinstance(Value
, str):
1970 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1973 # Use memcpy() to copy value into field
1975 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
1976 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1977 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
1980 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1982 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
1987 def GenerateCommandLineValueStatement(Pcd
):
1988 CApp
= ' Assign_%s_%s_CommandLine_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
1990 def GenerateFdfValue(self
,Pcd
):
1991 CApp
= "// Value in Fdf\n"
1992 CApp
= CApp
+ "void Assign_%s_%s_Fdf_Value(%s *Pcd){\n" % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
,Pcd
.DatumType
)
1993 CApp
= CApp
+ ' UINT32 FieldSize;\n'
1994 CApp
= CApp
+ ' CHAR8 *Value;\n'
1996 pcddefaultvalue
= Pcd
.PcdValueFromFdf
1997 for FieldList
in [pcddefaultvalue
,Pcd
.PcdFieldValueFromFdf
]:
2000 if pcddefaultvalue
and FieldList
== pcddefaultvalue
:
2001 IsArray
= IsFieldValueAnArray(FieldList
)
2004 FieldList
= ValueExpressionEx(FieldList
, TAB_VOID
)(True)
2005 except BadExpression
:
2006 EdkLogger
.error("Build", FORMAT_INVALID
, "Invalid value format for %s.%s, from Fdf: %s" %
2007 (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldList
))
2008 Value
, ValueSize
= ParseFieldValue (FieldList
)
2010 if isinstance(Value
, str):
2011 CApp
= CApp
+ ' Pcd = %s; // From Fdf \n' % (Value
)
2014 # Use memcpy() to copy value into field
2016 CApp
= CApp
+ ' Value = %s; // From Fdf .\n' % (DscBuildData
.IntToCString(Value
, ValueSize
))
2017 CApp
= CApp
+ ' memcpy (Pcd, Value, %d);\n' % (ValueSize
)
2019 for FieldName
in FieldList
:
2020 IsArray
= IsFieldValueAnArray(FieldList
[FieldName
][0])
2023 FieldList
[FieldName
][0] = ValueExpressionEx(FieldList
[FieldName
][0], TAB_VOID
, self
._GuidDict
)(True)
2024 except BadExpression
:
2025 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid value format for %s. From %s Line %d " %
2026 (".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, FieldName
)), FieldList
[FieldName
][1], FieldList
[FieldName
][2]))
2030 Value
, ValueSize
= ParseFieldValue (FieldList
[FieldName
][0])
2032 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]))
2033 if isinstance(Value
, str):
2034 CApp
= CApp
+ ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2037 # Use memcpy() to copy value into field
2039 CApp
= CApp
+ ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd
.DatumType
, FieldName
)
2040 CApp
= CApp
+ ' Value = %s; // From %s Line %d Value %s\n' % (DscBuildData
.IntToCString(Value
, ValueSize
), FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2041 CApp
= CApp
+ ' memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName
, ValueSize
, ValueSize
)
2044 CApp
= CApp
+ ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2046 CApp
= CApp
+ ' Pcd->%s = %d; // From %s Line %s Value %s\n' % (FieldName
, Value
, FieldList
[FieldName
][1], FieldList
[FieldName
][2], FieldList
[FieldName
][0])
2051 def GenerateFdfValueStatement(Pcd
):
2052 CApp
= ' Assign_%s_%s_Fdf_Value(Pcd);\n' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2055 def GenerateInitializeFunc(self
, SkuName
, DefaultStore
, Pcd
, InitByteValue
, CApp
):
2056 OverrideValues
= {DefaultStore
:""}
2057 if Pcd
.SkuOverrideValues
:
2058 OverrideValues
= Pcd
.SkuOverrideValues
[SkuName
]
2059 if not OverrideValues
:
2060 OverrideValues
= {TAB_DEFAULT_STORES_DEFAULT
:Pcd
.DefaultValues
}
2061 for DefaultStoreName
in OverrideValues
:
2062 CApp
= CApp
+ 'void\n'
2063 CApp
= CApp
+ 'Initialize_%s_%s_%s_%s(\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2064 CApp
= CApp
+ ' void\n'
2065 CApp
= CApp
+ ' )\n'
2067 CApp
= CApp
+ ' UINT32 Size;\n'
2068 CApp
= CApp
+ ' UINT32 FieldSize;\n'
2069 CApp
= CApp
+ ' CHAR8 *Value;\n'
2070 CApp
= CApp
+ ' UINT32 OriginalSize;\n'
2071 CApp
= CApp
+ ' VOID *OriginalPcd;\n'
2072 CApp
= CApp
+ ' %s *Pcd; // From %s Line %d \n' % (Pcd
.DatumType
, Pcd
.PkgPath
, Pcd
.PcdDefineLineNo
)
2075 if SkuName
in Pcd
.SkuInfoList
:
2076 DefaultValue
= Pcd
.SkuInfoList
[SkuName
].DefaultStoreDict
.get(DefaultStoreName
, Pcd
.SkuInfoList
[SkuName
].HiiDefaultValue
if Pcd
.SkuInfoList
[SkuName
].HiiDefaultValue
else Pcd
.SkuInfoList
[SkuName
].DefaultValue
)
2078 DefaultValue
= Pcd
.DefaultValue
2079 PcdDefaultValue
= StringToArray(DefaultValue
.strip())
2081 InitByteValue
+= '%s.%s.%s.%s|%s|%s\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Pcd
.DatumType
, PcdDefaultValue
)
2084 # Get current PCD value and size
2086 CApp
= CApp
+ ' OriginalPcd = PcdGetPtr (%s, %s, %s, %s, &OriginalSize);\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2089 # Determine the size of the PCD. For simple structures, sizeof(TYPE) provides
2090 # the correct value. For structures with a flexible array member, the flexible
2091 # array member is detected, and the size is based on the highest index used with
2092 # the flexible array member. The flexible array member must be the last field
2093 # in a structure. The size formula for this case is:
2094 # OFFSET_OF(FlexbleArrayField) + sizeof(FlexibleArray[0]) * (HighestIndex + 1)
2096 CApp
= CApp
+ DscBuildData
.GenerateSizeStatments(Pcd
)
2099 # Allocate and zero buffer for the PCD
2100 # Must handle cases where current value is smaller, larger, or same size
2101 # Always keep that larger one as the current size
2103 CApp
= CApp
+ ' Size = (OriginalSize > Size ? OriginalSize : Size);\n'
2104 CApp
= CApp
+ ' Pcd = (%s *)malloc (Size);\n' % (Pcd
.DatumType
)
2105 CApp
= CApp
+ ' memset (Pcd, 0, Size);\n'
2108 # Copy current PCD value into allocated buffer.
2110 CApp
= CApp
+ ' memcpy (Pcd, OriginalPcd, OriginalSize);\n'
2113 # Assign field values in PCD
2115 CApp
= CApp
+ DscBuildData
.GenerateDefaultValueAssignStatement(Pcd
)
2116 if Pcd
.Type
not in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
2117 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
2118 for skuname
in self
.SkuIdMgr
.GetSkuChain(SkuName
):
2119 storeset
= [DefaultStoreName
] if DefaultStoreName
== TAB_DEFAULT_STORES_DEFAULT
else [TAB_DEFAULT_STORES_DEFAULT
, DefaultStoreName
]
2120 for defaultstorenameitem
in storeset
:
2121 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: %s \n" % (skuname
, defaultstorenameitem
)
2122 CApp
= CApp
+ DscBuildData
.GenerateInitValueStatement(Pcd
, skuname
, defaultstorenameitem
)
2123 if skuname
== SkuName
:
2126 CApp
= CApp
+ "// SkuName: %s, DefaultStoreName: STANDARD \n" % self
.SkuIdMgr
.SystemSkuId
2127 CApp
= CApp
+ DscBuildData
.GenerateInitValueStatement(Pcd
, self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
)
2128 CApp
= CApp
+ DscBuildData
.GenerateFdfValueStatement(Pcd
)
2129 CApp
= CApp
+ DscBuildData
.GenerateCommandLineValueStatement(Pcd
)
2131 # Set new PCD value and size
2133 CApp
= CApp
+ ' PcdSetPtr (%s, %s, %s, %s, Size, (UINT8 *)Pcd);\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2138 CApp
= CApp
+ ' free (Pcd);\n'
2141 return InitByteValue
, CApp
2142 def SkuOverrideValuesEmpty(self
,OverrideValues
):
2143 if not OverrideValues
:
2145 for key
in OverrideValues
:
2146 if OverrideValues
[key
]:
2150 def GenerateByteArrayValue (self
, StructuredPcds
):
2152 # Generate/Compile/Run C application to determine if there are any flexible array members
2154 if not StructuredPcds
:
2158 CApp
= PcdMainCHeader
2160 IncludeFiles
= set()
2161 for PcdName
in StructuredPcds
:
2162 Pcd
= StructuredPcds
[PcdName
]
2163 for IncludeFile
in Pcd
.StructuredPcdIncludeFile
:
2164 if IncludeFile
not in IncludeFiles
:
2165 IncludeFiles
.add(IncludeFile
)
2166 CApp
= CApp
+ '#include <%s>\n' % (IncludeFile
)
2168 for PcdName
in StructuredPcds
:
2169 Pcd
= StructuredPcds
[PcdName
]
2170 CApp
= CApp
+ self
.GenerateSizeFunction(Pcd
)
2171 CApp
= CApp
+ self
.GenerateDefaultValueAssignFunction(Pcd
)
2172 CApp
= CApp
+ self
.GenerateFdfValue(Pcd
)
2173 CApp
= CApp
+ self
.GenerateCommandLineValue(Pcd
)
2174 if self
.SkuOverrideValuesEmpty(Pcd
.SkuOverrideValues
) or Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
2175 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
2176 CApp
= CApp
+ self
.GenerateInitValueFunction(Pcd
, self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
)
2178 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
2179 if SkuName
not in Pcd
.SkuOverrideValues
:
2181 for DefaultStoreName
in Pcd
.SkuOverrideValues
[SkuName
]:
2182 CApp
= CApp
+ self
.GenerateInitValueFunction(Pcd
, SkuName
, DefaultStoreName
)
2183 if self
.SkuOverrideValuesEmpty(Pcd
.SkuOverrideValues
) or Pcd
.Type
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_FIXED_AT_BUILD
],
2184 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_PATCHABLE_IN_MODULE
]]:
2185 InitByteValue
, CApp
= self
.GenerateInitializeFunc(self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
, Pcd
, InitByteValue
, CApp
)
2187 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
2188 if SkuName
not in Pcd
.SkuOverrideValues
:
2190 for DefaultStoreName
in Pcd
.DefaultStoreName
:
2191 Pcd
= StructuredPcds
[PcdName
]
2192 InitByteValue
, CApp
= self
.GenerateInitializeFunc(SkuName
, DefaultStoreName
, Pcd
, InitByteValue
, CApp
)
2194 CApp
= CApp
+ 'VOID\n'
2195 CApp
= CApp
+ 'PcdEntryPoint(\n'
2196 CApp
= CApp
+ ' VOID\n'
2197 CApp
= CApp
+ ' )\n'
2199 for Pcd
in StructuredPcds
.values():
2200 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
]]:
2201 CApp
= CApp
+ ' Initialize_%s_%s_%s_%s();\n' % (self
.SkuIdMgr
.SystemSkuId
, TAB_DEFAULT_STORES_DEFAULT
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2203 for SkuName
in self
.SkuIdMgr
.SkuOverrideOrder():
2204 if SkuName
not in self
.SkuIdMgr
.AvailableSkuIdSet
:
2206 for DefaultStoreName
in Pcd
.SkuOverrideValues
[SkuName
]:
2207 CApp
= CApp
+ ' Initialize_%s_%s_%s_%s();\n' % (SkuName
, DefaultStoreName
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)
2210 CApp
= CApp
+ PcdMainCEntry
+ '\n'
2212 if not os
.path
.exists(self
.OutputPath
):
2213 os
.makedirs(self
.OutputPath
)
2214 CAppBaseFileName
= os
.path
.join(self
.OutputPath
, PcdValueInitName
)
2215 SaveFileOnChange(CAppBaseFileName
+ '.c', CApp
, False)
2217 MakeApp
= PcdMakefileHeader
2218 if sys
.platform
== "win32":
2219 MakeApp
= MakeApp
+ 'APPNAME = %s\n' % (PcdValueInitName
) + 'OBJECTS = %s\%s.obj\n' % (self
.OutputPath
, PcdValueInitName
) + 'INC = '
2221 MakeApp
= MakeApp
+ PcdGccMakefile
2222 MakeApp
= MakeApp
+ 'APPNAME = %s\n' % (PcdValueInitName
) + 'OBJECTS = %s/%s.o\n' % (self
.OutputPath
, PcdValueInitName
) + \
2223 'include $(MAKEROOT)/Makefiles/app.makefile\n' + 'INCLUDE +='
2226 PlatformInc
= OrderedDict()
2227 for Cache
in self
._Bdb
._CACHE
_.values():
2228 if Cache
.MetaFile
.Ext
.lower() != '.dec':
2231 if str(Cache
.MetaFile
.Path
) not in PlatformInc
:
2232 PlatformInc
[str(Cache
.MetaFile
.Path
)] = []
2233 PlatformInc
[str(Cache
.MetaFile
.Path
)].append (os
.path
.dirname(Cache
.MetaFile
.Path
))
2234 PlatformInc
[str(Cache
.MetaFile
.Path
)].extend (Cache
.CommonIncludes
)
2237 for Pcd
in StructuredPcds
.values():
2238 for PackageDec
in Pcd
.PackageDecs
:
2239 Package
= os
.path
.normpath(mws
.join(GlobalData
.gWorkspace
, PackageDec
))
2240 if not os
.path
.exists(Package
):
2241 EdkLogger
.error('Build', RESOURCE_NOT_AVAILABLE
, "The dependent Package %s of PCD %s.%s is not exist." % (PackageDec
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
))
2242 if Package
not in PcdDependDEC
:
2243 PcdDependDEC
.append(Package
)
2245 if PlatformInc
and PcdDependDEC
:
2246 for pkg
in PcdDependDEC
:
2247 if pkg
in PlatformInc
:
2248 for inc
in PlatformInc
[pkg
]:
2249 MakeApp
+= '-I' + str(inc
) + ' '
2250 IncSearchList
.append(inc
)
2251 MakeApp
= MakeApp
+ '\n'
2253 CC_FLAGS
= LinuxCFLAGS
2254 if sys
.platform
== "win32":
2255 CC_FLAGS
= WindowsCFLAGS
2256 BuildOptions
= OrderedDict()
2257 for Options
in self
.BuildOptions
:
2258 if Options
[2] != EDKII_NAME
:
2261 if Family
and Family
!= self
.ToolChainFamily
:
2263 Target
, Tag
, Arch
, Tool
, Attr
= Options
[1].split("_")
2267 if Target
== "*" or Target
== self
._Target
:
2268 if Tag
== "*" or Tag
== self
._Toolchain
:
2269 if Arch
== "*" or Arch
== self
.Arch
:
2270 if Tool
not in BuildOptions
:
2271 BuildOptions
[Tool
] = OrderedDict()
2272 if Attr
!= "FLAGS" or Attr
not in BuildOptions
[Tool
] or self
.BuildOptions
[Options
].startswith('='):
2273 BuildOptions
[Tool
][Attr
] = self
.BuildOptions
[Options
]
2275 # append options for the same tool except PATH
2277 BuildOptions
[Tool
][Attr
] += " " + self
.BuildOptions
[Options
]
2279 BuildOptions
[Tool
][Attr
] = self
.BuildOptions
[Options
]
2281 for Tool
in BuildOptions
:
2282 for Attr
in BuildOptions
[Tool
]:
2284 Value
= BuildOptions
[Tool
][Attr
]
2285 ValueList
= Value
.split()
2287 for Id
, Item
in enumerate(ValueList
):
2288 if Item
in ['-D', '/D', '-U', '/U']:
2289 CC_FLAGS
+= ' ' + Item
2290 if Id
+ 1 < len(ValueList
):
2291 CC_FLAGS
+= ' ' + ValueList
[Id
+ 1]
2292 elif Item
.startswith(('-D', '/D', '-U', '/U')):
2293 CC_FLAGS
+= ' ' + Item
2296 if sys
.platform
== "win32":
2297 MakeApp
= MakeApp
+ PcdMakefileEnd
2298 MakeApp
= MakeApp
+ '\n'
2299 IncludeFileFullPaths
= []
2300 for includefile
in IncludeFiles
:
2301 for includepath
in IncSearchList
:
2302 includefullpath
= os
.path
.join(str(includepath
), includefile
)
2303 if os
.path
.exists(includefullpath
):
2304 IncludeFileFullPaths
.append(os
.path
.normpath(includefullpath
))
2307 SearchPathList
.append(os
.path
.normpath(mws
.join(GlobalData
.gWorkspace
, "BaseTools/Source/C/Include")))
2308 SearchPathList
.append(os
.path
.normpath(mws
.join(GlobalData
.gWorkspace
, "BaseTools/Source/C/Common")))
2309 SearchPathList
.extend(str(item
) for item
in IncSearchList
)
2310 IncFileList
= GetDependencyList(IncludeFileFullPaths
, SearchPathList
)
2311 for include_file
in IncFileList
:
2312 MakeApp
+= "$(OBJECTS) : %s\n" % include_file
2313 MakeFileName
= os
.path
.join(self
.OutputPath
, 'Makefile')
2314 MakeApp
+= "$(OBJECTS) : %s\n" % MakeFileName
2315 SaveFileOnChange(MakeFileName
, MakeApp
, False)
2317 InputValueFile
= os
.path
.join(self
.OutputPath
, 'Input.txt')
2318 OutputValueFile
= os
.path
.join(self
.OutputPath
, 'Output.txt')
2319 SaveFileOnChange(InputValueFile
, InitByteValue
, False)
2321 PcdValueInitExe
= PcdValueInitName
2322 if not sys
.platform
== "win32":
2323 PcdValueInitExe
= os
.path
.join(os
.getenv("EDK_TOOLS_PATH"), 'Source', 'C', 'bin', PcdValueInitName
)
2325 PcdValueInitExe
= os
.path
.join(os
.getenv("EDK_TOOLS_PATH"), 'Bin', 'Win32', PcdValueInitName
) +".exe"
2328 if sys
.platform
== "win32":
2329 MakeCommand
= 'nmake -f %s' % (MakeFileName
)
2330 returncode
, StdOut
, StdErr
= DscBuildData
.ExecuteCommand (MakeCommand
)
2333 MakeCommand
= 'make -f %s' % (MakeFileName
)
2334 returncode
, StdOut
, StdErr
= DscBuildData
.ExecuteCommand (MakeCommand
)
2336 Messages
= Messages
.split('\n')
2339 CAppBaseFileName
= os
.path
.join(self
.OutputPath
, PcdValueInitName
)
2340 File
= open (CAppBaseFileName
+ '.c', 'r')
2341 FileData
= File
.readlines()
2343 for Message
in Messages
:
2344 if " error" in Message
or "warning" in Message
:
2345 FileInfo
= Message
.strip().split('(')
2346 if len (FileInfo
) > 1:
2347 FileName
= FileInfo
[0]
2348 FileLine
= FileInfo
[1].split (')')[0]
2350 FileInfo
= Message
.strip().split(':')
2351 FileName
= FileInfo
[0]
2352 FileLine
= FileInfo
[1]
2353 if FileLine
.isdigit():
2354 error_line
= FileData
[int (FileLine
) - 1]
2355 if r
"//" in error_line
:
2356 c_line
, dsc_line
= error_line
.split(r
"//")
2358 dsc_line
= error_line
2359 message_itmes
= Message
.split(":")
2361 if "PcdValueInit.c" not in Message
:
2362 if not MessageGroup
:
2363 MessageGroup
.append(Message
)
2366 for item
in message_itmes
:
2367 if "PcdValueInit.c" in item
:
2368 Index
= message_itmes
.index(item
)
2369 message_itmes
[Index
] = dsc_line
.strip()
2371 MessageGroup
.append(":".join(message_itmes
[Index
:]).strip())
2374 MessageGroup
.append(Message
)
2376 EdkLogger
.error("build", PCD_STRUCTURE_PCD_ERROR
, "\n".join(MessageGroup
) )
2378 EdkLogger
.error('Build', COMMAND_FAILURE
, 'Can not execute command: %s' % MakeCommand
)
2380 if DscBuildData
.NeedUpdateOutput(OutputValueFile
, PcdValueInitExe
, InputValueFile
):
2381 Command
= PcdValueInitExe
+ ' -i %s -o %s' % (InputValueFile
, OutputValueFile
)
2382 returncode
, StdOut
, StdErr
= DscBuildData
.ExecuteCommand (Command
)
2384 EdkLogger
.warn('Build', COMMAND_FAILURE
, 'Can not collect output from command: %s' % Command
)
2386 File
= open (OutputValueFile
, 'r')
2387 FileBuffer
= File
.readlines()
2390 StructurePcdSet
= []
2391 for Pcd
in FileBuffer
:
2392 PcdValue
= Pcd
.split ('|')
2393 PcdInfo
= PcdValue
[0].split ('.')
2394 StructurePcdSet
.append((PcdInfo
[0], PcdInfo
[1], PcdInfo
[2], PcdInfo
[3], PcdValue
[2].strip()))
2395 return StructurePcdSet
2398 def NeedUpdateOutput(OutputFile
, ValueCFile
, StructureInput
):
2399 if not os
.path
.exists(OutputFile
):
2401 if os
.stat(OutputFile
).st_mtime
<= os
.stat(ValueCFile
).st_mtime
:
2403 if os
.stat(OutputFile
).st_mtime
<= os
.stat(StructureInput
).st_mtime
:
2407 ## Retrieve dynamic PCD settings
2409 # @param Type PCD type
2411 # @retval a dict object contains settings of given PCD type
2413 def _GetDynamicPcd(self
, Type
):
2416 Pcds
= OrderedDict()
2418 # tdict is a special dict kind of type, used for selecting correct
2419 # PCD settings for certain ARCH and SKU
2421 PcdDict
= tdict(True, 4)
2423 # Find out all possible PCD candidates for self._Arch
2424 RecordList
= self
._RawData
[Type
, self
._Arch
]
2425 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
2428 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
2429 SkuName
= SkuName
.upper()
2430 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
2431 if SkuName
not in AvailableSkuIdSet
:
2432 EdkLogger
.error('build', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
2433 File
=self
.MetaFile
, Line
=Dummy5
)
2434 if "." not in TokenSpaceGuid
:
2435 PcdList
.append((PcdCName
, TokenSpaceGuid
, SkuName
, Dummy5
))
2436 PcdDict
[Arch
, SkuName
, PcdCName
, TokenSpaceGuid
] = Setting
2438 # Remove redundant PCD candidates, per the ARCH and SKU
2439 for PcdCName
, TokenSpaceGuid
, SkuName
, Dummy4
in PcdList
:
2441 Setting
= PcdDict
[self
._Arch
, SkuName
, PcdCName
, TokenSpaceGuid
]
2445 PcdValue
, DatumType
, MaxDatumSize
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
2447 if int(MaxDatumSize
, 0) > 0xFFFF:
2448 EdkLogger
.error('build', FORMAT_INVALID
, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2449 File
=self
.MetaFile
, Line
=Dummy4
)
2450 if int(MaxDatumSize
, 0) < 0:
2451 EdkLogger
.error('build', FORMAT_INVALID
, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2452 File
=self
.MetaFile
, Line
=Dummy4
)
2453 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], '', '', '', '', '', PcdValue
)
2454 if (PcdCName
, TokenSpaceGuid
) in Pcds
:
2455 pcdObject
= Pcds
[PcdCName
, TokenSpaceGuid
]
2456 pcdObject
.SkuInfoList
[SkuName
] = SkuInfo
2457 if MaxDatumSize
.strip():
2458 CurrentMaxSize
= int(MaxDatumSize
.strip(), 0)
2461 if pcdObject
.MaxDatumSize
:
2462 PcdMaxSize
= int(pcdObject
.MaxDatumSize
, 0)
2465 if CurrentMaxSize
> PcdMaxSize
:
2466 pcdObject
.MaxDatumSize
= str(CurrentMaxSize
)
2468 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
2471 self
._PCD
_TYPE
_STRING
_[Type
],
2476 OrderedDict({SkuName
: SkuInfo
}),
2481 if SkuName
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
2482 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
] = {}
2483 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
][TAB_DEFAULT_STORES_DEFAULT
] = PcdValue
2485 for pcd
in Pcds
.values():
2486 pcdDecObject
= self
._DecPcds
[pcd
.TokenCName
, pcd
.TokenSpaceGuidCName
]
2487 # Only fix the value while no value provided in DSC file.
2488 for sku
in pcd
.SkuInfoList
.values():
2489 if not sku
.DefaultValue
:
2490 sku
.DefaultValue
= pcdDecObject
.DefaultValue
2491 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
not in pcd
.SkuInfoList
:
2492 valuefromDec
= pcdDecObject
.DefaultValue
2493 SkuInfo
= SkuInfoClass(TAB_DEFAULT
, '0', '', '', '', '', '', valuefromDec
)
2494 pcd
.SkuInfoList
[TAB_DEFAULT
] = SkuInfo
2495 elif TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2496 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
2497 del pcd
.SkuInfoList
[TAB_COMMON
]
2498 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2499 del pcd
.SkuInfoList
[TAB_COMMON
]
2501 map(self
.FilterSkuSettings
, Pcds
.values())
2505 def FilterSkuSettings(self
, PcdObj
):
2507 if self
.SkuIdMgr
.SkuUsageType
== self
.SkuIdMgr
.SINGLE
:
2508 if TAB_DEFAULT
in PcdObj
.SkuInfoList
and self
.SkuIdMgr
.SystemSkuId
not in PcdObj
.SkuInfoList
:
2509 PcdObj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
] = PcdObj
.SkuInfoList
[TAB_DEFAULT
]
2510 PcdObj
.SkuInfoList
= {TAB_DEFAULT
:PcdObj
.SkuInfoList
[self
.SkuIdMgr
.SystemSkuId
]}
2511 PcdObj
.SkuInfoList
[TAB_DEFAULT
].SkuIdName
= TAB_DEFAULT
2512 PcdObj
.SkuInfoList
[TAB_DEFAULT
].SkuId
= '0'
2514 elif self
.SkuIdMgr
.SkuUsageType
== self
.SkuIdMgr
.DEFAULT
:
2515 PcdObj
.SkuInfoList
= {TAB_DEFAULT
:PcdObj
.SkuInfoList
[TAB_DEFAULT
]}
2520 def CompareVarAttr(Attr1
, Attr2
):
2521 if not Attr1
or not Attr2
: # for empty string
2523 Attr1s
= [attr
.strip() for attr
in Attr1
.split(",")]
2524 Attr1Set
= set(Attr1s
)
2525 Attr2s
= [attr
.strip() for attr
in Attr2
.split(",")]
2526 Attr2Set
= set(Attr2s
)
2527 if Attr2Set
== Attr1Set
:
2532 def CompletePcdValues(self
, PcdSet
):
2533 Pcds
= OrderedDict()
2534 DefaultStoreObj
= DefaultStore(self
._GetDefaultStores
())
2535 SkuIds
= {skuname
:skuid
for skuname
, skuid
in self
.SkuIdMgr
.AvailableSkuIdSet
.items() if skuname
!= TAB_COMMON
}
2536 DefaultStores
= set(storename
for pcdobj
in PcdSet
.values() for skuobj
in pcdobj
.SkuInfoList
.values() for storename
in skuobj
.DefaultStoreDict
)
2537 for PcdCName
, TokenSpaceGuid
in PcdSet
:
2538 PcdObj
= PcdSet
[(PcdCName
, TokenSpaceGuid
)]
2540 if PcdObj
.Type
not in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_DEFAULT
],
2541 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
],
2542 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_VPD
],
2543 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_DEFAULT
],
2544 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
],
2545 self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_VPD
]]:
2546 Pcds
[PcdCName
, TokenSpaceGuid
]= PcdObj
2548 PcdType
= PcdObj
.Type
2549 if PcdType
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
2550 for skuid
in PcdObj
.SkuInfoList
:
2551 skuobj
= PcdObj
.SkuInfoList
[skuid
]
2552 mindefaultstorename
= DefaultStoreObj
.GetMin(set(defaultstorename
for defaultstorename
in skuobj
.DefaultStoreDict
))
2553 for defaultstorename
in DefaultStores
:
2554 if defaultstorename
not in skuobj
.DefaultStoreDict
:
2555 skuobj
.DefaultStoreDict
[defaultstorename
] = copy
.deepcopy(skuobj
.DefaultStoreDict
[mindefaultstorename
])
2556 skuobj
.HiiDefaultValue
= skuobj
.DefaultStoreDict
[mindefaultstorename
]
2557 for skuname
, skuid
in SkuIds
.items():
2558 if skuname
not in PcdObj
.SkuInfoList
:
2559 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(skuname
)
2560 while nextskuid
not in PcdObj
.SkuInfoList
:
2561 nextskuid
= self
.SkuIdMgr
.GetNextSkuId(nextskuid
)
2562 PcdObj
.SkuInfoList
[skuname
] = copy
.deepcopy(PcdObj
.SkuInfoList
[nextskuid
])
2563 PcdObj
.SkuInfoList
[skuname
].SkuId
= skuid
2564 PcdObj
.SkuInfoList
[skuname
].SkuIdName
= skuname
2565 if PcdType
in [self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_HII
], self
._PCD
_TYPE
_STRING
_[MODEL_PCD_DYNAMIC_EX_HII
]]:
2566 PcdObj
.DefaultValue
= PcdObj
.SkuInfoList
.values()[0].HiiDefaultValue
if self
.SkuIdMgr
.SkuUsageType
== self
.SkuIdMgr
.SINGLE
else PcdObj
.SkuInfoList
[TAB_DEFAULT
].HiiDefaultValue
2567 Pcds
[PcdCName
, TokenSpaceGuid
]= PcdObj
2569 ## Retrieve dynamic HII PCD settings
2571 # @param Type PCD type
2573 # @retval a dict object contains settings of given PCD type
2575 def _GetDynamicHiiPcd(self
, Type
):
2579 Pcds
= OrderedDict()
2580 UserDefinedDefaultStores
= []
2582 # tdict is a special dict kind of type, used for selecting correct
2583 # PCD settings for certain ARCH and SKU
2585 PcdDict
= tdict(True, 5)
2587 RecordList
= self
._RawData
[Type
, self
._Arch
]
2588 # Find out all possible PCD candidates for self._Arch
2589 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
2590 DefaultStoresDefine
= self
._GetDefaultStores
()
2592 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, DefaultStore
, Dummy4
, Dummy5
in RecordList
:
2593 SkuName
= SkuName
.upper()
2594 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
2595 DefaultStore
= DefaultStore
.upper()
2596 if DefaultStore
== TAB_COMMON
:
2597 DefaultStore
= TAB_DEFAULT_STORES_DEFAULT
2599 #The end user define [DefaultStores] and [SKUID_IDENTIFIER.Menufacturing] in DSC
2600 UserDefinedDefaultStores
.append((PcdCName
, TokenSpaceGuid
))
2601 if SkuName
not in AvailableSkuIdSet
:
2602 EdkLogger
.error('build', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
2603 File
=self
.MetaFile
, Line
=Dummy5
)
2604 if DefaultStore
not in DefaultStoresDefine
:
2605 EdkLogger
.error('build', PARAMETER_INVALID
, 'DefaultStores %s is not defined in [DefaultStores] section' % DefaultStore
,
2606 File
=self
.MetaFile
, Line
=Dummy5
)
2607 if "." not in TokenSpaceGuid
:
2608 PcdSet
.add((PcdCName
, TokenSpaceGuid
, SkuName
, DefaultStore
, Dummy5
))
2609 PcdDict
[Arch
, SkuName
, PcdCName
, TokenSpaceGuid
, DefaultStore
] = Setting
2612 # Remove redundant PCD candidates, per the ARCH and SKU
2613 for PcdCName
, TokenSpaceGuid
, SkuName
, DefaultStore
, Dummy4
in PcdSet
:
2615 Setting
= PcdDict
[self
._Arch
, SkuName
, PcdCName
, TokenSpaceGuid
, DefaultStore
]
2618 VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VarAttribute
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
2620 rt
, Msg
= VariableAttributes
.ValidateVarAttributes(VarAttribute
)
2622 EdkLogger
.error("build", PCD_VARIABLE_ATTRIBUTES_ERROR
, "Variable attributes settings for %s is incorrect.\n %s" % (".".join((TokenSpaceGuid
, PcdCName
)), Msg
),
2623 ExtraData
="[%s]" % VarAttribute
)
2625 FormatCorrect
= True
2626 if VariableOffset
.isdigit():
2627 if int(VariableOffset
, 10) > 0xFFFF:
2629 elif variablePattern
.match(VariableOffset
):
2630 if int(VariableOffset
, 16) > 0xFFFF:
2632 # For Offset written in "A.B"
2633 elif VariableOffset
.find('.') > -1:
2634 VariableOffsetList
= VariableOffset
.split(".")
2635 if not (len(VariableOffsetList
) == 2
2636 and IsValidWord(VariableOffsetList
[0])
2637 and IsValidWord(VariableOffsetList
[1])):
2638 FormatCorrect
= False
2640 FormatCorrect
= False
2641 if not FormatCorrect
:
2642 EdkLogger
.error('Build', FORMAT_INVALID
, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid
, PcdCName
)))
2645 EdkLogger
.error('Build', OPTION_VALUE_INVALID
, "The variable offset value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)))
2646 if (VariableName
, VariableGuid
) not in VariableAttrs
:
2647 VariableAttrs
[(VariableName
, VariableGuid
)] = VarAttribute
2649 if not DscBuildData
.CompareVarAttr(VariableAttrs
[(VariableName
, VariableGuid
)], VarAttribute
):
2650 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
)]))
2652 pcdDecObject
= self
._DecPcds
[PcdCName
, TokenSpaceGuid
]
2653 if (PcdCName
, TokenSpaceGuid
) in Pcds
:
2654 pcdObject
= Pcds
[PcdCName
, TokenSpaceGuid
]
2655 if SkuName
in pcdObject
.SkuInfoList
:
2656 Skuitem
= pcdObject
.SkuInfoList
[SkuName
]
2657 Skuitem
.DefaultStoreDict
.update({DefaultStore
:DefaultValue
})
2659 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VariableAttribute
=VarAttribute
, DefaultStore
={DefaultStore
:DefaultValue
})
2660 pcdObject
.SkuInfoList
[SkuName
] = SkuInfo
2662 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], VariableName
, VariableGuid
, VariableOffset
, DefaultValue
, VariableAttribute
=VarAttribute
, DefaultStore
={DefaultStore
:DefaultValue
})
2663 PcdClassObj
= PcdClassObject(
2666 self
._PCD
_TYPE
_STRING
_[Type
],
2671 OrderedDict({SkuName
: SkuInfo
}),
2674 pcdDecObject
.validateranges
,
2675 pcdDecObject
.validlists
,
2676 pcdDecObject
.expressions
,
2678 if (PcdCName
, TokenSpaceGuid
) in UserDefinedDefaultStores
:
2679 PcdClassObj
.UserDefinedDefaultStoresFlag
= True
2680 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObj
2682 Pcds
[PcdCName
, TokenSpaceGuid
].CustomAttribute
['DscPosition'] = int(Dummy4
)
2683 if SkuName
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
2684 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
] = {}
2685 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
][DefaultStore
] = DefaultValue
2686 for pcd
in Pcds
.values():
2687 SkuInfoObj
= pcd
.SkuInfoList
.values()[0]
2688 pcdDecObject
= self
._DecPcds
[pcd
.TokenCName
, pcd
.TokenSpaceGuidCName
]
2689 pcd
.DatumType
= pcdDecObject
.DatumType
2690 # Only fix the value while no value provided in DSC file.
2691 for sku
in pcd
.SkuInfoList
.values():
2692 if (sku
.HiiDefaultValue
== "" or sku
.HiiDefaultValue
is None):
2693 sku
.HiiDefaultValue
= pcdDecObject
.DefaultValue
2694 for default_store
in sku
.DefaultStoreDict
:
2695 sku
.DefaultStoreDict
[default_store
]=pcdDecObject
.DefaultValue
2696 pcd
.DefaultValue
= pcdDecObject
.DefaultValue
2697 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
not in pcd
.SkuInfoList
:
2698 valuefromDec
= pcdDecObject
.DefaultValue
2699 SkuInfo
= SkuInfoClass(TAB_DEFAULT
, '0', SkuInfoObj
.VariableName
, SkuInfoObj
.VariableGuid
, SkuInfoObj
.VariableOffset
, valuefromDec
, VariableAttribute
=SkuInfoObj
.VariableAttribute
, DefaultStore
={DefaultStore
:valuefromDec
})
2700 pcd
.SkuInfoList
[TAB_DEFAULT
] = SkuInfo
2701 elif TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2702 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
2703 del pcd
.SkuInfoList
[TAB_COMMON
]
2704 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2705 del pcd
.SkuInfoList
[TAB_COMMON
]
2707 if pcd
.MaxDatumSize
.strip():
2708 MaxSize
= int(pcd
.MaxDatumSize
, 0)
2711 if pcd
.DatumType
not in TAB_PCD_NUMERIC_TYPES
:
2712 for (_
, skuobj
) in pcd
.SkuInfoList
.items():
2714 skuobj
.HiiDefaultValue
= StringToArray(skuobj
.HiiDefaultValue
)
2715 datalen
= len(skuobj
.HiiDefaultValue
.split(","))
2716 if datalen
> MaxSize
:
2718 for defaultst
in skuobj
.DefaultStoreDict
:
2719 skuobj
.DefaultStoreDict
[defaultst
] = StringToArray(skuobj
.DefaultStoreDict
[defaultst
])
2720 pcd
.DefaultValue
= StringToArray(pcd
.DefaultValue
)
2721 pcd
.MaxDatumSize
= str(MaxSize
)
2722 rt
, invalidhii
= DscBuildData
.CheckVariableNameAssignment(Pcds
)
2724 invalidpcd
= ",".join(invalidhii
)
2725 EdkLogger
.error('build', PCD_VARIABLE_INFO_ERROR
, Message
='The same HII PCD must map to the same EFI variable for all SKUs', File
=self
.MetaFile
, ExtraData
=invalidpcd
)
2727 map(self
.FilterSkuSettings
, Pcds
.values())
2732 def CheckVariableNameAssignment(Pcds
):
2734 for pcdname
in Pcds
:
2736 varnameset
= set(sku
.VariableName
for (skuid
, sku
) in pcd
.SkuInfoList
.items())
2737 if len(varnameset
) > 1:
2738 invalidhii
.append(".".join((pcdname
[1], pcdname
[0])))
2740 return False, invalidhii
2743 ## Retrieve dynamic VPD PCD settings
2745 # @param Type PCD type
2747 # @retval a dict object contains settings of given PCD type
2749 def _GetDynamicVpdPcd(self
, Type
):
2752 Pcds
= OrderedDict()
2754 # tdict is a special dict kind of type, used for selecting correct
2755 # PCD settings for certain ARCH and SKU
2757 PcdDict
= tdict(True, 4)
2760 # Find out all possible PCD candidates for self._Arch
2761 RecordList
= self
._RawData
[Type
, self
._Arch
]
2762 AvailableSkuIdSet
= copy
.copy(self
.SkuIds
)
2764 for TokenSpaceGuid
, PcdCName
, Setting
, Arch
, SkuName
, Dummy3
, Dummy4
, Dummy5
in RecordList
:
2765 SkuName
= SkuName
.upper()
2766 SkuName
= TAB_DEFAULT
if SkuName
== TAB_COMMON
else SkuName
2767 if SkuName
not in AvailableSkuIdSet
:
2768 EdkLogger
.error('build', PARAMETER_INVALID
, 'Sku %s is not defined in [SkuIds] section' % SkuName
,
2769 File
=self
.MetaFile
, Line
=Dummy5
)
2770 if "." not in TokenSpaceGuid
:
2771 PcdList
.append((PcdCName
, TokenSpaceGuid
, SkuName
, Dummy5
))
2772 PcdDict
[Arch
, SkuName
, PcdCName
, TokenSpaceGuid
] = Setting
2774 # Remove redundant PCD candidates, per the ARCH and SKU
2775 for PcdCName
, TokenSpaceGuid
, SkuName
, Dummy4
in PcdList
:
2776 Setting
= PcdDict
[self
._Arch
, SkuName
, PcdCName
, TokenSpaceGuid
]
2780 # For the VOID* type, it can have optional data of MaxDatumSize and InitialValue
2781 # For the Integer & Boolean type, the optional data can only be InitialValue.
2782 # At this point, we put all the data into the PcdClssObject for we don't know the PCD's datumtype
2783 # until the DEC parser has been called.
2785 VpdOffset
, MaxDatumSize
, InitialValue
= self
._ValidatePcd
(PcdCName
, TokenSpaceGuid
, Setting
, Type
, Dummy4
)
2787 if int(MaxDatumSize
, 0) > 0xFFFF:
2788 EdkLogger
.error('build', FORMAT_INVALID
, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2789 File
=self
.MetaFile
, Line
=Dummy4
)
2790 if int(MaxDatumSize
, 0) < 0:
2791 EdkLogger
.error('build', FORMAT_INVALID
, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid
, PcdCName
)),
2792 File
=self
.MetaFile
, Line
=Dummy4
)
2793 SkuInfo
= SkuInfoClass(SkuName
, self
.SkuIds
[SkuName
][0], '', '', '', '', VpdOffset
, InitialValue
)
2794 if (PcdCName
, TokenSpaceGuid
) in Pcds
:
2795 pcdObject
= Pcds
[PcdCName
, TokenSpaceGuid
]
2796 pcdObject
.SkuInfoList
[SkuName
] = SkuInfo
2797 if MaxDatumSize
.strip():
2798 CurrentMaxSize
= int(MaxDatumSize
.strip(), 0)
2801 if pcdObject
.MaxDatumSize
:
2802 PcdMaxSize
= int(pcdObject
.MaxDatumSize
, 0)
2805 if CurrentMaxSize
> PcdMaxSize
:
2806 pcdObject
.MaxDatumSize
= str(CurrentMaxSize
)
2808 Pcds
[PcdCName
, TokenSpaceGuid
] = PcdClassObject(
2811 self
._PCD
_TYPE
_STRING
_[Type
],
2816 OrderedDict({SkuName
: SkuInfo
}),
2821 if SkuName
not in Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
:
2822 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
] = {}
2823 Pcds
[PcdCName
, TokenSpaceGuid
].DscRawValue
[SkuName
][TAB_DEFAULT_STORES_DEFAULT
] = InitialValue
2824 for pcd
in Pcds
.values():
2825 SkuInfoObj
= pcd
.SkuInfoList
.values()[0]
2826 pcdDecObject
= self
._DecPcds
[pcd
.TokenCName
, pcd
.TokenSpaceGuidCName
]
2827 pcd
.DatumType
= pcdDecObject
.DatumType
2828 # Only fix the value while no value provided in DSC file.
2829 for sku
in pcd
.SkuInfoList
.values():
2830 if not sku
.DefaultValue
:
2831 sku
.DefaultValue
= pcdDecObject
.DefaultValue
2832 if TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
not in pcd
.SkuInfoList
:
2833 valuefromDec
= pcdDecObject
.DefaultValue
2834 SkuInfo
= SkuInfoClass(TAB_DEFAULT
, '0', '', '', '', '', SkuInfoObj
.VpdOffset
, valuefromDec
)
2835 pcd
.SkuInfoList
[TAB_DEFAULT
] = SkuInfo
2836 elif TAB_DEFAULT
not in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2837 pcd
.SkuInfoList
[TAB_DEFAULT
] = pcd
.SkuInfoList
[TAB_COMMON
]
2838 del pcd
.SkuInfoList
[TAB_COMMON
]
2839 elif TAB_DEFAULT
in pcd
.SkuInfoList
and TAB_COMMON
in pcd
.SkuInfoList
:
2840 del pcd
.SkuInfoList
[TAB_COMMON
]
2843 map(self
.FilterSkuSettings
, Pcds
.values())
2846 ## Add external modules
2848 # The external modules are mostly those listed in FDF file, which don't
2851 # @param FilePath The path of module description file
2853 def AddModule(self
, FilePath
):
2854 FilePath
= NormPath(FilePath
)
2855 if FilePath
not in self
.Modules
:
2856 Module
= ModuleBuildClassObject()
2857 Module
.MetaFile
= FilePath
2858 self
.Modules
.append(Module
)
2861 def ToolChainFamily(self
):
2862 self
._ToolChainFamily
= TAB_COMPILER_MSFT
2863 BuildConfigurationFile
= os
.path
.normpath(os
.path
.join(GlobalData
.gConfDirectory
, "target.txt"))
2864 if os
.path
.isfile(BuildConfigurationFile
) == True:
2865 TargetTxt
= TargetTxtClassObject()
2866 TargetTxt
.LoadTargetTxtFile(BuildConfigurationFile
)
2867 ToolDefinitionFile
= TargetTxt
.TargetTxtDictionary
[DataType
.TAB_TAT_DEFINES_TOOL_CHAIN_CONF
]
2868 if ToolDefinitionFile
== '':
2869 ToolDefinitionFile
= "tools_def.txt"
2870 ToolDefinitionFile
= os
.path
.normpath(mws
.join(self
.WorkspaceDir
, 'Conf', ToolDefinitionFile
))
2871 if os
.path
.isfile(ToolDefinitionFile
) == True:
2872 ToolDef
= ToolDefClassObject()
2873 ToolDef
.LoadToolDefFile(ToolDefinitionFile
)
2874 ToolDefinition
= ToolDef
.ToolsDefTxtDatabase
2875 if TAB_TOD_DEFINES_FAMILY
not in ToolDefinition \
2876 or self
._Toolchain
not in ToolDefinition
[TAB_TOD_DEFINES_FAMILY
] \
2877 or not ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][self
._Toolchain
]:
2878 self
._ToolChainFamily
= TAB_COMPILER_MSFT
2880 self
._ToolChainFamily
= ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][self
._Toolchain
]
2881 return self
._ToolChainFamily
2883 ## Add external PCDs
2885 # The external PCDs are mostly those listed in FDF file to specify address
2886 # or offset information.
2888 # @param Name Name of the PCD
2889 # @param Guid Token space guid of the PCD
2890 # @param Value Value of the PCD
2892 def AddPcd(self
, Name
, Guid
, Value
):
2893 if (Name
, Guid
) not in self
.Pcds
:
2894 self
.Pcds
[Name
, Guid
] = PcdClassObject(Name
, Guid
, '', '', '', '', '', {}, False, None)
2895 self
.Pcds
[Name
, Guid
].DefaultValue
= Value
2899 if self
._DecPcds
is None:
2901 if GlobalData
.gFdfParser
:
2902 FdfInfList
= GlobalData
.gFdfParser
.Profile
.InfList
2904 for Inf
in FdfInfList
:
2905 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
=self
._Arch
)
2906 if ModuleFile
in self
._Modules
:
2908 ModuleData
= self
._Bdb
[ModuleFile
, self
._Arch
, self
._Target
, self
._Toolchain
]
2909 PkgSet
.update(ModuleData
.Packages
)
2910 self
._DecPcds
, self
._GuidDict
= GetDeclaredPcd(self
, self
._Bdb
, self
._Arch
, self
._Target
, self
._Toolchain
, PkgSet
)
2911 return self
._DecPcds