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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.18.0
+Version: 1.19.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/
@@ -50,31 +50,32 @@ code analysis.
 
 A list of supported languages:
 
+-  C# (C Sharp)
 -  C/C++ (works with C++14)
+-  Erlang
+-  Fortran
+-  GDScript
+-  Golang
 -  Java
--  C# (C Sharp)
 -  JavaScript (With ES6 and JSX)
--  TypeScript (With TSX)
--  VueJS
+-  Kotlin
+-  Lua
 -  Objective-C
--  Swift
+-  Perl
+-  PHP
+-  PL/SQL
 -  Python
+-  R
 -  Ruby
--  TTCN-3
--  PHP
--  Scala
--  GDScript
--  Golang
--  Lua
 -  Rust
--  Fortran
--  Kotlin
+-  Scala
 -  Solidity
--  Erlang
--  Zig
--  Perl
 -  Structured Text (St)
--  R
+-  Swift
+-  TTCN-3
+-  TypeScript (With TSX)
+-  VueJS
+-  Zig
 
 By default lizard will search for any source code that it knows and mix
 all the results together. This might not be what you want. You can use
@@ -162,7 +163,7 @@ Options
                         search for all languages it knows. `lizard -l cpp -l java`searches for
                         C++ and Java code. The available languages are: cpp, java, csharp,
                         javascript, python, objectivec, ttcn, ruby, php, swift, scala, GDScript,
-                        go, lua, rust, typescript
+                        go, lua, rust, typescript, plsql
   -V, --verbose         Output in verbose mode (long function name)
   -C CCN, --CCN CCN     Threshold for cyclomatic complexity number warning. The default value is
                         15. Functions with CCN bigger than it will generate warning
@@ -197,7 +198,7 @@ Options
   -X, --xml             Generate XML in cppncss style instead of the tabular output. Useful to
                         generate report in Jenkins server
   --csv                 Generate CSV output as a transform of the default output
-  -H, --html            Output HTML report
+  -H, --html            Output HTML report with interactive DataTables (sortable, searchable, filterable)
   --checkstyle          Generate Checkstyle XML output for integration with Jenkins and other tools
   -m, --modified        Calculate modified cyclomatic complexity number , which count a
                         switch/case with multiple cases as one CCN.
@@ -415,5 +416,14 @@ Lizard is also used as a plugin for fastlane to help check code complexity and s
 - `European research project FASTEN (Fine-grained Analysis of SofTware Ecosystems as Networks, <http://fasten-project.eu/)>`_
   - `for a quality analyzer <https://github.com/fasten-project/quality-analyzer>`_
 
+How To Contribute
+-----------------
+
+Contributions are welcome. Please refer to the rules and development workflow in:
+
+- https://github.com/terryyin/lizard/tree/master/.cursor/rules
+
+These guidelines are usable by both AI assistants and human contributors — what works for AI works for "I" as well — to keep changes cohesive, simple, and well-tested.
+
 
 

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

@@ -5,7 +5,7 @@ lizard_ext/checkstyleoutput.py,sha256=UzDHg837ErEZepXkR8I8YCoz2r1lkmzGctMA7dpyB-
 lizard_ext/csvoutput.py,sha256=43fhmo8kB85qcdujCwySGNuTC4FkKUPLqIApPeljPnA,2663
 lizard_ext/default_ordered_dict.py,sha256=YbVz6nPlQ6DjWc_EOFBz6AJN2XLo9dpnUdeyejQvUDE,831
 lizard_ext/extension_base.py,sha256=rnjUL2mqSGToUVYydju7fa8ZwynLPY8S1F17gIJP55I,346
-lizard_ext/htmloutput.py,sha256=oavhEzCIJtoJrFveiWIp0pMAOwg4pukJ6l07IpmPiag,4426
+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
@@ -20,17 +20,17 @@ lizard_ext/lizardignoreassert.py,sha256=sqLwcnJQ06SYqIk901ib4NQ8ECwjIe_qL4T6z1wL
 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=2_uZkRlaM1mDLLW8yXtO7MtjMGklU8_Cy-6ocaILEuo,4391
+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=WiI5ub_2twuTf6tscOzwP6MNdZV6kq-ElL2-2HqdUXc,181
+lizard_ext/version.py,sha256=gScBFBQFiyhdj77Gb-x1hY6wABdKwZlb_aaNdiiADQ0,181
 lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
