lizard 1.19.0__py2.py3-none-any.whl → 1.21.0__py2.py3-none-any.whl

{lizard-1.19.0.dist-info → lizard-1.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.19.0
+Version: 1.21.0
 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/
@@ -351,6 +351,15 @@ behavior of lizard. There are two types of forgiveness comments:
        ...
    }
 
+   Selective forgiveness: Use "#lizard forgives(metric1, metric2)" to forgive only specific metrics (e.g. length, cyclomatic_complexity, parameter_count, nloc, token_count).
+
+::
+
+   int foo() {
+       // #lizard forgives(length)  // Forgive only length violations
+       ...
+   }
+
 2. Global code forgiveness: Put "#lizard forgive global" before global code to suppress warnings for all code outside of functions.
 
 ::

lizard-1.21.0.dist-info/RECORD

@@ -0,0 +1,70 @@
+lizard.py,sha256=L5CBQ47VYvqzUwqrQD5LfzfcwCB5qBuUx4J59-zKOUU,42076
+lizard_ext/__init__.py,sha256=UQ2oZ4ej1CCekgiY2Qj8sGx8HheoYyxjcOxvrwF70kc,871
+lizard_ext/auto_open.py,sha256=byD_RbeVhvSUhR2bJMRitvA3zcKEapFwv0-XaDJ6GFo,1096
+lizard_ext/checkstyleoutput.py,sha256=UzDHg837ErEZepXkR8I8YCoz2r1lkmzGctMA7dpyB-M,1245
+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=G7MdLD7AwuR0LLCAkEpyHx4N_ssCcFQdXd7Xg5jZWX0,6537
+lizard_ext/keywords.py,sha256=VxsxoATtKV-8egMKd7I8sd2qbZMtEFEpsszk__6rmjQ,893
+lizard_ext/lizardboolcount.py,sha256=abmMA9X3VFRO5mziicUxWKmHldHNC0jBEe7NKAKA5fs,1062
+lizard_ext/lizardcomplextags.py,sha256=z4Jsz8HNxbZXhDRuUeVnNfgt5Zv4FYEW2kRPO4G3F3E,1027
+lizard_ext/lizardcpre.py,sha256=bVrMXffGUZlydv_zwIVtp-Ij9XyXMFEcap2R4DmLXPU,1277
+lizard_ext/lizarddependencycount.py,sha256=6Nt2z69cyG8P3pceTUCTU6yh4h73lezL2awRFh7K77Y,2423
+lizard_ext/lizarddumpcomments.py,sha256=-c46U3CP_beDfBuB9QhObpiB6wK7xq1u9jeRjgAyU90,683
+lizard_ext/lizardduplicate.py,sha256=tlU-UTB_d_qjekiO4MSaXPBT1FSX8uTaOcfeXnjBzU8,9762
+lizard_ext/lizardduplicated_param_list.py,sha256=_ApeSbjA-NU_rmICsivyfGEEg0-O94wWgWpeeE8F3Zc,1811
+lizard_ext/lizardexitcount.py,sha256=ziAVFi5RgjxJOwAQy6LzdZZflkvvxTiXOIp0FAL0wKQ,692
+lizard_ext/lizardgotocount.py,sha256=w2GWWwqVh4j7Fum41Wvg172b70JvtCm5BCzZUmmTlcM,514
+lizard_ext/lizardignoreassert.py,sha256=sqLwcnJQ06SYqIk901ib4NQ8ECwjIe_qL4T6z1wLXAk,644
+lizard_ext/lizardio.py,sha256=xQN-AgLGLKJarJkgfaqX_TKyupbb7GTcwPxrL2B1J1w,3357
+lizard_ext/lizardmccabe.py,sha256=nLwfYjnAWn1DSoDc-k3iPvltiSX_YmAEdAfM3rOdLSQ,1538
+lizard_ext/lizardmodified.py,sha256=51EY-HM840k_-jFiJugp_fOPBKvovX2Wu0s4ghLM3us,1002
+lizard_ext/lizardnd.py,sha256=h4MaSsFAY5rK8kOSr61LkWntwJWV1KnhaEOWZgp3-c0,7496
+lizard_ext/lizardnonstrict.py,sha256=DWdE2kTn39Gf8UkaRwIO9ogWTDuqA4lXNlQIBT3uLRM,457
+lizard_ext/lizardns.py,sha256=3PYJrXZeFjzFnbotINZBm-MHeS8MQxVNtkQJd_S5fYA,5161
+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=sIUtJyuNVeq7CiJtEKzI_OdOiYNcDqIVBKdYY_OOYRg,181
+lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
+lizard_languages/__init__.py,sha256=DniggHM3SOFlwkP8Tm4csEcisbf7_i1EvfoAkG9Atg0,1611
+lizard_languages/clike.py,sha256=BMtIrqPuxmRur-KB7LG6imJtUvnOH2-7p4XFeIFLjME,14892
+lizard_languages/code_reader.py,sha256=I2Kc9F0o4RNX4UUsasUMUieX34u4eOaS73ePhQLC9jg,7844
+lizard_languages/csharp.py,sha256=UDuiG20Ydbb4KMD_mgb82shD37URq3ZvqNLpI77VBPE,3015
+lizard_languages/erlang.py,sha256=tbVPDqi90jV2X1-luDYS32H1zK_2KHwssbJ-tCCOvzg,4249
+lizard_languages/fortran.py,sha256=vwKz1VdwyUtWoECURXuR6e8E2kTR71HtpdbOsmDoyDw,8993
+lizard_languages/gdscript.py,sha256=3mHeCarDq_ilDK_OZ2LOvwfWJqLTzK2lquprLDUnX08,737
+lizard_languages/go.py,sha256=sntz0jOEuj4klPipoTFd16UDK1fAUQfwK7YX_cLMZAc,1346
+lizard_languages/golike.py,sha256=vRIfjTVvc0VmJf27lTOLht55ZF1AQ9wn0Fvu-9WabWk,2858
+lizard_languages/java.py,sha256=8t8G6TR-1qxLHGu3m_T5Kuny49WvMfwCQe1eYnvwZmk,6610
+lizard_languages/javascript.py,sha256=vniCNMW-ea9Jpv6c8qCcjLVDYjT8VztjXigp5XRWt0E,317
+lizard_languages/js_style_regex_expression.py,sha256=Xgyogch4xElYtCG4EnBKvalHTl3tjRPcIIcIQRRd61I,1970
+lizard_languages/kotlin.py,sha256=1ao-VOHUrrSluxgGjMcMPIDt_-dqVfT1JOz15PJLJH8,3024
+lizard_languages/lua.py,sha256=3nqBcunBzJrhv4Iqaf8xvbyqxZy3aSxJ-IiHimHFlac,1573
+lizard_languages/objc.py,sha256=2a1teLdaXZBtCeFiIZer1j_sVx9LZ1CbF2XfnqlvLmk,2319
+lizard_languages/perl.py,sha256=lxxdC0KJsr3tmNLMATO7vx3O7yWGgICxHxVTfmu7db8,12111
+lizard_languages/php.py,sha256=ebHkNyKDOPLyzey5eDhKuu1AMsmGflxqGGmx1ZrlrGA,10542
+lizard_languages/plsql.py,sha256=Wtny6-YW4Jc6G4EhCgoSuw8D86x6JVREprzaUEyKffw,17261
+lizard_languages/python.py,sha256=-sI7ZzJ1erdmqo1MnCcg5cqn1krUhCHlR_phlhnmd_M,5978
+lizard_languages/r.py,sha256=NHNPDGnWXcl8hMi1VL8OM6nw8F9pP6xZX7EgUIocOec,12930
+lizard_languages/ruby.py,sha256=HL1ZckeuUUJU3QSVAOPsG_Zsl0C6X2PX5_VaWqclzkM,2277
+lizard_languages/rubylike.py,sha256=vnfY2lSeIYEgfjJWrfNL6fg1ISHGiwo32H7bf7Stwos,3604
+lizard_languages/rust.py,sha256=7ioyo-kpy5zSQ6Fwua6GcYopkLUdfyExg6kLP0Br3p0,1027
+lizard_languages/scala.py,sha256=onEuS8IsT7aCB-HV0arVDjmgpezXWndk1RCOgoySUes,1436
+lizard_languages/script_language.py,sha256=SKe45AbO6Z-axbN8KW_g7jf9g7YTXZ6dWzJj4ubDsM8,1172
+lizard_languages/solidity.py,sha256=eg7HQ7cuV1d0Awwj4lTySu9f63F1vrK8czsPt_W5Kqw,680
+lizard_languages/st.py,sha256=QiiGNYE8CzmfmZAF_wLQKovXk1Fyqa8QFGTXM1meNNk,4385
+lizard_languages/swift.py,sha256=JcHmBV-p916K2o2XrTKf98U6Bt9-jAEOS9JqA1W5tkA,2570
+lizard_languages/tnsdl.py,sha256=y2dcZI_PmriNd7UTP1Db9QEpWBzKeoH8odRzkiN-P1k,3009
+lizard_languages/tsx.py,sha256=fY9qzPcSvhHSs-62ZFh0mMGyKVaSCEfsYZxBS_uHzww,17161
+lizard_languages/ttcn.py,sha256=tSkPmtifsuUI5aUKBG-uHvwcmZTWcbtMWoUMF3Cw4cI,2199
+lizard_languages/typescript.py,sha256=SOef4ja2GE-Idt9fSF7d0gZTW6bwCNl8K2IT67nIMyA,14805
+lizard_languages/vue.py,sha256=KXUBUo2R1zNF8Pffrz_KsQEN44m5XFRMoGXylxKUeT0,1038
+lizard_languages/zig.py,sha256=RiDZyjnCn97jqFmcl5EQl7pbuH0G1oI2Qo72EXvdtDU,813
+lizard-1.21.0.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
+lizard-1.21.0.dist-info/METADATA,sha256=jLq4TDqRDAQd2RimhMDLBNUlv7ULP0vJ6pqybAtClPg,16978
+lizard-1.21.0.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
+lizard-1.21.0.dist-info/entry_points.txt,sha256=pPMMwoHAltzGHqR2WeJQItLeeyR7pbX5R2S_POC-xoo,40
+lizard-1.21.0.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
+lizard-1.21.0.dist-info/RECORD,,

