def test_long_lines_false(): ''' Tests that the long_lines method returns false with fortran input which has all lines shorter than the specified maximum''' input_string = ("! line1\n" "! " + "line2" * 5 + "\n" + "! line3\n") fll = FortLineLength(line_length=30) assert not fll.long_lines(input_string),\ "long_lines_false test should return False"
def test_long_lines_true(): ''' Tests that the long_lines method returns true with fortran input which has at least one line longer than the specified maximum''' input_string = ("! line1\n" "! " + "line2" * 6 + "\n" "! line3\n") fll = FortLineLength(line_length=30) assert fll.long_lines(input_string),\ "long_lines_true test should return True"
def check_line_length(filename): '''Check that the code contained within the filename file conforms to the 132 line length limit. :param str filename: The file containing the code. :raises InternalError: if the specified file can not be opened or read. :raises ParseError: if one of more lines are longer than the 132 \ line length limit. ''' fll = FortLineLength() try: with io.open(filename, "r", encoding='utf8') as myfile: code_str = myfile.read() except IOError as excinfo: raise InternalError("In utils.py:check_line_length: {0}".format( str(excinfo))) if fll.long_lines(code_str): raise ParseError("the file does not conform to the specified {0} line " "length limit".format(str(fll.length)))
def parse(alg_filename, api="", invoke_name="invoke", inf_name="inf", kernel_path="", line_length=False, distributed_memory=config.DISTRIBUTED_MEMORY): '''Takes a GungHo algorithm specification as input and outputs an AST of this specification and an object containing information about the invocation calls in the algorithm specification and any associated kernel implementations. :param str alg_filename: The file containing the algorithm specification. :param str invoke_name: The expected name of the invocation calls in the algorithm specification :param str inf_name: The expected module name of any required infrastructure routines. :param str kernel_path: The path to search for kernel source files (if different from the location of the algorithm source). :param bool line_length: A logical flag specifying whether we care about line lengths being longer than 132 characters. If so, the input (algorithm and kernel) code is checked to make sure that it conforms and an error raised if not. The default is False. :rtype: ast,invoke_info :raises IOError: if the filename or search path does not exist :raises ParseError: if there is an error in the parsing :raises RuntimeError: if there is an error in the parsing For example: >>> from parse import parse >>> ast,info=parse("argspec.F90") ''' if distributed_memory not in [True, False]: raise ParseError( "The distributed_memory flag in parse() must be set to" " 'True' or 'False'") config.DISTRIBUTED_MEMORY = distributed_memory if api == "": from psyclone.config import DEFAULTAPI api = DEFAULTAPI else: check_api(api) # Get the names of the supported Built-in operations for this API builtin_names, builtin_defs_file = get_builtin_defs(api) # drop cache fparser1.parsefortran.FortranParser.cache.clear() fparser.logging.disable('CRITICAL') if not os.path.isfile(alg_filename): raise IOError("File %s not found" % alg_filename) try: ast = fpapi.parse(alg_filename, ignore_comments=False, analyze=False) # ast includes an extra comment line which contains file # details. This line can be long which can cause line length # issues. Therefore set the information (name) to be empty. ast.name = "" except: import traceback traceback.print_exc() raise ParseError("Fatal error in external fparser tool") if line_length: fll = FortLineLength() with open(alg_filename, "r") as myfile: code_str = myfile.read() if fll.long_lines(code_str): raise ParseError( "parse: the algorithm file does not conform to the specified" " {0} line length limit".format(str(fll.length))) name_to_module = {} try: from collections import OrderedDict except: try: from ordereddict import OrderedDict except: import sys python_version = sys.version_info if python_version[0] <= 2 and python_version[1] < 7: raise ParseError( "OrderedDict not provided natively pre python 2.7 " "(you are running {0}. Try installing with 'sudo " "pip install ordereddict'".format(python_version)) else: raise ParseError( "OrderedDict not found which is unexpected as it is " "meant to be part of the Python library from 2.7 onwards") invokecalls = OrderedDict() # Keep a list of the named invokes so that we can check that the same # name isn't used more than once unique_invoke_labels = [] container_name = None for child in ast.content: if isinstance(child, fparser1.block_statements.Program) or \ isinstance(child, fparser1.block_statements.Module) or \ isinstance(child, fparser1.block_statements.Subroutine): container_name = child.name break if container_name is None: raise ParseError( "Error, program, module or subroutine not found in ast") for statement, depth in fpapi.walk(ast, -1): if isinstance(statement, fparser1.statements.Use): for name in statement.items: name_to_module[name] = statement.name if isinstance(statement, fparser1.statements.Call) \ and statement.designator == invoke_name: statement_kcalls = [] invoke_label = None for arg in statement.items: # We expect each item in an invoke call to be either a # call to a kernel or the name of the invoke (specifed # as name="my_name") try: parsed = expr.FORT_EXPRESSION.parseString(arg)[0] except ParseException: raise ParseError("Failed to parse string: {0}".format(arg)) if isinstance(parsed, expr.NamedArg): if parsed.name.lower() != "name": raise ParseError( "The arguments to an invoke() must be either " "kernel calls or an (optional) name='invoke-name' " "but got '{0}' in file {1}".format( str(parsed), alg_filename)) if invoke_label: raise ParseError( "An invoke must contain one or zero 'name=xxx' " "arguments but found more than one in: {0} in " "file {1}".format(str(statement), alg_filename)) if not parsed.is_string: raise ParseError( "The (optional) name of an invoke must be " "specified as a string but got {0} in file {1}.". format(str(parsed), alg_filename)) # Store the supplied label. Use lower-case (as Fortran # is case insensitive) invoke_label = parsed.value.lower() # Remove any spaces. # TODO check with LFRic team - should we raise an error if # it contains spaces? invoke_label = invoke_label.replace(" ", "_") # Check that the resulting label is a valid Fortran Name from fparser.two import pattern_tools if not pattern_tools.abs_name.match(invoke_label): raise ParseError( "The (optional) name of an invoke must be a " "string containing a valid Fortran name (with " "any spaces replaced by underscores) but " "got '{0}' in file {1}".format( invoke_label, alg_filename)) # Check that it's not already been used in this Algorithm if invoke_label in unique_invoke_labels: raise ParseError( "Found multiple named invoke()'s with the same " "name ('{0}') when parsing {1}".format( invoke_label, alg_filename)) unique_invoke_labels.append(invoke_label) # Continue parsing the other arguments to this invoke call continue argname = parsed.name argargs = [] for a in parsed.args: if type(a) is str: # a literal is being passed by argument argargs.append(Arg('literal', a)) else: # assume argument parsed as a FunctionVar variableName = a.name if a.args is not None: # argument is an indexed array so extract the # full text fullText = "" for tok in a.walk_skipping_name(): fullText += str(tok) argargs.append( Arg('indexed_variable', fullText, variableName)) else: # argument is a standard variable argargs.append( Arg('variable', variableName, variableName)) if argname in builtin_names: if argname in name_to_module: raise ParseError("A built-in cannot be named in a use " "statement but '{0}' is used from " "module '{1}' in file {2}".format( argname, name_to_module[argname], alg_filename)) # this is a call to a built-in operation. The # KernelTypeFactory will generate appropriate meta-data statement_kcalls.append( BuiltInCall( BuiltInKernelTypeFactory(api=api).create( builtin_names, builtin_defs_file, name=argname), argargs)) else: try: modulename = name_to_module[argname] except KeyError: raise ParseError( "kernel call '{0}' must either be named in a use " "statement or be a recognised built-in " "(one of '{1}' for this API)".format( argname, builtin_names)) # Search for the file containing the kernel source import fnmatch # We only consider files with the suffixes .f90 and .F90 # when searching for the kernel source. search_string = "{0}.[fF]90".format(modulename) # Our list of matching files (should have length == 1) matches = [] # If a search path has been specified then we look there. # Otherwise we look in the directory containing the # algorithm definition file if len(kernel_path) > 0: cdir = os.path.abspath(kernel_path) if not os.access(cdir, os.R_OK): raise IOError( "Supplied kernel search path does not exist " "or cannot be read: {0}".format(cdir)) # We recursively search down through the directory # tree starting at the specified path if os.path.exists(cdir): for root, dirnames, filenames in os.walk(cdir): for filename in fnmatch.filter( filenames, search_string): matches.append(os.path.join( root, filename)) else: # We look *only* in the directory that contained the # algorithm file cdir = os.path.abspath(os.path.dirname(alg_filename)) filenames = os.listdir(cdir) for filename in fnmatch.filter(filenames, search_string): matches.append(os.path.join(cdir, filename)) # Check that we only found one match if len(matches) != 1: if len(matches) == 0: raise IOError( "Kernel file '{0}.[fF]90' not found in {1}". format(modulename, cdir)) else: raise IOError( "More than one match for kernel file " "'{0}.[fF]90' found!".format(modulename)) else: try: modast = fpapi.parse(matches[0]) # ast includes an extra comment line which # contains file details. This line can be # long which can cause line length # issues. Therefore set the information # (name) to be empty. modast.name = "" except: raise ParseError( "Failed to parse kernel code " "'{0}'. Is the Fortran correct?".format( matches[0])) if line_length: fll = FortLineLength() with open(matches[0], "r") as myfile: code_str = myfile.read() if fll.long_lines(code_str): raise ParseError( "parse: the kernel file '{0}' does not" " conform to the specified {1} line length" " limit".format(modulename, str(fll.length))) statement_kcalls.append( KernelCall( modulename, KernelTypeFactory(api=api).create(modast, name=argname), argargs)) invokecalls[statement] = InvokeCall(statement_kcalls, name=invoke_label) return ast, FileInfo(container_name, invokecalls)