ceedling 0.30.0 → 0.31.0

data/vendor/cmock/docs/CMock_Summary.md

@@ -174,6 +174,23 @@ handle the call to a function.
 * `retval func(void)` => `void func_StopIgnore(void)`
 * `retval func(params)` => `void func_StopIgnore(void)`
 
+IgnoreStateless:
+----------------
+
+This plugin is similar to the Ignore plugin, but the IgnoreAndReturn functions are
+stateless. So the Ignored function will always return the last specified return value
+and does not queue the return values as the IgnoreAndReturn of the default plugin will.
+
+To stop ignoring a function you can call StopIgnore or simply overwrite the Ignore
+(resp. IgnoreAndReturn) with an Expect (resp. ExpectAndReturn). Note that calling
+Ignore (resp IgnoreAndReturn) will clear your previous called Expect
+(resp. ExpectAndReturn), so they are not restored after StopIgnore is called.
+
+You can use this plugin by using `:ignore_stateless` instead of `:ignore` in your
+CMock configuration file.
+
+The generated functions are the same as **Ignore** and **StopIgnore** above.
+
 Ignore Arg:
 ------------
 
@@ -440,6 +457,7 @@ from the defaults. We've tried to specify what the defaults are below.
   available currently:
 
   * `:ignore`
+  * `:ignore_stateless`
   * `:ignore_arg`
   * `:expect_any_args`
   * `:array`
@@ -457,7 +475,14 @@ from the defaults. We've tried to specify what the defaults are below.
   to prevent a function `functionName` from being mocked. By default, it
   is ignoring all gcc attribute extensions.
 
-  * default: ['(?:__attribute__\s*\(+.*?\)+)']
+  * default: `['(?:__attribute__\s*\(+.*?\)+)']`
+
+* `:exclude_setjmp_h`:
+  Some embedded systems don't have <setjmp.h> available. Setting this to true
+  removes references to this header file and the ability to use cexception.
+
+  * default: false
+
 
 * `:subdir`:
   This is a relative subdirectory for your mocks.  Set this to e.g. "sys" in

data/vendor/cmock/lib/cmock.rb

@@ -18,16 +18,18 @@ class CMock
     cm_config      = CMockConfig.new(options)
     cm_unityhelper = CMockUnityHelperParser.new(cm_config)
     cm_writer      = CMockFileWriter.new(cm_config)
-    cm_gen_utils   = CMockGeneratorUtils.new(cm_config, :unity_helper => cm_unityhelper)
+    cm_gen_utils   = CMockGeneratorUtils.new(cm_config,
+                                             :unity_helper => cm_unityhelper)
     cm_gen_plugins = CMockPluginManager.new(cm_config, cm_gen_utils)
     @cm_parser     = CMockHeaderParser.new(cm_config)
-    @cm_generator  = CMockGenerator.new(cm_config, cm_writer, cm_gen_utils, cm_gen_plugins)
+    @cm_generator  = CMockGenerator.new(cm_config, cm_writer, cm_gen_utils,
+                                        cm_gen_plugins)
     @silent        = (cm_config.verbosity < 2)
   end
 
-  def setup_mocks(files)
+  def setup_mocks(files, folder = nil)
     [files].flatten.each do |src|
-      generate_mock src
+      generate_mock(src, folder)
     end
   end
 
@@ -39,11 +41,11 @@ class CMock
 
   private ###############################
 
-  def generate_mock(src)
+  def generate_mock(src, folder)
     name = File.basename(src, '.*')
     ext = File.extname(src)
     puts "Creating mock for #{name}..." unless @silent
-    @cm_generator.create_mock(name, @cm_parser.parse(name, File.read(src)), ext)
+    @cm_generator.create_mock(name, @cm_parser.parse(name, File.read(src)), ext, folder)
   end
 
   def generate_skeleton(src)
@@ -85,12 +87,17 @@ if $0 == __FILE__
   options = {}
   filelist = []
   ARGV.each do |arg|