lizard.py

@@ -291,6 +291,7 @@ class FunctionInfo(Nesting):  # pylint: disable=R0902
         self.fan_out = 0
         self.general_fan_out = 0
         self.max_nesting_depth = 0  # Initialize max_nesting_depth to 0
+        self.forgiven_metrics = set()
 
     @property
     def name_in_space(self):
@@ -509,9 +510,15 @@ def comment_counter(tokens, reader):
         if comment is not None:
             for _ in comment.splitlines()[1:]:
                 yield '\n'
-            if comment.strip().startswith("#lizard forgive global"):
+            stripped = comment.strip()
+            if stripped.startswith("#lizard forgive global"):
                 reader.context.forgive_global = True
-            elif comment.strip().startswith("#lizard forgive"):
+            elif stripped.startswith("#lizard forgives("):
+                match = re.search(r'#lizard forgives?\(([^)]*)\)', stripped)
+                if match:
+                    metrics = {m.strip() for m in match.group(1).split(',') if m.strip()}
+                    reader.context.current_function.forgiven_metrics.update(metrics)
+            elif stripped.startswith("#lizard forgive"):
                 reader.context.forgive = True
             if "GENERATED CODE" in comment:
                 return
@@ -597,9 +604,16 @@ def warning_filter(option, module_infos):
     for file_info in module_infos:
         if file_info:
             for fun in file_info.function_list:
-                if any(getattr(fun, attr) > limit for attr, limit in
-                       option.thresholds.items()):
-                    yield fun
+                violated_metrics = [
+                    attr for attr, limit in option.thresholds.items()
+                    if getattr(fun, attr) > limit
+                ]
+                if not violated_metrics:
+                    continue
+                forgiven = getattr(fun, 'forgiven_metrics', set())
+                if all(metric in forgiven for metric in violated_metrics):
+                    continue
+                yield fun
 
 
 def whitelist_filter(warnings, script=None, whitelist=None):
@@ -1109,7 +1123,8 @@ def main(argv=None):
         sys.stdout = original_stdout
         output_file.close()
     if 0 <= options.number < warning_count:
