scripting.py

"""
This module contains functions usefull to build scripts around the pyfortool library
"""
 
import sys
from multiprocessing import cpu_count, get_context
from multiprocessing.managers import BaseManager
import re
import shlex
import os
import argparse
import logging
import traceback
 
from pyfortool.pyfortool import PYFT
from pyfortool.tree import Tree
from pyfortool.util import isint, PYFTError
from pyfortool import __version__
 
 
def task(filename):
    """
    Function to use on each file
    :param clsPYFT: PYFT class to use
    :param filename: file name
    """
    global PYFT  # noqa: F824
    global allFileArgs  # noqa: F824
    allArgs, orderedOptions = allFileArgs[filename]
    try:
        # Opening and reading of the FORTRAN file
        with PYFT(filename, filename,
                  parserOptions=getParserOptions(allArgs), verbosity=allArgs.logLevel,
                  wrapH=allArgs.wrapH,
                  enableCache=allArgs.enableCache) as pft:
 
            # apply the transformation in the order they were specified
            for arg in orderedOptions:
                logging.debug('Applying %s on %s', arg, filename)
                applyTransfo(pft, arg, allArgs,
                             filename if filename == allArgs.plotCentralFile else None)
                logging.debug('  -> Done')
 
            # Writing
            if not allArgs.dryRun:
                pft.write()
 
        # Reporting
        return (0, filename)
 
    except Exception as exc:  # pylint: disable=broad-except
        logging.error("The following error has occurred in the file %s", filename)
        # Three-argument form: the single-argument form needs python >= 3.10
        traceback.print_exception(type(exc), exc, exc.__traceback__, file=sys.stdout)
        sys.stdout.flush()
        return (1, filename)
 
 
class TreeManager(BaseManager):
    """
    Manager sharing a single Tree instance between the pyfortool_parallel processes
    """
 
 
TreeManager.register('Tree', Tree)
 
 
def poolInit(cls, afa):
    """
    Pool initializer
    """
    # After many, many attempts, it seems very difficult (if not impossible)
    # to do without global variables
    global PYFT  # pylint: disable=global-statement
    global allFileArgs  # pylint: disable=global-statement
    PYFT = cls
    allFileArgs = afa
 
 
def mainParallel(argv=None):
    """
    Core of the pyfortool_parallel.py command
    :param argv: list of arguments (including the 'programm' name in first position)
                 as would be obtained by sys.argv. Or None to use sys.argv
    """
    parser = argparse.ArgumentParser(description='Python FORTRAN tool', allow_abbrev=False,
                                     epilog="The argument order matters.")
 
    updateParser(parser, withInput=False, withOutput=False, withXml=False, withPlotCentralFile=True,
                 treeIsOptional=False, nbPar=True, restrictScope=False)
    commonArgs, getFileArgs = getArgs(parser, argv)
 
    # The 'fork' start method is requested explicitly. The parallel configuration installed
    # by PYFT.setParallel below is held in class attributes, and child processes can only
    # receive it by inheriting the parent memory. Python 3.14 made 'forkserver' the default
    # on Linux, under which the workers would start from a freshly imported (and therefore
    # unconfigured) PYFT class.
    ctx = get_context('fork')
 
    # Manager to share the Tree instance
    with TreeManager(ctx=ctx) as manager:
        # Set-up the Tree instance
        sharedTree = getDescTree(commonArgs, manager.Tree)
 
        # Prepare PYFT to be used in parallel (locks taken from the same 'fork' context)
        PYFT.setParallel(sharedTree, clsLock=ctx.Lock, clsRLock=ctx.RLock)
        try:
            # Set-up the processes
            allFileArgs = {file: getFileArgs(file) for file in sharedTree.getFiles()}
            logging.info('Executing in parallel on %i files with a maximum of %i processes',
                         len(allFileArgs), commonArgs.nbPar)
            with ctx.Pool(commonArgs.nbPar, initializer=poolInit,
                          initargs=(PYFT, allFileArgs)) as pool:
                result = pool.map(task, sharedTree.getFiles())
 
            # Writting the descTree object
            sharedTree.toJson(commonArgs.descTree)
 
            # General error
            errors = [item[1] for item in result if item[0] != 0]
            status = len(errors)
            if status != 0:
                logging.error('List of files with error:')
                for error in errors:
                    logging.error('  - %s', error)
                raise PYFTError(f"Errors have been reported in {status} file(s).")
        finally:
            # Unset parallel processing, even on error: the shared tree lives in the
            # manager process, which is stopped when leaving the 'with' block
            PYFT.unsetParallel()
 
 
def main(argv=None):
    """
    Core of the pyfortool.py command
    :param argv: list of arguments (including the 'programm' name in first position)
                 as would be obtained by sys.argv. Or None to use sys.argv
    """
    parser = argparse.ArgumentParser(description='Python FORTRAN tool', allow_abbrev=False,
                                     epilog="The argument order matters.")
 
    updateParser(parser, withInput=True, withOutput=True, withXml=True, withPlotCentralFile=False,
                 treeIsOptional=True, nbPar=False, restrictScope=True)
    args, orderedOptions = getArgs(parser, argv)[1]()
 
    parserOptions = getParserOptions(args)
    descTree = getDescTree(args)
 
    try:
        # Opening and reading of the FORTRAN file
        pft = PYFT(args.INPUT, args.OUTPUT, parserOptions=parserOptions,
                   verbosity=args.logLevel, wrapH=args.wrapH, tree=descTree,
                   enableCache=args.enableCache)
        if args.restrictScope != '':
            pft = pft.getScopeNode(args.restrictScope)
 
        # apply the transformation in the order they were specified
        for arg in orderedOptions:
            logging.debug('Applying %s on %s', arg, args.INPUT)
            applyTransfo(pft, arg, args, plotCentralFile=args.INPUT)
            logging.debug('  -> Done')
 
        # Writing
        if descTree is not None:
            descTree.toJson(args.descTree)
        if args.xml is not None:
            pft.mainScope.writeXML(args.xml)
        if not args.dryRun:
            pft.mainScope.write()
 
        # Closing
        pft.mainScope.close()
 
    except:  # noqa E722
        # 'exept' everything and re-raise error systematically
        logging.error("The following error has occurred in the file %s", args.INPUT)
        raise
 
 
