BaseTools: use set instead of list

as we only do membership (in) testing for this, set is better

Cc: Liming Gao <liming.gao@intel.com>
Cc: Yonghong Zhu <yonghong.zhu@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Jaben Carsey <jaben.carsey@intel.com>
Reviewed-by: Yonghong Zhu <yonghong.zhu@intel.com>

diff --git a/BaseTools/Source/Python/Common/Expression.py b/BaseTools/Source/Python/Common/Expression.py
index d7903c98b1d65ff90e9c923534dc66060ff4c899..9e9d9fdc02e7e075e56468d8eac31226e6fd1946 100644 (file)
--- a/BaseTools/Source/Python/Common/Expression.py
+++ b/BaseTools/Source/Python/Common/Expression.py
@@ -171,7 +171,7 @@ def ReplaceExprMacro(String, Macros, ExceptionList = None):
                 RetStr += '0'\r
             elif not InQuote:\r
                 Tklst = RetStr.split()\r
-                if Tklst and Tklst[-1] in ['IN', 'in'] and ExceptionList and Macro not in ExceptionList:\r
+                if Tklst and Tklst[-1] in {'IN', 'in'} and ExceptionList and Macro not in ExceptionList:\r
                     raise BadExpression(ERR_IN_OPERAND)\r
                 # Make sure the macro in exception list is encapsulated by double quote\r
                 # For example: DEFINE ARCH = IA32 X64\r
@@ -243,10 +243,10 @@ class ValueExpression(BaseExpression):
     def Eval(Operator, Oprand1, Oprand2 = None):\r
         WrnExp = None\r
 \r
-        if Operator not in ["==", "!=", ">=", "<=", ">", "<", "in", "not in"] and \\r
+        if Operator not in {"==", "!=", ">=", "<=", ">", "<", "in", "not in"} and \\r
             (type(Oprand1) == type('') or type(Oprand2) == type('')):\r
             raise BadExpression(ERR_STRING_EXPR % Operator)\r
-        if Operator in ['in', 'not in']:\r
+        if Operator in {'in', 'not in'}:\r
             if type(Oprand1) != type(''):\r
                 Oprand1 = IntToStr(Oprand1)\r
             if type(Oprand2) != type(''):\r
@@ -259,19 +259,19 @@ class ValueExpression(BaseExpression):
         }\r
 \r
         EvalStr = ''\r
-        if Operator in ["!", "NOT", "not"]:\r
+        if Operator in {"!", "NOT", "not"}:\r
             if type(Oprand1) == type(''):\r
                 raise BadExpression(ERR_STRING_EXPR % Operator)\r
             EvalStr = 'not Oprand1'\r
-        elif Operator in ["~"]:\r
+        elif Operator in {"~"}:\r
             if type(Oprand1) == type(''):\r
                 raise BadExpression(ERR_STRING_EXPR % Operator)\r
             EvalStr = '~ Oprand1'\r
         else:\r
-            if Operator in ["+", "-"] and (type(True) in [type(Oprand1), type(Oprand2)]):\r
+            if Operator in {"+", "-"} and (type(True) in {type(Oprand1), type(Oprand2)}):\r
                 # Boolean in '+'/'-' will be evaluated but raise warning\r
                 WrnExp = WrnExpression(WRN_BOOL_EXPR)\r
-            elif type('') in [type(Oprand1), type(Oprand2)] and type(Oprand1)!= type(Oprand2):\r
+            elif type('') in {type(Oprand1), type(Oprand2)} and type(Oprand1)!= type(Oprand2):\r
                 # == between string and number/boolean will always return False, != return True\r
                 if Operator == "==":\r
                     WrnExp = WrnExpression(WRN_EQCMP_STR_OTHERS)\r
@@ -284,10 +284,10 @@ class ValueExpression(BaseExpression):
                 else:\r
                     raise BadExpression(ERR_RELCMP_STR_OTHERS % Operator)\r
             elif TypeDict[type(Oprand1)] != TypeDict[type(Oprand2)]:\r