-        sys.exit(1)
+        return 1
+    return 0
 
 
 def print_extension_results(extensions):
@@ -1119,4 +1134,4 @@ def print_extension_results(extensions):
 
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main())

lizard_ext/__init__.py

@@ -21,7 +21,6 @@ def print_csv(results, options, _, total_factory):
 
 def print_checkstyle(results, options, _, total_factory, file=None):
     import sys
-    print("DEBUG: print_checkstyle called", file=sys.stderr)
     output = checkstyle_output(total_factory(list(results)), options.verbose)
     if file is None:
         file = sys.stdout

lizard_ext/lizardcomplextags.py

@@ -5,10 +5,16 @@ that adding the complexity and the line numbers of the keywords appear.
 
 
 class LizardExtension(object):  # pylint: disable=R0903
+    """
+    Complex tags extension: records all complexity-adding keywords and their line numbers.
+    Uses reader.conditions (combined set of all condition types) to track all
+    complexity contributors: control flow, logical operators, case labels, and ternary.
+    """
 
     # pylint: disable=W0221
     def __call__(self, tokens, reader):
         context = reader.context
+        # Use combined conditions set - intentionally includes all types
         conditions = reader.conditions
         for token in tokens:
             yield token

lizard_ext/lizardmccabe.py

@@ -14,9 +14,14 @@ from .extension_base import ExtensionBase
 
 
 class LizardExtension(ExtensionBase):  # pylint: disable=R0903
+    """
+    McCabe extension: only counts the first 'case' in a switch statement.
+    Consecutive cases without code between them don't add to complexity.
+    Works by detecting case tokens (conceptually from reader.case_keywords).
+    """
 
     def _state_global(self, token):
-        if token == "case":
+        if token == "case":  # Detect case keywords
             self._state = self._in_case
 
     def _in_case(self, token):

lizard_ext/lizardmodified.py

@@ -6,14 +6,19 @@ where the whole switch/case will be counted as 1.
 
 
 class LizardExtension(object):  # pylint: disable=R0903
+    """
+    Modified CCN extension: counts entire switch/case as 1 complexity.
+    Adds +1 for 'switch', subtracts -1 for each 'case'.
+    Works with switch/case keywords (conceptually from reader.case_keywords).
+    """
 
     def __call__(self, tokens, reader):
         for token in tokens:
-            if token == 'switch':
+            if token == 'switch':  # Add complexity for switch statement
                 reader.context.add_condition()
                 if hasattr(reader.context, "add_nd_condition"):
                     reader.context.add_nd_condition()
-            elif token == 'case':
+            elif token == 'case':  # Subtract complexity for each case
                 reader.context.add_condition(-1)
                 if hasattr(reader.context, "add_nd_condition"):
                     reader.context.add_nd_condition(-1)

lizard_ext/lizardnonstrict.py

@@ -9,5 +9,6 @@ class LizardExtension(object):  # pylint: disable=R0903
 
     # pylint: disable=W0221
     def __call__(self, tokens, reader):
-        reader.conditions -= set(['&&', '||', 'and', 'or'])
+        # Remove logical operators from conditions (non-strict mode)
+        reader.conditions -= reader.logical_operators
         return tokens

lizard_ext/lizardns.py

@@ -67,10 +67,35 @@ class LizardExtension(ExtensionBase):  # pylint: disable=R0903
 
     def __init__(self):
         super(LizardExtension, self).__init__(None)
-        self.structure_piles = [0]
+        self.structure_piles = [0]  # Invariant: must always have at least one element
 
-    def pile_up_within_block(self):
+    def _push_scope(self):
+        """Push a new scope level. Safe to call anytime."""
+        self.structure_piles.append(0)
+
+    def _pop_scope(self):
+        """Pop a scope level. Maintains invariant of at least one element."""
+        if len(self.structure_piles) > 1:
+            self.structure_piles.pop()
+
+    def _increment_current_scope(self):
+        """Increment structure count in current scope. Safe even if piles corrupted."""
+        if not self.structure_piles:
+            self.structure_piles = [0]  # Restore invariant
         self.structure_piles[-1] += 1
+
+    def _reset_or_decrement_current_scope(self, decrement=False):
+        """Reset or decrement current scope counter. Safe even if piles corrupted."""
+        if not self.structure_piles:
+            self.structure_piles = [0]  # Restore invariant
+            return
+        if decrement:
+            self.structure_piles[-1] -= 1
+        else:
+            self.structure_piles[-1] = 0
+
+    def pile_up_within_block(self):
+        self._increment_current_scope()
         cur_level = sum(self.structure_piles)
         # Is there a path around _state_global?
         if not hasattr(self.context.current_function, "max_nested_structures"):
@@ -83,10 +108,10 @@ class LizardExtension(ExtensionBase):  # pylint: disable=R0903
         if not hasattr(self.context.current_function, "max_nested_structures"):
             self.context.current_function.max_nested_structures = 0
         if token == '{':
-            self.structure_piles.append(0)
+            self._push_scope()
         elif token in ';}':
             if token == '}':
-                self.structure_piles.pop()
+                self._pop_scope()
             self._state = self._block_ending
         elif token in self.structures:
             self._state = self._in_structure_head
@@ -98,10 +123,8 @@ class LizardExtension(ExtensionBase):  # pylint: disable=R0903
         self._state(token)
 
     def _block_ending(self, token):
-        if token in self.matching_structures:
-            self.structure_piles[-1] -= 1
-        else:
-            self.structure_piles[-1] = 0
+        decrement = token in self.matching_structures
+        self._reset_or_decrement_current_scope(decrement=decrement)
         self._state = self._state_global
         self._state(token)
 

lizard_ext/version.py

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

lizard_languages/clike.py

@@ -32,8 +32,11 @@ class CLikeReader(CodeReader, CCppCommentsMixin):
 
     @staticmethod
     def generate_tokens(source_code, addition='', token_class=None):
