]> git.proxmox.com Git - mirror_edk2.git/blame - BaseTools/Source/Python/Common/Expression.py
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
BaseTools: Unify long and int in Expression.py
[mirror_edk2.git] / BaseTools / Source / Python / Common / Expression.py
CommitLineData
0d2711a6
LG		 1## @file\r
2# This file is used to parse and evaluate expression in directive or PCD value.\r
3#\r
35f613d9 4# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>\r
0d2711a6
LG		 5# This program and the accompanying materials\r
6# are licensed and made available under the terms and conditions of the BSD License\r
7# which accompanies this distribution. The full text of the license may be found at\r
8# http://opensource.org/licenses/bsd-license.php\r
9#\r
10# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
11# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
12\r
13## Import Modules\r
14#\r
72443dd2 15from __future__ import print_function\r
0d2711a6
LG		 16from Common.GlobalData import *\r
17from CommonDataClass.Exceptions import BadExpression\r
0d2711a6 18from CommonDataClass.Exceptions import WrnExpression\r
8565b582 19from Misc import GuidStringToGuidStructureString, ParseFieldValue, IsFieldValueAnArray\r
726c501c
YZ		 20import Common.EdkLogger as EdkLogger\r
21import copy\r
656d2539 22from Common.DataType import *\r
39456d00 23import sys\r
0d2711a6
LG		 24\r
25ERR_STRING_EXPR = 'This operator cannot be used in string expression: [%s].'\r
26ERR_SNYTAX = 'Syntax error, the rest of expression cannot be evaluated: [%s].'\r
27ERR_MATCH = 'No matching right parenthesis.'\r
28ERR_STRING_TOKEN = 'Bad string token: [%s].'\r
29ERR_MACRO_TOKEN = 'Bad macro token: [%s].'\r
30ERR_EMPTY_TOKEN = 'Empty token is not allowed.'\r
31ERR_PCD_RESOLVE = 'PCD token cannot be resolved: [%s].'\r
32ERR_VALID_TOKEN = 'No more valid token found from rest of string: [%s].'\r
33ERR_EXPR_TYPE = 'Different types found in expression.'\r
34ERR_OPERATOR_UNSUPPORT = 'Unsupported operator: [%s]'\r
35ERR_REL_NOT_IN = 'Expect "IN" after "not" operator.'\r
36WRN_BOOL_EXPR = 'Operand of boolean type cannot be used in arithmetic expression.'\r
37WRN_EQCMP_STR_OTHERS = '== Comparison between Operand of string type and Boolean/Number Type always return False.'\r
38WRN_NECMP_STR_OTHERS = '!= Comparison between Operand of string type and Boolean/Number Type always return True.'\r
39ERR_RELCMP_STR_OTHERS = 'Operator taking Operand of string type and Boolean/Number Type is not allowed: [%s].'\r
40ERR_STRING_CMP = 'Unicode string and general string cannot be compared: [%s %s %s]'\r
41ERR_ARRAY_TOKEN = 'Bad C array or C format GUID token: [%s].'\r
42ERR_ARRAY_ELE = 'This must be HEX value for NList or Array: [%s].'\r
d0acc87a 43ERR_EMPTY_EXPR = 'Empty expression is not allowed.'\r
64b2609f 44ERR_IN_OPERAND = 'Macro after IN operator can only be: $(FAMILY), $(ARCH), $(TOOL_CHAIN_TAG) and $(TARGET).'\r
0d2711a6 45\r
1f901a89 46__ValidString = re.compile(r'[_a-zA-Z][_0-9a-zA-Z]*$')\r
38504ad3
CJ		 47_ReLabel = re.compile('LABEL\((\w+)\)')\r
48_ReOffset = re.compile('OFFSET_OF\((\w+)\)')\r
e6c2468a 49PcdPattern = re.compile(r'[_a-zA-Z][0-9A-Za-z_]*\.[_a-zA-Z][0-9A-Za-z_]*$')\r
1f901a89 50\r
0d2711a6
LG		 51## SplitString\r
52# Split string to list according double quote\r
53# For example: abc"de\"f"ghi"jkl"mn will be: ['abc', '"de\"f"', 'ghi', '"jkl"', 'mn']\r
54#\r
55def SplitString(String):\r
ea927d2f 56 # There might be escaped quote: "abc\"def\\\"ghi", 'abc\'def\\\'ghi'\r
0d2711a6 57 RetList = []\r
ea927d2f
FY		 58 InSingleQuote = False\r
59 InDoubleQuote = False\r
0d2711a6 60 Item = ''\r
ae4cc2b0 61 for i, ch in enumerate(String):\r
ea927d2f 62 if ch == '"' and not InSingleQuote:\r
ae4cc2b0 63 if String[i - 1] != '\\':\r
ea927d2f
FY		 64 InDoubleQuote = not InDoubleQuote\r
65 if not InDoubleQuote:\r
66 Item += String[i]\r
67 RetList.append(Item)\r
68 Item = ''\r
69 continue\r
70 if Item:\r
71 RetList.append(Item)\r
72 Item = ''\r
73 elif ch == "'" and not InDoubleQuote:\r
ae4cc2b0 74 if String[i - 1] != '\\':\r
ea927d2f
FY		 75 InSingleQuote = not InSingleQuote\r
76 if not InSingleQuote:\r
0d2711a6
LG		 77 Item += String[i]\r
78 RetList.append(Item)\r
79 Item = ''\r
80 continue\r
81 if Item:\r
82 RetList.append(Item)\r
83 Item = ''\r
84 Item += String[i]\r
ea927d2f 85 if InSingleQuote or InDoubleQuote:\r
0d2711a6
LG		 86 raise BadExpression(ERR_STRING_TOKEN % Item)\r
87 if Item:\r
88 RetList.append(Item)\r
89 return RetList\r
90\r
3be421e9
FY		 91def SplitPcdValueString(String):\r
92 # There might be escaped comma in GUID() or DEVICE_PATH() or " "\r
93 # or ' ' or L' ' or L" "\r
3be421e9
FY		 94 RetList = []\r
95 InParenthesis = 0\r
96 InSingleQuote = False\r
97 InDoubleQuote = False\r
98 Item = ''\r
ae4cc2b0 99 for i, ch in enumerate(String):\r
3be421e9
FY		 100 if ch == '(':\r
101 InParenthesis += 1\r
3e8bab96 102 elif ch == ')':\r
3be421e9
FY		 103 if InParenthesis:\r
104 InParenthesis -= 1\r
105 else:\r
106 raise BadExpression(ERR_STRING_TOKEN % Item)\r
3e8bab96 107 elif ch == '"' and not InSingleQuote:\r
3be421e9
FY		 108 if String[i-1] != '\\':\r
109 InDoubleQuote = not InDoubleQuote\r
3e8bab96 110 elif ch == "'" and not InDoubleQuote:\r
3be421e9
FY		 111 if String[i-1] != '\\':\r
112 InSingleQuote = not InSingleQuote\r
3e8bab96 113 elif ch == ',':\r
3be421e9
FY		 114 if InParenthesis or InSingleQuote or InDoubleQuote:\r
115 Item += String[i]\r
116 continue\r
117 elif Item:\r
118 RetList.append(Item)\r
119 Item = ''\r
120 continue\r
121 Item += String[i]\r
122 if InSingleQuote or InDoubleQuote or InParenthesis:\r
123 raise BadExpression(ERR_STRING_TOKEN % Item)\r
124 if Item:\r
125 RetList.append(Item)\r
126 return RetList\r
127\r
1f901a89
CJ		 128def IsValidCName(Str):\r
129 return True if __ValidString.match(Str) else False\r
5ac0a545 130\r
8565b582 131def BuildOptionValue(PcdValue, GuidDict):\r
8565b582
YZ		 132 if PcdValue.startswith('H'):\r
133 InputValue = PcdValue[1:]\r
134 elif PcdValue.startswith("L'") or PcdValue.startswith("'"):\r
135 InputValue = PcdValue\r
136 elif PcdValue.startswith('L'):\r
137 InputValue = 'L"' + PcdValue[1:] + '"'\r
138 else:\r
139 InputValue = PcdValue\r
140 if IsFieldValueAnArray(InputValue):\r
8565b582 141 try:\r
656d2539 142 PcdValue = ValueExpressionEx(InputValue, TAB_VOID, GuidDict)(True)\r
8565b582
YZ		 143 except:\r
144 pass\r
145 return PcdValue\r
146\r
0d2711a6
LG		 147## ReplaceExprMacro\r
148#\r
149def ReplaceExprMacro(String, Macros, ExceptionList = None):\r
150 StrList = SplitString(String)\r
151 for i, String in enumerate(StrList):\r
152 InQuote = False\r
153 if String.startswith('"'):\r
154 InQuote = True\r
155 MacroStartPos = String.find('$(')\r
156 if MacroStartPos < 0:\r
9eb87141 157 for Pcd in gPlatformPcds:\r
c8d07c5e
YZ		 158 if Pcd in String:\r
159 if Pcd not in gConditionalPcds:\r
160 gConditionalPcds.append(Pcd)\r
0d2711a6
LG		 161 continue\r
162 RetStr = ''\r
163 while MacroStartPos >= 0:\r
164 RetStr = String[0:MacroStartPos]\r
165 MacroEndPos = String.find(')', MacroStartPos)\r
166 if MacroEndPos < 0:\r
167 raise BadExpression(ERR_MACRO_TOKEN % String[MacroStartPos:])\r
168 Macro = String[MacroStartPos+2:MacroEndPos]\r
169 if Macro not in Macros:\r
170 # From C reference manual:\r
171 # If an undefined macro name appears in the constant-expression of\r
172 # !if or !elif, it is replaced by the integer constant 0.\r
173 RetStr += '0'\r
64b2609f
LG		 174 elif not InQuote:\r
175 Tklst = RetStr.split()\r
4d601fc6 176 if Tklst and Tklst[-1] in {'IN', 'in'} and ExceptionList and Macro not in ExceptionList:\r
64b2609f 177 raise BadExpression(ERR_IN_OPERAND)\r
0d2711a6
LG		 178 # Make sure the macro in exception list is encapsulated by double quote\r
179 # For example: DEFINE ARCH = IA32 X64\r
180 # $(ARCH) is replaced with "IA32 X64"\r
64b2609f
LG		 181 if ExceptionList and Macro in ExceptionList:\r
182 RetStr += '"' + Macros[Macro] + '"'\r
183 elif Macros[Macro].strip():\r
0d2711a6
LG		 184 RetStr += Macros[Macro]\r
185 else:\r
186 RetStr += '""'\r
64b2609f
LG		 187 else:\r
188 RetStr += Macros[Macro]\r
0d2711a6
LG		 189 RetStr += String[MacroEndPos+1:]\r
190 String = RetStr\r
191 MacroStartPos = String.find('$(')\r
192 StrList[i] = RetStr\r
193 return ''.join(StrList)\r
194\r
726c501c
YZ		 195# transfer int to string for in/not in expression\r
196def IntToStr(Value):\r
197 StrList = []\r
198 while Value > 0:\r
199 StrList.append(chr(Value & 0xff))\r
200 Value = Value >> 8\r
201 Value = '"' + ''.join(StrList) + '"'\r
202 return Value\r
203\r
64b2609f
LG		 204SupportedInMacroList = ['TARGET', 'TOOL_CHAIN_TAG', 'ARCH', 'FAMILY']\r
205\r
b2aeaf57
CJ		 206class BaseExpression(object):\r
207 def __init__(self, *args, **kwargs):\r
208 super(BaseExpression, self).__init__()\r
209\r
210 # Check if current token matches the operators given from parameter\r
211 def _IsOperator(self, OpSet):\r
212 Idx = self._Idx\r
213 self._GetOperator()\r
214 if self._Token in OpSet:\r
215 if self._Token in self.LogicalOperators:\r
216 self._Token = self.LogicalOperators[self._Token]\r
217 return True\r
218 self._Idx = Idx\r
219 return False\r
220\r
221class ValueExpression(BaseExpression):\r
0d2711a6
LG		 222 # Logical operator mapping\r
223 LogicalOperators = {\r
224 '&&' : 'and', '||' : 'or',\r
225 '!' : 'not', 'AND': 'and',\r
226 'OR' : 'or' , 'NOT': 'not',\r
227 'XOR': '^' , 'xor': '^',\r
228 'EQ' : '==' , 'NE' : '!=',\r
229 'GT' : '>' , 'LT' : '<',\r
230 'GE' : '>=' , 'LE' : '<=',\r
231 'IN' : 'in'\r
232 }\r
233\r
bc0d7233 234 NonLetterOpLst = ['+', '-', '*', '/', '%', '&', '|', '^', '~', '<<', '>>', '!', '=', '>', '<', '?', ':']\r
0d2711a6 235\r
0d2711a6
LG		 236\r
237 SymbolPattern = re.compile("("\r
238 "\$\([A-Z][A-Z0-9_]*\)|\$\(\w+\.\w+\)|\w+\.\w+|"\r
239 "&&|\|\||!(?!=)|"\r
240 "(?<=\W)AND(?=\W)|(?<=\W)OR(?=\W)|(?<=\W)NOT(?=\W)|(?<=\W)XOR(?=\W)|"\r
241 "(?<=\W)EQ(?=\W)|(?<=\W)NE(?=\W)|(?<=\W)GT(?=\W)|(?<=\W)LT(?=\W)|(?<=\W)GE(?=\W)|(?<=\W)LE(?=\W)"\r
242 ")")\r
243\r
244 @staticmethod\r
245 def Eval(Operator, Oprand1, Oprand2 = None):\r
246 WrnExp = None\r
d0acc87a 247\r
4d601fc6 248 if Operator not in {"==", "!=", ">=", "<=", ">", "<", "in", "not in"} and \\r
0d1f5b2b 249 (isinstance(Oprand1, type('')) or isinstance(Oprand2, type(''))):\r
9efe8d60 250 raise BadExpression(ERR_STRING_EXPR % Operator)\r
4d601fc6 251 if Operator in {'in', 'not in'}:\r
0d1f5b2b 252 if not isinstance(Oprand1, type('')):\r
726c501c 253 Oprand1 = IntToStr(Oprand1)\r
0d1f5b2b 254 if not isinstance(Oprand2, type('')):\r
726c501c 255 Oprand2 = IntToStr(Oprand2)\r
0d2711a6
LG		 256 TypeDict = {\r
257 type(0) : 0,\r
39456d00
GL		 258 # For python2 long type\r
259 type(sys.maxsize + 1) : 0,\r
0d2711a6
LG		 260 type('') : 1,\r
261 type(True) : 2\r
262 }\r
263\r
264 EvalStr = ''\r
4d601fc6 265 if Operator in {"!", "NOT", "not"}:\r
0d1f5b2b 266 if isinstance(Oprand1, type('')):\r
0d2711a6
LG		 267 raise BadExpression(ERR_STRING_EXPR % Operator)\r
268 EvalStr = 'not Oprand1'\r
4d601fc6 269 elif Operator in {"~"}:\r
0d1f5b2b 270 if isinstance(Oprand1, type('')):\r
5e06f1a0
YZ		 271 raise BadExpression(ERR_STRING_EXPR % Operator)\r
272 EvalStr = '~ Oprand1'\r
0d2711a6 273 else:\r
4d601fc6 274 if Operator in {"+", "-"} and (type(True) in {type(Oprand1), type(Oprand2)}):\r
0d2711a6
LG		 275 # Boolean in '+'/'-' will be evaluated but raise warning\r
276 WrnExp = WrnExpression(WRN_BOOL_EXPR)\r
0d1f5b2b 277 elif type('') in {type(Oprand1), type(Oprand2)} and not isinstance(Oprand1, type(Oprand2)):\r
0d2711a6
LG		 278 # == between string and number/boolean will always return False, != return True\r
279 if Operator == "==":\r
280 WrnExp = WrnExpression(WRN_EQCMP_STR_OTHERS)\r
281 WrnExp.result = False\r
282 raise WrnExp\r
283 elif Operator == "!=":\r
284 WrnExp = WrnExpression(WRN_NECMP_STR_OTHERS)\r
285 WrnExp.result = True\r
286 raise WrnExp\r
287 else:\r
288 raise BadExpression(ERR_RELCMP_STR_OTHERS % Operator)\r
d0acc87a 289 elif TypeDict[type(Oprand1)] != TypeDict[type(Oprand2)]:\r
4d601fc6 290 if Operator in {"==", "!=", ">=", "<=", ">", "<"} and set((TypeDict[type(Oprand1)], TypeDict[type(Oprand2)])) == set((TypeDict[type(True)], TypeDict[type(0)])):\r
0d2711a6
LG		 291 # comparison between number and boolean is allowed\r
292 pass\r
4d601fc6 293 elif Operator in {'&', '|', '^', "and", "or"} and set((TypeDict[type(Oprand1)], TypeDict[type(Oprand2)])) == set((TypeDict[type(True)], TypeDict[type(0)])):\r
0d2711a6 294 # bitwise and logical operation between number and boolean is allowed\r
d0acc87a 295 pass\r
0d2711a6
LG		 296 else:\r
297 raise BadExpression(ERR_EXPR_TYPE)\r
0d1f5b2b 298 if isinstance(Oprand1, type('')) and isinstance(Oprand2, type('')):\r
0d2711a6
LG		 299 if (Oprand1.startswith('L"') and not Oprand2.startswith('L"')) or \\r
300 (not Oprand1.startswith('L"') and Oprand2.startswith('L"')):\r
301 raise BadExpression(ERR_STRING_CMP % (Oprand1, Operator, Oprand2))\r
0d1f5b2b 302 if 'in' in Operator and isinstance(Oprand2, type('')):\r
0d2711a6
LG		 303 Oprand2 = Oprand2.split()\r
304 EvalStr = 'Oprand1 ' + Operator + ' Oprand2'\r
305\r
306 # Local symbols used by built in eval function\r
307 Dict = {\r
308 'Oprand1' : Oprand1,\r
309 'Oprand2' : Oprand2\r
310 }\r
311 try:\r
312 Val = eval(EvalStr, {}, Dict)\r
5b0671c1 313 except Exception as Excpt:\r
0d2711a6
LG		 314 raise BadExpression(str(Excpt))\r
315\r
4d601fc6 316 if Operator in {'and', 'or'}:\r
0d2711a6
LG		 317 if Val:\r
318 Val = True\r
319 else:\r
320 Val = False\r
d0acc87a 321\r
0d2711a6
LG		 322 if WrnExp:\r
323 WrnExp.result = Val\r
324 raise WrnExp\r
325 return Val\r
326\r
327 def __init__(self, Expression, SymbolTable={}):\r
b2aeaf57 328 super(ValueExpression, self).__init__(self, Expression, SymbolTable)\r
0d2711a6 329 self._NoProcess = False\r
0d1f5b2b 330 if not isinstance(Expression, type('')):\r
0d2711a6
LG		 331 self._Expr = Expression\r
332 self._NoProcess = True\r
333 return\r
334\r
335 self._Expr = ReplaceExprMacro(Expression.strip(),\r
336 SymbolTable,\r
64b2609f 337 SupportedInMacroList)\r
0d2711a6
LG		 338\r
339 if not self._Expr.strip():\r
d0acc87a 340 raise BadExpression(ERR_EMPTY_EXPR)\r
0d2711a6
LG		 341\r
342 #\r
343 # The symbol table including PCD and macro mapping\r
344 #\r
726c501c 345 self._Symb = copy.deepcopy(SymbolTable)\r
0d2711a6
LG		 346 self._Symb.update(self.LogicalOperators)\r
347 self._Idx = 0\r
348 self._Len = len(self._Expr)\r
349 self._Token = ''\r
d0acc87a 350 self._WarnExcept = None\r
0d2711a6
LG		 351\r
352 # Literal token without any conversion\r
353 self._LiteralToken = ''\r
354\r
355 # Public entry for this class\r
d0acc87a
LG		 356 # @param RealValue: False: only evaluate if the expression is true or false, used for conditional expression\r
357 # True : return the evaluated str(value), used for PCD value\r
358 #\r
359 # @return: True or False if RealValue is False\r
360 # Evaluated value of string format if RealValue is True\r
361 #\r
4afd3d04 362 def __call__(self, RealValue=False, Depth=0):\r
0d2711a6
LG		 363 if self._NoProcess:\r
364 return self._Expr\r
365\r
4afd3d04
LG		 366 self._Depth = Depth\r
367\r
d0acc87a 368 self._Expr = self._Expr.strip()\r
4afd3d04 369 if RealValue and Depth == 0:\r
d0acc87a
LG		 370 self._Token = self._Expr\r
371 if self.__IsNumberToken():\r
372 return self._Expr\r
35f613d9 373 Token = ''\r
25918452
LG		 374 try:\r
375 Token = self._GetToken()\r
25918452
LG		 376 except BadExpression:\r
377 pass\r
0d1f5b2b 378 if isinstance(Token, type('')) and Token.startswith('{') and Token.endswith('}') and self._Idx >= self._Len:\r
35f613d9 379 return self._Expr\r
d0acc87a
LG		 380\r
381 self._Idx = 0\r
382 self._Token = ''\r
383\r
bc0d7233 384 Val = self._ConExpr()\r
d0acc87a 385 RealVal = Val\r
0d1f5b2b 386 if isinstance(Val, type('')):\r
d0acc87a
LG		 387 if Val == 'L""':\r
388 Val = False\r
389 elif not Val:\r
390 Val = False\r
391 RealVal = '""'\r
726c501c 392 elif not Val.startswith('L"') and not Val.startswith('{') and not Val.startswith("L'"):\r
d0acc87a
LG		 393 Val = True\r
394 RealVal = '"' + RealVal + '"'\r
0d2711a6
LG		 395\r
396 # The expression has been parsed, but the end of expression is not reached\r
397 # It means the rest does not comply EBNF of <Expression>\r
398 if self._Idx != self._Len:\r
399 raise BadExpression(ERR_SNYTAX % self._Expr[self._Idx:])\r
400\r
d0acc87a
LG		 401 if RealValue:\r
402 RetVal = str(RealVal)\r
403 elif Val:\r
404 RetVal = True\r
405 else:\r
406 RetVal = False\r
407\r
408 if self._WarnExcept:\r
409 self._WarnExcept.result = RetVal\r
410 raise self._WarnExcept\r
411 else:\r
412 return RetVal\r
0d2711a6
LG		 413\r
414 # Template function to parse binary operators which have same precedence\r
415 # Expr [Operator Expr]*\r
4d601fc6 416 def _ExprFuncTemplate(self, EvalFunc, OpSet):\r
0d2711a6 417 Val = EvalFunc()\r
4d601fc6 418 while self._IsOperator(OpSet):\r
0d2711a6 419 Op = self._Token\r
bc0d7233
YF		 420 if Op == '?':\r
421 Val2 = EvalFunc()\r
4d601fc6 422 if self._IsOperator({':'}):\r
bc0d7233
YF		 423 Val3 = EvalFunc()\r
424 if Val:\r
425 Val = Val2\r
426 else:\r
427 Val = Val3\r
428 continue\r
d0acc87a
LG		 429 try:\r
430 Val = self.Eval(Op, Val, EvalFunc())\r
5b0671c1 431 except WrnExpression as Warn:\r
d0acc87a
LG		 432 self._WarnExcept = Warn\r
433 Val = Warn.result\r
0d2711a6 434 return Val\r
bc0d7233
YF		 435 # A [? B]*\r
436 def _ConExpr(self):\r
4d601fc6 437 return self._ExprFuncTemplate(self._OrExpr, {'?', ':'})\r
0d2711a6
LG		 438\r
439 # A [|| B]*\r
440 def _OrExpr(self):\r
4d601fc6 441 return self._ExprFuncTemplate(self._AndExpr, {"OR", "or", "||"})\r
0d2711a6
LG		 442\r
443 # A [&& B]*\r
444 def _AndExpr(self):\r
4d601fc6 445 return self._ExprFuncTemplate(self._BitOr, {"AND", "and", "&&"})\r
0d2711a6
LG		 446\r
447 # A [ | B]*\r
448 def _BitOr(self):\r
4d601fc6 449 return self._ExprFuncTemplate(self._BitXor, {"|"})\r
0d2711a6
LG		 450\r
451 # A [ ^ B]*\r
452 def _BitXor(self):\r
4d601fc6 453 return self._ExprFuncTemplate(self._BitAnd, {"XOR", "xor", "^"})\r
0d2711a6
LG		 454\r
455 # A [ & B]*\r
456 def _BitAnd(self):\r
4d601fc6 457 return self._ExprFuncTemplate(self._EqExpr, {"&"})\r
0d2711a6
LG		 458\r
459 # A [ == B]*\r
460 def _EqExpr(self):\r
461 Val = self._RelExpr()\r
4d601fc6 462 while self._IsOperator({"==", "!=", "EQ", "NE", "IN", "in", "!", "NOT", "not"}):\r
0d2711a6 463 Op = self._Token\r
4d601fc6
CJ		 464 if Op in {"!", "NOT", "not"}:\r
465 if not self._IsOperator({"IN", "in"}):\r
0d2711a6
LG		 466 raise BadExpression(ERR_REL_NOT_IN)\r
467 Op += ' ' + self._Token\r
d0acc87a
LG		 468 try:\r
469 Val = self.Eval(Op, Val, self._RelExpr())\r
5b0671c1 470 except WrnExpression as Warn:\r
d0acc87a
LG		 471 self._WarnExcept = Warn\r
472 Val = Warn.result\r
0d2711a6
LG		 473 return Val\r
474\r
475 # A [ > B]*\r
476 def _RelExpr(self):\r
4d601fc6 477 return self._ExprFuncTemplate(self._ShiftExpr, {"<=", ">=", "<", ">", "LE", "GE", "LT", "GT"})\r
5e06f1a0
YZ		 478\r
479 def _ShiftExpr(self):\r
4d601fc6 480 return self._ExprFuncTemplate(self._AddExpr, {"<<", ">>"})\r
0d2711a6
LG		 481\r
482 # A [ + B]*\r
483 def _AddExpr(self):\r
4d601fc6 484 return self._ExprFuncTemplate(self._MulExpr, {"+", "-"})\r
5e06f1a0
YZ		 485\r
486 # A [ * B]*\r
487 def _MulExpr(self):\r
4d601fc6 488 return self._ExprFuncTemplate(self._UnaryExpr, {"*", "/", "%"})\r
0d2711a6
LG		 489\r
490 # [!]*A\r
491 def _UnaryExpr(self):\r
4d601fc6 492 if self._IsOperator({"!", "NOT", "not"}):\r
0d2711a6 493 Val = self._UnaryExpr()\r
d0acc87a
LG		 494 try:\r
495 return self.Eval('not', Val)\r
5b0671c1 496 except WrnExpression as Warn:\r
d0acc87a
LG		 497 self._WarnExcept = Warn\r
498 return Warn.result\r
4d601fc6 499 if self._IsOperator({"~"}):\r
5e06f1a0
YZ		 500 Val = self._UnaryExpr()\r
501 try:\r
502 return self.Eval('~', Val)\r
5b0671c1 503 except WrnExpression as Warn:\r
5e06f1a0
YZ		 504 self._WarnExcept = Warn\r
505 return Warn.result\r
0d2711a6
LG		 506 return self._IdenExpr()\r
507\r
508 # Parse identifier or encapsulated expression\r
509 def _IdenExpr(self):\r
510 Tk = self._GetToken()\r
511 if Tk == '(':\r
bc0d7233 512 Val = self._ConExpr()\r
0d2711a6
LG		 513 try:\r
514 # _GetToken may also raise BadExpression\r
515 if self._GetToken() != ')':\r
516 raise BadExpression(ERR_MATCH)\r
517 except BadExpression:\r
518 raise BadExpression(ERR_MATCH)\r
519 return Val\r
520 return Tk\r
521\r
522 # Skip whitespace or tab\r
523 def __SkipWS(self):\r
524 for Char in self._Expr[self._Idx:]:\r
525 if Char not in ' \t':\r
526 break\r
527 self._Idx += 1\r
528\r
529 # Try to convert string to number\r
530 def __IsNumberToken(self):\r
531 Radix = 10\r
532 if self._Token.lower()[0:2] == '0x' and len(self._Token) > 2:\r
533 Radix = 16\r
35f613d9
YF		 534 if self._Token.startswith('"') or self._Token.startswith('L"'):\r
535 Flag = 0\r
536 for Index in range(len(self._Token)):\r
4d601fc6 537 if self._Token[Index] in {'"'}:\r
ea927d2f
FY		 538 if self._Token[Index - 1] == '\\':\r
539 continue\r
35f613d9
YF		 540 Flag += 1\r
541 if Flag == 2 and self._Token.endswith('"'):\r
35f613d9
YF		 542 return True\r
543 if self._Token.startswith("'") or self._Token.startswith("L'"):\r
726c501c
YZ		 544 Flag = 0\r
545 for Index in range(len(self._Token)):\r
4d601fc6 546 if self._Token[Index] in {"'"}:\r
ea927d2f
FY		 547 if self._Token[Index - 1] == '\\':\r
548 continue\r
726c501c 549 Flag += 1\r
35f613d9 550 if Flag == 2 and self._Token.endswith("'"):\r
726c501c 551 return True\r
0d2711a6
LG		 552 try:\r
553 self._Token = int(self._Token, Radix)\r
554 return True\r
555 except ValueError:\r
556 return False\r
557 except TypeError:\r
558 return False\r
559\r
560 # Parse array: {...}\r
561 def __GetArray(self):\r
562 Token = '{'\r
563 self._Idx += 1\r
564 self.__GetNList(True)\r
565 Token += self._LiteralToken\r
566 if self._Idx >= self._Len or self._Expr[self._Idx] != '}':\r
567 raise BadExpression(ERR_ARRAY_TOKEN % Token)\r
568 Token += '}'\r
569\r
570 # All whitespace and tabs in array are already stripped.\r
571 IsArray = IsGuid = False\r
572 if len(Token.split(',')) == 11 and len(Token.split(',{')) == 2 \\r
573 and len(Token.split('},')) == 1:\r
ccaa7754 574 HexLen = [11, 6, 6, 5, 4, 4, 4, 4, 4, 4, 6]\r
0d2711a6
LG		 575 HexList= Token.split(',')\r
576 if HexList[3].startswith('{') and \\r
577 not [Index for Index, Hex in enumerate(HexList) if len(Hex) > HexLen[Index]]:\r
578 IsGuid = True\r
579 if Token.lstrip('{').rstrip('}').find('{') == -1:\r
580 if not [Hex for Hex in Token.lstrip('{').rstrip('}').split(',') if len(Hex) > 4]:\r
581 IsArray = True\r
582 if not IsArray and not IsGuid:\r
583 raise BadExpression(ERR_ARRAY_TOKEN % Token)\r
584 self._Idx += 1\r
585 self._Token = self._LiteralToken = Token\r
586 return self._Token\r
587\r
588 # Parse string, the format must be: "..."\r
589 def __GetString(self):\r
590 Idx = self._Idx\r
591\r
592 # Skip left quote\r
593 self._Idx += 1\r
594\r
595 # Replace escape \\\", \"\r
ea927d2f
FY		 596 if self._Expr[Idx] == '"':\r
597 Expr = self._Expr[self._Idx:].replace('\\\\', '//').replace('\\\"', '\\\'')\r
598 for Ch in Expr:\r
599 self._Idx += 1\r
600 if Ch == '"':\r
601 break\r
602 self._Token = self._LiteralToken = self._Expr[Idx:self._Idx]\r
603 if not self._Token.endswith('"'):\r
604 raise BadExpression(ERR_STRING_TOKEN % self._Token)\r
605 #Replace escape \\\', \'\r
606 elif self._Expr[Idx] == "'":\r
607 Expr = self._Expr[self._Idx:].replace('\\\\', '//').replace("\\\'", "\\\"")\r
608 for Ch in Expr:\r
609 self._Idx += 1\r
610 if Ch == "'":\r
611 break\r
612 self._Token = self._LiteralToken = self._Expr[Idx:self._Idx]\r
613 if not self._Token.endswith("'"):\r
614 raise BadExpression(ERR_STRING_TOKEN % self._Token)\r
0d2711a6
LG		 615 self._Token = self._Token[1:-1]\r
616 return self._Token\r
617\r
618 # Get token that is comprised by alphanumeric, underscore or dot(used by PCD)\r
619 # @param IsAlphaOp: Indicate if parsing general token or script operator(EQ, NE...)\r
620 def __GetIdToken(self, IsAlphaOp = False):\r
621 IdToken = ''\r
622 for Ch in self._Expr[self._Idx:]:\r
bc0d7233 623 if not self.__IsIdChar(Ch) or ('?' in self._Expr and Ch == ':'):\r
0d2711a6
LG		 624 break\r
625 self._Idx += 1\r
626 IdToken += Ch\r
627\r
628 self._Token = self._LiteralToken = IdToken\r
629 if not IsAlphaOp:\r
630 self.__ResolveToken()\r
631 return self._Token\r
632\r
633 # Try to resolve token\r
634 def __ResolveToken(self):\r
635 if not self._Token:\r
636 raise BadExpression(ERR_EMPTY_TOKEN)\r
637\r
638 # PCD token\r
e6c2468a 639 if PcdPattern.match(self._Token):\r
0d2711a6 640 if self._Token not in self._Symb:\r
64b2609f
LG		 641 Ex = BadExpression(ERR_PCD_RESOLVE % self._Token)\r
642 Ex.Pcd = self._Token\r
643 raise Ex\r
4afd3d04 644 self._Token = ValueExpression(self._Symb[self._Token], self._Symb)(True, self._Depth+1)\r
0d1f5b2b 645 if not isinstance(self._Token, type('')):\r
0d2711a6
LG		 646 self._LiteralToken = hex(self._Token)\r
647 return\r
648\r
649 if self._Token.startswith('"'):\r
650 self._Token = self._Token[1:-1]\r
4d601fc6 651 elif self._Token in {"FALSE", "false", "False"}:\r
0d2711a6 652 self._Token = False\r
4d601fc6 653 elif self._Token in {"TRUE", "true", "True"}:\r
0d2711a6
LG		 654 self._Token = True\r
655 else:\r
656 self.__IsNumberToken()\r
657\r
658 def __GetNList(self, InArray=False):\r
659 self._GetSingleToken()\r
660 if not self.__IsHexLiteral():\r
661 if InArray:\r
662 raise BadExpression(ERR_ARRAY_ELE % self._Token)\r
663 return self._Token\r
664\r
665 self.__SkipWS()\r
666 Expr = self._Expr[self._Idx:]\r
667 if not Expr.startswith(','):\r
668 return self._Token\r
669\r
670 NList = self._LiteralToken\r
671 while Expr.startswith(','):\r
672 NList += ','\r
673 self._Idx += 1\r
674 self.__SkipWS()\r
675 self._GetSingleToken()\r
676 if not self.__IsHexLiteral():\r
677 raise BadExpression(ERR_ARRAY_ELE % self._Token)\r
678 NList += self._LiteralToken\r
679 self.__SkipWS()\r
680 Expr = self._Expr[self._Idx:]\r
681 self._Token = self._LiteralToken = NList\r
682 return self._Token\r
683\r
684 def __IsHexLiteral(self):\r
685 if self._LiteralToken.startswith('{') and \\r
686 self._LiteralToken.endswith('}'):\r
687 return True\r
688\r
56326323 689 if gHexPattern.match(self._LiteralToken):\r
0d2711a6 690 Token = self._LiteralToken[2:]\r
0d2711a6
LG		 691 if not Token:\r
692 self._LiteralToken = '0x0'\r
693 else:\r
35f613d9 694 self._LiteralToken = '0x' + Token\r
0d2711a6
LG		 695 return True\r
696 return False\r
697\r
698 def _GetToken(self):\r
699 return self.__GetNList()\r
700\r
701 @staticmethod\r
702 def __IsIdChar(Ch):\r
5e06f1a0 703 return Ch in '._:' or Ch.isalnum()\r
0d2711a6
LG		 704\r
705 # Parse operand\r
706 def _GetSingleToken(self):\r
707 self.__SkipWS()\r
708 Expr = self._Expr[self._Idx:]\r
709 if Expr.startswith('L"'):\r
710 # Skip L\r
711 self._Idx += 1\r
712 UStr = self.__GetString()\r
713 self._Token = 'L"' + UStr + '"'\r
726c501c
YZ		 714 return self._Token\r
715 elif Expr.startswith("L'"):\r
716 # Skip L\r
717 self._Idx += 1\r
718 UStr = self.__GetString()\r
719 self._Token = "L'" + UStr + "'"\r
0d2711a6 720 return self._Token\r
726c501c
YZ		 721 elif Expr.startswith("'"):\r
722 UStr = self.__GetString()\r
723 self._Token = "'" + UStr + "'"\r
726c501c
YZ		 724 return self._Token\r
725 elif Expr.startswith('UINT'):\r
726 Re = re.compile('(?:UINT8|UINT16|UINT32|UINT64)\((.+)\)')\r
727 try:\r
728 RetValue = Re.search(Expr).group(1)\r
729 except:\r
730 raise BadExpression('Invalid Expression %s' % Expr)\r
731 Idx = self._Idx\r
732 for Ch in Expr:\r
733 self._Idx += 1\r
734 if Ch == '(':\r
735 Prefix = self._Expr[Idx:self._Idx - 1]\r
736 Idx = self._Idx\r
737 if Ch == ')':\r
738 TmpValue = self._Expr[Idx :self._Idx - 1]\r
739 TmpValue = ValueExpression(TmpValue)(True)\r
0d1f5b2b 740 TmpValue = '0x%x' % int(TmpValue) if not isinstance(TmpValue, type('')) else TmpValue\r
726c501c
YZ		 741 break\r
742 self._Token, Size = ParseFieldValue(Prefix + '(' + TmpValue + ')')\r
743 return self._Token\r
0d2711a6
LG		 744\r
745 self._Token = ''\r
746 if Expr:\r
747 Ch = Expr[0]\r
b1a9e404 748 Match = gGuidPattern.match(Expr)\r
0d2711a6
LG		 749 if Match and not Expr[Match.end():Match.end()+1].isalnum() \\r
750 and Expr[Match.end():Match.end()+1] != '_':\r
751 self._Idx += Match.end()\r
4afd3d04 752 self._Token = ValueExpression(GuidStringToGuidStructureString(Expr[0:Match.end()]))(True, self._Depth+1)\r
0d2711a6
LG		 753 return self._Token\r
754 elif self.__IsIdChar(Ch):\r
755 return self.__GetIdToken()\r
756 elif Ch == '"':\r
757 return self.__GetString()\r
758 elif Ch == '{':\r
759 return self.__GetArray()\r
760 elif Ch == '(' or Ch == ')':\r
761 self._Idx += 1\r
762 self._Token = Ch\r
763 return self._Token\r
764\r
765 raise BadExpression(ERR_VALID_TOKEN % Expr)\r
766\r
767 # Parse operator\r
768 def _GetOperator(self):\r
769 self.__SkipWS()\r
ccaa7754 770 LegalOpLst = ['&&', '||', '!=', '==', '>=', '<='] + self.NonLetterOpLst + ['?', ':']\r
0d2711a6
LG		 771\r
772 self._Token = ''\r
773 Expr = self._Expr[self._Idx:]\r
774\r
775 # Reach end of expression\r
776 if not Expr:\r
777 return ''\r
778\r
779 # Script operator: LT, GT, LE, GE, EQ, NE, and, or, xor, not\r
780 if Expr[0].isalpha():\r
781 return self.__GetIdToken(True)\r
782\r
783 # Start to get regular operator: +, -, <, > ...\r
784 if Expr[0] not in self.NonLetterOpLst:\r
785 return ''\r
786\r
787 OpToken = ''\r
788 for Ch in Expr:\r
789 if Ch in self.NonLetterOpLst:\r
d0acc87a 790 if '!' == Ch and OpToken:\r
0d2711a6
LG		 791 break\r
792 self._Idx += 1\r
793 OpToken += Ch\r
794 else:\r
795 break\r
796\r
797 if OpToken not in LegalOpLst:\r
798 raise BadExpression(ERR_OPERATOR_UNSUPPORT % OpToken)\r
799 self._Token = OpToken\r
800 return OpToken\r
801\r
726c501c
YZ		 802class ValueExpressionEx(ValueExpression):\r
803 def __init__(self, PcdValue, PcdType, SymbolTable={}):\r
804 ValueExpression.__init__(self, PcdValue, SymbolTable)\r
805 self.PcdValue = PcdValue\r
806 self.PcdType = PcdType\r
807\r
808 def __call__(self, RealValue=False, Depth=0):\r
809 PcdValue = self.PcdValue\r
810 try:\r
811 PcdValue = ValueExpression.__call__(self, RealValue, Depth)\r
656d2539 812 if self.PcdType == TAB_VOID and (PcdValue.startswith("'") or PcdValue.startswith("L'")):\r
0e6b8673
FY		 813 PcdValue, Size = ParseFieldValue(PcdValue)\r
814 PcdValueList = []\r
815 for I in range(Size):\r
816 PcdValueList.append('0x%02X'%(PcdValue & 0xff))\r
817 PcdValue = PcdValue >> 8\r
818 PcdValue = '{' + ','.join(PcdValueList) + '}'\r
656d2539 819 elif self.PcdType in TAB_PCD_NUMERIC_TYPES and (PcdValue.startswith("'") or \\r
35f613d9
YF		 820 PcdValue.startswith('"') or PcdValue.startswith("L'") or PcdValue.startswith('L"') or PcdValue.startswith('{')):\r
821 raise BadExpression\r
5b0671c1 822 except WrnExpression as Value:\r
726c501c 823 PcdValue = Value.result\r
5b0671c1 824 except BadExpression as Value:\r
656d2539 825 if self.PcdType in TAB_PCD_NUMERIC_TYPES:\r
35f613d9 826 PcdValue = PcdValue.strip()\r
b813843c 827 if PcdValue.startswith('{') and PcdValue.endswith('}'):\r
3be421e9 828 PcdValue = SplitPcdValueString(PcdValue[1:-1])\r
0d1f5b2b 829 if isinstance(PcdValue, type([])):\r
35f613d9 830 TmpValue = 0\r
726c501c 831 Size = 0\r
3be421e9 832 ValueType = ''\r
35f613d9 833 for Item in PcdValue:\r
3be421e9 834 Item = Item.strip()\r
656d2539 835 if Item.startswith(TAB_UINT8):\r
0e6b8673 836 ItemSize = 1\r
656d2539
CJ		 837 ValueType = TAB_UINT8\r
838 elif Item.startswith(TAB_UINT16):\r
35f613d9 839 ItemSize = 2\r
656d2539
CJ		 840 ValueType = TAB_UINT16\r
841 elif Item.startswith(TAB_UINT32):\r
35f613d9 842 ItemSize = 4\r
656d2539
CJ		 843 ValueType = TAB_UINT32\r
844 elif Item.startswith(TAB_UINT64):\r
35f613d9 845 ItemSize = 8\r
656d2539 846 ValueType = TAB_UINT64\r
ccaa7754 847 elif Item[0] in {'"', "'", 'L'}:\r
3be421e9 848 ItemSize = 0\r
656d2539 849 ValueType = TAB_VOID\r
35f613d9
YF		 850 else:\r
851 ItemSize = 0\r
656d2539 852 ValueType = TAB_UINT8\r
3be421e9 853 Item = ValueExpressionEx(Item, ValueType, self._Symb)(True)\r
35f613d9
YF		 854\r
855 if ItemSize == 0:\r
3be421e9 856 try:\r
0944818a 857 tmpValue = int(Item, 0)\r
3be421e9
FY		 858 if tmpValue > 255:\r
859 raise BadExpression("Byte array number %s should less than 0xFF." % Item)\r
5b0671c1 860 except BadExpression as Value:\r
3be421e9
FY		 861 raise BadExpression(Value)\r
862 except ValueError:\r
863 pass\r
35f613d9
YF		 864 ItemValue, ItemSize = ParseFieldValue(Item)\r
865 else:\r
866 ItemValue = ParseFieldValue(Item)[0]\r
867\r
0d1f5b2b 868 if isinstance(ItemValue, type('')):\r
0944818a 869 ItemValue = int(ItemValue, 0)\r
35f613d9
YF		 870\r
871 TmpValue = (ItemValue << (Size * 8)) | TmpValue\r
872 Size = Size + ItemSize\r
873 else:\r
0e6b8673
FY		 874 try:\r
875 TmpValue, Size = ParseFieldValue(PcdValue)\r
5b0671c1 876 except BadExpression as Value:\r
9efe8d60 877 raise BadExpression("Type: %s, Value: %s, %s" % (self.PcdType, PcdValue, Value))\r
0d1f5b2b 878 if isinstance(TmpValue, type('')):\r
9efe8d60
YF		 879 try:\r
880 TmpValue = int(TmpValue)\r
881 except:\r
882 raise BadExpression(Value)\r
35f613d9
YF		 883 else:\r
884 PcdValue = '0x%0{}X'.format(Size) % (TmpValue)\r
885 if TmpValue < 0:\r
886 raise BadExpression('Type %s PCD Value is negative' % self.PcdType)\r
656d2539 887 if self.PcdType == TAB_UINT8 and Size > 1:\r
35f613d9 888 raise BadExpression('Type %s PCD Value Size is Larger than 1 byte' % self.PcdType)\r
656d2539 889 if self.PcdType == TAB_UINT16 and Size > 2:\r
35f613d9 890 raise BadExpression('Type %s PCD Value Size is Larger than 2 byte' % self.PcdType)\r
656d2539 891 if self.PcdType == TAB_UINT32 and Size > 4:\r
35f613d9 892 raise BadExpression('Type %s PCD Value Size is Larger than 4 byte' % self.PcdType)\r
656d2539 893 if self.PcdType == TAB_UINT64 and Size > 8:\r
35f613d9 894 raise BadExpression('Type %s PCD Value Size is Larger than 8 byte' % self.PcdType)\r
6f49996c 895 else:\r
35f613d9 896 try:\r
39456d00 897 TmpValue = int(PcdValue)\r
35f613d9
YF		 898 TmpList = []\r
899 if TmpValue.bit_length() == 0:\r
900 PcdValue = '{0x00}'\r
726c501c 901 else:\r
35f613d9
YF		 902 for I in range((TmpValue.bit_length() + 7) / 8):\r
903 TmpList.append('0x%02x' % ((TmpValue >> I * 8) & 0xff))\r
904 PcdValue = '{' + ', '.join(TmpList) + '}'\r
905 except:\r
906 if PcdValue.strip().startswith('{'):\r
3be421e9
FY		 907 PcdValueList = SplitPcdValueString(PcdValue.strip()[1:-1])\r
908 LabelDict = {}\r
909 NewPcdValueList = []\r
3be421e9 910 LabelOffset = 0\r
e52aed0d 911 for Item in PcdValueList:\r
3be421e9 912 # compute byte offset of every LABEL\r
38504ad3
CJ		 913 LabelList = _ReLabel.findall(Item)\r
914 Item = _ReLabel.sub('', Item)\r
b31501c9 915 Item = Item.strip()\r
5ac0a545 916 if LabelList:\r
3be421e9 917 for Label in LabelList:\r
1f901a89 918 if not IsValidCName(Label):\r
5ac0a545 919 raise BadExpression('%s is not a valid c variable name' % Label)\r
9eb87141 920 if Label not in LabelDict:\r
3be421e9 921 LabelDict[Label] = str(LabelOffset)\r
656d2539 922 if Item.startswith(TAB_UINT8):\r
3be421e9 923 LabelOffset = LabelOffset + 1\r
656d2539 924 elif Item.startswith(TAB_UINT16):\r
3be421e9 925 LabelOffset = LabelOffset + 2\r
656d2539 926 elif Item.startswith(TAB_UINT32):\r
3be421e9 927 LabelOffset = LabelOffset + 4\r
656d2539 928 elif Item.startswith(TAB_UINT64):\r
3be421e9
FY		 929 LabelOffset = LabelOffset + 8\r
930 else:\r
8bd72d7c 931 try:\r
8bd72d7c
KM		 932 ItemValue, ItemSize = ParseFieldValue(Item)\r
933 LabelOffset = LabelOffset + ItemSize\r
35f613d9 934 except:\r
3be421e9
FY		 935 LabelOffset = LabelOffset + 1\r
936\r
e52aed0d 937 for Item in PcdValueList:\r
3be421e9
FY		 938 # for LABEL parse\r
939 Item = Item.strip()\r
940 try:\r
38504ad3 941 Item = _ReLabel.sub('', Item)\r
3be421e9
FY		 942 except:\r
943 pass\r
944 try:\r
38504ad3 945 OffsetList = _ReOffset.findall(Item)\r
3be421e9
FY		 946 except:\r
947 pass\r
cc0321f2 948 # replace each offset, except errors\r
3be421e9 949 for Offset in OffsetList:\r
cc0321f2 950 try:\r
ccaa7754 951 Item = Item.replace('OFFSET_OF({})'.format(Offset), LabelDict[Offset])\r
cc0321f2 952 except:\r
3be421e9 953 raise BadExpression('%s not defined' % Offset)\r
cc0321f2 954\r
3be421e9
FY		 955 NewPcdValueList.append(Item)\r
956\r
957 AllPcdValueList = []\r
958 for Item in NewPcdValueList:\r
959 Size = 0\r
960 ValueStr = ''\r
961 TokenSpaceGuidName = ''\r
91fa33ee 962 if Item.startswith(TAB_GUID) and Item.endswith(')'):\r
35f613d9 963 try:\r
3be421e9 964 TokenSpaceGuidName = re.search('GUID\((\w+)\)', Item).group(1)\r
35f613d9
YF		 965 except:\r
966 pass\r
3be421e9
FY		 967 if TokenSpaceGuidName and TokenSpaceGuidName in self._Symb:\r
968 Item = 'GUID(' + self._Symb[TokenSpaceGuidName] + ')'\r
969 elif TokenSpaceGuidName:\r
970 raise BadExpression('%s not found in DEC file' % TokenSpaceGuidName)\r
971 Item, Size = ParseFieldValue(Item)\r
972 for Index in range(0, Size):\r
973 ValueStr = '0x%02X' % (int(Item) & 255)\r
974 Item >>= 8\r
975 AllPcdValueList.append(ValueStr)\r
976 continue\r
977 elif Item.startswith('DEVICE_PATH') and Item.endswith(')'):\r
978 Item, Size = ParseFieldValue(Item)\r
979 AllPcdValueList.append(Item[1:-1])\r
980 continue\r
981 else:\r
35f613d9 982 ValueType = ""\r
656d2539 983 if Item.startswith(TAB_UINT8):\r
35f613d9 984 ItemSize = 1\r
656d2539
CJ		 985 ValueType = TAB_UINT8\r
986 elif Item.startswith(TAB_UINT16):\r
35f613d9 987 ItemSize = 2\r
656d2539
CJ		 988 ValueType = TAB_UINT16\r
989 elif Item.startswith(TAB_UINT32):\r
35f613d9 990 ItemSize = 4\r
656d2539
CJ		 991 ValueType = TAB_UINT32\r
992 elif Item.startswith(TAB_UINT64):\r
35f613d9 993 ItemSize = 8\r
656d2539 994 ValueType = TAB_UINT64\r
35f613d9
YF		 995 else:\r
996 ItemSize = 0\r
997 if ValueType:\r
998 TmpValue = ValueExpressionEx(Item, ValueType, self._Symb)(True)\r
999 else:\r
1000 TmpValue = ValueExpressionEx(Item, self.PcdType, self._Symb)(True)\r
0d1f5b2b 1001 Item = '0x%x' % TmpValue if not isinstance(TmpValue, type('')) else TmpValue\r
35f613d9
YF		 1002 if ItemSize == 0:\r
1003 ItemValue, ItemSize = ParseFieldValue(Item)\r
ccaa7754 1004 if Item[0] not in {'"', 'L', '{'} and ItemSize > 1:\r
3be421e9 1005 raise BadExpression("Byte array number %s should less than 0xFF." % Item)\r
35f613d9
YF		 1006 else:\r
1007 ItemValue = ParseFieldValue(Item)[0]\r
1008 for I in range(0, ItemSize):\r
3be421e9 1009 ValueStr = '0x%02X' % (int(ItemValue) & 255)\r
35f613d9 1010 ItemValue >>= 8\r
3be421e9 1011 AllPcdValueList.append(ValueStr)\r
35f613d9
YF		 1012 Size += ItemSize\r
1013\r
3be421e9
FY		 1014 if Size > 0:\r
1015 PcdValue = '{' + ','.join(AllPcdValueList) + '}'\r
0e6b8673 1016 else:\r
9efe8d60 1017 raise BadExpression("Type: %s, Value: %s, %s"%(self.PcdType, PcdValue, Value))\r
0e6b8673 1018\r
35f613d9
YF		 1019 if PcdValue == 'True':\r
1020 PcdValue = '1'\r
1021 if PcdValue == 'False':\r
1022 PcdValue = '0'\r
726c501c 1023\r
726c501c
YZ		 1024 if RealValue:\r
1025 return PcdValue\r
1026\r
0d2711a6
LG		 1027if __name__ == '__main__':\r
1028 pass\r
d0acc87a
LG		 1029 while True:\r
1030 input = raw_input('Input expr: ')\r
1031 if input in 'qQ':\r
1032 break\r
1033 try:\r
72443dd2
GL		 1034 print(ValueExpression(input)(True))\r
1035 print(ValueExpression(input)(False))\r
5b0671c1 1036 except WrnExpression as Ex:\r
72443dd2
GL		 1037 print(Ex.result)\r
1038 print(str(Ex))\r
5b0671c1 1039 except Exception as Ex:\r
72443dd2 1040 print(str(Ex))\r
EFI Development Kit II mirror for PVE