def __init__(self, reference, dim, *indices):
assertType(reference, 'reference', VariableReference)
assertType(dim, 'dim', int)
assertTypeAll(indices, 'indices', str)
super(FilledVariable, self).__init__(reference)
self.__dim = dim
self.__indices = indices
def __init__(self, subroutine, sourceFile, globalsReferences,
includeTestModule):
assertType(subroutine, 'subroutine', Subroutine)
assertType(sourceFile, 'sourceFile', SourceFile)
assertTypeAll(globalsReferences, 'globalsReferences',
VariableReference)
assertType(includeTestModule, 'includeTestModule', bool)
self.usedVariables = []
variables = set()
for ref in globalsReferences:
self.usedVariables.append(UsedVariable(ref))
variable = ref.getLevel0Variable()
variables.add(variable)
variables = sorted(variables)
self.usedVariables = sorted(self.usedVariables)
testModule = subroutine.getModule()
modules = dict()
for variable in variables:
moduleName = variable.getDeclaredInName()
if moduleName != testModule.getName() or includeTestModule:
if moduleName not in modules:
modules[moduleName] = []
varName = variable.getName()
if varName != variable.getOriginalName():
varName += ' => ' + variable.getOriginalName()
modules[moduleName].append(varName)
self.imports = []
for module, elements in sorted(modules.items()):
self.imports.append('USE ' + module + ', ONLY: ' +
', '.join(elements))
self.imports = "\n".join(self.imports)
def needsAllocationFilled(self, variable, dim, *indices):
assertType(variable, 'variable', UsedVariable)
assertType(dim, 'dim', int)
assertTypeAll(indices, 'indices', str)
filled = self.fillIndices(variable, dim, *indices)
return (variable.allocatableOrPointer() or
variable.hasClassType()) and not self.alreadyAllocated(filled)
def ubound(self, variable, dim, *placeholder):
'''DEPRECATED: work with fillIndices instead'''
assertType(variable, 'variable', UsedVariable, True)
assertType(dim, 'dim', int)
assertTypeAll(placeholder, 'placeholder', str)
bound = self.__bound(variable, dim, placeholder)
if bound != '':
return 'U' + bound
return ''
def __init__(self, subroutine, typeArgumentReferences):
assertType(subroutine, 'subroutine', Subroutine)
assertTypeAll(typeArgumentReferences, 'typeArgumentReferences',
VariableReference)
self.input = ArgumentsSubNameSpace(subroutine.getInArguments(),
typeArgumentReferences)
self.output = ArgumentsSubNameSpace(subroutine.getOutArguments(),
typeArgumentReferences)
self.all = ArgumentsSubNameSpace(subroutine.getArguments(),
typeArgumentReferences)
def __init__(self, sourceDirs, backupSuffix):
assertType(backupSuffix, 'backupSuffix', str)
if isinstance(sourceDirs, str):
sourceDirs = [sourceDirs]
assertTypeAll(sourceDirs, 'sourceDirs', str)
for baseDir in sourceDirs:
if not os.path.isdir(baseDir):
raise IOError("Not a directory: " + baseDir)
self.__sourceDirs = sourceDirs
self.__backupSuffix = '.' + backupSuffix.lstrip('.')
def __init__(self, subroutine, sourceFile, globalsReferences,
includeTestModule):
assertType(subroutine, 'subroutine', Subroutine)
assertType(sourceFile, 'sourceFile', SourceFile)
assertTypeAll(globalsReferences, 'globalsReferences',
VariableReference)
assertType(includeTestModule, 'includeTestModule', bool)
self.usedVariables = []
variables = set()
types = set()
for reference in globalsReferences:
self.usedVariables.append(reference.getExpression())
variable = reference.getLevel0Variable()
variables.add(variable)
if variable.hasDerivedType() and variable.isTypeAvailable():
types.add(variable.getType())
testModule = subroutine.getName().getModuleName()
modules = dict()
for variable in variables:
moduleName = variable.getDeclaredInName()
if moduleName != testModule or includeTestModule:
if moduleName not in modules:
modules[moduleName] = []
varName = variable.getName()
if varName != variable.getOriginalName():
varName += ' => ' + variable.getOriginalName()
modules[moduleName].append(varName)
for typE in types:
moduleName = typE.getDeclaredInName()
if isinstance(moduleName, str) and (moduleName != testModule
or includeTestModule):
if moduleName not in modules:
modules[moduleName] = []
modules[moduleName].append(typE.getName())
self.imports = ''
for module, elements in modules.iteritems():
self.imports += 'USE ' + module + ', ONLY: '
for element in elements:
self.imports += element
#TODO alias
self.imports += ', '
self.imports = self.imports.strip(', ')
self.imports += "\n"
self.imports = self.imports.strip("\n")
exportGlobals = ExportGlobalsNameSpace(testModule, sourceFile,
globalsReferences)
self.exports = exportGlobals.exports
def __init__(self, sourceFiles, templatePath, graphBuilder, postProcessor, settings):
assertType(sourceFiles, 'sourceFiles', SourceFiles)
assertType(templatePath, 'templatePath', str)
if not os.path.isfile(templatePath):
raise IOError("Template file not found: " + templatePath)
assertType(graphBuilder, 'graphBuilder', CallGraphBuilder)
assertType(postProcessor, 'postProcessor', CodePostProcessor)
assertType(settings, 'settings', CodeGeneratorSettings)
assertTypeAll(settings.excludeModules, 'settings.excludeModules', str)
assertTypeAll(settings.ignoreGlobalsFromModules, 'settings.ignoreGlobalsFromModules', str)
assertTypeAll(settings.ignoredTypes, 'settings.ignoredTypes', str)
assertType(settings.ignorePrefix, 'settings.ignorePrefix', str)
assertType(settings.abstractTypes, 'settings.abstractTypes', dict)
assertTypeAll(settings.abstractTypes, 'settings.abstractTypes', str)
assertType(settings.measureTime, 'settings.measureTime', bool)
assertType(settings.clearCache, 'settings.clearCache', bool)
self._sourceFiles = sourceFiles
self.__templatePath = templatePath
self.__graphBuilder = graphBuilder
self._postProcessor = postProcessor
self._settings = settings
templateDir = os.path.dirname(os.path.realpath(self.__templatePath))
templateDirParent = os.path.abspath(os.path.join(templateDir, os.pardir))
for name in os.listdir(templateDirParent):
templateDirSibling = os.path.join(templateDirParent, name)
if os.path.isdir(templateDirSibling):
sys.path.append(templateDirSibling)
ImportHooks.install()
def __init__(self, variable, references):
assertType(variable, 'variable', Variable)
assert variable.isFunctionResult()
assertTypeAll(references, 'references', VariableReference)
self.__var = variable
self.__used = []
for ref in references:
if ref.getLevel0Variable() == self.__var:
self.__used.append(UsedVariable(ref))
if not self.__used and variable.hasBuiltInType():
self.__used.append(
UsedVariable(
VariableReference(variable.getName(),
variable.getDeclaredIn().getName(), 0,
variable)))
def __bound(self, variable, dim, placeholder):
assertType(variable, 'variable', UsedVariable, True)
assertType(dim, 'dim', int)
assertTypeAll(placeholder, 'placeholder', str)
if variable is None:
return ''
noDim = False
if dim <= 0:
noDim = True
ref = variable.getReference()
if ref.isOneVariableArray():
if noDim:
dim = ref.getTotalDimensions()
elif dim > ref.getTotalDimensions():
return ''
top = 0
perc = ''
bound = 'BOUND('
for level in ref.getLevels():
var = ref.getVariable(level)
if var is None:
return ''
bound += perc + var.getName()
perc = '%'
bot = top
top += var.getDimension()
if top < dim:
if top > bot:
bound += '('
sep = ''
for i in range(bot, top):
bound += sep + placeholder[i]
sep = ', '
bound += ')'
else:
break
if not noDim:
bound += ', ' + str(dim - bot)
bound += ')'
return bound
return ''
def addCode(self, subroutineFullName, typeArgumentReferences,
typeResultReferences, globalsReferences, callgraph, types):
assertType(subroutineFullName, 'subroutineFullName',
SubroutineFullName)
assertTypeAll(typeArgumentReferences, 'typeArgumentReferences',
VariableReference)
assertTypeAll(typeResultReferences, 'typeResultReferences',
VariableReference)
assertTypeAll(globalsReferences, 'globalsReferences',
VariableReference)
assertType(callgraph, 'callgraph', CallGraph)
assertType(types, 'types', TypeCollection)
printLine('Create code in new test source file', indent=1)
tempTestFile = os.path.join(self.__testSourceDir, self.TEMP_TEST_FILE)
printLine('Create file ' + tempTestFile, indent=2)
self._writeFile(tempTestFile, [])
subroutine = self._findSubroutine(subroutineFullName)
self._setTypesToSubroutineVariables(subroutine, types)
templateNameSpace = ReplayTemplatesNameSpace(
subroutine, typeArgumentReferences, typeResultReferences,
globalsReferences, self.__testDataDir, callgraph,
self._postProcessor)
self._processTemplate(tempTestFile, 0, self.TEST_TEMPLATE_PART,
templateNameSpace)
testModuleName = self.__findModuleNameInTestFile(tempTestFile)
if testModuleName is not None:
testFilePath = os.path.join(self.__testSourceDir,
testModuleName + '.f90')
printLine('Rename file to ' + testFilePath, indent=2)
os.rename(tempTestFile, testFilePath)
def __init__(self, currentModule, typeArgumentReferences,
typeResultReferences, globalsReferences, subroutine,
callgraph, postProcessor):
assertType(currentModule, 'currentModule', Module)
assertTypeAll(typeArgumentReferences, 'typeArgumentReferences',
VariableReference)
assertTypeAll(typeResultReferences, 'typeResultReferences',
VariableReference)
assertTypeAll(globalsReferences, 'globalsReferences',
VariableReference)
assertType(subroutine, 'subroutine', Subroutine)
assertType(callgraph, 'callgraph', CallGraph)
assertType(postProcessor, 'postProcessor', CodePostProcessor)
self._postProcessor = postProcessor
self.module = ModuleNameSpace(currentModule.getName(), callgraph)
self.globals = ExportGlobalsNameSpace(currentModule, globalsReferences)
self.types = ExportTypesNameSpace(currentModule,
typeArgumentReferences,
typeResultReferences,
globalsReferences, subroutine)
self.subroutine = SubroutineNameSpace(subroutine, None, None,
callgraph)
self.clearLine = CodePostProcessor.CLEAR_LINE
def __init__(self, subroutine, typeArgumentReferences, globalsReferences,
includeTestModule):
assertType(subroutine, 'subroutine', Subroutine)
assertTypeAll(typeArgumentReferences, 'typeArgumentReferences',
VariableReference)
assertTypeAll(globalsReferences, 'globalsReferences',
VariableReference)
assertType(includeTestModule, 'includeTestModule', bool)
variables = set(subroutine.getDerivedTypeArguments())
for reference in globalsReferences:
variables.add(reference.getLevel0Variable())
self.__types = dict()
for variable in variables:
if variable.hasDerivedType() and variable.isTypeAvailable():
typE = variable.getType()
if typE.getName() not in self.__types:
self.__types[typE.getName()] = typE
#self.__addMemberTypesToTypSet(typE)
testModule = subroutine.getName().getModuleName()
modules = dict()
for typE in self.__types.values():
moduleName = typE.getDeclaredInName()
if isinstance(moduleName, str) and (moduleName != testModule
or includeTestModule):
if moduleName not in modules:
modules[moduleName] = []
modules[moduleName].append(typE.getName())
self.imports = ''
for module, typeNames in modules.iteritems():
self.imports += ' USE ' + module + ', ONLY: '
for typeName in typeNames:
self.imports += typeName + ', '
self.imports = self.imports.strip(', ')
self.imports += "\n"
self.imports = self.imports.strip("\n")
def alloc(self, variable, *dimSizes):
assertType(variable, 'variable', UsedVariable, True)
assertTypeAll(dimSizes, 'dimSizes', str)
if variable is None:
return ''
dim = variable.dim()
alloc = 'ALLOCATE('
if variable.polymorph():
alloc += variable.dynamicType() + '::'
alloc += variable.expression()
if dim > 0:
alloc += '('
sep = ''
for d in range(min(dim, len(dimSizes))):
alloc += sep + dimSizes[d]
sep = ', '
alloc += ')'
alloc += ')'
self.setAllocated(variable)
return alloc
def addCode(self, subroutineFullName, typeArgumentReferences,
typeResultReferences, globalsReferences, callgraph, types):
assertType(subroutineFullName, 'subroutineFullName',
SubroutineFullName)
assertTypeAll(typeArgumentReferences, 'typeArgumentReferences',
VariableReference)
assertTypeAll(typeResultReferences, 'typeResultReferences',
VariableReference)
assertTypeAll(globalsReferences, 'globalsReferences',
VariableReference)
assertType(callgraph, 'callgraph', CallGraph)
assertType(types, 'types', TypeCollection)
printLine('Add Code to Used Modules', indent=1)
self.__backupFinder.setBackupSuffixPrefix(
self.__backupFinder.EXPORT_SUFFIX_PREFIX)
refModules = list(
self.__getModulesFromCallgraph(callgraph).union(
self.__extractModulesFromVariableReferences(
globalsReferences)))
refModules.sort(reverse=True)
for refModule in refModules:
usedSourceFile = refModule.getSourceFile()
usedSourceFilePath = usedSourceFile.getPath()
if usedSourceFilePath.endswith(
self.__backupFinder.getBackupSuffix()):
usedSourceFilePath = usedSourceFilePath.replace(
self.__backupFinder.getBackupSuffix(),
CodeGenerator.DEFAULT_SUFFIX)
usedSourceFile = SourceFile(usedSourceFilePath,
usedSourceFile.isPreprocessed())
refModule = usedSourceFile.getModule(refModule.getName())
self.__backupFinder.setBackupSuffixPrefix(
BackupFileFinder.EXPORT_SUFFIX_PREFIX)
backup = self.__backupFinder.create(usedSourceFilePath)
subroutine = self._findSubroutine(subroutineFullName)
self._setTypesToSubroutineVariables(subroutine, types)
exportTemplateNameSpace = ExportTemplatesNameSpace(
refModule, typeArgumentReferences, typeResultReferences,
globalsReferences, subroutine, callgraph, self._postProcessor)
lastLine = refModule.getContainsLineNumber()
if lastLine < 0:
lastLine = refModule.getLastLineNumber()
result = self._processTemplate(usedSourceFilePath, lastLine - 1,
self.BEFORE_CONTAINS_TEMPLATE_PART,
exportTemplateNameSpace)
lastUseLineNumber = refModule.getLastUseLineNumber()
lastUseLineNumber = self._shiftLineNumberByPreprocesserorEndifs(
refModule, lastUseLineNumber)
result = self._processTemplate(usedSourceFilePath,
lastUseLineNumber,
self.AFTER_USE_TEMPLATE_PART,
exportTemplateNameSpace) or result
if backup and not result:
self.__backupFinder.remove(usedSourceFilePath)
def __init__(self, arguments, typeArgumentReferences=None):
if typeArgumentReferences is None:
assertTypeAll(arguments, 'arguments', Argument)
self.__arguments = arguments
else:
assertTypeAll(arguments, 'arguments', Variable)
assertTypeAll(typeArgumentReferences, 'typeArgumentReferences',
VariableReference)
self.__arguments = [
Argument(var, typeArgumentReferences) for var in arguments
]
def __init__(self, subroutine, typeArgumentReferences,
typeResultReferences, globalsReferences, includeTestModule):
assertType(subroutine, 'subroutine', Subroutine)
assertTypeAll(typeArgumentReferences, 'typeArgumentReferences',
VariableReference)
assertTypeAll(typeResultReferences, 'typeResultReferences',
VariableReference)
assertTypeAll(globalsReferences, 'globalsReferences',
VariableReference)
assertType(includeTestModule, 'includeTestModule', bool)
types = set()
for variable in subroutine.getDerivedTypeArguments():
if variable.hasDerivedType() and variable.isTypeAvailable():
types.add(variable.getType())
refTypes = set(types)
for reference in typeArgumentReferences + typeResultReferences + globalsReferences:
for level in reference.getLevels():
variable = reference.getVariable(level)
if variable is not None:
if variable.hasDerivedType() and variable.isTypeAvailable(
):
refTypes.add(variable.getType())
for typE in refTypes:
if typE.isAbstract() and typE.hasAssignedImplementation():
types.add(typE.getAssignedImplementation())
types = sorted(types)
testModule = subroutine.getModule()
modules = dict()
for typE in types:
module = typE.getModule()
if module is not None and module != testModule or includeTestModule:
moduleName = module.getName()
if moduleName not in modules:
modules[moduleName] = []
modules[moduleName].append(typE.getName())
self.imports = ''
for module, typeNames in modules.items():
self.imports += ' USE ' + module + ', ONLY: '
for typeName in typeNames:
self.imports += typeName + ', '
self.imports = self.imports.strip(', ')
self.imports += "\n"
self.imports = self.imports.strip("\n")
def __init__(self, currentModule, typeArgumentReferences,
typeResultReferences, globalsReferences, subroutine):
assertType(currentModule, 'currentModule', Module)
assertType(subroutine, 'subroutine', Subroutine)
assertTypeAll(typeArgumentReferences, 'typeArgumentReferences',
VariableReference)
assertTypeAll(typeResultReferences, 'typeResultReferences',
VariableReference)
assertTypeAll(globalsReferences, 'globalsReferences',
VariableReference)
types = set()
for variable in subroutine.getDerivedTypeArguments():
if variable.hasDerivedType() and variable.isTypeAvailable():
types.add(variable.getType())
refTypes = set(types)
for reference in typeArgumentReferences + typeResultReferences + globalsReferences:
for level in reference.getLevels():
variable = reference.getVariable(level)
if variable is not None:
if variable.hasDerivedType() and variable.isTypeAvailable(
):
refTypes.add(variable.getType())
for typE in refTypes:
if typE.isAbstract() and typE.hasAssignedImplementation():
implType = typE.getAssignedImplementation()
if implType.getName() not in types:
types.add(implType)
types = sorted(types)
publicElements = currentModule.getPublicElements()
self.exports = 'PUBLIC :: '
for typE in types:
module = typE.getModule()
typeName = typE.getName()
if module is not None and module == currentModule and not typE.isPublic(
) and typeName not in publicElements:
self.exports += typeName + ", "
self.exports = self.exports.strip(', ')
if self.exports == 'PUBLIC ::':
self.exports = ''
def __init__(self,
sourceFiles,
graphBuilder,
backupSuffix,
excludeModules=[],
ignoredModulesForGlobals=[],
ignoredTypes=[],
ignorePrefix=''):
assertType(sourceFiles, 'sourceFiles', SourceFiles)
assertType(graphBuilder, 'graphBuilder', CallGraphBuilder)
assertType(backupSuffix, 'backupSuffix', str)
assertTypeAll(excludeModules, 'excludeModules', str)
assertTypeAll(ignoredModulesForGlobals, 'ignoredModulesForGlobals',
str)
assertTypeAll(ignoredTypes, 'ignoredTypes', str)
self._sourceFiles = sourceFiles
self.__graphBuilder = graphBuilder
self._backupSuffix = '.' + backupSuffix.lstrip('.')
self.__excludeModules = excludeModules
self.__ignoredModulesForGlobals = ignoredModulesForGlobals
self.__ignoredTypes = ignoredTypes
self.__ignorePrefix = ignorePrefix
def fillIndices(self, variable, dim, *indices):
assertType(variable, 'variable', UsedVariable)
assertType(dim, 'dim', int)
assertTypeAll(indices, 'indices', str)
return FilledVariable(variable.getReference(), dim, *indices)
