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