ceedling 0.28.2 → 0.28.3

data/spec/support/test_example.fail

@@ -19,3 +19,4 @@
 :stdout:
 - Verbose output one
 - Verbous output two
+:time: 0.0

data/spec/support/test_example.pass

@@ -19,3 +19,4 @@
 :stdout:
 - Verbose output one
 - Verbous output two
+:time: 0.0

data/spec/support/test_example_empty.pass

@@ -11,3 +11,4 @@
   :failed: 0
   :ignored: 0
 :stdout: []
+:time: 0.0

data/spec/support/test_example_ignore.pass

@@ -19,3 +19,4 @@
 :stdout:
 - Verbose output one
 - Verbous output two
+:time: 0.0

data/spec/support/test_example_mangled.pass

@@ -17,3 +17,4 @@
 :stdout:
 - Verbose output one
 - test_example.c:269:test_tVerbous output two
+:time: 0.0

data/spec/support/test_example_with_time.pass

@@ -0,0 +1,22 @@
+---
+:source:
+  :path: some/place
+  :file: test_example.c
+:successes:
+- :test: test_one
+  :line: 257
+  :message: ''
+- :test: test_two
+  :line: 269
+  :message: ''
+:failures: []
+:ignores: []
+:counts:
+  :total: 2
+  :passed: 2
+  :failed: 0
+  :ignored: 0
+:stdout:
+- Verbose output one
+- Verbous output two
+:time: 0.01234

data/spec/system/deployment_spec.rb

@@ -30,11 +30,32 @@ describe "Ceedling" do
     it { can_test_projects_with_success }
     it { can_test_projects_with_fail }
     it { can_test_projects_with_compile_error }
+    it { uses_raw_output_report_plugin }
     it { can_use_the_module_plugin }
+    it { can_use_the_module_plugin_path_extension }
+    it { can_use_the_module_plugin_with_include_path }
     it { handles_creating_the_same_module_twice_using_the_module_plugin }
     it { handles_destroying_a_module_that_does_not_exist_using_the_module_plugin }
+    it { handles_destroying_a_module_that_does_not_exist_using_the_module_plugin_path_extension }
   end
 
+  describe "deployed in a project's `vendor` directory." do
+    before do
+      @c.with_context do
+        `bundle exec ruby -S ceedling new --with-ignore #{@proj_name} 2>&1`
+      end
+    end
+
+    it { can_create_projects }
+    it { has_an_ignore }
+    it { contains_a_vendor_directory }
+    it { contains_documentation }
+    it { can_test_projects_with_success }
+    it { can_use_the_module_plugin }
+  end
+
+
+
   describe "deployed in a project's `vendor` directory without docs." do
     before do
       @c.with_context do
@@ -51,8 +72,11 @@ describe "Ceedling" do
     it { can_test_projects_with_fail }
     it { can_test_projects_with_compile_error }
     it { can_use_the_module_plugin }
+    it { can_use_the_module_plugin_path_extension }
+    it { can_use_the_module_plugin_with_include_path }
     it { handles_creating_the_same_module_twice_using_the_module_plugin }
     it { handles_destroying_a_module_that_does_not_exist_using_the_module_plugin }
+    it { handles_destroying_a_module_that_does_not_exist_using_the_module_plugin_path_extension }
   end
 
   describe "ugrade a project's `vendor` directory" do
@@ -71,8 +95,11 @@ describe "Ceedling" do
     it { can_test_projects_with_fail }
     it { can_test_projects_with_compile_error }
     it { can_use_the_module_plugin }
+    it { can_use_the_module_plugin_path_extension }
+    it { can_use_the_module_plugin_with_include_path }
     it { handles_creating_the_same_module_twice_using_the_module_plugin }
     it { handles_destroying_a_module_that_does_not_exist_using_the_module_plugin }
+    it { handles_destroying_a_module_that_does_not_exist_using_the_module_plugin_path_extension }
 
     it { can_upgrade_projects }
     it { contains_a_vendor_directory }
