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