\r
# # Import Modules\r
#\r
+from __future__ import print_function\r
from Common.GlobalData import *\r
from CommonDataClass.Exceptions import BadExpression\r
from CommonDataClass.Exceptions import WrnExpression\r
import uuid\r
-from Common.Expression import PcdPattern\r
+from Common.Expression import PcdPattern, BaseExpression\r
from Common.DataType import *\r
\r
ERR_STRING_EXPR = 'This operator cannot be used in string expression: [%s].'\r
self.__clean__()\r
\r
def dump(self):\r
- print "----------------------"\r
+ print("----------------------")\r
rangelist = ""\r
for object in self.rangelist:\r
rangelist = rangelist + "[%d , %d]" % (object.start, object.end)\r
- print rangelist\r
+ print(rangelist)\r
\r
\r
class XOROperatorObject(object): \r
def __init__(self): \r
pass\r
def Calculate(self, Operand, DataType, SymbolTable): \r
- if type(Operand) == type('') and not Operand.isalnum():\r
+ if isinstance(Operand, type('')) and not Operand.isalnum():\r
Expr = "XOR ..."\r
raise BadExpression(ERR_SNYTAX % Expr)\r
rangeId = str(uuid.uuid1())\r
def __init__(self): \r
pass\r
def Calculate(self, Operand, DataType, SymbolTable): \r
- if type(Operand) == type('') and not Operand.isalnum():\r
+ if isinstance(Operand, type('')) and not Operand.isalnum():\r
Expr = "LE ..."\r
raise BadExpression(ERR_SNYTAX % Expr)\r
rangeId1 = str(uuid.uuid1())\r
def __init__(self): \r
pass\r
def Calculate(self, Operand, DataType, SymbolTable):\r
- if type(Operand) == type('') and not Operand.isalnum():\r
+ if isinstance(Operand, type('')) and not Operand.isalnum():\r
Expr = "LT ..." \r
raise BadExpression(ERR_SNYTAX % Expr) \r
rangeId1 = str(uuid.uuid1())\r
def __init__(self): \r
pass\r
def Calculate(self, Operand, DataType, SymbolTable): \r
- if type(Operand) == type('') and not Operand.isalnum():\r
+ if isinstance(Operand, type('')) and not Operand.isalnum():\r
Expr = "GE ..."\r
raise BadExpression(ERR_SNYTAX % Expr)\r
rangeId1 = str(uuid.uuid1())\r
def __init__(self): \r
pass\r
def Calculate(self, Operand, DataType, SymbolTable): \r
- if type(Operand) == type('') and not Operand.isalnum():\r
+ if isinstance(Operand, type('')) and not Operand.isalnum():\r
Expr = "GT ..."\r
raise BadExpression(ERR_SNYTAX % Expr)\r
rangeId1 = str(uuid.uuid1())\r
def __init__(self): \r
pass\r
def Calculate(self, Operand, DataType, SymbolTable): \r
- if type(Operand) == type('') and not Operand.isalnum():\r
+ if isinstance(Operand, type('')) and not Operand.isalnum():\r
Expr = "EQ ..."\r
raise BadExpression(ERR_SNYTAX % Expr)\r
rangeId1 = str(uuid.uuid1())\r
rangeContainer = RangeContainer()\r
- rangeContainer.push(RangeObject(int(Operand) , int(Operand)))\r
+ rangeContainer.push(RangeObject(int(Operand), int(Operand)))\r
SymbolTable[rangeId1] = rangeContainer\r
return rangeId1 \r
\r
else:\r
raise BadExpression("Bad Operator")\r
\r
-class RangeExpression(object):\r
+class RangeExpression(BaseExpression):\r
# Logical operator mapping\r
LogicalOperators = {\r
'&&' : 'and', '||' : 'or',\r
\r
\r
def __init__(self, Expression, PcdDataType, SymbolTable = {}):\r
+ super(RangeExpression, self).__init__(self, Expression, PcdDataType, SymbolTable)\r
self._NoProcess = False\r
- if type(Expression) != type(''):\r
+ if not isinstance(Expression, type('')):\r
self._Expr = Expression\r
self._NoProcess = True\r
return\r
\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
- except WrnExpression, Warn:\r
+ except WrnExpression as Warn:\r
self._WarnExcept = Warn\r
Val = Warn.result\r
return Val\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._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
Val = self.Eval(Op, Val, self._RelExpr())\r
- except WrnExpression, Warn:\r
+ except WrnExpression as Warn:\r
self._WarnExcept = Warn\r
Val = Warn.result\r
return Val\r
\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
return self.Eval(Token, Val)\r
- except WrnExpression, Warn:\r
+ except WrnExpression as Warn:\r
self._WarnExcept = Warn\r
return Warn.result\r
return self._IdenExpr()\r
Ex.Pcd = self._Token\r
raise Ex\r
self._Token = RangeExpression(self._Symb[self._Token], self._Symb)(True, self._Depth + 1)\r
- if type(self._Token) != type(''):\r
+ if not isinstance(self._Token, type('')):\r
self._LiteralToken = hex(self._Token)\r
return\r
\r
raise BadExpression(ERR_OPERATOR_UNSUPPORT % OpToken)\r
self._Token = OpToken\r
return OpToken\r
-\r
- # Check if current token matches the operators given from OpList\r
- def _IsOperator(self, OpList):\r
- Idx = self._Idx\r
- self._GetOperator()\r
- if self._Token in OpList:\r
- if self._Token in self.LogicalOperators:\r
- self._Token = self.LogicalOperators[self._Token]\r
- return True\r
- self._Idx = Idx\r
- return False\r
-\r
-\r
- \r
- \r
- \r
- \r
-\r
-\r
-\r
-\r
-# UTRangeList()\r