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