-    if arg =~ /^-o\"?([a-zA-Z0-9._\\\/:\s]+)\"?/
+    if arg =~ /^-o\"?([a-zA-Z0-9@._\\\/:\s]+)\"?/
       options.merge! CMockConfig.load_config_file_from_yaml(arg.gsub(/^-o/, ''))
     elsif arg == '--skeleton'
       options[:skeleton] = true
-    elsif arg =~ /^--([a-zA-Z0-9._\\\/:\s]+)=\"?([a-zA-Z0-9._\-\\\/:\s\;]+)\"?/
-      options = option_maker(options, Regexp.last_match(1), Regexp.last_match(2))
+    elsif arg =~ /^--strippables=\"?(.*)\"?/
+      # --strippables are dealt with separately since the user is allowed to
+      # enter any valid regular expression as argument
+      options = option_maker(options, 'strippables', Regexp.last_match(1))
+    elsif arg =~ /^--([a-zA-Z0-9._\\\/:\s]+)=\"?([a-zA-Z0-9._\-\\\/:\s\;]*)\"?/x
+      options = option_maker(options, Regexp.last_match(1),
+                             Regexp.last_match(2))
     else
       filelist << arg
     end

data/vendor/cmock/lib/cmock_config.rb

@@ -41,6 +41,7 @@ class CMockConfig
       :array_size_type             => [],
       :array_size_name             => 'size|len',
       :skeleton                    => false,
+      :exclude_setjmp_h            => false,
 
       # Format to look for inline functions.
       # This is a combination of "static" and "inline" keywords ("static inline", "inline static", "inline", "static")

data/vendor/cmock/lib/cmock_generator.rb

@@ -19,8 +19,10 @@ class CMockGenerator
     @ordered = @config.enforce_strict_ordering
     @framework = @config.framework.to_s
     @fail_on_unexpected_calls = @config.fail_on_unexpected_calls
+    @exclude_setjmp_h = @config.exclude_setjmp_h
 
     @subdir = @config.subdir
+    @folder = nil
 
     @includes_h_pre_orig_header  = (@config.includes || @config.includes_h_pre_orig_header || []).map { |h| h =~ /</ ? h : "\"#{h}\"" }
     @includes_h_post_orig_header = (@config.includes_h_post_orig_header || []).map { |h| h =~ /</ ? h : "\"#{h}\"" }
@@ -44,12 +46,24 @@ class CMockGenerator
     end
   end
 
-  def create_mock(module_name, parsed_stuff, module_ext = nil)
+  def create_mock(module_name, parsed_stuff, module_ext = nil, folder = nil)
     @module_name = module_name
     @module_ext  = module_ext || '.h'
     @mock_name   = @prefix + @module_name + @suffix
     @clean_mock_name = TypeSanitizer.sanitize_c_identifier(@mock_name)
+
+    @folder = if folder && @subdir
+                File.join(@subdir, folder)
+              elsif @subdir
+                @subdir
+              else
+                folder
+              end
+    # adds a trailing slash to the folder output
+    @folder = File.join(@folder, '') if @folder
+
     create_mock_subdir
+
     create_mock_header_file(parsed_stuff)
     create_mock_source_file(parsed_stuff)
   end
@@ -62,7 +76,7 @@ class CMockGenerator
   private if $ThisIsOnlyATest.nil? ##############################
 
   def create_mock_subdir
-    @file_writer.create_subdir(@subdir)
+    @file_writer.create_subdir(@folder)
   end
 
   def create_using_statement(file, function)
@@ -71,12 +85,12 @@ class CMockGenerator
 
   def create_mock_header_file(parsed_stuff)
     if @include_inline == :include
-      @file_writer.create_file(@module_name + (@module_ext || '.h'), @subdir) do |file, _filename|
+      @file_writer.create_file(@module_name + (@module_ext || '.h'), @folder) do |file, _filename|
         file << parsed_stuff[:normalized_source]
       end
     end
 
-    @file_writer.create_file(@mock_name + (@module_ext || '.h'), @subdir) do |file, filename|
+    @file_writer.create_file(@mock_name + (@module_ext || '.h'), @folder) do |file, filename|
       create_mock_header_header(file, filename)
       create_mock_header_service_call_declarations(file)
       create_typedefs(file, parsed_stuff[:typedefs])
