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

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.19.0
+Version: 1.20.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/
 Author: Terry Yin
 Author-email: terry@odd-e.com
 License: MIT
+Download-URL: https://pypi.python.org/lizard/
 Project-URL: Source, https://github.com/terryyin/lizard
 Platform: any
 Classifier: Development Status :: 5 - Production/Stable

{lizard-1.19.0.dist-info → lizard-1.20.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 lizard.py,sha256=B0g5lEp5me31bQpjfMKVayF0iUfH0PalVecOKeUX3-A,41365
-lizard_ext/__init__.py,sha256=AkZYVqCgd7XX1hMwLMyh_ABm9geIHmobEch-thYXZz8,932
+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
@@ -8,7 +8,7 @@ lizard_ext/extension_base.py,sha256=rnjUL2mqSGToUVYydju7fa8ZwynLPY8S1F17gIJP55I,
 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/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
@@ -18,53 +18,53 @@ lizard_ext/lizardexitcount.py,sha256=ziAVFi5RgjxJOwAQy6LzdZZflkvvxTiXOIp0FAL0wKQ
 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/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=pPG22up2uh9rEkdRFtTWdiuOaiBNe0ZUjaZQpSTX5LE,394
-lizard_ext/lizardns.py,sha256=8pztUoRS_UWN24MawwxeHEJgYh49id5PWODUBb6O72U,4184
+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=gScBFBQFiyhdj77Gb-x1hY6wABdKwZlb_aaNdiiADQ0,181
+lizard_ext/version.py,sha256=-BXaaeyLOLQJRgob-W_0qvVq5YJw_YJGMzo50rFVFAc,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/clike.py,sha256=msdvIm5WAlczPUEtl8tK7xobWxxwow1gxgxjr3qURPo,13834
+lizard_languages/code_reader.py,sha256=a5JxBQ_4HAeXiWHfLb6o6aCGJCCIAESRLjJcl3Zx-SY,7875
+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=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/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=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/perl.py,sha256=lxxdC0KJsr3tmNLMATO7vx3O7yWGgICxHxVTfmu7db8,12111
+lizard_languages/php.py,sha256=BIIxdKd-yeaqIjxw3yoq2ZFlhqQ-F1NNK26BOfRbO5U,10093
+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=dAGZ2wqW8nqaESMU8HkeR9gwQ-q9fmZqE6AANvVZD1Q,3426
-lizard_languages/rust.py,sha256=WarDHnFZv99Yu3_C5DpZfLS8dVWz6AcOzo2dzLW94rA,817
-lizard_languages/scala.py,sha256=6Jr_TG945VYqB3o5weD7jN7S4beHt4aVj3r-fmKeMAM,1316
+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=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/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=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,,
+lizard_languages/zig.py,sha256=RiDZyjnCn97jqFmcl5EQl7pbuH0G1oI2Qo72EXvdtDU,813
+lizard-1.20.0.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
+lizard-1.20.0.dist-info/METADATA,sha256=36pI9t3KO-tvapXxKTbrX1Gc465zs1zQqubteXPS4fY,16697
+lizard-1.20.0.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
+lizard-1.20.0.dist-info/entry_points.txt,sha256=pPMMwoHAltzGHqR2WeJQItLeeyR7pbX5R2S_POC-xoo,40
+lizard-1.20.0.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
+lizard-1.20.0.dist-info/RECORD,,

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.20.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)

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/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

@@ -231,8 +231,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)