ARG_UPDATE_CNT = ('--alignContinuation', '--addBeginContinuation',
                  '--removeBeginContinuation',
                  '--emoveALLContinuation')
 
 
def getArgs(parser, argv):
    """
    Parse arguments and interpret the --optsByEnv option
    :param parser: argparse parser
    :param argv: list of arguments (including the 'programm' name in first position)
                 as would be obtained by sys.argv. Or None to use sys.argv.
    :return: a tuple with
               - an argparse namespace containing common arguments (not using the --optsEnv option)
               - a function taking a filename as input and returning
                  - an argparse namespace with the common arguments and the ones added by
                    interpreting the --optsEnv option
                  - an ordered list of arguments
    """
    if argv is None:
        argv = sys.argv
    args = parser.parse_args(argv[1:])
 
    def getFileArgs(filename=args.INPUT if hasattr(args, 'INPUT') else None):
        """
        :param filename: name of source code file
        :return: argparse namespace to use with this file and
                 a list given the order in which the arguments were provided
        """
        # Decode the --optsByEnv option
        arguments = argv[1:]
        if args.optsByEnv is not None:
            extra = ''
            for line in [] if args.optsByEnv is None else os.environ[args.optsByEnv].split('\n'):
                if ':=:' in line:
                    if re.match(line.split(':=:')[0], filename):
                        extra = line.split(':=:')[1]
                else:
                    extra = line
            index = arguments.index('--optsByEnv')
            arguments = arguments[:index] + shlex.split(extra) + arguments[index + 2:]  # keep order
 
        # Compute the ordered list
        updateCnt = False
        optList = []
        for arg in arguments:
            if arg.startswith('--') and arg not in optList:
                if arg in ARG_UPDATE_CNT:
                    if not updateCnt:
                        updateCnt = True
                        optList.append(arg)
                else:
                    optList.append(arg)
 
        return parser.parse_args(arguments), optList
 
    return args, getFileArgs
 
 
def getParserOptions(args):
    """
    Get the options to use for the fxtran parser
    :param args: arguments parsed by the argparse parser
    """
    if args.parserOption is None:
        parserOptions = PYFT.DEFAULT_FXTRAN_OPTIONS.copy()
    else:
        parserOptions = [el for elements in args.parserOption for el in elements]
    if args.addIncludes:
        parserOptions = [opt for opt in parserOptions if opt not in ('-no-include', '-noinclude')]
    return parserOptions
 
 
def getDescTree(args, cls=Tree):
    """
    get the Tree object built with the parsed arguments
    :param args: arguments parsed by the argparse parser
    :param cls: class to use (usefull for manager)
    :return: a Tree instance
    """
    parserOptions = getParserOptions(args)
    if args.descTree:
        descTree = cls(tree=args.tree, descTreeFile=args.descTree,
                       parserOptions=parserOptions,
                       wrapH=args.wrapH, verbosity=args.logLevel)
    else:
        descTree = None
    return descTree
 
 
def updateParser(parser, withInput, withOutput, withXml, withPlotCentralFile, treeIsOptional,
                 nbPar, restrictScope):
    """
    Updates an argparse parser with arguments common to all the different tools
    :param parser: parser in which arguments are added
    :param withOutput: do we need the INPUT argument
    :param withOutput: do we need the OUTPUT argument
    :param withXml: do we need to be able to define an XML output file
    :param withPlotCentralFile: to add the --plotCentralFile argument
    :param treeIsOptional: is the --tree argument optional?
    :param nbPar: number of parallel processes
    :param restrictScope: can we specify the scope path
    """
 
    # ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
    # IMPORTANT NOTE
    # Argument order matters but argparse is not able to give the order
    # Therefore, arguments are processed twice. The first time by argparse to fully decode them.
    # Then a second pass is made direcly on sys.argv. This mechanism has two implications:
    # allow_abbrev must be set to False in ArgumentParser
    # only long argument options are allowed (begining with two dashes)
    # ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
    assert not parser.allow_abbrev, 'parser must be created with allow_abbrev=False'
 
    parser.add_argument('--version', action='version',
                        version='%(prog)s {version}'.format(version=__version__))
    parser.add_argument('--simplify', default=False, action='store_true',
                        help='After a deletion, recursively deletes the code ' +
                             'and variables that have become useless')
    parser.add_argument('--logLevel', default='warning',
                        help='Provide logging level. Example --logLevel debug (default is warning)')
    parser.add_argument('--enableCache', default=False, action='store_true',
                        help='Precompute parent of each xml node and store the result')
    if nbPar:
        parser.add_argument('--nbPar', default=cpu_count(), type=int,
                            help='Number of parallel processes, 0 to get as many processes ' +
                                 'as the number of cores (default=0)')
    parser.add_argument('--optsByEnv', default=None, type=str,
                        help='Name of the environment variable containing additional arguments ' +
                             'to use. These arguments are processed after all other arguments. ' +
                             'The variable can contain a multi-lines string. The ' +
                             'variable is read line by line and the last applicable line is ' +
                             'used. A line can take one of these two forms: ' +
                             '1) "FILE_DESCRIPTOR:=:OPTIONS" (where FILE_DESCRIPTOR is a ' +
                             'regular expression to test against the filename. If there ' +
                             'is a match, the OPTIONS can be used for the file) and ' +
                             '2) "OPTIONS" (if the line doesn\'t contain the FILE_DESCRIPTOR ' +
                             'part, it applies to all source code).')
 
    if restrictScope:
        parser.add_argument('--restrictScope', default='', type=str, metavar='SCOPEPATH',
                            help="Limit the action to this scope path (SUBROUTINE/FUNCTION/" +
                                 "MODULE/TYPE). It is '/'-separated path with each element " +
                                 "having the form 'module:<name of the module>', " +
                                 "'sub:<name of the subroutine>', " +
                                 "'func:<name of the function>' or 'type:<name of the type>'.")
 
    # Inputs and outputs
    updateParserInputsOutputs(parser, withInput, withOutput, withXml)
 
    # fxtran
    updateParserFxtran(parser)
 
    # Variables
    updateParserVariables(parser)
 
    # Cosmetics
    updateParserCosmetics(parser)
 
    # Applications
    updateParserApplications(parser)
 
    # openACC
    updateParserOpenACC(parser)
 
    # Checks
    updateParserChecks(parser)
 
    # Statements
    updateParserStatements(parser)
 
    # Misc
    updateParserMisc(parser)
 
    # Tree
    updateParserTree(parser, withPlotCentralFile, treeIsOptional)
 
    # Preprocessot
    updateParserPreprocessor(parser)
 
 
