ceedling 1.0.0 → 1.1.0

data/vendor/cmock/test/unit/cmock_header_parser_test.rb

@@ -1,7 +1,7 @@
 # =========================================================================
 #   CMock - Automatic Mock Generation for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
@@ -27,6 +27,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     @config.expect :inline_function_patterns, ['(static\s+inline|inline\s+static)\s*', '(\bstatic\b|\binline\b)\s*']
     @config.expect :array_size_type, ['int', 'size_t']
     @config.expect :array_size_name, 'size|len'
+    @config.expect :ct_assert_patterns, ['ct_assert', '_?[Ss]tatic_[Aa]ssert', '_Static_assert', 'STATIC_ASSERT', 'BUILD_ASSERT', 'CTASSERT']
 
     @parser = CMockHeaderParser.new(@config)
 
@@ -146,6 +147,118 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     assert_equal(expected, @parser.import_source(source, @test_project))
   end
 
+  it "remove code inside #if 0 blocks" do
+    source =
+      "void before(void);\n" +
+      "#if 0\n" +
+      "void hidden(void);\n" +
+      "#endif\n" +
+      "void after(void);\n"
+
+    expected = ["void before(void)", "void after(void)"]
+
+    assert_equal(expected, @parser.import_source(source, @test_project).map! { |s| s.strip })
+  end
+
+  it "keep code inside #if 1 blocks" do
+    source =
+      "void before(void);\n" +
+      "#if 1\n" +
+      "void visible(void);\n" +
+      "#endif\n" +
+      "void after(void);\n"
+
+    expected = ["void before(void)", "void visible(void)", "void after(void)"]
+
+    assert_equal(expected, @parser.import_source(source, @test_project).map! { |s| s.strip })
+  end
+
+  it "keep else branch of #if 0 blocks" do
+    source =
+      "void before(void);\n" +
+      "#if 0\n" +
+      "void hidden(void);\n" +
+      "#else\n" +
+      "void visible(void);\n" +
+      "#endif\n" +
+      "void after(void);\n"
+
+    expected = ["void before(void)", "void visible(void)", "void after(void)"]
+
+    assert_equal(expected, @parser.import_source(source, @test_project).map! { |s| s.strip })
+  end
+
+  it "remove else branch of #if 1 blocks" do
+    source =
+      "void before(void);\n" +
+      "#if 1\n" +
+      "void visible(void);\n" +
+      "#else\n" +
+      "void hidden(void);\n" +
+      "#endif\n" +
+      "void after(void);\n"
+
+    expected = ["void before(void)", "void visible(void)", "void after(void)"]
+
+    assert_equal(expected, @parser.import_source(source, @test_project).map! { |s| s.strip })
+  end
+
+  it "handle nested #if 1 blocks inside #if 0" do
+    source =
+      "void before(void);\n" +
+      "#if 0\n" +
+      "void hidden1(void);\n" +
+      "#if 1\n" +
+      "void hidden2(void);\n" +
+      "#endif\n" +
+      "void hidden3(void);\n" +
+      "#endif\n" +
+      "void after(void);\n"
+
+    expected = ["void before(void)", "void after(void)"]
+
+    assert_equal(expected, @parser.import_source(source, @test_project).map! { |s| s.strip })
+  end
+
+  it "handle nested #if 0 blocks inside #if 1" do
+    source =
+      "void before(void);\n" +
+      "#if 1\n" +
+      "void visible1(void);\n" +
+      "#if 0\n" +
+      "void hidden1(void);\n" +
+      "#endif\n" +
+      "void visible2(void);\n" +
+      "#endif\n" +
+      "void after(void);\n"
+
+    expected = ["void before(void)", "void visible1(void)", "void visible2(void)", "void after(void)"]
+
+    assert_equal(expected, @parser.import_source(source, @test_project).map! { |s| s.strip })
+  end
+
+  it "handle back to back #if 1 blocks and #if 0 blocks" do
+    source =
+      "void before(void);\n" +
+      "#if 0\n" +
+      "void hidden1(void);\n" +
+      "#endif\n" +
+      "#if 1\n" +
+      "void visible1(void);\n" +
+      "#endif\n" +
+      "#if 0\n" +
+      "void hidden2(void);\n" +
+      "#endif\n" +
+      "#if 1\n" +
+      "void visible2(void);\n" +
+      "#endif\n" +
+      "void after(void);\n"
+
+    expected = ["void before(void)", "void visible1(void)", "void visible2(void)", "void after(void)"]
+
+    assert_equal(expected, @parser.import_source(source, @test_project).map! { |s| s.strip })
+  end
+
 
   it "remove assembler pragma sections" do
     source =
@@ -259,6 +372,32 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
   end
 
 
+  it "ignore compile-time assertions and not treat them as function prototypes" do
+    source =
+      "static_assert(BLAH_BOOLEAN_TRAIT);\n" +
+      "void real_func(int a);\n" +
+      "ct_assert(COMMIT_ID_H, ID_SIZE == (sizeof(ID)) - 1);\n" +
+      "CTASSERT(OTHER_HEADER_H, BUF_SIZE != 0);\n" +
+      "BUILD_ASSERT(MAX_LEN <= 256);\n" +
+      "STATIC_ASSERT(sizeof(MyStruct) >= 4);\n"
+
+    expected = ["void real_func(int a)"]
+
+    assert_equal(expected, @parser.import_source(source, @test_project).map! { |s| s.strip })
+  end
+
+
+  it "ignore function pointer variables with pointer return types and not treat them as function prototypes" do
+    source =
+      "struct_t * (*func)(some_argument);\n" +
+      "void real_func(int a);\n"
+
+    expected = ["void real_func(int a)"]
+
+    assert_equal(expected, @parser.import_source(source, @test_project).map! { |s| s.strip })
+  end
+
+
   it "remove struct statements" do
     source =
       "struct _NamedStruct1 {\n" +
@@ -597,7 +736,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                           },
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[{:type=>"int", :name=>"a", :ptr? => false, :const? => false, :const_ptr? => false}],
+                 :args=>[{:type=>"int", :name=>"a", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}],
                  :args_string=>"int a",
                  :args_call=>"a"}
     assert_equal(expected, @parser.parse_declaration(@test_project, source))
@@ -643,7 +782,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                           },
                  :modifier=>"",
                  :contains_ptr? => true,
-                 :args=>[{:type=>"MY_FUNKY_VOID*", :name=>"bluh", :ptr? => true, :const? => false, :const_ptr? => false}],
+                 :args=>[{:type=>"MY_FUNKY_VOID*", :name=>"bluh", :ptr? => true, :string? => false, :const? => false, :const_ptr? => false}],
                  :args_string=>"MY_FUNKY_VOID* bluh",
                  :args_call=>"bluh" }
     assert_equal(expected, @parser.parse_declaration(@test_project, source))
@@ -745,8 +884,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                           },
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"int", :name=>"a", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"unsigned int", :name=>"b", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"int", :name=>"a", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"unsigned int", :name=>"b", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"int a, unsigned int b",
                  :args_call=>"a, b" }
