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)