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