783 cmock of the wrong file is generated

.gitignore

@@ -8,3 +8,4 @@ Gemfile.lock
 *.swp
 examples/make_example/build
 examples/temp_sensor/build
+*~

docs/CMock_Summary.md

@@ -82,6 +82,7 @@ replied with a version that is older than 2.0.0. Go ahead. We'll wait.
 Once you have Ruby, you have three options:
 
 * Clone the latest [CMock repo on github](https://github.com/ThrowTheSwitch/CMock/)
+  (This includes updating the submodules: `git submodules update --recursive`)
 * Download the latest [CMock zip from github](https://github.com/ThrowTheSwitch/CMock/)
 * Install Ceedling (which has it built in!) through your commandline using `gem install ceedling`.
 
@@ -135,7 +136,7 @@ that resembles a pointer or array, it breaks the argument into TWO arguments.
 The first is the original pointer. The second specify the number of elements
 it is to verify of that array. If you specify 1, it'll check one object. If 2,
 it'll assume your pointer is pointing at the first of two elements in an array.
-If you specify zero elements and `UNITY_COMPARE_PTRS_ON_ZERO_ARRAY` is defined, 
+If you specify zero elements and `UNITY_COMPARE_PTRS_ON_ZERO_ARRAY` is defined,
 then this assertion can also be used to directly compare the pointers to verify
 that they are pointing to the same memory address.
 
@@ -385,6 +386,38 @@ from the defaults. We've tried to specify what the defaults are below.
   * **note:** this option will reinsert these attributes onto the mock's calls.
     If that isn't what you are looking for, check out :strippables.
 
+* `:process_cpp_attributes`:
+  Allows the parsing and processing of C++ attribute syntax `[[...]]`.
+
+  * defaults: false
+
+* `:process_gcc_attributes`:
+  Allows the parsing and processing of GNU gcc attribute syntax
+  `__attribute__ ((...))`.
+  When setting it to true, mind removing `__attribute__` from the
+  `:strippables`` option.
+  Those attributes are matched both before and after the function name.
+
+  * defaults: false
+
+* `:noreturn_attributes`:
+    To allow processing of noreturn attributes, list in
+    `:noreturn_attributes` the keywords used as noreturn attributes.
+    (Since such attributes may hide behind macros, you may need to list
+    the macros too).
+>  :noreturn_attributes => ['_Noreturn', 'noreturn', '__noreturn__']
+	Note: when a keyword is listed in this option, it's available for
+    both the C syntax (keyword standing alone), the C++ syntax (keyword
+    in a `[[...]]` syntax, and the GNU gcc syntax (keyword in a
+    `__attribute__((...))` syntax)
+    When a noreturn attribute is matched, the returned function
+    dictionary will contain a :noreturn => true` entry, and the cmock
+    code generator will then avoid returning from the mocked function,
+    but instead will use the `TEST_DO_NOT_RETURN()` macro.
+
+  * defaults: []
+
+
 * `:c_calling_conventions`:
   Similarly, CMock may need to understand which C calling conventions
   might show up in your codebase. If it encounters something it doesn't

lib/CLexer.rb

@@ -0,0 +1,160 @@
+#
+# This is a simple lexer for the C programming language.
+# MIT license. (c) 2023 Pascal Bourguignon
+#
+
+class CLexer
+  #
+  # CLexer is a simple C lexer. It is used to tokenize a C source file.
+  #
+  # Usage:
+  #   lexer = CLexer.new(pre_processed_c_source)
+  #   tokens = lexer.tokenize
+  #
+  # The tokenize method returns an array of tokens.
+
+  KEYWORDS = %w[auto break case char const continue default do double else enum
+                extern float for goto if int long register return short signed
+                sizeof static struct switch typedef union unsigned void volatile while].freeze
+
+  STAR = :mul_op
+  ADDRESS = :logical_and_op
+
+  OPERATOR_SYMBOLS = {
+
+    '...' => :ellipsis,
+    '->*' => :ptr_mem_op,
+    '>>=' => :right_assign,
+    '<<=' => :left_assign,
+
+    '==' => :eq,
+    '!=' => :ne,
+    '<=' => :le,
+    '>=' => :ge,
+    '>>' => :right_op,
+    '<<' => :left_op,
+    '+=' => :add_assign,
+    '-=' => :sub_assign,
+    '*=' => :mul_assign,
+    '/=' => :div_assign,
+    '%=' => :mod_assign,
+    '&=' => :and_assign,
+    '^=' => :xor_assign,
+    '|=' => :or_assign,
+    '->' => :ptr_op,
+    '&&' => :and_op,
+    '||' => :or_op,
+    '++' => :increment,
+    '--' => :decrement,
+
+    '<:' => :open_bracket,
+    ':>' => :close_bracket,
+    '<%' => :open_brace,
+    '%>' => :close_brace,
+
+    '!' => :logical_not_op,
+    '%' => :mod_op,
+    '&' => :logical_and_op,
+    '(' => :open_paren,
+    ')' => :close_paren,
+    '*' => :mul_op,
+    '+' => :add_op,
+    ',' => :comma,
+    '-' => :sub_op,
+    '.' => :dot,
+    '/' => :div_op,
+    ':' => :colon,
+    ';' => :semicolon,
+    '<' => :lt,
+    '=' => :assign,
+    '>' => :gt,
+    '?' => :question,
+    '[' => :open_bracket,
+    ']' => :close_bracket,
+    '^' => :logical_xor_op,
+    '{' => :open_brace,
+    '|' => :logical_or_op,
+    '}' => :close_brace,
+    '~' => :bitwise_not_op
+
+  }.freeze
+
+  OPERATOR_REGEX = Regexp.new('\A(' + OPERATOR_SYMBOLS.keys.map { |op| Regexp.escape(op) }.join('|') + ')')
+  OPERATOR_SYMS = OPERATOR_SYMBOLS.values.freeze
+  KEYWORDS_SYMS = KEYWORDS.map(&:to_sym).freeze
+
+  def initialize(input)
+    @input = input
+    @tokens = []
+  end
+
+  def tokenize
+    while @input.size.positive?
+      case @input
+      when /\A[[:space:]]+/m
+        @input = $'
+      when /\A\/\/[^\n]*/
+        @input = $'
+      when /\A\/\*/
+        consume_multiline_comment
+      when /\A[_a-zA-Z][_a-zA-Z0-9]*/
+        identifier_or_keyword = $&
+        @input = $'
+        if KEYWORDS.include?(identifier_or_keyword)
+          @tokens << identifier_or_keyword.to_sym
+        else
+          @tokens << [:identifier, identifier_or_keyword]
+        end
+      when /\A\d+\.\d*([eE][+-]?\d+)?[fFlL]?|\.\d+([eE][+-]?\d+)?[fFlL]?|\d+[eE][+-]?\d+[fFlL]?/
+        float_constant = $&
+        @input = $'
+        @tokens << [:float_literal, float_constant]
+      when /\A\d+/
+        integer_constant = $&
+        @input = $'
+        @tokens << [:integer_literal, integer_constant]
+      when /\A0[xX][0-9a-fA-F]+/
+        hex_constant = $&
+        @input = $'
+        @tokens << [:hex_literal, hex_constant]
+      when /\A'((\\.|[^\\'])*)'/
+        char_literal = $&
+        @input = $'
+        @tokens << [:char_literal, char_literal]
+      when /\A"((\\.|[^\\"])*)"/
+        string_literal = $&
+        @input = $'
+        @tokens << [:string_literal, string_literal]
+      when OPERATOR_REGEX
+        operator = $&
+        @input = $'
+        @tokens << OPERATOR_SYMBOLS[operator]
+      else
+        raise "Unexpected character: #{@input[0].inspect}"
+      end
+    end
+
+    @tokens
+  end
+
+  private
+
+  def consume_multiline_comment
+    while @input.size.positive?
+      case @input
+      when /\A\*\//
+        @input = $'
+        break
+      when /\A./m
+        @input = $'
+      end
+    end
+  end
+end
+
+def example
+  input = File.read('tee.c')
+  lexer = CLexer.new(input)
+  tokens = lexer.tokenize
+  puts tokens.inspect
+end