@@ -771,9 +910,9 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"uint", :name=>"la", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"int",  :name=>"de", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"bool", :name=>"da", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"uint", :name=>"la", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"int",  :name=>"de", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"bool", :name=>"da", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"uint la, int     de, bool da",
                  :args_call=>"la, de, da" }
@@ -822,8 +961,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"const",
                  :contains_ptr? => true,
-                 :args=>[ {:type=>"int",           :name=>"Trinity", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"unsigned int*", :name=>"Neo",     :ptr? => true,  :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"int",           :name=>"Trinity", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"unsigned int*", :name=>"Neo",     :ptr? => true, :string? => false,  :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"int Trinity, unsigned int* Neo",
                  :args_call=>"Trinity, Neo" }
@@ -849,8 +988,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :modifier=>"const",
                  :c_calling_convention=>"__stdcall",
                  :contains_ptr? => true,
-                 :args=>[ {:type=>"int",           :name=>"Trinity", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"unsigned int*", :name=>"Neo",     :ptr? => true,  :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"int",           :name=>"Trinity", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"unsigned int*", :name=>"Neo",     :ptr? => true, :string? => false,  :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"int Trinity, unsigned int* Neo",
                  :args_call=>"Trinity, Neo" }
@@ -874,8 +1013,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                           },
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"int", :name=>"a", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"unsigned int", :name=>"b", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"int", :name=>"a", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"unsigned int", :name=>"b", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"int a, unsigned int b",
                  :args_call=>"a, b" }
@@ -902,8 +1041,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :class=>nil,
                   :modifier=>"const",
                   :contains_ptr? => true,
-                  :args=>[ {:type=>"int",           :name=>"Trinity", :ptr? => false, :const? => false, :const_ptr? => false},
-                           {:type=>"unsigned int*", :name=>"Neo",     :ptr? => true,  :const? => false, :const_ptr? => false}
+                  :args=>[ {:type=>"int",           :name=>"Trinity", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                           {:type=>"unsigned int*", :name=>"Neo",     :ptr? => true, :string? => false,  :const? => false, :const_ptr? => false}
                          ],
                   :args_string=>"int Trinity, unsigned int* Neo",
                  :args_call=>"Trinity, Neo" },
@@ -922,8 +1061,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :class=>nil,
                   :modifier=>"",
                   :contains_ptr? => true,
-                  :args=>[ {:type=>"int",           :name=>"cmock_arg1", :ptr? => false, :const? => false, :const_ptr? => false},
-                           {:type=>"unsigned int*", :name=>"cmock_arg2", :ptr? => true,  :const? => false, :const_ptr? => false}
+                  :args=>[ {:type=>"int",           :name=>"cmock_arg1", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                           {:type=>"unsigned int*", :name=>"cmock_arg2", :ptr? => true, :string? => false,  :const? => false, :const_ptr? => false}
                          ],
                   :args_string=>"int cmock_arg1, unsigned int* cmock_arg2",
                  :args_call=>"cmock_arg1, cmock_arg2"
@@ -951,8 +1090,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                             },
                   :modifier=>"const",
                   :contains_ptr? => true,
-                  :args=>[ {:type=>"int",           :name=>"Trinity", :ptr? => false, :const? => false, :const_ptr? => false},
-                           {:type=>"unsigned int*", :name=>"Neo", :ptr? => true,      :const? => false, :const_ptr? => false}
+                  :args=>[ {:type=>"int",           :name=>"Trinity", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                           {:type=>"unsigned int*", :name=>"Neo", :ptr? => true, :string? => false,      :const? => false, :const_ptr? => false}
                          ],
                   :args_string=>"int Trinity, unsigned int* Neo",
                   :args_call=>"Trinity, Neo"
@@ -1038,7 +1177,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                               :ptr?   => true,
                               :const? => false,
                               :const_ptr? => true,
-                              :str    => "int* cmock_to_return",
+                              :str    => "int* const cmock_to_return",
                               :void?  => false
                             },
                   :modifier=>"const",
@@ -1070,14 +1209,14 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :var_arg => nil,
                   :args_string => "int const* cmock_arg1, int* const cmock_arg2, const int* cmock_arg3, const int* const cmock_arg4, " +
                                   "int const* const cmock_arg5, int* cmock_arg6, int cmock_arg7, const int cmock_arg8",
-                  :args => [{ :type=>"int const*", :name => "cmock_arg1", :ptr? => true,  :const? => true,  :const_ptr? => false },
-                            { :type=>"int*",       :name => "cmock_arg2", :ptr? => true,  :const? => false, :const_ptr? => true  },
-                            { :type=>"const int*", :name => "cmock_arg3", :ptr? => true,  :const? => true,  :const_ptr? => false },
-                            { :type=>"const int*", :name => "cmock_arg4", :ptr? => true,  :const? => true,  :const_ptr? => true  },
-                            { :type=>"int const*", :name => "cmock_arg5", :ptr? => true,  :const? => true,  :const_ptr? => true  },
-                            { :type=>"int*",       :name => "cmock_arg6", :ptr? => true,  :const? => false, :const_ptr? => false },
-                            { :type=>"int",        :name => "cmock_arg7", :ptr? => false, :const? => false, :const_ptr? => false },
-                            { :type=>"int",        :name => "cmock_arg8", :ptr? => false, :const? => true,  :const_ptr? => false }],
+                  :args => [{ :type=>"int const*", :name => "cmock_arg1", :ptr? => true, :string? => false,  :const? => true,  :const_ptr? => false },
+                            { :type=>"int*",       :name => "cmock_arg2", :ptr? => true, :string? => false,  :const? => false, :const_ptr? => true  },
+                            { :type=>"const int*", :name => "cmock_arg3", :ptr? => true, :string? => false,  :const? => true,  :const_ptr? => false },
+                            { :type=>"const int*", :name => "cmock_arg4", :ptr? => true, :string? => false,  :const? => true,  :const_ptr? => true  },
+                            { :type=>"int const*", :name => "cmock_arg5", :ptr? => true, :string? => false,  :const? => true,  :const_ptr? => true  },
+                            { :type=>"int*",       :name => "cmock_arg6", :ptr? => true, :string? => false,  :const? => false, :const_ptr? => false },
+                            { :type=>"int",        :name => "cmock_arg7", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false },
+                            { :type=>"int",        :name => "cmock_arg8", :ptr? => false, :string? => false, :const? => true,  :const_ptr? => false }],
                   :args_call => "cmock_arg1, cmock_arg2, cmock_arg3, cmock_arg4, cmock_arg5, cmock_arg6, cmock_arg7, cmock_arg8",
                   :contains_ptr? => true
                 }]
@@ -1105,20 +1244,112 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :var_arg => nil,
                   :args_string => "int const* param1, int* const param2, const int* param3, const int* const param4, " +
                                   "int const* const param5, int* param6, int param7, const int param8",
-                  :args => [{ :type=>"int const*", :name => "param1", :ptr? => true,  :const? => true,  :const_ptr? => false },
-                            { :type=>"int*",       :name => "param2", :ptr? => true,  :const? => false, :const_ptr? => true  },
-                            { :type=>"const int*", :name => "param3", :ptr? => true,  :const? => true,  :const_ptr? => false },
-                            { :type=>"const int*", :name => "param4", :ptr? => true,  :const? => true,  :const_ptr? => true  },
-                            { :type=>"int const*", :name => "param5", :ptr? => true,  :const? => true,  :const_ptr? => true  },
-                            { :type=>"int*",       :name => "param6", :ptr? => true,  :const? => false, :const_ptr? => false },
-                            { :type=>"int",        :name => "param7", :ptr? => false, :const? => false, :const_ptr? => false },
-                            { :type=>"int",        :name => "param8", :ptr? => false, :const? => true,  :const_ptr? => false }],
+                  :args => [{ :type=>"int const*", :name => "param1", :ptr? => true, :string? => false,  :const? => true,  :const_ptr? => false },
+                            { :type=>"int*",       :name => "param2", :ptr? => true, :string? => false,  :const? => false, :const_ptr? => true  },
+                            { :type=>"const int*", :name => "param3", :ptr? => true, :string? => false,  :const? => true,  :const_ptr? => false },
+                            { :type=>"const int*", :name => "param4", :ptr? => true, :string? => false,  :const? => true,  :const_ptr? => true  },
+                            { :type=>"int const*", :name => "param5", :ptr? => true, :string? => false,  :const? => true,  :const_ptr? => true  },
+                            { :type=>"int*",       :name => "param6", :ptr? => true, :string? => false,  :const? => false, :const_ptr? => false },
+                            { :type=>"int",        :name => "param7", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false },
+                            { :type=>"int",        :name => "param8", :ptr? => false, :string? => false, :const? => true,  :const_ptr? => false }],
                   :args_call => "param1, param2, param3, param4, param5, param6, param7, param8",
                   :contains_ptr? => true
                 }].freeze
     assert_equal(expected, @parser.parse("module", source)[:functions])
   end
 
