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