def updateParserInputsOutputs(parser, withInput, withOutput, withXml):
    """
    Updates an argparse parser with input/output arguments
    :param parser: parser in which arguments are added
    :param withOutput: do we need the INPUT argument
    :param withOutput: do we need the OUTPUT argument
    :param withXml: do we need to be able to define an XML output file
    """
    gInOut = parser.add_argument_group('Input and output')
    if withInput:
        gInOut.add_argument('INPUT', help='FORTRAN input file')
    if withOutput:
        gInOut.add_argument('OUTPUT', default=None, help='FORTRAN output file', nargs='?')
    gInOut.add_argument('--renamefF', default=False, action='store_true',
                        help='Put file extension in upper case')
    gInOut.add_argument('--renameFf', default=False, action='store_true',
                        help='Put file extension in lower case')
    if withXml:
        gInOut.add_argument('--xml', default=None, type=str,
                            help='Output file for xml')
    gInOut.add_argument('--dryRun', default=False, action='store_true',
                        help='Dry run without writing the FORTRAN file (the xml ' +
                             'is still written')
 
 
def updateParserFxtran(parser):
    """
    Updates an argparse parser with fxtran arguments
    """
    gParser = parser.add_argument_group('fxtran parser relative options')
    gParser.add_argument('--parserOption', nargs='*', action='append',
                         help='Option to pass to fxtran, defaults ' +
                              f'to {PYFT.DEFAULT_FXTRAN_OPTIONS}')
    gParser.add_argument('--wrapH', default=False, action='store_true',
                         help='Wrap .h file content into a MODULE to enable the reading')
 
 
def updateParserVariables(parser):
    """
    Updates an argparse parser with variables arguments
    """
    gVariables = parser.add_argument_group('Options to deal with variables')
    gVariables.add_argument('--showVariables', default=False, action='store_true',
                            help='Show the declared variables')
    gVariables.add_argument('--removeVariable', nargs=2, action='append',
                            metavar=('SCOPEPATH', 'VARNAME'),
                            help="Variable to remove from declaration. The first argument " +
                                 "is the SUBROUTINE/FUNCTION/MODULE/TYPE where the variable " +
                                 "is declared. It is '/'-separated path with each element having " +
                                 "the form 'module:<name of the module>', " +
                                 "'sub:<name of the subroutine>', " +
                                 "'func:<name of the function>' or 'type:<name of the type>'. " +
                                 "The second argument is the variable name")
    gVariables.add_argument('--attachArraySpecToEntity', default=False, action='store_true',
                            help='Find all T-decl-stmt elements that have a child element ' +
                                 'attribute with attribute-N=DIMENSION and move the attribute ' +
                                 'into EN-N elements')
    gVariables.add_argument('--addVariable', nargs=4, action='append',
                            metavar=('SCOPEPATH', 'VARNAME', 'DECLARATION', 'POSITION'),
                            help='Add a variable. First argument is the scope path (as for ' +
                                 'the --removeVariable option. The second is the variable ' +
                                 'name, the third is the declarative statement to insert, ' +
                                 'the fourth is the position (python indexing) the new ' +
                                 'variable will have in the calling statment of the ' +
                                 'routine (non-integer value for a local variable).')
    gVariables.add_argument('--addModuleVariable', nargs=3, action='append',
                            metavar=('SCOPEPATH', 'MODULENAME', 'VARNAME'),
                            help='Add a USE statement. The first argument is the scope path ' +
                                 '(as for the --removeVariable option). The second is the module ' +
                                 'name; the third is the variable name.')
    gVariables.add_argument('--showUnusedVariables', default=False, action='store_true',
                            help='Show a list of unused variables.')
    gVariables.add_argument('--removeUnusedLocalVariables',
                            help='Remove unused local variables, excluding some variables (comma-' +
                                 'separated list or NONE to exclude nothing).')
    gVariables.add_argument('--removePHYEXUnusedLocalVariables',
                            help='Remove unused local variables, excluding some variables (comma-' +
                                 'separated list or NONE to exclude nothing). This option takes ' +
                                 'into account the mnh_expand directives to prevent from ' +
                                 'removing useful variables.')
    gVariables.add_argument('--addExplicitArrayBounds', action='store_true',
                            help='Adds explicit bounds to arrays that already have parentheses.')
    gVariables.add_argument('--addArrayParentheses', action='store_true',
                            help='Adds parentheses to arrays (A => A(:))')
    gVariables.add_argument('--modifyAutomaticArrays', metavar="DECL#START#END",
                            help='Transform all automatic arrays declaration using the templates.' +
                                 ' The DECL part of the template will replace the declaration ' +
                                 'statement, the START part will be inserted as the first ' +
                                 'executable statement while the END part will be inserted as ' +
                                 'the last executable statement. Each part ' +
                                 'of the template can use the following place holders: ' +
                                 '"{doubledotshape}", "{shape}", "{lowUpList}", "{name}" and ' +
                                 '"{type}" which are, respectively modified into ' +
                                 '":, :, :", "I, I:J, 0:I", "1, I, I, J, 0, I", "A", "REAL" ' +
                                 'if the original declaration statement ' +
                                 'was "A(I, I:J, 0:I)". For example, the template ' +
                                 '"{type}, DIMENSION({doubledotshape}), ALLOCATABLE :: ' +
                                 '{name}#ALLOCATE({name}({shape}))#DEALLOCATE({name})"' +
                                 'will replace automatic arrays by allocatables.')
    gVariables.add_argument('--replaceAutomaticWithAllocatable', action='store_true',
                            help='Replace all automatic arrays with allocatable arrays.')
    gVariables.add_argument('--addArgInTree', default=None, action='append', nargs=3,
                            metavar=('VARNAME', 'DECLARATION', 'POSITION'),
                            help='Add an argument variable. The first argument is the variable ' +
                                 'name, the second one is the declarative statement to insert, ' +
                                 'the third one is the position (python indexing) the new ' +
                                 'variable will have in the calling statement of the ' +
                                 'routine. Needs the --stopScopes argument')
    gVariables.add_argument('--addONLY', default=False, action='store_true',
                            help='Add missing ONLY clause to USE statements.')
 
 
