Analysis.Syntax

This module provides a number of helper functions for working with Fortran syntax that are useful between different analyses and transformations.

Comparison and ordering

data AnnotationFree t

AnnotationFree is a data type that wraps other types and denotes terms which should be compared for equality modulo their annotations and source location information

Constructors

AnnotationFree

Fields

annotationBound :: t

Instances

Eq (AnnotationFree Char)

Eq (AnnotationFree Int)

Eq (AnnotationFree a) => Eq (AnnotationFree [a])

(Eq (AnnotationFree a), Eq (AnnotationFree b)) => Eq (AnnotationFree (a, b))

Eq (AnnotationFree (SubName p))

Eq (AnnotationFree (Type a))

Eq (AnnotationFree (BaseType p))

Eq (AnnotationFree (Attr p))

Eq (AnnotationFree (MeasureUnitSpec p))

Eq (AnnotationFree (Fraction p))

Eq (AnnotationFree (IntentAttr p))

Eq (AnnotationFree (Expr a))

Eq (AnnotationFree (AccessP ()))

Show t => Show (AnnotationFree t)

af :: t -> AnnotationFree t

short-hand constructor for AnnotationFree

unaf :: AnnotationFree t -> t

short-hand deconstructor for AnnotationFree

eraseSrcLocs :: (Typeable (t a), Data (t a)) => t a -> t a

A helpful function, used by the 'Eq AnnotationFree' instance that resets and source location information

setCompactSrcLocs :: (Typeable (t a), Data (t a)) => t a -> t a

Sets the SrcLoc information to have the filename "compact" which triggers a special compact form of pretty printing in the Show SrcLoc instances

lower :: [Char] -> [Char]

Accessor functions for extracting various pieces of information out of syntax trees

getSubName :: ProgUnit p -> Maybe String

Extracts the subprocedure name from a program unit

accesses :: Data from => from -> [AccessP ()]

Extracts all accessors (variables and array indexing) from a piece of syntax

varExprToVariable :: Expr a -> Maybe Variable

Extracts a string of the (root) variable name from a variable expression (if it is indeed a variable expression

varExprToAccess :: Expr a -> Maybe Access

Extracts an accessor form a variable from a variable expression

varExprToAccesses :: Expr a -> [Access]

Extracts all accessors from a variable expression e.g., varExprToAccess on the syntax tree coming from a(i, j) returns a list of [VarA "a", VarA "i", VarA "j"]

class Successors t where

Methods

successorsRoot :: t a -> [t a]

Computes the root successor from the current

successors :: (Eq a, Typeable a) => Zipper (ProgUnit a) -> [t a]

Computes the successors nodes of a CFG (described by a zipper) for certain node types

Instances

Successors Fortran

rhsExpr :: Fortran Annotation -> [Expr Annotation]

extract all 'right-hand side' expressions e.g. rhsExpr (parse "x = e") = parse "e"

lhsExpr :: Fortran Annotation -> [Expr Annotation]

extract all 'left-hand side' expressions e.g. rhsExpr (parse "x = e") = parse "x"

Various simple analyses

countVariableDeclarations :: Program Annotation -> Int

Counts the number of declarations (of variables) in a whole program

numberStmts :: ProgUnit Annotation -> ProgUnit Annotation

Numbers all the statements in a program unit (successively) which is useful for analysis output

variables :: Data from => from -> [[Char]]

All variables from a Fortran syntax tree

isConstant :: Expr p -> Bool

A predicate on whether an expression is actually a constant constructor

freeVariables :: (Data (t a), Data a) => t a -> [String]

Free-variables in a piece of Fortran syntax

binders :: forall a t. (Data (t a), Typeable (t a), Data a, Typeable a) => t a -> [String]

All variables from binders

affineMatch :: (Num t1, Read t1) => Expr t -> Maybe (Variable, t1)

Tests whether an expression is an affine transformation (without scaling) on some variable, if so returns the variable and the translation factor

An embedded domain-specific language for describing syntax tree queries

data QueryCmd t where

QueryCmd provides commands of which pieces of syntax to find

Constructors

Exprs :: QueryCmd (Expr Annotation)

Blocks :: QueryCmd (Block Annotation)

Decls :: QueryCmd (Decl Annotation)

Locs :: QueryCmd Access

Vars :: QueryCmd (Expr Annotation)

from :: forall t synTyp. (Data t, Data synTyp) => QueryCmd synTyp -> t -> [synTyp]

from takes a command as its first parameter, a piece of syntax as its second, and returns all pieces of syntax matching the query request.

For example: from Decls x returns a list of all declarations in x, of type [Decl Annotation] If x is itself a declaration then this is returned as well (so be careful with recursive functions over things defined in turns of from. See topFrom for a solution to this.

topFrom :: forall t synTyp. (Data t, Data synTyp) => QueryCmd synTyp -> t -> [synTyp]

topFrom takes a command as first parameter, a piece of syntax as its second, and returns all pieces of syntax matching the query request that are *children* of the current piece of syntax. This means that it will not return itself.