273261126e
REF:https://bugzilla.tianocore.org/show_bug.cgi?id=3091 Add support for YAML format file generation in addition to current BSF structure. Configuration of YAML format output will be supported by an open source ConfigEditor. Reference to YAML code, test and ConfigEditor is at https://github.com/joshloo/fsp_yaml_cfg/tree/master/Tools A unit test is also added in Tests folder. This test compares the generated yaml file against the expected output to know if it is constructing the yaml data structure as expected. Cc: Maurice Ma <maurice.ma@intel.com> Cc: Nate DeSimone <nathaniel.l.desimone@intel.com> Cc: Star Zeng <star.zeng@intel.com> Cc: Chasel Chiu <chasel.chiu@intel.com> Signed-off-by: Loo Tung Lun <tung.lun.loo@intel.com> Reviewed-by: Chasel Chiu <chasel.chiu@intel.com>
1791 lines
76 KiB
Python
1791 lines
76 KiB
Python
## @ GenCfgOpt.py
|
|
#
|
|
# Copyright (c) 2014 - 2021, Intel Corporation. All rights reserved.<BR>
|
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
#
|
|
##
|
|
|
|
import os
|
|
import re
|
|
import sys
|
|
import struct
|
|
from datetime import date
|
|
from functools import reduce
|
|
|
|
# Generated file copyright header
|
|
|
|
__copyright_txt__ = """## @file
|
|
#
|
|
# THIS IS AUTO-GENERATED FILE BY BUILD TOOLS AND PLEASE DO NOT MAKE MODIFICATION.
|
|
#
|
|
# This file lists all VPD informations for a platform collected by build.exe.
|
|
#
|
|
# Copyright (c) %4d, 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.
|
|
#
|
|
"""
|
|
|
|
__copyright_bsf__ = """/** @file
|
|
|
|
Boot Setting File for Platform Configuration.
|
|
|
|
Copyright (c) %4d, 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.
|
|
|
|
This file is automatically generated. Please do NOT modify !!!
|
|
|
|
**/
|
|
|
|
"""
|
|
|
|
__copyright_h__ = """/** @file
|
|
|
|
Copyright (c) %4d, Intel Corporation. All rights reserved.<BR>
|
|
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted provided that the following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above copyright notice, this
|
|
list of conditions and the following disclaimer.
|
|
* Redistributions in binary form must reproduce the above copyright notice, this
|
|
list of conditions and the following disclaimer in the documentation and/or
|
|
other materials provided with the distribution.
|
|
* Neither the name of Intel Corporation nor the names of its contributors may
|
|
be used to endorse or promote products derived from this software without
|
|
specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
This file is automatically generated. Please do NOT modify !!!
|
|
|
|
**/
|
|
"""
|
|
|
|
BuildOptionPcd = []
|
|
|
|
class CLogicalExpression:
|
|
def __init__(self):
|
|
self.index = 0
|
|
self.string = ''
|
|
|
|
def errExit(self, err = ''):
|
|
print ("ERROR: Express parsing for:")
|
|
print (" %s" % self.string)
|
|
print (" %s^" % (' ' * self.index))
|
|
if err:
|
|
print ("INFO : %s" % err)
|
|
raise SystemExit
|
|
|
|
def getNonNumber (self, n1, n2):
|
|
if not n1.isdigit():
|
|
return n1
|
|
if not n2.isdigit():
|
|
return n2
|
|
return None
|
|
|
|
def getCurr(self, lens = 1):
|
|
try:
|
|
if lens == -1:
|
|
return self.string[self.index :]
|
|
else:
|
|
if self.index + lens > len(self.string):
|
|
lens = len(self.string) - self.index
|
|
return self.string[self.index : self.index + lens]
|
|
except Exception:
|
|
return ''
|
|
|
|
def isLast(self):
|
|
return self.index == len(self.string)
|
|
|
|
def moveNext(self, len = 1):
|
|
self.index += len
|
|
|
|
def skipSpace(self):
|
|
while not self.isLast():
|
|
if self.getCurr() in ' \t':
|
|
self.moveNext()
|
|
else:
|
|
return
|
|
|
|
def normNumber (self, val):
|
|
return True if val else False
|
|
|
|
def getNumber(self, var):
|
|
var = var.strip()
|
|
if re.match('^0x[a-fA-F0-9]+$', var):
|
|
value = int(var, 16)
|
|
elif re.match('^[+-]?\d+$', var):
|
|
value = int(var, 10)
|
|
else:
|
|
value = None
|
|
return value
|
|
|
|
def parseValue(self):
|
|
self.skipSpace()
|
|
var = ''
|
|
while not self.isLast():
|
|
char = self.getCurr()
|
|
if re.match('^[\w.]', char):
|
|
var += char
|
|
self.moveNext()
|
|
else:
|
|
break
|
|
val = self.getNumber(var)
|
|
if val is None:
|
|
value = var
|
|
else:
|
|
value = "%d" % val
|
|
return value
|
|
|
|
def parseSingleOp(self):
|
|
self.skipSpace()
|
|
if re.match('^NOT\W', self.getCurr(-1)):
|
|
self.moveNext(3)
|
|
op = self.parseBrace()
|
|
val = self.getNumber (op)
|
|
if val is None:
|
|
self.errExit ("'%s' is not a number" % op)
|
|
return "%d" % (not self.normNumber(int(op)))
|
|
else:
|
|
return self.parseValue()
|
|
|
|
def parseBrace(self):
|
|
self.skipSpace()
|
|
char = self.getCurr()
|
|
if char == '(':
|
|
self.moveNext()
|
|
value = self.parseExpr()
|
|
self.skipSpace()
|
|
if self.getCurr() != ')':
|
|
self.errExit ("Expecting closing brace or operator")
|
|
self.moveNext()
|
|
return value
|
|
else:
|
|
value = self.parseSingleOp()
|
|
return value
|
|
|
|
def parseCompare(self):
|
|
value = self.parseBrace()
|
|
while True:
|
|
self.skipSpace()
|
|
char = self.getCurr()
|
|
if char in ['<', '>']:
|
|
self.moveNext()
|
|
next = self.getCurr()
|
|
if next == '=':
|
|
op = char + next
|
|
self.moveNext()
|
|
else:
|
|
op = char
|
|
result = self.parseBrace()
|
|
test = self.getNonNumber(result, value)
|
|
if test is None:
|
|
value = "%d" % self.normNumber(eval (value + op + result))
|
|
else:
|
|
self.errExit ("'%s' is not a valid number for comparision" % test)
|
|
elif char in ['=', '!']:
|
|
op = self.getCurr(2)
|
|
if op in ['==', '!=']:
|
|
self.moveNext(2)
|
|
result = self.parseBrace()
|
|
test = self.getNonNumber(result, value)
|
|
if test is None:
|
|
value = "%d" % self.normNumber((eval (value + op + result)))
|
|
else:
|
|
value = "%d" % self.normNumber(eval ("'" + value + "'" + op + "'" + result + "'"))
|
|
else:
|
|
break
|
|
else:
|
|
break
|
|
return value
|
|
|
|
def parseAnd(self):
|
|
value = self.parseCompare()
|
|
while True:
|
|
self.skipSpace()
|
|
if re.match('^AND\W', self.getCurr(-1)):
|
|
self.moveNext(3)
|
|
result = self.parseCompare()
|
|
test = self.getNonNumber(result, value)
|
|
if test is None:
|
|
value = "%d" % self.normNumber(int(value) & int(result))
|
|
else:
|
|
self.errExit ("'%s' is not a valid op number for AND" % test)
|
|
else:
|
|
break
|
|
return value
|
|
|
|
def parseOrXor(self):
|
|
value = self.parseAnd()
|
|
op = None
|
|
while True:
|
|
self.skipSpace()
|
|
op = None
|
|
if re.match('^XOR\W', self.getCurr(-1)):
|
|
self.moveNext(3)
|
|
op = '^'
|
|
elif re.match('^OR\W', self.getCurr(-1)):
|
|
self.moveNext(2)
|
|
op = '|'
|
|
else:
|
|
break
|
|
if op:
|
|
result = self.parseAnd()
|
|
test = self.getNonNumber(result, value)
|
|
if test is None:
|
|
value = "%d" % self.normNumber(eval (value + op + result))
|
|
else:
|
|
self.errExit ("'%s' is not a valid op number for XOR/OR" % test)
|
|
return value
|
|
|
|
def parseExpr(self):
|
|
return self.parseOrXor()
|
|
|
|
def getResult(self):
|
|
value = self.parseExpr()
|
|
self.skipSpace()
|
|
if not self.isLast():
|
|
self.errExit ("Unexpected character found '%s'" % self.getCurr())
|
|
test = self.getNumber(value)
|
|
if test is None:
|
|
self.errExit ("Result '%s' is not a number" % value)
|
|
return int(value)
|
|
|
|
def evaluateExpress (self, Expr):
|
|
self.index = 0
|
|
self.string = Expr
|
|
if self.getResult():
|
|
Result = True
|
|
else:
|
|
Result = False
|
|
return Result
|
|
|
|
class CGenCfgOpt:
|
|
def __init__(self, Mode = ''):
|
|
self.Debug = False
|
|
self.Error = ''
|
|
self.Mode = Mode
|
|
self._GlobalDataDef = """
|
|
GlobalDataDef
|
|
SKUID = 0, "DEFAULT"
|
|
EndGlobalData
|
|
|
|
"""
|
|
self._BuidinOptionTxt = """
|
|
List &EN_DIS
|
|
Selection 0x1 , "Enabled"
|
|
Selection 0x0 , "Disabled"
|
|
EndList
|
|
|
|
"""
|
|
self._BsfKeyList = ['FIND','NAME','HELP','TYPE','PAGE', 'PAGES', 'BLOCK', 'OPTION','CONDITION','ORDER', 'MARKER', 'SUBT']
|
|
self._HdrKeyList = ['HEADER','STRUCT', 'EMBED', 'COMMENT']
|
|
self._BuidinOption = {'$EN_DIS' : 'EN_DIS'}
|
|
|
|
self._MacroDict = {}
|
|
self._VarDict = {}
|
|
self._PcdsDict = {}
|
|
self._CfgBlkDict = {}
|
|
self._CfgPageDict = {}
|
|
self._BsfTempDict = {}
|
|
self._CfgItemList = []
|
|
self._DscLines = []
|
|
self._DscFile = ''
|
|
|
|
self._MapVer = 0
|
|
self._DscTime = 0
|
|
|
|
def ParseMacros (self, MacroDefStr):
|
|
# ['-DABC=1', '-D', 'CFG_DEBUG=1', '-D', 'CFG_OUTDIR=Build']
|
|
self._MacroDict = {}
|
|
IsExpression = False
|
|
for Macro in MacroDefStr:
|
|
if Macro.startswith('-D'):
|
|
IsExpression = True
|
|
if len(Macro) > 2:
|
|
Macro = Macro[2:]
|
|
else :
|
|
continue
|
|
if IsExpression:
|
|
IsExpression = False
|
|
Match = re.match("(\w+)=(.+)", Macro)
|
|
if Match:
|
|
self._MacroDict[Match.group(1)] = Match.group(2)
|
|
else:
|
|
Match = re.match("(\w+)", Macro)
|
|
if Match:
|
|
self._MacroDict[Match.group(1)] = ''
|
|
if len(self._MacroDict) == 0:
|
|
Error = 1
|
|
else:
|
|
Error = 0
|
|
if self.Debug:
|
|
print ("INFO : Macro dictionary:")
|
|
for Each in self._MacroDict:
|
|
print (" $(%s) = [ %s ]" % (Each , self._MacroDict[Each]))
|
|
return Error
|
|
|
|
def EvaulateIfdef (self, Macro):
|
|
Result = Macro in self._MacroDict
|
|
if self.Debug:
|
|
print ("INFO : Eval Ifdef [%s] : %s" % (Macro, Result))
|
|
return Result
|
|
|
|
def ExpandMacros (self, Input, Preserve = False):
|
|
Line = Input
|
|
Match = re.findall("\$\(\w+\)", Input)
|
|
if Match:
|
|
for Each in Match:
|
|
Variable = Each[2:-1]
|
|
if Variable in self._MacroDict:
|
|
Line = Line.replace(Each, self._MacroDict[Variable])
|
|
else:
|
|
if self.Debug:
|
|
print ("WARN : %s is not defined" % Each)
|
|
if not Preserve:
|
|
Line = Line.replace(Each, Each[2:-1])
|
|
return Line
|
|
|
|
def ExpandPcds (self, Input):
|
|
Line = Input
|
|
Match = re.findall("(\w+\.\w+)", Input)
|
|
if Match:
|
|
for PcdName in Match:
|
|
if PcdName in self._PcdsDict:
|
|
Line = Line.replace(PcdName, self._PcdsDict[PcdName])
|
|
else:
|
|
if self.Debug:
|
|
print ("WARN : %s is not defined" % PcdName)
|
|
return Line
|
|
|
|
def EvaluateExpress (self, Expr):
|
|
ExpExpr = self.ExpandPcds(Expr)
|
|
ExpExpr = self.ExpandMacros(ExpExpr)
|
|
LogExpr = CLogicalExpression()
|
|
Result = LogExpr.evaluateExpress (ExpExpr)
|
|
if self.Debug:
|
|
print ("INFO : Eval Express [%s] : %s" % (Expr, Result))
|
|
return Result
|
|
|
|
def ValueToByteArray (self, ValueStr, Length):
|
|
Match = re.match("\{\s*FILE:(.+)\}", ValueStr)
|
|
if Match:
|
|
FileList = Match.group(1).split(',')
|
|
Result = bytearray()
|
|
for File in FileList:
|
|
File = File.strip()
|
|
BinPath = os.path.join(os.path.dirname(self._DscFile), File)
|
|
Result.extend(bytearray(open(BinPath, 'rb').read()))
|
|
else:
|
|
try:
|
|
Result = bytearray(self.ValueToList(ValueStr, Length))
|
|
except ValueError as e:
|
|
raise Exception ("Bytes in '%s' must be in range 0~255 !" % ValueStr)
|
|
if len(Result) < Length:
|
|
Result.extend(b'\x00' * (Length - len(Result)))
|
|
elif len(Result) > Length:
|
|
raise Exception ("Value '%s' is too big to fit into %d bytes !" % (ValueStr, Length))
|
|
|
|
return Result[:Length]
|
|
|
|
def ValueToList (self, ValueStr, Length):
|
|
if ValueStr[0] == '{':
|
|
Result = []
|
|
BinList = ValueStr[1:-1].split(',')
|
|
InBitField = False
|
|
LastInBitField = False
|
|
Value = 0
|
|
BitLen = 0
|
|
for Element in BinList:
|
|
InBitField = False
|
|
Each = Element.strip()
|
|
if len(Each) == 0:
|
|
pass
|
|
else:
|
|
if Each[0] in ['"', "'"]:
|
|
Result.extend(list(bytearray(Each[1:-1], 'utf-8')))
|
|
elif ':' in Each:
|
|
Match = re.match("(.+):(\d+)b", Each)
|
|
if Match is None:
|
|
raise Exception("Invald value list format '%s' !" % Each)
|
|
InBitField = True
|
|
CurrentBitLen = int(Match.group(2))
|
|
CurrentValue = ((self.EvaluateExpress(Match.group(1)) & (1<<CurrentBitLen) - 1)) << BitLen
|
|
else:
|
|
Result.append(self.EvaluateExpress(Each.strip()))
|
|
if InBitField:
|
|
Value += CurrentValue
|
|
BitLen += CurrentBitLen
|
|
if LastInBitField and ((not InBitField) or (Element == BinList[-1])):
|
|
if BitLen % 8 != 0:
|
|
raise Exception("Invald bit field length!")
|
|
Result.extend(Val2Bytes(Value, BitLen // 8))
|
|
Value = 0
|
|
BitLen = 0
|
|
LastInBitField = InBitField
|
|
elif ValueStr.startswith("'") and ValueStr.endswith("'"):
|
|
Result = Str2Bytes (ValueStr, Length)
|
|
elif ValueStr.startswith('"') and ValueStr.endswith('"'):
|
|
Result = Str2Bytes (ValueStr, Length)
|
|
else:
|
|
Result = Val2Bytes (self.EvaluateExpress(ValueStr), Length)
|
|
return Result
|
|
|
|
def FormatListValue(self, ConfigDict):
|
|
Struct = ConfigDict['struct']
|
|
if Struct not in ['UINT8','UINT16','UINT32','UINT64']:
|
|
return
|
|
|
|
dataarray = []
|
|
binlist = ConfigDict['value'][1:-1].split(',')
|
|
for each in binlist:
|
|
each = each.strip()
|
|
if each.startswith('0x'):
|
|
value = int(each, 16)
|
|
else:
|
|
value = int(each)
|
|
dataarray.append(value)
|
|
|
|
unit = int(Struct[4:]) / 8
|
|
if int(ConfigDict['length']) != unit * len(dataarray):
|
|
raise Exception("Array size is not proper for '%s' !" % ConfigDict['cname'])
|
|
|
|
bytearray = []
|
|
for each in dataarray:
|
|
value = each
|
|
for loop in range(int(unit)):
|
|
bytearray.append("0x%02X" % (value & 0xFF))
|
|
value = value >> 8
|
|
newvalue = '{' + ','.join(bytearray) + '}'
|
|
ConfigDict['value'] = newvalue
|
|
return ""
|
|
|
|
def ParseDscFile (self, DscFile, FvDir):
|
|
Hardcode = False
|
|
AutoAlign = False
|
|
self._CfgItemList = []
|
|
self._CfgPageDict = {}
|
|
self._CfgBlkDict = {}
|
|
self._DscFile = DscFile
|
|
self._FvDir = FvDir
|
|
|
|
self._DscLines = []
|
|
self._BsfTempDict = {}
|
|
|
|
# Initial DSC time is parent DSC time.
|
|
self._DscTime = os.path.getmtime(DscFile)
|
|
|
|
CfgDict = {}
|
|
|
|
IsDefSect = False
|
|
IsPcdSect = False
|
|
IsUpdSect = False
|
|
IsVpdSect = False
|
|
IsTmpSect = False
|
|
|
|
TemplateName = ''
|
|
|
|
IfStack = []
|
|
ElifStack = []
|
|
Error = 0
|
|
ConfigDict = {}
|
|
|
|
|
|
if type(DscFile) is list:
|
|
# it is DSC lines already
|
|
DscLines = DscFile
|
|
self._DscFile = '.'
|
|
else:
|
|
DscFd = open(DscFile, "r")
|
|
DscLines = DscFd.readlines()
|
|
DscFd.close()
|
|
self._DscFile = DscFile
|
|
|
|
SkipLines = 0
|
|
|
|
MaxAlign = 32 #Default align to 32, but if there are 64 bit unit, align to 64
|
|
SizeAlign = 0 #record the struct max align
|
|
Base = 0 #Starting offset of sub-structure.
|
|
|
|
while len(DscLines):
|
|
DscLine = DscLines.pop(0).strip()
|
|
if SkipLines == 0:
|
|
self._DscLines.append (DscLine)
|
|
else:
|
|
SkipLines = SkipLines - 1
|
|
if len(DscLine) == 0:
|
|
continue
|
|
|
|
Handle = False
|
|
Match = re.match("^\[(.+)\]", DscLine)
|
|
if Match is not None:
|
|
IsDefSect = False
|
|
IsPcdSect = False
|
|
IsVpdSect = False
|
|
IsUpdSect = False
|
|
IsTmpSect = False
|
|
SectionName = Match.group(1).lower()
|
|
if SectionName == "Defines".lower():
|
|
IsDefSect = True
|
|
if (SectionName == "PcdsFeatureFlag".lower() or SectionName == "PcdsFixedAtBuild".lower()):
|
|
IsPcdSect = True
|
|
elif SectionName == "PcdsDynamicVpd.Tmp".lower():
|
|
IsTmpSect = True
|
|
elif SectionName == "PcdsDynamicVpd.Upd".lower():
|
|
ConfigDict = {}
|
|
ConfigDict['header'] = 'ON'
|
|
ConfigDict['region'] = 'UPD'
|
|
ConfigDict['order'] = -1
|
|
ConfigDict['page'] = ''
|
|
ConfigDict['name'] = ''
|
|
ConfigDict['find'] = ''
|
|
ConfigDict['marker'] = ''
|
|
ConfigDict['struct'] = ''
|
|
ConfigDict['embed'] = ''
|
|
ConfigDict['comment'] = ''
|
|
ConfigDict['subreg'] = []
|
|
ConfigDict['condition'] = ''
|
|
ConfigDict['option'] = ''
|
|
IsUpdSect = True
|
|
Offset = 0
|
|
else:
|
|
if IsDefSect or IsPcdSect or IsUpdSect or IsVpdSect or IsTmpSect:
|
|
|
|
Match = False if DscLine[0] != '!' else True
|
|
if Match:
|
|
Match = re.match("^!(else|endif|ifdef|ifndef|if|elseif|include)\s*(.+)?$", DscLine.split("#")[0])
|
|
Keyword = Match.group(1) if Match else ''
|
|
Remaining = Match.group(2) if Match else ''
|
|
Remaining = '' if Remaining is None else Remaining.strip()
|
|
|
|
if Keyword in ['if', 'elseif', 'ifdef', 'ifndef', 'include'] and not Remaining:
|
|
raise Exception ("ERROR: Expression is expected after '!if' or !elseif' for line '%s'" % DscLine)
|
|
|
|
if Keyword == 'else':
|
|
if IfStack:
|
|
IfStack[-1] = not IfStack[-1]
|
|
else:
|
|
raise Exception ("ERROR: No paired '!if' found for '!else' for line '%s'" % DscLine)
|
|
elif Keyword == 'endif':
|
|
if IfStack:
|
|
IfStack.pop()
|
|
Level = ElifStack.pop()
|
|
if Level > 0:
|
|
del IfStack[-Level:]
|
|
else:
|
|
raise Exception ("ERROR: No paired '!if' found for '!endif' for line '%s'" % DscLine)
|
|
elif Keyword == 'ifdef' or Keyword == 'ifndef':
|
|
Result = self.EvaulateIfdef (Remaining)
|
|
if Keyword == 'ifndef':
|
|
Result = not Result
|
|
IfStack.append(Result)
|
|
ElifStack.append(0)
|
|
elif Keyword == 'if' or Keyword == 'elseif':
|
|
Result = self.EvaluateExpress(Remaining)
|
|
if Keyword == "if":
|
|
ElifStack.append(0)
|
|
IfStack.append(Result)
|
|
else: #elseif
|
|
if IfStack:
|
|
IfStack[-1] = not IfStack[-1]
|
|
IfStack.append(Result)
|
|
ElifStack[-1] = ElifStack[-1] + 1
|
|
else:
|
|
raise Exception ("ERROR: No paired '!if' found for '!elif' for line '%s'" % DscLine)
|
|
else:
|
|
if IfStack:
|
|
Handle = reduce(lambda x,y: x and y, IfStack)
|
|
else:
|
|
Handle = True
|
|
if Handle:
|
|
Match = re.match("!include\s+(.+)", DscLine)
|
|
if Match:
|
|
IncludeFilePath = Match.group(1)
|
|
IncludeFilePath = self.ExpandMacros(IncludeFilePath)
|
|
PackagesPath = os.getenv("PACKAGES_PATH")
|
|
if PackagesPath:
|
|
for PackagePath in PackagesPath.split(os.pathsep):
|
|
IncludeFilePathAbs = os.path.join(os.path.normpath(PackagePath), os.path.normpath(IncludeFilePath))
|
|
if os.path.exists(IncludeFilePathAbs):
|
|
IncludeDsc = open(IncludeFilePathAbs, "r")
|
|
break
|
|
else:
|
|
IncludeDsc = open(IncludeFilePath, "r")
|
|
if IncludeDsc == None:
|
|
print("ERROR: Cannot open file '%s'" % IncludeFilePath)
|
|
raise SystemExit
|
|
|
|
# Update DscTime when newer DSC time found.
|
|
CurrentDscTime = os.path.getmtime(os.path.realpath(IncludeDsc.name))
|
|
if CurrentDscTime > self._DscTime:
|
|
self._DscTime = CurrentDscTime
|
|
|
|
NewDscLines = IncludeDsc.readlines()
|
|
IncludeDsc.close()
|
|
DscLines = NewDscLines + DscLines
|
|
del self._DscLines[-1]
|
|
Offset = 0
|
|
else:
|
|
if DscLine.startswith('!'):
|
|
print("ERROR: Unrecognized directive for line '%s'" % DscLine)
|
|
raise SystemExit
|
|
if not Handle:
|
|
del self._DscLines[-1]
|
|
continue
|
|
|
|
if IsDefSect:
|
|
#DEFINE UPD_TOOL_GUID = 8C3D856A-9BE6-468E-850A-24F7A8D38E09
|
|
#DEFINE FSP_T_UPD_TOOL_GUID = 34686CA3-34F9-4901-B82A-BA630F0714C6
|
|
#DEFINE FSP_M_UPD_TOOL_GUID = 39A250DB-E465-4DD1-A2AC-E2BD3C0E2385
|
|
#DEFINE FSP_S_UPD_TOOL_GUID = CAE3605B-5B34-4C85-B3D7-27D54273C40F
|
|
Match = re.match("^\s*(?:DEFINE\s+)*(\w+)\s*=\s*(.+)", DscLine)
|
|
if Match:
|
|
self._MacroDict[Match.group(1)] = self.ExpandMacros(Match.group(2))
|
|
if self.Debug:
|
|
print ("INFO : DEFINE %s = [ %s ]" % (Match.group(1), self.ExpandMacros(Match.group(2))))
|
|
elif IsPcdSect:
|
|
#gSiPkgTokenSpaceGuid.PcdTxtEnable|FALSE
|
|
#gSiPkgTokenSpaceGuid.PcdOverclockEnable|TRUE
|
|
Match = re.match("^\s*([\w\.]+)\s*\|\s*(\w+)", DscLine)
|
|
if Match:
|
|
self._PcdsDict[Match.group(1)] = Match.group(2)
|
|
if self.Debug:
|
|
print ("INFO : PCD %s = [ %s ]" % (Match.group(1), Match.group(2)))
|
|
i = 0
|
|
while i < len(BuildOptionPcd):
|
|
Match = re.match("\s*([\w\.]+)\s*\=\s*(\w+)", BuildOptionPcd[i])
|
|
if Match:
|
|
self._PcdsDict[Match.group(1)] = Match.group(2)
|
|
i += 1
|
|
|
|
elif IsTmpSect:
|
|
# !BSF DEFT:{GPIO_TMPL:START}
|
|
Match = re.match("^\s*#\s+(!BSF)\s+DEFT:{(.+?):(START|END)}", DscLine)
|
|
if Match:
|
|
if Match.group(3) == 'START' and not TemplateName:
|
|
TemplateName = Match.group(2).strip()
|
|
self._BsfTempDict[TemplateName] = []
|
|
if Match.group(3) == 'END' and (TemplateName == Match.group(2).strip()) and TemplateName:
|
|
TemplateName = ''
|
|
else:
|
|
if TemplateName:
|
|
Match = re.match("^!include\s*(.+)?$", DscLine)
|
|
if Match:
|
|
continue
|
|
self._BsfTempDict[TemplateName].append(DscLine)
|
|
|
|
else:
|
|
Match = re.match("^\s*#\s+(!BSF|@Bsf|!HDR)\s+(.+)", DscLine)
|
|
if Match:
|
|
Remaining = Match.group(2)
|
|
if Match.group(1) == '!BSF' or Match.group(1) == '@Bsf':
|
|
Match = re.match("(?:^|.+\s+)PAGES:{(.+?)}", Remaining)
|
|
if Match:
|
|
# !BSF PAGES:{HSW:"Haswell System Agent", LPT:"Lynx Point PCH"}
|
|
PageList = Match.group(1).split(',')
|
|
for Page in PageList:
|
|
Page = Page.strip()
|
|
Match = re.match("(\w+):\"(.+)\"", Page)
|
|
self._CfgPageDict[Match.group(1)] = Match.group(2)
|
|
|
|
Match = re.match("(?:^|.+\s+)BLOCK:{NAME:\"(.+)\"\s*,\s*VER:\"(.+)\"\s*}", Remaining)
|
|
if Match:
|
|
self._CfgBlkDict['name'] = Match.group(1)
|
|
self._CfgBlkDict['ver'] = Match.group(2)
|
|
|
|
for Key in self._BsfKeyList:
|
|
Match = re.match("(?:^|.+\s+)%s:{(.+?)}" % Key, Remaining)
|
|
if Match:
|
|
if Key in ['NAME', 'HELP', 'OPTION'] and Match.group(1).startswith('+'):
|
|
ConfigDict[Key.lower()] += Match.group(1)[1:]
|
|
else:
|
|
ConfigDict[Key.lower()] = Match.group(1)
|
|
else:
|
|
for Key in self._HdrKeyList:
|
|
Match = re.match("(?:^|.+\s+)%s:{(.+?)}" % Key, Remaining)
|
|
if Match:
|
|
ConfigDict[Key.lower()] = Match.group(1)
|
|
|
|
Match = re.match("^\s*#\s+@Prompt\s+(.+)", DscLine)
|
|
if Match:
|
|
ConfigDict['name'] = Match.group(1)
|
|
|
|
Match = re.match("^\s*#\s*@ValidList\s*(.+)\s*\|\s*(.+)\s*\|\s*(.+)\s*", DscLine)
|
|
if Match:
|
|
if Match.group(2).strip() in self._BuidinOption:
|
|
ConfigDict['option'] = Match.group(2).strip()
|
|
else:
|
|
OptionValueList = Match.group(2).split(',')
|
|
OptionStringList = Match.group(3).split(',')
|
|
Index = 0
|
|
for Option in OptionValueList:
|
|
Option = Option.strip()
|
|
ConfigDict['option'] = ConfigDict['option'] + str(Option) + ':' + OptionStringList[Index].strip()
|
|
Index += 1
|
|
if Index in range(len(OptionValueList)):
|
|
ConfigDict['option'] += ', '
|
|
ConfigDict['type'] = "Combo"
|
|
|
|
Match = re.match("^\s*#\s*@ValidRange\s*(.+)\s*\|\s*(.+)\s*-\s*(.+)\s*", DscLine)
|
|
if Match:
|
|
if "0x" in Match.group(2) or "0x" in Match.group(3):
|
|
ConfigDict['type'] = "EditNum, HEX, (%s,%s)" % (Match.group(2), Match.group(3))
|
|
else:
|
|
ConfigDict['type'] = "EditNum, DEC, (%s,%s)" % (Match.group(2), Match.group(3))
|
|
|
|
Match = re.match("^\s*##\s+(.+)", DscLine)
|
|
if Match:
|
|
ConfigDict['help'] = Match.group(1)
|
|
|
|
# Check VPD/UPD
|
|
if IsUpdSect:
|
|
Match = re.match("^([_a-zA-Z0-9]+).([_a-zA-Z0-9]+)\s*\|\s*(0x[0-9A-F]+|\*)\s*\|\s*(\d+|0x[0-9a-fA-F]+)\s*\|\s*(.+)",DscLine)
|
|
else:
|
|
Match = re.match("^([_a-zA-Z0-9]+).([_a-zA-Z0-9]+)\s*\|\s*(0x[0-9A-F]+)(?:\s*\|\s*(.+))?", DscLine)
|
|
if Match:
|
|
ConfigDict['space'] = Match.group(1)
|
|
ConfigDict['cname'] = Match.group(2)
|
|
if Match.group(3) != '*':
|
|
Hardcode = True
|
|
Offset = int (Match.group(3), 16)
|
|
else:
|
|
AutoAlign = True
|
|
|
|
if Hardcode and AutoAlign:
|
|
print("Hardcode and auto-align mixed mode is not supported by GenCfgOpt")
|
|
raise SystemExit
|
|
ConfigDict['offset'] = Offset
|
|
if ConfigDict['order'] == -1:
|
|
ConfigDict['order'] = ConfigDict['offset'] << 8
|
|
else:
|
|
(Major, Minor) = ConfigDict['order'].split('.')
|
|
ConfigDict['order'] = (int (Major, 16) << 8 ) + int (Minor, 16)
|
|
if IsUpdSect:
|
|
Value = Match.group(5).strip()
|
|
if Match.group(4).startswith("0x"):
|
|
Length = int (Match.group(4), 16)
|
|
else :
|
|
Length = int (Match.group(4))
|
|
Offset += Length
|
|
else:
|
|
Value = Match.group(4)
|
|
if Value is None:
|
|
Value = ''
|
|
Value = Value.strip()
|
|
if '|' in Value:
|
|
Match = re.match("^.+\s*\|\s*(.+)", Value)
|
|
if Match:
|
|
Value = Match.group(1)
|
|
Length = -1
|
|
|
|
ConfigDict['length'] = Length
|
|
Match = re.match("\$\((\w+)\)", Value)
|
|
if Match:
|
|
if Match.group(1) in self._MacroDict:
|
|
Value = self._MacroDict[Match.group(1)]
|
|
|
|
ConfigDict['value'] = Value
|
|
if (len(Value) > 0) and (Value[0] == '{'):
|
|
Value = self.FormatListValue(ConfigDict)
|
|
|
|
if ConfigDict['name'] == '':
|
|
# Clear BSF specific items
|
|
ConfigDict['bsfname'] = ''
|
|
ConfigDict['help'] = ''
|
|
ConfigDict['type'] = ''
|
|
ConfigDict['option'] = ''
|
|
if IsUpdSect and AutoAlign:
|
|
ItemLength = int(ConfigDict['length'])
|
|
ItemOffset = int(ConfigDict['offset'])
|
|
ItemStruct = ConfigDict['struct']
|
|
Unit = 1
|
|
if ItemLength in [1, 2, 4, 8] and not ConfigDict['value'].startswith('{'):
|
|
Unit = ItemLength
|
|
# If there are 64 bit unit, align to 64
|
|
if Unit == 8:
|
|
MaxAlign = 64
|
|
SizeAlign = 8
|
|
if ItemStruct != '':
|
|
UnitDict = {'UINT8':1, 'UINT16':2, 'UINT32':4, 'UINT64':8}
|
|
if ItemStruct in ['UINT8', 'UINT16', 'UINT32', 'UINT64']:
|
|
Unit = UnitDict[ItemStruct]
|
|
# If there are 64 bit unit, align to 64
|
|
if Unit == 8:
|
|
MaxAlign = 64
|
|
SizeAlign = max(SizeAlign, Unit)
|
|
if (ConfigDict['embed'].find(':START') != -1):
|
|
Base = ItemOffset
|
|
SubOffset = ItemOffset - Base
|
|
SubRemainder = SubOffset % Unit
|
|
if SubRemainder:
|
|
Diff = Unit - SubRemainder
|
|
Offset = Offset + Diff
|
|
ItemOffset = ItemOffset + Diff
|
|
|
|
if (ConfigDict['embed'].find(':END') != -1):
|
|
Remainder = Offset % (MaxAlign/8) # MaxAlign is either 32 or 64
|
|
if Remainder:
|
|
Diff = int((MaxAlign/8) - Remainder)
|
|
Offset = Offset + Diff
|
|
ItemOffset = ItemOffset + Diff
|
|
MaxAlign = 32 # Reset to default 32 align when struct end
|
|
if (ConfigDict['cname'] == 'UpdTerminator'):
|
|
# ItemLength is the size of UpdTerminator
|
|
# Itemlength might be 16, 32, or 64
|
|
# Struct align to 64 if UpdTerminator
|
|
# or struct size is 64 bit, else align to 32
|
|
Remainder = Offset % max(ItemLength/8, 4, SizeAlign)
|
|
Offset = Offset + ItemLength
|
|
if Remainder:
|
|
Diff = int(max(ItemLength/8, 4, SizeAlign) - Remainder)
|
|
ItemOffset = ItemOffset + Diff
|
|
ConfigDict['offset'] = ItemOffset
|
|
|
|
self._CfgItemList.append(ConfigDict.copy())
|
|
ConfigDict['name'] = ''
|
|
ConfigDict['find'] = ''
|
|
ConfigDict['struct'] = ''
|
|
ConfigDict['embed'] = ''
|
|
ConfigDict['comment'] = ''
|
|
ConfigDict['marker'] = ''
|
|
ConfigDict['order'] = -1
|
|
ConfigDict['subreg'] = []
|
|
ConfigDict['option'] = ''
|
|
else:
|
|
# It could be a virtual item as below
|
|
# !BSF FIELD:{SerialDebugPortAddress0:1}
|
|
# or
|
|
# @Bsf FIELD:{SerialDebugPortAddress0:1b}
|
|
Match = re.match("^\s*#\s+(!BSF|@Bsf)\s+FIELD:{(.+):(\d+)([Bb])?}", DscLine)
|
|
if Match:
|
|
SubCfgDict = ConfigDict.copy()
|
|
if (Match.group(4) == None) or (Match.group(4) == 'B'):
|
|
UnitBitLen = 8
|
|
elif Match.group(4) == 'b':
|
|
UnitBitLen = 1
|
|
else:
|
|
print("ERROR: Invalide BSF FIELD length for line '%s'" % DscLine)
|
|
raise SystemExit
|
|
SubCfgDict['cname'] = Match.group(2)
|
|
SubCfgDict['bitlength'] = int (Match.group(3)) * UnitBitLen
|
|
if SubCfgDict['bitlength'] > 0:
|
|
LastItem = self._CfgItemList[-1]
|
|
if len(LastItem['subreg']) == 0:
|
|
SubOffset = 0
|
|
else:
|
|
SubOffset = LastItem['subreg'][-1]['bitoffset'] + LastItem['subreg'][-1]['bitlength']
|
|
SubCfgDict['bitoffset'] = SubOffset
|
|
LastItem['subreg'].append (SubCfgDict.copy())
|
|
ConfigDict['name'] = ''
|
|
return Error
|
|
|
|
def GetBsfBitFields (self, subitem, bytes):
|
|
start = subitem['bitoffset']
|
|
end = start + subitem['bitlength']
|
|
bitsvalue = ''.join('{0:08b}'.format(i) for i in bytes[::-1])
|
|
bitsvalue = bitsvalue[::-1]
|
|
bitslen = len(bitsvalue)
|
|
if start > bitslen or end > bitslen:
|
|
raise Exception ("Invalid bits offset [%d,%d] %d for %s" % (start, end, bitslen, subitem['name']))
|
|
return '0x%X' % (int(bitsvalue[start:end][::-1], 2))
|
|
|
|
def UpdateSubRegionDefaultValue (self):
|
|
Error = 0
|
|
for Item in self._CfgItemList:
|
|
if len(Item['subreg']) == 0:
|
|
continue
|
|
bytearray = []
|
|
if Item['value'][0] == '{':
|
|
binlist = Item['value'][1:-1].split(',')
|
|
for each in binlist:
|
|
each = each.strip()
|
|
if each.startswith('0x'):
|
|
value = int(each, 16)
|
|
else:
|
|
value = int(each)
|
|
bytearray.append(value)
|
|
else:
|
|
if Item['value'].startswith('0x'):
|
|
value = int(Item['value'], 16)
|
|
else:
|
|
value = int(Item['value'])
|
|
idx = 0
|
|
while idx < Item['length']:
|
|
bytearray.append(value & 0xFF)
|
|
value = value >> 8
|
|
idx = idx + 1
|
|
for SubItem in Item['subreg']:
|
|
valuestr = self.GetBsfBitFields(SubItem, bytearray)
|
|
SubItem['value'] = valuestr
|
|
return Error
|
|
|
|
def NoDscFileChange (self, OutPutFile):
|
|
NoFileChange = True
|
|
if not os.path.exists(OutPutFile):
|
|
NoFileChange = False
|
|
else:
|
|
OutputTime = os.path.getmtime(OutPutFile)
|
|
if self._DscTime > OutputTime:
|
|
NoFileChange = False
|
|
return NoFileChange
|
|
|
|
def CreateSplitUpdTxt (self, UpdTxtFile):
|
|
GuidList = ['FSP_T_UPD_TOOL_GUID','FSP_M_UPD_TOOL_GUID','FSP_S_UPD_TOOL_GUID']
|
|
SignatureList = ['0x545F', '0x4D5F','0x535F'] # _T, _M, and _S signature for FSPT, FSPM, FSPS
|
|
for Index in range(len(GuidList)):
|
|
UpdTxtFile = ''
|
|
FvDir = self._FvDir
|
|
if GuidList[Index] not in self._MacroDict:
|
|
self.Error = "%s definition is missing in DSC file" % (GuidList[Index])
|
|
return 1
|
|
|
|
if UpdTxtFile == '':
|
|
UpdTxtFile = os.path.join(FvDir, self._MacroDict[GuidList[Index]] + '.txt')
|
|
|
|
if (self.NoDscFileChange (UpdTxtFile)):
|
|
# DSC has not been modified yet
|
|
# So don't have to re-generate other files
|
|
self.Error = 'No DSC file change, skip to create UPD TXT file'
|
|
return 256
|
|
|
|
TxtFd = open(UpdTxtFile, "w")
|
|
TxtFd.write("%s\n" % (__copyright_txt__ % date.today().year))
|
|
|
|
NextOffset = 0
|
|
SpaceIdx = 0
|
|
StartAddr = 0
|
|
EndAddr = 0
|
|
Default = 'DEFAULT|'
|
|
InRange = False
|
|
for Item in self._CfgItemList:
|
|
if Item['cname'] == 'Signature' and str(Item['value'])[0:6] == SignatureList[Index]:
|
|
StartAddr = Item['offset']
|
|
NextOffset = StartAddr
|
|
InRange = True
|
|
if Item['cname'] == 'UpdTerminator' and InRange == True:
|
|
EndAddr = Item['offset']
|
|
InRange = False
|
|
InRange = False
|
|
for Item in self._CfgItemList:
|
|
if Item['cname'] == 'Signature' and str(Item['value'])[0:6] == SignatureList[Index]:
|
|
InRange = True
|
|
if InRange != True:
|
|
continue
|
|
if Item['cname'] == 'UpdTerminator':
|
|
InRange = False
|
|
if Item['region'] != 'UPD':
|
|
continue
|
|
Offset = Item['offset']
|
|
if StartAddr > Offset or EndAddr < Offset:
|
|
continue
|
|
if NextOffset < Offset:
|
|
# insert one line
|
|
TxtFd.write("%s.UnusedUpdSpace%d|%s0x%04X|0x%04X|{0}\n" % (Item['space'], SpaceIdx, Default, NextOffset - StartAddr, Offset - NextOffset))
|
|
SpaceIdx = SpaceIdx + 1
|
|
NextOffset = Offset + Item['length']
|
|
TxtFd.write("%s.%s|%s0x%04X|%s|%s\n" % (Item['space'],Item['cname'],Default,Item['offset'] - StartAddr,Item['length'],Item['value']))
|
|
TxtFd.close()
|
|
return 0
|
|
|
|
def CreateVarDict (self):
|
|
Error = 0
|
|
self._VarDict = {}
|
|
if len(self._CfgItemList) > 0:
|
|
Item = self._CfgItemList[-1]
|
|
self._VarDict['_LENGTH_'] = '%d' % (Item['offset'] + Item['length'])
|
|
for Item in self._CfgItemList:
|
|
Embed = Item['embed']
|
|
Match = re.match("^(\w+):(\w+):(START|END)", Embed)
|
|
if Match:
|
|
StructName = Match.group(1)
|
|
VarName = '_%s_%s_' % (Match.group(3), StructName)
|
|
if Match.group(3) == 'END':
|
|
self._VarDict[VarName] = Item['offset'] + Item['length']
|
|
self._VarDict['_LENGTH_%s_' % StructName] = \
|
|
self._VarDict['_END_%s_' % StructName] - self._VarDict['_START_%s_' % StructName]
|
|
if Match.group(2).startswith('TAG_'):
|
|
if (self.Mode != 'FSP') and (self._VarDict['_LENGTH_%s_' % StructName] % 4):
|
|
raise Exception("Size of structure '%s' is %d, not DWORD aligned !" % (StructName, self._VarDict['_LENGTH_%s_' % StructName]))
|
|
self._VarDict['_TAG_%s_' % StructName] = int (Match.group(2)[4:], 16) & 0xFFF
|
|
else:
|
|
self._VarDict[VarName] = Item['offset']
|
|
if Item['marker']:
|
|
self._VarDict['_OFFSET_%s_' % Item['marker'].strip()] = Item['offset']
|
|
return Error
|
|
|
|
def UpdateBsfBitUnit (self, Item):
|
|
BitTotal = 0
|
|
BitOffset = 0
|
|
StartIdx = 0
|
|
Unit = None
|
|
UnitDec = {1:'BYTE', 2:'WORD', 4:'DWORD', 8:'QWORD'}
|
|
for Idx, SubItem in enumerate(Item['subreg']):
|
|
if Unit is None:
|
|
Unit = SubItem['bitunit']
|
|
BitLength = SubItem['bitlength']
|
|
BitTotal += BitLength
|
|
BitOffset += BitLength
|
|
|
|
if BitOffset > 64 or BitOffset > Unit * 8:
|
|
break
|
|
|
|
if BitOffset == Unit * 8:
|
|
for SubIdx in range (StartIdx, Idx + 1):
|
|
Item['subreg'][SubIdx]['bitunit'] = Unit
|
|
BitOffset = 0
|
|
StartIdx = Idx + 1
|
|
Unit = None
|
|
|
|
if BitOffset > 0:
|
|
raise Exception ("Bit fields cannot fit into %s for '%s.%s' !" % (UnitDec[Unit], Item['cname'], SubItem['cname']))
|
|
|
|
ExpectedTotal = Item['length'] * 8
|
|
if Item['length'] * 8 != BitTotal:
|
|
raise Exception ("Bit fields total length (%d) does not match length (%d) of '%s' !" % (BitTotal, ExpectedTotal, Item['cname']))
|
|
|
|
def UpdateDefaultValue (self):
|
|
Error = 0
|
|
for Idx, Item in enumerate(self._CfgItemList):
|
|
if len(Item['subreg']) == 0:
|
|
Value = Item['value']
|
|
if (len(Value) > 0) and (Value[0] == '{' or Value[0] == "'" or Value[0] == '"'):
|
|
# {XXX} or 'XXX' strings
|
|
self.FormatListValue(self._CfgItemList[Idx])
|
|
else:
|
|
Match = re.match("(0x[0-9a-fA-F]+|[0-9]+)", Value)
|
|
if not Match:
|
|
NumValue = self.EvaluateExpress (Value)
|
|
Item['value'] = '0x%X' % NumValue
|
|
else:
|
|
ValArray = self.ValueToByteArray (Item['value'], Item['length'])
|
|
for SubItem in Item['subreg']:
|
|
SubItem['value'] = self.GetBsfBitFields(SubItem, ValArray)
|
|
self.UpdateBsfBitUnit (Item)
|
|
return Error
|
|
|
|
def ProcessMultilines (self, String, MaxCharLength):
|
|
Multilines = ''
|
|
StringLength = len(String)
|
|
CurrentStringStart = 0
|
|
StringOffset = 0
|
|
BreakLineDict = []
|
|
if len(String) <= MaxCharLength:
|
|
while (StringOffset < StringLength):
|
|
if StringOffset >= 1:
|
|
if String[StringOffset - 1] == '\\' and String[StringOffset] == 'n':
|
|
BreakLineDict.append (StringOffset + 1)
|
|
StringOffset += 1
|
|
if BreakLineDict != []:
|
|
for Each in BreakLineDict:
|
|
Multilines += " %s\n" % String[CurrentStringStart:Each].lstrip()
|
|
CurrentStringStart = Each
|
|
if StringLength - CurrentStringStart > 0:
|
|
Multilines += " %s\n" % String[CurrentStringStart:].lstrip()
|
|
else:
|
|
Multilines = " %s\n" % String
|
|
else:
|
|
NewLineStart = 0
|
|
NewLineCount = 0
|
|
FoundSpaceChar = False
|
|
while (StringOffset < StringLength):
|
|
if StringOffset >= 1:
|
|
if NewLineCount >= MaxCharLength - 1:
|
|
if String[StringOffset] == ' ' and StringLength - StringOffset > 10:
|
|
BreakLineDict.append (NewLineStart + NewLineCount)
|
|
NewLineStart = NewLineStart + NewLineCount
|
|
NewLineCount = 0
|
|
FoundSpaceChar = True
|
|
elif StringOffset == StringLength - 1 and FoundSpaceChar == False:
|
|
BreakLineDict.append (0)
|
|
if String[StringOffset - 1] == '\\' and String[StringOffset] == 'n':
|
|
BreakLineDict.append (StringOffset + 1)
|
|
NewLineStart = StringOffset + 1
|
|
NewLineCount = 0
|
|
StringOffset += 1
|
|
NewLineCount += 1
|
|
if BreakLineDict != []:
|
|
BreakLineDict.sort ()
|
|
for Each in BreakLineDict:
|
|
if Each > 0:
|
|
Multilines += " %s\n" % String[CurrentStringStart:Each].lstrip()
|
|
CurrentStringStart = Each
|
|
if StringLength - CurrentStringStart > 0:
|
|
Multilines += " %s\n" % String[CurrentStringStart:].lstrip()
|
|
return Multilines
|
|
|
|
def CreateField (self, Item, Name, Length, Offset, Struct, BsfName, Help, Option, BitsLength = None):
|
|
PosName = 28
|
|
PosComment = 30
|
|
NameLine=''
|
|
HelpLine=''
|
|
OptionLine=''
|
|
|
|
if Length == 0 and Name == 'Dummy':
|
|
return '\n'
|
|
|
|
IsArray = False
|
|
if Length in [1,2,4,8]:
|
|
Type = "UINT%d" % (Length * 8)
|
|
if Name.startswith("UnusedUpdSpace") and Length != 1:
|
|
IsArray = True
|
|
Type = "UINT8"
|
|
else:
|
|
IsArray = True
|
|
Type = "UINT8"
|
|
|
|
if Item and Item['value'].startswith('{'):
|
|
Type = "UINT8"
|
|
IsArray = True
|
|
|
|
if Struct != '':
|
|
Type = Struct
|
|
if Struct in ['UINT8','UINT16','UINT32','UINT64']:
|
|
IsArray = True
|
|
Unit = int(Type[4:]) / 8
|
|
Length = Length / Unit
|
|
else:
|
|
IsArray = False
|
|
|
|
if IsArray:
|
|
Name = Name + '[%d]' % Length
|
|
|
|
if len(Type) < PosName:
|
|
Space1 = PosName - len(Type)
|
|
else:
|
|
Space1 = 1
|
|
|
|
if BsfName != '':
|
|
NameLine=" - %s\n" % BsfName
|
|
else:
|
|
NameLine="\n"
|
|
|
|
if Help != '':
|
|
HelpLine = self.ProcessMultilines (Help, 80)
|
|
|
|
if Option != '':
|
|
OptionLine = self.ProcessMultilines (Option, 80)
|
|
|
|
if Offset is None:
|
|
OffsetStr = '????'
|
|
else:
|
|
OffsetStr = '0x%04X' % Offset
|
|
|
|
if BitsLength is None:
|
|
BitsLength = ''
|
|
else:
|
|
BitsLength = ' : %d' % BitsLength
|
|
|
|
return "\n/** Offset %s%s%s%s**/\n %s%s%s%s;\n" % (OffsetStr, NameLine, HelpLine, OptionLine, Type, ' ' * Space1, Name, BitsLength)
|
|
|
|
def PostProcessBody (self, TextBody):
|
|
NewTextBody = []
|
|
OldTextBody = []
|
|
IncludeLine = False
|
|
StructName = ''
|
|
VariableName = ''
|
|
IsUpdHdrDefined = False
|
|
IsUpdHeader = False
|
|
for Line in TextBody:
|
|
SplitToLines = Line.splitlines()
|
|
MatchComment = re.match("^/\*\sCOMMENT:(\w+):([\w|\W|\s]+)\s\*/\s([\s\S]*)", SplitToLines[0])
|
|
if MatchComment:
|
|
if MatchComment.group(1) == 'FSP_UPD_HEADER':
|
|
IsUpdHeader = True
|
|
else:
|
|
IsUpdHeader = False
|
|
if IsUpdHdrDefined != True or IsUpdHeader != True:
|
|
CommentLine = " " + MatchComment.group(2) + "\n"
|
|
NewTextBody.append("/**" + CommentLine + "**/\n")
|
|
Line = Line[(len(SplitToLines[0]) + 1):]
|
|
|
|
Match = re.match("^/\*\sEMBED_STRUCT:(\w+):(\w+):(START|END)\s\*/\s([\s\S]*)", Line)
|
|
if Match:
|
|
Line = Match.group(4)
|
|
if Match.group(1) == 'FSP_UPD_HEADER':
|
|
IsUpdHeader = True
|
|
else:
|
|
IsUpdHeader = False
|
|
|
|
if Match and Match.group(3) == 'START':
|
|
if IsUpdHdrDefined != True or IsUpdHeader != True:
|
|
NewTextBody.append ('typedef struct {\n')
|
|
StructName = Match.group(1)
|
|
VariableName = Match.group(2)
|
|
MatchOffset = re.search('/\*\*\sOffset\s0x([a-fA-F0-9]+)', Line)
|
|
if MatchOffset:
|
|
Offset = int(MatchOffset.group(1), 16)
|
|
else:
|
|
Offset = None
|
|
Line
|
|
IncludeLine = True
|
|
OldTextBody.append (self.CreateField (None, VariableName, 0, Offset, StructName, '', '', ''))
|
|
if IncludeLine:
|
|
if IsUpdHdrDefined != True or IsUpdHeader != True:
|
|
NewTextBody.append (Line)
|
|
else:
|
|
OldTextBody.append (Line)
|
|
|
|
if Match and Match.group(3) == 'END':
|
|
if (StructName != Match.group(1)) or (VariableName != Match.group(2)):
|
|
print ("Unmatched struct name '%s' and '%s' !" % (StructName, Match.group(1)))
|
|
else:
|
|
if IsUpdHdrDefined != True or IsUpdHeader != True:
|
|
NewTextBody.append ('} %s;\n\n' % StructName)
|
|
IsUpdHdrDefined = True
|
|
IncludeLine = False
|
|
NewTextBody.extend(OldTextBody)
|
|
return NewTextBody
|
|
|
|
def WriteLinesWithoutTailingSpace (self, HeaderFd, Line):
|
|
TxtBody2 = Line.splitlines(True)
|
|
for Line2 in TxtBody2:
|
|
Line2 = Line2.rstrip()
|
|
Line2 += '\n'
|
|
HeaderFd.write (Line2)
|
|
return 0
|
|
def CreateHeaderFile (self, InputHeaderFile):
|
|
FvDir = self._FvDir
|
|
|
|
HeaderFileName = 'FspUpd.h'
|
|
HeaderFile = os.path.join(FvDir, HeaderFileName)
|
|
|
|
# Check if header needs to be recreated
|
|
if (self.NoDscFileChange (HeaderFile)):
|
|
# DSC has not been modified yet
|
|
# So don't have to re-generate other files
|
|
self.Error = 'No DSC file change, skip to create UPD header file'
|
|
return 256
|
|
|
|
TxtBody = []
|
|
for Item in self._CfgItemList:
|
|
if str(Item['cname']) == 'Signature' and Item['length'] == 8:
|
|
Value = int(Item['value'], 16)
|
|
Chars = []
|
|
while Value != 0x0:
|
|
Chars.append(chr(Value & 0xFF))
|
|
Value = Value >> 8
|
|
SignatureStr = ''.join(Chars)
|
|
# Signature will be _T / _M / _S for FSPT / FSPM / FSPS accordingly
|
|
if '_T' in SignatureStr[6:6+2]:
|
|
TxtBody.append("#define FSPT_UPD_SIGNATURE %s /* '%s' */\n\n" % (Item['value'], SignatureStr))
|
|
elif '_M' in SignatureStr[6:6+2]:
|
|
TxtBody.append("#define FSPM_UPD_SIGNATURE %s /* '%s' */\n\n" % (Item['value'], SignatureStr))
|
|
elif '_S' in SignatureStr[6:6+2]:
|
|
TxtBody.append("#define FSPS_UPD_SIGNATURE %s /* '%s' */\n\n" % (Item['value'], SignatureStr))
|
|
TxtBody.append("\n")
|
|
|
|
for Region in ['UPD']:
|
|
UpdOffsetTable = []
|
|
UpdSignature = ['0x545F', '0x4D5F', '0x535F'] #['_T', '_M', '_S'] signature for FSPT, FSPM, FSPS
|
|
UpdStructure = ['FSPT_UPD', 'FSPM_UPD', 'FSPS_UPD']
|
|
for Item in self._CfgItemList:
|
|
if Item["cname"] == 'Signature' and Item["value"][0:6] in UpdSignature:
|
|
Item["offset"] = 0 # re-initialize offset to 0 when new UPD structure starting
|
|
UpdOffsetTable.append (Item["offset"])
|
|
|
|
for UpdIdx in range(len(UpdOffsetTable)):
|
|
CommentLine = ""
|
|
for Item in self._CfgItemList:
|
|
if Item["comment"] != '' and Item["offset"] >= UpdOffsetTable[UpdIdx]:
|
|
MatchComment = re.match("^(U|V)PD_DATA_REGION:([\w|\W|\s]+)", Item["comment"])
|
|
if MatchComment and MatchComment.group(1) == Region[0]:
|
|
CommentLine = " " + MatchComment.group(2) + "\n"
|
|
TxtBody.append("/**" + CommentLine + "**/\n")
|
|
elif Item["offset"] >= UpdOffsetTable[UpdIdx] and Item["comment"] == '':
|
|
Match = re.match("^FSP([\w|\W|\s])_UPD", UpdStructure[UpdIdx])
|
|
if Match:
|
|
TxtBody.append("/** Fsp " + Match.group(1) + " UPD Configuration\n**/\n")
|
|
TxtBody.append("typedef struct {\n")
|
|
NextOffset = 0
|
|
SpaceIdx = 0
|
|
Offset = 0
|
|
|
|
LastVisible = True
|
|
ResvOffset = 0
|
|
ResvIdx = 0
|
|
LineBuffer = []
|
|
InRange = False
|
|
for Item in self._CfgItemList:
|
|
if Item['cname'] == 'Signature' and str(Item['value'])[0:6] == UpdSignature[UpdIdx] or Region[0] == 'V':
|
|
InRange = True
|
|
if InRange != True:
|
|
continue
|
|
if Item['cname'] == 'UpdTerminator':
|
|
InRange = False
|
|
|
|
if Item['region'] != Region:
|
|
continue
|
|
|
|
if Item["offset"] < UpdOffsetTable[UpdIdx]:
|
|
continue
|
|
|
|
NextVisible = LastVisible
|
|
|
|
if LastVisible and (Item['header'] == 'OFF'):
|
|
NextVisible = False
|
|
ResvOffset = Item['offset']
|
|
elif (not LastVisible) and Item['header'] == 'ON':
|
|
NextVisible = True
|
|
Name = "Reserved" + Region[0] + "pdSpace%d" % ResvIdx
|
|
ResvIdx = ResvIdx + 1
|
|
TxtBody.append(self.CreateField (Item, Name, Item["offset"] - ResvOffset, ResvOffset, '', '', '', ''))
|
|
|
|
if Offset < Item["offset"]:
|
|
if LastVisible:
|
|
Name = "Unused" + Region[0] + "pdSpace%d" % SpaceIdx
|
|
LineBuffer.append(self.CreateField (Item, Name, Item["offset"] - Offset, Offset, '', '', '', ''))
|
|
SpaceIdx = SpaceIdx + 1
|
|
Offset = Item["offset"]
|
|
|
|
LastVisible = NextVisible
|
|
|
|
Offset = Offset + Item["length"]
|
|
if LastVisible:
|
|
for Each in LineBuffer:
|
|
TxtBody.append (Each)
|
|
LineBuffer = []
|
|
Comment = Item["comment"]
|
|
Embed = Item["embed"].upper()
|
|
if Embed.endswith(':START') or Embed.endswith(':END'):
|
|
if not Comment == '' and Embed.endswith(':START'):
|
|
Marker = '/* COMMENT:%s */ \n' % Item["comment"]
|
|
Marker = Marker + '/* EMBED_STRUCT:%s */ ' % Item["embed"]
|
|
else:
|
|
Marker = '/* EMBED_STRUCT:%s */ ' % Item["embed"]
|
|
else:
|
|
if Embed == '':
|
|
Marker = ''
|
|
else:
|
|
self.Error = "Invalid embedded structure format '%s'!\n" % Item["embed"]
|
|
return 4
|
|
Line = Marker + self.CreateField (Item, Item["cname"], Item["length"], Item["offset"], Item['struct'], Item['name'], Item['help'], Item['option'])
|
|
TxtBody.append(Line)
|
|
if Item['cname'] == 'UpdTerminator':
|
|
break
|
|
TxtBody.append("} " + UpdStructure[UpdIdx] + ";\n\n")
|
|
|
|
# Handle the embedded data structure
|
|
TxtBody = self.PostProcessBody (TxtBody)
|
|
|
|
HeaderTFileName = 'FsptUpd.h'
|
|
HeaderMFileName = 'FspmUpd.h'
|
|
HeaderSFileName = 'FspsUpd.h'
|
|
|
|
UpdRegionCheck = ['FSPT', 'FSPM', 'FSPS'] # FSPX_UPD_REGION
|
|
UpdConfigCheck = ['FSP_T', 'FSP_M', 'FSP_S'] # FSP_X_CONFIG, FSP_X_TEST_CONFIG, FSP_X_RESTRICTED_CONFIG
|
|
UpdSignatureCheck = ['FSPT_UPD_SIGNATURE', 'FSPM_UPD_SIGNATURE', 'FSPS_UPD_SIGNATURE']
|
|
ExcludedSpecificUpd = ['FSPT_ARCH_UPD', 'FSPM_ARCH_UPD', 'FSPS_ARCH_UPD']
|
|
|
|
IncLines = []
|
|
if InputHeaderFile != '':
|
|
if not os.path.exists(InputHeaderFile):
|
|
self.Error = "Input header file '%s' does not exist" % InputHeaderFile
|
|
return 6
|
|
|
|
InFd = open(InputHeaderFile, "r")
|
|
IncLines = InFd.readlines()
|
|
InFd.close()
|
|
|
|
for item in range(len(UpdRegionCheck)):
|
|
if UpdRegionCheck[item] == 'FSPT':
|
|
HeaderFd = open(os.path.join(FvDir, HeaderTFileName), "w")
|
|
FileBase = os.path.basename(os.path.join(FvDir, HeaderTFileName))
|
|
elif UpdRegionCheck[item] == 'FSPM':
|
|
HeaderFd = open(os.path.join(FvDir, HeaderMFileName), "w")
|
|
FileBase = os.path.basename(os.path.join(FvDir, HeaderMFileName))
|
|
elif UpdRegionCheck[item] == 'FSPS':
|
|
HeaderFd = open(os.path.join(FvDir, HeaderSFileName), "w")
|
|
FileBase = os.path.basename(os.path.join(FvDir, HeaderSFileName))
|
|
FileName = FileBase.replace(".", "_").upper()
|
|
HeaderFd.write("%s\n" % (__copyright_h__ % date.today().year))
|
|
HeaderFd.write("#ifndef __%s__\n" % FileName)
|
|
HeaderFd.write("#define __%s__\n\n" % FileName)
|
|
HeaderFd.write("#include <%s>\n\n" % HeaderFileName)
|
|
HeaderFd.write("#pragma pack(1)\n\n")
|
|
|
|
Export = False
|
|
for Line in IncLines:
|
|
Match = re.search ("!EXPORT\s+([A-Z]+)\s+EXTERNAL_BOOTLOADER_STRUCT_(BEGIN|END)\s+", Line)
|
|
if Match:
|
|
if Match.group(2) == "BEGIN" and Match.group(1) == UpdRegionCheck[item]:
|
|
Export = True
|
|
continue
|
|
else:
|
|
Export = False
|
|
continue
|
|
if Export:
|
|
HeaderFd.write(Line)
|
|
HeaderFd.write("\n")
|
|
|
|
Index = 0
|
|
StartIndex = 0
|
|
EndIndex = 0
|
|
StructStart = []
|
|
StructStartWithComment = []
|
|
StructEnd = []
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
Match = re.match("(typedef struct {)", Line)
|
|
if Match:
|
|
StartIndex = Index - 1
|
|
Match = re.match("}\s([_A-Z0-9]+);", Line)
|
|
if Match and (UpdRegionCheck[item] in Match.group(1) or UpdConfigCheck[item] in Match.group(1)) and (ExcludedSpecificUpd[item] not in Match.group(1)):
|
|
EndIndex = Index
|
|
StructStart.append(StartIndex)
|
|
StructEnd.append(EndIndex)
|
|
Index = 0
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
for Item in range(len(StructStart)):
|
|
if Index == StructStart[Item]:
|
|
Match = re.match("^(/\*\*\s*)", Line)
|
|
if Match:
|
|
StructStartWithComment.append(StructStart[Item])
|
|
else:
|
|
StructStartWithComment.append(StructStart[Item] + 1)
|
|
Index = 0
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
for Item in range(len(StructStart)):
|
|
if Index >= StructStartWithComment[Item] and Index <= StructEnd[Item]:
|
|
self.WriteLinesWithoutTailingSpace(HeaderFd, Line)
|
|
HeaderFd.write("#pragma pack()\n\n")
|
|
HeaderFd.write("#endif\n")
|
|
HeaderFd.close()
|
|
|
|
HeaderFd = open(HeaderFile, "w")
|
|
FileBase = os.path.basename(HeaderFile)
|
|
FileName = FileBase.replace(".", "_").upper()
|
|
HeaderFd.write("%s\n" % (__copyright_h__ % date.today().year))
|
|
HeaderFd.write("#ifndef __%s__\n" % FileName)
|
|
HeaderFd.write("#define __%s__\n\n" % FileName)
|
|
HeaderFd.write("#include <FspEas.h>\n\n")
|
|
HeaderFd.write("#pragma pack(1)\n\n")
|
|
|
|
for item in range(len(UpdRegionCheck)):
|
|
Index = 0
|
|
StartIndex = 0
|
|
EndIndex = 0
|
|
StructStart = []
|
|
StructStartWithComment = []
|
|
StructEnd = []
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
Match = re.match("(typedef struct {)", Line)
|
|
if Match:
|
|
StartIndex = Index - 1
|
|
Match = re.match("#define\s([_A-Z0-9]+)\s*", Line)
|
|
if Match and (UpdSignatureCheck[item] in Match.group(1) or UpdSignatureCheck[item] in Match.group(1)):
|
|
StructStart.append(Index - 1)
|
|
StructEnd.append(Index)
|
|
Index = 0
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
for Item in range(len(StructStart)):
|
|
if Index == StructStart[Item]:
|
|
Match = re.match("^(/\*\*\s*)", Line)
|
|
if Match:
|
|
StructStartWithComment.append(StructStart[Item])
|
|
else:
|
|
StructStartWithComment.append(StructStart[Item] + 1)
|
|
Index = 0
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
for Item in range(len(StructStart)):
|
|
if Index >= StructStartWithComment[Item] and Index <= StructEnd[Item]:
|
|
self.WriteLinesWithoutTailingSpace(HeaderFd, Line)
|
|
HeaderFd.write("#pragma pack()\n\n")
|
|
HeaderFd.write("#endif\n")
|
|
HeaderFd.close()
|
|
|
|
return 0
|
|
|
|
def WriteBsfStruct (self, BsfFd, Item):
|
|
LogExpr = CLogicalExpression()
|
|
if Item['type'] == "None":
|
|
Space = "gPlatformFspPkgTokenSpaceGuid"
|
|
else:
|
|
Space = Item['space']
|
|
Line = " $%s_%s" % (Space, Item['cname'])
|
|
Match = re.match("\s*\{([x0-9a-fA-F,\s]+)\}\s*", Item['value'])
|
|
if Match:
|
|
DefaultValue = Match.group(1).strip()
|
|
else:
|
|
DefaultValue = Item['value'].strip()
|
|
if 'bitlength' in Item:
|
|
BsfFd.write(" %s%s%4d bits $_DEFAULT_ = %s\n" % (Line, ' ' * (64 - len(Line)), Item['bitlength'], DefaultValue))
|
|
else:
|
|
BsfFd.write(" %s%s%4d bytes $_DEFAULT_ = %s\n" % (Line, ' ' * (64 - len(Line)), Item['length'], DefaultValue))
|
|
TmpList = []
|
|
if Item['type'] == "Combo":
|
|
if not Item['option'] in self._BuidinOption:
|
|
OptList = Item['option'].split(',')
|
|
for Option in OptList:
|
|
Option = Option.strip()
|
|
(OpVal, OpStr) = Option.split(':')
|
|
test = LogExpr.getNumber (OpVal)
|
|
if test is None:
|
|
raise Exception("Selection Index '%s' is not a number" % OpVal)
|
|
TmpList.append((OpVal, OpStr))
|
|
return TmpList
|
|
|
|
def WriteBsfOption (self, BsfFd, Item):
|
|
PcdName = Item['space'] + '_' + Item['cname']
|
|
WriteHelp = 0
|
|
if Item['type'] == "Combo":
|
|
if Item['option'] in self._BuidinOption:
|
|
Options = self._BuidinOption[Item['option']]
|
|
else:
|
|
Options = PcdName
|
|
BsfFd.write(' %s $%s, "%s", &%s,\n' % (Item['type'], PcdName, Item['name'], Options))
|
|
WriteHelp = 1
|
|
elif Item['type'].startswith("EditNum"):
|
|
Match = re.match("EditNum\s*,\s*(HEX|DEC)\s*,\s*\((\d+|0x[0-9A-Fa-f]+)\s*,\s*(\d+|0x[0-9A-Fa-f]+)\)", Item['type'])
|
|
if Match:
|
|
BsfFd.write(' EditNum $%s, "%s", %s,\n' % (PcdName, Item['name'], Match.group(1)))
|
|
WriteHelp = 2
|
|
elif Item['type'].startswith("EditText"):
|
|
BsfFd.write(' %s $%s, "%s",\n' % (Item['type'], PcdName, Item['name']))
|
|
WriteHelp = 1
|
|
elif Item['type'] == "Table":
|
|
Columns = Item['option'].split(',')
|
|
if len(Columns) != 0:
|
|
BsfFd.write(' %s $%s "%s",' % (Item['type'], PcdName, Item['name']))
|
|
for Col in Columns:
|
|
Fmt = Col.split(':')
|
|
if len(Fmt) != 3:
|
|
raise Exception("Column format '%s' is invalid !" % Fmt)
|
|
try:
|
|
Dtype = int(Fmt[1].strip())
|
|
except:
|
|
raise Exception("Column size '%s' is invalid !" % Fmt[1])
|
|
BsfFd.write('\n Column "%s", %d bytes, %s' % (Fmt[0].strip(), Dtype, Fmt[2].strip()))
|
|
BsfFd.write(',\n')
|
|
WriteHelp = 1
|
|
|
|
if WriteHelp > 0:
|
|
HelpLines = Item['help'].split('\\n\\r')
|
|
FirstLine = True
|
|
for HelpLine in HelpLines:
|
|
if FirstLine:
|
|
FirstLine = False
|
|
BsfFd.write(' Help "%s"\n' % (HelpLine))
|
|
else:
|
|
BsfFd.write(' "%s"\n' % (HelpLine))
|
|
if WriteHelp == 2:
|
|
BsfFd.write(' "Valid range: %s ~ %s"\n' % (Match.group(2), Match.group(3)))
|
|
|
|
def GenerateBsfFile (self, BsfFile):
|
|
|
|
if BsfFile == '':
|
|
self.Error = "BSF output file '%s' is invalid" % BsfFile
|
|
return 1
|
|
|
|
if (self.NoDscFileChange (BsfFile)):
|
|
# DSC has not been modified yet
|
|
# So don't have to re-generate other files
|
|
self.Error = 'No DSC file change, skip to create UPD BSF file'
|
|
return 256
|
|
|
|
Error = 0
|
|
OptionDict = {}
|
|
BsfFd = open(BsfFile, "w")
|
|
BsfFd.write("%s\n" % (__copyright_bsf__ % date.today().year))
|
|
BsfFd.write("%s\n" % self._GlobalDataDef)
|
|
BsfFd.write("StructDef\n")
|
|
NextOffset = -1
|
|
for Item in self._CfgItemList:
|
|
if Item['find'] != '':
|
|
BsfFd.write('\n Find "%s"\n' % Item['find'])
|
|
NextOffset = Item['offset'] + Item['length']
|
|
if Item['name'] != '':
|
|
if NextOffset != Item['offset']:
|
|
BsfFd.write(" Skip %d bytes\n" % (Item['offset'] - NextOffset))
|
|
if len(Item['subreg']) > 0:
|
|
NextOffset = Item['offset']
|
|
BitsOffset = NextOffset * 8
|
|
for SubItem in Item['subreg']:
|
|
BitsOffset += SubItem['bitlength']
|
|
if SubItem['name'] == '':
|
|
if 'bitlength' in SubItem:
|
|
BsfFd.write(" Skip %d bits\n" % (SubItem['bitlength']))
|
|
else:
|
|
BsfFd.write(" Skip %d bytes\n" % (SubItem['length']))
|
|
else:
|
|
Options = self.WriteBsfStruct(BsfFd, SubItem)
|
|
if len(Options) > 0:
|
|
OptionDict[SubItem['space']+'_'+SubItem['cname']] = Options
|
|
|
|
NextBitsOffset = (Item['offset'] + Item['length']) * 8
|
|
if NextBitsOffset > BitsOffset:
|
|
BitsGap = NextBitsOffset - BitsOffset
|
|
BitsRemain = BitsGap % 8
|
|
if BitsRemain:
|
|
BsfFd.write(" Skip %d bits\n" % BitsRemain)
|
|
BitsGap -= BitsRemain
|
|
BytesRemain = int(BitsGap / 8)
|
|
if BytesRemain:
|
|
BsfFd.write(" Skip %d bytes\n" % BytesRemain)
|
|
NextOffset = Item['offset'] + Item['length']
|
|
else:
|
|
NextOffset = Item['offset'] + Item['length']
|
|
Options = self.WriteBsfStruct(BsfFd, Item)
|
|
if len(Options) > 0:
|
|
OptionDict[Item['space']+'_'+Item['cname']] = Options
|
|
BsfFd.write("\nEndStruct\n\n")
|
|
|
|
BsfFd.write("%s" % self._BuidinOptionTxt)
|
|
|
|
for Each in OptionDict:
|
|
BsfFd.write("List &%s\n" % Each)
|
|
for Item in OptionDict[Each]:
|
|
BsfFd.write(' Selection %s , "%s"\n' % (Item[0], Item[1]))
|
|
BsfFd.write("EndList\n\n")
|
|
|
|
BsfFd.write("BeginInfoBlock\n")
|
|
BsfFd.write(' PPVer "%s"\n' % (self._CfgBlkDict['ver']))
|
|
BsfFd.write(' Description "%s"\n' % (self._CfgBlkDict['name']))
|
|
BsfFd.write("EndInfoBlock\n\n")
|
|
|
|
for Each in self._CfgPageDict:
|
|
BsfFd.write('Page "%s"\n' % self._CfgPageDict[Each])
|
|
BsfItems = []
|
|
for Item in self._CfgItemList:
|
|
if Item['name'] != '':
|
|
if Item['page'] != Each:
|
|
continue
|
|
if len(Item['subreg']) > 0:
|
|
for SubItem in Item['subreg']:
|
|
if SubItem['name'] != '':
|
|
BsfItems.append(SubItem)
|
|
else:
|
|
BsfItems.append(Item)
|
|
|
|
BsfItems.sort(key=lambda x: x['order'])
|
|
|
|
for Item in BsfItems:
|
|
self.WriteBsfOption (BsfFd, Item)
|
|
BsfFd.write("EndPage\n\n")
|
|
|
|
BsfFd.close()
|
|
return Error
|
|
|
|
|
|
def Usage():
|
|
print ("GenCfgOpt Version 0.56")
|
|
print ("Usage:")
|
|
print (" GenCfgOpt UPDTXT PlatformDscFile BuildFvDir [-D Macros]")
|
|
print (" GenCfgOpt HEADER PlatformDscFile BuildFvDir InputHFile [-D Macros]")
|
|
print (" GenCfgOpt GENBSF PlatformDscFile BuildFvDir BsfOutFile [-D Macros]")
|
|
|
|
def Main():
|
|
#
|
|
# Parse the options and args
|
|
#
|
|
i = 1
|
|
|
|
GenCfgOpt = CGenCfgOpt()
|
|
while i < len(sys.argv):
|
|
if sys.argv[i].strip().lower() == "--pcd":
|
|
BuildOptionPcd.append(sys.argv[i+1])
|
|
i += 1
|
|
i += 1
|
|
argc = len(sys.argv)
|
|
if argc < 4:
|
|
Usage()
|
|
return 1
|
|
else:
|
|
DscFile = sys.argv[2]
|
|
if not os.path.exists(DscFile):
|
|
print ("ERROR: Cannot open DSC file '%s' !" % DscFile)
|
|
return 2
|
|
|
|
OutFile = ''
|
|
if argc > 4:
|
|
if sys.argv[4][0] == '-':
|
|
Start = 4
|
|
else:
|
|
OutFile = sys.argv[4]
|
|
Start = 5
|
|
if argc > Start:
|
|
if GenCfgOpt.ParseMacros(sys.argv[Start:]) != 0:
|
|
print ("ERROR: Macro parsing failed !")
|
|
return 3
|
|
|
|
FvDir = sys.argv[3]
|
|
if not os.path.exists(FvDir):
|
|
os.makedirs(FvDir)
|
|
|
|
if GenCfgOpt.ParseDscFile(DscFile, FvDir) != 0:
|
|
print ("ERROR: %s !" % GenCfgOpt.Error)
|
|
return 5
|
|
|
|
if GenCfgOpt.UpdateSubRegionDefaultValue() != 0:
|
|
print ("ERROR: %s !" % GenCfgOpt.Error)
|
|
return 7
|
|
|
|
if sys.argv[1] == "UPDTXT":
|
|
Ret = GenCfgOpt.CreateSplitUpdTxt(OutFile)
|
|
if Ret != 0:
|
|
# No change is detected
|
|
if Ret == 256:
|
|
print ("INFO: %s !" % (GenCfgOpt.Error))
|
|
else :
|
|
print ("ERROR: %s !" % (GenCfgOpt.Error))
|
|
return Ret
|
|
elif sys.argv[1] == "HEADER":
|
|
Ret = GenCfgOpt.CreateHeaderFile(OutFile)
|
|
if Ret != 0:
|
|
# No change is detected
|
|
if Ret == 256:
|
|
print ("INFO: %s !" % (GenCfgOpt.Error))
|
|
else :
|
|
print ("ERROR: %s !" % (GenCfgOpt.Error))
|
|
return 8
|
|
return Ret
|
|
elif sys.argv[1] == "GENBSF":
|
|
Ret = GenCfgOpt.GenerateBsfFile(OutFile)
|
|
if Ret != 0:
|
|
# No change is detected
|
|
if Ret == 256:
|
|
print ("INFO: %s !" % (GenCfgOpt.Error))
|
|
else :
|
|
print ("ERROR: %s !" % (GenCfgOpt.Error))
|
|
return 9
|
|
return Ret
|
|
else:
|
|
if argc < 5:
|
|
Usage()
|
|
return 1
|
|
print ("ERROR: Unknown command '%s' !" % sys.argv[1])
|
|
Usage()
|
|
return 1
|
|
return 0
|
|
return 0
|
|
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(Main())
|