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