ceedling 0.9.0 → 1.0.1

data/vendor/cmock/lib/cmock_unityhelper_parser.rb

@@ -0,0 +1,82 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class CMockUnityHelperParser
+  attr_accessor :c_types
+
+  def initialize(config)
+    @config = config
+    @fallback = @config.plugins.include?(:array) ? 'UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY' : 'UNITY_TEST_ASSERT_EQUAL_MEMORY'
+    @c_types = map_c_types.merge(import_source)
+  end
+
+  def get_helper(ctype)
+    lookup = ctype.gsub(/(?:^|(\S?)(\s*)|(\W))const(?:$|(\s*)(\S)|(\W))/, '\1\3\5\6').strip.gsub(/\s+/, '_')
+    return [@c_types[lookup], ''] if @c_types[lookup]
+
+    if lookup =~ /\*$/
+      lookup = lookup.gsub(/\*$/, '')
+      return [@c_types[lookup], '*'] if @c_types[lookup]
+    else
+      lookup += '*'
+      return [@c_types[lookup], '&'] if @c_types[lookup]
+    end
+    return ['UNITY_TEST_ASSERT_EQUAL_PTR', ''] if ctype =~ /cmock_\w+_ptr\d+/
+    raise("Don't know how to test #{ctype} and memory tests are disabled!") unless @config.memcmp_if_unknown
+
+    lookup =~ /\*$/ ? [@fallback, '&'] : [@fallback, '']
+  end
+
+  private ###########################
+
+  def map_c_types
+    c_types = {}
+    @config.treat_as.each_pair do |ctype, expecttype|
+      if ctype.is_a?(Symbol)
+        raise ":treat_as expects a list of  identifier: identifier  mappings, but got a symbol: #{ctype}. Check the indentation in your project.yml"
+      end
+
+      c_type = ctype.gsub(/\s+/, '_')
+      if expecttype =~ /\*/
+        c_types[c_type] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype.delete('*')}_ARRAY"
+      else
+        c_types[c_type] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype}"
+        c_types["#{c_type}*"] ||= "UNITY_TEST_ASSERT_EQUAL_#{expecttype}_ARRAY"
+      end
+    end
+    c_types
+  end
+
+  def import_source
+    source = @config.load_unity_helper
+    return {} if source.nil?
+
+    c_types = {}
+    source = source.gsub(/\/\/.*$/, '') # remove line comments
+    source = source.gsub(/\/\*.*?\*\//m, '') # remove block comments
+
+    # scan for comparison helpers
+    match_regex = Regexp.new("^\\s*#define\\s+(UNITY_TEST_ASSERT_EQUAL_(\\w+))\\s*\\(#{Array.new(4, '\s*\w+\s*').join(',')}\\)")
+    pairs = source.scan(match_regex).flatten.compact
+    (pairs.size / 2).times do |i|
+      expect = pairs[i * 2]
+      ctype = pairs[(i * 2) + 1]
+      c_types[ctype] = expect unless expect.include?('_ARRAY')
+    end
+
+    # scan for array variants of those helpers
+    match_regex = Regexp.new("^\\s*#define\\s+(UNITY_TEST_ASSERT_EQUAL_(\\w+_ARRAY))\\s*\\(#{Array.new(5, '\s*\w+\s*').join(',')}\\)")
+    pairs = source.scan(match_regex).flatten.compact
+    (pairs.size / 2).times do |i|
+      expect = pairs[i * 2]
+      ctype = pairs[(i * 2) + 1]
+      c_types[ctype.gsub('_ARRAY', '*')] = expect
+    end
+
+    c_types
+  end
+end

data/vendor/cmock/lib/cmock_version.rb

@@ -0,0 +1,29 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+module CMockVersion
+  # Where is the header file from here?
+  path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'src', 'cmock.h'))
+
+  # Actually look up the version in the header file
+  a = [0, 0, 0]
+  begin
+    File.readlines(path).each do |line|
+      %w[VERSION_MAJOR VERSION_MINOR VERSION_BUILD].each_with_index do |field, i|
+        m = line.match(/CMOCK_#{field}\s+(\d+)/)
+        a[i] = m[1] unless m.nil?
+      end
+    end
+  rescue StandardError
+    abort('Can\'t find my header file.')
+  end
+
+  # splat it to return the final value
+  CMOCK_VERSION = a.join('.')
+
+  GEM = CMOCK_VERSION
+end

data/vendor/cmock/meson.build

@@ -0,0 +1,17 @@
+#
+# build script written by : Michael Brockus.
+# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
+#
+# license: MIT
+#
+project('cmock', 'c',
+    license: 'MIT',
+    meson_version: '>=0.53.0',
+    subproject_dir : 'vendor',
+    default_options: ['werror=true', 'c_std=c11']
+)
+
+unity_dep = dependency('unity', fallback: ['unity', 'unity_dep'])
+
+subdir('src')
+cmock_dep = declare_dependency(link_with: cmock_lib, include_directories: cmock_dir)

data/vendor/cmock/scripts/create_makefile.rb

@@ -0,0 +1,210 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'fileutils'
+ABS_ROOT = FileUtils.pwd
+CMOCK_DIR = File.expand_path(ENV.fetch('CMOCK_DIR', File.join(ABS_ROOT, '..', '..')))
+require "#{CMOCK_DIR}/lib/cmock"
+UNITY_DIR = File.join(CMOCK_DIR, 'vendor', 'unity')
+require "#{UNITY_DIR}/auto/generate_test_runner"
+
+SRC_DIR =  ENV.fetch('SRC_DIR',  './src')
+TEST_DIR = ENV.fetch('TEST_DIR', './test')
+UNITY_SRC = File.join(UNITY_DIR, 'src')
+CMOCK_SRC = File.join(CMOCK_DIR, 'src')
+BUILD_DIR = ENV.fetch('BUILD_DIR', './build')
+TEST_BUILD_DIR = ENV.fetch('TEST_BUILD_DIR', File.join(BUILD_DIR, 'test'))
+OBJ_DIR = File.join(TEST_BUILD_DIR, 'obj')
+UNITY_OBJ = File.join(OBJ_DIR, 'unity.o')
+CMOCK_OBJ = File.join(OBJ_DIR, 'cmock.o')
+RUNNERS_DIR = File.join(TEST_BUILD_DIR, 'runners')
+MOCKS_DIR = File.join(TEST_BUILD_DIR, 'mocks')
+TEST_BIN_DIR = TEST_BUILD_DIR
+MOCK_PREFIX = ENV.fetch('TEST_MOCK_PREFIX', 'mock_')
+MOCK_SUFFIX = ENV.fetch('TEST_MOCK_SUFFIX', '')
+TEST_MAKEFILE = ENV.fetch('TEST_MAKEFILE', File.join(TEST_BUILD_DIR, 'MakefileTestSupport'))
+MOCK_MATCHER = /#{MOCK_PREFIX}[A-Za-z_][A-Za-z0-9_\-.]+#{MOCK_SUFFIX}/
+
+[TEST_BUILD_DIR, OBJ_DIR, RUNNERS_DIR, MOCKS_DIR, TEST_BIN_DIR].each do |dir|
+  FileUtils.mkdir_p dir
+end
+
+all_headers_to_mock = []
+
+suppress_error = !ARGV.nil? && !ARGV.empty? && (ARGV[0].casecmp('--SILENT') == 0)
+
+File.open(TEST_MAKEFILE, 'w') do |mkfile|
+  # Define make variables
+  mkfile.puts 'CC ?= gcc'
+  mkfile.puts "BUILD_DIR = #{BUILD_DIR}"
+  mkfile.puts "SRC_DIR = #{SRC_DIR}"
+  mkfile.puts "TEST_DIR = #{TEST_DIR}"
+  mkfile.puts 'TEST_CFLAGS ?= -DTEST'
+  mkfile.puts "CMOCK_DIR ?= #{CMOCK_DIR}"
+  mkfile.puts "UNITY_DIR ?= #{UNITY_DIR}"
+  mkfile.puts 'TEST_BUILD_DIR ?= ${BUILD_DIR}/test'
+  mkfile.puts 'TEST_MAKEFILE = ${TEST_BUILD_DIR}/MakefileTestSupport'
+  mkfile.puts 'OBJ ?= ${BUILD_DIR}/obj'
+  mkfile.puts 'OBJ_DIR = ${OBJ}'
+  mkfile.puts ''
+
+  # Build Unity
+  mkfile.puts "#{UNITY_OBJ}: #{UNITY_SRC}/unity.c"
+  mkfile.puts "\t${CC} -o $@ -c $< -I #{UNITY_SRC}"
+  mkfile.puts ''
+
+  # Build CMock
+  mkfile.puts "#{CMOCK_OBJ}: #{CMOCK_SRC}/cmock.c"
+  mkfile.puts "\t${CC} -o $@ -c $< -I #{UNITY_SRC} -I #{CMOCK_SRC}"
+  mkfile.puts ''
+
+  test_sources = Dir["#{TEST_DIR}/**/test_*.c"]
+  test_targets = []
+  generator = UnityTestRunnerGenerator.new
+
+  # headers that begin with prefix or end with suffix are not included
+  all_headers = Dir["#{SRC_DIR}/**/*.h*"]
+
+  def reject_mock_files(file)
+    extn = File.extname file
+    filename = File.basename file, extn
+    if MOCK_SUFFIX.empty?
+      return filename.start_with? MOCK_PREFIX
+    end
+
+    (filename.start_with?(MOCK_PREFIX) || filename.end_with?(MOCK_SUFFIX))
+  end
+
+  all_headers = all_headers.reject { |f| reject_mock_files(f) }
+
+  makefile_targets = []
+
+  test_sources.each do |test|
+    module_name = File.basename(test, '.c')
+    src_module_name = module_name.sub(/^test_/, '')
+    test_obj = File.join(OBJ_DIR, "#{module_name}.o")
+    runner_source = File.join(RUNNERS_DIR, "runner_#{module_name}.c")
+    runner_obj = File.join(OBJ_DIR, "runner_#{module_name}.o")
+    test_bin = File.join(TEST_BIN_DIR, module_name)
+    test_results = File.join(TEST_BIN_DIR, "#{module_name}.testresult")
+
+    cfg = {
+      src: test,
+      includes: generator.find_includes(File.readlines(test).join(''))
+    }
+
+    # Build main project modules, with TEST defined
+    module_src = File.join(SRC_DIR, "#{src_module_name}.c")
+    module_obj = File.join(OBJ_DIR, "#{src_module_name}.o")
+    unless makefile_targets.include? module_obj
+      makefile_targets.push(module_obj)
+      mkfile.puts "#{module_obj}: #{module_src}"
+      mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I ${SRC_DIR} ${INCLUDE_PATH}"
+      mkfile.puts ''
+    end
+
+    # process link-only files
+    linkonly = cfg[:includes][:linkonly]
+    linkonly_objs = []
+    linkonly.each do |linkonlyfile|
+      linkonlybase = File.basename(linkonlyfile, '.*')
+      linkonlymodule_src = File.join(SRC_DIR, linkonlyfile.to_s)
+      linkonlymodule_obj = File.join(OBJ_DIR, "#{linkonlybase}.o")
+      linkonly_objs.push(linkonlymodule_obj)
+      # only create the target if we didn't already
+      next if makefile_targets.include? linkonlymodule_obj
+
+      makefile_targets.push(linkonlymodule_obj)
+      mkfile.puts "#{linkonlymodule_obj}: #{linkonlymodule_src}"
+      mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I ${SRC_DIR} ${INCLUDE_PATH}"
+      mkfile.puts ''
+    end
+
+    # Create runners
+    mkfile.puts "#{runner_source}: #{test}"
+    mkfile.puts "\t@UNITY_DIR=${UNITY_DIR} ruby ${CMOCK_DIR}/scripts/create_runner.rb #{test} #{runner_source}"
+    mkfile.puts ''
+
+    # Build runner
+    mkfile.puts "#{runner_obj}: #{runner_source}"
+    mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I #{SRC_DIR} -I #{MOCKS_DIR} -I #{UNITY_SRC} -I #{CMOCK_SRC} ${INCLUDE_PATH}"
+    mkfile.puts ''
+
+    # Collect mocks to generate
+    system_mocks = cfg[:includes][:system].select { |name| name =~ MOCK_MATCHER }
+    raise 'Mocking of system headers is not yet supported!' unless system_mocks.empty?
+
+    local_mocks = cfg[:includes][:local].select { |name| name =~ MOCK_MATCHER }
+
+    module_names_to_mock = local_mocks.map { |name| name.sub(/#{MOCK_PREFIX}/, '').to_s }
+    headers_to_mock = []
+    module_names_to_mock.each do |name|
+      header_to_mock = nil
+      all_headers.each do |header|
+        if header =~ /[\/\\]?#{name}$/
+          header_to_mock = header
+          break
+        end
+      end
+      raise "Module header '#{name}' not found to mock!" unless header_to_mock
+
+      headers_to_mock << header_to_mock
+    end
+
+    all_headers_to_mock += headers_to_mock
+    mock_objs = headers_to_mock.map do |hdr|
+      mock_name = MOCK_PREFIX + File.basename(hdr, '.*')
+      File.join(MOCKS_DIR, "#{mock_name}.o")
+    end
+    all_headers_to_mock.uniq!
+
+    # Build test suite
+    mkfile.puts "#{test_obj}: #{test} #{module_obj} #{mock_objs.join(' ')}"
+    mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I #{SRC_DIR} -I #{UNITY_SRC} -I #{CMOCK_SRC} -I #{MOCKS_DIR} ${INCLUDE_PATH}"
+    mkfile.puts ''
+
+    # Build test suite executable
+    test_objs = "#{test_obj} #{runner_obj} #{module_obj} #{mock_objs.join(' ')} #{linkonly_objs.join(' ')} #{UNITY_OBJ} #{CMOCK_OBJ}"
+    mkfile.puts "#{test_bin}: #{test_objs}"
+    mkfile.puts "\t${CC} -o $@ ${LDFLAGS} #{test_objs}"
+    mkfile.puts ''
+
+    # Run test suite and generate report
+    mkfile.puts "#{test_results}: #{test_bin}"
+    mkfile.puts "\t-#{test_bin} > #{test_results} 2>&1"
+    mkfile.puts ''
+
+    test_targets << test_bin
+  end
+
+  # Generate and build mocks
+  all_headers_to_mock.each do |hdr|
+    mock_name = MOCK_PREFIX + File.basename(hdr, '.*')
+    mock_header = File.join(MOCKS_DIR, mock_name + File.extname(hdr))
+    mock_src = File.join(MOCKS_DIR, "#{mock_name}.c")
+    mock_obj = File.join(MOCKS_DIR, "#{mock_name}.o")
+
+    mkfile.puts "#{mock_src}: #{hdr}"
+    mkfile.puts "\t@CMOCK_DIR=${CMOCK_DIR} ruby ${CMOCK_DIR}/scripts/create_mock.rb #{hdr}"
+    mkfile.puts ''
+
+    mkfile.puts "#{mock_obj}: #{mock_src} #{mock_header}"
+    mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I #{MOCKS_DIR} -I #{SRC_DIR} -I #{UNITY_SRC} -I #{CMOCK_SRC} ${INCLUDE_PATH}"
+    mkfile.puts ''
+  end
+
+  # Create test summary task
+  mkfile.puts 'test_summary:'
+  mkfile.puts "\t@UNITY_DIR=${UNITY_DIR} ruby ${CMOCK_DIR}/scripts/test_summary.rb #{suppress_error ? '--silent' : ''}"
+  mkfile.puts ''
+  mkfile.puts '.PHONY: test_summary'
+  mkfile.puts ''
+
+  # Create target to run all tests
+  mkfile.puts "test: #{test_targets.map { |t| "#{t}.testresult" }.join(' ')} test_summary"
+  mkfile.puts ''
+end

data/vendor/cmock/scripts/create_mock.rb

@@ -0,0 +1,15 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require "#{ENV['CMOCK_DIR']}/lib/cmock"
+
+raise 'Header file to mock must be specified!' unless ARGV.length >= 1
+
+mock_out = ENV.fetch('MOCK_OUT', './build/test/mocks')
+mock_prefix = ENV.fetch('MOCK_PREFIX', 'mock_')
+cmock = CMock.new(:plugins => %i[ignore return_thru_ptr], :mock_prefix => mock_prefix, :mock_path => mock_out)
+cmock.setup_mocks(ARGV[0])

data/vendor/cmock/scripts/create_runner.rb

@@ -0,0 +1,25 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+if $0 == __FILE__
+
+  # make sure there is at least one parameter left (the input file)
+  if ARGV.length < 2
+    puts ["\nusage: ruby #{__FILE__} input_test_file (output)",
+          '',
+          '  input_test_file         - this is the C file you want to create a runner for',
+          '  output                  - this is the name of the runner file to generate',
+          '                            defaults to (input_test_file)_Runner'].join("\n")
+    exit 1
+  end
+
+  require "#{ENV['UNITY_DIR']}/auto/generate_test_runner"
+
+  test = ARGV[0]
+  runner = ARGV[1]
+  UnityTestRunnerGenerator.new.run(test, runner)
+end

data/vendor/cmock/scripts/test_summary.rb

@@ -0,0 +1,25 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+suppress_error = !ARGV.nil? && !ARGV.empty? && (ARGV[0].casecmp('--SILENT') == 0)
+
+begin
+  require "#{ENV['UNITY_DIR']}/auto/unity_test_summary.rb"
+
+  build_dir = ENV.fetch('BUILD_DIR', './build')
+  test_build_dir = ENV.fetch('TEST_BUILD_DIR', File.join(build_dir, 'test'))
+
+  results = Dir["#{test_build_dir}/*.testresult"]
+  parser = UnityTestSummary.new
+  parser.targets = results
+  parser.run
+  puts parser.report
+rescue StandardError => e
+  raise e unless suppress_error
+end
+
+exit(parser.failures) unless suppress_error

data/vendor/cmock/src/cmock.c

@@ -0,0 +1,238 @@
+/* =========================================================================
+    CMock - Automatic Mock Generation for C
+    ThrowTheSwitch.org
+    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
+/* ==========================================
+    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]
+========================================== */
+
+#include "cmock.h"
+
+/* public constants to be used by mocks */
+const char* CMockStringOutOfMemory = "CMock has run out of memory. Please allocate more.";
+const char* CMockStringCalledMore  = "Called more times than expected.";
+const char* CMockStringCalledLess  = "Called fewer times than expected.";
+const char* CMockStringCalledEarly = "Called earlier than expected.";
+const char* CMockStringCalledLate  = "Called later than expected.";
+const char* CMockStringCallOrder   = "Called out of order.";
+const char* CMockStringIgnPreExp   = "IgnoreArg called before Expect.";
+const char* CMockStringPtrPreExp   = "ReturnThruPtr called before Expect.";
+const char* CMockStringPtrIsNULL   = "Pointer is NULL.";
+const char* CMockStringExpNULL     = "Expected NULL.";
+const char* CMockStringMismatch    = "Function called with unexpected argument value.";
+
+/* private variables */
+#ifdef CMOCK_MEM_DYNAMIC
+static unsigned char*         CMock_Guts_Buffer = NULL;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_ALIGN_SIZE;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
+#else
+static long long              CMock_Guts_Space[(CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE + sizeof(long long) - 1) / sizeof(long long)];
+static unsigned char*         CMock_Guts_Buffer = (unsigned char *)CMock_Guts_Space;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;//sizeof(CMock_Guts_Space);
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
+#endif
+
+/*-------------------------------------------------------
+ * CMock_Guts_MemNew
+ *-------------------------------------------------------*/
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size)
+{
+  CMOCK_MEM_INDEX_TYPE index;
+
+  /* verify arguments valid (we must be allocating space for at least 1 byte, and the existing chain must be in memory somewhere) */
+  if (size < 1)
+  {
+    return CMOCK_GUTS_NONE;
+  }
+
+  /* verify we have enough room */
+  size = size + CMOCK_MEM_INDEX_SIZE;
+  if (size & CMOCK_MEM_ALIGN_MASK)
+  {
+    size = (size + CMOCK_MEM_ALIGN_MASK) & ~CMOCK_MEM_ALIGN_MASK;
+  }
+  if ((CMock_Guts_BufferSize - CMock_Guts_FreePtr) < size)
+  {
+#ifndef CMOCK_MEM_DYNAMIC
+    return CMOCK_GUTS_NONE; /* nothing we can do; our static buffer is out of memory */
+#else
+    /* our dynamic buffer does not have enough room; request more via realloc() */
+    CMOCK_MEM_INDEX_TYPE new_buffersize = CMock_Guts_BufferSize + CMOCK_MEM_SIZE + size;
+    unsigned char* new_buffer = realloc(CMock_Guts_Buffer, (size_t)new_buffersize);
+    if (new_buffer == NULL)
+      return CMOCK_GUTS_NONE; /* realloc() failed; out of memory */
+    CMock_Guts_Buffer = new_buffer;
+    CMock_Guts_BufferSize = new_buffersize;
+#endif
+  }
+
+  /* determine where we're putting this new block, and init its pointer to be the end of the line */
+  index = CMock_Guts_FreePtr + CMOCK_MEM_INDEX_SIZE;
+  *(CMOCK_MEM_INDEX_TYPE*)(&CMock_Guts_Buffer[CMock_Guts_FreePtr]) = CMOCK_GUTS_NONE;
+  CMock_Guts_FreePtr += size;
+
+  return index;
+}
+
+/*-------------------------------------------------------
+ * CMock_Guts_MemChain
+ *-------------------------------------------------------*/
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemChain(CMOCK_MEM_INDEX_TYPE root_index, CMOCK_MEM_INDEX_TYPE obj_index)
+{
+  CMOCK_MEM_INDEX_TYPE index;
+  void* root;
+  void* obj;
+  void* next;
+
+  if (root_index == CMOCK_GUTS_NONE)
+  {
+    /* if there is no root currently, we return this object as the root of the chain */
+    return obj_index;
+  }
+  else
+  {
+    /* reject illegal nodes */
+    if ((root_index < CMOCK_MEM_ALIGN_SIZE) || (root_index >= CMock_Guts_FreePtr))
+    {
+      return CMOCK_GUTS_NONE;
+    }
+    if ((obj_index < CMOCK_MEM_ALIGN_SIZE) || (obj_index >= CMock_Guts_FreePtr))
+    {
+      return CMOCK_GUTS_NONE;
+    }
+
+    root = (void*)(&CMock_Guts_Buffer[root_index]);
+    obj  = (void*)(&CMock_Guts_Buffer[obj_index]);
+
+    /* find the end of the existing chain and add us */
+    next = root;
+    do {
+      index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE);
+      if (index >= CMock_Guts_FreePtr)
+      {
+        return CMOCK_GUTS_NONE;
+      }
+      if (index > 0)
+      {
+        next = (void*)(&CMock_Guts_Buffer[index]);
+      }
+    } while (index > 0);
+    *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE) = (CMOCK_MEM_INDEX_TYPE)((CMOCK_MEM_PTR_AS_INT)obj - (CMOCK_MEM_PTR_AS_INT)CMock_Guts_Buffer);
+    return root_index;
+  }
+}
+
+/*-------------------------------------------------------
+ * CMock_Guts_MemNext
+ *-------------------------------------------------------*/
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNext(CMOCK_MEM_INDEX_TYPE previous_item_index)
+{
+  CMOCK_MEM_INDEX_TYPE index;
+  void* previous_item;
+
+  /* There is nothing "next" if the pointer isn't from our buffer */
+  if ((previous_item_index < CMOCK_MEM_ALIGN_SIZE) || (previous_item_index  >= CMock_Guts_FreePtr))
+  {
+    return CMOCK_GUTS_NONE;
+  }
+  previous_item = (void*)(&CMock_Guts_Buffer[previous_item_index]);
+
+  /* if the pointer is good, then use it to look up the next index
+   * (we know the first element always goes in zero, so NEXT must always be > 1) */
+  index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)previous_item - CMOCK_MEM_INDEX_SIZE);
+  if ((index > 1) && (index < CMock_Guts_FreePtr))
+  {
+    return index;
+  }
+  else
+  {
+    return CMOCK_GUTS_NONE;
+  }
+}
+
+/*-------------------------------------------------------
+ * CMock_Guts_MemEndOfChain
+ *-------------------------------------------------------*/
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemEndOfChain(CMOCK_MEM_INDEX_TYPE root_index)
+{
+  CMOCK_MEM_INDEX_TYPE index = root_index;
+  CMOCK_MEM_INDEX_TYPE next_index;
+
+  for (next_index = root_index;
+       next_index != CMOCK_GUTS_NONE;
+       next_index = CMock_Guts_MemNext(index))
+  {
+    index = next_index;
+  }
+
+  return index;
+}
+
+/*-------------------------------------------------------
+ * CMock_GetAddressFor
+ *-------------------------------------------------------*/
+void* CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index)
+{
+  if ((index >= CMOCK_MEM_ALIGN_SIZE) && (index < CMock_Guts_FreePtr))
+  {
+    return (void*)(&CMock_Guts_Buffer[index]);
+  }
+  else
+  {
+    return NULL;
+  }
+}
+
+/*-------------------------------------------------------
+ * CMock_Guts_MemBytesCapacity
+ *-------------------------------------------------------*/
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesCapacity(void)
+{
+  return (sizeof(CMock_Guts_Buffer) - CMOCK_MEM_ALIGN_SIZE);
+}
+
+/*-------------------------------------------------------
+ * CMock_Guts_MemBytesFree
+ *-------------------------------------------------------*/
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesFree(void)
+{
+  return CMock_Guts_BufferSize - CMock_Guts_FreePtr;
+}
+
+/*-------------------------------------------------------
+ * CMock_Guts_MemBytesUsed
+ *-------------------------------------------------------*/
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesUsed(void)
+{
+  return CMock_Guts_FreePtr - CMOCK_MEM_ALIGN_SIZE;
+}
+
+/*-------------------------------------------------------
+ * CMock_Guts_MemFreeAll
+ *-------------------------------------------------------*/
+void CMock_Guts_MemFreeAll(void)
+{
+  CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE; /* skip the very beginning */
+}
+
+/*-------------------------------------------------------
+ * CMock_Guts_MemFreeFinal
+ *-------------------------------------------------------*/
+void CMock_Guts_MemFreeFinal(void)
+{
+  CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
+#ifdef CMOCK_MEM_DYNAMIC
+  if (CMock_Guts_Buffer)
+  {
+    free(CMock_Guts_Buffer);
+    CMock_Guts_Buffer = NULL;
+  }
+#endif
+}
+