123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698 |
- # # @file
- # This file is used to parse and evaluate range expression in Pcd declaration.
- #
- # Copyright (c) 2015 - 2018, Intel Corporation. All rights reserved.<BR>
- # This program and the accompanying materials
- # are licensed and made available under the terms and conditions of the BSD License
- # which accompanies this distribution. The full text of the license may be found at
- # http://opensource.org/licenses/bsd-license.php
- #
- # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
- # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
- # # 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 = {}):
- 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
|