lizard 1.17.13__py2.py3-none-any.whl → 1.17.15__py2.py3-none-any.whl

{lizard-1.17.13.dist-info → lizard-1.17.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.13
+Version: 1.17.15
 Summary: A code analyzer without caring the C/C++ header files. It works with Java, C/C++, JavaScript, Python, Ruby, Swift, Objective C. Metrics includes cyclomatic complexity number etc.
 Home-page: http://www.lizard.ws
 Download-URL: https://pypi.python.org/lizard/
@@ -53,7 +53,8 @@ A list of supported languages:
 -  Java
 -  C# (C Sharp)
 -  JavaScript (With ES6 and JSX)
--  TypeScript
+-  TypeScript (With TSX)
+-  VueJS
 -  Objective-C
 -  Swift
 -  Python
@@ -69,6 +70,7 @@ A list of supported languages:
 -  Kotlin
 -  Solidity
 -  Erlang
+-  Zig
 
 By default lizard will search for any source code that it knows and mix
 all the results together. This might not be what you want. You can use
@@ -386,5 +388,3 @@ Lizard is also used as a plugin for fastlane to help check code complexity and s
 - `European research project FASTEN (Fine-grained Analysis of SofTware Ecosystems as Networks, <http://fasten-project.eu/)>`_
   - `for a quality analyzer <https://github.com/fasten-project/quality-analyzer>`_
 
-
-

{lizard-1.17.13.dist-info → lizard-1.17.15.dist-info}/RECORD

@@ -1,7 +1,7 @@
-lizard.py,sha256=KR3F6F-5GzGQP0GLxjWmpRRUsLbfL-Lthtz3jWLlyPY,38576
+lizard.py,sha256=F6eF_WT_arglGadw__oqYk_NMgEVk-8idmybIrtd2OE,38568
 lizard_ext/__init__.py,sha256=Cz0pvH6QHyadK-rAeeEhQVsm0hW5M-fBQgV4FBaX9zk,500
 lizard_ext/auto_open.py,sha256=byD_RbeVhvSUhR2bJMRitvA3zcKEapFwv0-XaDJ6GFo,1096
-lizard_ext/csvoutput.py,sha256=IGTGICiK_IJcldRGDhd_jNDohxFWJEWYOVxkemaY20Q,3051
+lizard_ext/csvoutput.py,sha256=43fhmo8kB85qcdujCwySGNuTC4FkKUPLqIApPeljPnA,2663
 lizard_ext/default_ordered_dict.py,sha256=YbVz6nPlQ6DjWc_EOFBz6AJN2XLo9dpnUdeyejQvUDE,831
 lizard_ext/extension_base.py,sha256=rnjUL2mqSGToUVYydju7fa8ZwynLPY8S1F17gIJP55I,346
 lizard_ext/htmloutput.py,sha256=oavhEzCIJtoJrFveiWIp0pMAOwg4pukJ6l07IpmPiag,4426
@@ -25,39 +25,43 @@ lizard_ext/lizardns.py,sha256=8pztUoRS_UWN24MawwxeHEJgYh49id5PWODUBb6O72U,4184
 lizard_ext/lizardoutside.py,sha256=FGm2tbBZ17-2OCgmQlD-vobUCfQKb0FAygf86eM3xuM,336
 lizard_ext/lizardstatementcount.py,sha256=xYk6ixSIItSE1BWQXzrWmduFgGhA3VR817SNKLffyVQ,1182
 lizard_ext/lizardwordcount.py,sha256=2QYXD7-AtkkgAbi9VSidunMbSsGQ7MKYb6IT-bS-cok,7575
-lizard_ext/version.py,sha256=cV8SELFV7_EfiIev7wFOD2wke6gb9on99S4p_3CSUAc,182
+lizard_ext/version.py,sha256=bEnVphLi5lD3nsGDAkiBaNX1JY-mQDoiFcSVF8rk7zc,182
 lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
-lizard_languages/__init__.py,sha256=iIbCcjN1AzmVtqCB7caRcLWQ4CdQwyT0UAiRKCkVeL0,1273
-lizard_languages/clike.py,sha256=YgB0dHYdQ5Ae1pN00zcstkuXl94n8Ugo-aTYUNmJr7o,10723
-lizard_languages/code_reader.py,sha256=95_juW_8vcTShV_BoWNmBiz5CmCk59VxRi0QWF67Bsw,6164
+lizard_languages/__init__.py,sha256=2mvrPWMJVCq981kMjoAPEi2O07C8vo-vUWOG_wp7vKQ,1473
+lizard_languages/clike.py,sha256=Lnwkma-jEu8FNVEPqTAKPkz1Hi0T_dP7H9Jyq0Bd0kQ,10725
+lizard_languages/code_reader.py,sha256=P0PkE4QZBWOEj6cFHA4hj3hcLZLcGnqH31EmtltxlaE,6240
 lizard_languages/csharp.py,sha256=lVi-g-0JjHagqDR5r-lRdi2BuCdtR5aer9CYY-Nzw44,478
-lizard_languages/erlang.py,sha256=AaPfIGq_phVi2hRUVHNrrmXiQSdlEktbSVOvPxORWf8,3822
-lizard_languages/fortran.py,sha256=iXxS44sNJ2_h-nvJC58Pz6AGDyVx2HdBEVF-EeYGn84,7327
+lizard_languages/erlang.py,sha256=7YJS2cMyXDKEV_kpH8DzBARxFCFcjKuTOPSQ3K52auU,3860
+lizard_languages/fortran.py,sha256=KATDsnfjob5W3579A_VxbwrbTkK7Rx3p0eXdBgjx25I,8973
 lizard_languages/gdscript.py,sha256=KwlGoODilQnFgXvODpq_XlA6fV3hGbN9fd7bsiEUn78,637
 lizard_languages/go.py,sha256=dSbWxtWve7KSRW5i9w4DxhODtJ72EcBNrgp-7Xhn0Sg,465
 lizard_languages/golike.py,sha256=vRIfjTVvc0VmJf27lTOLht55ZF1AQ9wn0Fvu-9WabWk,2858
 lizard_languages/java.py,sha256=mfXCRicmZFZFxPW7QuTOQtAKzOZD3d-uh4tiALcGdX4,1186
-lizard_languages/javascript.py,sha256=agcEwJbrY0tFt8rGWwsO2pH-MKXvKmt9BMlcKkUB9m4,4314
-lizard_languages/js_style_language_states.py,sha256=2_dgrXLe113xEdfATByioohGquW428pPo9gI3I1duS4,4257
-lizard_languages/js_style_regex_expression.py,sha256=1d4eK5RR0GBAFg2eDb2cKA_YHIYlxjhG7PXAuMOKnRA,743
+lizard_languages/javascript.py,sha256=sGZeTqFqCjcl87ncR-Rmj-HTp-4s4ptoTMxeDgc8Jvw,522
+lizard_languages/js_style_language_states.py,sha256=Ie0eA15rd0gfahdNzUlSkQa-o_j5idTIB82JU32c378,4165
+lizard_languages/js_style_regex_expression.py,sha256=Xgyogch4xElYtCG4EnBKvalHTl3tjRPcIIcIQRRd61I,1970
+lizard_languages/jsx.py,sha256=tNoGFQ9hap2yS5NjRPgxMRlYZY-k5Gn07yI0o815Ghk,3566
 lizard_languages/kotlin.py,sha256=v_o2orEzA5gB9vM_0h-E4QXjrc5Yum-0K6W6_laOThc,2844
 lizard_languages/lua.py,sha256=3nqBcunBzJrhv4Iqaf8xvbyqxZy3aSxJ-IiHimHFlac,1573
 lizard_languages/objc.py,sha256=2a1teLdaXZBtCeFiIZer1j_sVx9LZ1CbF2XfnqlvLmk,2319
 lizard_languages/php.py,sha256=8OufyR2TIWyf3bXuTmp37Vwf_tEPF4YV5M3i5_jnguA,1377
-lizard_languages/python.py,sha256=JDXqQ7SEnNSXlbK5sMyUKwCFBTEto20Wg8_ZkzYisSI,3721
+lizard_languages/python.py,sha256=5MwhyuzUqbUkhNyzeo_YsTRp4onMUVC19t61lLnDyjc,3761
 lizard_languages/ruby.py,sha256=gUrFsaS6ZJbjb9CixBHP9n0BxGOb8HsDEg7jJ2bz_80,2187
 lizard_languages/rubylike.py,sha256=dAGZ2wqW8nqaESMU8HkeR9gwQ-q9fmZqE6AANvVZD1Q,3426
 lizard_languages/rust.py,sha256=DG2RkR9JWwcD6gIw-BPzg-Yo_lxQtSvfgHioFWIQm9o,610
 lizard_languages/scala.py,sha256=6Jr_TG945VYqB3o5weD7jN7S4beHt4aVj3r-fmKeMAM,1316
-lizard_languages/script_language.py,sha256=FOzB9Rg5-XTnFDeeRRyIrp2rDomRDHhaPsxsxeCx9GU,539
+lizard_languages/script_language.py,sha256=UUO3Wjkoa-ZqwwvcwvhOr5tg1rVavcrEYx3dNdoYSBc,531
 lizard_languages/solidity.py,sha256=Z0GD7U5bI5eUikdy7m_iKWeFD5yXRYq4r3zycscOhJQ,553
 lizard_languages/swift.py,sha256=p8S2OAkQOx9YQ02yhoVXFkr7pMqUH1Nb3RVXPHRU_9M,2450
 lizard_languages/tnsdl.py,sha256=pGcalA_lHY362v2wwPS86seYBOOBBjvmU6vd4Yy3A9g,2803
+lizard_languages/tsx.py,sha256=aTxmM_-u-R-pRVXRVyITJxrrFZfCeMe9kxMgaoL-qfk,706
 lizard_languages/ttcn.py,sha256=ygjw_raBmPF-4mgoM8m6CAdyEMpTI-n1kZJK1RL4Vxo,2131
-lizard_languages/typescript.py,sha256=yjUTVDkiONbg2v089pZC4wrCJSo1J5NVbQzbCfF4k6s,1547
-lizard-1.17.13.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
-lizard-1.17.13.dist-info/METADATA,sha256=XwvrQB7WJSc664t-xQovyEcKuufzKizZCnyUPSTowq8,15403
-lizard-1.17.13.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
-lizard-1.17.13.dist-info/entry_points.txt,sha256=pPMMwoHAltzGHqR2WeJQItLeeyR7pbX5R2S_POC-xoo,40
-lizard-1.17.13.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
-lizard-1.17.13.dist-info/RECORD,,
+lizard_languages/typescript.py,sha256=c_Kez4pOGMXhdo6q3HT-clEJDP7LuRIbBkkJSipComU,3568
+lizard_languages/vue.py,sha256=KXUBUo2R1zNF8Pffrz_KsQEN44m5XFRMoGXylxKUeT0,1038
+lizard_languages/zig.py,sha256=NX1iyBstBuJFeAGBOAIaRfrmeBREne2HX6Pt4fXZZTQ,586
+lizard-1.17.15.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
+lizard-1.17.15.dist-info/METADATA,sha256=P5tZ8sJtxBdTVX6qYePWJc_NuXcA7QI3yp4gomL0lgA,15428
+lizard-1.17.15.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
+lizard-1.17.15.dist-info/entry_points.txt,sha256=ZBqPhu-J3NoGGW5vn2Gfyoo0vdVlgBgM-wlNm0SGYUQ,39
+lizard-1.17.15.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
+lizard-1.17.15.dist-info/RECORD,,

{lizard-1.17.13.dist-info → lizard-1.17.15.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.44.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

{lizard-1.17.13.dist-info → lizard-1.17.15.dist-info}/entry_points.txt

@@ -1,3 +1,2 @@
 [console_scripts]
 lizard = lizard:main
-

lizard.py

@@ -298,8 +298,7 @@ class FunctionInfo(Nesting):  # pylint: disable=R0902
         return self.name.split('::')[-1]
 
     location = property(lambda self:
-                        " %(name)s@%(start_line)s-%(end_line)s@%(filename)s"
-                        % self.__dict__)
+                        f" {self.name}@{self.start_line}-{self.end_line}@{self.filename}")
 
     parameter_count = property(lambda self: len(self.parameters))
 
@@ -572,7 +571,9 @@ class FileAnalyzer(object):  # pylint: disable=R0903
             for _ in reader(tokens, reader):
                 pass
         except RecursionError as e:
-            sys.stderr.write("[skip] fail to process '%s' with RecursionError - %s\n" % (filename, e))
+            sys.stderr.write(
+                "[skip] fail to process '%s' with RecursionError - %s\n" %
+                (filename, e))
         return context.fileinfo
 
 
@@ -721,17 +722,13 @@ class OutputScheme(object):
             if e.get("avg_caption", None)])
 
     def clang_warning_format(self):
