Classes
class	SelectTypeInfo

Public Member Functions
def	__init__ (self)

def	generate_psyir (self, parse_tree)

def	generate_container (self, module_ast)

def	get_routine_schedules (self, name, module_ast)

def	process_declarations (self, parent, nodes, arg_list, visibility_map=None)

def	process_nodes (self, parent, nodes)

Static Public Member Functions
def	nodes_to_code_block (parent, fp2_nodes, message=None)

def	process_access_statements (nodes)

Public Attributes
	handlers

Static Public Attributes
	unary_operators

	binary_operators

Detailed Description

Class to encapsulate the functionality for processing the fparser2 AST and
convert the nodes to PSyIR.

Definition at line 1025 of file fparser2.py.

Member Function Documentation

◆ generate_container()

def psyclone.psyir.frontend.fparser2.Fparser2Reader.generate_container	(	self,
		module_ast
	)

Create a Container from the supplied fparser2 module AST.

:param module_ast: fparser2 AST of the full module.
:type module_ast: :py:class:`fparser.two.Fortran2003.Program`

:returns: PSyIR container representing the given module_ast or None \
          if there's no module in the parse tree.
:rtype: :py:class:`psyclone.psyir.nodes.Container`

:raises GenerationError: unable to generate a Container from the \
                         provided fpaser2 parse tree.

Definition at line 1224 of file fparser2.py.

     def generate_container(self, module_ast):
         '''
         Create a Container from the supplied fparser2 module AST.
  
         :param module_ast: fparser2 AST of the full module.
         :type module_ast: :py:class:`fparser.two.Fortran2003.Program`
  
         :returns: PSyIR container representing the given module_ast or None \
                   if there's no module in the parse tree.
         :rtype: :py:class:`psyclone.psyir.nodes.Container`
  
         :raises GenerationError: unable to generate a Container from the \
                                  provided fpaser2 parse tree.
         '''
         # Assume just 1 or 0 Fortran module definitions in the file
         modules = walk(module_ast, Fortran2003.Module_Stmt)
         if len(modules) > 1:
             raise GenerationError(
                 f"Could not process {module_ast}. Just one module definition "
                 f"per file supported.")
         if not modules:
             return None
  
         module = modules[0].parent
         mod_name = str(modules[0].children[1])
  
         # Create a container to capture the module information
         new_container = Container(mod_name)
  
         # Search for any accessibility statements (e.g. "PUBLIC :: my_var") to
         # determine the default accessibility of symbols as well as identifying
         # those that are explicitly declared as public or private.
         (default_visibility, visibility_map) = self.process_access_statements(
             module)
         new_container.symbol_table.default_visibility = default_visibility
  
         # Create symbols for all routines defined within this module
         _process_routine_symbols(module_ast, new_container.symbol_table,
                                  visibility_map)
  
         # Parse the declarations if it has any
         for child in module.children:
             if isinstance(child, Fortran2003.Specification_Part):
                 self.process_declarations(new_container, child.children,
                                           [], visibility_map)
                 break
  
         return new_container
  

References psyclone.psyir.frontend.fparser2.Fparser2Reader.process_access_statements(), and psyclone.psyir.frontend.fparser2.Fparser2Reader.process_declarations().

Here is the call graph for this function:

◆ generate_psyir()

def psyclone.psyir.frontend.fparser2.Fparser2Reader.generate_psyir	(	self,
		parse_tree
	)

Translate the supplied fparser2 parse_tree into PSyIR.

:param parse_tree: the supplied fparser2 parse tree.
:type parse_tree: :py:class:`fparser.two.Fortran2003.Program`

:returns: PSyIR representation of the supplied fparser2 parse_tree.
:rtype: :py:class:`psyclone.psyir.nodes.Container` or \
    :py:class:`psyclone.psyir.nodes.Routine`

:raises GenerationError: if the root of the supplied fparser2 \
    parse tree is not a Program.

