acpc_dealer 2.1.2 → 2.1.3

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/lib/cmock_header_parser.rb

@@ -1,277 +0,0 @@
-# ==========================================
-#   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 CMockHeaderParser
-
-  attr_accessor :funcs, :c_attributes, :treat_as_void, :treat_externs
-  
-  def initialize(cfg)
-    @funcs = []
-    @c_strippables = cfg.strippables
-    @c_attributes = (['const'] + cfg.attributes).uniq
-    @c_calling_conventions = cfg.c_calling_conventions.uniq
-    @treat_as_void = (['void'] + cfg.treat_as_void).uniq
-    @declaration_parse_matcher = /([\d\w\s\*\(\),\[\]]+??)\(([\d\w\s\*\(\),\.\[\]+-]*)\)$/m
-    @standards = (['int','short','char','long','unsigned','signed'] + cfg.treat_as.keys).uniq
-    @when_no_prototypes = cfg.when_no_prototypes
-    @local_as_void = @treat_as_void
-    @verbosity = cfg.verbosity
-    @treat_externs = cfg.treat_externs
-    @c_strippables += ['extern'] if (@treat_externs == :include) #we'll need to remove the attribute if we're allowing externs
-  end
-  
-  def parse(name, source)
-    @module_name = name.gsub(/\W/,'')
-    @typedefs = []
-    @funcs = []
-    function_names = []
-    
-    parse_functions( import_source(source) ).map do |decl| 
-      func = parse_declaration(decl)
-      unless (function_names.include? func[:name])
-        @funcs << func
-        function_names << func[:name]
-      end
-    end
-    
-    { :includes  => nil,
-      :functions => @funcs,
-      :typedefs  => @typedefs
-    }
-  end
-  
-  private if $ThisIsOnlyATest.nil? ################
-  
-  def import_source(source)
-
-    # void must be void for cmock _ExpectAndReturn calls to process properly, not some weird typedef which equates to void
-    # to a certain extent, this action assumes we're chewing on pre-processed header files, otherwise we'll most likely just get stuff from @treat_as_void
-    @local_as_void = @treat_as_void
-    void_types = source.scan(/typedef\s+(?:\(\s*)?void(?:\s*\))?\s+([\w\d]+)\s*;/)
-    if void_types
-      @local_as_void += void_types.flatten.uniq.compact
-    end
-  
-    # 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 assembler pragma sections
-    source.gsub!(/^\s*#\s*pragma\s+asm\s+.*?#\s*pragma\s+endasm/m, '')
-    
-    # remove gcc's __attribute__ tags
-    source.gsub(/__attrbute__\s*\(\(\.*\)\)/, '')
-    
-    # remove preprocessor statements and extern "C" 
-    source.gsub!(/^\s*#.*/, '')
-    source.gsub!(/extern\s+\"C\"\s+\{/, '')
-    
-    # enums, unions, structs, and typedefs can all contain things (e.g. function pointers) that parse like function prototypes, so yank them
-    # forward declared structs are removed before struct definitions so they don't mess up real thing later. we leave structs keywords in function prototypes
-    source.gsub!(/^[\w\s]*struct[^;\{\}\(\)]+;/m, '')                                      # remove forward declared structs
-    source.gsub!(/^[\w\s]*(enum|union|struct|typepdef)[\w\s]*\{[^\}]+\}[\w\s\*\,]*;/m, '') # remove struct, union, and enum definitions and typedefs with braces
-    source.gsub!(/(\W)(?:register|auto|static|restrict)(\W)/, '\1\2')                      # remove problem keywords
-    source.gsub!(/\s*=\s*['"a-zA-Z0-9_\.]+\s*/, '')                                        # remove default value statements from argument lists
-    source.gsub!(/^(?:[\w\s]*\W)?typedef\W.*/, '')                                         # remove typedef statements
-    source.gsub!(/(^|\W+)(?:#{@c_strippables.join('|')})(?=$|\W+)/,'\1') unless @c_strippables.empty? # remove known attributes slated to be stripped
-    
-    #scan for functions which return function pointers, because they are a pain
-    source.gsub!(/([\w\s\*]+)\(*\(\s*\*([\w\s\*]+)\s*\(([\w\s\*,]*)\)\)\s*\(([\w\s\*,]*)\)\)*/) do |m|
-      functype = "cmock_#{@module_name}_func_ptr#{@typedefs.size + 1}"
-      @typedefs << "typedef #{$1.strip}(*#{functype})(#{$4});"
-      "#{functype} #{$2.strip}(#{$3});"
-    end
-    
-    #drop extra white space to make the rest go faster
-    source.gsub!(/^\s+/, '')          # remove extra white space from beginning of line
-    source.gsub!(/\s+$/, '')          # remove extra white space from end of line
-    source.gsub!(/\s*\(\s*/, '(')     # remove extra white space from before left parens
-    source.gsub!(/\s*\)\s*/, ')')     # remove extra white space from before right parens
-    source.gsub!(/\s+/, ' ')          # remove remaining extra white space
-    
-    #split lines on semicolons and remove things that are obviously not what we are looking for
-    src_lines = source.split(/\s*;\s*/)
-    src_lines.delete_if {|line| line.strip.length == 0}                            # remove blank lines
-    src_lines.delete_if {|line| !(line =~ /[\w\s\*]+\(+\s*\*[\*\s]*[\w\s]+(?:\[[\w\s]*\]\s*)+\)+\s*\((?:[\w\s\*]*,?)*\s*\)/).nil?}     #remove function pointer arrays
-    if (@treat_externs == :include)
-      src_lines.delete_if {|line| !(line =~ /(?:^|\s+)(?:inline)\s+/).nil?}        # remove inline functions
-    else
-      src_lines.delete_if {|line| !(line =~ /(?:^|\s+)(?:extern|inline)\s+/).nil?} # remove inline and extern functions
-    end
-  end
-
-  def parse_functions(source)
-    funcs = []
-    source.each {|line| funcs << line.strip.gsub(/\s+/, ' ') if (line =~ @declaration_parse_matcher)}
-    if funcs.empty?
-      case @when_no_prototypes
-        when :error
-          raise "ERROR: No function prototypes found!" 
-        when :warn
-          puts "WARNING: No function prototypes found!" unless (@verbosity < 1)
-      end
-    end
-    return funcs
-  end
-  
-  def parse_args(arg_list)
-    args = []
-    arg_list.split(',').each do |arg|
-      arg.strip! 
-      return args if (arg =~ /^\s*((\.\.\.)|(void))\s*$/)   # we're done if we reach void by itself or ...
-      arg_array = arg.split
-      arg_elements = arg_array - @c_attributes              # split up words and remove known attributes
-      args << { :type   => (arg_type =arg_elements[0..-2].join(' ')), 
-                :name   => arg_elements[-1], 
-                :ptr?   => divine_ptr(arg_type),
-                :const? => arg_array.include?('const')
-              }
-    end
-    return args
-  end
-
-  def divine_ptr(arg_type)
-    return false unless arg_type.include? '*'
-    return false if arg_type.gsub(/(const|char|\*|\s)+/,'').empty?
-    return true
-  end
-
-  def clean_args(arg_list)
-    if ((@local_as_void.include?(arg_list.strip)) or (arg_list.empty?))
-      return 'void'
-    else
-      c=0
-      arg_list.gsub!(/(\w+)(?:\s*\[[\s\d\w+-]*\])+/,'*\1')  # magically turn brackets into asterisks
-      arg_list.gsub!(/\s+\*/,'*')                           # remove space to place asterisks with type (where they belong)
-      arg_list.gsub!(/\*(\w)/,'* \1')                       # pull asterisks away from arg to place asterisks with type (where they belong)
-      
-      #scan argument list for function pointers and replace them with custom types
-      arg_list.gsub!(/([\w\s\*]+)\(+\s*\*[\*\s]*([\w\s]*)\s*\)+\s*\(((?:[\w\s\*]*,?)*)\s*\)*/) do |m|
-
-        functype = "cmock_#{@module_name}_func_ptr#{@typedefs.size + 1}"
-        funcret  = $1.strip
-        funcname = $2.strip
-        funcargs = $3.strip
-        funconst = ''
-        if (funcname.include? 'const')
-          funcname.gsub!('const','').strip!
-          funconst = 'const '
-        end
-        @typedefs << "typedef #{funcret}(*#{functype})(#{funcargs});"
-        funcname = "cmock_arg#{c+=1}" if (funcname.empty?)
-        "#{functype} #{funconst}#{funcname}"
-      end
-      
-      #automatically name unnamed arguments (those that only had a type)
-      arg_list.split(/\s*,\s*/).map { |arg| 
-        parts = (arg.split - ['struct', 'union', 'enum', 'const', 'const*'])
-        if ((parts.size < 2) or (parts[-1][-1].chr == '*') or (@standards.include?(parts[-1])))
-          "#{arg} cmock_arg#{c+=1}" 
-        else
-          arg
-        end
-      }.join(', ')
-    end
-  end
-  
-  def parse_declaration(declaration)
-    decl = {}
-    
-    regex_match = @declaration_parse_matcher.match(declaration)
-    raise "Failed parsing function declaration: '#{declaration}'" if regex_match.nil? 
-    
-    #grab argument list
-    args = regex_match[2].strip
-
-    #process function attributes, return type, and name
-    descriptors = regex_match[1]
-    descriptors.gsub!(/\s+\*/,'*')     #remove space to place asterisks with return type (where they belong)
-    descriptors.gsub!(/\*(\w)/,'* \1') #pull asterisks away from function name to place asterisks with return type (where they belong)
-    descriptors = descriptors.split    #array of all descriptor strings
-
-    #grab name
-    decl[:name] = descriptors[-1]      #snag name as last array item
-
-    #build attribute and return type strings
-    decl[:modifier] = []
-    rettype = []
-    descriptors[0..-2].each do |word|
-      if @c_attributes.include?(word)
-        decl[:modifier] << word
-      elsif @c_calling_conventions.include?(word)
-        decl[:c_calling_convention] = word
-      else
-        rettype << word
-      end
-    end
-    decl[:modifier] = decl[:modifier].join(' ')
-    rettype = rettype.join(' ')
-    rettype = 'void' if (@local_as_void.include?(rettype.strip))
-    decl[:return] = { :type   => rettype, 
-                      :name   => 'cmock_to_return', 
-                      :ptr?   => divine_ptr(rettype),
-                      :const? => rettype.split(/\s/).include?('const'),
-                      :str    => "#{rettype} cmock_to_return",
-                      :void?  => (rettype == 'void')
-                    }
-        
-    #remove default argument statements from mock definitions
-    args.gsub!(/=\s*[a-zA-Z0-9_\.]+\s*/, ' ')
-    
-    #check for var args
-    if (args =~ /\.\.\./)
-      decl[:var_arg] = args.match( /[\w\s]*\.\.\./ ).to_s.strip
-      if (args =~ /\,[\w\s]*\.\.\./)
-        args = args.gsub!(/\,[\w\s]*\.\.\./,'')
-      else
-        args = 'void'
-      end
-    else
-      decl[:var_arg] = nil
-    end
-    args = clean_args(args)
-    decl[:args_string] = args
-    decl[:args] = parse_args(args)
-    decl[:args_call] = decl[:args].map{|a| a[:name]}.join(', ')
-    decl[:contains_ptr?] = decl[:args].inject(false) {|ptr, arg| arg[:ptr?] ? true : ptr }
-      
-    if (decl[:return][:type].nil?   or decl[:name].nil?   or decl[:args].nil? or
-        decl[:return][:type].empty? or decl[:name].empty?)
-      raise "Failed Parsing Declaration Prototype!\n" +
-        "  declaration: '#{declaration}'\n" +
-        "  modifier: '#{decl[:modifier]}'\n" +
-        "  return: #{prototype_inspect_hash(decl[:return])}\n" +
-        "  function: '#{decl[:name]}'\n" +
-        "  args: #{prototype_inspect_array_of_hashes(decl[:args])}\n"
-    end
-
-    return decl
-  end
-
-  def prototype_inspect_hash(hash)
-    pairs = []
-    hash.each_pair { |name, value| pairs << ":#{name} => #{"'" if (value.class == String)}#{value}#{"'" if (value.class == String)}" }
-    return "{#{pairs.join(', ')}}"
-  end
-
-  def prototype_inspect_array_of_hashes(array)
-    hashes = []
-    array.each { |hash| hashes << prototype_inspect_hash(hash) }
-    case (array.size)
-    when 0
-      return "[]"
-    when 1
-      return "[#{hashes[0]}]"
-    else
-      return "[\n    #{hashes.join("\n    ")}\n  ]\n"
-    end
-  end
-
-end

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/lib/cmock_plugin_manager.rb

@@ -1,40 +0,0 @@
-# ==========================================
-#   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 CMockPluginManager
-
-  attr_accessor :plugins
-  
-  def initialize(config, utils)
-    @plugins = []
-    plugins_to_load = [:expect, config.plugins].flatten.uniq.compact
-    plugins_to_load.each do |plugin|
-      plugin_name = plugin.to_s
-      object_name = "CMockGeneratorPlugin" + camelize(plugin_name)
-      begin
-        unless (Object.const_defined? object_name)
-          require "#{File.expand_path(File.dirname(__FILE__))}/cmock_generator_plugin_#{plugin_name.downcase}.rb"
-        end
-        @plugins << eval("#{object_name}.new(config, utils)")
-      rescue
-        raise "ERROR: CMock unable to load plugin '#{plugin_name}'"
-      end
-    end
-    @plugins.sort! {|a,b| a.priority <=> b.priority }
-  end
-  
-  def run(method, args=nil)
-    if args.nil?
-      return @plugins.collect{ |plugin| plugin.send(method) if plugin.respond_to?(method) }.flatten.join
-    else
-      return @plugins.collect{ |plugin| plugin.send(method, args) if plugin.respond_to?(method) }.flatten.join
-    end
-  end
-  
-  def camelize(lower_case_and_underscored_word)
-    lower_case_and_underscored_word.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
-  end
-end

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/lib/cmock_unityhelper_parser.rb

@@ -1,75 +0,0 @@
-# ==========================================
-#   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 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 = 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
-    return (lookup =~ /\*$/) ? [@fallback, '&'] : [@fallback, '']
-  end
-  
-  private ###########################
-  
-  def map_C_types
-    c_types = {}
-    @config.treat_as.each_pair do |ctype, expecttype|
-      c_type = ctype.gsub(/\s+/,'_')
-      if (expecttype =~ /\*/)
-        c_types[c_type] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype.gsub(/\*/,'')}_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/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/release/build.info

@@ -1,2 +0,0 @@
-212
-

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/release/version.info

@@ -1,2 +0,0 @@
-2.0
-

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/src/cmock.c

@@ -1,176 +0,0 @@
-/* ==========================================
-    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, 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_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
-}