+  it "properly parses volatile pointer argument types" do
+
+    source = "int16_t foo(volatile struct foo_obj *foo_handle, int plain, volatile int not_a_ptr);\n"
+
+    expected = [{ :name => "foo",
+                  :unscoped_name => "foo",
+                  :namespace=>[],
+                  :class=>nil,
+                  :modifier => "",
+                  :return => { :type       => "int16_t",
+                               :name       => "cmock_to_return",
+                               :str        => "int16_t cmock_to_return",
+                               :void?      => false,
+                               :ptr?       => false,
+                               :const?     => false,
+                               :const_ptr? => false
+                             },
+                  :var_arg => nil,
+                  :args_string => "volatile struct foo_obj* foo_handle, int plain, volatile int not_a_ptr",
+                  :args => [{ :type => "struct foo_obj*", :name => "foo_handle",
+                              :ptr? => true, :string? => false, :const? => false, :const_ptr? => false, :volatile? => true },
+                            { :type => "int",  :name => "plain",
+                              :ptr? => false, :string? => false, :const? => false, :const_ptr? => false },
+                            { :type => "volatile int", :name => "not_a_ptr",
+                              :ptr? => false, :string? => false, :const? => false, :const_ptr? => false }],
+                  :args_call => "foo_handle, plain, not_a_ptr",
+                  :contains_ptr? => true
+                }]
+    assert_equal(expected, @parser.parse("module", source)[:functions])
+  end
+
+  it "properly parses T volatile* style volatile pointer argument types" do
+    # volatile can appear before OR after the base type; both mean "pointer to volatile T"
+    # e.g. "int volatile*" is identical to "volatile int*" in C
+
+    source = "void bar(int volatile* a, struct foo_obj volatile* b);\n"
+
+    expected = [{ :name => "bar",
+                  :unscoped_name => "bar",
+                  :namespace=>[],
+                  :class=>nil,
+                  :modifier => "",
+                  :return => { :type       => "void",
+                               :name       => "cmock_to_return",
+                               :str        => "void cmock_to_return",
+                               :void?      => true,
+                               :ptr?       => false,
+                               :const?     => false,
+                               :const_ptr? => false
+                             },
+                  :var_arg => nil,
+                  :args_string => "int volatile* a, struct foo_obj volatile* b",
+                  :args => [{ :type => "int*", :name => "a",
+                              :ptr? => true, :string? => false, :const? => false, :const_ptr? => false, :volatile? => true },
+                            { :type => "struct foo_obj*", :name => "b",
+                              :ptr? => true, :string? => false, :const? => false, :const_ptr? => false, :volatile? => true }],
+                  :args_call => "a, b",
+                  :contains_ptr? => true
+                }]
+    assert_equal(expected, @parser.parse("module", source)[:functions])
+  end
+
+  it "treats int*volatile (volatile pointer to non-volatile type) as a plain pointer without volatile? flag" do
+    # "int * volatile p" = volatile pointer to int (the pointer itself is volatile, not the pointed-to value)
+    # This is distinct from "volatile int *p" (pointer to volatile int).
+    # CMock must NOT set volatile? here: the pointed-to type is not volatile, so no cast-qual issue.
+
+    source = "void baz(int * volatile p);\n"
+
+    expected = [{ :name => "baz",
+                  :unscoped_name => "baz",
+                  :namespace=>[],
+                  :class=>nil,
+                  :modifier => "",
+                  :return => { :type       => "void",
+                               :name       => "cmock_to_return",
+                               :str        => "void cmock_to_return",
+                               :void?      => true,
+                               :ptr?       => false,
+                               :const?     => false,
+                               :const_ptr? => false
+                             },
+                  :var_arg => nil,
+                  :args_string => "int* volatile p",
+                  :args => [{ :type => "int* volatile", :name => "p",
+                              :ptr? => true, :string? => false, :const? => false, :const_ptr? => false }],
+                  :args_call => "p",
+                  :contains_ptr? => true
+                }]
+    assert_equal(expected, @parser.parse("module", source)[:functions])
+  end
+
   it "converts typedef'd array arguments to pointers" do
 
     source = "Book AddToBook(Book book, const IntArray values);\n"
@@ -1137,8 +1368,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                                 :const_ptr? => false
                               },
                   :var_arg => nil,
-                  :args => [{ :type => "Page*",      :name => "book",   :ptr? => true, :const? => false, :const_ptr? => false },
-                            { :type => "const int*", :name => "values", :ptr? => true, :const? => true,  :const_ptr? => false }],
+                  :args => [{ :type => "Page*",      :name => "book",   :ptr? => true, :string? => false, :const? => false, :const_ptr? => false },
+                            { :type => "const int*", :name => "values", :ptr? => true, :string? => false, :const? => true,  :const_ptr? => false }],
                   :args_string => "Book book, const IntArray values",
                   :args_call => "book, values",
                   :contains_ptr? => true
@@ -1170,7 +1401,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                               },
                   :modifier=>"",
                   :contains_ptr? => false,
-                  :args=>[ {:type=>"int", :name=>"SingAlong", :ptr? => false, :const? => false, :const_ptr? => false} ],
+                  :args=>[ {:type=>"int", :name=>"SingAlong", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false} ],
                   :args_string=>"int SingAlong",
                   :args_call=>"SingAlong"
                 },