Definition at line 1199 of file fparser2.py.

     def generate_psyir(self, parse_tree):
         '''Translate the supplied fparser2 parse_tree into PSyIR.
  
         :param parse_tree: the supplied fparser2 parse tree.
         :type parse_tree: :py:class:`fparser.two.Fortran2003.Program`
  
         :returns: PSyIR representation of the supplied fparser2 parse_tree.
         :rtype: :py:class:`psyclone.psyir.nodes.Container` or \
             :py:class:`psyclone.psyir.nodes.Routine`
  
         :raises GenerationError: if the root of the supplied fparser2 \
             parse tree is not a Program.
  
         '''
         if not isinstance(parse_tree, Fortran2003.Program):
             raise GenerationError(
                 f"The Fparser2Reader generate_psyir method expects the root "
                 f"of the supplied fparser2 tree to be a Program, but found "
                 f"'{type(parse_tree).__name__}'")
  
         node = Container("dummy")
         self.process_nodes(node, [parse_tree])
         result = node.children[0]
         return result.detach()
  

References psyclone.psyir.frontend.fparser2.Fparser2Reader.process_nodes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_routine_schedules()

def psyclone.psyir.frontend.fparser2.Fparser2Reader.get_routine_schedules	(	self,
		name,
		module_ast
	)

Create one or more schedules for routines corresponding to the
supplied name in the supplied fparser2 AST. (There can be more than
one routine if the supplied name corresponds to an interface block
in the AST.)

:param str name: name of the subroutine represented by the kernel.
:param module_ast: fparser2 AST of the full module where the kernel \
                   code is located.
:type module_ast: :py:class:`fparser.two.Fortran2003.Program`

:returns: PSyIR schedules representing the matching subroutine(s).
:rtype: List[:py:class:`psyclone.psyir.nodes.KernelSchedule`]

:raises GenerationError: if supplied parse tree contains more than \
                         one module.
:raises GenerationError: unable to generate a kernel schedule from \
                         the provided fpaser2 parse tree.

Definition at line 1273 of file fparser2.py.

     def get_routine_schedules(self, name, module_ast):
         '''Create one or more schedules for routines corresponding to the
         supplied name in the supplied fparser2 AST. (There can be more than
         one routine if the supplied name corresponds to an interface block
         in the AST.)
  
         :param str name: name of the subroutine represented by the kernel.
         :param module_ast: fparser2 AST of the full module where the kernel \
                            code is located.
         :type module_ast: :py:class:`fparser.two.Fortran2003.Program`
  
         :returns: PSyIR schedules representing the matching subroutine(s).
         :rtype: List[:py:class:`psyclone.psyir.nodes.KernelSchedule`]
  
         :raises GenerationError: if supplied parse tree contains more than \
                                  one module.
         :raises GenerationError: unable to generate a kernel schedule from \
                                  the provided fpaser2 parse tree.
  
         '''
         psyir = self.generate_psyir(module_ast)
         lname = name.lower()
  
         containers = [ctr for ctr in psyir.walk(Container) if
                       not isinstance(ctr, FileContainer)]
         if not containers:
             raise GenerationError(
                 f"The parse tree supplied to get_routine_schedules() must "
                 f"contain a single module but found none when searching for "
                 f"kernel '{name}'.")
         if len(containers) > 1:
             raise GenerationError(
                 f"The parse tree supplied to get_routine_schedules() must "
                 f"contain a single module but found more than one "
                 f"({[ctr.name for ctr in containers]}) when searching for "
                 f"kernel '{name}'.")
         container = containers[0]
  
         # Check for an interface block
         actual_names = []
         interfaces = walk(module_ast, Fortran2003.Interface_Block)
  
         for interface in interfaces:
             if interface.children[0].children[0].string.lower() == lname:
                 # We have an interface block with the name of the routine
                 # we are searching for.
                 procs = walk(interface, Fortran2003.Procedure_Stmt)
                 for proc in procs:
                     for child in proc.children[0].children:
                         actual_names.append(child.string.lower())
                 break
         if not actual_names:
             # No interface block was found so we proceed to search for a
             # routine with the original name that we were passed.
             actual_names = [lname]
  
         routines = container.walk(Routine)
         selected_routines = [routine for routine in routines
                              if routine.name.lower() in actual_names]
  
         if not selected_routines:
             raise GenerationError(
                 f"Could not find subroutine or interface '{name}' in the "
                 f"module '{container.name}'.")
  
         return selected_routines
  

References psyclone.psyir.frontend.fparser2.Fparser2Reader.generate_psyir().