lib/cmock.rb

@@ -44,14 +44,14 @@ def setup_skeletons(files)
   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, folder)
+    puts "Creating mock for #{name}, from #{src}" unless @silent
+    @cm_generator.create_mock(name, @cm_parser.parse(name, File.read(src), src), ext, folder, src)
   end
 
   def generate_skeleton(src)
     name = File.basename(src, '.*')
-    puts "Creating skeleton for #{name}..." unless @silent
-    @cm_generator.create_skeleton(name, @cm_parser.parse(name, File.read(src)))
+    puts "Creating skeleton for #{name}, from #{src}" unless @silent
+    @cm_generator.create_skeleton(name, @cm_parser.parse(name, File.read(src), src), src)
   end
 end
 

lib/cmock_config.rb

@@ -16,6 +16,9 @@ class CMockConfig
       :subdir                      => nil,
       :plugins                     => [],
       :strippables                 => ['(?:__attribute__\s*\([ (]*.*?[ )]*\)+)'],
+      :process_gcc_attributes      => false, # __attribute__((...)) ; also remove it from strippables.
+      :process_cpp_attributes      => false, # [[ ... ]] 
+      :noreturn_attributes         => [], # simple keyword, before the function name
       :attributes                  => %w[__ramfunc __irq __fiq register extern],
       :c_calling_conventions       => %w[__stdcall __cdecl __fastcall],
       :enforce_strict_ordering     => false,
@@ -32,6 +35,7 @@ class CMockConfig
       :treat_inlines               => :exclude,        # the options being :include or :exclude
       :callback_include_count      => true,
       :callback_after_arg_check    => false,
+      :callback_kind               => "*",
       :includes                    => nil,
       :includes_h_pre_orig_header  => nil,
       :includes_h_post_orig_header => nil,

lib/cmock_file_writer.rb

@@ -22,6 +22,7 @@ def create_file(filename, subdir)
 
     full_file_name_temp = "#{@config.mock_path}/#{subdir + '/' if subdir}#{filename}.new"
     full_file_name_done = "#{@config.mock_path}/#{subdir + '/' if subdir}#{filename}"
+    $stderr.puts "Creating #{full_file_name_done.inspect}" unless (@config.verbosity < 2)
     File.open(full_file_name_temp, 'w') do |file|
       yield(file, filename)
     end