@@ -89,7 +103,7 @@ class CMockGenerator
   end
 
   def create_mock_source_file(parsed_stuff)
-    @file_writer.create_file(@mock_name + '.c', @subdir) do |file, filename|
+    @file_writer.create_file(@mock_name + '.c', @folder) do |file, filename|
       create_source_header_section(file, filename, parsed_stuff[:functions])
       create_instance_structure(file, parsed_stuff[:functions])
       create_extern_declarations(file)
@@ -116,7 +130,7 @@ class CMockGenerator
 
   def create_mock_header_header(file, _filename)
     define_name   = @clean_mock_name.upcase
-    orig_filename = (@subdir ? @subdir + '/' : '') + @module_name + (@module_ext || '.h')
+    orig_filename = (@folder || '') + @module_name + (@module_ext || '.h')
     file << "/* AUTOGENERATED FILE. DO NOT EDIT. */\n"
     file << "#ifndef _#{define_name}_H\n"
     file << "#define _#{define_name}_H\n\n"
@@ -165,11 +179,13 @@ class CMockGenerator
   end
 
   def create_source_header_section(file, filename, functions)
-    header_file = (@subdir ? @subdir + '/' : '') + filename.gsub('.c', (@module_ext || '.h'))
+    header_file = (@folder || '') + filename.gsub('.c', (@module_ext || '.h'))
     file << "/* AUTOGENERATED FILE. DO NOT EDIT. */\n" unless functions.empty?
     file << "#include <string.h>\n"
     file << "#include <stdlib.h>\n"
-    file << "#include <setjmp.h>\n"
+    unless @exclude_setjmp_h
+      file << "#include <setjmp.h>\n"
+    end
     file << "#include \"cmock.h\"\n"
     @includes_c_pre_header.each { |inc| file << "#include #{inc}\n" }
     file << "#include \"#{header_file}\"\n"
@@ -205,7 +221,9 @@ class CMockGenerator
   end
 
   def create_extern_declarations(file)
-    file << "extern jmp_buf AbortFrame;\n"
+    unless @exclude_setjmp_h
+      file << "extern jmp_buf AbortFrame;\n"
+    end
     if @ordered
       file << "extern int GlobalExpectCount;\n"
       file << "extern int GlobalVerifyOrder;\n"

data/vendor/cmock/lib/cmock_generator_plugin_cexception.rb

@@ -12,6 +12,7 @@ class CMockGeneratorPluginCexception
     @config = config
     @utils = utils
     @priority = 7
+    raise 'Error: cexception is not supported without setjmp support' if @config.exclude_setjmp_h
   end
 
   def include_files

data/vendor/cmock/lib/cmock_generator_plugin_ignore_stateless.rb

