12345qiupeng
/
gtsam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

all tests pass with new hack to parse pointers on arguments

release/4.3a0
Alex Cunningham 2012-11-27 19:03:22 +00:00
parent 2f44bc0a1a
commit 0030a28e45
2 changed files with 40 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
wrap/Module.cpp
View File

@ -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)] >>
!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)]) |

35
wrap/tests/testWrap.cpp
View File

@ -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