comment_strip-ruby 0.1.2.1 → 0.2.1

data/lib/comment_strip/language_families/c.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
 # ######################################################################## #
-# File:         comment_strip/language_families/c.rb
+# File:     comment_strip/language_families/c.rb
 #
-# Purpose:      Definition of strip() function for C-family languages.
+# Purpose:  Definition of strip() function for C-family languages.
 #
-# Created:      14th September 2020
-# Updated:      11th July 2022
+# Created:  14th September 2020
+# Updated:  30th August 2026
 #
-# Home:         http://github.com/synesissoftware/comment_strip.r
+# Home:     https://github.com/synesissoftware/comment_strip.r
 #
-# Copyright (c) 2020-2022, Matthew Wilson and Synesis Information Systems
+# Copyright (c) 2020-2026, Matthew Wilson and Synesis Information Systems
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -47,200 +48,324 @@ module LanguageFamilies
 
 module C
 
-    def self.strip input, lf, **options
+  def self.decimal_digit? character
 
-        return nil if input.nil?
-        return input if input.empty?
+    character && character >= ?0 && character <= ?9
+  end
 
-        line    =   0
-        column  =   0
+  def self.identifier_character? character
 
-        state   =   :text
+    return false unless character
 
-        r       =   ''
+    case character
+    when ?a..?z, ?A..?Z, ?0..?9, '_'
+      true
+    else
+      false
+    end
+  end
+
+  def self.strip input, lf, **options
+
+    return input if input.nil?
+    return input if input.empty?
+
+    line    =   0
+    column  =   0
+
+    # States:
+    #
+    # - :c_comment              - in a C comment, i.e. from immediately after "/*"
+    # - :c_comment_star         - in a C comment when just received '*', e.g. from immediately after "/* comment *"
+    # - :cpp_comment            - in a C++ comment, i.e. from immediately after "//"
+    # - :dq_string              - within a double-quoted string
+    # - :dq_string_escape       - within a double-quoted string when just received a '"', e.g. from immediately after '"the next word is quoted \'
+    # - :raw_string             - within a C++ raw string
+    # - :raw_string_closing     - waiting for the final '"' in a C++ raw string
+    # - :backtick_string        - within a Go raw string
+    # - :backtick_string_open   - waiting for the opening '`' in a Go raw string
+    # - :lifetime               - within a Rust lifetime name
+    # - :verbatim_string        - within a C# verbatim string
+    # - :verbatim_string_open   - waiting for the opening '"' in a C# verbatim string
+    # - :verbatim_string_quote  - waiting to determine whether a C# quote is doubled
+    # - :slash_start            - having found a slash (not in a string)
+    # - :sq_string_closing      - waiting for final '\'' in a single-quoted string
+    # - :sq_string_escape       - within a escaped single-quoted string, i.e. from immediately after "'\"
+    # - :sq_string_open         - within a single-quoted string, i.e. from immediately after "'"
+    # - :text                   - regular part of the code
+
+    state   =   :text
+
+    r       =   String.new
+    r.force_encoding input.encoding
+
+    cc_lines =   0
+    previous_was_cr = false
+
+    i = 0
+    while i < input.length
+      c = input[i]
+
+      if ?\\ == c
+        next_c = input[i + 1]
+
+        if ?\n == next_c
+          i += 2
+          previous_was_cr = false
+          next
+        elsif ?\r == next_c
+          i += 2
+          previous_was_cr = false
+
+          if ?\n == input[i]
+            i += 1
+            next
+          end
+
+          next if i >= input.length
+
+          c = input[i]
+        end
+      end
 
-        cc_lines =   0
+      case c
+      when ?\r, ?\n
 
-        input.each_char do |c|
+        line += 1 unless ?\n == c && previous_was_cr
+        column = 0
+      else
 
-            case c
-            when ?\r, ?\n
+        column += 1
+      end
 
-                line += 1
-                column = 0
-            else
+      skip = false
 
-                column += 1
-            end
+      if :text == state && 'R' == c && '"' == input[i + 1] && '(' == input[i + 2]
+        state = :raw_string
+      elsif :text == state && '@' == c && '"' == input[i + 1]
+        state = :verbatim_string_open
+      elsif :text == state && i > 0 && '<' == input[i - 1] && input[i + 1] && input[i + 1] >= ?a && input[i + 1] <= ?z
+        state = :lifetime
+      elsif :text == state && '`' == c
+        state = :backtick_string_open
+      end
 
-            skip = false
+      case c
+      when ?\r, ?\n
 
-            case c
-            when ?\r, ?\n
+        case state
+        when :c_comment, :c_comment_star
 
-                case state
-                when :c_comment, :c_comment_star
+          cc_lines += 1 unless ?\n == c && previous_was_cr
 
-                    cc_lines += 1
+          state = :c_comment
+        when :cpp_comment
 
-                    state = :c_comment
-                when :cpp_comment
+          state = :text
+        when :sq_string_escape, :sq_string_closing
 
-                    state = :text
-                when :sq_string, :sq_string_escape, :sq_string_closing
+          state = :text
+        when :dq_string_escape
 
-                    state = :text
-                when :dq_string_escape
+          state = :dq_string
+        when :slash_start
 
-                    state = :dq_string
-                when :slash_start
+          r << '/'
 
-                    r << '/'
+          state = :text
+        end
+      else
 
-                    state = :text
-                end
-            else
+        # special cases:
+        #
+        # - for escaped single/double quote
+        # - for slash-start
+        # - for comment-star
 