-                if Operator in ["==", "!=", ">=", "<=", ">", "<"] and set((TypeDict[type(Oprand1)], TypeDict[type(Oprand2)])) == set((TypeDict[type(True)], TypeDict[type(0)])):\r
+                if Operator in {"==", "!=", ">=", "<=", ">", "<"} and set((TypeDict[type(Oprand1)], TypeDict[type(Oprand2)])) == set((TypeDict[type(True)], TypeDict[type(0)])):\r
                     # comparison between number and boolean is allowed\r
                     pass\r
-                elif Operator in ['&', '|', '^', "and", "or"] and set((TypeDict[type(Oprand1)], TypeDict[type(Oprand2)])) == set((TypeDict[type(True)], TypeDict[type(0)])):\r
+                elif Operator in {'&', '|', '^', "and", "or"} and set((TypeDict[type(Oprand1)], TypeDict[type(Oprand2)])) == set((TypeDict[type(True)], TypeDict[type(0)])):\r
                     # bitwise and logical operation between number and boolean is allowed\r
                     pass\r
                 else:\r
@@ -310,7 +310,7 @@ class ValueExpression(BaseExpression):
         except Exception, Excpt:\r
             raise BadExpression(str(Excpt))\r
 \r
-        if Operator in ['and', 'or']:\r
+        if Operator in {'and', 'or'}:\r
             if Val:\r
                 Val = True\r
             else:\r
@@ -410,13 +410,13 @@ class ValueExpression(BaseExpression):
 \r
     # Template function to parse binary operators which have same precedence\r
     # Expr [Operator Expr]*\r
-    def _ExprFuncTemplate(self, EvalFunc, OpLst):\r
+    def _ExprFuncTemplate(self, EvalFunc, OpSet):\r
         Val = EvalFunc()\r
-        while self._IsOperator(OpLst):\r
+        while self._IsOperator(OpSet):\r
             Op = self._Token\r
             if Op == '?':\r
                 Val2 = EvalFunc()\r
-                if self._IsOperator(':'):\r
+                if self._IsOperator({':'}):\r
                     Val3 = EvalFunc()\r
                 if Val:\r
                     Val = Val2\r
@@ -431,35 +431,35 @@ class ValueExpression(BaseExpression):
         return Val\r
     # A [? B]*\r
     def _ConExpr(self):\r
-        return self._ExprFuncTemplate(self._OrExpr, ['?', ':'])\r
+        return self._ExprFuncTemplate(self._OrExpr, {'?', ':'})\r
 \r
     # A [|| B]*\r
     def _OrExpr(self):\r
-        return self._ExprFuncTemplate(self._AndExpr, ["OR", "or", "||"])\r
+        return self._ExprFuncTemplate(self._AndExpr, {"OR", "or", "||"})\r
 \r
     # A [&& B]*\r
     def _AndExpr(self):\r
-        return self._ExprFuncTemplate(self._BitOr, ["AND", "and", "&&"])\r
+        return self._ExprFuncTemplate(self._BitOr, {"AND", "and", "&&"})\r
 \r
     # A [ | B]*\r
     def _BitOr(self):\r
-        return self._ExprFuncTemplate(self._BitXor, ["|"])\r
+        return self._ExprFuncTemplate(self._BitXor, {"|"})\r
 \r
     # A [ ^ B]*\r
     def _BitXor(self):\r
-        return self._ExprFuncTemplate(self._BitAnd, ["XOR", "xor", "^"])\r
+        return self._ExprFuncTemplate(self._BitAnd, {"XOR", "xor", "^"})\r
 \r
     # A [ & B]*\r
     def _BitAnd(self):\r
-        return self._ExprFuncTemplate(self._EqExpr, ["&"])\r
+        return self._ExprFuncTemplate(self._EqExpr, {"&"})\r
 \r
     # A [ == B]*\r
     def _EqExpr(self):\r
         Val = self._RelExpr()\r