@@ -82,8 +109,11 @@ describe "Ceedling" do
     it { can_test_projects_with_fail }
     it { can_test_projects_with_compile_error }
     it { can_use_the_module_plugin }
+    it { can_use_the_module_plugin_path_extension }
+    it { can_use_the_module_plugin_with_include_path }
     it { handles_creating_the_same_module_twice_using_the_module_plugin }
     it { handles_destroying_a_module_that_does_not_exist_using_the_module_plugin }
+    it { handles_destroying_a_module_that_does_not_exist_using_the_module_plugin_path_extension }
   end
 
   describe "deployed as a gem" do
@@ -101,8 +131,11 @@ describe "Ceedling" do
     it { can_test_projects_with_fail }
     it { can_test_projects_with_compile_error }
     it { can_use_the_module_plugin }
+    it { can_use_the_module_plugin_path_extension }
+    it { can_use_the_module_plugin_with_include_path }
     it { handles_creating_the_same_module_twice_using_the_module_plugin }
     it { handles_destroying_a_module_that_does_not_exist_using_the_module_plugin }
+    it { handles_destroying_a_module_that_does_not_exist_using_the_module_plugin_path_extension }
   end
 
   describe "command: `ceedling examples`" do

data/vendor/cmock/README.md

@@ -7,17 +7,18 @@ Getting Started
 ================
 
 If you're using Ceedling, there is no need to install CMock. It will handle it for you.
-For everyone else, the simplest way is to grab it off github. You can also download it 
+For everyone else, the simplest way is to grab it off github. You can also download it
 as a zip if you prefer. The Github method looks something like this:
 
     > git clone --recursive https://github.com/throwtheswitch/cmock.git
     > cd cmock
     > bundle install # Ensures you have all RubyGems needed
-    
+
 If you plan to help with the development of CMock (or just want to verify that it can
 perform its self tests on your system) then you can enter the test directory and then
 ask it to test:
-    
+
+    > cd test
     > rake # Run all CMock self tests
 
 API Documentation

data/vendor/cmock/docs/CMock_Summary.md

@@ -597,7 +597,7 @@ Examples
 
 You can look in the [examples directory](/examples/) for a couple of examples on how
 you might tool CMock into your build process. You may also want to consider