-        # Add pattern for floating point literals to the token generation
-        addition = r"|(?:\d*\.\d+(?:[eE][-+]?\d+)?)" + \
+        # Add pattern for C++ raw string literals R"delimiter(content)delimiter"
+        # The delimiter can be empty or up to 16 chars (excluding parentheses, backslash, whitespace)
+        # Using a simplified pattern that handles most cases
+        addition = r"|R\"[^(\\]*\((?:[^)]|\)[^\"])*\)[^(\\]*\"" + \
+                  r"|(?:\d*\.\d+(?:[eE][-+]?\d+)?)" + \
                   r"|(?:\d+\.(?:\d+)?(?:[eE][-+]?\d+)?)" + \
                   addition
         return CodeReader.generate_tokens(source_code, addition, token_class)
@@ -319,53 +322,77 @@ class CLikeStates(CodeStateMachine):
     def _state_lambda_check(self, token):
         """Check if this is a lambda expression or a function attribute."""
         if token == ']':
-            # This is a lambda expression [](params) or [capture](params)
-            # Skip the lambda and continue parsing normally
+            # This is an empty capture list [](params)
             self._state = self._state_lambda_params
         elif token == '[':
             # This is a function attribute [[attribute]]
             self._state = self._state_attribute
         else:
             # This is a lambda with capture list [capture](params)
-            # Skip until we find the closing bracket
             self._state = self._state_lambda_capture
 
     def _state_lambda_params(self, token):
         """Handle lambda parameters and body."""
         if token == '(':
-            # Start of parameter list, skip until closing parenthesis
+            # Start of parameter list
+            self.bracket_stack.append('(')
             self._state = self._state_lambda_param_list
         else:
-            # No parameters, check for body
+            # No parameters, check for body or go back to global
             self._state = self._state_lambda_body
+            self._state(token)
 
     def _state_lambda_param_list(self, token):
-        """Handle lambda parameter list."""
-        if token == ')':
-            # End of parameter list, check for body
-            self._state = self._state_lambda_body
-        # Otherwise, continue in parameter list
+        """Handle lambda parameter list with proper bracket tracking."""
+        if token == '(':
+            self.bracket_stack.append('(')
+        elif token == ')':
+            if self.bracket_stack and self.bracket_stack[-1] == '(':
+                self.bracket_stack.pop()
+                if not self.bracket_stack:
+                    # End of parameter list, check for body
+                    self._state = self._state_lambda_body
+        elif token in ('<', '['):
+            self.bracket_stack.append(token)
+        elif token == '>' and self.bracket_stack and self.bracket_stack[-1] == '<':
+            self.bracket_stack.pop()
+        elif token == ']' and self.bracket_stack and self.bracket_stack[-1] == '[':
+            self.bracket_stack.pop()
 
     def _state_lambda_body(self, token):
-        """Handle lambda body."""
+        """Handle lambda body and qualifiers."""
         if token == '{':
-            # Start of lambda body, skip until closing brace
+            # Start of lambda body
+            self.bracket_stack.append('{')
             self._state = self._state_lambda_body_skip
-        elif token == ';':
-            # Lambda without body, just a semicolon
+        elif token in ('mutable', 'noexcept', 'constexpr', 'consteval'):
+            # Lambda qualifiers, stay in this state
+            pass
+        elif token == '->':
+            # Trailing return type, stay in this state until we find '{'
+            pass
+        elif token in (';', ',', ')'):
+            # Lambda declaration ended, return to global
             self._state = self._state_global
-        # Otherwise, continue
+            self._state(token)
+        else:
+            # Other tokens (type names, etc.) - stay in state
+            pass
 
     def _state_lambda_body_skip(self, token):
-        """Skip lambda body until closing brace."""
-        if token == '}':
-            # End of lambda body, continue parsing normally
-            self._state = self._state_global
-        # Otherwise, continue skipping
+        """Skip lambda body with proper brace tracking."""
+        if token == '{':
+            self.bracket_stack.append('{')
+        elif token == '}':
+            if self.bracket_stack and self.bracket_stack[-1] == '{':
+                self.bracket_stack.pop()
+                if not self.bracket_stack:
+                    # End of lambda body
+                    self._state = self._state_global
 
     def _state_lambda_capture(self, token):
         """Handle lambda capture list."""
         if token == ']':
-            # End of capture list, continue parsing normally
-            self._state = self._state_global
+            # End of capture list, now expect parameters
+            self._state = self._state_lambda_params
         # Otherwise, continue in capture list

lizard_languages/code_reader.py

@@ -94,12 +94,36 @@ class CodeReader:
     ext = []
     languages = None
     extra_subclasses = set()
-    _conditions = {'if', 'for', 'while', '&&', '||', '?', 'catch', 'case'}
+
+    # Condition categories - separate types that contribute to cyclomatic complexity
+    _control_flow_keywords = {'if', 'for', 'while', 'catch'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = {'case'}
+    _ternary_operators = {'?'}
+
+    @classmethod
+    def _build_conditions(cls):
+        """Build combined conditions set from separated categories.
+
+        Returns combined set of all condition types for CCN calculation.
+        """
+        return (cls._control_flow_keywords |
+                cls._logical_operators |
+                cls._case_keywords |
+                cls._ternary_operators)
 
     def __init__(self, context):
         self.parallel_states = []
         self.context = context
-        self.conditions = copy(self._conditions)
+
+        # Build combined conditions set from separated categories
+        self.conditions = copy(self.__class__._build_conditions())
+
+        # Expose individual categories for extensions
+        self.control_flow_keywords = copy(self.__class__._control_flow_keywords)
+        self.logical_operators = copy(self.__class__._logical_operators)
+        self.case_keywords = copy(self.__class__._case_keywords)
+        self.ternary_operators = copy(self.__class__._ternary_operators)
 
     @classmethod
     def match_filename(cls, filename):

lizard_languages/csharp.py

@@ -11,8 +11,11 @@ class CSharpReader(CLikeReader):
     ext = ['cs']
     language_names = ['csharp']
 
-    _conditions = set(['if', 'for', 'while', '&&', '||', '?', 'catch',
-                      'case', '??'])
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'for', 'while', 'catch'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = {'case'}
+    _ternary_operators = {'?', '??'}  # C# has both ?: and ?? (null-coalescing)
 
     def __init__(self, context):
         super(CSharpReader, self).__init__(context)
@@ -39,6 +42,22 @@ class CSharpStates(CLikeStates):
             if self.class_name and self.context.current_function:
                 self.context.current_function.name = f"{self.class_name}::{name}"
 
+    def _state_dec_to_imp(self, token):
+        """Override to handle C# expression-bodied members (=>)"""
+        if token == '=>':
+            # Expression-bodied member: confirm function and enter expression body
+            self.context.confirm_new_function()
+            self._state = self._state_expression_body
+        else:
+            super(CSharpStates, self)._state_dec_to_imp(token)
+
+    def _state_expression_body(self, token):
+        """Read the expression body until semicolon, processing tokens for complexity"""
+        if token == ';':
+            # End of expression-bodied method, finalize function and return to global state
+            self.context.end_of_function()
+            self._state = self._state_global
+
     def _state_global(self, token):
         if token in ("class", "struct", "record"):
             self.class_name = None

lizard_languages/erlang.py

@@ -13,7 +13,15 @@ class ErlangReader(CodeReader):
 
     ext = ['erl', 'hrl', 'es', 'escript']
     language_names = ['erlang']
-    _conditions = {'and', 'case', 'catch', 'if', 'not', 'or', '?', 'when'}
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'catch', 'when'}  # when is used in guards
+    _logical_operators = {'and', 'or', 'not'}
+    _case_keywords = {'case'}
+    # Note: '?' in Erlang is a macro expansion operator (e.g., ?MODULE, ?EMPTY_NODE)
+    # Unlike C-style ternary, it's for compile-time macro substitution
+    # Included in ternary_operators because macro usage adds to code complexity
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super(ErlangReader, self).__init__(context)