def updateParserCosmetics(parser):
    """
    Updates an argparse parser with cosmetics arguments
    """
    gCosmetics = parser.add_argument_group('Cosmetics options')
    gCosmetics.add_argument('--upperCase', default=False, action='store_true',
                            help='Put FORTRAN code in upper case letters')
    gCosmetics.add_argument('--lowerCase', default=False, action='store_true',
                            help='Put FORTRAN code in lower case letters')
    gCosmetics.add_argument('--changeIfStatementsInIfConstructs', default=False,
                            action='store_true',
                            help='Find all if-statement and convert it to if-then-statement')
    gCosmetics.add_argument('--indent', default=False, action='store_true',
                            help='Correct indentation')
    gCosmetics.add_argument('--removeIndent', default=False, action='store_true',
                            help='Remove indentation')
    gCosmetics.add_argument('--removeEmptyLines', default=False, action='store_true',
                            help='Remove empty lines')
    gCosmetics.add_argument('--removeComments', default=False, action='store_true',
                            help='Remove comments')
    gCosmetics.add_argument('--updateSpaces', default=False, action='store_true',
                            help='Updates spaces around operators, commas, parenthesis and ' +
                                 'at the end of line')
    gCosmetics.add_argument('--alignContinuation', default=False, action='store_true',
                            help='Align the beginings of continued lines')
    gCosmetics.add_argument('--addBeginContinuation', default=False, action='store_true',
                            help='Add missing continuation characters (\'&\') at the ' +
                                 'begining of lines')
    gCosmetics.add_argument('--removeBeginContinuation', default=False, action='store_true',
                            help='Remove continuation characters (\'&\') at the begining of lines')
    gCosmetics.add_argument('--removeALLContinuation', default=False, action='store_true',
                            help='Remove all continuation characters(\'&\')')
    gCosmetics.add_argument('--prettify', default=False, action='store_true',
                            help='Prettify the source code (indentation, spaces...)')
    gCosmetics.add_argument('--minify', default=False, action='store_true',
                            help='Simplify the source code (indentation, spaces...)')
    gCosmetics.add_argument('--removeEmptyCONTAINS', default=False, action='store_true',
                            help='Remove useless CONTAINS statements')
    gCosmetics.add_argument('--formatModuleUse', default=False, action='store_true',
                            help='Order USE declarations by module type (MODD_, MODE_, ' +
                            'MODI_, MODN_) and alphabetically within each group')
 
 
