def spec(self, variable, name):
        assertType(name, 'name', str, True)
        assertType(variable, 'variable', Variable)

        alias = variable.getAlias(name)
        if self.__intent is not None:
            alias.setIntent(self.__intent)
        if self.__allocatable is not None:
            if self.__allocatable:
                if (alias.getDimension() > 0
                        or alias.hasClassType()) and not alias.isPointer():
                    alias.setAllocatable(True)
            else:
                alias.setAllocatable(False)
        if self.__pointer is not None:
            if self.__pointer:
                alias.setPointer(True)
                alias.setAllocatable(False)
            else:
                alias.setPointer(False)
        if self.__optional is not None and alias.isArgument():
            alias.setOptional(self.__optional)
        if self.__charLengthZero and alias.hasBuiltInType(
        ) and alias.getTypeName().startswith('CHARACTER'):
            alias.setTypeName('CHARACTER(len=0)')
        alias.setTarget(False)
        return str(alias)
 def containerNeedsAllocation(self, variable):
     assertType(variable, 'variable', UsedVariable)
     for level in variable.levels(True):
         container = variable.container(level)
         if self.needsAllocation(container):
             return True
     return False
Пример #3
0
    def __init__(self, subroutine):
        assertType(subroutine, 'subroutine', Subroutine)

        self.name = subroutine.getSimpleName().lower()
        self.export = ''
        if self.name not in subroutine.getModule().getPublicElements():
            self.export = 'PUBLIC :: ' + self.name
 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 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 containerNeedsRegistration(self, variable):
        assertType(variable, 'variable', UsedVariable)

        for level in variable.levels(True):
            if not self.alreadyRegistered(variable.container(level)):
                return True

        return False
    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 ''
Пример #8
0
 def _setTypesToSubroutineVariables(self, subroutine, types):
     assertType(subroutine, 'subroutine', Subroutine)
     assertType(types, 'types', TypeCollection)
     
     for variable in subroutine.getVariables():
         if variable.hasDerivedType() and not variable.isTypeAvailable():
             typE = types.getType(variable.getDerivedTypeName(), subroutine.getModule())
             if typE is not None:
                 variable.setType(typE)
             else:
                 printWarning("Type " + variable.getDerivedTypeName() + " of variable " + variable.getName() + " not found.", location = "CodeGenerator")
Пример #9
0
    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)
Пример #10
0
    def generate(self, subroutineFullName):
        assertType(subroutineFullName, 'subroutineFullName', SubroutineFullName)

        if self._settings.ignorePrefix != '':
            self._settings.ignoreSubroutinesRegex = re.compile('^' + self._settings.ignorePrefix + '.*$')
        else:
            self._settings.ignoreSubroutinesRegex = None
            
        subroutine = self._findSubroutine(subroutineFullName)
        if subroutine is None:
            raise LookupError("Subroutine not found: " + str(subroutineFullName))

        if self._settings.measureTime: self.__initTime()
        
        printLine('Build Call Graph', indent = 1)
        callgraph = self.__graphBuilder.buildCallGraph(subroutineFullName, self._settings.clearCache)

        if self._settings.measureTime: self.__time(2)
        
        printLine('Find Interfaces and Types', indent = 1)
        useTraversal = UseTraversal(self._sourceFiles, self._settings.excludeModules, self._settings.abstractTypes)
        useTraversal.parseModules(callgraph.getRoot())
        interfaces = useTraversal.getInterfaces()
        types = useTraversal.getTypes()
        
        if self._settings.measureTime: self.__time(2)

        printLine('Analyse Source Code', indent = 1)
        argumentTracker = VariableTracker(self._sourceFiles, self._settings, interfaces, types, callGraphBuilder = self.__graphBuilder)
        
        printLine('Find References to Type Argument Members', indent = 2)
        typeArgumentReferences = argumentTracker.trackDerivedTypeArguments(callgraph)
        
        subroutine = self._findSubroutine(subroutineFullName)
        if subroutine.isFunction() and subroutine.getResultVariable().hasDerivedType():
            printLine('Find References to Type Result', indent = 2)
            typeResultReferences = argumentTracker.trackDerivedTypeResult(callgraph)
        else:
            typeResultReferences = []
        
        printLine('Find References to Global Variables', indent = 2)
        globalsTracker = GlobalVariableTracker(self._sourceFiles, self._settings, interfaces, types, callGraphBuilder = self.__graphBuilder)
        globalsReferences = globalsTracker.trackGlobalVariables(callgraph)
        
        sourceFile = subroutine.getSourceFile()
        sourceFilePath = sourceFile.getPath()
        if not os.path.isfile(sourceFile.getPath()):
            raise IOError("File not found: " + sourceFilePath);
        
        if self._settings.measureTime: self.__time(2)
        
        self.addCode(subroutineFullName, typeArgumentReferences, typeResultReferences, globalsReferences, callgraph, types)
        
        if self._settings.measureTime: self.__time(2, True, 1)
    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('.')