Here is the call graph for this function:

◆ nodes_to_code_block()

def psyclone.psyir.frontend.fparser2.Fparser2Reader.nodes_to_code_block	(	parent,
		fp2_nodes,
		message = `None`
	)

static

Create a CodeBlock for the supplied list of fparser2 nodes and then
wipe the list. A CodeBlock is a node in the PSyIR (Schedule)
that represents a sequence of one or more Fortran statements
and/or expressions which PSyclone does not attempt to handle.

:param parent: Node in the PSyclone AST to which to add this CodeBlock.
:type parent: :py:class:`psyclone.psyir.nodes.Node`
:param fp2_nodes: list of fparser2 AST nodes constituting the
                  CodeBlock.
:type fp2_nodes: list of :py:class:`fparser.two.utils.Base`
:param message: Include a preceeding comment attached to the CodeBlock.
:type message: Optional[str]

:returns: a CodeBlock instance.
:rtype: :py:class:`psyclone.CodeBlock`

Definition at line 1156 of file fparser2.py.

     def nodes_to_code_block(parent, fp2_nodes, message=None):
         '''Create a CodeBlock for the supplied list of fparser2 nodes and then
         wipe the list. A CodeBlock is a node in the PSyIR (Schedule)
         that represents a sequence of one or more Fortran statements
         and/or expressions which PSyclone does not attempt to handle.
  
         :param parent: Node in the PSyclone AST to which to add this CodeBlock.
         :type parent: :py:class:`psyclone.psyir.nodes.Node`
         :param fp2_nodes: list of fparser2 AST nodes constituting the
                           CodeBlock.
         :type fp2_nodes: list of :py:class:`fparser.two.utils.Base`
         :param message: Include a preceeding comment attached to the CodeBlock.
         :type message: Optional[str]
  
         :returns: a CodeBlock instance.
         :rtype: :py:class:`psyclone.CodeBlock`
  
         '''
         if not fp2_nodes:
             return None
  
         # Determine whether this code block is a statement or an
         # expression. Statements always have a `Schedule` as parent
         # and expressions do not. The only unknown at this point are
         # directives whose structure are in discussion. Therefore, for
         # the moment, an exception is raised if a directive is found
         # as a parent.
         if isinstance(parent, (Schedule, Container)):
             structure = CodeBlock.Structure.STATEMENT
         elif isinstance(parent, Directive):
             raise InternalError(
                 "Fparser2Reader:nodes_to_code_block: A CodeBlock with "
                 "a Directive as parent is not yet supported.")
         else:
             structure = CodeBlock.Structure.EXPRESSION
  
         code_block = CodeBlock(fp2_nodes, structure, parent=parent)
         if message:
             code_block.preceding_comment = message
         parent.addchild(code_block)
         del fp2_nodes[:]
         return code_block
  

Here is the caller graph for this function:

◆ process_access_statements()

def psyclone.psyir.frontend.fparser2.Fparser2Reader.process_access_statements ( nodes )

static

Search the supplied list of fparser2 nodes (which must represent a
complete Specification Part) for any accessibility
statements (e.g. "PUBLIC :: my_var") to determine the default
visibility of symbols as well as identifying those that are
explicitly declared as public or private.

:param nodes: nodes in the fparser2 parse tree describing a \
              Specification Part that will be searched.
:type nodes: list of :py:class:`fparser.two.utils.Base`

:returns: default visibility of symbols within the current scoping \
    unit and dict of symbol names with explicit visibilities.
:rtype: 2-tuple of (:py:class:`psyclone.symbols.Symbol.Visibility`, \
        dict)

:raises InternalError: if an accessibility attribute which is not \
    'public' or 'private' is encountered.
:raises GenerationError: if the parse tree is found to contain more \
    than one bare accessibility statement (i.e. 'PUBLIC' or 'PRIVATE')
:raises GenerationError: if a symbol is explicitly declared as being \
    both public and private.

