summaryrefslogtreecommitdiff
path: root/BaseTools/Source/Python/Common/RangeExpression.py
diff options
context:
space:
mode:
Diffstat (limited to 'BaseTools/Source/Python/Common/RangeExpression.py')
-rw-r--r--BaseTools/Source/Python/Common/RangeExpression.py1388
1 files changed, 694 insertions, 694 deletions
diff --git a/BaseTools/Source/Python/Common/RangeExpression.py b/BaseTools/Source/Python/Common/RangeExpression.py
index 039d281467..88a177a476 100644
--- a/BaseTools/Source/Python/Common/RangeExpression.py
+++ b/BaseTools/Source/Python/Common/RangeExpression.py
@@ -1,694 +1,694 @@
-# # @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
+# # @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
generated by cgit v1.2.3 (git 2.39.0) at 2026-09-09 22:07:29 +0300