Пример #12
0
    def extendSpecialModuleFiles(self, specialModuleFiles):
        assertType(specialModuleFiles, 'specialModuleFiles', dict)
        backupFiles = self.find()
        for module, filE in specialModuleFiles.items():
            backupFile = self.__getBackupFile(filE)
            if backupFile in backupFiles:
                specialModuleFiles[module] = backupFile
                backupFiles.remove(backupFile)
        for backupFile in backupFiles:
            specialModuleFiles[self.__getModuleName(backupFile)] = backupFile[(
                backupFile.rfind('/') + 1):]

        return specialModuleFiles
    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 generate(self, subroutineFullName):
        assertType(subroutineFullName, 'subroutineFullName',
                   SubroutineFullName)

        if self.__ignorePrefix != '':
            ignoreRegex = re.compile('^' + self.__ignorePrefix +
                                     subroutineFullName.getSimpleName() +
                                     '_.*$')
        else:
            ignoreRegex = None

        print "  Build Call Graph"
        callGraph = self.__graphBuilder.buildCallGraph(subroutineFullName)

        print "  Find Interfaces"
        useTraversal = UseTraversal(self._sourceFiles, self.__excludeModules)
        useTraversal.parseModules(callGraph.getRoot())
        interfaces = useTraversal.getInterfaces()
        types = useTraversal.getTypes()

        print "  Analyse Source Code"
        print "    Find References to Type Argument Members"
        argumentTracker = VariableTracker(self._sourceFiles,
                                          self.__excludeModules,
                                          self.__ignoredTypes, interfaces,
                                          types)
        argumentTracker.setIgnoreRegex(ignoreRegex)
        typeArgumentReferences = argumentTracker.trackDerivedTypeArguments(
            callGraph)
        print "    Find References to Global Variables"
        globalsTracker = GlobalVariableTracker(self._sourceFiles,
                                               self.__excludeModules,
                                               self.__ignoredModulesForGlobals,
                                               self.__ignoredTypes, interfaces,
                                               types)
        globalsTracker.setIgnoreRegex(ignoreRegex)
        globalsReferences = globalsTracker.trackGlobalVariables(callGraph)

        subroutine = self._findSubroutine(subroutineFullName)
        if subroutine is None:
            raise LookupError("Subroutine not found: " +
                              str(subroutineFullName))
        sourceFile = subroutine.getSourceFile()
        sourceFilePath = sourceFile.getPath()
        if not os.path.isfile(sourceFile.getPath()):
            raise IOError("File not found: " + sourceFilePath)

        self.addCode(subroutine, typeArgumentReferences, globalsReferences)
    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, 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 allocatedOrAssociated(self, variable, minLevel=0):
        assertType(variable, 'variable', UsedVariable, True)
        assertType(minLevel, 'minLevel', int)
        assert minLevel >= 0

        if variable is None:
            return ''

        if variable.allocatable():
            return 'ALLOCATED(' + variable.expression() + ')'
        elif variable.pointer():
            return 'ASSOCIATED(' + variable.expression() + ')'
        elif variable.level() > minLevel:
            return self.allocatedOrAssociated(variable.container())
        else:
            return ''
    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 __init__(self,
                 intent=None,
                 allocatable=None,
                 pointer=None,
                 optional=None,
                 charLengthZero=False):
        assertType(intent, 'intent', str, True)
        assertType(allocatable, 'allocatable', bool, True)
        assertType(pointer, 'pointer', bool, True)
        assertType(optional, 'optional', bool, True)
        assert not (allocatable and pointer)
        assertType(charLengthZero, 'charLengthZero', bool)

        self.__intent = intent
        self.__allocatable = allocatable
        self.__pointer = pointer
        self.__optional = optional
        self.__charLengthZero = charLengthZero
    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, currentModule, globalsReferences):
        assertType(currentModule, 'currentModule', Module)
        assertType(globalsReferences, 'globalsReferences', list)

        publicElements = currentModule.getPublicElements()

        self.exports = 'PUBLIC :: '
        variables = set()
        for ref in globalsReferences:
            variable = ref.getLevel0Variable()
            refModule = variable.getModule()
            if refModule == currentModule:
                variableName = variable.getOriginalName().lower()
                if variableName not in variables and not variable.isPublic(
                ) and variableName not in publicElements:
                    self.exports += variableName + ", "
                    variables.add(variableName)
        self.exports = self.exports.strip(', ')
        if self.exports == 'PUBLIC ::':
            self.exports = ''
