BaseTools/Source/Python/Common/Expression.py

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