From 0030a28e457e2faf48b4a90adf5bdbf7621bb730 Mon Sep 17 00:00:00 2001 From: Alex Cunningham Date: Tue, 27 Nov 2012 19:03:22 +0000 Subject: [PATCH] all tests pass with new hack to parse pointers on arguments --- wrap/Module.cpp | 25 +++++++++++-------------- wrap/tests/testWrap.cpp | 35 +++++++++++++++++++++++++++++------ 2 files changed, 40 insertions(+), 20 deletions(-) diff --git a/wrap/Module.cpp b/wrap/Module.cpp index 6154a2178..cef9bd9fd 100644 --- a/wrap/Module.cpp +++ b/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 #include #include @@ -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)] >> - !ch_p('*')[assign_a(arg.is_ptr,true)]; + eigenType_p[assign_a(arg.type)]; +// >> !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)]) | diff --git a/wrap/tests/testWrap.cpp b/wrap/tests/testWrap.cpp index 803287a23..648058c6d 100644 --- a/wrap/tests/testWrap.cpp +++ b/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 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