-        while self._IsOperator(["==", "!=", "EQ", "NE", "IN", "in", "!", "NOT", "not"]):\r
+        while self._IsOperator({"==", "!=", "EQ", "NE", "IN", "in", "!", "NOT", "not"}):\r
             Op = self._Token\r
-            if Op in ["!", "NOT", "not"]:\r
-                if not self._IsOperator(["IN", "in"]):\r
+            if Op in {"!", "NOT", "not"}:\r
+                if not self._IsOperator({"IN", "in"}):\r
                     raise BadExpression(ERR_REL_NOT_IN)\r
                 Op += ' ' + self._Token\r
             try:\r
@@ -471,29 +471,29 @@ class ValueExpression(BaseExpression):
 \r
     # A [ > B]*\r
     def _RelExpr(self):\r
-        return self._ExprFuncTemplate(self._ShiftExpr, ["<=", ">=", "<", ">", "LE", "GE", "LT", "GT"])\r
+        return self._ExprFuncTemplate(self._ShiftExpr, {"<=", ">=", "<", ">", "LE", "GE", "LT", "GT"})\r
 \r
     def _ShiftExpr(self):\r
-        return self._ExprFuncTemplate(self._AddExpr, ["<<", ">>"])\r
+        return self._ExprFuncTemplate(self._AddExpr, {"<<", ">>"})\r
 \r
     # A [ + B]*\r
     def _AddExpr(self):\r
-        return self._ExprFuncTemplate(self._MulExpr, ["+", "-"])\r
+        return self._ExprFuncTemplate(self._MulExpr, {"+", "-"})\r
 \r
     # A [ * B]*\r
     def _MulExpr(self):\r
-        return self._ExprFuncTemplate(self._UnaryExpr, ["*", "/", "%"])\r
+        return self._ExprFuncTemplate(self._UnaryExpr, {"*", "/", "%"})\r
 \r
     # [!]*A\r
     def _UnaryExpr(self):\r
-        if self._IsOperator(["!", "NOT", "not"]):\r
+        if self._IsOperator({"!", "NOT", "not"}):\r
             Val = self._UnaryExpr()\r
             try:\r
                 return self.Eval('not', Val)\r
             except WrnExpression, Warn:\r
                 self._WarnExcept = Warn\r
                 return Warn.result\r
-        if self._IsOperator(["~"]):\r
+        if self._IsOperator({"~"}):\r
             Val = self._UnaryExpr()\r
             try:\r
                 return self.Eval('~', Val)\r
@@ -531,7 +531,7 @@ class ValueExpression(BaseExpression):
         if self._Token.startswith('"') or self._Token.startswith('L"'):\r
             Flag = 0\r
             for Index in range(len(self._Token)):\r
-                if self._Token[Index] in ['"']:\r
+                if self._Token[Index] in {'"'}:\r
                     if self._Token[Index - 1] == '\\':\r
                         continue\r
                     Flag += 1\r
@@ -540,7 +540,7 @@ class ValueExpression(BaseExpression):
         if self._Token.startswith("'") or self._Token.startswith("L'"):\r
             Flag = 0\r
             for Index in range(len(self._Token)):\r
-                if self._Token[Index] in ["'"]:\r
+                if self._Token[Index] in {"'"}:\r
                     if self._Token[Index - 1] == '\\':\r
                         continue\r
                     Flag += 1\r
@@ -645,9 +645,9 @@ class ValueExpression(BaseExpression):
 \r
         if self._Token.startswith('"'):\r
             self._Token = self._Token[1:-1]\r
-        elif self._Token in ["FALSE", "false", "False"]:\r
+        elif self._Token in {"FALSE", "false", "False"}:\r
             self._Token = False\r
