lizard 1.19.0__tar.gz → 1.20.0__tar.gz

{lizard-1.19.0 → lizard-1.20.0}/PKG-INFO

@@ -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 → lizard-1.20.0}/lizard.egg-info/PKG-INFO

@@ -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 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/lizard_ext/version.py

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

{lizard-1.19.0 → lizard-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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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-1.19.0 → lizard-1.20.0}/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 → lizard-1.20.0}/test/testNestedStructures.py

@@ -375,6 +375,61 @@ class TestCppNestedStructures(unittest.TestCase):
         """)
         self.assertEqual(1, result[0].max_nested_structures)
 
+    def test_raw_string_literal_with_braces(self):
+        """Raw string literals containing braces should not cause IndexError."""
+        result = process_cpp(r'''
+        int main() {
+            const char* json = R"({
+  "name": "Ada Lovelace",
+  "id": 101,
+  "languages": ["C++", "Python", "Assembly"],
+  "active": true,
+  "profile": {
+    "bio": "Mathematician & pioneer",
+    "links": {
+      "website": "https://example.com/ada",
+      "github": "https://github.com/ada"
+    }
+  }
+})";
+            for (int i = 1; i <= 3; ++i) {
+                for (int j = 1; j <= 3; ++j) {
+                    return i + j;
+                }
+            }
+            return 0;
+        }
+        ''')
+        self.assertEqual(2, result[0].max_nested_structures)
+
+    def test_raw_string_literal_with_delimiter(self):
+        """Raw string literals with delimiters should be handled correctly."""
+        result = process_cpp(r'''
+        int fun() {
+            const char* s = R"delim(some {content} with )delim";
+            if (true) {
+                return 1;
+            }
+            return 0;
+        }
+        ''')
+        self.assertEqual(1, result[0].max_nested_structures)
+
+    def test_raw_string_literal_simple(self):
+        """Simple raw string literals should not interfere with complexity counting."""
+        result = process_cpp(r'''
+        int fun() {
+            const char* s = R"(hello world)";
+            if (a) {
+                if (b) {
+                    return c;
+                }
+            }
+            return 0;
+        }
+        ''')
+        self.assertEqual(2, result[0].max_nested_structures)
+
 
 class X: #TestPythonNestedStructures(unittest.TestCase):