-lizard_languages/__init__.py,sha256=NsYspQ6h--XHMJrIcmOxlZRF4f_l5M7JprenLBz2oIE,1559
-lizard_languages/clike.py,sha256=RICnhzBzLbMwpceo3X-z7_-hcTZmGAZKGqpKgJf0G0o,13598
-lizard_languages/code_reader.py,sha256=IfEHg9lzKnyCipX9xscgyGEOovll5qr9dCe5cSX2sJM,6852
+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
@@ -45,6 +45,7 @@ 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
@@ -58,12 +59,12 @@ lizard_languages/swift.py,sha256=p8S2OAkQOx9YQ02yhoVXFkr7pMqUH1Nb3RVXPHRU_9M,245
 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=C8VWmHLGGYwCrP6hJ9HmJ-PETrKux4npjOzDN6AkTGU,12347
+lizard_languages/typescript.py,sha256=unCDj040dY9fTOw9iIykqjt2j5tZWJ2Bm9fHYjOWY5I,14706
 lizard_languages/vue.py,sha256=KXUBUo2R1zNF8Pffrz_KsQEN44m5XFRMoGXylxKUeT0,1038
 lizard_languages/zig.py,sha256=NX1iyBstBuJFeAGBOAIaRfrmeBREne2HX6Pt4fXZZTQ,586
-lizard-1.18.0.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
-lizard-1.18.0.dist-info/METADATA,sha256=BX2GeLwA0iQpWmDi0wYg4xXCTISh6Un8alaLcJhuRxc,16260
-lizard-1.18.0.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
-lizard-1.18.0.dist-info/entry_points.txt,sha256=pPMMwoHAltzGHqR2WeJQItLeeyR7pbX5R2S_POC-xoo,40
-lizard-1.18.0.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
-lizard-1.18.0.dist-info/RECORD,,
+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_ext/htmloutput.py

@@ -48,6 +48,12 @@ TEMPLATE = '''<!DOCTYPE HTML PUBLIC
  <head>
   <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
   <title>Code complexity report</title>
+  <!-- DataTables CSS -->
+  <link rel="stylesheet" type="text/css" href="https://cdn.datatables.net/1.13.4/css/jquery.dataTables.min.css">
+  <!-- jQuery -->
+  <script src="https://code.jquery.com/jquery-3.7.0.min.js"></script>
+  <!-- DataTables JS -->
+  <script src="https://cdn.datatables.net/1.13.4/js/jquery.dataTables.min.js"></script>
   <style>
     h2
     {
@@ -88,6 +94,42 @@ TEMPLATE = '''<!DOCTYPE HTML PUBLIC
           font-family: sans-serif;
           white-space: nowrap;
         }
+    td.file-header
+        {
+          background-color: LightBlue;
+          font-weight: bold;
+        }
+    td.function-name
+        {
+          background-color: LightSteelBlue;
+        }
+    /* DataTables wrapper styling */
+    .dataTables_wrapper {
+          margin: 0 auto;
+          width: 95%;
+        }
+    /* Fallback styling if DataTables CSS doesn't load */
+    table#complexityTable {
+          border-collapse: collapse;
+          width: 95%;
+          margin: 0 auto;
+        }
+    table#complexityTable th {
+          background-color: #4CAF50;
+          color: white;
+          padding: 10px;
+          text-align: left;
+          border: 1px solid #ddd;
+        }
+    table#complexityTable td {
+          border: 1px solid #ddd;
+        }
+    table#complexityTable tr:nth-child(even) {
+          background-color: #f2f2f2;
+        }
+    table#complexityTable tr:hover {
+          background-color: #ddd;
+        }
   </style>
  </head>
  <body>
