jyapayne/cppast
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add support for member pointer types

Browse source
This commit is contained in:
Jonathan Müller 2017-02-23 15:39:12 +01:00
commit 23a7248964
4 changed files with 160 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

6
include/cppast/cpp_function_type.hpp
View file

@ -130,7 +130,7 @@ namespace cppast
/// \returns A reference to the return [cppast::cpp_type]().
const cpp_type& return_type() const noexcept
{
return *object_type_;
return *return_type_;
}
/// \returns An iteratable object iterating over the parameter types.
@ -148,7 +148,7 @@ namespace cppast
private:
cpp_member_function_type(std::unique_ptr<cpp_type> class_type,
std::unique_ptr<cpp_type> return_type)
: class_type_(std::move(class_type)), object_type_(std::move(return_type)), variadic_(false)
: class_type_(std::move(class_type)), return_type_(std::move(return_type)), variadic_(false)
{
}
@ -157,7 +157,7 @@ namespace cppast
return cpp_type_kind::member_function;
}
std::unique_ptr<cpp_type> class_type_, object_type_;
std::unique_ptr<cpp_type> class_type_, return_type_;
detail::intrusive_list<cpp_type> parameters_;
bool variadic_;
};

2
src/cpp_type.cpp
View file

@ -94,7 +94,7 @@ bool cppast::is_valid(const cpp_type& type) noexcept
{
auto& func = static_cast<const cpp_member_function_type&>(type);
if (func.class_type().kind() != cpp_type_kind::user_defined)
if (!can_compose(func.class_type()) || !is_valid(func.class_type()))
return false;
else if (!can_compose(func.return_type()) || !is_valid(func.return_type()))
return false;

88
src/libclang/type_parser.cpp
View file

@ -59,6 +59,7 @@ namespace
}
// const/volatile at the end (because people do that apparently!)
// also used on member function pointers
cpp_cv suffix_cv(std::string& spelling)
{
auto cv = cpp_cv_none;
@ -207,6 +208,25 @@ namespace
size_expr.rend()));
}
std::unique_ptr<cpp_type> parse_type_impl(const detail::parse_context& context,
const CXType& type);
template <class Builder>
std::unique_ptr<cpp_type> add_parameters(Builder& builder, const detail::parse_context& context,
const CXType& type)
{
auto no_args = clang_getNumArgTypes(type);
DEBUG_ASSERT(no_args >= 0, detail::parse_error_handler{}, type,
"invalid number of arguments");
for (auto i = 0u; i != unsigned(no_args); ++i)
builder.add_parameter(parse_type_impl(context, clang_getArgType(type, i)));
if (clang_isFunctionTypeVariadic(type))
builder.is_variadic();
return builder.finish();
}
std::unique_ptr<cpp_type> try_parse_function_type(const detail::parse_context& context,
const CXType& type)
{
@ -215,18 +235,51 @@ namespace
// not a function type
return nullptr;
cpp_function_type::builder builder(parse_type(context, result));
cpp_function_type::builder builder(parse_type_impl(context, result));
return add_parameters(builder, context, type);
}
auto no_args = clang_getNumArgTypes(type);
DEBUG_ASSERT(no_args >= 0, detail::parse_error_handler{}, type,
"invalid number of arguments");
for (auto i = 0u; i != unsigned(no_args); ++i)
builder.add_parameter(detail::parse_type(context, clang_getArgType(type, i)));
cpp_reference member_function_ref_qualifier(std::string& spelling)
{
if (remove_suffix(spelling, "&&"))
return cpp_ref_rvalue;
else if (remove_suffix(spelling, "&"))
return cpp_ref_lvalue;
return cpp_ref_none;
}
if (clang_isFunctionTypeVariadic(type))
builder.is_variadic();
std::unique_ptr<cpp_type> make_ref_qualified(std::unique_ptr<cpp_type> type, cpp_reference ref)
{
if (ref == cpp_ref_none)
return std::move(type);
return cpp_reference_type::build(std::move(type), ref);
}
return builder.finish();
std::unique_ptr<cpp_type> parse_member_pointee_type(const detail::parse_context& context,
const CXType& type)
{
auto spelling = get_type_spelling(type);
auto ref = member_function_ref_qualifier(spelling);
auto cv = suffix_cv(spelling);
auto class_t = clang_Type_getClassType(type);
auto class_entity =
make_ref_qualified(make_cv_qualified(parse_type_impl(context, class_t), cv), ref);
auto pointee = clang_getPointeeType(type); // for everything except the class type
auto result = clang_getResultType(pointee);
if (result.kind == CXType_Invalid)
{
// member data pointer
return cpp_member_object_type::build(std::move(class_entity),
parse_type_impl(context, pointee));
}
else
{
cpp_member_function_type::builder builder(std::move(class_entity),
parse_type_impl(context, result));
return add_parameters(builder, context, pointee);
}
}
std::unique_ptr<cpp_type> parse_type_impl(const detail::parse_context& context,
@ -300,7 +353,7 @@ namespace
case CXType_Pointer:
{
auto pointee = parse_type(context, clang_getPointeeType(type));
auto pointee = parse_type_impl(context, clang_getPointeeType(type));
auto pointer = cpp_pointer_type::build(std::move(pointee));
auto spelling = get_type_spelling(type);
@ -310,7 +363,7 @@ namespace
case CXType_LValueReference:
case CXType_RValueReference:
{
auto referee = parse_type(context, clang_getPointeeType(type));
auto referee = parse_type_impl(context, clang_getPointeeType(type));
return cpp_reference_type::build(std::move(referee), get_reference_kind(type));
}
@ -320,7 +373,7 @@ namespace
case CXType_ConstantArray:
{
auto size = parse_array_size(type);
auto value_type = parse_type(context, clang_getArrayElementType(type));
auto value_type = parse_type_impl(context, clang_getArrayElementType(type));
return cpp_array_type::build(std::move(value_type), std::move(size));
}
@ -328,16 +381,18 @@ namespace
case CXType_FunctionProto:
return try_parse_function_type(context, type);
case CXType_MemberPointer:
return cpp_pointer_type::build(parse_member_pointee_type(context, type));
// TODO
case CXType_Dependent:
break;
case CXType_MemberPointer:
break;
case CXType_Auto:
break;
}
DEBUG_UNREACHABLE(detail::assert_handler{});
return nullptr;
}
}
@ -346,8 +401,7 @@ std::unique_ptr<cpp_type> detail::parse_type(const detail::parse_context& contex
const CXType& type) try
{
auto result = parse_type_impl(context, type);
DEBUG_ASSERT(result && is_valid(*result), detail::parse_error_handler{}, type,
"invalid type parsed");
DEBUG_ASSERT(result && is_valid(*result), detail::parse_error_handler{}, type, "invalid type");
return std::move(result);
}
catch (parse_error& ex)
@ -370,5 +424,7 @@ std::unique_ptr<cpp_entity> detail::parse_cpp_type_alias(const detail::parse_con
detail::skip(stream, "=");
auto type = parse_type(context, clang_getTypedefDeclUnderlyingType(cur));
if (!type)
return nullptr;
return cpp_type_alias::build(*context.idx, get_entity_id(cur), name.c_str(), std::move(type));
}

