| # # @file | |
| # This file is used to parse and evaluate range expression in Pcd declaration. | |
| # | |
| # Copyright (c) 2015 - 2018, Intel Corporation. All rights reserved.<BR> | |
| # SPDX-License-Identifier: BSD-2-Clause-Patent | |
| # # Import Modules | |
| # | |
| from __future__ import print_function | |
| from Common.GlobalData import * | |
| from CommonDataClass.Exceptions import BadExpression | |
| from CommonDataClass.Exceptions import WrnExpression | |
| import uuid | |
| from Common.Expression import PcdPattern, BaseExpression | |
| from Common.DataType import * | |
| from re import compile | |
| ERR_STRING_EXPR = 'This operator cannot be used in string expression: [%s].' | |
| ERR_SNYTAX = 'Syntax error, the rest of expression cannot be evaluated: [%s].' | |
| ERR_MATCH = 'No matching right parenthesis.' | |
| ERR_STRING_TOKEN = 'Bad string token: [%s].' | |
| ERR_MACRO_TOKEN = 'Bad macro token: [%s].' | |
| ERR_EMPTY_TOKEN = 'Empty token is not allowed.' | |
| ERR_PCD_RESOLVE = 'The PCD should be FeatureFlag type or FixedAtBuild type: [%s].' | |
| ERR_VALID_TOKEN = 'No more valid token found from rest of string: [%s].' | |
| ERR_EXPR_TYPE = 'Different types found in expression.' | |
| ERR_OPERATOR_UNSUPPORT = 'Unsupported operator: [%s]' | |
| ERR_REL_NOT_IN = 'Expect "IN" after "not" operator.' | |
| WRN_BOOL_EXPR = 'Operand of boolean type cannot be used in arithmetic expression.' | |
| WRN_EQCMP_STR_OTHERS = '== Comparison between Operand of string type and Boolean/Number Type always return False.' | |
| WRN_NECMP_STR_OTHERS = '!= Comparison between Operand of string type and Boolean/Number Type always return True.' | |
| ERR_RELCMP_STR_OTHERS = 'Operator taking Operand of string type and Boolean/Number Type is not allowed: [%s].' | |
| ERR_STRING_CMP = 'Unicode string and general string cannot be compared: [%s %s %s]' | |
| ERR_ARRAY_TOKEN = 'Bad C array or C format GUID token: [%s].' | |
| ERR_ARRAY_ELE = 'This must be HEX value for NList or Array: [%s].' | |
| ERR_EMPTY_EXPR = 'Empty expression is not allowed.' | |
| ERR_IN_OPERAND = 'Macro after IN operator can only be: $(FAMILY), $(ARCH), $(TOOL_CHAIN_TAG) and $(TARGET).' | |
| class RangeObject(object): | |
| def __init__(self, start, end, empty = False): | |
| if int(start) < int(end): | |
| self.start = int(start) | |
| self.end = int(end) | |
| else: | |
| self.start = int(end) | |
| self.end = int(start) | |
| self.empty = empty | |
| class RangeContainer(object): | |
| def __init__(self): | |
| self.rangelist = [] | |
| def push(self, RangeObject): | |
| self.rangelist.append(RangeObject) | |
| self.rangelist = sorted(self.rangelist, key = lambda rangeobj : rangeobj.start) | |
| self.merge() | |
| def pop(self): | |
| for item in self.rangelist: | |
| yield item | |
| def __clean__(self): | |
| newrangelist = [] | |
| for rangeobj in self.rangelist: | |
| if rangeobj.empty == True: | |
| continue | |
| else: | |
| newrangelist.append(rangeobj) | |
| self.rangelist = newrangelist | |
| def merge(self): | |
| self.__clean__() | |
| for i in range(0, len(self.rangelist) - 1): | |
| if self.rangelist[i + 1].start > self.rangelist[i].end: | |
| continue | |
| else: | |
| self.rangelist[i + 1].start = self.rangelist[i].start | |
| self.rangelist[i + 1].end = self.rangelist[i + 1].end > self.rangelist[i].end and self.rangelist[i + 1].end or self.rangelist[i].end | |
| self.rangelist[i].empty = True | |
| self.__clean__() | |
| def dump(self): | |
| print("----------------------") | |
| rangelist = "" | |
| for object in self.rangelist: | |
| rangelist = rangelist + "[%d , %d]" % (object.start, object.end) | |
| print(rangelist) | |
| class XOROperatorObject(object): | |
| def __init__(self): | |
| pass | |
| def Calculate(self, Operand, DataType, SymbolTable): | |
| if isinstance(Operand, type('')) and not Operand.isalnum(): | |
| Expr = "XOR ..." | |
| raise BadExpression(ERR_SNYTAX % Expr) | |
| rangeId = str(uuid.uuid1()) | |
| rangeContainer = RangeContainer() | |
| rangeContainer.push(RangeObject(0, int(Operand) - 1)) | |
| rangeContainer.push(RangeObject(int(Operand) + 1, MAX_VAL_TYPE[DataType])) | |
| SymbolTable[rangeId] = rangeContainer | |
| return rangeId | |
| class LEOperatorObject(object): | |
| def __init__(self): | |
| pass | |
| def Calculate(self, Operand, DataType, SymbolTable): | |
| if isinstance(Operand, type('')) and not Operand.isalnum(): | |
| Expr = "LE ..." | |
| raise BadExpression(ERR_SNYTAX % Expr) | |
| rangeId1 = str(uuid.uuid1()) | |
| rangeContainer = RangeContainer() | |
| rangeContainer.push(RangeObject(0, int(Operand))) | |
| SymbolTable[rangeId1] = rangeContainer | |
| return rangeId1 | |
| class LTOperatorObject(object): | |
| def __init__(self): | |
| pass | |
| def Calculate(self, Operand, DataType, SymbolTable): | |
| if isinstance(Operand, type('')) and not Operand.isalnum(): | |
| Expr = "LT ..." | |
| raise BadExpression(ERR_SNYTAX % Expr) | |
| rangeId1 = str(uuid.uuid1()) | |
| rangeContainer = RangeContainer() | |
| rangeContainer.push(RangeObject(0, int(Operand) - 1)) | |
| SymbolTable[rangeId1] = rangeContainer | |
| return rangeId1 | |
| class GEOperatorObject(object): | |
| def __init__(self): | |
| pass | |
| def Calculate(self, Operand, DataType, SymbolTable): | |
| if isinstance(Operand, type('')) and not Operand.isalnum(): | |
| Expr = "GE ..." | |
| raise BadExpression(ERR_SNYTAX % Expr) | |
| rangeId1 = str(uuid.uuid1()) | |
| rangeContainer = RangeContainer() | |
| rangeContainer.push(RangeObject(int(Operand), MAX_VAL_TYPE[DataType])) | |
| SymbolTable[rangeId1] = rangeContainer | |
| return rangeId1 | |
| class GTOperatorObject(object): | |
| def __init__(self): | |
| pass | |
| def Calculate(self, Operand, DataType, SymbolTable): | |
| if isinstance(Operand, type('')) and not Operand.isalnum(): | |
| Expr = "GT ..." | |
| raise BadExpression(ERR_SNYTAX % Expr) | |
| rangeId1 = str(uuid.uuid1()) | |
| rangeContainer = RangeContainer() | |
| rangeContainer.push(RangeObject(int(Operand) + 1, MAX_VAL_TYPE[DataType])) | |
| SymbolTable[rangeId1] = rangeContainer | |
| return rangeId1 | |
| class EQOperatorObject(object): | |
| def __init__(self): | |
| pass | |
| def Calculate(self, Operand, DataType, SymbolTable): | |
| if isinstance(Operand, type('')) and not Operand.isalnum(): | |
| Expr = "EQ ..." | |
| raise BadExpression(ERR_SNYTAX % Expr) | |
| rangeId1 = str(uuid.uuid1()) | |
| rangeContainer = RangeContainer() | |
| rangeContainer.push(RangeObject(int(Operand), int(Operand))) | |
| SymbolTable[rangeId1] = rangeContainer | |
| return rangeId1 | |
| def GetOperatorObject(Operator): | |
| if Operator == '>': | |
| return GTOperatorObject() | |
| elif Operator == '>=': | |
| return GEOperatorObject() | |
| elif Operator == '<': | |
| return LTOperatorObject() | |
| elif Operator == '<=': | |
| return LEOperatorObject() | |
| elif Operator == '==': | |
| return EQOperatorObject() | |
| elif Operator == '^': | |
| return XOROperatorObject() | |
| else: | |
| raise BadExpression("Bad Operator") | |
| class RangeExpression(BaseExpression): | |
| # Logical operator mapping | |
| LogicalOperators = { | |
| '&&' : 'and', '||' : 'or', | |
| '!' : 'not', 'AND': 'and', | |
| 'OR' : 'or' , 'NOT': 'not', | |
| 'XOR': '^' , 'xor': '^', | |
| 'EQ' : '==' , 'NE' : '!=', | |
| 'GT' : '>' , 'LT' : '<', | |
| 'GE' : '>=' , 'LE' : '<=', | |
| 'IN' : 'in' | |
| } | |
| NonLetterOpLst = ['+', '-', '&', '|', '^', '!', '=', '>', '<'] | |
| RangePattern = compile(r'[0-9]+ - [0-9]+') | |
| def preProcessRangeExpr(self, expr): | |
| # convert hex to int | |
| # convert interval to object index. ex. 1 - 10 to a GUID | |
| expr = expr.strip() | |
| NumberDict = {} | |
| for HexNumber in gHexPattern.findall(expr): | |
| Number = str(int(HexNumber, 16)) | |
| NumberDict[HexNumber] = Number | |
| for HexNum in NumberDict: | |
| expr = expr.replace(HexNum, NumberDict[HexNum]) | |
| rangedict = {} | |
| for validrange in self.RangePattern.findall(expr): | |
| start, end = validrange.split(" - ") | |
| start = start.strip() | |
| end = end.strip() | |
| rangeid = str(uuid.uuid1()) | |
| rangeContainer = RangeContainer() | |
| rangeContainer.push(RangeObject(start, end)) | |
| self.operanddict[str(rangeid)] = rangeContainer | |
| rangedict[validrange] = str(rangeid) | |
| for validrange in rangedict: | |
| expr = expr.replace(validrange, rangedict[validrange]) | |
| self._Expr = expr | |
| return expr | |
| def EvalRange(self, Operator, Oprand): | |
| operatorobj = GetOperatorObject(Operator) | |
| return operatorobj.Calculate(Oprand, self.PcdDataType, self.operanddict) | |
| def Rangeintersection(self, Oprand1, Oprand2): | |
| rangeContainer1 = self.operanddict[Oprand1] | |
| rangeContainer2 = self.operanddict[Oprand2] | |
| rangeContainer = RangeContainer() | |
| for range1 in rangeContainer1.pop(): | |
| for range2 in rangeContainer2.pop(): | |
| start1 = range1.start | |
| end1 = range1.end | |
| start2 = range2.start | |
| end2 = range2.end | |
| if start1 >= start2: | |
| start1, start2 = start2, start1 | |
| end1, end2 = end2, end1 | |
| if range1.empty: | |
| rangeid = str(uuid.uuid1()) | |
| rangeContainer.push(RangeObject(0, 0, True)) | |
| if end1 < start2: | |
| rangeid = str(uuid.uuid1()) | |
| rangeContainer.push(RangeObject(0, 0, True)) | |
| elif end1 == start2: | |
| rangeid = str(uuid.uuid1()) | |
| rangeContainer.push(RangeObject(end1, end1)) | |
| elif end1 <= end2 and end1 > start2: | |
| rangeid = str(uuid.uuid1()) | |
| rangeContainer.push(RangeObject(start2, end1)) | |
| elif end1 >= end2: | |
| rangeid = str(uuid.uuid1()) | |
| rangeContainer.push(RangeObject(start2, end2)) | |
| self.operanddict[rangeid] = rangeContainer | |
| # rangeContainer.dump() | |
| return rangeid | |
| def Rangecollections(self, Oprand1, Oprand2): | |
| rangeContainer1 = self.operanddict[Oprand1] | |
| rangeContainer2 = self.operanddict[Oprand2] | |
| rangeContainer = RangeContainer() | |
| for rangeobj in rangeContainer2.pop(): | |
| rangeContainer.push(rangeobj) | |
| for rangeobj in rangeContainer1.pop(): | |
| rangeContainer.push(rangeobj) | |
| rangeid = str(uuid.uuid1()) | |
| self.operanddict[rangeid] = rangeContainer | |
| # rangeContainer.dump() | |
| return rangeid | |
| def NegativeRange(self, Oprand1): | |
| rangeContainer1 = self.operanddict[Oprand1] | |
| rangeids = [] | |
| for rangeobj in rangeContainer1.pop(): | |
| rangeContainer = RangeContainer() | |
| rangeid = str(uuid.uuid1()) | |
| if rangeobj.empty: | |
| rangeContainer.push(RangeObject(0, MAX_VAL_TYPE[self.PcdDataType])) | |
| else: | |
| if rangeobj.start > 0: | |
| rangeContainer.push(RangeObject(0, rangeobj.start - 1)) | |
| if rangeobj.end < MAX_VAL_TYPE[self.PcdDataType]: | |
| rangeContainer.push(RangeObject(rangeobj.end + 1, MAX_VAL_TYPE[self.PcdDataType])) | |
| self.operanddict[rangeid] = rangeContainer | |
| rangeids.append(rangeid) | |
| if len(rangeids) == 0: | |
| rangeContainer = RangeContainer() | |
| rangeContainer.push(RangeObject(0, MAX_VAL_TYPE[self.PcdDataType])) | |
| rangeid = str(uuid.uuid1()) | |
| self.operanddict[rangeid] = rangeContainer | |
| return rangeid | |
| if len(rangeids) == 1: | |
| return rangeids[0] | |
| re = self.Rangeintersection(rangeids[0], rangeids[1]) | |
| for i in range(2, len(rangeids)): | |
| re = self.Rangeintersection(re, rangeids[i]) | |
| rangeid2 = str(uuid.uuid1()) | |
| self.operanddict[rangeid2] = self.operanddict[re] | |
| return rangeid2 | |
| def Eval(self, Operator, Oprand1, Oprand2 = None): | |
| if Operator in ["!", "NOT", "not"]: | |
| if not gGuidPattern.match(Oprand1.strip()): | |
| raise BadExpression(ERR_STRING_EXPR % Operator) | |
| return self.NegativeRange(Oprand1) | |
| else: | |
| if Operator in ["==", ">=", "<=", ">", "<", '^']: | |
| return self.EvalRange(Operator, Oprand1) | |
| elif Operator == 'and' : | |
| if not gGuidPatternEnd.match(Oprand1.strip()) or not gGuidPatternEnd.match(Oprand2.strip()): | |
| raise BadExpression(ERR_STRING_EXPR % Operator) | |
| return self.Rangeintersection(Oprand1, Oprand2) | |
| elif Operator == 'or': | |
| if not gGuidPatternEnd.match(Oprand1.strip()) or not gGuidPatternEnd.match(Oprand2.strip()): | |
| raise BadExpression(ERR_STRING_EXPR % Operator) | |
| return self.Rangecollections(Oprand1, Oprand2) | |
| else: | |
| raise BadExpression(ERR_STRING_EXPR % Operator) | |
| def __init__(self, Expression, PcdDataType, SymbolTable = None): | |
| if SymbolTable is None: | |
| SymbolTable = {} | |
| super(RangeExpression, self).__init__(self, Expression, PcdDataType, SymbolTable) | |
| self._NoProcess = False | |
| if not isinstance(Expression, type('')): | |
| self._Expr = Expression | |
| self._NoProcess = True | |
| return | |
| self._Expr = Expression.strip() | |
| if not self._Expr.strip(): | |
| raise BadExpression(ERR_EMPTY_EXPR) | |
| # | |
| # The symbol table including PCD and macro mapping | |
| # | |
| self._Symb = SymbolTable | |
| self._Symb.update(self.LogicalOperators) | |
| self._Idx = 0 | |
| self._Len = len(self._Expr) | |
| self._Token = '' | |
| self._WarnExcept = None | |
| # Literal token without any conversion | |
| self._LiteralToken = '' | |
| # store the operand object | |
| self.operanddict = {} | |
| # The Pcd max value depends on PcdDataType | |
| self.PcdDataType = PcdDataType | |
| # Public entry for this class | |
| # @param RealValue: False: only evaluate if the expression is true or false, used for conditional expression | |
| # True : return the evaluated str(value), used for PCD value | |
| # | |
| # @return: True or False if RealValue is False | |
| # Evaluated value of string format if RealValue is True | |
| # | |
| def __call__(self, RealValue = False, Depth = 0): | |
| if self._NoProcess: | |
| return self._Expr | |
| self._Depth = Depth | |
| self._Expr = self._Expr.strip() | |
| self.preProcessRangeExpr(self._Expr) | |
| # check if the expression does not need to evaluate | |
| if RealValue and Depth == 0: | |
| self._Token = self._Expr | |
| if gGuidPatternEnd.match(self._Expr): | |
| return [self.operanddict[self._Expr] ] | |
| self._Idx = 0 | |
| self._Token = '' | |
| Val = self._OrExpr() | |
| RealVal = Val | |
| RangeIdList = RealVal.split("or") | |
| RangeList = [] | |
| for rangeid in RangeIdList: | |
| RangeList.append(self.operanddict[rangeid.strip()]) | |
| return RangeList | |
| # Template function to parse binary operators which have same precedence | |
| # Expr [Operator Expr]* | |
| def _ExprFuncTemplate(self, EvalFunc, OpSet): | |
| Val = EvalFunc() | |
| while self._IsOperator(OpSet): | |
| Op = self._Token | |
| try: | |
| Val = self.Eval(Op, Val, EvalFunc()) | |
| except WrnExpression as Warn: | |
| self._WarnExcept = Warn | |
| Val = Warn.result | |
| return Val | |
| # A [|| B]* | |
| def _OrExpr(self): | |
| return self._ExprFuncTemplate(self._AndExpr, {"OR", "or"}) | |
| # A [&& B]* | |
| def _AndExpr(self): | |
| return self._ExprFuncTemplate(self._NeExpr, {"AND", "and"}) | |
| def _NeExpr(self): | |
| Val = self._RelExpr() | |
| while self._IsOperator({"!=", "NOT", "not"}): | |
| Op = self._Token | |
| if Op in ["!", "NOT", "not"]: | |
| if not self._IsOperator({"IN", "in"}): | |
| raise BadExpression(ERR_REL_NOT_IN) | |
| Op += ' ' + self._Token | |
| try: | |
| Val = self.Eval(Op, Val, self._RelExpr()) | |
| except WrnExpression as Warn: | |
| self._WarnExcept = Warn | |
| Val = Warn.result | |
| return Val | |
| # [!]*A | |
| def _RelExpr(self): | |
| if self._IsOperator({"NOT", "LE", "GE", "LT", "GT", "EQ", "XOR"}): | |
| Token = self._Token | |
| Val = self._NeExpr() | |
| try: | |
| return self.Eval(Token, Val) | |
| except WrnExpression as Warn: | |
| self._WarnExcept = Warn | |
| return Warn.result | |
| return self._IdenExpr() | |
| # Parse identifier or encapsulated expression | |
| def _IdenExpr(self): | |
| Tk = self._GetToken() | |
| if Tk == '(': | |
| Val = self._OrExpr() | |
| try: | |
| # _GetToken may also raise BadExpression | |
| if self._GetToken() != ')': | |
| raise BadExpression(ERR_MATCH) | |
| except BadExpression: | |
| raise BadExpression(ERR_MATCH) | |
| return Val | |
| return Tk | |
| # Skip whitespace or tab | |
| def __SkipWS(self): | |
| for Char in self._Expr[self._Idx:]: | |
| if Char not in ' \t': | |
| break | |
| self._Idx += 1 | |
| # Try to convert string to number | |
| def __IsNumberToken(self): | |
| Radix = 10 | |
| if self._Token.lower()[0:2] == '0x' and len(self._Token) > 2: | |
| Radix = 16 | |
| try: | |
| self._Token = int(self._Token, Radix) | |
| return True | |
| except ValueError: | |
| return False | |
| except TypeError: | |
| return False | |
| # Parse array: {...} | |
| def __GetArray(self): | |
| Token = '{' | |
| self._Idx += 1 | |
| self.__GetNList(True) | |
| Token += self._LiteralToken | |
| if self._Idx >= self._Len or self._Expr[self._Idx] != '}': | |
| raise BadExpression(ERR_ARRAY_TOKEN % Token) | |
| Token += '}' | |
| # All whitespace and tabs in array are already stripped. | |
| IsArray = IsGuid = False | |
| if len(Token.split(',')) == 11 and len(Token.split(',{')) == 2 \ | |
| and len(Token.split('},')) == 1: | |
| HexLen = [11, 6, 6, 5, 4, 4, 4, 4, 4, 4, 6] | |
| HexList = Token.split(',') | |
| if HexList[3].startswith('{') and \ | |
| not [Index for Index, Hex in enumerate(HexList) if len(Hex) > HexLen[Index]]: | |
| IsGuid = True | |
| if Token.lstrip('{').rstrip('}').find('{') == -1: | |
| if not [Hex for Hex in Token.lstrip('{').rstrip('}').split(',') if len(Hex) > 4]: | |
| IsArray = True | |
| if not IsArray and not IsGuid: | |
| raise BadExpression(ERR_ARRAY_TOKEN % Token) | |
| self._Idx += 1 | |
| self._Token = self._LiteralToken = Token | |
| return self._Token | |
| # Parse string, the format must be: "..." | |
| def __GetString(self): | |
| Idx = self._Idx | |
| # Skip left quote | |
| self._Idx += 1 | |
| # Replace escape \\\", \" | |
| Expr = self._Expr[self._Idx:].replace('\\\\', '//').replace('\\\"', '\\\'') | |
| for Ch in Expr: | |
| self._Idx += 1 | |
| if Ch == '"': | |
| break | |
| self._Token = self._LiteralToken = self._Expr[Idx:self._Idx] | |
| if not self._Token.endswith('"'): | |
| raise BadExpression(ERR_STRING_TOKEN % self._Token) | |
| self._Token = self._Token[1:-1] | |
| return self._Token | |
| # Get token that is comprised by alphanumeric, underscore or dot(used by PCD) | |
| # @param IsAlphaOp: Indicate if parsing general token or script operator(EQ, NE...) | |
| def __GetIdToken(self, IsAlphaOp = False): | |
| IdToken = '' | |
| for Ch in self._Expr[self._Idx:]: | |
| if not self.__IsIdChar(Ch): | |
| break | |
| self._Idx += 1 | |
| IdToken += Ch | |
| self._Token = self._LiteralToken = IdToken | |
| if not IsAlphaOp: | |
| self.__ResolveToken() | |
| return self._Token | |
| # Try to resolve token | |
| def __ResolveToken(self): | |
| if not self._Token: | |
| raise BadExpression(ERR_EMPTY_TOKEN) | |
| # PCD token | |
| if PcdPattern.match(self._Token): | |
| if self._Token not in self._Symb: | |
| Ex = BadExpression(ERR_PCD_RESOLVE % self._Token) | |
| Ex.Pcd = self._Token | |
| raise Ex | |
| self._Token = RangeExpression(self._Symb[self._Token], self._Symb)(True, self._Depth + 1) | |
| if not isinstance(self._Token, type('')): | |
| self._LiteralToken = hex(self._Token) | |
| return | |
| if self._Token.startswith('"'): | |
| self._Token = self._Token[1:-1] | |
| elif self._Token in ["FALSE", "false", "False"]: | |
| self._Token = False | |
| elif self._Token in ["TRUE", "true", "True"]: | |
| self._Token = True | |
| else: | |
| self.__IsNumberToken() | |
| def __GetNList(self, InArray = False): | |
| self._GetSingleToken() | |
| if not self.__IsHexLiteral(): | |
| if InArray: | |
| raise BadExpression(ERR_ARRAY_ELE % self._Token) | |
| return self._Token | |
| self.__SkipWS() | |
| Expr = self._Expr[self._Idx:] | |
| if not Expr.startswith(','): | |
| return self._Token | |
| NList = self._LiteralToken | |
| while Expr.startswith(','): | |
| NList += ',' | |
| self._Idx += 1 | |
| self.__SkipWS() | |
| self._GetSingleToken() | |
| if not self.__IsHexLiteral(): | |
| raise BadExpression(ERR_ARRAY_ELE % self._Token) | |
| NList += self._LiteralToken | |
| self.__SkipWS() | |
| Expr = self._Expr[self._Idx:] | |
| self._Token = self._LiteralToken = NList | |
| return self._Token | |
| def __IsHexLiteral(self): | |
| if self._LiteralToken.startswith('{') and \ | |
| self._LiteralToken.endswith('}'): | |
| return True | |
| if gHexPattern.match(self._LiteralToken): | |
| Token = self._LiteralToken[2:] | |
| Token = Token.lstrip('0') | |
| if not Token: | |
| self._LiteralToken = '0x0' | |
| else: | |
| self._LiteralToken = '0x' + Token.lower() | |
| return True | |
| return False | |
| def _GetToken(self): | |
| return self.__GetNList() | |
| @staticmethod | |
| def __IsIdChar(Ch): | |
| return Ch in '._/:' or Ch.isalnum() | |
| # Parse operand | |
| def _GetSingleToken(self): | |
| self.__SkipWS() | |
| Expr = self._Expr[self._Idx:] | |
| if Expr.startswith('L"'): | |
| # Skip L | |
| self._Idx += 1 | |
| UStr = self.__GetString() | |
| self._Token = 'L"' + UStr + '"' | |
| return self._Token | |
| self._Token = '' | |
| if Expr: | |
| Ch = Expr[0] | |
| Match = gGuidPattern.match(Expr) | |
| if Match and not Expr[Match.end():Match.end() + 1].isalnum() \ | |
| and Expr[Match.end():Match.end() + 1] != '_': | |
| self._Idx += Match.end() | |
| self._Token = Expr[0:Match.end()] | |
| return self._Token | |
| elif self.__IsIdChar(Ch): | |
| return self.__GetIdToken() | |
| elif Ch == '(' or Ch == ')': | |
| self._Idx += 1 | |
| self._Token = Ch | |
| return self._Token | |
| raise BadExpression(ERR_VALID_TOKEN % Expr) | |
| # Parse operator | |
| def _GetOperator(self): | |
| self.__SkipWS() | |
| LegalOpLst = ['&&', '||', '!=', '==', '>=', '<='] + self.NonLetterOpLst | |
| self._Token = '' | |
| Expr = self._Expr[self._Idx:] | |
| # Reach end of expression | |
| if not Expr: | |
| return '' | |
| # Script operator: LT, GT, LE, GE, EQ, NE, and, or, xor, not | |
| if Expr[0].isalpha(): | |
| return self.__GetIdToken(True) | |
| # Start to get regular operator: +, -, <, > ... | |
| if Expr[0] not in self.NonLetterOpLst: | |
| return '' | |
| OpToken = '' | |
| for Ch in Expr: | |
| if Ch in self.NonLetterOpLst: | |
| if '!' == Ch and OpToken: | |
| break | |
| self._Idx += 1 | |
| OpToken += Ch | |
| else: | |
| break | |
| if OpToken not in LegalOpLst: | |
| raise BadExpression(ERR_OPERATOR_UNSUPPORT % OpToken) | |
| self._Token = OpToken | |
| return OpToken |