Converted the rest of the inline declarations to be defined outside the header.

src/CppParser/AST.cpp

@@ -37,6 +37,7 @@ TagType::TagType() : Type(TypeKind::Tag) {}
 ArrayType::ArrayType() : Type(TypeKind::Array) {}
 
 FunctionType::FunctionType() : Type(TypeKind::Function) {}
+DEF_VECTOR(FunctionType, Parameter*, Parameters)
 
 PointerType::PointerType() : Type(TypeKind::Pointer) {}
 
@@ -52,6 +53,10 @@ TemplateArgument::TemplateArgument() : Declaration(0) {}
 
 TemplateSpecializationType::TemplateSpecializationType()
     : Type(TypeKind::TemplateSpecialization), Template(0), Desugared(0) {}
+DEF_VECTOR(TemplateSpecializationType, TemplateArgument, Arguments)
+
+// TemplateParameter
+DEF_STRING(TemplateParameter, Name)
 
 TemplateParameterType::TemplateParameterType() : Type(TypeKind::TemplateParameter) {}
 
@@ -65,11 +70,16 @@ DependentNameType::DependentNameType() : Type(TypeKind::DependentName) {}
 
 BuiltinType::BuiltinType() : CppSharp::CppParser::AST::Type(TypeKind::Builtin) {}
 
+// RawComment
+DEF_STRING(RawComment, Text)
+DEF_STRING(RawComment, BriefText)
+
 RawComment::RawComment() : FullComment(0) {}
 
 VTableComponent::VTableComponent() : Offset(0), Declaration(0) {}
 
 ClassLayout::ClassLayout() : ABI(CppAbi::Itanium) {}
+DEF_VECTOR(ClassLayout, VFTableInfo, VFTables)
 
 Declaration::Declaration(DeclarationKind kind)
     : Kind(kind)
@@ -84,9 +94,21 @@ Declaration::Declaration(DeclarationKind kind)
 {
 }
 
+DEF_STRING(Declaration, Name)
+DEF_STRING(Declaration, DebugText)
+DEF_VECTOR(Declaration, PreprocessedEntity*, PreprocessedEntities)
+
 DeclarationContext::DeclarationContext()
     : Declaration(DeclarationKind::DeclarationContext) {}
 
