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