sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

BaseTools: Clean up source files

Browse Source 
1. Do not use tab characters
2. No trailing white space in one line
3. All files must end with CRLF

Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Liming Gao <liming.gao@intel.com>
Cc: Yonghong Zhu <yonghong.zhu@intel.com>
Reviewed-by: Yonghong Zhu <yonghong.zhu@intel.com>
This commit is contained in:
Liming Gao
2018-07-05 17:40:04 +08:00
parent 39456d00f3
commit f7496d7173
289 changed files with 10647 additions and 10647 deletions
Download Patch File Download Diff File Expand all files Collapse all files

118
BaseTools/Source/Python/Common/RangeExpression.py
View File

@ -43,7 +43,7 @@ ERR_IN_OPERAND = 'Macro after IN operator can only be: $(FAMILY), $(ARCH), $(TOO
class RangeObject(object):
def __init__(self, start, end, empty = False):
if int(start) < int(end):
self.start = int(start)
self.end = int(end)
@ -55,24 +55,24 @@ class RangeObject(object):
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):
def __clean__(self):
newrangelist = []
for rangeobj in self.rangelist:
if rangeobj.empty == True:
continue
else:
newrangelist.append(rangeobj)
self.rangelist = newrangelist
self.rangelist = newrangelist
def merge(self):
self.__clean__()
for i in range(0, len(self.rangelist) - 1):
@ -80,23 +80,23 @@ class RangeContainer(object):
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 + 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):
class XOROperatorObject(object):
def __init__(self):
pass
def Calculate(self, Operand, DataType, SymbolTable):
def Calculate(self, Operand, DataType, SymbolTable):
if isinstance(Operand, type('')) and not Operand.isalnum():
Expr = "XOR ..."
raise BadExpression(ERR_SNYTAX % Expr)
@ -108,9 +108,9 @@ class XOROperatorObject(object):
return rangeId
class LEOperatorObject(object):
def __init__(self):
def __init__(self):
pass
def Calculate(self, Operand, DataType, SymbolTable):
def Calculate(self, Operand, DataType, SymbolTable):
if isinstance(Operand, type('')) and not Operand.isalnum():
Expr = "LE ..."
raise BadExpression(ERR_SNYTAX % Expr)
@ -120,22 +120,22 @@ class LEOperatorObject(object):
SymbolTable[rangeId1] = rangeContainer
return rangeId1
class LTOperatorObject(object):
def __init__(self):
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)
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
return rangeId1
class GEOperatorObject(object):
def __init__(self):
def __init__(self):
pass
def Calculate(self, Operand, DataType, SymbolTable):
def Calculate(self, Operand, DataType, SymbolTable):
if isinstance(Operand, type('')) and not Operand.isalnum():
Expr = "GE ..."
raise BadExpression(ERR_SNYTAX % Expr)
@ -143,12 +143,12 @@ class GEOperatorObject(object):
rangeContainer = RangeContainer()
rangeContainer.push(RangeObject(int(Operand), MAX_VAL_TYPE[DataType]))
SymbolTable[rangeId1] = rangeContainer
return rangeId1
return rangeId1
class GTOperatorObject(object):
def __init__(self):
def __init__(self):
pass
def Calculate(self, Operand, DataType, SymbolTable):
def Calculate(self, Operand, DataType, SymbolTable):
if isinstance(Operand, type('')) and not Operand.isalnum():
Expr = "GT ..."
raise BadExpression(ERR_SNYTAX % Expr)
@ -156,12 +156,12 @@ class GTOperatorObject(object):
rangeContainer = RangeContainer()
rangeContainer.push(RangeObject(int(Operand) + 1, MAX_VAL_TYPE[DataType]))
SymbolTable[rangeId1] = rangeContainer
return rangeId1
return rangeId1
class EQOperatorObject(object):
def __init__(self):
def __init__(self):
pass
def Calculate(self, Operand, DataType, SymbolTable):
def Calculate(self, Operand, DataType, SymbolTable):
if isinstance(Operand, type('')) and not Operand.isalnum():
Expr = "EQ ..."
raise BadExpression(ERR_SNYTAX % Expr)
@ -169,8 +169,8 @@ class EQOperatorObject(object):
rangeContainer = RangeContainer()
rangeContainer.push(RangeObject(int(Operand), int(Operand)))
SymbolTable[rangeId1] = rangeContainer
return rangeId1
return rangeId1
def GetOperatorObject(Operator):
if Operator == '>':
return GTOperatorObject()
@ -214,8 +214,8 @@ class RangeExpression(BaseExpression):
NumberDict[HexNumber] = Number
for HexNum in NumberDict:
expr = expr.replace(HexNum, NumberDict[HexNum])
rangedict = {}
rangedict = {}
for validrange in self.RangePattern.findall(expr):
start, end = validrange.split(" - ")
start = start.strip()
@ -225,19 +225,19 @@ class RangeExpression(BaseExpression):
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
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]
@ -266,35 +266,35 @@ class RangeExpression(BaseExpression):
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 NegtiveRange(self, Oprand1):
rangeContainer1 = self.operanddict[Oprand1]
rangeids = []
for rangeobj in rangeContainer1.pop():
rangeContainer = RangeContainer()
rangeid = str(uuid.uuid1())
@ -321,13 +321,13 @@ class RangeExpression(BaseExpression):
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)
@ -338,7 +338,7 @@ class RangeExpression(BaseExpression):
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)
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)
@ -369,11 +369,11 @@ class RangeExpression(BaseExpression):
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
@ -393,9 +393,9 @@ class RangeExpression(BaseExpression):
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
@ -407,12 +407,12 @@ class RangeExpression(BaseExpression):
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