Definition at line 1486 of file fparser2.py.

     def process_access_statements(nodes):
         '''
         Search the supplied list of fparser2 nodes (which must represent a
         complete Specification Part) for any accessibility
         statements (e.g. "PUBLIC :: my_var") to determine the default
         visibility of symbols as well as identifying those that are
         explicitly declared as public or private.
  
         :param nodes: nodes in the fparser2 parse tree describing a \
                       Specification Part that will be searched.
         :type nodes: list of :py:class:`fparser.two.utils.Base`
  
         :returns: default visibility of symbols within the current scoping \
             unit and dict of symbol names with explicit visibilities.
         :rtype: 2-tuple of (:py:class:`psyclone.symbols.Symbol.Visibility`, \
                 dict)
  
         :raises InternalError: if an accessibility attribute which is not \
             'public' or 'private' is encountered.
         :raises GenerationError: if the parse tree is found to contain more \
             than one bare accessibility statement (i.e. 'PUBLIC' or 'PRIVATE')
         :raises GenerationError: if a symbol is explicitly declared as being \
             both public and private.
  
         '''
         default_visibility = None
         # Sets holding the names of those symbols whose access is specified
         # explicitly via an access-stmt (e.g. "PUBLIC :: my_var")
         explicit_public = set()
         explicit_private = set()
         # R518 an access-stmt shall appear only in the specification-part
         # of a *module*.
         access_stmts = walk(nodes, Fortran2003.Access_Stmt)
  
         for stmt in access_stmts:
  
             if stmt.children[0].lower() == "public":
                 public_stmt = True
             elif stmt.children[0].lower() == "private":
                 public_stmt = False
             else:
                 raise InternalError(
                     f"Failed to process '{stmt}'. Found an accessibility "
                     f"attribute of '{stmt.children[0]}' but expected either "
                     f"'public' or 'private'.")
             if not stmt.children[1]:
                 if default_visibility:
                     # We've already seen an access statement without an
                     # access-id-list. This is therefore invalid Fortran (which
                     # fparser does not catch).
                     current_node = stmt.parent
                     while current_node:
                         if isinstance(current_node, Fortran2003.Module):
                             mod_name = str(
                                 current_node.children[0].children[1])
                             raise GenerationError(
                                 f"Module '{mod_name}' contains more than one "
                                 f"access statement with an omitted "
                                 f"access-id-list. This is invalid Fortran.")
                         current_node = current_node.parent
                     # Failed to find an enclosing Module. This is also invalid
                     # Fortran since an access statement is only permitted
                     # within a module.
                     raise GenerationError(
                         "Found multiple access statements with omitted access-"
                         "id-lists and no enclosing Module. Both of these "
                         "things are invalid Fortran.")
                 if public_stmt:
                     default_visibility = Symbol.Visibility.PUBLIC
                 else:
                     default_visibility = Symbol.Visibility.PRIVATE
             else:
                 symbol_names = [child.string.lower() for child in
                                 stmt.children[1].children]
                 if public_stmt:
                     explicit_public.update(symbol_names)
                 else:
                     explicit_private.update(symbol_names)
         # Sanity check the lists of symbols (because fparser2 does not
         # currently do much validation)
         invalid_symbols = explicit_public.intersection(explicit_private)
         if invalid_symbols:
             raise GenerationError(
                 f"Symbols {list(invalid_symbols)} appear in access statements "
                 f"with both PUBLIC and PRIVATE access-ids. This is invalid "
                 f"Fortran.")
  
         # Symbols are public by default in Fortran
         if default_visibility is None:
             default_visibility = Symbol.Visibility.PUBLIC
  
         visibility_map = {}
         for name in explicit_public:
             visibility_map[name] = Symbol.Visibility.PUBLIC
         for name in explicit_private:
             visibility_map[name] = Symbol.Visibility.PRIVATE
  
         return (default_visibility, visibility_map)
  

References psyclone.psyir.frontend.fparser2.Fparser2Reader._parse_dimensions(), psyclone.psyir.frontend.fparser2.Fparser2Reader._process_decln(), psyclone.psyir.frontend.fparser2.Fparser2Reader._process_precision(), psyclone.psyir.frontend.fparser2.Fparser2Reader._process_type_spec(), and psyclone.psyir.frontend.fparser2.Fparser2Reader.process_nodes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_declarations()

def psyclone.psyir.frontend.fparser2.Fparser2Reader.process_declarations	(	self,
		parent,
		nodes,
		arg_list,
		visibility_map = `None`
	)

