class BasicIOList(BasicStatement):
def __init__(self, sLabel=None, loc=None, nIndent=0, sKeyword="",
sParOpen=None, opt=None):
BasicStatement.__init__(self, sLabel, loc, nIndent, isDeclaration=0)
self.sKeyword = sKeyword
self.sParOpen = sParOpen
self.sParClose = ')'
self.lParams = DoubleList()
if opt: self.AddIOOpt(opt)
# --------------------------------------------------------------------------
def SetParOpen(self, sParOpen='('): self.sParOpen = sParOpen
# --------------------------------------------------------------------------
def SetParClose(self, sParClose=')'): self.sParClose = sParClose
# --------------------------------------------------------------------------
def AddIOOpt(self, exp, sComma=None):
if type(exp)==type(1): exp=`exp`
self.lParams.append(exp, sComma)
# --------------------------------------------------------------------------
def sGetParClose(self): return self.sParClose
# --------------------------------------------------------------------------
def GetVarUsage(self, varUsage, sType="read", obj=None, loc=None):
for i in self.lParams.GetMainList():
varUsage.AddVariable(i, "unknown", obj, loc)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sKeyword))
if self.sParOpen:
l.append(self.sParOpen)
self.lParams.ToList(stylesheet, l),
l.append(self.sParClose)
class Implicit(BasicStatement):
# Stores a parameter declaration
def __init__(self, sImplicit="IMPLICIT", loc=None, nIndent=0):
BasicStatement.__init__(self, None, loc, nIndent)
self.sImplicit = sImplicit
self.sNone = None
self.type = None
self.l = DoubleList()
self.sParOpen = None
self.sParClose = None
# --------------------------------------------------------------------------
def SetParOpen(self, sParOpen): self.sParOpen = sParOpen
# --------------------------------------------------------------------------
def SetParClose(self, sParClose): self.sParClose = sParClose
# --------------------------------------------------------------------------
def SetImplicitNone(self, sNone="NONE"): self.sNone=sNone
# --------------------------------------------------------------------------
def isNone(self): return self.sNone!=None
# --------------------------------------------------------------------------
def SetType(self, type): self.type=type
# --------------------------------------------------------------------------
def AddLetter(self, sFrom, sDash=None, sTo=None, sComma=None):
self.l.append(FromTo(sFrom, sDash, sTo), sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sImplicit),nIndentNext=1)
if self.sNone:
l.append(stylesheet.sKeyword(self.sNone))
return
stylesheet.ToList(self.type, l)
l.append(self.sParOpen)
self.l.ToList(stylesheet, l)
l.append(self.sParClose)
class CrayPointer(BasicStatement):
def __init__(self, loc, sPointer='POINTER', nIndent=0):
BasicStatement.__init__(self, None, loc, nIndent)
self.sPointer = sPointer
self.lPointer = DoubleList()
# --------------------------------------------------------------------------
def AddPointer(self, pointer, sComma=None):
self.lPointer.append(pointer, sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(self.sPointer, nIndentNext=1)
self.lPointer.ToList(stylesheet, l)
class DataValueList(BasicRepr):
def __init__(self, sSlash1='/'):
self.sSlash1 = sSlash1
self.sSlash2 = None
self.ValueList = DoubleList()
# --------------------------------------------------------------------------
def AddValue(self, obj, sComma=None): self.ValueList.append(obj, sComma)
# --------------------------------------------------------------------------
def AddSlash(self, sSlash): self.sSlash2 = sSlash
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
l.append(self.sSlash1)
self.ValueList.ToList(stylesheet, l)
l.append(self.sSlash2)
class FunctionStatement(BasicStatement):
def __init__(self, loc=None, nIndent=0, lType=None, sFunc="FUNCTION", sName="",
oFunc = None):
BasicStatement.__init__(self, None, loc, nIndent, isDeclaration=0)
self.sFunc = sFunc
self.sName = sName
self.lArgs = DoubleList()
self.sParOpen = None
self.sParClose = None
self.lType = lType
self.oFunc = oFunc
self.lResult = []
# --------------------------------------------------------------------------
def SetParOpen(self, sParOpen ): self.sParOpen = sParOpen
# --------------------------------------------------------------------------
def SetParClose(self, sParClose): self.sParClose = sParClose
# --------------------------------------------------------------------------
def GetName(self): return self.sName
# --------------------------------------------------------------------------
def GetType(self): return self.lType
# --------------------------------------------------------------------------
def GetArguments(self): return self.lArgs.GetMainList()
# --------------------------------------------------------------------------
def AddArgument(self, sName, sComma=None, d=None):
self.lArgs.append(sName, sComma)
if self.oFunc:
self.oFunc.AddArgument(sName, sComma=sComma, d=d)
# --------------------------------------------------------------------------
def SetResult(self, sResult, sParOpen, sName, sParClose):
self.lResult = [sResult, sParOpen, sName, sParClose]
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
for i in self.lType:
if i.__class__==Type:
i.ToList(stylesheet, l)
else:
l.append(stylesheet.sKeyword(i))
l.indent(1)
l.append(stylesheet.sKeyword(self.sFunc), nIndentNext=1)
l.append(self.sName)
if not self.sParOpen:
return
l.append(self.sParOpen)
self.lArgs.ToList(stylesheet, l)
l.append(self.sParClose)
if self.lResult:
l.indent(1)
l.extend(self.lResult)
class ModuleProcedure(BasicStatement):
def __init__(self, loc, sModule=None, sProcedure="PROCEDURE", nIndent=0):
BasicStatement.__init__(self, None, loc, nIndent)
self.sModule = sModule
self.sProcedure = sProcedure
self.l = DoubleList()
# --------------------------------------------------------------------------
def AddProcedure(self, obj, sComma=None): self.l.append(obj, sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
if self.sModule:
l.append(self.sModule, nIndentNext=1)
l.append(self.sProcedure, nIndentNext=1)
else:
l.append(self.sProcedure, nIndentNext=1)
self.l.ToList(stylesheet, l)
class SubroutineStatement(BasicStatement):
def __init__(self, loc=None, lPrefix=[], sSub="SUBROUTINE", sName="",
nIndent=0, oSub = None):
BasicStatement.__init__(self, None, loc, nIndent)
self.lPrefix = lPrefix
self.sSub = sSub
self.sName = sName
self.lArgs = DoubleList()
self.sParOpen = None
self.sParClose = None
self.oSub = oSub
# --------------------------------------------------------------------------
def SetParOpen(self, sParOpen): self.sParOpen = sParOpen
# --------------------------------------------------------------------------
def SetParClose(self, sParClose): self.sParClose = sParClose
# --------------------------------------------------------------------------
def GetName(self): return self.sName
# --------------------------------------------------------------------------
def GetPrefix(self): return self.lPrefix
# --------------------------------------------------------------------------
def GetArguments(self): return self.lArgs.GetMainList()
# --------------------------------------------------------------------------
def AddArgument(self, sName, sComma=None, d=None):
if self.sParOpen==None: self.sParOpen="("
self.sParClose = ")"
if sComma==None and \
len(self.lArgs.lGetSecondaryList())==len(self.lArgs)-1:
self.lArgs.append(",", sName)
else:
self.lArgs.append(sName, sComma)
if self.oSub:
self.oSub.AddArgument(sName, sComma=sComma, d=d)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
for i in self.lPrefix:
l.append(stylesheet.sKeyword(i), nIndentNext=1)
l.append(stylesheet.sKeyword(self.sSub), nIndentNext=1)
l.append(self.sName)
if not self.sParOpen:
return
l.append(self.sParOpen)
self.lArgs.ToList(stylesheet, l)
l.append(self.sParClose)
class DataStatementSet(BasicRepr):
def __init__(self, sComma=None):
self.sComma = sComma
self.ObjectList = DoubleList()
self.DataValue = None
# --------------------------------------------------------------------------
def AddObject(self, obj, sComma=None): self.ObjectList.append(obj, sComma)
# --------------------------------------------------------------------------
def AddValueList(self, vl): self.DataValue = vl
# --------------------------------------------------------------------------
def AddSecondSlash(self, sSlash): self.sSlash2 = sSlash
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
if self.sComma:
l.append(self.sComma, nIndentNext=1)
self.ObjectList.ToList(stylesheet, l)
self.DataValue.ToList(stylesheet, l)
class Allocate(BasicStatement):
# Stores a return statement.
def __init__(self, sLabel=None, loc=None, sOp='ALLOCATE',sParOpen='(',
nIndent=0):
BasicStatement.__init__(self, sLabel, loc, nIndent, isDeclaration=0)
self.sOp = sOp
self.sParOpen = sParOpen
self.lVars = DoubleList()
self.lOptions = DoubleList()
self.sParClose = ")"
# --------------------------------------------------------------------------
def SetParClose(self, sParClose): self.sParClose = sParClose
# --------------------------------------------------------------------------
# Adds a variable to allocate to the allocate statement. Parameters:
#
# var -- Variable to add
#
# sSeparator -- String which separates a variable from the next. Usual a
# comma, but the ')' is stored here as well.
def AddVariable(self, var, sSeparator=None):
self.lVars.append(var, sSeparator)
# --------------------------------------------------------------------------
# Appends an option (stat, errmsg, or source) to the statement. Parameters:
#
# sName -- Name of the option
#
# sEqual -- The '=' character
#
# obj -- A scalar int variable
#
# sSeparator -- String which separates an option from the next. Usual a
# comma, but the ')' can be stored here as well.
def AddOption(self, sName, sEqual, obj, sSeparator=None):
self.lOptions.append( OptionString(sName, sEqual, obj), sSeparator )
# --------------------------------------------------------------------------
# Creates a list of strings which represents this statement. Parameters:
#
# stylesheet -- The stylesheet to use during layout
def ToList(self, stylesheet=None,l=[]):
BasicStatement.ToList(self, stylesheet, l)
l.extend([stylesheet.sKeyword(self.sOp), self.sParOpen]) # 'allocate', '('
self.lVars.ToList(stylesheet, l)
self.lOptions.ToList(stylesheet, l)
l.append(self.sParClose)
class Declaration(BasicStatement):
def __init__(self, sType, sComma=None, loc=None, nIndent=0, var=None,
attribute=None):
BasicStatement.__init__(self, None, loc, nIndent)
self.sType = sType
self.sComma = sComma
self.lAttributes = DoubleList()
self.lColons = []
self.lVars = DoubleList()
if var:
self.AppendVariable(var)
if attribute:
self.AddAttribute(attribute)
# --------------------------------------------------------------------------
# Add a variable or an array specification to the list of declaration
def AddDeclaredVariable(self, var, sComma=None):
self.lVars.append(var, sComma)
# --------------------------------------------------------------------------
# Add an attribute, like 'allocateable', ...
def AddAttribute(self, sAtt, sComma=None):
if len(self.lAttributes)==0 and not self.sComma:
self.sComma=","
self.lAttributes.append(sAtt, sComma)
# --------------------------------------------------------------------------
# Adds the optional double colon of a declaration. Parameters:
#
# c1/c2 -- Each of the two colons (the scanner returns two colons for a ::)
def AddDoubleColons(self, c1, c2): self.lColons=[c1,c2]
# --------------------------------------------------------------------------
# This function is used to construct new declaration statements:
def AppendVariable(self, v):
if len(self.lVars)==0:
self.lColons=[":",":"]
self.lVars.append(v)
else:
self.lVars.append(",", v)
# --------------------------------------------------------------------------
def GetAttributes(self):
return self.lAttributes.GetMainList()
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
stylesheet.ToList(self.sType, l)
if self.sComma:
l.append(self.sComma)
l.indent(1)
# The if is not really necessary, but without it two spaces
# would be added in case of an empy attribute list
if len(self.lAttributes.GetMainList())>0:
self.lAttributes.ToList(stylesheet, l, bAddSpace=1)
l.indent(1)
if self.lColons:
l.extend(self.lColons)
l.indent(1)
self.lVars.ToList(stylesheet, l, bAddSpace=1)
class Public(BasicStatement):
# Stores a public statement declaration
def __init__(self, loc, sPublic="PUBLIC", nIndent=0):
BasicStatement.__init__(self, None, loc, nIndent)
self.sPublic = sPublic
self.lColons = None
self.l = DoubleList()
# --------------------------------------------------------------------------
def AddDoubleColons(self, c1, c2): self.lColons=[c1,c2]
# --------------------------------------------------------------------------
def AddObject(self, obj, sComma=None): self.l.append(obj, sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sPublic), nIndentNext=1)
if self.lColons:
l.extend(self.lColons)
self.l.ToList(stylesheet, l)
class Intrinsic(BasicStatement):
# Stores an intrinsic declaration
def __init__(self, loc, sIntri="INTRINSIC", nIndent=0):
BasicStatement.__init__(self, None, loc, nIndent)
self.sIntri = sIntri
self.lColons = None
self.l = DoubleList()
# --------------------------------------------------------------------------
def AddDoubleColons(self, c1, c2): self.lColons=[c1,c2]
# --------------------------------------------------------------------------
def AddIntrinsic(self, obj, sComma=None): self.l.append(obj, sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sIntri),nIndentNext=1)
if self.lColons:
l.extend(self.lColons)
self.l.ToList(stylesheet, l)
class Read(BasicIOList):
# Stores a read statement
def __init__(self, sLabel=None, loc=None, nIndent=0,
sRead="READ", sParOpen=None,
nUnit=None, var=None):
BasicIOList.__init__(self, sLabel, loc, nIndent, sRead, sParOpen)
self.lIOExp = DoubleList()
self.sFormat = None
self.sComma = None
if nUnit:
if not sParOpen: self.SetParOpen()
self.AddIOOpt("%s"%nUnit)
self.SetParClose()
if var:
self.AddIOExpression(var)
# --------------------------------------------------------------------------
def SetFormat(self, sFormat, sComma=None):
self.sFormat = sFormat
self.sComma = sComma
# --------------------------------------------------------------------------
def AddIOExpression(self, exp, sComma=None):
# To simplify manually creating statements, a comma is automatically
# added, if only expressions are specified here (except for the first
# call).
if type(exp)==type(1): exp=`exp`
if sComma==None and \
len(self.lIOExp.lGetSecondaryList())==len(self.lIOExp)-1:
self.lIOExp.append(",", exp)
else:
self.lIOExp.append(exp, sComma)
# --------------------------------------------------------------------------
def GetVarUsage(self, varUsage, sType="read", obj=None, loc=None):
for i in self.lIOExp.GetMainList():
varUsage.AddVariable(i, "write", obj, loc)
BasicIOList.GetVarUsage(self, varUsage, sType, obj, loc)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicIOList.ToList(self, stylesheet, l)
l.append(' ')
if self.sFormat:
l.append(self.sFormat, nIndent=1)
if self.sComma:
l.append(self.sComma)
self.lIOExp.ToList(stylesheet, l)
class External(BasicStatement):
# Stores an external declaration
def __init__(self, loc, sExternal="EXTERNAL", nIndent=0):
BasicStatement.__init__(self, None, loc, nIndent)
self.sExternal = sExternal
self.lColon = []
self.l = DoubleList()
# --------------------------------------------------------------------------
def AddDoubleColon(self, sCol1, sCol2): self.lColon=[sCol1,sCol2]
# --------------------------------------------------------------------------
def AddExternal(self, ext, sComma=None):
self.l.append(ext, sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sExternal), nIndentNext=1)
if self.lColon:
l.extend(self.lColon)
self.l.ToList(stylesheet, l)
class Equivalence(BasicStatement):
def __init__(self, loc, sEq="EQUIVALENCE", nIndent=0):
BasicStatement.__init__(self, None, loc, nIndent)
self.sEq = sEq
self.lObjects = DoubleList()
# --------------------------------------------------------------------------
def AddObject(self, obj, sComma=None):
self.lObjects.append(obj, sComma)
# --------------------------------------------------------------------------
def GetAllUsedVariables(self):
l=[]
for i in self.lObjects.GetMainList():
l.extend(i.GetAllUsedVariables())
return l
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sEq))
self.lObjects.ToList(stylesheet, l)
class Nullify(BasicStatement):
def __init__(self, sLabel=None, loc=None, sNullify="NULLIFY",
sParOpen='(', nIndent=0):
BasicStatement.__init__(self, sLabel, loc, nIndent, isDeclaration=0)
self.sNullify = sNullify
self.sParOpen = sParOpen
self.sParClose = None
self.lPointers = DoubleList()
# --------------------------------------------------------------------------
def SetParClose(self, sParClose=')'): self.sParClose=')'
# --------------------------------------------------------------------------
def AddExpression(self, exp, sComma=None):
self.lPointers.append(exp, sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.extend([stylesheet.sKeyword(self.sNullify), self.sParOpen])
self.lPointers.ToList(stylesheet, l)
l.append(self.sParClose)
class IODoList(BasicRepr):
# Stores '(obj1, obj2, ..., objn, i=1, n)
def __init__(self,sParOpen, obj1, sComma1):
self.sParOpen = sParOpen
self.sParClose = None
self.lObj = DoubleList(l1=[obj1], l2=[sComma1])
self.lLoopData = [] # stores: [var,'=',from',',to]
# and maybe [',',stride]
# --------------------------------------------------------------------------
# Sets the implied do variable and the equal sign
def SetVar(self, v, sEqual): self.lLoopData.extend([v, sEqual])
# --------------------------------------------------------------------------
def SetFrom(self,f,sComma): self.lLoopData.extend([f,sComma])
# --------------------------------------------------------------------------
def SetTo(self,t): self.lLoopData.append(t)
# --------------------------------------------------------------------------
def SetStep(self,sComma, s): self.lLoopData.extend([sComma,s])
# --------------------------------------------------------------------------
def AddExpr(self, e, sComma): self.lObj.append(e, sComma)
# --------------------------------------------------------------------------
def SetParClose(self, sParClose): self.sParClose = sParClose
# --------------------------------------------------------------------------
def GetVarUsage(self, varUsage, sType="read", obj=None, loc=None):
for i in self.lObj.GetMainList():
varUsage.AddVariable(i, sType, obj, loc)
varUsage.AddVariable(self.lLoopData[0], "write", obj, loc)
varUsage.AddVariable(self.lLoopData[2], "read", obj, loc)
varUsage.AddVariable(self.lLoopData[4], "read", obj, loc)
if len(self.lLoopData)>5:
varUsage.AddVariable(self.lLoopData[6], "read", obj, loc)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
l.append(self.sParOpen)
self.lObj.ToList(stylesheet, l)
stylesheet.ToList(self.lLoopData[0], l) # var
l.append(self.lLoopData[1]) # =
stylesheet.ToList(self.lLoopData[2], l) # from
l.append(self.lLoopData[3]) # ,
stylesheet.ToList(self.lLoopData[4], l) # to
if len(self.lLoopData)>5:
l.append(self.lLoopData[5]) # ,
stylesheet.ToList(self.lLoopData[6], l) # step
l.append(self.sParClose)
class Dimension(BasicStatement):
def __init__(self, loc, sDim="DIMENSION", nIndent=0):
BasicStatement.__init__(self, None, loc, nIndent)
self.lVars = DoubleList()
self.sDim = sDim
self.lColons = []
# --------------------------------------------------------------------------
def AddDoubleColons(self, c1, c2):
self.lColons=[c1,c2]
# --------------------------------------------------------------------------
def AddArraySpec(self, arrayspec, sComma=None):
self.lVars.append(arrayspec, sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sDim), nIndentNext=1)
if self.lColons:
l.extend(self.lColons)
l.indent(1)
self.lVars.ToList(stylesheet, l, bAddSpace=1)
class Pointer(BasicStatement):
def __init__(self, loc, sPointer='POINTER', nIndent=0):
BasicStatement.__init__(self, None, loc, nIndent)
self.sPointer = sPointer
self.lPointer = DoubleList()
self.lColons = None
# --------------------------------------------------------------------------
def AddDoubleColons(self, c1, c2): self.lColons=[c1,c2]
# --------------------------------------------------------------------------
def AddPointer(self, pointer, sComma=None):
self.lPointer.append(pointer, sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(self.sPointer)
if self.lColons:
l.indent(1)
l.extend(self.lColons)
l.indent(1)
self.lPointer.ToList(stylesheet, l)
class Print(BasicStatement):
# Stores a return statement.
def __init__(self, sLabel=None, loc=None, sPrint="PRINT", nIndent=0,
format=None):
BasicStatement.__init__(self, sLabel, loc, nIndent, isDeclaration=0)
self.sPrint = sPrint
self.format = format
if format:
self.sComma = "," # First comma after format
else:
self.sComma = None # First comma after format
self.lIO = DoubleList()
# --------------------------------------------------------------------------
def AddIOExpression(self, e, sComma=None): self.lIO.append(e, sComma)
# --------------------------------------------------------------------------
def SetComma(self, sComma): self.sComma=sComma
# --------------------------------------------------------------------------
def GetVarUsage(self, varUsage, sType="read", obj=None, loc=None):
for i in self.lIO.GetMainList():
varUsage.AddVariable(i, sType, obj, loc)
# --------------------------------------------------------------------------
def SetFormat(self, format):
self.format = format
self.sComma = ","
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sPrint),nIndentNext=1)
if type(self.format)==StringType:
l.append(self.format)
elif type(self.format)==IntType:
l.append(`self.format`)
else:
stylesheet.ToList(self.format, l)
if not self.sComma: return
l.append(self.sComma)
self.lIO.ToList(stylesheet, l)
class Save(BasicStatement):
# Stores a parameter declaration
def __init__(self, loc, sSave="SAVE", nIndent=0):
BasicStatement.__init__(self, None, loc, nIndent)
self.sSave = sSave
self.lColons = None
self.l = DoubleList()
# --------------------------------------------------------------------------
def AddDoubleColons(self, c1, c2): self.lColons=[c1,c2]
# --------------------------------------------------------------------------
def AddCommonBlock(self, sSlash1, obj, sSlash2, sComma=None):
self.l.append(CommonBlockName(sSlash1, obj, sSlash2), sComma)
# --------------------------------------------------------------------------
def AddObject(self, obj, sComma=None):
self.l.append(obj, sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sSave), nIndentNext=1)
if self.lColons:
l.extend(self.lColons)
self.l.ToList(stylesheet, l)
class EquivalenceItem(BasicRepr):
def __init__(self, sParOpen):
self.sParOpen = sParOpen
self.l = DoubleList()
self.sParClose = ''
# --------------------------------------------------------------------------
def AddObject(self, obj, sComma=None): self.l.append(obj, sComma)
# --------------------------------------------------------------------------
def SetParClose(self, sParClose): self.sParClose = sParClose
# --------------------------------------------------------------------------
def GetAllEquivalentVariables(self):
return self.l.GetMainList()
# --------------------------------------------------------------------------
def GetAllUsedVariables(self):
l=[]
for i in self.l.GetMainList():
l.extend(i.GetAllUsedVariables())
return l
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
l.append(self.sParOpen)
self.l.ToList(stylesheet, l)
l.append(self.sParClose)
class Parameter(BasicStatement):
# Stores a parameter declaration
def __init__(self, loc, sParam="PARAMETER", nIndent=0, sParOpen="("):
BasicStatement.__init__(self, None, loc, nIndent)
self.sParam = sParam
self.l = DoubleList()
self.sParOpen = sParOpen
self.sParClose = None
# --------------------------------------------------------------------------
def AddVarValue(self, var, sEqual, obj, sComma=None):
a=Assignment(sLabel=None, loc=None, nIndent=0, lhs=var,
sEqual=sEqual, rhs=obj, bNoIndent=1)
self.l.append(a, sComma)
# --------------------------------------------------------------------------
def SetParClose(self, sParClose): self.sParClose=sParClose
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sParam))
l.append(self.sParOpen)
self.l.ToList(stylesheet, l)
l.append(self.sParClose)
class ComputedGoto(BasicStatement):
# Stores a goto statement (with a label)
#
# sLabel -- Label of the statement (5 digit number as a string)
#
# sGotoLabel -- The label to go to
def __init__(self, sLabel=None, loc=None, sGo="GO", sTo="TO",
sParOpen="(", nIndent=0):
BasicStatement.__init__(self, sLabel, loc, nIndent, isDeclaration=0)
self.sGo = sGo
self.sTo = sTo
self.sParOpen = sParOpen
self.sParClose = ""
self.sComma = ""
self.lLabels = DoubleList()
self.oExp = None
# --------------------------------------------------------------------------
def AddLabel(self, sLabel, sComma=None):
self.lLabels.append(sLabel, sComma)
# --------------------------------------------------------------------------
def SetParClose(self, sParClose): self.sParClose =sParClose
# --------------------------------------------------------------------------
def AddComma(self, sComma): self.sComma = sComma
# --------------------------------------------------------------------------
def SetExp(self, oExp): self.oExp = oExp
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.extend([stylesheet.sKeyword(self.sGo), stylesheet.sKeyword(self.sTo)])
l.append(self.sParOpen, nIndent=1)
self.lLabels.ToList(stylesheet, l)
l.append(self.sParClose)
if self.sComma:
l.append(self.sComma)
self.oExp.ToList(stylesheet, l)
class Case(BasicStatement):
# Stores a Case statement
#
def __init__(self, sLabel=None, loc=None, sCase='CASE', nIndent=0):
BasicStatement.__init__(self, sLabel, loc, nIndent, isDeclaration=0)
self.sCase = sCase
self.sName = None
self.sDefault = None # for DEFAULT
self.sParOpen = None
self.sParClose = None
self.lSelector = DoubleList()
# --------------------------------------------------------------------------
def SetName(self, sName): self.sName = sName
# --------------------------------------------------------------------------
def SetParOpen(self, sParOpen='('): self.sParOpen=sParOpen
# --------------------------------------------------------------------------
def SetParClose(self, sParClose=')'): self.sParClose=sParClose
# --------------------------------------------------------------------------
# Sets either the selector to 'DEFAULT' or to '(obj)'.
def AddSelector(self, obj=None, sComma=None, sDefault=None):
if sDefault:
self.sDefault = sDefault
else:
self.lSelector.append(obj, sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(self.sCase, nIndentNext=1)
if self.sDefault:
l.append(self.sDefault)
else:
l.append(self.sParOpen)
self.lSelector.ToList(stylesheet, l)
l.append(self.sParClose)
if self.sName: l.append(self.sName, nIndentNext=1)
class ArithmeticIf(BasicStatement):
# Stores an arithmetic if statement
def __init__(self, sLabel=None, loc=None, sIf="IF", sParOpen='(',
ifCond=None, sParClose=')', nIndent=0):
BasicStatement.__init__(self, sLabel, loc, nIndent, isDeclaration=0)
self.sIf = sIf
self.sParOpen = sParOpen
self.ifCond = ifCond
self.sParClose = sParClose
self.lLabels = DoubleList()
# --------------------------------------------------------------------------
def GetVarUsage(self, varUsage):
varUsage.AddVariable(self.ifCond, "read", self)
# --------------------------------------------------------------------------
def AppendLabel(self, sLabel, sComma=None):
self.lLabels.append(sLabel, sComma)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sIf), nIndentNext=1)
l.append(self.sParOpen)
stylesheet.ToList(self.ifCond, l)
l.append(self.sParClose, nIndentNext=1)
self.lLabels.ToList(stylesheet, l)
class FunctionCall(BasicRepr):
# Stores a function call.
def __init__(self, sName=None, sArg=None):
self.sName = sName
self.lArgs = DoubleList()
self.sParOpen = None
self.sParClose = None
if sArg:
self.sParOpen="("
self.AddArgument(sArg)
self.sParClose=")"
# --------------------------------------------------------------------------
# Returns the name of the called subroutine
def sGetName(self): return self.sName
# --------------------------------------------------------------------------
def lGetArgs(self): return self.lArgs
# --------------------------------------------------------------------------
def SetParOpen(self, sParOpen): self.sParOpen = sParOpen
# --------------------------------------------------------------------------
def SetParClose(self, sParClose): self.sParClose = sParClose
# --------------------------------------------------------------------------
# Adds an actual argument.
def AddArgument(self, arg, sComma=None):
if self.sParOpen==None: self.sParOpen="("
self.sParClose = ")"
if sComma==None and \
len(self.lArgs.lGetSecondaryList())==len(self.lArgs)-1:
self.lArgs.append(",", arg)
else:
self.lArgs.append(arg, sComma)
# --------------------------------------------------------------------------
# Adds a keyword argument: keyword=val
def AddKeywordArgument(self, sKeyword, sEqual, obj, sComma=None):
self.lArgs.append(OptionString(sKeyword, sEqual, obj), sComma)
# --------------------------------------------------------------------------
# Adds an alternate return specification: *123
def AddAltReturn(self, sStar, sLabel, sComma=None):
self.lArgs.append(StarLabel(sStar, sLabel), sComma)
# --------------------------------------------------------------------------
# Adds an alternate return specification with keyword: keyw=*123
def AddKeywordAltReturn(self, sKeyword, sEqual, sStar, sLabel, sComma=None):
self.lArgs.append(OptionString(sKeyword, sEqual,
StarLabel(sStar, sLabel)), sComma)
# --------------------------------------------------------------------------
def GetVarUsage(self, varUsage, sType="read", obj=None, loc=None):
for i in self.lArgs.GetMainList():
varUsage.AddVariable(i, "unknown", obj, loc)
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
if stylesheet["mathsmode"]:
s = string.lower(self.sName)
if s=="sqrt" and stylesheet["dosqrt"]:
return stylesheet.HandleSqrt(self, l)
if s=="exp" and stylesheet["doexp"]:
return stylesheet.HandleExp(self, l)
if s=="abs" and stylesheet["doabs"]:
return stylesheet.HandleAbs(self, l)
l.append(self.sName)
if not self.sParOpen: return
l.append(self.sParOpen)
self.lArgs.ToList(stylesheet, l, bAddSpace=1)
l.append(self.sParClose)
class Use(BasicStatement):
# Constructor. Parameters:
#
# sub -- progunit Object, used to store variables in
def __init__(self, loc, sUse="USE", nIndent=0):
BasicStatement.__init__(self, None, loc, nIndent)
self.sUse = sUse
self.lNature = []
self.lColons = []
self.lOnly = DoubleList()
self.lOnlyString = ''
self.lRename = DoubleList()
self.sComma = None
self.sName = None
# --------------------------------------------------------------------------
# Returns the name of the module
def GetName(self): return self.sName
# --------------------------------------------------------------------------
# Returns true if this is a 'use only' use statement
def IsOnly(self): return len(self.lOnly)>0
# --------------------------------------------------------------------------
# Returns a list of all imported entries from a module
def GetOnlyList(self):
return self.lOnly
# --------------------------------------------------------------------------
# Returns true if this has a rename list
def HasRename(self): return len(self.lRename)>0
# --------------------------------------------------------------------------
# Returns a list of tuples (from,to) for all renamed entries
def GetRenameList(self):
l=[]
for i in self.lRename:
l.append( (i[0], i[1]) )
return l
# --------------------------------------------------------------------------
def SetNature(self, sComma, sNature): self.lNature=[sComma, sNature]
# --------------------------------------------------------------------------
# Adds the optional double colon of an use statement. Parameters:
#
# c1/c2 -- Each of the two colons (the scanner returns two colons for a ::)
def AddDoubleColon(self, c1, c2): self.lColons=(c1,c2)
# --------------------------------------------------------------------------
# Sets the module name to import from. Parameter:
#
# sName -- Name
def SetName(self, sName):
self.sName=sName
# --------------------------------------------------------------------------
# Adds the comma which comes before a "ONLY" or a rename list
def AddComma(self, sComma): self.sComma=sComma
# --------------------------------------------------------------------------
# Adds the comma, the 'only' string, and the colon. If this function was
# called, no rename function (AddRenameComma/AddRename) should be called.
def AddOnlyString(self, sOnly="ONLY", sColon=":"):
self.lOnlyString=[sOnly, sColon]
# --------------------------------------------------------------------------
# Adds a 'only' import plus (optionally) a comma
def AddOnly(self, var, sComma=None): self.lOnly.append(var, sComma)
# --------------------------------------------------------------------------
# Adds a rename statement, i.e. the ", from => to" part - including the
# comma!
def AddRename(self, sFrom, sArrow, varTo, sComma=None):
self.lRename.append( RenameVar(sFrom, sArrow, varTo), sComma )
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sUse), nIndentNext=1)
if self.lNature: l.extend(self.lNature)
if self.lColons:
l.extend(self.lColons)
l.indent(1)
l.append(self.sName)
# If it's an 'only' use statement
if self.sComma: l.append(self.sComma)
if self.lOnly:
l.extend(self.lOnlyString)
self.lOnly.ToList(stylesheet, l)
else:
self.lRename.ToList(stylesheet, l)
