X-Git-Url: https://git.proxmox.com/?p=mirror_edk2.git;a=blobdiff_plain;f=BaseTools%2FSource%2FPython%2FCommon%2FExpression.py;h=ccc736846afa94cd70dbfd0237acd7e3b6e35d91;hp=d7903c98b1d65ff90e9c923534dc66060ff4c899;hb=f3fc5b47ad195dd9e2b644cb294448a386e18a53;hpb=b2aeaf573ee5454c4dc3227da696286cdba35ac1 diff --git a/BaseTools/Source/Python/Common/Expression.py b/BaseTools/Source/Python/Common/Expression.py index d7903c98b1..ccc736846a 100644 --- a/BaseTools/Source/Python/Common/Expression.py +++ b/BaseTools/Source/Python/Common/Expression.py @@ -12,13 +12,16 @@ ## Import Modules # +from __future__ import print_function +from __future__ import absolute_import from Common.GlobalData import * from CommonDataClass.Exceptions import BadExpression from CommonDataClass.Exceptions import WrnExpression -from Misc import GuidStringToGuidStructureString, ParseFieldValue, IsFieldValueAnArray +from .Misc import GuidStringToGuidStructureString, ParseFieldValue, IsFieldValueAnArray import Common.EdkLogger as EdkLogger import copy from Common.DataType import * +import sys ERR_STRING_EXPR = 'This operator cannot be used in string expression: [%s].' ERR_SNYTAX = 'Syntax error, the rest of expression cannot be evaluated: [%s].' @@ -171,7 +174,7 @@ def ReplaceExprMacro(String, Macros, ExceptionList = None): RetStr += '0' elif not InQuote: Tklst = RetStr.split() - if Tklst and Tklst[-1] in ['IN', 'in'] and ExceptionList and Macro not in ExceptionList: + if Tklst and Tklst[-1] in {'IN', 'in'} and ExceptionList and Macro not in ExceptionList: raise BadExpression(ERR_IN_OPERAND) # Make sure the macro in exception list is encapsulated by double quote # For example: DEFINE ARCH = IA32 X64 @@ -243,35 +246,36 @@ class ValueExpression(BaseExpression): def Eval(Operator, Oprand1, Oprand2 = None): WrnExp = None - if Operator not in ["==", "!=", ">=", "<=", ">", "<", "in", "not in"] and \ - (type(Oprand1) == type('') or type(Oprand2) == type('')): + if Operator not in {"==", "!=", ">=", "<=", ">", "<", "in", "not in"} and \ + (isinstance(Oprand1, type('')) or isinstance(Oprand2, type(''))): raise BadExpression(ERR_STRING_EXPR % Operator) - if Operator in ['in', 'not in']: - if type(Oprand1) != type(''): + if Operator in {'in', 'not in'}: + if not isinstance(Oprand1, type('')): Oprand1 = IntToStr(Oprand1) - if type(Oprand2) != type(''): + if not isinstance(Oprand2, type('')): Oprand2 = IntToStr(Oprand2) TypeDict = { type(0) : 0, - type(0L) : 0, + # For python2 long type + type(sys.maxsize + 1) : 0, type('') : 1, type(True) : 2 } EvalStr = '' - if Operator in ["!", "NOT", "not"]: - if type(Oprand1) == type(''): + if Operator in {"!", "NOT", "not"}: + if isinstance(Oprand1, type('')): raise BadExpression(ERR_STRING_EXPR % Operator) EvalStr = 'not Oprand1' - elif Operator in ["~"]: - if type(Oprand1) == type(''): + elif Operator in {"~"}: + if isinstance(Oprand1, type('')): raise BadExpression(ERR_STRING_EXPR % Operator) EvalStr = '~ Oprand1' else: - if Operator in ["+", "-"] and (type(True) in [type(Oprand1), type(Oprand2)]): + if Operator in {"+", "-"} and (type(True) in {type(Oprand1), type(Oprand2)}): # Boolean in '+'/'-' will be evaluated but raise warning WrnExp = WrnExpression(WRN_BOOL_EXPR) - elif type('') in [type(Oprand1), type(Oprand2)] and type(Oprand1)!= type(Oprand2): + elif type('') in {type(Oprand1), type(Oprand2)} and not isinstance(Oprand1, type(Oprand2)): # == between string and number/boolean will always return False, != return True if Operator == "==": WrnExp = WrnExpression(WRN_EQCMP_STR_OTHERS) @@ -284,19 +288,19 @@ class ValueExpression(BaseExpression): else: raise BadExpression(ERR_RELCMP_STR_OTHERS % Operator) elif TypeDict[type(Oprand1)] != TypeDict[type(Oprand2)]: - if Operator in ["==", "!=", ">=", "<=", ">", "<"] and set((TypeDict[type(Oprand1)], TypeDict[type(Oprand2)])) == set((TypeDict[type(True)], TypeDict[type(0)])): + if Operator in {"==", "!=", ">=", "<=", ">", "<"} and set((TypeDict[type(Oprand1)], TypeDict[type(Oprand2)])) == set((TypeDict[type(True)], TypeDict[type(0)])): # comparison between number and boolean is allowed pass - elif Operator in ['&', '|', '^', "and", "or"] and set((TypeDict[type(Oprand1)], TypeDict[type(Oprand2)])) == set((TypeDict[type(True)], TypeDict[type(0)])): + elif Operator in {'&', '|', '^', "and", "or"} and set((TypeDict[type(Oprand1)], TypeDict[type(Oprand2)])) == set((TypeDict[type(True)], TypeDict[type(0)])): # bitwise and logical operation between number and boolean is allowed pass else: raise BadExpression(ERR_EXPR_TYPE) - if type(Oprand1) == type('') and type(Oprand2) == type(''): + if isinstance(Oprand1, type('')) and isinstance(Oprand2, type('')): if (Oprand1.startswith('L"') and not Oprand2.startswith('L"')) or \ (not Oprand1.startswith('L"') and Oprand2.startswith('L"')): raise BadExpression(ERR_STRING_CMP % (Oprand1, Operator, Oprand2)) - if 'in' in Operator and type(Oprand2) == type(''): + if 'in' in Operator and isinstance(Oprand2, type('')): Oprand2 = Oprand2.split() EvalStr = 'Oprand1 ' + Operator + ' Oprand2' @@ -307,10 +311,10 @@ class ValueExpression(BaseExpression): } try: Val = eval(EvalStr, {}, Dict) - except Exception, Excpt: + except Exception as Excpt: raise BadExpression(str(Excpt)) - if Operator in ['and', 'or']: + if Operator in {'and', 'or'}: if Val: Val = True else: @@ -324,7 +328,7 @@ class ValueExpression(BaseExpression): def __init__(self, Expression, SymbolTable={}): super(ValueExpression, self).__init__(self, Expression, SymbolTable) self._NoProcess = False - if type(Expression) != type(''): + if not isinstance(Expression, type('')): self._Expr = Expression self._NoProcess = True return @@ -372,7 +376,7 @@ class ValueExpression(BaseExpression): Token = self._GetToken() except BadExpression: pass - if type(Token) == type('') and Token.startswith('{') and Token.endswith('}') and self._Idx >= self._Len: + if isinstance(Token, type('')) and Token.startswith('{') and Token.endswith('}') and self._Idx >= self._Len: return self._Expr self._Idx = 0 @@ -380,7 +384,7 @@ class ValueExpression(BaseExpression): Val = self._ConExpr() RealVal = Val - if type(Val) == type(''): + if isinstance(Val, type('')): if Val == 'L""': Val = False elif not Val: @@ -410,13 +414,13 @@ class ValueExpression(BaseExpression): # Template function to parse binary operators which have same precedence # Expr [Operator Expr]* - def _ExprFuncTemplate(self, EvalFunc, OpLst): + def _ExprFuncTemplate(self, EvalFunc, OpSet): Val = EvalFunc() - while self._IsOperator(OpLst): + while self._IsOperator(OpSet): Op = self._Token if Op == '?': Val2 = EvalFunc() - if self._IsOperator(':'): + if self._IsOperator({':'}): Val3 = EvalFunc() if Val: Val = Val2 @@ -425,79 +429,79 @@ class ValueExpression(BaseExpression): continue try: Val = self.Eval(Op, Val, EvalFunc()) - except WrnExpression, Warn: + except WrnExpression as Warn: self._WarnExcept = Warn Val = Warn.result return Val # A [? B]* def _ConExpr(self): - return self._ExprFuncTemplate(self._OrExpr, ['?', ':']) + return self._ExprFuncTemplate(self._OrExpr, {'?', ':'}) # A [|| B]* def _OrExpr(self): - return self._ExprFuncTemplate(self._AndExpr, ["OR", "or", "||"]) + return self._ExprFuncTemplate(self._AndExpr, {"OR", "or", "||"}) # A [&& B]* def _AndExpr(self): - return self._ExprFuncTemplate(self._BitOr, ["AND", "and", "&&"]) + return self._ExprFuncTemplate(self._BitOr, {"AND", "and", "&&"}) # A [ | B]* def _BitOr(self): - return self._ExprFuncTemplate(self._BitXor, ["|"]) + return self._ExprFuncTemplate(self._BitXor, {"|"}) # A [ ^ B]* def _BitXor(self): - return self._ExprFuncTemplate(self._BitAnd, ["XOR", "xor", "^"]) + return self._ExprFuncTemplate(self._BitAnd, {"XOR", "xor", "^"}) # A [ & B]* def _BitAnd(self): - return self._ExprFuncTemplate(self._EqExpr, ["&"]) + return self._ExprFuncTemplate(self._EqExpr, {"&"}) # A [ == B]* def _EqExpr(self): Val = self._RelExpr() - while self._IsOperator(["==", "!=", "EQ", "NE", "IN", "in", "!", "NOT", "not"]): + while self._IsOperator({"==", "!=", "EQ", "NE", "IN", "in", "!", "NOT", "not"}): Op = self._Token - if Op in ["!", "NOT", "not"]: - if not self._IsOperator(["IN", "in"]): + if Op in {"!", "NOT", "not"}: + if not self._IsOperator({"IN", "in"}): raise BadExpression(ERR_REL_NOT_IN) Op += ' ' + self._Token try: Val = self.Eval(Op, Val, self._RelExpr()) - except WrnExpression, Warn: + except WrnExpression as Warn: self._WarnExcept = Warn Val = Warn.result return Val # A [ > B]* def _RelExpr(self): - return self._ExprFuncTemplate(self._ShiftExpr, ["<=", ">=", "<", ">", "LE", "GE", "LT", "GT"]) + return self._ExprFuncTemplate(self._ShiftExpr, {"<=", ">=", "<", ">", "LE", "GE", "LT", "GT"}) def _ShiftExpr(self): - return self._ExprFuncTemplate(self._AddExpr, ["<<", ">>"]) + return self._ExprFuncTemplate(self._AddExpr, {"<<", ">>"}) # A [ + B]* def _AddExpr(self): - return self._ExprFuncTemplate(self._MulExpr, ["+", "-"]) + return self._ExprFuncTemplate(self._MulExpr, {"+", "-"}) # A [ * B]* def _MulExpr(self): - return self._ExprFuncTemplate(self._UnaryExpr, ["*", "/", "%"]) + return self._ExprFuncTemplate(self._UnaryExpr, {"*", "/", "%"}) # [!]*A def _UnaryExpr(self): - if self._IsOperator(["!", "NOT", "not"]): + if self._IsOperator({"!", "NOT", "not"}): Val = self._UnaryExpr() try: return self.Eval('not', Val) - except WrnExpression, Warn: + except WrnExpression as Warn: self._WarnExcept = Warn return Warn.result - if self._IsOperator(["~"]): + if self._IsOperator({"~"}): Val = self._UnaryExpr() try: return self.Eval('~', Val) - except WrnExpression, Warn: + except WrnExpression as Warn: self._WarnExcept = Warn return Warn.result return self._IdenExpr() @@ -531,7 +535,7 @@ class ValueExpression(BaseExpression): if self._Token.startswith('"') or self._Token.startswith('L"'): Flag = 0 for Index in range(len(self._Token)): - if self._Token[Index] in ['"']: + if self._Token[Index] in {'"'}: if self._Token[Index - 1] == '\\': continue Flag += 1 @@ -540,7 +544,7 @@ class ValueExpression(BaseExpression): if self._Token.startswith("'") or self._Token.startswith("L'"): Flag = 0 for Index in range(len(self._Token)): - if self._Token[Index] in ["'"]: + if self._Token[Index] in {"'"}: if self._Token[Index - 1] == '\\': continue Flag += 1 @@ -568,7 +572,7 @@ class ValueExpression(BaseExpression): IsArray = IsGuid = False if len(Token.split(',')) == 11 and len(Token.split(',{')) == 2 \ and len(Token.split('},')) == 1: - HexLen = [11,6,6,5,4,4,4,4,4,4,6] + HexLen = [11, 6, 6, 5, 4, 4, 4, 4, 4, 4, 6] HexList= Token.split(',') if HexList[3].startswith('{') and \ not [Index for Index, Hex in enumerate(HexList) if len(Hex) > HexLen[Index]]: @@ -639,15 +643,15 @@ class ValueExpression(BaseExpression): Ex.Pcd = self._Token raise Ex self._Token = ValueExpression(self._Symb[self._Token], self._Symb)(True, self._Depth+1) - if type(self._Token) != type(''): + if not isinstance(self._Token, type('')): self._LiteralToken = hex(self._Token) return if self._Token.startswith('"'): self._Token = self._Token[1:-1] - elif self._Token in ["FALSE", "false", "False"]: + elif self._Token in {"FALSE", "false", "False"}: self._Token = False - elif self._Token in ["TRUE", "true", "True"]: + elif self._Token in {"TRUE", "true", "True"}: self._Token = True else: self.__IsNumberToken() @@ -734,7 +738,7 @@ class ValueExpression(BaseExpression): if Ch == ')': TmpValue = self._Expr[Idx :self._Idx - 1] TmpValue = ValueExpression(TmpValue)(True) - TmpValue = '0x%x' % int(TmpValue) if type(TmpValue) != type('') else TmpValue + TmpValue = '0x%x' % int(TmpValue) if not isinstance(TmpValue, type('')) else TmpValue break self._Token, Size = ParseFieldValue(Prefix + '(' + TmpValue + ')') return self._Token @@ -764,7 +768,7 @@ class ValueExpression(BaseExpression): # Parse operator def _GetOperator(self): self.__SkipWS() - LegalOpLst = ['&&', '||', '!=', '==', '>=', '<='] + self.NonLetterOpLst + ['?',':'] + LegalOpLst = ['&&', '||', '!=', '==', '>=', '<='] + self.NonLetterOpLst + ['?', ':'] self._Token = '' Expr = self._Expr[self._Idx:] @@ -816,14 +820,14 @@ class ValueExpressionEx(ValueExpression): elif self.PcdType in TAB_PCD_NUMERIC_TYPES and (PcdValue.startswith("'") or \ PcdValue.startswith('"') or PcdValue.startswith("L'") or PcdValue.startswith('L"') or PcdValue.startswith('{')): raise BadExpression - except WrnExpression, Value: + except WrnExpression as Value: PcdValue = Value.result - except BadExpression, Value: + except BadExpression as Value: if self.PcdType in TAB_PCD_NUMERIC_TYPES: PcdValue = PcdValue.strip() if PcdValue.startswith('{') and PcdValue.endswith('}'): PcdValue = SplitPcdValueString(PcdValue[1:-1]) - if type(PcdValue) == type([]): + if isinstance(PcdValue, type([])): TmpValue = 0 Size = 0 ValueType = '' @@ -841,7 +845,7 @@ class ValueExpressionEx(ValueExpression): elif Item.startswith(TAB_UINT64): ItemSize = 8 ValueType = TAB_UINT64 - elif Item[0] in ['"',"'",'L']: + elif Item[0] in {'"', "'", 'L'}: ItemSize = 0 ValueType = TAB_VOID else: @@ -854,7 +858,7 @@ class ValueExpressionEx(ValueExpression): tmpValue = int(Item, 0) if tmpValue > 255: raise BadExpression("Byte array number %s should less than 0xFF." % Item) - except BadExpression, Value: + except BadExpression as Value: raise BadExpression(Value) except ValueError: pass @@ -862,7 +866,7 @@ class ValueExpressionEx(ValueExpression): else: ItemValue = ParseFieldValue(Item)[0] - if type(ItemValue) == type(''): + if isinstance(ItemValue, type('')): ItemValue = int(ItemValue, 0) TmpValue = (ItemValue << (Size * 8)) | TmpValue @@ -870,9 +874,9 @@ class ValueExpressionEx(ValueExpression): else: try: TmpValue, Size = ParseFieldValue(PcdValue) - except BadExpression, Value: + except BadExpression as Value: raise BadExpression("Type: %s, Value: %s, %s" % (self.PcdType, PcdValue, Value)) - if type(TmpValue) == type(''): + if isinstance(TmpValue, type('')): try: TmpValue = int(TmpValue) except: @@ -891,7 +895,7 @@ class ValueExpressionEx(ValueExpression): raise BadExpression('Type %s PCD Value Size is Larger than 8 byte' % self.PcdType) else: try: - TmpValue = long(PcdValue) + TmpValue = int(PcdValue) TmpList = [] if TmpValue.bit_length() == 0: PcdValue = '{0x00}' @@ -945,7 +949,7 @@ class ValueExpressionEx(ValueExpression): # replace each offset, except errors for Offset in OffsetList: try: - Item = Item.replace('OFFSET_OF({})'.format(Offset),LabelDict[Offset]) + Item = Item.replace('OFFSET_OF({})'.format(Offset), LabelDict[Offset]) except: raise BadExpression('%s not defined' % Offset) @@ -995,10 +999,10 @@ class ValueExpressionEx(ValueExpression): TmpValue = ValueExpressionEx(Item, ValueType, self._Symb)(True) else: TmpValue = ValueExpressionEx(Item, self.PcdType, self._Symb)(True) - Item = '0x%x' % TmpValue if type(TmpValue) != type('') else TmpValue + Item = '0x%x' % TmpValue if not isinstance(TmpValue, type('')) else TmpValue if ItemSize == 0: ItemValue, ItemSize = ParseFieldValue(Item) - if Item[0] not in ['"','L','{'] and ItemSize > 1: + if Item[0] not in {'"', 'L', '{'} and ItemSize > 1: raise BadExpression("Byte array number %s should less than 0xFF." % Item) else: ItemValue = ParseFieldValue(Item)[0] @@ -1028,10 +1032,10 @@ if __name__ == '__main__': if input in 'qQ': break try: - print ValueExpression(input)(True) - print ValueExpression(input)(False) - except WrnExpression, Ex: - print Ex.result - print str(Ex) - except Exception, Ex: - print str(Ex) + print(ValueExpression(input)(True)) + print(ValueExpression(input)(False)) + except WrnExpression as Ex: + print(Ex.result) + print(str(Ex)) + except Exception as Ex: + print(str(Ex))