def updateParserApplications(parser):
    """
    Updates an argparse parser with applications arguments
    """
    gApplications = parser.add_argument_group('Options to apply upper level transformation')
    gApplications.add_argument('--deleteDrHook', default=False, action='store_true',
                               help='Delete DR HOOK use')
    gApplications.add_argument('--addDrHook', default=False, action='store_true',
                               help='Add DR HOOK')
    gApplications.add_argument('--deleteBudgetDDH', default=False, action='store_true',
                               help='Delete Budget/DDH use')
    gApplications.add_argument('--deleteRoutineCallsMesoNHGPU', default=False, action='store_true',
                               help='Delete parts of the code not compatible with MesoNH-OpenACC' +
                               'such as OCND2 blocks')
    gApplications.add_argument('--splitModuleRoutineFile', default=False, action='store_true',
                               help='Split a file')
    gApplications.add_argument('--deleteNonColumnCallsPHYEX', default=False, action='store_true',
                               help='Delete call to PHYEX routines that needs information on ' +
                                    'horizontal points (multiple column dependency')
    gApplications.add_argument('--removeIJDim', default=False, action='store_true',
                               help='Remove I and J dimensions (1, KLON). ' +
                                    'Needs the --stopScopes argument.')
    gApplications.add_argument('--expandAllArraysPHYEX', default=False, action='store_true',
                               help='Expand all array syntax (computing and where block) ' +
                               'using PHYEX conventions')
    gApplications.add_argument('--expandAllArraysPHYEXConcurrent', default=False,
                               action='store_true',
                               help='Expand all array syntax with DO CONCURRENT loops ' +
                                    '(computing and where block) using PHYEX conventions')
    gApplications.add_argument('--expandAllArrays', default=False, action='store_true',
                               help='Expand all array syntax (computing and where block) ' +
                                    'using mnh directives if present')
    gApplications.add_argument('--expandAllArraysConcurrent', default=False, action='store_true',
                               help='Expand all array syntax with DO CONCURRENT loops ' +
                                    '(computing and where block) using mnh directives if present')
    gApplications.add_argument('--inlineContainedSubroutinesPHYEX', default=False,
                               action='store_true',
                               help='Inline containted subroutines in main routine, using ' +
                                    'PHYEX conventions')
    gApplications.add_argument('--addStack', metavar='MODEL', type=str,
                               help='Add local arrays to the stack. The argument is the ' +
                                    'the model name in which stack must be added ("AROME" ' +
                                    'or "MESONH"). Needs the --stopScopes argument for AROME.')
    gApplications.add_argument('--addIncludes', default=False, action='store_true',
                               help='Add .h includes in the file and remove the INCLUDE statement')
    gApplications.add_argument('--addSubmodulePHYEX', default=False, action='store_true',
                               help='Add SUBMODULE and INTERFACE of subroutines in PHYEX')
    gApplications.add_argument('--mnhExpand', default=False, action='store_true',
                               help='Apply the mnh_expand directives with DO loops')
    gApplications.add_argument('--mnhExpandConcurrent', default=False, action='store_true',
                               help='Apply the mnh_expand directives with DO CONCURRENT loops')
    gApplications.add_argument('--addMPPDB_CHECKS', default=False, action='store_true',
                               help='Add MPPDB_CHEKS bit-repro checking routines of MesoNH for ' +
                                    'all in and inout arrays in subroutines')
    gApplications.add_argument('--addPrints', default=False, action='store_true',
                               help='Add Prints of min/maxval and shape of all in, out, inout ' +
                                    'arguments of all scopes')
    gApplications.add_argument('--shumanFUNCtoCALL', default=False, action='store_true',
                               help='Transform shuman functions to call statements ' +
                                    '(legacy version)')
    gApplications.add_argument('--shugradTransfo', default=False, action='store_true',
                               help='Transform shuman functions to call statements')
    gApplications.add_argument('--mathFunctoBRFunc', default=False, action='store_true',
                               help='Convert intrinsic math functions **, LOG, ATAN, **2, **3, ' +
                                    '**4, EXP, COS, SIN, ATAN2 into a self defined function BR_ ' +
                                    'for MesoNH bit-repro.')
    gApplications.add_argument('--convertTypesInCompute', default=False, action='store_true',
                               help='Use single variable instead of variable contained in ' +
                                    'structure in compute statement for optimization issue ')
    gApplications.add_argument('--buildModi', default=False, action='store_true',
                               help='Builds the corresponding modi_ file')
    gApplications.add_argument('--removeExtraDOinMnhDoConcurrent', default=False,
                               action='store_true',
                               help='Remove DO and ENDDO instructions inside !$mnh_do_concurrent')
    gApplications.add_argument('--convertuseModuleToIncludes', default=False,
                               action='store_true',
                               help='Convert USE MODULE, ONLY: ROUTINE to #include routine.intfb.h')
 
 
def updateParserOpenACC(parser):
    """
    Updates an argparse parser with openACC arguments
    """
    gOpenACC = parser.add_argument_group('OpenACC')
    gOpenACC.add_argument('--addACCData', default=False, action='store_true',
                          help='Add !$acc data present and !$acc end data directives')
    gOpenACC.add_argument('--addACCRoutineSeq', default=False, action='store_true',
                          help='Add "!$acc routine seq" to routines under stopScopes')
    gOpenACC.add_argument('--craybyPassDOCONCURRENT', default=False, action='store_true',
                          help='remove acc loop independant collapse for BR_ fonctions and ' +
                               'mnh_undef(OPENACC) macro' +
                               ' use DO CONCURRENT with mnh_undef(LOOP)')
    gOpenACC.add_argument('--removeACC', default=False, action='store_true',
                          help='remove all ACC directives')
    gOpenACC.add_argument('--removebyPassDOCONCURRENT', default=False, action='store_true',
                          help='remove macro !$mnh_(un)def(OPENACC) and !$mnh_(un)def(LOOP) ' +
                               'directives')
    gOpenACC.add_argument('--buildACCTypeHelpers', default=False, action='store_true',
                          help='build module files containing helpers to copy user ' +
                               'type structures')
    gOpenACC.add_argument('--allocatetoHIP', default=False, action='store_true',
                          help='convert (DE)ALLOCATE to (DE)ALLOCATE_HIP on variables only sent ' +
                          'to the GPU via acc enter data copyin/create (for GPU AMD MI250X)')
 
 
def updateParserChecks(parser):
    """
    Updates an argparse parser with checks arguments
    """
 
    gChecks = parser.add_argument_group('Check options')
    gChecks.add_argument('--checkIMPLICIT', choices={'Warn', 'Err'}, default=None,
                         help='Send a warning or raise an error if the "IMPLICIT NONE" ' +
                              'is missing')
    gChecks.add_argument('--checkINTENT', choices={'Warn', 'Err'}, default=None,
                         help='Send a warning or raise an error if the "INTENT" ' +
                              'attribute is missing for a dummy argument')
    gChecks.add_argument('--checkOpInCall', choices={'Warn', 'Err'}, default=None,
                         help='Send a warning or raise an error if a call argument is an '
                              'operation.')
    gChecks.add_argument('--checkUnusedLocalVar', choices={'Warn', 'Err'}, default=None,
                         help='Send a warning or raise an error if some local '
                              'variables are unused.')
    gChecks.add_argument('--checkPHYEXUnusedLocalVar', choices={'Warn', 'Err'}, default=None,
                         help='Send a warning or raise an error if some local '
                              'variables are unused (excluding variables needed '
                              'for mnh_expand directives).')
    gChecks.add_argument('--checkEmptyParensInCall', choices={'Warn', 'Err'}, default=None,
                         help='Send a warning or raise an error if a call argument is an '
                              'array with empty parens.')
    gChecks.add_argument('--checkONLY', choices={'Warn', 'Err'}, default=None,
                         help='Send a warning or raise an error if a USE statement is not '
                              'followed by an ONLY clause.')
    gChecks.add_argument('--checkKeyDim', choices={'Warn', 'Err'}, default=None,
                         help='Send a warning or raise an error if MERGE-based array '
                              'dimensions are inconsistent across scopes.')
    gChecks.add_argument('--checkTopLevelUSE', choices={'Warn', 'Err'}, default=None,
                         help='Send a warning or raise an error if a USE statement in '
                              'top-level module is present')
 
 