Пример #22
0
    def __init__(self,
                 sourceFiles,
                 templateDir,
                 testSourceDir,
                 testDataDir,
                 graphBuilder,
                 backupSuffix,
                 excludeModules=[],
                 ignoredModulesForGlobals=[],
                 ignoredTypes=[],
                 ignoreRegex=''):
        assertType(sourceFiles, 'sourceFiles', SourceFiles)
        assertType(templateDir, 'templateDir', str)
        if not os.path.isdir(templateDir):
            raise IOError("Not a directory: " + templateDir)
        assertType(testDataDir, 'testDataDir', str)
        if not os.path.isdir(testDataDir):
            raise IOError("Not a directory: " + testDataDir)

        super(ReplayCodeGenerator,
              self).__init__(sourceFiles, graphBuilder, backupSuffix,
                             excludeModules, ignoredModulesForGlobals,
                             ignoredTypes, ignoreRegex)
        self.__testTemplate = os.path.join(templateDir, self.TEST_TEMPLATE)
        self.__testSourceDir = testSourceDir
        self.__testDataDir = testDataDir
    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)
Пример #24
0
    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)
Пример #25
0
    def __init__(self, subroutine, typeArgumentReferences, globalsReferences,
                 testDataDir):
        assertType(subroutine, 'subroutine', Subroutine)
        assertType(typeArgumentReferences, 'typeArgumentReferences', list)
        assertType(globalsReferences, 'globalsReferences', list)

        self.__subroutine = subroutine
        self._typeArgumentReferences = typeArgumentReferences

        self._globalsReferences = []
        for reference in globalsReferences:
            reference = reference.cleanCopy()
            variableName = reference.getVariableName()
            if reference.getDeclaredInName() != subroutine.getModuleName():
                variable = reference.getLevel0Variable()
                moduleName = variable.getDeclaredInName()
                if variable is not None and moduleName is not None:
                    newName = moduleName + '__' + variableName
                    alias = variable.getAlias(newName)
                    reference.setLevel0Variable(alias)
            self._globalsReferences.append(reference)

        self.subroutine = SubroutineNameSpace(subroutine)
        self.module = ModuleNameSpace(subroutine.getModuleName())
        self.arguments = ArgumentsNameSpace(subroutine, typeArgumentReferences)
        self.globals = GlobalsNameSpace(subroutine, subroutine.getSourceFile(),
                                        self._globalsReferences, False)
        self.dataDir = testDataDir.rstrip('/')
Пример #26
0
    def __init__(self, moduleName, sourceFile, globalsReferences):
        assertType(moduleName, 'moduleName', str)
        assertType(sourceFile, 'sourceFile', SourceFile)
        assertType(globalsReferences, 'globalsReferences', list)

        publicElements = sourceFile.getPublicElements()

        self.exports = 'PUBLIC :: '
        variables = set()
        types = set()
        for ref in globalsReferences:
            variable = ref.getLevel0Variable()
            refModule = variable.getDeclaredInName()
            if refModule == moduleName:
                variableName = variable.getOriginalName().lower()
                if variableName not in variables and not variable.isPublic(
                ) and variableName not in publicElements:
                    self.exports += variableName + ", "
                    variables.add(variableName)
            if variable.hasDerivedType() and variable.isTypeAvailable():
                typE = variable.getType()
                refModule = typE.getDeclaredInName()
                if refModule == moduleName:
                    typeName = typE.getName().lower()
                    if typeName not in types and typeName not in publicElements:
                        self.exports += typeName + ", "
                        types.add(typeName)
        self.exports = self.exports.strip(', ')

        if self.exports == 'PUBLIC ::':
            self.exports = ''
Пример #27
0
    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 writeVarNameWithFilledIndicesToString(self, variable, destination, dim,
                                              *indices):
        assertType(variable, 'variable', UsedVariable, True)

        if variable is None:
            return ''

        parts = []
        for index in indices:
            parts.append("', " + index + ", '")

        filled = self.fillIndices(variable, dim, *parts)
        if not filled:
            return ''
        if filled.expression() == variable.expression():
            return destination + ' = "' + variable.expression() + '"'

        write = "WRITE (" + destination + ",'("
        write += 'A,I0,' * min(dim, len(indices), variable.totalDim())
        write += "A)') '" + filled.expression() + "'"

        return write
Пример #29
0
    def __init__(self, moduleName, sourceFile, globalsReferences):
        assertType(moduleName, 'moduleName', str)
        assertType(sourceFile, 'sourceFile', SourceFile)
        assertType(globalsReferences, 'globalsReferences', list)

        self.module = ModuleNameSpace(moduleName)
        self.globals = ExportGlobalsNameSpace(moduleName, sourceFile,
                                              globalsReferences)
    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