Transform the variable declarations in the fparser2 parse tree into
symbols in the symbol table of the PSyIR parent node. The default
visibility of any new symbol is taken from the symbol table associated
with the `parent` node if necessary. The `visibility_map` provides
information on any explicit symbol visibilities that are specified
for the declarations.

:param parent: PSyIR node in which to insert the symbols found.
:type parent: :py:class:`psyclone.psyir.nodes.KernelSchedule`
:param nodes: fparser2 AST nodes containing declaration statements.
:type nodes: List[:py:class:`fparser.two.utils.Base`]
:param arg_list: fparser2 AST node containing the argument list.
:type arg_list: :py:class:`fparser.Fortran2003.Dummy_Arg_List`
:param visibility_map: mapping of symbol names to explicit
    visibilities.
:type visibility_map: dict[
    str, :py:class:`psyclone.psyir.symbols.Symbol.Visibility`]

:raises GenerationError: if an INCLUDE statement is encountered.
:raises NotImplementedError: the provided declarations contain
    attributes which are not supported yet.
:raises GenerationError: if the parse tree for a USE statement does
    not have the expected structure.
:raises SymbolError: if a declaration is found for a Symbol that is
    already in the symbol table with a defined interface.
:raises InternalError: if the provided declaration is an unexpected
    or invalid fparser or Fortran expression.

