all tests pass with new hack to parse pointers on arguments

wrap/Module.cpp

@@ -21,9 +21,10 @@
 #include "FileWriter.h" 
 #include "TypeAttributesTable.h" 
 #include "utilities.h" 
+
+//#define BOOST_SPIRIT_DEBUG
 #include "spirit_actors.h" 
  
-//#define BOOST_SPIRIT_DEBUG 
 #include <boost/spirit/include/classic_confix.hpp> 
 #include <boost/spirit/include/classic_clear_actor.hpp> 
 #include <boost/spirit/include/classic_insert_at_actor.hpp> 
@@ -142,8 +143,8 @@ void Module::parseMarkup(const std::string& data) {
   Rule namespace_arg_p = namespace_name_p[push_back_a(arg.namespaces)] >> str_p("::"); 
  
   Rule argEigenType_p = 
-    eigenType_p[assign_a(arg.type)] >> 
+    eigenType_p[assign_a(arg.type)];
-    !ch_p('*')[assign_a(arg.is_ptr,true)]; 
+//    >> !ch_p('*')[assign_a(arg.is_ptr,true)];
  
   Rule eigenRef_p = 
       !str_p("const") [assign_a(arg.is_const,true)] >> 
@@ -154,7 +155,8 @@ void Module::parseMarkup(const std::string& data) {
     !str_p("const") [assign_a(arg.is_const,true)] >> 
     *namespace_arg_p >> 
     className_p[assign_a(arg.type)] >> 
-    (ch_p('*')[assign_a(arg.is_ptr,true)] | ch_p('&')[assign_a(arg.is_ref,true)]); 
+//    !ch_p('*')[assign_a(arg.is_ptr,true)] >>
+    !ch_p('&')[assign_a(arg.is_ref,true)];
  
   Rule name_p = lexeme_d[alpha_p >> *(alnum_p | '_')]; 
  
@@ -198,9 +200,12 @@ void Module::parseMarkup(const std::string& data) {
     '<' >> name_p[push_back_a(cls.templateArgs)] >> *(',' >> name_p[push_back_a(cls.templateArgs)]) >> 
     '>'); 
  
+  static const bool istrue = true;
+
   Rule argument_p =  
     ((basisType_p[assign_a(arg.type)] | argEigenType_p | eigenRef_p | classArg_p) 
-        >> name_p[assign_a(arg.name)]) 
+        >> !ch_p('*')[assign_a(arg.is_ptr,istrue)]
+        >> name_p[assign_a(arg.name)])
     [push_back_a(args, arg)] 
     [assign_a(arg,arg0)]; 
  
@@ -217,20 +222,12 @@ void Module::parseMarkup(const std::string& data) {
  
   Rule namespace_ret_p = namespace_name_p[push_back_a(namespaces_return)] >> str_p("::"); 
  
-  // const values
+  // HACK: use const values instead of using enums themselves
   static const ReturnValue::return_category RETURN_EIGEN = ReturnValue::EIGEN;
   static const ReturnValue::return_category RETURN_BASIS = ReturnValue::BASIS;
   static const ReturnValue::return_category RETURN_CLASS = ReturnValue::CLASS;
   static const ReturnValue::return_category RETURN_VOID = ReturnValue::VOID;
 
-  // alternate version 1
-//  Rule returnType1_p =
-//    basisType_p[assign_a(retVal.category1, ReturnValue::BASIS)][assign_a(retVal.type1)] |
-//    eigenType_p[assign_a(retVal.category1, ReturnValue::EIGEN)][assign_a(retVal.type1)] |
-//    ((*namespace_ret_p)[assign_a(retVal.namespaces1, namespaces_return)][clear_a(namespaces_return)]
-//            >> (className_p[assign_a(retVal.category1, ReturnValue::CLASS)][assign_a(retVal.type1)]) >>
-//            !ch_p('*')[assign_a(retVal.isPtr1,true)]);
-
   // switching to using constants
   Rule returnType1_p =
     (basisType_p[assign_a(retVal.type1)][assign_a(retVal.category1, RETURN_BASIS)]) |

wrap/tests/testWrap.cpp

@@ -169,7 +169,6 @@ TEST( wrap, parse_geometry ) {
 //  EIGEN = 2,
 //  BASIS = 3,
 //  VOID  = 4,
-//  DUMMY = 5
 
   {
     // check first class
@@ -196,7 +195,7 @@ TEST( wrap, parse_geometry ) {
       Method m1 = cls.methods.find("returnChar")->second;
       LONGS_EQUAL(1, m1.returnVals.size());
       EXPECT(assert_equal("char", m1.returnVals.front().type1));
-      EXPECT_LONGS_EQUAL(ReturnValue::BASIS, m1.returnVals.front().category1); // FAIL: gets 1 instead of 3
+      EXPECT_LONGS_EQUAL(ReturnValue::BASIS, m1.returnVals.front().category1);
       EXPECT(!m1.returnVals.front().isPair);
       EXPECT(assert_equal("returnChar", m1.name));
       LONGS_EQUAL(1, m1.argLists.size());
@@ -210,7 +209,7 @@ TEST( wrap, parse_geometry ) {
       Method m1 = cls.methods.find("vectorConfusion")->second;
       LONGS_EQUAL(1, m1.returnVals.size());
       EXPECT(assert_equal("VectorNotEigen", m1.returnVals.front().type1));
-      EXPECT_LONGS_EQUAL(ReturnValue::CLASS, m1.returnVals.front().category1); // FAIL: gets 0 instead of 1
+      EXPECT_LONGS_EQUAL(ReturnValue::CLASS, m1.returnVals.front().category1);
       EXPECT(!m1.returnVals.front().isPair);
       EXPECT(assert_equal("vectorConfusion", m1.name));
       LONGS_EQUAL(1, m1.argLists.size());
@@ -247,7 +246,7 @@ TEST( wrap, parse_geometry ) {
     Method m1 = cls.methods.find("norm")->second;
     LONGS_EQUAL(1, m1.returnVals.size());
     EXPECT(assert_equal("double", m1.returnVals.front().type1));
-    EXPECT_LONGS_EQUAL(ReturnValue::BASIS, m1.returnVals.front().category1); // FAIL: gets 1 instead of 3
+    EXPECT_LONGS_EQUAL(ReturnValue::BASIS, m1.returnVals.front().category1);
     EXPECT(assert_equal("norm", m1.name));
     LONGS_EQUAL(1, m1.argLists.size());
     EXPECT_LONGS_EQUAL(0, m1.argLists.front().size());
@@ -267,10 +266,34 @@ TEST( wrap, parse_geometry ) {
     Method m2 = testCls.methods.find("return_pair")->second;
     LONGS_EQUAL(1, m2.returnVals.size());
     EXPECT(m2.returnVals.front().isPair);
-    EXPECT_LONGS_EQUAL(ReturnValue::EIGEN, m2.returnVals.front().category1); // FAIL: gets 1 instead of 2
+    EXPECT_LONGS_EQUAL(ReturnValue::EIGEN, m2.returnVals.front().category1);
     EXPECT(assert_equal("Vector", m2.returnVals.front().type1));
-    EXPECT_LONGS_EQUAL(ReturnValue::EIGEN, m2.returnVals.front().category2); // FAIL: gets 6201089 instead of 2
+    EXPECT_LONGS_EQUAL(ReturnValue::EIGEN, m2.returnVals.front().category2);
     EXPECT(assert_equal("Matrix", m2.returnVals.front().type2));
+
+    // checking pointer args and return values
+//    pair<Test*,Test*> return_ptrs (Test* p1, Test* p2) const;
+    CHECK(testCls.methods.find("return_ptrs") != testCls.methods.end());
+    Method m3 = testCls.methods.find("return_ptrs")->second;
+    LONGS_EQUAL(1, m3.argLists.size());
+    ArgumentList args = m3.argLists.front();
+    LONGS_EQUAL(2, args.size());
+
+    Argument arg1 = args.at(0);
+    EXPECT(arg1.is_ptr);
+    EXPECT(!arg1.is_const);
+    EXPECT(!arg1.is_ref);
+    EXPECT(assert_equal("Test", arg1.type));
+    EXPECT(assert_equal("p1", arg1.name));
+    EXPECT(arg1.namespaces.empty());
+
+    Argument arg2 = args.at(1);
+    EXPECT(arg2.is_ptr);
+    EXPECT(!arg2.is_const);
+    EXPECT(!arg2.is_ref);
+    EXPECT(assert_equal("Test", arg2.type));
+    EXPECT(assert_equal("p2", arg2.name));
+    EXPECT(arg2.namespaces.empty());
   }
 
   // evaluate global functions