@@ -1217,7 +1448,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :class=>nil,
                   :modifier=>"",
                   :contains_ptr? => false,
-                  :args=>[ {:type=>"struct SingAlong", :name=>"Blog", :ptr? => false, :const? => false, :const_ptr? => false} ],
+                  :args=>[ {:type=>"struct SingAlong", :name=>"Blog", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false} ],
                   :args_string=>"struct SingAlong Blog",
                   :args_call=>"Blog"
                 },
@@ -1236,7 +1467,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :class=>nil,
                   :modifier=>"",
                   :contains_ptr? => true,
-                  :args=>[ {:type=>"struct const _KeepYourHeadUp_*", :name=>"BillyBuddy", :ptr? => true, :const? => true, :const_ptr? => true} ],
+                  :args=>[ {:type=>"struct const _KeepYourHeadUp_*", :name=>"BillyBuddy", :ptr? => true, :string? => false, :const? => true, :const_ptr? => true} ],
                   :args_string=>"struct const _KeepYourHeadUp_* const BillyBuddy",
                   :args_call=>"BillyBuddy"
                 },
@@ -1279,8 +1510,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => true,
-                 :args=>[ {:type=>"union STARS_AND_STRIPES*", :name=>"a", :ptr? => true, :const? => false, :const_ptr? => false},
-                          {:type=>"union AFL_CIO", :name=>"b", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"union STARS_AND_STRIPES*", :name=>"a", :ptr? => true, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"union AFL_CIO", :name=>"b", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"union STARS_AND_STRIPES* a, union AFL_CIO b",
                  :args_call=>"a, b" }]
@@ -1305,11 +1536,11 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => true,
-                 :args=>[ {:type=> "unsigned int", :name=>"const_param", :ptr? => false, :const? => true, :const_ptr? => false},
-                          {:type=>"int", :name=>"int_param", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"int", :name=>"integer", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"char", :name=>"character", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"int*", :name=>"constant", :ptr? => true, :const? => false, :const_ptr? => true}
+                 :args=>[ {:type=> "unsigned int", :name=>"const_param", :ptr? => false, :string? => false, :const? => true, :const_ptr? => false},
+                          {:type=>"int", :name=>"int_param", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"int", :name=>"integer", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"char", :name=>"character", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"int*", :name=>"constant", :ptr? => true, :string? => false, :const? => false, :const_ptr? => true}
                         ],
                  :args_string=>"const unsigned int const_param, int int_param, int integer, char character, int* const constant",
                  :args_call=>"const_param, int_param, integer, character, constant" }]
@@ -1334,11 +1565,11 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => true,
-                 :args=>[ {:type=>"integer", :name=>"param", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"character", :name=>"thing", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"longint*", :name=>"junk", :ptr? => true, :const? => false, :const_ptr? => false},
-                          {:type=>"constant", :name=>"value", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"int32_t", :name=>"number", :ptr? => false, :const? => true, :const_ptr? => false}
+                 :args=>[ {:type=>"integer", :name=>"param", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"character", :name=>"thing", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"longint*", :name=>"junk", :ptr? => true, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"constant", :name=>"value", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"int32_t", :name=>"number", :ptr? => false, :string? => false, :const? => true, :const_ptr? => false}
                         ],
                  :args_string=>"integer param, character thing, longint* junk, constant value, int32_t const number",
                  :args_call=>"param, thing, junk, value, number" }]
@@ -1363,10 +1594,10 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"signed char", :name=>"abc", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"unsigned long int", :name=>"xyz_123", :ptr? => false, :const? => true, :const_ptr? => false},
-                          {:type=>"unsigned int", :name=>"abc_123", :ptr? => false, :const? => true, :const_ptr? => false},
-                          {:type=>"long long", :name=>"arm_of_the_law", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"signed char", :name=>"abc", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"unsigned long int", :name=>"xyz_123", :ptr? => false, :string? => false, :const? => true, :const_ptr? => false},
+                          {:type=>"unsigned int", :name=>"abc_123", :ptr? => false, :string? => false, :const? => true, :const_ptr? => false},
+                          {:type=>"long long", :name=>"arm_of_the_law", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"signed char abc, const unsigned long int xyz_123, unsigned int const abc_123, long long arm_of_the_law",
                  :args_call=>"abc, xyz_123, abc_123, arm_of_the_law" }]
@@ -1391,10 +1622,10 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => true,
-                 :args=>[ {:type=>"CUSTOM_TYPE", :name=>"abc", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"CUSTOM_TYPE*", :name=>"xyz_123", :ptr? => true, :const? => false, :const_ptr? => false},
-                          {:type=>"CUSTOM_TYPE", :name=>"abcxyz", :ptr? => false, :const? => true, :const_ptr? => false},
-                          {:type=>"struct CUSTOM_TYPE const*", :name=>"abc123", :ptr? => true, :const? => true, :const_ptr? => true}
+                 :args=>[ {:type=>"CUSTOM_TYPE", :name=>"abc", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"CUSTOM_TYPE*", :name=>"xyz_123", :ptr? => true, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"CUSTOM_TYPE", :name=>"abcxyz", :ptr? => false, :string? => false, :const? => true, :const_ptr? => false},
+                          {:type=>"struct CUSTOM_TYPE const*", :name=>"abc123", :ptr? => true, :string? => false, :const? => true, :const_ptr? => true}
                         ],
                  :args_string=>"CUSTOM_TYPE abc, CUSTOM_TYPE* xyz_123, CUSTOM_TYPE const abcxyz, struct CUSTOM_TYPE const* const abc123",
                  :args_call=>"abc, xyz_123, abcxyz, abc123" }]