Definition at line 2505 of file fparser2.py.

                              visibility_map=None):
         '''
         Transform the variable declarations in the fparser2 parse tree into
         symbols in the symbol table of the PSyIR parent node. The default
         visibility of any new symbol is taken from the symbol table associated
         with the `parent` node if necessary. The `visibility_map` provides
         information on any explicit symbol visibilities that are specified
         for the declarations.
  
         :param parent: PSyIR node in which to insert the symbols found.
         :type parent: :py:class:`psyclone.psyir.nodes.KernelSchedule`
         :param nodes: fparser2 AST nodes containing declaration statements.
         :type nodes: List[:py:class:`fparser.two.utils.Base`]
         :param arg_list: fparser2 AST node containing the argument list.
         :type arg_list: :py:class:`fparser.Fortran2003.Dummy_Arg_List`
         :param visibility_map: mapping of symbol names to explicit
             visibilities.
         :type visibility_map: dict[
             str, :py:class:`psyclone.psyir.symbols.Symbol.Visibility`]
  
         :raises GenerationError: if an INCLUDE statement is encountered.
         :raises NotImplementedError: the provided declarations contain
             attributes which are not supported yet.
         :raises GenerationError: if the parse tree for a USE statement does
             not have the expected structure.
         :raises SymbolError: if a declaration is found for a Symbol that is
             already in the symbol table with a defined interface.
         :raises InternalError: if the provided declaration is an unexpected
             or invalid fparser or Fortran expression.
  
         '''
         if visibility_map is None:
             visibility_map = {}
  
         # Look at any USE statements
         self._process_use_stmts(parent, nodes, visibility_map)
  
         # Look at any SAVE statements to determine any static symbols.
         statics_list = self._process_save_statements(nodes, parent)
  
         # Handle any derived-type declarations/definitions before we look
         # at general variable declarations in case any of the latter use
         # the former.
         for decl in walk(nodes, Fortran2003.Derived_Type_Def):
             self._process_derived_type_decln(parent, decl, visibility_map)
  
         # INCLUDE statements are *not* part of the Fortran language and
         # can appear anywhere. Therefore we have to do a walk to make sure we
         # find them if they are present.
         incl_nodes = walk(nodes, (Fortran2003.Include_Stmt,
                                   C99Preprocessor.Cpp_Include_Stmt))
         if incl_nodes:
             # The include_handler just raises an error so we use that to
             # reduce code duplication.
             self._include_handler(incl_nodes[0], parent)
  
         # Now we've captured any derived-type definitions, proceed to look
         # at the variable declarations.
         for node in nodes:
  
             if isinstance(node, Fortran2003.Interface_Block):
  
                 self._process_interface_block(node, parent.symbol_table,
                                               visibility_map)
  
             elif isinstance(node, Fortran2003.Type_Declaration_Stmt):
                 try:
                     self._process_decln(parent, parent.symbol_table, node,
                                         visibility_map, statics_list)
                 except NotImplementedError:
                     # Found an unsupported variable declaration. Create a
                     # DataSymbol with UnsupportedType for each entity being
                     # declared. Currently this means that any symbols that come
                     # after an unsupported declaration will also have
                     # UnsupportedType. This is the subject of Issue #791.
                     specs = walk(node, Fortran2003.Access_Spec)
                     if specs:
                         decln_vis = _process_access_spec(specs[0])
                     else:
                         decln_vis = parent.symbol_table.default_visibility
  
                     orig_children = list(node.children[2].children[:])
                     for child in orig_children:
                         # Modify the fparser2 parse tree so that it only
                         # declares the current entity. `items` is a tuple and
                         # thus immutable so we create a new one.
                         node.children[2].items = (child,)
                         symbol_name = str(child.children[0]).lower()
                         vis = visibility_map.get(symbol_name, decln_vis)
  
                         # Check whether the symbol we're about to add
                         # corresponds to the routine we're currently inside. If
                         # it does then we remove the RoutineSymbol in order to
                         # free the exact name for the DataSymbol, but we keep
                         # the tag to reintroduce it to the new symbol.
                         tag = None
                         try:
                             routine_sym = parent.symbol_table.lookup_with_tag(
                                 "own_routine_symbol")
                             if routine_sym.name.lower() == symbol_name:
                                 parent.symbol_table.remove(routine_sym)
                                 tag = "own_routine_symbol"  # Keep the tag
                         except KeyError:
                             pass
  
                         # Try to extract partial datatype information.
                         datatype, init = self._get_partial_datatype(
                             node, parent, visibility_map)
  
                         # If a declaration declares multiple entities, it's
                         # possible that some may have already been processed
                         # successfully and thus be in the symbol table.
                         try:
                             parent.symbol_table.add(
                                 DataSymbol(
                                     symbol_name, UnsupportedFortranType(
                                         str(node),
                                         partial_datatype=datatype),
                                     interface=UnknownInterface(),
                                     visibility=vis,
                                     initial_value=init),
                                 tag=tag)
  
                         except KeyError as err:
                             if len(orig_children) == 1:
                                 raise SymbolError(
                                     f"Error while processing unsupported "
                                     f"declaration ('{node}'). An entry for "
                                     f"symbol '{symbol_name}' is already in "
                                     f"the symbol table.") from err
                     # Restore the fparser2 parse tree
                     node.children[2].items = tuple(orig_children)
  
             elif isinstance(node, (Fortran2003.Access_Stmt,
                                    Fortran2003.Save_Stmt,
                                    Fortran2003.Derived_Type_Def,
                                    Fortran2003.Stmt_Function_Stmt,
                                    Fortran2003.Common_Stmt,
                                    Fortran2003.Use_Stmt)):
                 # These node types are handled separately
                 pass
  
             elif isinstance(node, Fortran2003.Implicit_Part):
                 # Anything other than a PARAMETER statement or an
                 # IMPLICIT NONE means we can't handle this code.
                 # Any PARAMETER statements are handled separately by the
                 # call to _process_parameter_stmts below.
                 # Any ENTRY statements are checked for in _subroutine_handler.
                 child_nodes = walk(node, Fortran2003.Format_Stmt)
                 if child_nodes:
                     raise NotImplementedError(
                         f"Error processing implicit-part: Format statements "
                         f"are not supported but found '{child_nodes[0]}'")
                 child_nodes = walk(node, Fortran2003.Implicit_Stmt)
                 if any(imp.children != ('NONE',) for imp in child_nodes):
                     raise NotImplementedError(
                         f"Error processing implicit-part: implicit variable "
                         f"declarations not supported but found '{node}'")
  
             elif isinstance(node, Fortran2003.Namelist_Stmt):
                 # Place the declaration statement into the symbol table using
                 # an internal symbol name. In case that we need more details
                 # (e.g. to update symbol information), the following code
                 # loops over namelist and each symbol:
                 # for namelist_object in node.children:
                 #    for symbol_name in namelist_object[1].items:
                 parent.symbol_table.new_symbol(
                     root_name="_PSYCLONE_INTERNAL_NAMELIST",
                     symbol_type=DataSymbol,
                     datatype=UnsupportedFortranType(str(node)))
             else:
                 raise NotImplementedError(
                     f"Error processing declarations: fparser2 node of type "
                     f"'{type(node).__name__}' not supported")
  
         # Process the nodes again, looking for PARAMETER statements. This is
         # done after the main declarations loop because they modify existing
         # symbols and can appear in any order.
         self._process_parameter_stmts(nodes, parent)
  
         # We process the nodes again looking for common blocks.
         # We do this here, after the main declarations loop, because they
         # modify the interface of existing symbols and can appear in any order.
         self._process_common_blocks(nodes, parent)
  
         if visibility_map is not None:
             # Check for symbols named in an access statement but not explicitly
             # declared. These must then refer to symbols that have been brought
             # into scope by an unqualified use statement.
             for name, vis in visibility_map.items():
                 if name not in parent.symbol_table:
                     # This call creates a Symbol and inserts it in the
                     # appropriate symbol table.
                     _find_or_create_unresolved_symbol(parent, name,
                                                       visibility=vis)
         try:
             arg_symbols = []
             # Ensure each associated symbol has the correct interface info.
             for arg_name in [x.string.lower() for x in arg_list]:
                 symbol = parent.symbol_table.lookup(arg_name)
                 if not symbol.is_argument:
                     # We didn't previously know that this Symbol was an
                     # argument (as it had no 'intent' qualifier). Mark
                     # that it is an argument by specifying its interface.
                     # Although a Fortran argument has intent(inout) by default,
                     # specifying this for an argument that is actually read
                     # only (and is declared as such in the caller) causes
                     # gfortran to complain. We therefore specify that the
                     # access is unknown at this stage.
                     symbol.interface = ArgumentInterface(
                         ArgumentInterface.Access.UNKNOWN)
                 arg_symbols.append(symbol)
             # Now that we've updated the Symbols themselves, set the
             # argument list
             parent.symbol_table.specify_argument_list(arg_symbols)
         except KeyError as info:
             decls_str_list = [str(node) for node in nodes]
             arg_str_list = [arg.string.lower() for arg in arg_list]
             raise InternalError(
                 f"The argument list {arg_str_list} for routine '{parent.name}'"
                 f" does not match the variable declarations:\n"
                 f"{os.linesep.join(decls_str_list)}\n"
                 f"(Note that PSyclone does not support implicit declarations.)"
                 f" Specific PSyIR error is {info}.") from info
  
         # fparser2 does not always handle Statement Functions correctly, this
         # loop checks for Stmt_Functions that should be an array statement
         # and recovers them, otherwise it raises an error as currently
         # Statement Functions are not supported in PSyIR.
         for stmtfn in walk(nodes, Fortran2003.Stmt_Function_Stmt):
             (fn_name, arg_list, scalar_expr) = stmtfn.items
             try:
                 symbol = parent.symbol_table.lookup(fn_name.string.lower())
                 if symbol.is_array:
                     # This is an array assignment wrongly categorized as a
                     # statement_function by fparser2.
                     array_subscript = arg_list.items
  
                     assignment_rhs = scalar_expr
  
                     # Create assignment node
                     assignment = Assignment(parent=parent)
                     parent.addchild(assignment)
  
                     # Build lhs
                     lhs = ArrayReference(symbol, parent=assignment)
                     self.process_nodes(parent=lhs, nodes=array_subscript)
                     assignment.addchild(lhs)
  
                     # Build rhs
                     self.process_nodes(parent=assignment,
                                        nodes=[assignment_rhs])
                 else:
                     raise InternalError(
                         f"Could not process '{stmtfn}'. Symbol "
                         f"'{symbol.name}' is in the SymbolTable but it is not "
                         f"an array as expected, so it can not be recovered as "
                         f"an array assignment.")
             except KeyError as err:
                 raise NotImplementedError(
                     f"Could not process '{stmtfn}'. Statement Function "
                     f"declarations are not supported.") from err
  

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_nodes()

