Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
match = re.compile(r'forall\s*\(.*\)\Z',re.I).match
name = ''
def process_item(self):
self.specs = self.item.get_line()[6:].lstrip()[1:-1].strip()
return BeginStatement.process_item(self)
def tostr(self):
return 'FORALL (%s)' % (self.specs)
def get_classes(self):
return [GeneralAssignment, WhereStmt, WhereConstruct,
ForallConstruct, ForallStmt]
ForallConstruct = Forall
# IfThen
class EndIfThen(EndStatement):
"""
END IF [ ]
"""
match = re.compile(r'end\s*if\s*\w*\Z', re.I).match
blocktype = 'if'
class IfThen(BeginStatement):
"""
[ :] IF ( ) THEN
IfThen instance has the following attributes:
expr
"""
match = re.compile(r'if\s*\(.*\)\s*then\Z',re.I).match
end_stmt_cls = EndIfThen
"""
match = re.compile(r'associate\s*\(.*\)\Z',re.I).match
end_stmt_cls = EndAssociate
def process_item(self):
line = self.item.get_line()[9:].lstrip()
self.associations = line[1:-1].strip()
return BeginStatement.process_item(self)
def tostr(self):
return 'ASSOCIATE (%s)' % (self.associations)
def get_classes(self):
return execution_part_construct
# Type
class EndType(EndStatement):
"""
END TYPE []
"""
match = re.compile(r'end\s*type\s*\w*\Z', re.I).match
blocktype = 'type'
class Type(BeginStatement, HasVariables, HasAttributes, AccessSpecs):
"""
TYPE [ [ , ] :: ] [ ( ) ]
= | EXTENDS ( )
| ABSTRACT | BIND(C)
"""
match = re.compile(r'type\b\s*').match
end_stmt_cls = EndType
a = AttributeHolder(extends = None,
s += '\n'
s += HasImplicitStmt.topyf(self, tab=tab+' ')
s += AccessSpecs.topyf(self, tab=tab+' ')
s += HasTypeDecls.topyf(self, tab=tab+' ')
s += HasVariables.topyf(self, tab=tab+' ', only_variables = self.args)
s += tab + 'END ' + self.__class__.__name__.upper() + ' ' + self.name + '\n'
return s
def is_public(self): return not self.is_private()
def is_private(self): return self.parent.check_private(self.name)
def is_recursive(self): return 'RECURSIVE' in self.a.attributes
def is_pure(self): return 'PURE' in self.a.attributes
def is_elemental(self): return 'ELEMENTAL' in self.a.attributes
class EndSubroutine(EndStatement):
"""
END [SUBROUTINE [name]]
"""
match = re.compile(r'end(\s*subroutine\s*\w*|)\Z', re.I).match
class Subroutine(SubProgramStatement):
"""
[ ] SUBROUTINE [ ( [ ] ) [ ]]
"""
end_stmt_cls = EndSubroutine
match = re.compile(r'(recursive|pure|elemental|\s)*subroutine\s*\w+', re.I).match
_repr_attr_names = ['prefix','bind','suffix','args'] + Statement._repr_attr_names
# Function
if rest:
self.parent.put_item(self.item.copy(prefix))
self.item.clone(rest)
self.isvalid = False
return
if self.parent.__class__ not in [Function, Subroutine]:
self.isvalid = False
return
prefix = prefix + ' ' + self.parent.prefix
self.parent.prefix = prefix.strip()
self.ignore = True
return
# SelectCase
class EndSelect(EndStatement):
match = re.compile(r'end\s*select\s*\w*\Z', re.I).match
blocktype = 'select'
class Select(BeginStatement):
"""
[ : ] SELECT CASE ( )
"""
match = re.compile(r'select\s*case\s*\(.*\)\Z',re.I).match
end_stmt_cls = EndSelect
name = ''
def tostr(self):
return 'SELECT CASE ( %s )' % (self.expr)
def process_item(self):
self.expr = self.item.get_line()[6:].lstrip()[4:].lstrip()[1:-1].strip()
self.construct_name = self.item.name
for name, stmt in list(self.a.module_subprogram.items()):
s += stmt.topyf(tab=tab+' ')
s += tab + 'END MODULE ' + self.name + '\n'
return s
def check_private(self, name):
if name in self.a.public_id_list: return False
if name in self.a.private_id_list: return True
if '' in self.a.public_id_list: return False
if '' in self.a.private_id_list: return True
#todo: handle generic-spec-s in id-lists.
return
# Python Module
class EndPythonModule(EndStatement):
match = re.compile(r'end(\s*python\s*module\s*\w*|)\Z', re.I).match
class PythonModule(BeginStatement, HasImplicitStmt, HasUseStmt,
HasVariables):
"""
PYTHON MODULE
..
END [PYTHON MODULE [name]]
"""
modes = ['pyf']
match = re.compile(r'python\s*module\s*\w+\Z', re.I).match
end_stmt_cls = EndPythonModule
def get_classes(self):
return [Interface, Function, Subroutine, Module]
match = re.compile(r'select\s*case\s*\(.*\)\Z',re.I).match
end_stmt_cls = EndSelect
name = ''
def tostr(self):
return 'SELECT CASE ( %s )' % (self.expr)
def process_item(self):
self.expr = self.item.get_line()[6:].lstrip()[4:].lstrip()[1:-1].strip()
self.construct_name = self.item.name
return BeginStatement.process_item(self)
def get_classes(self):
return [Case] + execution_part_construct
# Where
class EndWhere(EndStatement):
"""
END WHERE [ ]
"""
match = re.compile(r'end\s*\where\s*\w*\Z',re.I).match
class Where(BeginStatement):
"""
[ : ] WHERE ( )
=
"""
match = re.compile(r'where\s*\([^)]*\)\Z',re.I).match
end_stmt_cls = EndWhere
name = ''
def tostr(self):
return 'WHERE ( %s )' % (self.expr)
"""
BLOCK DATA [ ]
"""
end_stmt_cls = EndBlockData
match = re.compile(r'block\s*data\s*\w*\Z', re.I).match
def process_item(self):
self.name = self.item.get_line()[5:].lstrip()[4:].lstrip()
return BeginStatement.process_item(self)
def get_classes(self):
return specification_part
# Interface
class EndInterface(EndStatement):
match = re.compile(r'end\s*interface\s*(\w+\s*\(.*\)|\w*)\Z',re.I).match
blocktype = 'interface'
class Interface(BeginStatement, HasAttributes, HasImplicitStmt, HasUseStmt,
HasModuleProcedures, AccessSpecs
):
"""
INTERFACE [] | ABSTRACT INTERFACE
END INTERFACE []
=
| OPERATOR ( )
| ASSIGNMENT ( = )
|
= READ ( FORMATTED )
| READ ( UNFORMATTED )
return 'WHERE ( %s )' % (self.expr)
def process_item(self):
self.expr = self.item.get_line()[5:].lstrip()[1:-1].strip()
self.construct_name = self.item.name
return BeginStatement.process_item(self)
def get_classes(self):
return [Assignment, WhereStmt,
WhereConstruct, ElseWhere
]
WhereConstruct = Where
# Forall
class EndForall(EndStatement):
"""
END FORALL [ ]
"""
match = re.compile(r'end\s*forall\s*\w*\Z',re.I).match
class Forall(BeginStatement):
"""
[ : ] FORALL
[ ]...
=
|
|
|
|
= ( [ , ] )
= = : [ : ]
self.isvalid = False
return
def tostr(self):
assert len(self.content)==1,repr(self.content)
return 'IF (%s) %s' % (self.expr, str(self.content[0]).lstrip())
def tofortran(self,isfix=None):
return self.get_indent_tab(isfix=isfix) + self.tostr()
def get_classes(self):
return action_stmt
# Do
class EndDo(EndStatement):
"""
END DO [ ]
"""
match = re.compile(r'end\s*do\s*\w*\Z', re.I).match
blocktype = 'do'
class Do(BeginStatement):
"""
[ : ] DO label [loopcontrol]
[ : ] DO [loopcontrol]
"""
match = re.compile(r'do\b\s*\d*',re.I).match
item_re = re.compile(r'do\b\s*(?P<label>\d*)\s*,?\s*(?P.*)\Z',re.I).match
end_stmt_cls = EndDo</label>
if uattr not in known_attributes:
self.warning('unknown attribute %r' % (attr))
elif not known_attributes(uattr):
self.warning('unknown attribute %r' % (attr))
attributes.append(uattr)
else:
self.warning('multiple specification of attribute %r' % (attr))
return
class HasModuleProcedures(object):
a = AttributeHolder(module_procedures = [])
# File block
class EndSource(EndStatement):
"""
Dummy End statement for BeginSource.
"""
match = staticmethod(lambda s: False)
class BeginSource(BeginStatement):
"""
Fortran source content.
"""
match = staticmethod(lambda s: True)
end_stmt_cls = EndSource
a = AttributeHolder(module = {},
external_subprogram = {},
blockdata = {},
)
def tofortran(self,isfix=None):