Main features

• Definition, evaluation and removal of variables:

  #:if DEBUG > 0
    print *, "Some debug information"
  #:endif
  
  #:set LOGLEVEL = 2
  print *, "LOGLEVEL: ${LOGLEVEL}$"
  
  #:del LOGLEVEL

• Macro definitions and macro calls:

  #:def ASSERT(cond)
    #:if DEBUG > 0
      if (.not. ${cond}$) then
        print *, "Assert failed in file ${_FILE_}$, line ${_LINE_}$"
        error stop
      end if
    #:endif
  #:enddef ASSERT
  
  ! Invoked via direct call (argument needs no quotation)
  @:ASSERT(size(myArray) > 0)
  
  ! Invoked as Python expression (argument needs quotation)
  $:ASSERT('size(myArray) > 0')

• Conditional output:

  program test
  #:if defined('WITH_MPI')
    use mpi
  #:elif defined('WITH_OPENMP')
    use openmp
  #:else
    use serial
  #:endif

• Iterated output (e.g. for generating Fortran templates):

  interface myfunc
  #:for dtype in ['real', 'dreal', 'complex', 'dcomplex']
    module procedure myfunc_${dtype}$
  #:endfor
  end interface myfunc

• Inline directives:

  logical, parameter :: hasMpi = #{if defined('MPI')}# .true. #{else}# .false. #{endif}#

• Insertion of arbitrary Python expressions:

  character(*), parameter :: comp_date = "${time.strftime('%Y-%m-%d')}$"
  
  ! Evaluating python construct as a conditional
  #:if int(time.strftime('%m%d')) == 401
    print *, "April Fools!"
  #:endif

  with preprocessor variables available as Python variables:

  #:for plural in [("reds"), ("greens"), ("blues")]
  #:set singular = plural[:-1]
    print *, "Plural of ${singular}$ is ${plural}$"
  #:endfor

• Inclusion of files during preprocessing:

  #:include "macrodefs.fypp"

• Using Fortran-style continuation lines in preprocessor directives:

  #:if var1 > var2 &
      & or var2 > var4
    print *, "Doing something here"
  #:endif

• Passing (unquoted) multi-line string arguments to callables:

  #! Callable needs only string argument
  #:def DEBUG_CODE(code)
    #:if DEBUG > 0
      $:code
    #:endif
  #:enddef DEBUG_CODE
  
  #! Pass code block as first positional argument
  #:block DEBUG_CODE
    if (size(array) > 100) then
      print *, "DEBUG: spuriously large array"
    end if
  #:endblock DEBUG_CODE
  
  #! Callable needs also non-string argument types
  #:def REPEAT_CODE(code, repeat)
    #:for ind in range(repeat)
      $:code
    #:endfor
  #:enddef REPEAT_CODE
  
  #! Pass code block as positional argument and 3 as keyword argument "repeat"
  #:block REPEAT_CODE(repeat=3)
  this will be repeated 3 times
  #:endblock REPEAT_CODE

• Preprocessor comments:

  #! This will not show up in the output
  #! Also the newline characters at the end of the lines will be suppressed

• Suppressing the preprocessor output in selected regions:

  #! Definitions are read, but no output (e.g. newlines) will be produced
  #:mute
  #:include "macrodefs.fypp"
  #:endmute

• Explicit request for stopping the preprocessor:

  #:if DEBUGLEVEL < 0
    #:stop 'Negative debug level not allowed!'
  #:endif

• Easily check macro parameter validity:

  #:def mymacro(RANK)
    #! Macro only works for RANK 1 and above
    #:assert RANK > 0
    :
  #:enddef mymacro

• Line numbering directives in output:

  program test
  #:if defined('MPI')
  use mpi
  #:endif
  :

  transformed to

  # 1 "test.fypp" 1
  program test
  # 3 "test.fypp"
  use mpi
  # 5 "test.fypp"
  :

  when variable MPI is defined and Fypp was instructed to generate line markers.

• Automatic folding of generated lines exceeding line length limit

Installing

Fypp needs a working Python 3 interpreter (Python 3.10 or above).

When you install Fypp, you obtain the command line tool fypp and the Python module fypp.py. Latter you can import if you want to access the functionality of Fypp directly from within your Python scripts.

conda install -c conda-forge fypp

pip3 install fypp

pip3 install --user fypp

pacman -S mingw-w64-x86_64-python-fypp

git clone https://github.com/aradi/fypp.git

FYPP_SOURCE_FOLDER/bin/fypp

fypp

Running

The Fypp command line tool reads a file, preprocesses it and writes it to another file, so you would typically invoke it like:

fypp source.fpp source.f90

which would process source.fpp and write the result to source.f90. If input and output files are not specified, information is read from stdin and written to stdout.

The behavior of Fypp can be influenced with various command line options. A summary of all command line options can be obtained by:

fypp -h

Testing

Fypp can be tested with tox. Running

tox

in the project root folder builds the package, installs it into a virtual environment and runs the unit tests against the installed version. This is done for each supported Python version; versions whose interpreter is not available on your system are skipped.

To test with one Python version only, select the corresponding test environment:

tox -e 3.14

For a quick test during development, you can also run the unit tests directly on the source tree with your default python3 interpreter:

./test/runtests.sh

To use other interpreters, pass them as arguments (e.g. ./test/runtests.sh python3.12 python3.13).