def psyclone.psyir.frontend.fparser2.Fparser2Reader.process_nodes	(	self,
		parent,
		nodes
	)

Create the PSyIR of the supplied list of nodes in the
fparser2 AST.

:param parent: Parent node in the PSyIR we are constructing.
:type parent: :py:class:`psyclone.psyir.nodes.Node`
:param nodes: List of sibling nodes in fparser2 AST.
:type nodes: list[:py:class:`fparser.two.utils.Base`]

Definition at line 2894 of file fparser2.py.

     def process_nodes(self, parent, nodes):
         '''
         Create the PSyIR of the supplied list of nodes in the
         fparser2 AST.
  
         :param parent: Parent node in the PSyIR we are constructing.
         :type parent: :py:class:`psyclone.psyir.nodes.Node`
         :param nodes: List of sibling nodes in fparser2 AST.
         :type nodes: list[:py:class:`fparser.two.utils.Base`]
  
         '''
         code_block_nodes = []
         message = "PSyclone CodeBlock (unsupported code) reason:"
         for child in nodes:
             try:
                 psy_child = self._create_child(child, parent)
             except NotImplementedError as err:
                 # If child type implementation not found, add them on the
                 # ongoing code_block node list.
                 message += "\n - " + str(err)
                 code_block_nodes.append(child)
                 if not isinstance(parent, Schedule):
                     # If we're not processing a statement then we create a
                     # separate CodeBlock for each node in the parse tree.
                     # (Otherwise it is hard to correctly reconstruct e.g.
                     # the arguments to a Call.)
                     self.nodes_to_code_block(parent, code_block_nodes, message)
                     message = "PSyclone CodeBlock (unsupported code) reason:"
             else:
                 if psy_child:
                     self.nodes_to_code_block(parent, code_block_nodes, message)
                     message = "PSyclone CodeBlock (unsupported code) reason:"
                     parent.addchild(psy_child)
                 # If psy_child is not initialised but it didn't produce a
                 # NotImplementedError, it means it is safe to ignore it.
  
         # Complete any unfinished code-block
         self.nodes_to_code_block(parent, code_block_nodes, message)
  

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ binary_operators