-using [Ceedling](https://throwtheswitch.org/Ceedling). Please note that
+using [Ceedling](https://throwtheswitch.org/ceedling). Please note that
 these examples are meant to show how the build process works. They have
 failing tests ON PURPOSE to show what that would look like. Don't be alarmed. ;)
 

data/vendor/cmock/lib/cmock_config.rb

@@ -120,6 +120,8 @@ class CMockConfig
       'UINT32'          => 'HEX32',
       'UINT32_T'        => 'HEX32',
       'void*'           => 'HEX8_ARRAY',
+      'void const*'     => 'HEX8_ARRAY',
+      'const void*'     => 'HEX8_ARRAY',
       'unsigned short'  => 'HEX16',
       'uint16'          => 'HEX16',
       'uint16_t'        => 'HEX16',
@@ -131,6 +133,8 @@ class CMockConfig
       'UINT8'           => 'HEX8',
       'UINT8_T'         => 'HEX8',
       'char*'           => 'STRING',
+      'char const*'     => 'STRING',
+      'const char*'     => 'STRING',
       'pCHAR'           => 'STRING',
       'cstring'         => 'STRING',
       'CSTRING'         => 'STRING',

data/vendor/cmock/lib/cmock_generator.rb

@@ -103,7 +103,9 @@ class CMockGenerator
     file << "\n"
     file << "/* Ignore the following warnings, since we are copying code */\n"
     file << "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n"
+    file << "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n"
     file << "#pragma GCC diagnostic push\n"
+    file << "#endif\n"
     file << "#if !defined(__clang__)\n"
     file << "#pragma GCC diagnostic ignored \"-Wpragmas\"\n"
     file << "#endif\n"
@@ -128,8 +130,10 @@ class CMockGenerator
   def create_mock_header_footer(header)
     header << "\n"
     header << "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n"
+    header << "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n"
     header << "#pragma GCC diagnostic pop\n"
     header << "#endif\n"
+    header << "#endif\n"
     header << "\n"
     header << "#endif\n"
   end
@@ -247,10 +251,9 @@ class CMockGenerator
       file << "  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)\n"
       file << "    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);\n"
     end
-    return_type = function[:return][:const?] ? "(const #{function[:return][:type]})" : ((function[:return][:type] =~ /cmock/) ? "(#{function[:return][:type]})" : '')
     file << @plugins.run(:mock_implementation, function)
     file << "  UNITY_CLR_DETAILS();\n"
-    file << "  return #{return_type}cmock_call_instance->ReturnVal;\n" unless (function[:return][:void?])
+    file << "  return cmock_call_instance->ReturnVal;\n" unless (function[:return][:void?])
     file << "}\n\n"
   end
 

data/vendor/cmock/lib/cmock_generator_plugin_array.rb

@@ -27,8 +27,8 @@ class CMockGeneratorPluginArray
     return nil unless function[:contains_ptr?]
     args_call   = function[:args].map{|m| m[:ptr?] ? "#{m[:name]}, #{m[:name]}_Depth" : "#{m[:name]}"}.join(', ')
     args_string = function[:args].map do |m|
-      const_str = m[:const?] ? 'const ' : ''
-      m[:ptr?] ? "#{const_str}#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{const_str}#{m[:type]} #{m[:name]}"
+      type = @utils.arg_type_with_const(m)
+      m[:ptr?] ? "#{type} #{m[:name]}, int #{m[:name]}_Depth" : "#{type} #{m[:name]}"
     end.join(', ')
     if (function[:return][:void?])
       return "#define #{function[:name]}_ExpectWithArray(#{args_call}) #{function[:name]}_CMockExpectWithArray(__LINE__, #{args_call})\n" +
@@ -44,8 +44,8 @@ class CMockGeneratorPluginArray
     lines = []
     func_name = function[:name]
     args_string = function[:args].map do |m|
-      const_str = m[:const?] ? 'const ' : ''
-      m[:ptr?] ? "#{const_str}#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{const_str}#{m[:type]} #{m[:name]}"
+      type = @utils.arg_type_with_const(m)
+      m[:ptr?] ? "#{type} #{m[:name]}, int #{m[:name]}_Depth" : "#{type} #{m[:name]}"
     end.join(', ')
     call_string = function[:args].map{|m| m[:ptr?] ? "#{m[:name]}, #{m[:name]}_Depth" : m[:name]}.join(', ')
     if (function[:return][:void?])

data/vendor/cmock/lib/cmock_generator_plugin_callback.rb

@@ -33,7 +33,7 @@ class CMockGeneratorPluginCallback
 
   def mock_function_declarations(function)
     func_name = function[:name]
-    return_type = function[:return][:const?] ? "const #{function[:return][:type]}" : function[:return][:type]
+    return_type = function[:return][:type]
     style  = (@include_count ? 1 : 0) | (function[:args].empty? ? 0 : 2)
     styles = [ "void", "int cmock_num_calls", function[:args_string], "#{function[:args_string]}, int cmock_num_calls" ]
     "typedef #{return_type} (* CMOCK_#{func_name}_CALLBACK)(#{styles[style]});\nvoid #{func_name}_StubWithCallback(CMOCK_#{func_name}_CALLBACK Callback);\n"
@@ -41,7 +41,6 @@ class CMockGeneratorPluginCallback
 
   def mock_implementation_for_callbacks_after_arg_check(function)
     func_name   = function[:name]
-    return_cast = function[:return][:const?] ? "(#{function[:return][:type]})" : ""
     style  = (@include_count ? 1 : 0) | (function[:args].empty? ? 0 : 2) | (function[:return][:void?] ? 0 : 4)
     "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n  {\n" +
     case(style)
@@ -49,16 +48,15 @@ class CMockGeneratorPluginCallback
       when 1 then "    Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n  }\n"
       when 2 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n  }\n"
       when 3 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n  }\n"
