h&W      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     !!!!!!!""""""""################### Safe-Inferred 6J fortran-src;Represents map of files and replacements that will be done. fortran-srcAs we advance through the [] list, we consider "chunks" as the unit of text written out. A chunk is either: original source text up to a newline character, end of file or  described in 2. a single = that has non-empty replacement string or is deleted. fortran-srcException raised when two  objects overlap () or  points at invalid locations (). fortran-src5Represents the intent to replace content in the file.The content in  will be used in place of what is in the range described. Note that the replacement text can be shorter or larger than the original span, and it can also be multi-line. fortran-srcRepresents a character in the original source text along with any replacement operations applied to the character in place.It expects a character (in case it's empty, Nothing should be used), whether it should be removed, its  1 and a string that should be put in place of it.  fortran-src Represents range in source code.  fortran-src#Represents location in source code. Note that,   indicates space between characters, i.e the following example:  SourceLocation 0 1indicates position between first and second characters in a file.  fortran-src8Parses input string into a list of annotated characters. fortran-srcMarks RChars& in a given range to be removed later. fortran-src>Sets replacement string to be prepended to the given location. fortran-srcSets replacement string to be prepended to the begining of the given range. fortran-src3Applies all deletions and additions and transforms RChars back to a string. fortran-srcIf  is marked as deleted, it'll be evaluated to its replacement string, otherwise original character will be returned. fortran-srcFrom [ ], obtain a (, [RChars ]) where the  is the next  and the [] are the remaining s. fortran-srcSplits [] into s. fortran-srcTransform a list of s into a single string, applying continuation lines when neccessary. fortran-srcReturn TRUE iff the $ constitutes a character insertion. fortran-srcSets a single  given a list of s. fortran-srcSets a list of s given a list of s. fortran-srcheuristic to wrap line after comma or right parenthesis if applicable fortran-srcMark removal for the input   fortran-src4Append the input character to the replacement string! fortran-srcChecks whether two s are not overlapping." fortran-srcChecks whether: ,the start is before the end of the range and1both start and end locations are within the code.& fortran-srcApplies s to a string and return it.1Firstly, it transforms the string into a list of s.After that, it validates the   of each .In the end, it splits up s in  s, set the s and evaluates the s.(  !"#$%&'(   !"#$%&' Safe-Inferred75 fortran-srcObtain a UTF-8 safe % representation of a file's contents.3Invalid UTF-8 is replaced with the space character.6 fortran-srcList files in directory, with the directory prepended to each entry.7 fortran-src$List files in directory recursively.567567 Safe-Inferred 9>?889:;<=;<=89: Safe-Inferred 9>?8SDEFDEF Safe-Inferred389>?9p^ fortran-src.line-offset and filename as given by a pragma.c fortran-src(line, column) number taking into account any specified line pragmas.d fortran-srcBL fortran-srcA location-tagged list of t as (t decorated with an a annotation).$The AST is polymorphic on some type a, which is used for arbitrary annotations. Since many AST nodes use lists (e.g. executable statements, declarations), we define a dedicated annotated list type to reuse.(Note that the list itself also holds an a annotation. fortran-srcConvert a non-empty list to an . fortran-srcConvert a list to an *, returning Nothing iff the list is empty.  5 Safe-Inferred38DU fortran-srcThe Fortran specification version used (or relevant to its context).The constructor ordering is important, since it's used for the Ord instance (which is used extensively for pretty printing). fortran-src Deduce the  from a  using extension.1Defaults to Fortran 90 if suffix is unrecognized. fortran-src=Alias for previous function name. TODO: deprecate eventually.    Safe-Inferred 38?D=  Safe-Inferred38FR fortran-srcObtain set of intrinsics that are most closely aligned with given version. None 3589>?]5 fortran-srcDimension declarator stored in  dimension attributes and s. fortran-src Declarators.Declaration statements can have multiple variables on the right of the double colon, separated by commas. A " identifies a single one of these.Each declared variable can have an initializing expression. These expressions are defined in HP's F90 spec to be initialization expressions., which are specialized constant expressions.The length expressions here are defined in HP's F90 spec to be specifications expressions, which are scalar integer expressions with a bunch of restrictions similar to initialization expressions.s are also used for some less-used syntax that let you set variable attributes using statements, like:"integer arr dimension arr(10)#Some of these only set part of the  (e.g.  parameter only sets the initial value). Syntax note: length is set like character :: str*10, dimensions are set like integer :: arr(10). Careful to not get confused.Note that according to HP's F90 spec, lengths may only be specified for CHARACTER types. So for any declarations that aren't  in the outer , the length expression should be Nothing. However, this is not enforced by the AST or parser, so be warned. fortran-src/The string representation of an integer literal fortran-src+The string representation of a real literal fortran-src/The real and imaginary parts of a complex value fortran-srcA string literal fortran-srcA Hollerith literal fortran-srcThe name of a variable fortran-srcThe name of a built-in function fortran-srcA boolean value fortran-src$User-defined operators in interfaces fortran-src#Overloaded assignment in interfaces fortran-srcUse a value as an expression. fortran-src-A binary operator applied to two expressions. fortran-src+A unary operator applied to one expression. fortran-srcArray indexing fortran-src%) notation for variables inside data types fortran-src5A function expression applied to a list of arguments. fortran-src$Implied do (i.e. one-liner do loops) fortran-srcArray initialisation fortran-src#Function return value specification fortran-srcNote that the s in common group definitions do not contain initializing expressions. fortran-src5A COMMON statement, defining a list of common blocks. fortran-srcNothing indicates an yet-to-be processed include. (The F77 parser parses Nothing, then fills out each include statement in a post-parse step.) fortran-src The first + in the abbreviation tuple is always an ExpValue _ _ (ValVariable id). Also guaranteed nonempty. fortran-src/The "kind selector" of a declaration statement.HP's F90 spec (pg.24) actually differentiates between "kind selectors" and "char selectors", where char selectors can specify a length (alongside kind), and the default meaning of an unlabelled kind parameter (the 8 in INTEGER(8)) is length instead of kind. We handle this correctly in the parsers, but place both into this  type.The upshot is, length is invalid for non-CHARACTER types, and the parser guarantees that it will be Nothing. For CHARACTER types, both maybe or may not be present. fortran-srcThe type specification of a declaration statement, containing the syntactic type name and kind selector.See HP's F90 spec pg.24. fortran-srcType name referenced in syntax.In many Fortran specs and compilers, certain types are actually "synonyms" for other types with specified kinds. The primary example is DOUBLE PRECISION being equivalent to REAL(8). Type kinds were introduced in Fortran 90, and it should be safe to replace all instances of DOUBLE PRECISION with REAL(8) in Fortran 90 code. However, type kinds weren't present in (standard) Fortran 77, so this equivalence was detached from the user.In any case, it's unclear how strong the equivalence is and whether it can be retroactively applied to previous standards. We choose to parse types directly, and handle those transformations during type analysis, where we assign most scalars a kind (see $%). fortran-srcThe empty annotation.  fortran-srcVariable fortran-srcLength (character) fortran-src Initial value fortran-srcArray fortran-src Dimensions fortran-srcLength (character) fortran-src Initial value fortran-src Lower index fortran-src Upper index fortran-srcStride fortran-srcLabel fortran-src Statement fortran-srcLabel fortran-srcConstruct name fortran-srcHeader information fortran-srcBody fortran-srcLabel to END DO fortran-srcLabel fortran-srcConstruct name fortran-src Conditions fortran-srcBodies fortran-srcLabel to END IF fortran-srcLabel fortran-srcConstruct name fortran-src Scrutinee fortran-src Case ranges fortran-srcBodies fortran-srcLabel to END SELECT fortran-srcLabel fortran-srcConstruct name fortran-src Target label fortran-srcDo Specification fortran-srcBody fortran-srcLabel to END DO fortran-srcLabel fortran-srcConstruct name fortran-src Target label fortran-src Condition fortran-srcBody fortran-srcLabel to END DO fortran-srclabel fortran-src abstract? fortran-srcRoutine decls. in the interface fortran-srcModule procedures fortran-srclength (if present) fortran-srckind (if present) None >f fortran-src?i2 fortran-srcTRealLiteral SrcSpan String (Maybe RealExponent) (Maybe KindParam)                     None 38>?qX None358>t5  fortran-src A subset of 8 which can only contain values that can be assigned to.  fortran-src=If the expression can be seen as an lvalue, convert it to an  .  None 38{  fortran-srcspecified with a *  fortran-srcspecified with a : (Fortran2003) FIXME, possibly, with a more robust const-exp:  fortran-src'specified with a non-trivial expression  fortran-src!specified with a constant integer  fortran-srcThe declared dimensions of a staticically typed array variable type is of the form [(dim1_lower, dim1_upper), (dim2_lower, dim2_upper)]  fortran-src$Semantic type assigned to variables.( stores the "type tag" given in syntax.  s add metadata (kind and length), and resolve some "simple" types to a core type with a preset kind (e.g. `DOUBLE PRECISION` -> `REAL(8)`).;Fortran 90 (and beyond) features may not be well supported.  fortran-src"Nothing denotes dynamic dimensions  fortran-srcAttempt to recover the  that generated the given  .  fortran-srcRecover the most appropriate  for the given  , depending on the given .Kinds weren't formalized as a syntactic feature until Fortran 90, so we ask for a context. If possible (>=F90), we prefer the more explicit representation e.g. REAL(8)<. For older versions, for specific type-kind combinations, DOUBLE PRECISION and DOUBLE COMPLEX are used instead. However, we otherwise don't shy away from adding kind info regardless of theoretical version support.Array types don't work properly, due to array type info being in a parent node that holds individual elements.  fortran-srcGiven a ? infer the "default" kind (or size of the variable in memory).Useful when you need a default kind, but gives you an unwrapped type. Consider using Analysis.deriveSemTypeFromBaseType also.Further documentation: https://docs.oracle.com/cd/E19957-01/805-4939/c400041360f5/index.html  None238.( fortran-srcoriginal annotation fortran-srcunique name for function/variable, after variable renaming phase fortran-src8original name for function/variable found in source text fortran-srcbasic block graph fortran-src5unique number for each block during dataflow analysis fortran-src:Information about potential / actual constant expressions. fortran-srcinterpreted integer fortran-srcuninterpreted integer fortran-srcuninterpreted real fortran-src'binary operation on potential constants fortran-src&unary operation on potential constants fortran-src+The type of "transformBiM"-family functions fortran-src*The type of "transformBi"-family functions fortran-srcBasic block graph. fortran-srcthe underlying graph fortran-srcthe entry node(s) fortran-srcthe exit node(s) fortran-src Basic block fortran-srcEmpty basic block graph fortran-src%Call function on the underlying graph fortran-src1Monadically call function on the underlying graph fortran-src;True iff the expression can be used with varName or srcName fortran-srcObtain either uniqueName or source name from an ExpValue variable. fortran-src1Obtain the source name from an ExpValue variable. fortran-srcObtain either uniqueName or source name from an LvSimpleVar variable. fortran-src4Obtain the source name from an LvSimpleVar variable. fortran-srcGenerate an ExpValue variable with its source name == to its uniqueName. fortran-src?Obtain either ProgramUnit uniqueName or whatever is in the AST. fortran-src?Obtain either ProgramUnit sourceName or whatever is in the AST. fortran-srcCreate analysis annotations for the program, saving the original annotations. fortran-srcRemove analysis annotations from the program, restoring the original annotations. fortran-srcReturn list of expressions used as the left-hand-side of assignment statements (including for-loops and function-calls by reference). fortran-srcReturn list of expressions that are not "left-hand-side" of assignment statements. fortran-src,Is this an expression capable of assignment? fortran-src"Set of names found in an AST node. fortran-srcInitiate (lazy) computation of all LHS variables for each node of the AST so that it may be accessed later. fortran-srcSet of names found in the parts of an AST that are the target of an assignment statement. allLhsVars :: (Annotated b, Data a, Data (b (Analysis a))) => b (Analysis a) -> [Name] fortran-src:Set of expressions used -- not defined -- by an AST-block. fortran-src4Set of names used -- not defined -- by an AST-block. fortran-src%Set of names defined by an AST-block.Nonec fortran-src(Information about a detected type error. fortran-src%Mapping of names to type information. fortran-srcAnnotate AST nodes with type information and also return a type environment mapping names to type information. fortran-srcAnnotate AST nodes with type information and also return a type environment mapping names to type information; provided with a starting type environment. fortran-srcAnnotate AST nodes with type information, return a type environment mapping names to type information and return any type errors found; provided with a starting type environment. fortran-srcAttempt to derive the  = of a variable from the relevant parts of its surrounding .+This is an example of a simple declaration:INTEGER(8) :: var_nameA declaration holds a 0 (left of the double colon; LHS) and a list of s (right of the double colon; RHS). However, CHARACTER variable are allowed to specify their length via special syntax on the RHS:CHARACTER :: string*10so to handle that, this function takes that length as a Maybe Expression (as provided in ).If a length was defined on both sides, the declaration length (RHS) is used. This matches gfortran's behaviour, though even with -Wall they don't warn on this rather confusing syntax usage. We report a (soft) type error. fortran-srcAttempt to derive a   from a . fortran-srcDerive   directly from , using relevant default kinds.  None fortran-srcAnnotate unique names for variable and function declarations and uses. fortran-srcAnnotate unique names for variable and function declarations and uses. With external module map. fortran-srcTake the unique name annotations and substitute them into the actual AST. fortran-src,Take a renamed program and undo the renames.NoneLNone}NoneNoneNone?  fortran-src1A mapping of program unit names to bblock graphs. fortran-src;Insert basic block graphs into each program unit's analysis fortran-srcCreate a mapping of (non-module) program unit names to their associated bblock graph. fortran-src2Show a basic block graph in a somewhat decent way. fortran-src,Show a basic block graph without the clutter fortran-srcShow a basic block supergraph fortran-srcPick out and show the basic block graphs in the program file analysis. fortran-src)Output a graph in the GraphViz DOT format fortran-src.Output a supergraph in the GraphViz DOT format fortran-srcSome helper functions to output some pseudo-code for readability.None38?1 fortran-srcCallMap : program unit name -> { name of function or subroutine } fortran-src7InductionVarMapByASTBlock : AST-block label -> { name } fortran-srcMap of loop header nodes to the induction variables within that loop. fortran-src,LoopNodeMap : bblock node -> { bblock node } fortran-src(BackEdgeMap : bblock node -> bblock node fortran-srcThe map of all expressions and whether they are undecided (not present in map), a constant value (Just Constant), or probably not constant (Nothing). fortran-srcThe map of all parameter variables and their corresponding values fortran-src#Represent "flows" between variables fortran-srcFlowsGraph : nodes as AST-block (numbered by label), edges showing which definitions contribute to which uses. fortran-srcUDMap : use -> { definition } fortran-srcDUMap : definition -> { use } fortran-src-DefMap : variable name -> { AST-block label } fortran-srcBlockMap : AST-block label -> AST-block Each AST-block has been given a unique number label during analysis of basic blocks. The purpose of this map is to provide the ability to lookup AST-blocks by label. fortran-src?OutF, a function that returns the out-dataflow for a given node fortran-src=InF, a function that returns the in-dataflow for a given node fortran-src=InOutMap : node -> (dataflow into node, dataflow out of node) fortran-src>InOut : (dataflow into the bblock, dataflow out of the bblock) fortran-srcAn OrderF is a function from graph to a specific ordering of nodes. fortran-src-IDomMap : node -> immediate dominator of node fortran-src#DomMap : node -> dominators of node fortran-srcCompute dominators of each bblock in the graph. Node A dominates node B when all paths from the start node of that program unit must pass through node A in order to reach node B. That will be represented as the relation (B, [A, ...]) in the DomMap. fortran-srcCompute the immediate dominator of each bblock in the graph. The immediate dominator is, in a sense, the closest dominator of a node. Given nodes A and B, you can say that node A is immediately dominated by node B if there does not exist any node C such that: node A dominates node C and node C dominates node B. fortran-srcThe postordering of a graph outputs the label after traversal of children. fortran-srcReversed postordering. fortran-srcThe preordering of a graph outputs the label before traversal of children. fortran-srcReversed preordering. fortran-srcApply the iterative dataflow analysis method. Forces evaluation of intermediate data structures at each step. fortran-srcBuild a BlockMap from the AST. This can only be performed after analyseBasicBlocks has operated, created basic blocks, and labeled all of the AST-blocks with unique numbers. fortran-srcBuild a DefMap from the BlockMap. This allows us to quickly look up the AST-block labels that wrote into the given variable. fortran-srcDataflow analysis for live variables given basic block graph. Muchnick, p. 445: A variable is "live" at a particular program point if there is a path to the exit along which its value may be used before it is redefined. It is "dead" if there is no such path. fortran-srcReaching definitions dataflow analysis. Reaching definitions are the set of variable-defining AST-block labels that may reach a program point. Suppose AST-block with label A defines a variable named v. Label A may reach another program point labeled P if there is at least one program path from label A to label P that does not redefine variable v. fortran-srcdef-use map: map AST-block labels of defining AST-blocks to the AST-blocks that may use the definition. fortran-srcInvert the DUMap into a UDMap fortran-srcuse-def map: map AST-block labels of variable-using AST-blocks to the AST-blocks that define those variables. fortran-src6"Flows-To" analysis. Represent def-use map as a graph. fortran-srcCreate a map (A -> Bs) where A "flows" or contributes towards the variables Bs. fortran-srcGenerate a constant-expression map with information about the expressions (identified by insLabel numbering) in the ProgramFile pf (must have analysis initiated & basic blocks generated) . fortran-srcGet constant-expression information and put it into the AST analysis annotation. Must occur after analyseBBlocks. fortran-srcAnnotate AST with constant-expression information based on given ParameterVarMap. fortran-srcFind the edges that 'loop back' in the graph; ones where the target node dominates the source node. If the backedges are viewed as (m -> n) then n is considered the 'loop-header' fortran-srcFor each loop in the program, find out which bblock nodes are part of the loop by looking through the backedges (m, n) where n is considered the 'loop-header', delete n from the map, and then do a reverse-depth-first traversal starting from m to find all the nodes of interest. Intersect this with the strongly-connected component containing m, in case of improper& graphs with weird control transfers. fortran-srcSimilar to loopNodes except it creates a map from loop-header to the set of loop nodes, for each loop-header. fortran-src9The strongly connected component containing a given node. fortran-srcFor each loop in the program, figure out the names of the induction variables: the variables that are used to represent the current iteration of the loop. fortran-srcGenerate an induction variable map that is indexed by the labels on AST-blocks within those loops. fortran-srcFor every expression in a loop, try to derive its relationship to a basic induction variable. fortran-src.Show some information about dataflow analyses. fortran-srcOutputs a DOT-formatted graph showing flow-to data starting at the given AST-Block node in the given Basic Block graph. fortran-src7Create a call map showing the structure of the program. fortran-srcbasic block graph fortran-src'initialisation for in and out dataflows fortran-srcordering function fortran-src.compute the in-flow given an out-flow function fortran-src.compute the out-flow given an in-flow function fortran-srcfinal dataflow for each node fortran-srcresult of reaching definitionsNone38 fortran-src,Status of mod-file compared to Fortran file. fortran-srcA set of decoded mod files. fortran-src"The data stored in the "mod files" fortran-src8A map of variables => their constant expression if known fortran-srcA map of aliases => strings, in order to save space and share structure for repeated strings. fortran-srcMap of unique variable name to the unique name of the program unit where it was defined, and the corresponding SrcSpan. fortran-srcContext of a declaration: the ProgramUnit where it was declared. fortran-src(uniqName, srcName) fortran-src(uniqName, srcName) fortran-src1Standard ending of fortran-src-format "mod files" fortran-srcEmpty set of mod files. (future proof: may not always be a list) fortran-srcStarting point. fortran-srcExtracts the module map, declaration map and type analysis from an analysed and renamed ProgramFile, then inserts it into the ModFile. fortran-srcGenerate a fresh ModFile from the module map, declaration map and type analysis of a given analysed and renamed ProgramFile. fortran-srcLooks up the raw "other data" that may be stored in a ModFile by applications that make use of fortran-src. fortran-srcGet a list of the labels present in the "other data" of a ModFile. More of a meta-programming / debugging feature. fortran-srcAllows modification insertiondeletion of "other data" that may be stored in a ModFile by applications that make use of fortran-src. See &'< for more information about the interface of this function. fortran-src environment) by collecting all of the stored module maps within the PUModule annotation. fortran-srcExtract map of declared variables with their associated program unit and source span. fortran-srcCompare the source file timestamp to the fsmod file timestamp, if it exists.##None fortran-srcThe default post-parse AST transformations for each Fortran version.Note that some of these may not be commutative with each other. Specifically, the DO groupings are written so labeled (nonblock) DO grouping must occur first, followed by block DO grouping.  None>9 9 None>,9 9 None>~9 9  None>9 9 !None>F9 9 "None? fortran-srcDeduce the type of parser from the filename and parse the contents of the file. fortran-srcDeduce the type of parser from the filename and parse the contents of the file, within the context of given "mod files". fortran-src7Given a FortranVersion, parse the contents of the file. fortran-srcGiven a FortranVersion, parse the contents of the file, within the context of given "mod files".#None3  ()*+,--..//00123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzz{{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    %                                  $$                                                                                                         !!!!!!!""""""""##################  !!fortran-src-0.6.0-inplace"Language.Fortran.Rewriter.InternalLanguage.Fortran.Util.Files$Language.Fortran.Util.FirstParameter%Language.Fortran.Util.SecondParameterLanguage.Fortran.Util.PositionLanguage.Fortran.RewriterLanguage.Fortran.AST.AListLanguage.Fortran.VersionLanguage.Fortran.ParserMonadLanguage.Fortran.IntrinsicsLanguage.Fortran.ASTLanguage.Fortran.PrettyPrintLanguage.Fortran.Parser.UtilsLanguage.Fortran.Lexer.FreeForm Language.Fortran.Lexer.FixedFormLanguage.Fortran.LValue'Language.Fortran.Analysis.SemanticTypesLanguage.Fortran.AnalysisLanguage.Fortran.Analysis.Types"Language.Fortran.Analysis.Renaming.Language.Fortran.Transformation.TransformMonad(Language.Fortran.Transformation.Grouping8Language.Fortran.Transformation.Disambiguation.Intrinsic7Language.Fortran.Transformation.Disambiguation.Function!Language.Fortran.Analysis.BBlocks"Language.Fortran.Analysis.DataFlowLanguage.Fortran.Util.ModFileLanguage.Fortran.Transformer!Language.Fortran.Parser.Fortran95!Language.Fortran.Parser.Fortran90!Language.Fortran.Parser.Fortran77!Language.Fortran.Parser.Fortran66#Language.Fortran.Parser.Fortran2003Language.Fortran.Parser.Any"Language.Fortran.Analysis.ModGraphAnalysisSemTypeData.Map.StrictalterReplacementMapChunkReplacementErrorOverlappingErrorInvalidRangeError ReplacementRChar SourceRangeSourceLocation toRCharList markRChars markRChars_setReplacementStringSLsetReplacementStringSRevaluateRChars evaluateRChar nextChunk nextChunk_ allChunksevaluateChunksevaluateChunks_ isInsertion insertionSRsetReplacementsetReplacementsadjustLineWrapadjustLineWrapAuxdeleteRCappendRC areDisjoint isValidRangeisValidLocation checkRangescheckOverlappingapplyReplacementsapplyReplacements_$fOrdSourceLocation$fShowSourceRange$fOrdReplacement$fExceptionReplacementError$fShowReplacementError$fEqReplacementError$fShowReplacement$fEqReplacement $fShowRChar $fEqRChar$fEqSourceRange$fShowSourceLocation$fEqSourceLocation flexReadFilegetDirContentsrGetDirContentsGFirstParametergetFirstParameter'setFirstParameter'FirstParametergetFirstParametersetFirstParameter$fGFirstParameterU1[]$fGFirstParameter:*:e$fGFirstParameter:+:e$fGFirstParameterM1e$fGFirstParameterK1e$fGFirstParameterK1e0SecondParametergetSecondParametersetSecondParameter$fGSecondParameter:+:e$fGSecondParameterM1e$fGSecondParameterK1e$fGSecondParameter'K1e$fGSecondParameter'K1e0$fGSecondParameter':*:e$fGSecondParameter'M1e$fParameterLeaf:*:$fParameterLeafM1$fGSecondParameter:*:e SpannedPair getTransSpanSpannedgetSpansetSpanSrcSpanPositionposAbsoluteOffset posColumnposLinefilePathposPragmaOffsetLocgetPos initPositionlineColapparentLineColapparentFilePathcolumnDistance lineDistance spannedLines initSrcSpan$fShowPosition$fNFDataPosition$fBinaryPosition $fOutSrcSpan $fShowSrcSpan$fNFDataSrcSpan$fBinarySrcSpan$fSpannedEither$fSpannedSrcSpan$fSpannedPaira[]$fSpannedPaira[]0$fSpannedPairab $fSpanned(,,)$fSpanned(,,)0$fSpanned(,,)1$fSpanned(,,)2 $fSpanned(,) $fSpanned(,)0 $fSpanned(,)1 $fSpanned[] $fEqSrcSpan $fOrdSrcSpan $fDataSrcSpan$fGenericSrcSpan $fEqPosition $fOrdPosition$fDataPosition$fGenericPositionpartitionOverlappingprocessReplacementsspanToSourceRangespanToSourceRange2sourceRangeBetweenTwoSpansATupleAListfromList fromList'fromReverseListfromReverseList'aConsaReverseaStripaStrip'aMap $fNFDataAList $fOutAList$fSpannedAList$fSecondParameterAListSrcSpan$fFirstParameterALista$fFunctorAList$fNFDataATuple $fOutATuple$fSpannedATuple$fSecondParameterATupleSrcSpan$fFirstParameterATuplea $fEqATuple $fShowATuple $fDataATuple$fGenericATuple$fFunctorATuple $fEqAList $fShowAList $fDataAList$fGenericAListFortranVersion Fortran66 Fortran77Fortran77ExtendedFortran77Legacy Fortran90 Fortran95 Fortran2003 Fortran2008fortranVersionAliasesselectFortranVersiondeduceFortranVersion deduceVersion$fNFDataFortranVersion$fOutFortranVersion$fShowFortranVersion$fOrdFortranVersion$fEqFortranVersion$fDataFortranVersion$fGenericFortranVersionTokeofTokenParseunParse LastToken getLastTokenParseErrorSimpleerrorPos errorFilenameerrorMsg ParseResultParseOk ParseFailed ParseErrorerrPos errLastToken errFilenameerrMsg ParseState psAlexInputpsParanthesesCount psVersion psFilename psContextContextConStartConData ConImplicit ConNamelist ConCommonParanthesesCountpcActual pcHasReached0tokenMsgfromParseResultUnsafe fromRightfromParseResult getVersionputAlexgetAlex topContext popContext pushContext getPosition getSrcSpangetParanthesesCountresetParincPardecPar throwIOerrorrunParserunParseUnsafe evalParse execParse collectTokenscollectTokensSafe$fExceptionParseError$fShowParseError$fFunctorParseResult$fShowParseErrorSimple$fMonadErrorParseErrorParse$fMonadStateParseStateParse$fApplicativeParse$fFunctorParse$fMonadFailParse $fMonadParse$fShowParseState $fShowContext $fEqContext$fShowParanthesesCount$fEqParanthesesCountIntrinsicsTable IntrinsicTypeITReal ITInteger ITComplexITDouble ITLogical ITCharacterITParamgetVersionIntrinsicsgetIntrinsicReturnTypegetIntrinsicDefsUsesgetIntrinsicNames isIntrinsic allIntrinsics$fShowIntrinsicsEntry$fEqIntrinsicsEntry$fOrdIntrinsicsEntry$fGenericIntrinsicsEntry$fShowIntrinsicType$fEqIntrinsicType$fOrdIntrinsicType$fGenericIntrinsicTypeNamedgetNamesetNameProgramUnitNameNamelessBlockDataNamelessComment NamelessMainLabeledgetLabel getLastLabelsetLabel Annotated getAnnotation setAnnotationmodifyAnnotationBinaryOpAddition SubtractionMultiplicationDivisionExponentiation ConcatenationGTGTELTLTEEQNEOrXOrAnd Equivalent NotEquivalent BinCustomUnaryOpPlusMinusNotUnCustomDimensionDeclarator Declarator DeclVariable DeclArrayValue ValIntegerValReal ValComplex ValString ValHollerith ValVariable ValIntrinsic ValLogical ValOperator ValAssignmentValTypeValStarValColonIndexIxSingleIxRange ExpressionExpValue ExpBinaryExpUnary ExpSubscript ExpDataRefExpFunctionCall ExpImpliedDoExpInitialisation ExpReturnSpecDoSpecification FlushSpecFSUnitFSIOStatFSIOMsgFSErr FormatItem FIFormatList FIHollerith FIDelimiterFIFieldDescriptorDEFGFIFieldDescriptorAILFIBlankDescriptor FIScaleFactorUnionMap StructureItem StructFields StructUnionStructStructure DataGroupNamelist CommonGroup ImpElement ImpCharacterImpRangeImpListAllocOptAOStatAOErrMsgAOSource ControlPairIntentInOutInOut AttributeAttrAllocatableAttrAsynchronous AttrDimension AttrExternal AttrIntent AttrIntrinsic AttrOptional AttrParameter AttrPointer AttrPrivate AttrProtected AttrPublicAttrSave AttrSuffix AttrTarget AttrValue AttrVolatileArgumentUse UseRenameUseID ModuleNature ModIntrinsicModNonIntrinsicOnly Exclusive Permissive ForallHeader ProcInterfaceProcInterfaceNameProcInterfaceTypeProcDecl Statement StDeclaration StStructureStIntent StOptionalStPublic StPrivate StProtectedStSave StDimension StAllocatableStAsynchronous StPointerStTargetStValue StVolatileStData StAutomaticStStatic StNamelist StParameter StExternal StIntrinsicStCommon StEquivalenceStFormat StImplicitStEntry StIncludeStDo StDoWhileStEnddoStCycleStExit StIfLogicalStIfArithmetic StSelectCaseStCase StEndcase StFunctionStExpressionAssignStPointerAssign StLabelAssignStGotoUnconditionalStGotoAssignedStGotoComputedStCallStReturn StContinueStStopStPauseStReadStRead2StWriteStPrint StTypePrintStOpenStCloseStFlush StInquireStRewind StRewind2 StBackspace StBackspace2 StEndfile StEndfile2 StAllocate StNullify StDeallocateStWhereStWhereConstruct StElsewhere StEndWhereStUseStModuleProcedure StProcedureStType StEndType StSequenceStForallStForallStatement StEndForallStImportStEnum StEnumerator StEndEnum StFormatBogusBlock BlStatementBlForallBlIfBlCaseBlDo BlDoWhile BlAssociate BlInterface BlCommentCommentSuffixSfxBindPrefix PfxRecursive PfxElementalPfxPure PrefixSuffixSuffixesPrefixes ProgramUnitPUMainPUModule PUSubroutine PUFunction PUBlockData PUComment ProgramFileMetaInfo miVersion miFilenameKindSelectorTypeSpecBaseType TypeIntegerTypeRealTypeDoublePrecision TypeComplexTypeDoubleComplex TypeLogical TypeCharacter TypeCustom ClassStar ClassCustomTypeByteNameA0 pfSetFilename pfGetFilename emptyPrefixes emptySuffixesemptyPrefixSuffixvalidPrefixSuffixprogramUnitBodyupdateProgramUnitBodyprogramUnitSubprogramssetInitialisationnonExecutableStatementexecutableStatementexecutableStatementBlocknonExecutableStatementBlock$fNFDataBaseType $fOutBaseType$fBinaryBaseType$fNFDataMetaInfo $fOutMetaInfo$fNFDataPrefix $fOutPrefix$fSpannedPrefix$fSecondParameterPrefixSrcSpan$fFirstParameterPrefixa$fNFDataComment $fOutComment $fNFDataOnly $fOutOnly$fNFDataModuleNature$fOutModuleNature$fNFDataIntent $fOutIntent$fNFDataImpElement$fOutImpElement$fSpannedImpElement"$fSecondParameterImpElementSrcSpan$fFirstParameterImpElementa$fNFDataUnaryOp $fOutUnaryOp$fBinaryUnaryOp$fNFDataBinaryOp $fOutBinaryOp$fBinaryBinaryOp$fNFDataUnionMap$fNFDataStructureItem$fNFDataSuffix$fNFDataNamelist$fNFDataImpList$fNFDataFlushSpec$fNFDataFormatItem$fNFDataDeclarator$fNFDataDimensionDeclarator$fNFDataDataGroup$fNFDataAllocOpt$fNFDataControlPair$fNFDataCommonGroup$fNFDataAttribute $fNFDataUse$fNFDataArgument$fNFDataForallHeader$fNFDataSelector$fNFDataDoSpecification$fNFDataProcInterface$fNFDataProcDecl$fNFDataStatement $fNFDataValue $fNFDataIndex$fNFDataTypeSpec$fNFDataExpression $fNFDataBlock$fNFDataProgramUnit$fOutForallHeader $fOutAllocOpt$fOutControlPair$fOutDimensionDeclarator$fOutDeclarator $fOutSelector $fOutTypeSpec $fOutValue$fOutFlushSpec$fOutDoSpecification $fOutIndex$fOutExpression$fOutFormatItem $fOutNamelist $fOutUnionMap$fOutStructureItem$fOutDataGroup$fOutCommonGroup $fOutBlock $fOutImpList$fOutAttribute$fOutUse $fOutArgument$fOutProcInterface $fOutProcDecl$fOutStatement $fOutSuffix$fOutProgramUnit$fSpannedAllocOpt$fSpannedControlPair$fSpannedDimensionDeclarator$fSpannedDeclarator$fSpannedFlushSpec$fSpannedDoSpecification$fSpannedIndex$fSpannedExpression$fSpannedFormatItem$fSpannedNamelist$fSpannedUnionMap$fSpannedStructureItem$fSpannedDataGroup$fSpannedCommonGroup$fSpannedBlock$fSpannedImpList$fSpannedSelector$fSpannedProcInterface$fSpannedProcDecl$fSpannedTypeSpec$fSpannedAttribute $fSpannedUse$fSpannedArgument$fSpannedStatement$fSpannedSuffix$fSpannedProgramUnit $fSecondParameterAllocOptSrcSpan#$fSecondParameterControlPairSrcSpan+$fSecondParameterDimensionDeclaratorSrcSpan"$fSecondParameterDeclaratorSrcSpan!$fSecondParameterFlushSpecSrcSpan'$fSecondParameterDoSpecificationSrcSpan$fSecondParameterIndexSrcSpan"$fSecondParameterExpressionSrcSpan"$fSecondParameterFormatItemSrcSpan $fSecondParameterNamelistSrcSpan $fSecondParameterUnionMapSrcSpan%$fSecondParameterStructureItemSrcSpan!$fSecondParameterDataGroupSrcSpan#$fSecondParameterCommonGroupSrcSpan$fSecondParameterImpListSrcSpan!$fSecondParameterAttributeSrcSpan $fSecondParameterSelectorSrcSpan%$fSecondParameterProcInterfaceSrcSpan $fSecondParameterProcDeclSrcSpan $fSecondParameterTypeSpecSrcSpan$fSecondParameterUseSrcSpan $fSecondParameterArgumentSrcSpan!$fSecondParameterStatementSrcSpan$fSecondParameterBlockSrcSpan$fSecondParameterSuffixSrcSpan#$fSecondParameterProgramUnitSrcSpan$fFirstParameterAllocOpta$fFirstParameterControlPaira$$fFirstParameterDimensionDeclaratora$fFirstParameterDeclaratora$fFirstParameterFlushSpeca $fFirstParameterDoSpecificationa$fFirstParameterIndexa$fFirstParameterExpressiona$fFirstParameterFormatItema$fFirstParameterNamelista$fFirstParameterUnionMapa$fFirstParameterStructureItema$fFirstParameterDataGroupa$fFirstParameterCommonGroupa$fFirstParameterImpLista$fFirstParameterAttributea$fFirstParameterSelectora$fFirstParameterProcInterfacea$fFirstParameterProcDecla$fFirstParameterTypeSpeca$fFirstParameterUsea$fFirstParameterArgumenta$fFirstParameterStatementa$fFirstParameterBlocka$fFirstParameterSuffixa$fFirstParameterProgramUnita$fNFDataProgramFile$fOutProgramFile$fSpannedProgramFile$fAnnotatedAllocOpt$fAnnotatedControlPair$fAnnotatedDimensionDeclarator$fAnnotatedDeclarator$fAnnotatedFlushSpec$fAnnotatedDoSpecification$fAnnotatedIndex$fAnnotatedExpression$fAnnotatedFormatItem$fAnnotatedNamelist$fAnnotatedUnionMap$fAnnotatedStructureItem$fAnnotatedDataGroup$fAnnotatedCommonGroup$fAnnotatedImpElement$fAnnotatedImpList$fAnnotatedAttribute$fAnnotatedSelector$fAnnotatedProcInterface$fAnnotatedProcDecl$fAnnotatedTypeSpec$fAnnotatedUse$fAnnotatedArgument$fAnnotatedStatement$fAnnotatedBlock$fAnnotatedProgramUnit$fAnnotatedAList$fLabeledBlock$fNFDataProgramUnitName$fBinaryProgramUnitName$fNamedProgramUnit$fOrdProgramUnitName$fEqProgramUnitName$fShowProgramUnitName$fDataProgramUnitName$fGenericProgramUnitName$fEqProgramFile$fShowProgramFile$fDataProgramFile$fGenericProgramFile$fFunctorProgramFile$fEqExpression$fShowExpression$fDataExpression$fGenericExpression$fFunctorExpression $fEqValue $fShowValue $fDataValue$fGenericValue$fFunctorValue $fEqIndex $fShowIndex $fDataIndex$fGenericIndex$fFunctorIndex$fEqDoSpecification$fShowDoSpecification$fDataDoSpecification$fGenericDoSpecification$fFunctorDoSpecification $fEqStatement$fShowStatement$fDataStatement$fGenericStatement$fFunctorStatement$fEqDeclarator$fShowDeclarator$fDataDeclarator$fGenericDeclarator$fFunctorDeclarator$fEqDimensionDeclarator$fShowDimensionDeclarator$fDataDimensionDeclarator$fGenericDimensionDeclarator$fFunctorDimensionDeclarator $fEqFlushSpec$fShowFlushSpec$fDataFlushSpec$fGenericFlushSpec$fFunctorFlushSpec$fEqFormatItem$fShowFormatItem$fDataFormatItem$fGenericFormatItem$fFunctorFormatItem$fEqStructureItem$fShowStructureItem$fDataStructureItem$fGenericStructureItem$fFunctorStructureItem $fEqUnionMap$fShowUnionMap$fDataUnionMap$fGenericUnionMap$fFunctorUnionMap $fEqAttribute$fShowAttribute$fDataAttribute$fGenericAttribute$fFunctorAttribute $fEqSuffix $fShowSuffix $fDataSuffix$fGenericSuffix$fFunctorSuffix $fEqTypeSpec$fShowTypeSpec$fDataTypeSpec$fGenericTypeSpec$fFunctorTypeSpec $fEqSelector$fShowSelector$fDataSelector$fGenericSelector$fFunctorSelector $fEqDataGroup$fShowDataGroup$fDataDataGroup$fGenericDataGroup$fFunctorDataGroup $fEqNamelist$fShowNamelist$fDataNamelist$fGenericNamelist$fFunctorNamelist$fEqCommonGroup$fShowCommonGroup$fDataCommonGroup$fGenericCommonGroup$fFunctorCommonGroup $fEqImpList $fShowImpList $fDataImpList$fGenericImpList$fFunctorImpList $fEqAllocOpt$fShowAllocOpt$fDataAllocOpt$fGenericAllocOpt$fFunctorAllocOpt$fEqControlPair$fShowControlPair$fDataControlPair$fGenericControlPair$fFunctorControlPair $fEqArgument$fShowArgument$fDataArgument$fGenericArgument$fFunctorArgument$fEqUse $fShowUse $fDataUse $fGenericUse $fFunctorUse$fEqForallHeader$fShowForallHeader$fDataForallHeader$fGenericForallHeader$fFunctorForallHeader$fEqProcInterface$fShowProcInterface$fDataProcInterface$fGenericProcInterface$fFunctorProcInterface $fEqProcDecl$fShowProcDecl$fDataProcDecl$fGenericProcDecl$fFunctorProcDecl $fEqBlock $fShowBlock $fDataBlock$fGenericBlock$fFunctorBlock$fEqProgramUnit$fShowProgramUnit$fDataProgramUnit$fGenericProgramUnit$fFunctorProgramUnit $fEqBinaryOp $fOrdBinaryOp$fShowBinaryOp$fDataBinaryOp$fGenericBinaryOp $fEqUnaryOp $fOrdUnaryOp $fShowUnaryOp $fDataUnaryOp$fGenericUnaryOp$fEqImpElement$fShowImpElement$fDataImpElement$fGenericImpElement$fFunctorImpElement $fEqIntent $fShowIntent $fDataIntent$fGenericIntent$fEqModuleNature$fShowModuleNature$fDataModuleNature$fGenericModuleNature$fEqOnly $fShowOnly $fDataOnly $fGenericOnly $fEqComment $fShowComment $fDataComment$fGenericComment$fFunctorComment $fEqPrefix $fShowPrefix $fDataPrefix$fGenericPrefix$fFunctorPrefix $fEqMetaInfo$fShowMetaInfo$fDataMetaInfo$fGenericMetaInfo $fOrdBaseType $fEqBaseType$fShowBaseType$fDataBaseType$fGenericBaseType ReformatStateRefmtStNewlineRefmtStComment RefmtStStmtPrettypprint'IndentablePrettypprint IndentationtooOld olderThannewlineincIndentationindentoverlay fixedFormpprintAndRenderendGencommaSep$reformatMixedFormInsertContinuations$fFirstParameterValue[]$fIndentablePrettyUnionMap$fIndentablePretty[]$fIndentablePretty[]0$fIndentablePrettyProgramFile$fIndentablePrettyMaybe$fPrettyBinaryOp$fPrettyUnaryOp$fPrettyDimensionDeclarator$fPrettyDeclarator$fIndentablePrettyStructureItem $fPrettyValue $fPrettyIndex$fPrettyExpression$fPrettyImpElement$fPrettyDataGroup$fPrettyNamelist$fPrettyCommonGroup$fPrettyImpList$fPrettyAllocOpt$fPrettyControlPair$fPrettyDoSpecification$fPrettyFlushSpec$fPrettyFormatItem$fPrettyIntent$fPrettySuffix$fPrettyAttribute$fPrettyArgument $fPrettyUse $fPrettyOnly$fPrettyProcDecl$fPrettyProcInterface$fPrettyStatement$fPrettySelector$fPrettyTypeSpec$fPrettyBaseType$fPrettyATuple $fPrettyAList $fPretty[] $fPrettyMaybe$fIndentablePrettyBlock$fIndentablePrettyProgramUnit$fIndentablePrettya$fEqReformatState$fOrdReformatState$fShowReformatStateNumSignSignPosSignNegExponentLetter ExpLetterD ExpLetterEExponent expLetterexpSignexpNumRealLit realLitValuerealLitExponentrealLitKindParamreadReal readIntegerparseRealLiteral $fEqRealLit $fOrdRealLit $fShowRealLit $fEqExponent $fOrdExponent$fShowExponent $fEqNumSign $fOrdNumSign $fShowNumSign$fEqExponentLetter$fOrdExponentLetter$fShowExponentLetter AlexAccPredAlexAcc AlexAccNone AlexAccSkipAlexAccSkipPred AlexLastAccAlexNone AlexLastSkip AlexReturnAlexEOF AlexErrorAlexSkip AlexTokenAlexAddrAlexA# SpecifiesType isTypeSpecTokenTIdTCommentTStringTIntegerLiteral TRealLiteral TBozLiteralTCommaTComma2 TSemiColonTColon TDoubleColon TOpAssignTArrowTPercentTLeftPar TLeftPar2 TRightPar TLeftInitPar TRightInitPar TOpCustomTOpExpTOpPlusTOpMinusTStar TOpDivisionTSlashTOpOrTOpAndTOpNot TOpEquivalentTOpNotEquivalentTOpLTTOpLETOpEQTOpNETOpGTTOpGETLogicalLiteralTProgram TEndProgram TFunction TEndFunctionTResultTPure TElemental TRecursive TSubroutineTEndSubroutine TBlockData TEndBlockDataTModule TEndModule TContainsTUseTOnlyTImport TAbstract TInterface TEndInterface TProcedureTModuleProcedure TAssignment TOperatorTCallTReturnTEntryTIncludeTBindTCTName TAllocatable TAsynchronous TDimension TExternalTIntent TIntrinsic TNonIntrinsic TOptional TParameterTPointerTPrivateTPublic TProtectedTSaveTTargetTValue TVolatileTInTOutTInOutTData TNamelist TImplicit TEquivalenceTCommonTFormatTBlob TAllocateTStatTErrMsgTSource TDeallocateTNullifyTNoneTGotoTAssignTTo TContinueTStopTPauseTDoTEndDoTWhileTIfTThenTElseTElsifTEndIfTCase TSelectCase TEndSelectTDefaultTCycleTExitTForall TEndForall TAssociate TEndAssociateTWhere TElsewhere TEndWhereTTypeTEndType TSequenceTClassTEnum TEnumeratorTEndEnumTKindTLenTIntegerTRealTDoublePrecisionTLogical TCharacterTComplexTOpenTCloseTReadTWriteTPrint TBackspaceTRewindTInquireTEndfileTEndTNewlineTEOFTFlushTUnitTIOStatTIOMsgTErrMove ContinuationCharNewlineUser LexAction AlexInput aiSourceBytes aiPosition aiEndOffsetaiPreviousCharaiLexeme aiStartCodeaiPreviousTokenaiPreviousTokensInLine StartCodescActualscStatusStartCodeStatusReturnStableLexeme lexemeMatch lexemeStart lexemeEnd lexemeIsCmt alex_tab_size alex_base alex_table alex_check alex_deflt alex_accept alex_actionsformatPfollowsDoWithOptLabelP followsColonPlabelledWhereP selectorPifConditionEndPopPpartOfExpOrPointerAssignmentPprecedesDoubleColon parenLevel allocateP attributePbindPconstructNameP genericSpecPnotDefinedOperP typeSpecPresultPnotPrecedingDotPfollowsIntentPfollowsProcedureP followsBindP followsCP followsFlushPuseStPcaseStP assignStPprevTokenConstrnextTokenConstr seenConstr fillConstr adjustCommentleftParcommaslashOrDivisionaddSpanaddSpanAndMatch getLexeme putLexeme resetLexemegetMatchputMatchupdatePreviousTokenaddToPreviousTokensInLinecheckPreviousTokensInLine getLexemeSpan lexCharactertoSCstabiliseStartCodenormaliseStartCodeinvalidPositionisValidPosition initLexemevanillaAlexInput updateLexeme alexGetBytealexInputPrevChar currentCharadvanceWithoutContinuationisContinuationskipContinuation skipCCommentadvancelexHashlexerlexer'initParseStatecollectFreeTokensscCscIscNscT alex_action_0 alex_action_1 alex_action_2 alex_action_3 alex_action_5 alex_action_6 alex_action_7 alex_action_8 alex_action_9alex_action_10alex_action_11alex_action_12alex_action_13alex_action_14alex_action_15alex_action_16alex_action_17alex_action_18alex_action_19alex_action_20alex_action_21alex_action_22alex_action_23alex_action_24alex_action_25alex_action_26alex_action_27alex_action_28alex_action_29alex_action_30alex_action_31alex_action_32alex_action_33alex_action_34alex_action_35alex_action_36alex_action_37alex_action_38alex_action_39alex_action_40alex_action_41alex_action_42alex_action_43alex_action_44alex_action_45alex_action_46alex_action_47alex_action_48alex_action_49alex_action_50alex_action_51alex_action_52alex_action_53alex_action_54alex_action_55alex_action_56alex_action_57alex_action_58alex_action_59alex_action_60alex_action_61alex_action_62alex_action_63alex_action_64alex_action_65alex_action_66alex_action_67alex_action_68alex_action_69alex_action_70alex_action_71alex_action_72alex_action_73alex_action_74alex_action_75alex_action_76alex_action_77alex_action_78alex_action_79alex_action_80alex_action_81alex_action_82alex_action_83alex_action_84alex_action_85alex_action_86alex_action_87alex_action_88alex_action_89alex_action_90alex_action_91alex_action_92alex_action_93alex_action_94alex_action_95alex_action_96alex_action_97alex_action_98alex_action_99alex_action_100alex_action_101alex_action_102alex_action_103alex_action_104alex_action_105alex_action_106alex_action_107alex_action_108alex_action_109alex_action_110alex_action_111alex_action_112alex_action_113alex_action_114alex_action_115alex_action_116alex_action_117alex_action_118alex_action_119alex_action_120alex_action_121alex_action_122alex_action_123alex_action_124alex_action_125alex_action_126alex_action_127alex_action_128alex_action_129alex_action_130alex_action_131alex_action_132alex_action_133alex_action_134alex_action_135alex_action_136alex_action_137alex_action_138alex_action_139alex_action_140alex_action_141alex_action_142alex_action_143alex_action_144alex_action_145alex_action_146alex_action_147alex_action_148alex_action_149alex_action_150alex_action_151alex_action_152alex_action_153alex_action_154alex_action_155alex_action_156alex_action_157alex_action_158alex_action_159alex_action_160alex_action_161alex_action_162alex_action_163alex_action_164alex_action_165alex_action_166alex_action_167alex_action_168alex_action_169alex_action_170alex_action_171alex_action_172alex_action_173alex_action_174alex_action_175alex_action_176alex_action_177alex_action_178alex_action_179alex_action_180alex_action_181alex_action_182alex_action_183alex_action_184alex_action_185alex_action_186alex_action_187alex_action_188alex_action_189alex_action_190alex_action_191alex_action_192alex_action_193alex_action_194alex_action_195alex_action_196alex_action_197alex_action_198alex_action_199alex_action_200alex_action_201alex_action_202alex_action_203alex_action_204alex_action_205alex_action_206alexIndexInt16OffAddralexIndexInt32OffAddr quickIndexalexScan alexScanUser alex_scan_tkn alexAndPredalexPrevCharIsalexPrevCharMatchesalexPrevCharIsOneOfalexRightContext$fSpannedLexeme $fTokToken$fSpannedToken$fFirstParameterTokenSrcSpan$fLastTokenAlexInputToken$fLocAlexInput$fSpecifiesType[]$fSpecifiesTypeToken$fShowAlexInput $fEqToken $fShowToken $fDataToken$fGenericToken$fShowStartCode$fShowStartCodeStatus $fShowLexemeaiBytesaiWhiteSensitiveCharCountaiCaseSensitive aiInFormataiFortranVersion TLeftArrayParTRightArrayParTDot TStructureTRecordTUnionTMap TEndStructure TEndUnionTEndMapTEndif TCaseDefaultTDoWhile TTypePrintTStatic TAutomaticTIntTBozInt TExponentTBool TAmpersandTOpXOr THollerithTLabellexNcollectFixedTokenscollectFixedTokensSafe $fOrdTokenLValue LvSimpleVar LvSubscript LvDataReftoLValue$fSpannedLValue$fAnnotatedLValue$fSecondParameterLValueSrcSpan$fFirstParameterLValuea $fEqLValue $fShowLValue $fDataLValue$fGenericLValue$fFunctorLValue CharacterLen CharLenStar CharLenColon CharLenExp CharLenInt DimensionsTByteTArrayTCustomcharLenSelectorcharLenSelector'charLenToValue getTypeKind setTypeKind charLenConcatrecoverSemTypeTypeSpeckindOfBaseType getTypeSize setTypeSize$fNFDataCharacterLen$fOutCharacterLen$fBinaryCharacterLen$fPrettySemType $fOutSemType$fBinarySemType $fEqSemType $fOrdSemType $fShowSemType $fDataSemType$fGenericSemType$fOrdCharacterLen$fEqCharacterLen$fShowCharacterLen$fDataCharacterLen$fGenericCharacterLenprevAnnotation uniqueName sourceNamebBlocksinsLabel moduleEnvidType allLhsVarsAnnconstExpConstantConstIntConstUninterpIntConstUninterpReal ConstBinary ConstUnaryIDTypeidVTypeidCType ConstructType CTFunction CTSubroutine CTExternal CTVariableCTArray CTParameter CTIntrinsicModEnvNameType NTSubprogram NTVariable NTIntrinsic TransFuncM TransFuncBBNodeBBGrbbgrGr bbgrEntries bbgrExitsBB bbgrEmptybbgrMapbbgrMapMisNamedExpressionvarNamesrcName lvVarName lvSrcNamegenVarpuName puSrcName initAnalysis stripAnalysislhsExprsrhsExprsisLExprallVarsanalyseAllLhsVarsanalyseAllLhsVars1 allLhsVars blockRhsExprs blockVarUses blockVarDefs$fDataGr $fOutNameType$fBinaryNameType$fBinaryConstructType$fOutConstructType$fBinaryIDType $fOutIDType$fBinaryConstant $fOutConstant $fOutAnalysis$fFunctorAnalysis$fDataAnalysis$fShowAnalysis $fEqAnalysis$fGenericAnalysis$fShowConstant $fOrdConstant $fEqConstant$fGenericConstant$fDataConstant $fOrdIDType $fEqIDType $fShowIDType $fDataIDType$fGenericIDType$fOrdConstructType$fEqConstructType$fShowConstructType$fDataConstructType$fGenericConstructType$fShowNameType $fEqNameType $fOrdNameType$fDataNameType$fGenericNameType $fDataBBGr $fShowBBGr$fEqBBGr $fGenericBBGr TypeErrorTypeEnv analyseTypesanalyseTypesWithEnvanalyseAndCheckTypesWithEnvextractTypeEnv inferState0runInferderiveSemTypeFromDeclarationderiveSemTypeFromTypeSpecderiveSemTypeFromBaseType$fShowInferState ModuleMapanalyseRenamesanalyseRenamesWithModuleMaprenameunrename$fShowRenameState$fEqRenameState Transform runTransformgetProgramFileputProgramFilemodifyProgramFile groupForallgroupDogroupLabeledDodisambiguateIntrinsicdisambiguateFunction$fIndexedExpression$fIndexedArgument SuperBBGrsuperBBGrGraphsuperBBGrClusterssuperBBGrEntries ASTExprNode ASTBlockNode BBlockMapanalyseBBlocks genBBlockMap genSuperBBGrfindLabeledBBlockshowBBGrshowAnalysedBBGr showSuperBBGr showBBlocks bbgrToDOTsuperBBGrToDOT showBlockCallMapDerivedInductionMap InductionExprIETopIELinearIEBottomInductionVarMapByASTBlockInductionVarMap LoopNodeMap BackEdgeMap ConstExpMapParameterVarMap VarFlowsMap FlowsGraphUDMapDUMapDefMapBlockMapOutFInFInOutMapOrderFIDomMapDomMapASTExprNodeSetASTExprNodeMapASTBlockNodeSetASTBlockNodeMap BBNodeSet BBNodeMap dominators iDominators postOrder revPostOrderpreOrder revPreOrderdataFlowSolver genBlockMap genDefMapliveVariableAnalysisreachingDefinitionsgenDUMap duMapToUdMapgenUDMapgenFlowsToGraphgenVarFlowsToMapgenConstExpMapanalyseConstExpsanalyseParameterVarsgenBackEdgeMap loopNodesgenLoopNodeMapsccWithgenInductionVarMapgenInductionVarMapByASTBlockgenDerivedInductionMap showDataFlow showFlowsDOT genCallMap$fNFDataInductionExpr$fNFDataIEFlow $fShowIEFlow $fEqIEFlow $fOrdIEFlow$fGenericIEFlow $fDataIEFlow$fShowInductionExpr$fEqInductionExpr$fOrdInductionExpr$fGenericInductionExpr$fDataInductionExprTimestampStatus NoSuchFile CompileFile ModFileExistsModFilesModFile ParamVarMap StringMapDeclMap DeclContextDCMain DCBlockDataDCModule DCFunction DCSubroutine modFileSuffix emptyModFiles emptyModFile regenModFile genModFilelookupModFileDatagetLabelsModFileDataalterModFileData encodeModFile decodeModFilecombinedModuleMapcombinedTypeEnvcombinedDeclMapcombinedStringMapcombinedParamVarMapmoduleFilenamegenUniqNameToFilenameMapextractModuleMapextractDeclMapcheckTimestamps$fBinaryDeclContext$fBinaryModFile $fEqModFile $fOrdModFile $fShowModFile $fDataModFile$fGenericModFile$fOrdDeclContext$fEqDeclContext$fShowDeclContext$fDataDeclContext$fGenericDeclContextTransformation GroupForallGroupDoGroupLabeledDoDisambiguateFunctionDisambiguateIntrinsictransformWithModFiles transformdefaultTransformations$fEqTransformation blockParserstatementParserfunctionParserfortran95Parserfortran95ParserWithTransformsfortran95ParserWithModFiles)fortran95ParserWithModFilesWithTransformsfortran90Parserfortran90ParserWithTransformsfortran90ParserWithModFiles)fortran90ParserWithModFilesWithTransformsexpressionParserfortran77Parserfortran77ParserWithTransformsfortran77ParserWithModFiles)fortran77ParserWithModFilesWithTransformsextended77Parserextended77ParserWithTransformsextended77ParserWithModFiles*extended77ParserWithModFilesWithTransformslegacy77Parserlegacy77ParserWithTransformslegacy77ParserWithModFiles(legacy77ParserWithModFilesWithTransformslegacy77ParserWithIncludes(legacy77ParserWithIncludesWithTransforms includeParserfortran66Parserfortran66ParserWithTransformsfortran66ParserWithModFiles)fortran66ParserWithModFilesWithTransformsfortran2003Parserfortran2003ParserWithTransformsfortran2003ParserWithModFiles+fortran2003ParserWithModFilesWithTransformsParserWithModFilesParserparserVersionsparserWithModFilesVersions fortranParserfortranParserWithModFilesfortranParserWithVersion#fortranParserWithModFilesAndVersionModGraph mgModNodeMapmgGraph mgNumNodes ModOriginMOFileMOFSMod genModGraph modGraphToDOT takeNextMods delModNodes$fOrdModOrigin $fEqModGraph$fDataModGraph $fEqModOrigin$fDataModOrigin$fShowModOriginbytestring-0.10.12.0Data.ByteString.Internal ByteStringbaseGHC.IOFilePathghc-prim GHC.TypesDoubleHappyStk