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