-      when 4 then "    cmock_call_instance->ReturnVal = #{return_cast}Mock.#{func_name}_CallbackFunctionPointer();\n  }\n"
-      when 5 then "    cmock_call_instance->ReturnVal = #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n  }\n"
-      when 6 then "    cmock_call_instance->ReturnVal = #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n  }\n"
-      when 7 then "    cmock_call_instance->ReturnVal = #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n  }\n"
+      when 4 then "    cmock_call_instance->ReturnVal = Mock.#{func_name}_CallbackFunctionPointer();\n  }\n"
+      when 5 then "    cmock_call_instance->ReturnVal = Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n  }\n"
+      when 6 then "    cmock_call_instance->ReturnVal = Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n  }\n"
+      when 7 then "    cmock_call_instance->ReturnVal = Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n  }\n"
     end
   end
 
   def mock_implementation_for_callbacks_without_arg_check(function)
     func_name   = function[:name]
-    return_cast = function[:return][:const?] ? "(#{function[:return][:type]})" : ""
     style  = (@include_count ? 1 : 0) | (function[:args].empty? ? 0 : 2) | (function[:return][:void?] ? 0 : 4)
     "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n  {\n" +
     case(style)
@@ -66,10 +64,10 @@ class CMockGeneratorPluginCallback
       when 1 then "    Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n    return;\n  }\n"
       when 2 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n    return;\n  }\n"
       when 3 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n    return;\n  }\n"
-      when 4 then "    return #{return_cast}Mock.#{func_name}_CallbackFunctionPointer();\n  }\n"
-      when 5 then "    return #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n  }\n"
-      when 6 then "    return #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n  }\n"
-      when 7 then "    return #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n  }\n"
+      when 4 then "    return Mock.#{func_name}_CallbackFunctionPointer();\n  }\n"
+      when 5 then "    return Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n  }\n"
+      when 6 then "    return Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n  }\n"
+      when 7 then "    return Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n  }\n"
     end
   end
 

data/vendor/cmock/lib/cmock_generator_plugin_cexception.rb

@@ -41,7 +41,6 @@ class CMockGeneratorPluginCexception
 
   def mock_interfaces(function)
     arg_insert = (function[:args_string] == "void") ? "" : "#{function[:args_string]}, "
