421ccda307
1. Add a recovery mode for UPT failure 2. Add UNI file support 3. Add binary file header support 4. Add support for PCD error message 5. Add support for replace 6. Format generated INF/DEC files 7. Update dependency check 8. Other minor fixes Contributed-under: TianoCore Contribution Agreement 1.0 Signed-off-by: Hess Chen <hesheng.chen@intel.com> Reviewed-by: Gao, Liming <liming.gao@intel.com> git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@15896 6f19259b-4bc3-4df7-8a09-765794883524
1003 lines
41 KiB
Python
1003 lines
41 KiB
Python
## @file
|
|
# This file is used to define class objects of [Defines] section for INF file.
|
|
# It will consumed by InfParser
|
|
#
|
|
# Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
|
|
#
|
|
# This program and the accompanying materials are licensed and made available
|
|
# under the terms and conditions of the BSD License which accompanies this
|
|
# distribution. The full text of the license may be found at
|
|
# http://opensource.org/licenses/bsd-license.php
|
|
#
|
|
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
'''
|
|
InfDefineObject
|
|
'''
|
|
|
|
import os
|
|
import re
|
|
|
|
from Logger import StringTable as ST
|
|
from Logger import ToolError
|
|
from Library import GlobalData
|
|
from Library import DataType as DT
|
|
from Library.String import GetSplitValueList
|
|
from Library.Misc import CheckGuidRegFormat
|
|
from Library.Misc import Sdict
|
|
from Library.Misc import ConvPathFromAbsToRel
|
|
from Library.Misc import ValidateUNIFilePath
|
|
from Library.ExpressionValidate import IsValidFeatureFlagExp
|
|
from Library.ParserValidate import IsValidWord
|
|
from Library.ParserValidate import IsValidInfMoudleType
|
|
from Library.ParserValidate import IsValidHex
|
|
from Library.ParserValidate import IsValidHexVersion
|
|
from Library.ParserValidate import IsValidDecVersion
|
|
from Library.ParserValidate import IsValidCVariableName
|
|
from Library.ParserValidate import IsValidBoolType
|
|
from Library.ParserValidate import IsValidPath
|
|
from Library.ParserValidate import IsValidFamily
|
|
from Library.ParserValidate import IsValidIdentifier
|
|
from Library.ParserValidate import IsValidDecVersionVal
|
|
from Object.Parser.InfCommonObject import InfLineCommentObject
|
|
from Object.Parser.InfCommonObject import CurrentLine
|
|
from Object.Parser.InfCommonObject import InfSectionCommonDef
|
|
from Object.Parser.InfMisc import ErrorInInf
|
|
from Object.Parser.InfDefineCommonObject import InfDefineLibraryItem
|
|
from Object.Parser.InfDefineCommonObject import InfDefineEntryPointItem
|
|
from Object.Parser.InfDefineCommonObject import InfDefineUnloadImageItem
|
|
from Object.Parser.InfDefineCommonObject import InfDefineConstructorItem
|
|
from Object.Parser.InfDefineCommonObject import InfDefineDestructorItem
|
|
|
|
class InfDefSectionOptionRomInfo():
|
|
def __init__(self):
|
|
self.PciVendorId = None
|
|
self.PciDeviceId = None
|
|
self.PciClassCode = None
|
|
self.PciRevision = None
|
|
self.PciCompress = None
|
|
self.CurrentLine = ['', -1, '']
|
|
def SetPciVendorId(self, PciVendorId, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.PciVendorId != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_PCI_VENDOR_ID),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
#
|
|
# The PciVendorId should be hex string.
|
|
#
|
|
if (IsValidHex(PciVendorId)):
|
|
self.PciVendorId = InfDefMember()
|
|
self.PciVendorId.SetValue(PciVendorId)
|
|
self.PciVendorId.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(PciVendorId),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
def GetPciVendorId(self):
|
|
return self.PciVendorId
|
|
|
|
def SetPciDeviceId(self, PciDeviceId, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.PciDeviceId != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_PCI_DEVICE_ID),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
#
|
|
# The PciDeviceId should be hex string.
|
|
#
|
|
if (IsValidHex(PciDeviceId)):
|
|
self.PciDeviceId = InfDefMember()
|
|
self.PciDeviceId.SetValue(PciDeviceId)
|
|
self.PciDeviceId.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(PciDeviceId),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
def GetPciDeviceId(self):
|
|
return self.PciDeviceId
|
|
|
|
def SetPciClassCode(self, PciClassCode, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.PciClassCode != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_PCI_CLASS_CODE),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
#
|
|
# The PciClassCode should be 4 bytes hex string.
|
|
#
|
|
if (IsValidHex(PciClassCode)):
|
|
self.PciClassCode = InfDefMember()
|
|
self.PciClassCode.SetValue(PciClassCode)
|
|
self.PciClassCode.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%\
|
|
(PciClassCode),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
def GetPciClassCode(self):
|
|
return self.PciClassCode
|
|
|
|
def SetPciRevision(self, PciRevision, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.PciRevision != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_PCI_REVISION),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
#
|
|
# The PciRevision should be 4 bytes hex string.
|
|
#
|
|
if (IsValidHex(PciRevision)):
|
|
self.PciRevision = InfDefMember()
|
|
self.PciRevision.SetValue(PciRevision)
|
|
self.PciRevision.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(PciRevision),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
def GetPciRevision(self):
|
|
return self.PciRevision
|
|
|
|
def SetPciCompress(self, PciCompress, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.PciCompress != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_PCI_COMPRESS),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
#
|
|
# The PciCompress should be 'TRUE' or 'FALSE'.
|
|
#
|
|
if (PciCompress == 'TRUE' or PciCompress == 'FALSE'):
|
|
self.PciCompress = InfDefMember()
|
|
self.PciCompress.SetValue(PciCompress)
|
|
self.PciCompress.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(PciCompress),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
def GetPciCompress(self):
|
|
return self.PciCompress
|
|
##
|
|
# INF [Define] section Object
|
|
#
|
|
class InfDefSection(InfDefSectionOptionRomInfo):
|
|
def __init__(self):
|
|
self.BaseName = None
|
|
self.FileGuid = None
|
|
self.ModuleType = None
|
|
self.ModuleUniFileName = None
|
|
self.InfVersion = None
|
|
self.EdkReleaseVersion = None
|
|
self.UefiSpecificationVersion = None
|
|
self.PiSpecificationVersion = None
|
|
self.LibraryClass = []
|
|
self.Package = None
|
|
self.VersionString = None
|
|
self.PcdIsDriver = None
|
|
self.EntryPoint = []
|
|
self.UnloadImages = []
|
|
self.Constructor = []
|
|
self.Destructor = []
|
|
self.Shadow = None
|
|
self.CustomMakefile = []
|
|
self.Specification = []
|
|
self.UefiHiiResourceSection = None
|
|
self.DpxSource = []
|
|
self.CurrentLine = ['', -1, '']
|
|
InfDefSectionOptionRomInfo.__init__(self)
|
|
|
|
## SetHeadComment
|
|
#
|
|
# @param BaseName: BaseName
|
|
#
|
|
def SetBaseName(self, BaseName, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.BaseName != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_BASE_NAME),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
if not (BaseName == '' or BaseName == None):
|
|
if IsValidWord(BaseName) and not BaseName.startswith("_"):
|
|
self.BaseName = InfDefMember()
|
|
self.BaseName.SetValue(BaseName)
|
|
self.BaseName.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_NAME_INVALID%(BaseName),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
## GetBaseName
|
|
#
|
|
def GetBaseName(self):
|
|
return self.BaseName
|
|
|
|
## SetFileGuid
|
|
#
|
|
# @param FileGuid: FileGuid
|
|
#
|
|
def SetFileGuid(self, FileGuid, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.FileGuid != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
|
|
%(DT.TAB_INF_DEFINES_FILE_GUID),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
#
|
|
# Do verification of GUID content/format
|
|
#
|
|
if (CheckGuidRegFormat(FileGuid)):
|
|
self.FileGuid = InfDefMember()
|
|
self.FileGuid.SetValue(FileGuid)
|
|
self.FileGuid.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_GUID_INVALID%(FileGuid),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
## GetFileGuid
|
|
#
|
|
def GetFileGuid(self):
|
|
return self.FileGuid
|
|
|
|
## SetModuleType
|
|
#
|
|
# @param ModuleType: ModuleType
|
|
#
|
|
def SetModuleType(self, ModuleType, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.ModuleType != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
|
|
%(DT.TAB_INF_DEFINES_MODULE_TYPE),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
#
|
|
# Valid Module Type or not
|
|
#
|
|
if (IsValidInfMoudleType(ModuleType)):
|
|
self.ModuleType = InfDefMember()
|
|
self.ModuleType.SetValue(ModuleType)
|
|
self.ModuleType.CurrentLine = CurrentLine()
|
|
self.ModuleType.CurrentLine.SetLineNo(self.CurrentLine[1])
|
|
self.ModuleType.CurrentLine.SetLineString(self.CurrentLine[2])
|
|
self.ModuleType.CurrentLine.SetFileName(self.CurrentLine[0])
|
|
self.ModuleType.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_MODULETYPE_INVALID%\
|
|
(ModuleType),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
## GetModuleType
|
|
#
|
|
def GetModuleType(self):
|
|
return self.ModuleType
|
|
|
|
## SetModuleUniFileName
|
|
#
|
|
# @param ModuleUniFileName: ModuleUniFileName
|
|
#
|
|
def SetModuleUniFileName(self, ModuleUniFileName, Comments):
|
|
if Comments:
|
|
pass
|
|
if self.ModuleUniFileName != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_MODULE_UNI_FILE),
|
|
LineInfo=self.CurrentLine)
|
|
self.ModuleUniFileName = ModuleUniFileName
|
|
|
|
## GetModuleType
|
|
#
|
|
def GetModuleUniFileName(self):
|
|
return self.ModuleUniFileName
|
|
|
|
## SetInfVersion
|
|
#
|
|
# @param InfVersion: InfVersion
|
|
#
|
|
def SetInfVersion(self, InfVersion, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.InfVersion != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
|
|
%(DT.TAB_INF_DEFINES_INF_VERSION),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
#
|
|
# The InfVersion should be 4 bytes hex string.
|
|
#
|
|
if (IsValidHex(InfVersion)):
|
|
if (InfVersion < '0x00010005'):
|
|
ErrorInInf(ST.ERR_INF_PARSER_NOT_SUPPORT_EDKI_INF,
|
|
ErrorCode=ToolError.EDK1_INF_ERROR,
|
|
LineInfo=self.CurrentLine)
|
|
|
|
self.InfVersion = InfDefMember()
|
|
self.InfVersion.SetValue(InfVersion)
|
|
self.InfVersion.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(InfVersion),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
## GetInfVersion
|
|
#
|
|
def GetInfVersion(self):
|
|
return self.InfVersion
|
|
|
|
## SetEdkReleaseVersion
|
|
#
|
|
# @param EdkReleaseVersion: EdkReleaseVersion
|
|
#
|
|
def SetEdkReleaseVersion(self, EdkReleaseVersion, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.EdkReleaseVersion != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
|
|
%(DT.TAB_INF_DEFINES_EDK_RELEASE_VERSION),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
#
|
|
# The EdkReleaseVersion should be 4 bytes hex string.
|
|
#
|
|
if IsValidHexVersion(EdkReleaseVersion) or \
|
|
IsValidDecVersionVal(EdkReleaseVersion):
|
|
self.EdkReleaseVersion = InfDefMember()
|
|
self.EdkReleaseVersion.SetValue(EdkReleaseVersion)
|
|
self.EdkReleaseVersion.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID\
|
|
%(EdkReleaseVersion),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
## GetEdkReleaseVersion
|
|
#
|
|
def GetEdkReleaseVersion(self):
|
|
return self.EdkReleaseVersion
|
|
|
|
## SetUefiSpecificationVersion
|
|
#
|
|
# @param UefiSpecificationVersion: UefiSpecificationVersion
|
|
#
|
|
def SetUefiSpecificationVersion(self, UefiSpecificationVersion, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.UefiSpecificationVersion != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
|
|
%(DT.TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
#
|
|
# The EdkReleaseVersion should be 4 bytes hex string.
|
|
#
|
|
if IsValidHexVersion(UefiSpecificationVersion) or \
|
|
IsValidDecVersionVal(UefiSpecificationVersion):
|
|
self.UefiSpecificationVersion = InfDefMember()
|
|
self.UefiSpecificationVersion.SetValue(UefiSpecificationVersion)
|
|
self.UefiSpecificationVersion.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID\
|
|
%(UefiSpecificationVersion),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
## GetUefiSpecificationVersion
|
|
#
|
|
def GetUefiSpecificationVersion(self):
|
|
return self.UefiSpecificationVersion
|
|
|
|
## SetPiSpecificationVersion
|
|
#
|
|
# @param PiSpecificationVersion: PiSpecificationVersion
|
|
#
|
|
def SetPiSpecificationVersion(self, PiSpecificationVersion, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.PiSpecificationVersion != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
|
|
%(DT.TAB_INF_DEFINES_PI_SPECIFICATION_VERSION),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
#
|
|
# The EdkReleaseVersion should be 4 bytes hex string.
|
|
#
|
|
if IsValidHexVersion(PiSpecificationVersion) or \
|
|
IsValidDecVersionVal(PiSpecificationVersion):
|
|
self.PiSpecificationVersion = InfDefMember()
|
|
self.PiSpecificationVersion.SetValue(PiSpecificationVersion)
|
|
self.PiSpecificationVersion.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID\
|
|
%(PiSpecificationVersion),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
## GetPiSpecificationVersion
|
|
#
|
|
def GetPiSpecificationVersion(self):
|
|
return self.PiSpecificationVersion
|
|
|
|
## SetLibraryClass
|
|
#
|
|
# @param LibraryClass: LibraryClass
|
|
#
|
|
def SetLibraryClass(self, LibraryClass, Comments):
|
|
ValueList = GetSplitValueList(LibraryClass)
|
|
Name = ValueList[0]
|
|
if IsValidWord(Name):
|
|
InfDefineLibraryItemObj = InfDefineLibraryItem()
|
|
InfDefineLibraryItemObj.SetLibraryName(Name)
|
|
InfDefineLibraryItemObj.Comments = Comments
|
|
if len(ValueList) == 2:
|
|
Type = ValueList[1]
|
|
TypeList = GetSplitValueList(Type, ' ')
|
|
TypeList = [Type for Type in TypeList if Type != '']
|
|
for Item in TypeList:
|
|
if Item not in DT.MODULE_LIST:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Item),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
InfDefineLibraryItemObj.SetTypes(TypeList)
|
|
self.LibraryClass.append(InfDefineLibraryItemObj)
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Name),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
return True
|
|
|
|
def GetLibraryClass(self):
|
|
return self.LibraryClass
|
|
|
|
def SetVersionString(self, VersionString, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.VersionString != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
|
|
%(DT.TAB_INF_DEFINES_VERSION_STRING),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
if not IsValidDecVersion(VersionString):
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID\
|
|
%(VersionString),
|
|
LineInfo=self.CurrentLine)
|
|
self.VersionString = InfDefMember()
|
|
self.VersionString.SetValue(VersionString)
|
|
self.VersionString.Comments = Comments
|
|
return True
|
|
|
|
|
|
def GetVersionString(self):
|
|
return self.VersionString
|
|
|
|
def SetPcdIsDriver(self, PcdIsDriver, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.PcdIsDriver != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
|
|
%(DT.TAB_INF_DEFINES_PCD_IS_DRIVER),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
if PcdIsDriver == 'PEI_PCD_DRIVER' or PcdIsDriver == 'DXE_PCD_DRIVER':
|
|
self.PcdIsDriver = InfDefMember()
|
|
self.PcdIsDriver.SetValue(PcdIsDriver)
|
|
self.PcdIsDriver.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(PcdIsDriver),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
|
|
def GetPcdIsDriver(self):
|
|
return self.PcdIsDriver
|
|
|
|
#
|
|
# SetEntryPoint
|
|
#
|
|
def SetEntryPoint(self, EntryPoint, Comments):
|
|
#
|
|
# It can be a list
|
|
#
|
|
ValueList = []
|
|
TokenList = GetSplitValueList(EntryPoint, DT.TAB_VALUE_SPLIT)
|
|
ValueList[0:len(TokenList)] = TokenList
|
|
InfDefineEntryPointItemObj = InfDefineEntryPointItem()
|
|
if not IsValidCVariableName(ValueList[0]):
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%\
|
|
(ValueList[0]),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineEntryPointItemObj.SetCName(ValueList[0])
|
|
if len(ValueList) == 2:
|
|
if ValueList[1].strip() == '':
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%\
|
|
(ValueList[1]),
|
|
LineInfo=self.CurrentLine)
|
|
#
|
|
# Validate FFE
|
|
#
|
|
FeatureFlagRtv = IsValidFeatureFlagExp(ValueList[1].strip())
|
|
if not FeatureFlagRtv[0]:
|
|
ErrorInInf(ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID%\
|
|
(FeatureFlagRtv[1]),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineEntryPointItemObj.SetFeatureFlagExp(ValueList[1])
|
|
if len(ValueList) > 2:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(EntryPoint),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineEntryPointItemObj.Comments = Comments
|
|
self.EntryPoint.append(InfDefineEntryPointItemObj)
|
|
|
|
def GetEntryPoint(self):
|
|
return self.EntryPoint
|
|
|
|
#
|
|
# SetUnloadImages
|
|
#
|
|
def SetUnloadImages(self, UnloadImages, Comments):
|
|
#
|
|
# It can be a list
|
|
#
|
|
ValueList = []
|
|
TokenList = GetSplitValueList(UnloadImages, DT.TAB_VALUE_SPLIT)
|
|
ValueList[0:len(TokenList)] = TokenList
|
|
InfDefineUnloadImageItemObj = InfDefineUnloadImageItem()
|
|
if not IsValidCVariableName(ValueList[0]):
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[0]),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineUnloadImageItemObj.SetCName(ValueList[0])
|
|
if len(ValueList) == 2:
|
|
if ValueList[1].strip() == '':
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[1]),
|
|
LineInfo=self.CurrentLine)
|
|
#
|
|
# Validate FFE
|
|
#
|
|
FeatureFlagRtv = IsValidFeatureFlagExp(ValueList[1].strip())
|
|
if not FeatureFlagRtv[0]:
|
|
ErrorInInf(ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID%(FeatureFlagRtv[1]),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineUnloadImageItemObj.SetFeatureFlagExp(ValueList[1])
|
|
|
|
if len(ValueList) > 2:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(UnloadImages),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineUnloadImageItemObj.Comments = Comments
|
|
self.UnloadImages.append(InfDefineUnloadImageItemObj)
|
|
|
|
def GetUnloadImages(self):
|
|
return self.UnloadImages
|
|
|
|
#
|
|
# SetConstructor
|
|
#
|
|
def SetConstructor(self, Constructor, Comments):
|
|
#
|
|
# It can be a list
|
|
#
|
|
ValueList = []
|
|
TokenList = GetSplitValueList(Constructor, DT.TAB_VALUE_SPLIT)
|
|
ValueList[0:len(TokenList)] = TokenList
|
|
InfDefineConstructorItemObj = InfDefineConstructorItem()
|
|
if not IsValidCVariableName(ValueList[0]):
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[0]),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineConstructorItemObj.SetCName(ValueList[0])
|
|
if len(ValueList) >= 2:
|
|
ModList = GetSplitValueList(ValueList[1], ' ')
|
|
if ValueList[1].strip() == '':
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[1]),
|
|
LineInfo=self.CurrentLine)
|
|
for ModItem in ModList:
|
|
if ModItem not in DT.MODULE_LIST:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_MODULETYPE_INVALID%(ModItem),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineConstructorItemObj.SetSupModList(ModList)
|
|
if len(ValueList) == 3:
|
|
if ValueList[2].strip() == '':
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[2]),
|
|
LineInfo=self.CurrentLine)
|
|
#
|
|
# Validate FFE
|
|
#
|
|
FeatureFlagRtv = IsValidFeatureFlagExp(ValueList[2].strip())
|
|
if not FeatureFlagRtv[0]:
|
|
ErrorInInf(ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID%(FeatureFlagRtv[2]),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineConstructorItemObj.SetFeatureFlagExp(ValueList[2])
|
|
|
|
if len(ValueList) > 3:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Constructor),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineConstructorItemObj.Comments = Comments
|
|
self.Constructor.append(InfDefineConstructorItemObj)
|
|
|
|
def GetConstructor(self):
|
|
return self.Constructor
|
|
|
|
#
|
|
# SetDestructor
|
|
#
|
|
def SetDestructor(self, Destructor, Comments):
|
|
#
|
|
# It can be a list and only 1 set to TRUE
|
|
#
|
|
ValueList = []
|
|
TokenList = GetSplitValueList(Destructor, DT.TAB_VALUE_SPLIT)
|
|
ValueList[0:len(TokenList)] = TokenList
|
|
InfDefineDestructorItemObj = InfDefineDestructorItem()
|
|
if not IsValidCVariableName(ValueList[0]):
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[0]),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineDestructorItemObj.SetCName(ValueList[0])
|
|
if len(ValueList) >= 2:
|
|
ModList = GetSplitValueList(ValueList[1].strip(), ' ')
|
|
if ValueList[1].strip() == '':
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[1]),
|
|
LineInfo=self.CurrentLine)
|
|
for ModItem in ModList:
|
|
if ModItem not in DT.MODULE_LIST:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_MODULETYPE_INVALID%(ModItem),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineDestructorItemObj.SetSupModList(ModList)
|
|
if len(ValueList) == 3:
|
|
if ValueList[2].strip() == '':
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[2]),
|
|
LineInfo=self.CurrentLine)
|
|
#
|
|
# Validate FFE
|
|
#
|
|
FeatureFlagRtv = IsValidFeatureFlagExp(ValueList[2].strip())
|
|
if not FeatureFlagRtv[0]:
|
|
ErrorInInf(ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID%(FeatureFlagRtv[1]),
|
|
LineInfo=self.CurrentLine)
|
|
InfDefineDestructorItemObj.SetFeatureFlagExp(ValueList[2])
|
|
|
|
if len(ValueList) > 3:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Destructor),
|
|
LineInfo=self.CurrentLine)
|
|
|
|
InfDefineDestructorItemObj.Comments = Comments
|
|
self.Destructor.append(InfDefineDestructorItemObj)
|
|
|
|
def GetDestructor(self):
|
|
return self.Destructor
|
|
|
|
def SetShadow(self, Shadow, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.Shadow != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_SHADOW),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
if (IsValidBoolType(Shadow)):
|
|
self.Shadow = InfDefMember()
|
|
self.Shadow.SetValue(Shadow)
|
|
self.Shadow.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Shadow),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
def GetShadow(self):
|
|
return self.Shadow
|
|
|
|
#
|
|
# <Family> ::= {"MSFT"} {"GCC"}
|
|
# <CustomMake> ::= [<Family> "|"] <Filename>
|
|
#
|
|
def SetCustomMakefile(self, CustomMakefile, Comments):
|
|
if not (CustomMakefile == '' or CustomMakefile == None):
|
|
ValueList = GetSplitValueList(CustomMakefile)
|
|
if len(ValueList) == 1:
|
|
FileName = ValueList[0]
|
|
Family = ''
|
|
else:
|
|
Family = ValueList[0]
|
|
FileName = ValueList[1]
|
|
Family = Family.strip()
|
|
if Family != '':
|
|
if not IsValidFamily(Family):
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Family),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
#
|
|
# The MakefileName specified file should exist
|
|
#
|
|
IsValidFileFlag = False
|
|
ModulePath = os.path.split(self.CurrentLine[0])[0]
|
|
if IsValidPath(FileName, ModulePath):
|
|
IsValidFileFlag = True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(FileName),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
if IsValidFileFlag:
|
|
FileName = ConvPathFromAbsToRel(FileName, GlobalData.gINF_MODULE_DIR)
|
|
self.CustomMakefile.append((Family, FileName, Comments))
|
|
IsValidFileFlag = False
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def GetCustomMakefile(self):
|
|
return self.CustomMakefile
|
|
|
|
#
|
|
# ["SPEC" <Spec> <EOL>]*{0,}
|
|
# <Spec> ::= <Word> "=" <VersionVal>
|
|
# <VersionVal> ::= {<HexVersion>] {<DecVersion>}
|
|
# <HexNumber> ::= "0x" [<HexDigit>]{1,}
|
|
# <DecVersion> ::= (0-9){1,} ["." (0-9){1,2}]
|
|
#
|
|
def SetSpecification(self, Specification, Comments):
|
|
#
|
|
# Valid the value of Specification
|
|
#
|
|
__ValueList = []
|
|
TokenList = GetSplitValueList(Specification, DT.TAB_EQUAL_SPLIT, 1)
|
|
__ValueList[0:len(TokenList)] = TokenList
|
|
if len(__ValueList) != 2:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_NO_NAME + ' Or ' + ST.ERR_INF_PARSER_DEFINE_ITEM_NO_VALUE,
|
|
LineInfo=self.CurrentLine)
|
|
Name = __ValueList[0].strip()
|
|
Version = __ValueList[1].strip()
|
|
if IsValidIdentifier(Name):
|
|
if IsValidDecVersion(Version):
|
|
self.Specification.append((Name, Version, Comments))
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Version),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Name),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
return True
|
|
|
|
def GetSpecification(self):
|
|
return self.Specification
|
|
|
|
#
|
|
# [<UefiHiiResource> <EOL>]{0,1}
|
|
# <UefiHiiResource> ::= "UEFI_HII_RESOURCE_SECTION" "=" <BoolType>
|
|
#
|
|
def SetUefiHiiResourceSection(self, UefiHiiResourceSection, Comments):
|
|
#
|
|
# Value has been set before.
|
|
#
|
|
if self.UefiHiiResourceSection != None:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND
|
|
%(DT.TAB_INF_DEFINES_UEFI_HII_RESOURCE_SECTION),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
if not (UefiHiiResourceSection == '' or UefiHiiResourceSection == None):
|
|
if (IsValidBoolType(UefiHiiResourceSection)):
|
|
self.UefiHiiResourceSection = InfDefMember()
|
|
self.UefiHiiResourceSection.SetValue(UefiHiiResourceSection)
|
|
self.UefiHiiResourceSection.Comments = Comments
|
|
return True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(UefiHiiResourceSection),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
else:
|
|
return False
|
|
|
|
def GetUefiHiiResourceSection(self):
|
|
return self.UefiHiiResourceSection
|
|
|
|
def SetDpxSource(self, DpxSource, Comments):
|
|
#
|
|
# The MakefileName specified file should exist
|
|
#
|
|
IsValidFileFlag = False
|
|
ModulePath = os.path.split(self.CurrentLine[0])[0]
|
|
if IsValidPath(DpxSource, ModulePath):
|
|
IsValidFileFlag = True
|
|
else:
|
|
ErrorInInf(ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(DpxSource),
|
|
LineInfo=self.CurrentLine)
|
|
return False
|
|
if IsValidFileFlag:
|
|
DpxSource = ConvPathFromAbsToRel(DpxSource,
|
|
GlobalData.gINF_MODULE_DIR)
|
|
self.DpxSource.append((DpxSource, Comments))
|
|
IsValidFileFlag = False
|
|
return True
|
|
|
|
def GetDpxSource(self):
|
|
return self.DpxSource
|
|
|
|
gFUNCTION_MAPPING_FOR_DEFINE_SECTION = {
|
|
#
|
|
# Required Fields
|
|
#
|
|
DT.TAB_INF_DEFINES_BASE_NAME : InfDefSection.SetBaseName,
|
|
DT.TAB_INF_DEFINES_FILE_GUID : InfDefSection.SetFileGuid,
|
|
DT.TAB_INF_DEFINES_MODULE_TYPE : InfDefSection.SetModuleType,
|
|
#
|
|
# Required by EDKII style INF file
|
|
#
|
|
DT.TAB_INF_DEFINES_INF_VERSION : InfDefSection.SetInfVersion,
|
|
#
|
|
# Optional Fields
|
|
#
|
|
DT.TAB_INF_DEFINES_MODULE_UNI_FILE : InfDefSection.SetModuleUniFileName,
|
|
DT.TAB_INF_DEFINES_EDK_RELEASE_VERSION : InfDefSection.SetEdkReleaseVersion,
|
|
DT.TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION : InfDefSection.SetUefiSpecificationVersion,
|
|
DT.TAB_INF_DEFINES_PI_SPECIFICATION_VERSION : InfDefSection.SetPiSpecificationVersion,
|
|
DT.TAB_INF_DEFINES_LIBRARY_CLASS : InfDefSection.SetLibraryClass,
|
|
DT.TAB_INF_DEFINES_VERSION_STRING : InfDefSection.SetVersionString,
|
|
DT.TAB_INF_DEFINES_PCD_IS_DRIVER : InfDefSection.SetPcdIsDriver,
|
|
DT.TAB_INF_DEFINES_ENTRY_POINT : InfDefSection.SetEntryPoint,
|
|
DT.TAB_INF_DEFINES_UNLOAD_IMAGE : InfDefSection.SetUnloadImages,
|
|
DT.TAB_INF_DEFINES_CONSTRUCTOR : InfDefSection.SetConstructor,
|
|
DT.TAB_INF_DEFINES_DESTRUCTOR : InfDefSection.SetDestructor,
|
|
DT.TAB_INF_DEFINES_SHADOW : InfDefSection.SetShadow,
|
|
DT.TAB_INF_DEFINES_PCI_VENDOR_ID : InfDefSection.SetPciVendorId,
|
|
DT.TAB_INF_DEFINES_PCI_DEVICE_ID : InfDefSection.SetPciDeviceId,
|
|
DT.TAB_INF_DEFINES_PCI_CLASS_CODE : InfDefSection.SetPciClassCode,
|
|
DT.TAB_INF_DEFINES_PCI_REVISION : InfDefSection.SetPciRevision,
|
|
DT.TAB_INF_DEFINES_PCI_COMPRESS : InfDefSection.SetPciCompress,
|
|
DT.TAB_INF_DEFINES_CUSTOM_MAKEFILE : InfDefSection.SetCustomMakefile,
|
|
DT.TAB_INF_DEFINES_SPEC : InfDefSection.SetSpecification,
|
|
DT.TAB_INF_DEFINES_UEFI_HII_RESOURCE_SECTION : InfDefSection.SetUefiHiiResourceSection,
|
|
DT.TAB_INF_DEFINES_DPX_SOURCE : InfDefSection.SetDpxSource
|
|
}
|
|
|
|
## InfDefMember
|
|
#
|
|
#
|
|
class InfDefMember():
|
|
def __init__(self, Name='', Value=''):
|
|
self.Comments = InfLineCommentObject()
|
|
self.Name = Name
|
|
self.Value = Value
|
|
self.CurrentLine = CurrentLine()
|
|
def GetName(self):
|
|
return self.Name
|
|
def SetName(self, Name):
|
|
self.Name = Name
|
|
def GetValue(self):
|
|
return self.Value
|
|
def SetValue(self, Value):
|
|
self.Value = Value
|
|
|
|
## InfDefObject
|
|
#
|
|
#
|
|
class InfDefObject(InfSectionCommonDef):
|
|
def __init__(self):
|
|
self.Defines = Sdict()
|
|
InfSectionCommonDef.__init__(self)
|
|
def SetDefines(self, DefineContent, Arch = None):
|
|
#
|
|
# Validate Arch
|
|
#
|
|
HasFoundInfVersionFalg = False
|
|
LineInfo = ['', -1, '']
|
|
ArchListString = ' '.join(Arch)
|
|
#
|
|
# Parse Define items.
|
|
#
|
|
for InfDefMemberObj in DefineContent:
|
|
ProcessFunc = None
|
|
Name = InfDefMemberObj.GetName()
|
|
Value = InfDefMemberObj.GetValue()
|
|
if Name == DT.TAB_INF_DEFINES_MODULE_UNI_FILE:
|
|
ValidateUNIFilePath(Value)
|
|
Value = os.path.join(os.path.dirname(InfDefMemberObj.CurrentLine.FileName), Value)
|
|
if not os.path.isfile(Value) or not os.path.exists(Value):
|
|
LineInfo[0] = InfDefMemberObj.CurrentLine.GetFileName()
|
|
LineInfo[1] = InfDefMemberObj.CurrentLine.GetLineNo()
|
|
LineInfo[2] = InfDefMemberObj.CurrentLine.GetLineString()
|
|
ErrorInInf(ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(Name),
|
|
LineInfo=LineInfo)
|
|
InfLineCommentObj = InfLineCommentObject()
|
|
InfLineCommentObj.SetHeaderComments(InfDefMemberObj.Comments.GetHeaderComments())
|
|
InfLineCommentObj.SetTailComments(InfDefMemberObj.Comments.GetTailComments())
|
|
if Name == 'COMPONENT_TYPE':
|
|
ErrorInInf(ST.ERR_INF_PARSER_NOT_SUPPORT_EDKI_INF,
|
|
ErrorCode=ToolError.EDK1_INF_ERROR,
|
|
RaiseError=True)
|
|
if Name == DT.TAB_INF_DEFINES_INF_VERSION:
|
|
HasFoundInfVersionFalg = True
|
|
if not (Name == '' or Name == None):
|
|
#
|
|
# Process "SPEC" Keyword definition.
|
|
#
|
|
ReName = re.compile(r"SPEC ", re.DOTALL)
|
|
if ReName.match(Name):
|
|
SpecValue = Name[Name.find("SPEC") + len("SPEC"):].strip()
|
|
Name = "SPEC"
|
|
Value = SpecValue + " = " + Value
|
|
if self.Defines.has_key(ArchListString):
|
|
DefineList = self.Defines[ArchListString]
|
|
LineInfo[0] = InfDefMemberObj.CurrentLine.GetFileName()
|
|
LineInfo[1] = InfDefMemberObj.CurrentLine.GetLineNo()
|
|
LineInfo[2] = InfDefMemberObj.CurrentLine.GetLineString()
|
|
DefineList.CurrentLine = LineInfo
|
|
#
|
|
# Found the process function from mapping table.
|
|
#
|
|
if Name not in gFUNCTION_MAPPING_FOR_DEFINE_SECTION.keys():
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_SECTION_KEYWORD_INVALID%(Name),
|
|
LineInfo=LineInfo)
|
|
else:
|
|
ProcessFunc = gFUNCTION_MAPPING_FOR_DEFINE_SECTION[Name]
|
|
if (ProcessFunc != None):
|
|
ProcessFunc(DefineList, Value, InfLineCommentObj)
|
|
self.Defines[ArchListString] = DefineList
|
|
else:
|
|
DefineList = InfDefSection()
|
|
LineInfo[0] = InfDefMemberObj.CurrentLine.GetFileName()
|
|
LineInfo[1] = InfDefMemberObj.CurrentLine.GetLineNo()
|
|
LineInfo[2] = InfDefMemberObj.CurrentLine.GetLineString()
|
|
DefineList.CurrentLine = LineInfo
|
|
#
|
|
# Found the process function from mapping table.
|
|
#
|
|
if Name not in gFUNCTION_MAPPING_FOR_DEFINE_SECTION.keys():
|
|
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_SECTION_KEYWORD_INVALID%(Name),
|
|
LineInfo=LineInfo)
|
|
#
|
|
# Found the process function from mapping table.
|
|
#
|
|
else:
|
|
ProcessFunc = gFUNCTION_MAPPING_FOR_DEFINE_SECTION[Name]
|
|
if (ProcessFunc != None):
|
|
ProcessFunc(DefineList, Value, InfLineCommentObj)
|
|
self.Defines[ArchListString] = DefineList
|
|
#
|
|
# After set, check whether INF_VERSION defined.
|
|
#
|
|
if not HasFoundInfVersionFalg:
|
|
ErrorInInf(ST.ERR_INF_PARSER_NOT_SUPPORT_EDKI_INF,
|
|
ErrorCode=ToolError.EDK1_INF_ERROR,
|
|
RaiseError=True)
|
|
return True
|
|
|
|
def GetDefines(self):
|
|
return self.Defines
|
|
|