# # @file\r
# This file is used to parse and evaluate range expression in Pcd declaration.\r
#\r
-# Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2015 - 2018, Intel Corporation. All rights reserved.<BR>\r
# This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
# which accompanies this distribution. The full text of the license may be found at\r
\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, BaseExpression\r
+from Common.DataType import *\r
+from re import compile\r
\r
ERR_STRING_EXPR = 'This operator cannot be used in string expression: [%s].'\r
ERR_SNYTAX = 'Syntax error, the rest of expression cannot be evaluated: [%s].'\r
ERR_STRING_TOKEN = 'Bad string token: [%s].'\r
ERR_MACRO_TOKEN = 'Bad macro token: [%s].'\r
ERR_EMPTY_TOKEN = 'Empty token is not allowed.'\r
-ERR_PCD_RESOLVE = 'PCD token cannot be resolved: [%s].'\r
+ERR_PCD_RESOLVE = 'The PCD should be FeatureFlag type or FixedAtBuild type: [%s].'\r
ERR_VALID_TOKEN = 'No more valid token found from rest of string: [%s].'\r
ERR_EXPR_TYPE = 'Different types found in expression.'\r
ERR_OPERATOR_UNSUPPORT = 'Unsupported operator: [%s]'\r
ERR_EMPTY_EXPR = 'Empty expression is not allowed.'\r
ERR_IN_OPERAND = 'Macro after IN operator can only be: $(FAMILY), $(ARCH), $(TOOL_CHAIN_TAG) and $(TARGET).'\r
\r
-def MaxOfType(DataType):\r
- if DataType == 'UINT8':\r
- return int('0xFF', 16)\r
- if DataType == 'UINT16':\r
- return int('0xFFFF', 16)\r
- if DataType == 'UINT32':\r
- return int('0xFFFFFFFF', 16)\r
- if DataType == 'UINT64':\r
- return int('0xFFFFFFFFFFFFFFFF', 16)\r
-\r
class RangeObject(object):\r
def __init__(self, start, end, empty = False):\r
- \r
+\r
if int(start) < int(end):\r
self.start = int(start)\r
self.end = int(end)\r
class RangeContainer(object):\r
def __init__(self):\r
self.rangelist = []\r
- \r
+\r
def push(self, RangeObject):\r
self.rangelist.append(RangeObject)\r
self.rangelist = sorted(self.rangelist, key = lambda rangeobj : rangeobj.start)\r
self.merge()\r
- \r
+\r
def pop(self):\r
for item in self.rangelist:\r
yield item\r
- \r
- def __clean__(self): \r
+\r
+ def __clean__(self):\r
newrangelist = []\r
for rangeobj in self.rangelist:\r
if rangeobj.empty == True:\r
continue\r
else:\r
newrangelist.append(rangeobj)\r
- self.rangelist = newrangelist \r
+ self.rangelist = newrangelist\r
def merge(self):\r
self.__clean__()\r
for i in range(0, len(self.rangelist) - 1):\r
continue\r
else:\r
self.rangelist[i + 1].start = self.rangelist[i].start\r
- self.rangelist[i + 1].end = self.rangelist[i + 1].end > self.rangelist[i].end and self.rangelist[i + 1].end or self.rangelist[i].end \r
+ self.rangelist[i + 1].end = self.rangelist[i + 1].end > self.rangelist[i].end and self.rangelist[i + 1].end or self.rangelist[i].end\r
self.rangelist[i].empty = True\r
\r
self.__clean__()\r
- \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
- \r
- \r
-class XOROperatorObject(object): \r
- def __init__(self): \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
+ def Calculate(self, Operand, DataType, SymbolTable):\r
+ if isinstance(Operand, type('')) and not Operand.isalnum():\r
Expr = "XOR ..."\r
raise BadExpression(ERR_SNYTAX % Expr)\r
rangeId = str(uuid.uuid1())\r
rangeContainer = RangeContainer()\r
rangeContainer.push(RangeObject(0, int(Operand) - 1))\r
- rangeContainer.push(RangeObject(int(Operand) + 1, MaxOfType(DataType)))\r
+ rangeContainer.push(RangeObject(int(Operand) + 1, MAX_VAL_TYPE[DataType]))\r
SymbolTable[rangeId] = rangeContainer\r
return rangeId\r
\r
class LEOperatorObject(object):\r
- def __init__(self): \r
+ def __init__(self):\r
pass\r
- def Calculate(self, Operand, DataType, SymbolTable): \r
- if type(Operand) == type('') and not Operand.isalnum():\r
+ def Calculate(self, Operand, DataType, SymbolTable):\r
+ if isinstance(Operand, type('')) and not Operand.isalnum():\r
Expr = "LE ..."\r
raise BadExpression(ERR_SNYTAX % Expr)\r
rangeId1 = str(uuid.uuid1())\r
SymbolTable[rangeId1] = rangeContainer\r
return rangeId1\r
class LTOperatorObject(object):\r
- def __init__(self): \r
+ def __init__(self):\r
pass\r
def Calculate(self, Operand, DataType, SymbolTable):\r
- if type(Operand) == type('') and not Operand.isalnum():\r
- Expr = "LT ..." \r
- raise BadExpression(ERR_SNYTAX % Expr) \r
+ if isinstance(Operand, type('')) and not Operand.isalnum():\r
+ Expr = "LT ..."\r
+ raise BadExpression(ERR_SNYTAX % Expr)\r
rangeId1 = str(uuid.uuid1())\r
rangeContainer = RangeContainer()\r
rangeContainer.push(RangeObject(0, int(Operand) - 1))\r
SymbolTable[rangeId1] = rangeContainer\r
- return rangeId1 \r
+ return rangeId1\r
\r
class GEOperatorObject(object):\r
- def __init__(self): \r
+ def __init__(self):\r
pass\r
- def Calculate(self, Operand, DataType, SymbolTable): \r
- if type(Operand) == type('') and not Operand.isalnum():\r
+ def Calculate(self, Operand, DataType, SymbolTable):\r
+ if isinstance(Operand, type('')) and not Operand.isalnum():\r
Expr = "GE ..."\r
raise BadExpression(ERR_SNYTAX % Expr)\r
rangeId1 = str(uuid.uuid1())\r
rangeContainer = RangeContainer()\r
- rangeContainer.push(RangeObject(int(Operand), MaxOfType(DataType)))\r
+ rangeContainer.push(RangeObject(int(Operand), MAX_VAL_TYPE[DataType]))\r
SymbolTable[rangeId1] = rangeContainer\r
- return rangeId1 \r
- \r
+ return rangeId1\r
+\r
class GTOperatorObject(object):\r
- def __init__(self): \r
+ def __init__(self):\r
pass\r
- def Calculate(self, Operand, DataType, SymbolTable): \r
- if type(Operand) == type('') and not Operand.isalnum():\r
+ def Calculate(self, Operand, DataType, SymbolTable):\r
+ if isinstance(Operand, type('')) and not Operand.isalnum():\r
Expr = "GT ..."\r
raise BadExpression(ERR_SNYTAX % Expr)\r
rangeId1 = str(uuid.uuid1())\r
rangeContainer = RangeContainer()\r
- rangeContainer.push(RangeObject(int(Operand) + 1, MaxOfType(DataType)))\r
+ rangeContainer.push(RangeObject(int(Operand) + 1, MAX_VAL_TYPE[DataType]))\r
SymbolTable[rangeId1] = rangeContainer\r
- return rangeId1 \r
- \r
+ return rangeId1\r
+\r
class EQOperatorObject(object):\r
- def __init__(self): \r
+ def __init__(self):\r
pass\r
- def Calculate(self, Operand, DataType, SymbolTable): \r
- if type(Operand) == type('') and not Operand.isalnum():\r
+ def Calculate(self, Operand, DataType, SymbolTable):\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
+ return rangeId1\r
+\r
def GetOperatorObject(Operator):\r
if Operator == '>':\r
return GTOperatorObject()\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
NonLetterOpLst = ['+', '-', '&', '|', '^', '!', '=', '>', '<']\r
\r
- PcdPattern = re.compile(r'[_a-zA-Z][0-9A-Za-z_]*\.[_a-zA-Z][0-9A-Za-z_]*$')\r
- HexPattern = re.compile(r'0[xX][0-9a-fA-F]+')\r
- RegGuidPattern = re.compile(r'[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}')\r
- ExRegGuidPattern = re.compile(r'[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$')\r
- \r
- SymbolPattern = re.compile("("\r
- "\$\([A-Z][A-Z0-9_]*\)|\$\(\w+\.\w+\)|\w+\.\w+|"\r
- "&&|\|\||!(?!=)|"\r
- "(?<=\W)AND(?=\W)|(?<=\W)OR(?=\W)|(?<=\W)NOT(?=\W)|(?<=\W)XOR(?=\W)|"\r
- "(?<=\W)EQ(?=\W)|(?<=\W)NE(?=\W)|(?<=\W)GT(?=\W)|(?<=\W)LT(?=\W)|(?<=\W)GE(?=\W)|(?<=\W)LE(?=\W)"\r
- ")")\r
- \r
- RangePattern = re.compile(r'[0-9]+ - [0-9]+')\r
+ RangePattern = compile(r'[0-9]+ - [0-9]+')\r
\r
def preProcessRangeExpr(self, expr):\r
# convert hex to int\r
# convert interval to object index. ex. 1 - 10 to a GUID\r
expr = expr.strip()\r
NumberDict = {}\r
- for HexNumber in self.HexPattern.findall(expr):\r
+ for HexNumber in gHexPattern.findall(expr):\r
Number = str(int(HexNumber, 16))\r
NumberDict[HexNumber] = Number\r
for HexNum in NumberDict:\r
expr = expr.replace(HexNum, NumberDict[HexNum])\r
- \r
- rangedict = {} \r
+\r
+ rangedict = {}\r
for validrange in self.RangePattern.findall(expr):\r
start, end = validrange.split(" - ")\r
start = start.strip()\r
rangeContainer.push(RangeObject(start, end))\r
self.operanddict[str(rangeid)] = rangeContainer\r
rangedict[validrange] = str(rangeid)\r
- \r
+\r
for validrange in rangedict:\r
expr = expr.replace(validrange, rangedict[validrange])\r
- \r
- self._Expr = expr \r
+\r
+ self._Expr = expr\r
return expr\r
- \r
- \r
+\r
+\r
def EvalRange(self, Operator, Oprand):\r
\r
operatorobj = GetOperatorObject(Operator)\r
return operatorobj.Calculate(Oprand, self.PcdDataType, self.operanddict)\r
- \r
+\r
def Rangeintersection(self, Oprand1, Oprand2):\r
rangeContainer1 = self.operanddict[Oprand1]\r
rangeContainer2 = self.operanddict[Oprand2]\r
rangeContainer = RangeContainer()\r
for range1 in rangeContainer1.pop():\r
for range2 in rangeContainer2.pop():\r
- if range1.start >= range2.start:\r
- start = range1.start\r
- end = range1.end\r
- range1.start = range2.start\r
- range1.end = range2.end\r
- range2.start = start\r
- range2.end = end\r
+ start1 = range1.start\r
+ end1 = range1.end\r
+ start2 = range2.start\r
+ end2 = range2.end\r
+ if start1 >= start2:\r
+ start1, start2 = start2, start1\r
+ end1, end2 = end2, end1\r
if range1.empty:\r
rangeid = str(uuid.uuid1())\r
rangeContainer.push(RangeObject(0, 0, True))\r
- if range1.end < range2.start:\r
+ if end1 < start2:\r
rangeid = str(uuid.uuid1())\r
rangeContainer.push(RangeObject(0, 0, True))\r
- elif range1.end == range2.start:\r
+ elif end1 == start2:\r
rangeid = str(uuid.uuid1())\r
- rangeContainer.push(RangeObject(range1.end, range1.end))\r
- elif range1.end <= range2.end and range1.end > range2.start:\r
+ rangeContainer.push(RangeObject(end1, end1))\r
+ elif end1 <= end2 and end1 > start2:\r
rangeid = str(uuid.uuid1())\r
- rangeContainer.push(RangeObject(range2.start, range1.end))\r
- elif range1.end >= range2.end:\r
+ rangeContainer.push(RangeObject(start2, end1))\r
+ elif end1 >= end2:\r
rangeid = str(uuid.uuid1())\r
- rangeContainer.push(RangeObject(range2.start, range2.end))\r
- \r
+ rangeContainer.push(RangeObject(start2, end2))\r
+\r
self.operanddict[rangeid] = rangeContainer\r
# rangeContainer.dump()\r
return rangeid\r
- \r
+\r
def Rangecollections(self, Oprand1, Oprand2):\r
\r
rangeContainer1 = self.operanddict[Oprand1]\r
rangeContainer2 = self.operanddict[Oprand2]\r
rangeContainer = RangeContainer()\r
- \r
+\r
for rangeobj in rangeContainer2.pop():\r
rangeContainer.push(rangeobj)\r
for rangeobj in rangeContainer1.pop():\r
rangeContainer.push(rangeobj)\r
- \r
+\r
rangeid = str(uuid.uuid1())\r
self.operanddict[rangeid] = rangeContainer\r
- \r
+\r
# rangeContainer.dump()\r
return rangeid\r
- \r
- \r
- def NegtiveRange(self, Oprand1):\r
+\r
+\r
+ def NegativeRange(self, Oprand1):\r
rangeContainer1 = self.operanddict[Oprand1]\r
- \r
- \r
+\r
+\r
rangeids = []\r
- \r
+\r
for rangeobj in rangeContainer1.pop():\r
rangeContainer = RangeContainer()\r
rangeid = str(uuid.uuid1())\r
if rangeobj.empty:\r
- rangeContainer.push(RangeObject(0, MaxOfType(self.PcdDataType)))\r
+ rangeContainer.push(RangeObject(0, MAX_VAL_TYPE[self.PcdDataType]))\r
else:\r
if rangeobj.start > 0:\r
rangeContainer.push(RangeObject(0, rangeobj.start - 1))\r
- if rangeobj.end < MaxOfType(self.PcdDataType):\r
- rangeContainer.push(RangeObject(rangeobj.end + 1, MaxOfType(self.PcdDataType)))\r
+ if rangeobj.end < MAX_VAL_TYPE[self.PcdDataType]:\r
+ rangeContainer.push(RangeObject(rangeobj.end + 1, MAX_VAL_TYPE[self.PcdDataType]))\r
self.operanddict[rangeid] = rangeContainer\r
rangeids.append(rangeid)\r
\r
if len(rangeids) == 0:\r
rangeContainer = RangeContainer()\r
- rangeContainer.push(RangeObject(0, MaxOfType(self.PcdDataType)))\r
+ rangeContainer.push(RangeObject(0, MAX_VAL_TYPE[self.PcdDataType]))\r
rangeid = str(uuid.uuid1())\r
self.operanddict[rangeid] = rangeContainer\r
return rangeid\r
re = self.Rangeintersection(rangeids[0], rangeids[1])\r
for i in range(2, len(rangeids)):\r
re = self.Rangeintersection(re, rangeids[i])\r
- \r
+\r
rangeid2 = str(uuid.uuid1())\r
self.operanddict[rangeid2] = self.operanddict[re]\r
return rangeid2\r
- \r
+\r
def Eval(self, Operator, Oprand1, Oprand2 = None):\r
- \r
+\r
if Operator in ["!", "NOT", "not"]:\r
- if not self.RegGuidPattern.match(Oprand1.strip()):\r
+ if not gGuidPattern.match(Oprand1.strip()):\r
raise BadExpression(ERR_STRING_EXPR % Operator)\r
- return self.NegtiveRange(Oprand1)\r
+ return self.NegativeRange(Oprand1)\r
else:\r
if Operator in ["==", ">=", "<=", ">", "<", '^']:\r
return self.EvalRange(Operator, Oprand1)\r
elif Operator == 'and' :\r
- if not self.ExRegGuidPattern.match(Oprand1.strip()) or not self.ExRegGuidPattern.match(Oprand2.strip()):\r
+ if not gGuidPatternEnd.match(Oprand1.strip()) or not gGuidPatternEnd.match(Oprand2.strip()):\r
raise BadExpression(ERR_STRING_EXPR % Operator)\r
- return self.Rangeintersection(Oprand1, Oprand2) \r
+ return self.Rangeintersection(Oprand1, Oprand2)\r
elif Operator == 'or':\r
- if not self.ExRegGuidPattern.match(Oprand1.strip()) or not self.ExRegGuidPattern.match(Oprand2.strip()):\r
+ if not gGuidPatternEnd.match(Oprand1.strip()) or not gGuidPatternEnd.match(Oprand2.strip()):\r
raise BadExpression(ERR_STRING_EXPR % Operator)\r
return self.Rangecollections(Oprand1, Oprand2)\r
else:\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
self._Len = len(self._Expr)\r
self._Token = ''\r
self._WarnExcept = None\r
- \r
+\r
\r
# Literal token without any conversion\r
self._LiteralToken = ''\r
- \r
+\r
# store the operand object\r
self.operanddict = {}\r
# The Pcd max value depends on PcdDataType\r
self._Depth = Depth\r
\r
self._Expr = self._Expr.strip()\r
- \r
+\r
self.preProcessRangeExpr(self._Expr)\r
- \r
+\r
# check if the expression does not need to evaluate\r
if RealValue and Depth == 0:\r
self._Token = self._Expr\r
- if self.ExRegGuidPattern.match(self._Expr):\r
+ if gGuidPatternEnd.match(self._Expr):\r
return [self.operanddict[self._Expr] ]\r
\r
self._Idx = 0\r
\r
Val = self._OrExpr()\r
RealVal = Val\r
- \r
+\r
RangeIdList = RealVal.split("or")\r
RangeList = []\r
for rangeid in RangeIdList:\r
RangeList.append(self.operanddict[rangeid.strip()])\r
- \r
+\r
return RangeList\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
raise BadExpression(ERR_EMPTY_TOKEN)\r
\r
# PCD token\r
- if self.PcdPattern.match(self._Token):\r
+ if PcdPattern.match(self._Token):\r
if self._Token not in self._Symb:\r
Ex = BadExpression(ERR_PCD_RESOLVE % self._Token)\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
self._LiteralToken.endswith('}'):\r
return True\r
\r
- if self.HexPattern.match(self._LiteralToken):\r
+ if gHexPattern.match(self._LiteralToken):\r
Token = self._LiteralToken[2:]\r
Token = Token.lstrip('0')\r
if not Token:\r
self._Token = ''\r
if Expr:\r
Ch = Expr[0]\r
- Match = self.RegGuidPattern.match(Expr)\r
+ Match = gGuidPattern.match(Expr)\r
if Match and not Expr[Match.end():Match.end() + 1].isalnum() \\r
and Expr[Match.end():Match.end() + 1] != '_':\r
self._Idx += Match.end()\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
projects / mirror_edk2.git / blobdiff