psyclone.psyir.frontend.fparser2.Fparser2Reader.binary_operators

static

Initial value:

=  OrderedDict([
        ('+', BinaryOperation.Operator.ADD),
        ('-', BinaryOperation.Operator.SUB),
        ('*', BinaryOperation.Operator.MUL),
        ('/', BinaryOperation.Operator.DIV),
        ('**', BinaryOperation.Operator.POW),
        ('==', BinaryOperation.Operator.EQ),
        ('.eq.', BinaryOperation.Operator.EQ),
        ('.eqv.', BinaryOperation.Operator.EQV),
        ('/=', BinaryOperation.Operator.NE),
        ('.ne.', BinaryOperation.Operator.NE),
        ('.neqv.', BinaryOperation.Operator.NEQV),
        ('<=', BinaryOperation.Operator.LE),
        ('.le.', BinaryOperation.Operator.LE),
        ('<', BinaryOperation.Operator.LT),
        ('.lt.', BinaryOperation.Operator.LT),
        ('>=', BinaryOperation.Operator.GE),
        ('.ge.', BinaryOperation.Operator.GE),
        ('>', BinaryOperation.Operator.GT),
        ('.gt.', BinaryOperation.Operator.GT),
        ('.and.', BinaryOperation.Operator.AND),
        ('.or.', BinaryOperation.Operator.OR)])

Definition at line 1036 of file fparser2.py.

◆ unary_operators

psyclone.psyir.frontend.fparser2.Fparser2Reader.unary_operators

static

Initial value:

=  OrderedDict([
        ('+', UnaryOperation.Operator.PLUS),
        ('-', UnaryOperation.Operator.MINUS),
        ('.not.', UnaryOperation.Operator.NOT)])

Definition at line 1031 of file fparser2.py.

The documentation for this class was generated from the following file:

/home/docs/checkouts/readthedocs.org/user_builds/psyclone-ref/checkouts/latest/src/psyclone/psyir/frontend/fparser2.py

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Member Function Documentation

◆ generate_container()

◆ generate_psyir()

◆ get_routine_schedules()

◆ nodes_to_code_block()

◆ process_access_statements()

◆ process_declarations()

◆ process_nodes()

Member Data Documentation

◆ binary_operators

◆ unary_operators