-    call_string = function[:args].map{|m| m[:name]}.join(', ')
     [ "void #{function[:name]}_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, #{arg_insert}CEXCEPTION_T cmock_to_throw)\n{\n",
       @utils.code_add_base_expectation(function[:name]),
       @utils.code_call_argument_loader(function),

data/vendor/cmock/lib/cmock_generator_plugin_ignore.rb

@@ -40,10 +40,9 @@ class CMockGeneratorPluginIgnore
       lines << "    return;\n  }\n"
     else
       retval = function[:return].merge( { :name => "cmock_call_instance->ReturnVal"} )
-      return_type = function[:return][:const?] ? "(const #{function[:return][:type]})" : ((function[:return][:type] =~ /cmock/) ? "(#{function[:return][:type]})" : '')
-      lines << "    if (cmock_call_instance == NULL)\n      return #{return_type}Mock.#{function[:name]}_FinalReturn;\n"
+      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 #{return_type}cmock_call_instance->ReturnVal;\n  }\n"
+      lines << "    return cmock_call_instance->ReturnVal;\n  }\n"
     end
     lines
   end

data/vendor/cmock/lib/cmock_generator_plugin_ignore_arg.rb

@@ -29,14 +29,12 @@ class CMockGeneratorPluginIgnoreArg
     lines = []
     func_name = function[:name]
     function[:args].each do |arg|
-      arg_name = arg[:name]
-      arg_type = arg[:type]
-      lines << "void #{function[:name]}_CMockIgnoreArg_#{arg[:name]}(UNITY_LINE_TYPE cmock_line)\n"
+      lines << "void #{func_name}_CMockIgnoreArg_#{arg[:name]}(UNITY_LINE_TYPE cmock_line)\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"
       lines << "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);\n"
-      lines << "  cmock_call_instance->IgnoreArg_#{arg_name} = 1;\n"
+      lines << "  cmock_call_instance->IgnoreArg_#{arg[:name]} = 1;\n"
       lines << "}\n\n"
     end
     lines

data/vendor/cmock/lib/cmock_generator_plugin_return_thru_ptr.rb

@@ -40,7 +40,6 @@ class CMockGeneratorPluginReturnThruPtr
     func_name = function[:name]
     function[:args].each do |arg|
       arg_name = arg[:name]
-      arg_type = arg[:type]
       if (@utils.ptr_or_str?(arg[:type]) and not arg[:const?])
         lines << "void #{func_name}_CMockReturnMemThruPtr_#{arg_name}(UNITY_LINE_TYPE cmock_line, #{arg[:type]} #{arg_name}, int cmock_size)\n"
         lines << "{\n"
@@ -60,7 +59,6 @@ class CMockGeneratorPluginReturnThruPtr
     lines = []
     function[:args].each do |arg|
       arg_name = arg[:name]
-      arg_type = arg[:type]
       if (@utils.ptr_or_str?(arg[:type]) and not arg[:const?])
         lines << "  if (cmock_call_instance->ReturnThruPtr_#{arg_name}_Used)\n"
         lines << "  {\n"

data/vendor/cmock/lib/cmock_generator_utils.rb

@@ -22,6 +22,19 @@ class CMockGeneratorUtils
 	  @helpers = helpers
   end
 
+  def self.arg_type_with_const(arg)
+    # Restore any "const" that was removed in header parsing
+    if arg[:type].include?('*')
+      arg[:const_ptr?] ? "#{arg[:type]} const" : arg[:type]
+    else
+      arg[:const?] ? "const #{arg[:type]}" : arg[:type]
+    end
+  end
+
+  def arg_type_with_const(arg)
+    self.class.arg_type_with_const(arg)
+  end
+
   def code_verify_an_arg_expectation(function, arg)
     if (@arrays)
       case(@ptr_handling)
@@ -58,7 +71,7 @@ class CMockGeneratorUtils
 
   def code_assign_argument_quickly(dest, arg)
     if (arg[:ptr?] or @treat_as.include?(arg[:type]))
-      "  #{dest} = #{arg[:const?] ? "(#{arg[:type]})" : ''}#{arg[:name]};\n"
+      "  #{dest} = #{arg[:name]};\n"
     else
       "  memcpy(&#{dest}, &#{arg[:name]}, sizeof(#{arg[:type]}));\n"
     end
@@ -68,8 +81,8 @@ class CMockGeneratorUtils
     if (function[:args_string] != "void")
       if (@arrays)
         args_string = function[:args].map do |m|
-          const_str = m[ :const? ] ? 'const ' : ''
-          m[:ptr?] ? "#{const_str}#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{const_str}#{m[:type]} #{m[:name]}"
+          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" +
         function[:args].inject("") { |all, arg| all + code_add_an_arg_expectation(arg, (arg[:ptr?] ? "#{arg[:name]}_Depth" : 1) ) } +

data/vendor/cmock/lib/cmock_header_parser.rb

@@ -6,12 +6,13 @@
 
 class CMockHeaderParser
 
-  attr_accessor :funcs, :c_attributes, :treat_as_void, :treat_externs
+  attr_accessor :funcs, :c_attr_noconst, :c_attributes, :treat_as_void, :treat_externs
 
   def initialize(cfg)
     @funcs = []
     @c_strippables = cfg.strippables
-    @c_attributes = (['const'] + cfg.attributes).uniq
+    @c_attr_noconst = cfg.attributes.uniq - ['const']
+    @c_attributes = ['const'] + c_attr_noconst
     @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
@@ -139,16 +140,51 @@ class CMockHeaderParser
     return funcs
   end
 
+  def parse_type_and_name(arg)
+    # Split up words and remove known attributes.  For pointer types, make sure
+    # to remove 'const' only when it applies to the pointer itself, not when it
+    # applies to the type pointed to.  For non-pointer types, remove any
+    # occurrence of 'const'.
+    arg.gsub!(/(\w)\*/,'\1 *') # pull asterisks away from preceding word
+    arg.gsub!(/\*(\w)/,'* \1') # pull asterisks away from following word
+    arg_array = arg.split
+    arg_info = divine_ptr_and_const(arg)
+    arg_info[:name] = arg_array[-1]
+
+    attributes = arg.include?('*') ? @c_attr_noconst : @c_attributes
+    attr_array = []
+    type_array = []
+
+    arg_array[0..-2].each do |word|
+      if attributes.include?(word)
+        attr_array << word
+      elsif @c_calling_conventions.include?(word)
+        arg_info[:c_calling_convention] = word
+      else
+        type_array << word
+      end
+    end
+
+    if arg_info[:const_ptr?]
+      attr_array << 'const'
+      type_array.delete_at(type_array.rindex('const'))
+    end
+
+    arg_info[:modifier] = attr_array.join(' ')
+    arg_info[:type] = type_array.join(' ').gsub(/\s+\*/,'*') # remove space before asterisks
+    return arg_info
+  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_elements[0..-2].join(' '),
-                :name   => arg_elements[-1]
-              }.merge(divine_ptr_and_const(arg))
+
+      arg_info = parse_type_and_name(arg)
+      arg_info.delete(:modifier)             # don't care about this
+      arg_info.delete(:c_calling_convention) # don't care about this
+      args << arg_info
     end
     return args
   end
@@ -227,35 +263,24 @@ class CMockHeaderParser
     args = regex_match[2].strip
 
     #process function attributes, return type, and name
-    descriptors = regex_match[1]
-    descriptors.gsub!(/(\w)\*/,'\1 *') #pull asterisks away from preceding word
-    descriptors.gsub!(/\*(\w)/,'* \1') #pull asterisks away from following word
-    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 = []
-    full_retval = descriptors[0..-2].join(' ')
-    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
+    parsed = parse_type_and_name(regex_match[1])
+
+    decl[:name] = parsed[:name]
+    decl[:modifier] = parsed[:modifier]
+    unless parsed[:c_calling_convention].nil?
+      decl[:c_calling_convention] = parsed[:c_calling_convention]
     end
-    decl[:modifier] = decl[:modifier].join(' ')
-    rettype = rettype.join(' ').gsub(/\s+\*/,'*') #remove space before asterisks
+
+    rettype = parsed[:type]
     rettype = 'void' if (@local_as_void.include?(rettype.strip))
-    decl[:return] = { :type   => rettype,
-                      :name   => 'cmock_to_return',
-                      :str    => "#{rettype} cmock_to_return",
-                      :void?  => (rettype == 'void')
-                    }.merge(divine_ptr_and_const(full_retval))
+    decl[:return] = { :type       => rettype,
+                      :name       => 'cmock_to_return',
+                      :str        => "#{rettype} cmock_to_return",
+                      :void?      => (rettype == 'void'),
+                      :ptr?       => parsed[:ptr?],
+                      :const?     => parsed[:const?],
+                      :const_ptr? => parsed[:const_ptr?]
+                    }
 
     #remove default argument statements from mock definitions
     args.gsub!(/=\s*[a-zA-Z0-9_\.]+\s*/, ' ')