def updateParserStatements(parser):
    """
    Updates an argparse parser with statements arguments
    """
 
    gStatement = parser.add_argument_group('Statements options')
    gStatement.add_argument('--removeCall', action='append',
                            help="Call to remove from the source code. The argument " +
                                 "is the subprogram name")
    gStatement.add_argument('--removePrints', default=False, action='store_true',
                            help="Remove print statements from the source code.")
    gStatement.add_argument('--inlineContainedSubroutines', default=False, action='store_true',
                            help='Inline containted subroutines in main routine')
    gStatement.add_argument('--setFalseIfStmt', default=None,
                            help='Replace this value by .FALSE. in if statements')
    gStatement.add_argument('--checkEmptyParensInMnhExpand', choices={'Warn', 'Err'}, default=None,
                            help='Send a warning or raise an error if an empty parens ' +
                                 'is found in an mnh_expand directive.')
 
 
def updateParserMisc(parser):
    """
    Updates an argparse parser with misc arguments
    """
    gMisc = parser.add_argument_group('Miscellaneous')
    gMisc.add_argument('--showScopes', default=False, action='store_true',
                       help='Show the different scopes found in the source code')
    gMisc.add_argument('--empty', default=False, action='store_true',
                       help='Empty the different scopes')
 
 
def updateParserTree(parser, withPlotCentralFile, treeIsOptional):
    """
    Updates an argparse parser with statements arguments
    :param withPlotCentralFile: to add the --plotCentralFile argumen
    :param treeIsOptional: is the --tree argument optional?
    """
    gTree = parser.add_argument_group('Tree')
    gTree.add_argument('--tree', default=None, action='append', required=not treeIsOptional,
                       help='Directories where source code must be searched for')
    gTree.add_argument('--descTree', default=None, required=not treeIsOptional,
                       help='File to write and/or read the description of the tree.')
    if withPlotCentralFile:
        gTree.add_argument('--plotCentralFile', default=None, type=str,
                           help='Central file of the plot')
    gTree.add_argument('--plotCompilTree', default=None,
                       help='File name for compilation dependency graph (.dot or image extension)')
    gTree.add_argument('--plotExecTree', default=None,
                       help='File name for execution dependency graph (.dot or image extension)')
    gTree.add_argument('--plotMaxUpper', default=None, type=int,
                       help='Maximum number of upper elements in the plot tree')
    gTree.add_argument('--plotMaxLower', default=None, type=int,
                       help='Maximum number of lower elements in the plot tree')
    gTree.add_argument('--stopScopes', default=None, type=str,
                       help='#-separated list of scopes ' +
                            'where the recursive inclusion of an argument variable ' +
                            'must stop (needed for some transformations).')
 
 
def updateParserPreprocessor(parser):
    """
    Updates an argparse parser with statements arguments
    """
    gCpp = parser.add_argument_group('Preprocessor')
    gCpp.add_argument('--applyCPPifdef', nargs='*', action='append',
                      help="This option is followed by the list of defined or undefined " +
                           "CPP keys. " +
                           "All #ifdef and #ifndef concerning these keys are evaluated. " +
                           "Undefined keys are preceded by a percentage sign.")
 
 
def applyTransfo(pft, arg, args, plotCentralFile):
    """
    Apply transformation on a PYFT instance
    :param pft: PYFT instance
    :param arg: argument to deal with
    :param args: parsed argparsed arguments
    :param plotCentralFile: central file for plots
    """
    simplify = {'simplify': args.simplify}
    parserOptions = getParserOptions(args)
    stopScopes = args.stopScopes.split('#') if args.stopScopes is not None else None
 
    # File name manipulations
    applyTransfoFileName(pft, arg)
 
    # Variables
    applyTransfoVariables(pft, arg, args, simplify, parserOptions, stopScopes)
 
    # Applications
    applyTransfoApplications(pft, arg, args, simplify, parserOptions, stopScopes)
 
    # OpenACC
    applyTransfoOpenACC(pft, arg, args, stopScopes)
 
    # Cosmetics
    applyTransfoCosmetics(pft, arg, args)
 
    # Checks
    applyTransfoChecks(pft, arg, args, stopScopes)
 
    # Statements
    applyTransfoStatements(pft, arg, args, simplify)
 
    # Misc
    applyTransfoMisc(pft, arg, args, simplify)
 
    # Tree
    applyTransfoTree(pft, arg, args, plotCentralFile)
 
    # Preprocessor
    applyTransfoPreprocessor(pft, arg, args)
 
 
def applyTransfoFileName(pft, arg):
    """
    Apply file name transformations on a PYFT instance
    :param pft: PYFT instance
    :param arg: argument to deal with
    :param args: parsed argparsed arguments
    """
 
    # File name manipulations
    if arg == '--renamefF':
        pft.renameUpper()
    elif arg == '--renameFf':
        pft.renameLower()
 
 