94
test/cpp_type_alias.cpp
View file

@ -28,9 +28,10 @@ bool equal_types(const cpp_entity_index& idx, const cpp_type& parsed, const cpp_
auto user_synthesized = static_cast<const cpp_user_defined_type&>(synthesized).entity();
if (user_parsed.name() != user_synthesized.name())
return false;
// check that the referring also works
auto entity = user_parsed.get(idx);
return entity.has_value() && entity.value().name() == user_parsed.name();
return true;
// TODO: check that the referring also works (need parsing of structs)
// auto entity = user_parsed.get(idx);
// return entity.has_value() && entity.value().name() == user_parsed.name();
}
case cpp_type_kind::cv_qualified:
@ -100,12 +101,40 @@ bool equal_types(const cpp_entity_index& idx, const cpp_type& parsed, const cpp_
}
return iter_a == func_a.parameter_types().end() && iter_b == func_b.parameter_types().end();
}
case cpp_type_kind::member_function:
{
auto& func_a = static_cast<const cpp_member_function_type&>(parsed);
auto& func_b = static_cast<const cpp_member_function_type&>(synthesized);
if (!equal_types(idx, func_a.return_type(), func_b.return_type()))
return false;
else if (!equal_types(idx, func_a.class_type(), func_b.class_type()))
return false;
else if (func_a.is_variadic() != func_b.is_variadic())
return false;
auto iter_a = func_a.parameter_types().begin();
auto iter_b = func_a.parameter_types().begin();
while (iter_a != func_a.parameter_types().end() && iter_b != func_b.parameter_types().end())
{
if (!equal_types(idx, *iter_a, *iter_b))
return false;
++iter_a;
++iter_b;
}
return iter_a == func_a.parameter_types().end() && iter_b == func_b.parameter_types().end();
}
case cpp_type_kind::member_object:
{
auto& obj_a = static_cast<const cpp_member_object_type&>(parsed);
auto& obj_b = static_cast<const cpp_member_object_type&>(synthesized);
if (!equal_types(idx, obj_a.class_type(), obj_b.class_type()))
return false;
return equal_types(idx, obj_a.object_type(), obj_b.object_type());
}
// TODO
case cpp_type_kind::member_function:
break;
case cpp_type_kind::member_object:
break;
case cpp_type_kind::template_parameter:
break;
case cpp_type_kind::template_instantiation:
@ -151,8 +180,17 @@ using m = char[3 * 2 + 4 ? 42 : 43];
// function pointers
using n = void(*)(int);
using o = char*(&)(int&,...);
using o = char*(&)(const int&,...);
using p = n(*)(int, o);
struct foo {};
// member function pointers
using q = void(foo::*)(int);
using r = void(foo::*)(int,...) const &;
// member data pointers
using s = int(foo::*);
)";
auto add_cv = [](std::unique_ptr<cpp_type> type, cpp_cv cv) {
@ -259,7 +297,8 @@ using p = n(*)(int, o);
cpp_function_type::builder builder(
cpp_pointer_type::build(cpp_builtin_type::build("char")));
builder.add_parameter(
cpp_reference_type::build(cpp_builtin_type::build("int"), cpp_ref_lvalue));
cpp_reference_type::build(add_cv(cpp_builtin_type::build("int"), cpp_cv_const),
cpp_ref_lvalue));
builder.is_variadic();
auto type = cpp_reference_type::build(builder.finish(), cpp_ref_lvalue);
@ -276,8 +315,43 @@ using p = n(*)(int, o);
REQUIRE(equal_types(idx, alias.underlying_type(), *type));
}
else if (alias.name() == "q")
{
cpp_member_function_type::builder builder(cpp_user_defined_type::build(
cpp_type_ref(cpp_entity_id(""), "foo")),
cpp_builtin_type::build("void"));
builder.add_parameter(cpp_builtin_type::build("int"));
auto type = cpp_pointer_type::build(builder.finish());
REQUIRE(equal_types(idx, alias.underlying_type(), *type));
}
else if (alias.name() == "r")
{
auto obj = cpp_reference_type::build(add_cv(cpp_user_defined_type::build(
cpp_type_ref(cpp_entity_id(""), "foo")),
cpp_cv_const),
cpp_ref_lvalue);
cpp_member_function_type::builder builder(std::move(obj),
cpp_builtin_type::build("void"));
builder.add_parameter(cpp_builtin_type::build("int"));
builder.is_variadic();
auto type = cpp_pointer_type::build(builder.finish());
REQUIRE(equal_types(idx, alias.underlying_type(), *type));
}
else if (alias.name() == "s")
{
auto pointee = cpp_member_object_type::
build(cpp_user_defined_type::build(cpp_type_ref(cpp_entity_id(""), "foo")),
cpp_unexposed_type::build(
"int")); // type not exposed directly for some reason
auto type = cpp_pointer_type::build(std::move(pointee));
REQUIRE(equal_types(idx, alias.underlying_type(), *type));
}
else
REQUIRE(false);
});
REQUIRE(count == 16u);
REQUIRE(count == 19u);
}