ceedling 0.18.0 → 0.19.0

data/vendor/cmock/release/build.info

@@ -1,2 +1,2 @@
-213
+214
 

data/vendor/cmock/release/version.info

@@ -1,2 +1,2 @@
-2.3
+2.4.0
 

data/vendor/cmock/scripts/create_makefile.rb

@@ -0,0 +1,161 @@
+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_')
+TEST_MAKEFILE = ENV.fetch('TEST_MAKEFILE', File.join(TEST_BUILD_DIR, 'MakefileTestSupport'))
+MOCK_MATCHER = /#{MOCK_PREFIX}[A-Za-z_][A-Za-z0-9_\-\.]+/
+
+[TEST_BUILD_DIR, OBJ_DIR, RUNNERS_DIR, MOCKS_DIR, TEST_BIN_DIR].each do |dir|
+  FileUtils.mkdir_p dir
+end
+
+all_headers_to_mock = []
+
+File.open(TEST_MAKEFILE, "w") do |mkfile|
+
+  # Define make variables
+  mkfile.puts "CC ?= gcc"
+  mkfile.puts "BUILD_DIR ?= ./build"
+  mkfile.puts "SRC_DIR ?= ./src"
+  mkfile.puts "TEST_DIR ?= ./test"
+  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
+  all_headers = Dir["#{SRC_DIR}/**/*.h"]
+
+  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 + '.result')
+
+    # 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")
+    mkfile.puts "#{module_obj}: #{module_src}"
+    mkfile.puts "\t${CC} -o $@ -c $< -DTEST -I #{SRC_DIR}"
+    mkfile.puts ""
+
+    # 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}"
+    mkfile.puts ""
+
+    # Collect mocks to generate
+    cfg = {
+      src: test,
+      includes: generator.find_includes(File.readlines(test).join(''))
+    }
+    system_mocks = cfg[:includes][:system].select{|name| name =~ MOCK_MATCHER}
+    raise "Mocking of system headers is not yet supported!" if !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}/,'')}.h"}
+    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, '.h')
+      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}"
+    mkfile.puts ""
+
+    # Build test suite executable
+    test_objs = "#{test_obj} #{runner_obj} #{module_obj} #{mock_objs.join(' ')} #{UNITY_OBJ} #{CMOCK_OBJ}"
+    mkfile.puts "#{test_bin}: #{test_objs}"
+    mkfile.puts "\t${CC} -o $@ #{test_objs}"
+    mkfile.puts ""
+
+    # Run test suite and generate report
+    mkfile.puts "#{test_results}: #{test_bin}"
+    mkfile.puts "\t-#{test_bin} &> #{test_results}"
+    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, '.h')
+    mock_header = File.join(MOCKS_DIR, mock_name + '.h')
+    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}"
+    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"
+  mkfile.puts ""
+  mkfile.puts ".PHONY: test_summary"
+  mkfile.puts ""
+
+  # Create target to run all tests
+  mkfile.puts "test: #{test_targets.map{|t| t + '.result'}.join(' ')} test_summary"
+  mkfile.puts ""
+
+end

data/vendor/cmock/scripts/create_mock.rb

@@ -0,0 +1,8 @@
+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: [:ignore, :return_thru_ptr], mock_prefix: 'mock_', mock_path: mock_out)
+cmock.setup_mocks(ARGV[0])

data/vendor/cmock/scripts/create_runner.rb

@@ -0,0 +1,20 @@
+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]
+  generator = UnityTestRunnerGenerator.new.run(test, runner)
+
+end

data/vendor/cmock/scripts/test_summary.rb

@@ -0,0 +1,11 @@
+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}/*.result"]
+parser = UnityTestSummary.new
+parser.set_targets(results)
+parser.run
+puts parser.report
+exit(parser.failures)

data/vendor/cmock/src/cmock.c

@@ -1,192 +1,203 @@
-/* ==========================================
-    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 "unity.h"
-
-#include "cmock_internals.h"
-
-//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;
-#else
-static unsigned char          CMock_Guts_Buffer[CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE];
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr;
-#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)
-  {
-#ifdef CMOCK_MEM_DYNAMIC
-    CMock_Guts_BufferSize += CMOCK_MEM_SIZE + size;
-    CMock_Guts_Buffer = realloc(CMock_Guts_Buffer, (size_t)CMock_Guts_BufferSize);
-    if (CMock_Guts_Buffer == NULL)
-#endif //yes that if will continue to the return below if TRUE
-      return CMOCK_GUTS_NONE;
-  }
-
-  //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_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
-}
-
+/* ==========================================
+    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 "unity.h"
+#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 less 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* 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;
+#else
+static unsigned char          CMock_Guts_Buffer[CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE];
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr;
+#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)
+  {
+#ifdef CMOCK_MEM_DYNAMIC
+    CMock_Guts_BufferSize += CMOCK_MEM_SIZE + size;
+    CMock_Guts_Buffer = realloc(CMock_Guts_Buffer, (size_t)CMock_Guts_BufferSize);
+    if (CMock_Guts_Buffer == NULL)
+#endif //yes that if will continue to the return below if TRUE
+      return CMOCK_GUTS_NONE;
+  }
+
+  //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_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
+}
+