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