RangeExpression.py 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698
  1. # # @file
  2. # This file is used to parse and evaluate range expression in Pcd declaration.
  3. #
  4. # Copyright (c) 2015 - 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. # # Import Modules
  13. #
  14. from __future__ import print_function
  15. from Common.GlobalData import *
  16. from CommonDataClass.Exceptions import BadExpression
  17. from CommonDataClass.Exceptions import WrnExpression
  18. import uuid
  19. from Common.Expression import PcdPattern, BaseExpression
  20. from Common.DataType import *
  21. from re import compile
  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 = 'The PCD should be FeatureFlag type or FixedAtBuild type: [%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. class RangeObject(object):
  43. def __init__(self, start, end, empty = False):
  44. if int(start) < int(end):
  45. self.start = int(start)
  46. self.end = int(end)
  47. else:
  48. self.start = int(end)
  49. self.end = int(start)
  50. self.empty = empty
  51. class RangeContainer(object):
  52. def __init__(self):
  53. self.rangelist = []
  54. def push(self, RangeObject):
  55. self.rangelist.append(RangeObject)
  56. self.rangelist = sorted(self.rangelist, key = lambda rangeobj : rangeobj.start)
  57. self.merge()
  58. def pop(self):
  59. for item in self.rangelist:
  60. yield item
  61. def __clean__(self):
  62. newrangelist = []
  63. for rangeobj in self.rangelist:
  64. if rangeobj.empty == True:
  65. continue
  66. else:
  67. newrangelist.append(rangeobj)
  68. self.rangelist = newrangelist
  69. def merge(self):
  70. self.__clean__()
  71. for i in range(0, len(self.rangelist) - 1):
  72. if self.rangelist[i + 1].start > self.rangelist[i].end:
  73. continue
  74. else:
  75. self.rangelist[i + 1].start = self.rangelist[i].start
  76. 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
  77. self.rangelist[i].empty = True
  78. self.__clean__()
  79. def dump(self):
  80. print("----------------------")
  81. rangelist = ""
  82. for object in self.rangelist:
  83. rangelist = rangelist + "[%d , %d]" % (object.start, object.end)
  84. print(rangelist)
  85. class XOROperatorObject(object):
  86. def __init__(self):
  87. pass
  88. def Calculate(self, Operand, DataType, SymbolTable):
  89. if isinstance(Operand, type('')) and not Operand.isalnum():
  90. Expr = "XOR ..."
  91. raise BadExpression(ERR_SNYTAX % Expr)
  92. rangeId = str(uuid.uuid1())
  93. rangeContainer = RangeContainer()
  94. rangeContainer.push(RangeObject(0, int(Operand) - 1))
  95. rangeContainer.push(RangeObject(int(Operand) + 1, MAX_VAL_TYPE[DataType]))
  96. SymbolTable[rangeId] = rangeContainer
  97. return rangeId
  98. class LEOperatorObject(object):
  99. def __init__(self):
  100. pass
  101. def Calculate(self, Operand, DataType, SymbolTable):
  102. if isinstance(Operand, type('')) and not Operand.isalnum():
  103. Expr = "LE ..."
  104. raise BadExpression(ERR_SNYTAX % Expr)
  105. rangeId1 = str(uuid.uuid1())
  106. rangeContainer = RangeContainer()
  107. rangeContainer.push(RangeObject(0, int(Operand)))
  108. SymbolTable[rangeId1] = rangeContainer
  109. return rangeId1
  110. class LTOperatorObject(object):
  111. def __init__(self):
  112. pass
  113. def Calculate(self, Operand, DataType, SymbolTable):
  114. if isinstance(Operand, type('')) and not Operand.isalnum():
  115. Expr = "LT ..."
  116. raise BadExpression(ERR_SNYTAX % Expr)
  117. rangeId1 = str(uuid.uuid1())
  118. rangeContainer = RangeContainer()
  119. rangeContainer.push(RangeObject(0, int(Operand) - 1))
  120. SymbolTable[rangeId1] = rangeContainer
  121. return rangeId1
  122. class GEOperatorObject(object):
  123. def __init__(self):
  124. pass
  125. def Calculate(self, Operand, DataType, SymbolTable):
  126. if isinstance(Operand, type('')) and not Operand.isalnum():
  127. Expr = "GE ..."
  128. raise BadExpression(ERR_SNYTAX % Expr)
  129. rangeId1 = str(uuid.uuid1())
  130. rangeContainer = RangeContainer()
  131. rangeContainer.push(RangeObject(int(Operand), MAX_VAL_TYPE[DataType]))
  132. SymbolTable[rangeId1] = rangeContainer
  133. return rangeId1
  134. class GTOperatorObject(object):
  135. def __init__(self):
  136. pass
  137. def Calculate(self, Operand, DataType, SymbolTable):
  138. if isinstance(Operand, type('')) and not Operand.isalnum():
  139. Expr = "GT ..."
  140. raise BadExpression(ERR_SNYTAX % Expr)
  141. rangeId1 = str(uuid.uuid1())
  142. rangeContainer = RangeContainer()
  143. rangeContainer.push(RangeObject(int(Operand) + 1, MAX_VAL_TYPE[DataType]))
  144. SymbolTable[rangeId1] = rangeContainer
  145. return rangeId1
  146. class EQOperatorObject(object):
  147. def __init__(self):
  148. pass
  149. def Calculate(self, Operand, DataType, SymbolTable):
  150. if isinstance(Operand, type('')) and not Operand.isalnum():
  151. Expr = "EQ ..."
  152. raise BadExpression(ERR_SNYTAX % Expr)
  153. rangeId1 = str(uuid.uuid1())
  154. rangeContainer = RangeContainer()
  155. rangeContainer.push(RangeObject(int(Operand), int(Operand)))
  156. SymbolTable[rangeId1] = rangeContainer
  157. return rangeId1
  158. def GetOperatorObject(Operator):
  159. if Operator == '>':
  160. return GTOperatorObject()
  161. elif Operator == '>=':
  162. return GEOperatorObject()
  163. elif Operator == '<':
  164. return LTOperatorObject()
  165. elif Operator == '<=':
  166. return LEOperatorObject()
  167. elif Operator == '==':
  168. return EQOperatorObject()
  169. elif Operator == '^':
  170. return XOROperatorObject()
  171. else:
  172. raise BadExpression("Bad Operator")
  173. class RangeExpression(BaseExpression):
  174. # Logical operator mapping
  175. LogicalOperators = {
  176. '&&' : 'and', '||' : 'or',
  177. '!' : 'not', 'AND': 'and',
  178. 'OR' : 'or' , 'NOT': 'not',
  179. 'XOR': '^' , 'xor': '^',
  180. 'EQ' : '==' , 'NE' : '!=',
  181. 'GT' : '>' , 'LT' : '<',
  182. 'GE' : '>=' , 'LE' : '<=',
  183. 'IN' : 'in'
  184. }
  185. NonLetterOpLst = ['+', '-', '&', '|', '^', '!', '=', '>', '<']
  186. RangePattern = compile(r'[0-9]+ - [0-9]+')
  187. def preProcessRangeExpr(self, expr):
  188. # convert hex to int
  189. # convert interval to object index. ex. 1 - 10 to a GUID
  190. expr = expr.strip()
  191. NumberDict = {}
  192. for HexNumber in gHexPattern.findall(expr):
  193. Number = str(int(HexNumber, 16))
  194. NumberDict[HexNumber] = Number
  195. for HexNum in NumberDict:
  196. expr = expr.replace(HexNum, NumberDict[HexNum])
  197. rangedict = {}
  198. for validrange in self.RangePattern.findall(expr):
  199. start, end = validrange.split(" - ")
  200. start = start.strip()
  201. end = end.strip()
  202. rangeid = str(uuid.uuid1())
  203. rangeContainer = RangeContainer()
  204. rangeContainer.push(RangeObject(start, end))
  205. self.operanddict[str(rangeid)] = rangeContainer
  206. rangedict[validrange] = str(rangeid)
  207. for validrange in rangedict:
  208. expr = expr.replace(validrange, rangedict[validrange])
  209. self._Expr = expr
  210. return expr
  211. def EvalRange(self, Operator, Oprand):
  212. operatorobj = GetOperatorObject(Operator)
  213. return operatorobj.Calculate(Oprand, self.PcdDataType, self.operanddict)
  214. def Rangeintersection(self, Oprand1, Oprand2):
  215. rangeContainer1 = self.operanddict[Oprand1]
  216. rangeContainer2 = self.operanddict[Oprand2]
  217. rangeContainer = RangeContainer()
  218. for range1 in rangeContainer1.pop():
  219. for range2 in rangeContainer2.pop():
  220. start1 = range1.start
  221. end1 = range1.end
  222. start2 = range2.start
  223. end2 = range2.end
  224. if start1 >= start2:
  225. start1, start2 = start2, start1
  226. end1, end2 = end2, end1
  227. if range1.empty:
  228. rangeid = str(uuid.uuid1())
  229. rangeContainer.push(RangeObject(0, 0, True))
  230. if end1 < start2:
  231. rangeid = str(uuid.uuid1())
  232. rangeContainer.push(RangeObject(0, 0, True))
  233. elif end1 == start2:
  234. rangeid = str(uuid.uuid1())
  235. rangeContainer.push(RangeObject(end1, end1))
  236. elif end1 <= end2 and end1 > start2:
  237. rangeid = str(uuid.uuid1())
  238. rangeContainer.push(RangeObject(start2, end1))
  239. elif end1 >= end2:
  240. rangeid = str(uuid.uuid1())
  241. rangeContainer.push(RangeObject(start2, end2))
  242. self.operanddict[rangeid] = rangeContainer
  243. # rangeContainer.dump()
  244. return rangeid
  245. def Rangecollections(self, Oprand1, Oprand2):
  246. rangeContainer1 = self.operanddict[Oprand1]
  247. rangeContainer2 = self.operanddict[Oprand2]
  248. rangeContainer = RangeContainer()
  249. for rangeobj in rangeContainer2.pop():
  250. rangeContainer.push(rangeobj)
  251. for rangeobj in rangeContainer1.pop():
  252. rangeContainer.push(rangeobj)
  253. rangeid = str(uuid.uuid1())
  254. self.operanddict[rangeid] = rangeContainer
  255. # rangeContainer.dump()
  256. return rangeid
  257. def NegativeRange(self, Oprand1):
  258. rangeContainer1 = self.operanddict[Oprand1]
  259. rangeids = []
  260. for rangeobj in rangeContainer1.pop():
  261. rangeContainer = RangeContainer()
  262. rangeid = str(uuid.uuid1())
  263. if rangeobj.empty:
  264. rangeContainer.push(RangeObject(0, MAX_VAL_TYPE[self.PcdDataType]))
  265. else:
  266. if rangeobj.start > 0:
  267. rangeContainer.push(RangeObject(0, rangeobj.start - 1))
  268. if rangeobj.end < MAX_VAL_TYPE[self.PcdDataType]:
  269. rangeContainer.push(RangeObject(rangeobj.end + 1, MAX_VAL_TYPE[self.PcdDataType]))
  270. self.operanddict[rangeid] = rangeContainer
  271. rangeids.append(rangeid)
  272. if len(rangeids) == 0:
  273. rangeContainer = RangeContainer()
  274. rangeContainer.push(RangeObject(0, MAX_VAL_TYPE[self.PcdDataType]))
  275. rangeid = str(uuid.uuid1())
  276. self.operanddict[rangeid] = rangeContainer
  277. return rangeid
  278. if len(rangeids) == 1:
  279. return rangeids[0]
  280. re = self.Rangeintersection(rangeids[0], rangeids[1])
  281. for i in range(2, len(rangeids)):
  282. re = self.Rangeintersection(re, rangeids[i])
  283. rangeid2 = str(uuid.uuid1())
  284. self.operanddict[rangeid2] = self.operanddict[re]
  285. return rangeid2
  286. def Eval(self, Operator, Oprand1, Oprand2 = None):
  287. if Operator in ["!", "NOT", "not"]:
  288. if not gGuidPattern.match(Oprand1.strip()):
  289. raise BadExpression(ERR_STRING_EXPR % Operator)
  290. return self.NegativeRange(Oprand1)
  291. else:
  292. if Operator in ["==", ">=", "<=", ">", "<", '^']:
  293. return self.EvalRange(Operator, Oprand1)
  294. elif Operator == 'and' :
  295. if not gGuidPatternEnd.match(Oprand1.strip()) or not gGuidPatternEnd.match(Oprand2.strip()):
  296. raise BadExpression(ERR_STRING_EXPR % Operator)
  297. return self.Rangeintersection(Oprand1, Oprand2)
  298. elif Operator == 'or':
  299. if not gGuidPatternEnd.match(Oprand1.strip()) or not gGuidPatternEnd.match(Oprand2.strip()):
  300. raise BadExpression(ERR_STRING_EXPR % Operator)
  301. return self.Rangecollections(Oprand1, Oprand2)
  302. else:
  303. raise BadExpression(ERR_STRING_EXPR % Operator)
  304. def __init__(self, Expression, PcdDataType, SymbolTable = {}):
  305. super(RangeExpression, self).__init__(self, Expression, PcdDataType, SymbolTable)
  306. self._NoProcess = False
  307. if not isinstance(Expression, type('')):
  308. self._Expr = Expression
  309. self._NoProcess = True
  310. return
  311. self._Expr = Expression.strip()
  312. if not self._Expr.strip():
  313. raise BadExpression(ERR_EMPTY_EXPR)
  314. #
  315. # The symbol table including PCD and macro mapping
  316. #
  317. self._Symb = SymbolTable
  318. self._Symb.update(self.LogicalOperators)
  319. self._Idx = 0
  320. self._Len = len(self._Expr)
  321. self._Token = ''
  322. self._WarnExcept = None
  323. # Literal token without any conversion
  324. self._LiteralToken = ''
  325. # store the operand object
  326. self.operanddict = {}
  327. # The Pcd max value depends on PcdDataType
  328. self.PcdDataType = PcdDataType
  329. # Public entry for this class
  330. # @param RealValue: False: only evaluate if the expression is true or false, used for conditional expression
  331. # True : return the evaluated str(value), used for PCD value
  332. #
  333. # @return: True or False if RealValue is False
  334. # Evaluated value of string format if RealValue is True
  335. #
  336. def __call__(self, RealValue = False, Depth = 0):
  337. if self._NoProcess:
  338. return self._Expr
  339. self._Depth = Depth
  340. self._Expr = self._Expr.strip()
  341. self.preProcessRangeExpr(self._Expr)
  342. # check if the expression does not need to evaluate
  343. if RealValue and Depth == 0:
  344. self._Token = self._Expr
  345. if gGuidPatternEnd.match(self._Expr):
  346. return [self.operanddict[self._Expr] ]
  347. self._Idx = 0
  348. self._Token = ''
  349. Val = self._OrExpr()
  350. RealVal = Val
  351. RangeIdList = RealVal.split("or")
  352. RangeList = []
  353. for rangeid in RangeIdList:
  354. RangeList.append(self.operanddict[rangeid.strip()])
  355. return RangeList
  356. # Template function to parse binary operators which have same precedence
  357. # Expr [Operator Expr]*
  358. def _ExprFuncTemplate(self, EvalFunc, OpSet):
  359. Val = EvalFunc()
  360. while self._IsOperator(OpSet):
  361. Op = self._Token
  362. try:
  363. Val = self.Eval(Op, Val, EvalFunc())
  364. except WrnExpression as Warn:
  365. self._WarnExcept = Warn
  366. Val = Warn.result
  367. return Val
  368. # A [|| B]*
  369. def _OrExpr(self):
  370. return self._ExprFuncTemplate(self._AndExpr, {"OR", "or"})
  371. # A [&& B]*
  372. def _AndExpr(self):
  373. return self._ExprFuncTemplate(self._NeExpr, {"AND", "and"})
  374. def _NeExpr(self):
  375. Val = self._RelExpr()
  376. while self._IsOperator({"!=", "NOT", "not"}):
  377. Op = self._Token
  378. if Op in ["!", "NOT", "not"]:
  379. if not self._IsOperator({"IN", "in"}):
  380. raise BadExpression(ERR_REL_NOT_IN)
  381. Op += ' ' + self._Token
  382. try:
  383. Val = self.Eval(Op, Val, self._RelExpr())
  384. except WrnExpression as Warn:
  385. self._WarnExcept = Warn
  386. Val = Warn.result
  387. return Val
  388. # [!]*A
  389. def _RelExpr(self):
  390. if self._IsOperator({"NOT", "LE", "GE", "LT", "GT", "EQ", "XOR"}):
  391. Token = self._Token
  392. Val = self._NeExpr()
  393. try:
  394. return self.Eval(Token, Val)
  395. except WrnExpression as Warn:
  396. self._WarnExcept = Warn
  397. return Warn.result
  398. return self._IdenExpr()
  399. # Parse identifier or encapsulated expression
  400. def _IdenExpr(self):
  401. Tk = self._GetToken()
  402. if Tk == '(':
  403. Val = self._OrExpr()
  404. try:
  405. # _GetToken may also raise BadExpression
  406. if self._GetToken() != ')':
  407. raise BadExpression(ERR_MATCH)
  408. except BadExpression:
  409. raise BadExpression(ERR_MATCH)
  410. return Val
  411. return Tk
  412. # Skip whitespace or tab
  413. def __SkipWS(self):
  414. for Char in self._Expr[self._Idx:]:
  415. if Char not in ' \t':
  416. break
  417. self._Idx += 1
  418. # Try to convert string to number
  419. def __IsNumberToken(self):
  420. Radix = 10
  421. if self._Token.lower()[0:2] == '0x' and len(self._Token) > 2:
  422. Radix = 16
  423. try:
  424. self._Token = int(self._Token, Radix)
  425. return True
  426. except ValueError:
  427. return False
  428. except TypeError:
  429. return False
  430. # Parse array: {...}
  431. def __GetArray(self):
  432. Token = '{'
  433. self._Idx += 1
  434. self.__GetNList(True)
  435. Token += self._LiteralToken
  436. if self._Idx >= self._Len or self._Expr[self._Idx] != '}':
  437. raise BadExpression(ERR_ARRAY_TOKEN % Token)
  438. Token += '}'
  439. # All whitespace and tabs in array are already stripped.
  440. IsArray = IsGuid = False
  441. if len(Token.split(',')) == 11 and len(Token.split(',{')) == 2 \
  442. and len(Token.split('},')) == 1:
  443. HexLen = [11, 6, 6, 5, 4, 4, 4, 4, 4, 4, 6]
  444. HexList = Token.split(',')
  445. if HexList[3].startswith('{') and \
  446. not [Index for Index, Hex in enumerate(HexList) if len(Hex) > HexLen[Index]]:
  447. IsGuid = True
  448. if Token.lstrip('{').rstrip('}').find('{') == -1:
  449. if not [Hex for Hex in Token.lstrip('{').rstrip('}').split(',') if len(Hex) > 4]:
  450. IsArray = True
  451. if not IsArray and not IsGuid:
  452. raise BadExpression(ERR_ARRAY_TOKEN % Token)
  453. self._Idx += 1
  454. self._Token = self._LiteralToken = Token
  455. return self._Token
  456. # Parse string, the format must be: "..."
  457. def __GetString(self):
  458. Idx = self._Idx
  459. # Skip left quote
  460. self._Idx += 1
  461. # Replace escape \\\", \"
  462. Expr = self._Expr[self._Idx:].replace('\\\\', '//').replace('\\\"', '\\\'')
  463. for Ch in Expr:
  464. self._Idx += 1
  465. if Ch == '"':
  466. break
  467. self._Token = self._LiteralToken = self._Expr[Idx:self._Idx]
  468. if not self._Token.endswith('"'):
  469. raise BadExpression(ERR_STRING_TOKEN % self._Token)
  470. self._Token = self._Token[1:-1]
  471. return self._Token
  472. # Get token that is comprised by alphanumeric, underscore or dot(used by PCD)
  473. # @param IsAlphaOp: Indicate if parsing general token or script operator(EQ, NE...)
  474. def __GetIdToken(self, IsAlphaOp = False):
  475. IdToken = ''
  476. for Ch in self._Expr[self._Idx:]:
  477. if not self.__IsIdChar(Ch):
  478. break
  479. self._Idx += 1
  480. IdToken += Ch
  481. self._Token = self._LiteralToken = IdToken
  482. if not IsAlphaOp:
  483. self.__ResolveToken()
  484. return self._Token
  485. # Try to resolve token
  486. def __ResolveToken(self):
  487. if not self._Token:
  488. raise BadExpression(ERR_EMPTY_TOKEN)
  489. # PCD token
  490. if PcdPattern.match(self._Token):
  491. if self._Token not in self._Symb:
  492. Ex = BadExpression(ERR_PCD_RESOLVE % self._Token)
  493. Ex.Pcd = self._Token
  494. raise Ex
  495. self._Token = RangeExpression(self._Symb[self._Token], self._Symb)(True, self._Depth + 1)
  496. if not isinstance(self._Token, type('')):
  497. self._LiteralToken = hex(self._Token)
  498. return
  499. if self._Token.startswith('"'):
  500. self._Token = self._Token[1:-1]
  501. elif self._Token in ["FALSE", "false", "False"]:
  502. self._Token = False
  503. elif self._Token in ["TRUE", "true", "True"]:
  504. self._Token = True
  505. else:
  506. self.__IsNumberToken()
  507. def __GetNList(self, InArray = False):
  508. self._GetSingleToken()
  509. if not self.__IsHexLiteral():
  510. if InArray:
  511. raise BadExpression(ERR_ARRAY_ELE % self._Token)
  512. return self._Token
  513. self.__SkipWS()
  514. Expr = self._Expr[self._Idx:]
  515. if not Expr.startswith(','):
  516. return self._Token
  517. NList = self._LiteralToken
  518. while Expr.startswith(','):
  519. NList += ','
  520. self._Idx += 1
  521. self.__SkipWS()
  522. self._GetSingleToken()
  523. if not self.__IsHexLiteral():
  524. raise BadExpression(ERR_ARRAY_ELE % self._Token)
  525. NList += self._LiteralToken
  526. self.__SkipWS()
  527. Expr = self._Expr[self._Idx:]
  528. self._Token = self._LiteralToken = NList
  529. return self._Token
  530. def __IsHexLiteral(self):
  531. if self._LiteralToken.startswith('{') and \
  532. self._LiteralToken.endswith('}'):
  533. return True
  534. if gHexPattern.match(self._LiteralToken):
  535. Token = self._LiteralToken[2:]
  536. Token = Token.lstrip('0')
  537. if not Token:
  538. self._LiteralToken = '0x0'
  539. else:
  540. self._LiteralToken = '0x' + Token.lower()
  541. return True
  542. return False
  543. def _GetToken(self):
  544. return self.__GetNList()
  545. @staticmethod
  546. def __IsIdChar(Ch):
  547. return Ch in '._/:' or Ch.isalnum()
  548. # Parse operand
  549. def _GetSingleToken(self):
  550. self.__SkipWS()
  551. Expr = self._Expr[self._Idx:]
  552. if Expr.startswith('L"'):
  553. # Skip L
  554. self._Idx += 1
  555. UStr = self.__GetString()
  556. self._Token = 'L"' + UStr + '"'
  557. return self._Token
  558. self._Token = ''
  559. if Expr:
  560. Ch = Expr[0]
  561. Match = gGuidPattern.match(Expr)
  562. if Match and not Expr[Match.end():Match.end() + 1].isalnum() \
  563. and Expr[Match.end():Match.end() + 1] != '_':
  564. self._Idx += Match.end()
  565. self._Token = Expr[0:Match.end()]
  566. return self._Token
  567. elif self.__IsIdChar(Ch):
  568. return self.__GetIdToken()
  569. elif Ch == '(' or Ch == ')':
  570. self._Idx += 1
  571. self._Token = Ch
  572. return self._Token
  573. raise BadExpression(ERR_VALID_TOKEN % Expr)
  574. # Parse operator
  575. def _GetOperator(self):
  576. self.__SkipWS()
  577. LegalOpLst = ['&&', '||', '!=', '==', '>=', '<='] + self.NonLetterOpLst
  578. self._Token = ''
  579. Expr = self._Expr[self._Idx:]
  580. # Reach end of expression
  581. if not Expr:
  582. return ''
  583. # Script operator: LT, GT, LE, GE, EQ, NE, and, or, xor, not
  584. if Expr[0].isalpha():
  585. return self.__GetIdToken(True)
  586. # Start to get regular operator: +, -, <, > ...
  587. if Expr[0] not in self.NonLetterOpLst:
  588. return ''
  589. OpToken = ''
  590. for Ch in Expr:
  591. if Ch in self.NonLetterOpLst:
  592. if '!' == Ch and OpToken:
  593. break
  594. self._Idx += 1
  595. OpToken += Ch
  596. else:
  597. break
  598. if OpToken not in LegalOpLst:
  599. raise BadExpression(ERR_OPERATOR_UNSUPPORT % OpToken)
  600. self._Token = OpToken
  601. return OpToken