@@ -1406,13 +1637,11 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     source = 'void KeyOperated(CUSTOM_TYPE thing1[], int thing2 [ ], ' \
              'char thing3 [][2 ][ 3], int* thing4[4], u8 thing5[((u8)((5 + 5*2)/3))])'
     expected_args = [
-      { type: 'CUSTOM_TYPE*', name: 'thing1', ptr?: true,  const?: false, const_ptr?: false },
-      { type: 'int*',         name: 'thing2', ptr?: true,  const?: false, const_ptr?: false },
-      # this one will likely change in the future when we improve multidimensional array support
-      { type: 'char*',        name: 'thing3', ptr?: false, const?: false, const_ptr?: false },
-      # this one will likely change in the future when we improve multidimensional array support
-      { type: 'int**',        name: 'thing4', ptr?: true,  const?: false, const_ptr?: false },
-      { type: 'u8*',          name: 'thing5', ptr?: true,  const?: false, const_ptr?: false }
+      { type: 'CUSTOM_TYPE*', name: 'thing1', ptr?: true, string?: false,  const?: false, const_ptr?: false, array_dims: [''] },
+      { type: 'int*',         name: 'thing2', ptr?: true, string?: false,  const?: false, const_ptr?: false, array_dims: [''] },
+      { type: 'char*',        name: 'thing3', ptr?: false, string?: true, const?: false, const_ptr?: false, array_dims: ['', '2', '3'] },
+      { type: 'int**',        name: 'thing4', ptr?: true, string?: false,  const?: false, const_ptr?: false, array_dims: ['4'] },
+      { type: 'u8*',          name: 'thing5', ptr?: true, string?: false,  const?: false, const_ptr?: false, array_dims: ['((u8)((5 + 5*2)/3))'] }
     ]
     expected = [{:var_arg=>nil,
                  :return=>{ :type   => "void",
@@ -1430,8 +1659,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :modifier=>"",
                  :contains_ptr? => true,
                  :args => expected_args,
-                 :args_string => 'CUSTOM_TYPE* thing1, int* thing2, ' \
-                                 'char* thing3, int** thing4, u8* thing5',
+                 :args_string => 'CUSTOM_TYPE thing1[], int thing2[], char thing3[][2][3], int* thing4[4], u8 thing5[((u8)((5 + 5*2)/3))]',
                  :args_call => 'thing1, thing2, thing3, thing4, thing5' }]
     result = @parser.parse("module", source)
     assert_equal(expected, result[:functions])
@@ -1454,9 +1682,9 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"unsigned CUSTOM_TYPE", :name=>"abc", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"unsigned", :name=>"xyz", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"CUSTOM_TYPE1 CUSTOM_TYPE2", :name=>"pdq", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"unsigned CUSTOM_TYPE", :name=>"abc", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"unsigned", :name=>"xyz", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"CUSTOM_TYPE1 CUSTOM_TYPE2", :name=>"pdq", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"unsigned CUSTOM_TYPE abc, unsigned xyz, CUSTOM_TYPE1 CUSTOM_TYPE2 pdq",
                  :args_call=>"abc, xyz, pdq" }]
@@ -1481,7 +1709,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"cmock_module_func_ptr1 func_ptr",
                  :args_call=>"func_ptr" }]
@@ -1508,7 +1736,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"cmock_module_func_ptr1 func_ptr",
                  :args_call=>"func_ptr" }]
@@ -1518,6 +1746,33 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     assert_equal(typedefs, result[:typedefs])
   end
 
+  it "extract functions using a function pointer with shorthand notation and a calling convention" do
+    source = "void FunkyTurkey(void __stdcall * func_ptr(int arg0))"
+    expected = [{ :var_arg=>nil,
+                 :return=>{ :type   => "void",
+                            :name   => 'cmock_to_return',
+                            :ptr?   => false,
+                            :const? => false,
+                            :const_ptr? => false,
+                            :str    => "void cmock_to_return",
+                            :void?  => true
+                          },
+                 :name=>"FunkyTurkey",
+                 :unscoped_name=>"FunkyTurkey",
+                 :namespace=>[],
+                 :class=>nil,
+                 :modifier=>"",
+                 :contains_ptr? => false,
+                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
+                        ],
+                 :args_string=>"cmock_module_func_ptr1 func_ptr",
+                 :args_call=>"func_ptr" }]
+    typedefs = ["typedef void *(__stdcall *cmock_module_func_ptr1)(int arg0);"]
+    result = @parser.parse("module", source)
+    assert_equal(expected, result[:functions])
+    assert_equal(typedefs, result[:typedefs])
+  end
+
   it "extract functions containing a function pointer with a void" do
     source = "void FunkyTurkey(void (*func_ptr)(void))"
     expected = [{ :var_arg=>nil,
@@ -1535,7 +1790,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"cmock_module_func_ptr1 func_ptr",
                  :args_call=>"func_ptr" }]
@@ -1562,7 +1817,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"cmock_module_func_ptr1 func_ptr",
                  :args_call=>"func_ptr" }]
@@ -1589,7 +1844,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :const? => true, :const_ptr? => false}
+                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :string? => false, :const? => true, :const_ptr? => false}
                         ],
                  :args_string=>"cmock_module_func_ptr1 const func_ptr",
                  :args_call=>"func_ptr" }]
@@ -1604,7 +1859,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     # expected = [{ :var_arg=>nil,
                  # :return=>{ :type   => "void",
                             # :name   => 'cmock_to_return',
-                            # :ptr?   => false,
+                            # :ptr?   => false, :string? => false,
                             # :const? => false,
                             # :const_ptr? => false,
                             # :str    => "void cmock_to_return",
@@ -1616,7 +1871,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  # :class=>nil,
                  # :modifier=>"",
                  # :contains_ptr? => false,
-                 # :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :const? => false, :const_ptr? => false}
+                 # :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         # ],
                  # :args_string=>"cmock_module_func_ptr1 func_ptr",
                  # :args_call=>"func_ptr" }]
@@ -1643,8 +1898,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr1", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"cmock_module_func_ptr2", :name=>"func_ptr2", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"func_ptr1", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"cmock_module_func_ptr2", :name=>"func_ptr2", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"cmock_module_func_ptr1 func_ptr1, cmock_module_func_ptr2 func_ptr2",
                  :args_call=>"func_ptr1, func_ptr2" }]
@@ -1671,9 +1926,9 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"uint16_t", :name=>"num1", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"uint16_t", :name=>"num2", :ptr? => false, :const? => false, :const_ptr? => false},
-                          {:type=>"cmock_module_func_ptr1", :name=>"func_ptr1", :ptr? => false, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"uint16_t", :name=>"num1", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"uint16_t", :name=>"num2", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"cmock_module_func_ptr1", :name=>"func_ptr1", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"uint16_t num1, uint16_t num2, cmock_module_func_ptr1 func_ptr1",
                  :args_call=>"num1, num2, func_ptr1" }]
@@ -1700,7 +1955,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"cmock_arg1", :ptr? => false, :const? => true, :const_ptr? => false}
+                 :args=>[ {:type=>"cmock_module_func_ptr1", :name=>"cmock_arg1", :ptr? => false, :string? => false, :const? => true, :const_ptr? => false}
                         ],
                  :args_string=>"cmock_module_func_ptr1 const cmock_arg1",
                  :args_call=>"cmock_arg1" }]
@@ -1727,7 +1982,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => false,
-                 :args=>[ {:type=>"char", :name=>"op_code", :ptr? => false, :const? => true, :const_ptr? => false}
+                 :args=>[ {:type=>"char", :name=>"op_code", :ptr? => false, :string? => false, :const? => true, :const_ptr? => false}
                         ],
                  :args_string=>"const char op_code",
                  :args_call=>"op_code" }]
@@ -1806,8 +2061,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :class=>nil,
                  :modifier=>"",
                  :contains_ptr? => true,
-                 :args=>[ {:type=>"double*", :name=>"foo", :ptr? => true, :const? => false, :const_ptr? => false},
-                          {:type=>"THING*", :name=>"bar", :ptr? => true, :const? => false, :const_ptr? => false}
+                 :args=>[ {:type=>"double*", :name=>"foo", :ptr? => true, :string? => false, :const? => false, :const_ptr? => false},
+                          {:type=>"THING*", :name=>"bar", :ptr? => true, :string? => false, :const? => false, :const_ptr? => false}
                         ],
                  :args_string=>"double* foo, THING* bar",
                  :args_call=>"foo, bar" }]