@@ -0,0 +1,85 @@
+# ==========================================
+#   CMock Project - Automatic Mock Generation for C
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   [Released under MIT License. Please refer to license.txt for details]
+# ==========================================
+
+class CMockGeneratorPluginIgnoreStateless
+  attr_reader :priority
+  attr_reader :config, :utils
+
+  def initialize(config, utils)
+    @config = config
+    @utils = utils
+    @priority = 2
+  end
+
+  def instance_structure(function)
+    if function[:return][:void?]
+      "  char #{function[:name]}_IgnoreBool;\n"
+    else
+      "  char #{function[:name]}_IgnoreBool;\n  #{function[:return][:type]} #{function[:name]}_FinalReturn;\n"
+    end
+  end
+
+  def mock_function_declarations(function)
+    lines = if function[:return][:void?]
+              "#define #{function[:name]}_Ignore() #{function[:name]}_CMockIgnore()\n" \
+              "void #{function[:name]}_CMockIgnore(void);\n"
+            else
+              "#define #{function[:name]}_IgnoreAndReturn(cmock_retval) #{function[:name]}_CMockIgnoreAndReturn(cmock_retval)\n" \
+              "void #{function[:name]}_CMockIgnoreAndReturn(#{function[:return][:str]});\n"
+            end
+
+    # Add stop ignore function. it does not matter if there are any args
+    lines << "#define #{function[:name]}_StopIgnore() #{function[:name]}_CMockStopIgnore()\n" \
+                "void #{function[:name]}_CMockStopIgnore(void);\n"
+    lines
+  end
+
+  def mock_implementation_precheck(function)
+    lines = "  if (Mock.#{function[:name]}_IgnoreBool)\n  {\n"
+    lines << "    UNITY_CLR_DETAILS();\n"
+    if function[:return][:void?]
+      lines << "    return;\n  }\n"
+    else
+      retval = function[:return].merge(:name => 'cmock_call_instance->ReturnVal')
+      lines << "    if (cmock_call_instance == NULL)\n      return Mock.#{function[:name]}_FinalReturn;\n"
+      lines << '  ' + @utils.code_assign_argument_quickly("Mock.#{function[:name]}_FinalReturn", retval) unless retval[:void?]
+      lines << "    return cmock_call_instance->ReturnVal;\n  }\n"
+    end
+    lines
+  end
+
+  # this function is adjusted
+  def mock_interfaces(function)
+    lines = ''
+    lines << if function[:return][:void?]
+               "void #{function[:name]}_CMockIgnore(void)\n{\n"
+             else
+               "void #{function[:name]}_CMockIgnoreAndReturn(#{function[:return][:str]})\n{\n"
+             end
+    unless function[:return][:void?]
+      lines << "  Mock.#{function[:name]}_CallInstance = CMOCK_GUTS_NONE;\n"
+      lines << "  Mock.#{function[:name]}_FinalReturn = cmock_to_return;\n"
+    end
+    lines << "  Mock.#{function[:name]}_IgnoreBool = (char)1;\n"
+    lines << "}\n\n"
+
+    # Add stop ignore function. it does not matter if there are any args
+    lines << "void #{function[:name]}_CMockStopIgnore(void)\n{\n"
+    lines << "  Mock.#{function[:name]}_IgnoreBool = (char)0;\n"
+    lines << "}\n\n"
+
+    lines
+  end
+
+  def mock_ignore(function)
+    "  Mock.#{function[:name]}_IgnoreBool = (char)1;\n"
+  end
+
+  def mock_verify(function)
+    func_name = function[:name]
+    "  if (Mock.#{func_name}_IgnoreBool)\n    call_instance = CMOCK_GUTS_NONE;\n"
+  end
+end

data/vendor/cmock/lib/cmock_generator_plugin_return_thru_ptr.rb

@@ -14,7 +14,7 @@ class CMockGeneratorPluginReturnThruPtr
 
       lines << "  char ReturnThruPtr_#{arg[:name]}_Used;\n"
       lines << "  #{arg[:type]} ReturnThruPtr_#{arg[:name]}_Val;\n"
-      lines << "  int ReturnThruPtr_#{arg[:name]}_Size;\n"
+      lines << "  size_t ReturnThruPtr_#{arg[:name]}_Size;\n"
     end
     lines
   end
@@ -33,10 +33,10 @@ class CMockGeneratorPluginReturnThruPtr
                  " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, sizeof(*#{arg[:name]}))\n"
                end
       lines << "#define #{function[:name]}_ReturnArrayThruPtr_#{arg[:name]}(#{arg[:name]}, cmock_len)"
-      lines << " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, (int)(cmock_len * (int)sizeof(*#{arg[:name]})))\n"
+      lines << " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, cmock_len * sizeof(*#{arg[:name]}))\n"
       lines << "#define #{function[:name]}_ReturnMemThruPtr_#{arg[:name]}(#{arg[:name]}, cmock_size)"
       lines << " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, cmock_size)\n"
-      lines << "void #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(UNITY_LINE_TYPE cmock_line, #{arg[:type]} #{arg[:name]}, int cmock_size);\n"
+      lines << "void #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(UNITY_LINE_TYPE cmock_line, #{arg[:type]} #{arg[:name]}, size_t cmock_size);\n"
     end
     lines
   end
@@ -48,7 +48,7 @@ class CMockGeneratorPluginReturnThruPtr
       arg_name = arg[:name]
       next unless @utils.ptr_or_str?(arg[:type]) && !(arg[:const?])
 
