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