-        return (
-            "{f.filename}:{f.start_line}: warning: {f.name} has " +
-            ", ".join([
-                "{{f.{ext[value]}}} {caption}"
-                .format(ext=e, caption=e['caption'].strip())
-                for e in self.items[:-1]
-                ]))
+        return ("{f.filename}:{f.start_line}: warning: {f.name} has {f.nloc} NLOC, "
+                "{f.cyclomatic_complexity} CCN, {f.token_count} token, {f.parameter_count} PARAM, "
+                "{f.length} length, {f.max_nesting_depth} ND")
 
     def msvs_warning_format(self):
         return (
-            "{f.filename}({f.start_line}): warning: {f.name} has " +
+            "{f.filename}({f.start_line}): warning: {f.name} ({f.long_name}) has " +
             ", ".join([
                 "{{f.{ext[value]}}} {caption}"
                 .format(ext=e, caption=e['caption'].strip())

lizard_ext/csvoutput.py

@@ -36,9 +36,9 @@ def csv_output(result, options):
     if options.verbose:
         extension_caption = ""
         for caption in extension_captions:
-            extension_caption = "{},{}".format(extension_caption, caption)
-        print("NLOC,CCN,token,PARAM,length,location,file,function," +
-              "long_name,start,end{}".format(extension_caption))
+            extension_caption = f"{extension_caption},{caption}"
+        print(f"NLOC,CCN,token,PARAM,length,location,file,function," +
+              f"long_name,start,end{extension_caption}")
 
     for source_file in result:
         if source_file:
@@ -46,25 +46,11 @@ def csv_output(result, options):
                 if source_function:
                     extension_string = ''
                     for variable in extension_variables:
-                        extension_string = '{},{}'.\
-                            format(extension_string,
-                                   source_function.__getattribute__(variable))
-                    print('{},{},{},{},{},"{}","{}","{}","{}",{},{}{}'.format(
-                        source_function.nloc,
-                        source_function.cyclomatic_complexity,
-                        source_function.token_count,
-                        len(source_function.parameters),
-                        source_function.length,
-                        "{}@{}-{}@{}".format(
-                            source_function.name.replace("\"", "'"),
-                            source_function.start_line,
-                            source_function.end_line,
-                            source_file.filename
-                        ),
-                        source_file.filename,
-                        source_function.name.replace("\"", "'"),
-                        source_function.long_name.replace("\"", "'"),
-                        source_function.start_line,
-                        source_function.end_line,
-                        extension_string
-                    ))
+                        extension_string = f"{extension_string},{source_function.__getattribute__(variable)}"
+                    print(f"{source_function.nloc},{source_function.cyclomatic_complexity},"
+                          f"{source_function.token_count},{len(source_function.parameters)},"
+                          f'{source_function.length},"{source_function.name.replace(chr(34), chr(39))}@'
+                          f'{source_function.start_line}-{source_function.end_line}@{source_file.filename}",'
+                          f'"{source_file.filename}","{source_function.name.replace(chr(34), chr(39))}",'
+                          f'"{source_function.long_name.replace(chr(34), chr(39))}",'
+                          f"{source_function.start_line},{source_function.end_line}{extension_string}")

lizard_ext/version.py

@@ -3,4 +3,4 @@
 #
 # pylint: disable=missing-docstring,invalid-name
 
-version = "1.17.13"
+version = "1.17.15"

lizard_languages/__init__.py

@@ -1,5 +1,6 @@
 ''' programming languages of lizard '''
 
+from lizard_languages.zig import ZigReader
 from .clike import CLikeReader
 from .erlang import ErlangReader
 from .java import JavaReader
@@ -20,6 +21,9 @@ from .rust import RustReader
 from .typescript import TypeScriptReader
 from .fortran import FortranReader
 from .solidity import SolidityReader
+from .jsx import JSXReader
+from .tsx import TSXReader
+from .vue import VueReader
 
 
 def languages():
@@ -44,6 +48,10 @@ def languages():
         KotlinReader,
         SolidityReader,
         ErlangReader,
+        ZigReader,
+        JSXReader,
+        TSXReader,
+        VueReader,
     ]
 
 

lizard_languages/clike.py

@@ -182,7 +182,7 @@ class CLikeStates(CodeStateMachine):
             self.context.add_to_function_name(' ' + token)
 
     def _state_name_with_space(self, token):
-        self._state = self._state_operator\
+        self._state = self._state_operator \
             if token == 'operator' else self._state_function
         self.context.add_to_function_name(token)
 
@@ -196,7 +196,7 @@ class CLikeStates(CodeStateMachine):
             else:
                 self.next(self._state_global)
         elif len(self.bracket_stack) == 1:
-            if token != 'void': # void is a reserved keyword, meaning no parameters
+            if token != 'void':  # void is a reserved keyword, meaning no parameters
                 self.context.parameter(token)
             return
         self.context.add_to_long_function_name(token)

lizard_languages/code_reader.py

@@ -8,7 +8,7 @@ from functools import reduce
 from operator import or_
 
 
-class CodeStateMachine(object):
+class CodeStateMachine:
     """ the state machine """
     # pylint: disable=R0903
     # pylint: disable=R0902
@@ -50,6 +50,7 @@ class CodeStateMachine(object):
             self.next(self.saved_state)
             if self.callback:
                 self.callback()
+                self.callback = None
         self.last_token = token
         if self.to_exit:
             return True
@@ -117,11 +118,13 @@ class CodeReader:
         def _generate_tokens(source, add, flags=0):
             # DO NOT put any sub groups in the regex. Good for performance
             _until_end = r"(?:\\\n|[^\n])*"
-            combined_symbols = ["<<=", ">>=", "||", "&&", "===", "!==",
-                                "==", "!=", "<=", ">=", "->", "=>",
-                                "++", "--", '+=', '-=',
-                                "+", "-", '*', '/',
-                                '*=', '/=', '^=', '&=', '|=', "..."]
+            combined_symbols = [
+                "<<=", ">>=", "||", "&&", "===", "!==",
+                "==", "!=", "<=", ">=", "->", "=>",
+                "++", "--", '+=', '-=',
+                "+", "-", '*', '/',
+                '*=', '/=', '^=', '&=', '|=', "..."
+            ]
             token_pattern = re.compile(
                 r"(?:" +
                 r"\/\*.*?\*\/" +
@@ -171,8 +174,12 @@ class CodeReader:
         pattern = re.compile(r'\(\?[aiLmsux]+\)')
         re_flags = ''.join(opt[2:-1] for opt in pattern.findall(addition))
         flags = reduce(or_, (flag_dict[flag] for flag in re_flags), 0)
+        cleaned_addition = pattern.sub('', addition)
 
-        return _generate_tokens(source_code, pattern.sub('', addition), flags=flags)
+        return _generate_tokens(
+            source_code,
+            cleaned_addition,
+            flags=flags)
 
     def __call__(self, tokens, reader):
         self.context = reader.context

lizard_languages/erlang.py

@@ -26,8 +26,12 @@ class ErlangReader(CodeReader):
 
     @staticmethod
     def generate_tokens(source_code, addition='', token_class=None):
-        return map(lambda x: x[1], filter(lambda x: x[0] != py_token.Whitespace,
-                                          lex(source_code, lexer=lexers.get_lexer_by_name('erlang'))))
+        lexer = lexers.get_lexer_by_name('erlang')
+        tokens = lex(source_code, lexer=lexer)
+        return map(
+            lambda x: x[1],
+            filter(lambda x: x[0] != py_token.Whitespace, tokens)
+        )
 
 
 class ErlangStates(CodeStateMachine):
@@ -77,8 +81,8 @@ class ErlangStates(CodeStateMachine):
         if token == '-':
             self.punctuated = True
         elif token == '>' and self.punctuated:
-            if len(self.context.stacked_functions) <= 1 or \
-                    self.context.current_function.name == 'fun':
+            if (len(self.context.stacked_functions) <= 1 or
+                    self.context.current_function.name == 'fun'):
                 self.next(self._state_func_first_line, token)
         else:
             self.func_match_failed(token)
@@ -93,8 +97,8 @@ class ErlangStates(CodeStateMachine):
 
     def _state_nested_end(self, token):
         if token == '.' or token == ',':
-            if len(self.context.stacked_functions) > 1 \
-                    and self.context.stacked_functions[-1].name == 'fun':
+            if (len(self.context.stacked_functions) > 1 and
+                    self.context.stacked_functions[-1].name == 'fun'):
                 self.statemachine_return()
                 return
 

lizard_languages/fortran.py

@@ -6,57 +6,65 @@ import re
 from .code_reader import CodeStateMachine, CodeReader
 
 
-# pylint: disable=R0903
-class FortranCommentsMixin(object):
+class FortranCommentsMixin:
     @staticmethod
     def get_comment_from_token(token):
         if token.startswith('!'):
             return token[1:]
 
 
-# pylint: disable=R0903
 class FortranReader(CodeReader, FortranCommentsMixin):
-    ''' This is the reader for Fortran. '''
+    '''This is the reader for Fortran.'''
 
     ext = ['f70', 'f90', 'f95', 'f03', 'f08', 'f', 'for', 'ftn', 'fpp']
     language_names = ['fortran']
-    _conditions = set((
+
+    # Conditions need to have all the cases because the matching is case-insensitive
+    # and is not done here.
+    _conditions = {
         'IF', 'DO', '.AND.', '.OR.', 'CASE',
-        'if', 'do', '.and.', '.or.', 'case'))
-    _blocks = ['PROGRAM', 'MODULE', 'SUBROUTINE', 'FUNCTION', 'TYPE', 'INTERFACE', 'BLOCK', 'IF', 'DO', 'FORALL', 'WHERE', 'SELECT', 'ASSOCIATE']
+        'if', 'do', '.and.', '.or.', 'case'
+    }
+    _blocks = [
+        'PROGRAM', 'MODULE', 'SUBMODULE', 'SUBROUTINE', 'FUNCTION', 'TYPE',
+        'INTERFACE', 'BLOCK', 'IF', 'DO', 'FORALL', 'WHERE', 'SELECT', 'ASSOCIATE'
+    ]
 
     def __init__(self, context):
-        super(FortranReader, self).__init__(context)
+        super().__init__(context)
         self.macro_disabled = False
         self.parallel_states = [FortranStates(context, self)]
 
     @staticmethod
     def generate_tokens(source_code, addition='', token_class=None):
         _until_end = r'(?:\\\n|[^\n])*'
-        return CodeReader.generate_tokens(
-            source_code,
+        block_endings = '|'.join(r'END\s*{0}'.format(_) for _ in FortranReader._blocks)
+        # Include all patterns and the (?i) flag in addition
+        addition = (
             r'(?i)'
-            r'\/\/' +
-            r'|\#' + _until_end +
-            r'|\!' + _until_end +
-            r'|^\*' + _until_end +
-            r'|\.OR\.' +
-            r'|\.AND\.' +
-            r'|ELSE +IF' +
-            ''.join(r'|END[ \t]+{0}'.format(_) for _ in FortranReader._blocks) +
-            addition,
-            token_class)
+            r'\/\/|'
+            r'\#' + _until_end + r'|'
+            r'\!' + _until_end + r'|'
+            r'^\*' + _until_end + r'|'
+            r'\.OR\.|'
+            r'\.AND\.|'
+            r'ELSE\s+IF|'
+            r'MODULE\s+PROCEDURE|'
+            + block_endings + addition
+        )
+        return CodeReader.generate_tokens(
+            source_code, addition=addition, token_class=token_class)
 
     def preprocess(self, tokens):
         macro_depth = 0
         new_line = True
         for token in tokens:
-            if new_line and token[0].upper() in ('c', 'C', '*'):
-                token = '!'+token[1:]
+            if new_line and token[0].upper() in ('C', '*'):
+                token = '!' + token[1:]
             new_line = token == '\n'
-            macro = re.match(r'#\s*(\w+)', token)
-            if macro:
-                macro = macro.group(1).lower()
+            macro_match = re.match(r'#\s*(\w+)', token)
+            if macro_match:
+                macro = macro_match.group(1).lower()
                 if macro in ('if', 'ifdef', 'ifndef', 'elif'):
                     self.context.add_condition()
                 if macro_depth > 0:
@@ -66,22 +74,29 @@ class FortranReader(CodeReader, FortranCommentsMixin):
                         macro_depth -= 1
                 elif macro in ('else', 'elif'):
                     macro_depth += 1
-                # In order to don't mess the nesting,
-                # only the first branch of #if #elif #else
-                # is read by the FortranStateMachine
+                # Only the first branch of #if #elif #else is read
                 self.macro_disabled = macro_depth != 0
             elif not token.isspace() or token == '\n':
                 yield token
 
-# pylint: disable=R0903
+
 class FortranStates(CodeStateMachine):
-    # pylint: disable=line-too-long
-    # pylint: disable=protected-access
-    _ends = re.compile('(?:'+'|'.join(r'END\s*{0}'.format(_) for _ in FortranReader._blocks)+')', re.I)
+    _ends = re.compile(
+        '|'.join(r'END\s*{0}'.format(_) for _ in FortranReader._blocks), re.I)
+
+    # Define token groups to eliminate duplication
+    IGNORE_NEXT_TOKENS = {'%', '::', 'SAVE', 'DATA'}
+    IGNORE_VAR_TOKENS = {'INTEGER', 'REAL', 'COMPLEX', 'LOGICAL', 'CHARACTER'}
+    RESET_STATE_TOKENS = {'RECURSIVE', 'ELEMENTAL'}
+    FUNCTION_NAME_TOKENS = {'SUBROUTINE', 'FUNCTION'}
+    NESTING_KEYWORDS = {'FORALL', 'WHERE', 'SELECT', 'INTERFACE', 'ASSOCIATE'}
+    PROCEDURE_TOKENS = {'PROCEDURE', 'MODULE PROCEDURE'}
 
     def __init__(self, context, reader):
-        super(FortranStates, self).__init__(context)
+        super().__init__(context)
         self.reader = reader
+        self.last_token = None
+        self.in_interface = False
 
     def __call__(self, token, reader=None):
         if self.reader.macro_disabled:
@@ -96,28 +111,35 @@ class FortranStates(CodeStateMachine):
 
     def _state_global(self, token):
         token_upper = token.upper()
-        if token_upper in ('%', '::', 'SAVE', 'DATA'):
+        if token_upper in self.IGNORE_NEXT_TOKENS:
             self._state = self._ignore_next
-        elif token_upper in ('INTEGER', 'REAL','COMPLEX','LOGICAL', 'CHARACTER'):
+        elif token_upper in self.IGNORE_VAR_TOKENS:
             self._state = self._ignore_var
         elif token == '(':
             self.next(self._ignore_expr, token)
-        elif token_upper in ('PROGRAM',):
+        elif token_upper in self.RESET_STATE_TOKENS:
+            self.reset_state()
+        elif token_upper in self.FUNCTION_NAME_TOKENS:
+            self._state = self._function_name
+        elif token_upper == 'PROGRAM':
             self._state = self._namespace
         elif token_upper == 'MODULE':
+            self._state = self._module_or_procedure
+        elif token_upper == 'SUBMODULE':
             self._state = self._module
-        elif token_upper in ('SUBROUTINE', 'FUNCTION'):
-            self._state = self._function_name
+            self._module(token)
         elif token_upper == 'TYPE':
             self._state = self._type
         elif token_upper == 'IF':
             self._state = self._if
-        elif token_upper in ('BLOCK',):
+        elif token_upper == 'BLOCK':
             self._state = self._ignore_if_paren
-        elif token_upper in ('DO',):
+        elif token_upper == 'DO':
             self._state = self._ignore_if_label
-        elif token_upper in ('FORALL', 'WHERE', 'SELECT', 'INTERFACE', 'ASSOCIATE'):
+        elif token_upper in self.NESTING_KEYWORDS:
             self.context.add_bare_nesting()
+            if token_upper == 'INTERFACE':
+                self.in_interface = True
         elif token_upper == 'ELSE':
             self.context.pop_nesting()
             self.context.add_bare_nesting()
@@ -127,6 +149,9 @@ class FortranStates(CodeStateMachine):
                 self.context.add_condition()
             self._state = self._if
         elif token_upper == 'END' or self._ends.match(token):
+            end_token_upper = token_upper.replace(' ', '')
+            if end_token_upper.startswith('ENDINTERFACE'):
+                self.in_interface = False
             self.context.pop_nesting()
 
     def reset_state(self, token=None):
@@ -134,12 +159,11 @@ class FortranStates(CodeStateMachine):
         if token is not None:
             self._state_global(token)
 
-    # pylint: disable=unused-argument
     def _ignore_next(self, token):
         self.reset_state()
 
     def _ignore_var(self, token):
-        if token.upper() in ('SUBROUTINE', 'FUNCTION'):
+        if token.upper() in self.FUNCTION_NAME_TOKENS:
             self.reset_state(token)
         else:
             self.reset_state()
@@ -152,7 +176,7 @@ class FortranStates(CodeStateMachine):
             self.reset_state()
 
     def _ignore_if_label(self, token):
-        if all(char in "0123456789" for char in token):
+        if token.isdigit():
             self.reset_state()
         else:
             self.context.add_bare_nesting()
@@ -184,11 +208,24 @@ class FortranStates(CodeStateMachine):
         self.reset_state(token)
 
     def _module(self, token):
-        if token.upper() == 'PROCEDURE':
-            self.reset_state()
+        if token.upper() in self.FUNCTION_NAME_TOKENS:
+            self._state = self._function_name
+        elif token.upper() in self.PROCEDURE_TOKENS:
+            self._state = self._procedure
         else:
             self._namespace(token)
 
+    def _procedure(self, token):
+        # Start a new function regardless of context
+        if self.last_token and self.last_token.upper() == 'MODULE':
+            # For "module procedure" case, use the current token as function name
+            self.context.restart_new_function(token)
+        else:
+            # For standalone "procedure" case
+            self.context.restart_new_function(token)
+        self.context.add_bare_nesting()
+        self.reset_state()
+
     def _type(self, token):
         if token in (',', '::') or token[0].isalpha():
             self._namespace(token)
@@ -210,8 +247,15 @@ class FortranStates(CodeStateMachine):
         pass
 
     def _if_then(self, token):
-        if token.upper() == 'THEN':
+        token_upper = token.upper()
+        if token_upper == 'THEN':
             self.context.add_bare_nesting()
             self.reset_state()
         else:
             self.reset_state(token)
+
+    def _module_or_procedure(self, token):
+        if token.upper() == 'PROCEDURE':
+            self._state = self._procedure
+        else:
+            self._module(token)