fortran-src

Parsers and analyses for Fortran standards 66, 77, 90 and 95.

https://github.com/camfort/fortran-src#readme

Version on this page:0.6.1
LTS Haskell 20.26:0.12.0
Stackage Nightly 2023-04-28:0.13.0
Latest on Hackage:0.15.1

See all snapshots fortran-src appears in

Apache-2.0 licensed by Mistral Contrastin, Matthew Danish, Dominic Orchard, Andrew Rice
Maintained by [email protected]
This version can be pinned in stack with:fortran-src-0.6.1@sha256:40081de1ae4f8d5627b735211e24683e050640a83137d722f785f6a2714af70d,7361

fortran-src

CI status badge

Provides lexing, parsing, and basic analyses of Fortran code covering standards: FORTRAN 66, FORTRAN 77, Fortran 90, Fortran 95 and part of Fortran 2003. Includes data flow and basic block analysis, a renamer, and type analysis. For example usage, see the ‘camfort’ project (https://github.com/camfort/camfort), which uses fortran-src as its front end.

For features that output graphs, the intended usage is to pipe it into the command ‘dot -Tpdf’ and redirect that into a PDF file. The ‘dot’ command is part of the GraphViz project (https://www.graphviz.org/), please see their manual for the many other options that can be explored for visualisation purposes.

Usage: fortran-src [OPTION...] <file>
  -v VERSION, -F VERSION  --fortranVersion=VERSION         Fortran version to use, format: Fortran[66/77/77Legacy/77Extended/90]
  -a ACTION               --action=ACTION                  lex or parse action
  -t                      --typecheck                      parse and run typechecker
  -R                      --rename                         parse and rename variables
  -B                      --bblocks                        analyse basic blocks
  -S                      --supergraph                     analyse super graph of basic blocks
  -r                      --reprint                        Parse and output using pretty printer
                          --dot                            output graphs in GraphViz DOT format
                          --dump-mod-file                  dump the information contained within mod files
  -I DIR                  --include-dir=DIR                directory to search for precompiled 'mod files'
  -c                      --compile                        compile an .fsmod file from the input
                          --show-block-numbers[=LINE-NUM]  Show the corresponding AST-block identifier number next to every line of code.
                          --show-flows-to=AST-BLOCK-ID     dump a graph showing flows-to information from the given AST-block ID; prefix with 's' for supergraph
                          --show-flows-from=AST-BLOCK-ID   dump a graph showing flows-from information from the given AST-block ID; prefix with 's' for supergraph

Building

fortran-src supports building with Stack or Cabal. You should be able to build and use without any dependencies other than GHC itself.

As of 2021-04-28, fortran-src supports and is regularly tested on GHC 8.6, 8.8, 8.10 and 9.0. Releases prior to/newer than those may have issues. We welcome fixes that would let us support a wider range of compilers.

You will likely need at least 3 GiBs of memory to build fortran-src.

For installing GHC and build tools, we strongly recommend ghcup.

When latest recommended is used, it means the latest version of the tool that ghcup tags with recommended. This sometimes lags behind the latest-tagged version. With ghcup installed, run ghcup list for a better understanding.

Following are general guides for any OS that provides the relevant tools. If you have trouble, consider checking the CI workflow files in .github/workflows.

Stack

We support the latest recommended version of Stack (as of 2021-09-17, Stack 2.7). Generally, any Stack 2.x should work. (Stack 1.x may work with minor alternations – you may have to download the resolver manually.)

stack build

For an interactive shell:

stack build
stack ghci

Note that running stack ghci before running stack build won’t work properly, due to stack ghci not running build tools like Alex and Happy. So parser modules will not be built, and you’ll receive an error after building the other modules. You can cheat a bit and run stack build until you see Building library for [...] (= preprocessing has finished), then hit <Ctrl-C> to stop the build and run stack ghci as usual.

Cabal

We support the latest recommended version of Cabal (as of 2021-09-17, Cabal 3.4)

cabal build

Usage

As a dependency

fortran-src is available on Hackage, so add fortran-src to your project dependencies. That’s all.

If you’re using Stack, note that Stackage retains an old version watch out, because TODO

TODO you can stuff a Hackage reference into stack.yaml using extra-deps, like:

fortran-src is available on Hackage. Stackage has a very old version and is definitely not what you want, but you can specify a newer Hackage version in stack.yaml to use it conveniently with Stack-based projects.

resolver: ...
...

extra-deps:
- ...
- fortran-src-$VERSION

As a CLI tool

If you have Cabal properly configured, you should be able install fortran-src from Hackage:

cabal install fortran-src

Otherwise, we suggest building from source if you want to use the fortran-src CLI tool. See #Build from source for details.

Changes

0.6.1 (Sep 17, 2021)

  • Properly include test data in package dist (in preparation for placing on Stackage)

0.6.0 (Sep 03, 2021)

  • IF and CASE block constructs are now parsed as blocks at parsing instead of as a post-parse transformation (no intermediate statement representation) #154
  • add ASSOCIATE block construct (Fortran 2003 parser only) #165
  • CommonGroup AST nodes now store Declarators instead of Expressions #173
    • various bug fixes related to their typing as a result
  • CI now building on Windows, and save Linux & Windows executables for each build
  • various bugfixes (#34, #155)

0.5.0 (Jun 30, 2021)

  • Introduce a second-stage type representation including kind info alongside types, and resolving some types to semantic type with preset kinds (e.g. DOUBLE PRECISION -> REAL(8)).
    • Module is at Language.Fortran.Analysis.SemanticTypes . Includes utils and instances.
    • The type analysis in Language.Fortran.Analysis.Types uses this representation now (IDType stores a SemType instead of a BaseType).
  • Move CharacterLen from parsing to type analysis.
    • This makes BaseType now a plain tag/enum with no extra info.
  • Add extended Fortran 90 real literal parser (parses kind info).
  • Export some infer monad utils (potentially useful for running just parts of type analysis)
  • Parser & lexer tweaks
    • Fortran 77 parser should no longer attempt to parse kind selectors for DOUBLE types
    • Fix an edge case with the fixed form lexer (#150)

0.4.3 (May 25, 2021)

  • Add Haddock documentation to AST module. Many parts of the AST now have commentary on meaning and usage, and the Haddock page is sectioned.
  • Add STATIC statement (should be similar/identical to SAVE attribute) to fixed-form lexer, support in Fortran 77 Extended parser.
  • Rewrite post-parse transformation handling. Parser modules now export more parsers which allow you to select post-parse transformations to apply, intended to enable quicker parsing if you know you don’t need to certain transformations.
  • Support percent data references in fixed-form lexer, enable in Fortran 77 parser
  • Now also testing on GHC 9.0
  • Cache INCLUDE-ed files to avoid unnecessary re-parsing

0.4.2 (March 03, 2021)

  • FortranVersion from ParserMonad moved to its own module Language.Fortran.Version. ParserMonad will re-export it for now.
  • Version.deduceVersion renamed to deduceFortranVersion due to often being imported non-qualified. deduceVersion remains as an alias.
  • Provide a continuation reformatter in PrettyPrint. Runs on Strings and doesn’t guarantee the output is a valid program, so not enabled by default.
  • Add a diff-like rewriter, similar to reprinter but uses replacements rather than an annotated AST.
  • Various internal de-duplication and changes.

0.4.1

  • Ignore comments in structure declaration PR#107 (thanks Jason Xu)

0.4.0 (August 29, 2019)

  • ModGraph: parse Fortran files and assemble them into a dependency graph in order to construct automated ‘build’ plans for analysis and summarisation (e.g. with –make-mods option).
  • Change name of compilation to summarisation. Remains as ‘-c’ option.
  • Allow multiple files and directories to be specified on command line.
  • Search includedir recursively for fsmod files.
  • Change format of fsmod-files so that they can contain [ModFile] since multiple Fortran files can be summarised into a single mod file.
  • Introduce strictness and NFData dependencies across the board.
  • Use Pipes to process large amounts of files in order to control memory usage and more efficiently process things.
  • Parsing rules for StructStructures (thanks Raoul Charman)

0.3.0 (June 13, 2019)

  • Add partial Fortran2003 support.
  • Introduce datatype for BBGr instead of prior type alias for Gr.
    • Now split into three fields: bbgrGr, bbgrEntries and bbgrExits
    • May require refactoring of code to use bbgrGr field where a Gr was expected before.
  • Introduce pragmaOffset field for Position, allowing pragmas to specify an apparent file and line-number.
    • May require refactoring of code that uses the Position constructor.
    • Fifth field is Maybe (Int, String), containing a line-offset and a target filename when present.
    • It’s designed such that most Position-based transformations are not affected by the pragmaOffset.
    • They may need to preserve the field, though, as it passes through functions.
    • Default value is ‘Nothing’.
  • Add –show-flows-to/–show-flows-from features
    • Visualise the dataflow use/def chains using GraphViz.
  • Add –show-block-numbers feature.
    • Allows user to get AST-block numbers easily in order to use them with the above visualisation features.
  • Fix several bugs with dataflow analysis that had accumulated.
  • Eliminate StContinue and StEnddo are eliminated during GroupLabeledDo transformations.
    • To be consistent with unlabeled Do.
  • Parse and discard C-comments as a convenience feature for when fortran-src must interact with the output of C preprocessors that insert spurious comments.
  • Add type propagation into type analysis, annotating every expression with a type.
    • Additional interface: analyseTypesWithEnv to access a list of type errors found.
  • Add dimensional information to CTArray and length/kind to TypeCharacter.
  • Stricter checking of the grouping transform - if any statements that should be grouped are not grouped, raise an error.
  • Support pragmas that alter the current ‘filename and position’ tracker, often used by preprocessors to help pinpoint original code locations.
    • Uses a relative offset field called ‘posPragmaOffset’ so that relative measures continue to function correctly.
  • Add constant propagation / parameter variable analysis.
  • Add -c feature to compile ‘fsmod files’ with renaming and type info.

0.2.1.1 (May 18, 2018)

  • Extend Fortran 95 support
  • Extend support for legacy extensions

0.2.1.1 (December 13, 2017)

  • Fortran95Experimental module renamed to Fortran95
  • No infinite loops due to symlinks.
  • Fortran 95 support.
    • AST extended to support more non-standard statements internally.