def applyTransfoVariables(pft, arg, args, simplify, parserOptions, stopScopes):
    """
    Apply variables transformations on a PYFT instance
    :param pft: PYFT instance
    :param arg: argument to deal with
    :param args: parsed argparsed arguments
    :param simplify: kwargs to simplify
    :param parserOptions: fxtran parser options
    :param stopScopes: upper limit in call tree for some transformations
    """
    if arg == '--showVariables':
        pft.varList.showVarList()
    elif arg == '--attachArraySpecToEntity':
        pft.attachArraySpecToEntity()
    elif arg == '--removeVariable':
        pft.removeVar(args.removeVariable, **simplify)
    elif arg == '--addVariable':
        pft.addVar([[v[0], v[1], v[2], (int(v[3]) if isint(v[3]) else None)]
                    for v in args.addVariable])
    elif arg == '--addModuleVariable':
        pft.addModuleVar([[v[0], v[1], v[2]] for v in args.addModuleVariable])
    elif arg == '--showUnusedVariables':
        pft.showUnusedVar()
    elif arg == '--removeUnusedLocalVariables':
        pft.removeUnusedLocalVar(
            [item.strip() for item in args.removeUnusedLocalVariables.split(',')]
            if args.removeUnusedLocalVariables != 'NONE' else None, **simplify)
    elif arg == '--removePHYEXUnusedLocalVariables':
        pft.removePHYEXUnusedLocalVar(
            [item.strip() for item in args.removePHYEXUnusedLocalVariables.split(',')]
            if args.removePHYEXUnusedLocalVariables != 'NONE' else None, **simplify)
    elif arg == '--addExplicitArrayBounds':
        pft.addExplicitArrayBounds()
    elif arg == '--addArrayParentheses':
        pft.addArrayParentheses()
    elif arg == '--modifyAutomaticArrays':
        pft.modifyAutomaticArrays(*(args.modifyAutomaticArrays.split('#')))
    elif arg == '--replaceAutomaticWithAllocatable':
        pft.modifyAutomaticArrays(
            "{type}, DIMENSION({doubledotshape}), ALLOCATABLE :: {name}",
            "ALLOCATE({name}({shape}))", "DEALLOCATE({name})")
    elif arg == '--addArgInTree':
        for varName, declStmt, pos in args.addArgInTree:
            pft.addArgInTree(varName, declStmt, int(pos), stopScopes,
                             parserOptions=parserOptions,
                             wrapH=args.wrapH)
    elif arg == '--addONLY':
        pft.addONLY(parserOptions=parserOptions, wrapH=args.wrapH)
 
 
def applyTransfoApplications(pft, arg, args, simplify, parserOptions, stopScopes):
    """
    Apply applications transformations on a PYFT instance
    :param pft: PYFT instance
    :param arg: argument to deal with
    :param args: parsed argparsed arguments
    :param simplify: kwargs to simplify
    :param parserOptions: fxtran parser options
    :param stopScopes: upper limit in call tree for some transformations
    """
    if arg == '--addStack':
        pft.addStack(args.addStack, stopScopes,
                     parserOptions=parserOptions,
                     wrapH=args.wrapH)
    elif arg == '--deleteDrHook':
        pft.deleteDrHook(**simplify)
    elif arg == '--addDrHook':
        pft.addDrHook()
    elif arg == '--deleteBudgetDDH':
        pft.deleteBudgetDDH(**simplify)
    elif arg == '--deleteRoutineCallsMesoNHGPU':
        pft.deleteRoutineCallsMesoNHGPU(**simplify)
    elif arg == '--deleteNonColumnCallsPHYEX':
        pft.deleteNonColumnCallsPHYEX(**simplify)
    elif arg == '--addMPPDB_CHECKS':
        pft.addMPPDB_CHECKS()
    elif arg == '--addPrints':
        pft.addMPPDB_CHECKS(printsMode=True)
    elif arg == '--addSubmodulePHYEX':
        pft.addSubmodulePHYEX()
    # mnhExpand must be before inlineContainedSubroutines as inlineContainedSubroutines
    # can change variable names used by mnh_expand directives
    assert not (args.mnhExpand and args.mnhExpandConcurrent), \
        "Only one of --mnhExpand and --mnhExpandConcurrent"
    if arg == '--mnhExpand':
        pft.removeArraySyntax(everywhere=False, addAccIndependentCollapse=False)
    elif arg == '--mnhExpandConcurrent':
        pft.removeArraySyntax(concurrent=True, everywhere=False)
    elif arg == '--inlineContainedSubroutines':
        pft.inlineContainedSubroutines(**simplify)
    elif arg == '--inlineContainedSubroutinesPHYEX':
        pft.inlineContainedSubroutinesPHYEX(**simplify)
    elif arg == '--expandAllArrays':
        pft.removeArraySyntax()
    elif arg == '--expandAllArraysConcurrent':
        pft.removeArraySyntax(concurrent=True)
    elif arg == '--expandAllArraysPHYEX':
        pft.expandAllArraysPHYEX()
    elif arg == '--expandAllArraysPHYEXConcurrent':
        pft.expandAllArraysPHYEX(concurrent=True)
    elif arg == '--removeIJDim':
        pft.removeIJDim(stopScopes,
                        parserOptions=parserOptions,
                        wrapH=args.wrapH, **simplify)
    elif arg == '--shumanFUNCtoCALL':
        pft.shumanFUNCtoCALL()
    elif arg == '--shugradTransfo':
        pft.shugradTransfo()
    elif arg == '--buildACCTypeHelpers':
        pft.buildACCTypeHelpers()
    elif arg == '--mathFunctoBRFunc':
        pft.mathFunctoBRFunc()
    elif arg == '--convertTypesInCompute':
        pft.convertTypesInCompute()
    elif arg == '--buildModi':
        pft.buildModi()
    elif arg == '--splitModuleRoutineFile':
        pft.splitModuleRoutineFile()
    elif arg == '--removeExtraDOinMnhDoConcurrent':
        pft.removeExtraDOinMnhDoConcurrent()
    elif arg == '--convertuseModuleToIncludes':
        pft.convertuseModuleToIncludes()
 
 
def applyTransfoOpenACC(pft, arg, args, stopScopes):  # pylint: disable=unused-argument
    """
    Apply openACC transformations on a PYFT instance
    :param pft: PYFT instance
    :param arg: argument to deal with
    :param args: parsed argparsed arguments
    :param stopScopes: upper limit in call tree for some transformations
    """
    if arg == '--addACCData':
        pft.addACCData()
    elif arg == '--craybyPassDOCONCURRENT':
        pft.craybyPassDOCONCURRENT()
    elif arg == '--removebyPassDOCONCURRENT':
        pft.removebyPassDOCONCURRENT()
    elif arg == '--addACCRoutineSeq':
        pft.addACCRoutineSeq(stopScopes)
    elif arg == '--removeACC':
        pft.removeACC()
    elif arg == '--allocatetoHIP':
        pft.allocatetoHIP()
 
 
