def Query(self, Model):
SqlCommand = """select ID, Value1, Value2, Value3, Arch, BelongsToItem, BelongsToFile, StartLine from %s
where Model = %s
and Enabled > -1""" % (self.Table, Model)
EdkLogger.debug(4, "SqlCommand: %s" % SqlCommand)
self.Cur.execute(SqlCommand)
return self.Cur.fetchall()
def Write(self, FilePath):
if not (FilePath is not None or len(FilePath) != 0):
EdkLogger.error("VpdInfoFile", BuildToolError.PARAMETER_INVALID,
"Invalid parameter FilePath: %s." % FilePath)
Content = FILE_COMMENT_TEMPLATE
Pcds = sorted(self._VpdArray.keys(), key=lambda x: x.TokenCName)
for Pcd in Pcds:
i = 0
PcdTokenCName = Pcd.TokenCName
for PcdItem in GlobalData.MixedPcd:
if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName
) in GlobalData.MixedPcd[PcdItem]:
PcdTokenCName = PcdItem[0]
for skuname in self._VpdArray[Pcd]:
PcdValue = str(Pcd.SkuInfoList[skuname].DefaultValue).strip()
if PcdValue == "":
PcdValue = Pcd.DefaultValue
Content += "%s.%s|%s|%s|%s|%s \n" % (
Pcd.TokenSpaceGuidCName, PcdTokenCName, skuname,
str(self._VpdArray[Pcd][skuname]).strip(),
str(Pcd.MaxDatumSize).strip(), PcdValue)
i += 1
return SaveFileOnChange(FilePath, Content, False)
def BuildDatabase(self, SpeciDirs=None):
# Clean report table
EccGlobalData.gDb.TblReport.Drop()
EccGlobalData.gDb.TblReport.Create()
# Build database
if self.IsInit:
if self.ScanMetaData:
EdkLogger.quiet("Building database for Meta Data File ...")
self.BuildMetaDataFileDatabase(SpeciDirs)
if self.ScanSourceCode:
EdkLogger.quiet("Building database for Meta Data File Done!")
if SpeciDirs is None:
c.CollectSourceCodeDataIntoDB(EccGlobalData.gTarget)
else:
for specificDir in SpeciDirs:
c.CollectSourceCodeDataIntoDB(
os.path.join(EccGlobalData.gTarget, specificDir))
EccGlobalData.gIdentifierTableList = GetTableList(
(MODEL_FILE_C, MODEL_FILE_H), 'Identifier', EccGlobalData.gDb)
EccGlobalData.gCFileList = GetFileList(MODEL_FILE_C, EccGlobalData.gDb)
EccGlobalData.gHFileList = GetFileList(MODEL_FILE_H, EccGlobalData.gDb)
EccGlobalData.gUFileList = GetFileList(MODEL_FILE_UNI,
EccGlobalData.gDb)
def CheckUsage(Comments, Usages, InfFile, LineNo, Value, ErrorMsg):
for Comment in Comments:
for Word in Comment[0].replace('#', ' ').split():
if Word in Usages:
return
EdkLogger.error("Parser", FORMAT_INVALID,
ErrorMsg % (InfFile, LineNo, Value))
def GetDepexExpresionList(self):
DepexExpressionList = []
if not self._FileSectionDataList:
return DepexExpressionList
for SectionDataDict in self._FileSectionDataList:
for key in SectionDataDict:
if key.lower() == "[depex]" or key.lower().startswith(
"[depex."):
SectionLine = key.lstrip(TAB_SECTION_START).rstrip(
TAB_SECTION_END)
SubSectionList = [SectionLine]
if str(SectionLine).find(TAB_COMMA_SPLIT) > -1:
SubSectionList = str(SectionLine).split(
TAB_COMMA_SPLIT)
for SubSection in SubSectionList:
SectionList = SubSection.split(TAB_SPLIT)
SubKey = ()
if len(SectionList) == 1:
SubKey = (TAB_ARCH_COMMON, TAB_ARCH_COMMON)
elif len(SectionList) == 2:
SubKey = (SectionList[1], TAB_ARCH_COMMON)
elif len(SectionList) == 3:
SubKey = (SectionList[1], SectionList[2])
else:
EdkLogger.error("build", AUTOGEN_ERROR,
'Section %s is invalid.' % key)
DepexExpressionList.append(
{SubKey: SectionDataDict[key]})
return DepexExpressionList
def CreateDepsInclude(self):
deps_file = {'deps_file': self.deps_files}
MakePath = self.module_autogen.BuildOption.get('MAKE', {}).get('PATH')
if not MakePath:
EdkLogger.error("build",
PARAMETER_MISSING,
Message="No Make path available.")
elif "nmake" in MakePath:
_INCLUDE_DEPS_TEMPLATE = TemplateString('''
${BEGIN}
!IF EXIST(${deps_file})
!INCLUDE ${deps_file}
!ENDIF
${END}
''')
else:
_INCLUDE_DEPS_TEMPLATE = TemplateString('''
${BEGIN}
-include ${deps_file}
${END}
''')
try:
deps_include_str = _INCLUDE_DEPS_TEMPLATE.Replace(deps_file)
except Exception as e:
print(e)
SaveFileOnChange(os.path.join(self.makefile_folder, "dependency"),
deps_include_str, False)
def Generate(self, File=None):
Buffer = BytesIO()
if len(self.PostfixNotation) == 0:
return False
for Item in self.PostfixNotation:
if Item in self.Opcode[self.Phase]:
Buffer.write(pack("B", self.Opcode[self.Phase][Item]))
elif Item in self.SupportedOpcode:
EdkLogger.error("GenDepex",
FORMAT_INVALID,
"Opcode [%s] is not expected in %s phase" %
(Item, self.Phase),
ExtraData=self.ExpressionString)
else:
Buffer.write(self.GetGuidValue(Item))
FilePath = ""
FileChangeFlag = True
if File is None:
sys.stdout.write(Buffer.getvalue())
FilePath = "STDOUT"
else:
FileChangeFlag = SaveFileOnChange(File, Buffer.getvalue(), True)
Buffer.close()
return FileChangeFlag
def ParseConfig(self):
Filepath = os.path.normpath(self.Filename)
if not os.path.isfile(Filepath):
ErrorMsg = "Can't find configuration file '%s'" % Filepath
EdkLogger.error("Ecc", EdkLogger.ECC_ERROR, ErrorMsg, File = Filepath)
LineNo = 0
for Line in open(Filepath, 'r'):
LineNo = LineNo + 1
Line = CleanString(Line)
if Line != '':
List = GetSplitValueList(Line, TAB_EQUAL_SPLIT)
if List[0] not in _ConfigFileToInternalTranslation:
ErrorMsg = "Invalid configuration option '%s' was found" % List[0]
EdkLogger.error("Ecc", EdkLogger.ECC_ERROR, ErrorMsg, File = Filepath, Line = LineNo)
assert _ConfigFileToInternalTranslation[List[0]] in self.__dict__
if List[0] == 'ModifierList':
List[1] = GetSplitValueList(List[1], TAB_COMMA_SPLIT)
if List[0] == 'MetaDataFileCheckPathOfGenerateFileList' and List[1] == "":
continue
if List[0] == 'SkipDirList':
List[1] = GetSplitValueList(List[1], TAB_COMMA_SPLIT)
if List[0] == 'SkipFileList':
List[1] = GetSplitValueList(List[1], TAB_COMMA_SPLIT)
if List[0] == 'BinaryExtList':
List[1] = GetSplitValueList(List[1], TAB_COMMA_SPLIT)
if List[0] == 'Copyright':
List[1] = GetSplitValueList(List[1], TAB_COMMA_SPLIT)
if List[0] == 'TokenReleaceList':
List[1] = GetSplitValueList(List[1], TAB_COMMA_SPLIT)
self.__dict__[_ConfigFileToInternalTranslation[List[0]]] = List[1]
def GetLanguageCode(LangName, IsCompatibleMode, File):
length = len(LangName)
if IsCompatibleMode:
if length == 3 and LangName.isalpha():
TempLangName = LangConvTable.get(LangName.lower())
if TempLangName is not None:
return TempLangName
return LangName
else:
EdkLogger.error("Unicode File Parser", FORMAT_INVALID,
"Invalid ISO 639-2 language code : %s" % LangName,
File)
if (LangName[0] == 'X' or LangName[0] == 'x') and LangName[1] == '-':
return LangName
if length == 2:
if LangName.isalpha():
return LangName
elif length == 3:
if LangName.isalpha() and LangConvTable.get(LangName.lower()) is None:
return LangName
elif length == 5:
if LangName[0:2].isalpha() and LangName[2] == '-':
return LangName
elif length >= 6:
if LangName[0:2].isalpha() and LangName[2] == '-':
return LangName
if LangName[0:3].isalpha() and LangConvTable.get(
LangName.lower()) is None and LangName[3] == '-':
return LangName
EdkLogger.error("Unicode File Parser", FORMAT_INVALID,
"Invalid RFC 4646 language code : %s" % LangName, File)
def VerifyUcs2Data(FileIn, FileName, Encoding):
Ucs2Info = codecs.lookup('ucs-2')
#
# Convert to unicode
#
try:
FileDecoded = codecs.decode(FileIn, Encoding)
Ucs2Info.encode(FileDecoded)
except:
UniFile = BytesIO(FileIn)
Info = codecs.lookup(Encoding)
(Reader, Writer) = (Info.streamreader, Info.streamwriter)
File = codecs.StreamReaderWriter(UniFile, Reader, Writer)
LineNumber = 0
ErrMsg = lambda Encoding, LineNumber: \
'%s contains invalid %s characters on line %d.' % \
(FileName, Encoding, LineNumber)
while True:
LineNumber = LineNumber + 1
try:
Line = File.readline()
if Line == '':
EdkLogger.error('Unicode File Parser', PARSER_ERROR,
ErrMsg(Encoding, LineNumber))
Ucs2Info.encode(Line)
except:
EdkLogger.error('Unicode File Parser', PARSER_ERROR,
ErrMsg('UCS-2', LineNumber))
def MacroExtend(Str, MacroDict=None, Arch=DataType.TAB_COMMON):
if Str is None:
return None
Dict = {
'$(WORKSPACE)': GenFdsGlobalVariable.WorkSpaceDir,
# '$(OUTPUT_DIRECTORY)': GenFdsGlobalVariable.OutputDirFromDsc,
'$(TARGET)': GenFdsGlobalVariable.TargetName,
'$(TOOL_CHAIN_TAG)': GenFdsGlobalVariable.ToolChainTag,
'$(SPACE)': ' '
}
if Arch != DataType.TAB_COMMON and Arch in GenFdsGlobalVariable.ArchList:
OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[Arch]
else:
OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[
GenFdsGlobalVariable.ArchList[0]]
Dict['$(OUTPUT_DIRECTORY)'] = OutputDir
if MacroDict:
Dict.update(MacroDict)
for key in Dict:
if Str.find(key) >= 0:
Str = Str.replace(key, Dict[key])
if Str.find('$(ARCH)') >= 0:
if len(GenFdsGlobalVariable.ArchList) == 1:
Str = Str.replace('$(ARCH)', GenFdsGlobalVariable.ArchList[0])
else:
EdkLogger.error("GenFds", GENFDS_ERROR,
"No way to determine $(ARCH) for %s" % Str)
return Str
def InitDatabase(self, NewDatabase=True):
EdkLogger.verbose("\nInitialize ECC database started ...")
#
# Drop all old existing tables
#
if NewDatabase:
if os.path.exists(self.DbPath):
os.remove(self.DbPath)
self.Conn = sqlite3.connect(self.DbPath, isolation_level='DEFERRED')
self.Conn.execute("PRAGMA page_size=4096")
self.Conn.execute("PRAGMA synchronous=OFF")
# to avoid non-ascii character conversion error
self.Conn.text_factory = str
self.Cur = self.Conn.cursor()
self.TblDataModel = TableDataModel(self.Cur)
self.TblFile = TableFile(self.Cur)
self.TblFunction = TableFunction(self.Cur)
self.TblIdentifier = TableIdentifier(self.Cur)
self.TblPcd = TablePcd(self.Cur)
self.TblReport = TableReport(self.Cur)
self.TblInf = ModuleTable(self.Cur)
self.TblDec = PackageTable(self.Cur)
self.TblDsc = PlatformTable(self.Cur)
self.TblFdf = TableFdf(self.Cur)
#
# Create new tables
#
if NewDatabase:
self.TblDataModel.Create()
self.TblFile.Create()
self.TblFunction.Create()
self.TblPcd.Create()
self.TblReport.Create()
self.TblInf.Create()
self.TblDec.Create()
self.TblDsc.Create()
self.TblFdf.Create()
#
# Init each table's ID
#
self.TblDataModel.InitID()
self.TblFile.InitID()
self.TblFunction.InitID()
self.TblPcd.InitID()
self.TblReport.InitID()
self.TblInf.InitID()
self.TblDec.InitID()
self.TblDsc.InitID()
self.TblFdf.InitID()
#
# Initialize table DataModel
#
if NewDatabase:
self.TblDataModel.InitTable()
EdkLogger.verbose("Initialize ECC database ... DONE!")
def GetStringObject(self, Item):
Language = ''
Value = ''
Name = Item.split()[1]
# Check the string name
if Name != '':
MatchString = gIdentifierPattern.match(Name)
if MatchString is None:
EdkLogger.error(
'Unicode File Parser', FORMAT_INVALID,
'The string token name %s defined in UNI file %s contains the invalid character.'
% (Name, self.File))
LanguageList = Item.split(u'#language ')
for IndexI in range(len(LanguageList)):
if IndexI == 0:
continue
else:
Language = LanguageList[IndexI].split()[0]
Value = LanguageList[IndexI][
LanguageList[IndexI].find(u'\"') + len(u'\"'):
LanguageList[IndexI].rfind(u'\"')] #.replace(u'\r\n', u'')
Language = GetLanguageCode(Language, self.IsCompatibleMode,
self.File)
self.AddStringToList(Name, Language, Value)
def run(self):
try:
fin_num = 0
while True:
badnews = self.feedback_q.get()
if badnews is None:
break
if badnews == "Done":
fin_num += 1
elif badnews == "QueueEmpty":
EdkLogger.debug(EdkLogger.DEBUG_9,
"Worker %s: %s" % (os.getpid(), badnews))
self.TerminateWorkers()
else:
EdkLogger.debug(EdkLogger.DEBUG_9,
"Worker %s: %s" % (os.getpid(), badnews))
self.Status = False
self.TerminateWorkers()
if fin_num == len(self.autogen_workers):
self.clearQueue()
for w in self.autogen_workers:
w.join()
break
except Exception:
return
def UpdateDepsFileforTrim(self):
""" Update .deps file which generated by trim. """
for abspath in self.deps_files:
if not abspath.endswith(".trim.deps"):
continue
try:
newcontent = []
with open(abspath, "r") as fd:
lines = fd.readlines()
if lines[-1] == DEP_FILE_TAIL:
continue
source_abs = lines[0].strip().split(" ")[0]
targetitem = self.GetRealTarget(source_abs.strip(" :"))
targetitem += ": "
if len(lines) >= 2:
targetitem += lines[1]
newcontent.append(targetitem)
newcontent.extend(lines[2:])
newcontent.append("\n")
newcontent.append(DEP_FILE_TAIL)
with open(abspath, "w") as fw:
fw.write("".join(newcontent))
except Exception as e:
EdkLogger.error("build",
FILE_NOT_FOUND,
"%s doesn't exist" % abspath,
ExtraData=str(e),
RaiseError=False)
continue
def ParseOption(self):
(Options, Target) = self.EccOptionParser()
if Options.Workspace:
os.environ["WORKSPACE"] = Options.Workspace
# Check workspace environment
if "WORKSPACE" not in os.environ:
EdkLogger.error("ECC",
BuildToolError.ATTRIBUTE_NOT_AVAILABLE,
"Environment variable not found",
ExtraData="WORKSPACE")
else:
EccGlobalData.gWorkspace = os.path.normpath(os.getenv("WORKSPACE"))
if not os.path.exists(EccGlobalData.gWorkspace):
EdkLogger.error("ECC",
BuildToolError.FILE_NOT_FOUND,
ExtraData="WORKSPACE = %s" %
EccGlobalData.gWorkspace)
os.environ["WORKSPACE"] = EccGlobalData.gWorkspace
# Set log level
self.SetLogLevel(Options)
# Set other options
if Options.ConfigFile is not None:
self.ConfigFile = Options.ConfigFile
if Options.OutputFile is not None:
self.OutputFile = Options.OutputFile
if Options.ReportFile is not None:
self.ReportFile = Options.ReportFile
if Options.ExceptionFile is not None:
self.ExceptionFile = Options.ExceptionFile
if Options.Target is not None:
if not os.path.isdir(Options.Target):
EdkLogger.error("ECC",
BuildToolError.OPTION_VALUE_INVALID,
ExtraData="Target [%s] does NOT exist" %
Options.Target)
else:
EccGlobalData.gTarget = self.GetRealPathCase(
os.path.normpath(Options.Target))
else:
EdkLogger.warn(
"Ecc", EdkLogger.ECC_ERROR,
"The target source tree was not specified, using current WORKSPACE instead!"
)
EccGlobalData.gTarget = os.path.normpath(os.getenv("WORKSPACE"))
if Options.keepdatabase is not None:
self.IsInit = False
if Options.metadata is not None and Options.sourcecode is not None:
EdkLogger.error(
"ECC",
BuildToolError.OPTION_CONFLICT,
ExtraData="-m and -s can't be specified at one time")
if Options.metadata is not None:
self.ScanSourceCode = False
if Options.sourcecode is not None:
self.ScanMetaData = False
if Options.folders is not None:
self.OnlyScan = True
def __init__(self):
# Version and Copyright
self.VersionNumber = ("1.0" + " Build " + gBUILD_VERSION)
self.Version = "%prog Version " + self.VersionNumber
self.Copyright = "Copyright (c) 2009 - 2018, Intel Corporation All rights reserved."
self.InitDefaultConfigIni()
self.OutputFile = 'output.txt'
self.ReportFile = 'Report.csv'
self.ExceptionFile = 'exception.xml'
self.IsInit = True
self.ScanSourceCode = True
self.ScanMetaData = True
self.MetaFile = ''
self.OnlyScan = None
# Parse the options and args
self.ParseOption()
EdkLogger.info(time.strftime("%H:%M:%S, %b.%d %Y ", time.localtime()) + "[00:00]" + "\n")
WorkspaceDir = os.path.normcase(os.path.normpath(os.environ["WORKSPACE"]))
os.environ["WORKSPACE"] = WorkspaceDir
# set multiple workspace
PackagesPath = os.getenv("PACKAGES_PATH")
mws.setWs(WorkspaceDir, PackagesPath)
GlobalData.gWorkspace = WorkspaceDir
GlobalData.gGlobalDefines["WORKSPACE"] = WorkspaceDir
EdkLogger.info("Loading ECC configuration ... done")
# Generate checkpoints list
EccGlobalData.gConfig = Configuration(self.ConfigFile)
# Generate exception list
EccGlobalData.gException = ExceptionCheck(self.ExceptionFile)
# Init Ecc database
EccGlobalData.gDb = Database.Database(Database.DATABASE_PATH)
EccGlobalData.gDb.InitDatabase(self.IsInit)
#
# Get files real name in workspace dir
#
GlobalData.gAllFiles = DirCache(GlobalData.gWorkspace)
# Build ECC database
# self.BuildDatabase()
self.DetectOnlyScanDirs()
# Start to check
self.Check()
# Show report
self.GenReport()
# Close Database
EccGlobalData.gDb.Close()
def GenerateVfrBinSec(ModuleName, DebugDir, OutputFile):
VfrNameList = []
if os.path.isdir(DebugDir):
for CurrentDir, Dirs, Files in os.walk(DebugDir):
for FileName in Files:
Name, Ext = os.path.splitext(FileName)
if Ext == '.c' and Name != 'AutoGen':
VfrNameList.append (Name + 'Bin')
VfrNameList.append (ModuleName + 'Strings')
EfiFileName = os.path.join(DebugDir, ModuleName + '.efi')
MapFileName = os.path.join(DebugDir, ModuleName + '.map')
VfrUniOffsetList = GetVariableOffset(MapFileName, EfiFileName, VfrNameList)
if not VfrUniOffsetList:
return
try:
fInputfile = open(OutputFile, "wb+")
except:
EdkLogger.error("Trim", FILE_OPEN_FAILURE, "File open failed for %s" %OutputFile, None)
# Use a instance of BytesIO to cache data
fStringIO = BytesIO()
for Item in VfrUniOffsetList:
if (Item[0].find("Strings") != -1):
#
# UNI offset in image.
# GUID + Offset
# { 0x8913c5e0, 0x33f6, 0x4d86, { 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66 } }
#
UniGuid = b'\xe0\xc5\x13\x89\xf63\x86M\x9b\xf1C\xef\x89\xfc\x06f'
fStringIO.write(UniGuid)
UniValue = pack ('Q', int (Item[1], 16))
fStringIO.write (UniValue)
else:
#
# VFR binary offset in image.
# GUID + Offset
# { 0xd0bc7cb4, 0x6a47, 0x495f, { 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2 } };
#
VfrGuid = b'\xb4|\xbc\xd0Gj_I\xaa\x11q\x07F\xda\x06\xa2'
fStringIO.write(VfrGuid)
type (Item[1])
VfrValue = pack ('Q', int (Item[1], 16))
fStringIO.write (VfrValue)
#
# write data into file.
#
try :
fInputfile.write (fStringIO.getvalue())
except:
EdkLogger.error("Trim", FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the file been locked or using by other applications." %OutputFile, None)
fStringIO.close ()
fInputfile.close ()
def TrimPreprocessedVfr(Source, Target):
CreateDirectory(os.path.dirname(Target))
try:
with open(Source, "r") as File:
Lines = File.readlines()
except:
EdkLogger.error("Trim", FILE_OPEN_FAILURE, ExtraData=Source)
# read whole file
FoundTypedef = False
Brace = 0
TypedefStart = 0
TypedefEnd = 0
for Index in range(len(Lines)):
Line = Lines[Index]
# don't trim the lines from "formset" definition to the end of file
if Line.strip() == 'formset':
break
if FoundTypedef == False and (Line.find('#line') == 0
or Line.find('# ') == 0):
# empty the line number directive if it's not aomong "typedef struct"
Lines[Index] = "\n"
continue
if FoundTypedef == False and gTypedefPattern.search(Line) is None:
# keep "#pragram pack" directive
if gPragmaPattern.search(Line) is None:
Lines[Index] = "\n"
continue
elif FoundTypedef == False:
# found "typedef struct", keept its position and set a flag
FoundTypedef = True
TypedefStart = Index
# match { and } to find the end of typedef definition
if Line.find("{") >= 0:
Brace += 1
elif Line.find("}") >= 0:
Brace -= 1
# "typedef struct" must end with a ";"
if Brace == 0 and Line.find(";") >= 0:
FoundTypedef = False
TypedefEnd = Index
# keep all "typedef struct" except to GUID, EFI_PLABEL and PAL_CALL_RETURN
if Line.strip("} ;\r\n") in [
TAB_GUID, "EFI_PLABEL", "PAL_CALL_RETURN"
]:
for i in range(TypedefStart, TypedefEnd + 1):
Lines[i] = "\n"
# save all lines trimmed
try:
with open(Target, 'w') as File:
File.writelines(Lines)
except:
EdkLogger.error("Trim", FILE_OPEN_FAILURE, ExtraData=Target)
def GenSection(self,
OutputPath,
ModuleName,
SecNum,
keyStringList,
FfsFile=None,
Dict=None,
IsMakefile=False):
if self.ExpressionProcessed == False:
self.Expression = self.Expression.replace("\n",
" ").replace("\r", " ")
ExpList = self.Expression.split()
for Exp in ExpList:
if Exp.upper() not in ('AND', 'OR', 'NOT', 'TRUE', 'FALSE',
'SOR', 'BEFORE', 'AFTER', 'END'):
GuidStr = self.__FindGuidValue(Exp)
if GuidStr is None:
EdkLogger.error(
"GenFds", RESOURCE_NOT_AVAILABLE,
"Depex GUID %s could not be found in build DB! (ModuleName: %s)"
% (Exp, ModuleName))
self.Expression = self.Expression.replace(Exp, GuidStr)
self.Expression = self.Expression.strip()
self.ExpressionProcessed = True
if self.DepexType == 'PEI_DEPEX_EXP':
ModuleType = SUP_MODULE_PEIM
SecType = BINARY_FILE_TYPE_PEI_DEPEX
elif self.DepexType == 'DXE_DEPEX_EXP':
ModuleType = SUP_MODULE_DXE_DRIVER
SecType = BINARY_FILE_TYPE_DXE_DEPEX
elif self.DepexType == 'SMM_DEPEX_EXP':
ModuleType = SUP_MODULE_DXE_SMM_DRIVER
SecType = BINARY_FILE_TYPE_SMM_DEPEX
else:
EdkLogger.error(
"GenFds", FORMAT_INVALID,
"Depex type %s is not valid for module %s" %
(self.DepexType, ModuleName))
InputFile = os.path.join(
OutputPath, ModuleName + SUP_MODULE_SEC + SecNum + '.depex')
InputFile = os.path.normpath(InputFile)
Depex = DependencyExpression(self.Expression, ModuleType)
Depex.Generate(InputFile)
OutputFile = os.path.join(
OutputPath, ModuleName + SUP_MODULE_SEC + SecNum + '.dpx')
OutputFile = os.path.normpath(OutputFile)
GenFdsGlobalVariable.GenerateSection(
OutputFile, [InputFile],
Section.Section.SectionType.get(SecType),
IsMakefile=IsMakefile)
return [OutputFile], self.Alignment
def SetLogLevel(self, Option):
if Option.verbose is not None:
EdkLogger.SetLevel(EdkLogger.VERBOSE)
elif Option.quiet is not None:
EdkLogger.SetLevel(EdkLogger.QUIET)
elif Option.debug is not None:
EdkLogger.SetLevel(Option.debug + 1)
else:
EdkLogger.SetLevel(EdkLogger.INFO)
def AddStringToList(self,
Name,
Language,
Value,
Token=None,
Referenced=False,
UseOtherLangDef='',
Index=-1):
for LangNameItem in self.LanguageDef:
if Language == LangNameItem[0]:
break
else:
EdkLogger.error('Unicode File Parser', FORMAT_NOT_SUPPORTED, "The language '%s' for %s is not defined in Unicode file %s." \
% (Language, Name, self.File))
if Language not in self.OrderedStringList:
self.OrderedStringList[Language] = []
self.OrderedStringDict[Language] = {}
IsAdded = True
if Name in self.OrderedStringDict[Language]:
IsAdded = False
if Value is not None:
ItemIndexInList = self.OrderedStringDict[Language][Name]
Item = self.OrderedStringList[Language][ItemIndexInList]
Item.UpdateValue(Value)
Item.UseOtherLangDef = ''
if IsAdded:
Token = len(self.OrderedStringList[Language])
if Index == -1:
self.OrderedStringList[Language].append(
StringDefClassObject(Name, Value, Referenced, Token,
UseOtherLangDef))
self.OrderedStringDict[Language][Name] = Token
for LangName in self.LanguageDef:
#
# New STRING token will be added into all language string lists.
# so that the unique STRING identifier is reserved for all languages in the package list.
#
if LangName[0] != Language:
if UseOtherLangDef != '':
OtherLangDef = UseOtherLangDef
else:
OtherLangDef = Language
self.OrderedStringList[LangName[0]].append(
StringDefClassObject(Name, '', Referenced, Token,
OtherLangDef))
self.OrderedStringDict[LangName[0]][Name] = len(
self.OrderedStringList[LangName[0]]) - 1
else:
self.OrderedStringList[Language].insert(
Index,
StringDefClassObject(Name, Value, Referenced, Token,
UseOtherLangDef))
self.OrderedStringDict[Language][Name] = Index
def Insert(self, *Args):
self.ID = self.ID + self._ID_STEP_
if self.ID >= (self.IdBase + self._ID_MAX_):
self.ID = self.IdBase + self._ID_STEP_
Values = ", ".join(str(Arg) for Arg in Args)
SqlCommand = "insert into %s values(%s, %s)" % (self.Table, self.ID,
Values)
EdkLogger.debug(EdkLogger.DEBUG_5, SqlCommand)
self.Cur.execute(SqlCommand)
return self.ID
def InitTable(self):
EdkLogger.verbose("\nInitialize table DataModel started ...")
Count = self.GetCount()
if Count is not None and Count != 0:
return
for Item in DataClass.MODEL_LIST:
CrossIndex = Item[1]
Name = Item[0]
Description = Item[0]
self.Insert(CrossIndex, Name, Description)
EdkLogger.verbose("Initialize table DataModel ... DONE!")
def DetectOnlyScanDirs(self):
if self.OnlyScan == True:
OnlyScanDirs = []
# Use regex here if multiple spaces or TAB exists in ScanOnlyDirList in config.ini file
for folder in re.finditer(r'\S+', EccGlobalData.gConfig.ScanOnlyDirList):
OnlyScanDirs.append(folder.group())
if len(OnlyScanDirs) != 0:
self.BuildDatabase(OnlyScanDirs)
else:
EdkLogger.error("ECC", BuildToolError.OPTION_VALUE_INVALID, ExtraData="Use -f option need to fill specific folders in config.ini file")
else:
self.BuildDatabase()
def IsIntegrity(self):
Result = False
try:
TimeStamp = self.MetaFile.TimeStamp
if not self.CurrentContent:
Result = False
else:
Result = self.CurrentContent[-1][0] < 0
except Exception as Exc:
EdkLogger.debug(EdkLogger.DEBUG_5, str(Exc))
return False
return Result
def ParseInf(self, Lines=[], FileRelativePath='', Filename=''):
IfDefList, SectionItemList, CurrentSection, ArchList, ThirdList, IncludeFiles = \
[], [], TAB_UNKNOWN, [], [], []
LineNo = 0
for Line in Lines:
LineNo = LineNo + 1
if Line == '':
continue
if Line.startswith(TAB_SECTION_START) and Line.endswith(
TAB_SECTION_END):
self.ParserSource(CurrentSection, SectionItemList, ArchList,
ThirdList)
# Parse the new section
SectionItemList = []
ArchList = []
ThirdList = []
# Parse section name
CurrentSection = ''
LineList = GetSplitValueList(
Line[len(TAB_SECTION_START):len(Line) -
len(TAB_SECTION_END)], TAB_COMMA_SPLIT)
for Item in LineList:
ItemList = GetSplitValueList(Item, TAB_SPLIT)
if CurrentSection == '':
CurrentSection = ItemList[0]
else:
if CurrentSection != ItemList[0]:
EdkLogger.error(
"Parser",
PARSER_ERROR,
"Different section names '%s' and '%s' are found in one section definition, this is not allowed."
% (CurrentSection, ItemList[0]),
File=Filename,
Line=LineNo)
ItemList.append('')
ItemList.append('')
if len(ItemList) > 5:
RaiseParserError(Line, CurrentSection, Filename, '',
LineNo)
else:
ArchList.append(ItemList[1].upper())
ThirdList.append(ItemList[2])
continue
# Add a section item
SectionItemList.append([Line, LineNo])
# End of parse
self.ParserSource(CurrentSection, SectionItemList, ArchList, ThirdList)
def SearchImageID(ImageFileObject, FileList):
if FileList == []:
return ImageFileObject
for File in FileList:
if os.path.isfile(File):
Lines = open(File, 'r')
for Line in Lines:
ImageIdList = IMAGE_TOKEN.findall(Line)
for ID in ImageIdList:
EdkLogger.debug(EdkLogger.DEBUG_5,
"Found ImageID identifier: " + ID)
ImageFileObject.SetImageIDReferenced(ID)
def _GenOffsetValue(self):
if self.PcdOffset != TAB_STAR:
try:
self.PcdBinOffset = int(self.PcdOffset)
except:
try:
self.PcdBinOffset = int(self.PcdOffset, 16)
except:
EdkLogger.error(
"BPDG", BuildToolError.FORMAT_INVALID,
"Invalid offset value %s for PCD %s (File: %s Line: %s)"
% (self.PcdOffset, self.PcdCName, self.FileName,
self.Lineno))
def _PackPtrValue(self, ValueString, Size):
if ValueString.startswith('L"') or ValueString.startswith("L'"):
self._PackUnicode(ValueString, Size)
elif ValueString.startswith('{') and ValueString.endswith('}'):
self._PackByteArray(ValueString, Size)
elif (ValueString.startswith('"') and ValueString.endswith('"')) or (
ValueString.startswith("'") and ValueString.endswith("'")):
self._PackString(ValueString, Size)
else:
EdkLogger.error(
"BPDG", BuildToolError.FORMAT_INVALID,
"Invalid VOID* type PCD %s value %s (File: %s Line: %s)" %
(self.PcdCName, ValueString, self.FileName, self.Lineno))
