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