lizard_languages/fortran.py

@@ -19,12 +19,11 @@ class FortranReader(CodeReader, FortranCommentsMixin):
     ext = ['f70', 'f90', 'f95', 'f03', 'f08', 'f', 'for', 'ftn', 'fpp']
     language_names = ['fortran']
 
-    # 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'
-    }
+    # Separated condition categories (case-insensitive language)
+    _control_flow_keywords = {'IF', 'DO', 'if', 'do'}
+    _logical_operators = {'.AND.', '.OR.', '.and.', '.or.'}
+    _case_keywords = {'CASE', 'case'}
+    _ternary_operators = set()
     _blocks = [
         'PROGRAM', 'MODULE', 'SUBMODULE', 'SUBROUTINE', 'FUNCTION', 'TYPE',
         'INTERFACE', 'BLOCK', 'IF', 'DO', 'FORALL', 'WHERE', 'SELECT', 'ASSOCIATE'

lizard_languages/gdscript.py

@@ -9,8 +9,12 @@ class GDScriptReader(PythonReader):
 
     ext = ['gd']
     language_names = ['GDScript']
-    _conditions = set(['if', 'else', 'for', 'while', '&&', '||', '?', 'catch',
-                      'case', 'do'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'elif', 'for', 'while', 'catch', 'do'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = {'case'}
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super(GDScriptReader, self).__init__(context)

lizard_languages/java.py

@@ -54,11 +54,15 @@ class JavaStates(CLikeStates):  # pylint: disable=R0903
 
     def _try_start_a_class(self, token):
         if token in ("class", "record", "enum"):
+            # "record" inside method bodies is a variable name, not a keyword
+            if token == "record" and self.in_method_body:
+                return False
             self.class_name = None
             self.is_record = token == "record"
             self.in_record_constructor = False
             self._state = self._state_class_declaration
             return True
+        return False
 
     def _state_global(self, token):
         if token == '@':

lizard_languages/kotlin.py

@@ -13,9 +13,12 @@ class KotlinReader(CodeReader, CCppCommentsMixin, SwiftReplaceLabel):
 
     ext = ['kt', 'kts']
     language_names = ['kotlin']
-    _conditions = {
-        'if', 'for', 'while', 'catch', '&&', '||', '?:'
-    }
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'for', 'while', 'catch'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = set()  # Kotlin uses 'when' expressions, not case
+    _ternary_operators = {'?:'}  # Elvis operator
 
     def __init__(self, context):
         super(KotlinReader, self).__init__(context)

lizard_languages/perl.py

@@ -19,8 +19,13 @@ class PerlReader(CodeReader, ScriptLanguageMixIn):
 
     ext = ['pl', 'pm']
     language_names = ['perl']
-    _conditions = set(['if', 'elsif', 'unless', 'while', 'until', 'for', 'foreach',
-                       '&&', '||', '?', ':', 'when', 'given', 'default', 'do'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'elsif', 'unless', 'while', 'until', 'for', 
+                              'foreach', 'when', 'given', 'default', 'do'}
+    _logical_operators = {'&&', '||'}  # Perl also has 'and', 'or' with different precedence
+    _case_keywords = set()
+    _ternary_operators = {'?', ':'}  # Both parts of ternary operator
 
     def __init__(self, context):
         super(PerlReader, self).__init__(context)
@@ -65,8 +70,7 @@ class PerlReader(CodeReader, ScriptLanguageMixIn):
 
 
 class PerlStates(CodeStateMachine):
-    _conditions = set(['if', 'elsif', 'unless', 'while', 'until', 'for', 'foreach',
-                       '&&', '||', '?', ':', 'when', 'given', 'default', 'do'])
+    # Note: _conditions removed - now inherited from PerlReader
 
     def __init__(self, context):
         super(PerlStates, self).__init__(context)

lizard_languages/php.py

@@ -31,11 +31,15 @@ class PHPLanguageStates(CodeStateMachine):
         self.match_case_count = 0
 
     def _state_global(self, token):
-        if token == 'class':
+        if token == 'use':
+            # Enter use statement state
+            self._state = self._state_use
+        elif token == 'class':
             self._state = self._class_declaration
         elif token == 'trait':
             self._state = self._trait_declaration
         elif token == 'function':
+            # Treat 'function' as function declaration
             self.is_function_declaration = True
             self._state = self._function_name
         elif token == 'fn':
@@ -88,6 +92,13 @@ class PHPLanguageStates(CodeStateMachine):
             else:
                 self.last_tokens = ''
 
+    def _state_use(self, token):
+        """Handle use statements (use function, use const, etc.)"""
+        if token == ';':
+            # End of use statement, return to global state
+            self._state = self._state_global
+        # Ignore all other tokens in use statements
+
     def _trait_declaration(self, token):
         if token and not token.isspace() and token not in ['{', '(']:
             self.trait_name = token
@@ -231,8 +242,12 @@ class PHPReader(CodeReader, CCppCommentsMixin):
 
     ext = ['php']
     language_names = ['php']
-    _conditions = set(['if', 'elseif', 'for', 'foreach', 'while', '&&', '||', '?',
-                       'catch', 'case', 'match'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'elseif', 'for', 'foreach', 'while', 'catch', 'match'}
+    _logical_operators = {'&&', '||'}  # PHP also has 'and', 'or' with different precedence
+    _case_keywords = {'case'}
+    _ternary_operators = {'?'}
 
     @staticmethod
     def generate_tokens(source_code, addition='', token_class=None):

lizard_languages/plsql.py

@@ -45,11 +45,14 @@ class PLSQLReader(CodeReader, CCppCommentsMixin):
     ext = ["sql", "pks", "pkb", "pls", "plb", "pck"]
     language_names = ["plsql", "pl/sql"]
 
-    # PL/SQL conditions for cyclomatic complexity
+    # Separated condition categories
     # Note: 'loop' is NOT in this set because LOOP has special handling:
     # - standalone LOOP adds +1
     # - LOOP after WHILE/FOR should not add (it's part of the compound statement)
-    _conditions = {"if", "elsif", "when", "while", "for", "and", "or"}
+    _control_flow_keywords = {"if", "elsif", "when", "while", "for"}
+    _logical_operators = {"and", "or"}
+    _case_keywords = set()  # PL/SQL uses 'when' in case expressions
+    _ternary_operators = set()
 
     def __init__(self, context):
         super(PLSQLReader, self).__init__(context)

lizard_languages/python.py

@@ -29,10 +29,12 @@ class PythonReader(CodeReader, ScriptLanguageMixIn):
 
     ext = ['py']
     language_names = ['python']
-    _conditions = set([
-        'if', 'for', 'while', 'and', 'or',
-        'elif', 'except', 'finally'
-    ])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'elif', 'for', 'while', 'except', 'finally'}
+    _logical_operators = {'and', 'or'}
+    _case_keywords = set()  # Python uses if/elif, not case
+    _ternary_operators = set()  # Python uses 'x if c else y' syntax, not ?
 
     def __init__(self, context):
         super(PythonReader, self).__init__(context)

lizard_languages/r.py

@@ -12,12 +12,15 @@ class RReader(CodeReader, ScriptLanguageMixIn):
     ext = ['r', 'R']
     language_names = ['r', 'R']
 
-    # R-specific conditions that increase cyclomatic complexity
-    _conditions = {
-        'if', 'else if', 'for', 'while', 'repeat', 'switch',
-        '&&', '||', '&', '|', 'ifelse',
-        'tryCatch', 'try'
-    }
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'else if', 'for', 'while', 'repeat', 'switch',
+                              'tryCatch', 'try', 'ifelse'}  # ifelse is a vectorized control function
+    # R has both short-circuit (&&, ||) and element-wise (&, |) operators
+    # Both types count toward CCN as they represent conditional logic (vectorized or not)
+    # Users can use -Enonstrict to exclude logical operators if desired
+    _logical_operators = {'&&', '||', '&', '|'}
+    _case_keywords = set()
+    _ternary_operators = set()
 
     def __init__(self, context):
         super(RReader, self).__init__(context)

lizard_languages/rubylike.py

@@ -97,9 +97,12 @@ class RubylikeStateMachine(CodeStateMachine):
 class RubylikeReader(CodeReader, ScriptLanguageMixIn):
     # pylint: disable=R0903
 
-    _conditions = set(['if', 'until', 'for', 'while', 'and', 'or',
-                       'elsif', 'elseif', 'rescue',
-                       'ensure', 'when', '||', '&&', '?'])
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'elsif', 'elseif', 'until', 'for', 'while', 
+                              'rescue', 'ensure', 'when'}
+    _logical_operators = {'and', 'or', '||', '&&'}  # Both word and symbol forms
+    _case_keywords = set()  # Ruby uses 'when' for case expressions
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super(RubylikeReader, self).__init__(context)

lizard_languages/rust.py

@@ -12,8 +12,13 @@ class RustReader(CodeReader, CCppCommentsMixin):
 
     ext = ['rs']
     language_names = ['rust']
-    _conditions = set(['if', 'for', 'while', '&&', '||', '?', 'catch',
-                      'case', 'match', 'where'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'for', 'while', 'catch', 'match', 'where'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = set()  # Rust uses match arms, not case keyword
+    # Note: '?' in Rust is the error propagation operator, not ternary
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super().__init__(context)

lizard_languages/scala.py

@@ -12,8 +12,12 @@ class ScalaReader(CodeReader, CCppCommentsMixin):
 
     ext = ['scala']
     language_names = ['scala']
-    _conditions = set(['if', 'for', 'while', '&&', '||', '?', 'catch',
-                      'case', 'do'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'for', 'while', 'catch', 'do'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = {'case'}  # Pattern matching
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super(ScalaReader, self).__init__(context)

lizard_languages/solidity.py

@@ -11,7 +11,12 @@ class SolidityReader(CodeReader, CCppCommentsMixin):
 
     ext = ['sol']
     language_names = ['solidity']
-    _conditions = set(['if', 'for', 'while', '&&', '||', '?'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'for', 'while'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = set()
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super(SolidityReader, self).__init__(context)

lizard_languages/st.py

@@ -22,11 +22,15 @@ class StReader(CodeReader, StCommentsMixin):
     language_names = ['st']
     macro_pattern = re.compile(r"#\s*(\w+)\s*(.*)", re.M | re.S)
 
-    # track block starters
-    _conditions = set([
-        'if', 'elsif', 'case', 'for', 'while', 'repeat',
-        'IF', 'ELSIF', 'CASE', 'FOR', 'WHILE', 'REPEAT'
-    ])
+    # Separated condition categories (case-insensitive language)
+    _control_flow_keywords = {
+        'if', 'elsif', 'for', 'while', 'repeat',
+        'IF', 'ELSIF', 'FOR', 'WHILE', 'REPEAT'
+    }
+    # ST is case-insensitive, so include both lowercase and uppercase forms
+    _logical_operators = {'and', 'or', 'AND', 'OR'}
+    _case_keywords = {'case', 'CASE'}
+    _ternary_operators = set()
 
     _functions = set([
         'FUNCTION_BLOCK', 'FUNCTION', 'ACTION'

lizard_languages/swift.py

@@ -30,8 +30,12 @@ class SwiftReader(CodeReader, CCppCommentsMixin, SwiftReplaceLabel):
     FUNC_KEYWORD = 'def'
     ext = ['swift']
     language_names = ['swift']
-    _conditions = set(['if', 'for', 'while', '&&', '||', '?', 'catch',
-                      'case', 'guard'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'for', 'while', 'catch', 'guard'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = {'case'}  # Pattern matching
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super(SwiftReader, self).__init__(context)

lizard_languages/tnsdl.py

@@ -84,7 +84,12 @@ class SDLReader(CodeReader, CCppCommentsMixin):
         if condition:
             return self.context.CONDITION()
 
-    _conditions = set(['WHILE', 'AND', 'OR', '#if'])
+    # Separated condition categories
+    _control_flow_keywords = {'WHILE', '#if'}
+    _logical_operators = {'AND', 'OR'}
+    _case_keywords = set()
+    _ternary_operators = set()
+    # Note: No need to define _conditions - base class builds it automatically
 
     def _is_condition(self, token, last_token):
         if token == ':' and last_token == ')':

lizard_languages/tsx.py

@@ -48,8 +48,8 @@ class JSXTypeScriptStates(CodeStateMachine):
         self.started_function = None
         self.pending_function_name = ''
         self._ts_declare = False
-        self._conditions = set(['if', 'elseif', 'for', 'while', '&&', '||', '?',
-                               'catch', 'case'])
+        # Note: Condition categories come from TypeScriptReader class level,
+        # no need to define instance-level duplicates
         self.inside_function = inside_function  # Track if we're already inside a function
 
     def statemachine_before_return(self):

lizard_languages/ttcn.py

@@ -10,9 +10,11 @@ class TTCNReader(CLikeReader):  # pylint: disable=R0903
     ext = ['ttcn', 'ttcnpp']
     language_names = ['ttcn', 'ttcn3']
 
-    _conditions = set(['if', 'else', 'for', 'while',
-                       'altstep', 'case', 'goto', 'alt',
-                       'interleave', 'and', 'or', 'xor'])
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'for', 'while', 'altstep', 'alt', 'interleave', 'goto'}
+    _logical_operators = {'and', 'or', 'xor'}
+    _case_keywords = {'case'}
+    _ternary_operators = set()
 
     def __init__(self, context):
         super(TTCNReader, self).__init__(context)

lizard_languages/typescript.py

@@ -51,8 +51,12 @@ class TypeScriptReader(CodeReader, CCppCommentsMixin):
 
     ext = ['ts']
     language_names = ['typescript', 'ts']
-    _conditions = set(['if', 'elseif', 'for', 'while', '&&', '||', '?',
-                       'catch', 'case'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'elseif', 'for', 'while', 'catch'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = {'case'}
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super().__init__(context)

lizard_languages/zig.py

@@ -12,7 +12,13 @@ from .golike import GoLikeStates
 class ZigReader(CodeReader, CCppCommentsMixin):
     ext = ["zig"]
     language_names = ["zig"]
-    _conditions = {"if", "for", "while", "and", "or", "orelse", "try", "catch", "=>"}
+    
+    # Separated condition categories
+    _control_flow_keywords = {"if", "for", "while", "try", "catch"}
+    _logical_operators = {"and", "or", "orelse"}  # orelse is Zig's null coalescing
+    _case_keywords = set()
+    # Note: '=>' is for error union and switch cases in Zig
+    _ternary_operators = {"=>"}
 
     def __init__(self, context):
         super().__init__(context)

lizard-1.19.0.dist-info/RECORD

@@ -1,70 +0,0 @@
-lizard.py,sha256=B0g5lEp5me31bQpjfMKVayF0iUfH0PalVecOKeUX3-A,41365
-lizard_ext/__init__.py,sha256=AkZYVqCgd7XX1hMwLMyh_ABm9geIHmobEch-thYXZz8,932
-lizard_ext/auto_open.py,sha256=byD_RbeVhvSUhR2bJMRitvA3zcKEapFwv0-XaDJ6GFo,1096
-lizard_ext/checkstyleoutput.py,sha256=UzDHg837ErEZepXkR8I8YCoz2r1lkmzGctMA7dpyB-M,1245
-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=G7MdLD7AwuR0LLCAkEpyHx4N_ssCcFQdXd7Xg5jZWX0,6537
-lizard_ext/keywords.py,sha256=VxsxoATtKV-8egMKd7I8sd2qbZMtEFEpsszk__6rmjQ,893
-lizard_ext/lizardboolcount.py,sha256=abmMA9X3VFRO5mziicUxWKmHldHNC0jBEe7NKAKA5fs,1062
-lizard_ext/lizardcomplextags.py,sha256=flrwYg24P5DoDsBO3gdcK9SxkugX_brhfjuu8zgPnOc,681
-lizard_ext/lizardcpre.py,sha256=bVrMXffGUZlydv_zwIVtp-Ij9XyXMFEcap2R4DmLXPU,1277
-lizard_ext/lizarddependencycount.py,sha256=6Nt2z69cyG8P3pceTUCTU6yh4h73lezL2awRFh7K77Y,2423
-lizard_ext/lizarddumpcomments.py,sha256=-c46U3CP_beDfBuB9QhObpiB6wK7xq1u9jeRjgAyU90,683
-lizard_ext/lizardduplicate.py,sha256=tlU-UTB_d_qjekiO4MSaXPBT1FSX8uTaOcfeXnjBzU8,9762
-lizard_ext/lizardduplicated_param_list.py,sha256=_ApeSbjA-NU_rmICsivyfGEEg0-O94wWgWpeeE8F3Zc,1811
-lizard_ext/lizardexitcount.py,sha256=ziAVFi5RgjxJOwAQy6LzdZZflkvvxTiXOIp0FAL0wKQ,692
-lizard_ext/lizardgotocount.py,sha256=w2GWWwqVh4j7Fum41Wvg172b70JvtCm5BCzZUmmTlcM,514
-lizard_ext/lizardignoreassert.py,sha256=sqLwcnJQ06SYqIk901ib4NQ8ECwjIe_qL4T6z1wLXAk,644
-lizard_ext/lizardio.py,sha256=xQN-AgLGLKJarJkgfaqX_TKyupbb7GTcwPxrL2B1J1w,3357
-lizard_ext/lizardmccabe.py,sha256=RiO8ASmQUah4udOH8SbE2OOMxwShIPByW93TlFxXlQU,1274
-lizard_ext/lizardmodified.py,sha256=4Ld7yy1D2m2biMtx-g0DtjXwLa-9mG2togS2IRDAF3k,705
-lizard_ext/lizardnd.py,sha256=h4MaSsFAY5rK8kOSr61LkWntwJWV1KnhaEOWZgp3-c0,7496
-lizard_ext/lizardnonstrict.py,sha256=pPG22up2uh9rEkdRFtTWdiuOaiBNe0ZUjaZQpSTX5LE,394
-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=gScBFBQFiyhdj77Gb-x1hY6wABdKwZlb_aaNdiiADQ0,181
-lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
-lizard_languages/__init__.py,sha256=DniggHM3SOFlwkP8Tm4csEcisbf7_i1EvfoAkG9Atg0,1611
-lizard_languages/clike.py,sha256=_oDUbA1hEIPujKw3wyAtC1uFPvjmg4TBgKbHLa-S1wg,13597
-lizard_languages/code_reader.py,sha256=O0nZkI4xEHIWGgFBDwczj8-ay7aKllPnzRsblQtL3Gc,6874
-lizard_languages/csharp.py,sha256=EfFAIOIcJXUUhXTlZApXGSlzG34NZvHM9OSe6m7hpv0,2141
-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=sntz0jOEuj4klPipoTFd16UDK1fAUQfwK7YX_cLMZAc,1346
-lizard_languages/golike.py,sha256=vRIfjTVvc0VmJf27lTOLht55ZF1AQ9wn0Fvu-9WabWk,2858
-lizard_languages/java.py,sha256=HQBTZjUKbUJwgmtLYIzJrWtPpFP3ZdBP_NJK7YOXZC0,6424
-lizard_languages/javascript.py,sha256=vniCNMW-ea9Jpv6c8qCcjLVDYjT8VztjXigp5XRWt0E,317
-lizard_languages/js_style_regex_expression.py,sha256=Xgyogch4xElYtCG4EnBKvalHTl3tjRPcIIcIQRRd61I,1970
-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/perl.py,sha256=136w620eECe_t-kmlRUGrsZSxQNo2JQ_PZTSQfCSmHY,11987
-lizard_languages/php.py,sha256=UV40p8WzNC64NQ5qElPKzcFTjVt5kenLMz-eKYlcnMY,9940
-lizard_languages/plsql.py,sha256=17zf0AkDLFW7mA3ngUNrU7z6U6DkmA96CKOcEhYNC5Q,17137
-lizard_languages/python.py,sha256=AsL0SmQ73zhNS1iGi4Z8VtuUE0VjqBzo9W8W0mjqL0E,5790
-lizard_languages/r.py,sha256=IoyMhmFtUmTji6rm6-fqss_j_kvIHu3JjABRh6RNys0,12583
-lizard_languages/ruby.py,sha256=HL1ZckeuUUJU3QSVAOPsG_Zsl0C6X2PX5_VaWqclzkM,2277
-lizard_languages/rubylike.py,sha256=dAGZ2wqW8nqaESMU8HkeR9gwQ-q9fmZqE6AANvVZD1Q,3426
-lizard_languages/rust.py,sha256=WarDHnFZv99Yu3_C5DpZfLS8dVWz6AcOzo2dzLW94rA,817
-lizard_languages/scala.py,sha256=6Jr_TG945VYqB3o5weD7jN7S4beHt4aVj3r-fmKeMAM,1316
-lizard_languages/script_language.py,sha256=SKe45AbO6Z-axbN8KW_g7jf9g7YTXZ6dWzJj4ubDsM8,1172
-lizard_languages/solidity.py,sha256=Z0GD7U5bI5eUikdy7m_iKWeFD5yXRYq4r3zycscOhJQ,553
-lizard_languages/st.py,sha256=7fpOfNAoUjNY8RCHSYLufnOzZTUkKwjVvcyRyM1xP2Y,4160
-lizard_languages/swift.py,sha256=p8S2OAkQOx9YQ02yhoVXFkr7pMqUH1Nb3RVXPHRU_9M,2450
-lizard_languages/tnsdl.py,sha256=pGcalA_lHY362v2wwPS86seYBOOBBjvmU6vd4Yy3A9g,2803
-lizard_languages/tsx.py,sha256=1oOVCcz5yHkmYLYGhSarCMSXfGVasweklAqqapkuNR4,17160
-lizard_languages/ttcn.py,sha256=ygjw_raBmPF-4mgoM8m6CAdyEMpTI-n1kZJK1RL4Vxo,2131
-lizard_languages/typescript.py,sha256=unCDj040dY9fTOw9iIykqjt2j5tZWJ2Bm9fHYjOWY5I,14706
-lizard_languages/vue.py,sha256=KXUBUo2R1zNF8Pffrz_KsQEN44m5XFRMoGXylxKUeT0,1038
-lizard_languages/zig.py,sha256=NX1iyBstBuJFeAGBOAIaRfrmeBREne2HX6Pt4fXZZTQ,586
-lizard-1.19.0.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
-lizard-1.19.0.dist-info/METADATA,sha256=DNAVbhrtdVrI5tn2rWZoSBwCfZ5ArhMQ0XNmHvOqbh4,16697
-lizard-1.19.0.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
-lizard-1.19.0.dist-info/entry_points.txt,sha256=pPMMwoHAltzGHqR2WeJQItLeeyR7pbX5R2S_POC-xoo,40
-lizard-1.19.0.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
-lizard-1.19.0.dist-info/RECORD,,