-        elif self._Token in ["TRUE", "true", "True"]:\r
+        elif self._Token in {"TRUE", "true", "True"}:\r
             self._Token = True\r
         else:\r
             self.__IsNumberToken()\r
@@ -841,7 +841,7 @@ class ValueExpressionEx(ValueExpression):
                         elif Item.startswith(TAB_UINT64):\r
                             ItemSize = 8\r
                             ValueType = TAB_UINT64\r
-                        elif Item[0] in ['"',"'",'L']:\r
+                        elif Item[0] in {'"',"'",'L'}:\r
                             ItemSize = 0\r
                             ValueType = TAB_VOID\r
                         else:\r
@@ -998,7 +998,7 @@ class ValueExpressionEx(ValueExpression):
                                 Item = '0x%x' % TmpValue if type(TmpValue) != type('') else TmpValue\r
                                 if ItemSize == 0:\r
                                     ItemValue, ItemSize = ParseFieldValue(Item)\r
-                                    if Item[0] not in ['"','L','{'] and ItemSize > 1:\r
+                                    if Item[0] not in {'"','L','{'} and ItemSize > 1:\r
                                         raise BadExpression("Byte  array number %s should less than 0xFF." % Item)\r
                                 else:\r
                                     ItemValue = ParseFieldValue(Item)[0]\r

diff --git a/BaseTools/Source/Python/Common/RangeExpression.py b/BaseTools/Source/Python/Common/RangeExpression.py
index 00c0c5e94ddc9cd52642ae074a19691f6d331c9b..7f504d6e310c0abe2299a5315b596bdc85dd1b1c 100644 (file)
--- a/BaseTools/Source/Python/Common/RangeExpression.py
+++ b/BaseTools/Source/Python/Common/RangeExpression.py
@@ -416,9 +416,9 @@ class RangeExpression(BaseExpression):
 \r
     # Template function to parse binary operators which have same precedence\r
     # Expr [Operator Expr]*\r
-    def _ExprFuncTemplate(self, EvalFunc, OpLst):\r
+    def _ExprFuncTemplate(self, EvalFunc, OpSet):\r
         Val = EvalFunc()\r
-        while self._IsOperator(OpLst):\r
+        while self._IsOperator(OpSet):\r
             Op = self._Token\r
             try:\r
                 Val = self.Eval(Op, Val, EvalFunc())\r
@@ -429,18 +429,18 @@ class RangeExpression(BaseExpression):
 \r
     # A [|| B]*\r
     def _OrExpr(self):\r
-        return self._ExprFuncTemplate(self._AndExpr, ["OR", "or"])\r
+        return self._ExprFuncTemplate(self._AndExpr, {"OR", "or"})\r
 \r
     # A [&& B]*\r
     def _AndExpr(self):\r
-        return self._ExprFuncTemplate(self._NeExpr, ["AND", "and"])\r
+        return self._ExprFuncTemplate(self._NeExpr, {"AND", "and"})\r
 \r
     def _NeExpr(self):\r
         Val = self._RelExpr()\r
-        while self._IsOperator([ "!=", "NOT", "not"]):\r
+        while self._IsOperator({"!=", "NOT", "not"}):\r
             Op = self._Token\r
             if Op in ["!", "NOT", "not"]:\r
-                if not self._IsOperator(["IN", "in"]):\r
+                if not self._IsOperator({"IN", "in"}):\r
                     raise BadExpression(ERR_REL_NOT_IN)\r
                 Op += ' ' + self._Token\r
             try:\r
@@ -452,7 +452,7 @@ class RangeExpression(BaseExpression):
 \r
     # [!]*A\r
     def _RelExpr(self):\r
-        if self._IsOperator(["NOT" , "LE", "GE", "LT", "GT", "EQ", "XOR"]):\r
+        if self._IsOperator({"NOT" , "LE", "GE", "LT", "GT", "EQ", "XOR"}):\r
             Token = self._Token\r
             Val = self._NeExpr()\r
             try:\r