@@ -1834,11 +2089,11 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                    :class=>nil,
                    :modifier=>"SQLITE_API",
                    :contains_ptr? => true,
-                   :args=>[ {:type=>"sqlite3_stmt*", :name=>"cmock_arg2", :ptr? => true, :const? => false, :const_ptr? => false},
-                            {:type=>"int", :name=>"cmock_arg3", :ptr? => false, :const? => false, :const_ptr? => false},
-                            {:type=>"const char*", :name=>"cmock_arg4", :ptr? => false, :const? => true, :const_ptr? => false},
-                            {:type=>"int", :name=>"n", :ptr? => false, :const? => false, :const_ptr? => false},
-                            {:type=>"cmock_module_func_ptr1", :name=>"cmock_arg1", :ptr? => false, :const? => false, :const_ptr? => false}
+                   :args=>[ {:type=>"sqlite3_stmt*", :name=>"cmock_arg2", :ptr? => true, :string? => false, :const? => false, :const_ptr? => false},
+                            {:type=>"int", :name=>"cmock_arg3", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                            {:type=>"const char*", :name=>"cmock_arg4", :ptr? => false, :string? => true, :const? => true, :const_ptr? => false},
+                            {:type=>"int", :name=>"n", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                            {:type=>"cmock_module_func_ptr1", :name=>"cmock_arg1", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                           ],
                    :args_string=>"sqlite3_stmt* cmock_arg2, int cmock_arg3, const char* cmock_arg4, int n, cmock_module_func_ptr1 cmock_arg1",
                    :args_call=>"cmock_arg2, cmock_arg3, cmock_arg4, n, cmock_arg1" }]
@@ -1848,6 +2103,59 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     assert_equal(typedefs, result[:typedefs])
   end
 
+  it "extract functions containing a parenthesized pointer argument" do
+    source = "void func(char *str, int (* numb))"
+    expected = [{ :var_arg=>nil,
+                 :return=>{ :type   => "void",
+                            :name   => 'cmock_to_return',
+                            :ptr?   => false,
+                            :const? => false,
+                            :const_ptr? => false,
+                            :str    => "void cmock_to_return",
+                            :void?  => true
+                          },
+                 :name=>"func",
+                 :unscoped_name=>"func",
+                 :namespace=>[],
+                 :class=>nil,
+                 :modifier=>"",
+                 :contains_ptr? => true,
+                 :args=>[ {:type=>"char*", :name=>"str", :ptr? => false, :string? => true, :const? => false, :const_ptr? => false},
+                          {:type=>"int*",  :name=>"numb", :ptr? => true, :string? => false, :const? => false, :const_ptr? => false}
+                        ],
+                 :args_string=>"char* str, int* numb",
+                 :args_call=>"str, numb" }]
+    result = @parser.parse("module", source)
+    assert_equal(expected, result[:functions])
+    assert_equal([], result[:typedefs])
+  end
+
+  it "extract functions containing a parenthesized const pointer argument" do
+    source = "void func(int (* const numb))"
+    expected = [{ :var_arg=>nil,
+                 :return=>{ :type   => "void",
+                            :name   => 'cmock_to_return',
+                            :ptr?   => false,
+                            :const? => false,
+                            :const_ptr? => false,
+                            :str    => "void cmock_to_return",
+                            :void?  => true
+                          },
+                 :name=>"func",
+                 :unscoped_name=>"func",
+                 :namespace=>[],
+                 :class=>nil,
+                 :modifier=>"",
+                 :contains_ptr? => true,
+                 :args=>[ {:type=>"int*", :name=>"numb", :ptr? => true, :string? => false, :const? => false, :const_ptr? => true}
+                        ],
+                 :args_string=>"int* const numb",
+                 :args_call=>"numb" }]
+    result = @parser.parse("module", source)
+    assert_equal(expected, result[:functions])
+    assert_equal([], result[:typedefs])
+  end
+
   it "extract functions with varargs" do
     source = "int XFiles(int Scully, int Mulder, ...);\n"
     expected = [{ :var_arg=>"...",
@@ -1865,8 +2173,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :class=>nil,
                   :modifier=>"",
                   :contains_ptr? => false,
-                  :args=>[ {:type=>"int", :name=>"Scully", :ptr? => false, :const? => false, :const_ptr? => false},
-                           {:type=>"int", :name=>"Mulder", :ptr? => false, :const? => false, :const_ptr? => false}
+                  :args=>[ {:type=>"int", :name=>"Scully", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                           {:type=>"int", :name=>"Mulder", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                          ],
                   :args_string=>"int Scully, int Mulder",
                   :args_call=>"Scully, Mulder"
@@ -1891,7 +2199,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :class=>nil,
                   :modifier=>"",
                   :contains_ptr? => true,
-                  :args=>[ {:type=>"void*", :name=>"stuff", :ptr? => true, :const? => false, :const_ptr? => false}
+                  :args=>[ {:type=>"void*", :name=>"stuff", :ptr? => true, :string? => false, :const? => false, :const_ptr? => false}
                          ],
                   :args_string=>"void* stuff",
                   :args_call=>"stuff"
@@ -1916,8 +2224,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :class=>nil,
                   :modifier=>"",
                   :contains_ptr? => false,
-                  :args=>[ {:type=>"int", :name=>"Lenny", :ptr? => false, :const? => false, :const_ptr? => false},
-                           {:type=>"int", :name=>"Squiggy", :ptr? => false, :const? => false, :const_ptr? => false}
+                  :args=>[ {:type=>"int", :name=>"Lenny", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                           {:type=>"int", :name=>"Squiggy", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                          ],
                   :args_string=>"int Lenny, int Squiggy",
                   :args_call=>"Lenny, Squiggy"
@@ -1942,8 +2250,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :class=>nil,
                   :modifier=>"",
                   :contains_ptr? => false,
-                  :args=>[ {:type=>"int", :name=>"Cliff", :ptr? => false, :const? => false, :const_ptr? => false},
-                           {:type=>"int", :name=>"Claire", :ptr? => false, :const? => false, :const_ptr? => false}
+                  :args=>[ {:type=>"int", :name=>"Cliff", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                           {:type=>"int", :name=>"Claire", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                          ],
                   :args_string=>"int Cliff, int Claire",
                   :args_call=>"Cliff, Claire"
@@ -1981,7 +2289,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
       assert_equal(@parser.divine_ptr(entry[0]), entry[1])
       assert_equal(@parser.divine_const(entry[0]), entry[2])
       assert_equal(@parser.divine_ptr_and_const(entry[0]),
-        { ptr?: entry[1], const?: entry[2], const_ptr?: entry[3] })
+        { ptr?: entry[1], string?: false, const?: entry[2], const_ptr?: entry[3] })
     end
   end
 
@@ -2348,8 +2656,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :class=>nil,
                   :modifier=>"",
                   :contains_ptr? => false,
-                  :args=>[ {:type=>"int", :name=>"Lenny", :ptr? => false, :const? => false, :const_ptr? => false},
-                           {:type=>"int", :name=>"Squiggy", :ptr? => false, :const? => false, :const_ptr? => false}
+                  :args=>[ {:type=>"int", :name=>"Lenny", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false},
+                           {:type=>"int", :name=>"Squiggy", :ptr? => false, :string? => false, :const? => false, :const_ptr? => false}
                          ],
                   :args_string=>"int Lenny, int Squiggy",
                   :args_call=>"Lenny, Squiggy"
@@ -2592,7 +2900,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
         :var_arg => nil,
         :args_string => "int a",
         :args => [
-          { :ptr? => false,
+          { :ptr? => false, :string? => false,
             :const? => false,
             :const_ptr? => false,
             :name => "a",
@@ -2615,7 +2923,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
         :var_arg => nil,
         :args_string => "int* a",
         :args => [
-          { :ptr? => true,
+          { :ptr? => true, :string? => false,
             :const? => false,
             :const_ptr? => false,
             :name => "a",
@@ -2664,7 +2972,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
         :var_arg => nil,
         :args_string => "int a",
         :args => [
-          { :ptr? => false,
+          { :ptr? => false, :string? => false,
             :const? => false,
             :const_ptr? => false,
             :name => "a",
@@ -2687,7 +2995,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
         :var_arg => nil,
         :args_string => "int* a",
         :args => [
-          { :ptr? => true,
+          { :ptr? => true, :string? => false,
             :const? => false,
             :const_ptr? => false,
             :name => "a",
@@ -2882,5 +3190,293 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     assert_equal(expected, @parser.transform_inline_functions(source))
   end
 
+  it "pairs size arg with adjacent pointer when no name affinity exists" do
+    source = "void process(int *data, int size)"
+
+    result = @parser.parse("module", source)
+    args = result[:functions].first[:args]
+
+    data_arg = args.find { |a| a[:name] == 'data' }
+    size_arg = args.find { |a| a[:name] == 'size' }
+
+    assert_equal(:after, data_arg[:array_size_order], "data should be paired with size (after)")
+    assert_equal(true,   size_arg[:array_size?],      "size should be marked as array_size?")
+  end
+
+  it "pairs size arg with the pointer whose name it matches, even when a different pointer is adjacent" do
+    # buf_size is adjacent to status, but 'buf' root matches 'buf' exactly
+    source = "void store(int *status, int buf_size, int *buf)"
+
+    result = @parser.parse("module", source)
+    args = result[:functions].first[:args]
+
+    status_arg  = args.find { |a| a[:name] == 'status' }
+    buf_size_arg = args.find { |a| a[:name] == 'buf_size' }
+    buf_arg     = args.find { |a| a[:name] == 'buf' }
+
+    assert_nil(status_arg[:array_size_order],            "status should NOT be paired")
+    assert_equal(:before, buf_arg[:array_size_order],    "buf should be paired with size (before)")
+    assert_equal(true,    buf_size_arg[:array_size?],    "buf_size should be marked as array_size?")
+  end
+
+  it "pairs size arg with pointer that comes after it when name affinity is stronger than adjacency" do
+    # buff_size is adjacent to bytes_to_read, but 'buff' root is a prefix of 'buffer'
+    source = "void read_interface(size_t *bytes_to_read, size_t buff_size, char **buffer)"
+
+    result = @parser.parse("module", source)
+    args = result[:functions].first[:args]
+
+    bytes_arg     = args.find { |a| a[:name] == 'bytes_to_read' }
+    buff_size_arg = args.find { |a| a[:name] == 'buff_size' }
+    buffer_arg    = args.find { |a| a[:name] == 'buffer' }
+
+    assert_nil(bytes_arg[:array_size_order],               "bytes_to_read should NOT be paired")
+    assert_equal(:before, buffer_arg[:array_size_order],   "buffer should be paired with size (before)")
+    assert_equal(true,    buff_size_arg[:array_size?],     "buff_size should be marked as array_size?")
+  end
+
+  it "pairs multiple size args each with their best-matched pointer" do
+    source = "void copy(int *dst, int dst_len, int *src, int src_len)"
+
+    result = @parser.parse("module", source)
+    args = result[:functions].first[:args]
+
+    dst_arg     = args.find { |a| a[:name] == 'dst' }
+    dst_len_arg = args.find { |a| a[:name] == 'dst_len' }
+    src_arg     = args.find { |a| a[:name] == 'src' }
+    src_len_arg = args.find { |a| a[:name] == 'src_len' }
+
+    assert_equal(:after, dst_arg[:array_size_order], "dst should be paired with size (after)")
+    assert_equal(true, dst_len_arg[:array_size?],    "dst_len should be marked as array_size?")
+    assert_equal(:after, src_arg[:array_size_order], "src should be paired with size (after)")
+    assert_equal(true, src_len_arg[:array_size?],    "src_len should be marked as array_size?")
+  end
+
+  it "pairs size arg with adjacent array when no name affinity exists" do
+    source = "void process(int data[], int size)"
+
+    result = @parser.parse("module", source)
+    args = result[:functions].first[:args]
+
+    data_arg = args.find { |a| a[:name] == 'data' }
+    size_arg = args.find { |a| a[:name] == 'size' }
+
+    assert_equal(:after, data_arg[:array_size_order], "data should be paired with size (after)")
+    assert_equal(true,   size_arg[:array_size?],      "size should be marked as array_size?")
+  end
+
+  it "pairs size arg with the array whose name it matches, even when a different pointer is adjacent" do
+    # buf_size is adjacent to status, but 'buf' root matches 'buf' exactly
+    source = "void store(int status[], int buf_size, int buf[])"
+
+    result = @parser.parse("module", source)
+    args = result[:functions].first[:args]
+
+    status_arg  = args.find { |a| a[:name] == 'status' }
+    buf_size_arg = args.find { |a| a[:name] == 'buf_size' }
+    buf_arg     = args.find { |a| a[:name] == 'buf' }
+
+    assert_nil(status_arg[:array_size_order],            "status should NOT be paired")
+    assert_equal(:before, buf_arg[:array_size_order],    "buf should be paired with size (before)")
+    assert_equal(true,    buf_size_arg[:array_size?],    "buf_size should be marked as array_size?")
+  end
+
+  it "pairs size arg with array that comes after it when name affinity is stronger than adjacency" do
+    # buff_size is adjacent to bytes_to_read, but 'buff' root is a prefix of 'buffer'
+    source = "void read_interface(size_t bytes_to_read[], size_t buff_size, char *buffer[])"
+
+    result = @parser.parse("module", source)
+    args = result[:functions].first[:args]
+
+    bytes_arg     = args.find { |a| a[:name] == 'bytes_to_read' }
+    buff_size_arg = args.find { |a| a[:name] == 'buff_size' }
+    buffer_arg    = args.find { |a| a[:name] == 'buffer' }
+
+    assert_nil(bytes_arg[:array_size_order],               "bytes_to_read should NOT be paired")
+    assert_equal(:before, buffer_arg[:array_size_order],   "buffer should be paired with size (before)")
+    assert_equal(true, buff_size_arg[:array_size?],        "buff_size should be marked as array_size?")
+  end
+
+  it "pairs multiple size args each with their best-matched array" do
+    source = "void copy(int dst[], int dst_len, int src[], int src_len)"
+
+    result = @parser.parse("module", source)
+    args = result[:functions].first[:args]
+
+    dst_arg     = args.find { |a| a[:name] == 'dst' }
+    dst_len_arg = args.find { |a| a[:name] == 'dst_len' }
+    src_arg     = args.find { |a| a[:name] == 'src' }
+    src_len_arg = args.find { |a| a[:name] == 'src_len' }
+
+    assert_equal(:after, dst_arg[:array_size_order],  "dst should be paired with size (after)")
+    assert_equal(true, dst_len_arg[:array_size?],     "dst_len should be marked as array_size?")
+    assert_equal(:after, src_arg[:array_size_order],  "src should be paired with size (after)")
+    assert_equal(true, src_len_arg[:array_size?],     "src_len should be marked as array_size?")
+  end
+
+  it "correctly parse const int* const return type (both const qualifiers)" do
+    sources = [
+      "const int* const DoubleConst(void);\n",
+      "const int *const DoubleConst(void);\n",
+    ]
+
+    # The trailing 'const' (const_ptr?) also lands in :modifier, matching the existing
+    # behavior seen for 'int* const' return types (see the test above for PorkRoast).
+    # The generated mock correctly uses return[:str] and function_return_type() which
+    # reconstruct the full "const int* const" from :type + const_ptr? without needing :modifier.
+    expected = [{ :var_arg => nil,
+                  :name    => "DoubleConst",
+                  :unscoped_name => "DoubleConst",
+                  :namespace => [],
+                  :class => nil,
+                  :return  => { :type       => "const int*",
+                                :name       => 'cmock_to_return',
+                                :ptr?       => true,
+                                :const?     => true,
+                                :const_ptr? => true,
+                                :str        => "const int* const cmock_to_return",
+                                :void?      => false
+                              },
+                  :modifier      => "const",
+                  :contains_ptr? => false,
+                  :args          => [],
+                  :args_string   => "void",
+                  :args_call     => ""
+                }]
+
+    sources.each do |source|
+      assert_equal(expected, @parser.parse("module", source)[:functions])
+    end
+  end
+
+  it "correctly parse int const* const return type (trailing-const form, both qualifiers)" do
+    sources = [
+      "int const* const DoubleConst(void);\n",
+      "int const *const DoubleConst(void);\n",
+    ]
+
+    expected = [{ :var_arg => nil,
+                  :name    => "DoubleConst",
+                  :unscoped_name => "DoubleConst",
+                  :namespace => [],
+                  :class => nil,
+                  :return  => { :type       => "int const*",
+                                :name       => 'cmock_to_return',
+                                :ptr?       => true,
+                                :const?     => true,
+                                :const_ptr? => true,
+                                :str        => "int const* const cmock_to_return",
+                                :void?      => false
+                              },
+                  :modifier      => "const",
+                  :contains_ptr? => false,
+                  :args          => [],
+                  :args_string   => "void",
+                  :args_call     => ""
+                }]
+
+    sources.each do |source|
+      assert_equal(expected, @parser.parse("module", source)[:functions])
+    end
+  end
+
+  it "correctly parse double-pointer argument types preserving const and pointer ordering" do
+    # Tests the full parse pipeline for double-pointer args (not just divine_ptr_and_const).
+    # const int** p  → const? false (const is not before the final *), type preserves "const int**"
+    # int** const q  → const_ptr? true, type is "int**"
+    # int* const* p  → const? true (const* before the last *), type is "int* const*"
+    source = "void TriplePlay(const int** a, int** const b, int* const* c);\n"
+
+    expected = [{ :var_arg => nil,
+                  :name    => "TriplePlay",
+                  :unscoped_name => "TriplePlay",
+                  :namespace => [],
+                  :class => nil,
+                  :return  => { :type       => "void",
+                                :name       => 'cmock_to_return',
+                                :ptr?       => false,
+                                :const?     => false,
+                                :const_ptr? => false,
+                                :str        => "void cmock_to_return",
+                                :void?      => true
+                              },
+                  :modifier      => "",
+                  :contains_ptr? => true,
+                  :args => [
+                    { :type => "const int**", :name => "a", :ptr? => true, :string? => false,
+                      :const? => false, :const_ptr? => false },
+                    { :type => "int**",       :name => "b", :ptr? => true, :string? => false,
+                      :const? => false, :const_ptr? => true  },
+                    { :type => "int* const*", :name => "c", :ptr? => true, :string? => false,
+                      :const? => true,  :const_ptr? => false },
+                  ],
+                  :args_string => "const int** a, int** const b, int* const* c",
+                  :args_call   => "a, b, c"
+                }]
+
+    assert_equal(expected, @parser.parse("module", source)[:functions])
+  end
+
+  it "correctly parse double-pointer argument types with all consts" do
+    # const int** const p  → both const forms: type "const int**", const?=false, const_ptr?=true
+    # int* const* const q  → both const forms: type "int* const*", const?=true, const_ptr?=true
+    source = "void AllConst(const int** const a, int* const* const b);\n"
+
+    expected = [{ :var_arg => nil,
+                  :name    => "AllConst",
+                  :unscoped_name => "AllConst",
+                  :namespace => [],
+                  :class => nil,
+                  :return  => { :type       => "void",
+                                :name       => 'cmock_to_return',
+                                :ptr?       => false,
+                                :const?     => false,
+                                :const_ptr? => false,
+                                :str        => "void cmock_to_return",
+                                :void?      => true
+                              },
+                  :modifier      => "",
+                  :contains_ptr? => true,
+                  :args => [
+                    { :type => "const int**", :name => "a", :ptr? => true, :string? => false,
+                      :const? => false, :const_ptr? => true  },
+                    { :type => "int* const*", :name => "b", :ptr? => true, :string? => false,
+                      :const? => true,  :const_ptr? => true  },
+                  ],
+                  :args_string => "const int** const a, int* const* const b",
+                  :args_call   => "a, b"
+                }]
+
+    assert_equal(expected, @parser.parse("module", source)[:functions])
+  end
+
+  it "preserve const on non-pointer custom type arguments (e.g. const MyType_t)" do
+    source = "int myFunc(const MyType_t t_MyType);\n"
+
+    expected = [{ :var_arg => nil,
+                  :name    => "myFunc",
+                  :unscoped_name => "myFunc",
+                  :namespace => [],
+                  :class => nil,
+                  :return  => { :type       => "int",
+                                :name       => 'cmock_to_return',
+                                :ptr?       => false,
+                                :const?     => false,
+                                :const_ptr? => false,
+                                :str        => "int cmock_to_return",
+                                :void?      => false
+                              },
+                  :modifier      => "",
+                  :contains_ptr? => false,
+                  :args => [
+                    { :type => "MyType_t", :name => "t_MyType", :ptr? => false, :string? => false,
+                      :const? => true, :const_ptr? => false }
+                  ],
+                  :args_string => "const MyType_t t_MyType",
+                  :args_call   => "t_MyType"
+                }]
+
+    assert_equal(expected, @parser.parse("module", source)[:functions])
+  end
 
 end