-                # special cases:
-                #
-                # - for escaped single/double quote
-                # - for slash-start
-                # - for comment-star
+        case state
+        when :backtick_string_open
 
-                case state
-                when :sq_string_open
+          state = :backtick_string if '`' == c
+        when :backtick_string
 
-                    state = (?\\ == c) ? :sq_string_escape : :sq_string_closing
-                when :sq_string_escape
+          state = :text if '`' == c
+        when :lifetime
 
-                    state = :sq_string_closing
-                when :dq_string_escape
+          if !identifier_character?(c)
+            state = :text
+          elsif !identifier_character?(input[i + 1])
+            state = :text
+          end
+        when :verbatim_string_open
 
-                    state = :dq_string
-                when :c_comment_star
+          state = :verbatim_string if '"' == c
+        when :verbatim_string
 
-                    case c
-                    when ?/
+          if '"' == c
+            state = :verbatim_string_quote if '"' == input[i + 1]
+            state = :text unless '"' == input[i + 1]
+          end
+        when :verbatim_string_quote
 
-                        r << ?\n * cc_lines
-                        cc_lines = 0
+          state = :verbatim_string if '"' == c
+        when :raw_string
 
-                        state = :text
-                        skip = true
-                    when '*'
+          state = :raw_string_closing if ')' == c && '"' == input[i + 1]
+        when :raw_string_closing
 
-                        ;
-                    else
+          state = :text if '"' == c
+        when :sq_string_open
 
-                        state = :c_comment
-                    end
-                else
+          state = (?\\ == c) ? :sq_string_escape : :sq_string_closing
+        when :sq_string_escape
 
-                    if false
-                    elsif state == :slash_start && ('/' != c && '*' != c)
+          state = :sq_string_closing
+        when :dq_string_escape
 
-                        state = :text
-                        r << '/'
-                    else
+          state = :dq_string
+        when :c_comment_star
 
-                        case c
-                        when '/'
+          case c
+          when ?/
 
-                            case state
-                            when :text
+            r << ?\n * cc_lines
+            cc_lines = 0
 
-                                state = :slash_start
-                            when :slash_start
+            state = :text
+            skip = true
+          when '*'
 
-                                state = :cpp_comment
-                            when :c_comment_star
+            ;
+          else
 
-                                r << ?\n * cc_lines
-                                cc_lines = 0
+            state = :c_comment
+          end
+        else
 
-                                state = :text
-                                skip = true
-                            end
-                        when '*'
+          if false
+          elsif state == :slash_start && ('/' != c && '*' != c)
 
-                            case state
-                            when :slash_start
+            state = :text
+            r << '/'
+          else
 
-                                state = :c_comment
-                            when :c_comment
+            case c
+            when '/'
 
-                                state = :c_comment_star
-                            else
+              case state
+              when :text
 
-                            end
+                state = :slash_start
+              when :slash_start
 
-                        when ?\'
+                state = :cpp_comment
+              when :c_comment_star
 
-                            case state
-                            when :text
+                r << ?\n * cc_lines
+                cc_lines = 0
 
-                                state = :sq_string_open
-                            when :sq_string_closing
+                state = :text
+                skip = true
+              else
 
-                                state = :text
-                            else
+                ;
+              end
+            when '*'
 
-                            end
-                        when '"'
+              case state
+              when :slash_start
 
-                            case state
-                            when :text
+                state = :c_comment
+              when :c_comment
 
-                                state = :dq_string
-                            when :dq_string
+                state = :c_comment_star
+              else
 
-                                state = :text
-                            else
-                            end
-                        when ?\\
+                ;
+              end
+            when ?\'
 
-                            case state
-                            when :sq_string_open
+              case state
+              when :text
 
-                                state = :sq_string_escape
-                            when :sq_string_escape
+                if i > 0 && decimal_digit?(input[i - 1]) && decimal_digit?(input[i + 1])
+                  ;
+                else
+                  state = :sq_string_open
+                end
+              when :sq_string_closing
 
-                                state = :sq_string
-                            when :dq_string
+                state = :text
+              else
 
-                                state = :dq_string_escape
-                            else
+                ;
+              end
+            when '"'
 
-                            end
-                        else
+              case state
+              when :text
 
-                            case state
-                            when :sq_string_escape
+                state = :dq_string
+              when :dq_string
 
-                                state = :sq_string_closing
-                            else
+                state = :text
+              else
 
-                            end
-                        end
-                    end
-                end
-            end
+                ;
+              end
+            when ?\\
+
+              case state
+              when :sq_string_open
 
+                state = :sq_string_escape
+              when :sq_string_escape
 
-            case state
-            when :slash_start
-            when :cpp_comment
-            when :c_comment
-            when :c_comment_star
+                state = :sq_string_closing
+              when :dq_string
 
+                state = :dq_string_escape
+              else
+
+                ;
+              end
             else
 
-                r << c unless skip
+              case state
+              when :sq_string_escape
+
+                state = :sq_string_closing
+              else
+
+                ;
+              end
             end
+          end
         end
+      end
 
-        r
+
+      case state
+      when :slash_start
+      when :cpp_comment
+      when :c_comment
+      when :c_comment_star
+
+        ;
+      else
+
+        r << c unless skip
+      end
+
+      previous_was_cr = ?\r == c
+      i += 1
     end
+
+    r << '/' if :slash_start == state
+    r << ?\n * cc_lines if [ :c_comment, :c_comment_star, ].include?(state)
+
+    r
+  end
 end # module C
 
 end # module LanguageFamilies