+DEF_VECTOR(DeclarationContext, Namespace*, Namespaces)
+DEF_VECTOR(DeclarationContext, Enumeration*, Enums)
+DEF_VECTOR(DeclarationContext, Function*, Functions)
+DEF_VECTOR(DeclarationContext, Class*, Classes)
+DEF_VECTOR(DeclarationContext, Template*, Templates)
+DEF_VECTOR(DeclarationContext, TypedefDecl*, Typedefs)
+DEF_VECTOR(DeclarationContext, Variable*, Variables)
+
 Declaration* DeclarationContext::FindAnonymous(uint64_t key)
 {
     auto it = Anonymous.find(key);
@@ -319,15 +341,25 @@ Parameter::Parameter() : Declaration(DeclarationKind::Parameter),
 Function::Function() : Declaration(DeclarationKind::Function),
     IsReturnIndirect(false) {}
 
+DEF_STRING(Function, Mangled)
+DEF_STRING(Function, Signature)
+DEF_VECTOR(Function, Parameter*, Parameters)
+
 Method::Method() : IsDefaultConstructor(false), IsCopyConstructor(false),
     IsMoveConstructor(false) { Kind = DeclarationKind::Method; }
 
 Enumeration::Enumeration() : Declaration(DeclarationKind::Enumeration) {}
 
+DEF_VECTOR(Enumeration, Enumeration::Item, Items)
+
 Enumeration::Item::Item() : Declaration(DeclarationKind::EnumerationItem) {}
 
+DEF_STRING(Enumeration::Item, Expression)
+
 Variable::Variable() : Declaration(DeclarationKind::Variable) {}
 
+DEF_STRING(Variable, Mangled)
+
 BaseClassSpecifier::BaseClassSpecifier() : Type(0) {}
 
 Field::Field() : Declaration(DeclarationKind::Field), Class(0) {}
@@ -337,13 +369,24 @@ AccessSpecifierDecl::AccessSpecifierDecl()
 
 Class::Class() { Kind = DeclarationKind::Class; }
 
+DEF_VECTOR(Class, BaseClassSpecifier*, Bases)
+DEF_VECTOR(Class, Field*, Fields)
+DEF_VECTOR(Class, Method*, Methods)
+DEF_VECTOR(Class, AccessSpecifierDecl*, Specifiers)
+
 Template::Template() : Declaration(DeclarationKind::Template) {}
 
+DEF_VECTOR(Template, TemplateParameter, Parameters)
+
 ClassTemplate::ClassTemplate() { Kind = DeclarationKind::ClassTemplate; }
 
-ClassTemplateSpecialization::ClassTemplateSpecialization()
+DEF_VECTOR(ClassTemplate, ClassTemplateSpecialization*, Specializations)
+
+ClassTemplateSpecialization::ClassTemplateSpecialization() : TemplatedDecl(0)
     { Kind = DeclarationKind::ClassTemplateSpecialization; }
 
+DEF_VECTOR(ClassTemplateSpecialization, TemplateArgument, Arguments)
+
 ClassTemplatePartialSpecialization::ClassTemplatePartialSpecialization()
     { Kind = DeclarationKind::ClassTemplatePartialSpecialization; }
 
@@ -357,10 +400,21 @@ PreprocessedEntity::PreprocessedEntity()
 
 MacroDefinition::MacroDefinition() { Kind = DeclarationKind::MacroDefinition; }
 
+DEF_STRING(MacroDefinition, Expression)
+
 MacroExpansion::MacroExpansion() { Kind = DeclarationKind::MacroExpansion; }
 
+DEF_STRING(MacroExpansion, Text)
+
 TranslationUnit::TranslationUnit() { Kind = DeclarationKind::TranslationUnit; }
 
+DEF_STRING(TranslationUnit, FileName)
+DEF_VECTOR(TranslationUnit, MacroDefinition*, Macros)
+
+// NativeLibrary
+DEF_STRING(NativeLibrary, FileName)
+DEF_VECTOR_STRING(NativeLibrary, Symbols)
+
 ClassTemplateSpecialization* ClassTemplate::FindSpecialization(void* ptr)
 {
     return 0;

src/CppParser/AST.h

@@ -7,33 +7,7 @@
 
 #pragma once
 
-#include <cstdint>
+#include "Helpers.h"
-#include <vector>
-#include <map>
-#include <string>
-
-#define CS_FLAGS
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#define CS_API __declspec(dllexport)
-#else
-#define CS_API 
-#endif
-
-#define VECTOR(type, name) \
-    std::vector<type> name; \
-    type get##name (unsigned i) { return name[i]; } \
-    unsigned get##name##Count () { return name.size(); }
-
-#define VECTOR_STRING(name) \
-    std::vector<std::string> name; \
-    const char* get##name (unsigned i) { return name[i].c_str(); } \
-    unsigned get##name##Count () { return name.size(); }
-
-#define STRING(name) \
-    std::string name; \
-    const char* get##name() { return name.c_str(); } \
-    void set##name(const char* s) { name = s; }
 
 namespace CppSharp { namespace CppParser { namespace AST {
 

src/CppParser/CppParser.cpp

@@ -20,10 +20,24 @@ ParserOptions::ParserOptions()
 {
 }
 
+DEF_STRING(ParserOptions, FileName)
+DEF_VECTOR_STRING(ParserOptions, IncludeDirs)
+DEF_VECTOR_STRING(ParserOptions, SystemIncludeDirs)
+DEF_VECTOR_STRING(ParserOptions, Defines)
+DEF_VECTOR_STRING(ParserOptions, LibraryDirs)
+DEF_STRING(ParserOptions, TargetTriple)
+
 ParserResult::ParserResult()
     : ASTContext(0)
     , Library(0)
 {
 }
 
+DEF_STRING(ParserDiagnostic, FileName)
+DEF_STRING(ParserDiagnostic, Message)
+
+DEF_VECTOR(ParserResult, ParserDiagnostic, Diagnostics)
+
+
+
 } }

src/CppParser/CppParser.h

@@ -8,23 +8,7 @@
 #pragma once
 
 #include "AST.h"
-
+#include "Helpers.h"
-#define VECTOR_OPTIONS(type, name) \
-    std::vector<type> name; \
-    type get##name (unsigned i) { return name[i]; } \
-    void add##name (const type& s) { return name.push_back(s); } \
-    unsigned get##name##Count () { return name.size(); }
-
-#define VECTOR_STRING_OPTIONS(name) \
-    std::vector<std::string> name; \
-    const char* get##name (unsigned i) { return name[i].c_str(); } \
-    void add##name (const char* s) { return name.push_back(std::string(s)); } \
-    unsigned get##name##Count () { return name.size(); }
-
-#define STRING_OPTIONS(name) \
-    std::string name; \
-    const char* get##name() { return name.c_str(); } \
-    void set##name(const char* s) { name = s; }
 
 namespace CppSharp { namespace CppParser {
 
@@ -35,13 +19,13 @@ struct CS_API ParserOptions
     ParserOptions();
 
     // C/C++ header file name.
-    STRING_OPTIONS(FileName)
+    STRING(FileName)
 
     // Include directories
-    VECTOR_STRING_OPTIONS(IncludeDirs)
+    VECTOR_STRING(IncludeDirs)
-    VECTOR_STRING_OPTIONS(SystemIncludeDirs)
+    VECTOR_STRING(SystemIncludeDirs)
-    VECTOR_STRING_OPTIONS(Defines)
+    VECTOR_STRING(Defines)
-    VECTOR_STRING_OPTIONS(LibraryDirs)
+    VECTOR_STRING(LibraryDirs)
 
     CppSharp::CppParser::AST::ASTContext* ASTContext;
 
@@ -85,7 +69,7 @@ struct CS_API ParserResult
     ParserResult();
 
     ParserResultKind Kind;
-    VECTOR_OPTIONS(ParserDiagnostic, Diagnostics)
+    VECTOR(ParserDiagnostic, Diagnostics)
 
     CppSharp::CppParser::AST::ASTContext* ASTContext;
     CppSharp::CppParser::AST::NativeLibrary* Library;

src/CppParser/Helpers.h

@@ -0,0 +1,55 @@
+/************************************************************************
+*
+* CppSharp
+* Licensed under the simplified BSD license. All rights reserved.
+*
+************************************************************************/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+#include <map>
+#include <string>
+
+#define CS_FLAGS
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define CS_API __declspec(dllexport)
+#else
+#define CS_API 
+#endif
+
+/** We use these macros to workaround the lack of good standard C++
+ * containers/string support in the C# binding backend. */
+
+#define VECTOR(type, name) \
+    std::vector<type> name; \
+    type get##name (unsigned i); \
+    void add##name (type& s); \
+    unsigned get##name##Count ();
+
+#define DEF_VECTOR(klass, type, name) \
+    type klass::get##name (unsigned i) { return name[i]; } \
+    void klass::add##name (type& s) { return name.push_back(s); } \
+    unsigned klass::get##name##Count () { return name.size(); }
+
+#define VECTOR_STRING(name) \
+    std::vector<std::string> name; \
+    const char* get##name (unsigned i); \
+    void add##name (const char* s); \
+    unsigned get##name##Count ();
+
+#define DEF_VECTOR_STRING(klass, name) \
+    const char* klass::get##name (unsigned i) { return name[i].c_str(); } \
+    void klass::add##name (const char* s) { return name.push_back(std::string(s)); } \
+    unsigned klass::get##name##Count () { return name.size(); }
+
+#define STRING(name) \
+    std::string name; \
+    const char* get##name(); \
+    void set##name(const char* s);
+
+#define DEF_STRING(klass, name) \
+    const char* klass::get##name() { return name.c_str(); } \
+    void klass::set##name(const char* s) { name = s; }