## @file\r
# This file is used to parse and evaluate expression in directive or PCD value.\r
#\r
-# Copyright (c) 2011 - 2016, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 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 __future__ import absolute_import\r
from Common.GlobalData import *\r
from CommonDataClass.Exceptions import BadExpression\r
from CommonDataClass.Exceptions import WrnExpression\r
-from Misc import GuidStringToGuidStructureString\r
+from .Misc import GuidStringToGuidStructureString, ParseFieldValue\r
+import Common.EdkLogger as EdkLogger\r
+import copy\r
+from Common.DataType import *\r
+import sys\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
+__ValidString = re.compile(r'[_a-zA-Z][_0-9a-zA-Z]*$')\r
+_ReLabel = re.compile('LABEL\((\w+)\)')\r
+_ReOffset = re.compile('OFFSET_OF\((\w+)\)')\r
+PcdPattern = re.compile(r'[_a-zA-Z][0-9A-Za-z_]*\.[_a-zA-Z][0-9A-Za-z_]*$')\r
+\r
## SplitString\r
# Split string to list according double quote\r
# For example: abc"de\"f"ghi"jkl"mn will be: ['abc', '"de\"f"', 'ghi', '"jkl"', 'mn']\r
#\r
def SplitString(String):\r
- # There might be escaped quote: "abc\"def\\\"ghi"\r
- Str = String.replace('\\\\', '//').replace('\\\"', '\\\'')\r
+ # There might be escaped quote: "abc\"def\\\"ghi", 'abc\'def\\\'ghi'\r
RetList = []\r
- InQuote = False\r
+ InSingleQuote = False\r
+ InDoubleQuote = False\r
Item = ''\r
- for i, ch in enumerate(Str):\r
- if ch == '"':\r
- InQuote = not InQuote\r
- if not InQuote:\r
+ for i, ch in enumerate(String):\r
+ if ch == '"' and not InSingleQuote:\r
+ if String[i - 1] != '\\':\r
+ InDoubleQuote = not InDoubleQuote\r
+ if not InDoubleQuote:\r
+ Item += String[i]\r
+ RetList.append(Item)\r
+ Item = ''\r
+ continue\r
+ if Item:\r
+ RetList.append(Item)\r
+ Item = ''\r
+ elif ch == "'" and not InDoubleQuote:\r
+ if String[i - 1] != '\\':\r
+ InSingleQuote = not InSingleQuote\r
+ if not InSingleQuote:\r
Item += String[i]\r
RetList.append(Item)\r
Item = ''\r
RetList.append(Item)\r
Item = ''\r
Item += String[i]\r
- if InQuote:\r
+ if InSingleQuote or InDoubleQuote:\r
+ raise BadExpression(ERR_STRING_TOKEN % Item)\r
+ if Item:\r
+ RetList.append(Item)\r
+ return RetList\r
+\r
+def SplitPcdValueString(String):\r
+ # There might be escaped comma in GUID() or DEVICE_PATH() or " "\r
+ # or ' ' or L' ' or L" "\r
+ RetList = []\r
+ InParenthesis = 0\r
+ InSingleQuote = False\r
+ InDoubleQuote = False\r
+ Item = ''\r
+ for i, ch in enumerate(String):\r
+ if ch == '(':\r
+ InParenthesis += 1\r
+ elif ch == ')':\r
+ if InParenthesis:\r
+ InParenthesis -= 1\r
+ else:\r
+ raise BadExpression(ERR_STRING_TOKEN % Item)\r
+ elif ch == '"' and not InSingleQuote:\r
+ if String[i-1] != '\\':\r
+ InDoubleQuote = not InDoubleQuote\r
+ elif ch == "'" and not InDoubleQuote:\r
+ if String[i-1] != '\\':\r
+ InSingleQuote = not InSingleQuote\r
+ elif ch == ',':\r
+ if InParenthesis or InSingleQuote or InDoubleQuote:\r
+ Item += String[i]\r
+ continue\r
+ elif Item:\r
+ RetList.append(Item)\r
+ Item = ''\r
+ continue\r
+ Item += String[i]\r
+ if InSingleQuote or InDoubleQuote or InParenthesis:\r
raise BadExpression(ERR_STRING_TOKEN % Item)\r
if Item:\r
RetList.append(Item)\r
return RetList\r
\r
+def IsValidCName(Str):\r
+ return True if __ValidString.match(Str) else False\r
+\r
+def BuildOptionValue(PcdValue, GuidDict):\r
+ if PcdValue.startswith('H'):\r
+ InputValue = PcdValue[1:]\r
+ elif PcdValue.startswith("L'") or PcdValue.startswith("'"):\r
+ InputValue = PcdValue\r
+ elif PcdValue.startswith('L'):\r
+ InputValue = 'L"' + PcdValue[1:] + '"'\r
+ else:\r
+ InputValue = PcdValue\r
+ try:\r
+ PcdValue = ValueExpressionEx(InputValue, TAB_VOID, GuidDict)(True)\r
+ except:\r
+ pass\r
+\r
+ return PcdValue\r
+\r
## ReplaceExprMacro\r
#\r
def ReplaceExprMacro(String, Macros, ExceptionList = None):\r
InQuote = True\r
MacroStartPos = String.find('$(')\r
if MacroStartPos < 0:\r
- for Pcd in gPlatformPcds.keys():\r
+ for Pcd in gPlatformPcds:\r
if Pcd in String:\r
if Pcd not in gConditionalPcds:\r
gConditionalPcds.append(Pcd)\r
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
StrList[i] = RetStr\r
return ''.join(StrList)\r
\r
+# transfer int to string for in/not in expression\r
+def IntToStr(Value):\r
+ StrList = []\r
+ while Value > 0:\r
+ StrList.append(chr(Value & 0xff))\r
+ Value = Value >> 8\r
+ Value = '"' + ''.join(StrList) + '"'\r
+ return Value\r
+\r
SupportedInMacroList = ['TARGET', 'TOOL_CHAIN_TAG', 'ARCH', 'FAMILY']\r
\r
-class ValueExpression(object):\r
+class BaseExpression(object):\r
+ def __init__(self, *args, **kwargs):\r
+ super(BaseExpression, self).__init__()\r
+\r
+ # Check if current token matches the operators given from parameter\r
+ def _IsOperator(self, OpSet):\r
+ Idx = self._Idx\r
+ self._GetOperator()\r
+ if self._Token in OpSet:\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
+class ValueExpression(BaseExpression):\r
# Logical operator mapping\r
LogicalOperators = {\r
'&&' : 'and', '||' : 'or',\r
'IN' : 'in'\r
}\r
\r
- NonLetterOpLst = ['+', '-', '&', '|', '^', '!', '=', '>', '<']\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
\r
SymbolPattern = re.compile("("\r
"\$\([A-Z][A-Z0-9_]*\)|\$\(\w+\.\w+\)|\w+\.\w+|"\r
def Eval(Operator, Oprand1, Oprand2 = None):\r
WrnExp = None\r
\r
- if Operator not in ["==", "!=", ">=", "<=", ">", "<", "in", "not in"] and \\r
- (type(Oprand1) == type('') or type(Oprand2) == type('')):\r
+ if Operator not in {"==", "!=", ">=", "<=", ">", "<", "in", "not in"} and \\r
+ (isinstance(Oprand1, type('')) or isinstance(Oprand2, type(''))):\r
raise BadExpression(ERR_STRING_EXPR % Operator)\r
-\r
+ if Operator in {'in', 'not in'}:\r
+ if not isinstance(Oprand1, type('')):\r
+ Oprand1 = IntToStr(Oprand1)\r
+ if not isinstance(Oprand2, type('')):\r
+ Oprand2 = IntToStr(Oprand2)\r
TypeDict = {\r
type(0) : 0,\r
- type(0L) : 0,\r
+ # For python2 long type\r
+ type(sys.maxsize + 1) : 0,\r
type('') : 1,\r
type(True) : 2\r
}\r
\r
EvalStr = ''\r
- if Operator in ["!", "NOT", "not"]:\r
- if type(Oprand1) == type(''):\r
+ if Operator in {"!", "NOT", "not"}:\r
+ if isinstance(Oprand1, type('')):\r
raise BadExpression(ERR_STRING_EXPR % Operator)\r
EvalStr = 'not Oprand1'\r
+ elif Operator in {"~"}:\r
+ if isinstance(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 not isinstance(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
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
raise BadExpression(ERR_EXPR_TYPE)\r
- if type(Oprand1) == type('') and type(Oprand2) == type(''):\r
+ if isinstance(Oprand1, type('')) and isinstance(Oprand2, type('')):\r
if (Oprand1.startswith('L"') and not Oprand2.startswith('L"')) or \\r
(not Oprand1.startswith('L"') and Oprand2.startswith('L"')):\r
raise BadExpression(ERR_STRING_CMP % (Oprand1, Operator, Oprand2))\r
- if 'in' in Operator and type(Oprand2) == type(''):\r
+ if 'in' in Operator and isinstance(Oprand2, type('')):\r
Oprand2 = Oprand2.split()\r
EvalStr = 'Oprand1 ' + Operator + ' Oprand2'\r
\r
}\r
try:\r
Val = eval(EvalStr, {}, Dict)\r
- except Exception, Excpt:\r
+ except Exception as 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
return Val\r
\r
def __init__(self, Expression, SymbolTable={}):\r
+ super(ValueExpression, self).__init__(self, Expression, 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
# The symbol table including PCD and macro mapping\r
#\r
- self._Symb = SymbolTable\r
+ self._Symb = copy.deepcopy(SymbolTable)\r
self._Symb.update(self.LogicalOperators)\r
self._Idx = 0\r
self._Len = len(self._Expr)\r
self._Token = self._Expr\r
if self.__IsNumberToken():\r
return self._Expr\r
-\r
+ Token = ''\r
try:\r
Token = self._GetToken()\r
- if type(Token) == type('') and Token.startswith('{') and Token.endswith('}') and self._Idx >= self._Len:\r
- return self._Expr\r
except BadExpression:\r
pass\r
+ if isinstance(Token, type('')) and Token.startswith('{') and Token.endswith('}') and self._Idx >= self._Len:\r
+ return self._Expr\r
\r
self._Idx = 0\r
self._Token = ''\r
\r
- Val = self._OrExpr()\r
+ Val = self._ConExpr()\r
RealVal = Val\r
- if type(Val) == type(''):\r
+ if isinstance(Val, type('')):\r
if Val == 'L""':\r
Val = False\r
elif not Val:\r
Val = False\r
RealVal = '""'\r
- elif not Val.startswith('L"') and not Val.startswith('{'):\r
+ elif not Val.startswith('L"') and not Val.startswith('{') and not Val.startswith("L'"):\r
Val = True\r
RealVal = '"' + RealVal + '"'\r
\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
+ if Op == '?':\r
+ Val2 = EvalFunc()\r
+ if self._IsOperator({':'}):\r
+ Val3 = EvalFunc()\r
+ if Val:\r
+ Val = Val2\r
+ else:\r
+ Val = Val3\r
+ continue\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
+ # A [? B]*\r
+ def _ConExpr(self):\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
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 [ > B]*\r
def _RelExpr(self):\r
- return self._ExprFuncTemplate(self._AddExpr, ["<=", ">=", "<", ">", "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
\r
# A [ + B]*\r
def _AddExpr(self):\r
- return self._ExprFuncTemplate(self._UnaryExpr, ["+", "-"])\r
+ return self._ExprFuncTemplate(self._MulExpr, {"+", "-"})\r
+\r
+ # A [ * B]*\r
+ def _MulExpr(self):\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
+ except WrnExpression as Warn:\r
+ self._WarnExcept = Warn\r
+ return Warn.result\r
+ if self._IsOperator({"~"}):\r
+ Val = self._UnaryExpr()\r
+ try:\r
+ return self.Eval('~', Val)\r
+ except WrnExpression as Warn:\r
self._WarnExcept = Warn\r
return Warn.result\r
return self._IdenExpr()\r
def _IdenExpr(self):\r
Tk = self._GetToken()\r
if Tk == '(':\r
- Val = self._OrExpr()\r
+ Val = self._ConExpr()\r
try:\r
# _GetToken may also raise BadExpression\r
if self._GetToken() != ')':\r
Radix = 10\r
if self._Token.lower()[0:2] == '0x' and len(self._Token) > 2:\r
Radix = 16\r
+ 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 - 1] == '\\':\r
+ continue\r
+ Flag += 1\r
+ if Flag == 2 and self._Token.endswith('"'):\r
+ return True\r
+ 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 - 1] == '\\':\r
+ continue\r
+ Flag += 1\r
+ if Flag == 2 and self._Token.endswith("'"):\r
+ return True\r
try:\r
self._Token = int(self._Token, Radix)\r
return True\r
IsArray = IsGuid = False\r
if len(Token.split(',')) == 11 and len(Token.split(',{')) == 2 \\r
and len(Token.split('},')) == 1:\r
- HexLen = [11,6,6,5,4,4,4,4,4,4,6]\r
+ HexLen = [11, 6, 6, 5, 4, 4, 4, 4, 4, 4, 6]\r
HexList= Token.split(',')\r
if HexList[3].startswith('{') and \\r
not [Index for Index, Hex in enumerate(HexList) if len(Hex) > HexLen[Index]]:\r
self._Idx += 1\r
\r
# Replace escape \\\", \"\r
- Expr = self._Expr[self._Idx:].replace('\\\\', '//').replace('\\\"', '\\\'')\r
- for Ch in Expr:\r
- self._Idx += 1\r
- if Ch == '"':\r
- break\r
- self._Token = self._LiteralToken = self._Expr[Idx:self._Idx]\r
- if not self._Token.endswith('"'):\r
- raise BadExpression(ERR_STRING_TOKEN % self._Token)\r
+ if self._Expr[Idx] == '"':\r
+ Expr = self._Expr[self._Idx:].replace('\\\\', '//').replace('\\\"', '\\\'')\r
+ for Ch in Expr:\r
+ self._Idx += 1\r
+ if Ch == '"':\r
+ break\r
+ self._Token = self._LiteralToken = self._Expr[Idx:self._Idx]\r
+ if not self._Token.endswith('"'):\r
+ raise BadExpression(ERR_STRING_TOKEN % self._Token)\r
+ #Replace escape \\\', \'\r
+ elif self._Expr[Idx] == "'":\r
+ Expr = self._Expr[self._Idx:].replace('\\\\', '//').replace("\\\'", "\\\"")\r
+ for Ch in Expr:\r
+ self._Idx += 1\r
+ if Ch == "'":\r
+ break\r
+ self._Token = self._LiteralToken = self._Expr[Idx:self._Idx]\r
+ if not self._Token.endswith("'"):\r
+ raise BadExpression(ERR_STRING_TOKEN % self._Token)\r
self._Token = self._Token[1:-1]\r
return self._Token\r
\r
def __GetIdToken(self, IsAlphaOp = False):\r
IdToken = ''\r
for Ch in self._Expr[self._Idx:]:\r
- if not self.__IsIdChar(Ch):\r
+ if not self.__IsIdChar(Ch) or ('?' in self._Expr and Ch == ':'):\r
break\r
self._Idx += 1\r
IdToken += Ch\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 = ValueExpression(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
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
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._LiteralToken = '0x0'\r
else:\r
- self._LiteralToken = '0x' + Token.lower()\r
+ self._LiteralToken = '0x' + Token\r
return True\r
return False\r
\r
\r
@staticmethod\r
def __IsIdChar(Ch):\r
- return Ch in '._/:' or Ch.isalnum()\r
+ return Ch in '._:' or Ch.isalnum()\r
\r
# Parse operand\r
def _GetSingleToken(self):\r
UStr = self.__GetString()\r
self._Token = 'L"' + UStr + '"'\r
return self._Token\r
+ elif Expr.startswith("L'"):\r
+ # Skip L\r
+ self._Idx += 1\r
+ UStr = self.__GetString()\r
+ self._Token = "L'" + UStr + "'"\r
+ return self._Token\r
+ elif Expr.startswith("'"):\r
+ UStr = self.__GetString()\r
+ self._Token = "'" + UStr + "'"\r
+ return self._Token\r
+ elif Expr.startswith('UINT'):\r
+ Re = re.compile('(?:UINT8|UINT16|UINT32|UINT64)\((.+)\)')\r
+ try:\r
+ RetValue = Re.search(Expr).group(1)\r
+ except:\r
+ raise BadExpression('Invalid Expression %s' % Expr)\r
+ Idx = self._Idx\r
+ for Ch in Expr:\r
+ self._Idx += 1\r
+ if Ch == '(':\r
+ Prefix = self._Expr[Idx:self._Idx - 1]\r
+ Idx = self._Idx\r
+ if Ch == ')':\r
+ TmpValue = self._Expr[Idx :self._Idx - 1]\r
+ TmpValue = ValueExpression(TmpValue)(True)\r
+ TmpValue = '0x%x' % int(TmpValue) if not isinstance(TmpValue, type('')) else TmpValue\r
+ break\r
+ self._Token, Size = ParseFieldValue(Prefix + '(' + TmpValue + ')')\r
+ return self._Token\r
\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
# Parse operator\r
def _GetOperator(self):\r
self.__SkipWS()\r
- LegalOpLst = ['&&', '||', '!=', '==', '>=', '<='] + self.NonLetterOpLst\r
+ LegalOpLst = ['&&', '||', '!=', '==', '>=', '<='] + self.NonLetterOpLst + ['?', ':']\r
\r
self._Token = ''\r
Expr = self._Expr[self._Idx:]\r
OpToken = ''\r
for Ch in Expr:\r
if Ch in self.NonLetterOpLst:\r
- if '!' == Ch and OpToken:\r
+ if Ch in ['!', '~'] and OpToken:\r
break\r
self._Idx += 1\r
OpToken += Ch\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
+class ValueExpressionEx(ValueExpression):\r
+ def __init__(self, PcdValue, PcdType, SymbolTable={}):\r
+ ValueExpression.__init__(self, PcdValue, SymbolTable)\r
+ self.PcdValue = PcdValue\r
+ self.PcdType = PcdType\r
+\r
+ def __call__(self, RealValue=False, Depth=0):\r
+ PcdValue = self.PcdValue\r
+ try:\r
+ PcdValue = ValueExpression.__call__(self, RealValue, Depth)\r
+ if self.PcdType == TAB_VOID and (PcdValue.startswith("'") or PcdValue.startswith("L'")):\r
+ PcdValue, Size = ParseFieldValue(PcdValue)\r
+ PcdValueList = []\r
+ for I in range(Size):\r
+ PcdValueList.append('0x%02X'%(PcdValue & 0xff))\r
+ PcdValue = PcdValue >> 8\r
+ PcdValue = '{' + ','.join(PcdValueList) + '}'\r
+ elif self.PcdType in TAB_PCD_NUMERIC_TYPES and (PcdValue.startswith("'") or \\r
+ PcdValue.startswith('"') or PcdValue.startswith("L'") or PcdValue.startswith('L"') or PcdValue.startswith('{')):\r
+ raise BadExpression\r
+ except WrnExpression as Value:\r
+ PcdValue = Value.result\r
+ except BadExpression as Value:\r
+ if self.PcdType in TAB_PCD_NUMERIC_TYPES:\r
+ PcdValue = PcdValue.strip()\r
+ if PcdValue.startswith('{') and PcdValue.endswith('}'):\r
+ PcdValue = SplitPcdValueString(PcdValue[1:-1])\r
+ if isinstance(PcdValue, type([])):\r
+ TmpValue = 0\r
+ Size = 0\r
+ ValueType = ''\r
+ for Item in PcdValue:\r
+ Item = Item.strip()\r
+ if Item.startswith(TAB_UINT8):\r
+ ItemSize = 1\r
+ ValueType = TAB_UINT8\r
+ elif Item.startswith(TAB_UINT16):\r
+ ItemSize = 2\r
+ ValueType = TAB_UINT16\r
+ elif Item.startswith(TAB_UINT32):\r
+ ItemSize = 4\r
+ ValueType = TAB_UINT32\r
+ elif Item.startswith(TAB_UINT64):\r
+ ItemSize = 8\r
+ ValueType = TAB_UINT64\r
+ elif Item[0] in {'"', "'", 'L'}:\r
+ ItemSize = 0\r
+ ValueType = TAB_VOID\r
+ else:\r
+ ItemSize = 0\r
+ ValueType = TAB_UINT8\r
+ Item = ValueExpressionEx(Item, ValueType, self._Symb)(True)\r
+\r
+ if ItemSize == 0:\r
+ try:\r
+ tmpValue = int(Item, 0)\r
+ if tmpValue > 255:\r
+ raise BadExpression("Byte array number %s should less than 0xFF." % Item)\r
+ except BadExpression as Value:\r
+ raise BadExpression(Value)\r
+ except ValueError:\r
+ pass\r
+ ItemValue, ItemSize = ParseFieldValue(Item)\r
+ else:\r
+ ItemValue = ParseFieldValue(Item)[0]\r
+\r
+ if isinstance(ItemValue, type('')):\r
+ ItemValue = int(ItemValue, 0)\r
+\r
+ TmpValue = (ItemValue << (Size * 8)) | TmpValue\r
+ Size = Size + ItemSize\r
+ else:\r
+ try:\r
+ TmpValue, Size = ParseFieldValue(PcdValue)\r
+ except BadExpression as Value:\r
+ raise BadExpression("Type: %s, Value: %s, %s" % (self.PcdType, PcdValue, Value))\r
+ if isinstance(TmpValue, type('')):\r
+ try:\r
+ TmpValue = int(TmpValue)\r
+ except:\r
+ raise BadExpression(Value)\r
+ else:\r
+ PcdValue = '0x%0{}X'.format(Size) % (TmpValue)\r
+ if TmpValue < 0:\r
+ raise BadExpression('Type %s PCD Value is negative' % self.PcdType)\r
+ if self.PcdType == TAB_UINT8 and Size > 1:\r
+ raise BadExpression('Type %s PCD Value Size is Larger than 1 byte' % self.PcdType)\r
+ if self.PcdType == TAB_UINT16 and Size > 2:\r
+ raise BadExpression('Type %s PCD Value Size is Larger than 2 byte' % self.PcdType)\r
+ if self.PcdType == TAB_UINT32 and Size > 4:\r
+ raise BadExpression('Type %s PCD Value Size is Larger than 4 byte' % self.PcdType)\r
+ if self.PcdType == TAB_UINT64 and Size > 8:\r
+ raise BadExpression('Type %s PCD Value Size is Larger than 8 byte' % self.PcdType)\r
+ else:\r
+ try:\r
+ TmpValue = int(PcdValue)\r
+ TmpList = []\r
+ if TmpValue.bit_length() == 0:\r
+ PcdValue = '{0x00}'\r
+ else:\r
+ for I in range((TmpValue.bit_length() + 7) / 8):\r
+ TmpList.append('0x%02x' % ((TmpValue >> I * 8) & 0xff))\r
+ PcdValue = '{' + ', '.join(TmpList) + '}'\r
+ except:\r
+ if PcdValue.strip().startswith('{'):\r
+ PcdValueList = SplitPcdValueString(PcdValue.strip()[1:-1])\r
+ LabelDict = {}\r
+ NewPcdValueList = []\r
+ LabelOffset = 0\r
+ for Item in PcdValueList:\r
+ # compute byte offset of every LABEL\r
+ LabelList = _ReLabel.findall(Item)\r
+ Item = _ReLabel.sub('', Item)\r
+ Item = Item.strip()\r
+ if LabelList:\r
+ for Label in LabelList:\r
+ if not IsValidCName(Label):\r
+ raise BadExpression('%s is not a valid c variable name' % Label)\r
+ if Label not in LabelDict:\r
+ LabelDict[Label] = str(LabelOffset)\r
+ if Item.startswith(TAB_UINT8):\r
+ LabelOffset = LabelOffset + 1\r
+ elif Item.startswith(TAB_UINT16):\r
+ LabelOffset = LabelOffset + 2\r
+ elif Item.startswith(TAB_UINT32):\r
+ LabelOffset = LabelOffset + 4\r
+ elif Item.startswith(TAB_UINT64):\r
+ LabelOffset = LabelOffset + 8\r
+ else:\r
+ try:\r
+ ItemValue, ItemSize = ParseFieldValue(Item)\r
+ LabelOffset = LabelOffset + ItemSize\r
+ except:\r
+ LabelOffset = LabelOffset + 1\r
+\r
+ for Item in PcdValueList:\r
+ # for LABEL parse\r
+ Item = Item.strip()\r
+ try:\r
+ Item = _ReLabel.sub('', Item)\r
+ except:\r
+ pass\r
+ try:\r
+ OffsetList = _ReOffset.findall(Item)\r
+ except:\r
+ pass\r
+ # replace each offset, except errors\r
+ for Offset in OffsetList:\r
+ try:\r
+ Item = Item.replace('OFFSET_OF({})'.format(Offset), LabelDict[Offset])\r
+ except:\r
+ raise BadExpression('%s not defined' % Offset)\r
+\r
+ NewPcdValueList.append(Item)\r
+\r
+ AllPcdValueList = []\r
+ for Item in NewPcdValueList:\r
+ Size = 0\r
+ ValueStr = ''\r
+ TokenSpaceGuidName = ''\r
+ if Item.startswith(TAB_GUID) and Item.endswith(')'):\r
+ try:\r
+ TokenSpaceGuidName = re.search('GUID\((\w+)\)', Item).group(1)\r
+ except:\r
+ pass\r
+ if TokenSpaceGuidName and TokenSpaceGuidName in self._Symb:\r
+ Item = 'GUID(' + self._Symb[TokenSpaceGuidName] + ')'\r
+ elif TokenSpaceGuidName:\r
+ raise BadExpression('%s not found in DEC file' % TokenSpaceGuidName)\r
+ Item, Size = ParseFieldValue(Item)\r
+ for Index in range(0, Size):\r
+ ValueStr = '0x%02X' % (int(Item) & 255)\r
+ Item >>= 8\r
+ AllPcdValueList.append(ValueStr)\r
+ continue\r
+ elif Item.startswith('DEVICE_PATH') and Item.endswith(')'):\r
+ Item, Size = ParseFieldValue(Item)\r
+ AllPcdValueList.append(Item[1:-1])\r
+ continue\r
+ else:\r
+ ValueType = ""\r
+ if Item.startswith(TAB_UINT8):\r
+ ItemSize = 1\r
+ ValueType = TAB_UINT8\r
+ elif Item.startswith(TAB_UINT16):\r
+ ItemSize = 2\r
+ ValueType = TAB_UINT16\r
+ elif Item.startswith(TAB_UINT32):\r
+ ItemSize = 4\r
+ ValueType = TAB_UINT32\r
+ elif Item.startswith(TAB_UINT64):\r
+ ItemSize = 8\r
+ ValueType = TAB_UINT64\r
+ else:\r
+ ItemSize = 0\r
+ if ValueType:\r
+ TmpValue = ValueExpressionEx(Item, ValueType, self._Symb)(True)\r
+ else:\r
+ TmpValue = ValueExpressionEx(Item, self.PcdType, self._Symb)(True)\r
+ Item = '0x%x' % TmpValue if not isinstance(TmpValue, type('')) else TmpValue\r
+ if ItemSize == 0:\r
+ ItemValue, ItemSize = ParseFieldValue(Item)\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
+ for I in range(0, ItemSize):\r
+ ValueStr = '0x%02X' % (int(ItemValue) & 255)\r
+ ItemValue >>= 8\r
+ AllPcdValueList.append(ValueStr)\r
+ Size += ItemSize\r
+\r
+ if Size > 0:\r
+ PcdValue = '{' + ','.join(AllPcdValueList) + '}'\r
+ else:\r
+ raise BadExpression("Type: %s, Value: %s, %s"%(self.PcdType, PcdValue, Value))\r
+\r
+ if PcdValue == 'True':\r
+ PcdValue = '1'\r
+ if PcdValue == 'False':\r
+ PcdValue = '0'\r
+\r
+ if RealValue:\r
+ return PcdValue\r
\r
if __name__ == '__main__':\r
pass\r
if input in 'qQ':\r
break\r
try:\r
- print ValueExpression(input)(True)\r
- print ValueExpression(input)(False)\r
- except WrnExpression, Ex:\r
- print Ex.result\r
- print str(Ex)\r
- except Exception, Ex:\r
- print str(Ex)\r
+ print(ValueExpression(input)(True))\r
+ print(ValueExpression(input)(False))\r
+ except WrnExpression as Ex:\r
+ print(Ex.result)\r
+ print(str(Ex))\r
+ except Exception as Ex:\r
+ print(str(Ex))\r