-      lines << "void #{func_name}_CMockReturnMemThruPtr_#{arg_name}(UNITY_LINE_TYPE cmock_line, #{arg[:type]} #{arg_name}, int cmock_size)\n"
+      lines << "void #{func_name}_CMockReturnMemThruPtr_#{arg_name}(UNITY_LINE_TYPE cmock_line, #{arg[:type]} #{arg_name}, size_t cmock_size)\n"
       lines << "{\n"
       lines << "  CMOCK_#{func_name}_CALL_INSTANCE* cmock_call_instance = " \
                "(CMOCK_#{func_name}_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.#{func_name}_CallInstance));\n"

data/vendor/cmock/lib/cmock_generator_utils.rb

@@ -17,6 +17,7 @@ class CMockGeneratorUtils
     @return_thru_ptr = @config.plugins.include? :return_thru_ptr
     @ignore_arg = @config.plugins.include? :ignore_arg
     @ignore = @config.plugins.include? :ignore
+    @ignore_stateless = @config.plugins.include? :ignore_stateless
     @treat_as = @config.treat_as
     @helpers = helpers
   end
@@ -52,7 +53,7 @@ class CMockGeneratorUtils
     lines << "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);\n"
     lines << "  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));\n"
     lines << "  Mock.#{func_name}_CallInstance = CMock_Guts_MemChain(Mock.#{func_name}_CallInstance, cmock_guts_index);\n"
-    lines << "  Mock.#{func_name}_IgnoreBool = (char)0;\n" if @ignore
+    lines << "  Mock.#{func_name}_IgnoreBool = (char)0;\n" if @ignore || @ignore_stateless
     lines << "  cmock_call_instance->LineNumber = cmock_line;\n"
     lines << "  cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" if @ordered && global_ordering_supported
     lines << "  cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n" if @cexception
@@ -86,11 +87,13 @@ class CMockGeneratorUtils
           type = arg_type_with_const(m)
           m[:ptr?] ? "#{type} #{m[:name]}, int #{m[:name]}_Depth" : "#{type} #{m[:name]}"
         end.join(', ')
-        "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{args_string})\n{\n" +
+        "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{args_string});\n" \
+          "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{args_string})\n{\n" +
           function[:args].inject('') { |all, arg| all + code_add_an_arg_expectation(arg, (arg[:ptr?] ? "#{arg[:name]}_Depth" : 1)) } +
           "}\n\n"
       else
-        "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{function[:args_string]})\n{\n" +
+        "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{function[:args_string]});\n" \
+          "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{function[:args_string]})\n{\n" +
           function[:args].inject('') { |all, arg| all + code_add_an_arg_expectation(arg) } +
           "}\n\n"
       end

data/vendor/cmock/lib/cmock_header_parser.rb

@@ -61,6 +61,15 @@ class CMockHeaderParser
 
   private if $ThisIsOnlyATest.nil? ################
 