def applyTransfoCosmetics(pft, arg, args):
    """
    Apply cosmetics transformations on a PYFT instance
    :param pft: PYFT instance
    :param arg: argument to deal with
    :param args: parsed argparsed arguments
    """
    if arg == '--upperCase':
        pft.upperCase()
    elif arg == '--lowerCase':
        pft.lowerCase()
    elif arg == '--changeIfStatementsInIfConstructs':
        pft.changeIfStatementsInIfConstructs()
    elif arg == '--indent':
        pft.indent()
    elif arg == '--removeIndent':
        pft.indent(indentProgramunit=0, indentBranch=0)
    elif arg == '--removeEmptyLines':
        pft.removeEmptyLines()
    elif arg == '--removeComments':
        pft.removeComments()
    elif arg == '--updateSpaces':
        pft.updateSpaces()
    elif arg in ARG_UPDATE_CNT:
        pft.updateContinuation(align=args.alignContinuation,
                               addBegin=args.addBeginContinuation,
                               removeBegin=args.removeBeginContinuation,
                               removeALL=args.removeALLContinuation)
    elif arg == '--prettify':
        pft.indent()
        pft.upperCase()
        pft.removeEmptyLines()
        pft.updateSpaces()
        pft.updateContinuation()
    elif arg == '--minify':
        pft.indent(indentProgramunit=0, indentBranch=0)
        pft.upperCase()
        pft.removeComments()
        pft.removeEmptyLines()
        pft.updateSpaces()
        pft.updateContinuation(align=False, removeALL=True, addBegin=False)
    elif arg == '--removeEmptyCONTAINS':
        pft.removeEmptyCONTAINS()
    elif arg == '--formatModuleUse':
        pft.formatModuleUse()
 
 
def applyTransfoChecks(pft, arg, args, stopScopes):
    """
    Apply checks transformations on a PYFT instance
    :param pft: PYFT instance
    :param arg: argument to deal with
    :param args: parsed argparsed arguments
    :param stopScopes: list of scope paths or None
    """
    if arg == '--checkIMPLICIT':
        pft.checkImplicitNone(args.checkIMPLICIT == 'Err')
    elif arg == '--checkINTENT':
        pft.checkIntent(args.checkINTENT == 'Err')
    elif arg == '--checkOpInCall':
        pft.checkOpInCall(args.checkOpInCall == 'Err')
    elif arg == '--checkUnusedLocalVar':
        pft.checkUnusedLocalVar(args.checkUnusedLocalVar == 'Err')
    elif arg == '--checkPHYEXUnusedLocalVar':
        pft.checkPHYEXUnusedLocalVar(args.checkPHYEXUnusedLocalVar == 'Err')
    elif arg == '--checkEmptyParensInCall':
        pft.checkEmptyParensInCall(args.checkEmptyParensInCall == 'Err')
    elif arg == '--checkONLY':
        pft.checkONLY(args.checkONLY == 'Err')
    elif arg == '--checkKeyDim':
        pft.checkKeyDimConsistency(args.checkKeyDim == 'Err',
                                   stopScopes=stopScopes)
    elif arg == '--checkTopLevelUSE':
        pft.checkTopLevelUSE(args.checkTopLevelUSE == 'Err')
    elif arg == '--checkEmptyParensInMnhExpand':
        pft.checkEmptyParensInMnhExpand(args.checkEmptyParensInMnhExpand == 'Err')
 
 
def applyTransfoStatements(pft, arg, args, simplify):
    """
    Apply statements transformations on a PYFT instance
    :param pft: PYFT instance
    :param arg: argument to deal with
    :param args: parsed argparsed arguments
    :param simplify: kwargs to simplify
    """
    if arg == '--removeCall':
        for rc in args.removeCall:
            pft.removeCall(rc, **simplify)
    elif arg == '--removePrints':
        pft.removePrints(**simplify)
    elif arg == '--setFalseIfStmt':
        pft.setFalseIfStmt(args.setFalseIfStmt, **simplify)
 
 
def applyTransfoMisc(pft, arg, args, simplify):  # pylint: disable=unused-argument
    """
    Apply misc transformations on a PYFT instance
    :param pft: PYFT instance
    :param arg: argument to deal with
    :param args: parsed argparsed arguments
    :param simplify: kwargs to simplify
    """
    if arg == '--showScopes':
        pft.showScopesList()
    elif arg == '--empty':
        pft.empty(**simplify)
 
 
def applyTransfoTree(pft, arg, args, plotCentralFile):
    """
    Apply tree transformations on a PYFT instance
    :param pft: PYFT instance
    :param arg: argument to deal with
    :param args: parsed argparsed arguments
    :param plotCentralFile: central file for plots
    """
    if arg == '--plotCompilTree' and plotCentralFile is not None:
        pft.tree.plotCompilTreeFromFile(plotCentralFile, args.plotCompilTree,
                                        args.plotMaxUpper, args.plotMaxLower)
    elif arg == '--plotExecTree' and plotCentralFile is not None:
        pft.tree.plotExecTreeFromFile(plotCentralFile, args.plotExecTree,
                                      args.plotMaxUpper, args.plotMaxLower)
 
 
def applyTransfoPreprocessor(pft, arg, args):
    """
    Apply preprocessor transformations on a PYFT instance
    :param pft: PYFT instance
    :param arg: argument to deal with
    :param args: parsed argparsed arguments
    """
    if arg == '--applyCPPifdef':
        pft.applyCPPifdef([k for aList in args.applyCPPifdef for k in aList])
 
 
if __name__ == "__main__":
    main()