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)