+  # Remove C/C++ comments from a string
+  # +source+:: String which will have the comments removed
+  def remove_comments_from_source(source)
+    # remove comments (block and line, in three steps to ensure correct precedence)
+    source.gsub!(/(?<!\*)\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '')  # remove line comments that comment out the start of blocks
+    source.gsub!(/\/\*.*?\*\//m, '')                            # remove block comments
+    source.gsub!(/\/\/.*$/, '')                                 # remove line comments (all that remain)
+  end
+
   def remove_nested_pairs_of_braces(source)
     # remove nested pairs of braces because no function declarations will be inside of them (leave outer pair for function definition detection)
     if RUBY_VERSION.split('.')[0].to_i > 1
@@ -119,6 +128,9 @@ class CMockHeaderParser
     # let's clean up the encoding in case they've done anything weird with the characters we might find
     source = source.force_encoding('ISO-8859-1').encode('utf-8', :replace => nil)
 
+    # Comments can contain words that will trigger the parser (static|inline|<user_defined_static_keyword>)
+    remove_comments_from_source(source)
+
     # smush multiline macros into single line (checking for continuation character at end of line '\')
     # If the user uses a macro to declare an inline function,
     # smushing the macros makes it easier to recognize them as a macro and if required,
@@ -138,11 +150,18 @@ class CMockHeaderParser
     #  - Copy everything after the inline function implementation and start the parsing of the next inline function
     # There are ofcourse some special cases (inline macro declarations, inline function declarations, ...) which are handled and explained below
     inline_function_regex_formats.each do |format|
+      inspected_source = ''
+      regex_matched = false
       loop do
         inline_function_match = source.match(/#{format}/) # Search for inline function declaration
 
-        break if inline_function_match.nil? # No inline functions so nothing to do
+        if inline_function_match.nil? # No inline functions so nothing to do
+          # Join pre and post match stripped parts for the next inline function detection regex
+          source = inspected_source + source if regex_matched == true
+          break
+        end
 
+        regex_matched = true
         # 1. Determine if we are dealing with a user defined macro to declare inline functions
         # If the end of the pre-match string is a macro-declaration-like string,
         # we are dealing with a user defined macro to declare inline functions
@@ -150,7 +169,8 @@ class CMockHeaderParser
           # Remove the macro from the source
           stripped_pre_match = inline_function_match.pre_match.sub(/(#define\s*)\z/, '')
           stripped_post_match = inline_function_match.post_match.sub(/\A(.*[\n]?)/, '')
-          source = stripped_pre_match + stripped_post_match
+          inspected_source += stripped_pre_match
+          source = stripped_post_match
           next
         end
 
@@ -159,23 +179,32 @@ class CMockHeaderParser
         # we are dealing with a inline function declaration
         if /\A#{@function_declaration_parse_base_match}\s*;/m =~ inline_function_match.post_match
           # Only remove the inline part from the function declaration, leaving the function declaration won't do any harm
-          source = inline_function_match.pre_match + inline_function_match.post_match
+          inspected_source += inline_function_match.pre_match
+          source = inline_function_match.post_match
           next
         end
 
         # 3. If we get here, we found an inline function declaration AND inline function body.
-        #    Remove the function body to transform it into a 'normal' function.
-        total_pairs_to_remove = count_number_of_pairs_of_braces_in_function(inline_function_match.post_match)
+        # Remove the function body to transform it into a 'normal' function declaration.
+        if /\A#{@function_declaration_parse_base_match}\s*\{/m =~ inline_function_match.post_match
+          total_pairs_to_remove = count_number_of_pairs_of_braces_in_function(inline_function_match.post_match)
 
-        break if total_pairs_to_remove == 0 # Bad source?
+          break if total_pairs_to_remove == 0 # Bad source?
 
-        inline_function_stripped = inline_function_match.post_match
+          inline_function_stripped = inline_function_match.post_match
 
-        total_pairs_to_remove.times do
-          inline_function_stripped.sub!(/\s*#{square_bracket_pair_regex_format}/, ';') # Remove inline implementation (+ some whitespace because it's prettier)
+          total_pairs_to_remove.times do
+            inline_function_stripped.sub!(/\s*#{square_bracket_pair_regex_format}/, ';') # Remove inline implementation (+ some whitespace because it's prettier)
+          end
+          inspected_source += inline_function_match.pre_match
+          source = inline_function_stripped
+          next
         end
 
-        source = inline_function_match.pre_match + inline_function_stripped # Make new source with the inline function removed and move on to the next
+        # 4. If we get here, it means the regex match, but it is not related to the function (ex. static variable in header)
+        # Leave this code as it is.
+        inspected_source += inline_function_match.pre_match + inline_function_match[0]
+        source = inline_function_match.post_match
       end
     end
 
@@ -205,10 +234,7 @@ class CMockHeaderParser
     # smush multiline macros into single line (checking for continuation character at end of line '\')
     source.gsub!(/\s*\\\s*/m, ' ')
 
-    # remove comments (block and line, in three steps to ensure correct precedence)
-    source.gsub!(/(?<!\*)\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '')  # remove line comments that comment out the start of blocks
-    source.gsub!(/\/\*.*?\*\//m, '')                            # remove block comments
-    source.gsub!(/\/\/.*$/, '')                                 # remove line comments (all that remain)
+    remove_comments_from_source(source)
 
     # remove assembler pragma sections
     source.gsub!(/^\s*#\s*pragma\s+asm\s+.*?#\s*pragma\s+endasm/m, '')