@@ -95,26 +137,29 @@ TEMPLATE = '''<!DOCTYPE HTML PUBLIC
 
 <center>
 
-<table>
+<table id="complexityTable" class="display" style="width:100%">
+  <thead>
+    <tr>
+      <th>File</th>
+      <th>Function name</th>
+      <th>Cyclomatic complexity ({{ thresholds["cyclomatic_complexity"] }})</th>
+      <th>LOC ({{ thresholds["nloc"] }})</th>
+      <th>
+        {% if thresholds["token_count"] %}
+           Token count ({{ thresholds["token_count"] }})
+        {% else %}
+           Token count
+        {% endif %}
+      </th>
+      <th>Parameter count ({{ thresholds["parameter_count"] }})</th>
+    </tr>
+  </thead>
+  <tbody>
 {% for file in files %}
-  <tr><td colspan="7" style="background-color:LightBlue;">
-  Source file: <b>{{ file.filename }}</b></td></tr>
-{% if file.functions|length > 0 %}
-<tr><th>Function name</th><th></th><th>
-Cyclomatic complexity
-({{ thresholds["cyclomatic_complexity"] }})
-</th><th>LOC ({{ thresholds["nloc"] }})</th><th>
-    {% if thresholds["token_count"] %}
-       Token count ({{ thresholds["token_count"] }})
-    {% else %}
-       Token count
-    {% endif %}
-</th><th>Parameter count ({{ thresholds["parameter_count"] }})</th></tr>
-{% endif %}
   {% for func in file.functions %}
   <tr>
-    <td style="background-color:LightSteelBlue">{{ func.name }}</td>
-    <td></td>
+    <td>{{ file.filename }}</td>
+    <td class="function-name">{{ func.name }}</td>
     {% if func.cyclomatic_complexity > thresholds["cyclomatic_complexity"] %}
        <td class="greater-value">{{ func.cyclomatic_complexity }}</td>
     {% else %}
@@ -145,6 +190,7 @@ Cyclomatic complexity
   </tr>
   {% endfor %}
 {% endfor %}
+  </tbody>
 </table>
 <center>
 
@@ -154,6 +200,29 @@ Cyclomatic complexity
     <a href="http://www.lizard.ws/">Lizard</a> on {{ date }}
     </td></tr>
 </table>
+
+<script>
+// Gracefully degrade if CDN is unavailable
+if (typeof jQuery !== 'undefined' && typeof jQuery.fn.dataTable !== 'undefined') {
+    $(document).ready(function() {
+        try {
+            $('#complexityTable').DataTable({
+                "pageLength": 25,
+                "order": [[2, "desc"]],  // Sort by cyclomatic complexity descending by default
+                "columnDefs": [
+                    { "type": "num", "targets": [2, 3, 4, 5] }  // Ensure numeric sorting for metric columns
+                ]
+            });
+        } catch (e) {
+            console.warn('DataTables initialization failed. Displaying static table.', e);
+        }
+    });
+} else {
+    // Fallback: Table will display as static HTML
+    console.info('DataTables not available. Displaying static HTML table.');
+}
+</script>
+
  </body>
 </html>
 

lizard_ext/lizardnd.py

@@ -45,11 +45,43 @@ class LizardExtension(object):  # pylint: disable=R0903
         else:
             indent_indicator = ';'
         for token in tokens:
-            if token in loops:
+            # Handle opening parenthesis - start of condition
+            if token == '(':
+                reader.context.set_in_condition(True)
+                reader.context.increment_condition_depth()
+                reader.context.set_logical_operator_added(False)  # Reset for new condition
+            # Handle closing parenthesis - end of condition
+            elif token == ')':
+                reader.context.decrement_condition_depth()
+                if reader.context.get_condition_depth() == 0:
+                    reader.context.set_in_condition(False)
+                    reader.context.set_logical_operator_added(False)
+            
+            # Handle logical operators && and || within conditions
+            elif token in ('&&', '||'):
+                if reader.context.get_in_condition():
+                    # Only add nesting depth for the first logical operator in a condition
+                    # Subsequent && or || operators in the same condition don't add depth
+                    if not reader.context.get_logical_operator_added():
+                        l_depth = reader.context.add_nd_condition()
+                        if not reader.context.get_loop_status():
+                            reader.context.add_hidden_bracket_condition()
+                            reader.context.loop_bracket_status()
+                        reader.context.set_logical_operator_added(True)
+                else:
+                    # Not in a condition, treat as regular nesting
+                    l_depth = reader.context.add_nd_condition()
+                    if not reader.context.get_loop_status():
+                        reader.context.add_hidden_bracket_condition()
+                        reader.context.loop_bracket_status()
+            
+            # Handle other loop keywords (if, for, while, etc.)
+            elif token in loops and token not in ('&&', '||'):
                 l_depth = reader.context.add_nd_condition()
                 if not reader.context.get_loop_status():
                     reader.context.add_hidden_bracket_condition()
                     reader.context.loop_bracket_status()
+            
             if token == loop_indicator:
                 reader.context.loop_bracket_status()
             if token == bracket:
@@ -82,6 +114,7 @@ class NDFileInfoAddition(FileInfoBuilder):
         self.current_function.nesting_depth = 0
         self.current_function.hidden_bracket = 0
         self.current_function.bracket_loop = False
+        self.reset_condition_tracking()
 
     def add_hidden_bracket_condition(self, inc=1):
         self.current_function.hidden_bracket += inc
@@ -96,6 +129,33 @@ class NDFileInfoAddition(FileInfoBuilder):
     def get_loop_status(self):
         return self.current_function.bracket_loop
 
+    def set_in_condition(self, in_condition):
+        self.current_function.in_condition = in_condition
+
+    def get_in_condition(self):
+        return self.current_function.in_condition
+
+    def increment_condition_depth(self):
+        self.current_function.condition_depth += 1
+
+    def decrement_condition_depth(self):
+        if self.current_function.condition_depth > 0:
+            self.current_function.condition_depth -= 1
+
+    def get_condition_depth(self):
+        return self.current_function.condition_depth
+
+    def reset_condition_tracking(self):
+        self.current_function.in_condition = False
+        self.current_function.condition_depth = 0
+        self.current_function.logical_operator_added = False
+
+    def set_logical_operator_added(self, added):
+        self.current_function.logical_operator_added = added
+
+    def get_logical_operator_added(self):
+        return self.current_function.logical_operator_added
+
 
 def get_method(cls, name):
     """ python3 doesn't need the __func__ to get the func of the
@@ -127,6 +187,9 @@ def _init_nesting_depth_data(self, *_):
     self.max_nesting_depth = 0
     self.hidden_bracket = 0
     self.bracket_loop = False
+    self.in_condition = False  # Track if we're inside a condition
+    self.condition_depth = 0   # Track nesting depth within conditions
+    self.logical_operator_added = False  # Track if we've added nesting for logical operators in current condition
 
 
 patch(NDFileInfoAddition, FileInfoBuilder)

lizard_ext/version.py

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

lizard_languages/__init__.py

@@ -26,6 +26,7 @@ from .vue import VueReader
 from .perl import PerlReader
 from .st import StReader
 from .r import RReader
+from .plsql import PLSQLReader
 
 
 def languages():
@@ -56,6 +57,7 @@ def languages():
         PerlReader,
         StReader,
         RReader,
+        PLSQLReader,
     ]
 
 

lizard_languages/clike.py

@@ -54,7 +54,7 @@ class CLikeReader(CodeReader, CCppCommentsMixin):
                     elif macro.group(1) == 'include':
                         yield "#include"
                         yield macro.group(2) or "\"\""
-                    for _ in macro.group(2).splitlines()[1:]:
+                    for _ in macro.group(2).split('\n')[1:]:
                         yield '\n'
                 else:
                     yield token

lizard_languages/code_reader.py

@@ -138,7 +138,7 @@ class CodeReader:
                 r"|\/\/" + _until_end +
                 r"|\#" +
                 r"|:=|::|\*\*" +
-                r"|\<\s*\?(?:\s*extends\s+\w+)?\s*\>" +
+                r"|\<(?=(?:[^<>]*\?)+[^<>]*\>)(?:[\w\s,.?]|(?:extends))+\>" +
                 r"|" + r"|".join(re.escape(s) for s in combined_symbols) +
                 r"|\\\n" +
                 r"|\n" +

lizard_languages/plsql.py

@@ -0,0 +1,419 @@
+"""
+Language parser for PL/SQL (Oracle's Procedural Language extension to SQL)
+
+This module implements complexity analysis for PL/SQL code, supporting:
+- Procedures, Functions, and Triggers
+- Package Bodies (not specifications - they only contain signatures)
+- Nested procedures and functions
+- Anonymous blocks with nested functions (blocks themselves aren't counted)
+- Control structures: IF/ELSIF/ELSE, CASE/WHEN, LOOP/WHILE/FOR
+- Exception handlers
+- Cursor declarations and cursor FOR loops
+
+Design Decisions:
+- EXIT WHEN: The WHEN keyword is filtered out by the preprocessor because
+  "EXIT WHEN condition" is not a branching construct - it's a conditional
+  exit that doesn't create alternate execution paths. The LOOP itself adds
+  complexity.
+
+- CONTINUE WHEN: Similar to EXIT WHEN, the WHEN is counted as it does create
+  a branch in the loop execution.
+
+- GOTO: Does not add to cyclomatic complexity as it's just an unconditional
+  jump, not a decision point.
+
+- Standalone LOOP: Adds +1 complexity as it creates a repeating path.
+
+- FOR/WHILE LOOP: The FOR/WHILE keyword adds complexity; the following LOOP
+  keyword is part of the same construct and doesn't add additional complexity.
+
+- Parameter Counting: Currently counts all non-whitespace tokens and commas
+  in parameter lists. This approach works but differs from some other language
+  implementations.
+"""
+
+from .code_reader import CodeReader, CodeStateMachine
+from .clike import CCppCommentsMixin
+
+
+class PLSQLReader(CodeReader, CCppCommentsMixin):
+    """
+    Reader for PL/SQL language supporting procedures, functions, packages,
+    and core control structures.
+    """
+
+    ext = ["sql", "pks", "pkb", "pls", "plb", "pck"]
+    language_names = ["plsql", "pl/sql"]
+
+    # PL/SQL conditions for cyclomatic complexity
+    # 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"}
+
+    def __init__(self, context):
+        super(PLSQLReader, self).__init__(context)
+        self.parallel_states = [PLSQLStates(context)]
+        # PL/SQL is case-insensitive, so add both lowercase and uppercase versions
+        # of keywords to the conditions set for the automatic condition counter
+        self.conditions = self.conditions | {c.upper() for c in self.conditions}
+
+    def preprocess(self, tokens):
+        """
+        Preprocess tokens to handle PL/SQL-specific constructs.
+        Merge compound keywords to prevent the condition counter from double-counting:
+        - "END IF", "END LOOP", "END CASE", "END WHILE", "END FOR" -> single tokens
+        - "EXIT WHEN" -> remove the WHEN keyword (EXIT doesn't create a branch)
+        """
+        last_nonwhitespace_token = None
+        pending_tokens = []
+
+        for token in tokens:
+            if not token.isspace() or token == "\n":
+                token_upper = token.upper()
+
+                # Handle "END IF", "END LOOP", etc.
+                if (
+                    last_nonwhitespace_token
+                    and last_nonwhitespace_token.upper() == "END"
+                ):
+                    if token_upper in ("IF", "LOOP", "CASE", "WHILE", "FOR"):
+                        # Merge into "END_IF", "END_LOOP", etc.
+                        yield "END_" + token_upper
+                        last_nonwhitespace_token = None
+                        pending_tokens = []
+                        continue
+
+                # Handle "EXIT WHEN" - skip the WHEN keyword
+                if (
+                    last_nonwhitespace_token
+                    and last_nonwhitespace_token.upper() == "EXIT"
+                    and token_upper == "WHEN"
+                ):
+                    # Skip this WHEN keyword
+                    pending_tokens = []
+                    continue
+
+                # Yield any pending tokens
+                if last_nonwhitespace_token:
+                    yield last_nonwhitespace_token
+                for pending in pending_tokens:
+                    yield pending
+                pending_tokens = []
+
+                # Update tracking
+                last_nonwhitespace_token = token
+            else:
+                # Accumulate whitespace
+                pending_tokens.append(token)
+
+        # Don't forget the last tokens
+        if last_nonwhitespace_token:
+            yield last_nonwhitespace_token
+        for pending in pending_tokens:
+            yield pending
+
+    @staticmethod
+    def generate_tokens(source_code, addition="", token_class=None):
+        """
+        Generate tokens for PL/SQL code.
+        PL/SQL uses:
+        - Single-line comments: --
+        - Multi-line comments: /* */
+        - String literals: 'text' (with '' for escaping)
+        - Assignment operator: :=
+        """
+        # Add PL/SQL-specific patterns
+        addition = r"|--[^\n]*" + addition  # Single-line comment starting with --
+        return CodeReader.generate_tokens(source_code, addition, token_class)
+
+    def get_comment_from_token(self, token):
+        """
+        Override to recognize PL/SQL's -- line comments in addition to /* */ block comments.
+        PL/SQL uses -- for single-line comments (like SQL standard).
+
+        Note: This method correctly identifies -- comments, but due to a limitation in
+        the NLOC calculation, these comments may still be counted in NLOC.
+        """
+        if token.startswith("--"):
+            return token  # Return full comment token (like Lua does)
+        # Delegate to parent for /* */ and // comments
+        return super().get_comment_from_token(token)
+
+
+class PLSQLStates(CodeStateMachine):
+    """
+    State machine for parsing PL/SQL code structure.
+    """
+
+    def __init__(self, context):
+        super(PLSQLStates, self).__init__(context)
+        self.in_parameter_list = False
+        self.last_control_keyword = None  # Track FOR/WHILE to avoid counting their LOOP
+        self.declaring_nested_function = (
+            False  # Track if we're declaring a nested function
+        )
+
+    def _state_global(self, token):
+        """Global state - looking for function/procedure/trigger declarations."""
+        token_lower = token.lower()
+
+        if token_lower == "procedure":
+            self.next(self._procedure_name)
+        elif token_lower == "function":
+            self.next(self._function_name)
+        elif token_lower == "trigger":
+            self.next(self._trigger_name)
+
+    def _procedure_name(self, token):
+        """Read procedure name."""
+        if token.isspace() or token == "\n":
+            return
+        if token == "(":
+            self.in_parameter_list = True
+            self.next(self._parameters, "(")
+        elif token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        else:
+            # Check if this is a nested function
+            if self.declaring_nested_function:
+                self.context.push_new_function(token)
+                self.declaring_nested_function = False
+            else:
+                self.context.try_new_function(token)
+            self.next(self._procedure_after_name)
+
+    def _procedure_after_name(self, token):
+        """After procedure name, look for parameters or IS/AS."""
+        if token == ".":
+            # Schema-qualified name: the previous token was the schema,
+            # next non-whitespace token will be the actual procedure name
+            self.next(self._procedure_name_after_dot)
+        elif token == "(":
+            self.in_parameter_list = True
+            self.next(self._parameters, "(")
+        elif token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        # Skip whitespace and other tokens
+
+    def _procedure_name_after_dot(self, token):
+        """Read the actual procedure name after schema.dot."""
+        if token.isspace() or token == "\n":
+            return
+        # Replace the previous (schema) name with the actual procedure name
+        self.context.current_function.name = token
+        self.next(self._procedure_after_name)
+
+    def _function_name(self, token):
+        """Read function name."""
+        if token.isspace() or token == "\n":
+            return
+        if token == "(":
+            self.in_parameter_list = True
+            self.next(self._parameters, "(")
+        elif token.lower() == "return":
+            self.next(self._return_type)
+        elif token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        else:
+            # Check if this is a nested function
+            if self.declaring_nested_function:
+                self.context.push_new_function(token)
+                self.declaring_nested_function = False
+            else:
+                self.context.try_new_function(token)
+            self.next(self._function_after_name)
+
+    def _function_after_name(self, token):
+        """After function name, look for parameters, RETURN, or IS/AS."""
+        if token == ".":
+            # Schema-qualified name: the previous token was the schema,
+            # next non-whitespace token will be the actual function name
+            self.next(self._function_name_after_dot)
+        elif token == "(":
+            self.in_parameter_list = True
+            self.next(self._parameters, "(")
+        elif token.lower() == "return":
+            self.next(self._return_type)
+        elif token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        # Skip whitespace and other tokens
+
+    def _function_name_after_dot(self, token):
+        """Read the actual function name after schema.dot."""
+        if token.isspace() or token == "\n":
+            return
+        # Replace the previous (schema) name with the actual function name
+        self.context.current_function.name = token
+        self.next(self._function_after_name)
+
+    def _return_type(self, token):
+        """Skip return type declaration."""
+        if token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        # Skip everything else (return type tokens)
+
+    def _parameters(self, token):
+        """Read parameters."""
+        if token == ")":
+            self.in_parameter_list = False
+            self.next(self._after_parameters)
+        elif token == ",":
+            # Each comma separates parameters
+            self.context.parameter(token)
+        elif not token.isspace() and token != "\n":
+            # Track non-whitespace tokens as potential parameters
+            self.context.parameter(token)
+
+    def _after_parameters(self, token):
+        """After parameters, look for IS/AS or RETURN."""
+        if token.lower() == "return":
+            self.next(self._return_type)
+        elif token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        # Skip whitespace and other tokens
+
+    def _trigger_name(self, token):
+        """Read trigger name."""
+        if token.isspace() or token == "\n":
+            return
+        # Trigger name found
+        self.context.try_new_function(token)
+        self.seen_trigger_name_token = False  # Track if we've seen non-whitespace after name
+        self.next(self._trigger_after_name)
+
+    def _trigger_after_name(self, token):
+        """After trigger name, skip until DECLARE or BEGIN."""
+        token_lower = token.lower()
+
+        # Only check for dot immediately after trigger name (before any other tokens)
+        if token == "." and not self.seen_trigger_name_token:
+            # Schema-qualified name: the previous token was the schema,
+            # next non-whitespace token will be the actual trigger name
+            self.next(self._trigger_name_after_dot)
+            return
+
+        # Mark that we've seen a non-whitespace token after the trigger name
+        if not token.isspace() and token != "\n":
+            self.seen_trigger_name_token = True
+
+        if token_lower == "declare":
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        elif token_lower == "begin":
+            self.context.confirm_new_function()
+            self.br_count = 1
+            self.next(self._state_body)
+        # Skip everything else (BEFORE/AFTER, INSERT/UPDATE/DELETE, ON table_name, FOR EACH ROW, etc.)
+
+    def _trigger_name_after_dot(self, token):
+        """Read the actual trigger name after schema.dot."""
+        if token.isspace() or token == "\n":
+            return
+        # Replace the previous (schema) name with the actual trigger name
+        self.context.current_function.name = token
+        self.seen_trigger_name_token = False  # Reset for the real trigger name
+        self.next(self._trigger_after_name)
+
+    def _state_before_begin(self, token):
+        """
+        State between IS/AS and BEGIN - this is the declaration section.
+        Watch for nested procedures/functions and the BEGIN keyword.
+        """
+        token_lower = token.lower()
+
+        # Check for nested procedure/function declarations
+        if token_lower == "procedure":
+            self.declaring_nested_function = True
+            # Store current br_count level to know when nested function ends
+            if not hasattr(self, "nested_br_level"):
+                self.nested_br_level = 0
+            self.next(self._procedure_name)
+            return
+        elif token_lower == "function":
+            self.declaring_nested_function = True
+            # Store current br_count level to know when nested function ends
+            if not hasattr(self, "nested_br_level"):
+                self.nested_br_level = 0
+            self.next(self._function_name)
+            return
+        elif token_lower == "begin":
+            # Start of the implementation body
+            # Check if we had nested functions and need to reset br_count tracking
+            if hasattr(self, "nested_br_level"):
+                self.br_count = self.nested_br_level + 1
+                delattr(self, "nested_br_level")
+            else:
+                self.br_count = 1  # Initialize counter for the first BEGIN
+            self.next(self._state_body)
+
+    def _state_body(self, token):
+        """
+        Process function/procedure body.
+        Track control structures for cyclomatic complexity.
+        Manually track BEGIN/END blocks.
+        """
+        token_lower = token.lower()
+        token_upper = token.upper()
+
+        # Check for merged compound keywords like "END_IF", "END_LOOP", etc.
+        # These are created by the preprocessor
+        if token_lower.startswith("end_"):
+            # This is a compound END keyword, reset tracking
+            self.last_control_keyword = None
+            return
+
+        # Handle nested procedure/function declarations
+        if token_lower == "procedure":
+            self.next(self._procedure_name)
+            return
+        elif token_lower == "function":
+            self.next(self._function_name)
+            return
+
+        # Track FOR and WHILE to know when LOOP follows them
+        if token_upper in ("FOR", "WHILE"):
+            self.last_control_keyword = token_upper
+
+        # Handle LOOP keyword manually
+        # - Standalone LOOP adds +1 complexity
+        # - LOOP after FOR/WHILE does not add complexity (already counted for FOR/WHILE)
+        elif token_upper == "LOOP":
+            if self.last_control_keyword not in ("FOR", "WHILE"):
+                # This is a standalone LOOP, add complexity
+                self.context.add_condition()
+            # Reset tracking after processing LOOP
+            self.last_control_keyword = None
+
+        # PL/SQL uses BEGIN/END instead of {}
+        if token_lower == "begin":
+            self.br_count += 1
+            self.context.add_bare_nesting()
+        elif token_lower == "end":
+            # This is a standalone END (for BEGIN/END block)
+            self.br_count -= 1
+            if self.br_count == 0:
+                # This END closes the function/procedure
+                # Check if we have a parent function BEFORE ending (stack gets popped)
+                has_parent = len(self.context.stacked_functions) > 0
+                self.context.end_of_function()
+                # Return to appropriate state based on whether this was nested
+                if has_parent:
+                    # Return to parent function's declaration section
+                    self.next(self._state_before_begin)
+                else:
+                    # No parent function, return to global
+                    self.next(self._state_global)
+                return
+            else:
+                self.context.pop_nesting()
+
+        # Note: Basic conditions (if, elsif, when, while, for, and, or)
+        # are automatically counted by the condition_counter processor
+        # based on the _conditions set in the Reader class.

lizard_languages/typescript.py

@@ -128,6 +128,9 @@ class TypeScriptStates(CodeStateMachine):
         self._getter_setter_prefix = None
         self.arrow_function_pending = False
         self._ts_declare = False  # Track if 'declare' was seen
+        self._static_seen = False  # Track if 'static' was seen
+        self._async_seen = False  # Track if 'async' was seen
+        self._prev_token = ''  # Track previous token to detect method calls
 
     def statemachine_before_return(self):
         # Ensure the main function is closed at the end
@@ -152,6 +155,20 @@ class TypeScriptStates(CodeStateMachine):
             return
         self._ts_declare = False
 
+        # Track static and async modifiers
+        if token == 'static':
+            self._static_seen = True
+            self._prev_token = token
+            return
+        if token == 'async':
+            self._async_seen = True
+            self._prev_token = token
+            return
+        if token == 'new':
+            # Track 'new' keyword to avoid treating constructors as functions
+            self._prev_token = token
+            return
+
         if self.as_object:
             # Support for getter/setter: look for 'get' or 'set' before method name
             if token in ('get', 'set'):
@@ -169,15 +186,26 @@ class TypeScriptStates(CodeStateMachine):
                 self.function_name = self.last_tokens
                 return
             elif token == '(':
+                # Check if this is a method call (previous token was . or this/identifier)
+                if self._prev_token == '.' or self._prev_token == 'new':
+                    # This is a method call, not a function definition
+                    self._prev_token = token
+                    return
                 if not self.started_function:
                     self.arrow_function_pending = True
                     self._function(self.last_tokens)
                 self.next(self._function, token)
                 return
+            # If we've seen async/static and this is an identifier, it's likely a method name
+            elif (self._async_seen or self._static_seen) and token not in ('*', 'function'):
+                # This is a method name after async/static
+                self.last_tokens = token
+                return
 
         if token in '.':
             self._state = self._field
             self.last_tokens += token
+            self._prev_token = token
             return
         if token == 'function':
             self._state = self._function
@@ -191,8 +219,14 @@ class TypeScriptStates(CodeStateMachine):
         elif token == '=':
             self.function_name = self.last_tokens
         elif token == "(":
-            self.sub_state(
-                self.__class__(self.context))
+            # Check if this is a method call or constructor
+            if self._prev_token == '.' or self._prev_token == 'new':
+                # This is a method call or constructor, not a function definition
+                self.sub_state(
+                    self.__class__(self.context))
+            else:
+                self.sub_state(
+                    self.__class__(self.context))
         elif token in '{':
             if self.started_function:
                 self.sub_state(
@@ -205,14 +239,21 @@ class TypeScriptStates(CodeStateMachine):
         elif self.context.newline or token == ';':
             self.function_name = ''
             self._pop_function_from_stack()
+            # Reset modifiers on newline/semicolon
+            self._static_seen = False
+            self._async_seen = False
 
         if token == '`':
             self.next(self._state_template_literal)
         if not self.as_object:
             if token == ':':
                 self._consume_type_annotation()
+                self._prev_token = token
                 return
         self.last_tokens = token
+        # Don't overwrite _prev_token if it's 'new' or '.' (preserve for next token)
+        if self._prev_token not in ('new', '.'):
+            self._prev_token = token
 
     def read_object(self):
         def callback():
@@ -220,7 +261,13 @@ class TypeScriptStates(CodeStateMachine):
 
         object_reader = self.__class__(self.context)
         object_reader.as_object = True
+        # Pass along the modifier flags
+        object_reader._static_seen = self._static_seen
+        object_reader._async_seen = self._async_seen
         self.sub_state(object_reader, callback)
+        # Reset modifiers after entering object
+        self._static_seen = False
+        self._async_seen = False
 
     def _expecting_condition_and_statement_block(self, token):
         def callback():
@@ -269,6 +316,9 @@ class TypeScriptStates(CodeStateMachine):
             return
         if token != '(':
             self.function_name = token
+            # Reset modifiers after setting function name
+            self._static_seen = False
+            self._async_seen = False
         else:
             if not self.started_function:
                 self._push_function_to_stack()